;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                                                                   ;
;  DSKTIM.M68 - Disk timing program (combines REDALL,RNDRED,REDEND) ;
;                                                                   ;
;    Usage:  DSKTIM dev0: reads /S/R/L/E /D:n /B:n /P:n /N          ;
;                                                                   ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (c) Bob Fowler, 08/01/86, runs on any AMOSL 1.0 or later.
; Permission is given to copy and use this program, but not for profit.
; The references to REDEND refer to REDEND.M68, published in SF/AMUS.

; Explanation of options:
;   /S - is the fastest read possible (sequential reads, like REDALL)
;   /R - is a typical worst case (random reads, like RNDRED)
;   /L - same as /R, but use the AMOSL method if possible (<65536 blocks)
;   /E - is the slowest possible case (read first/last blocks, REDEND)
; Other options:
;   /D:n   - simulates a physical device with n logical devices
;   /B:n   - simulates a logical device with n blocks
;   /B:a-b - simulates device from blocks a to b (>0)
;   /P:n   - displays progress reports every n reads (beware, slows timing)
;   /N     - no displays except for final timings
; Both /B and /D allow read ranges beyond one logical drive.
; If neither /B nor /D appear, the read range defaults to the given drive.

; A respresentative set of timings for each device is as follows:
;   DSKTIM  2000 dev0: /S/N     (only one short timing necessary)
;   DSKTIM  2000 dev0: /E/N/D:n (several short timings necessary)
;   DSKTIM 10000 dev0: /R/N/D:n (several longer timings necessary)
; where a separate timing is done for each of n = 1,2,4,8,16,32,max,min
; (max and min being the maximum and minimum "allowed" logical devices).

; If you do timings on any interesting disks (eg, non-Alpha Micro drives),
; please phone the results to Bob Fowler at 415-527-7631, 
; and I will ad them to my growing list (goes back to Persci).

; Current liberal limitations:
;   (a) a timing longer than 23.8 hours will calculate wrong average time
;   (b) only 65536 drives on one device; DSK65536: will not work.

; Notes on usage
;   (a) Timings are only in seconds, at least 100 seconds is recommended.
;   (b) On random reads, at least 10000 reads are suggested.
;       To monitor the convergence behavior of /R and /L timings,
;       do a test run with /P:100, then do a final run without /P.
;   (c) Note that /B:1 can be used to read the same block repeatedly.
;       /B:68 can be used to read the same track (on an AM-1000 10MB).
;       /E/B:69 or /E/B:136 can be used to always seek one track.
;       /B:a-b can be used to randomly read one file, or one area of a disk.
;   (d) Note that /D:1/R simulates random access of all devices.

; Notes on random read methods.
;   Two random read methods are available, via switches /L and /R.
;   (a) /L uses the same method as AMOSL RNDRED.LIT.
;          This method is limited to 16-bit block ranges (65536 or less).
;          It uses AMOSL.MON to generate random numbers as follows.
;             Start X as garbage, then repeat the following ad infinitum:
;             MOD ( 2*X + monitor word 1 + monitor word 2 , 65536) / blocks
;             divides to a quotient Q and remainder R, read block R,
;             set X = Q + R, and repeat loop.
;   (b) /R uses a method based on Knuth (Semi-Numerical Algorithms, p1-24).
;          It generates 32-bit pseudo-random numbers via the expression:
;          X = ( (X + monitor word) x (1 + 2^2 + 2^14 + 2^23) + 1) MOD 2^32
;          The monitor word can be left out, but is currently included.
;   The tradeoffs: /R is more versatile, but has more CPU overhead.

; CPU overhead (ie, all operations other than the READ monitor calls):
;   /S =   .044 ms/read
;   /E =   .029 ms/read
;   /L =   .071 ms/read
;   /R =   .534 ms/read (/B:1) , .397 (/B:1000) , .337 (/B:8000000)
;   /P = 16.6   ms per line displayed (one disk rotation) on the AM-1000
; Note the relatively large overhead for /R (because of 32-bit divisions).
; Any difference between /R and /L is undetectable in /B:1 and /B:68 ranges.
; Wide ranges are difficult to test definitively, due to randomness,
; but in several 4-hour timing comparisons of /L and /R in the /D:2 range,
; /R was consistently about 1.6% (1.3 ms/read) slower than /L.
; This is either due to /R overhead, or defects in one/both random algorithms.
; The overhead for /P does affect timings, but in a very regular fashion.
; Each /P line on the AM-1000 adds 16.6 ms (one disk rotation) to the timing.
; Hence, /P should not be used during a definitive timing run.


