Benchmarking
Using the on-board real-time clock (RTC) we can do a lot of interesting tests on the Geneve, in its MDOS and GPL mode. There are plenty of interesting things to be found out by benchmarking. For example, you can
- determine the execution times of instructions
- check the memory speed
- find out about the usage of wait states in the system
- find out when a certain bit in the system is set, and when it is reset.
In the last case, for example, I wanted to find out whether the EO bit of the video processor's status register 2 is used in non-interlaced modes or not. The EO bit indicates which of the two screens is currently displayed (when using interlace). It was not clear, however, whether it is locked to a constant value when we do not use interlace or whether it still alternates between 0 and 1.
How can we do this by measuring time? - The concept is to find out how long it takes until we have got 10000 times of this bit set to 1 when reading the status register. If the bit is locked to 0 it will take forever, so we need an upper bound for our iterations. If the bit is locked to 1 it will quickly terminate, so the number of iterations should not be too low.
What I found was that it takes equal time for getting 10000 status reads with the bit set to 0 or to 1. This means that the bit indeed continuously changes between 0 and 1.
Timer main program
For my benchmark experiments I use the same frame program which launches the tests that are included. I split the parts of the program in order to explain them one after another. The complete file can be downloaded as a file in TIFILES format or on a Sector Dump Format image.
DEF START START B @GO * F040 = ON-CHIP CODE EQU >6040 REGS EQU >F000 SRAM EQU >5000 DRAM EQU >6000 PAD EQU >F030 BOX EQU >8080 RESTXT TEXT 'Result for test ' CRLF BYTE 13,10 VALBUF DATA >3132,>3334,>3536,>3738 VIDXOP DATA 6
The list of tests is here. We are using pointers to the start and to the end of the test routine. The null value indicates the end of the list.
TESTS DATA T01,T01E
DATA 0
Now for the main program. We will set the mapper so that some areas are available as SRAM, some as DRAM, and also the Peripheral Box will be available.
COUNT BYTE >30,>30,':',>20
H01 BYTE >01
H30 BYTE >30
H3A BYTE >3A
SAVMAP DATA 0
GO LWPI >F000
LIMI 0
LI R1,>ED20
MOV R1,@>F112 4000=SRAM, 6000=DRAM
LI R1,>EEEF
MOV R1,@>F116 C000-FFFF = SRAM
MOV @>F114,@SAVMAP
LI R1,>BA00
MOVB R1,@>F114 8000=BOX 4000
LI R12,>1EE0
* SBZ 15 // wait state on
SBO 15 // wait state off
This is the test loop. Repeat until we read a null value from the list. Copy each test routine to the target memory area. The pointer to the area is CODE. So when we set CODE to F040 above, the tests will be run in the on-chip RAM.
LI R15,TESTS
BLOOP MOV *R15+,@PARM
JEQ STOP
MOV *R15+,@PARM+2
AB @H01,@COUNT+1
CB @H3A,@COUNT+1
JNE B1
AB @H01,@COUNT
MOVB @H30,@COUNT+1
B1 BL @COPY
PARM DATA 0,0
BL @GETTIM
MOV R7,R14
BL @CODE
BL @GETTIM
MOV R14,R6
BL @PRINT
LIMI 2
LIMI 0
JMP BLOOP
STOP NOP
LI R12,>1EE0
SBO 15
MOV @SAVMAP,@>F114
BLWP @>0000
This subprogram prints the difference of R6 and R7. We expect both registers to contain time values in tenths of seconds, starting from the current hour. So the maximum value will be 36000, 60 minutes times 60 seconds times 10 tenths. No test should be longer than one hour.
*
* PRINT: Prints the difference of R6 and R7
* If R7<R6 (new hour), add 36000 to their difference
*
PRINT MOV R11,R13
CLR R0
C R6,R7
JLE P2
P1 LI R0,36000
P2 S R6,R7
A R0,R7
LI R0,>27
LI R1,RESTXT
LI R2,16
XOP @VIDXOP,0
LI R1,COUNT
LI R2,4
XOP @VIDXOP,0
LI R1,VALBUF+7
MOV R7,R3
BL @ITOA
LI R1,VALBUF+7
S R2,R1
INC R1
LI R0,>27
XOP @VIDXOP,0
LI R0,>27
LI R1,CRLF
LI R2,2
XOP @VIDXOP,0
MOV R13,R11
RT
Get the time from the clock chip. We do not have high precision timers here; in fact, we can only measure up to one tenth of a second. But this is no problem if we use loops in our test. That way, the actual time can be calculated afterwards. For example, if some command takes 1.2 microseconds, and you have it executed 10 million times, you will get a time period of 12 seconds.
*
* GETTIM: Gets the time as seconds and tenths
* Returns time in R7
*
* Uses R6-R10
*
GETTIM LI R9,10
MOVB @>F135,R7 // digit for 10 m
SLA R7,4
SRL R7,12
MPY R9,R7 // R8 contains minutes (tens) * 10
MOVB @>F134,R6 // minutes (units)
SLA R6,4
SRL R6,12
A R6,R8 // add units
MOV R8,R7 // store in R7
LI R9,60
MPY R9,R7 // R8 now contains minutes since begin. of hour
MOV R8,R10 // as seconds. Save in R10.
LI R9,10
MOVB @>F133,R7 // digit for 10 s
SLA R7,4
SRL R7,12 //
MPY R9,R7 // *10 (-> R7,R8)
MOVB @>F132,R6 // seconds (units)
SLA R6,4
SRL R6,12
A R6,R8 //
A R10,R8 // add seconds to the above value
MOV R8,R7
MPY R9,R7 // R8 has seconds *10
MOVB @>F131,R6 // tenths
SLA R6,4
SRL R6,12
A R6,R8 // add tenths
MOV R8,R7 // now in R7: number of 10ths seconds in this hour
RT
Convert our binary value to a string of ASCII so that we can output it on the screen.
*
* Integer to ASCII
* R1 = Pointer of target buffer
* R3 = 16 bit value
* Returns: R2: length of number
*
ITOA LI R8,10
CLR R2
MOV R3,R5
ITOAL CLR R4
DIV R8,R4 // R5=number mod 10
SLA R5,8
AI R5,>3000
MOVB R5,*R1
DEC R1
INC R2
MOV R4,R5
JNE ITOAL
RT
This subprogram copies the test routine into the target memory location.
*
* Copy into test area
*
COPY MOV *R11+,R0
MOV *R11+,R2
LI R1,CODE
C1 MOV *R0+,*R1+
C R0,R2
JLE C1
RT
Now what follows are the test routines. You can see a sample below. Just add the pointers to the start and end of the routine to the list above. You can add the routines as text to this file, or you can use COPY directives to let the assembler add the code.
Determining the video interrupt rate
* Wait in a loop until the desired number of
* interrupts have occured
T01 LIMI 0
CLR R12
SBO 2 enable VDP interrupt propagation through 9901
LI R0,>8170 VReg 1 contains a flag to enable vertical sync interrupt
SWPB R0
MOVB R0,@>F102
SWPB R0
MOVB R0,@>F102
LI R0,>8980 VReg 9 contains flags to set 192/212 lines, NTSC/PAL, interlace/non-interlace
SWPB R0
MOVB R0,@>F102
SWPB R0
MOVB R0,@>F102
MOV @>0004,R6 Save INT2 vector to R6/R7
MOV @>0006,R7
LI R0,>F040 Set our own interrupt routine at INT2
MOV R0,@>0004
LI R0,INTR
MOV R0,@>0006
* We set our counter to 1000 interrupts
LI R3,1000
MOV R3,@ITER
* Arm the interrupts
LIMI 2
* ... and wait in a loop until the counter is zero
T012 MOV @ITER,R0
JNE T012
* Block the interrupts again
LIMI 0
MOV R6,@>0004 Restore the vector
MOV R7,@>0006
T01E RT
This is the interrupt routine which we have to install:
ITER DATA 0 Counter
* Start of the routine
INTR LIMI 0 Block all interrupts (see below, 1)
* Read the status registers. This will clear the flags. (2)
* One of the flags is in SREG1
BL @GETREG
DATA 1
BL @GETREG
DATA 0
SLA R0,1 Is the leftmost flag set (VSYNC)?
JNC SKIP If not, skip the DEC command
DEC @ITER Decrease our counter
SKIP RTWP
* Routine to read a given status register into R0
* Register number must be in data line (LSB)
GETREG MOV *R11+,R0
ORI R0,>8F00
SWPB R0
MOVB R0,@>F102
SWPB R0
MOVB R0,@>F102
CLR R0
NOP
MOVB @>F102,R0
RT
Comments:
(1) We have to disable the interrupts here. The routine above has set the mask to 0002, which enables interrupts from other sources as well. If we do not block the interrupts, another interrupt request may interrupt this handler, and we will lose the return vector. The RTWP command at the end will restore the interrupt mask.
(2) We must clear the flag which caused the interrupt. Unless cleared, the INT line from the VDP will stay low (active) and will re-trigger the interrupt. So the first thing to do in the interrupt handler is to clear the origin of the interrupt.
Result of the video benchmark
Using the RTC we can determine the time which passed between the first and the 1000th interrupt:
- NTSC set (video register 9): 16.67 s
- PAL set (also in reg 9): 20.0 s
Accordingly, we get 60 Hz for the NTSC and 50 Hz for the PAL setting. The timing is not affected by the number of display lines (192 or 212) and not by interlace mode (on or off).