*DECK XEXEC USETEXT NIPDEF USETEXT AT USETEXT PARAMP USETEXT BACKBUF USETEXT CET USETEXT DRHDR USETEXT FREETAB USETEXT KDIS USETEXT OVERLAY USETEXT PIT USETEXT PT USETEXT LLCB USETEXT NCNT USETEXT PCNB USETEXT NBT USETEXT NHEADER USETEXT STATTAB USETEXT SYSCOMD USETEXT SYSTIME USETEXT TNT USETEXT DBGBUF PROC XEXEC; # NIP MAIN EXECUTION CONTROL # STARTIMS; # # STOPIMS; # EXTERNAL VARIABLES # XREF BEGIN PROC HHIR; # MAIN HOST INTERFACE PROCESSOR # PROC MGETS; # GET ONE FREE BUFFER # PROC MRELS; # FREE ONE BUFFER INTO THE FREE CHAIN # PROC NEIB; # UPLINE MESSAGE PROCESSOR # PROC NEIB1; # CONTINUE PROCESSING OF UPLINE MESSAGES # PROC NNETREL; # RELEASE ZZZZZDN FILE # PROC OMSG; # SEND MESSAGE # PROC OTIME; # GET SYSTEM TIME # PROC OVLCALL; # OVERLAY LOADER # PROC XRECALL; # RECALL # PROC XSACB; # PROCESS ACB STATUS CHANGES # PROC XTRACE; # TRACE CALLS # END # LOCAL DEFINITIONS # DEF TCET # 2000 #; # CHECK CET STATUS CHANGE TIMER IN MS # DEF TPCR # 5000 #; # XCHKPCR CALL TIMER IN MILLISECONDS # DEF TACBS # 500 #; # CHECK ACB STATUS CHANGE TIMER IN MS # DEF TRASIZE # 274 #; # TRACE BUFFER SIZE # DEF PBTID # 63 #; # PIP TRACE BUFFER ID # # LOCAL VARIABLES # ITEM BUF ; # BUFFER FOR INTRAHOST A-A QUEUE # ITEM I I; # INDUCTION VARIABLE # ITEM NBTADR U; ITEM FINISH B; # FLAG TO INDICATE FINISHED RELEASING BUF # ITEM NEWMS U=0; # NEW MILLESECOND TIME # ITEM RECALL B; # RECALL FLAG # ITEM MS U; # MILLISECOND CLOCK # ITEM TIMER$CET U=0; # CHECK CET TIMER IN MS # ITEM TIMER$PCR U=0; # XCHKPCR CALL TIMER IN MS # ITEM TIMER$BUF U=0; # GARBAGE COLLECTION CALL TIMER IN MS # ITEM TIMER$ACBS U=0; # CHECK ACB STATUS TIMER IN MS # ITEM TEMP U; # TEMPORARY # ITEM TEMP1 U; # TEMPORARY # ITEM TMP U; # TEMPORARY # ITEM TMPFET U; # TEMPORARY # CONTROL IFEQ STAT,1; ARRAY STIME P(1); # RTIME BUFFER FOR STARTING TIME # BEGIN ITEM SMILS U(0,24,36); # STARTING TIME IN MILLESECONDS # END ARRAY ETIME P(1); # RTIME BUFFER FOR ENDING TIME # BEGIN ITEM EMILS U(0,24,36); # ENDING TIME IN MILLESECONDS # END ITEM STTEMP; # TEMPORARY STATISTICS VARIABLE # CONTROL FI; ARRAY KZEROS S(1); BEGIN # LINE OF BINARY ZEROES # ITEM KZEROLINE U(00,00,60) = [0]; END ARRAY CNX ; BEGIN ITEM CNE U(00,00,60) ; ITEM CN1 U(00,52,04) ; ITEM CN2 U(00,56,04) ; END CONTROL EJECT; BEGIN # XEXEC # CONTROL IFEQ DEBUG,1; XTRACE("XEXEC"); # TRACE CALL # CONTROL FI; KDIS$STAT = 0; # NO STATUS DISPLAY TO FORMAT # OTIME(THETIME); # GET CURRENT TIME # MS = MSECS[0]; # SET MILLISECOND CLOCK # P = 0; # PERFORM PERIODIC SERVICES # IF TIMER$ACBS LQ MS OR MSG$AN GR 0 THEN BEGIN CONTROL IFEQ STAT,1; OTIME(STIME); # GET SYSTEM TIME BEFORE XSACB CALL # CONTROL FI; IF TIMER$ACBS LQ MS # SHOULD LOOK AT ALL AN # THEN BEGIN MSG$AN = 0; # CLEAR MSG$AN SUCH THAT ALL AN ARE CHECK # END XSACB; # PROCESS ACB(S) STATUS CHANGES # CONTROL IFEQ STAT,1; OTIME(ETIME); # GET SYSTEM TIME AFTER XSACB CALL # STTEMP = EMILS[0] - SMILS[0]; IF STTEMP GR ST$LXS THEN # FOUND LARGER TIME INTERVAL # BEGIN ST$LXS = STTEMP; # LARGEST TIME INTERVAL # END IF STTEMP GR 200 THEN # SPENT MORE THAN .2 SECONDS IN INTERVAL # BEGIN ST$MXS = ST$MXS + 1; # INCREMENT NO OF TIMES GREATER .2 SEC# END ST$TXS = ST$TXS + STTEMP; # INCREMENT TOTAL TIME IN INTERVAL# CONTROL FI; IF MSG$AN EQ 0 # IF ALL TIMER$ACBS HAVE TO BE CHECKED # THEN BEGIN TIMER$ACBS = MS + TACBS; # UPDATE TIMER # END ELSE BEGIN MSG$AN = 0; # CLEAR MESSAGE FOR APPLICATION FLAG # END # DO NOT UPDATE TIMER$ACBS SO THAT # # OTHER APPLICATIONS CAN BE CHECKED # IF TIMER$PCR LQ MS THEN BEGIN # CHECK CONNECTION INACTIVITY/ K DISPLAY # OVLNAME = XCHKPCRP;# AND RELEASE UNUSED DATA STRUCTURES # OVLCALL; TIMER$PCR = MS + TPCR; END IF (ATENTRYW[NVFAN] NQ 0 ) AND ( ( (TIMER$BUF LQ MS ) AND ( (FRENOFB GR NFBUFF) OR (FRESFB GR NFSIZE ) OR (REDUCEFL NQ 0 ) ) ) OR (HRL LQ HRLV1 ) ) THEN # CALL GARBAGE COLLECTION TO PACK FL # BEGIN COUNTER = COUNTER + 1 ; # COUNTING FOR PRU BUFFER MOVING# PARAMP1 = 0 ; # ASSUMING NO PRU TO BE MOVED # PRUMOVE = FALSE; # NOT MOVING FREE PRU BUFFERS # IF COUNTER EQ MGBCLPB THEN BEGIN # REACH THE LIMIT # # SET FROM LIST TO CIRCULAR CHN # PRUMOVE = TRUE; # OKAY TO MOVE FREE PRU BUFFERS # OVLNAME = MSETPTRP ; OVLCALL ; COUNTER = 0 ; END # REACH THE LIMIT # FLGBGCLT[0] = TRUE; # GARBAGE COLLECTION IN PROGRESS# OVLNAME = MGBGCLTP; OVLCALL; FLGBGCLT[0] = FALSE; # GARBAGE COLLECTION COMPLETED # TIMER$BUF = MS + TBUF; END IF TIMER$CET LQ MS OR CETC[0] # CET ENTRY(S) STATUS CHANGED # THEN BEGIN # PROCESS CET CHANGE # OVLNAME = XCHKCETP; OVLCALL; TIMER$CET = MS + TCET; END END # CHECK IF PIP NEEDS ADDITIONAL PRU BUFFERS # IF PITRPA[0] THEN # PIP NEEDS ADDITIONAL PRU BUFS # BEGIN PITRPA[0] = FALSE; # CLEAR REQUEST PRU ACTIVITY FLG# OVLNAME = XCHKABCP; # NAME OF OVERLAY TO LOAD # OVLCALL; # LOAD AND EXECUTE OVERLAY # END # RELEASE PIP PROCESSED BUFFERS # IF OUTREL THEN # OUTBOUND BUFFER(S) TO RELEASE # BEGIN OUTREL = FALSE; FOR TMPFET=0 STEP NBTFETNO UNTIL NBTMAXID DO # SCAN THROUGH ALL THE ACTIVE NBT ENTRIES # BEGIN # TO RELEASE ALL PROCESSED OUTBOUND BUFFERS # IF NBTIUF[TMPFET] THEN # NBT ENTRY IN USE # BEGIN FOR TMP=TMPFET+2 STEP 1 UNTIL TMPFET+4 DO # GO THROUGH ALL OUTBOUND FETS # BEGIN IF NBTOUT[TMP] NQ 0 THEN # OUTBOUND BUFFER PROCEESED BY PIP # BEGIN # CHECK IF BUFFER(S) CAN BE RELEASED # P = NBTFIRST[TMP]; # FIRST BUFFER IN CHAIN # FINISH = FALSE; FOR TEMP=TEMP WHILE NOT FINISH DO # RELEASE BUFS IN OUTBOUND CHAIN# BEGIN # CHECK AND PROCESS SPECIAL BLOCK ID FIRST # IF BLKID[0] EQ PRUSPECID THEN BEGIN # SPECIAL OUTBOUND BLK FOR PCNB # P = P + BLKHSIZE ; P = NHWORD[0] ; #CAN NOW CONVERT NCNB TO PCNB# CNE[0] = PCNBCN[0] ; # SET BATCH STREAM STATE AND BLOCK HANDLER STATE # P = PCNBCTAD[0] ; NCNTBSS[CN2+NCNTHSIZE] = BSSI ; IF PCNBDT[0] EQ DT$CR OR ( PCNBXFR[0] # FILE TRANSFER CONN # AND PCNBREC[0] ) # RECEIVING # THEN BEGIN NCNTBHS[CN2+NCNTHSIZE] = BHSPRUI ; # INPUT PRU # END ELSE BEGIN NCNTBHS[CN2+NCNTHSIZE] = BHSPRUO ; # PRU OUTPUT # END PCNBID[0] = PCNBIDVALUE ; # ID NOW IS PCNB # BLKID[0] = POBIDVALUE; # CONVERT TO REGULAR ID # END TEMP = NEXTPTR[0]; # NEXT BUFFER IN CHIAN # IF P EQ NBTOUT[TMP] THEN # NOT LAST BUFFER IN CHAIN # BEGIN FINISH = TRUE; # COMPLETED RELEASING BUFFERS # END ELSE # THIS BUFFER CAN BE RELEASED # BEGIN # CHECK AND PROCESS BACKS BLOCKS FROM BACK TABLE # IF (P LS BACKBLWA) AND (P GQ BACKBFWA) THEN # THIS IS BACK ENTRY IN BACK BUF # BEGIN P = P - 1; # HEAD WRD OF ENTRY# CMWORD[0] = BACKFFREE; # PTR TO NEXT FREE ENTRY # BACKFFREE = P; # NEW FIRST FREE ENTRY # END ELSE # THIS IS REGULAR DYNAMIC BUFFER # BEGIN MRELS(P); # RELEASE BUFFER # END P = TEMP; # RESET POINTER # END END NBTFIRST[TMP] = P; # NEW FIRST BUF IN CHAIN # OUTREL = OUTREL OR (NBTIN[TMP] NQ P); # FLAG MORE OUTSTANDING OUTBOUND BUFFERS # END END END END END FOR NBTIDX = 0 STEP NBTFETNO WHILE NBTIDX LQ NBTMAXID DO BEGIN IF NBTREQ[NBTIDX + 5] # REQUEST FLAG SET # THEN BEGIN IF NOT NBTACT[NBTIDX + 5] # ACTIVE FLAG NOT SET # THEN BEGIN IF NOT NBTREL[NBTIDX + 5] # RELEASE FLAG NOT SET # THEN BEGIN MGETS(TRASIZE,NBTADR,0); # ALLOCATES BUFFER # P = NBTADR; BLKID[0] = PBTID; NBTFIRST[NBTIDX + 5] = NBTADR + BLKHSIZE; NBTWD4[NBTIDX + 5] = NBTADR + TRASIZE; NBTACT[NBTIDX + 5] = TRUE; END END END END IF HRL NQ 0 THEN # NAM NOT AT MAX FIELD LENGTH # BEGIN # PROCESS UPLINE NETWORK MESSAGES # CONTROL IFEQ STAT,1; OTIME(STIME); # GET SYSTEM TIME BEFORE NEIB CALL # CONTROL FI; NEIB; # PROCESS INCOMING NETWORK TRAFFIC # CONTROL IFEQ STAT,1; OTIME(ETIME); # GET SYSTEM TIME AFTER NEIB CALL # STTEMP = EMILS[0] - SMILS[0]; IF STTEMP GR ST$LNI THEN # FOUND LARGER TIME INTERVAL # BEGIN ST$LNI = STTEMP; # LARGEST TIME INTERVAL # END IF STTEMP GR 200 THEN # SPENT MORE THAN .2 SECONDS IN INTERVAL # BEGIN ST$MNI = ST$MNI + 1; # INCREMENT NO OF TIMES GREATER .2 SEC# END ST$TNI = ST$TNI + STTEMP; # INCREMENT TOTAL TIME IN NEIB # CONTROL FI; # PROCESS WORKLIST FROM APPLICATION # HHIR; # PROCESS INCOMING APPLICATION WORKLISTS # # CHECK IF ANY MESSAGES HAVE BEEN ADDED TO THE INTRAHOST QUEUE # P = TNTLLAD[0]; IF P NQ 0 THEN # HOST TO HOST LOGICAL LINK EXISTS # BEGIN P = 0; BUF = LLCBSHFP[0]; # FIRST MSG IN LIST # FOR I=I WHILE BUF NQ 0 DO BEGIN LLCBSHFP[0] = NEXTPTR[BUF]; # UPDATE FORWARD POINTER # NBTIDX = NBTMAXID + 1; # NBT INDEX FOR INTRAHOST MSG # NEIB1(BUF,0); # PROCESS INTRAHOST MESSAGE # BUF = LLCBSHFP[0]; END END END # PROCESS NAM BUFFER REGULATION LEVEL CHANGES # CONTROL IFEQ STAT,1; OTIME(STIME); # GET SYSTEM TIME AT THIS POINT IN PROC # CONTROL FI; IF HRL NQ LASTHRL THEN BEGIN OVLNAME = XNBRLCP; OVLCALL; END # CHECK NAM K DISPLAY ACTIVITY # IF NOT KDVW[0] THEN # K DISPLAY NOT BEING VIEWED # BEGIN IF KDLCOMP[0] OR KDRCOMP[0] THEN # K DISPLAY ASSIGNED TO NAM # BEGIN OMSG(KZEROS,2); # CLEAR FLASHING REQUEST ON B-DISPLAY # KDALERT[0] = FALSE; # CLEAR OUTSTANDING ALERT FLAG # KDVW[0] = TRUE; # K DISPLAY NOW BEING VIEWED # KDTIMER[0] = RTSECS[0] + TKDVW; # SET VIEW TIMEOUT TIMER # KDLCOMP[0] = FALSE; KDRCOMP[0] = FALSE; END END ELSE # K DISPLAY IS BEING VIEWED # BEGIN IF KWLPTR[0] NQ 0 THEN # KWL TO ADD/DELETE ST ENTRY(S) # BEGIN OVLNAME = KCHANGEP; OVLCALL; END IF KBUF1[0] NQ 0 THEN # K DISPLAY INPUT AVAILABLE # BEGIN OVLNAME = KPTYPINP; # PROCESS K DISPLAY TYPE INS # OVLCALL; END IF KSHOW[0] THEN BEGIN IF KDETAIL[0] THEN OVLNAME=KRIGHTDP; ELSE OVLNAME=KRIGHTP; OVLCALL; END IF KDIS$STAT NQ 0 THEN # STATUS DISPLAY FORMATTING REQUIRED # BEGIN OVLNAME = KDSTINP; # FORMAT STATUS DISPLAY # OVLCALL; END END # RELEASE NETWORK TRACE FILE ZZZZZDN IF MC PARAMETER IS SPECIFIED IN NIP-S CONTROL STATEMENT AND MC NUMBER OF TRACE MESSAGES HAS REACHED # CONTROL IFEQ ZZDN,1; IF MC NQ 0 AND MSGCNT GQ MC THEN NNETREL(ZNRF1,0); CONTROL FI; CONTROL IFEQ STAT,1; # STATISTICS ON # ST$LOOP = ST$LOOP + 1; # INCR NO OF TIMES THROUGH # OTIME(ETIME); # GET SYSTEM TIME AT THIS POINT IN PROC # STTEMP = EMILS[0] - SMILS[0]; IF STTEMP GR ST$LT2 THEN # FOUND LARGER TIME INTERVAL # BEGIN ST$LT2 = STTEMP; # NEW LARGEST TIME INTERVAL # END IF STTEMP GR 200 THEN # SPENT MORE THAN .2 SECONDS IN INTERVAL # BEGIN ST$MT2 = ST$MT2 + 1; # INCREMENT NO OF TIMES GREATER .2 SEC # END ST$TT2 = ST$TT2 + STTEMP; # TOTAL TIME SPEND IN THIS INTERVAL # SMILS[0] = EMILS[0]; # BEGINNING TIME FOR NEXT PART OF PROC # CONTROL FI; # XEXEC LOOP # IF MSG$AN EQ 0 THEN # NO DATA QUEUED FOR APP TO PROCESS # BEGIN # GIVE UP CPU UNTIL SOMETHING TO DO # RECALL = TRUE; # INITIALIZE RECALL FLAG # FOR MS=MS WHILE RECALL DO # LOOP UNTIL SOMETHING TO DO # BEGIN IF SSCLK[0] THEN # SSC WORKLIST HAS BEEN RECEIVED # BEGIN RECALL = FALSE; # DO NOT WANT TO GO INTO RECALL # END ELSE # NO SSC WORKLIST HAS BEEN RECEIVED # BEGIN IF PITWORK[0] THEN # PIP HAS WORK FOR NIP TO DO # BEGIN PITWORK[0] = FALSE; # CLEAR WORK-FOR-NIP FLAG # RECALL = FALSE; # DO NOT WANT TO GO INTO RECALL # END ELSE # GO INTO RECALL FOR SMALLEST TIMEOUT # BEGIN OTIME(THETIME); # CALL RTIME NOS MACRO # NEWMS = MSECS[0]; # CURRENT MILLISECOND TIME # IF (NEWMS - TIMER$ACBS) GQ 0 THEN # SMALLEST TIMEOUT INVERVAL HAS ELAPSED # BEGIN RECALL = FALSE; # TERMINATE WHILE LOOP # END ELSE # OKAY TO GO INTO RECALL # BEGIN XRECALL(0); # CALL RECALL NOS MACRO # END END END END END CONTROL IFEQ STAT,1; OTIME(ETIME); # GET SYSTEM TIME AT END OF PROC # STTEMP = EMILS[0] - SMILS[0]; IF STTEMP GR ST$LT3 THEN # FOUND LARGER TIME INTERVAL # BEGIN ST$LT3 = STTEMP; # NEW LARGEST TIME INTERVAL # END IF STTEMP GR 500 THEN # SPENT MORE THAN .5 SECONDS IN INTERVAL # BEGIN ST$MT3 = ST$MT3 + 1; # INCREMENT NO OF TIMES GREATER .5 SEC # END ST$TT3 = ST$TT3 + STTEMP; # INCREMENT TOTAL TIME IN THIS PART # CONTROL FI; RETURN; END TERM