; Use of registers:
;   A0 = base of impure work area
;   A1 = device driver address
;   A2 = [user input command string]
;   A3,A4, D0,D1,D2,D3 = [work areas]
;   D4 = random generator (during random read)
;      = blocks on logical device (sequential read)


	COPY	SYS
	SEARCH	SYSSYM

DSKTIM:	BYP				; bypass blanks
	LIN				; empty?
	JEQ	USAGE			;   yes - missing device

;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                         ;
;  #1 - process filespec  ;
;                         ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;

GETROM:	GETIMP	MEMLTH,A0		; get impure user work area
	MOV	#-1,D6			; get only device code (devn:)
	FSPEC	DDB(A0)			; process devn: input
	INIT	DDB(A0)			; get I/O buffer
	MOV	DDB+D.DVR(A0),A1	; device driver address
	MOV	DD.DSZ(A1),LOGBLK(A0)	; blocks on drive (undocumented)
	MOV	A3,AMRLIM(A0)		; A3 used in AMOSL RNDRED algorithm

; For non-winchesters, physical blocks = logical blocks
	MOVW	#1,TOTLOG(A0)		; default to 1 logical device
	MOV	LOGBLK(A0),PHYBLK(A0)	; default physical to logical blocks
	CLRW	HCS(A0)			; Head/Cylinder/Sector not used
	CMPW	70(A1),#170707		; Winchester?
	BEQ	GETPHY			;   yes - get physical blocks
; The following is used by Xebec drivers
	CMPW	120(A1),#70707		; Winchester?
	BEQ	GETPHY			;   yes - get physical blocks
	BR	GOTPHY			;   no - already have physical blocks

; For winchesters, physical blocks = heads x cylinders x sectors
GETPHY:	MOVW	110(A1),TOTLOG(A0)	; save total # of logical drives
	CLR	D0			; clear upper word
	MOVW	74(A1),D0		; D0 = heads
	CLR	D1			; clear upper word
	MOVW	100(A1),D1		; sectors
	MULU	D0,D1			; D0 = heads * sectors
	MOVW	76(A1),D1		; D1 = cylinders
	MULU	D0,D1			; D0 = heads * sectors * cylinders
	MOV	D0,PHYBLK(A0)		; Total physical blocks
	MOVW	#1,HCS(A0)		; Head/Cylinder/Sector used
GOTPHY:	MOVW	TOTLOG(A0),USRLOG(A0)	; User logicals defaults to total log

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                           ;
;  #2 - process read count  ;
;                           ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Get number of reads from user input (defaults to 2^32-1)
	MOV	#-1,D1			; default lasts 414+ days ...
	BYP				; bypass blanks
	LIN				; anything there ?
	BEQ	GOTRDS			;   no - use default
	CMPB	@A2,#'/			; is next character "/" ?
	BEQ	GOTRDS			;   yes - use default
	GTDEC				; get user input
GOTRDS:	MOV	D1,REQRDS(A0)		; save

;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                         ;
;  #3 - process switches  ;
;                         ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Initialize default switch values
	CLRW	REDALL(A0)		; don't do REDALL
	CLRW	RNDRED(A0)		; don't do RNDRED
	CLRW	REDEND(A0)		; don't do REDEND
	MOVW	#1,DSPFLG(A0)		; do displays
	MOV	#-1,DSPRAT(A0)		; don't do progress displays
	MOV	DD.DSZ(A1),REQRNG(A0)	; range defaults to logical drive
	MOV	#1,BOTBLK(A0)		; default first block is one
	MOV	DD.DSZ(A1),TOPBLK(A0)	; default last block is logical size

SWLOOP:	BYP				; bypass blanks
	LIN				; anything there?
	JEQ	SWEND			;   no - user input complete
	CMPB	(A2)+,#'/		; slash?
	JNE	USAGE			;   no - invalid input

	CMPB	@A2,#'S			; /S ?
	BNE	SWR			;   no - try another
	MOVW	#1,REDALL(A0)		; do REDALL
SWBYP:	ADD	#1,A2			; pass over /S
	BR	SWLOOP			; look for another switch

