.TITLE	RTMON	System Display Monitor
	.ENABL	LC
	.NLIST	BEX
	.ENABL	GBL

; Insert verbiage here

;	R. Billig, J. Harris - Authors
;	L. Parent	     - Enhancements 11/79, 2/80

; System MACRO requirements

	.MCALL	.GTJB,	.EXIT,	.PRINT,	.TWAIT,	.RCTRL,	.TTYOU, .GVAL, .MTPS

; SYSLIB modules referenced

	.GLOBL	DATE,	TIME,	R50ASC
	.SBTTL	Definitions

; Get Job Parameter Block

GT.NUM	= 0		;Job number * 2
GT.HGH	= 2		;High memory limit
GT.LOW	= 4		;Low memory limit
GT.IOC	= 6		;Adrs of I/O channel space
GT.IMP	= 10		;Adrs of job's impure area
GT.CON	= 12		;Console TT unit number (*byte*)
GT.NAM	= 22		;ASCII job name (6 characters)
GT.END  = 30		;*End of Parameter Block*

; Job Impure Area Offsets

I.STATE	= 0		;Status bits
I.QHDR	= 2		;I/O queue header
I.CMPE	= 4		;Completion queue last element
I.CMPL	= 6		;Completion queue head
I.CHWT	= 10		;Pointer to channel during I/O wait
I.PCHW	= 12		;Saved I.CHWT during completion
I.PERR	= 14		;Saved ERRBYT during completion
I.CNSL	= 16		;Pointer to TCB for this job's console (MTTY)
I.TID	= 22		;Pointer to job's ID area
I.JNUM	= 24		;Job number
I.CNUM	= 26		;Number of channels defined
I.CSW	= 30		;Pointer to channel area
I.IOCT	= 32		;Number of outstanding I/O operations
I.SCTR	= 34		;Suspend counter (<0 => suspended)
I.BLOK	= 36		;Blocking bits for job

; RMON Fixed Offset Definitions

RMON	= 54		;Base address of RMON
 CONFG2	= 370			;Configuration word 2
 MONAME	= 406			;Booted monitor name
 PNAME	= 404			;Offset to $PNAME table
 NULCNT	= 416			;Null loop counter (Not a fixed offset!!!!)
 EIS$	= 000400		;Extended Instruction Set present

SYSOP	= 372		;Sysgen options
 STASK$	= 040000		;System task support present
 MMGT$	= 000002		;Extended memory support


; Job Status Word Definitions

JSW	= 44		;Address of JSW
SPMODE	= 010000	;Special TT mode in JSW

; Channel Definitions

CSWMSK	= ^C<76>	;Mask for device index in CSW
C.UNIT	= 11		;Offset in channel of device unit byte

; PSW Definitions

PR0	= 000000	;Priority 0 mask
PR7	= 000340	;Priority 7 mask
	.SBTTL	Blocking, State Conditions

; The following macro is used to define masks on I.BLOK and the
; corresponding messages to be printed.

	.MACRO	BITDEF	BIT,REASON,LABEL
	.WORD	BIT
.IIF NB <LABEL>, LABEL:
	.ASCII	%'REASON%<200>
	.ENDM	BITDEF


	.PSECT	SYSDAT

BLKTAB:	BITDEF	001000,< Done  >
	BITDEF	000100,<SUSPEND>
	BITDEF	040000,<KB Wait>
	BITDEF	020000,<TT Wait>
	BITDEF	004000,<I/O XX0>,IOWAIT
	BITDEF	002000,<SP Wait>
	BITDEF	000400,<Rundown>
	BITDEF	000020,<USRwait>
	BITDEF	000000,<Running>

; Job state word (I.STATE) bit definitions

STATAB:	BITDEF	000040,< Abort >
	BITDEF	100000,< Cmplt >
	BITDEF	000200,< Cpend >
	BITDEF	000004,<  Csi  >
	BITDEF	000010,<  Usr  >
	BITDEF	000000,<       >

	WINDW$	= 10000			;Privileged job bit (not displayed
					; here)
