.TITLE	MRP
	.IDENT	/050782/


;+
;	MRP -- FORMAT MONITOR REPORT
;
; THIS PROGRAM IS REQUESTED BY ...MON TO RUN AND IT THEN READS
; SY:[1,2]MONITOR.DAT TO FORMAT THE DATA GATHERED INTO A REPORT
; FILE SY:[1,2]MONITOR.RPT.
;
; SEE MON.MAC FOR DETAILS OF MONITOR.DAT FILE FORMAT AND OPERATION.
;
;-

	.PAGE
	.SBTTL	MACROS

	.MCALL	EXIT$S,FCSMC$,QIOW$S,GTIM$S

	FCSMC$				; FCS MACROS

	OUTLUN	=	1		; OUTPUT FILE LUN
	INLUN	=	2		; INPUT FILE LUN
	INEF	=	2		; INPUT FILE EVENT FLAG
	ERRLUN	=	5		; ERROR DEVICE LUN
	ERREF	=	5		; ERROR DEVICE EVENT FLAG
	LINPAG	=	58.		; LINES/PAGE
	TSKBLK	=	5		; NUMBER OF BLOCKS FOR TASK PACKETS
	DEVBLK	=	1		; NUMBER OF BLOCKS FOR DEVICE BUFFER
	TSKSIZ	=	24.		; SIZE OF TASK PACKET IN OUTPUT FILE
	PTRSIZ	=	6		; SIZE OF POINTER/PC PACKET
	MAXTSK	=	<<TSKBLK*256.>-HDRSIZ>/<TSKSIZ/2> ; MAX # OF TASKS
	BUFCNT	=	2		; NUMBER OF READ BUFFERS
	BLKSIZ	=	512.		; SIZE OF READ BUFFER


; COMMAND SWITCHES FROM MON

	SW.PC	=	1		; NO PC STATS
	SW.ME	=	2		; NO MEMORY STATS
	SW.IO	=	4		; NO IO STATS
	SW.DR	=	10		; NO DIRECTIVE STATS

	.MACRO	SPACE,NUM

; MACRO TO SKIP A LINE
; NUM = NUMBER OF LINES TO SKIP
;

	JSR	R5,NEWLIN
	.WORD	NUM
	.ENDM

	.MACRO	PAGE
;
; MACRO TO START AT A NEW PAGE
;
	CALL	NEWPAG
	.ENDM

	.MACRO	READWD,ADR,ADDTO
;
; MACRO TO READ NEXT WORD FROM FILE POINTED TO BY NEXT WORD
;


	.IF	NB,<ADDTO>
	ADD	ADDTO,R1
	CMP	R1,#512.
	BNE	.+6
	CLR	R1
	INC	R0
	.ENDC
	CALL	GETWRD
	MOV	R4,ADR
	.ENDM

	.MACRO	PERCNT,D,Q,RESULT,A1,A2,?LAB1,?LAB2
	.NTYPE	$$ARG1,D
	.NTYPE	$$ARG2,Q

	.IF	NE,$$ARG1-67
	MOV	D,LAB1
	.IIF	NB,<A1>		ADD	A1,LAB1
	.ENDC

	.IF	NE,$$ARG2-67
	MOV	Q,LAB2
	.IIF	NB,<A2>		ADD	A2,LAB2
	.ENDC


	JSR	R5,CALCPC
	.IF	EQ,$$ARG1-67
	.WORD	D
	.IFF
LAB1:	.WORD	0
	.ENDC

	.IF	EQ,$$ARG2-67
	.WORD	Q
	.IFF
LAB2:	.WORD	0
	.ENDC

	.WORD	RESULT

	.ENDM

	.MACRO	WRTLIN,ARGBLK,MSG

;
; OUTPUT A LINE TO THE REPORT FILE
;
	JSR	R5,OUTPUT
	.WORD	ARGBLK
	.WORD	MSG

	.ENDM
	.PAGE
	.SBTTL	DIRECTIVE NAME TABLE