SWR:	CMPB	@A2,#'R			; /R ?
	BNE	SWL			;   no - try another
	MOVW	#1,RNDRED(A0)		; do RNDRED
	BR	SWBYP			; look for another switch

SWL:	CMPB	@A2,#'L			; /L ?
	BNE	SWE			;   no - try another
	MOVW	#1,RNDRED(A0)		; do RNDRED
	MOVW	#1,AMOSL(A0)		; use AMOSL method
	BR	SWBYP			; look for another switch

SWE:	CMPB	@A2,#'E			; /E ?
	BNE	SWN			;   no - try another
	MOVW	#1,REDEND(A0)		; do REDEND
	BR	SWBYP			; look for another switch

SWN:	CMPB	@A2,#'N			; /N ?
	BNE	SWD			;   no - try another
	CLRW	DSPFLG(A0)		; don't do displays
	BR	SWBYP			; look for another switch

; /D:n switch - emulate any number of logical devices
SWD:	CMPB	@A2,#'D			; /D ?
	BNE	SWB			;   no - try another
	ADD	#1,A2			; skip past "D"
	CMPB	(A2)+,#':		; ":" ?
	JNE	USAGE			;   no - invalid format
	GTDEC				; emulated number of logical devices
	MOVW	D1,USRLOG(A0)		; save (from longword to word)
	JEQ	USAGE			; zero logical devices illegal
	MOV	PHYBLK(A0),D0		; recall total physical blocks
	CALL	DIVIDE			; extended divide routine (D2=D0/D1)
	MOV	D2,REQRNG(A0)		; quotient is requested block range
	MOV	BOTBLK(A0),D0		; first block in requested range
	ADD	D2,D0			; + requested range
	SUB	#1,D0			; - 1
	MOV	D0,TOPBLK(A0)		; = last block in requested range
	JMP	SWLOOP			; look for another switch

; /B:n - range of blocks to read
SWB:	CMPB	@A2,#'B			; /B ?
	BNE	SWP			;   no - try another
	ADD	#1,A2			; skip past "B"
	CMPB	(A2)+,#':		; ":" ?
	JNE	USAGE			;   no - invalid format
	GTDEC				; input first block range number
	TST	D1			; zero?
	JEQ	USAGE			;   yes - not allowed
; one input number n indicates range 1 to n
	MOV	#1,BOTBLK(A0)		; first block defaults to 1
	MOV	D1,TOPBLK(A0)		; last block is user input
	CMPB	@A2,#'-			; "-" ?
	BNE	FINSWB			;   no - done
; two input numbers a-b indicate range a to b
	MOV	D1,BOTBLK(A0)		; first block in requested range
	ADD	#1,A2			; skip past "-"
	GTDEC				; input second block range number
	MOV	D1,TOPBLK(A0)		; last block in requested range
FINSWB:	SUB	BOTBLK(A0),D1		; range = last - first
	ADD	#1,D1			; + 1
	MOV	D1,REQRNG(A0)		; range of requested blocks
	JMP	SWLOOP			; look for another switch

; /P:n switch - display progress reports
SWP:	CMPB	@A2,#'P			; /P ?
	BNE	SWZ			;   no - try another
	ADD	#1,A2			; skip past "P"
	CMPB	(A2)+,#':		; ":" ?
	JNE	USAGE			;   no - invalid format
	GTDEC				; reads between displays
	MOV	D1,DSPRAT(A0)		; save
	JMP	SWLOOP			; look for another switch

; invalid switch
SWZ:	JMP	USAGE			; none of the above ...

SWEND:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                          ;
;  #4 - display disk data  ;
;                          ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Display physical device parameters
	TSTW	DSPFLG(A0)		; do display?
	JEQ	ENDSP1			;   no - skip displays 
	TYPE	<Physical device is>
	MOV	PHYBLK(A0),D1		; physical blocks
	DCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPE	<blocks>
	TSTW	HCS(A0)			; Head/Cylinder/Sector used?
	BEQ	FINHCS			;   no - skip rest of line
	TYPE	< (>
	CLR	D1			; clear upper word
	MOVW	74(A1),D1		; heads
	DCVT	0,OT$TRM!OT$TSP
	TYPE	<heads x>
	MOVW	76(A1),D1		; cylinders
	DCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPE	<cylinders x>
	MOVW	100(A1),D1		; sectors
	DCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPE	<sectors)>
FINHCS:	CRLF

