.ENABL	LC
	.TITLE	PROBE - PROBE FOR AND OUTPUT SYSTEM STATISTICS
	.IDENT	/X02.01/

; VERSION 1	7/80	ART PERLO	YALE UNIVERSITY
;	  1.01	12/80	R. NANCE	JCI/SSO
;			CHANGED TO ALLOW TO CONTINUE TIMING PAST OUTPUT
;			CHANGED TO OUTPUT TASK ID OF LAST USER TASK
;	  2.00	7/81	R. NANCE	JCI/SSO
;			CHANGED TO OUTPUT LAST MODULE W/ TRACE CALLED
;			CHANGED TO OUTPUT TABLE OF MODULES CALLED BY
;			- TASKS W/ SPECIAL TR:NAMES ROUTINE
;			CHANGED TO KEEP TRACK OF TSKNAM IN RESIDENT COMMON
;			- SO AS TO BE ABLE TO MORE FAIRLY CHARGE MODULES.
;			ADDED PARTIAL SORTING OF MODULE STATUSES
;			ADDED RESTART CAPABILITY
;	  2.01	9/81	REFORMATTED SCREEN AND CHANGED TO VT100
;			CHANGED TO LOCATE MODULE INFO INDEPENDENTLY OF A
;			- RESIDENT COMMON (LOCATES TASKS TRACE LIST POINTER)
;
; MAC PROBE=LB:[200,200]RSXMC/PA:1,[1,1]EXEMC/ML,SY:'<UIC>'PROBE
; TKB> PROBE/PR,PROBE/-SP=PROBE,LB:[1,54]RSX11M.STB/SS,[1,1]EXELIB/LB
; TKB> /
; TKB> STACK=32
; TKB> UNITS=1
; TKB> ASG=TI:1
; TKB> TASK=PROBE
; TKB> PRI=230
; TKB> //

;+
; PROGRAM TO PROBE FOR SYSTEM STATUS.
; PROBE KEEPS TRACK OF 4 COUNTERS:
;	INTTIM	TIME SPENT IN ALL DRIVER INTERRUPT ROUTINES
;	SYSTIM	TIME SPENT IN SYSTEM STATE
;	USRTIM	TIME SPENT IN USER STATE
;	NULTIM	TIME SPENT TWIDDLING BITS
;	AND OUTPUTS THE LAST TASK IN USER MODE PER SAMPLE
;	AND THE LAST MODULE W/ TRACE
; PROBE ALSO OUTPUTS TABLE OF COUNTS OF MODULES AND CALLING TASK.
;
;-
	.PAGE
	.SBTTL	CONSTANT DECLARATIONS

TI     = 1				;TI: LUN
CR     = 15
LF     = 12
ESC    = 33
SPACE  = 40
SPACES = 20040				;TWO SPACES
QEF    = 1				;EVENT FLAG FOR QIOW
WTFLAG = 2				;EVENT FLAG TO TIME PROBING
GOFLAG = 52.				;EVENT FLAG TO START PROBING
TIMTYP = 1				;TIMING INTERVAL TYPE
INTRVL = 15.				;TIME INTERVAL OF ABOVE TYPE
NUMINT = 40.				;# OF TASK NAME INTERVALS/TIME UPDATE

INFSIZ = 6				;# OF INFO WORDS IN ISR
PMODE  = 30000				;PREVIOUS MODE BITS IN PS
$$CVEC = 100				;SYSTEM CLOCK VECTOR