DIRNAM:	.ASCII	'QIO '		;001.-QUEUE I/O
	.ASCII	'QIOW'		;003.-QUEUE I/O AND WAIT
	.ASCII	'GLUN'		;005.-GET LUN INFORMATION
	.ASCII	'ALUN'		;007.-ASSIGN LUN
	.ASCII	'ALTP'		;009.-ALTER PRIORITY
	.ASCII	'RQST'		;011.-REQUEST/SPAWN
	.ASCII	'D013'		;013.-INVALID DIC
	.ASCII	'D015'		;015.-INVALID DIC
	.ASCII	'RUN '		;017.-RUN TASK
	.ASCII	'D018'		;019.-INVALID DIC
	.ASCII	'SRRA'		;021.-REC BY REF AST
	.ASCII	'MRKT'		;023.-MARK TIME
	.ASCII	'CSRQ'		;025.-CANCEL SCHEDULE REQUESTS
	.ASCII	'CMKT'		;027.-CANCEL SELECTIVE MARK TIMES
	.ASCII	'EXST'		;029.-EXIT WITH STATUS
	.ASCII	'CLEF'		;031.-CLEAR EVENT FLAG
	.ASCII	'SETF'		;033.-SET EVENT FLAG
	.ASCII	'DECL'		;035.-DECLARE SIGNIFICANT EVENT
	.ASCII	'RDEF'		;037.-READ EVENT FLAG
	.ASCII	'RDAF'		;039.-READ ALL(EXTENDED) EVENT FLAG
	.ASCII	'WTSE'		;041.-WFR SINGLE EVENT FLAG
	.ASCII	'WTLO'		;043.-WAITFOR LOGICAL OR OF EF
	.ASCII	'SPND'		;045.-SUSPEND EXECUTION
	.ASCII	'RSUM'		;047.-RESUME TASK EXECUTION
	.ASCII	'WSIG'		;049.-WAITFOR SIGNIFICANT EVENT
	.ASCII	'EXIT'		;051.-TASK EXIT
	.ASCII	'EXIF'		;053.-EXIT IF
	.ASCII	'CRRG'		;055.-CREATE REGION
	.ASCII	'ATRG'		;057.-ATTACH REGION
	.ASCII	'DTRG'		;059.-DETACH REGION
	.ASCII	'GTIM'		;061.-GET TIME PARAMETERS
	.ASCII	'GTSK'		;063.-GET TASK PARAMETERS
	.ASCII	'GPRT'		;065.-GET PARTITION PARAMETERS
	.ASCII	'D067'		;067.-INVALID DIC
	.ASCII	'SREF'		;069.-SEND BY REFERENCE
	.ASCII	'SDAT'		;071.-SEND (AND VARIABLE SEND) DATA
	.ASCII	'D073'		;073.-INVALID DIC
	.ASCII	'RCVD'		;075.-RECEIVE (AND VARIABLE REC) DATA
	.ASCII	'RCVX'		;077.-REC (AND VAR REC) DATA OR EXIT
	.ASCII	'D079'		;079.-INVALID DIC
	.ASCII	'RREF'		;081.-RCV BY REFERENCE
	.ASCII	'ABRT'		;083.-ABORT TASK
	.ASCII	'D085'		;085.-INVALID DIC
	.ASCII	'D087'		;087.-INVALID DIC
	.ASCII	'EXTK'		;089.-EXTEND PARTITION
	.ASCII	'D091'		;091.-INVALID DIC
	.ASCII	'D093'		;093.-INVALID DIC
	.ASCII	'DSCP'		;095.-DISABLE CHECKPOINTING
	.ASCII	'ENCP'		;097.-ENABLE CHECKPOINTING
	.ASCII	'DSAR'		;099.-DISABLE AST RECOGNITION
	.ASCII	'ENAR'		;101.-ENABLE AST RECOGNITION
	.ASCII	'SVDB'		;103.-SPECIFY ODT SST VECTOR
	.ASCII	'SVTK'		;105.-SPECIFY TASK SST VECTOR
	.ASCII	'SRDA'		;107.-SETUP FOR RECEIVE AST
	.ASCII	'SPRA'		;109.-SETUP FOR POWER UP AST
	.ASCII	'SFPA'		;111.-SETUP FOR FLP AST
	.ASCII	'GMCX'		;113.-GET MAPPING CONTEXT
	.ASCII	'ASTX'		;115.-AST TRAP EXIT
	.ASCII	'CRAW'		;117.-CREATE ADDRESS WINDOW
	.ASCII	'ELAW'		;119.-ELIMINATE ADDRESS WINDOW
	.ASCII	'MAP '		;121.-MAP ADDRESS WINDOW
	.ASCII	'UMAP'		;123.-UNMAP ADDRESS WINDOW
	.ASCII	'GSSW'		;125.-GET SENSE SWITCHES
	.ASCII	'GMCR'		;127.-GET MCR COMMAND LINE
	.ASCII	'CINT'		;129.-CONNECT TO INTERRUPT
	.ASCII	'STOP'		;131.-STOP TASK
	.ASCII	'USTP'		;133.-UNSTOP TASK
	.ASCII	'STSE'		;135.-STOP FOR SNGL EFN
	.ASCII	'STLO'		;137.-STOP FOR LOGICAL OR OF EFN'S
	.ASCII	'VRCS'		;139.-RECEIVE (AND VAR REC) DATA OR STOP
	.ASCII	'SDRC'		;141.-SDRC
	.ASCII	'CNCT'		;143.-CONNECT TO TASK
	.ASCII	'D145'		;145.-INVALID DIC
	.ASCII	'EMST'		;147.-EMIT STATUS
	.ASCII	'CRVT'		;149.-CREATE VIRTUAL TERMINAL
	.ASCII	'ELVT'		;151.-ELIMINATE VIRTUAL TERMINAL
	.ASCII	'D153'		;153.-INVALID DIC
	.ASCII	'SCAL'		;155.-SUPERVISOR MODE CALL
	.ASCII	'CRGF'		;157.-CREATE GROUP GLOBAL EVENT FLAGS
	.ASCII	'ELGF'		;159.-ELIMINATE GROUP GLOBAL EVENT FLAGS
	.ASCII	'STAF'		;161.-SPECIFY AFFINITY
	.ASCII	'RMAF'		;163.-REMOVE AFFINITY
	.ASCII	'SPEA'		;165.-SET UP FOR PARITY ERROR AST
	.ASCII	'SREX'		;167.-SET UP FOR REQUESTED EXIT AST
	.ASCII	'D169'		;169.-GET / PUT SYSTEM INFORMATION
	.ASCII	'SMSG'		;171.-SEND MESSAGE TO ERROR LOGGING
	.ASCII	'SCLI'		;173.-CLI DIRECTIVE
	.ASCII	'D175'		;175.-RESERVED RSX-11M FUTURE USE
	.ASCII	'D177'		;177.-RESERVED RSX-11M FUTURE USE
	.ASCII	'D179'		;179.-RESERVED RSX-11M FUTURE USE
	.ASCII	'D181'		;181.-RESERVED RSX-11M FUTURE USE
	.ASCII	'D183'		;183.-RESERVED RSX-11M FUTURE USE
	.ASCII	'D185'		;185.-RESERVED RSX-11M FUTURE USE
	.ASCII	'D187'		;187.-RESERVED RSX-11M FUTURE USE
	.ASCII	'D189'		;189.-RESERVED RSX-11M FUTURE USE
	.ASCII	'D191'		;191.-RESERVED FOR USER USE
	.ASCII	'D193'		;193.-RESERVED FOR USER USE
	.ASCII	'D195'		;195.-RESERVED FOR USER USE
	.ASCII	'D197'		;197.-RESERVED FOR USER USE
	.ASCII	'D199'		;199.-RESERVED FOR USER USE
	.ASCII	'MSDS'		;201.-MODIFY SUPERVISOR MAPPING
	.ASCII	'MVTS'		;203.-MOVE TO/FROM VARIOUS TASK SPACES
	.ASCII	'CPCR'		;205.-CPCR CKP COMMON REGION
	.ASCII	'D207'		;207.-RESERVED RSX-11M+
	.ASCII	'D209'		;209.-RESERVED RSX-11M+ FUTURE USE
	.ASCII	'D211'		;211.-RESERVED FOR FUTURE USE
	.ASCII	'D213'		;213.-RESERVED FOR FUTURE USE
	.ASCII	'D215'		;215.-RESERVED FOR FUTURE USE
	.ASCII	'D217'		;217.-RESERVED FOR FUTURE USE
	.ASCII	'D219'		;219.-RESERVED FOR FUTURE USE
	.ASCII	'D221'		;221.-RESERVED FOR FUTURE USE
	.ASCII	'D223'		;223.-RESERVED FOR FUTURE USE
	.ASCII	'D225'		;225.-RESERVED FOR FUTURE USE
	.ASCII	'D227'		;227.-RESERVED FOR FUTURE USE
	.ASCII	'D229'		;229.-RESERVED FOR FUTURE USE
	.ASCII	'D231'		;231.-RESERVED FOR FUTURE USE
	.ASCII	'D233'		;233.-RESERVED FOR FUTURE USE
	.ASCII	'D235'		;235.-RESERVED FOR FUTURE USE
	.ASCII	'D237'		;237.-RESERVED FOR FUTURE USE
	.ASCII	'D239'		;239.-RESERVED FOR FUTURE USE
	.ASCII	'D241'		;241.-RESERVED FOR FUTURE USE
	.ASCII	'D243'		;243.-RESERVED FOR FUTURE USE
	.ASCII	'D245'		;245.-RESERVED FOR FUTURE USE
	.ASCII	'D247'		;247.-RESERVED FOR FUTURE USE
	.ASCII	'D249'		;249.-RESERVED FOR FUTURE USE
	.ASCII	'D251'		;251.-RESERVED FOR FUTURE USE
	.ASCII	'D253'		;253.-RESERVED FOR FUTURE USE
	.ASCII	'D255'		;255.-RESERVED FOR FUTURE USE
	.PAGE
	.SBTTL	EDIT MESSAGE STRINGS

TIMMSG:	.ASCIZ	'MONITOR WAS ACTIVE %3Z'
CPUMSG:.ASCIZ	'TOTAL CPU UTILIZATION IS %M.%M%M%A'
MSG1:	.ASCIZ	'%Y %2Z%19SSYSTEM MONITOR%22SPAGE: '
PAGMSG:	.ASCIZ	'%M'
MSG2:	.ASCIZ	'TOTAL SYSTEM SAMPLES IS %T. AT %M.%M%M SAMPLES PER SECOND'
MSG3:	.ASCIZ	'*IDLE* -- %T. SAMPLES   %M.%M%M%A OF TOTAL CPU TIME'
MSG4:	.ASCIZ	'%2R -- %T. SAMPLES   %M.%M%M%A OF TOTAL CPU TIME'
MSG5:	.ASCIZ	'%8S%P - %P   %T. SAMPLES   %M.%M%M%A OF TASK CPU TIME'
MSG6:	.ASCIZ	'%T. MISSED SAMPLE INTERVALS'
MSG7:	.ASCIZ	'%M. LOST TASKS BECAUSE OF INSUFFICANT BUFFER SPACE'
MSG8:	.ASCIZ	'STATISTICS GATHERED ON %M. TASKS'
MSG9:	.ASCIZ	'TOTAL DIRECTIVES EXECUTED = %T.'
MSG10:	.ASCIZ	'%2R'
MSG11:	.ASCIZ	'______'
MSG12:	.ASCII	'DIRECTIVES --  %T. SAMPLES AND %M.%M%M%A OF'
	.ASCIZ	' TOTAL CPU USAGE'

MSG13:	.ASCII	'TASK DIRECTIVES --  %T. SAMPLES AND %M.%M%M%A OF'
	.ASCIZ	' TOTAL CPU USAGE OF TASK'
MSG14:	.ASCIZ	'%2R --  IN - %M.  %M.%M%M%A   OUT - %M.  %M.%M%M%A   %M. KW'
MSG15:	.ASCIZ	'MONITOR -- %T. SAMPLES   %M.%M%M%A OF TOTAL CPU USAGE'
SUMHED:	.ASCIZ	'%18SS Y S T E M  A C T I V I T Y  S U M M A R Y'
MSG16:	.ASCIZ	'DEVICE TOTAL = %T. SAMPLES AND %M.%M%M%A OF TOTAL CPU'
MSG17:	.ASCIZ	'%2A -- %T. SAMPLES AND %M.%M%M%A OF DEVICE TOTAL'
MSG18:	.ASCIZ	'%2A%M: -- %T. QIOS AND %M.%M%M%A OF TOTAL FOR %2A'
MSG19:	.ASCIZ	'%2A -- %T. QIOS AND %M.%M%M%A OF TOTAL QIOS'
MSG20:	.ASCIZ	'%6S%M.%M%M  QIOS/SECOND AVERAGE'
DIRHED:	.ASCIZ	'%12SD I R E C T I V E  A C T I V I T Y  S U M M A R Y'
DEVHED:	.ASCIZ	'%13SD E V I C E  D R I V E R  S U M M A R Y'
MEMHED:	.ASCIZ	'%21SM E M O R Y  U S A G E  S U M M A R Y'
DIRMSG:	.ASCIZ	'%4A - DIC%M%5SEXECUTED %T. TIMES FOR %M.%M%M%A OF TOTAL'
MEMMSG:	.ASCIZ	'TASKS IN    MIN. %M.   MAX. %M.   AVG. %T.   %TKW AVG.'
CKPMSG:	.ASCIZ	'TASKS OUT   MIN. %M.   MAX. %M.   AVG. %T.   %TKW AVG.'