; Display logical device parameters
	TYPE	<Logical device is>
	MOV	LOGBLK(A0),D1		; logical blocks
	DCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPE	<blocks>
	TSTW	HCS(A0)			; Head/Cylinder/Sector used?
	BEQ	FINLOG			;   no - skip rest of line
	TYPE	< (>
	MOV	PHYBLK(A0),D1		; physical blocks
	DCVT	0,OT$TRM!OT$TSP
	MOVB	#'/,D1			; can't put into TYPE
	TTY
	CLR	D1			; clear upper word
	MOVW	TOTLOG(A0),D1		; logical devices
	DCVT	0,OT$TRM!OT$LSP
	TYPE	<)>
FINLOG:	CRLF

ENDSP1:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;                          ;
;  #5 - set up read range  ;
;                          ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Range may span more than 1 logical device - allow for this
	MOVW	DDB+D.DRV(A0),BOTDRV(A0); bottom drive defaults to input
	MOVW	DDB+D.DRV(A0),TOPDRV(A0); top drive defaults to input
	MOV	REQRNG(A0),D1		; final block range
	MOV	D1,ACTRNG(A0)		; actual range (default value)
	MOV	BOTBLK(A0),D0		; first block in requested range
	SUB	#1,D0			; blocks go from 0 to X-1
	MOV	D0,BOTREC(A0)		; bottom record of actual range
	ADD	D0,D1			; + requested range
	SUB	#1,D1			; - 1 = last block in actual range
	MOV	D1,TOPREC(A0)		; top record of actual range
	CLR	NOTAVL(A0)		; default to 0 blocks not available

CHKLOG:	CMP	D1,LOGBLK(A0)		; range beyond this logical device?
	BLO	GOTRNG			;   no - range calculated
	CLR	D0			; clear upper word
	MOVW	TOPDRV(A0),D0		; pick up current drive
	ADD	#1,D0			; convert to range starting with 1
	CMPW	D0,TOTLOG(A0)		; it is beyond last drive?
	BHIS	OVRFLO			;   yes - user request not possible
	ADDW	#1,TOPDRV(A0)		; top drive goes to next logical
	SUB	LOGBLK(A0),D1		; reduce block number
	MOV	D1,TOPREC(A0)		; save record number
	BR	CHKLOG			; check next logical drive

; Too many blocks requested.  This can even happen on a simple /D:n request.
; If (eg) physical drive has 3002 blocks, in 3 logical devices,
; each logical device has 1000 blocks, and last 2 blocks are "unavailable".
OVRFLO:	SUB	LOGBLK(A0),D1		; overflow block count
	ADD	#1,D1			; starts at 0
	MOV	LOGBLK(A0),TOPREC(A0)	; top record number
	SUB	#1,TOPREC(A0)		; blocks go from 0 to X-1
	SUB	D1,ACTRNG(A0)		; subtract overflow from actual range
	MOV	D1,NOTAVL(A0)		; save overflow count
GOTRNG:

; AMOSL method is possible if first and last device are same
	TSTW	AMOSL(A0)		; is /L selected?
	BEQ	FINAML			;   no - no problem
;	CLR	D0			; clear upper word
	MOVW	BOTDRV(A0),D0		; pick up first drive number
	CMPW	D0,TOPDRV(A0)		; same as last drive?
	BEQ	FINAML			;   yes - no problem
	CLRW	AMOSL(A0)		;   no - can't use AMOSL method
	TYPECR	<AMOSL method not possible>
FINAML:

; Displays
	TSTW	DSPFLG(A0)		; do display?
	JEQ	ENDSP2			;   no - skip displays 
; Block range requested
	MOV	REQRNG(A0),D1		; block range requested
	DCVT	0,OT$TRM
	TYPECR	<-block range requested>
; Range overflow
	MOV	NOTAVL(A0),D1		; get overflow count
	BEQ	FINAVL			; zero - no display
	TYPE	<Last>			; tell user what happened
	DCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPECR	<blocks not available>