PRIV:	.ASCII	/Priv   /<200>		;String to print if priv. job
NPRIV:	.ASCII	/Virtual/<200>		;If not, print this.
	.SBTTL	Messages

; The following lines define the basic screen setup.

	.PSECT	SYSMSG
INTMSG:	.ASCII	<7>/RT11 System Display Monitor Initializing /
	.ASCIZ	/for 5 sec ... please wait/<7>

LINE01:	.ASCII	/RTMON V01.06/<11><11>/    RT-11 SYSTEM MONITOR/<15><012><012>
LINE03:	.ASCII	/       (   )/<11>/ BGND/<11>/ SYS1/<11>/ SYS2/<11>/ SYS3/<11>
	.ASCII	/ SYS4/<011>/ SYS5/<011>/ SYS6/<011>/ FGND/<015><012><012>
LINE05:	.ASCII	/Job Name:/<015><012><200>	;Pause here for a moment
LINE06:	.ASCII	/Status:/
EOL06:	.ASCII	<015><012>
LINE07:	.ASCII	/Terminal:/<015><012><012>
LINE09:	.ASCII	/Low  Limit:/<015><012>
LINE10:	.ASCII	/High Limit:/<015><012>
LINE11:	.ASCII	/Size (words):/<015><012><012>
LINE13:	.ASCII	/Impure Area:/<015><012><012>
LINE15:	.ASCII	/Channels Open:/<015><012>
LINE16:	.ASCII	%Pending I/O:%<015><012>
LINE17:	.ASCII	/Free Qelements:/<015><012><012>
LINE19:	.ASCII	/Job State:/<015><012><012><012><012>
LINE23:	.ASCII	/System Idle:/

	.BYTE 	200

; Escape sequence definitions

VT52:	.BYTE	033,'[,'?,'2,'l,200	;Set VT100 in VT52 mode
HOME:	.BYTE	033,'H,200		;Cursor home
CLREOS:	.BYTE	033,'J,200		;Clear to end of screen
CURPOS:	.BYTE	033,'Y,200		;Cursor position
GRPON:	.BYTE	033,'F,200		;Select Graphics character set
GRPOFF:	.BYTE	033,'G,200		;Select ASCII character set
ERSEOL:	.BYTE	033,'K,200		;Erase to end of line

; Handy string for clearing a field

CLEAR:	.ASCII	/        /<200>

; String for idle-time histogram

GRAPH:	.REPT	60.
	.BYTE	141
	.ENDR
	.BYTE	040,200

; Error messages

NOST:	.ASCIZ	/RTMON-F-Monitor not generated with system job support/
NOEIS:	.ASCIZ	/RTMON-F-No EIS hardware/
	.SBTTL	Initialization

	.ASECT
.=JSW
	.WORD	SPMODE

	.PSECT	SYSCOD

