*DECK HWLP
USETEXT NIPDEF
USETEXT APPSTAT 
USETEXT AWLNTRY 
USETEXT DRHDR 
USETEXT FREETAB 
USETEXT NWLHEAD 
USETEXT NWLNTRY 
USETEXT OVERLAY 
USETEXT PARAMP
USETEXT PT
USETEXT AT
USETEXT ACB 
USETEXT STATTAB 
 PROC HWLP;                  # PROCESS WORKLIST                        #
  
 STARTIMS;
 #
*1DC  HWLP
* 
*     1. PROC NAME           AUTHOR              DATE 
*        HWLP                E. GEE              78/01/25 
* 
*     2. FUNCTIONAL DESCRIPTION.
*          PROCESS NETWORK WORKLIST 
* 
*     3. METHOD USED. 
*          PROCESS WORKLIST ENTRIES UNTIL NONE LEFT OR LAST WORKLIST
*            FUNCTION NOT COMPLETED 
*            CHECK FOR VALID AIP HEADER WORD
*            CALL APPROPRIATE ROUTINE TO PROCESS NETWORK WORKLIST ENTRY 
*              FUNCTION 
*          IF ENTIRE WORKLIST PROCESSED, THEN PROCESS AWL (IF ONE TO
*            PROCESS) AND RELEASE REST OF NWL 
* 
*     4. ENTRY PARAMETERS.
*          ACBADDR           ACB ADDRESS
* 
*     5. EXIT PARAMETERS. 
*          ABTAPPF           ABORT FLG SET IF AIP SENT US BAD WORKLIST
*                            ENTRY
* 
*     6. COMDECKS CALLED AND SYMPL TEXTS USED.
*        APPSTAT     BUFFTAB     DRHDR
*        NIPDEF     NWLHEAD     NWLNTRY 
*        ACB
*        STATTAB             STATISTICS TABLE 
* 
*     7. ROUTINES AND OVERLAYS CALLED.
*          HPAWL             PROCESS AWL
*          HPGET             PROCESS *NETGET* 
*          HPGETMM           PROCESS *NETGMM* 
*          HPGETSM           PROCESS *NETGSM* 
*          HPPUT             PROCESS *NETPUT* 
*          HPWAIT            PROCESS *NETWAIT*
*          HRELWWL           RELEASE WHOLE WORKLIST 
*          OTIME             GET SYSTEM RTIME 
*          XTRACE            RECORD PROCEDURE CALLS 
* 
*     8. DAYFILE MESSAGES AND OTHER IMPORTANT INFORMATION.
*        THIS PROCEDURE IS CALLED BY HHIR,HPFL, AND XSACB.
* 
 #
 STOPIMS; 
# 
                    EXTERNAL VARIABLES
# 
 XREF BEGIN 
   PROC HPAWL;               # PROCESS APPLICATION WORKLIST            #
   PROC HPGET;               # PROCESS NETGET, NETGETL, NEGETF, NETGTFL#
   PROC HPGETMM ;                  # PROCESS GETMM WORKLIST            #
   PROC HPGETSM;             # PROCESS NETGETSM                        #
   PROC HPPUT;               # PROCESS NETPUT, NETPUTF                 #
   PROC HPWAIT;              # PROCESS NETWAIT                         #
   PROC HPXFR ; 
   PROC HPPUTQ ;
   PROC HRELWWL;             # RELEASE WHOLE NWL                       #
   PROC MRELS;               # RELEASE BUFFER SAPCE                    #
   PROC OTIME;               # GET SYSTEM RTIME                        #
   PROC OVLCALL;             # LOAD AND EXECUTE OVERLAY                #
   PROC XTRACE;              # TRACE CALL                              #
   END
# 
                    INTERNAL VARIABLES
# 
# 
                    NWL OP-CODE JUMP TABLE
# 
  SWITCH NWLOPJT ,OP1,OP2,OP3,OP4,OP5,OP6,OP7,OP8,OP9,
                  OP10,OP11,OP12,OP13,OP14,OP15,OP16,OP17,OP18; 
  
 ITEM TEMP; 
  
 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;
  
  
#**********************************************************************#
  
      BEGIN 
  
      CONTROL IFEQ DEBUG,1; 
        XTRACE("HWLP ") ; 
      CONTROL FI; 
  
# 
      STEP 1  INITIALIZE FUNCTION-COMPLETE FLAG AND SEE IF ANYTHING 
              TO DO 
