









		100-111-005-00


	   FUNCTIONAL SPECIFICATION AND
		DESIGN SPECIFICATION
	FOR MECHANISM FOR LOCKING JOBS IN CORE




	AUTHOR: J. FLEMMING
	DATE: 14-AUG-70
	FILE: LOKUUO.MAN%005
	REVISION DATE: 13-OCT-70


	THE INFORMATION IN THIS MEMORANDUM IS SUBJECT TO
	CHANGE WITHOUT NOTICE AND SHOULD NOT BE CONSTRUED
	AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.

	ACTUAL DISTRIBUTION OF THE SOFTWARE DESCRIBED IN
	THIS SPECIFICATION WILL BE SUBJECT TO TERMS AND
	CONDITIONS TO BE ANNOUNCED AT SOME FUTURE DATE BY
	DIGITAL EQUIPMENT CORPORATION.


	TABLE OF CONTENTS

   FUCTIONAL SPECIFICATION:
	1. INTRODUCTION
	2. GOALS

   DESIGN SPECIFICATION:
	1. INTRODUCTION
	1.1 FUCTION
	1.2 DEFINITIONS
	FIGURE 1
	2. UUO DESCRIPTION
	3. GENERAL FLOW
	FIGURE 2
	4. CORE REQUIREMENTS
	5. MONITOR BUILDING CONSIDERATIONS
	6. ONCE ONLY
	7. TEST PROGRAMS
	8. CODING TECHNIQUES
		FUNCTIONAL SPECIFICATIONS




1.0	INTRODUCTION


	CERTAIN CLASSES OF PRIVLEGED JOBS, FOR VARIOUS REASONS,
	DESIRE THE CAPABILITY OF BEING LOCKED IN CORE, I.E., NEVER
	BECOMING A CANDIDATE FOR SWAPPING OR SHUFFLING.  SOME EXAMPLES
	OF SUCH JOBS AND THE REASONS THEY DESIRE THIS CAPABILITY ARE
	AS FOLLOWS:

1.1	REAL-TIME JOBS

	THESE JOBS REQUIRE IMMEDIATE ACCESS TO THE PROCESSOR IN
	RESPONSE TO AN INTERRUPT, AND THEREFORE, THEY CANNOT BE
	SHUFFLED OR SWAPPED.

1.2	DISPLAY JOBS

	TO KEEP A PICTURE FLICKER-FREE, THE DISPLAY MUST BE REFRESHED
	FROM A DISPLAY FILE IN THE USER'S CORE AREA WHICH IMPLIES THE
	JOB CANNOT BE SHUFFLED OR SWAPPED IF A FLICKER-FREE IMAGE IS
	TO BE GUARANTEED.

1.3	BATCH

	BY LOCKING THE BATCH CONTROL CUSP IN CORE, BATCH THROUGHPUT
	COULD BE ENHANCED.

1.4	PERFORMANCE ANALYSIS

	PERFORMANCE ANALYSIS JOBS WHICH MONITOR THE ACTIVITIES OF THE
	SYSTEM NEED TO BE LOCKED IN CORE SO THAT WHENEVER THEY ARE
	ENTERED TO GATHER DATA THEY ARE AWARE OF THEIR STATE AND THEY
	CAN THUS RECORD ACTIVITIES OF THE MONITOR INDEPENDENT OF THE MONITOR.




2.0	GOALS


	TO PROVIDE THE ABOVE CAPABILITIES WITHOUT DEGRADING THE SYSTEM,
	A MODULE (OPTIONALLY INCLUDED IN THE SYSTEM AT GENERATION TIME)
	HAS BEEN IMPLEMENTED WHICH OPTIMIZES THE PLACEMENT OF A JOB IN
	CORE AND THEN LOCKS IT THERE.  THIS ACTION IS IN RESPONSE
	TO A MONITOR CALL EXECUTED BY THE USER JOB.  THE OBJECTIVES IN THE
	IMPLEMENTATION OF THIS MODULE INCLUDE THE FOLLOWING:

2.1	IMPROVE THE SHUFFLER BY INTRODUCING A NEW ALGORITHM FOR PICKING
	THE JOB TO SHUFFLE.  THE BEST CHOICE OF A JOB TO SHUFFLE
	IS DETERMINED AS FOLLOWS:

2.1.0	PICK THE HIGEST JOB IN CORE THAT WILL EXACTLY FIT IN THE LOWEST
	HOLE AND WHICH IS NOT IN I/O WAIT.  MOVE IT DOWN INTO THE HOLE.

2.1.1	FAILING 2.1.0, PICK THE HIGHEST JOB IN CORE THAT WILL EXACTLY FIT
	THAT IS IN I/O WAIT AND WAIT FOR IT TO BECOME SHUFFABLE.  THEN
	MOVE IT DOWN.

