*DECK TIMEVNT 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRMEM 
USETEXT COMRQUE 
USETEXT COMRNDR 
USETEXT COMRNET 
USETEXT COMRRHH 
USETEXT COMRFLS 
PROC TIMEVNT; 
# TITLE TIMEVNT - PROCESS PERIODIC FUNCTIONS #
  
      BEGIN  # TIMEVNT #
  
# 
**    TIMEVNT - PROCESS PERIODIC FUNCTIONS. 
* 
*     INITIATES PROCESSING FOR EVENTS THAT REQUIRE PERIODIC ATTENTION.
* 
*     PROC TIMEVNT. 
* 
*     ENTRY   -  NONE 
* 
*     EXIT       PERIODIC EVENTS PROCESSED. 
* 
*     PROCESS -  INITIATE PROCESSING OF WAIT SWAP QUEUE 
*                CLEAR CONVERT MODE WAIT QUEUE. 
*                FOR EACH APPLICATION TABLE HEADER: 
*                  CHECK FOR SWAPIN REQUEST COMPLETION. 
*                  IF IDLE DOWN IN PROGRESS 
*                    AND IDLE MESSAGES NOT SENT 
*                    AND APPLICATION NETTED ON
*                  THEN:  
*                    SEND IDLE MESSAGE TO APPLICATION.
*                  IF ONE SECOND HAS EXPIRED
*                  THEN:  
*                    AGE NETWAIT TIMER
*                    AGE NETON TIMER
*                    AGE CONNECTION REQUEST TIMER 
*                    RETRY REQUESTS ON DELAY QUEUE
*                    CHECK FOR SUPERVISORY MESSAGE LIMIT REACHED. 
*                    IF ITF AND NETTED ON 
*                    THEN 
*                      CHECK FOR MUJ ACTIVITY 
*                CLEAR IDLE SECONDS COUNTER.
*                IF IDLE DOWN IN PROGRESS 
*                  AND IDLE MESSAGE NOT SENT
*                THEN:  
*                  SEND IDLE MESSAGE TO RHF"S B-DISPLAY.
*                  SET IDLE MESSAGE SENT FLAG.
*                IF ONE SECOND HAS EXPIREC
*                THEN:  
*                  CHECK FLASHING OPERATOR MESSAGE
*                  IF 5 SECONDS EXPIRED 
*                  THEN:  
*                    CLEAR PATH REJECT BITS 
*                    CALL RHH TO UPDATE EST STATUS
*                    WAIT FOR RHH FUNCTION TO COMPLETE. 
*                  FOR EACH LOCAL NAD ENTRY:  
*                    IF JOB WAITING TO BE SWAPPED IN FOR CONVERT
*                         MODE RESOURCES
*                    THEN 
*                      CALL RETURN NSUP TO SWAP IN THE JOB. 
*                    IF 5 SECONDS EXPIRED 
*                    THEN:  
*                      PROCESS EST STATUS CHANGES...
*                      RELEASE UNNECESSARY EMPTY QUEUE SPACE. 
*                      IF IDLE NETWAIT TIME LIMIT LESS THAN 5 SECONDS 
*                      THEN 
*                        SET GOIDLE FALSE.
*                  IF GOIDLE FALSE
*                  THEN 
*                    FOR EACH LOCAL NAD ENTRY:  
*                      ENSURE STATUS REQUEST QUEUED 
*                RETURN:  
* 
* 
****  PROC TIMEVNT - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC AGENTON;                # AGE NETON TOMER #
        PROC AGEREQ;                 # AGE CONNECTION REQUEST TIMER # 
        PROC AGEWAIT;                # AGE NETWAIT TIMER #
        PROC CKESTAT;                # CHECK FOR CHANGES IN EST STATUS# 
        PROC CKMXSUP;                # CHECK FOR MAXIMUM SUPR. MSGS # 
        PROC CKOPMSG;                # CHECK FOR FLASHING OPERATOR MSGS#
        PROC CKSWPIN;                # CHECK SWAPIN COMPLETION #
        PROC CLRPTHR;                # CLEAR PATH REJECT BITS # 
        PROC DLYRTRY;                # RETRY REQUESTS ON DELAY QUEUE #
        ITEM FAPLADR  I;             # FIRST APPLICATION TABLE ADDRESS #
        PROC FREEMEM;                # RELEASE UNUSED MEMORY #
        PROC GENWAIT;                # GENERATE NETWAIT UCP REPLY QUE # 
        ITEM LAPLADR  I;             # LAST APPLICATION TABLE ADDRESS # 
        PROC MUJACT;                 # CHECK FOR MUJ ACTIVITY # 
        ITEM NUMNADS I;              # NUMBER OF LOCAL NADS # 
        ITEM NADTBL  I;              # START OF LOCAL NAD TABLE # 
        PROC REQSTAT;                # ENSURE STATUS REQUEST QUEUED # 
        PROC RHFMSG;                 # DAYFILE RHF MESSAGE #
        PROC RTNNSUP;                # SET FUNCTION COMPLETE #
        PROC SNDSHDM;                # SEND SHUT DOWN MESSAGE # 
        PROC STRTNDR;                # START UP COPY OF NDR # 
        PROC CALLSYS;                # MAKE RA+1 CALLS #
        PROC WAIT;                   # WAIT FOR COMPLETION #
        PROC WAITSWP;                # PROCESS ENTRIES ON WAIT SWAP Q # 
        END 
  
      DEF FSTSECONDS #1#;            # FAST TIMER EXPIRATION TIME # 
      DEF MEDSECONDS #5#;            # MEDIUM TIMER EXPIRATION TIME # 
      DEF SLOSECONDS #60#;           # SLOW TIMER EXPIRATION TIME # 
