*DECK CSTRND USETEXT TEXTCS USETEXT TXTCTCS PROC CSTRND (SWTESS); # TITLE CSTRND - RECEIVE NCF DATA. # BEGIN # CSTRND # # ** CSTRND - RECEIVE NCF DATA. * * D. G. DEPEW. 81/09/24. * * THIS PROCEDURE DEBLOCKS LINE RECORDS FROM THE NCF CIO BUFFER AND * COMBINES THEM WITH THE CORRESPONDING NCF READ REQUESTS QUEUE * ENTRIES TO CREATE NCF DATA QUEUE ENTRIES. * * PROC CSTRND (SWTESS) * * ENTRY THE NCF DATA QUEUE MAY CONTAIN EITHER OF THE FOLLOWING: * - ZERO (I.E., IT MAY BE EMPTY) OR MORE COMPLETE ENTRIES. * - ZERO OR MORE COMPLETE ENTRIES FOLLOWED BY A PARTIALLY * COMPLETED ENTRY. A PARTIALLY COMPLETED ENTRY IS ONE * WHICH AS YET CONTAINS ONLY A PROTION OR ITS LINE * RECORD. * THE NCF READ REQUESTS QUEUE CONTAINS ENTRIES CORRESPONDING * TO THOSE LINE RECORDS FOR WHICH DEBLOCKING HAS NOT YET * BEGUN. * ITEM *RLCOUNT* (IN TXTCTCS) CONTAINS THE NUMBER OF LINE * RECORDS BEING READ BY THE CURRENT READLS FUNCTION (AND * THENCE THE NUMBER OF RESULTING NCF DATA QUEUE ENTRIES). * ITEM *RLIORD* (IN TXTCTCS) POINTS TO THE READ LIST INDEX * ENTRY CORRESPONDING TO ONE OF THE FOLLOWING: * - THE LINE RECORD CURRENTLY BEING DEBLOCKED IF THE LAST * ENTRY IN THE NCF DATA QUEUE IS INCOMPLETE. * - THE LINE RECORD FOR WHICH DEBLOCKING WILL BEGIN IF THE * LAST ENTRY IN THE NCF DATA QUEUE IS COMPLETE OR THE * QUEUE IS EMPTY. * DATA IS AVAILABLE IN THE NCF CIO BUFFER. * * EXIT LINE RECORD DATA AND/OR NEW ENTRIES HAVE BEEN ADDED TO THE * NCF DATA QUEUE AS DESCRIBED BELOW UNDER *METHOD*. * NCF READ REQUESTS QUEUE ENTRIES, CORRESPONDING TO THOSE * NEW ENTRIES (EITHER COMPLETE OR INCOMPLETE) THAT HAVE * BEEN ADDED TO THE NCF DATA QUEUE THIS TIME (IF ANY), * HAVE BEEN DELETED. * FORMAL RETURN PARAMETER ARRAY SWTESS IS SET AS FOLLOWS: * - IF ALL LINE RECORDS SPECIFIED IN THE CURRENT READLS * OPERATION HAVE BEEN COMPLETELY PROCESSED, SWTESS IS * SET SO THAT PROC CSTSNR IS CALLED WHEN AN ENTRY IS * MADE IN THE CONFIGURE TERMINAL REQUEST QUEUE. * - IF ALL LINE RECORDS SPECIFIED IN THE CURRENT READLS * OPERATION HAVE NOT BEEN PROCESSED AND THE NCF CIO * BUFFER IS EMPTY, SWTESS IS SET SUCH THAT THIS ROUTINE * WILL AGAIN BE CALLED WHEN THE FET COMPLETE BIT IS SET * OR THE IN POINTER DOES NOT EQUAL THE OUT POINTER. * IF WE ARE WAITING FOR DATA TO BE PLACED IN THE BUFFER AND * THE I/O HAS STOPPED, THE READLS FUNCTION IS REISSUED. * * METHOD THIS ROUTINE CONSISTS PRIMARILY OF A LARGE LOOP. EACH * TIME THROUGH THE LOOP ONE OF THE FOLLOWING OCCURS: * - A NEW, SKELETON ENTRY IS ADDED TO THE NCF DATA QUEUE. * THIS ENTRY CONSISTS OF THE CNF/TE/R SM (FROM THE NCF * READ REQUESTS QUEUE) PLUS THE FIRST TWO WORDS OF THE * LINE RECORD. (WORD TWO OF A LINE RECORD CONTAINS ITS * LENGTH, WHICH IS USED TO DETERMINE THE SIZE OF THE * NCF DATA QUEUE ENTRY.) THE NCF READ REQUESTS QUEUE * ENTRY IS DELETED. * - LINE RECORD DATA IS ADDED TO AN INCOMPLETE NCF DATA * QUEUE ENTRY, BUT BECAUSE OF INSUFFICIENT DATA * AVAILABILITY, THE ENTRY CANNOT BE COMPLETED. * - LINE RECORD DATA IS ADDED TO AN INCOMPLETE NCF DATA * QUEUE ENTRY, COMPLETING IT EXACTLY. * THE LOOP TERMINATES WHEN ALL LINE RECORDS SPECIFIED IN THE * READLS FUNCTION HAVE BEEN PROCESSED OR WHEN THE CIO BUFFER * IS EMPTY. THIS ROUTINE CAN STOP AN INDEFINITE NUMBER OF * TIMES TO WAIT FOR I/O. # *CALL SWTESS # **** PROC CSTRND - XREF LIST BEGIN. # XREF BEGIN PROC CSTSNR; #START NCF READ REQUESTS # PROC MOVE; #MOVE STORAGE DIRECT ADDRESSING (MACREL) # PROC READLS; #ISSUE CIO READLS FUNCTION (MACREL) # PROC READW; #READ WORDS FROM CIO BUFFER (MACREL) # PROC SSFCBS; #DETERMINE AVAIL DATA AND SPACE IN BUFFER # PROC SSSAWR; #ACCEPT WORKLIST REQUEST # PROC SSTATS; #ALLOCATE STORAGE AT END OF TABLE # PROC SSTRTS; #REMOVE STORAGE ANYWHERE IN TABLE # END # **** # ITEM I; #LOOP INDUCTION VARIABLE # ITEM QORD; #CALCULATED ORD LAST ENTRY OF NCF DATA Q # ITEM RORD; #NDQ ORD TO RD INTO OR CORRES NRQ NTRY ORD# ITEM NEED; #AMT OF DATA NEEDED TO COMPLETE NDQ ENTRY # ITEM AVAIL; #AMT OF DATA AVAILABLE IN NCF CIO BUFFER # ITEM WC; #SIZ NEW NDQ NTRY OR AMT FILLED IN SO FAR # ITEM SIZ; #SIZ OF CORRESPONDING NCF READ Q ENTRY # ITEM TEMP; #FOR UNNEEDED GARBAGE # ARRAY LINEHDR [00:00] S(LRHDRL$); #LINE RECORD HEADER WSA # ITEM LH$LRLEN U(01,48,12); #LINE REC LENGTH EXCLUDING ID WD # IF NDQL NQ 0 THEN # AT LEAST ONE ENTRY IN NDQ (MAY BE INC) # FOR QORD=0 STEP NDQ$ESIZE[QORD] WHILE (QORD + NDQ$ESIZE[QORD]) LS NDQL DO # FIND FIRST WD OF LAST NCF DATA Q ENTRY # BEGIN END FOR I=0 WHILE NF$IN[0] NQ NF$OUT[0] AND RLIORD LS RLCOUNT DO # LOOP UNTIL BUF EMPTY OR ALL LINRECS READ# IF NDQL NQ 0 AND NOT NDQ$CFLAG[QORD] THEN # NDQ NOT EMPTY AND LAST ENTRY INCOMPLETE # BEGIN # CONTINUE ENTRY IN PROGRESS # WC = NDQ$TCSIZE[QORD] + NDQ$LRSIZE[QORD]; # TOT DATA SO FAR # NEED = NDQ$ESIZE[QORD] - WC; SSFCBS (NCFFET, TEMP, AVAIL); # FIND OUT WHAT'S AVAILABLE # IF AVAIL GQ NEED THEN # THE LAST ENTRY CAN BE COMPLETED NOW # BEGIN AVAIL = NEED; # WILL ADD EXACT AMOUNT TO COMPLETE ENTRY # NDQ$CFLAG[QORD] = TRUE; # SET ENTRY COMPLETE # SSSAWR(CSWDF"CTDNQ") ; # CONFIGUE OR RE-CONFIGUE TERM# RLIORD = RLIORD + 1; # NEXT READLIST INDEX ENTRY # END RORD = QORD + WC; # ORD TO WHICH DATA WILL BE READ # READW (NCFFET, NDQ[RORD], AVAIL, TEMP); # XFER DATA TO NTRY # NDQ$LRSIZE[QORD] = NDQ$LRSIZE[QORD] + AVAIL; # AMT RD SO FAR# END ELSE # NDQ EMPTY OR LAST ENTRY COMPLETE # BEGIN # CREATE A NEW SKELETON NCF DATA Q ENTRY # QORD = NDQL; # WHERE NEW NDQ ENTRY WILL BE # FOR RORD=0 STEP NRQ$ESIZE[RORD] WHILE NRQ$LRIORD[RORD] NQ RLI$LRIORD [RLIORD] DO # FND NRQ NTRY CORRESPONDING TO NXT LINREC# BEGIN END READW (NCFFET, LINEHDR, LRHDRL$, TEMP); # GET NXT LINREC HDR# SIZ = NRQ$ESIZE[RORD]; WC = SIZ + LH$LRLEN[0] + 1; # TOTAL SIZE NEW NCF DATA Q NTRY# SSTATS (P, WC); # ADD NEW ENTRY SPACE TO NCF DATA Q # MOVE (SIZ, NRQ[RORD], NDQ[QORD]); # START NEW NDQ ENTRY # SSTRTS (P, RORD, SIZ); # DELETE NCF READ QUEUE ENTRY # NDQ$CFLAG[QORD] = FALSE; NDQ$LRSIZE[QORD] = LRHDRL$; # AMT OF LINREC IN NTRY SO FAR # NDQ$TCSIZE[QORD] = SIZ; # CNF/TE/R SIZ SAME AS NRQ NTRY SIZ # NDQ$ESIZE[QORD] = WC; # INITIALIZE WITH FINAL ENTRY SIZE # RORD = QORD + SIZ; # BEGINNING ORDINAL OF LINE RECORD # MOVE (LRHDRL$, LINEHDR, NDQ[RORD]); # SKELETON NDQ NTRY DONE# END # SET UP FORMAL RETURN PARAMETER ARRAY SWTESS. # IF RLIORD EQ RLCOUNT AND NF$CBIT[0] THEN # ALL LINE RECORDS HAVE BEEN DEBLOCKED # BEGIN # WE WANT PROC CSTSNR TO BE CALLED WHENEVER AN ENTRY IS PLACED IN # # THE CONFIGURE TERMINAL REQUEST QUEUE (CTQ) AND IF THERE IS # # ALREADY AN ENTRY IN THE CTQ, WE WANT CSTSNR CALLED IMMEDIATELY. # # AT THIS POINT, HOWEVER, THE INTERRUPT CELL FOR PROC CSTSNR (ITEM # # *ICSTSNR* - WATCHED BY THE STATUS WORKLIST ENTRY PROCESSOR AND # # INCREMENTED WHENEVER AN ENTRY IS PLACED IN THE CTQ) HAS SOME NON-# # ZERO VALUE THAT MAY OR MAY NOT ACCURATELY REFLECT THE PRESENSE # # OF AN ENTRY IN THE CTQ (*ICSTSNR* MAY BE NON-ZERO SOLELY AS A # # RESULT OF PREVIOUS ENTRIES THAT HAVE ALL BEEN PROCESSED). IF WE # # SIMPLY CLEAR *ICSTSNR*, RECOLLECTION OF ANY ENTRIES THAT MIGHT # # ALREADY BE IN THE CTQ WILL BE LOST AND THEY WONT GET PROCESSED # # UNTIL ANOTHER ENTRY IS PLACED IN THE CTQ (COULD BE A LONG TIME). # # WHAT WE WANT TO DO IS SET *ICSTSNR* TO ZERO IF THE CTQ IS EMPTY, # # OR SET IT NON-ZERO (ACTUAL VALUE OF NO CONSEQUENCE) IF THERE IS # # AT LEAST ONE ENTRY IN THE CTQ. HENCE, THE FOLLOWING CODE LINE. # ICSTSNR = CTQL; # REFLECTS PRESENSE OF CNF/TE/R Q ENTRIES # STE$ADDR1[0] = LOC (ICSTSNR); # WATCH INTERRUPT CELL # STE$ADDR2[0] = 0; # WATCH ONE CELL ONLY # STE$RTN[0] = LOC (CSTSNR); # PROCESSOR OF CNF/TE/R QUEUE # STE$INIT1[0] = 0; # CALL WHEN NONZERO ENTRIES IN CNF/TE/R Q # STE$INIT2[0] = 0; END ELSE # WE MUST WAIT FOR I/O # BEGIN STE$ADDR1[0] = LOC (NCFFET); # WATCH FIRST WORD OF NCF FET # STE$ADDR2[0] = LOC (NF$IN[0]); # WATCH FET IN POINTER # STE$RTN[0] = LOC (CSTRND); # RECALL THIS ROUTINE # STE$INIT1[0] = NF$WORD[0]; # SET UP INIT VALUE OF FET 1ST WD # STE$CBIT1[0] = FALSE; # RECALL WHEN FET COMP BIT IS SET # STE$INIT2[0] = NF$OUT[0]; # RECALL WHEN *IN* NQ *OUT* # IF NF$CBIT[0] THEN # I/O HAS STOPPED # READLS (NCFFET); # RESTART CURRENT READLS OPERATION # END END # CSTRND # TERM