2.1.2	FAILING 2.1.1, PICK THE JOB IMMEDIATELY ABOVE THE HOLE.

2.2	PROVIDE A MONITOR CALL WHICH WHEN EXECUTED BY A PRIVILEGED
 	USER PROGRAM (PRIVILEGES GRANTED BY THE SYSTEM MANAGER) RESULTS
	IN THAT JOB BEING LOCKED IN THE OPTIMAL POSITION IN MEMORY (AT
	AN EXTREMITY OF USER CORE).

2.3	PROVIDE A MECHANISM FOR UNLOCKING JOBS WHEN THEY REACH COMPLETION.
		DESIGN SPECIFICATIONS


1.0	INTRODUCTION

1.1	FUNCTION

	PROVIDE A MECHANISM FOR OPTIMALLY POSITIONING JOBS IN USER MEMORY
	AND LOCKING THEM THERE.

1.2	DEFINITIONS (SEE FIGURE 1)

1.2.0	LOCKED
	A JOB IS "LOCKED" IN CORE IF IT IS NEVER A CANDIDATE FOR
	SWAPPING OR SHUFFLING.
1.2.1	ZERO-CORE
	"ZERO-CORE" IS ANY CONTIGUOUS PORTION OF EXISTANT MEMORY WHICH DOES
	NOT CONTAIN THE MONITOR, OR AN ACTIVE, DORMANT, OR IDLE SEGMENT.
1.2.2	ONE-CORE
	"ONE-CORE" IS ANY PORTION OF USER CORE WHICH CAN
	BE MADE ZERO-CORE BY DELETING DORMANT, IDLE, AND ACTIVE SEGMENTS.
1.2.3	TWO-CORE
	"TWO-CORE" IS NON-EXISTANT MEMORY, CORE MEMORY OCCUPIED BY THE
	MONITOR, AND CORE MEMORY OCCUPIED BY A LOCKED JOB.
1.2.4	ZERO-HOLE
	A "ZERO-HOLE" IS ANY CONTIGUOUS BLOCK OF ZERO-CORE.
1.2.5	ONE-HOLE
	A "ONE-HOLE" IS ANY CONTIGUOUS BLOCK OF ZERO AND/OR ONE-CORE.
1.2.6	LOWER EXTREMITY
	THE "LOWER EXTREMITY" IS THE LOWEST ADDRESS CONTAINED IN THE LARGEST
	ONE-HOLE.
1.2.7	UPPER EXTREMITY
	THE "UPPER EXTREMITY" IS THE ADDRESS OF THE FIRST LOCATION IMMEDIALTELY
	ABOVE THE LARGEST ONE-HOLE.
1.2.8	CORE REQUIRED FOR THE LARGEST EXISTING JOB
	THE "CORE REQUIRED FOR THE LARGEST EXISTING JOB" (MINCOR)
	IS THE SIZE THAT THE LARGEST ONE-HOLE MUST BE TO RUN ANY JOB
	CURRENTLY KNOWN TO THE SYSTEM.  ITS EXTENT IS COMPUTED AS
		SIZE OF SWAPPED LOW SEGMENT (IF ANY) +
		SIZE OF SWAPPED HIGH SEGMENT (IF ANY) +
		LOW SEGMENT CORE IN CORE IN THE LARGEST ONE-HOLE (IF ANY) +
		HIGH SEGMENT CORE IN CORE IN THE LARGEST ONE-HOLE (IF ANY).
1.2.9	CORMAX
	"CORMAX" IS THE SIZE IN WORDS OF THE LARGEST LEGAL USER JOB (SUM
	OF THE SIZE OF THE LOW AND HIGH SEGMENTS).  THE DEFAULT VALUE IS
	ALL OF USER CORE BUT IT MAY BE RESTRICTED BY THE SYSTEM MANAGER
	AT MONGEN TIME OR THROUGH THE ONCE ONLY DIALOG.
1.2.10	CORMIN
	"CORMIN" IS THE GUARANTEED MINIMUN SIZE OF THE LARGEST ONE-HOLE.
	ITS DEFAULT VALUE IS CORMAX, BUT IT CAN BE INCREASED OR DECREASED
	BY THE SYSTEM MANAGER.
1.2.11	MEMORY FRAGMENTATION
	MEMORY IS SAID TO BE FRAGMENTED IF THERE ARE TWO OR MORE ONE-HOLES.



		FIGURE	1.