# 
****  PROC TIMEVNT - XREF LIST END. 
# 
  
  
      ITEM INDX      I;              # INDEX FOR LOCAL NAD TABLE TOUR # 
      ITEM REQSTQUED B;              # NAD REQUEST QUEUED FLAG #
      ITEM SECONDSF  I;              # SECONDS SINCE LAST UPDATE OF 
                                       FAST TIMER (SECOND TIMER) #
      ITEM SECONDSM  I;              # SECONDS SINCE LAST UPDATE OF 
                                       MEDIUM TIMER (5 SECOND TIMER) #
      ITEM SECONDSS  I;              # SECONDS SINCE LAST UPDATE OF 
                                       SLOW TIMER (MINUTE TIMER) #
      ITEM IDLE      I = 0;          # IDLE MESSAGE TO BE SENT #
  
      ARRAY CMSWAPQ [0:19] S(1); # MAX OF 20 LOCAL NADS # 
        BEGIN 
        ITEM CS$WD1     I(00,00,60);
        ITEM CS$ATA     I(00,00,18); # APPLICATION TABLE ADDRESS #
        ITEM CS$TIME    U(00,24,12); # TIME LEFT IN NETWAIT # 
        END 
  
CONTROL EJECT;
  
      SECONDSF = (TIMER - FASTIME) / (2**12); 
      SECONDSM  = (TIMER - MEDTIME) / (2**12);
      SECONDSS  = (TIMER - SLOTIME) / (2**12);
  
      IF FASTIME EQ 0 
      THEN
        BEGIN  # FIRST TIMEVNT CALL # 
        FASTIME = TIMER - FSTSECONDS * 2**12; 
        MEDTIME = TIMER - MEDSECONDS * 2**12; 
        END 
  
      IF SECONDSF GE FSTSECONDS 
      THEN
        BEGIN  # FAST TIMER EXPIRED # 
        FASTIME = FASTIME + FSTSECONDS * 2**12;  # UPDATE FAST TIMER #
        END 
  
      IF SECONDSM GE MEDSECONDS 
      THEN
        BEGIN  # MEDIUM TIMER EXPIRED # 
        MEDTIME = MEDTIME + MEDSECONDS * 2**12;  # UPDATE MEDIUM TIMER #
        END 
  
      IF SECONDSS GE SLOSECONDS 
      THEN
        BEGIN  # SLOW TIMER EXPIRED # 
        SLOTIME = TIMER;             # UPDATE SLOW TIMER #
        END 
  
  
      WAITSWP;                       # CK ENTRIES ON WAIT SWAP QUEUE #
  
      FOR INDX = 1 STEP 1 UNTIL NUMNADS DO
        BEGIN 
        CS$WD1[INDX-1] = 0; 
        END 
  
      IDLEWAIT = O"7777"; 
  
      P<APL$HEADER> = FAPLADR;
      ASLONGAS P<APL$HEADER> LE LAPLADR 
      DO
        BEGIN  # LOOP THRU APL HEADERS #
        CKSWPIN;                   # CK FOR COMPLETED SWAPINS # 
  
        IF IDLEDWN
          AND NOT IDLEMESSNT
          AND APL$NETON 
        THEN
          BEGIN 
          SNDSHDM(IDLE);
          END 
  
        IF SECONDSF GE FSTSECONDS 
        THEN
          BEGIN  # FAST TIMER EXPIRED # 
          AGEWAIT(CMSWAPQ);          # AGE NETWAIT QUEUE #
          AGENTON;                   # AGE NETON STARTUP TIMER #
          AGEREQ;                    #AGE CONNECTION REQUEST TIMER #
          DLYRTRY;                   # RETRY REQUESTS ON DELAY Q #
          CKMXSUP;                   # CK FOR MAX SVP MSGS #
          IF APL$NAME EQ APL$ITF
            AND APL$NETON 
          THEN
            BEGIN 
            MUJACT;                  # CHECK FOR MUJ ACTIVITY # 
            END 
  
          END 
  
        P<APL$HEADER> = P<APL$HEADER>  + APL$LENGTH 
                           + APL$NUMCON * CON$LENGTH; 
        END 
  
      IDLESEC = 0;
  
      IF IDLEDWN
        AND NOT IDLEMESSNT
      THEN
        BEGIN 
        RHFMSG(LOC(MSG$IDLDWN),MSG$IDLLGT); 
        IDLEMESSNT = TRUE;
        END 
  
      IF SECONDSF GE FSTSECONDS 
      THEN
        BEGIN  # FAST TIMER EXPIRED # 
        CKOPMSG;                     # CK FLASHING OPERATOR MSG # 
  
        IF SECONDSM GE MEDSECONDS 
        THEN
        BEGIN  # MEDIUM TIMER EXPIRED # 
          RHH$PARAM = 0;
          RHH$NUMNAD = NUMNADS; 
          RHH$NADADR = NADTBL;
          RHHFUNCTN  = RH$INIT; 
          RHHPARMAD  = LOC(RHH$PARAM);
          CALLSYS(RHHCALL); 
  
          CLRPTHR;
  
          WAIT(LOC(RHH$PARAM)); 
          END 
  
        P<NAD$ENTRY> = NADTBL;
        SLOWFOR INDX = 1 STEP 1 UNTIL NUMNADS 
        DO
          BEGIN  # LOOP THRU NAD TABLE #
  
          IF CS$WD1[INDX-1] NE 0
          THEN
            BEGIN 
            P<APL$HEADER> = CS$ATA[INDX-1]; 
            GENWAIT;
            RTNNSUP;
            END 
  
          IF SECONDSM GE MEDSECONDS 
          THEN
            BEGIN  # MEDIUM TIMER EXPIRED # 
            CKESTAT;                 # CHECK AND UPDATE EST STATUS #
            END 
  
          P<NAD$ENTRY> = P<NAD$ENTRY> + NAD$LENGTH; 
          END 
  
        IF SECONDSM GE MEDSECONDS 
        THEN
          BEGIN  # MEDIUM TIMER EXPIRED # 
          FREEMEM;                   # TRY TO RELEASE EMPTY QUEUE SPACE#
          IF IDLEWAIT LT 5
          THEN
            BEGIN 
            GOIDLE = FALSE; 
            END 
  
          END 
  
        REQSTQUED = FALSE;
        IF NOT GOIDLE 
        THEN
          BEGIN 
          P<NAD$ENTRY> = NADTBL;
          SLOWFOR INDX = 1 STEP 1 UNTIL NUMNADS 
          DO
            BEGIN  # LOOP THRU NAD TABLE #
            REQSTAT;                 # ENSURE STATUS REQUEST QUEUED # 
            IF NAD$Q NE 0 
            THEN
              BEGIN  # NAD REQUEST QUEUED # 
              REQSTQUED = TRUE; 
              REQ$DROPIL = TRUE;
              END 
  
            P<NAD$ENTRY> = P<NAD$ENTRY> + NAD$LENGTH; 
            END 
  
          END 
  
        IF ACTIVENDRS EQ 0  AND REQSTQUED 
        THEN
          BEGIN  # START UP NDR # 
          STRTNDR;
          END 
  
        END 
  
      RETURN; 
      END  # TIMEVNT #
  
      TERM