START:	.RCTRLO				;Get special mode into operation
	MOV	#NOST,R1		;R1 -> Error message
	.GVAL	#AREA,#SYSOP		;Get monitor sysgen options
	MOV	R0,SYSGEN		;Save for later
	BIT	#STASK$,R0		;System task support present?
	BEQ	EXIT			; If eq, no - can't run demo
	MOV	#NOEIS,R1		;R1 -> Error message
	.GVAL	#AREA,#CONFG2		;Get configuration word 2
	BIT	#EIS$,R0		;Do we have EIS hardware?
	BEQ	EXIT			; If eq, no - can't run demo
	.PRINT	#VT52			;Set VT100 in VT52 mode
	.PRINT	#HOME
	.PRINT	#CLREOS
	.PRINT	#INTMSG			;Indicate initialization in progress
	MOV	@#RMON,R1		;R1 -> RMON
	CLR	NULCNT(R1)		;Clear the null job counter
	.TWAIT	#AREA,#INITTM		;Wait for five seconds for reference
	MOV	NULCNT(R1),R4		;Get count for 5 seconds
	CLR	NULCNT(R1)		;Reinitialize
	ROR	R4			;Scale for XM (assumes C clear)
	MOV	R4,MAXNUL		;Set max value for 5 seconds
	MOVB	275(R1),R5		;Get unit # of system device
	ADD	#'0,R5			;Make it ASCII
	MOVB	R5,LINE03+12		;Put it in line too
	MOV	R2,-(SP)		;Save some registers
	MOV	R4,-(SP)
	MOV	R1,R4			;Copy RMON pointer
	ADD	#MONAME,R4		;Point to RAD50 monitor name
	MOV	R4,PNMADR		;Set it in argument list
	MOV	#R50ARG,R5		;Point to argument list
	CALL	R50ASC			;Convert RAD50 to ASCII
	MOV	#IOWAIT+4,PNMADR+2	;Set up for rest of execution
	MOV	#2,CONST
	mov	@#RMON,R1		;Get RMON pointer again
	MOV	PNAME(R1),R4		;R4 = offset to $PNAME
	ADD	R1,R4			;R4 => $PNAME
	ADD	#2,R4			;2nd device = system device
	MOV	R4,PNMADR		;Put addr of R50 name in arg list
	MOV	#R50ARG,R5		;Use SYSLIB R50ASC to convert it
	CALL	R50ASC			;to ASCII...
	MOV	IOWAIT+4,LINE03+10	;Put system device name in line
	MOV	(SP)+,R4		;Restore registers...
	MOV	(SP)+,R2
	.PRINT	#HOME			;Home the cursor
	.PRINT	#CLREOS			;And clear the screen
	.PRINT	#LINE01			;Put up first part of default screen
	MOV	#LINE06,R0		;Assume its an XM monitor
	BIT	#MMGT$,SYSGEN		;Well, is it?
	BNE	1$			; If ne, yes - we guessed right
	MOV	#EOL06,R0		;Skip past 'Status:'
1$:	.PRINT				;Put up rest of default screen	
	BR	UPDATE			;Go print first update

EXIT:	.PRINT	R1			;Print error message
	.EXIT				;Leave
SLEEP:	MOV	#TIMARG,R5		;Get current time of day
	CALL	TIME
	MOV	#DATARG,R5		;And current date
	CALL	DATE
	.PRINT	#DATTIM
	MOV	@#RMON,R0		;R0 -> RMON
	MOV	NULCNT(R0),R3		;Get null loop count
	CLR	NULCNT(R0)		;Clear to start new interval
	ASR	R3			;Divide by two to compare with MAXNUL
	MOV	#5*60.,R4		;Convert to 5 second equivalent
	MUL	R3,R4
	DIV	MAXNUL,R4		;Get percentage
	CMP	R4,#60.			;Should be in range 1..60
	BLOS	1$			;If LOS, okay
	MOV	#60.,R4			;Else set to max value
1$:	CMP	R4,OLDIDL		;Check against last displayed value
	BEQ	SNOOZE			;If the same, just snooze now
	BLT	2$			;If NEW < OLD, go erase part
	MOV	#23.,R1			;Position to line 23
	MOV	OLDIDL,R0		;Get length of old bar
	ADD	#17.,R0			;And set to column beyond old bar
	CALL	GPOSIT			;Position cursor
	MOV	#GRAPH+60.,R5		;Get base of graph bar
	SUB	R4,R5			;And index to get subsection
	ADD	OLDIDL,R5
	.PRINT	#GRPON			;Enter special graphics set
	.PRINT	R5			;Output new bar
	.PRINT	#GRPOFF			;Reselect ASCII set
	BR	3$			;Go print percentage

2$:	MOV	#23.,R1			;Set to line 23
	MOV	R4,R0			;Get end of new bar
	ADD	#17.,R0			; as a column number
	CALL	GPOSIT			;Position cursor
	.PRINT	#ERSEOL			;Erase old extraneous chars
	.TTYOUT	#040			;And a space before the percentage
3$:	MOV	R4,OLDIDL		;Remember what we drew last time
	MOV	R3,R0			;Get percentage base
	MUL	#5*100.,R0
	DIV	MAXNUL,R0
	CMP	R0,#99.			;Cheat for two digit display
	BLOS	4$
	MOV	#99.,R0
4$:	MOV	#BUFFER,R3
	CALL	CVT10			;Convert to decimal ASCII
	MOVB	#'%,(R3)+		;Followed by %
	MOVB	#200,@R3
	.PRINT	#BUFFER			;And output percentage