!-----------------------! _-------------
!			!	^
!	MONITOR		!	^
!			!	^
!-----------------------!   TWO ^ CORE
! LOCKED JOB		!	^
!			!	^
!			!	^
!-----------------------! _-------------  _-------------
! TIME-SHARING JOB	!	^		^
!-----------------------!	^		^
! TIME-SHARING JOB	!   ONE ^ CORE 	    ONE ^ HOLE
!			!	^		^
!-----------------------!	^		^
! TIME-SHARING JOB	!	^		^
!-----------------------! _-------------  _-------------
! LOCKED JOB		!   TWO ^ CORE
!-----------------------! _-------------  _-------------	__ LOWER EXTREMITY
! TIME-SHARING JOB	!   ONE ^ CORE		^
!			!	^		^
!-----------------------! _-------------	^
!///////////////////////!	^		^
!///////////////////////!	^		^
!///////////////////////!	^		^
!///////////////////////!  ZERO ^ CORE	    ONE ^ HOLE (LARGEST)
!///////////////////////!	^		^
!///////////////////////!	^		^
!///////////////////////!	^		^
!///////////////////////!	^		^
!-----------------------! _-------------  _-------------	__ UPPER EXTREMITY
! LOCKED JOB		!   TWO ^ CORE
!			!	^
!-----------------------! _-------------



AID FOR UNDERSTANDING DEFINITIONS.
2.0	DESCRIPTION OF MONITOR CALL FOR LOCKING JOBS IN CORE

2.1	MONITOR CALL

2.1.0	PROTOTYPE "LOCK" UUO

		MOVSI	AC,1		;IF HIGH SEGMENT IS TO BE LOCKED
		MOVSI	AC,0		;IF NO HIGH SEGMENT
					;OR HIGH SEGMENT IS NOT TO BE LOCKED
		HRRI	AC,1		;IF LOW SEGMENT IS TO BE LOCKED
		LOCK	AC,		OR		CALLI	AC,60
		ERROR RETURN
		NORMAL RETURN

2.1.1	NORMAL RETURN

	UPON NORMAL RETURN, THE JOB WILL BE LOCKED IN CORE IN THE OPTIMAL
	POSITION.  THE CONTENTS OF THE LEFT HALF OF AC WILL CONTAIN THE
	ABSOLUTE ADDRESS OF THE HIGH SEGMENT SHIFTED RIGHT
	NINE BIT POSITIONS IF THERE IS A HIGH SEGMENT.
	OTHERWISE THE LEFT HALF WILL CONTAIN ZERO.  THE RIGHT HALF OF
	AC WILL CONTAIN THE ABSOLUTE ADDRESS OF THE LOW SEGMENT SHIFTED
	RIGHT NINE BIT POSITIONS.

2.1.2	ERROR RETURN

	UPON ERROR RETURN AC CONTAINS AN ERROR CODE AS INDICATED AND ONE OF
	THE FOLLOWING CONDITIONS PREVENTED THE JOB FROM BEING LOCKED.


2.1.2.0	THE JOB DOES NOT HAVE LOCKING PRIVILEGES (ERROR CODE = 1).
	N.B. PRIVILEGES ARE GRANTED BY THE SYSTEM MANAGER BY RUNNING
	THE REACT CUSP AND GIVING THE APPROPRIATE RESPONSE TO THE QUESTION
	"PRIVILEGE WORD:".  A JOB WILL HAVE LOCKING PRIVILEGES IF BIT 14
	(PVLOCK) IS SET IN RESPONSE TO THAT QUESTION.

2.1.2.1	THERE WOULD NOT A ONE-HOLE LARGE ENOUGH TO RUN THE LARGEST
	EXISTING NON-LOCKED JOB IF THIS JOB WERE LOCKED IN CORE 
	(APPLIES ONLY IN SWAPPING SYSTEMS) (ERROR CODE = 2).

2.1.2.2	IF THE JOB WERE LOCKED, THE EXTENT OF THE LARGEST ONE-HOLE
	WOULD BE LESS THAN CORMIN (APPLIES ONLY IN SWAPPING SYSTEMS)
	(ERROR CODE = 3).

2.2	OTHER CONSIDERATIONS

	WHILE THE LOCK UUO WILL MAKE EVERY ATTEMPT TO PUT THE JOB BEING
	LOCKED IN A POSITION IN USER CORE WHERE IT WILL NOT CAUSE MEMORY
	FRAGMENTATION, AND THE SHUFFLER WILL TRY TO MINIMIZE FRAGMENTATION
	REGARDLESS OF WHERE JOBS ARE LOCKED, THE ALGORITHM FOR DETERMING
	WHETHER A JOB CAN BE LOCKED, ALWAYS ALLOWS A JOB TO BE LOCKED IF
	ALL EXISTING JOBS CAN STILL CONTINUE TO EXECUTE AND A ONE-HOLE
	WILL REMAIN WITH SIZE GREATER THAN OR EQUAL TO CORMIN.  THUS, IT IS
	REASONABLY IMPORTANT THAT THE SYSTEM MANAGER EXERCISE CONSTRANT
	IN GRANTING LOCKING PRIVILEDGES.  THE FOLLOWING ARE SOME GUIDELINES
	FOR USING THE "LOCK" UUO.  THEY ARE SUBDIVIDED INTO GUIDELINES FOR
	NON-SWAPPING SYSTEMS AND SWAPPING SYSTEMS.

