.SBTTL	INTRODUCTION
	.TITLE	AST8
	.IDENT	"VOO3E"
;
;
;
;
;
;
;    COPYRIGHT (C) 1974, DIGITAL EQUIPMENT CORP., MAYNARD, MASSACHUSETTS 01754.
;      
;      
;    THE SOFTWARE DESCRIBED IN THIS DOCUMENT, INCLUDING BUT NOT LIMITED TO, IN-
;    STRUCTION EXECUTION TIMES AND OPERATING SPEEDS IS FOR INFORMATION PURPOSES
;    ONLY.   ALL  SUCH  MATERIAL  IS  SUBJECT   TO   CHANGE   WITHOUT   NOTICE.
;    CONSEQUENTLY  DIGITAL MAKES NO CLAIM AND SHALL NOT BE LIABLE FOR ITS ACCU-
;    RACY.
;      
;    THE SOFTWARE DESCRIBED IS FURNISHED TO THE PURCHASER UNDER A  LICENSE  FOR
;    USE  ON  A SINGLE COMPUTER SYSTEM AND CAN BE COPIED (WITH THE INCLUSION OF
;    DIGITAL'S COPYRIGHT NOTICE) ONLY FOR USE IN SUCH  SYSTEM,  EXCEPT  AS  MAY
;    OTHERWISE BE PROVIDED IN WRITING BY DIGITAL.
;      
;    DIGITAL ASSUMES NO RESPONSIBILITY  FOR  THE  USE  OR  RELIABILITY  OF  ITS
;    SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
;      
;      
;    UNLESS SPECIFIED OTHERWISE, THE TERMS "RSX" AND "RSX-11"  IN THIS DOCUMENT 
;    IMPLY "RSX-11D".
;
;
;
;
;	VERSION:	VOO3E
;	AUTHOR:		R. KLEINMAN
;	DATE:		5 FEB 74
;
;
;   THIS MODULE CONTAINS
;	1-- CODE FOR EVALUATE
;
;
	.PAGE
;+
;THIS OVERLAY TO EVALU8 WILL HANDLE GATHERING OF DATA FOR THE
;TABLES LOCATED IN THE ROOT SEGMENT. IT CONSISTS OF AN AST PROCESSOR.
;
;THE ASTS WILL STOP OCCURRING WHEN:
;	A.  A RESUME OCCURS TO THE ROOT TASK [IF SET UP THAT WAY]
;	B.  THE TASK IS RUNNING FOR A SPECIFIED TIME
;
;
;CASE "B" CAN ONLY OCCUR WHEN NO "RESUME" HAS BEEN
;ISSUED FOR THE ROOT TASK.  IT FORCES THE AST TO NOT ISSUE
;A NEW MARK TIME AST, AND TO RESUME THE TASK.
;
;SEQUENCE OF EVENTS:  THE AST DOES THE FOLLOWING
;
;	A.  SAVES ALL REGISTERS
;	B.  FOR EACH PARTITION IN THE TPD [TO THE FIRST 0 ENTRY IN THE TPD'N TABLE]
;
;	   1.  FINDS THE SMALLEST HOLE- INSERTS IF LESS THAN PREVIOUS MINIMUM
;	   2.  FINDS THE LARGEST HOLE- INSERTS IF GREATER THAN PREVIOUS MAXIMUM
;	   3.  ADDS # FREE 32 WORD CHUNKS TO RUNNING TOTAL
;
;	C.  FOR THE POOL, STEPS 1-3 ABOVE ARE DONE FOR THE # OF FREE NODES
;	D.  FOR EACH TASK ENCOUNTERED IN THE ATL OR MRL
;
;	   1.  AN ENTRY IS MADE [IF NOT PRESENT AND THERE IS ROOM] IN THE
;	       TASK TABLES
;	   2.  AN INCREMENT IS MADE IN THE APPROPRIATE TABLE ENTRY FOR ITS CURRENT
;	   3.  AN INCREMENT IS MADE IF ITS STATUS IS AST OR RUNNING
;	   4.  AN INCREMENT IS MADE IF IT IS LOCATED DIRECTLY BELOW EVALU8 IN
;	       THE ATL, AND IS THE FIRST TASK CAPABLE OF RUNNING
;	E.  THE "SNAPSHOT #" IS DECREMENTED, AND IF NOT=0, A MARK-TIME AST
;	    IS REISSUED.  IF "SNAPSHOT #"=0, THE EVALU8 TASK IS RESUMED
;TOTAL OVERLAY STRUCTURE:[EVALU8-(AST8,RPU8M-(RPU8A,RPU8B,RPU8C))]
	.PAGE
	.SBTTL	AST CODE:TPD
	.MCALL	CALL
	.MCALL	RETURN
	.LIST	MEB
				;
				;
	.MACRO	ENABL
	MOV	(SP)+,@#PSW	;ENABLE INTERRUPTS, TASK SWITCHING
	.ENDM
				;
	.MACRO	INHIB
	MOV	@#PSW,-(SP)	;INHIBIT INTERRUPTS
	BIS	#340,@#PSW
	.ENDM
				;
	.MACRO	DPADD	A,B
	ADD	A,2+B
	ADC	B
	.ENDM
				;
	.MACRO	INHTS		;INHIBIT TASK SWITCHING
	MOV	@#PSW,-(SP)
	BIS	#140,@#PSW
	.ENDM
ATP2J:	JMP	ATP2		;BRANCH AID
;AST BEGINS
;
AST::				;SAVE REGISTERS
	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)
				;
;REGISTER USAGE FOR TPD SEGMENT
;
;R0=TPD TABLE POINTER
;R1=RUNNING HOLE SIZE
;R2=LARGEST HOLE SIZE
;R3=TPD HOLE POINTER IN EXEC
;				;
	MOV	#TPDTBS,R0
ATP1:				;SET UP FOR NEXT ENTRY
	MOV	(R0),R3		;GET NEXT TPD ENTRY ADDRESS
	BEQ	ATP2J		;IF=0, TABLE COMPLETE, EXIT
	CLR	R1		;ELSE 0 RUNNING HOLE, LARGEST HOLE SIZE
	CLR	R2
	INHTS			;INHIBIT TASK SWITCH[PRI 3]
	BIT	#TF.UC,T.FW(R3) ;;IS THIS A USER PARTITION?
	BEQ	8$		;;NO.  GO ON
	BIT	#TF.OU,T.FW(R3) ;;YES.  IS IT OCCUPIED?
	BEQ	5$
	INC	AP.SM(R0)	;;IF YES, BUMP "SEEN"
5$:
	ENABL			;;END OF THIS PARTITION
	BR	30$
8$:				;;SYSTEM PARTITION
	MOV	T.HP(R3),R3	;;GET FIRST HOLE POINTER
	BEQ	20$		;;IF NO HOLE, FINISH UP
10$:				;;YES.  NEW HOLE.  SWAP PAGE LOCATION TO GET IN
	MOV	#ASR3F,-(SP)	;;DESCRIPTOR AND ADDRESS
	MOV	R3,-(SP)	;;
	CALL	..SPD3		;;SWAPPED
	MOV	60002,R4	;;GET SIZE OF HOLE
	ADD	R4,R1		;;ADD TO RUNNING TOTAL
	CMP	R4,R2		;;IS IT BIGGER THAN LARGEST HOLE?
	BLT	15$		;;NO.  GO ON
	MOV	R4,R2		;;YES.  STORE IT AS LARGEST HOLE
	.PAGE
15$:				;;POP OUT OLD ASR'S FROM STACK
	CMP	(SP)+,(SP)+	;;
	MOV	60000,R3	;;MORE HOLES IN PARTITION
	BNE	10$		;;OH GOD YES.  DO IT AGAIN!
20$:				;;NO.  END OF HOLES FOR THIS PARTITION
	ENABL			;ENABLE TASK SWITCHING
				;
				;ADD IN TOTAL # HOLE SEGMENTS TO
	DPADD	R1,AP.HM(R0)	;RUNNING TOTAL FOR THIS PARTITION
				;
				;ADD IN LARGEST HOLE SEGMENT TO
	DPADD	R2,AP.LM(R0)	;RUNNING TOTAL FOR THIS PARTITON
				;
				;INSERT TOTAL # HOLE SEGMENTS IN TPD
				;TABLE IF THE RECORD FOR THIS ENTRY
	CMP	R1,AP.LG(R0)
	BLE	25$
	MOV	R1,AP.LG(R0)	;ITS > MAXIMUM.  INSERT IT
25$:
	CMP	R1,AP.SM(R0)
	BGE	30$
	MOV	R1,AP.SM(R0)	;ITS < MINIMUM.  INSERT IT
				;
30$:				;ALL DONE WITH PARTITION FOR THIS SNAPSHOT
	CALL	MRLS		;SEARCH MRL FOR LOADING/CHECKPOINTED TASKS
	ADD	#AP.SZ,R0	;ADVANCE TPD TABLE POINTER.  START AGAIN
	JMP	ATP1
	.PAGE
	.SBTTL	AST CODE:POOL
;REGISTER USAGE FOR POOL SEGMENT
;
;R0=POOL TABLE POINTER
;R1=RUNNING FREE NODE COUNT
;R2=LISTHEAD FOR POOL
;R3=CURRENT POOL NODE ADDRESS
;
ATP2:
	MOV	#PLTBS,R0	;INITIALIZE REGISTERS
	CLR	R1
	MOV	#.POLLH,R2	;ADDRESS OF LISTHEAD
	INHIB			;INHIBIT INTERRUPTS
				;;;
	MOV	(R2),R3		;;;
20$:				;;;ANY MORE NODES IN POOL
	CMP	R2,R3		;;;
	BEQ	30$		;;;NO.  EXIT
	INC	R1		;;YES.  BUMP COUNT.  GET NEXT ONE
	MOV	(R3),R3		;;;
	BR	20$		;;;
30$:				;;;INSERT DATA IN POOL TABLE
	ENABL			;;;ENABLE INTERRUPTS
				;[R1 HAS TOTAL # POOL NODES]
	DPADD	R1,AL.FS(R0)	;ADD TO RUNNING SUM
	CMP	R1,AL.LG(R0)	;REPLACE POOL TABLE ENTRY IF # NODES ARE:
	BLE	35$
	MOV	R1,AL.LG(R0)	;> MAXIMUM, OR
35$:
	CMP	R1,AL.SM(R0)
	BGE	40$
	MOV	R1,AL.SM(R0)	;< MINIMUM
40$:					;GO TO TASK SECTION
	BR	ATP3
	.PAGE
	.SBTTL	AST CODE - ATL STATUS TABLE
;+
;EACH BYTE IN THIS TABLE COORESPONDS TO HALF AN ATL STATUS[+2,+4 ETC]
;THE VALUE OF THE OFFSET IS THE WORD IN THE ATL TABLE TO BUMP IF
;THE STATUS IS PRESENT.  BYTE 0 CONTAINS THE # OF CODES IN THE TABLE
;-
STTB:	.BYTE	30		;MAX SIZE OF TABLE
	.BYTE	AT.LC		;2-TASK LOAD REQ Q'D
	.BYTE	AT.LC		;4-TASK LOAD REQ SUC
	.BYTE	AT.LC		;6-TASK LOAD REQ FAIL
	.BYTE	AT.RA		;10-TASK RUNNING
	.BYTE	0		;12-TASK AST Q'D
	.BYTE	AT.SP		;14-TASK SUSPENDED
	.BYTE	AT.W4		;16-WT4 EV FLG 1-16
	.BYTE	AT.W4		;20-WT4 EV FLG 17-32
	.BYTE	AT.W4		;22-WT4 EV FLG 33-48
	.BYTE	AT.W4		;24-WTH EV FLG 49-64
	.BYTE	AT.W4		;26-WT4 EV FLG 1-64
	.BYTE	0		;30-TASK EXITED [DON'T LOG]
	.BYTE	AT.RT		;32-TASK I/O RUNDOWN REQUIRED
	.BYTE	AT.RT		;34-TASK I/O RUNDOWN IN PROG
	.BYTE	AT.RT		;36-TASK I/O RUNDOWN PART FINISHED
	.BYTE	AT.RT		;40-TASK I/O RUNDOWN FAILURE
	.BYTE	AT.RT		;42-TASK TERMINATED
	.BYTE	AT.RT		;44-TASK TERMINATION NOTICE REQUESTED
	.BYTE	AT.RT		;46-TASK SUSPENDED TILL NOTICE OUTPUT
	.BYTE 	AT.LC		;50-TASK SUSPENDED FOR CHECKPOINTING
	.BYTE	AT.LC		;52-TASK RECORD REQUEST Q'D
	.BYTE	AT.LC		;54-TASK RECORD REQUEST SUC
	.BYTE 	AT.LC		;56-TASK RECORD REQUEST FAILED
	.BYTE	0		;60-TASK PARITY ERROR[SUSPENDED]
	.EVEN
	.PAGE
	.SBTTL	AST CODE:TASK DATA
;REGISTER USAGE
;
;R0=TASK TABLE POINTER
;R1=ATL POINTER IN EXEC
;R2=ATL TEMPORY OFFSET POINTER,R5=TABLE TEMPORARY OFFSET POINTER
;R3=FLAGS WORD:  BIT 0 CLEAR IF HIGHEST RUNNABLE TASK NOT SEEN
;R4=# OF ENTRY IN TABLE
ATP3:
	CLR	R3		;INITIALIZE FLAGS WORD
	MOV	#.ATLLH,R1	;GET START OF ATL
	INHTS			;INHIBIT TASK SWITCHING
10$:				;;GET NEXT ATL ENTRY
	MOV	(R1),R1
	CMP	@#.CRTSK,R1	;;IS IT THIS TASK?
	BEQ	10$		;;YES.  TRY NEXT
	MOV	A.TD(R1),R2	;;NO.  IS IT THE NULL TASK?
	BEQ	50$		;;YES.  END OF THIS PASS
	CALL	TASPUT		;NO.  INSERT NAME
				;AND PROCESS STATUS
	BR	10$		;GET NEXT ENTRY
50$:				;;PROCESS NULL TASK
	MOV	#TASTBN,R0
	CALL	TASPR
	ENABL			;;REENABLE TASK SWITCHING
	INC	TTIME		; INCREMENT SWAPSHOT #
	DEC	BFNSS		;IS THIS THE LAST ONE?
	BEQ	80$		;YES.  RESUME TASK.  DON'T ISSUE AST
				;NO.  REISSUE NEW MARK TIME AST
	MOV	#DPASTM,-(SP)
	EMT	377
	BR	ASTEX		;EXIT AST
80$:				;
	MOV	#DPRES,-(SP)	;ALL DONE.  RESUME TASK
	EMT	377
				;
ASTEX:				;EXIT AST-RESTORE REGISTERS
	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	TST	(SP)+		;POP OFF DIRECTIVE STATUS FOR AST
	MOV	#DPASTX,-(SP)
	EMT	377
	.PAGE
;SUBROUTINE TO PROCESS TASK IN ATL FOR COORESPONDING TABLE ENTRY
;R0 POINTS AT TABLE ENTRY, R1 POINTS AT ATL NODE;R3=RUNNABLE FLAG;R5 ALTERED
TASPR:				;;PROCESS ENTRY
	INC	AT.AC(R0)	;;BUMP # TIMES SEEN
	MOVB	A.AS(R1),R5	;;CHECK IF AST IN PROGRESS
	BNE	80$		;;IT IS.  USE STATUS IN "PREV STAT"
	MOVB	A.TS(R1),R5	;;NO.  GET CURRENT STATUS
80$:				;;STATUS IN R5, DIVIDE BY 2, INDEX
	ASR	R5		;;THROUGH TABLE
	MOVB	STTB(R5),R5	;;OFFSET OF WORD TO BUMP IN R5
	BEQ	90$		;;IF=0, DO NO BUMP
	ADD	R0,R5		;;OTHERWISE BUMP LOCATION
	INC	(R5)
90$:				;;IF STATUS RUNNABLE, CHECK IF TASK
	SUB	R0,R5		;;RESTORE R5 TO STATUS OFFSET
	CMP	#AT.RA,R5	;;COULD RUN
	BNE	ASTBR
	TST	R3		;;IT COULD RUN.  IS THIS THE FIRST SUCH TASK?
	BNE	ASTBR		;;NO.  GO ON
	INC	AT.RN(R0)	;;YES.  BUMP "RUNNING"
	INC	R3		;;AND LOCKOUT MORE
ASTBR::	RETURN			;;ALL UPDATED.  GO BACK FOR NEW ATL TASK
				;;THIS IS ALSO ROOT CALL TO FORCE AST8 IN
	.PAGE
;+
;SUBROUTINE TO IDENTIFY MRL NODES [= ATL NODES] FOR SPECIFIC
;PARTITION.  WHEN FOUND, THE TASK TABLE ENTRY STATUS WILL BE
;APPROPRIATELY BUMPED
;
;INPUT:
;
;R0=TPD TABLE POINTER
;
;REGISTER:  USAGE [ALTERED]
;
;R1=MRL NODE POINTER
;R2=MRL LISTHEAD
;R3=RUNNABLE FLAG
;	R4,R5 ALTERED
;-
MRLS:
	MOV	#1,R3		;SET "NON RUNNABLE"
	INHTS			;INHIBIT TASK SWITCHING
	MOV	(R0),R2		;;GET START OF TPD.
	ADD	#T.RF,R2	;;GET MRL LISTHEAD ADD
	MOV	(R2),R1		;;AND NEXT MRL NODE
10$:				;;IS MRL OVER?
	CMP	R1,R2
	BNE	20$
	ENABL
	RETURN			;YES.  GO ONTO NEXT PARTITION
20$:				;;NO.  PROCESS THIS NODE
	CALL	TASPUT
	MOV	(R1),R1		;;GET NEXT MRL NODE
	BR	10$		;;TRY TO PROCESS AGAIN
	.PAGE
;+
;SUBROUTINE TO COMPLETELY PROCESS AN ATL [OR MRL] NODE FOR THIS
;SNAPSHOT.
;
;INPUT
;
;R1=POINTS AT ATL NODE
;
;REGISTER USAGE:
;
;R0=TASK TABLE ENTRY
;R1=ATL NODE
;R2=STD POINTER
;R3=RUNNABLE FLAG
;
;R4,R5 TEMPORARY, ALTERED
;
;OUTPUT:IF NO ENTRY IN TASK TABLE, AND NO ROOM, JUST RETURN
;	IF NO ENTRY IN TASK TABLE, AND ROOM, ENTRY IS CREATED
;	WHEN ENTRY FOUND, APPROPRIATE STATUS IS BUMPED.
;-
TASPUT:				;;SAVE REGISTERS
	MOV	R0, -(SP)
	MOV	R2, -(SP)
	MOV	#TASTBS,R0	;;PUT R0 AT START OF TASK TABLES
	MOV	#TASNUM,R4	;;INITIALIZE ENTRY #
	MOV	A.TD(R1),R2	;;STD PTR
20$:				;;
	TST	(R0)		;;ATTEMPT TO MATCH TASK NAME TO TABLE
	BEQ	60$		;;TABLE OVER.  INSERT THIS ENTRY
				;;MORE IN TABLE
	CMP	AT.NM(R0),S.TN(R2) ;;IS THIS A MATCH?
	BNE	30$
	CMP	AT.NM+2(R0),S.TN+2(R2)
	BEQ	70$		;;YES.  PROCESS IT
30$:				;;NO.  TRY AGAIN ON NEXT TABLE ENTRY
	ADD	#AT.SZ,R0	;;ADVANCE PTR
	SOB	R4,20$		;;GO BACK IF ROOM LEFT IN TABLE
				;;
40$:				;;NO MORE ROOM IN TABLE TO PUT NEW TASK.  GIVE UP
				;;GO BACK AND GET NEXT ENTRY
	MOV	(SP)+,R2	;;RESTORE REGISTER, RETURN
	MOV	(SP)+,R0
	RETURN
60$:				;;TABLE OVER.  INSERT STD ENTRY
	MOV	S.TN(R2),AT.NM(R0)
	MOV	S.TN+2(R2),AT.NM+2(R0)
70$:					;;PROCESS ENTRY
	CALL	TASPR
	BR	40$		;;GO BACK FOR MORE
	.END
	.PAGE