SNOOZE:	MOV	#24.,R1
	MOV	#1.,R0
	CALL	GPOSIT
	.TWAIT	#AREA,#WAITTM		;Go to sleep

UPDATE:
	.SBTTL	Screen Update

; Whenever the sleep period elapses, come here to update the display

UPDATE:	MOV	#-2,R4			;Preset current job #
NXTJOB:	ADD	#2,R4			;Update to next job
	CMP	R4,#16			;Have we finished all jobs yet?
	BHI	SLEEP			;If HI yes - go to sleep now
	.GTJB	#AREA,#GTDATA,R4	;Get job parameters
	BCC	JOBDAT			;If CC, job exists
	TST	JOBTAB(R4)		;Was this job existing last time?
	BEQ	NXTJOB			;If EQ no - area already blank
	MOV	#5.,R1			;Else clear area, starting at line 5
1$:	CALL	POSIT			;Position to this job's section
	.PRINT	#CLEAR			;Clear the 8 bytes
	INC	R1			;Move to next line
	CMP	R1,#19.			;Have we cleared all lines yet?
	BLOS	1$			;If LOS no
	COM	JOBTAB(R4)		;Indicate no job here
	BR	NXTJOB			;Else examine next job

JOBDAT:	MOV	#-1,JOBTAB(R4)		;Indicate job present
	MOV	#5.,R1			;Position to job name
	CALL	POSIT			;Reposition to job name
	MOVB	#200,GTDATA+GT.END	;Set stopper at end of name
	TST	R4			;Are we doing the background job?
	BNE	2$			; If ne, no
	MOV	#GTDATA+GT.NAM,R1	;R1 -> Logical job name in .GTJB block
1$:	TSTB	(R1)+			;Scan name, replace 0s with spaces
	BMI	2$			; If MI, we're at the end
	BNE	1$			; If NE, its a character
	MOVB	#040,-(R1)		;Make it a space (rescan will skip it)
	BR	1$			;Rescan the space, continue

2$:	.PRINT	#GTDATA+GT.NAM		;Print out name
	BIT	#MMGT$,SYSGEN		;Is this an XM monitor?
	BEQ	4$			; If eq, no - skip status business
	MOV	#6.,R1			;Position to job status
	CALL	POSIT
	MOV	#PRIV,R2		;Assume its a privileged job
	MOV	GTDATA+GT.IMP,R3	;R3 -> Impure area of job
	BIT	#WINDW$,I.STATE(R3)	;Is it a virtual job?
	BEQ	3$			; If EQ, no - we guessed right
	MOV	#NPRIV,R2		;R2 -> virtual job message
3$:	.PRINT	R2			;Print job status
4$:	MOV	#7.,R1			;Position to terminal ID
	CALL	POSIT
	MOV	GTDATA+GT.IMP,R5	;R5 -> job's impure area
	CLR	R0			;R0 = count of open channels
	MOV	I.CNUM(R5),R1		;R1 = number of channels defined
	BEQ	7$			;If EQ none
	MOV	I.CSW(R5),R2		;R2 -> channel area
5$:	TST	@R2			;Is this channel active?
	BPL	6$			;If PL no
	INC	R0			;Else increase active count
6$:	ADD	#12,R2			;Skip current channel
	SOB	R1,5$			;And continue for all defined
7$:	MOV	R0,CHNCNT		;Store count of open channels
	.MTPS	#PR7			;;; No interrupts here!
	MOV	I.IOCT(R5),IOCNT	;;;Store pending I/O count
	MOV	I.STATE(R5),STATBT	;;; and job state
	MOV	I.BLOK(R5),BLOKBT	;;; and blocking bits
	MOV	I.CHWT(R5),R0		;;; and channel wait info
	MOV	@R0,CHWAIT		;;; store channel CSW
	MOVB	C.UNIT(R0),CHUNIT	;;; also unit # of device
	.MTPS	#PR0			;Okay, all you clock ticks...
	CLR	R0			;R0 = count of elements free
	MOV	I.QHDR(R5),R1		;R1 -> next free Q element
	BEQ	9$			;If EQ, none free
