.TITLE	CPULOG
	.IDENT	/02/
 
;+
; CPULOG IS BASED ON THE ORIGINAL WORK OF GREG A. BASSET(ACCLOG,ACCOFF) WHICH KEPT
; ACCOUNT OF CERTAIN SYSTEM STATISTICS.  ACCLOG HOWEVER, DOES NOT RUN UNDER V3.1/V3.2
; AND IS NOT SUITABLE FOR USE AS A STANDARD SYSTEM MONITOR OF SYSTEM CPU USAGE.
; CPULOG ACCUMULATES STATISTICS FOR CPU TIME USAGE UTILIZATION(USER TIME, NULL TIME,
; AND EXEC TIME) AND PRINTS THE STATISTICS TO LB:[1,4]CPULOG.DAT WHEN IT EXITS.
; CPULOG REPLACES THE JUMP TO THE CLOCK INTERRUPT SERVICE ROUTINE, WITH
; A JUMP TO A SECTION OF PIC CODE LEFT SITTING IN THE EXEC.  WHEN CPUOFF
; SENDS A PACKET TO CPULOG REQUESTING THAT CPU TIME LOGGING STOP, CPULOG
; RETURNS THE CORRECT INTERRUPT JUMPS.
;
; BECAUSE TIME IS ACCUMULATED AS TICS IN A TWO WORD ARRAY, CPULOG CAN
; RUN FOR A MAXIMUM OF ABOUT 5.9 HOURS BEFORE OVERFLOW WILL DESTROY THE
; DATA.  TO CIRCUMVENT THIS PROBLEM, CPULOG UNSTOPS ITSELF EVERY SO OFTEN
; AND WRITES THE DATA OUT TO THE FILE .
;
; THE WRITE INTERVAL IS SET FOR 4 HOURS.
;

; J. G. DOWNWARD	5-MAR-79
;
; CPU USAGE LOGGING TASK
;
; ASSEMBLY PARAMETERS
;
;	THE SYMBOL "$$CVEC" SHOULD BE SET EQUAL TO THE SYSTEM CLOCK
;	INTERRUPT VECTOR ADDRESS. THE STANDARD ADDRESSES FOLLOW:
;
;		KW-11L LINE FREQUENCY CLOCK	100
;		KW-11P PROGRAMMABLE CLOCK	104
;
; FOR EASE OF USE, THE VALUES OF $$CVEC, AND $$TKPS MAY BE SET IN THE
; TASKBUILD FILE VIA GLOBAL DEFINITIONS.
; FOR CONVENIENCE THE GLOBAL DEFINITION OF $RNDOF IS ALSO SET AT TASK
; BUILD TIME.  $RNDOF=5 FOR A 100 TIC/SEC PROGRAMABLE CLOCK.  IT PROVIDES
; A ROUND OFF OF COMPUTED TIMES UP TO THE NEAREST .1 SEC(10 TICS).
 
;$$CVEC=104			; STANDARD PROGRAMABLE CLOCK
;$$TKPS=100.			; CLOCK INTERRUPTS PER SECOND
;$RNDOF=5.			; ROUND OFF VALUE FOR 100 TICS/SEC CLOCK
 
	.MCALL	QIOW$C,QIOW$,DIR$,EXIT$S,GTIM$C
	.MCALL	PKTDF$,TCBDF$,HWDDF$
	.MCALL	RCST$,ASTX$,MRKT$,USTP$,CMKT$S
	PKTDF$			; DEFINE PACKET OFFSETS
	TCBDF$			; DEFINE TCB OFFSETS
	HWDDF$			; DEFINE HARDWARE
 
 
	.MCALL	FSRSZ$,FDBDF$,FDAT$A,FDOP$A,NMBLK$
	.MCALL	OPEN$W,CLOSE$,PUT$,OPEN$A
 
 
;
; ACCOUNTING DATA STRUCTURES
CODNOD:	.WORD	0		; CODE NODE ADDRESS
IOST:	.BLKW	2		; I/O STATUS BLOCK
STRTTM:	.BLKB	20.		; START TIME
STPTM:	.BLKB	20.		; STOP TIME
TIMBUF:	.BLKB	20.		; SAVE TIME BUFFER
HEDFLG:	.WORD	0		; =1 IF HEADER TO BE WRITTEN OUT
ERROR:	.WORD	0		; ALLOCATION FAILURE ERROR SWITCH
 