PCNTCH:	.ASCII	'%'
	.EVEN

	.PAGE
	.SBTTL	ERROR MESSAGES

; ERROR MESSAGES

OPMSGI:	.ASCIZ	'MRP -- ERROR DURING OPEN OF INPUT FILE - F.ERR = %B'
OPMSGO:	.ASCIZ	'MRP -- ERROR DURING OPEN OF OUTPUT FILE - F.ERR = %B'
OUTMSG:	.ASCIZ	'MRP -- ERROR DURING WRITE TO OUTPUT FILE - F.ERR = %B'
INPDSW:	.ASCIZ	'MRP -- READ ERROR ON INPUT FILE - DSW = %P'
INPISB:	.ASCIZ	'MRP -- READ ERROR ON INPUT FILE - IOSB = %B'

	.EVEN

	.PAGE
	.SBTTL	EDIT MESSAGE ARGUMENT BLOCKS

ARGBK2:	.WORD	TOTCNT			; POINTER TO  TOTAL SAMPLES
	.WORD	0,0,0			; SAMPLES / SECOND
ARGBK3:	.WORD	IDLCT			; TOTAL SAMPLES IDLE
	.WORD	0,0,0			; % OF TOTAL TIME
	.WORD	PCNTCH			; POINTER TO '%'

ARGBK4:	.WORD	0,0			; TASK NAME
	.WORD	0			; TOTAL SAMPLES FOR TASK
	.WORD	0,0,0			; % OF TOTAL TIME
	.WORD	PCNTCH			; POINTER TO '%'

ARGBK5:	.WORD	0,0			; ADDRESS RANGE
	.WORD	0			; TOTAL TICK IN RANGE
	.WORD	0,0,0			; % OF TASK TIME IN RANGE
	.WORD	PCNTCH			; => TO '%'

ARGBK6:	.WORD	ERRCNT			; COUNT OF LOST INTERRUPTS

ARGBK8:	.WORD	0			; # OF TASKS
ARGBK9:	.WORD	DIRTOT			; TOTAL DIRECTIVES EXECUTED
ARGB10:	.WORD	0,0			; TASK NAME
ARGB12:	.WORD	USRTRP			; => TOTAL USER TRAP SAMPLES
	.WORD	0,0,0
	.WORD	PCNTCH

ARGB13:	.WORD	0
	.WORD	0,0,0
	.WORD	PCNTCH
ARGB14:	.BLKW	2			; TASK NAME
	.WORD	0			; TIMES IN MEMORY
	.WORD	0,0,0		 	;PERCENT
	.WORD	PCNTCH
	.WORD	0			; TIMES OUT OF MEMORY
	.WORD	0,0,0			; PERCENT
	.WORD	PCNTCH
	.WORD	0			; KW

ARGB15:	.WORD	MONCNT			; PTR TO MONITOR TOTAL
	.WORD	0,0,0			; PERCENT OF TOTAL
	.WORD	PCNTCH

ARGB16:	.WORD	DEVTOT		; PTR TO TOTAL SAMPLES FOR DEVICES
	.WORD	0,0,0			; FOR % OF TOTAL SAMPLES
	.WORD	PCNTCH			; PTR TO '%'

ARGB17:	.WORD	0			; PTR TO DEVICE NAME
	.WORD	0			; PTR TO SAMPLES FOR DEVICE
	.WORD	0,0,0			; FOR %
	.WORD	PCNTCH

ARGB18:	.WORD				; PTR TO DEVICE NAME
	.WORD				; UNIT NUMBER
	.WORD	0			; PTR TO UNIT TOTAL
	.WORD	0,0,0			; %
	.WORD	PCNTCH
	.WORD	0			; PTR TO DEVICE NAME

ARGB19:	.WORD				; PTR TO DEVICE NAME
	.WORD	QIOTOT			; PTR TO DEVICE TOTAL
	.WORD	0,0,0			; %
	.WORD	PCNTCH

ARGB20:	.WORD	0,0,0		; QIOS/SECOND

TOTSEC:	.WORD	0,0			; TOTAL # OF SECONDS THE MONITOR IS ACTIVE
TOTMEM:	.WORD	0,0			; TOTAL TIMES IN OR OUT OF MEMORY
TOTIN:	.WORD	0,0		 	; TOTAL TIMES IN MEMORY
TOTOUT:	.WORD	0,0			; TOTAL TIME OUT OF MEMORY

DIRBLK:	.WORD	0			; POINTER TO DIRECTIVE NAME
	.WORD	1			; DIRECTIVE NUMBER
	.WORD	0			; TOTAL TIMES EXECUTED
	.WORD	0,0,0			; PERCENT OF TOTAL
	.WORD	PCNTCH
MEMBLK:	.WORD	0			; TASKS IN LO
	.WORD	0			; TASKS IN HIGH
	.WORD	0			; TASKS IN AVERAGE
	.WORD	0			; MEM. SIZE IN

CKPBLK:	.WORD	0			; TASKS OUT LO
	.WORD	0			; TASKS OUT HIGH
	.WORD	0			; TASKS OUT AVERAGE
	.WORD	0			; PTR TO CKP SIZE TOTAL


CPUBLK:	.WORD	0,0,0			; FOR % UTILIZAED
	.WORD	PCNTCH

ERRARG:	.BLKW	5			; ARGUMENT BLOCK FOR I/O ERRORS

	.PAGE
	.SBTTL	BUFFER AND FCS STUFF

OUTBUF:	.BLKB	80.			; OUTPUT BUFFER

	.BYTE	12,15
ERRBUF:	.BLKB	80.			; ERROR MESSAGE OUTPUT BUFFER


; FDBS
	FSRSZ$	2


; REPORT FILE FDB

OUTFDB:	FDBDF$
	FDAT$A	R.VAR,FD.CR,,-10.,-10.
	FDOP$A	OUTLUN,OUTDSP,OUTFNB

OUTDSP:	.WORD	0,0,OUTUSZ,OUTUIC,0,0

OUTUIC:	.ASCII	'[1,2]'
	OUTUSZ=.-OUTUIC

	.EVEN

OUTFNB:	NMBLK$	MONITOR,RPT,0,SY,0



; INPUT FILE FDB

INFDB:	FDBDF$
	FDRC$A	FD.RWM
	FDOP$A	INLUN,INDSPT,INFNB

INDSPT:	.WORD	0,0,INUSZ,INUIC,0,0

INUIC:	.ASCII	'[1,2]'
	INUSZ=.-INUIC
	.EVEN

INFNB:	NMBLK$	MONITOR,DAT,0,SY,0



	.PAGE
	.SBTTL	INPUT BLOCKS AND OFFSETS

TSKCNT:	.WORD			; # OF TASKS
DIRTOT:	.WORD	0,0		; # OF DIRECTIVES EXECUTED
USRTRP:	.WORD	0,0		; USER TRAP TOTAL
TSKLST:	.WORD			; # OF LOST TASKS
ERRCNT:	.BLKW	2		; COUNT OF MISSED INTERRUPTS
IDLCT:	.BLKW	2		; TOTAL IDLE SAMPLES
TOTCNT:	.BLKW	2		; TOTAL SAMPLES ACTIVE
HOUR:	.WORD	0		; MONITOR ACTIVE TIME
MIN:	.WORD	0
SEC:	.WORD	0
MEMLO:	.WORD	0		; LOWEST # OF TASKS IN MEMORY
MEMHI:	.WORD	0		; HIGHEST # OF TASKS IN MEMORY
MEMNO:	.WORD	0,0		; AVERAGE # OF TASKS IN MEMORY
MEMSIZ:	.WORD	0,0		; AVERAGE SIZE OF MEMORY IN USE

CKPLO:	.WORD	0		; LOWEST # OF TASKS OUT OF MEMORY
CKPHI:	.WORD	0		; HIGHEST # OF TASKS OUT OF MENORY
CKPNO:	.WORD	0,0		; AVERAGE # OF TASKS OUT OF MEMORY
CKPSIZ:	.WORD	0,0		; AVERAGE SIZE OF CHECKPOINTED MEMORY
MEMCNT:	.WORD	0		; COUNT OF # OF MEMORY SAMPLES
MONCNT:	.WORD	0,0		; COUNT OF TIMES IN MONITOR
SWMASK:	.WORD	0		; SWITCHES FROM MON

	HDRSIZ=<.-TSKCNT>/2