# 
      ABTADDR = ACBADDR;
      DONE = TRUE;
      P<ACB> = ACBADDR; 
      WLADDR = ACBWLADR[0]; 
  
      FOR TEMP=TEMP WHILE DONE # PREVIOUS WORKLIST ENTRY COMPLETED     #
                      AND ACBNWLE[0] NQ 0 # MORE NWL ENTRY TO PROCESS  #
                      AND HRL NQ 0 # NAM BUFFER LEVEL NOT ZERO         #
      DO
        BEGIN                # THERE IS WORK FOR HWLP TO DO            #
# 
        STEP 2  CHECK FOR VALID AIP HEADER WORD 
# 
        P<NWLENTRY> = WLADDR; 
        TEMP = NWLEBS[0]; 
        NEXTWLA = WLADDR + TEMP;
        IF NEXTWLA GR ACBWLLWA[0] OR TEMP LS LENGTHMIN
        THEN
          BEGIN 
          ABTAPPF = XBADWCNE; # SET ABORT-APPLICATION FLAG             #
          DONE = FALSE; 
          END 
        ELSE
          BEGIN 
           IF NWLOP LS WLOPMIN OR NWLOP GR WLOPMAX
          THEN
            BEGIN 
            ABTAPPF = XBADOP; 
            DONE = FALSE; 
            END 
          ELSE
            BEGIN 
# 
            STEP 3  PROCESS OP-CODE FUNCTION
# 
# 
            **********  BEGINNING OF CASE STATEMENT  ********** 
# 
            GOTO  NWLOPJT[NWLOP[0]];
OP1:                         # PROCESS *NETPUT*                        #
OP9:                         # PROCESS *NETPUTF*                       #
  
            CONTROL IFEQ STAT,1;
              OTIME(STIME);  # GET SYSTEM TIME BEFORE PROCESSING PUT   #
            CONTROL FI; 
  
            HPPUT;
  
            CONTROL IFEQ STAT,1;
              OTIME(ETIME);  # GET SYSTEM TIME AFTER PROCESSING PUT    #
              ST$NPU = ST$NPU + 1; # INCREMENT NUMBER OF PUT TYPE CALLS#
              STTEMP = EMILS[0] - SMILS[0];  # TIME SPENT IN HPPUT     #
              ST$TPU = ST$TPU + STTEMP;  # TOTAL TIME SPENT IN HPPUT   #
              IF ST$LPU LS STTEMP 
              THEN           # FOUND LARGER TIME INTERVAL IN HPPUT     #
                BEGIN 
                ST$LPU = STTEMP;   # NEW LARGEST TIME INTERVAL         #
                END 
            CONTROL FI; 
  
            GOTO CHECKFC; 
OP2:                         # PROCESS *NETGET*                        #
OP3:                         # PROCESS *NETGETL*                       #
OP8:                         # PROCESS *NETGETF*                       #
OP10:                        # PROCESS *NETGTFL*                       #
  
            CONTROL IFEQ STAT,1;
              OTIME(STIME);  # GET SYSTEM TIME BEFORE PROCESSING GET   #
            CONTROL FI; 
  
            HPGET;
  
            CONTROL IFEQ STAT,1;
              OTIME(ETIME);  # GET SYSTEM TIME AFTER PRCESSING GET     #
              ST$NGE = ST$NGE + 1; # INCRE NUMBER OF GET TYPE CALLS    #
              STTEMP = EMILS[0] - SMILS[0];  # TIME SPENT IN HPGET     #
              ST$TGE = ST$TGE + STTEMP;  # TOTAL TIME SPENT IN HPGET   #
              IF ST$LGE LS STTEMP 
              THEN           # FOUND LARGER TIME INTERVAL IN HPGET     #
                BEGIN 
                ST$LGE = STTEMP;   # NEW LARGEST TIME INTERVAL         #
                END 
            CONTROL FI; 
  
            GOTO CHECKFC; 
OP4:                         # PROCESS *NETGETSM*                      #
  
            CONTROL IFEQ STAT,1;
              OTIME(STIME);  # GET SYSTEM TIME BEFORE PROCESSING GETSM #
            CONTROL FI; 
  
            HPGETSM;
  
            CONTROL IFEQ STAT,1;
              OTIME(ETIME);  # GET SYSTEM TIME AFTER PROCESSING GETSM  #
              ST$NGS = ST$NGS + 1; # INCRE NUMBER OF NETGETSM CALLS    #
              STTEMP = EMILS[0] - SMILS[0];  # TIME SPENT IN HPGETSM   #
              ST$TGS = ST$TGS + STTEMP;  # TOTAL TIME SPENT IN HPGETSM #
              IF ST$LGS LS STTEMP 
              THEN           # FOUND LARGER TIME INTERVAL IN HPGETSM   #
                BEGIN 
                ST$LGS = STTEMP;   # NEW LARGEST TIME INTERVAL         #
                END 
            CONTROL FI; 
  
            GOTO CHECKFC; 