; MACRO DEFINITIONS
 
	.MACRO	PRINT	STRING
 
	MOV	#STRING,R0
	CALL	PNTLIN
 
	.ENDM	PRINT
 
	.MACRO	OUTPUT	STRING
 
	MOV	#STRING,R0
	CALL	OUTLIN
 
	.ENDM	OUTPUT
 
 
	FSRSZ$	1		; ONE RECORD BUFFER
 
ACCFDB:	FDBDF$			; DEFINE AN FDB
	FDAT$A	R.VAR,FD.CR!FD.BLK ; GIVE THE FILE SOME ATTRIBUTES
	FDOP$A	1,CPDSPT	; AND A NAME
 
CPDSPT:	.WORD	3		; 3 CHAR DEV NAME
	.WORD	DEV		; IN DEV
	.WORD	9.		; 9 CHAR UIC STRING
	.WORD	DIR		;
	.WORD	NAMSIZ		;
	.WORD	NAM		;
 
DEV:	.ASCII	/LB:/
DIR:	.ASCII	/[001,004]/
NAM:	.ASCII	/CPULOG.DAT/
NAMSIZ=.-NAM
 
ACCNAM:	NMBLK$	ACCOUNT,DAT	; THIS NAME!
RCVSTP:	RCST$	,BUF		; RECEIVE DATA OR STOP
BUF:	.BLKW	15.		; FOR RECIEVE DATA
MARKTM:	MRKT$	3,4,4,MRKAST	; MARK TIME FOR 4 HOURS
ASTEXT:	ASTX$			; AST EXIT
UNSTOP:	USTP$	CPULOG		; UNSTOP OURSELVES
AGAIN:	.WORD	0		; FLAG, IF=1, WRITE OUT STATISTICS AND GO BACK
				; FOR MORE.
 
 

	.SBTTL	ACCOUNTING INITALIZATION CODE
	.ENABL	LSB
START:				; REF. LABEL
	CLR	AGAIN		; CLEAR FLAG IN CASE THIS IS A REPEAT
	CLR	ERROR		; CLEAR ERROR INDICATOR
	GTIM$C	STRTTM		; GET STARTUP TIME
35$:				; REF. LABEL
 
	.IF NDF	M$$MGE
 
	MOV	#CODST,CODNOD	; ASSUME NO NODE NEEDED
	MOV	$TKTCB,R5	; GET OUR TCB ADDRESS
	BIT	#T2.CHK,T.ST2(R5) ; ARE WE CHECKPOINTABLE?
	BNE	50$		; IF NO, THEN NO NODE NEEDED
 
	.ENDC			; NDF M$$MGE
 
	CLR	CODNOD		; CLEAR FLAG TO STORE CODE NODE
	MOV	#CODSIZ,R1	; GET CODE SIZE
	CALL	$SWSTK,50$	; SWITCH TO SYSTEM STATE
	CALL	$ALOCB		;; ALLOCATE THE CODE BLOCK FROM DSR
	BCS	40$		;; IF UNABLE THEN LEAVE FLAG 0
	MOV	R0,CODNOD	;; STORE NODE ADDRESS
40$:	RETURN			;; EXIT FROM SYSTEM STATE
50$:	MOV	CODNOD,R5	; GET NODE ADDRESS
	MOV	R5,R0		; COPY TO R0
	BNE	55$		; IF .NE. 0 THEN WE GOT ONE
	INC	ERROR		; INDICATE AN ERROR HAS OCCURRED
	JMP	106$		; ALLOCATION FAILURE
55$:	MOV	#CODSIZ,R1	; GET TOTAL CODE SIZE
	INC	R1		; ROUND UP TO WORD BOUNDARY
	ASR	R1		; CONVERT TO WORDS
	MOV	#CODST,R2	; GET CODE STARTING ADDRESS
60$:	MOV	(R2)+,(R0)+	; STORE WORD
	DEC	R1		; ANY MORE TO TRANSFER?
	BNE	60$		; YES. CONTINUE
	MOV	$TKTCB,ACCPTR-CODST(R5) ; SAVE CPULOG TCB ADDRESS