FINAVL:
; Actual test range
	TYPE	<Test range is>		; display range used
	MOV	ACTRNG(A0),D1		; final block range
	DCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPE	<blocks (>
	PUSH	A1
	LEA	A1,DDB+D.DEV(A0)	; location of RAD50 device name
	LEA	A2,PRTDEV(A0)		; location of ASCII output area
	UNPACK				; device name in ASCII (dev)
	CLRB	@A2			; following by a null
	POP	A1
	SUB	#3,A2			; go back to beginning of string
	TTYL	@A2
	CLR	D1			; clear upper word
	MOVW	BOTDRV(A0),D1		; bottom drive #
	DCVT	0,OT$TRM
	TYPE	<:>
	MOV	BOTREC(A0),D1		; bottom record #
	OCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPE	<to >
	TTYL	@A2
	CLR	D1			; clear upper word
	MOVW	TOPDRV(A0),D1		; top drive #
	DCVT	0,OT$TRM
	TYPE	<:>
	MOV	TOPREC(A0),D1		; top record #
	OCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPECR	<octal)>

ENDSP2:

;;;;;;;;;;;;;;;;;;;
;                 ;
;  #6 - do reads  ;
;                 ;
;;;;;;;;;;;;;;;;;;;

; REDALL routine - preserve D4
	TSTW	REDALL(A0)		; do a REDALL?
	JEQ	ENDALL			;   no - skip to end
	CALL	DOCRLF
	TYPE	<REDALL - >
	MOV	ACTRNG(A0),D1		; actual range
	MOV	REQRDS(A0),D0		; requested reads
	CMP	D0,#-1			; request number entered?
	BEQ	BEGALL			;   no - use actual range
	CMP	D0,D1			; requested reads too high?
	BHI	BEGALL			;   yes - use actual range
	MOV	D0,D1			;   no - use requested reads
BEGALL:	CALL	BEFORE
	MOVW	BOTDRV(A0),DDB+D.DRV(A0); bottom drive number
	MOV	BOTREC(A0),DDB+D.REC(A0); bottom block number
	MOV	LOGBLK(A0),D4		; logical blocks on drive
NXTALL:	CTRLC	FINALL			; check for impatient user ...
	READ	DDB(A0)			; read!
	ADD	#1,CURRDS(A0)		; one more read done
	SUB	#1,REMRDS(A0)		; one less read to do
	BNE	CNTALL			; skip display if countdown not 0
	CALL	AFTER			; display progress
	BEQ	ENDALL			; if done, don't continue
CNTALL:
	ADD	#1,DDB+D.REC(A0)	; go to next block
	CMP	D4,DDB+D.REC(A0)	; block beyond this drive?
	BHI	NXTALL			;   no - keep going
	ADDW	#1,DDB+D.DRV(A0)	;   yes - go to next logical drive
	CLR	DDB+D.REC(A0)		; block number starts at zero
	BR	NXTALL			; do another read
FINALL:	CALL	LSTDSP			; display timings
ENDALL:

; REDEND routine - preserve no regs
	TSTW	REDEND(A0)		; do a REDEND?
	JEQ	ENDEND			;   no - skip to end
	CALL	DOCRLF
	TYPE	<REDEND - >
	MOV	REQRDS(A0),D1		; requested reads
	CALL	BEFORE
NXTEND:	CTRLC	FINEND			; check for impatient user ...
	MOVW	BOTDRV(A0),DDB+D.DRV(A0); bottom drive number
	MOV	BOTREC(A0),DDB+D.REC(A0); bottom block number
	READ	DDB(A0)			; read!
	ADD	#1,CURRDS(A0)		; one more read done
	SUB	#1,REMRDS(A0)		; one less read to do
	BNE	CNTEND			; skip display if countdown not 0
	CALL	AFTER			; display progress
	BEQ	ENDEND			; if done, don't continue
CNTEND:
	MOVW	TOPDRV(A0),DDB+D.DRV(A0); top drive number
	MOV	TOPREC(A0),DDB+D.REC(A0); top block number
	READ	DDB(A0)			; read!
	ADD	#1,CURRDS(A0)		; one more read done
	SUB	#1,REMRDS(A0)		; one less read to do
	BNE	NXTEND			; skip display if countdown not 0
	CALL	AFTER			; display progress
	BNE	NXTEND			; if done, don't continue
	BR	ENDEND			; don't display again
FINEND:	CALL	LSTDSP			; display timings
ENDEND:

; RNDRED routine - preserve A3,A4,D4
	TSTW	RNDRED(A0)		; do a RNDRED?
	JEQ	ENDRND			;   no - skip to end
	CALL	DOCRLF
	TSTW	AMOSL(A0)		; use AMOSL method?
	JNE	AMRND			;   yes - go to it

	TYPE	<RBF RNDRED - >
	MOV	REQRDS(A0),D1		; requested reads
	CALL	BEFORE
	MOV	MEMBAS,A4		; use monitor up to first user
	CLR	D4			; start random seed
