IDENT MTR,0 PERIPH J BASE MIXED SST FTN,IA,PPR,TH,.EST,SSCP *COMMENT MTR - PPU MONITOR. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. TITLE MTR - PP MONITOR. SPACE 4 *** MTR - PP MONITOR. * G. R. MANSFIELD. 70/12/13. * R. E. TATE. 76/11/10. SPACE 4 *** *MTR* IS LOADED INTO PP 0 AT DEAD START TIME AND * REMAINS THERE FOR THE DURATION OF SYSTEM EXECUTION. * * *MTR* PERFORMS THE FOLLOWING FUNCTIONS. * 1. PROCESS CERTAIN PPU REQUESTS. * 2. ALLOCATION OF CENTRAL MEMORY. * 3. MAINTAIN TIME OF DAY AND DATE. * 4. MAINTAIN THE REAL TIME CLOCK. * 5. CHECK THE CONTENTS OF (RA+1) OF ACTIVE CENTRAL * PROGRAMS FOR SYSTEM REQUESTS. * * *MTR* INPUT REGISTER. * *T, IR 18/ *MTR*,6/ SC,36/0 * * SC SYSTEM CONTROL POINT NUMBER. * * *MTR* MAINTAINS THE FOLLOWING DATA IN THE * STATISTICAL DATA AREA. * *T, MTRS 12/0,12/ CLOCK,12/ MXN,12/ WCT,12/ CCT * * CLOCK COUNT OF TIMES *TIM* CALLED AND CLOCK UPDATE MISSED. * MXN WORST CASE TIME TO DO AN MXN. (MICRO SECONDS) * WCT WORST CASE CYCLE TIME. (MILLISECONDS) * CCT CURRENT CYCLE TIME. (MILLISECONDS) SPACE 4 *CALL COMPMAC *CALL COMPIOU *CALL COMSCPS *CALL COMSMSC QUAL DSL *CALL COMSDSL QUAL * *CALL COMSDFT *CALL COMSDST *CALL COMSIOU *CALL COMSJCE LIST X *CALL COMSMTR LIST * *CALL COMSMST *CALL COMSPIM *CALL COMSPRD QUAL REM *CALL COMSREM QUAL * *CALL COMSSSD QUAL MSP *CALL COMSMSP QUAL * *CALL COMSSCR QUAL IOU *CALL COMSIOU QUAL * SPACE 4 **** DIRECT LOCATION ASSIGNENTS. ORG 0 T0 CON PRS-1 TEMPORARY STORAGE PD EQU T0 - T0+4 PACKED DATE AND TIME (*PDTL*) T1 CON 0 T2 CON 0 T3 CON 0 T4 CON 0 T5 CON 0 T6 CON 0 T7 CON 0 CM VFD 60/0 CM WORD BUFFER TI EQU CM - CM+4 DISPLAY CODE TIME (*TIML*) T8 CON 0 TEMPORARY STORAGE MB CON 0,0 MEMORY BLOCKS - TEMPORARY CN VFD 60/0 CM WORD BUFFER LS CON 7777 LATEST SECOND COUNT BA CON 0 BYTE ADDRESS PA CON 0 PARAMETER ADDRESS CS VFD 60/0 CONTROL POINT STATUS WORD RC CON RQRL RECALL STACK POINTER RQ CON RQRL *RQRL* POINTER CF CON 1 CHANNEL TABLE WRITE FLAG MM BSS 0 MEMORY MANAGEMENT MM.0 CON 7777 CONTROL POINT MOVING MM.1 CON 0 MOVE INCREMENT MM.2 CON 0 LOWER MOVE CONTROL POINT MM.3 CON 0 CONTROL POINT REQUESTING MOVE MM.4 CON 0 PP REQUESTING MOVE NP CON 0 NUMBER OF PPS NC CON 0 NUMBER OF CONTROL POINTS TM BSS 0 REAL TIME CLOCK VFD 24/0 SECONDS VFD 36/0 MILLISECONDS MS CON 0 LAST MICROSECOND COUNT ST CON 1000D SECOND TIMER FT CON 4000 CONSTANT 4000 SC CON SCRL *SCRL* POINTER OR VFD 60/0 PP OUTPUT REGISTER OF CON 0 ADDRESS OF FIRST PP OUTPUT REGISTER PP CON 0 CURRENT PP NUMBER PR CON 0 PRIORITY SEEK REQUEST PP ON CON 1 CONSTANT 1 HN CON 100 CONSTANT 100 FR CON 4 CONSTANT FOUR TR CON 3 CONSTANT 3 CP CON 0 CONTROL POINT NUMBER CY CON 0 START OF CURRENT CYCLE OA CON 0 CURRENT OUTPUT REGISTER ADDRESS ZR VFD 60/0 CM ZERO WORD (5 LOCATIONS) * ASSEMBLY CONSTANTS. MLSC EQU 1000D MICROSECONDS/MILLISECOND CH EQU CHSC S/C REGISTER CHANNEL MR EQU CHMR CYBER 170-8X5 MAINTENANCE CHANNEL MXRC EQU 3 MAXIMUM RECALL REQUESTS PER LOOP MBCS EQU 6 MEMORY BLOCK CONVERSION SHIFT COUNT **** TITLE MACRO DEFINITIONS. PPR SPACE 4 MSTA SPACE 4,20 ** MSTA - GENERATE MST ADDRESS. * * THIS MACRO IS TO BE USED FOR ALL MST ADDRESSES IN ORDER TO * ALLOW FOR EST EXPANSION. * * MSTA WORD,PP,DC,EO * ENTRY WORD = MST WORD DESIRED. * PP = PP NUMBER USED TO ACCESS PP TABLE OF MST * ADDRESSES (*TPMS*). * DC = 5 BYTES OF SCRATCH DIRECT CELLS. * EO = IF SUPPLIED, (A) = EST ORDINAL. * * EXIT (A) = CM ADDRESS IF *WORD* SUPPLIED. * (DC - DC+4) = *EQDE* WORD OF EST ENTRY IF *DC* IS * SUPPLIED. * * IF *DC* IS SUPPLIED MST ADDRESS IS OBTAINED FROM THE * EST, AND IF *PP* IS SUPPLIED, IT IS STORED INTO *TPMS*. * IF *DC* IS NOT SUPPLIED, THE MST ADDRESS IS OBTAINED FROM * *TPMS*. IF *WORD* IS NOT SUPPLIED THE CM ADDRESS IS NOT * RETURNED. MSTA MACRO WORD,PP,DC,EO MACREF MSTA .M1 IFC NE,*DC** IFC EQ,*EO**,1 LDD T5 SFA EST ADK EQDE CRD DC LDD DC+4 IFC NE,*PP**,1 STM TPMS,PP .M1 ELSE LDM TPMS,PP .M1 ENDIF IFC NE,*WORD**,2 SHN 3 ADN WORD ENDM NSDJ SPACE 4,10 ** NSDJ - NO SHARED DEVICES JUMP. * * THE INSTRUCTION FOLLOWING THIS MACRO IS REPLACED BY A *UJN* * IF THERE ARE NO SHARED DEVICES IN THE SYSTEM. * * NSDJ ADDR * ENTRY ADDR = ADDRESS TO JUMP TO. NSDJ MACRO A LOCAL AA MACREF NSDJ AA EQU * NSDJ RMT CON AA LOC AA UJN A LOC *O NSDJ RMT ENDM N8SJ SPACE 4,10 ** N8SJ - NO ISD SUBSYSTEM JUMP. * * THE INSTRUCTION FOLLOWING THIS MACRO IS REPLACED BY A *UJN* * IF THERE IS NO ISD SUBSYSTEM PRESENT. * * N8SJ ADDR * ENTRY ADDR = ADDRESS TO JUMP TO. N8SJ MACRO A LOCAL AA MACREF N8SJ AA EQU * N8SJ RMT CON AA LOC AA UJN A LOC *O N8SJ RMT ENDM PPR SPACE 4,10 ** PPR - SET PP REQUEST PROCESSOR. * * PPR FCN,PRC * ENTRY *FCN* = FUNCTION NUMBER. * IF *PRC* IS SPECIFIED, *.PRC* IS ADDRESS OF PROCESSOR. * OTHERWISE, *.FCN* IS ADDRESS OF PROCESSOR. PPR MACRO FCN,PRC LOCAL J,K MACREF PPR J OCTMIC FCN IFC EQ,$PRC$$ K MICRO 1,3, FCN K MICRO 1,4,*."K"* "K" CON FCN ORG *-1 ELSE 1 K MICRO 1,, PRC PPR RMT ORG TPPR+FCN CON "K" PPR RMT ENDM SUBFUN SPACE 4,10 ** SUBFUN - SET SUBFUNCTION PROCESSOR. * *SFA SUBFUN FNC,SFN * ENTRY SFA = SUBFUNCTION PROCESSOR ENTRY NAME. * FNC = FUNCTION NAME. * SFN = SUBFUNCTION NAME. * * THIS MACRO BUILDS A TABLE OF SUBFUNCTION PROCESSORS. * THE TABLE IS NAMED T*FNC*, AND EACH ENTRY IS THE * ADDRESS OF THE PROCESSOR FOR THE SUBFUNCTION. MACRO SUBFUN,SFA,FNC,SFN MACREF SUBFUN SFA BSS 0 IRP SFN T_FNC RMT ORG T_FNC+SFN CON SFA T_FNC RMT IRP ENDM TITLE MAIN PROGRAM. MRP SPACE 4,10 ** MONITOR RE-ENTRY PROCESSOR. MRP CON 0 REENTRY ADDRESS LDM MRP STM TREA,PP * UJN MTR CHECK NEXT PP MTR SPACE 4,10 ** MTR - MAIN PROGRAM. MTR AOD PP GET NEXT OUTPUT REGISTER ADDRESS MTRA SBN ** (NUMBER OF NON-CONCURRENT PPS) MTRB NJN MTR1 IF NOT LAST NPP * UJN MTR2 (NO CONCURRENT PPS PRESENT) * UJN MTR1 (MONITOR STEP SET) LDN PPRL CHECK FOR CPP REQUESTS CRD CM LDD CM ZJN MTR4 IF NO CPP REQUESTS LDN 0 CLEAR CPP REQUEST FLAG STD CM LDK PPRL CWD CM MTR1 SBN ** (NUMBER OF CONCURRENT PPS) MTRC EQU *-1 ERRPL 10-PPRL *PPRL* MIGHT EQUAL NUMBER OF CPPS MTR2 ZJN MTR4 IF ALL OUTPUT REGISTERS CHECKED LDD PP READ PP-S OUTPUT REGISTER MTR3 SHN 3 ADD OF STD OA CRD OR LDM TREA,PP GET PP-S REENTRY ADDRESS STM MTRD LDD OR ZJN MTR IF NO REQUEST LJM ** EXIT TO PROCESSOR MTRD EQU *-1 * PERFORM SYSTEM FUNCTIONS. MTR4 RJM TIM UPDATE TIME RJM CRQ CHECK RECALL QUEUE LDD CF ZJN MTR5 IF NO CHANNEL UPDATES MTRE LDN CTALL WORD COUNT OF CHANNEL TABLE * LDN NCTAL (CCH-S NOT PRESENT) STD CF LDC ** WRITE CHANNEL TABLE MTRF EQU *-1 CWM TCHS,CF LDN 0 CLEAR CHANNEL UPDATE FLAG STD CF MTR5 RJM PHE PROCESS HARDWARE ERRORS MTRG EQU *-2 * UJN *+2 (6000 SERIES) * UPDATE STATISTICAL DATA. TLDC MTRS,SDA READ *MTR* STATISTICAL DATA CRD CM LDC ** UPDATE MISSED CLOCK UPDATE COUNT MTRI EQU *-1 (MISSED CLOCK UPDATE COUNT) RAD CM+1 LDN 0 RESET CURRENT CYCLE MISSED CLOCK UPDATES STM MTRI LDD TM+4 CALCULATE ELAPSED CYCLE TIME SBD CY PJN MTR6 IF NO OVERFLOW ADC 10000 MTR6 STD CM+4 RAD CY LDD CM+4 SBD CM+3 MJN MTR7 IF NOT NEW WORST CASE TIME RAD CM+3 UPDATE WORST CASE CYCLE TIME MTR7 LDC ** SET WORST CASE *MXN* TIME MTRJ EQU *-1 (WORST CASE *MXN* TIME) SBD CM+2 MJN MTR8 IF NOT WORST CASE *MXN* TIME RAD CM+2 UPDATE WORST CASE *MXN* TIME MTR8 LDN 0 RESET CURRENT CYCLE WORST CASE *MXN* TIME STM MTRJ TLDC MTRS,SDA WRITE *MTR* STATISTICAL DATA CWD CM * THE CPU SWITCH IS DONE AS LONG AS POSSIBLE AFTER THE CALL * TO *CRQ* TO ALLOW *CPUMTR* TO HAVE FINISHED PROCESSING CPU * RECALLS. THE CALL TO *WXP* IS MADE TO INSURE ANY RECALLS * HAVE COMPLETED. RJM WXP WAIT RECALL COMPLETION RJM CCS CHECK CPU SWITCH RJM CCP CHECK CENTRAL PROGRAM LDN 0 SET UP OUTPUT REGISTER SCAN STD PP LJM MTR LOOP TITLE TIMEKEEPING. AVC SPACE 4 ** AVC - ADVANCE CLOCK. * * ENTRY MUST BE MADE AT LEAST EVERY 4 MILLISECONDS. * * IF THE MACHINE IS IN A MULTI-MAINFRAME COMPLEX THE * FOLLOWING IS DONE. * 1) STATUS FLAG REGISTER BITS. * 2) WRITE REAL TIME CLOCK TO ECS. * 3) STATUS MAINFRAMES ECS CLOCKS EVERY 2 SECONDS. * * USES CM - CM+4, T3. * * CALLS AVT, CPR, TIM. AVC4 BSS 0 AVCB LDC 10000B+ARTF ADVANCE CPU-1 RUNNING TIME * UJN AVC5 (1 CPU) RJM CPR AVC5 LDD HN RESET RETURN STM AVCA RJM AVT ADVANCE TIME OF DAY AVCC LDD TM+1 * UJN AVCD (NO MULTI-MAINFRAME PROCESSING) LPN 1 STD CN+2 SET TIME TO STATUS MAINFRAMES AVCD LDN ARMF ADVANCE RUNNING TIME * LDN ARTF (NO MULTI-MAINFRAME PROCESSING) RJM CPR AVC SUBR ENTRY/EXIT * UJN AVC4 (ONE SECOND ELAPSED) AVCA EQU *-2 RJM TIM ADVANCE MILLISECOND CLOCK AVC1 TLDC CACX,CMT READ CPU 0 EXCHANGE REQUEST * UJN AVCX (1 CPU ONLY) CX1 EQU *-2 CRD CM LDN 0 CLEAR EXCHANGE REQUEST OUTSTANDING FLAG STD T3 LDD CM+1 ADD CM+2 ZJN AVC2 IF NO EXCHANGE REQUEST AOD T3 LDN PCXF PROCESS CPU 0 EXCHANGE REQUEST RJM CPR AVC2 TLDC CACX+1,CMT READ CPU 1 EXCHANGE REQUEST CRD CM LDD CM+1 ADD CM+2 ZJN AVC3 IF NO EXCHANGE REQUEST AOD T3 LDC 10000+PCXF PROCESS CPU 1 EXCHANGE REQUEST RJM CPR AVC3 LDD T3 NJN AVC1 IF EXCHANGE REQUEST OUTSTANDING UJN AVCX RETURN TIM SPACE 4,20 ** TIM - UPDATE REAL TIME CLOCK. * * THE REAL TIME CLOCK IN CM IS UPDATED EVERY MILLISECOND. THIS * ROUTINE WHEN CALLED FROM OTHER THAN *AVC* IS USED TO MAINTAIN * TIME ACCURACY WITHOUT CALLS TO *CPR*. ON CYBER 180 AND * CYBER 170-865/875 MAINFRAMES, THE REAL TIME CLOCK IS READ * AFTER EVERY EXCHANGE TO *CPUMTR*, SINCE *CPUMTR* CONTROLS * THE CLOCK USING THE CPU CLOCK. BETWEEN EXCHANGES, *MTR* * MAINTAINS THE REAL TIME CLOCK IN THE USUAL WAY TO ENSURE * ACCURACY DURING PERIODS WHEN *CPUMTR* IS INACTIVE. * * EXIT (RTCL) UPDATED IN CM IF MILLISECOND OR MORE ELAPSED. * (MTRI) = COUNT OF TIMES CLOCK UPDATE MISSED. * * USES LS, MS, ST, CM - CM+4, TM - TM+4. * * CALLS ETA. TIM5 LDD HN RESET RETURN STM TIMX UJN TIM1 REENTER LOOP TIM6 STD MS TLDC /EXPACS/MXP+6,XBP READ (MA), (A6), (B6) CRD CM LDD CM ADD CM+1 NJN TIMX IF EXCHANGE PACKAGE NOT READY LDC RTCL CRD TM READ THE MILLISECOND CLOCK LDD TM+1 SBD LS ZJN TIM8 IF NO CHANGE IN SECONDS PJN TIM7 IF NO OVERFLOW ADC 10000 TIM7 RJM ETA ENABLE TIME ADVANCE LDD TM+1 MARK CURRENT SECONDS STD LS TIM8 LDN PSNI RESET EXCHANGE SWITCH STM TIMB TIM SUBR ENTRY/EXIT TIM1 IAN 14 READ CLOCK TIMB PSN NORMAL * UJN TIM6 EXCHANGE OUTSTANDING (CPU CLOCK) SBD MS PJN TIM2 IF NO OVERFLOW ADC 10000 TIM2 ADC -MLSC+35 CYCLES TILL RTCL WRITTEN * ADC -MLSC+17 (2X PP SPEED) * ADC -MLSC+10 (4X PP SPEED) TIMA EQU *-1 MJN TIMX IF NOT .GE. 1 MILLISECOND ELAPSED SHN -12 ZJN TIM3 IF REMAINDER .LT. 1024 MICROSECONDS AOM MTRI COUNT MISSED CLOCK UPDATE ISTORE TIMX,(UJN TIM5) SET UP TO LOOP TIM3 LDC MLSC RAD MS AOD TM+4 ADVANCE MILLISECOND CLOCK SHN -14 ZJN TIM4 IF NO OVERFLOW RAD TM+3 UPDATE MILLISECONDS ON OVERFLOW SHN -14 RAD TM+2 TIM4 SOD ST UPDATE SECOND TIMER NJN TIM4.1 IF NOT 1 SECOND ELAPSED LDN 1 SET INCREMENT FOR *AVT* RJM ETA ENABLE TIME ADVANCE AOD TM+1 UPDATE SECONDS STD LS MARK CURRENT SECONDS SHN -14 RAD TM TIM4.1 LDC RTCL UPDATE CLOCK CWD TM LJM TIMX EXIT ETA SPACE 4 ** ETA - ENABLE TIME ADVANCE. * * THE UPDATE OF THE DATE AND TIME IS ENABLED, THE * NUMBER OF SECONDS TO ADVANCE IT IS ESTABLISHED, * AND THE SECOND TIMER IS RESET. * * ENTRY (A) .EQ. NUMBER OF SECONDS TO ADVANCE TIME. * * EXIT TIME ADVANCE IS ENABLED. ETA SUBR ENTRY/EXIT STM AVTC SET SECONDS INCREMENT ISTORE AVCA,(UJN AVC4) ENABLE CLOCK UPDATE LDC 1000D RESET SECOND TIMER STD ST UJN ETAX EXIT AVT SPACE 4,10 ** AVT - ADVANCE TIME. * * ADVANCES THE TIME OF DAY AND DATE IN RESPONSE TO THE REAL * TIME CLOCK AND STORES THEM IN CENTRAL MEMORY. ON THE HOUR, * THE TIME PROCESSING FUNCTION CODE IS SET IN THE *1MB* CALL * WORD. * * EXIT (PDTL), (JDAL), (TIML), (DTEL) UPDATED IN CMR. * * USES CN, PD - PD+4(T0 - T0+4), TI - TI+4(CM - CM+4). * * CALLS CPR. AVT2 LDN PDTL WRITE *PDTL* AND *TIML* CWD PD ADK TIML-PDTL CWD TI LDD CN NJN AVTX IF NOT TOP OF HOUR * LDN 0 CLEAR BUFFER ADDRESS * STD CN LDN ADTF CALL *CPUMTR* TO COMPLETE THE ADVANCE RJM CPR AVT SUBR ENTRY/EXIT LDN PDTL READ *PDTL* AND *TIML* CRD PD ADK TIML-PDTL CRD TI LDC 1 ADVANCE SECONDS AVTC EQU *-1 STD CN INITIALIZE TOP OF HOUR FLAG RAD PD+4 LDM AVTC SHN 6 RAD TI+4 SHN -6 SBN 1R9+1 AVT1 MJN AVT2 IF NOT 10 SECONDS SHN 6 ADC 2R0. RESET SECONDS STD TI+4 AOD TI+3 ADVANCE 10 SECONDS LPN 77 SBN 1R6 MJN AVT1 IF NOT 60 SECONDS LDN 100-60D ADVANCE MINUTES, RESET SECONDS RAD PD+4 LDC 2R.0 RESET 10 SECONDS STD TI+3 AOD TI+2 ADVANCE MINUTES LPN 77 SBN 1R9+1 MJN AVT1 IF NOT 10 MINUTES LDN 100+1R0-1R9-1 ADVANCE 10 MINUTES RAD TI+2 SHN -6 SBN 1R6 MJN AVT1 IF NOT 60 MINUTES LDM PHED+2 SCN SPTP AVTA LMN SPTP SET TIME PROCESSING FUNCTION FOR *1MB* * LMN 0 (NO TIME CALL FOR C70 NON-SIMULATION) ERRNZ SPTP-1 (ERROR IF TIME FUNCTION VALUE CHANGES) STM PHED+2 LDN 0 CLEAR BUFFER ADDRESS STD CN LJM AVT2 CALL *CPUMTR* TO COMPLETE THE ADVANCE TITLE RECALL CRITERION PROCESSING. CRQ SPACE 4,10 ** CRQ - CHECK RECALL CRITERION. * * THIS ROUTINE PROCESSED UP TO *MXRC* ENTRIES OF THE RECALL * REQUEST QUEUE. EACH ENTRY IS CHECKED TO SEE IF THE * RECALL CRITERION HAS BEEN SATISFIED. IF IT HAS, *CPUMTR* IS * CALLED TO BRING THE REQUEST OUT OF RECALL. * * CALLS CPR, RCP. CRQ6 LDD CN+2 CHECK REQUEST LPN 77 LMN CRCW-100 ERRNG CRCW-100 *CRCW* MUST BE .GE. 100 ZJN CRQ7 IF CPU IN RECALL LDC 10000+PRQF RJM CPR UJN CRQ3 CHECK NEXT REQUEST CRQ7 RJM RCP RECALL CPU CRQ SUBR ENTRY/EXIT LDN MXRC SET MAXIMUM NUMBER OF REQUESTS TO PROCESS STD T3 LDD RC LMD RQ NJN CRQ4 IF NOT POINTER WORD AOD T3 * THIS CODE IS USED TO RESET THE LIST POINTER TO THE * BEGINNING IN THE INFREQUENT EVENT THAT *MTR* TRIES * TO USE A BAD POINTER, WHICH IS USUALLY CAUSED BY * *CPUMTR* MAKING CHANGES IN THE LIST WHILE *MTR* IS * SCANNING IT. CRQ2 LDD RQ RESET TO START OF LIST CRD CM LDD CM+4 SET TO PROCESS FIRST ENTRY STD RC CRQ3 SOD T3 MJN CRQX IF LIMIT OF ENTRIES TO PROCESS CRQ4 LDD RC CRQ5 CRD CM STD CN+2 LDD CM+4 SET NEXT ENTRY STD RC SCN 17 ZJN CRQ2 IF END OF LIST * THE FOLLOWING LOGIC IS DEPENDENT ON THE RECALL TYPES BEING * IN A CERTAIN ORDER. ERRNZ PCBF-1 LOGIC REQUIRES THIS VALUE ERRNZ PTRF-2 LOGIC REQUIRES THIS VALUE ERRNZ PTMF-3 LOGIC REQUIRES THIS VALUE LDD CM SBN PTMF ZJN PTM IF TIMED RECALL PJN CRQ2 IF ILLEGAL RECALL CRITERION ADN -PCBF+PTMF CRQA ZJN PCB IF PROCESS COMPLETION BIT * ZJN PCB3 (CME PRESENT) MJN CRQ2 IF NOT TIMED RECALL PTM SPACE 4,10 ** PTM - TIMED RECALL PROCESSOR. * *T, CM 12/ PTMF,36/ RT,12/ LK * RT RECALL TIME. * LK NEXT RECALL ENTRY. PTM LDD TM+2 SBD CM+1 NJN PTM1 IF LIMIT PASSED OR NOT REACHED LDD TM+3 SBD CM+2 NJN PTM1 IF LIMIT PASSED OR NOT REACHED LDD TM+4 SBD CM+3 PTM1 MJN PTM3 IF NOT TIME TO RECALL REQUEST PTM2 LJM CRQ6 RECALL REQUEST PTM3 LDD CM LMN PTRF ZJN PCB2 IF *PTRF* ENTRY PRESENT LDD RQ RESET POINTER TO START OF LIST STD RC LJM CRQX RETURN PCB SPACE 4,10 ** PCB - COMPLETION BIT PROCESSOR. * *T, CM 12/ PCBF,12/,24/ AD,12/ LK * AD ADDRESS OF WORD TO CHECK COMPLETION BIT. * LK NEXT RECALL ENTRY. PCB LDD CM+2 CHECK COMPLETION BIT PCB1 SHN 14 ADD CM+3 CRD OR LDD OR+4 LPN 1 NJN PTM2 IF COMPLETE PCB2 LJM CRQ3 CHECK NEXT REQUEST * COMPLETION BIT PROCESSOR FOR CME MAINFRAMES. PCB3 LDD CM+2 SET R-REGISTER TO UPPER 12 BITS SHN 6 STD OR+1 SHN -14 STD OR LDC 0 GET UPPER HALF OF MACHINE SIZE/100B PCBA EQU *-1 SBD OR MJN PCB2 IF ADDRESS .GT. MACHINE SIZE NJN PCB4 IF ADDRESS .LT. MACHINE SIZE LDD CM+3 SHN -6 ADD OR+1 STD T0 LDC 0 GET LOWER HALF OF MACHINE SIZE/100B PCBB EQU *-1 SBD T0 MJN PCB2 IF ADDRESS .GT. MACHINE SIZE ZJN PCB2 IF ADDRESS .EQ. MACHINE SIZE PCB4 LRD OR LOAD R-REGISTER LDN 40 SET R-REGISTER BIT IN A UJN PCB1 READ COMPLETION ADDRESS TITLE PROCESS HARDWARE ERRORS. PHE SPACE 4,20 ** PHE - PROCESS HARDWARE ERRORS. * * EXIT (A) = 0 IF *1MB* CALL NOT REQUIRED. * = 1 IF *1MB* WAS CALLED OR WAS ALREADY CALLED. * * USES CP, T4, CM - CM+4, CS - CS+4. * * CALLS FTN, ODW, PSE. * * NOTE *1MB* IS CALLED IF ONE OR MORE OF THE FOLLOWING * CONDITIONS HAVE BEEN DETECTED WHEN CHECKING THE * S/C REGISTERS AND THE *1MB* INHIBIT BIT IS NOT SET. * 1) A UNIQUE SINGLE BIT SECDED ERROR HAS OCCURRED. * 2) ERRORS OTHER THAN UNIQUE SINGLE BIT SECDED * ERRORS HAVE OCCURRED. * 3) TOP-OF-HOUR PROCESSING HAS BEEN SPECIFIED. * * *1MB* IS CALLED FOR MAINTENANCE REGISTER PROCESSING * AND TIME PROCESSING IF THE MACHINE IS A CYBER 180. PHE SUBR ENTRY/EXIT * CHECK CYBER 180 MAINTENANCE REGISTERS. * * NOTE THE FOLLWING CODE IS ALTERED BY *PRESET* TO PROCESS * HARDWARE ERRORS ON VARIOUS MAINFRAMES. PHEA LDC ** (ADDRESS OF *DFT* CONTROL WORD) CRD CM READ *DFT* CONTROL WORD PHEF LDC ** (ADDRESS OF NOS REQUEST HEADER) CRD CS LDD CM+4 SHN 21-2 MJN PHE0 IF NOT DEDICATED *DFT* LDD CM+4 LPN 1 UJN PHE3 CHECK FOR *1MB* CALL PHE0 SCF PHEX,MR IF CHANNEL RESERVED BY ANOTHER PP FNC /IOU/MRSS,MR SUMMARY STATUS IJM PHE1,MR IF CHANNEL RESPONDED TO FUNCTION DCN MR+40 CCF *,MR UJN PHEX RETURN PHE1 ACN MR IAN MR READ SUMMARY STATUS DCN MR+40 CFM PHE2,MR IF NO ERRORS OCCURRED LDN 1 ERROR IN READING SS REGISTER PHE2 CCF *,MR * UJN PHE3 PROCESS *1MB* CALL * ACCESS CYBER 70, 170, 700 SERIES AND 865/875 S/C REGISTER. PHEE RMT LOC PHEA LDC FCTE TEST ERROR FUNCTION * LDC FCTB (CYBER 70 NON-SCR SIMULATION) FJM PHEX,CH IF CHANNEL HUNG FULL * FJM PHEX,15 (CYBER 70) RJM ODW UJN PHE3 SAVE ERROR STATUS LOC *O PHEE RMT * SAVE ERROR PRESENT STATUS. * CHECK IF *1MB* CALL IS NEEDED. PHE3 STD T0 SAVE ERROR STATUS PHEG ADD CS+4 INCLUDE *DFT* REQUEST PRESENT STATUS * PSN (NON-CYBER 180 MAINFRAME) ADM PHED+2 ZJN PHE4.1 IF *1MB* CALL NOT REQUIRED LDD SC CHECK INHIBIT BIT CRD CS LDD CS SHN 0-13 NJN PHE4.1 IF *1MB* ALREADY CALLED LDD T0 GET ERROR STATUS UJN PHE5 PROCESS CYBER 180 ERROR * ZJN PHE5 (CYBER 170, 865/875 ERROR/TIME PROCESSING) * UJN PHE5 (CYBER 70 AND NO SIMULATION) PHEB EQU *-1 RJM PSE PROCESS SINGLE BIT ERRORS LDC FCTE TEST FOR OTHER ERRORS RJM ODW STD T4 LDC FCCL+DSBL ENABLE SINGLE BIT LOGGING RJM ODW UJN PHE4 TEST FOR NEED TO CALL *1MB* * PSN (CYBER 176) PHEC EQU *-1 LDC FCCL+DLSL ENABLE 176 LCME SINGLE BIT LOGGING RJM ODW PHE4 LDM PHED+2 TEST FOR NEED TO CALL *1MB* ADD T4 NJN PHE5 IF TIME/ERROR PROCESSING REQUIRED PHE4.1 LJM PHEX RETURN * CALL *1MB* VIA *1MP*. PHE5 LDD FT SET INHIBIT BIT RAD CS LDD SC CWD CS LDD NC SYSTEM CONTROL POINT NUMBER STD CP LDD OF PP0 OUTPUT REGISTER ADDRESS ADN 1 CWM PHED,ON WRITE PP CALL TO MESSAGE BUFFER LDN 0 STD CM+1 MONITOR RPPM REQUEST PP EXECUTE 1MP,= * LDN SPLG RESTORE LOGGING FUNCTION ERRNZ SPLG CODE DEPENDS ON VALUE STM PHED+2 STM PHED+4 LDN 1 SET ERROR FOUND UJN PHE4.1 RETURN PHED VFD 18/3L1MP,6/**,12/0,24/0 PSE SPACE 4,10 ** PSE - PROCESS SINGLE BIT ERRORS. * * ENTRY (PSEA) = CORRECT MAINFRAME TABLE INDEX. * * CALLS BIS, ODW. PSE SUBR ENTRY/EXIT LDC FCSB+DSBL DISABLE CM SINGLE BIT LOGGING RJM ODW LDC FCTB+SECD TEST FOR SECDED ERROR RJM ODW ZJN PSE1 IF NO SECDED ERROR LDC FCTB+SDSC TEST FOR DOUBLE BIT ERROR RJM ODW NJN PSE1 IF DOUBLE BIT ERROR PSEA LDN 0 PASS MAINFRAME TABLE INDEX * LDN 1 (CYBER 176) RJM BIS SEARCH FOR MATCHING IDENTIFIER PSE1 UJN PSEX RETURN * PSN (CYBER 176) PSEB EQU *-1 * PROCESS CYBER 176 LCM ERRORS. LDC FCSB+DLSL DISABLE LCME SINGLE BIT LOGGING RJM ODW LDC FCTB+LSCD TEST FOR LCME SECDED ERROR RJM ODW ZJN PSEX IF NO LCME SECDED ERROR LDC FCTB+LDSC TEST FOR LCME DOUBLE SECDED ERROR RJM ODW NJN PSE2 IF DOUBLE BIT ERROR LDN UIDL ADD OFFSET FOR LCME ID TABLE RAM BISD LDN 2 LOAD IDENTIFIER FOR 176 LCME RJM BIS SEARCH FOR MATCHING IDENTIFIER LCN UIDL RESTORE OFFSET FOR CM ID TABLE RAM BISD PSE2 LJM PSEX EXIT ODW SPACE 4,10 ** ODW - OUTPUT DESCRIPTOR WORD. * * ENTRY (A) = DESCRIPTOR WORD. * * EXIT (A) = SCR REPLY WORD. ODW SUBR ENTRY/EXIT OAN CHSC OUTPUT DESCRIPTOR WORD * OAN 15 (CYBER 70) ODWA EQU *-1 IAN CHSC INPUT SCR REPLY WORD * IAN 15 (CYBER 70) ODWB EQU *-1 UJN ODWX EXIT BIS SPACE 4,10 ** BIS - BUILD ID AND SEARCH TABLE. * * ENTRY (A) = 0 - BUILD ID FOR CYBER 170 AND 865/875. * 1 - BUILD ID FOR 176 CM. * 2 - BUILD ID FOR 176 LCME. * * EXIT (CM-CM+4) = ERROR COUNTS IN *CECL* UPDATED. * * USES T1, T2, T4, T6, T7, CM - CM+4, CN - CN+4, CS - CS+4. * * CALLS ODW. BIS8 AOD CM+4 INITIALIZE ID ERROR COUNT LDD T6 STORE UNIQUE ID INTO TABLE SHN 14 ADD T4 CWD CM LDD T2 SET APPROPRIATE FUNCTION BIT LMN 2 ZJN BIS9 IF LCME SECDED ERROR LDN SPCS-SPLS SET CM SECDED ERROR FUNCTION BIT BIS9 ADN SPLS SET LCME SECDED ERROR FUNCTION BIT RAM PHED+2 BIS SUBR ENTRY/EXIT STD T2 SAVE ID BUILD TYPE LDM TBIS,T2 SAVE FWA OF ID BUILD ROUTINE STD T7 LDN ZERL CLEAR FIELD FOR BUILDING ID CRD CM * BUILD ID FOR APPROPRIATE MACHINE. LDN CM INITIALIZE ID BUILD ADDRESS STD T6 BIS1 AOD T7 LDI T7 GET NEXT SCR WORD INFORMATION ZJN BIS2 IF ID BUILD COMPLETE STM BISA SET APPROPRIATE MASK FOR SCR BYTES AOD T7 LDI T7 GET SHIFT COUNT LPN 77 ADC SHNI BUILD SHIFT INSTRUCTION STM BISB LDI T7 GET SCR WORD FROM TABLE AND READ SHN -6 LPN 37 IFNE FCRD,0,1 (ADJUST IF READ FUNCTION CHANGES) ADC FCRD RJM ODW LPC * BISA EQU *-1 MASK OFF DESIRED SCR BITS SHN 0 BISB EQU *-1 POSITION FOR ID BIT MERGE RAI T6 MERGE ID BITS LDI T7 CONTINUE ID BUILD IN APPROPRIATE BYTE SHN 0-13 RAD T6 UJN BIS1 GET NEXT SCR WORD * SCAN UNIQUE ID TABLE BACKWARDS TO SEE IF * THERE IS ALREADY AN ENTRY FOR THIS ERROR. BIS2 LDN UIDL UNIQUE ID TABLE LENGTH STD T1 BIS3 SOD T1 DECREMENT CURRENT ENTRY OFFSET MJN BIS5 IF SCAN COMPLETE ADC ** FWA OF UNIQUE ID TABLE BISC EQU *-1 BISD ADN 0 ADD OFFSET FOR APPROPRIATE ID TABLE CRD CN STD T4 STORE UNIQUE ID TABLE ADDRESS SHN -14 STD T6 LDD CN TEST IF ENTRY IS AVAILABLE ADD CN+1 ADD CN+2 NJN BIS4 IF LOCATION CONTAINS AN IDENTIFIER LJM BIS8 IF LOCATION IS AVAILABLE BIS4 LDD CM TEST IF BYTE 0 MATCHES LMD CN NJN BIS3 IF NO MATCH LDD CM+1 TEST IF BYTE 1 MATCHES LMD CN+1 NJN BIS3 IF NO MATCH LDD CM+2 TEST IF BYTE 2 MATCHES LMD CN+2 NJN BIS3 IF NO MATCH * THE NEWLY-BUILT IDENTIFIER MATCHES A TABLE ENTRY. LDN 77 LMD CN+4 ZJN BIS5 IF REACHED THRESHOLD AOD CN+4 INCREMENT COUNTER LDD T6 REWRITE UPDATED ID AND COUNT SHN 14 ADD T4 CWD CN * TEST WHICH RANK AND/OR SECDED BITS TO CLEAR. BIS5 AOD T7 ISSUE SECDED CLEARING FUNCTION(S) LDI T7 RJM ODW AOD T7 BISE LDI T7 * UJN BIS6 (CYBER 170 OR 865/875) RJM ODW SET C176 CM/LCME RANK II CLEAR AOD T7 LDI T7 CLEAR C176 CM/LCME RANK II CLEAR RJM ODW BIS6 LDD T2 INCREMENT APPROPRIATE ERROR COUNT SHN -1 ADN CM+3 STD T2 LDK CECL CRD CM LDI T2 LMC 7777 ZJN BIS7 IF CM/LCME ERROR COUNT THRESHOLD REACHED AOI T2 LDK CECL CWD CM UPDATE *CECL* BIS7 LJM BISX RETURN * TBIS - TABLE OF ID BUILD ENTRY POINTS. TBIS BSS 0 LOC 0 CON BISF-1 BUILD ID FOR LOWER C170 CM. CON BISF-1 BUILD ID FOR C176 CM. CON BISG-1 BUILD ID FOR C176 LCME. LOC *O * THE TABLE FIELDS BELOW CONTAIN THE FOLLOWING INFORMATION. * * 12/MASK, 1/INCR, 5/SCR WORD, 6/SHIFT. * WHERE INCR = 0, IF NO INCREMENT TO NEXT ID CELL. * = 1, IF INCREMENT REQUIRED. * SHIFT = BIT ALIGNMENT NEEDED TO MERGE SCR BITS * INTO ID. * * FOLLOWING THE TERMINATOR FOR EACH ID TYPE ARE THE * ERROR-CLEARING FUNCTION CODES TO BE ISSUED TO THE SCR. * EACH FUNCTION USES 12 BITS. BISF BSS 0 C176 CM ID INFORMATION VFD 12/7777,1/1,5/LCMW,6/0 VFD 12/77,1/0,5/CMAW,6/6 VFD 12/7700,1/1,5/SYNW,6/-6 VFD 12/60,1/0,5/SYNW,6/6 CON 0 C176 CM ID BUILD TERMINATOR CON FCCL+SECD CON FCSB+CCRT CON FCCL+CCRT BISFL EQU *-BISF LENGTH OF TABLE *BISF BSS 0 C170 CM ID INFORMATION * VFD 12/6000,1/0,5/CSEW,6/0 * VFD 12/77,1/0,5/CMAW,6/4 * VFD 12/7400,1/1,5/SYNW,6/-10 * VFD 12/360,1/0,5/SYNW,6/4 * CON 0 C170 ID BUILD TERMINATOR * CON FCCL+SECD * CON 0 TERMINATOR FOR C170 CLEARING FUNCTIONS * CON 0 BISG BSS 0 C176 LCME ID INFORMATION VFD 12/377,1/0,5/LSYW,6/4 VFD 12/1400,1/0,5/LERW,6/-6 VFD 12/60,1/1,5/LCAW,6/-4 VFD 12/17,1/0,5/LCAW,6/10 CON 0 C176 LCME ID BUILD TERMINATOR CON FCCL+LSCD CON FCSB+LCRT CON FCCL+LCRT TITLE PP REQUEST PROCESSING. *** PP FUNCTION REQUESTS. * * PP FUNCTION REQUESTS ARE MADE TO *MTR* BY PLACING * THE FUNCTION CODE IN BYTE 0 OF THE PP-S OUTPUT REGISTER. * WHEN THE REQUEST IS COMPLETED, *MTR* CLEARS BYTE 0 OF * THE OUTPUT REGISTER. SPACE 4,10 ** PP REQUEST PROCESSOR. * NOTE - FOLLOWING CODE MUST BE IN ORDER. HNG SPACE 4 ** HNG - HANG PPU AND DISPLAY MESSAGE HNGB DATA 7777 A REGISTER SAVE AREA HNG CON ** ADDRESS OF CALLER HNG1 STM HNGB SAVE (A) LDD OA ADN 6 CRD CN LDN PDTL SET PACKED DATE AND TIME CRD CM LDC 2RHN ADD *HNG/* TO PACKED DATE/TIME STD CM LDC 2RG/ STD CM+1 LMD CN+1 NJN HNG2 IF INITIAL DETECTION OF HUNG PP LDD CM LMD CN ZJN HNG3 IF NOT INITIAL DETECTION OF HUNG PP HNG2 LDD OA ADN 6 CWD CM LDD OA ADD PP NAME TO *HUNG PP* MESSAGE SBN 1 CRD CM LDD CM STM HNGC LDD CM+1 SCN 77 STM HNGC+1 HNG3 LDC MS2W+** DISPLAY SYSTEM CP MESSAGE HNGD EQU *-1 CWM HNGA,TR UJN DSD1 RETURN HNGA DATA H*HUNG PP - * HNGC DATA C*XXX* NAME OF HUNG PP DSD SPACE 4,10 ** DSD - PROCESS *DSD* REQUEST. DSD LDC 7000 CHECK REQUEST RAD OR SHN 21-11 MJN DSD1 IF PREVIOUSLY PROCESSED LDD OR SBN CPUM MJN PPR1 IF MTR FUNCTION LDD OA WRITE *OR* WITH CLEARED INTERLOCK CWD OR RJM CPR PROCESS CPU FUNCTION DSD1 UJN FNR FUNCTION RETURN PPR SPACE 4,10 ** PPR - PROCESS PP REQUEST. * * ENTRY (A) = REQUEST. * (OA) = PP OUTPUT REGISTER ADDRESS. * (OR - OR+4) = PP OUTPUT REGISTER. * * EXIT TO FUNCTION PROCESSOR WITH (A) = (OA). PPR SBN CPUM PPRA EQU *-1 * UJN MSC (STEP MODE) PJN FNR1 IF NOT AN *MTR* FUNCTION PPR1 LDM TPPR,OR SET FUNCTION PROCESSOR STD T8 LDD OA LJM 0,T8 PROCESS FUNCTION FNZ SPACE 4 ** FNZ - FUNCTION RETURN TO CLEAR OUTPUT REGISTER. FNZ LDD OA CLEAR OUTPUT REGISTER CWD ZR * UJN FNR FNR SPACE 4 ** FNR - FUNCTION RETURN. FNR RJM CCP CHECK CENTRAL PROGRAM FNR1 LJM MTR RETURN TO MAIN LOOP FNC SPACE 4 ** FNC - FUNCTION RETURN TO CLEAR UPPER BYTE OF *OR*. FNC LDN 0 FNC1 STD OR LDD OA CWD OR UJN FNR FUNCTION RETURN MSC SPACE 4 ** MSC - MONITOR STEP CONTROL. MSC LDD OA READ INPUT REGISTER SBN 1 CRD CM LDN OR RJM CFS CHECK FOR STEP CRITERION NJN MSC5 IF STEP CRITERION NOT MET LDC 7777 * LDC 0 (STEP REQUESTED BY *DSD*) MSCA EQU *-1 NJN FNR IF NOT STEPPED LDD OA SBD OF LMC ** (NEXT PP TO STEP) MSCB EQU *-1 ZJN MSC4 IF THIS PP RJM SNP SET NEXT PP TO STEP MSC3 UJN FNR IGNORE REQUEST MSC4 LCN 0 RESET STEP FLAG STM MSCA LDN 10 ADVANCE PP RAM MSCB MSC5 RJM TIM UPDATE TIME RJM SNP SET NEXT PPU TO STEP * PROCESS FUNCTION. LDD OR CHECK FUNCTION SBN CPUM PJN MSC6 IF CPU FUNCTION RJM TIM UPDATE TIME LJM PPR1 PROCESS REQUEST MSC6 LDD OR SHN 0-11 LMN 1 NJN MSC3 IF NOT *STEP* ONLY LDD OR CLEAR FLAGS LPC 177 STD OR LDD OA CWD OR RJM CPR UJN MSC3 COMPLETE FUNCTION SNP SPACE 4 ** SNP - SET NEXT PP TO STEP. * * ENTRY (MSCB) = CURRENT PP. * * EXIT (MSCB) = NEXT PP. * * USES T1, T2, T4, CM - CM+4, CN - CN+4. * * CALLS CFS. SNP5 LDN 20 UJN SNP1 RESET PP 2 SNP SUBR ENTRY/EXIT LDN 1 SET PP COUNT STD T1 LDM MSCB SET PP SNP1 STD T2 SNP2 STM MSCB SHN -3 STD T4 SAVE PP NUMBER LMD NP ZJN SNP5 IF LAST PP AOD T1 ADVANCE PP COUNT LMD NP SNP3 ZJN SNPX IF ALL PP-S CHECKED LDD T2 READ INPUT REGISTER ADD OF CRD CN SBN 1 CRD CM LDD CM ZJN SNP4 IF PP NOT ASSIGNED LDD CN ZJN SNP4 IF NO FUNCTION REQUEST LDN CN RJM CFS CHECK FOR STEP NJN SNP4 IF STEP CRITERION NOT MET LDM TREA,T4 LMC PPR ZJN SNP3 IF NO REENTRY PROCESSING SNP4 LDN 10 ADVANCE PP RAD T2 UJN SNP2 LOOP TITLE PP REQUEST FUNCTION PROCESSORS. ** NOTE - EXIT CONDITION REFERENCES TO (OR - OR+4) SPECIFY * THE STATUS OF THE PP OUTPUT REGISTER IN CENTRAL MEMORY. * IN ALL CASES, (OR) = 0. IF A BYTE IS NOT SPECIFIED, * THAT BYTE IS NOT CHANGED. * THE DIRECT LOCATIONS *OR - OR+4* MAY DIFFER IN CONTENT * FROM THE ACTUAL OUTPUT REGISTER. ASCM SPACE 4,10 *** *ASCM* IS A *PPR* FUNCTION. IT IS USED TO TELL PP RESIDENT * ROUTINE *PLL* THAT THE LIBRARY HAS BEEN SEARCHED DURING * ASSIGNMENT OF THE PP. NO *MTR* PROCESSING IS REQUIRED. PPR ASCM,FNR1 BOTM SPACE 4,10 *** *BOTM* IS A *PPR* FUNCTION. IT IS USED TO TELL PP RESIDENT * ROUTINE *FTN* TO LOAD A BOOTSTRAP PROGRAM. NO *MTR* * PROCESSING IS REQUIRED. PPR BOTM,FNR1 CCHM SPACE 4,10 *** CCHM - CHECK CHANNEL. * * ASSIGN CHANNEL IF NOT IN USE. * * ENTRY *T, OR 12/ CCHM,6/ ,1/ C,5/ CH,36/ * C SET IF CONCURRENT CHANNEL. * CH CHANNEL NUMBER. * * EXIT *T, OR 12/ 0,12/ CH,12/ ST,24/ * CH CHANNEL ASSIGNED IF ST = 1. * BIT 2**5 OF CH SET IF DOWN CHANNEL IN USE BY ANOTHER * MAINTENANCE USER. * ST = 1 IF CHANNEL ASSIGNED. * ST = 0 IF CHANNEL NOT ASSIGNED. PPR CCHM LDD OR+1 CHECK CHANNEL RJM TCH ZJN CCH3 IF FREE MJN CCH2 IF DOWN CCH1 LJM FNZ REJECT FUNCTION CCH2 SHN 5-21 LPN 37 NJN CCH1 IF DOWN CHANNEL IN USE LDD T2 RJM GCE GET CHANNEL ASSIGNMENT TABLE ENTRY ZJN CCH3 IF CHANNEL IS NOT ASSIGNED TO A JOB LMD CN NJN CCH6 IF CHANNEL IS NOT ASSIGNED TO THIS JOB CCH3 LDN 1 SET OUTPUT REGISTER STD OR+2 * ENTRY FROM *RCHM*. CCH4 LDD T2 SET CHANNEL LPN 37 STD OR+1 LDD PP SET ASSIGNMENT TO THIS PP STD CF SET FLAG FOR CHANNEL UPDATE LMM TCHS,T2 LPC -4000 STM TCHS,T2 CCH5 LJM FNC COMPLETE FUNCTION CCH6 LDD OR+1 INDICATE DOWN CHANNEL IN USE SCN 40 LMN 40 STD OR+1 UJN CCH5 COMPLETE FUNCTION CDBM SPACE 4,15 *** CDBM - CHECK DAYFILE BUSY. * * CHECK STATUS OF SPECIFIED DAYFILE. * * ENTRY *T, OR 12/ CDBM, 12/ BC, 12/ MO, 12/ CP+SF, 12/ DI * BC BYTE COUNT OF MESSAGE. * MO MESSAGE OPTION. * CP CONTROL POINT ADDRESS. * SF = 0 TO WAIT ON SPACE IN DAYFILE BUFFER. * = 1 TO WAIT UNTIL PP DUMP BUFFER NOT BUSY. * DI DAYFILE INDEX. * 0 = JOB DAYFILE. * 1 = MASTER DAYFILE. * 2 = ACCOUNT DAYFILE. * 3 = ERRLOG DAYFILE. * 4 = MAINLOG DAYFILE. * * EXIT (SUBFUNCTION (SF) REQUEST SATISFIED) *T, OR 12/ DFMM, 12/ BC, 12/ MO, 12/, 12/ PPR CDBM LDD OR+3 CHECK FOR MOVE SHN 0-7 LMD MM.0 ZJP FNR IF CP SCHEDULED FOR MOVE LDD OR+3 CHECK REQUEST LPN 1 ZJN CDB1 IF WAITING ON SPACE IN BUFFER LDN DFPP CRD CS LJM CDB5 CHECK DUMP BUFFER BUSY CDB1 LDD OR+4 ZJN CDB2 IF JOB DAYFILE SHN 1 CDBA ADC ** (FWA-3 OF DAYFILE POINTERS) ADD OR+4 UJN CDB3 CONTINUE PROCESSING CDB2 LDD OA REREAD INPUT REGISTER SBN 1 CRD CM LDD CM+1 EXTRACT CONTROL POINT NUMBER LPN 37 SHN 7 CDBB ADN FLSW GET RA FROM FL CONTROL WORD * ADN FLSW+1 (CME PRESENT) CRD CM LRD CM+1 LDD CM+3 READ BUFFER POINTERS FROM NFL SHN 6 SBN DAPN CDB3 CRD CM ADN 1 CRD CN ADN 1 CRD CS LDD CN+4 OUT - IN SBD CM+4 ZJN CDB6 IF BUFFER EMPTY PJN CDB4 IF OUT .GT. IN ADD CN+2 ADD BUFFER LENGTH CDB4 SBN MXML PJN CDB6 IF SPACE IN BUFFER CDB5 LDD CS+4 LPN 1 ZJN CDB7 IF DAYFILE BUSY CDB6 LDC DFMM+5000 HAVE PP REISSUE REQUEST WITHOUT DELAY STD OR LDD OA STORE OUTPUT REGISTER CWD OR CDB7 LJM FNR RETURN DCHM SPACE 4,10 *** DCHM - DROP CHANNEL. * * RELEASE CHANNEL FROM ASSIGNMENT. * * ENTRY *T, OR 12/ DCHM,6/ 0,1/ C,5/ CH,36/ * C SET IF CONCURRENT CHANNEL SPECIFIED IN CH. * CH CHANNEL TO DROP. * * EXIT *T, OR 60/ 0 PPR DCHM LDD OR+1 CHECK LEGAL CHANNEL NUMBER RJM VCN LDD PP LMM TCHS,T2 LPN 37 ZJN DCH1 IF CHANNEL ASSIGNED TO THIS PP LDD PP SBN 1 NJN DCH2 IF NOT *DSD* DCH1 LDD OA CLEAR OUTPUT REGISTER STD CF SET FLAG FOR CHANNEL UPDATE CWD ZR LDM TCHS,T2 LPC 140 UPDATE CHANNEL RESERVATION TABLE STM TCHS,T2 UJN CDB7 RETURN DCH2 RJM HNG HANG PP DRCM SPACE 4 *** DRCM - DRIVER RECALL CPU. * * PERFORMS AN RCLM IF THE JOB IS IN RECALL. THIS IS USED BY * THE TAPE AND MASS STORAGE DRIVERS WHO WRITE THIS FUNCTION TO * THEIR OUTPUT REGISTER WITHOUT WAITING FOR AN ACCEPT. * * ENTRY *T, OR 12/ DRCM,48/ * * EXIT *T, OR 60/ 0 PPR DRCM CWD ZR CLEAR OUTPUT REGISTER LDD PP GET ASSIGNED CP/PCP SHN PPXES TADC ACPP,PPX CRD CM LDD CM+4 SET CP ADDRESS STD CN+2 ADN STSW CHECK RECALL STATUS CRD CS DCRA ADN FLSW-STSW * ADN FLSW+1-STSW (CME PRESENT) CRD CM LDD CS SHN -11 LMN XCPS ZJN DRC1 IF *X* STATUS LDD CN+2 ADN CWQW CRD CM LDD CM+1 SHN 21-12 PJN DRC2 IF TO RECALL CPU UJN DRC4 RETURN DRC1 LRD CM+1 LDD CM+3 CHECK (RA+1) SHN 6 ADN 1 CRD CM LDD CM NJN DRC4 IF (RA+1) .NE. 0 DRC2 RJM RCP RECALL CPU DRC4 LJM FNR RETURN DSWM SPACE 4,70 *** DSWM - DRIVER SEEK WAIT. * * CAUTION, STORAGE MOVE MAY OCCUR DURING *DSWM* PROCESSING. * * ENTRY *T, OR 12/ DSWM,12/,12/,12/ F,12/ *T, MB 12/ T4,12/ T5,12/ T6,12/ T7,12/ CHRV *T, MB+1 12/ LU,6/ SF,6/ PU,12/ PC,12/ PT,12/ PS * F = SUBFUNCTION CODE. * 0 = DROP CHANNEL. * 1 = REQUEST CHANNEL, AND EQUIPMENT IF READSYS. * 2 = SEEK IN PROGRESS. * 4 = UNIT SWITCH. * 10 = DRIVE RESERVE. * 11 = REQUEST CHANNEL, UNIT, AND EQUIPMENT IF READSYS. * 20 = WRITE IN PROGRESS (ISD ONLY). * 2000 = CONTROLLER RESERVED. * T4 = CHANNEL. * T5 = EQUIPMENT. * T6 = LOGICAL TRACK. * T7 = LOGICAL SECTOR. * CHRV = WORD *CHRV*. * LU = LOGICAL UNIT NUMBER. * SF = SEEK TYPE (USED ON ISD DEVICES ONLY). * 0 = NORMAL SEEK. * 1 = WRITE/SEEK. * 2 = READ/SEEK. * 3 = CHECK WRITE COMPLETE. * PU = PHYSICAL UNIT NUMBER. * PC = CYLINDER ADDRESS. * PT = PHYSICAL TRACK. * PS = PHYSICAL SECTOR. * * HANG CONDITIONS - * * BAD CHANNEL NUMBER. * EQUIPMENT *EQ* NOT MASS STORAGE. * CHANNEL NOT ASSIGNED WHEN BIT 0 OF *CHRV* .NE. 0. * * * EXIT *T, OR 12/ 0,12/ RF,12/ CC,12/ ST,12/ T4 *T, MB 60/ SAME AS INPUT WITH *CHRV* UPDATED. *T, MB+1 60/ *PU* UPDATED IF READSYS, *SF* SET TO 3 IF SUBFUNCTION 20 * RF = RELEASE FUNCTION. * A DRIVE RELEASE FUNCTION IS RETURNED IF SEEK WAITS * ARE OUTSTANDING ON THE CHANNEL FOR SHARED DEVICES. * AN OPERATION COMPLETE IS RETURNED IN ALL OTHER CASES. * THE OPERATION COMPLETE RELEASES BOTH THE DRIVE AND * THE CONTROLLER. * CC = 1, IF ISD AND FUNCTION WAS *WRITE IN PROGRESS*. * 12, OTHERWISE. * ST = (CHRV), IF OK TO SEEK. * COMPLEMENT OF EC, IF ERROR DETECTED. * EC = CRSE, IF CONTROLLER RESERVE TIME OUT. * EC = CHFE, IF INCORRECT *DSWM* FUNCTION NUMBER. * EC = DRVE, IF DRIVE RESERVE TIMEOUT. * EC = LNRE, IF LOGICAL NOT READY. * * RE-ENTRY *T, OR 12/ DSWM,12/ RP,12/ CPM,12/ CH,5/ CP,7/ FG * RP = REENTRY PROCESSOR ADDRESS. * CPM = CONTROL POINT/PSEUDO-CONTROL POINT FOR MOVE CHECK. * CH = CHANNEL(S) TO REQUEST. * CP = CONTROL POINT NUMBER FOR PRIVILEGES CHECK. * FG = FLAGS. * 1 = REQUEST FOR CHANNEL AND UNIT ON NEW SEEK. * 2 = SEEK WAIT FLAG. * 4 = EQUIPMENT IS A SHARED DEVICE. * 10 = SEEK OUTSTANDING ON SHARED DEVICE. * 20 = CALLER SELECTED CHANNEL. * 40 = ISD DEVICE FLAG. * 100 = WRITE IN PROGRESS (ISD ONLY). *T, MB SAME AS INPUT WITH (T4) = ALLOWABLE CHANNEL(S). SPACE 4,20 ** MAXIMIZATION OF SEEK OVERLAP. * * THE THROUGHPUT OF THE MASS STORAGE SUBSYSTEM CAN BE ENHANCED * BY MAXIMIZING THE SEEK OPERATIONS WHICH ARE PERFORMED IN * PARALLEL WITH DATA TRANSFERS, IE. SEEK OVERLAP. IN ORDER TO * MAXIMIZE SEEK OVERLAPS WE MUST GIVE PRIORITY TO THE * INITIATION OF NEW SEEKS, WHICH WILL START THE POSITIONER * MOVING. WE SHOULD NOT GIVE THE CHANNEL TO A PP WHICH IS * CHECKING FOR THE COMPLETION OF A SEEK OPERATION IF ANOTHER * PP IS WAITING TO INITIATE A SEEK. DOING SO WOULD TEND TO * SERIALIZE THE SEEK AND DATA TRANSFER OPERATIONS. * * TO GIVE PRIORITY TO THE ASSIGNMENT OF THE CHANNEL TO INITIAL * SEEK OPERATIONS, *DSWM* KEEPS TRACK OF THE FOLLOWING. * 1) FOR EACH CHANNEL REQUESTED BY A PP FOR AN INITIAL * SEEK, THE PP NUMBER OF THE REQUESTING PP IS SAVED * IN *TCHR*. * 2) FOR EACH EQUIPMENT THE PP REQUESTING LOGICAL UNIT * ZERO IS SAVED IN *DALL* BYTE 3. * USING THIS INFORMATION WE KNOW WHEN RELEASING A RESOURCE * (IE. CHANNEL OR LOGICAL UNIT ZERO OF AN EQUIPMENT) IF * ANOTHER PP NEEDS THE RESOURCE TO INITIATE A SEEK OPERATION. * WHEN ANOTHER PP DOES NEED THE RESOURCE TO INITIATE A SEEK * THIS IS TERMED A *PRIORITY SEEK REQUEST*. * * THE MECHANISM OF GIVING PRIORITY TO A PARTICULAR PP IS * ACCOMPLISHED BY PROCESSING THE PRIORITY SEEK REQUEST UPON * EXIT OF THE *DSWM* PROCESSING. WHEN A *DSWM* FUNCTION * RESULTS IN THE FREEING OF A RESOURCE (IE. UNIT OR CHANNEL), * THE RESOURCE WOULD NORMALLY BE ASSIGNED TO THE NEXT PP IN * NUMERIC ORDER WHICH IS WAITING FOR IT. TO ASSIGN IT TO A * PRIORITY PP, NOT THE NEXT NUMERICAL PP, THE PP NUMBER IS * SAVED IN DIRECT CELL *PR* WHEN THE RESOURCE IS RELEASED. * WHEN THE *DSWM* REQUEST WHICH RELEASED THE RESOURCE, AND SET * *PR* IS COMPLETE OR GOES INTO REENTRY PROCESSING, A CHECK IS * MADE FOR A PENDING PRIORITY REQUEST. IF ONE IS PRESENT, * THEN BEFORE RETURNING TO THE MAIN LOOP OF MTR, THE PRIORITY * SEEK REQUEST IS PROCESSED. THIS IS ACCOMPLISHED BY SETTING * THE REGISTERS TO LOOK EXACTLY LIKE THE REQUEST WAS SENSED * BY THE MAIN LOOP IN MTR. IN EFFECT THE PROCESSING OF A * PRIORITY SEEK REQUEST LOOKS AS THOUGH THE REQUEST WERE * INSERTED AS THE NEXT REQUEST IN THE MAIN LOOP OF MTR. THIS * APPROACH USES ALL THE NORMAL REENTRY LOGIC FOR RESOURCE * ASSIGNMENT, THUS MINIMIZING SPECIAL CASE LOGIC. ** MSEK - THIS TAG DEFINES THE MAXIMUM NUMBER OF SEEK WAITS * ON A CHANNEL WITH SHARED DEVICES BEFORE ACCESS TO THE * CHANNEL FOR NEW SHARED DEVICE ACTIVITY IS * DISALLOWED. THE TABLE *TSCA* CONTAINS THE NUMBER * OF SEEK WAITS FOR SHARED DEVICES WHICH ARE OUTSTANDING * ON A CHANNEL. WHEN THERE ARE OUTSTANDING SEEKS ON * SHARED DEVICES, A DRIVE RELEASE FUNCTION WILL BE * ISSUED INSTEAD OF AN OPERATION COMPLETE FOR ALL * DEVICES ON THE CHANNEL. THE * CONTINUED ISSUANCE OF DRIVE RELEASES INSTEAD OF * OPERATION COMPLETES WILL LOCK OUT ACCESS BY OTHER * MACHINES TO THE CONTROLLER AND DRIVES. THUS THE * NEED FOR A LIMIT ON THE NUMBER OF TIMES A DRIVE * RELEASE IS ISSUED. *MSEK* PROVIDES A LIMIT TO * THE CONTINUED ACCESS OF A CONTROLLER BY A SINGLE * MACHINE. THIS NUMBER DOES NOT HAVE A DIRECT * CORRESPONDENCE TO THE NUMBER OF CONTIGUOUS I/O * REQUESTS ALLOWED ON A CHANNEL. THIS IS BECAUSE * THE TABLE *TSEK* WHICH *MSEK* LIMITS IS NOT A * COUNT OF I/O REQUESTS BUT RATHER IT IS A COUNT * OF THE NUMBER TIMES A SEEK WAIT IS ISSUED WITH * MULTIPLE SHARED DEVICE SEEKS OUTSTANDING. THUS * THE CONTINUED ACCESS BY A SINGLE MACHINE WILL * BE LIMITED BUT NOT TO ANY SPECIFIC NUMBER OF * REQUESTS. MSEK EQU 40 PPR DSWM ADN 1 READ PARAMETERS CRD T4 LDD PP GET ASSIGNED CP/PCP SHN PPXES TADC ACPP,PPX CRD CN LDD CN SET ASSIGNED CP/PCP FOR MOVE CHECK STD OR+2 LDD CN+4 STD OR+4 SET CP FOR PRIVILEGES CHECK LDD CM SET CALLER SELECTED CHANNEL FLAG LPN 20 RAD OR+4 MSTA DALL,PP,CS GET EST, SAVE MST ADDRESS, READ DALL CRD CN LDD CS SHN 21-13 MJN DSW1 IF MASS STORAGE LDD T5 NJP DSW7 IF NOT PERFORMING ON-LINE RECONFIGURATION DSW1 N8SJ DSW3 (NO ISD SUBSYSTEM JUMP) LDD CS+3 LMC 2RDG ZJN DSW2 IF 836 DEVICE LMN 1RD&1RG NJN DSW3 IF NOT 834 DEVICE DSW2 LDN 40 RAD OR+4 DSW3 NSDJ DSW4 (NO SHARED DEVICE JUMP) LDD CS SHN 2-11 LPN 4 SET SHARED DEVICE FLAG RAD OR+4 DSW4 LDD CM LPN 1 ZJP DSW12 IF CHANNEL NOT RESERVED * PROCESS RELEASE OF CHANNEL. LDN MXNC STD CF SET FLAG FOR CHANNEL UPDATE SBD T4 DSW5 MJN DSW7 IF INVALID CHANNEL LDM TCHR,T4 SET REQUESTING PP ZJN DSW6 IF NO PRIORITY SEEK REQUEST STD PR LDN 0 CLEAR PRIORITY SEEK REQUEST STM TCHR,T4 DSW6 LDM TCHS,T4 LMD PP STD T1 LPN 37 ZJN DSW8 IF ASSIGNED TO THIS PP DSW7 RJM HNG HANG PP DSW8 LDD T1 CLEAR CHANNEL ASSIGNMENT LPC -4000 STM TCHS,T4 NSDJ DSW9 (NO SHARED DEVICE JUMP) LDD OR+4 SHN 21-2 PJN DSW8.1 IF NOT SHARED DEVICE LDD OR+3 SCN 4 NJN DSW9 IF NOT ENDMS OR UNIT SWITCH FUNCTION DSW8.1 LDM TSCA,T4 NJN DSW9 IF SHARED CHANNEL ACTIVITY STM TSEK,T4 CLEAR SEEK COUNT DSW9 N8SJ DSW12 (NO ISD SUBSYSTEM JUMP) LDD OR+3 LPN 22 NJN DSW12 IF SEEK OR BUFFER FLUSH WAIT LDD OR+4 LPN 40 DSW10 ZJN DSW12 IF NOT ISD DEVICE * DECREMENT CONTROL MODULE ACTIVITY EXCEPT DURING SEEK * WAITS OR WRITE IN PROGRESS WAITS. MAINTAINING THE * CONTROL MODULE ACTIVITY INSURES THE REQUEST WILL RECEIVE * THE SAME CHANNEL ASSIGNMENT. LDM TCMN,PP SHN -3 ADC TCMA STD T1 SOI T1 LPN 77 NJN DSW11 IF NOT DECREMENT TO ZERO STI T1 CLEAR CHANNEL ASSIGNMENT LDD CN+4 REVERSE CHANNEL PRIORITY SHN 6 LMD CN+4 SHN 6 STD CN+4 LDN 0 DSW11 LPN 40 NJN DSW15 IF UNDERFLOW DSW12 LDD OR+3 VALIDATE FUNCTION CODE SBN MXDSWM MJN DSW14 IF FUNCTION IN TABLE SBN 20-MXDSWM ZJP WIP IF ISD BUFFER FLUSH WAIT SBK 2000-20 ZJN RSV IF CONTROLLER RESERVE DSW13 LCN /MSP/CHFE SET CHANNEL FAILURE CODE LJM RCE6 RETURN INCORRECT FUNCTION STATUS DSW14 LDM TDSWM,OR+3 STD T8 LJM 0,T8 ENTER PROCESSOR DSW15 RJM HNG HANG PP MXDSWM EQU 12 MAXIMUM VALUE OF DSWM SUBFUNCTION RSV SPACE 4,10 ** RSV - *DSWM* ROUTINE TO PROCESS RESERVE SITUATIONS. * * FUNCTION 10 = DRIVE RESERVE. * FUNCTION 2000 = CONTROLLER RESERVE. * * THESE FUNCTIONS SHOULD ONLY BE EXECUTED IN A MULTI-MAINFRAME * CONFIGURATION OR WHERE CONTROLLERS ARE BEING SHARED BETWEEN * MACHINES. THE PURPOSE OF THESE FUNCTIONS ARE TO RETRY THE * REQUEST UNTIL THE APPROPRIATE RESERVES CAN BE GAINED OR * UNTIL THE FIVE SECOND TIME OUT HAS EXPIRED. WHEN A TIME * OUT OCCURS, THE DRIVER WILL CALL THE ERROR PROCESSOR AND * THE APPROPRIATE ERROR PROCESSING WILL BE EXECUTED DEPENDING * ON THE CALLER SELECTED OPTIONS. RSV SUBFUN DSWM,10 DRIVE RESERVE PROCESSOR ENTRY SUBFUN DSWM,2000 CONTROLLER RESERVE ENTRY LDD CN+4 REVERSE CHANNELS IN MST SHN 6 LMD CN+4 SHN 6 STD CN+4 MSTA DALL,PP CWD CN LDD OA ADN 3 CRD CS LDD OR+3 SBD CS ZJN RSV3 IF START TIME SET RAD CS LDD TM+1 STD CS+4 LDD OA REWRITE TIME WORD ADN 3 CWD CS RSV3 LDD TM+1 SBD CS+4 PJN RSV4 IF NO ROLL OVER ADC 10000 RSV4 SBN 20D MJN RSV6 IF 20 SECONDS HAVE NOT ELAPSED LCN 0 SET UNIT NUMBER CLEARED STD CS RJM CDA CLEAR DEVICE ACTIVITY LDD OR+3 LMN 10 ZJN RSV5 IF DRIVE RESERVED LCN /MSP/CRSE-/MSP/DRVE RSV5 SBN /MSP/DRVE LJM RCE6 SET ERROR CODE RSV6 RJM SCS SET CHANNEL SELECTION PROCESSING LJM RER REASSIGN CHANNEL UPON REENTRY SPACE 4,20 ** RCE - *DSWM* ROUTINE TO REQUEST IO RESOURCES. * * FUNCTION 11 = REQUEST CHANNEL, UNIT, AND EQUIPMENT. * * THIS FUNCTION REQUESTS ALL THE RESOURCES THAT ARE NEEDED TO * PERFORM AN I/O OPERATION FOR THE *6DI* AND *6DJ* DRIVERS. * THE ORDER OF RESOURCE ASSIGNMENT IS AS FOLLOWS. * FIRST, IF A SYSTEM REQUEST IS PENDING AND MORE THAN ONE * SYSTEM DEVICE IS PRESENT, THE SYSTEM EQUIPMENT WILL BE * SELECTED. THE SELECTION CRITERION IS DOCUMENTED IN *RSY*. * SECOND, THE SOFTWARE UNIT INTERLOCK IN *DALL* IS GAINED. * THIS IS AN IMPORTANT INTERLOCK IN THAT IT INSURES ONLY * ONE REQUEST IS PROCESSED FOR A UNIT AT A TIME. * THIRDLY, A CHANNEL IS SELECTED AND RESERVED. * * FUNCTION 4 = UNIT SWITCH. * * THE UNIT INTERLOCK FOR THE PREVIOUS UNIT IS RELEASED AND THE * INTERLOCK FOR THE NEXT OR CURRENT UNIT IS REQUESTED. * * ACCESS TO AN *OFF* OR *SUSPECT* DEVICE WILL NOT NORMALLY BE * GRANTED. HOWEVER, IT WILL BE ALLOWED IF ONE OF THE FOLLOWING * CONDITIONS IS MET - * 1. THE OPERATION IS A *READSYS* AND NO *ON* OR *IDLE* * SYSTEM DEVICE EXISTS. * 2. THE *AD* OR *NS* *SETMS* ERROR PROCESSING OPTIONS * WERE SELECTED. * 3. THE JOB TO WHICH THE CALLING PP IS ASSIGNED HAS AT * LEAST ONE OF THE FOLLOWING ATTRIBUTES - * A. IT-S A SUBSYSTEM. * B. IT HAS THE *UTL=* ENTRY POINT. * C. IT IS IN THE PROCESS OF BEING * UNCONDITIONALLY TERMINATED BY THE * OPERATOR. * ACCESS TO A *DOWN* DEVICE WILL BE GRANTED ONLY IF THE CALLER * SPECIFIED THE *AD* *SETMS* ERROR PROCESSING OPTION. ALTHOUGH * THE CHECK FOR A *DOWN* DEVICE IS BYPASSED FOR *READSYS* * OPERATIONS, ACCESS TO A *DOWN* DEVICE WILL NOT BE GRANTED * SINCE ROUTINE *RSY* WILL ALWAYS SELECT A NON-*DOWN* DEVICE * AND IT IS NOT POSSIBLE TO *DOWN* THE LAST SYSTEM DEVICE. RCE SUBFUN DSWM,(11,4) REQUEST CHANNEL AND UNIT PROCESSOR ENTRY LDD OA ADN 2 CRD CS AOD OR+4 SET INITIAL SEEK REQUEST N8SJ RCE1 (NO ISD SUBSYSTEM JUMP) LPN 40 ZJN RCE1 IF NOT ISD DEVICE LDD CS+1 STORE UNIT NUMBER IN *TCMN* LPN 77 STM TCMN,PP RCE1 RJM CDA CLEAR CURRENT UNIT ACTIVITY LDD CM SHN 21-5 PJN RCE1.1 IF NOT *READSYS* UJN RCE2 CONTINUE * LDC RSY (MULTIPLE SYSTEM DEVICES EXIST) RCEA EQU *-1 CON RSY LJM RCE8 SET REENTRY PROCESSOR ADDRESS RCE1.1 SHN 5-1 MJN RCE2.2 IF ACCESS TO A *DOWN* DEVICE ALLOWED LDD CN SHN 21-7 PJN RCE2.0 IF DEVICE IS ACCESSIBLE LDK INWL CRD CM+1 LDD CM+1+3 SHN 21-3 RCE2 MJN RCE2.2 IF DEADSTART SEQUENCING NOT COMPLETE LDD CN SHN 0-10 LPN 3 LMN 3 NJN RCE2.1 IF DEVICE NOT *DOWN* MSTA ACGL,PP CRD CM+1 LDD CM+1+4 SHN 21-GRDR+GRDR/12D*12D PJP RCE5 IF NOT BEING REDEFINED LCN /MSP/RDFE UJP RCE6 SET ERROR CODE RCE2.0 UJN RCE3 CONTINUE RCE2.1 LDD CM SHN 21-2 RCE2.2 MJN RCE4 IF *NS* *SETMS* OPTION SELECTED LDD OR+4 LPC 7600 ADK TFSW CRD CM+1 ADK SEPW-TFSW CRD CM+2 ADK JCIW-SEPW CRD CM+3 LDD CM+5 SBK LSSI+1 RCE3 PJN RCE7 IF SUBSYSTEM LDD CM+2 SHN 21-10 RCE4 MJN RCE7 IF *UTL=* ENTRY POINT PRESENT LDD CM+1 CFI EJT,,CM+1 RCEB ADC SCHE CRD CM+1 LDD CM+3 SHN 21-12 ERRNZ UCTM-2 CODE ASSUMES VALUE MJN RCE7 IF UNCONDITIONAL JOB TERMINATION MODE RCE5 LCN /MSP/LNRE SET ERROR CODE RCE6 STD OR+3 LDD OA WRITE PARAMETERS ADN 1 CWD T4 LDN 0 LJM RRX2 RETURN ERROR STATUS RCE7 LDC CUI SET REENTRY PROCESSOR ADDRESS RCE8 STD OR+1 LDM TMSK,CS SET UNIT MASK STD OR+3 UJN RCO1 CHECK FOR RESOURCES AVAILABLE RCO SPACE 4 ** RCO - *DSWM* ROUTINE TO REQUEST A CHANNEL ONLY. * * FUNCTION 1 = REQUEST CHANNEL. * * THIS FUNCTION IS USED BY DRIVERS WHO DO NOT USE THE UNIT * INTERLOCK SCHEME. THUS THE ONLY RESOURCE THEY NEED TO * EXECUTE A DRIVER REQUEST IS THE CHANNEL. RCO SUBFUN DSWM,1 REQUEST CHANNEL ONLY PROCESSOR ENTRY AOD OR+4 SET INITIAL SEEK FOR PRIORITY SEEK REQUEST RJM SCS SET CHANNEL SELECTION PROCESSING LDM TPPI,PP NJN RCO2 IF ACTIVITY SET AOD CN MSTA DALL,PP CWD CN LDN 1 RCO1 STM TPPI,PP ENTER HERE FROM *RCE* LDD OA WRITE REENTRY PARAMETERS CWD OR RCO2 LJM RER2 CHECK FOR RESOURCES AVAILABLE SPACE 4,10 ** EMS - *DSWM* ROUTINE TO RELEASE IO RESOURCES. * * FUNCTION 0 = END MASS STORAGE OPERATION. * * THIS ROUTINE RELEASES THE CHANNEL AND SOFTWARE UNIT RESERVE * WHEN PRESENT. EMS SUBFUN DSWM,0 END MASS STORAGE PROCESSOR ENTRY LDD T4 INSURE VALID CHANNEL LPN 37 STD T4 LCN 0 SET NO UNIT ASSIGNED STD CS RJM CDA CLEAR DEVICE ACTIVITY LDD OA WRITE PARAMETERS ADN 1 CWD T4 LDD OR+2 CHECK FOR MOVE LMD MM.0 NJP RRX IF NO MOVE REQUESTED LDC CHD SET CHANNEL DROP PROCESSOR STD OR+1 LDD OA WRITE REENTRY PARAMETERS CWD OR LJM RER RETRY DROP ON REENTRY WIP SPACE 4,10 ** WIP - *DSWM* ISD WRITE WAIT PROCESSOR. * * FUNCTION 20 = ISD WRITE IN PROGRESS. * * THIS FUNCTION GIVES UP THE CHANNEL DURING AN ISD WRITE * OPERATION SO THAT OTHER PP-S MAY USE THE CHANNEL. IT SETS * *CHECK WRITE COMPLETE* IN THE SEEK PARAMETERS, ALLOWING *6DJ* * TO PROPERLY CHECK FOR WRITE COMPLETION WHEN IT GETS THE * CHANNEL BACK. *WIP* MUST ALSO RESTORE THE UNIT NUMBER PART * OF THE SEEK PARAMETERS SINCE THE CALLING PP MAY HAVE USED THE * MESSAGE BUFFER FOR OTHER PURPOSES BETWEEN WRITING SECTORS. *WIP SUBFUN DSWM,20 WAIT FOR WRITE IN PROGRESS WIP LDM TCMN,PP RESTORE UNIT NUMBER SEEK PARAMETER ADC 300 SET *CHECK WRITE COMPLETE* STD CS+1 LDD OA REWRITE SEEK PARAMETER WORD ADN 2 CWD CS LDC 102 SET SEEK AND WAIT FOR WRITE COMPLETE UJN SEK2 SET FLAGS SPACE 4,20 ** SEK - *DSWM* SEEK WAIT PROCESSOR. * * FUNCTION 2 = SEEK IN PROGRESS. * * THIS FUNCTION GIVES UP THE CHANNEL DURING A SEEK OPERATION * SO THAT OTHER REQUESTS MAY USE THE CHANNEL. THE DRIVE IS * PROTECTED FROM OTHER REQUESTS BY TWO METHODS. * * FIRST, FOR A NON-SHARED DEVICE, THE SOFTWARE * UNIT RESERVE IN *DALL* INSURES THAT OTHER REQUESTS IN THIS * MACHINE WILL NOT ACCESS THE SEEKING DRIVE. * THIS IS NEEDED BECAUSE THE DRIVER RELEASES THE DRIVE AFTER * INITIATING THE SEEK TO ALLOW OTHER PP-S TO ACCESS OTHER * DRIVES ON THE CHANNEL DURING THE SEEK OPERATION. SINCE THE * DRIVE IS RELEASED WHILE SEEKING, THE OPERATION CAN BE * CONTINUED ON A CHANNEL DIFFERENT FROM THE ONE WHICH INITIATED * THE SEEK. THIS CAPABILITY GIVES A SIGNIFICANT PERFORMANCE * GAIN FOR DUAL CHANNEL ACCESS TO NON-SHARED DEVICES. * * SECOND, FOR A SHARED DEVICE, SINCE THE SOFTWARE UNIT * INTERLOCK ONLY APPLIES TO ONE MACHINE, THE CONTROLLER AND * UNIT RESERVES ARE MAINTAINED WHILE SEEKING SO THAT REQUESTS * ON ANOTHER MACHINE DO NOT GAIN ACCESS TO THE DRIVE. * THE RESERVES MUST BE HELD DURING AN ENTIRE I/O SEQUENCE * (INCLUDING ERROR PROCESSING) ON INDEPENDENT SHARED DEVICES * SINCE THEY PROVIDE THE INTERLOCK FOR UPDATING TABLES ON THE * DEVICE. MMF DOES NOT DEPEND ON THE RESERVES FOR INTERLOCKS, * HOWEVER, THIS SCHEME IMPROVES PERFORMANCE BY ELIMINATING * RESEEKS FROM OTHER MACHINES DURING AN ACCESS. * * ENTRY (CN - CN+4) = MST WORD *DALL*. SEK SUBFUN DSWM,2 SEEK WAIT PROCESSOR ENTRY AOM TSEK,T4 INCREMENT TOTAL SEEK COUNT LDD T6 SBD CN+2 ZJN SEK1 IF NO CHANGE IN POSITION RAD CN+2 MSTA DALL,PP UPDATE DEVICE ACTIVITY WORD CWD CN SEK1 LDN 2 SET SEEK WAIT SEK2 RAD OR+4 CHECK FOR SHARED SEEK LPN 4 ZJN SEK3 IF NOT SHARED DEVICE AOM TSCA,T4 INCREMENT SHARED SEEK CHANNEL ACTIVITY LDN 10 RAD OR+4 SEK3 RJM SCS SET CHANNEL SELECTION PROCESSING * UJN RER REASSIGN CHANNEL UPON REENTRY TITLE RER - REENTRY PROCESSING. ** RER - *DSWM* REENTRY PROCESSING. * * THIS ROUTINE ASSIGNS THE RESOURCES REQUIRED FOR THE I/O * OPERATION. THE MAIN *DSWM* ROUTINE ALONG WITH THE * FUNCTION PROCESSORS SETS UP THE RESOURCE REQUIREMENTS * WHICH CAN THEN BE PROCESSED UPON INITIAL OR REENTRY. * * NOTE - A LARGE PART OF *MTR-S* EXECUTION TIME IS SPENT IN * THIS SUBROUTINE. IT IS EXTREMELY IMPORTANT TO OPTIMIZE AND * REDUCE OVERHEAD IN THIS CODE IN ORDER TO NOT MAKE THE *MTR* * CYCLE TIME TOO LARGE. A LARGE *MTR* CYCLE TIME AFFECTS * OVERALL SYSTEM PERFORMANCE. * ENTER HERE TO ALLOW ACCESS TO RESOURCES BY OTHER PPS BEFORE * REASSIGNING TO THIS REQUEST. RER LDD PR CHECK IF PRIORITY REQUEST ZJN RER1 IF NO PRIORITY SEEK REQUEST RJM PRR PROCESS PRIORITY REQUEST RER1 RJM TIM UPDATE TIME RJM MRP RETURN TO MAIN LOOP * ENTER HERE TO IMMEDIATELY CHECK RESOURCES. RER2 LDD OR+2 CHECK FOR MOVE LMD MM.0 ZJN RER IF MOVE REQUESTED, RETRY UPON REENTRY LJM 0,OR+1 JUMP TO PROCESSOR C1M SPACE 4,20 ** C1M - CHECK FOR ONE CONTROL MODULE CHANNEL FREE. * * WHEN ATTEMPTING ASSIGNMENT OF A SPECIFIC CHANNEL FOR * CONTROL MODULE ACCESS, ONE OF THE FOLLOWING CASES EXISTS. * 1) NO CHANNEL IS PRESENTLY ASSIGNED TO THE REQUIRED * CONTROL MODULE. * THE REQUESTED CHANNEL MAY BE ASSIGNED IF IT IS FREE. * THIS CHANNEL WILL THEN BECOME ASSIGNED TO THE CONTROL * MODULE. * 2) A CHANNEL IS PRESENTLY ASSIGNED TO THE CONTROL MODULE * AND IS THE SAME AS THE REQUESTED CHANNEL. * THE REQUESTED CHANNEL MAY BE ASSIGNED IF IT IS FREE. * 3) A CHANNEL IS PRESENTLY ASSIGNED TO THE CONTROL MODULE * AND IS DIFFERENT FROM THE REQUESTED CHANNEL. * NO CHANNEL ASSIGNMENT IS POSSIBLE. THE REQUEST MUST * WAIT UNTIL ALL CONTROL MODULE REQUESTS ARE COMPLETE * AT WHICH TIME CASE (1) EXISTS, AND AN ASSIGNMENT MAY * BE ALLOWED. C1M LDM TCMN,PP SHN -3 ADC TCMA STD T1 LDI T1 ZJN C2M1 IF CHANNEL NOT ASSIGNED TO CONTROL MODULE SHN -6 LMD OR+3 ZJN C2M1 IF REQUEST FOR CHANNEL ASSIGNED TO C. M. UJN RER RETRY ASSIGNMENT ON REENTRY C2M SPACE 4,15 ** C2M - CHECK FOR ONE OF TWO CONTROL MODULE CHANNELS FREE. * * WHEN ATTEMPTING ASSIGNMENT OF ONE OF TWO CHANNELS FOR * CONTROL MODULE ACCESS, ONE OF THE FOLLOWING CASES EXISTS. * 1) NO CHANNEL IS PRESENTLY ASSIGNED TO THE REQUIRED * CONTROL MODULE. * EITHER CHANNEL MAY BE ASSIGNED IF IT IS FREE AND THE * SEEK LIMIT IS NOT REACHED. * THIS CHANNEL WILL THEN BECOME ASSIGNED TO THE CONTROL * MODULE. * 2) A CHANNEL IS PRESENTLY ASSIGNED TO THE CONTROL MODULE. * THIS CHANNEL MAY BE ASSIGNED IF IT IS FREE AND THE * SEEK LIMIT IS NOT REACHED. IF THIS CHANNEL MAY NOT * BE ASSIGNED, THE OTHER CHANNEL IS NOT CHECKED. C2M LDM TCMN,PP GET THE CONTROL MODULE NUMBER SHN -3 ADC TCMA STD T1 LDI T1 ZJN C2C IF CHANNEL NOT ASSIGNED TO CONTROL MODULE SHN -6 STD OR+3 C2M1 UJN C1C CHECK FOR FREE CHANNEL C1C SPACE 4,15 ** C1C - CHECK FOR SINGLE CHANNEL FREE. * * IF THE REQUESTED CHANNEL IS FREE AND HAS NOT REACHED THE * SHARED DEVICE SEEK LIMIT, IT IS ASSIGNED. * IF THE CHANNEL IS BEING REASSIGNED TO A REQUEST * WHICH IS SEEKING ON A SHARED DEVICE, THEN THE * SHARED SEEK COUNTER FOR THE CHANNEL IS DECREMENTED. * * IF THE REQUESTED CHANNEL IS NOT FREE, THE CHANNEL * REQUESTED BIT IS SET. A PRIORITY SEEK REQUEST IS * ALSO SET IF THE CHANNEL IS REQUESTED FOR AN INITIAL * SEEK OPERATION. C2C SPACE 4,10 ** C2C - CHECK FOR ONE OF TWO CHANNELS FREE. * * IF EITHER CHANNEL IS FREE AND HAS NOT REACHED THE * SHARED DEVICE SEEK LIMIT, IT IS ASSIGNED. * * IF NEITHER CHANNEL IS FREE, THE CHANNEL REQUESTED BIT * IS SET FOR THE PRIMARY CHANNEL. A PRIORITY SEEK REQUEST IS * ALSO SET FOR EACH OF THE CHANNELS. AN INITIAL SEEK PRIORITY * REQUEST IS ONLY SET IF THE SEEK LIMIT HAS NOT BEEN REACHED. * INITIAL SEEK REQUESTS HAVE PRIORITY OVER OTHER SEEKS. C2C LDD OR+3 SHN 14 STD OR+3 SHN -14 STD T2 LDM TCHS,T2 NJN C2C3 IF PRIMARY CHANNEL NOT FREE * CHECK SEEK LIMIT REACHED FOR PRIMARY CHANNEL. NSDJ C2C1 (NON-SHARED DEVICE JUMP) LDD OR+4 LPN 6 LMN 4 NJN C2C1 IF NOT SHARED DEVICE OR SEEK WAIT LDM TSEK,T2 ADK -MSEK PJN C2C3 IF SEEK LIMIT REACHED - TRY OTHER CHANNEL C2C1 LDD T2 SET PRIMARY CHANNEL STD OR+3 C2C2 LJM C2C10 ASSIGN CHANNEL - CANNOT BE SHARED SEEK * CHECK SINGLE CHANNEL, OR SECOND OF DUAL CHANNELS. C1C BSS 0 SINGLE CHANNEL REQUESTED PROCESSOR LDD FT INDICATE SINGLE CHANNEL STD T2 C2C3 LDM TCHS,OR+3 NJN C2C5 IF SECONDARY CHANNEL IS NOT FREE NSDJ C2C2 (NON-SHARED DEVICE JUMP) LDD OR+4 LPN 16 LMN 04 NJP C2C9 IF NOT SHARED DEVICE OR SEEK WAIT LDK MSEK-1 SBM TSEK,OR+3 PJN C2C2 IF SEEK LIMIT NOT REACHED LJM RER RETRY UPON REENTRY C2C5 LPC -4000 SET THE CHANNEL REQUESTED FLAG LMD FT STD CF SET FLAG FOR CHANNEL UPDATE STM TCHS,OR+3 * SET PRIORITY REQUEST. LDD T2 LMD FT NJN C2C5.1 IF NOT CHANNEL SPECIFIC REQUEST LDM TCHS,OR+3 LPN 37 ZJN C2C8.1 IF CHANNEL NOT ASSIGNED C2C5.1 LDD OR+4 SET PRIMARY CHANNEL REQUESTED LPN 1 ZJN C2C6 IF NOT INITIAL SEEK LDM TSEK,T2 ADK -MSEK PJN C2C7.1 IF SEEK LIMIT REACHED UJN C2C7 CONTINUE PROCESSING C2C6 LDM TCHR,T2 NJN C2C7.1 IF REQUEST ALREADY SET C2C7 LDD PP SET CHANNEL REQUESTED STM TCHR,T2 C2C7.1 LDD OR+4 SET SECOND CHANNEL LPN 1 ZJN C2C7.3 IF NOT INITIAL CHANNEL REQUEST LDM TSEK,OR+3 ADK -MSEK PJN C2C8 IF SEEK LIMIT REACHED UJN C2C7.4 CONTINUE PROCESSING C2C7.3 LDM TCHR,OR+3 NJN C2C8 IF REQUEST ALREADY SET C2C7.4 LDD PP SET THIS PP AS REQUESTING CHANNEL STM TCHR,OR+3 C2C8 LJM RER RETRY ASSIGNMENT UPON REENTRY C2C8.1 LDD OR+4 C2C9 LPN 10 ZJN C2C10 IF NO SHARED DEVICE SEEK SOM TSCA,OR+3 * CHANNEL ASSIGNMENT ALLOWED. C2C10 LDD OA READ CHANNEL PARAMETER ADN 1 CRD T4 LDD OR+3 ASSIGN CHANNEL STD T4 LDD CM SCN 11 LMN 1 STD CM LDD OA REWRITE PARAMETERS STD CF SET FLAG FOR CHANNEL UPDATE ADN 1 CWD T4 LDM TCHS,T4 RESERVE CHANNEL LPC -4000 LMD PP STM TCHS,T4 N8SJ RRX (NO ISD SUBSYSTEM JUMP) LDD OR+4 LPN 42 LMN 40 NJN RRX IF NOT ISD DEVICE OR SEEK WAIT ASSIGNMENT AOI T1 LMN 1 NJN RRX IF NOT FIRST ACTIVITY ON CONTROL MODULE LDD T4 SHN 6 RAI T1 UJN RRX EXIT REENTRY PROCESSING CHD SPACE 4,10 ** CHD - CHANNEL DROP PROCESSOR. * * COMPLETE THE CHANNEL DROP AFTER STORAGE MOVE COMPLETES. CHD LDD OA READ CHANNEL STATUS ADN 1 CRD T4 * UJN RRX COMPLETE FUNCTION RRX SPACE 4,10 ** RRX - EXIT *DSWM* REENTRY PROCESSING. RRX LDD CM SET CHANNEL STATUS STD OR+3 NSDJ RRX2 (NO SHARED DEVICES JUMP) LPN 1 ZJN RRX2 IF NO CHANNEL ASSIGNED UPON EXIT LDM TSCA,T4 ZJN RRX2 IF NO SHARED DEVICE ACTIVITY LDD OR+4 LPN 40 ZJN RRX1 IF NOT ISD DEVICE LDI T1 LPN 76 ZJN RRX2 IF NO OTHER CONTROL MODULE ACTIVITY RRX1 LDN 20-10 SET DRIVE RELEASE RRX2 ADN 10 * LDN 10 (NO SHARED DEVICES) RRXA EQU *-1 STD OR+1 LDN 0 COMPLETE FUNCTION STD OR N8SJ RRX3 (NO ISD SUBSYSTEM JUMP) LDD OR+4 LPC 100 ZJN RRX3 IF ISD WRITE IN PROGRESS LCN 12-1 RRX3 ADN 12 STD OR+2 LDD T4 SET CHANNEL IN REPLY LPN 37 STD OR+4 LDD OA CWD OR LDC PPR RESET REENTRY ADDRESS STM TREA,PP LDD PR ZJN RRX4 IF NO PRIORITY REQUEST RJM PRR PROCESS REQUEST RRX4 LJM FNR RETURN TO MAIN LOOP SPACE 4,10 ** RSY - SELECT SYSTEM DEVICE. * * THIS ROUTINE SELECTS A SYSTEM DEVICE BASED UPON THE * FOLLOWING CRITERION. * 1) SELECT DEVICE WITH LEAST ACTIVITY. * 2) IF ACTIVITY COUNTS EQUAL, SELECT DEVICE WHICH WILL * REQUIRE THE LEAST MOVE OF THE POSITIONER. RSY LDD OA READ PARAMETERS FROM MESSAGE BUFFER ADN 1 CRD T4 RJM TIM LCN 0 STD CM+1 (CM+1) = LEAST ACTIVITY FOUND STD CM+2 (CM+2) = TABLE INDEX UJN RSY4 ENTER SEARCH LOOP RSY1 RAD CM+1 SET NEW LEAST ACTIVITY LDD CN+2 SBD T6 PJN RSY2 IF POSITIVE DISTANCE LMC -0 RSY2 STD CM+4 (CM+4) = LEAST DISTANCE TO POSITION RSY3 LDD CM+2 SET BEST EQUIPMENT STD CM+3 (CM+3) = *TSYD* INDEX OF EQUIPMENT FOUND * SEARCH SYSTEM DEVICES FOR FREE UNIT INTERLOCK. RSY4 AOD CM+2 INCREMENT TO NEXT SYSTEM DEVICE LDM TSYM,CM+2 ZJN RSY6 IF END OF LIST SHN 3 ADN DALL CRD CN LDD CN LPC 7677 IGNORE LOW SPACE INDICATOR SBD CM+1 MJN RSY1 IF LESS ACTIVITY NJN RSY4 IF MORE ACTIVITY LDD CN+2 SBD T6 PJN RSY5 IF POSITIVE DISTANCE LMC -0 RSY5 SBD CM+4 PJN RSY4 IF .GE. PREVIOUS DISTANCE RAD CM+4 UJN RSY3 SET BEST EQUIPMENT RSY6 LDM TSYD,CM+3 SBD T5 ZJP RSY11 IF NO EQUIPMENT CHANGE * CHANGE EQUIPMENT DEPENDENT PARAMETERS. RAD T5 SET NEW EQUIPMENT NSDJ RSY7 (NO SHARED DEVICES JUMP) LDD OR+4 RESET SHARED FLAG SCN 4 LMM TSHS,CM+3 STD OR+4 RSY7 LDD OA RESET UNIT NUMBER ADN 2 CRD CS LDM TSYM,CM+3 SET NEW MST STM TPMS,PP SHN 3 ADN DDLL CRD CN READ NEW UNIT LIST LDN CN*2+11 SET BYTE POINTER = CN+4 - LU/2 SBD CS SHN 21 STD T2 SCN 77 LMI T2 MJN RSY8 IF FIRST UNIT IN BYTE SHN -6 RSY8 BSS 0 RSYA LPN 77 *RSYA LPN 37 (33502 SYSTEM) RSYB UJN RSY9 (NOT 33502 SYSTEM JUMP) *RSYB LMD CS+1 LPN 37 LMD CS+1 RSY9 STD CS+1 N8SJ RSY10 (NO ISD SUBSYSTEM JUMP) STM TCMN,PP LMC 200 RESTORE READ/SEEK PARAMETER STD CS+1 RSY10 LDD OA WRITE NEW EQUIPMENT NUMBER ADN 1 CWD T4 ADN 1 WRITE NEW PHYSICAL UNIT NUMBER CWD CS RSY11 BSS 0 * UJN CUI CHECK UNIT INTERLOCK CUI SPACE 4,10 ** CUI - CHECK FOR UNIT INTERLOCK FREE. * * NOTE THAT THE ACTIVITY COUNT IS NOT INCREMENTED UNTIL AFTER * THE SYSTEM SELECTION HAS TAKEN PLACE. THIS IS DONE TO INSURE * EQUAL TREATMENT OF ALL SYSTEM DEVICES. IT ALSO PREVENTS * DEVICE ACTIVITY FROM BEING SET WHEN WAITING FOR STORAGE MOVE. * * *CUI* SETS THIS PP AS REQUESTING THE UNIT, IF THE UNIT * INTERLOCK IS BUSY AND THE REQUEST IS FOR LOGICAL UNIT ZERO. * * A UNIT REQUEST WILL BE PROCESSED IMMEDIATELY UPON RELEASE OF * THE UNIT, INSURING THE SEEK WILL BE INITIATED PRIOR TO * ASSIGNING THE CHANNEL TO OTHER REQUESTS. WITHOUT THIS LOGIC * THE CHANNEL MAY BE GIVEN TO A REQUEST WHICH IS ON-CYLINDER * THUS PREVENTING THE SEEK FROM BEING INITIATED AND OVERLAPING * WITH I/O OPERATIONS. CUI MSTA DALL,PP ENTRY TO INCREMENT ACTIVITY COUNT CRD CN AOD CN LDD CN+1 LMD OR+3 SBD CN+1 PJN CUI4 IF UNIT INTERLOCK AVAILABLE LDC CUI3 RESET ENTRY TO CHECK UNIT INTERLOCK STD OR+1 LDD OA WRITE UPDATED PROCESSOR ADDRESS CWD OR CUI1 LDD OR+3 SHN -13 ZJN CUI2 IF NOT FIRST UNIT OF DEVICE LDD PP SET THIS PP AS REQUESTING UNIT STD CN+3 CUI2 MSTA DALL,PP CWD CN LJM RER RECHECK INTERLOCK UPON REENTRY CUI3 MSTA DALL,PP CRD CN LDD CN+1 LMD OR+3 SBD CN+1 MJN CUI1 IF UNIT INTERLOCK SET CUI4 RAD CN+1 SET UNIT INTERLOCK LDD OA READ TRACK ADN 1 CRD T4 LDD T6 SET CURRENT POSITION STD CN+2 MSTA DALL,PP WRITE UPDATED UNIT INTERLOCK CWD CN RJM SCS SET CHANNEL SELECTION PROCESSING LJM 0,OR+1 CHECK CHANNEL PRR SPACE 4,15 ** PRR - PROCESS PRIORITY REQUEST. * * *PRR* IS ENTERED TWICE, FIRST, TO PROCESS A PRIORITY * REQUEST, AND SECOND, UPON COMPLETION OF PROCESSING A * PRIORITY REQUEST. * * ENTRY (A) = (PR) = PRIORITY PP NUMBER ON INITIAL ENTRY. * (A) = (PR) = PP OR ADDRESS FOR SECOND ENTRY. * * EXIT TO *RER2* TO PROCESS PRIORITY SEEK REQUEST. * TO INITIAL RETURN ADDRESS FOR SECOND ENTRY. * * USES T1, PR. PRR SUBR ENTRY/EXIT STD T1 SHN -5 NJN PRR1 IF NOT INITIAL ENTRY LDM PRR SAVE EXIT ADDRESS STM PRRA LDM TREA,T1 LMC RER2 NJN PRR2 IF NOT IN REENTRY PROCESSING RJM TIM LDD OA SET ORIGINAL OUTPUT REGISTER ADDRESS STD PR LDD T1 STD PP LJM MTR3 PROCESS PRIORITY REQUEST PRR1 LDD PR RESET OUTPUT REGISTER ADDRESS STD OA SBD OF RESET PP NUMBER SHN -3 STD PP PRR2 LDN 0 STD PR LJM * RETURN TO ORIGINAL ENTRY PRRA EQU *-1 SCS SPACE 4,30 ** SCS - SET *DSWM* CHANNEL SELECTION. * * THIS ROUTINE SELECTS THE CHANNEL ASSIGNMENT PROCESSOR BASED * UPON THE FOLLOWING TABLE. THE TABLE CONTAINS ENTRIES FOR * EACH OF THE POSSIBLE COMBINATIONS OF THE RELEVANT *DSWM* * REENTRY FLAGS. THE RELEVANT *DSWM* REENTRY FLAGS ARE - * * BIT 5 ISD DEVICE. * BIT 4 CHANNEL SELECTED BY CALLER. * BIT 3 SEEK ON SHARED DEVICE. * * FLAGS PROCESSOR CHANNEL(S) * 0X C2C CN+4 * 1X C1C T4 * 2X C1C T4 * 3X C1C T4 * 4X C2M CN+4 * 5X C1M T4 * 6X C1M T4 * 7X C1M T4 * * SELECTION OF THE *C2C* OR *C2M* PROCESSOR WILL BE MADE ONLY * IF NEITHER CHANNEL OF A DUAL ACCESS DEVICE IS BEING IDLED. * * ENTRY (OR+4) = *DSWM* REENTRY PROCESSING FLAGS. * (CN+4) = CHANNELS FOR UNIT. * (T4) = CURRENTLY SELECTED CHANNEL. * * EXIT (OR+1) = CHANNEL ASSIGNMENT PROCESSOR. * (OR+3) = CHANNEL(S) FOR ASSIGNMENT PROCESSOR. * (OR - OR+4) WRITTEN TO (OA). SCS8 STD OR+3 LDD OA WRITE PARAMETERS CWD OR SCS SUBR ENTRY/EXIT LDD OR+4 LPN 70 ZJN SCS5 IF NO SPECIAL PROCESSING, FLAGS = 0X SBN 40 MJN SCS1 IF NOT ISD DEVICE, FLAGS = 1X, 2X, 3X ZJN SCS4 IF NO CHANNEL SELECTION, FLAGS = 4X SCS0 LDC C1M FLAGS = 5X, 6X, 7X UJN SCS2 SELECT SINGLE CONTROL MODULE CHANNEL SCS0.1 LDD OR+4 LPN 40 NJN SCS0 IF ISD SCS1 LDC C1C SCS2 STD OR+1 SET SINGLE CHANNEL PROCESSOR LDD T4 SCS3 UJN SCS8 STORE OUTPUT REGISTER AND RETURN SCS4 LCN C2C-C2M SCS5 ADC C2C CHANNEL SELECTION PROCESSOR STD OR+1 LDD CN+4 SHN 14 STD T1 SHN -14 SCS6 STD T4 LMD T1 ZJN SCS0.1 IF SINGLE CHANNEL ACCESS LDM TCHS,T1 SHN 21-6 MJN SCS1 IF CHANNEL BEING IDLED LDM TCHS,T4 SHN 21-6 PJN SCS7 IF CHANNEL NOT BEING IDLED LDD T1 UJN SCS6 SELECT OTHER CHANNEL SCS7 LDD CN+4 SET CHANNELS FOR SELECTION UJN SCS3 STORE OUTPUT REGISTER AND RETURN TDSWM SPACE 4,10 TDSWM BSS 0 TABLE OF *DSWM* SUBFUNCTION PROCESSORS DUP MXDSWM,1 CON DSW15 TDSWM HERE ORG TDSWM+MXDSWM SPACE 4 ** TMSK - TABLE OF SINGLE BIT MASKS TMSK BSS 0 CON 4000 CON 2000 CON 1000 CON 0400 CON 0200 CON 0100 CON 0040 CON 0020 ECXM TITLE PP REQUEST FUNCTION PROCESSORS. HLTM SPACE 4,10 *** HLTM - HALT PP WHILE IN SYSTEM DEBUG MODE. * * ENTRY *T, OR 12/ HLTM,12/,12/,12/,12/ * * EXIT IF SYSTEM DEBUG MODE DISABLED *T, OR 60/0 * * EXIT IF SYSTEM DEBUG MODE ENABLED *T, OR 12/ HLTM,12/,12/,12/,12/ PPR HLTM LDK SSTL CHECK SYSTEM DEBUG DISABLED FLAG CRD CM LDD CM+3 SHN 21-1 PJN PRL1 IF SYSTEM DEBUG ENABLED HLT1 LDC MS2W+** CLEAR PP HUNG MESSAGE AT SYSTEM CP HLTA EQU *-1 CWD ZR UJN PRL2 RETURN CLEARING OUTPUT REGISTER PRLM SPACE 4 *** PRLM - PAUSE FOR STORAGE RELOCATION. * * ENTRY *T, OR 12/ PRLM,12/,12/,12/,12/ * * EXIT *T, OR 12/ 0, 48/ PPR PRLM LDD MM.4 ZJN PRL2 IF NO MOVE IN PROGRESS LDD PP GET ASSIGNED CP/PCP SHN PPXES TADC ACPP,PPX CRD CM LDD CM CHECK CP/PCP ASSIGNMENT LMD MM.0 NJN PRL2 IF NOT AT MOVE PRL1 LJM FNR EXIT PRL2 LJM FNC EXIT TO CLEAR OUTPUT REGISTER RCHM SPACE 4,20 *** RCHM - REQUEST CHANNEL. * * REQUEST ASSIGNMENT OF 1 OF 2 POSSIBLE CHANNELS. * * ENTRY *T, OR 12/ RCHM,1/R,5/ ,1/C,5/ CH0,6/ ,1/C,5/ CH1,24/ * R SET IF CALLER WANTS IMMEDIATE RETURN IF CHANNEL(S) * DOWN. * C SET IF CONCURRENT CHANNEL IS SPECIFIED BY CHX. * CHX CHANNEL. * * EXIT *T, OR 12/ 0,1/R,11/ CH,36/ * R SET IF CHANNEL(S) DOWN AND CALLER REQUESTED IMMEDIATE * RETURN. THE *CH* FIELDS ARE UNCHANGED IN THIS CASE. * CH CHANNEL ASSIGNED. PPR RCHM LDD PP GET ASSIGNED CP/PCP SHN PPXES TADC ACPP,PPX CRD CM LDD CM CHECK FOR MOVE LMD MM.0 ZJN PRL1 IF MOVE REQUEST LDD OR+1 LPN 77 RJM TCH NJN RCH2 IF CHANNEL NOT AVAILABLE RCH1 LJM CCH4 RESERVE THE CHANNEL RCH2 SHN 0-21 STD T1 SAVE CHANNEL STATUS LDD OR+2 NJN RCH4 IF SECOND CHANNEL SPECIFIED AOD T1 RCH3 SHN -1 ZJN PRL1 IF AT LEAST 1 CHANNEL UP LDD OR+1 SBD FT MJN PRL1 IF REPLY NOT REQUESTED LJM FNC RETURN REJECT STATUS RCH4 RJM TCH ZJN RCH1 IF CHANNEL AVAILABLE SHN 0-21 RAD T1 UJN RCH3 CHECK FOR BOTH CHANNELS DOWN RCXM SPACE 4,25 *** RCXM - PERFORM EM TRANSFER DURING ROLLIN/ROLLOUT. * * *RCXM* REQUESTS ARE ISSUED BY *1RI* AND *1RO* DURING THE * ROLLIN/ROLLOUT OF USER EM. THE ISSUING PP PLACES THE REQUEST * IN ITS OUTPUT REGISTER AND PERFORMS I/O ASYNCHRONOUSLY WITH * THE COMPLETION OF THE REQUEST. *MTR* CHANGES THE REQUEST TO * AN *ECXM* REQUEST AND PASSES IT ON TO *CPUMTR*. THE * APPROPRIATE REQUEST BIT WILL BE SET IN *CPUMTR-S* *PR* * PROGRAM MODE REQUEST WORD. * * ENTRY *T, OR 12/ECXM, 1/C, 11/, 12/CPN, 5/, 1/T, 18/ADDR * C SET IF ALTERNATE CP/PCP SPECIFIED. * CPN ALTERNATE CP/PCP NUMBER IF *C* SELECTED. * T FUNCTION TYPE - * 0 READ. * 1 WRITE. * ADDR RESPONSE ADDRESS. * * EXIT *T, OR 60/0 *T, ADDR 12/0, 12/ST, 36/0 * ST = STATUS. * 0 NO ERROR IN TRANSFER. * 7777 ERROR IN TRANSFER. PPR RCXM LDC ECXM+2000 CHANGE FUNCTION TO PROGRAM MODE *ECXM* STD OR LDD OA WRITE OUTPUT REGISTER CWD OR SBD OF COMPUTE PROGRAM MODE REQUEST STACK BIT SHN -3 ADN 11D STD CN+2 LDN EPRF ENTER PROGRAM MODE REQUEST RJM CPR LJM FNR RETURN WITHOUT CLEARING PP OR SFLM SPACE 4,15 *** SFLM - SET FL INCREASE REJECTED. * * ENTRY *T, OR 12/ SFLM,12/ FN,12/ CP,12/,12/ * * FN FUNCTION * 1 = SET CM INCREASE REJECTED. * 2 = SET ECS INCREASE REJECTED. * CP CONTROL POINT NUMBER. * * EXIT *T, OR 12/ 0,48/ PPR SFLM LDD OR+2 SBD NC PJN SFR2 IF ILLEGAL CP NUMBER ADD NC SHN 7 ADN FLIW STD OR+3 CRD CM LDD CM+3 ADD CM+4 ZJN SFR1 IF INCREASE NO LONGER PENDING LCN 0 LMD OR+1 SET MASK STM SFRA LDD CM+1 SET CORRECT BIT LPC * * LPC 7776 (SET CM INCREASE REJECT) * LPC 7775 (SET ECS INCREASE REJECT) SFRA EQU *-1 LMD OR+1 STD CM+1 LDD OR+3 REWRITE FL INCREASE CONTROL WORD CWD CM SFR1 LJM FNC COMPLETE FUNCTION SFR2 RJM HNG HANG PP RSTM SPACE 4,50 *** RSTM - REQUEST STORAGE. * * REQUEST CM OR ECS STORAGE ASSIGNMENT AT CONTROL POINT. * CM AND ECS STORAGE REQUESTS ARE DEFINED TO BE * .GE. 0 AND .LE. 3777B. * * A *HUNG PP* WILL BE GENERATED IF ANY OF THE FOLLOWING OCCURS. * 1) REQUEST FOR ECS AND USER ECS IS NOT DEFINED. * 2) REQUEST FOR NEGATIVE FL FOR ECS. * 3) CMR REQUEST FOR NEGATIVE FL. * 4) FL REQUEST GREATER THAN 3777B. * 5) A SPECIAL REQUEST WAS MADE BY A PP OTHER THAN *VER*. * 6) REQUEST IS FOR AN INVALID CONTROL POINT. * * THERE ARE SEVERAL CHECKS IN MEMORY ALLOCATION WHICH WILL * STOP *MTR* IF SOMETHING IS WRONG. THIS TYPE OF LOGIC IS * NEEDED TO PRESERVE CONDITIONS AND ENSURE SYSTEM INTEGRITY. * * ENTRY * *T, OR 12/ RSTM,12/ FL,12/ F,12/ PN,12/ * FL FIELD LENGTH DESIRED (CM FL/100, ECS FL/*UESB*). * IF NEGATIVE, AMOUNT OF CM TO RETURN TO SYSTEM * (SPECIAL *VER* REQUEST ONLY). * * F FLAG BITS. * BIT 0 = TYPE OF STORAGE REQUEST (1 = XM). * 1 = UNUSED. * 2 = UNUSED. * 3 = UNUSED. * 4 = UNUSED. * 5 = CLEAR STORAGE REQUEST COMPLETE. * 6 = SET INCREASE IN *FLIW* IF NOT AVAILABLE. * 7 = CHANGE EXECUTION FL (*VER* ONLY). * 8 = CM REQUEST IS FOR NEGATIVE FL. * 9 = CHANGE CMR SIZE. * 10 = TRANSFER FL FROM CP TO PCP (PSEUDO-ROLLOUT). * 11 = TRANSFER FL FROM PCP TO CP (PSEUDO-ROLLIN). * * PN PSEUDO-CONTROL POINT NUMBER IF CP/PCP TRANSFER (BIT 10 * OR BIT 11 SET). * * EXIT * *T, OR 60/ 0 * REQUEST HAS BEEN HONORED. * *T, OR 12/ 0,12/ FL,12/,12/,12/ * STORAGE IS NOT AVAILABLE. PPR RSTM SBD OF GET ASSIGNED CP OR PCP SHN PPXES-PPCES TADC ACPP,PPX CRD CM LDD MM.4 NJP FNR IF MOVE IN PROGRESS LDD CM SET ASSIGNED CP/PCP NUMBER STD CP STD T6 ZJN RST2 IF INVALID CP/PCP NUMBER SBM UFLA PJN RST2 IF INVALID CP/PCP NUMBER LDD OR+2 LPN 1 SET STORAGE TYPE STD T5 RSTA SBN 2 * SBN 1 (USER ECS UNDEFINED) PJN RST2 IF ILLEGAL REQUEST LDD OR+2 SHN 0-11 ZJN RST3 IF NOT CP/PCP FL TRANSFER OR CMR REQUEST SCN 1 NJN RST1 IF PSEUDO-ROLLIN OR PSEUDO-ROLLOUT STD CP SET CMR MCT ORDINAL STD T6 UJN RST3 SET FL CONTROL WORD ADDRESS = CMRL RST1 LDD OR+3 STD T8 SAVE PCP NUMBER SBM UFLA RST2 PJN RST4 IF INVALID PCP NUMBER RST3 LDM MAFA,T5 STD OR+3 SET FL CONTROL WORD ADDRESS LDD CP RJM SCP READ FL CONTROL WORD ADD OR+3 CRD CS LDD OR+2 SET BYTE INDEX SHN -6 LPN 4 LMN 4 STD OR+4 NJN RST5 IF NOT NEGATIVE FL REQUEST LDD T5 NJN RST4 IF XM REQUEST LDD CP ZJN RST4 IF CMR REQUEST RJM STA CRD CM GET MCT ENTRY FOR CP LDD CM STD T6 SET MCT ORDINAL TO BACKWARD LINK LDD OR+1 SBN MNFL+1 MJN RST6 IF VALID NFL REQUEST RST4 RJM HNG HANG PP RST5 LDD OR+2 CHECK FLAG BITS SHN 21-7 MJN RST8 IF SPECIAL REQUEST LDD CS ADD OR+1 SHN -13 NJN RST4 IF REQUEST .GT. 3777 RST6 LDD T5 RSTB ZJN RST7 IF NOT AN ECS REQUEST * UJN RST7 (SINGLE CPU OR CPU-1 FOR NOS/VE ONLY) * UJN RST7 (810/830 ALLOW USER XM ON EITHER CPU) * UJN RST7 (865/875 ALLOW ECS ON EITHER CPU) LDD NC SBD CP MJN RST7 IF PCP LDN 1 STD CM+4 SET IMPLICIT CPU 0 SELECTION LDN CPUS STD CM+1 CHANGE JOB CONTROL PARAMETERS MONITOR SJCM RST7 LDD OA STORE OUTPUT REGISTER CWD OR LDD OR+2 CHECK FLAG BITS SHN 0-12 NJN RST10 IF PSEUDO CONTROL POINT OPERATION LDD OR+1 CHECK INCREASE SBM CS,OR+4 NJN RST12 IF FL CHANGE RJM CFL CLEAR FL INCREASE REQUEST LJM FNZ CLEAR OUTPUT REGISTER RST8 RJM PVE CHECK SPECIAL REQUEST FROM *VER* PJN RST17 IF INCREASE RST9 LJM RST22 PROCESS DECREASE RST10 LJM RST19 PROCESS PCP REQUEST RST12 STD T7 SAVE INCREMENT PJN RST17 IF INCREASE * PROCESS STORAGE DECREASE. LDD CP ZJN RST9 IF CMR REQUEST LMN 1 NJN RST15 IF NOT FIRST CP LDD OR+4 ZJN RST9 IF NEGATIVE FL REQUEST RST15 LDD CP RSTE SBN ** CHECK CONTROL POINT * SBN (NC)-1 NJN RST16 IF NOT LAST CONTROL POINT LDD OR+4 NJN RST9 IF NOT NEGATIVE FL REQUEST RST16 LDD OR+2 RSTC EQU RST16 * UJN RST20 (MEMORY CLEARING NOT ENABLED) LPN 40 NJN RST20 IF STORAGE CLEARED LJM RST26 SET UP *CSTM* REQUEST * PROCESS STORAGE INCREASE. RST17 LDD T6 RJM RSB FETCH UNASSIGNED MEMORY BLOCK SBD T7 PJN RST20 IF INCREASE POSSIBLE WITH NO MOVE RJM UFL CHECK UNASSIGNED FL MJN RST21 IF MEMORY NOT AVAILABLE RJM EMO EVALUATE MOVE OPTIONS RST19 RJM CRA CHANGE REFERENCE ADDRESS RST20 RJM MFL MODIFY FIELD LENGTH LJM FNZ CLEAR OUTPUT REGISTER RST21 RJM SFL SET FL INCREASE LJM FNC COMPLETE FUNCTION * MOVE CP 1 ON CMR DECREASE. * MOVE LAST CONTROL POINT ON DECREASE. * MOVE CP 1 ON CP 1 NEGATIVE FL DECREASE. RST22 LDD CP SET REQUESTING CP STD MM.3 NJN RST23 IF NOT CMR REQUEST LDN 1 RST23 STD MM.0 SET CP/PCP FOR MOVE STM AMVB LMN 1 ZJN RST24 IF CMR REQUEST OR CP 1 LCN 0 RST24 LMD T7 SET MOVE INCREMENT STD MM.1 RJM MFL MODIFY FIELD LENGTH LJM EMO3 INITIATE MOVE RST26 LDD OA SAVE *RSTM* REQUEST IN MB+5 ADN 6 CWD OR LDC 400 SET SPECIAL *CSTM* REQUEST STD OR+1 LDC CSTM+4000 STD OR LDD OA CWD OR LJM FNR WAIT FOR *CSTM* TO COMPLETE SCHM SPACE 4 SEQM SPACE 4,20 *** SEQM - SET EQUIPMENT PARAMETERS. * * ENTRY. *T, OR 12/ SEQM,12/ P0,12/ SF,12/ P1,12/ P2 * WHERE - * P0 EST ORDINAL FOR ALL SUBFUNCTIONS EXCEPT CCNS, ICNS. * FOR SF = DNCS, IF *P0* = 0 THEN UNCONFIGURED CHANNEL * IS BEING GLOBALLY DOWNED. * P0 CONTROL POINT NUMBER FOR FUNCTIONS CCNS, ICNS. * (IF 4000B + CONTROL POINT NUMBER, *P2* = ALTERNATE * EJT ORDINAL). * SF SUBFUNCTION CODE. * ONES = 0 = ON EQUIPMENT. * IDES = 1 = IDLE EQUIPMENT. * OFES = 2 = OFF EQUIPMENT. * DWES = 3 = DOWN EQUIPMENT. * SB0S = 4 = SET BYTE 0 OF EST. * SB1S = 5 = SET BYTE 1 OF EST. * SB2S = 6 = SET BYTE 2 OF EST. * SB3S = 7 = SET BYTE 3 OF EST. * SB4S = 10 = SET BYTE 4 OF EST. * DNCS = 11 = DOWN CHANNEL. * UPCS = 12 = UP CHANNEL. * 13 = RESERVED. * CCNS = 14 = RELEASE CHANNEL FROM MAINTENANCE JOB. * ICNS = 15 = ASSIGN CHANNEL TO MAINTENANCE JOB. * 16 = RESERVED. * 17 = RESERVED. * SMNS = 20 = SET EQUIPMENT MNEMONIC. * CSES = 21 = CLEAR SUSPECT FLAG. * SSES = 22 = SET SUSPECT FLAG. * CRES = 23 = CLEAR RESTRICT NEW ACTIVITY FLAG. * SRES = 24 = SET RESTRICT NEW ACTIVITY FLAG. * 25 = RESERVED. * CKPS = 26 = CHECKPOINT SYSTEM. * * P1 EQUIPMENT MNEMONIC FOR SUBFUNCTION SMNS. * P1 MASK FOR SUBFUNCTIONS SB0S - SB4S. * P1 6/ 0,6/ CH FOR SF = DNCS, UPCS, CCNS AND ICNS. * CH = CHANNEL, INCLUDING CONCURRENCY FLAG. * P2 VALUE FOR SUBFUNCTIONS SB0S - SB4S. * P2 MUX CHANNEL INDICATOR FOR SUBFUNCTIONS DNCS, UPCS. * P2 ALTERNATE EJT ORDINAL TO ASSIGN/RELEASE CHANNEL * TO/FROM FOR FUNCTIONS CCNS, ICNS, IF *P0* = 4000B + * CONTROL POINT NUMBER. * * EXIT. * *T, OR 12/ 0,48/ UNCHANGED. * REQUEST HAS BEEN HONORED. * *T, OR 60/ 0 FOR SUBFUNCTIONS ONES, IDES AND OFES WHEN THE DEVICE IS * DOWN AND ASSIGNED TO A DIAGNOSTIC. * *T, OR 60/ 0 FOR SUBFUNCTION DWES WHEN ATTEMPTING TO DOWN THE LAST * SYSTEM DEVICE. * *T, OR 12/ 0,12/ ST,36/ UNCHANGED FOR SUBFUNCTION DNCS WHEN UNABLE * TO PROCESS REQUEST NORMALLY. * ST = 0 IF ONLY ONE NON-DOWN ACCESS REMAINS ON A * NON-DOWN DEVICE. * *T, OR 60/ 0 FOR SUBFUNCTION UPCS WHEN - * A MAINTENANCE USER IS ACTIVE ON THE CHANNEL. * * HANG CONDITIONS - * * MUX CHANNEL AND CONCURRENT CHANNEL SPECIFIED ON * UP/DOWN CHANNEL REQUEST (SUBFUNCTIONS DNCS, UPCS) * THE VALUE OF THE CHANNEL DESCRIPTOR (1/C,5/CH) * EXCEEDS 51B (SUBFUNCTIONS DNCS, UPCS, CCNS, ICNS). * FOR SUBFUNCTION CCNS IF CHANNEL NOT ASSIGNED * TO CALLER (OR ALTERNATE EJT ORDINAL). PPR SEQM LDD PP GET ASSIGNED CP/PCP SHN PPXES TADC ACPP,PPX CRD CM LDD CM CHECK FOR MOVE LMD MM.0 ZJP FNR IF MOVE IN PROGRESS LDD OR+2 CHECK SUBFUNCTION SBN CCNS ZJN SEQ4 IF MAINTENANCE JOB REQUEST SBN ICNS-CCNS ZJN SEQ4 IF MAINTENANCE JOB REQUEST SBN TSEQL-ICNS MJN SEQ2 IF VALID SUBFUNCTION SEQ1 RJM HNG HANG PP SEQ2 LDD OR+1 FETCH EST ENTRY SFA EST ADK EQDE CRD CS LDD OR+2 SBN DNCS NJN SEQ3 IF NOT DOWN CHANNEL REQUEST LDD OR+1 NJN SEQ3 IF EST ORDINAL SPECIFIED LDD FT STD CM+1 LJM DNC10 SET GLOBAL DOWN FLAG SEQ3 LDC 0 VALIDATE EST ORDINAL SEQA EQU *-1 SBD OR+1 MJN SEQ1 IF INVALID ORDINAL SEQ4 LDM TSEQM,OR+2 SET PROCESSOR ADDRESS STD T8 LDD OR+3 GET MASK LJM 0,T8 JUMP TO PROCESSOR SST SPACE 4,10 *** SST - SET EQUIPMENT STATE. * ON, IDLE, OFF, DOWN EQUIPMENT. SST SUBFUN SEQM,DWES DOWN EQUIPMENT LDD CS SHN 21-13 PJP SST4 IF NOT MASS STORAGE SHN 13-12 PJN SST3 IF NOT SYSTEM DEVICE LCN 0 STD T1 STD T2 SST1 AOD T2 INCREMENT NON-DOWN SYSTEM DEVICE COUNT SST1.1 AOD T1 ADVANCE SYSTEM DEVICE TABLE INDEX LDM TSYM,T1 ZJN SST2 IF END OF SYSTEM DEVICE LIST SHN 3 ADK DALL CRD CN LDD CN SHN 0-10 LMN 3 NJN SST1 IF NOT DOWN, COUNT IT UJN SST1.1 AVOID COUNTING DOWN DEVICE SST2 LDD T2 SHN -1 ZJP FNZ IF ONLY ONE NON-DOWN SYSTEM DEVICE REMAINS SST3 LDD OR+1 STD CM+1 MONITOR CDAM CHECK DEVICE ACTIVITY LDD CM+1 NJP FNR IF ACTIVITY REMAINS SST4 SUBFUN SEQM,(ONES,IDES,OFES) LDD CS SET NEW DOWN BIT SCN 3 LMD OR+2 STD CS LDD OR+2 BITS TO SET 2/ STATE, 1/ SUSPECT, 1/ SHN 2 LMD OR+2 LPN 16 SHN 14 LMN 16 UJN SST9 SET STATE IN MST * SET/CLEAR SUSPECT BIT. SST5 SUBFUN SEQM,SSES LDC 20002 UJN SST9 SET SUSPECT BIT SST6 SUBFUN SEQM,CSES CLEAR SUSPECT BIT LDD CS LPN 2 NJP FNC IF OFF OR DOWN, DO NOT CLEAR SUSPECT LDN 2 UJN SST9 ADJUST BITS IN MST * SET/CLEAR RESTRICT NEW ACTIVITY BIT. SST7 SUBFUN SEQM,SRES SET RESTRICT NEW ACTIVITY BIT LDC 10001 UJN SST9 SET BIT IN MST SST8 SUBFUN SEQM,CRES CLEAR RESTRICT NEW ACTIVITY BIT LDN 1 SST9 STD CM+4 SET BITS TO CHANGE SHN -14 STD CM+2 NEW BIT VALUES LDD CS SHN 21-13 PJN SMN1 IF NOT MASS STORAGE LDN SSTS SET EQUIPMENT STATE BITS VIA CPUMTR STD CM+3 LDD OR+1 SET EQUIPMENT STD CM+1 MONITOR SMDM LDD CM+1 ZJN SMN1 IF DEVICE NOT ASSIGNED TO DIAGNOSTIC LJM FNZ REJECT FUNCTION SEB SPACE 4,10 *** SEB - SET EST BYTES. SEB SUBFUN SEQM,(SB0S,SB1S,SB2S,SB3S,SB4S) SET BYTES OF EST STM SEBA SET CLEARING MASK LDM CS-SB0S,OR+2 LPC 0 SEBA EQU *-1 LMD OR+4 MERGE IN NEW BITS STM CS-SB0S,OR+2 UJN SMN1 WRITE EST TO MEMORY SMN SPACE 4,10 *** SMN - SET EQUIPMENT MNEMONIC. SMN SUBFUN SEQM,SMNS STD CS+3 SMN1 SFA EST,OR+1 UPDATE EST ENTRY ADK EQDE CWD CS LJM FNC COMPLETE FUNCTION UPC SPACE 4,10 *** UPC - UP CHANNEL. UPC SUBFUN SEQM,UPCS UP CHANNEL LDD OR+4 NJN UPC2 IF MUX CHANNEL LDD OR+3 RJM VCN VERIFY CHANNEL NUMBER LDM TCHS,OR+3 LPN 40 ZJN UPC2 IF NOT GLOBALLY DOWN LDD OR+3 RJM GCE ZJN UPC2 IF CHANNEL NOT ASSIGNED TO JOB UPC1 LJM FNZ REJECT FUNCTION UPC2 LDN UPSS RJM RCS REQUEST CHANNEL STATE CHANGE ZJN UPC1 IF FUNCTION REJECTED LDD OR+4 NJN UPC3 IF MUX CHANNEL AOD CF SET CHANNEL TABLE UPDATE FLAG LDM TCHS,OR+3 ENSURE GLOBAL DOWN BIT CLEAR SCN 40 STM TCHS,OR+3 UPC3 LJM FNC COMPLETE FUNCTION DNC SPACE 4,10 *** DNC - DOWN CHANNEL. DNC SUBFUN SEQM,DNCS DOWN CHANNEL LDD OR+4 NJN DNC1 IF MUX CHANNEL LDD OR+3 RJM VCN VERIFY CHANNEL NUMBER * CHECK FOR DOWNING LAST ACCESS TO NON-DOWN DEVICE. LDD CS SHN 21-13 DNC1 PJP DNC9 IF NOT MASS STORAGE LDN 2 STD T1 DNC2 SOD T1 PJN DNC3 IF NOT END OF CHECK LDD CS LPN 3 LMN 3 ZJN DNC4 IF DEVICE IS DOWN LJM FNZ REJECT FUNCTION DNC3 LDM CS+1,T1 SHN 21-13 PJN DNC2 IF ACCESS NOT PRESENT OR DISABLED SHN 13-12 MJN DNC2 IF CHANNEL DOWN SHN 12-21 LPN 77 LMD OR+3 ZJN DNC2 IF NOT ALTERNATE PATH DNC4 LDD CS+4 READ *STLL* FROM MST SHN 3 ADN STLL CRD CM LDD CM+1 CHECK *1MV* ACTIVE ON DEVICE SHN 21-7 MJN DNC7 IF *1MV* ACTIVE, LEAVE REQUEST PENDING LDM TCHS,T2 SET IDLEDOWN FLAG IN CHANNEL TABLE LPC -100 LMD HN STM TCHS,T2 STD CF SET CHANNEL TABLE UPDATE FLAG * REQUEST *CPUMTR* TO SET CHANNEL STATE = *IDLE*. LDK SICS REQUEST CHANNEL STATE CHANGE RJM RCS * CHECK FOR ACTIVITY ON 834/836 DEVICE THROUGH CHANNEL BEING * DOWNED. LDD CS+3 LMC 2RDG ZJN DNC5 IF 836 DEVICE LMN 1RD&1RG NJN DNC8 IF NOT 834 DEVICE DNC5 LDN 10 CHECK *TCMA* ENTRIES STD T1 DNC6 SOD T1 MJN DNC8 IF ALL *TCMA* ENTRIES CHECKED LDM TCMA,T1 ZJN DNC6 IF NO ACTIVITY ON THIS CONTROL MODULE SHN -6 LMD OR+3 NJN DNC6 IF ACTIVITY THROUGH DIFFERENT CHANNEL DNC7 LJM FNR LEAVE REQUEST PENDING * CHECK FOR SEEK PENDING THROUGH THIS CHANNEL ON A SHARED * NONBUFFERED DEVICE. DNC8 LDD CS LPC 1060 SHN 21-5 MJN DNC9 IF BUFFERED DEVICE ZJN DNC9 IF NOT A SHARED DEVICE LDM TCHS,OR+3 LPN 37 NJN DNC7 IF CHANNEL IS ASSIGNED LDM TSCA,OR+3 NJN DNC7 IF SEEK PENDING THROUGH THIS CHANNEL * REQUEST *CPUMTR* TO SET THE CHANNEL STATE = *DOWN*. DNC9 LDK DWSS REQUEST CHANNEL STATE CHANGE RJM RCS ZJN DNC7 IF REQUEST WAS REJECTED DNC10 LDD OR+4 NJN DNC11 IF MUX CHANNEL * CLEAR THE IDLEDOWN AND GLOBAL DOWN FLAGS IN THE CHANNEL * TABLE. LDM TCHS,OR+3 LPC -140 STM TCHS,OR+3 * SET THE GLOBAL DOWN FLAG IF THE CHANNEL IS GLOBALLY DOWN. LDD CM+1 STD CF SET CHANNEL UPDATE FLAG SHN 0-13 SHN 5-0 RAM TCHS,OR+3 DNC11 LJM FNC COMPLETE THE FUNCTION AMC SPACE 4,10 *** AMC - ASSIGN/RELEASE CHANNEL TO/FROM MAINTENANCE JOB. AMC SUBFUN SEQM,(CCNS,ICNS) * LDD OR+3 GET CHANNEL ASSIGNMENT STATUS RJM GCE LDD OR+1 CHECK FOR ALTERNATE EJT ORDINAL SHN 21-13 PJN AMC1 IF NO ALTERNATE EJT ORDINAL LDD OR+4 STD CN AMC1 LDD OR+2 LMN ICNS NJN AMC5 IF RELEASE CHANNEL LDM TCHS,OR+3 LMN 40 ZJN AMC3 IF CHANNEL GLOBALLY DOWN AMC2 LJM FNZ REJECT FUNCTION AMC3 LDI T1 NJN AMC2 IF CHANNEL ASSIGNED TO A JOB LDD CN INSERT NEW EST ORDINAL AMC4 STI T1 LDC 0 WRITE CHANNEL ASSIGNMENT TABLE SEQB EQU *-1 ADD T0 ADD CORRECT WORD INDEX CWD CM UJN CKP1 COMPLETE FUNCTION AMC5 LDD CN CHECK EST ORDINAL LMI T1 ZJN AMC4 IF CHANNEL ASSIGNED TO THIS JOB RJM HNG HANG PP CKP SPACE 4,10 *** CKP - FORCE SYSTEM CHECKPOINT. CKP SUBFUN SEQM,CKPS LDM PHED+2 SET *1MB* FUNCTION FLAG SCN SPCP LMN SPCP STM PHED+2 CKP1 LJM FNC COMPLETE FUNCTION TSEQM SPACE 4,10 TSEQM BSS 0 DUP MXSEQM,1 CON HNG1 TSEQL EQU MXSEQM TSEQM HERE ORG TSEQM+MXSEQM DSRM SPACE 4,20 *** DSRM - DSD REQUESTS. * * NOTE - THIS FUNCTION WILL BE HONORED ONLY FROM *DSD*, OR IF * REQUEST *SET EMERGENCY STEP* AND BIT 57 OF *SCRL* SET. * REQUEST 02 - SET DATE AND TIME - WILL BE ACCEPTED FROM * NON-DSD PROGRAMS TO SUPPORT *PLATO* MMF MODE. * * ENTRY *T, OR 12/ DSRM,6/ P,6/ SF,36/ P * P = PARAMETERS * SF = SUBFUNCTION CODE * * EXIT (CM - CM+4) = (SCRL). * * USES T7. * * SUBFUNCTION MSPS - SET MONITOR STEP. * * ENTRY *T, OR 12/ DSRM,6/ BN,6/ MSPS,12/ EO,12/ FN,12/ BV * BN = BYTE NUMBER TO STEP ON. * EO = EJT ORDINAL. ZERO IF ALL EXECUTING JOBS. * FN = FUNCTION TO STEP. ZERO IF ALL FUNCTIONS. * BV = BYTE VALUE TO STEP ON. * IF B = 0, THEN * V = 2/,1/ F,2/,7/ FN * WHERE F = 1 IF FN IS *CPUMTR* FUNCTION. * * EXIT *T, OR 60/ 0 * * SUBFUNCTION STPS - STEP MONITOR. * * ENTRY *T, OR 12/ DSRM,6/ ,6/ STPS,36/ * * EXIT *T, OR 60/ 0 * * SUBFUNCTION EDTS - ENTER DATE AND TIME. * * ENTRY *T, OR 12/ DSRM,6/ ,6/ EDTS,12/ ADDR,24/ * * ADDR ADDRESS + 1 OF MESSAGE BUFFER * *T, MB+1 60/ JULIAN DATE *T, MB+2 60/ PACKED DATE AND TIME *T, MB+3 60/ TIME *T, MB+4 60/ DATE *T, MB+5 12/ DAY LIMIT, 48/ UNUSED * * EXIT * *T, OR 60/ 0 * * SUBFUNCTION ESPS - SET EMERGENCY STEP. * * ENTRY *T, OR 12/ DSRM,6/ BN,6/ MSPS,12/ 0,12/ FN,12/ BV * BN = BYTE NUMBER TO STEP ON. * FN = FUNCTION TO STEP. * BV = BYTE VALUE TO STEP ON. * IF B = 0, THEN * V = 2/,1/ F,2/,7/ FN * WHERE F = 1 IF FN IS *CPUMTR* FUNCTION. * * EXIT *T, OR 60/ 0 * * SUBFUNCTION CSPS - CLEAR MONITOR STEP. * * ENTRY *T, OR 12/ DSRM,6/ ,6/ CSPS,36/ * * EXIT *T, OR 60/ 0 * * SUBFUNCTION SKCS - SET K DISPLAY COMPLETE BIT. * * ENTRY *T, OR 12/ DSRM,6/ SF,6/ SKCS,12/ CPA,12/ * * SF = LEFT/RIGHT SCREEN FLAG * = 0 IF LEFT SCREEN * = 1 IF RIGHT SCREEN * CPA = CONTROL POINT ADDRESS * * EXIT *T, OR 60/ 0 PPR DSRM LDD SC CRD CM LDD PP SBN 1 CHECK REQUESTER ZJN DSR1 IF *DSD* LDD OR+1 CHECK FOR TIME SET SBN 2 ZJN DSR1 IF TIME SET MJN DSR2 IF NOT VALID *1MB* REQUEST SBN 5-2 PJN DSR2 IF NOT VALID *1MB* REQUEST LDD CM SHN 21-11 PJN DSR2 IF NOT *1MB* REQUEST DSR1 LDD OR+1 LPN 77 STD T7 LDM TDSRM,T7 SET REQUEST PROCESSOR STD T7 * EXIT TO PROCESSOR WITH * (A) = 0. * (CM - CM+4) = *SCRL*. LDN 0 LJM 0,T7 ENTER PROCESSOR DSR2 RJM HNG HANG PP SES SPACE 4,10 ** SES - SET EMERGENCY STEP. * * EXIT TO *MSP*. SES SUBFUN DSRM,ESPS LDN 1 SET EMERGENCY STEP FLAG * UJN MSP EXIT TO *MSPS* PROCESSOR MSP SPACE 4,10 ** MSP - SET MONITOR STEP. * * EXIT TO *FNZ* TO CLEAR OUTPUT REGISTER. * * USES CM, CN+2. * * CALLS CPR. * * MACROS ISTORE. MSP SUBFUN DSRM,MSPS ADN 1 SET STEP FLAG POSITION SHN 7 STD T0 LMC -0 STEP FLAG MASK STM MSPA LDD CM LPC 0 MSPA EQU *-1 LMD T0 SET STEP FLAG STD CM LDD SC CWD CM LDD OR+2 SET EJT ORDINAL STM CFSA LDD OR+3 SET FUNCTION TO TRAP STM CFSB LDD OR+1 SET BYTE NUMBER TO STEP SHN -6 STM CFSC LDD OR+4 SET BYTE VALUE TO STEP STM CFSD ISTORE MTRB,(UJN MTR1) FORCE CHECK OF CPP OUTPUT REGISTERS ISTORE PPRA,(UJN MSC) SET TRANSFER TO *MSC* STM MSCA LDN 0 SET STEP MODE STD CN+2 LDN MSCF CHANGE STEP MODE CONTROL RJM CPR LJM FNZ EXIT TO CLEAR OUTPUT REGISTER CMS SPACE 4,10 ** CMS - CLEAR MONITOR STEP MODE. * * EXIT STEP MODE CLEARED. * TO *STP* TO CLEAR OUTPUT REGISTER. * * USES CM, CN+2, T7, OR - OR+4. * * CALLS CPR. * * MACROS ISTORE. CMS SUBFUN DSRM,CSPS LDD CM CLEAR STEP SET LPC 6177 STD CM LDD SC CWD CM CMSA ISTORE MTRB,(NJN MTR1) RESET CONDITIONAL CPP CHECKING * ISTORE MTRB,(UJN MTR2) (NO CPP-S PRESENT) ISTORE PPRA,(SBN CPUM) RESET *PPR* PROCESSING LDN 1 CLEAR STEP MODE STD CN+2 LDN MSCF CHANGE STEP MODE CONTROL RJM CPR LDD OF SET PP 2 ADN 20 STD T7 CMS1 LDD T7 READ OUTPUT REGISTER CRD OR LDD OR SHN 21-11 PJN CMS2 IF *MTR* FUNCTION OR NOT STEPPED SHN 11-6 SHN 6-21 LMD FT STD OR LDD T7 CWD OR CMS2 LDN 10 ADVANCE PP RAD T7 SBD OF SHN -3 LMD NP NJN CMS1 IF NOT LAST PP * UJN STP EXIT TO CLEAR OUTPUT REGISTER STP SPACE 4,10 ** STP - STEP MONITOR. * * EXIT STEP MODE SET IF ENTERED FROM *STPS* SUBFUNCTION. * STEP MODE CLEARED IF ENTERED FROM *CSPS* SUBFUNCTION. * TO *FNZ* TO CLEAR OUTPUT REGISTER. STP SUBFUN DSRM,STPS STM MSCA STP1 LJM FNZ EXIT TO CLEAR OUTPUT REGISTER EDT SPACE 4,10 ** EDT - ENTER DATE AND TIME. * * EXIT *ADTF* FUNCTION ISSUED TO *CPUMTR* TO ALTER DATE AND * TIME. * TO *STP1* TO CLEAR OUTPUT REGISTER. * * USES CN. * * CALLS CPR. EDT SUBFUN DSRM,EDTS LDD OR+2 SET BUFFER ADDRESS STD CN LDN ADTF CALL *CPUMTR* TO ENTER DATE AND TIME RJM CPR UJN STP1 EXIT TO CLEAR OUTPUT REGISTER SKC SPACE 4,10 ** SKC - SET K DISPLAY COMPLETE BIT. * * EXIT *SKCF* FUNCTION ISSUED TO *CPUMTR* TO SET K DISPLAY * COMPLETE BIT. * TO *STP1* TO CLEAR OUTPUT REGISTER. * * USES CN+1, CN+2. * * CALLS CPR. SKC SUBFUN DSRM,SKCS LDD OR+1 SET LEFT/RIGHT SCREEN FLAG STD CN+1 LDD OR+2 SET CP ADDRESS STD CN+2 LDN SKCF CALL *CPUMTR* TO SET COMPLETE BIT RJM CPR UJN STP1 EXIT TO CLEAR OUTPUT REGISTER TDSRM SPACE 4,10 TDSRM BSS 0 DUP MXDSRM,1 CON HNG1 TDSRL EQU MXDSRM TDSRM HERE ORG TDSRM+MXDSRM TITLE CPU PROGRAM CONTROL ROUTINES. CCP SPACE 4 ** CCP - CHECK CENTRAL PROGRAM. * * THE CONTENTS OF THE CPU OUTPUT REGISTER, (RA+1), ARE CHECKED * AND *CPUMTR* IS REQUESTED TO PROCESS THE REQUEST. * UPDATES CPU ASSIGNMENTS AMD PRIORITIES. * * USES CM - CM+4, CS - CS+4, OR - OR+4, T1, T7. * * CALLS AVC, CPR, MST. CCP6 LDN SMRL CHECK STORAGE MOVE COMPLETE CRD CM LDD CM NJN CCP1 IF MOVE NOT COMPLETE CCP7 RJM MST. PROCESS COMPLETION UJN CCP1 CHECK RA+1 CCP8 BSS 0 SET OTHER CPU CCPD LDM CCPB * UJN CCPX (SINGLE CPU) ERRNZ ACPL-ACPL/2*2 *ACPL* MUST BE EVEN LMN 1 STM CCPB CCP SUBR ENTRY/EXIT * CHECK STORAGE MOVE STATUS. CCPA CON 0 * UJN CCP6 (STORAGE MOVE IN PROGRESS) CCP1 RJM AVC ADVANCE CLOCK CCPB LDN ACPL READ ADDRESS OF ACTIVE RA * LDN ACPL+1 (CHECKING CPU 1) STD T7 CRD CM LDD CM ZJN CCP8 IF NO RA+1 TO CHECK CCPC UJN CCP2 READ RA+1 * SHN 6 (CME PRESENT) STD OR+1 SHN 6 STD OR LRD OR LDN 40 CCP2 SHN 14 ADD CM+1 ADN 1 READ RA+1 CRD OR LDD OR ZJN CCP4 IF (RA+1) = 0 * REQUEST *CPUMTR* TO PROCESS (RA+1) REQUEST. LDN ZERL CRD CN ERRNZ CCPF CODE REQUIRES VALUE LDD T7 REQUEST (RA+1) CHECK SBN ACPL SHN 14 RJM CPR CCP3 LJM CCP8 SET OTHER CPU CCP4 LDD CM+2 ADD CM+3 ZJN CCP3 IF NO SUB-CONTROL POINT LDD TM+2 CHECK FOR LIMIT SBD CM+2 NJN CCP5 IF LIMIT PASSED OR NOT REACHED LDD TM+3 SBD CM+3 NJN CCP5 IF LIMIT PASSED OR NOT REACHED LDD TM+4 SBD CM+4 CCP5 MJN CCP3 IF LIMIT NOT REACHED LDD T7 SET CPU NUMBER SBN ACPL SHN 14 ADN CSLF CHECK SUB-CONTROL POINT LIMIT RJM CPR UJN CCP3 SET NEXT CPU CCS SPACE 4,10 ** CCS - CHECK FOR CPU SWITCH. * * EXIT CPU SWITCH INITIATED AS NEEDED. * * USES T7, CM - CM+4, CN - CN+4. * * CALLS CPR. * REQUEST CPU SWITCH. *CSWF* IS ISSUED IF A SWITCH REQUEST WAS * DETECTED IN *CSWL* SO THAT *CPR* WILL NOT RETRY IF THE * EXCHANGE REQUEST IS REJECTED. IF THE CPU IS ALREADY IN * MONITOR MODE, *CPUMTR* WILL MOST LIKELY DETECT THE *CSWL* * REQUEST ON EXIT FROM MONITOR MODE. CCS8 LDN CSWF SET SWITCH CPU FUNCTION CCS9 SHN 6 ADD T7 SHN 14 RJM CPR REQUEST CPU SWITCH CCS SUBR ENTRY/EXIT * CHECK CPU SWITCH REQUEST AND CPU SLICE EXPIRED. LDM CCSB TOGGLE CPU NUMBER IF DUAL CPU CCSA LMN 3 * LMN 0 (SINGLE CPU) STM CCSB LPN 1 SET CPU NUMBER STD T7 ADN CSWL CRD CN ADN TSCL-CSWL CRD CM LDD CN SHN 21-13 MJN CCS8 IF CPU SWITCH REQUESTED LDD TM+2 CHECK CPU SLICE LIMIT SBD CN+2 NJN CCS1 IF LIMIT PASSED OR NOT REACHED LDD TM+3 SBD CN+3 NJN CCS1 IF LIMIT PASSED OR NOT REACHED LDD TM+4 SBD CN+4 CCS1 MJN CCS3 IF NOT TIME TO SWITCH CPU CCS2 LDN TCSF SET TIME SLICE CPU SWITCH FUNCTION UJN CCS9 SWITCH CPU * CHECK RECALL SLICE EXPIRED. CCS3 LDD CM CHECK RECALL FLAG SHN 21-0 CCS4 PJN CCSX IF RECALL SLICE NOT IN EFFECT LDD TM+2 CHECK RECALL CPU SLICE LIMIT SBD CM+2 NJN CCS5 IF LIMIT PASSED OR NOT REACHED LDD TM+3 SBD CM+3 NJN CCS5 IF LIMIT PASSED OR NOT REACHED LDD TM+4 SBD CM+4 CCS5 MJN CCS7 IF RECALL CPU SLICE NOT EXPIRED LDC WQRL GET *WQ* POINTER CRD CN CCS6 LDD CN+3 LPN 77 SHN 14 LMD CN+4 ZJN CCS4 IF JOB WAS REMOVED FROM *WQ* CRD CN LDC TSCL GET PRIORITY OF JOB IN THIS CPU ADD T7 CRD CM LDD CN COMPARE PRIORITIES AND FLAGS SBD CM MJN CCS7 IF PRIORITY/FLAGS DO NOT ALLOW CPU SWITCH LDD CN+2 CHECK CPU SELECTION AND BYPASS FLAG CCSB LPN 6 * LPN 5 (CHECKING CPU 1) NJN CCS6 IF CANNOT ASSIGN CPU TO JOB LJM CCS2 SWITCH CPU CCS7 LJM CCSX RETURN CPR SPACE 4,15 ** CPR - CPUMTR REQUEST PROCESSOR. * * *CPUMTR* WILL TYPICALLY BE IN MONITOR MODE ON EXIT. * * ENTRY (A) BITS 0 - 11 = REQUEST. * (A) BITS 12 - 17 = CPU NUMBER. * (CN - CN+3) = PARAMETERS. * * EXIT (MTRJ) = MAXIMUM WAIT TO MONITOR EXCHANGE TIME. * * USES CN+3, CN+4, T1, T2, CM - CM+4. * * CALLS TIM, WXP. * * MACROS ISTORE. CPR SUBR ENTRY/EXIT STD CN+4 SET REQUEST CPRB SHN -14 * UJN CPR1 (1 CPU ONLY) LMC MXNI SET *MXN* INSTRUCTION STM MXN LPN 7 SET (A0) SHN 6 STM CPRA+3 CPR1 RJM WXP WAIT EXCHANGE PACKAGE READY LDD CN+3 SCN 77 CLEAR UNUSED FIELD STD CN+3 RJM TIM MAKE SURE *TIMB* EXCHANGE SWITCH RESET LDN PPXL SET *PP EXCHANGE PENDING* FLAG CWD HN IAN 14 SAVE CURRENT CLOCK VALUE STD T1 * ENTER REQUEST. SINCE THE MICROCODE FOR RUNNING DUAL-CPU * *NOS* ON A CACHE MACHINE CHECKS (B0) TO DETERMINE IF THE * EXCHANGE PACKAGE IS READY, THE WORD CONTAINING (B0) *MUST* * BE THE LAST WORD STORED INTO THE EXCHANGE PACKAGE. * OTHERWISE, IF A *PURGE ALTERNATE CACHE* REQUEST WAS BEING * PROCESSED BY MICROCODE AT THE SAME TIME THAT *MTR* WAS * PREPARING THE EXCHANGE PACKAGE, THE EXCHANGE COULD OCCUR * BEFORE THE EXCHANGE PACKAGE WAS READY. TLDC /EXPACS/MXP+10,XBP STORE (X0) CWD CN SBN 10 STORE (P), (A0), (B0) CWM CPRA,ON * EXCHANGE CPU. TO EXCHANGE CPU 1 ON A DUAL CPU CACHE MACHINE, * AN EXTERNAL INTERRUPT (*INPN*) IS USED INSTEAD OF AN *MXN*. * SINCE THE *INPN* DOES NOT WAIT FOR THE EXCHANGE TO SUCCEED * OR FAIL BEFORE COMPLETING, *MTR* MUST WAIT 25 MICROSECONDS * BEFORE CHECKING THE EXCHANGE PACKAGE. SINCE THE EXCHANGE MAY * OCCUR AFTER AN EVEN LONGER INTERVAL IN SOME CASES, *MTR* MUST * NEVER ABANDON AN ATTEMPT TO EXCHANGE CPU 1. SINCE THE *INPN* * WILL INTERRUPT A UEM BLOCK COPY EVEN IN MONITOR MODE, *MTR* * MUST DELAY 125 MICROSECONDS AFTER AN APPARENT FAILED EXCHANGE * BEFORE RETRYING, IF CPU 1 IS CURRENTLY IN MONITOR MODE. CPR2 UJN CPR3 EXCHANGE CPU * LDM CPRA+3 (DUAL CPU CACHE MACHINE) CON CPRA+3 CPRC EQU *-2 ZJN CPR3 IF EXCHANGING CPU 0 INPN 4 INTERRUPT PROCESSOR 1 ON PORT 2 CPRE LDN ** WAIT 25 MICROSECONDS BEFORE CHECKING SBN 1 NJN *-1 IF DELAY NOT COMPLETE TLDC /EXPACS/MXP+0,XBP CRD CM LDD CM+4 ZJN CPR4 IF EXCHANGE TAKEN CPRG LDC **+CMST+1 CHECK FOR CPU 1 IN MONITOR MODE CRD CM LDD CM+1 ADD CM+2 ADD CM+3 ADD CM+4 ZJN CPR5 IF CPU 1 NOT IN MONITOR MODE CPRH LDC ** WAIT 125 MICROSECONDS BEFORE RETRYING SBN 1 NJN *-1 IF DELAY NOT COMPLETE UJN CPR5 UPDATE TIME AND RETRY CPR3 TLDC /EXPACS/MXP+0,XBP EXCHANGE CPU MXN MXN 0 CRD CM READ (P), (A0), (B0) LDD CM+4 CPR4 ZJN CPR10 IF EXCHANGE TAKEN * ZJN CPR9 IF EXCHANGE TAKEN (CME MACHINE) CPRF EQU *-1 LDD CN+4 SBN NXWF MJN CPR10 IF NO WAIT FOR EXCHANGE REQUIRED CPR5 RJM TIM UPDATE TIME IAN 14 SBD T1 STD T2 PJN CPR6 IF NO ROLL OVER AOD T2 CPR6 ADC -MLSC MJN CPR7 IF NOT ONE MILLISECOND LDN 1 HAVE CPUMTR NOTE EXCHANGE REQUEST STD CM+4 LDN CPSL CWD CM CPR7 LDD T2 CHECK FOR MAXIMUM EXCHANGE WAIT SBM MTRJ MJN CPR8 IF NOT MAXIMUM RAM MTRJ UPDATE WORST-CASE *MXN* TIME CPR8 LJM CPR2 RETRY EXCHANGE CPR9 ISTORE TIMB,(UJN TIM6) SET UP EXCHANGE PACKAGE CHECK CPR10 LJM CPRX EXIT WXP SPACE 4,10 ** WXP - WAIT EXCHANGE PACKAGE READY. * * INSURES *CPUMTR* HAS EXITED FROM MONITOR MODE ON LAST CPR * REQUEST. ALSO ADVANCES TIME WHILE WAITING. * * EXIT (A) = 0. * * USES CM - CM+4. * * CALLS TIM. WXP SUBR ENTRY/EXIT WXP1 RJM TIM TLDC /EXPACS/MXP+6,XBP READ (MA), (A6), (B6) CRD CM LDD CM ADD CM+1 ZJN WXPX IF PACKAGE READY UJN WXP1 LOOP TITLE MEMORY ALLOCATION ROUTINES. *** MEMORY ALLOCATION. * * CENTRAL MEMORY IS ALLOCATED TO EACH CONTROL POINT IN * CONTIGUOUS BLOCKS FOR EACH JOB. UNALLOCATED MEMORY * GENERALLY RESIDES BETWEEN JOBS. IF A JOB REQUIRES MORE * MEMORY THAN IS AVAILABLE ABOVE IT-S CURRENT MEMORY, A * STORAGE MOVE IS REQUIRED. THE JOBS ARE MOVED ONE AT A * TIME TO MOVE THE REQUIRED AMOUNT OF UNALLOCATED MEMORY * TO THE REQUESTING JOB. MST SPACE 4,25 ** MST - MOVE STORAGE. * * *MST* WILL LOOP MOVING CONTROL POINTS UNTIL THE MOVE IS * COMPLETE, A CONTROL POINT CANNOT BE MOVED DUE TO PP ACTIVITY, * OR UNTIL 10B CONTROL POINTS HAVE BEEN MOVED. IF ANY OF * THESE CONDITIONS ARE ENCOUNTERED AN EXIT IS MADE SO THAT THE * THE ROUTINE WILL BE REENTERED. * * ENTRY (MM - MM+4) = MOVE PARAMETERS. * (OR+1) = REQUESTED FIELD LENGTH. * (OR+2) = XX00 IF CM REQUEST. * = XX01 IF ECS REQUEST. * (OR+3) = *CMRL*/*FLSW* IF CM REQUEST. * = *ECRL*/*ECSW* IF ECS REQUEST. * (OR+4) = 4 IF POSITIVE FL/ECS REQUEST. * = 0 IF NEGATIVE FL REQUEST. * * USES CP, T1, T5, MM+1, CM - CM+6, CN - CN+3, CS - CS+4, * OR - OR+4. * * CALLS AMV, AVC, CPR, ISR, MRP, PHE, SCP, STA, TIM. * * MACROS MONITOR. MSTX RJM MRP RETURN TO MAIN LOOP LDM CCPA NJN MSTX IF MOVE NOT COMPLETE * CHECK IF PP-S PAUSED. MST RJM TIM UPDATE TIME LDD MM.0 STD CP SET CP FOR MOVE RJM SCP ADN STSW GET CP STATUS CRD CS LDD OR+2 SET STORAGE TYPE LPN 1 STD T5 LDD CS CHECK CP STATUS LPN 37 ZJN MST3 IF NO PP-S ASSIGNED LMN 1 SHN 14 LMD CP CHECK IF MOVE OF REQUESTING CP LMD MM.3 NJN MST1 IF NOT ONLY REQUESTING PP LDD OR+2 LPC 200 ZJN MST3 IF NOT SPECIAL REQUEST MST1 LDN PPXE SET PP1 *ACPP* OFFSET STD T1 MST2 LDN PPXE ADVANCE TO NEXT PP RAD T1 TADC ACPP,PPX READ CP/PCP ASSIGNMENT CRD CM TLMC ACPP,PPX (LAST *ACPP* WORD + *PPXE*) MSTA EQU *-1 MST3 ZJN MST6 IF END OF SCAN LDD CM LMD MM.0 NJN MST2 IF PP NOT ACCESSING MOVE CP/PCP ** IMPORTANT NOTE - * * ALL MONITOR FUNCTIONS SHOULD BE CONSIDERED STORAGE MOVABLE * WHILE THE REQUEST IS PENDING. THEREFORE, PP ROUTINES * SHOULD RECOMPUTE ANY ABSOLUTE ADDRESSES AFTER ISSUING ANY * MONITOR FUNCTION. THIS WILL ALLOW FOR THE FUTURE GOAL OF * ACTUALLY ACHIEVING THIS OBJECTIVE. LDD T1 SET PP COMMUNICATION AREA OFFSET SHN PPCES-PPXES ADD OF READ OUTPUT REGISTER CRD CM LDD CM ZJN MST5 IF NO FUNCTION SHN 21-10 MJN MST2 IF STORAGE MOVE ALLOWED SHN 10-21 SBN SMAM MJN MST5 IF NON-MOVABLE *MTR* FUNCTION SBN SMEM-SMAM MJN MST2 IF MOVABLE FUNCTION MST5 RJM AVC LJM MSTX RETURN * CP READY TO MOVE. MST6 LDD MM.0 SET CP/PCP ADDRESS RJM SCP ADD OR+3 GET FL CONTROL WORD CRD CS SBD OR+3 ADN ECSW CHECK *ECXM* INTERLOCK CRD CM LDD CM+1 SHN 21-13 MJN MST5 IF *ECXM* IN PROGRESS LDD MM.0 RJM STA FETCH MEMORY TABLE ENTRY CRD CM LDD CM+1 CHECK FORWARD LINK LMD NC NJN MST9 IF NOT LAST CP LDD MM.1 SHN 21-13 PJN MST9 IF UPWARD MOVE LDD OR+2 SHN 21-7 PJN MST7 IF NOT SPECIAL REQUEST LDN 0 UJN MST8 SAVE INCREMENT MST7 LDM CS,OR+4 MOVE DOWN BY INCREASE MST8 SBD OR+1 STD MM.1 MST9 LDD CS+4 CHECK CURRENT FL ADD CS NJN MST11 IF FL .NE. 0 * UPDATE RA FOR CONTROL POINT IF FL = 0. STD CN+3 LDD MM.1 SET MEMORY INCREMENT STD CN LDD T5 STORAGE TYPE STD CN+1 LDN MRAF MODIFY REFERENCE ADDRESS RJM ISR RJM AMV ADVANCE MOVE LDD MM.4 ZJN MST10 IF MOVE COMPLETED CRD OR LJM MST LOOP MST10 LJM FNR EXIT * INITIATE STORAGE MOVE. MST11 LDN 0 PRESET NO CPU STATUS STD CM+1 LDD MM.0 CHECK CP AT MOVE SBD NC PJN MST13 IF PSEUDO CONTROL POINT LDN SMRL CWD CP-4 SET *JAV* INTERLOCK MONITOR DCPM LDD CM+1 SAVE CPU STATUS FROM *DCPM* STM MSTE LDD CP GET CPA ERROR FLAG SHN 7 ADN STSW CRD CS LDD CS+1 LPN 37 LMN PEET NJN MST12 IF NOT PARITY ERROR MSTC RJM PHE VALIDATE PARITY ERROR * UJN *+2 (NO S/C REGISTER OR SIMULATOR) NJN MST15 IF ERROR IN SCR MST12 LDC 0 SET CPU STATUS MSTE EQU *-1 STD CM+1 MST13 LDD MM.1 SET MOVE INCREMENT STD CM LDC 0 SET/CLEAR BLOCK MOVE MSTG EQU *-1 STD CM+2 LDN 0 CLEAR BLOCK MOVE INDICATOR STM MSTG LDD T5 INSERT MEMORY TYPE STD CM+3 LDD CP SET CONTROL POINT NUMBER STD CM+4 LDN SMRL STORE MOVE REQUEST CWD CM LDC 0 SET MOVE IN PROGRESS FLAG ORG *-1 LOC CCPA UJN CCP6 STORAGE MOVE IN PROGRESS LOC *O STM CCPA LDM MAFC,CM+3 REQUEST STORAGE MOVE STD CN+2 LDN EPRF ENTER PROGRAM MODE REQUEST RJM CPR LJM MSTX RETURN * SET STORAGE UNAVAILABLE WHEN FATAL ERROR SET. MST15 LDC FNC SET RETURN FOR COMPLETING MOVE STM AMV LDN SMRL CLEAR *SMRL* CWD ZR LJM AMV10 COMPLETE MOVE * COMPLETE MOVE PROCESSING. * * ENTRY (CM - CM+4) = (SMRL). MSTX. LJM * RETURN EXIT COMPLETION CODE MST. EQU *-1 LDD CM+1 ZJN MST16 IF NO ERROR ON MOVE LDD MM.0 RJM SCP SET CP / PCP ADDRESS ADN TFSW CRD CM+2 (CM+2) = EJT ORDINAL LDN 0 STD CP INDICATE REQUEST FROM CP 0 LDC 4000+ECET STD CM+1 SET ERROR FLAG MONITOR CEFM * LDN 0 CLEAR MOVE IN PROGRESS FLAG MST16 STM CCPA LDD MM.0 SET MOVE CP / PCP STD CP LDD MM.4 RE-READ OUTPUT REGISTER CRD OR LDD OR+2 RESET STORAGE TYPE LPN 1 STD T5 RJM AMV ADVANCE MOVE UJN MSTX. RETURN AMF SPACE 4,15 ** AMF - ADJUST MACHINE FL. * * ENTRY (A) = 10, TO UPDATE *MABL*, *ACML*, AND MCT OF LAST CP. * (A) = 11, TO UPDATE MCT OF LAST CP ONLY. * (OR+1) = MEMORY DECREMENT (IF POSITIVE). * (OR+1) = MEMORY INCREMENT (IF NEGATIVE). * * USES CN, CN+1. * * CALLS CPR, WXP. AMF SUBR ENTRY/EXIT STD CN+1 SAVE REQUEST TYPE LDD OR+1 SET MEMORY INCREMENT/DECREMENT STD CN LDN MFLF MODIFY MACHINE FL RJM CPR ISSUE REQUEST RJM WXP WAIT FOR REQUEST TO COMPLETE UJN AMFX RETURN AMM SPACE 4,25 ** AMM - ACCUMULATE MEMORY TO MOVE. * * ENTRY (A) = ADDRESS OF ORDINAL OF MCT ENTRY. * (T3) = UNASSIGNED MEMORY ACCUMULATOR. * (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * (T7) = AMOUNT OF MEMORY REQUIRED. * (OR+3) = *FLSW* IF CM REQUEST. * = *ECSW* IF XM REQUEST. * (MM+1) = MOVE COUNT ACCUMULATOR. * (MM+4) = ASSIGNED MEMORY ACCUMULATOR. * * EXIT (A) = INITIAL MOVE INCREMENT. * (MM+3) = ASSIGNED MEMORY TO MOVE. * (CS) = FIRST CP/PCP FOR LOWER MOVE. * (CS+1) = FIRST CP/PCP FOR UPPER MOVE. * (CS+2) = FIRST LOWER MOVE INCREMENT. * (CS+3) = FIRST UPPER MOVE INCREMENT. * (CS+4) = NUMBER OF CP/PCP-S TO MOVE. * * USES BA, PA, MM+1, MM+2, MM+4, T3, CN - CN+4. * * CALLS RSB, SCP, TIM. AMM5 LDD CS+4 RESET MOVE COUNT FOR REENTRY STD MM+1 LDD MM+3 RESET MOVE BLOCKS FOR REENTRY STD MM+4 LDN 0 INDICATE SEARCH INCOMPLETE AMM SUBR ENTRY/EXIT STD PA LPN 1 ADN CM SET ADDRESS OF BACKWARD/FORWARD LINK STD BA AMM1 LDI PA SET CP/PCP AREA ADDRESS RJM SCP ADD OR+3 GET FL CONTROL WORD CRD CN LDD CN+4 ACCUMULATE MEMORY TO MOVE ADD CN ZJN AMM4 IF NO ASSIGNED MEMORY RAD MM+4 SHN -14 ZJN AMM2 IF NO OVERFLOW LCN 0 STD MM+4 SET MAXIMUM MEMORY AMM2 AOD MM+1 AMM3 MJN AMM1 IF MORE MEMORY REQUIRED AMM4 LDI PA ZJN AMM5 IF END OF MCT SCAN STD MM+2 LDI BA SAVE LINK STM AMMA RJM TIM UPDATE CLOCK LDC ** READ MCT ENTRY AMMA EQU *-1 RJM RSB ZJN AMM1 IF NO UNASSIGNED MEMORY FOUND * ACCUMULATE UNASSIGNED MEMORY. LDD MM+2 SET CP/PCP FOR MOVE STM CS-CM,BA LDD MM+1 SAVE MOVE COUNT STD CS+4 LDD MM+4 SAVE BLOCKS TO MOVE STD MM+3 LDD T0 SAVE BLOCK SIZE STM CS+2-CM,BA RAD T3 ACCUMULATE UNASSIGNED MEMORY SBD T7 MJN AMM3 IF MORE MEMORY REQUIRED SBD T0 LMC -0 SET PARTIAL BLOCK STM CS+2-CM,BA LJM AMMX RETURN AMV SPACE 4,20 ** AMV - ADVANCE MOVE. * * ENTRY (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * (OR+1) = REQUESTED MEMORY. * (OR+2) = *RSTM* FLAGS. * (OR+3) = *CMRL*/*FLSW* IF CM REQUEST. * = *ECRL*/*ECSW* IF ECS REQUEST. * (OR+4) = 4 IF POSITIVE FL/ECS REQUEST. * = 0 IF NEGATIVE FL REQUEST. * (MM - MM+4) = MOVE PARAMETERS. * * EXIT (MM - MM+4) UPDATED. * *MABL* AND *ACML* ADJUSTED, IF SPECIAL *VER* REQUEST. * * USES CP, T4, CN - CN+4, CS - CS+4, MM - MM+4. * * CALLS AMF, MFL, RSB, SCP. AMV8 LDD MM.3 REQUESTING CP NUMBER STD CP RJM SCP SET CP ADDRESS ADD OR+3 CRD CS RJM MFL LDD OR+2 SHN 21-7 PJN AMV9 IF NOT *VER* SPECIAL REQUEST LDN 10 SET REQUEST TYPE RJM AMF ADJUST MACHINE FL LDK MABL READ NEW *MABL* CRD CN LDD CN+2 SAVE NEW SIZE FOR COMPLETION BIT TESTING STM PCBA LDD CN+3 STM PCBB AMV9 LDD MM.4 SET *RSTM* COMPLETE CWD ZR AMV10 LDD MM.4 EXTRACT REENTRY TABLE INDEX SHN -3 STD MM.4 LDC PPR RESET MAIN LOOP STM TREA,MM.4 * STM TREA-(OF)/10,MM.4 AMVC EQU *-1 LDN ZERL CLEAR MOVE PARAMETERS CRD MM LCN 0 SET MOVE COMPLETE STD MM.0 AMVX LDN CMCL STORE CONTROL WORD CWD MM RJM PCM PURGE CACHE IF CPU 1 IN MONITOR MODE LJM * RETURN EXIT AMV EQU *-1 LDD MM.0 GET MCT ENTRY FOR MOVE CP RJM RSB STD T4 LDD CM+1 CHECK FORWARD LINK LMD NC ZJN AMV4 IF LAST CP LDD MM.1 SHN 6 MJN AMV5 IF DOWNWARD MOVE LDD MM.0 LMD MM.3 ZJN AMV3 IF REQUESTING CP JUST MOVED LDD CM STD MM.0 SET NEXT CP/PCP FOR MOVE LMD MM.3 NJN AMV1 IF UPPER MOVE NOT COMPLETE LDD OR+4 NJN AMV3 IF NOT NEGATIVE FL REQUEST AMV1 LDD MM.0 RJM RSB FETCH NEXT MOVE INCREMENT AMV2 STD MM.1 UJP AMVX RETURN * BEGIN LOWER MOVE. AMV3 LDC 0 INITIAL LOWER MOVE INCREMENT AMVA EQU *-1 ZJN AMV4 IF NO LOWER MOVE STD T4 LDD MM.2 NJN AMV6 IF NOT CMR REQUEST AMV4 LJM AMV8 COMPLETE MOVE * ADVANCE LOWER MOVE. AMV5 LDD MM.0 CHECK CP/PCP JUST MOVED LMC 0 AMVB EQU *-1 ZJN AMV4 IF REQUESTING CP LDD CM+1 AMV6 STD MM.0 SET NEXT CP/PCP FOR MOVE LMD MM.3 NJN AMV7 IF LOWER MOVE NOT COMPLETE LDD OR+4 ZJN AMV4 IF NEGATIVE FL REQUEST AMV7 LCN 0 NEXT MOVE INCREMENT LMD T4 UJN AMV2 SET NEGATIVE INCREMENT CFL SPACE 4,10 ** CFL - CLEAR FL INCREASE. * * ENTRY (CP) = CONTROL POINT NUMBER. * (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * * USES CM - CM+4. * * CALLS SCP. CFL1 LDN 0 CLEAR ECS INCREASE STD CM+3 LDD CM+1 SCN 2 CFL2 STD CM+1 LDD CP SET CP/PCP ADDRESS RJM SCP ADN FLIW REWRITE FL INCREASE CONTROL WORD CWD CM CFL SUBR ENTRY/EXIT LDD CP ZJN CFLX IF CMR REQUEST RJM SCP ADN FLIW READ FL INCREASE WORD CRD CM LDD T5 NJN CFL1 IF XM REQUEST STD CM+2 STD CM+4 CLEAR FL INCREASE LDD CM+1 SCN 1 UJN CFL2 REWRITE FL INCREASE CONTROL WORD CRA SPACE 4,15 ** CRA - CHANGE REFERENCE ADDRESS. * * ENTRY (CP) = CP/PCP NUMBER. * (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * (T8) = MCT ORDINAL OF HOLE. * (OR+2) = *RSTM* FLAGS. * * USES CP, CN - CN+4. * * CALLS ISR. CRA1 LDD T8 SET MCT ORDINAL OF HOLE STD CN CRA2 LDD T5 INSERT STORAGE TYPE STD CN+1 LDN CRAF CHANGE RA IN CPA, XP AND MCT RJM ISR CRA SUBR ENTRY/EXIT LDD OR+2 SCN 77 PRESERVE PCP FLAGS STD CN+3 SHN 21-12 PJN CRA1 IF NOT PSEUDO-ROLLOUT LDD CP STD CN LDD T8 SET (CP) TO PCP NUMBER STD CP UJN CRA2 COMPLETE REQUEST EMO SPACE 4,15 ** EMO - EVALUATE MOVE OPTIONS. * * ENTRY (T8) = MCT ORDINAL OF HOLE. * (CS - CS+4) = FL CONTROL WORD OF REQUESTING CP. * * EXIT TO CALLER IF NO FIELD LENGTH ASSIGNED. * TO *MST* TO INITIATE MOVE IF FL PRESENT. * * USES MB, MM - MM+4. * * CALLS IMV. EMO5 LDD T8 ZJN EMO2 IF NO HOLE FOUND EMO SUBR ENTRY/EXIT LDD CS ADD CS+4 ZJN EMO1 IF NO ASSIGNED FL SHN -MBCS ADN 1 CONVERT MEMORY MOVE COUNT EMO1 STD MB ZJN EMO5 IF NEW JOB / NEW XM REQUEST * INVESTIGATE INCREMENTAL MOVE. EMO2 RJM IMV INITIATE MOVE LDD CS+4 SBD MB MJN EMO4 IF INCREMENTAL CHEAPER THAN BLOCK MOVE LDD T8 ZJN EMO4 IF NO HOLE FOUND STM MSTG LDD MM.3 SET CP FOR MOVE STD MM.0 * LDN 1 FAKE POSITIVE MOVE INCREMENT STD MM.1 EMO3 LDN 0 CLEAR LOWER MOVE STD MM.2 EMO4 LDD OA SET REQUESTING PP OR ADDRESS STD MM.4 LDN CMCL STORE MOVE CONTROL WORD CWD MM RJM PCM PURGE CACHE IF CPU 1 IN MONITOR MODE LJM MST MOVE STORAGE IMV SPACE 4 ** IMV - INITIATE INCREMENTAL MOVE. * * ENTRY (CP) = CONTROL POINT NUMBER / MCT ORDINAL. * (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * (T6) = MCT ORDINAL IF NORMAL FL OR XM REQUEST. * = ORDINAL OF BACKWARD LINK IF NFL REQUEST. * (T7) = AMOUNT OF MEMORY REQUIRED. * (OR+4) = 4 IF POSITIVE FL OR XM REQUEST. * = 0 IF NEGATIVE FL REQUEST. * * EXIT (CS+4) = MOVE OVERHEAD COUNT. * (MM - MM+3) SET UP FOR FIRST MOVE. * * USES MB+1, T2, T3, T4, CM - CM+4, CS - CS+4, MM - MM+4. * * CALLS AMM, RSB, STA, TIM. * * ERROR EXIT TO *HGM* IF MOVE CANNOT BE COMPLETED. IMV SUBR ENTRY/EXIT LDN ZERL CRD CS LDD T6 FETCH UNASSIGNED MEMORY BLOCK RJM RSB STD T3 SET HOLE SIZE ABOUT THIS CP LDD CM+1 STD T4 SAVE FORWARD LINK * COMPUTE UPPER + LOWER MOVE. LDN CM+1 ACCUMULATE MEMORY FOR UPPER MOVE RJM AMM NJN IMV2 IF REQUEST SATISFIED WITH UPPER MOVE LDD T6 STD T2 RJM STA GET MCT ENTRY CRD CM LDN T2 ACCUMULATE MEMORY FOR LOWER MOVE RJM AMM NJN IMV2 IF MOVE CAN BE COMPLETED IMV1 RJM HGM HANG *MTR* (NO RETURN) IMV2 LDD MM+3 CONVERT MOVE MEMORY TO COUNT SHN -MBCS RAD CS+4 APPEND TO MOVE COUNT STD MB+1 RJM TIM UPDATE CLOCK LDN CMCL CRD MM CWD CS SAVE COMPUTED VALUES LDD CP SBN 2 MJN IMV5 IF CMR REQUEST OR CP 1 * COMPUTE LOWER + UPPER MOVE. LDD T6 GET UNASSIGNED MEMORY BLOCK RJM RSB STD T3 SET HOLE SIZE ABOUT THIS CP LDN ZERL CRD CS LDN T2 ACCUMULATE MEMORY FOR LOWER MOVE RJM AMM NJN IMV3 IF REQUEST SATISFIED WITH LOWER MOVE LDD T4 STD CM+1 LDN CM+1 ACCUMULATE MEMORY FOR UPPER MOVE RJM AMM ZJN IMV1 IF MOVE CANNOT BE COMPLETED IMV3 LDD MM+3 SHN -MBCS CONVERT MOVE MEMORY TO COUNT RAD CS+4 * COMPARE OVERHEAD OF UPPER/LOWER VS LOWER/UPPER MOVES. SBD MB+1 MJN IMV4 IF LOWER/UPPER MOVE CHEAPER LDN CMCL CRD CS RESET UPPER/LOWER PARAMETERS IMV4 RJM TIM IMV5 LDD CS+1 NJN IMV6 IF UPPER MOVE PRESENT STD MM.2 LDD CS SET INITIAL CP/PCP FOR LOWER MOVE STD MM.0 LDD CS+2 DEFINE NEGATIVE INCREMENT LMC -0 UJN IMV7 SET INCREMENT IMV6 STD MM.0 SET INITIAL CP/PCP FOR UPPER MOVE LDD CS STD MM.2 SET INITIAL CP/PCP FOR LOWER MOVE LDD CS+2 STM AMVA SET INITIAL LOWER MOVE INCREMENT LDD CS+3 IMV7 STD MM.1 SET MOVE INCREMENT LDD CP STD MM.3 SET REQUESTING CP STM AMVB LJM IMVX RETURN ISR SPACE 4,15 ** ISR - ISSUE STORAGE REQUEST. * * ENTRY (A) = MONITOR FUNCTION. * (CP) = CONTROL POINT NUMBER. * (CN, CN+1, CN+3) = PARAMETERS. * * EXIT (A) = 0. * * USES CN - CN+4. * * CALLS CPR, TIM. ISR SUBR ENTRY/EXIT STM ISRA LDD CP SET CP NUMBER IN X0 IMAGE STD CN+2 LDN 0 CLEAR UNUSED BYTE STD CN+4 LDN SMRL STORE FUNCTION IN PROGRESS CWD CN LDC 10000 ISSUE *CPUMTR* REQUEST ISRA EQU *-1 RJM CPR ISR1 RJM TIM UPDATE TIME LDN SMRL CRD CN GET FUNCTION STATUS LDD CN NJN ISR1 IF NOT COMPLETE * LDN 0 UJN ISRX RETURN MFL SPACE 4,20 ** MFL - MODIFY FIELD LENGTH. * * ENTRY (CP) = CONTROL POINT NUMBER. * (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * (OR+1) = NEW FIELD LENGTH. * (OR+2) = *RSTM* FLAGS. * (OR+3) = *CMRL*/*FLSW* IF CM REQUEST. * = *ECRL*/*ECSW* IF ECS REQUEST. * (OR+4) = 4 IF POSITIVE FL/ECS REQUEST. * = 0 IF NEGATIVE FL REQUEST. * (CS - CS+4) = FL STATUS. * * USES CM - CM+4, CN - CN+4. * * CALLS CFL, CPR, ISR, SCP, WXP. * * ERROR EXIT TO *HGM* IF CMR SIZE .GE. MCMR*100B. MFL4 LDD CP SET CP/PCP NUMBER STD CN+2 LDN 0 CLEAR UNUSED FIELDS STD CN+4 LDN SMRL SET REQUEST IN PROGRESS CWD CN MFL5 LDD CP FORM CP/PCP AREA ADDRESS RJM SCP ADN STSW GET STATUS WORD CRD CM LDD CM CHECK CPU STATUS SHN -11 LMN ACPS ZJN MFL6 IF ACTIVITY IN CPU - 0 LDC 10000 MFL6 LMN MFLF MODIFY FIELD LENGTH RJM CPR RJM WXP WAIT REQUEST COMPLETE LDN SMRL CRD CN FETCH REQUEST STATUS LDD CN NJN MFL5 IF CHANGE NOT MADE MFL SUBR ENTRY/EXIT LDD OR+2 LPC 1S11+1S10+1S7 NJN MFLX IF SPECIAL REQUEST STD CN+3 LDD CP NJN MFL2 IF NOT CMR REQUEST LDD OR+1 SBK MCMR MJN MFL3 IF REQUEST .LT. MCMR*100B MFL1 RJM HGM HANG *MTR* (NO RETURN) MFL2 RJM CFL CLEAR FL INCREASE REQUEST MFL3 LDD OR+1 SBM CS,OR+4 SET MEMORY INCREMENT STD CN ZJN MFLX IF NO CHANGE LDD OR+4 SHN 6 SET TYPE OF FL + TYPE OF MEMORY LMD T5 STD CN+1 MFLA LJM MFL4 (DUAL CPU) * LDN MFLF (SINGLE CPU) * RJM ISR CON ISR UJP MFLX RETURN PVE SPACE 4,20 ** PVE - PROCESS SPECIAL REQUEST. * * ENTRY (T5) = 0 IF CM REQUEST. * (T5) = 1 IF XM REQUEST. * (OR+1) = REQUESTED MEMORY INCREMENT. * (OR - OR+4) = UPDATED OUTPUT REGISTER. * * EXIT (A) .GT. 0 IF INCREASE. * .LT. 0 IF DECREASE. * (CP) = LAST CONTROL POINT. * (T6) = MCT ORDINAL OF LAST CONTROL POINT. * (T7) = AMOUNT OF INCREASE / DECREASE. * (CS - CS+4) = FL CONTROL WORD FOR LAST CONTROL POINT. * * USES CP, T6, T7, CM - CM+4, CS - CS+4. * * CALLS AMF, HNG, SCP. PVE2 LDN ** SET CP TO LAST CONTROL POINT * LDN (NC)-1 PVEA EQU *-1 STD CP STD T6 RJM SCP READ FL CONTROL WORD ADD OR+3 CRD CS LDD OA STORE OUTPUT REGISTER CWD OR LDD OR+1 SET MEMORY INCREMENT STD T7 SHN 21-13 CHECK REQUEST TYPE PJN PVEX IF *VER* REQUESTING MEMORY LDN 11 SET REQUEST TYPE RJM AMF SET UNASSIGNED MEMORY AFTER LAST CP LCN 1 INDICATE *VER* RETURNING MEMORY PVE SUBR ENTRY/EXIT LDD OA VERIFY CALLER SBN 1 CRD CM LDD CM+1 SCN 77 SHN 6 LMD CM LMC 3RRVE ZJN PVE2 IF CALLER IS *VER* PVE1 RJM HNG HANG PP RSB SPACE 4,15 ** RSB - RETURN SIZE OF UNASSIGNED MEMORY BLOCK. * * ENTRY (A) = ORDINAL OF MCT ENTRY. * (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * * EXIT (A) = (T0) = BLOCK SIZE. * (T2) = ORDINAL OF MCT ENTRY. * (CM - CM+4) = MCT ENTRY. * * USES T0, T2, CM - CM+4. * * CALLS STA. * * ERROR TO *HGM* IF MCT ENTRY DESTROYED. RSB2 LDC 3777 RETURN MAXIMUM MEMORY RSB3 STD T0 RSB SUBR ENTRY/EXIT STD T2 RJM STA FETCH MCT ENTRY CRD CM LDD CM+3 VERIFY ENTRY SHN 21-13 MJN RSB1 IF MCT ENTRY BAD SHN 14-6 LMD CM+4 CHECK UNASSIGNED MEMORY SBK 3777 PJN RSB2 IF .GE. MAXIMUM FOR JOB LDD CM+4 UJN RSB3 RETURN RSB1 RJM HGM HANG *MTR* (NO RETURN) SCP SPACE 4,10 ** SCP - SET CP/PCP AREA ADDRESS. * * ENTRY (A) = CP/PCP NUMBER. * (NC) = SYSTEM CP NUMBER. * * EXIT (A) = CPA/PCPA ADDRESS. SCP1 ADD NC SET REAL CP AREA ADDRESS SHN 7 SCP SUBR ENTRY/EXIT SBD NC MJN SCP1 IF REAL CP ZJN SCP1 IF SYSTEM CP SHN 7 ADC 0 ADD BASE PCPA ADDRESS - CPA LENGTH SCPA EQU *-1 UJN SCPX RETURN SFL SPACE 4,15 ** SFL - SET FL INCREASE. * * ENTRY (CP) = CONTROL POINT NUMBER. * (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * (OR+1) = FL TO SET FOR INCREASE. * (OR+4) = 0 IF NEGATIVE FL REQUEST. * (CS - CS+4) = CP FL STATUS WORD. * * USES CM - CM+4. * * MACROS MONITOR. SFL5 LDD OR+1 SET XM FL REQUIRED STD CM+3 SFL6 LDD CP SET CP ADDRESS SHN 7 ADN FLIW REWRITE FL INCREASE CONTROL WORD CWD CM LDN 0 CLEAR INPUT FILE SCHEDULING FLAG STD CM+2 MONITOR RSJM REQUEST JOB SCHEDULER SFL SUBR ENTRY/EXIT LDD OR+2 SHN 21-6 PJN SFLX IF DO NOT SET *FLIW* LDD CP SHN 7 ADN FLIW READ FL INCREASE CONTROL WORD CRD CM LDD T5 NJN SFL5 IF XM REQUEST LDD CM+4 ZJN SFL4 IF NO CM INCREASE PENDING LDD OR+4 ZJN SFL2 IF NFL REQUEST SFL1 LDD CS UJN SFL3 COMPUTE TOTAL CM FL SFL2 LDD CM+2 NJN SFLX IF REISSUE OF NFL REQUEST LDD OR+1 SBD CS STD CM+2 COMPUTE NFL INCREASE AMOUNT LDD CM+4 SBD CS SFL3 ADD OR+1 STD CM+4 LJM SFL6 REWRITE FL INCREASE CONTROL WORD SFL4 LDD OR+4 NJN SFL1 IF NOT NFL INCREASE LDD OR+1 SBD CS STD CM+2 COMPUTE NFL INCREASE LDD CS+4 UJN SFL3 ADD NFL TO CM FL STA SPACE 4,10 ** STA - SET MEMORY CONTROL TABLE ADDRESS. * * ENTRY (A) = CP/PCP NUMBER. * (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * * EXIT (A) = ABSOLUTE TABLE ADDRESS. STA SUBR ENTRY/EXIT SHN 1 ADC 0 APPEND BASE MCT ADDRESS STAA EQU *-1 ADD T5 UJN STAX RETURN UFL SPACE 4,20 ** UFL - SET UNASSIGNED FIELD LENGTHS. * * ENTRY (CP) = CP/PCP NUMBER. * (NC) = SYSTEM CP NUMBER. * (T5) = 0 IF CM REQUEST. * = 1 IF XM REQUEST. * (T7) = AMOUNT OF MEMORY REQUIRED. * (OR+4) = 0 IF NFL REQUEST. * (CS - CS+4) = FL CONTROL WORD OF REQUESTING CP. * * EXIT (A) .LT. 0 IF MEMORY UNAVAILABLE. * (T8) = MCT ORDINAL OF MEMORY HOLE. * * USES T1, T3, T4, T7, T8, CM - CM+4, CN - CN+4. * * CALLS RSB, TIM. UFL11 LDD T4 NJN UFL12 IF CP HAS MEMORY ASSIGNED LDD OR+4 ZJN UFL12 IF NFL REQUEST LDN MSCL GET MEMORY PAD SIZE CRD CN LDD T7 CHECK REQUEST SIZE ADD CN+4 SBK 3770 MJN UFL12 IF REQUEST SHORT ENOUGH TO PAD LDN 0 STD CN+4 UFL12 LDD CM CHECK CENTRAL MEMORY SHN 14 LMD CM+1 TOTAL UNASSIGNED MEMORY UFL13 SBD T7 PJN UFL1 IF SUFFICIENT TO SATISFY REQUEST UFL SUBR ENTRY/EXIT LDD CS ADD CS+4 TOTAL ASSIGNED MEMORY STD T4 LDN ACML FETCH UNASSIGNED MEMORY COUNT CRD CM LDN 0 CLEAR MEMORY ASSIGNMENT PAD STD CN+4 STD T8 SET MEMORY HOLE NOT FOUND LDD T5 ZJN UFL11 IF REQUEST FOR CENTRAL MEMORY LDD CM+3 UJN UFL13 CHECK UNASSIGNED EXTENDED MEMORY UFL1 SBD CN+4 PJN UFL3 IF SUFFICIENT MEMORY FOR REQUEST + PAD ADD CN+4 SBD T4 PJN UFL6 IF ENOUGH MEMORY TO WARRANT HOLE SEARCH UFL2 LDN 0 UJN UFLX RETURN UFL3 SBD T4 PJN UFL5 IF HOLE SEARCH FOR REQUEST + PAD LDD CN+4 RAD T7 UFL4 UJN UFLX RETURN UFL5 LDD CN+4 APPEND PAD TO REQUEST RAD T7 UFL6 LDD OR+4 ZJN UFLX IF NFL REQUEST LDD CP SBN 2 MJN UFL2 IF CMR OR CP 1 ADN 3 LMD NC UFL7 ZJN UFL4 IF LAST REAL CP LDD T7 RAD T4 INCLUDE CURRENT INCREASE LDC 0 UFLA EQU *-1 (NUMBER OF MCT ENTRIES) SBN 3 STD T1 LDN 1 INITIALIZE FORWARD LINK STD CM+1 LCN 0 PRESET HOLE SIZE STD T3 UFL8 LDD CM+1 SAVE FORWARD LINK STM UFLB RJM TIM UPDATE CLOCK LDC ** UFLB EQU *-1 RJM RSB SBD T4 MJN UFL9 IF HOLE NOT FOUND SBD T3 PJN UFL9 IF THIS HOLE LARGER RAD T3 LDD T2 SAVE ORDINAL OF HOLE STD T8 LDD T0 CHECK HOLE SIZE SBD T4 ZJN UFL7 IF EXACT FIT UFL9 SOD T1 ZJN UFL7 IF SCAN COMPLETE UJN UFL8 CHECK NEXT MCT ENTRY SPACE 4,10 * MEMORY ALLOCATION ADDRESSES / FUNCTIONS. MAFA CON FLSW,ECSW MAFC CON MSTF,MECF ERRNZ FLSW-CMRL ERRNZ ECSW-ECRL TITLE SUBROUTINES. ACP SPACE 4 ** NOTE - SUBROUTINES WILL NOT ALTER OA, CP, OR - OR+4. CDA SPACE 4,15 ** CDA - CLEAR DEVICE ACTIVITY. * * ENTRY (T4 - CM) = *DSWM* PARAMETERS FROM MESSAGE BUFFER. * (CS) = UNIT TO WRITE TO *DRQP*. * (CN - CN+4) = DEVICE ACTIVITY WORD. * * EXIT PP ACTIVITY WORD WRITTEN. * (PR) = PP NUMBER WAITING FOR THE UNIT BEING RELEASED. * * USES CM, CN, CN+1, CN+3, PR. * * MACROS MSTA. CDA6 LDD PP STORE *DRQP* SHN PPXES TADC DRQP,PPX CWD CS CDA SUBR ENTRY/EXIT LDD CM CLEAR *CHRV* CHANNEL STATUS SCN 11 STD CM LDM TPPI,PP ZJN CDA6 IF NO INTERLOCK HELD SCN 1 ZJN CDA3 IF NO INTERLOCK SET LMD CN+1 STD CN+1 SHN -13 NJN CDA2 IF FIRST UNIT NOT FREE LDD PR NJN CDA1 IF REQUEST FOR CHANNEL BY OTHER UNIT LDD CN+3 ZJN CDA3 IF UNIT NOT REQUESTED STD PR CDA1 LDN 0 CLEAR UNIT REQUEST STD CN+3 CDA2 LDN 0 CDA3 STM TPPI,PP LDD CN+1 SCN 17 NJN CDA4 IF OTHER LOGICAL RESERVE(S) STILL SET LDN 1 STD CN+1 CLEAR *DALL* UPDATE INTERLOCK CDA4 SOD CN SHN 21-5 PJN CDA5 IF NO UNDERFLOW SHN 5-21+22 ADN 1 FIX UNDERFLOW PROBLEM STD CN CDA5 MSTA DALL,PP UPDATE DEVICE ACTIVITY CWD CN LJM CDA6 RETURN CFS SPACE 4,10 ** CFS - CHECK FOR STEP CRITERION MET. * * ENTRY (A) = POINTER TO OUTPUT REGISTER. * (CM - CM+4) = INPUT REGISTER. * * EXIT (A) = 0 IF STEP CRITERION MET BY THIS PPU. * * USES T3, CM - CM+4. CFS SUBR ENTRY/EXIT STD T3 SAVE OUTPUT REGISTER ADDRESS LDD CM+1 LPN 37 SHN 7 ADN TFSW READ CALLING CP EJT ORDINAL CRD CM LDC 0 EJT ORDINAL TO STEP CFSA EQU *-1 ZJN CFS1 IF NOT EJT ORDINAL STEP LMD CM ZJN CFS1 IF CORRECT EJT ORDINAL LDD T3 SBD OF SHN PPXES-PPCES TADC ACPP,PPX CRD CM GET ALTERNATE CP/PCP ASSIGNMENT IF PRESENT LDD CM+1 SHN 14 ADD CM+2 ADK TFSW READ POSSIBLE ALTERNATE CP/PCP EJT ORDINAL CRD CM LDD CM LMM CFSA NJN CFSX IF NOT CORRECT EJT ORDINAL CFS1 LDC ** FUNCTION TO STEP CFSB EQU *-1 ZJN CFSX IF NO FUNCTION TO STEP LMI T3 LPC 177 NJN CFS2 IF INCORRECT FUNCTION LDM **,T3 CFSC EQU *-1 BYTE NUMBER STEPING ON LMC ** BYTE VALUE TO STEP ON CFSD EQU *-1 CFS2 LJM CFSX RETURN FTN SPACE 4,15 ** FTN - PROCESS MONITOR FUNCTION. * * ENTRY (A) = FUNCTION. * (CP) = CONTROL POINT NUMBER. * (CM+1 - CM+4) = PARAMETERS. * * EXIT (CM - CM+4) = RESPONSE. * (A) = 0. * * USES CN - CN+4. * * CALLS AVC, CPR. FTN4 LDN ZERL INITIALIZE *ACPP* CRD CN LDD CP SET CONTROL POINT NUMBER STD CN SHN 7 SET CONTROL POINT ADDRESS STD CN+2 STD CN+4 TLDC ACPP,PPX WRITE *ACPP* CWD CN LDD OF WRITE OUTPUT REGISTER CWD CM FTNB LMC 0 MERGE CPU NUMBER RJM CPR FTN5 RJM AVC ADVANCE CLOCK LDD OF READ OUTPUT REGISTER CRD CM LDD CM NJN FTN5 IF NOT COMPLETE FTN SUBR ENTRY/EXIT STD CM SET REQUEST FTNA LDC LMCI * UJN FTN4 (1 CPU ONLY) STM FTNB LDD CM LMN DCPM ZJN FTN1 IF FUNCTION REQUIRING CORRECT CPU LMN CEFM&DCPM NJN FTN3 IF FUNCTION DOES NOT REQUIRE CORRECT CPU FTN1 LDD CP CHECK CPU SELECTION SHN 7 ADN CWQW CRD CN LDD CN+2 LPN 3 SBN 3 ZJN FTN3 IF NEITHER CPU ASSIGNABLE ADN 3-1 PJN FTN2 IF CPU SELECTION LDD CP CHECK FOR ACTIVE JOB SHN 7 ADN STSW CRD CN LDD CN SHN -11 ZJN FTN3 IF NOT ACTIVE SBN 3 PJN FTN3 IF NOT ACTIVE ADN 2 FTN2 RAM FTNB SET CORRECT CPU FTN3 LJM FTN4 ISSUE REQUEST GCE SPACE 4,15 ** GCE - GET CHANNEL ASSIGNMENT TABLE ENTRY. * * ENTRY (A) = CHANNEL NUMBER. * * EXIT (A) = ((T1)) = CHANNEL ASSIGNMENT TABLE ENTRY. * (CM - CM+4) = CHANNEL ASSIGNMENT TABLE WORD. * (CN) = REQUESTING JOB-S EJT ORDINAL. * (T0) = WORD INDEX FOR CHANNEL ASSIGNMENT TABLE. * * USES T0, T1, CM - CM+4, CN - CN+4. * * CALLS VCN. * GCE SUBR ENTRY/EXIT STD T1 SAVE CHANNEL NUMBER RJM VCN VERIFY CHANNEL NUMBER LCN 0 INITIALIZE WORD INDEX STD T0 GCE1 AOD T0 INCREMENT WORD INDEX LCN 5 DIVIDE BY 5 LOOP RAD T1 PJN GCE1 IF NOT CORRECT INDEX ADN 5+CM STD T1 LDC 0 READ CHANNEL ASSIGNMENT TABLE WORD GCEA EQU *-1 ADD T0 ADD CORRECT WORD INDEX CRD CM LDD OA GET JOB-S CP NUMBER SBN 1 CRD CN LDD CN+1 GET REQUESTING JOB-S EJT ORDINAL LPN 37 SHN 7 ADN TFSW CRD CN LDI T1 UJN GCEX RETURN HGM SPACE 4,10 ** HGM - HANG *MTR*. HGM CON ** CALLER-S ADDRESS HGM1 LDC MS2W+** DISPLAY MESSAGE HGMB EQU *-1 CWM HGMA,ON UJN HGM1 LOOP HGMA DATA C*MTR HUNG* PCM SPACE 4,10 ** PCM - PURGE CACHE IF CPU 1 IN MONITOR MODE. * * PURGE CACHE IN CPU 1 ON A DUAL CPU MACHINE WITH * CACHE, IF CPU 1 IS IN MONITOR MODE. * * EXIT CPU 1 CACHE PURGED IF DUAL-CPU NOS AND MONITOR MODE. * * USES CM - CM+4. PCM SUBR ENTRY/EXIT PCMA UJN PCMX IF NOT DUAL-CPU NOS CACHE MACHINE * LDC **+CMST+1 (DUAL-CPU NOS CACHE MACHINE) CON ** CHECK IF CPU 1 IN MONITOR MODE CRD CM LDD CM+1 ADD CM+2 ADD CM+3 ADD CM+4 ZJN PCMX IF CPU 1 NOT IN MONITOR MODE LDN ZERL CRD CM LDC 1S8 BIT 56 (IN 4 16-BIT BYTES) SELECTS CPU 1 STD CM LDK EIBP SET MICROCODE CPU 1 CACHE PURGE BIT RDSL CM CENTRAL READ AND SET LOCK (SELECT CPU 1) INPN 4 PURGE CACHE IN SELECTED CPU (CPU 1) UJN PCMX RETURN RCP SPACE 4,10 ** RCP - RECALL CPU. * * ENTRY (CN+2) = CONTROL POINT AREA ADDRESS. * * USES T7, CM - CM+4. * * CALLS CPR. * THE FOLLOWING CODE WILL SELECT CPU 0 IF NEITHER CPU CAN BE * CURRENTLY ASSIGNED ON A DUAL CPU MACHINE WITH CACHE. RCP1 ADN CWQW GET CPU SELECTION CRD CM LDD CM+2 LPN 3 ZJN RCP1.1 IF EITHER CPU ASSIGNABLE LMN 3 LPN 1 SELECT CPU FOR RECALL UJN RCP2.1 RECALL CPU * SELECT CPU WITH LOWEST PRIORITY JOB. RCP1.1 LDC TSCL CPU - 0 PRIORITY CRD T7 ADN 1 CPU - 1 PRIORITY CRD CM LDD CM SBD T7 RCP2 SHN 0-21 SIGN BIT TO RECALL CPU - 1 RCP2.1 SHN 14 LMN RCLF RJM CPR RCP SUBR ENTRY/EXIT LDD CN+2 LPC 7600 SET CONTROL POINT ADDRESS STD CN+2 RCPA UJN RCP1 CHECK CPU SELECTION * UJN RCP2 (SINGLE CPU) RCS SPACE 4,15 ** RCS - REQUEST CHANNEL STATE CHANGE. * * ENTRY (A) = *SCSM* SUBFUNCTION. * (OR+1) = EST ORDINAL. * (OR+3) = CHANNEL NUMBER. * * EXIT (A) = (CM+1) = *SCSM* REPLY. * = 0 IF FUNCTION WAS REJECTED. * * USES CM+1 - CM+3. * * MACROS MONITOR. RCS SUBR ENTRY/EXIT STD CM+3 SUBFUNCTION LDD OR+1 EST ORDINAL STD CM+1 LDD OR+3 CHANNEL STD CM+2 MONITOR SCSM LDD CM+1 UJN RCSX RETURN TCH SPACE 4 ** TCH - TEST CHANNEL. * * ENTRY (A) = CHANNEL NUMBER. * * EXIT (T2) = CHANNEL. * (A) = 0 IF CHANNEL FREE. * (A) .GT. 0 IF CHANNEL IS RESERVED. * (A) = NEGATIVE IF CHANNEL DOWN. * * CALLS VCN. TCH SUBR ENTRY/EXIT RJM VCN VERIFY CHANNEL NUMBER LDM TCHS,T2 ZJN TCHX IF CHANNEL IS FREE AND UP SHN 21-5 MJN TCHX IF CHANNEL DOWN SHN -14 ZJN TCHX IF CHANNEL UNASSIGNED STD CF SET CHANNEL UPDATE FLAG LDM TCHS,T2 SET CHANNEL REQUESTED FLAG LPC -4000 LMD FT STM TCHS,T2 UJN TCHX RETURN VCN SPACE 4,10 ** VCN - VERIFY CHANNEL NUMBER. * * ENTRY (A) = CHANNEL DESCRIPTOR. * * EXIT (T2) = CHANNEL NUMBER. * * ERROR TO *HNG* IF INVALID CHANNEL NUMBER. VCN SUBR ENTRY/EXIT LPN 77 STD T2 EXTRACT CHANNEL NUMBER VCNA SBN 0 MJN VCNX IF NON-CONCURRENT CHANNEL VCNB SBN 40-0 MJN VCN1 IF UNDEFINED CHANNEL VCNC SBN 0 MJN VCNX IF CONCURRENT CHANNEL VCN1 RJM HNG HANG PP COMMON SPACE 4,10 ** COMMON DECKS. EST$ EQU 1 SELECT EST PROCESSOR IFP$ EQU 1 SELECT REMOTE INITIALIZATION *CALL COMPGFP TITLE TABLES. TCHS SPACE 4,10 ** TCHS - CHANNEL TABLE. * * ENTRY = 1 WORD. * INDEXED BY CHANNEL NUMBER. * *T, TCHS 1/ R,4/,1/ I,1/ D,5/ ST * R SET IF CHANNEL IS REQUESTED. * I SET IF CHANNEL BEING IDLED DOWN. * D SET IF CHANNEL IS DOWN. * ST 0 IF CHANNEL FREE. * ST PP NUMBER IF CHANNEL BUSY. TCHS EQU * TCHSL EQU MXCH+1 CHANNEL NUMBER VALIDATION TPPR SPACE 4 * TPPR - TABLE OF *MTR* PP REQUESTS. * ENTRY = 1 WORD. * INDEXED BY MONITOR FUNCTION CODE. * *T, 12/ ADDR TPPR EQU TCHS+CTALL*5 ORG TPPR DUP CPUM,1 CON HNG1 PPR HERE INSERT REQUEST PROCESSOR ADDRESSES ORG TPPR+CPUM TREA SPACE 4,10 ** TREA - TABLE OF REENTRY ADDRESSES. * ENTRY = 1 WORD. * *T, TREA 12/ ADDR * ADDR ADDRESS OF CURRENT PROCESSOR FOR THE PP. * = 0, IF PP IS TURNED OFF. TREA EQU *-1 CON DSD DUP 30D-2,1 NO ENTRY FOR *MTR*, SPECIAL ONE FOR *DSD* CON PPR SPACE 4 ** CPRA - (P), (A0), (B0) FOR EXCHANGE PACKAGE. CPRA BSS 5 SPACE 4 ** BEGIN TABLES OVERLAYED BY PRESET. BEGIN BSSN CPRA+5 TSYD SPACE 4,10 ** TSYD - TABLE OF SYSTEM DEVICES. * ENTRY = 1 WORD. * *T, TSYD 12/ EQ * EQ NEXT SYSTEM DEVICE EST ORDINAL. TSYD EQU * BSSN MXSY TSHS SPACE 4,10 ** TSHS - TABLE OF SHARED SYSTEM DEVICES. * ENTRY = 1 WORD. * *T, TSHS 12/ V * V 4, IF THIS SYSTEM DEVICE IS SHARED, ELSE 0. TSHS EQU * BSSN MXSY TSYM SPACE 4,10 ** TSYM - TABLE OF SYSTEM DEVICE MST ADDRESSES. * ENTRY = ONE WORD, ZERO WORD TERMINATES TABLE. * *T, TSYM 12/ MSTA * MSTA MST ADDRESS OF SYSTEM EQUIPMENT IN *TSYD* WITH SAME * RELATIVE TABLE POSITION. TSYM EQU * BSSN MXSY+1 FORCE ZERO TERMINATOR TCHR SPACE 4,10 ** TCHR - TABLE OF PRIORITY SEEK REQUESTS. * ENTRY = ONE WORD, INDEXED BY CHANNEL NUMBER. * *T, TCHR 12/ PPN * PPN NUMBER OF PP WITH A PRIORITY REQUEST FOR THE CHANNEL. * A PRIORITY REQUEST IS ONE TO PERFORM THE INITIAL * POSITION ON A UNIT. TCHR EQU * BSSN MXNC+1 SPACE 4,10 ** THE FOLLOWING TABLES ARE PRESET TO ZERO. TCMA SPACE 4,10 ** TCMA - TABLE OF CONTROL MODULE ACTIVITY. * ENTRY = 1 WORD. * INDEXED BY CONTROL MODULE NUMBER. * *T, TCMA 6/ CH,6/ AC * CH CHANNEL NUMBER. * AC ACTIVITY COUNT. TCMA EQU * BSSN 8D TCMN SPACE 4,10 ** TCMN - TABLE OF DEVICE UNIT NUMBERS. * ENTRY = 1 WORD. * INDEXED BY PP NUMBER. * *T, TCMN 12/ UN * UN DEVICE UNIT NUMBER. TCMN EQU *-2 BSSN 20D-2 NO TABLE ENTRY FOR PP0, PP1 TPPI SPACE 4,10 ** TPPI - TABLE OF PPU INTERLOCK BITS. * ENTRY = 1 WORD. * INDEXED BY PPU NUMBER. * *T, TPPI 8/ IL,3/,1/ AC * IL INTERLOCK HELD BY PPU. * AC ACTIVITY BIT. TPPI EQU *-2 BSSN 20D-2 NO TABLE ENTRY FOR PP0, PP1 TSCA SPACE 4,10 ** TSCA - TABLE OF SHARED DEVICE OUTSTANDING SEEKS. * ENTRY = 1 WORD. * INDEXED BY CHANNEL NUMBER. * *T, TSCA 12/ N * N = NUMBER OF SEEK WAITS FOR SHARED DEVICES ON THIS CHANNEL. TSCA BSSN MXNC+1 TSEK SPACE 4,10 ** TSEK - TABLE OF SEEK WAITS ON SHARED DEVICES. * ENTRY = 1 WORD. * INDEXED BY CHANNEL NUMBER. * *T, TSEK 12/ N * N = NUMBER OF SEEK WAITS PROCESSED FOR THIS CHANNEL * SINCE A TIME WHEN NO SHARED DEVICE ACTIVITY WAS * PRESENT ON THE CHANNEL. WHEN THIS COUNTER REACHES * A PREDEFINED CONSTANT FURTHER ASSIGNMENT OF THE * CHANNEL FOR SHARED DEVICE ACCESS WILL BE DISALLOWED * UNTIL ALL REQUESTS COMPLETE AND OTHER MACHINES ARE * ALLOWED ACCESS TO THE CONTROLLER. TSEK BSSN MXNC+1 EZOT EQU * END OF ZEROED OUT TABLES TPMS SPACE 4,15 ** TPMS - TABLE OF MST ADDRESSES BY PP. * ENTRY = 1 WORD. * INDEXED BY PPU NUMBER. * *T, TPMS 12/ MSTA * MSTA MST ADDRESS / 10. TPMS EQU *-1 BSSN 20D-1 NO TABLE ENTRY FOR PP0 ERRNG 7776-* TABLE OVERFLOW END BSSN TITLE MONITOR PRESET. PRS SPACE 4,10 PRS8 CRD CM ADN 1 CRM OVLL,CM+4 LOAD NEXT PRESET OVERLAY OVLL BSS 0 PRESET OVERLAY LOAD ADDRESS ** PRS - PRESET TABLES AND CONSTANTS. PRS BSS 0 ENTRY LDN PPCP FETCH PP COMMUNICATION AREA POINTER CRD CM AOD CM+4 SET FIRST OUTPUT REGISTER ADDRESS STD OF SHN -3 LMC -0 RAM AMVC * SET PP COMMUNICATION ADDRESSES. PRS1 LDN PPUL SET PP STATUS CRD CN LDD CN SET MAXIMUM CHANNEL NUMBER + 1 ERRNZ NCHL-PPUL CODE DEPENDS ON VALUE RAM VCNA LDN 0 SBD CN RAM VCNB LDD CN+3 SET NUMBER OF CONCURRENT PPS * ERRNZ CPPL-PPUL CODE DEPENDS ON VALUE LPN 77 STD CN+3 NJN PRS2 IF CONCURRENT PPS PRESENT ISTORE MTRB,(UJN MTR2) SKIP CPP PROCESSING STM CMSA+1 ISTORE MTRE,(LDN NCTAL) WRITE ONLY NON CCH-S PRS2 LDD CN+3 RAM MTRC STM VCNC LDD CN+2 SET NUMBER OF NON-CONCURRENT PPS LMK 10D ZJN PRS3 IF 10 PP-S LDN 10D PRS3 ADN 10D RAM MTRA LPN 77 SET TOTAL NUMBER OF PPS ADD CN+3 STD NP SHN PPXES SET END OF PP-S FOR STORAGE MOVE CHECK ADN PPXE ALLOW FOR PSEUDO-PP STM MSTA LDN 1 SET PP 1 STD T1 PRS4 LDD T1 CHECK FOR UNAVAILABLE PPS SHN 3 ADD OF SBN 1 READ INPUT REGISTER CRD CM LDD CM CHECK PP STATUS LMC 2R** NJN PRS5 IF AVAILABLE LDC MTR INHIBIT PROCESSING STM TREA,T1 PRS5 AOD T1 ADVANCE PP NUMBER LMD NP NJN PRS4 IF NOT ALL PPS CHECKED * RELOCATE CENTRAL MEMORY ADDRESS CONSTANTS. LDK CMTP READ *CPUMTR* FWA CRD CM LDD CM+3 SHN 14 ADD CM+4 ADK CXBP READ *EXPACS* BLOCK POINTER CRD T4 LDK PPCP READ EXTENDED PP COMMUNICATION BLOCK FWA CRD CN LDK SDAP READ STATISTICAL DATA AREA POINTER CRD CS LDC TSIC SET RELOCATION TABLE ADDRESS RJM SIC RELOCATE INSTRUCTIONS ERRPL CPRA-* CODE DESTROYED READING EXCHANGE PACKAGE TLDC /EXPACS/MXP+0,XBP READ EXCHANGE PACKAGE CRM CPRA,ON LDC 210B SET *B0* (MICROCODE REQUIRES THIS VALUE) STM CPRA+4 * LOAD *4MZ* AND CONTINUE PRESET. LDC RPLP CRD CM LDD CM SHN 14 ADD CM+1 LJM PRS8 OVERLAY WITH NEXT PRESET OVERLAY SPACE 4,10 ** INSTRUCTION RELOCATION EQUIVALENCES. CMT EQU CM+3 *CPUMTR* FWA XBP EQU T4+3 *CPUMTR* *EXPACS* BLOCK POINTER PPX EQU CN+0 EXTENDED PP CONTROL BLOCK POINTER SDA EQU CS+0 STATISTICAL DATA AREA POINTER SPACE 4,10 ** COMMON DECKS. *CALL COMPSIC TSIC SPACE 4,10 ** TSIC - INSTRUCTION RELOCATION TABLE. TSIC BSS 0 LIST D SIC HERE CON 0 TERMINATE ENTRIES LIST * ERRNG 7777-*-5 4MZ TTL 4MZ - MTR PRESET (PART 2). 4MZ TITLE MONITOR PRESET. IDENT 4MZ,FMZ *COMMENT MTR - PRESET (PART 2). COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. 4MZ SPACE 4,10 *** 4MZ - MTR PRESET (PART 2). * * TO FREE SPACE IN *MTR*, SEVERAL PRESET OVERLAYS HAVE BEEN * DEFINED. THESE OVERLAYS ARE - * *4MZ*, *4MY*, *4MX*, *4MW*, *4MV* AND *4MU*. * *STL* LOADS THESE OVERLAYS INTO THE RPL BEFORE RELEASING * *MTR*. ONCE *MTR* HAS FINISHED PRESET, *STL* LOADS THE * DEADSTART RPL OVER THESE OVERLAYS. *STL* IS PREVENTED FROM * OVERWRITING THE PRESET OVERLAYS BEFORE *MTR* HAS READ THEM * BY THE FOLLOWING SCHEME - * 1) AFTER RELEASING *MTR*, *STL* INITIALIZES *DIO* * RESIDENT AND ATTEMPTS TO READ THE NEXT TAPE BLOCK. * 2) THE TAPE BLOCK CANNOT BE READ UNTIL *DIO* FINISHES * INITIALIZING ITSELF, WHICH INCLUDES REQUESTING A CHANNEL * WITH A *RCHM* MONITOR FUNCTION. * 3) THE *RCHM* FUNCTION CANNOT COMPLETE UNTIL *MTR* HAS * READ ALL PRESET OVERLAYS AND BEGUN EXECUTING. ORG OVLL FMZ BSS 0 ENTRY LDN DFPP SET FWA-3 OF DAYFILE POINTERS FOR *CDBM* CRD CM LDD CM SHN 14 ADD CM+1 SBN 3 STM CDBA+1 SHN -14 RAM CDBA LDN ECRL CHECK USER ECS ENABLED CRD CM LDD CM+1 CHECK USER EXTENDED MEMORY SIZE SBD CM+4 NJN FMZ0 IF USER EM DEFINED SOM RSTA LDC HNG1 DISABLE *RCXM* FUNCTION STM TPPR+RCXM FMZ0 LDK MABL CRD CN ADN CHTP-MABL READ CHANNEL TABLE POINTER CRD CM * PRESET CHANNEL TABLE. LDD CM+3 SET CHANNEL STATUS TABLE ADDRESS STM MTRF ADN CTALL SET CHANNEL ASSIGNMENT TABLE ADDRESS STM SEQB STM GCEA SHN -14 STD T0 SAVE OVERFLOW, IF ANY LDD CM+2 RAM MTRF-1 ADD T0 STM SEQB-1 STM GCEA-1 LDN CTALL READ CHANNEL TABLE STD T1 LDD CM+2 SHN 14 LMD CM+3 CRM TCHS,T1 * COMPLETE CHANNEL TABLE PRESET. LDK MXCH STD T1 FMZ1 LDM TCHS,T1 PRESERVE DOWN STATUS LPN 40 STM TCHS,T1 SOD T1 PJN FMZ1 IF MORE CHANNELS AOM TCHS+CHDS ASSIGN DISPLAY CHANNEL TO *DSD* * ADJUST FOR MACHINE SIZE, PP SPEED AND MEMORY CLEARING. LDM FMZA,CN+4 SET *RTCL* BASED ON PP SPEED STM TIMA LDD CN+2 SAVE MACHINE SIZE STM PCBA LDD CN+3 STM PCBB LDK SSTL CHECK FOR MEMORY CLEARING ENABLED CRD CM LDD CM SHN 21-12 PJN FMZ2 IF MEMORY CLEARING ENABLED ISTORE RSTC,(UJN RST20) DISABLE MEMORY CLEARING * PRESET SECDED PROCESSING. FMZ2 LDD SC SAVE ADDRESS OF UID TABLE CRD CM LDD CM LPN 77 RAM BISC-1 LDD CM+1 STM BISC LDD CN+1 SHN -11 LMN 7 ZJN FMZ4 IF CYBER 176 ISTORE BISE,(UJN BIS6) DISABLE CYBER 176 PROCESSING * MOVE SECDED PROCESSING TABLE FOR NON-176 INTO *BIS*. LDN FMZBL SET LENGTH TO MOVE STD T1 FMZ3 LDM FMZB-1,T1 STM BISF-1,T1 SOD T1 NJN FMZ3 IF NOT DONE MOVING * LOAD *4MY* AND CONTINUE PRESET. FMZ4 LDK RPLP CRD CM LDD CM SHN 14 ADD CM+1 CRD CM ADD CM+4 LJM PRS8 LOAD NEXT PRESET OVERLAY FMZA BSS 0 CYCLES UNTIL *RTCL* WRITTEN LOC 0 CON -MLSC+35 1X PP SPEED CON -MLSC+17 2X PP SPEED CON -MLSC+10 4X PP SPEED LOC *O FMZB BSS 0 C170 CM ID INFORMATION VFD 12/6000,1/0,5/CSEW,6/0 VFD 12/77,1/0,5/CMAW,6/4 VFD 12/7400,1/1,5/SYNW,6/-10 VFD 12/360,1/0,5/SYNW,6/4 CON 0 C170 ID BUILD TERMINATOR CON FCCL+SECD CON 0 TERMINATOR FOR C170 CLEARING FUNCTIONS CON 0 FMZBL EQU *-FMZB TABLE LENGTH ERRNZ FMZBL-BISFL TABLE LENGTH ERROR SPACE 4,10 ERRNG 7777-*-10D OVERFLOW ON OVERLAY LOAD 4MY TTL 4MY - MTR PRESET (PART 3). 4MY TITLE MONITOR PRESET. IDENT 4MY,FMY *COMMENT MTR - PRESET (PART 3). COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. 4MY SPACE 4,10 *** 4MY - MTR PRESET (PART 3). * * ENTRY (CN - CN+4) = MABL. ORG OVLL FMY BSS 0 ENTRY * PRESET CYBER 180 HARDWARE ERROR PROCESSING. LDD CN+1 SHN 21-13 MJP FMY2 IF LARGE CENTRAL MEMORY NOT PRESENT ISTORE CPRF,(ZJN CPR9) ENABLE *CPUMTR* CONTROL OF *RTCL* AOM CDBB READ *FLSW* + 1 AOM DCRA ISTORE CCPC,(SHN 6) CHANGE TO CME CODE ISTORE CRQA,(ZJN PCB3) CHANGE TO CME PROCESSOR LDC UJNI-ZJNI PREVENT CPU SELECTION FOR ECS RAM RSTB LDD CN+1 CHECK FOR CYBER 170 S/C REGISTER SHN 21-6 PJP FMY2 IF CYBER 170-865/875 LDK EIBP READ *EICB* POINTER CRD CM LDD CM SHN 21-12 PJP FMY1 IF NOT DUAL CPU MACHINE WITH CACHE LDC LDMI+0 ENABLE CPU 0 CHECK STM CPRC LDK CMTP SET *CPUMTR* BASE ADDRESS CRD T1 LDD T1+3 SHN 14 LMD T1+4 RAM CPRG+1 STM PCMA+1 SHN -14 RAM CPRG STM PCMA LDM FMYA,CN+4 SET COUNTER FOR 25 MICROSECOND DELAY RAM CPRE LDM FMYB,CN+4 SET COUNTER FOR 125 MICROSECOND DELAY STM CPRH+1 SCF *,MR GET MAINTENANCE CHANNEL DCN MR+40 FNC MRDC,MR KILL DEADMAN TIMER DCN MR+40 LDC STII+T3+1S15 (STIL INSTRUCTION) ACN MR OAN MR LDN 1 IAM FMYD,MR READ *STIL* TO MEMORY DCN MR+40 ENSURE MAINTENANCE CHANNEL INACTIVE CCF *,MR RELEASE CHANNEL LDC FMYC SET UP INSTRUCTION TABLE ADDRESS STD T2 FMY0 LDI T2 ADDRESS OF 16-BIT INSTRUCTION ZJN FMY1 IF FINISHED STD T3 LDI T3 LMC 1S15 CONVERT TO 16-BIT INSTRUCTION FMYD STI T3 SET LONG INSTRUCTIONS * STIL T3 SET LONG INSTRUCTIONS AOD T2 UJN FMY0 PROCESS NEXT INSTRUCTION FMY1 LDD CM+3 SHN 14 LMD CM+4 ADN DSCM+3 READ DFT/OS BUFFER POINTER CRD CM LDD CM+2 SAVE ADDRESS OF *DFT* CONTROL WORD SHN 14 LMD CM+3 SHN -4 SHN 6 LMD CM STM PHEA+1 SHN -14 RAM PHEA LPN 37 SHN 14 READ NOS REQUEST AREA POINTER ADM PHEA+1 ADN DFRQ CRD CM LDD CM+2 SAVE ADDRESS OF NOS REQUEST HEADER SHN 14 LMD CM+3 SHN -4 SHN 6 LMD CM STM PHEF+1 SHN -14 RAM PHEF * LOAD *4MX* AND CONTINUE PRESET. FMY2 LDK RPLP CRD CM LDD CM SHN 14 ADD CM+1 CRD CM ADD CM+4 CRD CM ADD CM+4 LJM PRS8 LOAD NEXT PRESET OVERLAY FMYA CON 14,30,61 COUNTERS FOR 25 MICROSECOND DELAY FMYB CON 75,173,370 COUNTERS FOR 125 MICROSECOND DELAY FMYC LIST16 LIST OF LOCATIONS OF 16-BIT INSTRUCTIONS SPACE 4,10 ERRNG 7777-*-10D OVERFLOW ON OVERLAY LOAD 4MX TTL 4MX - MTR PRESET (PART 4). 4MX TITLE MONITOR PRESET. IDENT 4MX,OMU *COMMENT MTR - PRESET (PART 4). COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. 4MX SPACE 4,10 *** 4MX - MTR PRESET (PART 4). * * ENTRY (CN - CN+4) = MABL. ORG OVLL OMU BSS 0 ENTRY * PRESET CYBER 70, 170 HARDWARE ERROR PROCESSING. LDD CN+1 SHN 21-13 MJN OMU1 IF LARGE CENTRAL MEMORY NOT PRESENT SHN 21-6-21+13 PJN OMU2 IF CYBER 865/875 LJM OMU7 LOAD NEXT OVERLAY OMU1 SHN 21-6-21+13 MJN OMU3 IF NOT CYBER 170 S/C REGISTER OMU2 LDD HN CHANGE TO TIME PROCESSING * LDC ZJNI-UJNI ERRNZ 100-ZJNI+UJNI (ADJUST IF INSTRUCTIONS CHANGE) RAM PHEB LDD CN+1 SHN -11 LMN 7 NJN OMU4 IF NOT CYBER 176 AOM PSEA LDN PSNI STM PHEC STM PSEB UJN OMU4 LOAD CYBER 170 PROCESSER OMU3 SHN 21-7-21+6+22 MJN OMU6 IF NOT CYBER 70 INTERLOCK REGISTER SOM OMUC CHANGE TO INTERLOCK REGISTER SOM ODWA SOM ODWB LDN SSTL GET SUB-SYSTEM STATUS CRD CM LDD CM+3 CHECK SIMULATED SCR SHN 21-3 PJN OMU4 IF SIMULATED SCR IS SELECTED SOM AVTA NO TIME CALL FOR C70 NON-SIMULATION LDC FCTB TEST BIT 0 FUNCTION STM OMUB * MOVE CYBER 70, 170, 700 SERIES, 865/875 BLOCK INTO *PHE*. OMU4 LDN OMUAL LENGTH TO MOVE STD T1 ISTORE PHEG,(PSN) DISABLE *DFT* CHECK IF NOT CYBER 180 OMU5 LDM OMUA-1,T1 STM PHEA-1,T1 SOD T1 NJN OMU5 IF MOVE NOT DONE UJN OMU7 CONTINUE OMU6 LDC UJNI+2 DISABLE *1MB* CALL STM MTRG STM MSTC * LOAD *4MW* AND CONTINUE PRESET. OMU7 LDK RPLP CRD CM LDD CM SHN 14 ADD CM+1 CRD CM ADD CM+4 CRD CM ADD CM+4 CRD CM ADD CM+4 LJM PRS8 LOAD NEXT PRESET OVERLAY OMUA BSS 0 CYBER 170 ERROR PROCESSOR LIST D PHEE HERE LIST * OMUAL EQU *-OMUA OMUB EQU OMUA+1 OMUC EQU OMUA+2 SPACE 4,10 ERRNG PHE3-PHEA-OMUAL OVERFLOW OF *PHE* ERRNG 7777-*-10D OVERFLOW ON OVERLAY LOAD 4MW TTL 4MW - MTR PRESET (PART 5). 4MW TITLE MONITOR PRESET. IDENT 4MW,SCC *COMMENT MTR - PRESET (PART 5). COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. 4MW SPACE 4,10 ** 4MW - MTR PRESET (PART 5). ORG OVLL SCC BSS 0 ENTRY LDK MCTP GET MEMORY CONTROL TABLE POINTER CRD CN LDD CN+1 SET MCT BASE ADDRESS STM STAA LDD CN RAM STAA-1 LDD CN+2 SET NUMBER OF MCT ENTRIES STM UFLA ERRNZ MCTP-PCPP CODE DEPENDS ON VALUE LDD CN+3 SHN 14 FORM BASE PCPA ADDRESS LMD CN+4 SBK CPAS STM SCPA SET ADDRESS - *CPAS* SHN -14 RAM SCPA-1 LDN NCPL READ NUMBER OF CONTROL POINTS CRD CM AOD CM+1 SET SYSTEM CONTROL POINT STD NC SBN 1 SET LAST CONTROL POINT RAM RSTE LPN 77 RAM PVEA LDD NC SET ADDRESS OF *MS2W* OF SYSTEM CP SHN 7 RAM HGMB STM HNGD STM HLTA RJM IFP INITIALIZE *COMPGFP* LDN ACPL READ CPU 0 STATUS CRD CM LDD CM CHECK CPU 0 SHN 6 PJN SCC3 IF AVAILABLE LDD HN * LDC 100 (SAVES 1 BYTE) RAM CPRA+3 SET CPU - 1 AOM MXN AOM CCPB SOM CCSB SCC1 LDC SCCA STD T1 SAVE TABLE ADDRESS SCC2 LDI T1 ZJN SCC4 IF NO MORE INSTRUCTIONS TO MODIFY STD T2 AOD T1 LDI T1 GET NEW INSTRUCTION VALUE STI T2 STORE ON TOP OF OLD INSTRUCTION AOD T1 UJN SCC2 MODIFY THE NEXT INSTRUCTION SCC3 LDN ACPL+1 READ CPU 1 STATUS CRD CM LDD CM CHECK CPU 1 SHN 6 MJN SCC1 IF NOT AVAILABLE * LOAD *4MV* AND CONTINUE PRESET. SCC4 LDK RPLP CRD CM LDD CM SHN 14 LMD CM+1 CRD CM ADD CM+4 CRD CM ADD CM+4 CRD CM ADD CM+4 CRD CM ADD CM+4 LJM PRS8 LOAD NEXT PRESET OVERLAY * TABLE OF INSTRUCTION MODIFICATIONS FOR SINGLE CPU OPERATION. SCCA BSS 0 CON AVCB LOC AVCB UJN AVC5 SKIP PROCESSING FOR OTHER CPU LOC *O CON CCPD LOC CCPD UJN CCPX RETURN LOC *O CON CCSA LOC CCSA LMN 0 LOC *O CON CPRB LOC CPRB UJN CPR1 LOC *O CON CX1 LOC CX1 UJN AVCX RETURN LOC *O CON MFLA LOC MFLA CON LDNI+MFLF LOC *O CON MFLA+1 LOC MFLA+1 CON RJMI LOC *O CON FTNA LOC FTNA UJN FTN4 AVOID CPU SELECTION LOC *O CON RCPA LOC RCPA UJN RCP2 AVOID CPU SELECTION LOC *O CON RSTB LOC RSTB UJN RST7 AVOID CPU SELECTION LOC *O CON 0 END OF TABLE SPACE 4,10 IFP HERE *COMPGFP* INITIALIZATION CODE SPACE 4,10 ERRNG 7777-*-10D OVERFLOW ON OVERLAY LOAD 4MV TTL 4MV - MTR PRESET (PART 6). 4MV TITLE MONITOR PRESET. IDENT 4MV,THU *COMMENT MTR - PRESET (PART 6). COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. 4MV SPACE 4,10 ** 4MV - MTR PRESET (PART 6). ORG OVLL THU BSS 0 ENTRY * SET MULTI-MAINFRAME PROCESSING. LDK MMFL CHECK MMF ENVIRONMENT CRD CS ADN EFRL-MMFL CHECK ERROR IN PRESET CRD CN LDD CN+4 NJN THU1 IF ERROR DETECTED IN *CPUMTR* PRESET LDD CS+1 LPC 777 NJN THU2 IF MMF PRESENT THU1 ISTORE AVCC,(UJN AVCD) DISABLE MULTI-MAINFRAME PROCESSING LCN ARMF-ARTF RAM AVCD LDD CS+1 NJN THU2 IF INDEPENDENT SHARED DEVICES PRESENT LDC NSDJ DISABLE SHARED DEVICE CODE RJM MMI MODIFY *MTR* INSTRUCTIONS LDC LDNI+10 STM RRXA THU2 LDK CFGL CRD CM LDD CM+3 SHN 21-11 MJN THU3 IF ISD SUBSYSTEM PRESENT LDC N8SJ DISABLE ISD SUBSYSTEM CODE RJM MMI MODIFY *MTR* INSTRUCTIONS THU3 LDC RTCL INITIALIZE REAL-TIME CLOCK CRD TM LDD TM+4 INITIALIZE CYCLE TIME STD CY * LOAD *4MU* AND CONTINUE PRESET. LDK RPLP CRD CM LDD CM SHN 14 LMD CM+1 CRD CM ADD CM+4 CRD CM ADD CM+4 CRD CM ADD CM+4 CRD CM ADD CM+4 CRD CM ADD CM+4 LJM PRS8 LOAD NEXT PRESET OVERLAY NSDJ SPACE 4,10 ** NSDJ - TABLE OF NO SHARED DEVICE JUMP INSTRUCTIONS. * *T, NSDJ 12/ ADDRESS,12/ *UJN* INSTRUCTION NSDJ BSS 0 NSDJ HERE CON 0 N8SJ SPACE 4,10 ** N8SJ - TABLE OF ISD SUBSYSTEM JUMP INSTRUCTIONS. * *T, N8SJ 12/ ADDRESS,12/ *UJN* INSTRUCTION N8SJ BSS 0 N8SJ HERE CON 0 MMI SPACE 4,10 ** MMI - MODIFY *MTR* INSTRUCTIONS. * * ENTRY (A) = ADDRESS OF MODIFICATION TABLE. * * EXIT INSTRUCTIONS MODIFIED. * * USES T1, T2. MMI SUBR ENTRY/EXIT STD T1 SAVE TABLE ADDRESS MMI1 LDI T1 ZJN MMIX IF NO MORE INSTRUCTIONS TO MODIFY STD T2 AOD T1 LDI T1 GET NEW INSTRUCTION VALUE STI T2 STORE ON TOP OF OLD INSTRUCTION AOD T1 UJN MMI1 MODIFY THE NEXT INSTRUCTION SPACE 4,10 ERRNG 7777-*-10D OVERFLOW ON OVERLAY LOAD 4MU TTL 4MU - MTR PRESET (PART 7). 4MU TITLE MONITOR PRESET. IDENT 4MU,FMV *COMMENT MTR - PRESET (PART 7). COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. 4MU SPACE 4,10 ** 4MU - MTR PRESET (PART 7). ORG OVLL FMV BSS 0 ENTRY LDK ESTP READ EST POINTER CRD OR ADK EJTP-ESTP READ EJT POINTER CRD CM SOD OR+2 SET EST SIZE STM SEQA LDD CM+1 SET EJT FWA + *SCHE* OFFSET RAM RCEB+1 SHN -14 ADD CM RAM RCEB LDK NOPE INITIALIZE EST ORDINAL FOR SEARCH STD OR+1 * BUILD MASS STORAGE TABLES. LDN 0 STD T1 INITIALIZE SYSTEM DEVICE COUNT LDC TSYM SET SYSTEM MST TABLE ADDRESS STD T2 ERRNG *-TSYM-MXSY TABLE OVERLAYS CODE FMV1 SFA EST,OR+1 READ EST ENTRY ADK EQDE CRD CS LDD CS SHN 0-12 LMN 3 NJN FMV3 IF NOT SYSTEM DEVICE AOD T1 SHN -1 ZJN FMV2 IF NOT MORE THAN 1 SYSTEM DEVICE LDC LDCI ENABLE SYSTEM DEVICE SELECTION CODE STM RCEA FMV2 LDD OR+1 SET EST ORDINAL STM TSYD-TSYM,T2 LDD CS SET SHARED FLAG SHN 2-11 LPN 4 STM TSHS-TSYM,T2 LDD CS+4 SET MST ADDRESS STI T2 AOD T2 LDD CS+3 LMC 2RDA FMV3 NJN FMV4 IF NOT 33502 ISTORE RSYA,(LPN 37) ENABLE 33502 SYSTEM PROCESSING ISTORE RSYB,(LMD CS+1) FMV4 AOD OR+1 LMD OR+3 LAST MASS STORAGE ORDINAL + 1 NJP FMV1 IF NOT END OF EQUIPMENT IAN 14 STD MS LDC EZOT STD T1 LDN DSCL SET UP *MTR* ACTIVE STATUS CRD CM STD CM+2 IFPL EZOT-*,1 BSSZ EZOT-* INSURE CODE TO ZERO TABLE IS BEYOND TABLE FMV5 LDN 0 CLEAR TABLES STI T2 AOD T2 LMD T1 NJN FMV5 IF NOT END OF TABLES LDN DSCL SET *MTR* ACTIVE STATUS CWD CM LJM MTR4 ENTER MAIN LOOP SPACE 4,10 ERRNG 7777-*-10D OVERFLOW ON OVERLAY LOAD TTL MTR - PP MONITOR. SPACE 4,10 END