; TASK PACKET OFFSETS

	TS.NAM	=	0		; TASK NAME
	TS.PTR	=	4		; LINK TO PC PACKETS
	TS.CNT	=	10		; TOTAL TASK ACTIVE COUNT
	TS.DIR	=	14		; TASK DIRECTIVE COUNT
	TS.IN	=	20		; TASK IN MEMORY COUNT
	TS.OU	=	22		; TASK OUT OF MEMORY COUNT
	TS.SIZ	=	24		; TASK SIZE
	TS.LNK	=	26		; TASK PACKET HASH LINK


TSKBUF:	.BLKB	TSKBLK*512.-<.-TSKCNT> ; REST OF BUFFER

DIRBUF:	.BLKW	256.			; FOR DIRECTIVE COUNTS



; DEVICE PACKET OFFSETS

	DM.NAM	=	0		; DEVICE NAME
	DM.PAR	=	2		; DRIVER PAR FOR APR5
	DM.NUM	=	4		; NUMBER OF UNITS
	DM.PTR	=	6		; PTR TO UNIT COUNTS
	DM.HIC	=	10		; DEVICE SAMPLE COUNT - HIGH
	DM.LOC	=	12		; LOW
	DM.QIO	=	14		; TOTAL # OF QIOS
	DM.SIZ	=	20		; SIZE OF PACKET


DEVTOT:	.WORD	0,0			; DEVICE TOTAL
DEVCNT:	.WORD	0			; NUMBER OF DEVICES
QIOTOT:	.WORD	0,0			; TOTAL NUMBER OF QIOS
DEVBUF:	.BLKW	<DEVBLK*256.>-<<.-DEVTOT>/2>	; REST OF TABLE



NXTWRD:	.WORD	0,0			; POINTER TO NEXT READ POSITION
PGCNTR:	.WORD	0			; SAVED PC READ FROM FILE

; VIRTUAL READ CONTROL BLOCKS

BLKTBL:	.WORD	BUF1			; POINTER TO THE 1ST BUFFER
	.WORD	0,0			; VBN,USE COUNT
	.WORD	BUF2			; POINTER TO THE 2ND BUFFER
	.WORD	0,0			; VBN,USE COUNT

IOSB:	.BLKW	2			; I/O STATUS BLOCK

BUF1:	.BLKB	BLKSIZ			; 1ST READ BUFFER

BUF2:	.BLKB	BLKSIZ		; 2ND READ BUFFER

	.PAGE
	.SBTTL	DATA AREA

ADRCNT:	.BLKW	512.*2		; ADDRESS RANGES (64. WORD INTERVALS)

TIMBUF:	.BLKW	8.		; TIME PARAMETERS

	.BYTE	14		; FOR FORM FEED
TITBUF:	.BLKB	79.		; FOR TITLE
PAGEPT:	.WORD	0		; ADDRESS TO INSERT PAGE
PAGCNT:	.WORD	0		; PAGE COUNTER
LINCNT:	.WORD	0		; LINE COUNTER

CPUCNT:	.WORD	0,0		; TOTAL CPU UTILIZATION COUNT

	.PAGE
	.SBTTL	CHKIO -- CHECK FOR QIO ERRORS

CHKIO:	BCC	10$		; NO DIRECTIVE ERROR
	MOV	$DSW,ERRARG	; STORE DSW INTO ARGUMENT BLOCK
	MOV	#INPDSW,R1	; R1 => MESSAGE
	JMP	PRTERR		; OUTPUT ERROR MESSAGE
10$:	TSTB	IOSB		; AN ERROR?
	BPL	20$		; NO
	MOV	#IOSB,ERRARG	; SAVE ERROR POINTER
	MOV	#INPISB,R1	; R1 => ERROR MESSAGE
	JMP	PRTERR		; OUTPUT ERROR MESSAGE
20$:	RETURN

	.PAGE
	.SBTTL	OPEN FILE ERROR ROUTINES

OPNERO:	MOV	#OPMSGO,R1	; R1 => ERROR MESSAGE
	BR	OPNERR

OPNERI:	MOV	#OPMSGI,R1	; R1 => ERROR MESSAGE
OPNERR:	MOV	R0,ERRARG	; STORE ERROR POINTER
	ADD	#F.ERR,ERRARG
	JMP	PRTERR

PUTERR:	MOV	#OUTMSG,R1	; R1 => FORMAT LINE
	MOV	#OUTFDB+F.ERR,ERRARG


	.PAGE
	.SBTTL	PRTERR -- OUTPUT ERROR MESSAGE

PRTERR:	INC	ERRFLG		; SET ERROR FLAG
	MOV	#ERRBUF,R0	; R0 => OUTPUT BUFFER
	MOV	#ERRARG,R2	; R2 => ARG BLK
	CALL	$EDMSG		; FORMAT MESSAGE
	SUB	#ERRBUF-2,R0	; GET LENGTH
	QIOW$S	#IO.WVB,#ERRLUN,#ERREF,,,,<#ERRBUF-2,R0,#40> ; WRITE LINE
	JMP	EXIT		; EXIT TASK


	.PAGE
	.SBTTL	INITIALIZATION

INIT:	FINIT$			; INIT FCS
	OPEN$R	#INFDB,,,,,,OPNERI	; OPEN INPUT FILE
	OPEN$W	#OUTFDB,,,,,,OPNERO	; OPEN OUTPUT FILE
	QIOW$S	#IO.RVB,#INLUN,#INEF,,#IOSB,,<#TSKCNT,#<TSKBLK+1+DEVBLK>*512.,,,#1> ; READ IN HEADER
	CALL	CHKIO		; MAKE SURE I/O IS OK
	SUB	ERRCNT+2,TOTCNT+2	; SUBTRACT OUT ERROR COUNT FROM TOTAL
	SBC	TOTCNT
	SUB	ERRCNT,TOTCNT
	CALL	SORTTN		; SORT TASK NAMES
	GTIM$S	#TIMBUF		; GET TIME/DATE
	MOV	#TIMBUF,R2	; FORMAT TITLE LINE
	MOV	#TITBUF,R0
	MOV	#MSG1,R1
	CALL	$EDMSG
	MOV	R0,PAGEPT	; SAVE ADDRESS TO INSERT PAGE

; START PRINTING THE REPORT
; FIRST PAGE IS MISC.


	PAGE			; START NEW PAGE

; WRITE TIME ACTIVE

	WRTLIN	HOUR,TIMMSG	; WRITE TOTAL TIME ACTIVE
	SPACE	1		; SKIP A LINE

; WRITE SAMPLES/SECOND

	CALL	GETSEC		; FIND TOTAL SAMPLES/SECOND
	MOV	#ARGBK2+2,R4	; POINT TO RESULT BUFFER
	MOV	TOTCNT,R2	; GET TOTAL NUMBER OF SAMPLES
	MOV	TOTCNT+2,R3
	CALL	PERSEC		; FIND PER SECOND TOTAL
	WRTLIN	ARGBK2,MSG2	; WRITE TOTALS
	SPACE	1		; SKIP A LINE

; WRITE TOTAL CPU TIME USED

	MOV	TOTCNT,R0	; GET CPU TIME USED
	MOV	TOTCNT+2,R1
	SUB	IDLCT+2,R1
	SBC	R0
	SUB	IDLCT,R0
	MOV	R0,CPUCNT	; STORE
	MOV	R1,CPUCNT+2
	PERCNT	TOTCNT,CPUCNT,CPUBLK ; FIND %
	WRTLIN	CPUBLK,CPUMSG	; WRITE LINE
	SPACE	1		; SKIP A LINE

; WRITE NUMBER OF TASKS

	MOV	TSKCNT,ARGBK8	; GET # OF TASKS
	DEC	ARGBK8		; 1 IS THE EXEC
	WRTLIN	ARGBK8,MSG8	; WRITE LINE
	SPACE	1		; SKIP A LINE

; WRITE MONITOR TOTALS

	PERCNT	TOTCNT,MONCNT,ARGB15+2	; FIND % OF TOTAL FOR MONITOR
	WRTLIN	ARGB15,MSG15	; WRITE LINE
	SPACE	1		; SKIP A LINE

; WRITE NUMBER OF TASKS LOST BECAUSE OF QUEUE FULL

	WRTLIN	TSKLST,MSG7	; WRITE TASK LOST LINE
	SPACE	1		; SKIP A LINE

; WRITE NUMBER OF MISSED INTERRUPTS

	WRTLIN	ARGBK6,MSG6	; WRITE MISSED INTERRUPTS
	SPACE	1		; SKIP A LINE