2.2.0	USING THE "LOCK" UUO IN NON-SWAPPING SYSTEMS

2.2.0.0	ANY NUMBER OF JOBS CAN BE LOCKED IN CORE WITHOUT FRAGMENTATION
	IF THEY ARE INITIATED IMMEDIATELY AFTER THE MONITOR IS LOADED.

2.2.0.1	DURING NORMAL TIME-SHARING, A JOB WILL BE LOCKED AT THE TOP OF USER
	MEMORY IF THERE IS A ZERO-HOLE LARGE ENOUGH TO CONTAIN IT.  OTHER-
	WISE, IT WILL BE LOCKED IN CORE AS LOW AS POSSIBLE.

2.2.0.2	LOCKING A JOB IN CORE WILL NEVER MAKE THE SYSTEM FAIL, BUT CAN
	MAKE IT POSSIBLE THAT ALL AVAILABLE CORE WILL NOT BE UTILIZED IN
	SOME JOB MIXES.

2.2.1	USE OF THE "LOCK" UUO IN SWAPPING SYSTEMS

2.2.1.0	AS LONG AS THERE ARE NO MORE THAN TWO JOBS LOCKED IN CORE, THERE
	WILL NEVER BE ANY MEMORY FRAGMENTATION.

2.2.1.1	WHENEVER NONE OF THE LOCKED JOBS RELINQUISH THEIR LOCKED STATUS,
	I.E., NO JOB WHICH EXECUTES A "LOCK" UUO TERMINATES, THERE WILL
	BE NO FRAGMENTATION.  THUS, JOBS WITH LOCKING PRIVILEGES SHOULD
	IN GENERAL BE PRODUCTION JOBS.

2.2.1.2	IF A JOB WHICH EXECUTES A "LOCK" UUO IS BEING DEBUGGED AND PRO-
	DUCTION JOBS WHICH ARE TO BE RUN MUST BE LOCKED IN CORE, THE JOB
	TO BE DEBUGGED SHOULD BE INITIATED FIRST AND SHOULD LOCK ITSELF IN
	CORE.  THEN, THE PRODUCTION JOBS SHOULD BE INITIATED.  THIS PRO-
	CEDURE WILL RESERVE THE SPACE AT THE TOP OF CORE FOR THE JOB
	BEING DEBUGGED AND GUARANTEE THAT THIS IS NO FRAGMENTATION AS IT
	LOCKS AND UNLOCKS.

2.2.1.3	CORMIN AND CORMAX

	CORMAX IS A PARAMETER WHICH THE SYSTEM MANAGER MAY USE TO RESTRICT
	THE SIZE OF THE LARGEST USER.  CORMIN IS A PARAMETER WHICH MAY
	BE USED TO RESTRICT THE AMOUNT OF USER MEMORY AVAILABLE TO
	LOCKED JOBS.  IN GENERAL, THE EFFECTS OF THE TWO PARAMETERS AND
	THEIR RELATIONSHIPS ARE AS FOLLOWS:  CORMIN EQUAL TO ZERO MEANS
	ALL OF USER MEMORY IS POTENTIALLY AVAILABLE TO LOCKED JOBS.
	CORMIN EQUAL TO THE SIZE OF USER MEMORY MEANS ANY JOB ATTEMPTING
	A LOCK UUO WILL RECEIVE AN ERROR RETURN.  CORMIN EQUAL TO CORMAX
	MEANS THAT THE LARGEST LEGAL JOB CAN EXECUTE AND THAT THE SIZE
	OF USER MEMORY MINUS CORMIN IS POTENTIALLY AVAILABLE TO LOCKED JOBS
	ON A FIRST COME FIRST SERVE BASIS.

2.3	UNLOCKING LOCKED JOBS

	A JOB RELINQUISHES ITS LOCKED STATUS WHENEVER A CALLI [SIXBIT/RESET/]
	IS EXECUTED BY THE USER PROGRAM OR THE MONITOR DOES AN IMPLICIT
	RESET FOR THE USER.  IMPLICIT RESETS OCCUR WHENEVER

2.3.0	THE USER PROGRAM EXECUTES A RUN UUO OR AN EXIT UUO WITH A ZERO
	AC FIELD.