;
; SET UP CLOCK INTERRUPT VECTOR
;
	BIS	#340,PS		; RAISE PRIORITY TO 7
	MOV	R5,@#$$CVEC	;;; STORE NODE ADDRESS IN VECTOR
	ADD	#TIMINT-CODST,@#$$CVEC ;;; ADD OFFSET TO TIME ISR
	MOV	#341,@#$$CVEC+2	;;; SET NEW PS (WITH C BIT SET)
	CLRB	PS		;;; DROP PRIORITY TO ZERO
 
	.PAGE
	.SBTTL	EXIT CODE
;
; NOW WE STOP AND WAIT UNTIL ASKED TO EXIT BY CPUOFF.
; ALSO WE WILL MARK TIME. WHEN THE MARK TIME IS SATISFIED
; WE WILL ALSO PRINT OUT SYSTEM STATISTICS.  THE LONGEST
; APART THE WRITES TO A FILE CAN BE IS ABOUT 5.9 HOURS FOR
; A 100 TPS PROGRAMABLE CLOCK, ELSE OVERFLOW OCCURS AND ALL DATA
; IS LOST.  NORMALLY THE CODE IS SET FOR EVERY 4 HOURS.
; STATISTICS WILL ALSO BE PRINTED TO FILE IF A 2 IS SENT
; AS THE FIRST WORD IN THE BUFFER.  A 1 IN THE BUFFER
; WILL CAUSE CPULOG TO EXIT
; CPUOFF WILL QUEUE A REQUEST TO OUR RECIEVE QUEUE WHICH
; WILL START US UP AGAIN AND FORCE US TO CLEAN UP AND EXIT
;
	DIR$	#MARKTM		; MARK TIME, EXECUTE AST, AT END OF TIME TO UNSTOP US
80$:	DIR$	#RCVSTP		; RECIEVE DATA OR STOP
	CMP	#IS.SET,$DSW	; SOMETHING HAPPENED, DO WE HAVE DATA
	BNE	85$		; WE HAVE DATA SO PROCEED
	TST	AGAIN		; SOMETHING UNSTOPPED US WAS IT THE MARKTIME
	BEQ	80$		; SOMETHING ELSE UNSTOPPED US, NOT EITHER THE MARKTIME
				; OR CPUOFF, SO LETS JUST CONTINUE
 
85$:	CMP	#1,BUF+4	; IS THIS A SIGNAL TO EXIT
	BEQ	EXIT		; YES. CLEANUP AND EXIT
	INC	AGAIN		; NO, PRINT STATISTICS TO FILE AND COME BACK FOR MORE
	JMP	EXIT		; GO DO EXIT STUFF BUT RESTART AFTER CLOSING FILE
 
 
;
; MARKTM
;
MRKAST:	DIR$	#UNSTOP		; LETS UNSTOP US
	INC	AGAIN		; TELL THE TASK TO LOOP AFTER PRINTING FILE
	TST	(SP)+		; CLEAN OF EFN MASK WORD FROM STACK
	DIR$	#ASTEXT		; EXIT AST ROUTINE
	.SBTTL	CPU TIME ACCOUNTING EXIT RUNDOWN
;
; THIS CODE WILL 
;	PRINT SYSTEM STATISTICS, AND
;	WILL EXIT CPULOG.
;
EXIT:				; REF. LABEL
	CMKT$S			; CANCEL ALL MARKTIMES
 
 
	MOV	CODNOD,R0	; PUT CODE ADDRESS IN R0
	ADD	#TIME-CODST,R0	; POINT IT TO INFO
	MOV	#TIMBUF,R4	; PUT DATA BUFFER ADDRESS INTO R4
	MOV	R4,R1		; POINT R1 TO NUMBERS
	MOV	#10,R2		; GET NUMBER OF NUMBERS TO COPY
	BIS	#340,PS		; RAISE THE PRIORITY TO 7
102$:	MOV	(R0)+,(R1)+	;;; COPY THE TIMES
	DEC	R2		;;; DONE?
	BNE	102$		;;; NOPE. KEEP GOING
	CLRB	PS		;;; DROP IT BACK DOWN
 
 
	OPEN$A	#ACCFDB,,,,,,CREATE; OPEN FILE FOR APPEND, IF ERROR TRY AND CREATE NEW FILE
	BR	103$		; IF OK BRANCH AROUND