; WRITE TOTAL NUMBER OF DIRECTIVES

	WRTLIN	ARGBK9,MSG9	; PRINT DIRECTIVE TOTAL LINE


; PRINT MEMORY,SUMMARY,DIRECTIVE AND TASK SUBREPORTS


	RETURN

	.PAGE
	.SBTTL	PERSEC -- FIND SAMPLES/SECOND

GETSEC:	MOV	HOUR,R0		; GET TIME INTO SECONDS
	MUL	#3600.,R0	; MUL BY SEC/HOUR
	MOV	MIN,R2		; GET MIN INTO SECONDS
	MUL	#60.,R2
	ADD	R3,R1		; ADD TO TOTAL
	ADD	SEC,R1		; ADD IN SECONDS
	ADC	R0
	MOV	R0,TOTSEC	; SAVE TOTAL SECONDS
	MOV	R1,TOTSEC+2
	RETURN

;+
;	PERSEC -- FIND PER SECOND TOTAL XXXX.XX
;
; INPUT
;
;	R2,R3 = VALUE TO BE DIVIDED INTO PER SECOND
;	R4 => 3 WORD RESULT
;
; OUTPUT
;
;	RESULT STORED -4(R4)
;
;-

PERSEC:	MOV	R0,-(SP)	; SAVE REGISTERS
	MOV	R1,-(SP)
	MOV	TOTSEC,R0	; GET TOTAL SECONDS
	MOV	TOTSEC+2,R1
	MOV	R0,-(SP)	; SAVE TOTAL SECONDS
	MOV	R1,-(SP)
	CALL	$$DDIV		; DO DIVISION
	MOV	R3,(R4)+	; SAVE HIGH PART
	MOV	R1,R2		; MUL BY 10 (REMAINDER)
	CALL	MUL10		;
	MOV	@SP,R1		; GET BACK TOTAL SECONDS
	MOV	2(SP),R0
	CALL	$$DDIV		; DO DIVISION
	MOV	R3,(R4)+	; SAVE
	MOV	R1,R2		; FOR MUL
	CALL	MUL10		; MULTIPLY BY 10
	MOV	(SP)+,R1	; RESTORE TOTAL SECONDS
	MOV	(SP)+,R0
	CALL	$$DDIV		; DO DIVIDION
	MOV	R3,(R4)		; STORE
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RETURN

	.PAGE
	.SBTTL	SORTTN -- SORT TASK NAMES

SORTTN:	
	MOV	TSKCNT,R1		; GET # OF TASKS TO SORT
	DEC	R1			; MAKE IT 1 LESS
	BEQ	100$			; ONLY 1
	MOV	#TSKBUF,R2		; START AT BEGINNING

10$:	MOV	R2,R3			; MAKE R3 THE SAME AS R2
	ADD	#TSKSIZ,R3		; MAKE IT POINT TO NEXT PACKET
	MOV	R1,R4			; FOR LOOP CONTROL
20$:	CMP	(R3),(R2)		; COMPARE TASK NAMES
	BHI	40$			; DON'T NEED TO SWITCH THESE 2
	BLO	30$			; WE DO THESE
	CMP	2(R3),2(R2)		; CHECK 2ND HALF
	BHIS	40$			; NOPE

; SWAP TASK PACKETS

30$:	MOV	R2,R0			; SAVE PACKET
	MOV	#TSKSIZ/2,R5
35$:	MOV	(R0)+,-(SP)		; SAVE IT ON THE STACK
	SOB	R5,35$			; LOOP
	MOV	#TSKSIZ/2,R5
	MOV	R2,R0			; POINT TO PACKET TO SWAP
36$:	MOV	(R3)+,(R0)+		; STORE IT
	SOB	R5,36$			; LOOP
	MOV	#TSKSIZ/2,R5
37$:	MOV	(SP)+,-(R3)		; STORE OTHER PACKET
	SOB	R5,37$			; LOOP

40$:	ADD	#TSKSIZ,R3		; TRY NEXT PACKET
	SOB	R4,20$			; LOOP
	ADD	#TSKSIZ,R2		; SORT NEXT PART OF BUFFER
	SOB	R1,10$			; LOOP

100$:	MOV	#^RRSX,TSKBUF		; MAKE 1ST ENTRY RSX11M
	MOV	#^R11M,TSKBUF+2		; 
	RETURN

	.PAGE
	.SBTTL	CALCPC -- CALCULATE PERCENT

CALCPC:
	MOV	R0,-(SP)	; SAVE REGISTERS
	MOV	R1,-(SP)	
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)

	MOV	(R5)+,R4	; R4 =>  PARAMETER 1
	MOV	(R5)+,R3	; R3 =>  PARAMETER 2
	MOV	(R3)+,R0	; GET HIGH WORD
	MOV	(R3)+,R2	; GET LOW WORD
	CALL	MUL100		; MULTIPLY R0,R1 BY 100.
	MOV	2(R4),R1	; GET BACK PARAMETER 1
	MOV	(R4),R0
	MOV	(R5)+,-(SP)	; SAVE ADDRESS TO STOTE %
	CALL	DIVIDE		; GET %


; 1/10 %

	ADD	#2,@SP		; POINT TO .NN PART OF RESULT
	MOV	R1,R2		; MOVE LOW PART
	CALL	MUL10		; MULTIPLY BY 10
	MOV	(R4)+,R0	; GET HIGH WORD
	MOV	(R4),R1
	CALL	DIVIDE		; GET %

; NOW FOR 1/100 %

	ADD	#2,@SP		; NOW FOR 1/100 OF %
	MOV	R1,R2		; MOVE LOW PART
	CALL	MUL10		; MULTIPLY BY 10
	MOV	@R4,R1		; GET TOTAL 
	MOV	-(R4),R0
	CALL	DIVIDE		; DIVIDE IT

	ADD	#2,SP		; FIX SP

; RESTORE REGISTERS AND RETURN

40$:	MOV	(SP)+,R4	; RESTORE REGISTERS
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	R5		; RETURN

DIVIDE:	TST	R0		; ZERO HIGH PART?
	BNE	30$		; NO HIGH PART?
	TST	R1		; LOW PART MINUS?
	BMI	30$		; YES

; USE HARDWARE DIVIDE

	DIV	R1,R2		; USE HARWARE DIVIDE
	BVC	20$		; NO ERROR
	CLR	R2		; MAKE IT ZERO
20$:	MOV	R2,@2(SP)	; STORE RESULT
	CLR	R0		; FOR HIGH PART OF REMAINDER
	MOV	R3,R1		; MAKE REGISTERS COME OUT RIGHT
	BR	40$		; EXIT

; USE SOFTWARE DIVIDE

30$:	CALL	$$DDIV		; USE DOUBLE PERCISION DIVIDE ROUTINE
	MOV	R3,@2(SP)	; STORE RESULT
40$:	RETURN

MUL10:	CLR	-(SP)		; SET AMOUNT TO ADD IN
	TST	R2		; HIGH BIT OF R2 SET?
	BPL	10$		; HIGH BIT IS SET

; MULTIPLY BY 10.

	MOV	#5,@SP		; SAVE FOR LATER
	BIC	#100000,R2	; CLEAR HIGH BIT

10$:	MUL	#10.,R0		; GET HIGH WORD RESULT
	MUL	#10.,R2		; GET LOW RESULT
	ADD	R1,R2		; ADD PARTIALS
	ADD	(SP)+,R2	; ADD IN HIGH BIT MULTIPLICATION
	RETURN
MUL100:	CLR	-(SP)		; SET AMOUNT TO ADD IN
	TST	R2		; HIGH BIT OF R2 SET?
	BPL	10$		; HIGH BIT IS SET

; MULTIPLY BY 100.

	MOV	#62,@SP		; SAVE FOR LATER
	BIC	#100000,R2	; CLEAR HIGH BIT

10$:	MUL	#100.,R0	; GET HIGH WORD RESULT
	MUL	#100.,R2	; GET LOW RESULT
	ADD	R1,R2		; ADD PARTIALS
	ADD	(SP)+,R2	; ADD IN HIGH BIT MULTIPLICATION
	RETURN
	.PAGE
	.SBTTL	DOUBLE DIVIDE ROUTINE

;+
;	$$DDIV -- DIVIDE DOUBLE
;
; INPUTS
;	R3 = LOW ORDER DIVIDEND (32 BITS
;	R2 =HIGH ORDER           UNSIGNED)
;	R1 = LOW ORDER DIVISOR  (32 BITS
;	R0 = HIGH ORDER          UNSIGNED)
;
; OUTPUTS
;
;	R0,R1 = REMAINDER
;	R2,R3 = QUOTIENT
;
;-