2.3.1	WHENEVER THE USER TYPE ANY OF THE FOLLOWING MONITOR COMMANDS

2.3.1.0	R	(RUN A PROGRAM FROM DEVICE SYS)
2.3.1.1	RUN	(RUN A PROGRAM FROM A DEVICE OTHER THAN SYS)
2.3.1.2	GET	(GET A PROGRAM FROM A DEVICE)
2.3.1.3	SAVE	(SAVE A PROGRAM ON A DEVICE)
2.3.1.4	SSAVE	(SAVE A TWO SEGMENT PROGRAM ON A DEVICE)
2.3.1.5	CORE 0	(RETURN ALL CORE CURRENTLY ALLOCATED)
2.3.1.6	ANY CCL COMMAND

2.4	EFFECT ON OTHER UUOS AND MONITOR COMMANDS

	CORE UUOS AND CORE COMMANDS ARE UNSUCESSFULL IF AN ATTEMPT IS MADE
	TO CHANGE THE CORE ALLOCATION FOR A LOCKED SEGMENT AND THUS ALWAYS GIVE
	ERROR RESPONSES.  THEREFORE, THE USER SHOULD DETERMINE THE AMOUNT
	OF CORE NEEDED FOR THE EXECUTION OF HIS PROGRAM AND REQUEST IT
	BEFORE EXECUTING THE LOCK UUO.

3.0	GENERAL FLOW

	THE ROUTINES WHICH LOCK JOBS IN CORE ARE CONSIDERED TO BE A
	SHARABLE RESOURCE, SINCE THEY USE THE SWAPPING SERVICE ROUTINE
	AND THE CORE ALLOCATION ROUTINE.  THIS RESOURCE IS CALLED THE
	SEMI-PERMANENT CORE ALLOCATION RESOURCE AND HAS THE MNEMONIC
	"CA".  A JOB ENTERS THE QUEUE ASSOCIATED WITH THIS RESOURCE 
	WHENEVER IT DOES A LOCK UUO AND THE SYSTEM IS CURRENTLY ENGAGED
	IN DOING A LOCK UUO FOR ANOTHER JOB.  BECAUSE A JOB MAY HAVE
	TO "WAIT IN LINE" AND BECAUSE SWAPPING AND
	SHUFFLING MAY BE REQUIRED TO POSITION THE JOB WHERE IT IS TO
	BE LOCKED, THE ACTUAL EXECUTATION TIME TO COMPLETE THE PROCESS
	OF LOCKING THE JOB MIGHT BE ON THE ORDER OF SECONDS.  A JOB MAY BE LOCKED IN CORE
	IF THE FOLLOWING REQUIREMENTS ARE MET.  IF NONE CAN BE SATIS-
	FIED, AN ERROR RETURN IS GIVEN (N.B. PARENTHETICAL REMARKS APPLY
	ONLY TO SWAPPING SYSTEMS).

3.0.0	THE JOB IS PRIVILEGED.

3.0.1	WHENEVER THE SEMI-PERMANENT CORE ALLOCATION RESOURCE IS
	AVAILABLE, IF THE JOB, WHEN LOCKED, WILL NOT PREVENT AN
	EXISTING JOB FROM RUNNING.  THIS CONDITION IS NOT VIOLATED
	IF ANY OF THE FOLLOWING ARE TRUE:

3.0.1.0	THERE IS A ONE-HOLE AT THE TOP OF MEMORY, AND EITHER THE "UPPER
	EXTREMITY" IS LESS THAN MEMORY SIZE (JOB ISSUING THE LOCK
	UUO IS NOT CONTAINED IN THE LARGEST ONE-HOLE), OR "UPPER EXTREMITY" IS
	EQUAL TO MEMORY SIZE AND JOB SIZE PLUS "MINCOR" IS LESS THAN OR
	EQUAL TO THE SIZE OF THE LARGEST ONE-HOLE (JOB ISSUING THE
	LOCK UUO IS IN THE LARGEST ONE-HOLE BUT A LARGE ENOUGH ONE-HOLE
	WILL REMAIN AFTER IT IS LOCKED TO ALLOW THE LARGEST EXISTING
	JOB TO CONTINUE TO RUN).

3.0.1.1	THERE IS A ONE-HOLE IN LOW MEMORY AND EITHER "LOWER EXTREMITY"
	IS GREATER THAN THE LOW MEMORY ADDRESS PLUS THE JOB SIZE (JOB ISSUING
	THE LOCK UUO IS CONTAINED IN THE LARGEST ONE-HOLE) OR JOB
	SIZE PLUS "MINCOR" IS LESS THAN OR EQUAL TO THE SIZE OF THE
	LARGEST ONE-HOLE (JOB ISSUING THE LOCK UUO IS IN THE LARGEST ONE-HOLE
	BUT A LARGE ENOUGH ONE-HOLE WILL REMAIN AFTER IT IS LOCKED TO
	ALLOW THE LARGEST EXISTING JOB TO CONTINUE TO RUN).  