CREATE:	OPEN$W	#ACCFDB,,,,,,OPNERR ; OPEN THE OUTPUT FILE
	INC	HEDFLG		; SHOW MUST WRITE HEADER
103$:				; REF LABLE
	TST	HEDFLG		; SEE IF WE SHOULD WRITE OUT HEADER
	BEQ	1030$		; IF NO, BRANCH
	OUTPUT	HEADER		; PRINT HEADER
1030$:	MOV	#STRTTM,R1	; POINT TO THE DATE
	MOV	#DATE1,R0	; GET OUTPUT STRING ADDRESS
	CMP	#10.,STRTTM+4	; IF DAY<10, MUST BUMP OVER 1 SPACE
	BLE	1031$		; IF LE, DAY >10, DON'T PUMP POINTER
	INC	R0		; MOVE OVER ONE PLACE TO ALLIGN PRINTOUT
1031$:	CALL	$DAT		; CONVERT TO ASCII
	MOV	#TIME1,R0	; POINT TO TIME STRING
	MOV	#4,R2		; MAKE THE FORMAT "HH:MM:SS.S"
	CALL	$TIM		; AND CONVERT THE TIME
	GTIM$C	STPTM		; GET TIME CPU TIME LOGGING TURNED OFF
	MOV	#STPTM+6,R1	; GET TIME CPULOG STOPED LOGGING CPU TME
	MOV	#TIME2,R0	; PLACE ASCII VALUE HERE
	MOV	#4,R2		; FORCE FORMAT TO BE "HH:MM:SS.S"
	CALL	$TIM		; CONVERT THE TIME
	MOV	#TIMBUF,R0	; GET TIME BUFFER ADDRESS
	MOV	(R0),R1		; GET HIGH ORDER START TIME
	MOV	2(R0),R2	; GET LOW ORDER TIME
	CALL	CVTTIM		; INSERT RIGHT VALUES IN STPTM
	MOV	#STPTM+6,R1	; GET TIME VALUE
	MOV	#ETIME,R0	; GET TIME STRING ADDRESS
	MOV	#4,R2		; FORCE HH:MM:SS.S
	CALL	$TIM		; INSERT IN IN STRING
	MOV	#TIMBUF,R0	; GET TIME BUFFER ADDRESS
	MOV	10(R0),R1	; GET HIGH ORDER CPU TIME
	MOV	12(R0),R2	; GET LO ORDER CPU TIME
	ADD	4(R0),R1	; ADD IN HIGH ORDER USER TIME
	ADC	R2		; ADD IN CARRY IF ANY
	ADD	6(R0),R2	; AND ANY LEFT OVER USR TIME
	CALL	CVTTIM		; INSERT VALUES IN STPTM
	MOV	#STPTM+6,R1	; GET TIME VALUE
	MOV	#CPTIM,R0	; GET TARGET ADDRESS
	MOV	#4,R2		; FORCE HH:MM:SS
	CALL	$TIM		; INSERT IN STRING
	MOV	#TIMBUF,R0	; GET POINTER TO TIME
	ADD	#4,R0		; POINT R0 TO USRTIM
	MOV	#USRPCT,R3	; GET OUTPUT BUFFER POINTER
	CALL	PERPNT		; PRINT PERCENTAGE
	MOV	R4,R0		; GET INFO ADDRESS
	ADD	#10,R0		; POINT TO KERNEL INFO
	MOV	#KNLPCT,R3	; OUTPUT BUFFER ADDRESS
	CALL	PERPNT		; PRINT KERNEL PERCENTAGE
	MOV	R4,R0		; GET INFO POINTER
	ADD	#14,R0		; POINT TO NULL TIME
	MOV	#NULPCT,R3	; OUTPUT POINTER
	CALL	PERPNT		; PRINT PERCENTAGE OF NULL TIME
				; $TIM SOMETIMES PRINTS AN EXTRA 0, SO REPLACE TAB, SPACES
	MOVB	#40,TIME1+10.	; BACK GOES A SPACE
	MOVB	#11,TIME2+10.	; AND A TAB
	MOVB	#11,ETIME+10.	; AND ANOTHER
	MOVB	#11,CPTIM+10.	; AND YET ONE MORE
	OUTPUT	DATA		; OUTPUT COMPOSIT DATA LINE