CYCLE1:	MOV	#SYSTEM,A3		; base of AMOSL.MON
NXTRND:	CTRLC	FINRND			; check for impatient user ...
	MOV	D4,D2			; D4 x 2^0
; following computes D4 = (D4 x (1 + 2^2 + 2^14 + 2^23) + 1) MOD 2^32
	ASL	D2,#2			; D4 x 2^2
	ADD	D2,D4
	ASL	D2,#6
	ASL	D2,#6			; D4 x 2^14
	ADD	D2,D4
	ASL	D2,#3
	ASL	D2,#6			; D4 x 2^23
	ADD	D2,D4
	ADD	#1,D4			; +1
; 32-bit number / physical blocks ===> remainder is random block
	MOV	D4,D0			; random number
	MOV	ACTRNG(A0),D1		; / block range
	CALL	DIVIDE			; D0 / D1 ===> D2 rem D0
; block / logical blocks ===> quotient (drive #) rem (logical block)
	ADD	BOTREC(A0),D0		; may not start at block 0
	MOV	LOGBLK(A0),D1		; logical blocks
	CALL	DIVIDE			; D0 / D1 ===> D2 rem D0
	ADDW	BOTDRV(A0),D2		; may not start at drive 0
	MOVW	D2,DDB+D.DRV(A0)	; longword to word
	MOV	D0,DDB+D.REC(A0)
	READ	DDB(A0)
	ADD	#1,CURRDS(A0)		; one more read done
	SUB	#1,REMRDS(A0)		; one less read to do
	BNE	CNTRND			; skip display if countdown not 0
	CALL	AFTER			; display progress
	BEQ	ENDRND			; if done, don't continue
CNTRND:
; To remove AMOSL.MON from random calculation, comment out next 3 lines
	ADD	(A3)+,D4		; add in AMOSL.MON longword
	CMP	A4,A3			; here yet?
	BLO	CYCLE1			;   yes - cycle through again
	BR	NXTRND			;   no - just do other stuff
FINRND:	CALL	LSTDSP			; display timings
ENDRND:
	JMP	END

; AMOSL RNDRED routine - preserve A3,A4,D4,D5
AMRND:	TYPE	<AMOSL RNDRED - >
	MOV	REQRDS(A0),D1		; requested reads
	CALL	BEFORE
	MOV	AMRLIM(A0),A4		; use monitor up to first user
	MOV	ACTRNG(A0),D5		; logical blocks
CYCLE2:	MOV	#SYSTEM,A3		; start at beginning of monitor
NXTAMR:	CTRLC	FINRND			; check for control-C exit
	ASL 	D4			; random number x 2
	ADDW	(A3)+,D4		;   + first monitor word
	ADDW	(A3)+,D4		;   + second monitor word
	AND	#177777,D4		; use only lower order word
	DIV	D4,D5			;   / blocks
	MOV	D4,D1			; get remainder (high order word)
	SWAP	D1
	AND	#177777,D1
	ADD	D1,D4			;   + quotient is next random #
	ADD	BOTREC(A0),D1		; may not start at block 0
	MOV	D1,DDB+D.REC(A0)	; next block to read
	READ	DDB(A0)			; read this block
	ADD	#1,CURRDS(A0)		; one more read done
	SUB	#1,REMRDS(A0)		; one less read to do
	BNE	CNTAMR			; skip display if countdown not 0
	CALL	AFTER			; display progress
	BEQ	ENDRND			; if done, don't continue
CNTAMR:
	CMP	A4,A3			; are we at end of used memory ?
	BLO	CYCLE2			;   yes - recycle through monitor
	BR	NXTAMR			;   no - get another word from memory

END:	EXIT

;;;;;;;;;;;;;;;;;;;
;                 ;
;  #7 - routines  ;
;                 ;
;;;;;;;;;;;;;;;;;;;

DOCRLF:	TSTW	DSPFLG(A0)		; do display?
	BEQ	CRLF1			;   no - skip displays 
	CRLF
CRLF1:	RTN



BEFORE:
	TSTW	DSPFLG(A0)		; do display?
	BEQ	BEFOR1			;   no - skip following
	TYPE	<Doing>
	DCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPECR	<reads (control-C allowed) ...>
BEFOR1:	JOBIDX	A1			; get address of job status word
	ANDW	#^CJ.CCC,JOBSTS(A1)	; clear any pending control-C
	CLR	CURRDS(A0)		; clear read counter
	MOV	D1,ACTRDS(A0)		; save actual number of reads
	MOV	DSPRAT(A0),D0		; pick up display rate
	CMP	D0,D1			; is it higher?
	BHI	BEGCNT			;   yes - use actual number of reads
	MOV	D0,D1			;   no - use display rate instead
BEGCNT:	MOV	D1,REMRDS(A0)		; start progress display countdown
	GTIMEI	D0			; get starting time (seconds)
	MOV	D0,BEGTIM(A0)		; save it 
	GDATEI	D0			; get starting date (days)
	MOV	D0,BEGDAT(A0)		; save it 
	RTN



LSTDSP:	MOV	CURRDS(A0),ACTRDS(A0)	; Control-C abort - end reads
AFTER:	MOV	CURRDS(A0),D1		; total number of reads
	CMP	D1,ACTRDS(A0)		; is this the last display?
	BHIS	AFTER1			;   yes - must display results
	TSTW	DSPFLG(A0)		; do displays? (/N)
	JEQ	FINDSP			;   no - skip displays this time
AFTER1:	TST	D1			; did zero blocks get read?
	BNE	GOTRED			;   no - no problem
	TYPECR	<no reads>		;   yes - avoid division by zero
	JMP	FINDSP			; bypass all further display
GOTRED:	DCVT	0,OT$TRM!OT$TSP
	TYPE	<disk reads in>
	GDATEI	D0			; get current date (days)
	SUB	BEGDAT(A0),D0		; subtract starting date
	MULU	D0,#43200.		; convert to seconds
	ADD	D0,D0			; cannot multiply by 86400 (> 65536)
	GTIMEI	D1			; get current time (seconds)
	ADD	D1,D0			; add to total
	SUB	BEGTIM(A0),D0		; subtract beginning time (seconds)
	MOV	D0,D1
	DCVT	0,OT$TRM!OT$LSP!OT$TSP
	TYPE	<seconds >
	TST	D1			; positive?
	BGT	TIMEOK			;   yes - calculate average
	TYPECR	<(time not valid)>	;   no - end
	BR	FINDSP
TIMEOK:	TYPE	<=>
; following overflows if timings go longer than 84000 seconds (.9 days)
	MULU	D0,#50000.		; get .02 ms units (must be < 86400)
	MOV	CURRDS(A0),D1		; total number of reads
	CALL	DIVIDE			; big fat divide ...
	DIVU	D2,#50.			; quotient is ms, remainder is .01 ms
	CLR	D1			; clear upper word
	MOVW	D2,D1			; ms part
	DCVT	0,OT$TRM!OT$LSP		; "nnnn"
	TYPE	<.>			; "."
	SWAP	D2			; get remainder
	MOVW	D2,D1			; centi-ms part
	ADD	D1,D1			; convert from n/50 to n/100
	DCVT	2,OT$TRM!OT$TSP		; "nn"
	TYPECR	<ms per read>
FINDSP:	MOV	ACTRDS(A0),D1		; total reads planned
	SUB	CURRDS(A0),D1		; - reads accomplished
	BEQ	ENDDSP			; done (Z bit still set on return)
	MOV	DSPRAT(A0),D0		; pick up display rate
	CMP	D0,D1			; is it higher?
	BHI	SETDSP			;   yes - use actual number of reads
	MOV	D0,D1			;   no - use display rate instead
SETDSP:	MOV	D1,REMRDS(A0)		; start progress display countdown
ENDDSP:	RTN				; read some more (Z bit is returned)



USAGE:	LEA	A2,HELP			; give 'em some assistance
	TTYL	@A2
	EXIT				; and leave

HELP:	ASCII	|Usage: DSKTIM dev0: reads /S/R/L/E /D:n/B:n/P:n/N|
	BYTE	15
	ASCII	|       /S      does a sequential read (REDALL)|
	BYTE	15
	ASCII	|       /R      does a random read (RNDRED)|
	BYTE	15
	ASCII	|       /L      does a random read using AMOSL method|
	BYTE	15
	ASCII	|       /E      does a first-last read (REDEND)|
	BYTE	15
	ASCII	|       /D:n    simulates n logical devices|
	BYTE	15
	ASCII	|       /B:n    simulates device with n decimal blocks|
	BYTE	15
	ASCII	|       /B:a-b  simulates device from blocks a to b (>0)|
	BYTE	15
	ASCII	|       /P:n    display progress every n reads (slows timing!)|
	BYTE	15
	ASCII	|       /N      no display except final timings|
	BYTE	15
	BYTE	0
	EVEN



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;				;
;  Extended Divide Routine	;
;				;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; The 68000 can only divide 32 bits / 16 bits ===> 16-bit quot , 16-bit rem
; The routine below divides 32 bits / 32 bits ===> 32-bit quot , 32-bit rem
; This can be done in one instruction on the 68020

; Reg   Input          Output
; ---   -----------    ---------
; D0    Dividend       Remainder
; D1    Divisor        Divisor
; D2    [garbage]      Quotient
; D3    [garbage]      [zero]

DIVIDE:

; Following is the 68000 routine
	CLR	D2			; D2 = quotient (clear first)
	MOV	#1,D3			; D3 = current quotient bit
SHIFT1:	CMP	D0,D1			; can we subtract?
	BLO	TEST			;   no - divisor is shifted enough
	ASL	D1			; shift again
	BCS	BACK			; we went too far!
	ASL	D3			; quotient bit similiarly shifted
	BR	SHIFT1			; keep going
BACK:	ROXR	D1			; undo last shift
TEST:	CMP	D0,D1			; can we subtract?
	BLO	SHIFT2			;   no - go shift
	SUB	D1,D0			; subtract divisor multiple
	ADD	D3,D2			; add bit to quotient
SHIFT2:	LSR	D3			; quotient bit halved
	BEQ	ENDDIV			; if zero, we are done
	LSR	D1			; divisor multiple is halved
	BR	TEST			; test next quotient subtract
ENDDIV:	RTN

; Following is the equivalent 68020 routine
;	DIVUL	D2:D0,D1
;	EXG	D0,D2
;	RTN



	ASECT
	.=0
; Symbols for impure work.buffer area - MUST BE PUT HERE
; (if put at beginning, FIX uses these labels instead of the PSECT labels !!!)

AMRLIM:	BLKL	1		; contents of A3 upon entering program
HCS:	BLKW	1		; Head/Cylinder/Sector used flag
REDALL:	BLKW	1		; REDALL requested flag (/S)
RNDRED:	BLKW	1		; RNDRED requested flag (/R)
REDEND:	BLKW	1		; REDEND requested flag (/E)
AMOSL:	BLKW	1		; Use AMOSL method for random read (/L)
DSPRAT:	BLKL	1		; Reads between each progress display (/P)
DSPFLG:	BLKL	1		; Display flag (/N)
REQRDS:	BLKL	1		; Requested number of reads (user)
ACTRDS:	BLKL	1		; Actual number of reads planned
REMRDS:	BLKL	1		; Remaining number of reads (until display)
TOTLOG:	BLKW	1		; Total logical devices in physical drive
USRLOG:	BLKW	1		; User (emulated) logical devices
LOGBLK:	BLKL	1		; Blocks on logical device (1+)
PHYBLK:	BLKL	1		; Blocks on physical device (1+)
BOTBLK:	BLKL	1		; First block in requested range (1+)
TOPBLK:	BLKL	1		; Last block in requested range (1+)
REQRNG:	BLKL	1		; Block range of reads - requested
ACTRNG:	BLKL	1		; Block range of reads - actual
CURRDS:	BLKL	1		; Current number of reads done so far
BOTDRV:	BLKW	1		; Bottom Drive Number
BOTREC:	BLKL	1		; Bottom Block Number
TOPDRV:	BLKW	1		; Top Drive Number
TOPREC:	BLKL	1		; Top Block Number
BEGTIM:	BLKL	1		; Beginning time (seconds)
BEGDAT:	BLKL	1		; Beginning date (days)
PRTDEV:	BLKB	3		; For RAD50 unpacking (ASCII)
NULL:	BLKB	1		; For RAD50 unpacking (null)
NOTAVL:	BLKL	1		; Not available for reading
DDB:	BLKB	D.DDB		; DDB for reading
MEMLTH:				; Memory used

	END	


.