3.0.1.2	THERE IS A ONE-HOLE IN WHICH THE JOB WILL FIT ABOVE THE LARGEST
	ONE-HOLE (CAN ONLY HAPPEN IF FRAGMENTATION ALREADY EXISTS).

3.1	WHEN IT HAS BEEN ESTABLISHED THAT A JOB CAN BE LOCKED, THE LOW
	SEGMENT NUMBER AND THE HIGH SEGMENT NUMBER OR THE LOW SEGMENT
	NUMBER IF THERE IS NO HIGH SEGMENT, ARE STORED AS A FLAG TO
	ACTIVATE THE LOCKING PROCEDURES WHEN THE SWAPPER AND SHUFFLER
	ARE IDLE.  IN ADDITION, THE "IDEAL" POSITION FOR THE LOCKED
	JOB IS STORED AS A GOAL FOR THE LOCKING ROUTINE.  IN A SWAPPING
	SYSTEM, THE "IDEAL" WILL ALWAYS BE ACHIEVED GUARANTEEING MINIMUM
	FRAGMENTATION.  HOWEVER, IN THE NON-SWAPPING SYSTEM, MINIMUM
	FRAGMENTATION CAN ONLY BE ACHIEVED IF THE "IDEAL" LOCATION DOES
	NOT CONTAIN AN ACTIVE SEGMENT.
	FIGURE 1 ILLUSTRATES SEVERAL MEMORY LAYOUTS BEFORE AND AFTER
	EXECUTING LOCK UUOS.  FIGURES 1D AND 1E ARE EXAMPLES OF WORST
	CASE FRAGMENTATION RESULTING FROM A JOB ISSUING A LOCK UUO
	WHICH CAN BE SATISFIED BUT NOT BY PLACING THE JOB AT AN EXTREMITY
	(SEE 3.0.1.2).

3.2	IN SWAPPING SYSTEMS, AFTER THE JOB HAS BEEN LOCKED, THE LOCKING
	ROUTINE DETERMINES THE SIZE OF THE NEW LARGEST ONE-HOLE (N.B.
	THIS QUANITY MUST BE AT LEAST AS GREAT AS CORMIN).  CORMAX IS
	THEN SET EQUAL TO THE SMALLER OF THAT VALUE OR THE ORIGINAL
	VALUE SPECIFIED BY THE SYSTEM MANAGER AT ONCE ONLY OR MONGEN
	TIME.



		FIGURE	2.








	BEFORE					AFTER

!-----------------------!		!-----------------------!
!			!		!			!
!	MONITOR		!		!	MONITOR		!
!			!		!			!
!-----------------------!	_	!-----------------------!	_
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!-----------------------!	^	!///////////////////////!	^
! TIME-SHARING JOB	!	^	!///////////////////////!	^
! ISSUING LOCK UUO	!	^	!///////////////////////!	^
!-----------------------!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!     CORMAX	!///////////////////////!     CORMAX
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!-----------------------!	_
!///////////////////////!	^	! LOCKED JOB		!
!///////////////////////!	^	!			!
!-----------------------!	_	!-----------------------!



		FIGURE	2A.

MEMORY LAYOUT AFTER LOCKING JOB IN CORE.
UNLABLED AREAS REPRESENT ONE-HOLES.




	BEFORE					AFTER

!-----------------------!		!-----------------------!
!			!		!			!
!	MONITOR		!		!	MONITOR		!
!			!		!			!
!-----------------------!	_	!-----------------------!
!///////////////////////!	^	! LOCKED JOB		!
!///////////////////////!	^	!			!
!///////////////////////!	^	!-----------------------!	_
!-----------------------!	_	!///////////////////////!	^
! TIME-SHARING JOB	!	_	!///////////////////////!	^
! ISSUING LOCK UUO	!	_	!///////////////////////!	^
!-----------------------!	_	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!     CORMAX	!///////////////////////!     CORMAX
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!-----------------------!	_	!-----------------------!	_
! LOCKED JOB		!		! LOCKED JOB		!
!			!		!			!
!-----------------------!		!-----------------------!



		FIGURE	2B.

MEMORY LAYOUT AFTER LOCKING JOB IN CORE.
UNLABLED AREAS REPRESENT ONE-HOLES.




	BEFORE					AFTER