$$DDIV::MOV	R4,-(SP)	; SAVE REGISTER
	MOV	#32.,R4		; LOOP 32. TIMES
	MOV	R0,-(SP)	; SAVE DIVISOR
	MOV	R1,-(SP)
	CLR	R0		; START REMAINDER AT 0
	CLR	R1

; DO DIVISION

10$:	ASL	R3		; SHIFT TO LEFT
	ROL	R2

	ROL	R1		; SHIFT REMAINDER TO LEFT
	ROL	R0

	CMP	R0,2(SP)	; REMAINDER TOO LARGE?
	BLO	50$		; NO  LOW
	BHI	30$		; TOO BIG

	CMP	R1,(SP)		; CHECK LOW ORDER DIVISOR
	BLO	50$		; NOT BIG ENOUGH

30$:	SUB	(SP),R1		; SUBTRACT OUT DIVISOR
	SBC	R0
	SUB	2(SP),R0
	INC	R3		; ADD 1 INTO RESULT

50$:	SOB	R4,10$		; LOOP

	ADD	#4,SP		; CLEAN UP STACK
	MOV	(SP)+,R4
	RETURN
	.PAGE
	.SBTTL	OUTPUT -- OUTPUT AND FORAMT A LINE

OUTPUT:	MOV	R0,-(SP)	; SAVE SOME REGISTERS
	MOV	R1,-(SP)
	MOV	R2,-(SP)

	MOV	(R5)+,R2	; R2 => ARG BLK
	MOV	(R5)+,R1	; R1 => EDIT MESSAGE
	MOV	#OUTBUF,R0	; R0 => OUTPUT BUFFER
	CALL	$EDMSG		; FORMAT LINE
	SUB	#OUTBUF,R0	; R0 = LENGTH
	MOV	R0,R1		; FCS USES R0
	INC	LINCNT		; INCREMENT LINE COUNTER
	CMP	LINCNT,#LINPAG	; ENOUGH SPACE ON THIS PAGE?
	BLE	10$		; YES
	PAGE			; START A NEW PAGE
10$:	PUT$	#OUTFDB,#OUTBUF,R1,PUTERR ; OUTPUT LINE

	MOV	(SP)+,R2	; RESTORE REGISTERS
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	R5



NEWPAG:	MOV	R0,-(SP)	; SAVE R0
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	#PAGMSG,R1		; R1 => FORMAT LINE
	MOV	PAGEPT,R0
	INC	PAGCNT			; NEXT PAGE
	MOV	#PAGCNT,R2
	CALL	$EDMSG			; FORMAT PAGE COUNT
	MOV	R0,R1			; FIND LENGTH
	SUB	#TITBUF-1,R1
	PUT$	#OUTFDB,#TITBUF-1,R1,PUTERR ; WRITE LINE
	MOV	#1,LINCNT		; COUNT LINE
	SPACE	2			; SKIP 2 LINES
	MOV	(SP)+,R2		; RESTORE REGISTERS
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RETURN


BLANK:	.ASCII	'  '

NEWLIN:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	(R5)+,R1		; NUMBER OF LINES TO SKIP
10$:	INC	LINCNT			; INCREMENT LINE COUNT
	CMP	LINCNT,#LINPAG		; AT BOTTOM OF PAGE?
	BLE	20$			; NOT YET
	PAGE				; START A NEW PAGE
	BR	50$			; EXIT
20$:	PUT$	#OUTFDB,#BLANK,#1,PUTERR ; OUTPUT A BLANK LINE
	SOB	R1,10$			; LOOP

50$:	MOV	(SP)+,R1		; RESTORE REGISTERS
	MOV	(SP)+,R0
	RTS	R5			; RETURN

	.PAGE
	.SBTTL	DEVSUM


DEVSUM:	PAGE			; GET TO A NEW PAGE
	WRTLIN	0,DEVHED	; PRINT HEADING
	SPACE 2			; SKIP 2 LINES

; PRINT TOTAL LINE

	PERCNT	TOTCNT,DEVTOT,ARGB16+2	; FIND % OF TOTAL SAMPLES
	WRTLIN	ARGB16,MSG16	; WRITE A LINE
	SPACE	2		; SKIP 2 LINES

; PRINT DEVICE TOTALS

	MOV	DEVCNT,R5	; PRINT TOTALS FOR ALL DEVICES
	MOV	#DEVBUF,R4
10$:	MOV	R4,ARGB17 	; POINT TO DEVICE NAME
	ADD	#DM.NAM,ARGB17
	MOV	R4,ARGB17+2	; POINT TO DEVICE TOTAL
	ADD	#DM.HIC,ARGB17+2
	PERCNT	DEVTOT,@#ARGB17+2,ARGB17+4 ; FIND %
	WRTLIN	ARGB17,MSG17	; PRINT A  LINE
	ADD	#DM.SIZ,R4	; POINT TO NEXT DEVICE
	SOB	R5,10$		; LOOP

; PRINT QIO SUMMARIES

	MOV	#DEVBUF,R5	; R5 => DEVICE TABLE
	MOV	DEVCNT,R4	; GET # OF DEVICES

20$:	PAGE			; START AT A NEW PAGE
	MOV	R5,ARGB19	; POINT TO DEVICE NAME
	MOV	R5,ARGB19+2	; POINT TO DEVICE TOTAL
	ADD	#DM.QIO,ARGB19+2
	PERCNT	QIOTOT,@#ARGB19+2,ARGB19+4 ; FIND %
	WRTLIN	ARGB19,MSG19	; WRITE DEVICE TOTAL
	SPACE	2		; SKIP A COUPLE OF LINES

; FOR EACH DEVICE

	MOV	ARGB19,ARGB18	; STORE DEVICE NAME POINTER
	MOV	ARGB18,ARGB18+14. ;
	CLR	ARGB18+2	; CLEAR UNIT NUMBER
	MOV	DM.PTR(R5),R3	; R3 => UNIT TOTALS
	ADD	#DEVBUF,R3	; ADD IN START OF BUFFER
	MOV	DM.NUM(R5),R2	; R2 = NUMBER OF UNITS
30$:	MOV	R3,ARGB18+4	; STORE PTR TO UNIT TOTAL
	PERCNT	@#ARGB19+2,R3,ARGB18+6 ; FIND % OF DEVICE TOTAL
	WRTLIN	ARGB18,MSG18	; PRINT LINE
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	@R3,R2		; GET TOTAL QIOS FOR DEVICE
	MOV	2(R3),R3	;
	MOV	#ARGB20,R4	; POINT TO RESULT BUFFER
	CALL	PERSEC		; GET PER SECOND TOTAL
	MOV	(SP)+,R4	; RESTORE REGISTERS
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	WRTLIN	ARGB20,MSG20	; WRITE LINE
	SPACE	1		; SKIP A LINE
	ADD	#4,R3		; FOR NEXT TOTAL
	INC	ARGB18+2	; INCREMENT UNIT NUMBER
	SOB	R2,30$		; LOOP
	ADD	#DM.SIZ,R5	; NEXT DEVICE
	DEC	R4		; SIMULATE A SOB
	BNE	20$		; LOOP
	RETURN

	.PAGE
	.SBTTL	DIRECTIVE SUMMARY

TMPTOT:	.WORD	0,0
DIRSUM:	PAGE			; START ON A NEW PAGE
	WRTLIN	0,DIRHED	; WRITE SUMMARY HEADING
	SPACE	2		; SKIP 2 LINES
	PERCNT	TOTCNT,USRTRP,ARGB12+2 ; GET USER TRAP TOTAL
	WRTLIN	ARGB12,MSG12		; WRITE USER TRAP TOTAL
	SPACE	1			; SKIP A LINE

	MOV	#DIRNAM,R5	; R5 => DIRECTIVE NAMES
	MOV	#DIRBUF,R4	; R5 => TO DIRECTIVE STATISTICS BUFFER
	MOV	#128.,R3	; 128. DIRECTIVES
10$:
	TST	2(R4)		; DIRECTIVE NOT EXECUTED?
	BNE	20$		; NO
	TST	@R4		; CHECK LOW WORD
	BEQ	30$		; YES
20$:	MOV	R5,DIRBLK	; POINT TO DIRECTIVE NAME
	MOV	R4,DIRBLK+4	; TOTAL POINTER FOR DIRECTIVE
	ADD	2(R4),TMPTOT+2
	ADC	TMPTOT
	ADD	@R4,TMPTOT
	PERCNT	DIRTOT,R4,DIRBLK+6	; CALCULATE PERCDENT OF TOTAL
	WRTLIN	DIRBLK,DIRMSG	; WRITE LINE