104$:				; REF LABEL
105$:	CALL	CLEAN		; RESTORE CLOCK INTERRUPT INTERCEPT
106$:	TST	ERROR		; IS THIS AN ERROR CONDITION?
	BEQ	107$		; NO. SKIP ERROR MESSAGE
	PRINT	M10		; ALLOCATION FAILURE
107$:				; REF. LABEL
	CLOSE$	#ACCFDB		; CLOSE FILE
	OPEN$A	#ACCFDB,,,,,,OPNERR ; OPEN FOR APPEND
	MOV	#ACCFDB,R0	; GET ADDRESS OF CPULOG'S FILE FDB
	CALL	.TRNCL		; CLOSE AND TRUNCATE THE FILE(IF POSSIBLE)
	TST	AGAIN		; SHOULD WE TRY ONCE MORE
	BEQ	THEEND		; NO, ALL DONE
	JMP	START		; YES, BACK TO THE START
THEEND:	PRINT	M12		; PRINT TASK EXITING MESSAGE
	EXIT$S			; AND DO IT

 
;+
; INPUT DEVICE ERROR
;
DEVERR:	PRINT	M11		; PRINT DEVICE ERROR MESSAGE
	BR	107$		; AND EXIT
 
;
; OPEN ERROR ON OUTPUT FILE
;
OPNERR:	PRINT	M16		; PRINT OPEN FAILURE
	BR	107$		; AND EXIT
;
; PUT ERROR ON OUTPUT FILE
;
PUTERR:	PRINT	M17		; PRINT PUT FAILURE
	BR	105$		; AND EXIT
 
 
	.PAGE
	.SBTTL	RESTORE CLOCK INTERUPT SERVICE ROUTINE POINTER
;
;
CLEAN:				; REF LABLE
	CALL	$SWSTK,125$	; SWITCH TO SYSTEM STATE
	MOV	#$CKINT,@#$$CVEC ;;; RESTORE CLOCK INTERRUPT SERVICE ROUTINE
	MOV	CODNOD,R5	;; GET CODE NODE ADDRESS
 
	.IF NDF	M$$MGE
 
	CMP	#CODST,R5	;; IS THIS CODE IN A NODE?
	BEQ	125$		;; NO. DON'T RETURN IT
 
	.ENDC			;; NDF M$$MGE
 
	MOV	R5,R0		;; RETRIEVE THE NODE ADDRESS
	MOV	#CODSIZ,R1	;; GET THE SIZE OF IT
	CALLR	$DEACB		;; AND RETURN IT TO THE POOL
125$:	RETURN
	.PAGE
	.SBTTL	PRINTING ROUTINES
;
 
 
;+
; CVTTIM
; THIS ROUTINE WILL TAKE A DOUBLE PRECISION WORD(TICS)
; AND CONVERT IT INTO A FORMAT SUITABLE FOR $TIM TO USE
; CVTTIM
;
; TO CONVERT IT TO AN ASCII TIME STRING.
;	R1  HIGH ORDER TIME
;	R2  LOW ORDER TIME
;-
CVTTIM:	MOV	#$$TKPS,R0	; GET NUMBER OF TICS/SEC
	CALL	$DDIV		; DO DIVIDE
	ADD	#$RNDOF,R0	; ROUND UP TO NEXT .1SEC($RNDOF=5  FOR 100TPS CLOCK)
	MOV	R0,STPTM+14	; STORE REMAINDER IN TICS SLOT
	MOV	#60.,R0		; # SEC /MIN
	CALL	$DDIV		; DIVIDE IT
	MOV	R0,STPTM+12	; STORE REMAINDER AS SECONDS
	MOV	#60.,R0		; # MIN/HOUR
	CALL	$DDIV		; DIVIDE IT OUT
	MOV	R0,STPTM+10	; STORE REMAINDER AS MINUTES
	MOV	R2,STPTM+6	; AND THE DIVIDEND AS HOURS
	RETURN
 
 
 