8$:	INC	R0			;Else increase free count
	MOV	@R1,R1			;Link to next
	BNE	8$			;And continue if not last in list
9$:	MOV	R0,QELCNT		;Store number of free Q elements
	MOVB	GTDATA+GT.CON,R0	;Get console lun number
	MOV	#TTNUM,R3		;Set adrs of lun output
	CALL	CVT8			;Convert as octal
	MOVB	#':,(R3)+		;Followed by a colon
	MOVB	#200,@R3		;And terminate
	.PRINT	#TTNAME			;Print terminal name
	MOV	#9.,R1			;Position to low mem limit
	CALL	POSIT
	MOV	GTDATA+GT.LOW,R0	;R0 = low memory limit
	MOV	#BUFFER,R3
	CALL	OCTASC			;Convert to ascii
	MOVB	#200,@R3
	.PRINT	#BUFFER			;Print low limit
	MOV	#10.,R1			;Position to high memory limit
	CALL	POSIT
	MOV	GTDATA+GT.HGH,R0	;R0 = high memory limit
	MOV	#BUFFER,R3
	CALL	OCTASC
	MOVB	#200,@R3
	.PRINT	#BUFFER
	MOV	#11.,R1			;Position to job size area
	CALL	POSIT
	MOV	GTDATA+GT.HGH,R0	;Get high memory limit
	SUB	GTDATA+GT.LOW,R0	;Subtract low limit
	CLC
	ROR	R0			;Compute size in words
	ADC	R0
	CALL	15$			;Output as decimal
	MOV	#13.,R1			;Position to impure area output
	CALL	POSIT
	MOV	#BUFFER,R3
	MOV	R5,R0			;R0 = address of impure area
	CALL	OCTASC
	MOVB	#200,@R3
	.PRINT	#BUFFER
	MOV	#15.,R1			;Position to channels open
	CALL	POSIT
	MOV	CHNCNT,R0		;Get count of open channels
	CALL	15$			;Output as decimal
	MOV	#16.,R1			;Position to pending I/O count
	CALL	POSIT
	MOV	IOCNT,R0		;R0 = pending I/O count
	CALL	15$			;Output as decimal
	MOV	#17.,R1			;Position to free Q element area
	CALL	POSIT
	MOV	QELCNT,R0		;Get free Q element count
	CALL	15$			;Output as decimal
	MOV	#19.,R1			;Position to job status
	CALL	POSIT
	MOV	#BLKTAB,R3		;Get blocking masks table address
10$:	TST	(R3)+			;End of table reached yet?
	BEQ	12$			;If EQ yes - print defined state
	BIT	-2(R3),BLOKBT		;Is job blocked on this condition?
	BNE	11$			;If NE yes - print this state
	ADD	#8.,R3			;Else skip description
	BR	10$

11$:	CMP	R3,#IOWAIT		;Is this I/O wait state?
	BNE	12$			;If NE no
	MOV	CHWAIT,R1		;R1 = CSW for channel
	BIC	#CSWMSK,R1		;Isolate device index * 2
	MOV	@#RMON,R0		;R0 -> RMON
	ADD	PNAME(R0),R0		;R0 -> $PNAME table
	ADD	R0,R1			;R1 -> RAD50 device name
	MOV	R1,PNMADR		;Set address of RAD50 name
	MOV	R4,-(SP)
	MOV	R2,-(SP)
	MOV	#R50ARG,R5		;Load argument list address
	CALL	R50ASC			;Let SYSLIB do the work
	MOV	(SP)+,R2
	MOV	(SP)+,R4
	MOVB	CHUNIT,R0		;Get unit #
	BISB	#'0,R0			;ASCIIfy it
	MOVB	R0,IOWAIT+6		;And insert after device name
	MOV	#IOWAIT,R3
12$:	.PRINT	R3			;Print job state description
	MOV	#20.,R1			;Position to second line
	CALL	POSIT
	MOV	#STATAB,R3		;R3 -> Bit definitions for I.STATE