!-----------------------!		!-----------------------!
!			!		!			!
!	MONITOR		!		!	MONITOR		!
!			!		!			!
!-----------------------!		!-----------------------!
! LOCKED JOB		!		! LOCKED JOB		!
!			!		!			!
!-----------------------!	_	!-----------------------!
!///////////////////////!	^	! LOCKED JOB		!
!///////////////////////!	^	!			!
!-----------------------!	^	!-----------------------!	_
! TIME-SHARING JOB	!	^	!///////////////////////!	^
! ISSUING LOCK UUO	!	^	!///////////////////////!	^
!-----------------------!	^	!///////////////////////!	^
!///////////////////////!     CORMAX	!///////////////////////!     CORMAX
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!-----------------------!	_	!-----------------------!	_
! LOCKED JOB		!		! LOCKED JOB		!
!			!		!			!
!-----------------------!		!-----------------------!



		FIGURE	2C.

MEMORY LAYOUT AFTER LOCKING JOB IN CORE.
UNLABLED AREAS REPRESENT ONE-HOLES.




	BEFORE					AFTER

!-----------------------!		!-----------------------!
!			!		!			!
!	MONITOR		!		!	MONITOR		!
!			!		!			!
!-----------------------!		!-----------------------!
!///////////////////////!		!///////////////////////!	
!///////////////////////!		!///////////////////////!	
!-----------------------!		!-----------------------!
! LOCKED JOB		!		! LOCKED JOB		!
!			!		!			!
!-----------------------!	_	!-----------------------!
!///////////////////////!	^	! LOCKED JOB		!
!///////////////////////!	^	!			!
!-----------------------!	^	!			!
! TIME-SHARING JOB	!	^	!-----------------------!	_
! ISSUING LOCK UUO	!	^	!///////////////////////!	^
!			!     CORMAX	!///////////////////////!     CORMAX
!-----------------------!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!-----------------------!	_	!-----------------------!	_
! LOCKED JOB		!		! LOCKED JOB		!
!			!		!			!
!-----------------------!		!-----------------------!



		FIGURE	2D.

MEMORY LAYOUT AFTER LOCKING JOB IN CORE (EXAMPLE OF FRAGMENTATION
CAUSED BY A LOCKED JOB TERMINATING).
UNLABLED AREAS REPRESENT ONE-HOLES.




	BEFORE					AFTER

!-----------------------!		!-----------------------!
!			!		!			!
!	MONITOR		!		!	MONITOR		!
!			!		!			!
!-----------------------!	_	!-----------------------!	_
! TIME-SHARING JOB	!	^	!///////////////////////!	^
! ISSUING LOCK UUO	!	^	!///////////////////////!	^
!-----------------------!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!     CORMAX	!///////////////////////!     CORMAX
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!///////////////////////!	^	!///////////////////////!	^
!-----------------------!	_	!-----------------------!	_
! LOCKED JOB		!		! LOCKED JOB		!
!-----------------------!		!-----------------------!
!///////////////////////!		! LOCKED JOB		!
!///////////////////////!		!			!
!///////////////////////!		!			!
!///////////////////////!		!-----------------------!
!///////////////////////!		!///////////////////////!	
!///////////////////////!		!///////////////////////!	
!-----------------------!		!-----------------------!
! LOCKED JOB		!		! LOCKED JOB		!
!			!		!			!
!-----------------------!		!-----------------------!



		FIGURE	2E.

MEMORY LAYOUT AFTER LOCKING JOB IN CORE (EXAMPLE OF FRAGMENTATION
INCREASED BY THE REQUIREMENT ON THE SIZE OF THE LARGEST ONE-HOLE).
UNLABLED AREAS REPRESENT ONE-HOLES.

4.0	CORE REQUIREMENTS

4.1	JOB TABLES

	NONE.

4.2	VARIABLES IN COMMON

4.2.0	LOCK

	LOCK CONTAINS LOW SEGMENT NUMBER IF NO HIGH SEGMENT NUMBER OR
	HIGH SEGMENT IS LOCKED.  OTHERWISE, IT CONTAINS BOTH THE LOW
	AND HIGH SEGMENT NUMBERS.

4.2.1	LOKREL

	LOKREL CONTAINS THE "IDEAL" LOCATION FOR LOW OR HIGH SEGMENT
	BEING LOCKED.

4.2.2	HOLEF1

	HOLEF1 CONTAINS "LOWER EXTREMITY".

4.2.3	HOLTOP

	HOLTOP CONTAINS "UPPER EXTREMITY".

4.2.4	CORTAB

	CORTAB CONTAINS ZERO-CORE, ONE-CORE, AND TWO-CORE INDICATORS.

4.2.5	CORMIN

	CORMIN CONTAINS THE VALUE OF "CORMIN"

4.2.6	CORMAX

	CORMAX CONTAINS THE CURRENT VALUE OF "CORMAX"