;
; THIS ROUTINE WILL PRINT AN ASCIZ LINE
;
PNTLIN:	MOV	#-1,R1		; GET COUNT INITIALIZED
	MOV	R0,QIODPB+Q.IOPL ; STORE BUFFER ADDRESS
170$:	INC	R1		; INCREMENT COUNTER
	TSTB	(R0)+		; IS THIS THE LAST BYTE?
	BNE	170$		; NO. KEEP GOING
	MOV	R1,QIODPB+Q.IOPL+2 ; STORE BYTE COUNT
	DIR$	#QIODPB
	RETURN
;
; THIS ROUTINE WILL OUTPUT A LINE TO THE OUTPUT DEVICE (ONLY NESS.
;	WHEN $$FILE IS DEFINED) .
;
 
 
OUTLIN:	MOV	#-1,R1		; SETUP COUNT
	MOV	R0,R2		; COPY BUFFER POINTER
175$:	INC	R1		; INCREMENT COUNTER
	TSTB	(R0)+		; IS THIS THE LAST BYTE?
	BNE	175$		; NO. KEEP COUNTING
	PUT$	#ACCFDB,R2,R1,PUTERR
	RETURN			; RETURN TO USER
 
 
;
;+
; PERPNT -- FORMAT PERCENTAGES INTO SUITABLE VALUES FOR PRINTING
;
; IN EACH CASE THE DISPLAY IS RIGHT JUSTIFIED SO THAT THE "."'S WILL
; LINE UP
; THIS ROUTINE WILL FORMAT THE TIME POINTED TO BY R0
;	INTO THE FOLLOWING FORMAT:
;
;		XX.X%
;
 
 
PERPNT:	MOV	R3,-(SP)	; SAVE BUFFER ADDRESS ON THE STACK
	MOV	(R0)+,R2	; GET HIGH ORDER NUMBER
	MOV	(R0),R3		; GET LOW ORDER
	MOV	#1000.,R0	; GET SCALE FACTOR
	CALL	$DMUL		; AND MULTIPLY
	MOV	R1,R2		; GET THE INFO WHERE IT BELONGS
	MOV	R0,R1		;
	BMI	190$		; IF < 0 , THEN AN OVERFLOW OCCURED
	MOV	2(R4),R0	; GET LOW ORDER TOTAL TIME
	MOV	(R4),-(SP)	; PUT HIGH ORDER TIME ON STACK
176$:	TST	(SP)		; IS THERE ANY HIGH ORDER TIME LEFT?
	BNE	177$		; YES. CONTINUE SCALING
	TST	R0		; IS THE LOW ORDER UNSIGNED YET?
	BPL	180$		; YES. DO IT!
177$:	ASR	R1		; DIVIDE HIGH ORDER BY 2
	ROR	R2		; AND CONTINUE WITH LOW ORDER
	ASR	(SP)		; SHIFT HIGH ORDER TOTAL ALSO
	ROR	R0		; AND LOW ORDER
	BR	176$		; DO THE TEST.
 
180$:	TST	(SP)+		; CLEAN THE STACK AND CONTINUE
	CALL	$DDIV		; DO D.P. DIVIDE
	MOV	R2,R1		; GET RESULT (PERCENT * 10.)
	CLR	R2		; SUPPRESS ZEROES
	MOV	(SP)+,R0	; GET OUTPUT BUFFER POINTER
 
	CMP	R1,#100.	; IS IT <10%, IF SO MUST SLIDE RIGHT 1 PLACE
	BGE	184$		; IF GT, NO
	INC	R0		; IF LT, YES , BUMP POINTER 1 PLACE RIGHT
	CMP	R1,#10.		; IS IT <1%, IF SO MUST SLIDE RIGHT 1 PLACE
	BGE	184$		; IF GT NO, PROCEED WITHOUT SHIFTING
	INC	R0		; SLIDE POINTER RIGHT
184$:
 
	CALL	$CBDMG		; CONVERT TO ASCII
	MOVB	-(R0),1(R0)	; MOVE LAST BYTE OVER TO MAKE ROOM
	MOVB	#'.,(R0)+	; PUT IN A DECIMAL POINT
	INC	R0		; STEP PAST LAST NUMBER
	MOVB	#'%,(R0)+	; MAKE IT A PERCENT
	RETURN			; AND RETURN
 