30$:	ADD	#4,R4		; NEXT DIRECTIVE
	ADD	#4,R5
	ADD	#2,DIRBLK+2	; NEXT DIC
	SOB	R3,10$		; LOOP

	MOV	#TMPTOT,ARGBK9
	SPACE	1
	WRTLIN	ARGBK9,MSG9
	RETURN
	.PAGE
	.SBTTL	SUMMARY PAGE

SUMARY:	PAGE			; START ON A NEW PAGE
	WRTLIN	0,SUMHED	; WRITE SUMMARY HEADING
	SPACE	2		; SKIP 2 LINES
	PERCNT	TOTCNT,IDLCT,ARGBK3+2 ; GET IDLE %
	WRTLIN	ARGBK3,MSG3	; OUTPUT IDLE TIME

	MOV	TSKCNT,R0	; GET # OF TASKS
	MOV	#TSKBUF,R1	; GET START OF TASK BUFFER
10$:	CMP	TS.LNK(R1),#-1	; DON'T PRINT FOR THIS TASK?
	BEQ	20$		; YES
	MOV	(R1),ARGBK4	; STORE TASK NAME
	MOV	TS.NAM+2(R1),ARGBK4+2
	ADD	TS.DIR+2(R1),TS.CNT+2(R1); ADD USER TRAP TOTAL TO TASK TOTAL
	ADC	TS.CNT(R1)
	ADD	TS.DIR(R1),TS.CNT(R1)
	MOV	R1,ARGBK4+4	; STORE POINTER
	ADD	#TS.CNT,ARGBK4+4
	PERCNT	TOTCNT,@#ARGBK4+4,ARGBK4+6 ; FINS PERCENT
	WRTLIN	ARGBK4,MSG4
	TST	ARGBK4+6.	; 0% OF TOTAL?
	BNE	20$		; NO
	MOV	#-1,TS.LNK(R1)	; MARK IT TO NOT PRINT TASK PROFILE
20$:	ADD	#TSKSIZ,R1		; POINT TO NEXT TASK PACKET
	SOB	R0,10$		; LOOP
	RETURN

	.PAGE
	.SBTTL	GETNXT -- GET NEXT TASK PC PACKET

GETNXT:	CALL	$SAVAL		; SAVE REGISTERS
	MOV	NXTWRD,R0	; GET NEXT ADDRESS
	MOV	NXTWRD+2,R1
	DIV	#512.,R0	; GET VBN,OFFSET
	INC	R0		; MAKE IT THE REAL VBN
	READWD	PGCNTR		; GET PROGRAM COUNTER
	READWD	NXTWRD,#2	; GET NEXT PACKET POINTER
	READWD	NXTWRD+2,#2	; GET LOW WORD
	RETURN


GETWRD:	MOV	R1,-(SP)	; SAVE REGISTERS
	MOV	R2,-(SP)
	CALL	BLKRED		; FIND OUT IF WE ALREADY READ BLOCK
	BCC	10$		; WE HAVE
	CALL	GETBLK		; READ IT IN THEN
10$:	INC 4(R2)		; INCREMENT ACCESS COUNT
	ADD	@R2,R1		; ADD IN ADDRESS OF BUFFER
	MOV	@R1,R4		; R4 = WORD READ
	MOV	(SP)+,R2	; RESTORE REGISTERS
	MOV	(SP)+,R1
	RETURN


BLKRED:	MOV	#BUFCNT,R4	; R4=NUMBER OF READ BUFFERS
	MOV	#BLKTBL,R2	; R2 => BUFFER TABLE
10$:	CMP	R0,2(R2)	; THIS BUFFER IS VBN?
	BEQ	20$		; YES
	ADD	#6,R2		; TRY NEXT BUFFER
	SOB	R4,10$		; LOOP
	SEC
	RETURN			; BLOCK WASN'T READ

20$:	CLC			; WE HAVE ALREADY READ BLOCK
	RETURN

GETBLK:	MOV	#BUFCNT,R4	; R4 = NUMBER OF READ BUFFERS
	MOV	#BLKTBL,R2	; POINT TO READ BUFFER TABLE
	CLR	-(SP)		; GET A TEMP LOCATION
	MOV	#-1,R5		; START AT HIGH USAGE
10$:	CMP	4(R2),R5	; THIS ONE SMALLER
	BHIS	20$		; NO
	MOV	R2,(SP)	; SAVE TABLE POSITION
	MOV	4(R2),R5	; USE THIS USAGE COUNT
20$:	SOB	R4,10$		; LOOP
	MOV	(SP)+,R2	; R2 = TABLE PTR FOR BUFFER TO USE
	CLR	4(R2)		; SET USE TO ZERO
	MOV	R0,2(R2)	; STORE VBN
	QIOW$S	#IO.RVB,#INLUN,#INEF,,#IOSB,,<(R2),#BLKSIZ,,,R0> ; READ BLOCK
	CALL	CHKIO		; MAKE SURE IT WORKED
	RETURN

	.PAGE
	.SBTTL	GETCNT -- GET TASK EXECUTION COUNTS

GETCNT:	TST	NXTWRD		; ARE WE FINISHED?
	BNE	10$		; NOT YET
	TST	NXTWRD+2	; COULD BE
	BEQ	100$		; STOP

10$:	CALL	GETNXT		; GET NEXT TASK PC BUFFER
	MOV	PGCNTR,R1	; FIND TASK COUNT BUFFER OFFSET
	ASH	#-7,R1		; GET OFFSET
	BIC	#^C<777>,R1	; MAKE SURE BITS ARE CLEAR
	ASH	#2,R1		; MAKE IT A 2 WORD OFFSET
	ADD	#1,ADRCNT+2(R1)	; ADD INTO TOTAL
	ADC	ADRCNT(R1)
	BR	GETCNT		; LOOP

100$:	MOV	#512.,R5	; THERE ARE 512. ENTRIES
	MOV	#ADRCNT,R4	; R4 => COUNT TABLE
105$:	TST	@R4		; ZERO COUNT?
	BNE	110$		; NOPE
	TST	2(R4)
	BEQ	120$		; YES
110$:	MOV	R4,ARGBK5+4	; POINT TO COUNT
	PERCNT	R0,R4,ARGBK5+6,#TS.CNT ; FIND %
	TST	ARGBK5+6	; < 1% ?
	BEQ	120$		; YES DON'T PRINT LINE
	WRTLIN	ARGBK5,MSG5	; WRITE A LINE
120$:	ADD	#4,R4		; NEXT ADDRESS RANGE
	ADD	#128.,ARGBK5	; NEXT ADDRESS RANGE
	ADD	#128.,ARGBK5+2
	SOB	R5,105$		; LOOP
	RETURN

	.PAGE
	.SBTTL	PRTTSK -- PRINT TASK EXECUTION RANGE

PRTTSK:	CMP	TS.LNK(R0),#-1	; DON'T PRINT FOR THIS TASK
	BEQ	20$		; YES
	CALL	$SAVAL		; SAVE REGISTERS
	PAGE			; GET A NEW PAGE
	MOV	@R0,ARGB10	; STORE TASK NAME
	MOV	2(R0),ARGB10+2
	WRTLIN	ARGB10,MSG10	; WRITE TASK NAME
	WRTLIN	0,MSG11		; UNDER LINE IT
	SPACE	2		; SKIP 2 LINES

	MOV	@R0,ARGBK4	; STORE TASK NAME
	MOV	2(R0),ARGBK4+2
	MOV	R0,R1		; GET TOTAL FOR TASK
	ADD	#TS.CNT,R1		; POINTER TO COUNT
	MOV	R1,ARGBK4+4	; SAVE IT
	PERCNT	TOTCNT,R1,ARGBK4+6 ; FIND %
	WRTLIN	ARGBK4,MSG4	; WRITE TASK TOTAL LINE

	CMP	@R0,#^RRSX	; IS IT RSX11M?
	BNE	5$		; NO
	CMP	2(R0),#^R11M	;
	BEQ	7$		; YES -ITS THE EXEC DON'T PRINT USER DIRECTIVE LINE
5$:	ADD	#<TS.DIR-TS.CNT>,R1	; POINT TO USER TRAP TOTAL
	MOV	R1,ARGB12	; STORE INTO ARGUMENT BLOCK
	PERCNT	TOTCNT,R1,ARGB12+2 ; FIND %
	WRTLIN	ARGB12,MSG12
	MOV	R1,ARGB13	; STORE INTO ARGUMENT BLOCK
	SUB	#<TS.DIR-TS.CNT>,R1 ; POINT TO TOTAL CPU
	PERCNT	R1,R1,ARGB13+2,,#<TS.DIR-TS.CNT> ; FIND %
	WRTLIN	ARGB13,MSG13	; WRITE LINE