MODNUM = 16.				;# OF MODULES KEPT TRACK OF IN TABLE+1
TSKNUM = 5.
	.PAGE
	.SBTTL	MACRO DECLARATIONS

	.MCALL	QIOW$,QIOW$S,EXIT$S,DIR$,WTSE$S,CLEF$S,SETF$S,MRKT$S
	.MCALL	TCBDF$,PCBDF$,HDRDF$,HWDDF$

	HWDDF$
	PCBDF$
	TCBDF$
	HDRDF$

	.MACRO	OUT,BUFNUM
	MOV	#P'BUFNUM,QWDIR+Q.IOPL
	MOV	#LP'BUFNUM,QWDIR+Q.IOPL+2
	DIR$	#QWDIR
	.ENDM

	.MACRO	MOVEW,SRC,DEST,NUMBER,?LABEL
	.NTYPE	SRCTYP,SRC
	.NTYPE	DESTYP,DEST
	.NTYPE	NUMTYP,NUMBER
	.IF	NE	SRCTYP
	MOV	SRC,R0
	.ENDC
	.IF	NE	DESTYP-1
	MOV	DEST,R1
	.ENDC
	.IF	NE	NUMTYP-2
	MOV	NUMBER,R2
	.ENDC
LABEL:	MOV	(R0)+,(R1)+
	SOB	R2,LABEL
	.ENDM
	.PAGE
	.SBTTL	LOCAL STORAGE - MESSAGES AND OTHER DECLARATIONS