OP5:                         # PROCESS *NETWAIT*                       #
  
            CONTROL IFEQ STAT,1;
              OTIME(STIME);  # GET SYS TIME BEFORE PROCESSING NETWAIT  #
            CONTROL FI; 
  
            HPWAIT; 
  
            CONTROL IFEQ STAT,1;
              OTIME(ETIME);  # GET SYSTEM TIME AFTER PROCESSING NETWAIT#
              ST$NWA = ST$NWA + 1; # INCRE NUMBER OF NETWAIT CALLS     #
              STTEMP = EMILS[0] - SMILS[0];  # TIME SPENT IN HPWAIT    #
              ST$TWA = ST$TWA + STTEMP;  # TATAL TIME SPENT IN HPWAIT  #
              IF ST$LWA LS STTEMP 
              THEN           # FOUND LARGER TIME INTERVAL IN HPWAIT    #
                BEGIN 
                ST$LWA = STTEMP;   # NEW LARGEST TIME INTERVAL         #
                END 
            CONTROL FI; 
  
            GOTO CHECKFC; 
OP6:                         # NETON NOT ALLOWED HERE                  #
OP7:                         # NETOFF NOT ALLOWED HERE                 #
OP13:                        # BAD OPCODE RECEIVED FOR WORKLIST        #
OP15: 
OP16: 
OP17: 
            DONE = FALSE; 
            ABTAPPF = XBADOP; 
            GOTO CHECKFC ;
OP11: 
            HPXFR ; 
            GOTO CHECKFC ;
OP12: 
            GOTO CHECKFC ;
OP14:                        # PROCESS GETMM WORKLIST                  #
            HPGETMM ; 
            GOTO CHECKFC ;
OP18:                        # PROCESS NETPUTQ OPCODE                  #
            HPPUTQ(NWLTLW[0],NWLPQN[0]) ; 
            GOTO CHECKFC ;
CHECKFC:  
# 
            **********  END OF CASE STATEMENT  ********** 
# 
# 
            STEP 4  CHECK IF LAST FUNCTION COMPLETED
# 
            P<ACB> = ACBADDR;# ACB MAY HAVE MOVED                      #
            IF DONE 
            THEN             # FUNCTION  COMPLETED                     #
              BEGIN 
              ACBNWLE[0] = ACBNWLE[0] - 1;
              WLADDR = NEXTWLA; 
              ACBWLADR[0] = NEXTWLA;
              END 
            END 
          END 
        END 
  
      IF HRL EQ 0 # NAM REACHED MAX FL                                 #
        AND DONE # PREVIOUS NWL ENTRY PROCESSED                        #
        AND ACBNWLE[0] NQ 0 # MORE NWL ENTRY TO PROCESS                #
      THEN
        BEGIN # SUSPEND NWL WORKLIST PROCESSING                        #
        TEMP = ACBAN[0]; # APPLICATION NUMBER                          #
        ATHRL0[TEMP] = TRUE; # SET NWL SUSPENDED AT HRL=0              #
        END 
  
      IF ATU[ACBAN[0]]
      THEN                  # DATA AVAIL WORD IN AIP NEEDS UPDATING    #
        BEGIN               # SUSPEND WORKLIST PROCESSING COMPLETION   #
        DONE = FALSE;       #   TILL UPDATED                           #
        IF ATASBI[ACBAN[0]] 
        THEN                # APP SWAPPED OUT BY OS - SWAPIN ISSUED    #
          BEGIN 
          ATASBS[ACBAN[0]] = TRUE;  # SET APP SWAPPED OUT BY OS FLAG   #
          END 
        END 
      IF DONE                # NWL PROCESSING COMPLETE                 #
        AND ACBNWLE[0] EQ 0 
      THEN
        BEGIN 
        IF ACBAWLADDR[0] NQ 0 
        THEN # RETURN AWL/ CLEAR SHORT TERM CONNECTIONS                #
          HPAWL;
        ELSE # CLEAN UP ACB                                            #
          BEGIN 
          HRELWWL;
          END 
        IF (ACBAN[0] NQ 1) AND (ACBSMQ[0] GR MAXSUPMSG) 
        THEN    # IF A NON-NVF APP IS NOT PICKING UP QUEUED SUP MSGS   #
          BEGIN 
          ABTAPPF = X2MANYSM;  # SET ABORT APPLICATION FLAG            #
          END 
        END 
  
      RETURN; 
      END 
TERM
