TITLE CORE1 - LOGICAL AND PHYSICAL CORE ALLOCATION ROUTINES - V414 SUBTTL T. HASTINGS/TH/RCC TS 04 JUN 69 XP VCORE1,414 ;THIS MACRO PUTS VERSION NO. IN STORAGE MAP AND GLOB ENTRY CORE1 ;ALWAYS LOAD CORE1(FOR LIB SEARCH) ;CORE ALLOCATION IS DONE ON A 1K BLOCK BASIS ;USING A USE BIT TABLE(CORTAB) WHICH HAS A 1 ;FOR EVERY BLOCK WHICH IS NOT AVAILABLE BECAUSE: ; 1.IN USE BY MONITOR ; 2.IN USE BY USER ; 3.NON-EXISTANT MEMORY ;0 MEANS BLOCK IS NOT IN USE ;WHEN THE SYSTEM IS STARTED, SYSINI SETS THE CORTAB TABLE ;IT ALSO SETS A BYTE POINTER(CORLST) WHICH POINTS TO THE ;LOWEST NON-EXISTANT BLOCK IMMEDIATELY ABOVE THE HIGHEST ;EXISTANT BLOCK. IT ALSO SETS CORTAL TO THE NO. OF ;FREE BLOCKS AVAILABLE. ;THE CORE1 ROUTINE ASSIGNS CORE IF POSSIBLE. SETS THE USE BITS. ;AND MOVES THE JOB IF NEW ASSIGNEMENT IS A DIFFERENT PLACE THEN OLD ;THE JBTADR TABLE IS ALSO UPDATED BY THE CORE ROUTINES ;LH-PROTECTION,RH=RELOCATION ;JOBADR IS MODIFIED IF CORE FOR CURRENT JOB ;HARDWARE RELOC. AND PROTEC. ARE RESET IF CURRENT JOB ;FINALLY JOBREL(PROTECTION) IN JOB DATA AREA IS ALWAYS UPDATED ;LIST OF GLOBALS AFFECTED: ;JBTADR,CORTAL,CORTAB,HOLEF,SWFWAT,JOBADR ;ACS USED(BESIDES TAC,TAC1,JDAT,IOS,DEVDAT,AND POP) BLK=BUFPNT ;HIGHEST REL. ADR. IN USER AREA LOC=BUFWRD ;ABS. LOC. OF FIRST BLOCK IN USER AREA T=AC1 ;TEMPORARY T1=AC2 ;" ;CORE UUO ;CALL MOVEI AC,HIGHEST REL. ADR. DESIRED IN LOW SEG ; HRLI AC,HIGHEST REL. ADR. DESIRED IN HIGH SEG ; CALL AC,[SIXBIT /CORE/] ; ERROR RETURN ; OK RETURN TO USER. JOB MOVED IF NECESSARY ;RETURN NO. OF FREE 1K BLOCKS IN AC(OR MAX. NO. BLOCKS ALLOWED IF SWAPPING SYS) ;BOTH HALVES 0 MEANS ERROR RETURN NO. OF FREE 1K BLOCKS(OR MAX. NO. OF BLOCKS ; ALLOWED IF SWAPPING SYSTEM) IMMEDIATELY WIOTHOUT AFFECTING CORE ; OR WAITING FOR IO DEVICES ;LH=0 MEANS DO NOT CHANGE HIGH SEG ASSIGNMENT ;RH=0 MEANS DO NOT CHANGE LOW SEG ASSIGNMENT INTERNAL CORUUO EXTERNAL USRREL,JOB,CORTAL EXTERNAL ESTOP1,IOWAIT,OERROR,SETREL,STOTAC,WSCHED CORUUO: JUMPE TAC,ZERCOR ;IS HE ASKING FOR ZERO CORE? PUSH PDP,TAC ;NO, SAVE HIGHEST DESIRED ADDRESS IN BOTH SEGS PUSHJ PDP,IOWAIT ;WAIT FOR ALL DEVICE INACTIVE HRRZ TAC,(PDP) ;HIGHEST REL. LOC. DESIRED FOR LOW SEG(RH) JUMPE TAC,CORU1 ;IS RH 0(IF YES DO NOT CHANGE LOW SEG)? IORI TAC,1777 ;NO, MAKE EVEN MULTIPLE OF 1K-1 PUSHJ PDP,CORE1 ;TRY TO ASSIGN CORE JRST CORERR ;NOT AVIALABLE, ERROR RETURN ; SUM OF NEW LOW AND OLD HIGH SEG TO BIG CORU1: HLRZ TAC,(PDP) ;CHECK TO SEE IF USER REQUESTING HIGH CORE IFE FT2REL,< CAMG TAC,USRREL ;0 MEANS NO CHANGE, 1 THRU TOP OF LOW SEG MEANS ; RETURN HIGH CORE (IF ANY), ALWAYS LEGAL ; EVEN IF NO HIGH SEB SHARP WARE OR SOFTWARE > IFN FT2REL,< EXTERN UCORHI PUSHJ PDP,UCORHI ;TRY TO ASSIGN CORE TO HIGH SEG. ; UCORHI EXPECTS ARG ON PD LIST JRST CORERR ;ERROR-ACTIVE IO(SAVE IN PROGRESS FOR SOME USER) ; OR SUM OF NEW LOW SEG AND NEW HIGH SEG TOO BIG > AOS -1(PDP) ;SET FOR DK(SKIP) RETURN CORERR: POP PDP,TAC ;REMOVE ARG FROM LIST IFN FTSWAP,< PUSHJ PDP,WSCHED ;CALL SCHEDULER TO STOP JOB ; IN CASE LOW SEG MUST BE SWAPPED OUT TO EXPAND ; OR HIGH SEG LOGICAL CORE ASSIGNED ON DISK ; SAVE ALL ACS EXECPT AC1,AC2,AC3, > ZERCOR: IFE FTSWAP,< MOVE TAC,CORTAL ;RETURN NO. OF FREE 1K BLOCKS (COUNTING ; DORMANT AND IDLE SEGMENTS AS FREE) > IFN FTSWAP,< MOVE TAC,CORMAX ;RETURN MAX. NO. 1K BLOCKS ALLOWED FOR 1 USER TO HAVE LSH TAC,-12 > JRST STOTAC ;STORE IN USER AC AND RETURN TO USER ;ROUTINE TO CHECK JOBS TO SEE IF ANY JOB CAN BE SHUFFLED ;IT IS CALLED EVERY 60TH OF A SECOND BY CLOCK ROUTINE ;PROVIDING CURRENT JOB IS IN USER MODE OR JUST ENTERING ;IO WAIT OR SHARABLE DEVICE WIAT OR RETURNING ON UUO CALLS ;IE CURRENT JOB AND ALL OTHER JOB ARE SHUFFABLE WITH RESPECT ;TO RELOCATION INFO IN MONITOR ;SINCE RESCHEDULING IS NEVER DONE WHEN CURRENT JOB ;IS NOT SHUFFABLE. ALL JOBS ARE SHUFFABLE WHEN ;CHKSHF IS CALLED. ;THE NOSHUFFLE MACRO SHOULD STILL BE USED WHEN EVER ;THE MONITOR MOVES RELOCATION OUT OF ACS PDP,PROG. OR JDAT ;IN CASE IT SHOULD PROVE DESIRABLE IN THE FUTURE TO SHUFFLE ;MORE FREQUENTLY THEN AT THE ABOVE TIMES ;FINALLY A JOB MUST HAVE ALL DEVICES INACTIVE(SINCE SOME ;OF THEM USE ABSOLUTE ADDRESSES)BEFORE IT CAN BE MOVED ;SO CORE CANNOT BE REASSIGNED WHILE DEVICES ARE ACTIVE ;IF DEVICES ARE ACTIVE, JOB WILL BE STOPPED SO THAT IO WILL ;CEASE SOON SO JOB CAN BE SHUFFLED ;ALL DEVICES LOOK AT SHF BIT IN JBTSTS(ADVBEF OR ADVDFE) ;TO SEE IF MONITOR IS WAITING TO SHUFFLE JOB ;THE NSHF BIT IN JOBSTS WHOULD BE SET FOR JOBS USING DISPLAYS ;SINCE DISSER CONTINUALLY REFERENCES USER AREA EVEN THOUGH ;IOAC1 IS OFF. ;THIS VERSION OF THE CORE SHUFFLER WORKS AS FOLLOWS: ;EVERY CLOCK TICK FOR WHICH ALL JOBS ARE SHUFFABLE(NOT COUNTING ACTIVE ;IO DEVICES). THE JOB IMMEDIATELY ABOVE THE LOWEST HOLE ;(IF ANY) WILL BE MOVED DOWN INTO HOLE. THE HOLEF IS SET NON-ZERO ;TO THE ADDRESS OF JOB IMMEDIATELY ABOVE THE LOWEST ;HOLE(0 IF NONE), EVERY TIME CORE IS REASSIGNED. ;CANNOT BE CALLED WHILE SWAPPING IN PROGRESS FOR THIS JOB(BECAUSE IT CALLS CORE0) INTERNAL CHKSHF,FTSWAP EXTERNAL SHFWAT,HOLEF,CLKCHL,JBTADR,JBTSTS,JBTMAX CHKSHF: SKIPE ITEM,SHFWAT ;HAS CHKSHF STOPPED A JOB AND IS WAITING FOR ; DEVICES TO BECOME INACTIVE? JRST SHFLOP ;YES, SEE IF IO HAS STOPPED YET SKIPN TAC,HOLEF ;NO, DOES CORE HAVE A HOLE IN IT? POPJ PDP, ;NO MOVEI ITEM,JBTMAX ;SEARCH FOR JOB OR HIGH SEG JUST ABOVE HOLE HOLLOP: HRRZ TAC1,JBTADR(ITEM) ;ADR. OF JOB CAME TAC1,TAC SOJG ITEM,HOLLOP ;NOT JOB ABOVE HOLE KEEP LOOKG JUMPG ITEM,SHFLOP ;FOUND ONE? SETZM HOLEF ;NO, CLEAR HOLEF OR ELSE ERROR WILL BE PRINTED EVERY ; CLOCK TICK AND ERROR MESSAGE WILL NEVER PRINT JSP DAT,OERROR ;SYSTEM ERROR(TELL OPERATOR) SHFLOP: SKIPE PROG,JBTADR(ITEM) ;JOB ABOVE HOLE STILL IN CORE ? PUSHJ PDP,ANYACT ;NO ALL DEVICES FINISHED ? JRST NOTSHF ;YES, GO SEE IF HOLD STILL THERE IFN JDAT-PROG,< MOVE JDAT,JBTDAT(ITEM) ;JOB DATA AREA > HLRZ TAC,PROG ;YEST, REASSIGN SAME AMOUNT OF CORE. PUSHJ PDP,SCORE1 ;IN A LOWER POSITION IN CORE NOTSH1: SETZM SHFWAT ;JOB SHUFFLED, CLEAR FLAG MOVSI TAC,SHF ;CLEAR SHUFFLE WAIT BIT IN CASE IT WAS ON ANDCAM TAC,JBTSTS(ITEM) POPJ PDP, ;JOB CANNOT BE MOVED BECAUSE IT HAS ACTIVE DEVICES OR NSHF BIT SET(DISPLAY,REALTIME) ; SO JOB CANNOT BY SHUFFLED AT THIS TIME NOTSHF: SKIPN HOLEF ;IS HOLE STILL THERE? JRST NOTSH1 ;NO IFN FTSWAP,< EXTERNAL FIT,FORCE MOVE TAC,FORCE CAME ITEM,FIT CAMN ITEM,TAC JRST NOTSH1 > MOVEM ITEM,SHFWAT ;SET SHUFFLE WAIT FLAG WITH JOB NO. MOVSI TAC,SHF ;SET SHF WAIT BIT IN JOB STATUS WORD IORM TAC,JBTSTS(ITEM) ;SO JOB WILL NOT BE RUN POPJ PDP, ;AND IO WILL STOP SOON ;ROUTINE TO TEST FOR ANY ACTIVE DEVICES ;CALL: MOVE ITEM,JOB NUMBER OR HIGH SEG NUMBER ; MOVE JDAT,ADDRESS OF JOB DATA AREA ; PUSHJ PDP,ANYACT ; DEVICES ACTIVE ; DEVICES NOT ACTIVE EXCEPT POSSIBLY TTY ;IN SWAPPIN SYSTEMS ANYACT IS BROKEN INTO 2 CALLS, TRYSWP AND ANYDEV ;TRYSWP TEST WHTETHER SWAPPER SHOULD EVEN CONSIDER SWAPING JOB INTERN ANYACT,ANYDEV EXTERN JOBMAX ANYACT: IFN FTSWAP,< INTERN ANYDEV PUSHJ PDP,TRYSWP ;SHOULD SWAPPER MAKE JOB UNRUNNABLE ; IN ORDER TO SWAP OUT? POPJ PDP, ;NO, ACTIVE SAVE IN PROGRSS OR NSH,NSWP ; (REAL TIME OR DISPLAY) > ANYDEV: MOVE T,JBTSTS(ITEM) ;IS JOB(OR HIGH SEG) NOT SHUFFABLE? TLNE T,NSHF ;DISPLAY AND REAL TIME SET NSHF POPJ PDP, ;CANNOT BE SHUFFLED IFN FT2REL,< CAILE ITEM,JOBMAX ;YES IT THIS A HIGH SEG? JRST CPOPJ1 ;YES, OK TO SHUFFLE OR SWAP SINCE NSHF,NSWP ; AND NO SAVE IN PROGRESS > MOVEI T,JOBJDA(JDAT) ;ASSUME JOB IS NOT CURRENT JOB CAMN ITEM,JOB ;IS IT? MOVEI T,USRJDA ;IT IS CURRENT JOB ; DEVICE ASSIGNMENT TABLE IN MONITOR MOVEI IOS,IOACT ;IO DEVICE ACTIVE BIT HRRZ T1,JOBJMH(T) ;GET NO. OF USER IO CHANNELS IN USE ; FOR JOB(EITHER FROM JOB DATA AREA ; OR FROM MONITOR (IGNORE LH WHICH MY BE-1 ; IF SAVEGET IN PROGRESS) TLO T,T1 ;SET TO ADD T TO T1 MOVSI AC3,DVTTY ;DEVICE IS A TTY BIT ANY: SKIPE DEVDAT,@T ;IS A DEVICE ASSIGNED TO THIS CHANNEL? TDNN IOS,DEVIOS(DEVDAT) ;YES, IS IT ACTIVE? ANY2: SOJGE T1,ANY ;NO, KEEP LOOKING JUMPL T1,CPOPJ1 ;YES, FINISHED YET? TDNN AC3,DEVMOD(DEVDAT) ;NOT FINISHED, IS DEVICE TTY? POPJ PDP, ;NO, ERROR RETURN, CANNOT ASSIGN CORE JRST ANY2 ;YES, KEEP LOOKING FOR AN ACTIVE DEVICE ;ROUTINE TO TEST TO SEE IF JOB OR HIGH SEG CAN BE SWAPPED ; OR WHETHER IT SHOULD BE ALLOWED TO CONITNUE RUNNING ; UNTIL A MORE FAVORABLE ITME ;CALL: MOVE ITEM,HIGH RO LOW SEG NUMBER ; PUSHJ PDP,TRYSWP ; RETURN1 - JOB MUST REMAIN RUNABLE(NSHF,NSWP SET OR SAVE,GET IN PROGRESS) ; RETURN2 - OK TO SWAP HIGH OR LOW SEG IFN FTSWAP,< INTERN TRYSWP EXTERN JBTSTS,CPOPJ1 TRYSWP: MOVE T,JBTSTS(ITEM) ;IS JONB OR HIGH SEG NOT SWAPPABLE? TLNE T,NSHF!NSWP ;OR SHUFFABLE(DISPLAY,REAL TIME)? POPJ PDP, ;YES, ERROR RETURN IFN FT2REL,< EXTERN ANYSAV JRST ANYSAV ;NO, SEE IF THIS JOB IS INVLOVED IN A SAVE,GET ; WHICH IS STILL ACTIVE > IFE FT2REL,< JRST CPOPJ1 ;NO, GIVE OK RETURN > > ;ROUTINE TO FLUSH PHYSICAL CORE ASSIGNED IN MEMORY ;NOTE: THIS ROUTINE DIFERS SIGNIFICANTLY FROM CORE0 AND CORE1 IN THAT ;IT IS ONLY A PHYSICAL REMOVAL OF CORE(VIRTAL IS NOT AFFECTED) ;SEE COMMENTS FOR CORE1 ;CALL: MOVE ITEM,HIGH OR LOW SEGMENT NUMBER ; PUSHJ PDP,KCORE1 ; ALWAYS RETURN HERE ;SCORE1 IS CALLED FROM SHUFFLER WITH TAC SET TO SEG SIZE INTERN KCORE1 KCORE1: MOVEI TAC,0 ;SETUP DESIRED HIGHEST ADR SCORE1: SOS(PDP) ;CORE1 WILL ALWAYS SKIP RETURN JRST CORE1A ;BYPASS LOGICAL CORE ASSIGNMENT PART ; AND FLUSH PHYSICAL CORE(LOGICAL CORE UNEFFECTED) ;CORE0 IS CALLED BY THE CORE MONITOR COMMAND AND THE CORE SHUFFLER ;AND RUN COMMAND ;BOTH LOGICAL AND PHYSICAL CORE ASSIGNMENT ARE AFFECTED ;CALL: MOVE TAC,HIGHEST LEGAL ASSRESSABLE LOC. DESIRED ; MOVE ITEM,JOB NUMBER ; MOVE PROG,[XWD PROT,,RELOC.]=JBTADR(ITEM) ; PUSHJ PDP,CORE0 ; ERROR ;EITHER JOB HAS ACTIVE IO ; OR NOT ENOUGH CORE ; OK RETURN ;JOB IS MOVED IF NECESSARY TO SATISFY REQUEST ;PROG AND JDAT ARE SET TO NEW CORE ASSIGNMENT ON EITHER RETURN ;0 MEANS NONE ASSIGNED IN MEMORY, ASSIGNED ON DISK INTERNAL CORE0 INTERNAL CORE1,FTTIME,FTTRPSET,CORGET,FTSWAP EXTERNAL JOBJDA,JOB,USRJDA,JOBADR,JBTADR EXTERNAL JOBREL,JOBADR,JOBDAC,JOBPC,JOBDAT,JBTDAT EXTERNAL CORTAL,CORLST,CORTAB,HOLEF,CLRWRD EXTERNAL USRREL,CPOPJ1,JOBJMH,JOBENB,JOBDPD,JOBDPG EXTERNAL JOBPR1,CPOPJ1,JOBPRT,USRPC,CORMAX ;ENTER HERE FROM CORE CONSOLE COMMAND OR INITIAL CORE ;ASSIGNMENT OF JUST A JOB DATA AREA FOR RUN COMMAND ;IE ENTER WHEN DEVICES MAY BE ACTIVE OR JOB MAY HAVE NO PREVIOUS CORE ;JOB CAN HAVE CORE IN MEMORY, CORE ON DISK., OR NONE EITHER PLACE ;JOB CANNOT BE IN PROCESS OF SWAP OUT OR SWAP IN(CALLER'S RESPONSIBILITY) ;CORE0 NO LONGER REASSIGN CORE ON DISK IF OLD CORE ON DISK ;BECAUSE OF FRAGMENTED SWAPPING(TOO HARD) UNLESS 0 BEING ASKED FOR ;THEREFORE THE CORE COMMAND CAUSES JOB TO BE SWAPPED INTO CORE FIRST(INCORE=1) ;HOWEVER, THE R,RUN,GET,KJOB COMMANDS DO NOT REQUIRE HE PREVIOUS CORE IMAGE TO ;BE SWAPPED IN(AS THIS IS SLOW). THEY ASK FOR 140 WORDS, AND LARGER DISK SPACE IS RELINQUISHED ;UPON SWAPIN BY THE SWAPPER, VIRTAL IS INCREASED THEN RATHER THAN ;ON THE CALL TO CORE0. ;IT WILL TRY TO REASSIGN CORE IN MEMORY IF OLD CORE IN MEMORY ;IF THIS FAILS, IT WILL REASSIGN NEW CORE ON DISK AND ASK SWAPPER TO EXPAND ;IF JOB DID NOT HAVE OLD CORE, AN ATTEMPT WILL BE MADE TO ASSIGN CORE IN MEMORY ;IF THIS FAILS, TI WILL BE ASSIGNED ON THE DISK AND ASK SWAPPER TO EXPAND ;THE OTHER PLACES IN THE MONITOR WHERE THE IN-CORE COUNT IS TOUCHED IS ;IN GET WHERE IT INCREMENTS TO SHARE COPY ALREADY IN CORE. ;AND END OF SWPIN OF LOW SEG AND HIGH SEG IS ALREADY IN CORE FOR OTHER USER ;THE CORE ROUTINES DO NOT ALTER THE HIGH SEG IN CORE COUT. IT IS UP TO THE CALLER ;(IN SEGCOR) TO CALL THE CORE ROUTINES ONLY IF IN CORE COUNT IS 0 ;AND END OF SWAPIN OF LOW SEG AND HIGH SEG IS ALREADY IN CORE FOR OTHER USER CORE0: IFE FTSWAP,< JUMPE PROG,CORGET ;IS JOB WITHOUT CORE IN MEMORY? > IFN FTSWAP,< EXTERN IMGOUT,CPOPJ1,CHGSWP JUMPN PROG,CORE0A ;DOES JOB HAVE CORE IN MEMORY? ; (ALWAYS TRUE BOTH SEGS IF CORE UUO) IFE FT2REL,< EXTERN CORMAX CAML TAC,CORMAX ;NO, WILL REQUEST FIT IN PHYSICAL CORE? ; COMPARE WITH LARGEST PERMITTED ADR+1(BUILD AND ; ONCE CAN RESTART CORMAX) > IFN FT2REL,< EXTERN SUMSEG PUSHJ PDP,SUMSEG ;NO, WILL SUM OF BOTHER SEGMENTS FIR IN PHYSICAL CORE? ; LARGEST PERMITTED CORE, COMPARE SUM WITH CORMAX > POPJ PDP, ;NO, GIVE ERROR RETURN MOVSI TAC1,SWP ;IS JOB SWAPPED OUT? TDNN TAC1,JBTSTS(ITEM) ;(MAY HAVE 0 DISK SPACE ALTHOUGH SWAPPED OUT) JRST CORE1 ;NO, TRY TO ASSIGN CORE IN MEMORY PUSHJ PDP,CHGSWP ;YES, CHANGE ASSIGNMENT OF SWAPPING SPACE ON DISK ; INCREASE VIRTAL(COUNT OF FREE 1K BLOCKS OF SWAPPING ; (SHOULD NEVER NEED TO DECREASE VIRTAL SINCE ; CORE COMMAND ALWAYSSWAPS JOB IN FIRST). ; (FRAGMENTATION POSTPONES RETURNING SPACE AND ; INCREASING VIRTAL UNTIL SWAP IN IF NOTASKING ; FOR 0 VIRTUAL CORE) JRST CPOPJ1 ;GIVE OK RETURN TO CALLER CORE0A: EXTERNAL JBTSWP > IFN FTTRPSET,< EXTERNAL STOPTS SKIPN STOPTS ;NO,IS TIME SHARING STOPPED BY ; TRPSET UUO DONE FOR JOB 1? > PUSHJ PDP,ANYACT ;NO,ANY ACTIVE DEVICE? POPJ PDP, ;YES, CANNOT ASSIGN CORE ; NO, FALL INTO CORE1 ;ROUTINE TO TRY TO ASSIGN CORE IN CORE ;LOW OR HIGH SEG MUST NOT BE SWAPPED OUT(CALLER'S RESPONSIBILITY) ;AND MUST NOT HAVE ANY ACTIVE DEVICES(IT MAY HAVE 0 CORE IN CORE THOUGH) ;IN OTHER WORDS HIGH OR LOW SEG MAY OR MAY NOT HAVE VIRTUAL CORE ;BUT IF IT HAS VIRTUAL CORE IT MUST BE IN PHYSICAL CORE ;THIS IS BOTH A LOGICAL AND A PHYSICAL CORE ASSIGNMENT ;FIRST OLD CORE IS RETURNED TO SYSTEM ;THEN NEW REQUEST IS ATTEMPTED TO BE SATISFIED IN LOWEST ;POSITION POSSIBLE. THUS CORE TENDS TO BE PACKED ;IF NEW REQUEST CANNOT BE GRANTED, OLD AMOUNT OIS RETAINED, IF NON-SWAPPING SYS ;OTHERWISE SWAPPER IS CALLED(XPAND) TO EXPAND CORE BY SWAPPING OUT EXTERN SEGSIZ CORE1: NOSCHEDULE ;PREVENT SCHEDULING IFN FTSWAP,< EXTERN VIRTAL PUSHJ PDP,SEGSIZ ;TAC1=OLD SEG SIZE SKIPN LOC,TAC ;IS 0 BEING REQUESTED? MOVNI LOC,1 ;YES, PRETEND -1(DEPEND ON ASH BUG WHICH KEEPS -1 ; ON RT. SHIFT) ASH LOC,-12 ;CONVERT TO NO. OF K-1(01,0,1,2,...) SUB LOC,TAC1 ;NO. OF K-1 INCREASE=NEW-OLD-1 CAMGE LOC,VIRTAL ;IS THERE ENOUGH FREE VIRTUAL CORE IN SYSTEM? > IFE FT2REL,< CAML TAC,CORMAX ; YES, IS REQUEST LESS THAN MAX, ALLOWED COR+1? > IFN FT2REL,< EXTERN SUMSEG PUSHJ PDP,SUMSEG ;YES, IS SUM OF SEGS LESS THEN MAX. ALLOWED CORE+1? > POPJ PDP, ;NO, ERROR RETURN IFN FTSWAP,< ADDI LOC,1 ;YES, GET NO. OF K OF INCREASE MOVNS LOC ;MAKE MINUS FOR UPDATE ADDM LOC,VIRTAL ;AND UPDATE TOTAL VIRTUAL CORE IN SYSTEM ; SINCE THIS REQUEST CAN BE SATISFIIED > CORE1A: NOSCHEDULE ;PREVENT JOB SCHEDULING JUMPE PROG,CORGET ;OLD ASSIGNMENT 0? ; IF YES, DO NOT ATTEMPT TO RETURN OLD CORE HRRZ LOC,PROG ;NO. ABS, LOC. OF OLD CORE HLRZ BLK,PROG ;HIGHEST LEGAL REL. ADR. MOVEI T,0 ;CLEAR FOR CORSTG CALL PUSHJ PDP,CORSTG ;RETURN OLD CORE TO FREE STORAGE ;CORGET IS CALLED BY SWAPPER WHEN JOB IS ON DISC AND IS ;WANTED IN CORE. CORGET: SETZB LOC,PROG ;SET NEW ASSIGNMENT TO 0 AND DIST. MOVED JUMPE TAC,DIDLE1 ;IS ZERO CORE BEING REQUESTED? PUSHJ PDP,HOLSRC ;NO, SEARCH FOR HOLE BIG ENOUGH JRST BAKOLD ;NONE, GIVE BACK OLD AMOUNT INTERN FTTRACK IFN FTTRACK,< EXTERN LASCOR MOVEM ITEM,LASCOR ;LEAVE TRACKS FOR LAST JOB USING ; PHYSICAL CORE ALLOCATION ; (FOR DEBUGGING ONLY) > MOVEM LOC,PROG ;SETUP NEW RELOC HRLM TAC,PROG ;AND NEW PROTECT. MOVEI BLK,(TAC) ;HIGHEST REL ADR. BEING REQUESTED MOVEI T,1 ;SET USE BITS IN CORE TBALE PUSHJ PDP,CORSTG MOVE BLK,JBTADR(ITEM) ;OLD CORE ASSIGNMENT JUMPN BLK,MOVCOR ;WAS THERE OLD MEMORY ASSIGNED? ; NO, IFN FTSWAP,< LDB TAC1,IMGOUT ;SIZE(IN K) OF SEG ON DISK TO BE SWAAPED IN LSH TAC1,12 ;CONVERT TO WORDS > IFE FTSWAP,< MOVEI TAC1,0 ;JOB HAS NO PREVIOUS VIRT. CORE(NON-SWAP SYS) > MOVE BLK,PROG ;MAKE OLD ASSIGNMENT(BL) APPEAR TO START ; AT SAME PLACE AS NEW ASSIGNMENT(FOR CLEARING) SOJA TAC1,CLRCR1 ;IF NEW CORE SIZE IS BIGGER THAN ;OLD, CLEAR OUT INCREASED SO SECURITY WILL ; BE MAINTAINED. TAC1 IS SIZE-1 OF OLD ; ASSIGNMENT. -1 OF NO OLD ASSIGNMENT ;HERE WHEN FREE CORE TABLE DOES NOT HAVE ENOUGH ROOM FOR REQUEST BAKOLD: IFN FTSWAP,< EXTERN XPAND PUSHJ PDP,XPAND ;TELL SWAPPER TO SWAP OUT > IFE FTSWAP,< IFE FT2REL,< SOSO (PDP) ;SET FOR ERROR RETURN AND GET BACK LO CORE > IFN FT2REL,< EXTERN FRECOR PUSHJ PDP,FRECOR ;TRY TO DELETE 1 DORMANT HIGH SEGMENT, ; IF REQUEST DOES NOT EXCEED FREE CORE+DORMANT SEGS SOSA (PDP) ;ERROR RETURN-NOT ENOUGH CORE, GET OLD AMOUNT BACK JRST CORGET ;1 DORMANT SEG DELETED, TRY REQUEST AGAIN > > BKOLD1: HLRZ TAC,JBTADR(ITEM) ;GIVE BACK OLD CORE. JRST CORGET ;MOVE OLD CORE TO NEW AREA MOVCOR: CAIN LOC,(BLK) ;IS NEW CORE IN SAME PLACE AS OLD? JRST CLRCOR ;YES, DO NOT MOVE IT,CLEAR IF INCREASE HLRZ TAC1,BLK ;LENGTH OF OLD CORE CAILE TAC1,(TAC) ;IS OLD CORE LESS THEN NEW? HRRZ TAC1,TAC ;NO, MOVE THE SHORTENED NEW CORE IFN FTTIME,< EXTERNAL SHFWRD ADDM TAC1,SHFWRD ;INCREMENT TOTAL NO. WORDS SHUFFLED > ADD TAC1,LOC ;ADD IN NEW RELOC. MOVE AC1,LOC ;DEST.=NEW RELOC. HRL AC1,BLK ;SOURCE=OLD RELOC. SETZM JBTADR(ITEM) ;FLAG THAT CORE IS IN TRANSIT(TTY ROUTINES) BLT AC1,(TAC1) ;MOVE CORE TO NEW ASSIGNMENT ;CLEAR INCREASE IF NEW CORE IS BIGGER THAN OLD CLRCOR: HLRZ TAC1,BLK ;OLD CORE SIZE-1 CLRCR1: CAMG TAC,TAC1 ;IS NEW CORE SIZE-1 VREATER THAN OLD CORE SIZE-1 JRST DIDLE ;NO, DO NOT CLEAR ANY CORE IFN FTTIME,< MOVE AC1,TAC ;NEW CORE SIZE SUB AC1,TAC1 ;LESS OLD CORE SIZE ADDM AC1,CLRWRD ;ACCUMULATE NO. OF WORDS CLEARED > ADDI TAC1,2(PROG) ;YES, OLD SIZE-1+NEW RELOC+2=2ND LOC TO CLEAR ADDI TAC,(PROG) ;NEW SIZE-1+NEW RELOC=LAST LOC TO CLEAR SETZM -1(TAC1) ;CLEAR FIRST WORD HRLI TAC1,-1(TAC1) ;SET LH TO FIRST ADR. TO CLEAR BLT TAC1,(TAC) ;CLEAR THE INCREASE PORTION ;IF THE SHUFFLED JOB IS IN EXEC MODE, ITS DUMP ACS ;(PDP,PROG,JDAT SAVED IN JOB DATA AREA) MUST BE ;ALTERED BY DISTANCE CODE WAS MOVED ;IF THE SHUFFLED JOB IS CURRENT JOB, THE SOFTWARE STATE OF ;THE MONITOR(IE SOFTWARE INFO OF JOB) MUST BE ALTERED BY AMOUNT ;CORE WAS MOVED EXTERNAL SYSSIZ DIDLE: SUBI LOC,(BLK) ;DISTANCE JOB WAS MOVED(DIST.-SOURCE) CAME ITEM,JOB ;IS THIS CURRENT JOB? SKIPA TAC,JOBPC(JDAT) ;NO. GET PC IN JOB DATA AREA MOVE TAC,USRPC ;YES, PC IN PROTECTED SYSTEM AREA IFN FT2REL,< EXTERN JOBMAX CAIG ITEM,JOBMAX ;IS THIS A HIGH SEGMENT? > TLNE TAC,USRMOD ;NO. IS JOB IN USER MODE? JRST DIDLE1 ;YES, DO NOT ALTER DUMP ACS ; BECAUSE THEY ARE IN USERS(OR HIGH SEG) ADDM LOC,JOBDPD(JDAT) ;NO. ALTER DUMP PDP BY DIST. OF MOVE ADDM LOC,JOBDPG(JDAT) ;AND ALTER PROG BY DIST. MOVED DIDLE1: MOVEM PROG,JBTADR(ITEM) ;STORE NEW CORE ASSIGNMENT(LOW OR HIGH SEG) CAME ITEM,JOB ;IS THIS CURRENT JOB? JRST DIDLE3 ;NO, DO NOT ALTER STATE OF MONITOR MOVE TAC,SYSSIZ ;DONT CHANGE PDP IF LIST CAIG TAC,(PDP) ;IS IN SYSTEM ADD PDP,LOC ;YES, ALTER PUSH DOWN POINTER BY AMOUNT OF MOVE PUSHJ PDP,SETREL ;GO SETUP NEW HARDWARE AND SOFTWARE RELOCATION ; INFORMATION FOR HIGH AND LOW SEGS FOR CURRENT JOB DIDLE3: IFN FT2REL,< EXTERN CURHGH PUSHJ PDP,CURHGH ;CHECK TO SEE IF THIS CORE ASSIGNMENT IS FOR ; HIGH SEG WHICH CURRENT USER MAY ALSO BE USING ; IF YES, RESET HARDWARE AND SOFTWARE RELOC INFO. ; RETURN WITH ITEM PRESERVED,PROG SET TO RELOC ; OF SEG WHICH HAS JUST HAD CORE REASSIGNED > SETZB TAC,HOLEF ;CLEAR HOLD FLAG PUSHJ PDP,HOLSRC ;IS THERE A NON-ZERO HOLE? JRST COROK ;NO ADDI LOC,1(BLK) ;YES, FORM ADR. OF JOB JUST ABOVE HOLD CAME T,CORLST ;IS HOLE AT TOP OF MEMORY MOVEM LOC,HOLEF ;NO, FLAG WITH ADDRESS OF JOB ABOVE HOLE COROK: IFN FTSWAP,< EXTERNAL BIGHOLE MOVEI TAC,-1 ;FIND BIGGEST HOLE PUSHJ PDP,HOLSRC ;ALWAYS GET ERROR RETURN ASH T1,-^D10 ;CONVERT TPO 1K BLOCKS MOVEM T1,BIGHOLE > SCHEDULE JRST CPOPJ1 ;SKIP RETURN(UNLES ERROR) ;ROUTINE TO FIND HOLD BIG ENOUGH FOR REQUEST ;CALL: MOVE TAC,HIGHEST REL. ADR. ASKING FOR ; PUSHJ PDP,HOLSRC ; RETURN1 ;NO HOLES BIG ENOUGH ; RETURN2 ;T BYTE SET TO LAST BLOCK+1 IN HOLE ; ;BLK SET TO HIGHEST REL. LOC. IN THAT HOLE ; ;LOC SET TO ADDRESS OF FIRST BLOCK IN HOLE ; ;T1=LARGEST HOLE SEEN ;USES TAC1 HOLSRC: MOVE T,CORE2P ;BYTE POINTER TO FIRST BIT-1 SETZB LOC,T1 ;START AT BOTTOM OF MEMORY ; LARGEST HOLE SO FAR=0 CORHOL: TDZA BLK,BLK ;START BLK AT 0 AND SKIP CORHO0: ADDI BLK,2000 ;INCREMENT HIGHEST REL LOC. CORHO1: CAMN T,CORLST ;BYTE POINTER TO 1ST NON-EXISTANT BLOCK POPJ PDP, ;NO MORE CORE TO SEARCH ILDB TAC1,T ;GET NEXT CORE USE BIT ADDI LOC,2000 ;INCREMENT ADDRESS OF BLOCK JUMPE TAC1,CORHO0 ;IS THIS BLOCK IN USE? JUMPE BLK,CORHO1 ;YES, HAVE ANY FREE BLOCKS BEEN SEEN YET? IFN FTSWAP,< CAMLE BLK,T1 ;YES, BIGGEST SO FAR? MOVEM BLK,T1 ;YES, SAVE IN T1. > CAMG BLK,TAC ;YES, IS THIS HOLD EQUAL OR GREATER THEN REQUEST? JRST CORHOL ;NO, KEEP LOOKING FOR HOLES SUBI LOC,2000(BLK) ;YES, SET LOC TO FIRST BLOCK IN HOLD SOJA BLK,CPOPJ1 ;SET BLK TO HIGHEST REL. LOC. ; AND RETURN ;ROUTINE TO SET AND CLEAR CORE USE TABLE ;CALL: MOVEI T,1 ;TO SET TABLE ; MOVEI T,0 ;TO CLEAR TABLE ; MOVE BLK,HIGHEST REL. LOC. IN USER AREA ; MOVE LOC,ADDRESS OF FIRST BLOCK TO SET CLEAR INTERN CORE2P EXTERN TPOPJ CORSTG: PUSH PDP,TAC ;SAVE HIGHEST LOC. BEING REQUESTED ASH BLK,-12 ;CONVERT TO NO. OF BLOCKS-1 ADDI BLK,1 ;NO. OF BLOCKS SKIPE T ;UPDATE NO OF FREE BLOCKS MOVNS BLK ;DECREASE IF SETTING BITS ADDM BLK,CORTAL ;INCREASE IF CLEARING,DECREASE IF SSETING BITS MOVE TAC,LOC ;ADDRESS OF FIRST BLOCK ASH TAC,-12 ;FORM BYTE POINTER TO BIT-1 IDIVI TAC,^D36 ;TAC=WORD,TAC1=BIT ADD TAC,CORE2P ;FORM BYTE POINTER MOVNS TAC1 ADDI TAC1,^D36 DPB TAC1,[POINT 6,TAC,5] MOVMS BLK ;GET MAG. OF NO. OF BLOCKS INVOLVED IDPB T,TAC ;SET OR CLEAR EACH USE BIT SOJG BLK,.-1 JRST TPOPJ ;RESTORE TAC. AND POPJ CORE2P: POINT 1,CORTAB ;BYTE POINTER TO FIRST BIT-1 ;ROUTINE TO CLEAR PART OF JOB DAT AREA(PART PROTECTED FROM USER IO) ;CALLED WHEN NEW CORE ASSIGNED AND AT SYSTEM RESTART(140) ; MOVE ITEM,JOB NO. ;CALL: MOVE JDAT,ADR. OF JOB DATA AREA ; PUSHJ PDP,CLRJOB INTERNAL CLRJOB EXTERNAL JOBPRT,JOBPR1,JOBPFI,JOBENB EXTERNAL JOBPD1,JOBDDT CLRJOB: SETZM JOBPRT(JDAT) ;FIRST LOC. PROTECED FROM USER MOVSI TAC,JOBPRT(JDAT) HRRI TAC,JOBPR1(JDAT) MOVE TAC1,JOBDDT(JDAT) ;SAVE DDT STARTING ADDRESS BLT TAC,JOBPFI(JDAT) MOVEM TAC1,JOBDDT(JDAT) SETZM JOBENB(JDAT) ;ALSO CLEAR APR ENABLE WORD SETZM JOBPD1(JDAT) ;AND UUO PC FLAGS(USED WHEN JOB STARTS) JRST ESTOP1 ;GO SET JOB STATUS, SO CONT WILL ; NOT WORK,(DO NOT CLEAR JACCT BIT) COREND: END