7$:	SPACE	2		; SKIP 2 LINES
	MOV	#1024.,R5	; CLEAR COUNT BUFFER
	MOV	#ADRCNT,R1	; R1 => ADDRESS RANGE COUNT TABLE
10$:	CLR	(R1)+
	SOB	R5,10$

	CLR	ARGBK5		; MAKE RANGE START AT 0
	MOV	#127.,ARGBK5+2	; AND END AT 127.
	MOV	TS.PTR(R0),NXTWRD ; GET STARTING PC PACKET LINK
	MOV	TS.PTR+2(R0),NXTWRD+2
	CALL	GETCNT		; PRINT TASK COUNTS
20$:	RETURN			; EXIT



	.PAGE
	.SBTTL	MEMSUM -- PRINT IN/OUT OF MEMORY SUMMARY

MEMSUM:	PAGE			; START A NEW PAGE
	WRTLIN	0,MEMHED	; PRINT HRADING
	SPACE	2		; SKIP 2 LINES

; WRITE SYSTEM TOTALS

; FIND AVG. SIZE OF MEMORY USED

	MOV	MEMSIZ+2,R3	; GET INTO 1024. BYTE
	MOV	MEMSIZ,R2
	CLR	R0		; FIND AVG. MEMORY USED
	MOV	MEMCNT,R1
	CALL	$$DDIV		; DO DIVISION
	ADD	#16.,R3		; ROUND IT
	ADC	R2
	ASHC	#-5,R2		; GET INTO 1024. WORD BLOCKS
	MOV	R3,MEMSIZ+2	; SAVE
	MOV	R2,MEMSIZ

; FIND AVG. NUMBER OF TASKS IN MENORY

	MOV	MEMNO,R2	; NOW FIND AVG. NO. OF TASKS IN MEMORY
	MOV	MEMNO+2,R3
	CLR	R0		; FOR DIVISOR
	MOV	MEMCNT,R1	; USE NUMBER OF SAMPLES
	CALL	$$DDIV		; DO DIVISION
	MOV	R2,MEMNO	; STORE RESULT
	MOV	R3,MEMNO+2

; STORE INTO PARAMETER BLOCK

	MOV	MEMLO,MEMBLK	; STORE LOW NO. OF TASKS IN MEMORY
	MOV	MEMHI,MEMBLK+2	; STORE HIGH NO. OF TASKS IN MEMORY
	MOV	#MEMNO,MEMBLK+4	; STORE PTR TO AVG. NUMBER OF TASKS IN MEMORY
	MOV	#MEMSIZ,MEMBLK+6; STORE PTR TO AVG. AMOUNT OF MEMORY USED
	WRTLIN	MEMBLK,MEMMSG	; PRINT MEMORY USAGE

; CHECKPOINTED TASKS NOW

; FIND AVG. SIZE OF CHECKPOINTED  MEMORY USED

	MOV	CKPSIZ+2,R3	; GET INTO 1024. BYTE
	MOV	CKPSIZ,R2
	CLR	R0		; FIND AVG. MEMORY USED
	MOV	MEMCNT,R1
	CALL	$$DDIV		; DO DIVISION
	ADD	#16.,R3		; ROUND IT
	ADC	R2
	ASHC	#-5,R2		; GET INTO 1024. WORD BLOCKS
	MOV	R3,CKPSIZ+2	; SAVE
	MOV	R2,CKPSIZ

; FIND AVG. NUMBER OF TASKS CHECKPOINTED

	MOV	CKPNO,R2	; NOW FIND AVG. NO. OF TASKS CHECKPOINTED
	MOV	CKPNO+2,R3
	CLR	R0		; FOR DIVISOR
	MOV	MEMCNT,R1	; USE NUMBER OF SAMPLES
	CALL	$$DDIV		; DO DIVISION
	MOV	R2,CKPNO	; STORE RESULT
	MOV	R3,CKPNO+2

; STORE INTO PARAMETER BLOCK

	MOV	CKPLO,CKPBLK+2	; STORE CHECKPOINTED LOW
	MOV	CKPHI,CKPBLK+2	; STORE HIGH NO. OF TASKS CHECKPOINTED
	MOV	#CKPNO,CKPBLK+4	; STORE PTR TO AVG. NUMBER OF TASKS CHECKPOINTED
	MOV	#CKPSIZ,CKPBLK+6; STORE PTR TO AVG. AMOUNT OF MEMORY USED
	WRTLIN	CKPBLK,CKPMSG	; PRINT MEMORY USAGE

; WRITE TASK TOTALS

	SPACE	1		; SKIP A LINE
	MOV	#TSKBUF+TSKSIZ,R0	; POINT TO TASK PACKETS
	MOV	TSKCNT,R1		; GET # OF TASKS
	DEC	R1
	BEQ	200$			; AREN'T ANY

10$:	CALL	PRTIO			; PRINT LINES
	TST	TS.CNT(R0)		; NO SAMPLES?
	BNE	20$			; NO
	TST	TS.CNT+2(R0)		; 2ND HALF?
	BNE	20$			; NO
	MOV	#-1,TS.LNK(R0)		; SET DON'T PRINT LATER
20$:	ADD	#TSKSIZ,R0		; POINT TO NEXT ENTRY
	SOB	R1,10$			; LOOP

200$:	RETURN				; EXIT

;+
;	PRTIO -- PRINT IN/OUT OF MEMORY TOTALS
;-

PRTIO:	TST	TS.IN(R0)	; ZERO?
	BNE	10$		; NO
	TST	TS.OU(R0)	; ZERO
	BEQ	20$		; YES -- SO DON'T PRINT IT
10$:
	MOV	TS.SIZ(R0),R5		; GET SIZE INTO KW
	CLR	R4
	ADD	#16.,R5			; FOR ROUNDING
	ADC	R4
	ASHC	#-5,R4			; GET INTO 1KW BLOCKS
	MOV	R5,ARGB14+24.		; STORE TASK SIZE
	MOV	TS.NAM(R0),ARGB14	; STORE TASK NAME
	MOV	TS.NAM+2(R0),ARGB14+2
	MOV	TS.IN(R0),TOTIN+2	; STORE TOTAL IN MEMORY
	MOV	TS.IN(R0),ARGB14+4	; SAVE TO BE PRINTED
	MOV	TS.OU(R0),ARGB14+16	; SAVE TOTAL MEMORY OUT
	MOV	TS.OU(R0),TOTOUT+2	; SAVE
	MOV	TS.OU(R0),TOTMEM+2	; GET TOTAL OF IN/OUT
	ADD	TS.IN(R0),TOTMEM+2
	ADC	TOTMEM
	PERCNT	TOTMEM,TOTIN,ARGB14+6	; FIND % IN MEMORY
	PERCNT	TOTMEM,TOTOUT,ARGB14+20	; FIND % OUT OF MEMORY
	WRTLIN	ARGB14,MSG14		; WRITE LINE
20$:	RETURN

	.PAGE
	.SBTTL	MAIN ROUTINE

START:	CALL	INIT		; INITIALIZE PROGRAM
	BIT	#SW.ME,SWMASK	; PRINT MEMORY STATS?
	BNE	10$		; NO
	CALL	MEMSUM		; PRINT MEMORY USAGE PAGE
10$:	CALL	SUMARY		; PRINT SUMMARY PAGE
	BIT	#SW.IO,SWMASK	; PRINT DEVICE STATS?
	BNE	20$		; NO
	CALL	DEVSUM		; PRINT DEVICE SUMMARY
20$:	BIT	#SW.DR,SWMASK	; PRINT DIRECTIVE SUMMARY?
	BNE	30$		; NO
	CALL	DIRSUM		; PRINT DIRECTIVE SUMMARY

; PRINT TASK EXECUTION STATISTICS

30$:	BIT	#SW.PC,SWMASK	; PRINT TASK STATS?
	BNE	EXIT		; NO
	MOV	#TSKBUF,R0	; R0 => TASK BUFFER
	MOV	TSKCNT,R1	; R1 = NUMBER OF TASKS
50$:	CALL	PRTTSK		; PRINT TASK EXECUTION DATA
	ADD	#TSKSIZ,R0	; POINT TO NEXT TASK
	SOB	R1,50$		; LOOP



EXIT:	TST	ERRFLG		; ERROR?
	BNE	10$		; YES
	DELET$	#INFDB		; DELET INPUT FILE
	BR	20$
10$:	CLOSE$	#INFDB		; CLOSE INPUT FILE
20$:	CLOSE$	#OUTFDB		; CLOSE OUTPUT FILE
	EXIT$S			; EXIT TASK
ERRFLG:	.WORD	0		; ERROR FLAG

	.END	START