P1:	.ASCII	<ESC>^[2J^<ESC>^[1;1H^		;CLEAR SCREEN CHARS FOR VT100
LP1 = .-P1

P2:	.ASCII <CR><LF>^ERROR ALLOCATING BLOCK^
LP2 = .-P2

	.EVEN
P3:	.ASCII	<CR>^TASK:^
P3A:	.BLKB	6
LP3 = .-P3
LOP3 = <. - P3A> / 2			;IN WORDS
P3END:
	.PAGE
P4:
	.ASCII	<ESC>^[J^<CR><LF>^INTTIM: ^
P4A:	.BLKB	5
	.ASCII	<CR><LF>^SYSTIM: ^
P4B:	.BLKB	5
	.ASCII	<CR><LF>^USRTIM: ^
P4C:	.BLKB	5
	.ASCII	<CR><LF>^NULTIM: ^
P4D:	.BLKB	5
	.ASCII	<CR><LF>^TOTAL SAMPLES: ^
TOTLBF:	.BLKB	5
	.ASCII	^ UNCOUNTED: ^
OTHRBF:	.BLKB	5
	.ASCII	<CR><LF>
MODBUF:	.BLKB	<MODNUM+1>*<TSKNUM*12.+2>
	.ASCII	<ESC>^[1;12H^<ESC>^[K^	;VT100 ESC SEQ. -> END(TOP LN)
LP4 = .-P4

P5:	.ASCII	<ESC>^[23;1H^		;VT100 ESC SEQ. -> 23RD LINE
LP5 = .-P5
	.PAGE
	.EVEN
QWDIR:	QIOW$	IO.WLB,TI,QEF,,ISB,,<P4,LP4,,,,0>
ISB:	.BLKW	2			;FOR IO STATUS BLOCK
TKTIM:	.WORD	0			;TASK NAME OUTPUT COUNTER
ISRPT:	.WORD	0			;-> ISR IN SYSTEM POOL
OLDP3:	.BLKW	LOP3			;LAST TERMINAL TOP LINE OUTPUT
OP3END:
MODNAM:	.BLKW	2.			;RETRIEVED MODULE NAME IN RAD50
TKNAML:	.BLKW	TSKNUM*2		;TASK NAME LIST
MONAML:	.BLKW	TSKNUM*MODNUM*2		;MODULE NAME LISTS
TKDATA:	.BLKW	TSKNUM			;TASK LIST COUNTERS
MODATA:	.BLKW	TSKNUM*MODNUM		;MODULE LISTS' COUNTERS
TSKPTR:	.WORD	0			;FIRST AVAIL TASK SLOT
MODPTR:	.BLKW	TSKNUM			;FIRST AVAIL MODULE SLOT FOR EACH TASK
ODTPTR:	.WORD	0			;USED TO TRAVERSE COUNTS FOR OUTPUT
OTHRTM:	.WORD	0			;TIME NOT CHARGED TO MODULE IN TABLE
TOTLTM:	.WORD	0			;TOTAL NUMBER OF SAMPLES
	.EVEN
	.PAGE
	.SBTTL	PROBE MAIN PROGRAM
;
; PROBE IS RUN AND WAITS FOR GLOBAL EVENT FLAG GOFLG TO BE SET.
; THE PROGRAM UNDER TEST OR SOME OTHER PROGRAM SETS GOFLG TO START
; TIMING, AND RESETS GOFLAG TO STOP TIMING. WHEN WTFLAG IS SET,
; PROBE TYPES BRIEF INFO ON TERMINAL, AND EVERY NUMINT'TH TIME OUTPUTS
; A FULL SCREEN'S WORTH.

PROBE::
STLOOP:	CLEF$S	#GOFLAG
	CALL	INITMD			;INITIALIZE MODULE TABLE BUFFER
	WTSE$S	#GOFLAG			;WAIT FOR GO SIGNAL
	OUT	\1			;CLEAR VT52 SCREEN
	CALL	TAKBLK			;GET CORE BLOCK AND XFER CODE
	BCS	PRBXIT			;IF SOME PROBLEM

ALLOOP:	CLR	TKTIM			;RESET COUNTER
	
TIMLUP:	CALL	CLKON			;START COUNTING
	MRKT$S	#WTFLAG,#INTRVL,#TIMTYP	;SET TIMER FOR INTRVL TICKS
	WTSE$S	#WTFLAG			;WAIT TILL TIME IS UP
	CALL	CLKOFF			;TURN OFF CLOCK & RETREIVE INFO
	CALL	UPDATE			;STORE OR INC MODULE IN TABLE
	CALL	PUTTSK			;OUTPUT TASK ID OF LAST TASK RUN
	INC	TKTIM			;BUMP TASK NAME OUTPUT COUNTER
	MOV	#NUMINT,R0
	SUB	TKTIM,R0		;CHECK IF < NUMINT
	BGT	TIMLUP			;IF SO, GO BACK

	CALL	LOADMD			;LOAD OUTPUT BUFFER FROM TABLES
	CALL	PUTALL			;OUTPUT THE TIMES
	CALL	RESET			;RESET VALUES IN ISR IN POOL
	SETF$S	#GOFLAG			;CHECK IF STILL SET
	TST	@#$DSW
	BNE	ALLOOP			;IF STILL SET, START COUNTERS AGAIN

	CALL	GIVBLK			;GIVE BACK CORE BLOCK
	OUT	\5
	BR	STLOOP			;WAIT TIL ASKED FOR AGAIN

PRBXIT:	EXIT$S
	.PAGE
	.SBTTL	INITIALIZE MODULE TABLE
INITMD:
;
; INITIALIZE EACH LINE IN TABLE TO BLANKS FOLLOWED BY CR,LF
; AND OTHER MODULE ORIENTED DATA
;
	CLR	OTHRTM			;CLEAR SAMPLE COUNT ACCUMULATORS
	MOV	#SPACE,R0		;AND THEIR OUTPUT BUFFERS
	MOV	#OTHRBF,R1
	MOV	#5,R2
10$:	MOVB	R0,(R1)+
	SOB	R2,10$
	CLR	TOTLTM
	MOV	#TOTLBF,R1
	MOV	#5,R2
20$:	MOVB	R0,(R1)+
	SOB	R2,20$
	MOV	#TKNAML,R0		;ZERO OUT TASK NAMES TABLE
	MOV	R0,TSKPTR		;SET TSKPTR TO 1ST TASK SLOT AVAILABLE
	MOV	#<2*TSKNUM>,R1
30$:	CLR	(R0)+
	SOB	R1,30$
	MOV	#TSKNUM,R3		;INITIALIZE MONAML FREE SPACE POINTERS
	MOV	#MODPTR,R2
	MOV	#MONAML,R0
40$:	MOV	R0,(R2)+
	ADD	#4,R0			;WIDTH(NAME TABLE) = 4 BYTES/ELEMENT
	SOB	R3,40$
	MOV	#MONAML,R0		;ZERO OUT MODULE NAMES TABLE
	MOV	#<2*TSKNUM*MODNUM>,R1
50$:	CLR	(R0)+
	SOB	R1,50$
	MOV	#TKDATA,R0		;ZERO OUT TASK COUNTS TABLE
	MOV	#TSKNUM,R1
60$:	CLR	(R0)+
	SOB	R1,60$
	MOV	#MODATA,R0		;ZERO OUT MODULE COUNTS TABLE
	MOV	#<TSKNUM*MODNUM>,R1
70$:	CLR	(R0)+
	SOB	R1,70$

	RETURN
	.PAGE
	.SBTTL	ALLOCATE AND DEALLOCATE A BLOCK IN POOL
TAKBLK:
;
; ALLOCATE A BLOCK IN SYSTEM POOL AND TRANSFER ISR CODE TO IT
;
	MOV	#LISR,R1		;R1 = LEN (ISR)
	CALL	$SWSTK,10$		;SWITCH TO SYSTEM STATE
	CALL	$ALOCB			;;ALLOCATE BLOCK R1 BYTES LONG
	BCS	5$			;;IF FAILED
	MOV	R0,ISRPT		;;LET ISRPT -> POOL BLOCK
5$:	RETURN				;;FROM SYSTEM STATE
10$:					;RETURNED FROM SYSTEM STATE
	MOV	ISRPT,R1		;TEST FOR ERROR
	BEQ	ALOERR			;IF NO POOL BLOCK (ERROR)
	MOVEW	#ISR,R1,#LISRW		;COPY CODE INTO POOL BLOCK
	CLC				;CLAIM SUCCESS
	BR	TAKRET

ALOERR:	OUT	\2			;OUTPUT "ERROR ALLOCATING BLOCK"
	SEC				;INDICATE ERROR
TAKRET:	RETURN

GIVBLK:
;
; RESTORE CORE BLOCK TO SYSTEM POOL
;
	CALL	$SWSTK,10$		;SWITCH TO SYSTEM STATE
	MOV	ISRPT,R0		;;R0 -> CORE BLOCK
	MOV	#LISR,R1		;;R1 = LEN (ISR)
	CALLR	$DEACB			;;DEALLOCATE & RETURN FROM SYS STATE
10$:	RETURN
	.PAGE
	.SBTTL	CONTROL OF STATISTICS GATHERING
CLKON:					; ($$CVEC -> SYSTEM CLOCK VECTOR)
	MOV	ISRPT,R0		;LET R0 -> ISR IN SYSTEM POOL
	MOV	@#$$CVEC,CLKAD-ISR(R0)	;SO ISR WILL RETURN TO THE RIGHT PLACE
	MOV	R0,@#$$CVEC		;INTRPT NOW GOES TO ISR
	RETURN

CLKOFF:
	MOV	ISRPT,R0		;LET R0 -> ISR IN POOL
	ADD	#CLKAD-ISR,R0		;LET R0 -> CLKAD IN ISR IN POOL
	MOV	(R0)+,@#$$CVEC		;RESTORE CLOCK VECTOR
					;R0 NOW -> INTTIM IN POOL
	MOVEW	R0,#INTTIM,#INFSIZ	;COPY INTTIM, ETC FROM POOL TO OUR
	RETURN				;	PROGRAM SPACE


RESET:
	MOV	ISRPT,R0		;LET R0 -> ISR IN POOL
	ADD	#INTTIM-ISR,R0		;LET R0 -> INTTIM IN ISR IN POOL
	MOV	#INFSIZ,R2		;NUMBER OF WORDS TO CLEAR
10$:	CLR	(R0)+			;RESET VALUE
	SOB	R2,10$
	RETURN
	.PAGE
	.SBTTL	ADD MODULE & TASKS TO TABLE OR INCREMENT THEIR COUNTS
UPDATE:
;
; FIND, ADD OR REJECT TASK NAME. IF TASK FOUND OR ADDED THEN FIND,
; ADD OR REJECT MODULE NAME. IF MODULE FOUND OR ADDED, CHECK TO SEE
; IF LIST SHOULD BE RE-ORDERED.
;
	INC	TOTLTM			;BUMP TOTAL TIME COUNTER
	MOV	TKNAM,R2		;LOAD LAST ACTIVE TASK'S 1ST 3 CHARS
	TST	R2
	BEQ	UPOTHR			;MAKE SURE NOT NULL TASK
	MOV	TKNAM+2,R4		;LOAD LAST ACTIVE TASK'S 2ND 3 CHARS
	MOV	#TKNAML,R5		;LOAD PTR TO FIRST TASK NAME
	MOV	#TSKNUM,R1		;LOAD DOWNWARD COUNTER WITH TOTAL #
TKLOOP:	CMP	R2,(R5)+		;SEARCH TASK LIST FOR ENTRY
	BNE	TKNFND			;IF NOT FOUND
	CMP	R4,(R5)
	BEQ	TKFND			;FOUND
TKNFND:	INC	R5			;DON'T CARE ABOUT 2ND 3 CHARS
	INC	R5
	SOB	R1,TKLOOP		;ANY MORE LEFT TO CHECK?
TSKADD:	MOV	TSKPTR,R5		;DETERMINE IF THERE'S ROOM FOR ANOTHER
	CMP	R5,#MONAML
	BGE	UPDRET			;NOT FOUND AND NO ROOM - REJECT
	MOV	R2,(R5)+		;IS ROOM SO ADD NAME TO LIST
	MOV	R4,(R5)+
	MOV	R5,TSKPTR		;AND BUMP FREE SPACE PTR
	DEC	R5
	DEC	R5
TKFND:	SUB	#TKNAML+2,R5		;COMPUTE TASK INDEX
	MOV	R5,R3			;SAVE INDEX FOR START OF MODULE LIST
	ASR	R5
	INC	TKDATA(R5)		;INCREMENT TASK COUNT
	CALLR	MDSRCH			;SEARCH FOR MODULE AND UPDATE IF POSS.
UPOTHR:	INC	OTHRTM			;TASK NOT ACTIVE
UPDRET:	RETURN
	.PAGE
MDSRCH:
;
; HAVE FOUND OR ADDED TASK ENTRY SO NOW SEARCH MODULE LIST FOR THAT TASK.
; UPDATE TTHAT MODULE ENTRY OR ADD IT (UNLESS THERE IS NO MORE ROOM FOR
; FOR MORE MODULES IN THAT TASK'S LIST). IF THE MODULE JUST HIT'S COUNT
; IS NOW GREATER THAN THE MODULE PRECEDING IT IN THE MODULE LIST, THEN
; SWAP THEM. THIS WILL CAUSE THE LIST TO TEND TOWARD BEING SORTED.
;
	CALL	GMDINF			;LOAD MODULE INFO
	MOV	MODNAM,R1		;MODULE NAME'S 1ST 3 CHARS
	TST	R1
	BEQ	MDTRET			;0 => NO NAME AVAILABLE
	MOV	#MODNUM,R0		;LENGTH OF LIST TO SEARCH
	MOV	MODNAM+2,R2
	ADD	#MONAML,R3		;COMPUTE NAME LIST STARTING ADDRESS
	MOV	R3,R4			;SAVE TO COMPUTE MODULE COUNT INDEX
MDLOOP:	CMP	R1,(R3)+		;SEARCH LIST FOR MODULE
	BNE	MDNFND
	CMP	R2,(R3)
	BEQ	MDFND
MDNFND:	ADD	#<4*TSKNUM-2>,R3	;RESET PTR TO ENTRY IN NEXT ROW
	SOB	R0,MDLOOP
MDADD:	CMP	MODPTR(R5),R3		;IS THERE ROOM FOR ANOTHER?
	BGE	MDTRET			;NOT FOUND AND NO ROOM
	MOV	MODPTR(R5),R3
	MOV	R1,(R3)+		;ADD MODULE NAME
	MOV	R2,(R3)
	ADD	#<4*TSKNUM>,MODPTR(R5)	;BUMP FREE SPACE PTR
MDFND:	DEC	R3			;MOVE R3 BACK TO START OF MONAML ENTRY
	DEC	R3
	MOV	R3,R2			;SAVE FOR SORTOF
	SUB	R4,R3			;COMPUTE MODULE INDEX
	ASR	R3
	ADD	R5,R3
	INC	MODATA(R3)		;INC MODULE COUNT
	BLE	MDTRET			;(ON RESULT OF ABOVE SUB)
SORTOF:	ADD	#MODATA,R3
	CMP	(R3),-<2*TSKNUM>(R3)	;LARGER COUNT?
	BLE	MDTRET
	MOV	-<2*TSKNUM>(R3),R0	;EXCHANGE THE MODULE COUNT VALUES
	MOV	(R3),-<2*TSKNUM>(R3)
	MOV	R0,(R3)
	MOV	R2,R3
	SUB	#<4*TSKNUM>,R3
	MOV	(R3),R0			;EXCHANGE THE MODULE'S NAMES
	MOV	(R2),(R3)+
	MOV	R0,(R2)+
	MOV	(R3),R0
	MOV	(R2),(R3)
	MOV	R0,(R2)
MDTRET:	RETURN
	.PAGE
	.SBTTL	GET MODULE INFO
GMDINF:
;
; LOCATE LAST ACTIVE TASK'S FORTRAN IMPURE AREA (IF POSSIBLE). FOLLOW
; ERROR TRACE POINTER TO FIND WHAT MODULE IS PRESENTLY EXECUTING.
;
	CLR	MODNAM
	CALL	$SWSTK,GMDRET
	MOV	$ACTHD,R0		;;LOAD R0 -> ACTIVE TASK LIST
TCBLUP:	TST	R0			;;END OF LIST?
	BEQ	GMDRET			;;LAST ACTIVE TASK NO LONGER ACTIVE
	CMP	T.NAM(R0),R2		;;COMPARE NAME'S 1ST 3 CHARS
	BNE	NFTCB
	CMP	T.NAM+2(R0),R4		;;COMPARE NAME'S 2ND 3 CHARS
	BEQ	FNDTCB
NFTCB:	MOV	T.ACTL(R0),R0		;;GO TO NEXT TCB IN CHAIN
	BR	TCBLUP
FNDTCB:	MOV	T.PCB(R0),R0		;;LOAD R0 -> PCB OF ACTIVE TASK
	BIT	#<PS.OUT+PS.CKP+PS.LIO>,P.STAT(R0) ;;MAKE SURE IN MEMORY
	BNE	GMDRET			;;NOPE - GIVE UP
	MOV	P.REL(R0),R4		;;GET PHYSICAL ADDR
	MOV	P.HDR(R0),R0		;;LOAD R0 -> TASK HEADER
	MOV	H.WND(R0),R1		;;LOAD WITH NUMBER OF W'S POINTER
	INC	R1			;;ADJUST TO BEGINNING OF WDB
	INC	R1
	MOV	H.FORT(R0),R2		;;GET PTR TO FORTRAN IMPURE AREA
	TST	R2
	BEQ	GMDRET
	BIC	#160000,R2		;;CLEAR OUT OLD APR FIELD
	MOV	KISAR6,-(SP)		;;SAVE OLD APR 6
	MOV	KISDR6,-(SP)
	MOV	W.BSIZ(R1),R5		;;LOAD SIZE OF TASK'S FIRST WINDOW
	CMP	#177,R5			;;IF ITS BIGGER THAN 4KW
	BGE	WSIZOK
	MOV	#177,R5			;;- THEN LIMIT IT TO 4KW
WSIZOK:	BIS	#3000,R5		;;(ALLOW ALL ACCESSES WITHOUT TRAP)
	SWAB	R5
	MOV	R5,KISDR6
	MOV	R4,KISAR6
	MOV	140002(R2),R3		;;GET TRACE LIST POINTER
	TST	R3
	BEQ	GIVUP
	BIC	#160000,R3		;;CLEAR OUT OLD APR FIELD
	MOV	140004(R3),MODNAM	;;NAME IS 2 WORDS ABOVE PTR
	MOV	140006(R3),MODNAM+2
GIVUP:	MOV	(SP)+,KISDR6		;;RESTORE APR 6
	MOV	(SP)+,KISAR6
GMDRET:	RETURN				;;RETURN TO USER MODE AND CALLER
	.PAGE
	.SBTTL	OUTPUT TASK & ROUTINE
PUTTSK:
;
; OUTPUT THE TASK NAME STORED IN TKNAM
; (ASSUMES THIS IS IN VARIABLE OF SAME NAME BELOW)
;
	MOV	#TKNAM,R3
	MOV	#P3A,R0
	MOV	(R3)+,R1
	BEQ	10$			;NO TASK STARTS WITH "   "
	CALL	$C5TA			;LOAD & XLATE TASK NAME
	MOV	(R3)+,R1
	CALL	$C5TA
	BR	20$
10$:	MOV	#SPACES,R1		;CLEAR OUT TASK NAME
	MOV	R1,(R0)+
	MOV	R1,(R0)+
	MOV	R1,(R0)
20$:	MOV	#P3END,R0		;SET UP FOR COMPARE OF OLD & NEW P3'S
	MOV	#OP3END,R1
	MOV	#LOP3,R2
30$:	CMP	-(R0),-(R1)		;COMPARE OLD W/ NEW FROM END
	BNE	40$			;IF NOT SAME COPY REST => OUTPUT NEW
	SOB	R2,30$			;OTHERWISE CHECK NEXT
	BR	PTKRET			;IDENTICAL SO WE'RE DONE
40$:	MOV	(R0),(R1)		;START COPYING FROM FIRST DIFFERENT
	BR	60$			;COUNT ABOVE MOVE BEFORE LOOP
50$:	MOV	-(R0),-(R1)		;COPY THE REST
60$:	SOB	R2,50$

	OUT	\3			;OUTPUT TASK & MODULE NAMES
PTKRET:	RETURN
	.PAGE
	.SBTTL	LOAD MODULE TABLE OUTPUT BUFFER
LOADMD:
;
; UPDATE OUTPUT BUFFER ONE TASK AT A TIME
;
	MOV	#TKNAML,R3		;LOAD PTR TO TKNAML
	MOV	#TKDATA,ODTPTR		;LOAD PTR TO TKDATA
	MOV	#MODBUF,R0		;LOAD BUFFER POINTER
	MOV	#MODNUM+1,R4		;FOR I=1,(MODNUM+1)
10$:	MOV	#TSKNUM,R5		;   FOR J=1,TSKNUM
20$:	MOV	(R3)+,R1		;	LOAD 1ST 3 CHARS OF NAME
	CALL	$C5TA			;	AND TRANSLATE THEM
	MOV	(R3)+,R1		;	LOAD 2ND 3 CHARS
	CALL	$C5TA			;	AND TRANSLATE THEM
	MOV	#SPACE,R2
	MOVB	R2,(R0)+		;	LOAD SPACE BETWEEN NAME & NUM.
	MOV	R0,R1			;	LOAD NUMBER FIELD WITH SPACES
	MOVB	R2,(R1)+
	MOVB	R2,(R1)+
	MOVB	R2,(R1)+
	MOVB	R2,(R1)+
	MOVB	R2,(R1)+
	MOV	R1,-(SP)		;	SAVE END OF FIELD POINTER
	MOV	ODTPTR,R2
	MOV	(R2)+,R1		;	LOAD NUMBER TO BE TRANSLATED
	MOV	R2,ODTPTR		;	UPDATE DATA AREA POINTER
	CLR	R2			;	(INDICATES NO LEADING ZEROS)
	TST	R1			;	IF ITS COUNT IS ZERO
	BEQ	30$			;	   THEN DON'T CONVERT AT ALL
	CALL	$CBDMG			;	TRANSLATE INTO MODBUF
30$:	MOV	(SP)+,R0		;	POINT TO NEXT FIELD IN LINE
	SOB	R5,20$
	MOVB	#LF,(R0)+		;   ADD CR,LF TO END OF LINE
	MOVB	#CR,(R0)+
	SOB	R4,10$
	MOV	OTHRTM,R1		;TRANSLATE OTHER TIME VALUE
	MOV	#OTHRBF,R0
	CALL	$CBDMG
	MOV	TOTLTM,R1		;TRANSLATE TOTAL TIME VALUE
	CLR	R2
	MOV	#TOTLBF,R0
	CALL	$CBDMG
	RETURN
	.PAGE
	.SBTTL	REFRESH TASK, MODULE, AND TIME INFO
PUTALL:
;
; OUTPUTS THE TASK NAME INFO LIKE PUTTSK ABOVE, THEN
; OUTPUTS THE TIMES FOR INTTIM,SYSTIM,USRTIM,NULTIM
; ASSUMES THESE ARE IN VARIABLES OF THE SAME NAME BELOW
;
	MOV	#INTTIM,R4		;LET R4 -> NUMBERS TO CONVERT
	MOV	#4,R3			;THIS IS THE NUMBER OF NUMBERS
	MOV	#P4A,R0			;-> OUTPUT BUFFER
PTALP:	MOV	(R4)+,R1		;NUMBER TO CONVERT
	MOV	R0,-(SP)		;SAVE BUFFER ADDR
	MOV	#5,R2			;# OF BYTES TO CLEAR BEFORE CONVERSION
10$:	CLRB	(R0)+
	SOB	R2,10$			;0 LEFT IN R2 SUPRESSES 0'S IN $CBDMG
	MOV	(SP),R0			;RESTORE BUFFER ADDR ARGUMENT
	CALL	$CBDMG			;CONVERT DECIMAL MAG
	MOV	(SP)+,R0
	ADD	#P4B-P4A,R0		;POINT TO NEXT BUFFER
	SOB	R3,PTALP		;IFF THERE IS A NEXT BUFFER

	OUT	\4			;OUTPUT FULL SCREEN
	RETURN
	.PAGE
	.SBTTL	CODE PLACED IN POOL
; ISR: THIS PORTION OF CODE IS PLACED IN POOL SPACE AND
;	RECEIVES CONTROL ON EACH TICK OF THE CLOCK.
;
ISR:	MOV	@#PS,-(SP)		;;;SAVE PS LOADED FROM CLOCK VECTOR
	MOV	CLKAD,-(SP)		;;;GET ADDR OF STD CLOCK ROUTINE
	BIT	#PMODE,@#PS		;;;KERNEL MODE?
	BNE	30$			;;;NO
	CLR	TKNAM
	BIT	#PR7,6(SP)		;;;PREV. PS AT NON-0 PRIORITY?
	BEQ	10$			;;;NO
	INC	INTTIM
	RTI
10$:	TSTB	@#$CURPRI		;;;$CURPRI=0 => NULL TASK
	BNE	20$
	INC	NULTIM
	RTI
20$:	INC	SYSTIM
	RTI
30$:	INC	USRTIM
	MOV	R0,-(SP)		;;;SAVE R0
	MOV	@#$TKTCB,R0		;;;LET R0 -> TCB OF CURRENT TASK
	MOV	T.NAM(R0),TKNAM		;;;SAVE TASK NAME
	MOV	10(R0),TKNAM2
	MOV	(SP)+,R0		;;;RESTORE R0
	RTI				;;;XFER TO STD CLOCK RTN WITH STD VEC

CLKAD:	.WORD	0			;CLOCK ROUTINE ADDR STORED HERE
INTTIM:	.WORD	0
SYSTIM:	.WORD	0
USRTIM:	.WORD	0
NULTIM:	.WORD	0
TKNAM:	.WORD	0			;CURRENT TASK NAME IN RAD50
TKNAM2:	.WORD	0
LISR = .-ISR				;LENGTH OF ISR
LISRW = LISR / 2			;IN WORDS
	.PAGE
	.SBTTL	END (LAST PAGE)
	.END	PROBE