190$:	PRINT	M151		; PRINT OVER FLOW ERROR
	TST	(SP)+		; CLEAN THE STACK
	JMP	104$		; AND CONTINUE
 
 
;
; START OF CLOCK TIC INTERCEPT CODE
;
CODST=.
;
; THIS IS THE CLOCK ISR. IT MERELY KEEP COUNT IN TICKS AND CONTINUES
;
TIMINT:	;ADD	#1,TIME+2	;;; COUNT LOW ORDER (C BIT MUST BE SET)
	ADC	TIME+2		;;; COUNT LOW ORDER (C BIT MUST BE SET)
	ADC	TIME		;;; AND DON'T FORGET THE CARRY
 
 
	CMP	#$HEADR,@#$RQSCH ;;; ARE WE POINTING AT THE NULL TASK
	BEQ	208$		;;; IF EQ, YES
	BIT	#PMODE,@#PS	;;; DID WE COME FROM THE EXEC?
	BEQ	209$		;;; IF EQ, YES, COUNT AS KERNAL TIME
206$:	ADD	#1,USRTIM+2	;;; COUNT USER TIME
	ADC	USRTIM		;;; AND HIGH ORDER
207$:	JMP	@#$CKINT	;;; JUMP TO CLOCK ISR IN TDSCH
208$:	ADD	#1,NULTIM+2	;;; YES, COUNT AS NULL TIME
	ADC	NULTIM		;;; AND HIGH ORDER PART
	JMP	@#$CKINT	;;; AND EXIT
209$:	ADD	#1,KNLTIM+2	;;; YES. COUNT IT AS KERNEL TIME
	ADC	KNLTIM		;;; AND HIGH ORDER
	JMP	@#$CKINT	;;; CONTINUE
 
 
 
;
; DATA BASES
;
ACCHD:	.WORD	0		; ACCOUNTING LISTHEAD
	.WORD	.-2
ACCPTR:	.WORD	0		; CPULOG TCB ADDRESS
TIME:	.WORD	0,0		; TIME FROM START OF CPULOG
USRTIM:	.WORD	0,0		; USER TIME
KNLTIM:	.WORD	0,0		; KERNEL TIME
NULTIM:	.WORD	0,0		; NULL TIME
 
;
; END OF CODE (IN NODE)
;
CODEN=.
; SIZE OF ALL CODE
;
CODSIZ=CODEN-CODST

	.SBTTL	TEXT MESSAGES
 
QIODPB:	QIOW$	IO.WVB,2,2,,,,<0,0,0>
 
 
 
	.NLIST	BEX
;
;
DATE:	.BLKB	 21.
HEADER:	.ASCII	/DATE	/
	.ASCII	/   START TIME  STOP TIME	ELAPSED TIME	CPU TIME	/
	.ASCIZ	/% USER TIME	% EXEC TIME	% NULL TIME/<15><12><12>
DATA:
DATE1:	.ASCII	/         /<40><40>			; DD-MMM-YY
TIME1:	.ASCII	/HH:MM:SS.S/<40><40>
TIME2:	.ASCII	/HH:MM:SS.S/<11>
ETIME:	.ASCII	/HH:MM:SS.S/<11>
CPTIM:	.ASCII	/HH:MM:SS.S/<11>
	.ASCII	/    /
USRPCT:	.ASCII	/     /<11>
	.ASCII	/    /
KNLPCT:	.ASCII	/     /<11>
	.ASCII	/    /
NULPCT:	.ASCII	/     /
	.BYTE	0			; SENTINAL
M10:	.ASCIZ	<15><12>/CPULOG -- MEMORY ALLOCATION FAILURE/<15><12>
M11:	.ASCIZ	/CPULOG -- INPUT ERROR/
M12:	.ASCIZ	/CPULOG -- EXITING/<15><12>/>/
 
 
CRLF:	.ASCIZ	<15><12><12>
M151:	.ASCIZ	<15><12>/CPULOG -- STATISTICS OVERFLOW ERROR/<15><12>
 
 
 
M16:	.ASCIZ	<15><12>/CPULOG -- OPEN FAILURE ON OUTPUT FILE/<15><12>
M17:	.ASCIZ	<15><12>/CPULOG -- PUT FAILURE ON OUTPUT FILE/<15><12>
 
	.END	START