13$:	TST	(R3)+			;End of table?
	BEQ	14$			; If eq, yes - print a field of spaces
	BIT	-2(R3),STATBT		;Is this bit on?
	BNE	14$			; If ne, yes - print description
	ADD	#8.,R3			;Else skip description
	BR	13$			;Try next bit
14$:	.PRINT	R3			;Print description
	JMP	NXTJOB

15$:	MOV	#BUFFER,R3		;R3 -> temp output area
	CALL	CVT10			;Convert number to decimal ASCII
	MOVB	#'.,(R3)+		;Indicate decimal
16$:	CMP	R3,#BUFFER+6		;Have we filled 7 characters yet?
	BHIS	17$			;If HIS yes
	MOVB	#040,(R3)+		;Else blank-fill
	BR	16$

17$:	MOVB	#200,@R3		;Set stopper
	.PRINT	#BUFFER			;Print the converted number
	RETURN
	.SBTTL	Data Areas

	.PSECT	SYSDAT

AREA:	.BLKW	8.

GTDATA:	.BLKW	12.
CHNCNT:	.BLKW
IOCNT:	.BLKW
QELCNT:	.BLKW
BLOKBT:	.BLKW
CHWAIT:	.BLKW
CHUNIT:	.BLKW
STATBT:	.BLKW

SYSGEN:	.BLKW

MAXNUL:	.BLKW
OLDIDL:	.WORD	0
NEWIDL:	.WORD	0

R50ARG:	.WORD	3
	.WORD	CONST
PNMADR:	.BLKW
	.WORD	LINE03

CONST:	.WORD	6

JOBTAB:	.WORD	0,0,0,0,0,0,0,0

TTNAME:	.ASCII	/TT/
TTNUM:	.BLKB	20

INITTM:	.WORD	0,300.+3		;DON'T TIMEOUT WHEN MTTY
WAITTM:	.WORD	0,60.+3			;TIME-OUT DOES !!!

DATARG:	.WORD	1
	.WORD	DATOUT
TIMARG:	.WORD	1
	.WORD	TIMOUT

DATTIM:	.BYTE	033,'Y,040,040+61.
DATOUT:	.ASCII	/DD-MMM-YY  /
TIMOUT:	.ASCII	/HH:MM:SS/<200>

BUFFER:
	.REPT	80.
	.BYTE	040
	.ENDR
	.SBTTL	Cursor Positioning

; POSIT
;
; Positions the cursor at the current job's area of the line specified.
;
; R1 = line number desired (1..24)
; R4 = current job number (*2)

; GPOSIT
;
; General cursor positioning entry
;
; R0 = column number desired (1..80)
; R1 = line number desired (1..24)

POSIT:	MOV	R4,R0			;Take job #
	ASL	R0			; *4
	ASL	R0			; *8
	ADD	#17.,R0			;And make column #
GPOSIT:	MOV	R0,-(SP)		;Save desired column
	.PRINT	#CURPOS			;Start cursor positioning sequence
	MOV	R1,R0			;Get line number
	ADD	#040-1,R0
	.TTYOUT				;Send desired line
	MOV	(SP)+,R0		;Restore column #
	ADD	#040-1,R0
	.TTYOUT				;And send column
	RETURN


	.SBTTL	Conversion Routines

CVT10:	MOV	#10.,R2	;Do base 10 output
	BR	CVT

CVT8:	MOV	#8.,R2	;Do base 8 output

CVT:	MOV	R0,R1		;Copy number to convert
	CLR	R0
	DIV	R2,R0		;Divide by current radix
	MOV	R1,-(SP)	;Save remainder
	TST	R0		;Anything left to convert?
	BEQ	1$		;If EQ no
	CALL	CVT		;Else recur
1$:	MOVB	(SP)+,@R3	;Move binary byte to output area
	BISB	#'0,(R3)+	;And make ASCII
	RETURN

OCTASC:	MOVB	#30,@R3
	SEC
1$:	ROL	R0
	ROLB	(R3)+
	MOVB	#206,@R3
2$:	ASL	R0
	BEQ	3$
	ROLB	@R3
	BCS	2$
	BR	1$

3$:	RETURN

	.END	START