4.3	CODE CORE REQUIREMENTS

	THE MODULE FOR LOCKING JOBS IN CORE REQUIRES APPROXIMATELY THREE
	HUNDRED WORDS OF MEMORY IN THE SWAPPING SYSTEM, AND ABOUT ONE
	HUNDRED WORDS OF CORE IN THE NON-SWAPPING SYSTEM.

5.0	MONITOR BUILDING CONSIDERATIONS

5.1	MONGEN QUESTIONS

	MONGEN WILL ASK THE FOLLOWING QUESTIONS:

	"DO YOU WANT TO LOCK JOBS IN CORE?"

	IF THE ANSWER IS NO, FIVE OR SIX WORDS OF ADDITIONAL CODE IS
	GENERATED IN COMMON TO CREATE A DUMMY LOCKING MODULE.  IF THE 
	ANSWER IS YES, THE MODULE "LOKCON" IS LOADED FROM THE MONITOR 
	REL LIBRARY  DURING THE LOADERS LIBRARY SEARCH.

	"WHAT IS THE MINIMUM AMOUNT OF CORE (IN K) TO BE GUARANTEED TO JOBS
	THAT ARE NOT LOCKED? [0 ASSUMES STANDARD]"

	IF THE ANSWER IS 0, THEN CORMIN IS EQUATED TO THE RESPONSE
	WHICH ESTABLISHES CORMAX.  OTHERWISE, THE ASSUMED VALUE OF CORMIN
	AT ONCE ONLY TIME WILL BE WHATEVER THE SYSTEM BUILDER RESPONDED.

5.2	FEATURE CONDITIONALS

	IF THE MONITOR IS ASSEMBLED WITH THE FEATURE SWITCH "FTLOCK"
	SET EQUAL TO ZERO, APPROXIMATELY 30 LOCATIONS IN THE SWAPPING
	SYSTEM AND 35 LOCATIONS IN THE NON-SWAPPING SYSTEM WILL BE
	SAVED.

5.3	ASSEMBLY INSTRUCTIONS

	SAME AS THE REST OF THE MONITOR SOURCES, I.E.,

	.COMPILE LOCKON=S+FTNNX+LOKCON
	-

5.4	"REL" FILES LOADED

	THE MODULE "LOKCON" IS LOADED IF MONGEN QUESTION IS ANSWERED
	IN THE AFFIRMATIVE.  OTHERWISE, AN EXTRA FOUR OR FIVE WORDS
	IN COMMON ARE ASSEMBLED TO FORM DUMMY LOCKING ROUTINE RESOLVING
	GLOBAL REFERENCES AND SATISFYING SUBROUTINE CALLS.

6.0	ONCE ONLY

6.1	QUESTIONS

	ONCE WILL ASK THE FOLLOWING QUESTION:

	"MINIMUM AMOUNT OF CORE GUARANTEED TO SWAPPABLE JOBS IS XXXK
	TYPE DESIRED MINIMUM"

	A RESPONSE OF <CR> WILL SET CORMIN EQUAL TO CORMAX.  ANY OTHER
	VALID ANSWER WILL SET CORMIN TO THE RESPONSE.

6.2	CORE SPACE ASSIGNED

	ONCE ONLY HAS BEEN MODIFIED TO ALWAYS SET SYSTEM SIZE TO A
	BOUNDARY EVENLY DIVISABLE BY 2000(8) (EXTRA CODE ONLY IN
	NON-SWAPPING SYSTEMS).

7.0	TEST PROGRAMS

	THE TEST PROGRAM IS CALLED TLOCK.  THE FIRST QUESTION IT ASKS
	IS IF AN EXPLAINATION IS DESIRED.  IF THIS QUESTION IS ANSWERED
	IN THE AFFIRMATIVE, THE OPERATING INSTRUCTIONS AND AN EXPLAINATION
	OF THE OUTPUT OF THE PROGRAM IS TYPED.

8.0	CODING TECHNIQUES

8.1	REGISTER USAGE

8.1.0	IN THE FOUR SERIES MONITOR, THE REGISTER USAGE CONVENTIONS WILL
	CONFORM TO THOSE ESTABLISHED IN THE FOUR SERIES MODULES "CORE1"
	AND "SCHED".

8.1.1	WHEN "LOKCON" IS INTEGRATED INTO THE FIVE SERIES MONITOR, THE
	REGISTER USAGE CONVENTIONS IN "LOKCON" AND "CORE1" WILL BE MADE
	TO CONFORM TO THE LEVEL D STANDARDS.

8.2	SUBROUTINE CONVENTIONS

	SAME AS LEVEL D.

8.3	EDITING CONVENTIONS

	SAME AS LEVEL D.
   