• Michael Abrash‘s Graphics Programming Black Book--chapter3综计器

    https://github.com/jagregory/abrash-black-book/blob/master/src/chapter-03.md
    Chapter 3 -- Assume Nothing
    Understanding and Using the Zen Timer
    shows 8253-based timer software -- 模拟环境估计没有8253,可以试试。

    LISTING 3.1 PZTIMER.ASM
    ; The precision Zen timer (PZTIMER.ASM)
    ;
    ; Uses the 8253 timer to time the performance of code that takes
    ; less than about 54 milliseconds to execute, with a resolution
    ; of better than 10 microseconds.
    ;
    ; By Michael Abrash
    ;
    ; Externally callable routines:
    ;
    ;  ZTimerOn: Starts the Zen timer, with interrupts disabled.
    ;
    ;  ZTimerOff: Stops the Zen timer, saves the timer count,
    ;    times the overhead code, and restores interrupts to the
    ;    state they were in when ZTimerOn was called.
    ;
    ;  ZTimerReport: Prints the net time that passed between starting
    ;    and stopping the timer.
    ;
    ; Note: If longer than about 54 ms passes between ZTimerOn and
    ;    ZTimerOff calls, the timer turns over and the count is
    ;    inaccurate. When this happens, an error message is displayed
    ;    instead of a count. The long-period Zen timer should be used
    ;    in such cases.
    ;
    ; Note: Interrupts *MUST* be left off between calls to ZTimerOn
    ;    and ZTimerOff for accurate timing and for detection of
    ;    timer overflow.
    ;
    ; Note: These routines can introduce slight inaccuracies into the
    ;    system clock count for each code section timed even if
    ;    timer 0 doesn't overflow. If timer 0 does overflow, the
    ;    system clock can become slow by virtually any amount of
    ;    time, since the system clock can't advance while the
    ;    precison timer is timing. Consequently, it's a good idea
    ;    to reboot at the end of each timing session. (The
    ;    battery-backed clock, if any, is not affected by the Zen
    ;    timer.)
    ;
    ; All registers, and all flags except the interrupt flag, are
    ; preserved by all routines. Interrupts are enabled and then disabled
    ; by ZTimerOn, and are restored by ZTimerOff to the state they were
    ; in when ZTimerOn was called.

    LISTING 3.2 PZTEST.ASM
    ; Program to measure performance of code that takes less than
    ; 54 ms to execute. (PZTEST.ASM)
    ;
    ; Link with PZTIMER.ASM (Listing 3.1). PZTEST.BAT (Listing 3.4)
    ; can be used to assemble and link both files. Code to be
    ; measured must be in the file TESTCODE; Listing 3.3 shows
    ; a sample TESTCODE file.
    ;
    ; By Michael Abrash

    LISTING 3.3 LST3-3.ASM
    执行了1000次MOV指令
    ; Test file;
    ; Measures the performance of 1,000 loads of AL from
    ; memory. (Use by renaming to TESTCODE, which is
    ; included by PZTEST.ASM (Listing 3.2). PZTIME.BAT
    ; (Listing 3.4) does this, along with all assembly
    ; and linking.)
    ;

    LISTING 3.4 PZTIME.BAT
    批处理来调度测量testcode

    运行：
    pztime LST3-3.ASM
    发现可以运行，说明dosbox模拟了8253外部定时器这个硬件，看来是标配。
    运行结果：
    Timed count: 00333 microseconds
    不过这个数字已经超过了54ms,按说是不对的。

    是不是用下面的长周期综计器？

    LISTING 3.5 LZTIMER.ASM
    ;
    ; The long-period Zen timer. (LZTIMER.ASM)
    ; Uses the 8253 timer and the BIOS time-of-day count to time the
    ; performance of code that takes less than an hour to execute.
    ; Because interrupts are left on (in order to allow the timer
    ; interrupt to be recognized), this is less accurate than the
    ; precision Zen timer, so it is best used only to time code that takes
    ; more than about 54 milliseconds to execute (code that the precision
    ; Zen timer reports overflow on). Resolution is limited by the
    ; occurrence of timer interrupts.
    ;
    ; By Michael Abrash


    LISTING 3.6 LZTEST.ASM
    ; Program to measure performance of code that takes longer than
    ; 54 ms to execute. (LZTEST.ASM)
    ;
    ; Link with LZTIMER.ASM (Listing 3.5). LZTIME.BAT (Listing 3.7)
    ; can be used to assemble and link both files. Code to be
    ; measured must be in the file TESTCODE; Listing 3.8 shows
    ; a sample file (LST3-8.ASM) which should be named TESTCODE.
    ;
    ; By Michael Abrash

    LISTING 3.7 LZTIME.BAT

    LISTING 3.8 LST3-8.ASM
    执行20000次
    ;
    ; Measures the performance of 20,000 loads of AL from
    ; memory. (Use by renaming to TESTCODE, which is
    ; included by LZTEST.ASM (Listing 3.6). LZTIME.BAT
    ; (Listing 3.7) does this, along with all assembly
    ; and linking.)
    ;
    ; Note: takes about ten minutes to assemble on a slow PC if
    ;you are using MASM

    最终看效果：
    lztime lst3-8.asm
    Timed count: 0000006669 microseconds
    是333ms的20倍。MOV次数从1000次改为20000次，正好也是20倍。所以说这个定时器还是基本准确的。
    书上的数据，在主频4.77MHZ的PC机器上执行（90年代的老机器）
    1000次：3619微妙 每次内存装入寄存器AL，约3.619微妙.我的dosbox是333微妙，差距如此之大？
    20000次：72544微妙 即内存装入寄存器AL，一次约3.63微妙，多一些是因为有中断    。

    PZTIMER.ASM

    1. ; The precision Zen timer (PZTIMER.ASM)
    2. ;
    3. ; Uses the 8253 timer to time the performance of code that takes
    4. ; less than about 54 milliseconds to execute, with a resolution
    5. ; of better than 10 microseconds.
    6. ;
    7. ; By Michael Abrash
    8. ;
    9. ; Externally callable routines:
    10. ;
    11. ;  ZTimerOn: Starts the Zen timer, with interrupts disabled.
    12. ;
    13. ;  ZTimerOff: Stops the Zen timer, saves the timer count,
    14. ;    times the overhead code, and restores interrupts to the
    15. ;    state they were in when ZTimerOn was called.
    16. ;
    17. ;  ZTimerReport: Prints the net time that passed between starting
    18. ;    and stopping the timer.
    19. ;
    20. ; Note: If longer than about 54 ms passes between ZTimerOn and
    21. ;    ZTimerOff calls, the timer turns over and the count is
    22. ;    inaccurate. When this happens, an error message is displayed
    23. ;    instead of a count. The long-period Zen timer should be used
    24. ;    in such cases.
    25. ;
    26. ; Note: Interrupts *MUST* be left off between calls to ZTimerOn
    27. ;    and ZTimerOff for accurate timing and for detection of
    28. ;    timer overflow.
    29. ;
    30. ; Note: These routines can introduce slight inaccuracies into the
    31. ;    system clock count for each code section timed even if
    32. ;    timer 0 doesn't overflow. If timer 0 does overflow, the
    33. ;    system clock can become slow by virtually any amount of
    34. ;    time, since the system clock can't advance while the
    35. ;    precison timer is timing. Consequently, it's a good idea
    36. ;    to reboot at the end of each timing session. (The
    37. ;    battery-backed clock, if any, is not affected by the Zen
    38. ;    timer.)
    39. ;
    40. ; All registers, and all flags except the interrupt flag, are
    41. ; preserved by all routines. Interrupts are enabled and then disabled
    42. ; by ZTimerOn, and are restored by ZTimerOff to the state they were
    43. ; in when ZTimerOn was called.
    44. ;
    46. Code segment word public 'CODE'
    47.      assume       cs:Code, ds:nothing
    48.      public       ZTimerOn, ZTimerOff, ZTimerReport
    50. ;
    51. ; Base address of the 8253 timer chip.
    52. ;
    53. BASE_8253        equ 40h
    54. ;
    55. ; The address of the timer 0 count registers in the 8253.
    56. ;
    57. TIMER_0_8253     equ BASE_8253 + 0
    58. ;
    59. ; The address of the mode register in the 8253.
    60. ;
    61. MODE_8253        equ BASE_8253 + 3
    62. ;
    63. ; The address of Operation Command Word 3 in the 8259 Programmable
    64. ; Interrupt Controller (PIC) (write only, and writable only when
    65. ; bit 4 of the byte written to this address is 0 and bit 3 is 1).
    66. ;
    67. OCW3              equ 20h
    68. ;
    69. ; The address of the Interrupt Request register in the 8259 PIC
    70. ; (read only, and readable only when bit 1 of OCW3 = 1 and bit 0
    71. ; of OCW3 = 0).
    72. ;
    73. IRR               equ 20h
    74. ;
    75. ; Macro to emulate a POPF instruction in order to fix the bug in some
    76. ; 80286 chips which allows interrupts to occur during a POPF even when
    77. ; interrupts remain disabled.
    78. ;
    79. MPOPF macro
    80.       local p1, p2
    81.       jmp short p2
    82. p1:   iret             ; jump to pushed address & pop flags
    83. p2:   push cs          ; construct far return address to
    84.       call p1          ; the next instruction
    85.       endm
    87. ;
    88. ; Macro to delay briefly to ensure that enough time has elapsed
    89. ; between successive I/O accesses so that the device being accessed
    90. ; can respond to both accesses even on a very fast PC.
    91. ;
    92. DELAY macro
    93.       jmp     $+2
    94.       jmp     $+2
    95.       jmp     $+2
    96.       endm
    98. OriginalFlags   db    ?    ; storage for upper byte of
    99.                            ; FLAGS register when
    100.                            ; ZTimerOn called
    101. TimedCount      dw    ?    ; timer 0 count when the timer
    102.                            ; is stopped
    103. ReferenceCount  dw    ?    ; number of counts required to
    104.                            ; execute timer overhead code
    105. OverflowFlag    db    ?    ; used to indicate whether the
    106.                            ; timer overflowed during the
    107.                            ; timing interval
    108. ;
    109. ; String printed to report results.
    110. ;
    111. OutputStr  label byte
    112.            db    0dh, 0ah, 'Timed count: ', 5 dup (?)
    113. ASCIICountEnd    label byte
    114.            db    ' microseconds', 0dh, 0ah
    115.            db    '$'
    116. ;
    117. ; String printed to report timer overflow.
    118. ;
    119. OverflowStr label byte
    120.       db    0dh, 0ah
    121.       db    '****************************************************'
    122.       db    0dh, 0ah
    123.       db    '* The timer overflowed, so the interval timed was  *'
    124.       db    0dh, 0ah
    125.       db    '* too long for the precision timer to measure.     *'
    126.       db    0dh, 0ah
    127.       db    '* Please perform the timing test again with the    *'
    128.       db    0dh, 0ah
    129.       db    '* long-period timer.                               *'
    130.       db    0dh, 0ah
    131.       db    '****************************************************'
    132.       db    0dh, 0ah
    133.       db    '$'
    135. ; ********************************************************************
    136. ; * Routine called to start timing.                                  *
    137. ; ********************************************************************
    139. ZTimerOn    proc   near
    141. ;
    142. ; Save the context of the program being timed.
    143. ;
    144.    push   ax
    145.    pushf
    146.    pop    ax                       ; get flags so we can keep
    147.                                    ; interrupts off when leaving
    148.                                    ; this routine
    149.    mov    cs:[OriginalFlags],ah    ; remember the state of the
    150.                                    ; Interrupt flag
    151.    and    ah,0fdh                  ; set pushed interrupt flag
    152.                                    ; to 0
    153.    push   ax
    154. ;
    155. ; Turn on interrupts, so the timer interrupt can occur if it's
    156. ; pending.
    157. ;
    158.      sti
    159. ;
    160. ; Set timer 0 of the 8253 to mode 2 (divide-by-N), to cause
    161. ; linear counting rather than count-by-two counting. Also
    162. ; leaves the 8253 waiting for the initial timer 0 count to
    163. ; be loaded.
    164. ;
    165.      mov  al,00110100b               ;mode 2
    166.      out  MODE_8253,al
    167. ;
    168. ; Set the timer count to 0, so we know we won't get another
    169. ; timer interrupt right away.
    170. ; Note: this introduces an inaccuracy of up to 54 ms in the system
    171. ; clock count each time it is executed.
    172. ;
    173.      DELAY
    174.      sub     al,al
    175.      out     TIMER_0_8253,al     ;lsb
    176.      DELAY
    177.      out     TIMER_0_8253,al     ;msb
    178. ;
    179. ; Wait before clearing interrupts to allow the interrupt generated
    180. ; when switching from mode 3 to mode 2 to be recognized. The delay
    181. ; must be at least 210 ns long to allow time for that interrupt to
    182. ; occur. Here, 10 jumps are used for the delay to ensure that the
    183. ; delay time will be more than long enough even on a very fast PC.
    184. ;
    185.     rept 10
    186.     jmp   $+2
    187.     endm
    188. ;
    189. ; Disable interrupts to get an accurate count.
    190. ;
    191.      cli
    192. ;
    193. ; Set the timer count to 0 again to start the timing interval.
    194. ;
    195.       mov  al,00110100b        ; set up to load initial
    196.       out  MODE_8253,al        ; timer count
    197.       DELAY
    198.       sub  al,al
    199.       out  TIMER_0_8253,al     ; load count lsb
    200.       DELAY
    201.       out  TIMER_0_8253,al; load count msb
    202. ;
    203. ; Restore the context and return.
    204. ;
    205.      MPOPF                   ; keeps interrupts off
    206.      pop   ax
    207.      ret
    209. ZTimerOn     endp
    211. ;********************************************************************
    212. ;* Routine called to stop timing and get count.                     *
    213. ;********************************************************************
    215. ZTimerOff proc     near
    217. ;
    218. ; Save the context of the program being timed.
    219. ;
    220.      push    ax
    221.      push    cx
    222.      pushf
    223. ;
    224. ; Latch the count.
    225. ;
    226.      mov  al,00000000b     ; latch timer 0
    227.      out  MODE_8253,al
    228. ;
    229. ; See if the timer has overflowed by checking the 8259 for a pending
    230. ; timer interrupt.
    231. ;
    232.      mov   al,00001010b        ; OCW3, set up to read
    233.      out   OCW3,al             ; Interrupt Request register
    234.      DELAY
    235.      in    al,IRR              ; read Interrupt Request
    236.                                ; register
    237.      and   al,1                ; set AL to 1 if IRQ0 (the
    238.                                ; timer interrupt) is pending
    239.      mov   cs:[OverflowFlag],al; store the timer overflow
    240.                                ; status
    241. ;
    242. ; Allow interrupts to happen again.
    243. ;
    244.       sti
    245. ;
    246. ; Read out the count we latched earlier.
    247. ;
    248.      in     al,TIMER_0_8253   ; least significant byte
    249.      DELAY
    250.      mov    ah,al
    251.      in     al,TIMER_0_8253   ; most significant byte
    252.      xchg   ah,al
    253.      neg    ax                ; convert from countdown
    254.                               ; remaining to elapsed
    255.                               ; count
    256.      mov    cs:[TimedCount],ax
    257. ; Time a zero-length code fragment, to get a reference for how
    258. ; much overhead this routine has. Time it 16 times and average it,
    259. ; for accuracy, rounding the result.
    260. ;
    261.      mov   cs:[ReferenceCount],0
    262.      mov   cx,16
    263.      cli                ; interrupts off to allow a
    264.                         ; precise reference count
    265.  RefLoop:
    266.      call   ReferenceZTimerOn
    267.      call   ReferenceZTimerOff
    268.      loop   RefLoop
    269.      sti
    270.      add    cs:[ReferenceCount],8; total + (0.5 * 16)
    271.      mov    cl,4
    272.      shr    cs:[ReferenceCount],cl; (total) / 16 + 0.5
    273. ;
    274. ; Restore original interrupt state.
    275. ;
    276.      pop    ax                    ; retrieve flags when called
    277.      mov    ch,cs:[OriginalFlags] ; get back the original upper
    278.                                   ; byte of the FLAGS register
    279.      and    ch,not 0fdh           ; only care about original
    280.                                   ; interrupt flag...
    281.      and    ah,0fdh               ; ...keep all other flags in
    282.                                   ; their current condition
    283.      or     ah,ch                 ; make flags word with original
    284.                                   ; interrupt flag
    285.      push   ax                    ; prepare flags to be popped
    286. ;
    287. ; Restore the context of the program being timed and return to it.
    288. ;
    289.     MPOPF                      ; restore the flags with the
    290.                                ; original interrupt state
    291.     pop    cx
    292.     pop    ax
    293.     ret
    295. ZTimerOff  endp
    297. ;
    298. ; Called by ZTimerOff to start timer for overhead measurements.
    299. ;
    301. ReferenceZTimerOn proc  near
    302. ;
    303. ; Save the context of the program being timed.
    304. ;
    305.       push  ax
    306.       pushf     ; interrupts are already off
    307. ;
    308. ; Set timer 0 of the 8253 to mode 2 (divide-by-N), to cause
    309. ; linear counting rather than count-by-two counting.
    310. ;
    311.    mov    al,00110100b    ; set up to load
    312.    out    MODE_8253,al    ; initial timer count
    313.    DELAY
    314. ;
    315. ; Set the timer count to 0.
    316. ;
    317.      sub    al,al
    318.      out    TIMER_0_8253,al; load count lsb
    319.      DELAY
    320.      out    TIMER_0_8253,al; load count msb
    321. ;
    322. ; Restore the context of the program being timed and return to it.
    323. ;
    324.      MPOPF
    325.      pop    ax
    326.      ret
    328. ReferenceZTimerOn endp
    330. ;
    331. ; Called by ZTimerOff to stop timer and add result to ReferenceCount
    332. ; for overhead measurements.
    333. ;
    335. ReferenceZTimerOff proc     near
    336. ;
    337. ; Save the context of the program being timed.
    338. ;
    339.       push   ax
    340.       push   cx
    341.       pushf
    342. ;
    343. ; Latch the count and read it.
    344. ;
    345.      mov   al,00000000b        ; latch timer 0
    346.      out   MODE_8253,al
    347.      DELAY
    348.      in    al,TIMER_0_8253     ; lsb
    349.      DELAY
    350.      mov   ah,al
    351.      in    al,TIMER_0_8253     ; msb
    352.      xchg  ah,al
    353.      neg   ax                  ; convert from countdown
    354.                                ; remaining to amount
    355.                                ; counted down
    356.      add   cs:[ReferenceCount],ax
    357. ;
    358. ; Restore the context of the program being timed and return to it.
    359. ;
    360.     MPOPF
    361.     pop    cx
    362.     pop    ax
    363.     ret
    365. ReferenceZTimerOff endp
    367. ; ********************************************************************
    368. ; * Routine called to report timing results.                         *
    369. ; ********************************************************************
    371. ZTimerReport proc    near
    373.        pushf
    374.        push  ax
    375.        push  bx
    376.        push  cx
    377.        push  dx
    378.        push  si
    379.        push  ds
    380. ;
    381.        push       cs     ; DOS functions require that DS point
    382.        pop        ds     ; to text to be displayed on the screen
    383.        assume     ds     :Code
    384. ;
    385. ; Check for timer 0 overflow.
    386. ;
    387.      cmp  [OverflowFlag],0
    388.      jz   PrintGoodCount
    389.      mov  dx,offset OverflowStr
    390.      mov  ah,9
    391.      int  21h
    392.      jmp  short EndZTimerReport
    393. ;
    394. ; Convert net count to decimal ASCII in microseconds.
    395. ;
    396. PrintGoodCount:
    397.      mov   ax,[TimedCount]
    398.      sub   ax,[ReferenceCount]
    399.      mov   si,offset ASCIICountEnd - 1
    400. ;
    401. ; Convert count to microseconds by multiplying by .8381.
    402. ;
    403.      mov   dx, 8381
    404.      mul   dx
    405.      mov   bx, 10000
    406.      div   bx                ;* .8381 = * 8381 / 10000
    407. ;
    408. ; Convert time in microseconds to 5 decimal ASCII digits.
    409. ;
    410.      mov   bx, 10
    411.      mov   cx, 5
    412. CTSLoop:
    413.      sub   dx, dx
    414.      div   bx
    415.       add  dl,'0'
    416.      mov   [si],dl
    417.      dec   si
    418.      loop  CTSLoop
    419. ;
    420. ; Print the results.
    421. ;
    422.      mov   ah, 9
    423.      mov   dx, offset OutputStr
    424.      int   21h
    425. ;
    426. EndZTimerReport:
    427.      pop   ds
    428.      pop   si
    429.      pop   dx
    430.      pop   cx
    431.      pop   bx
    432.      pop   ax
    433.      MPOPF
    434.      ret
    436. ZTimerReport  endp
    438. Code   ends
    439.        end
    440.

    PZTEST.ASM

    1. ; Program to measure performance of code that takes less than
    2. ; 54 ms to execute. (PZTEST.ASM)
    3. ;
    4. ; Link with PZTIMER.ASM (Listing 3.1). PZTEST.BAT (Listing 3.4)
    5. ; can be used to assemble and link both files. Code to be
    6. ; measured must be in the file TESTCODE; Listing 3.3 shows
    7. ; a sample TESTCODE file.
    8. ;
    9. ; By Michael Abrash
    10. ;
    11. mystack   segment  para stack 'STACK'
    12.       db  512 dup(?)
    13. mystack   ends
    14. ;
    15. Code  segment   para public 'CODE'
    16.       assume    cs:Code, ds:Code
    17.       extrn     ZTimerOn:near, ZTimerOff:near, ZTimerReport:near
    18. Start proc near
    19.       push cs
    20.       pop  ds    ; set DS to point to the code segment,
    21.                  ; so data as well as code can easily
    22.                  ; be included in TESTCODE
    23. ;
    24.       include    TESTCODE ;code to be measured, including
    25.                  ; calls to ZTimerOn and ZTimerOff
    26. ;
    27. ; Display the results.
    28. ;
    29.     call   ZTimerReport
    30. ;
    31. ; Terminate the program.
    32. ;
    33.        mov   ah,4ch
    34.        int   21h
    35. Start endp
    36. Code  ends
    37.       end  Start

    LST3-3.ASM

    1. ; Test file;
    2. ; Measures the performance of 1,000 loads of AL from
    3. ; memory. (Use by renaming to TESTCODE, which is
    4. ; included by PZTEST.ASM (Listing 3.2). PZTIME.BAT
    5. ; (Listing 3.4) does this, along with all assembly
    6. ; and linking.)
    7. ;
    8. jmp   Skip     ;jump around defined data
    9. ;
    10. MemVar db      ?
    11. ;
    12. Skip:
    13. ;
    14. ; Start timing.
    15. ;
    16.       call  ZTimerOn
    17. ;
    18.       rept  1000
    19.       mov al,[MemVar]
    20.       endm
    21. ;
    22. ; Stop timing.
    23. ;
    24.     call  ZTimerOff

    PZTIME.BAT

    1. echo off
    2. rem
    3. rem *** Listing 3.4 ***
    4. rem
    5. rem ***************************************************************
    6. rem * Batch file PZTIME.BAT, which builds and runs the precision  *
    7. rem * Zen timer program PZTEST.EXE to time the code named as the  *
    8. rem * command-line parameter. Listing 3.1 must be named           *
    9. rem * PZTIMER.ASM, and Listing 3.2 must be named PZTEST.ASM. To   *
    10. rem * time the code in LST3-3, you'd type the DOS command:        *
    11. rem *                                                             *
    12. rem * pztime lst3-3                                               *
    13. rem *                                                             *
    14. rem * Note that MASM and LINK must be in the current directory or *
    15. rem * on the current path in order for this batch file to work.   *
    16. rem *                                                             *
    17. rem * This batch file can be speeded up by assembling PZTIMER.ASM *
    18. rem * once, then removing the lines:                              *
    19. rem *                                                             *
    20. rem * masm pztimer;                                               *
    21. rem * if errorlevel 1 goto errorend                               *
    22. rem *                                                             *
    23. rem * from this file.                                             *
    24. rem *                                                             *
    25. rem * By Michael Abrash                                           *
    26. rem ***************************************************************
    27. rem
    28. rem Make sure a file to test was specified.
    29. rem
    30. if not x%1==x goto ckexist
    31. echo ***************************************************************
    32. echo * Please specify a file to test.                              *
    33. echo ***************************************************************
    34. goto end
    35. rem
    36. rem Make sure the file exists.
    37. rem
    38. :ckexist
    39. if exist %1 goto docopy
    40. echo ***************************************************************
    41. echo * The specified file, "%1," doesn't exist.                    *
    42. echo ***************************************************************
    43. goto end
    44. rem
    45. rem copy the file to measure to TESTCODE.
    46. rem
    47. :docopy
    48. copy %1 testcode
    49. masm pztest;
    50. if errorlevel 1 goto errorend
    51. masm pztimer;
    52. if errorlevel 1 goto errorend
    53. link pztest+pztimer;
    54. if errorlevel 1 goto errorend
    55. pztest
    56. goto end
    57. :errorend
    58. echo ***************************************************************
    59. echo * An error occurred while building the precision Zen timer.   *
    60. echo ***************************************************************
    61. :end

    LZTIMER.ASM

    1. ;
    2. ; The long-period Zen timer. (LZTIMER.ASM)
    3. ; Uses the 8253 timer and the BIOS time-of-day count to time the
    4. ; performance of code that takes less than an hour to execute.
    5. ; Because interrupts are left on (in order to allow the timer
    6. ; interrupt to be recognized), this is less accurate than the
    7. ; precision Zen timer, so it is best used only to time code that takes
    8. ; more than about 54 milliseconds to execute (code that the precision
    9. ; Zen timer reports overflow on). Resolution is limited by the
    10. ; occurrence of timer interrupts.
    11. ;
    12. ; By Michael Abrash
    13. ;
    14. ; Externally callable routines:
    15. ;
    16. ;  ZTimerOn: Saves the BIOS time of day count and starts the
    17. ;    long-period Zen timer.
    18. ;
    19. ;  ZTimerOff: Stops the long-period Zen timer and saves the timer
    20. ;    count and the BIOS time-of-day count.
    21. ;
    22. ;  ZTimerReport: Prints the time that passed between starting and
    23. ;    stopping the timer.
    24. ;
    25. ; Note: If either more than an hour passes or midnight falls between
    26. ;     calls to ZTimerOn and ZTimerOff, an error is reported. For
    27. ;     timing code that takes more than a few minutes to execute,
    28. ;     either the DOS TIME command in a batch file before and after
    29. ;     execution of the code to time or the use of the DOS
    30. ;     time-of-day function in place of the long-period Zen timer is
    31. ;     more than adequate.
    32. ;
    33. ; Note: The PS/2 version is assembled by setting the symbol PS2 to 1.
    34. ;     PS2 must be set to 1 on PS/2 computers because the PS/2's
    35. ;     timers are not compatible with an undocumented timer-stopping
    36. ;     feature of the 8253; the alternative timing approach that
    37. ;     must be used on PS/2 computers leaves a short window
    38. ;     during which the timer 0 count and the BIOS timer count may
    39. ;     not be synchronized. You should also set the PS2 symbol to
    40. ;     1 if you're getting erratic or obviously incorrect results.
    41. ;
    42. ; Note: When PS2 is 0, the code relies on an undocumented 8253
    43. ;     feature to get more reliable readings. It is possible that
    44. ;     the 8253 (or whatever chip is emulating the 8253) may be put
    45. ;     into an undefined or incorrect state when this feature is
    46. ;     used.
    47. ;
    48. ;     ******************************************************************
    49. ;     * If your computer displays any hint of erratic behavior         *
    50. ;      *    after the long-period Zen timer is used, such as the floppy*
    51. ;     *    drive failing to operate properly, reboot the system, set   *
    52. ;     *    PS2 to 1 and leave it that way!                             *
    53. ;     ******************************************************************
    54. ;
    55. ; Note: Each block of code being timed should ideally be run several
    56. ;     times, with at least two similar readings required to
    57. ;     establish a true measurement, in order to eliminate any
    58. ;     variability caused by interrupts.
    59. ;
    60. ; Note: Interrupts must not be disabled for more than 54 ms at a
    61. ;     stretch during the timing interval. Because interrupts
    62. ;     are enabled, keys, mice, and other devices that generate
    63. ;     interrupts should not be used during the timing interval.
    64. ;
    65. ; Note: Any extra code running off the timer interrupt (such as
    66. ;     some memory-resident utilities) will increase the time
    67. ;     measured by the Zen timer.
    68. ;
    69. ; Note: These routines can introduce inaccuracies of up to a few
    70. ;     tenths of a second into the system clock count for each
    71. ;     code section timed. Consequently, it's a good idea to
    72. ;     reboot at the conclusion of timing sessions. (The
    73. ;     battery-backed clock, if any, is not affected by the Zen
    74. ;     timer.)
    75. ;
    76. ; All registers and all flags are preserved by all routines.
    77. ;
    79. Code segment word public 'CODE'
    80.      assume      cs:Code, ds:nothing
    81.      public      ZTimerOn, ZTimerOff, ZTimerReport
    83. ;
    84. ; Set PS2 to 0 to assemble for use on a fully 8253-compatible
    85. ; system; when PS2 is 0, the readings are more reliable if the
    86. ; computer supports the undocumented timer-stopping feature,
    87. ; but may be badly off if that feature is not supported. In
    88. ; fact, timer-stopping may interfere with your computer's
    89. ; overall operation by putting the 8253 into an undefined or
    90. ; incorrect state. Use with caution!!!
    91. ;
    92. ; Set PS2 to 1 to assemble for use on non-8253-compatible
    93. ; systems, including PS/2 computers; when PS2 is 1, readings
    94. ; may occasionally be off by 54 ms, but the code will work
    95. ; properly on all systems.
    96. ;
    97. ; A setting of 1 is safer and will work on more systems,
    98. ; while a setting of 0 produces more reliable results in systems
    99. ; which support the undocumented timer-stopping feature of the
    100. ; 8253. The choice is yours.
    101. ;
    102. PS2                  equ    1
    103. ;
    104. ; Base address of the 8253 timer chip.
    105. ;
    106. BASE_8253            equ    40h
    107. ;
    108. ; The address of the timer 0 count registers in the 8253.
    109. ;
    110. TIMER_0_8253         equ    BASE_8253 + 0
    111. ;
    112. ; The address of the mode register in the 8253.
    113. ;
    114. MODE_8253            equ    BASE_8253 + 3
    115. ;
    116. ; The address of the BIOS timer count variable in the BIOS
    117. ; data segment.
    118. ;
    119. TIMER_COUNT           equ   46ch
    120. ;
    121. ; Macro to emulate a POPF instruction in order to fix the bug in some
    122. ; 80286 chips which allows interrupts to occur during a POPF even when
    123. ; interrupts remain disabled.
    124. ;
    125. MPOPF macro
    126.       local p1, p2
    127.       jmp short p2
    128. p1:   iret        ;jump to pushed address & pop flags
    129. p2:   push cs      ;construct far return address to
    130.       call p1     ; the next instruction
    131.       endm
    132.  
    133. ;
    134. ; Macro to delay briefly to ensure that enough time has elapsed
    135. ; between successive I/O accesses so that the device being accessed
    136. ; can respond to both accesses even on a very fast PC.
    137. ;
    138. DELAY macro
    139.      jmp $+2
    140.      jmp $+2
    141.      jmp $+2
    142.      endm
    143.  
    144. StartBIOSCountLow     dw   ?       ;BIOS count low word at the
    145.                                    ; start of the timing period
    146. StartBIOSCountHigh    dw   ?       ;BIOS count high word at the
    147.                                    ; start of the timing period
    148. EndBIOSCountLow       dw   ?       ;BIOS count low word at the
    149.                                    ; end of the timing period
    150. EndBIOSCountHigh      dw   ?       ;BIOS count high word at the
    151.                                    ; end of the timing period
    152. EndTimedCount         dw   ?       ;timer 0 count at the end of
    153.                                    ; the timing period
    154. ReferenceCount        dw   ?       ;number of counts required to
    155.                                    ; execute timer overhead code
    156. ;
    157. ; String printed to report results.
    158. ;
    159. OutputStr label byte
    160.           db     0dh, 0ah, 'Timed count: '
    161. TimedCountStr    db    10 dup (?)
    162.           db     '    microseconds', 0dh, 0ah
    163.           db     '$'
    164. ;
    165. ; Temporary storage for timed count as it's divided down by powers
    166. ; of ten when converting from doubleword binary to ASCII.
    167. ;
    168. CurrentCountLow       dw    ?
    169. CurrentCountHigh  dw  ?
    170. ;
    171. ; Powers of ten table used to perform division by 10 when doing
    172. ; doubleword conversion from binary to ASCII.
    173. ;
    174. PowersOfTen label word
    175.      dd   1
    176.      dd   10
    177.      dd   100
    178.      dd   1000
    179.      dd   10000
    180.      dd   100000
    181.      dd   1000000
    182.      dd   10000000
    183.      dd   100000000
    184.      dd   1000000000
    185. PowersOfTenEnd   label word
    186. ;
    187. ; String printed to report that the high word of the BIOS count
    188. ; changed while timing (an hour elapsed or midnight was crossed),
    189. ; and so the count is invalid and the test needs to be rerun.
    190. ;
    191. TurnOverStr label byte
    192.      db 0dh, 0ah
    193.      db '****************************************************'
    194.      db 0dh, 0ah
    195.      db '*   Either midnight passed or an hour or more passed *'
    196.      db 0dh, 0ah
    197.      db '*  while timing was in progress. If the former was  *'
    198.      db 0dh, 0ah
    199.      db '*  the case, please rerun the test; if the latter   *'
    200.      db 0dh, 0ah
    201.      db '* was the case, the test code takes too long to    *'
    202.      db 0dh, 0ah
    203.      db '* run to be timed by the long-period Zen timer.    *'
    204.      db 0dh, 0ah
    205.      db '* Suggestions: use the DOS TIME command, the DOS   *'
    206.      db 0dh, 0ah
    207.      db '* time function, or a watch.                       *'
    208.      db 0dh, 0ah
    209.      db '****************************************************'
    210.      db 0dh, 0ah
    211.      db '$'
    213. ;********************************************************************
    214. ;* Routine called to start timing.         *
    215. ;********************************************************************
    217. ZTimerOn  proc near
    219. ;
    220. ; Save the context of the program being timed.
    221. ;
    222.      push ax
    223.      pushf
    224. ;
    225. ; Set timer 0 of the 8253 to mode 2 (divide-by-N), to cause
    226. ; linear counting rather than count-by-two counting. Also stops
    227. ; timer 0 until the timer count is loaded, except on PS/2
    228. ; computers.
    229. ;
    230.      mov  al,00110100b      ;mode 2
    231.      out  MODE_8253,al
    232. ;
    233. ; Set the timer count to 0, so we know we won't get another
    234. ; timer interrupt right away.
    235. ; Note: this introduces an inaccuracy of up to 54 ms in the system
    236. ; clock count each time it is executed.
    237. ;
    238.      DELAY
    239.      sub al,al
    240.      out TIMER_0_8253,al       ;lsb
    241.      DELAY
    242.      out TIMER_0_8253,al       ;msb
    243. ;
    244. ; In case interrupts are disabled, enable interrupts briefly to allow
    245. ; the interrupt generated when switching from mode 3 to mode 2 to be
    246. ; recognized. Interrupts must be enabled for at least 210 ns to allow
    247. ; time for that interrupt to occur. Here, 10 jumps are used for the
    248. ; delay to ensure that the delay time will be more than long enough
    249. ; even on a very fast PC.
    250. ;
    251.      pushf
    252.      sti
    253.      rept 10
    254.      jmp  $+2
    255.      endm
    256.      MPOPF
    257. ;
    258. ; Store the timing start BIOS count.
    259. ; (Since the timer count was just set to 0, the BIOS count will
    260. ; stay the same for the next 54 ms, so we don't need to disable
    261. ; interrupts in order to avoid getting a half-changed count.)
    262. ;
    263.      push   ds
    264.      sub    ax, ax
    265.      mov    ds, ax
    266.      mov    ax, ds:[TIMER_COUNT+2]
    267.      mov    cs:[StartBIOSCountHigh],ax
    268.      mov    ax, ds:[TIMER_COUNT]
    269.      mov    cs:[StartBIOSCountLow],ax
    270.      pop    ds
    271. ;
    272. ; Set the timer count to 0 again to start the timing interval.
    273. ;
    274.      mov    al,00110100b        ;set up to load initial
    275.      out    MODE_8253,al        ; timer count
    276.      DELAY
    277.      sub    al, al
    278.      out    TIMER_0_8253,al;    load count lsb
    279.      DELAY
    280.      out   TIMER_0_8253,al;     load count msb
    281. ;
    282. ; Restore the context of the program being timed and return to it.
    283. ;
    284.      MPOPF
    285.      pop   ax
    286.      ret
    288. ZTimerOn  endp
    290. ;********************************************************************
    291. ;* Routine called to stop timing and get count.                     *
    292. ;********************************************************************
    294. ZTimerOff proc near
    296. ;
    297. ; Save the context of the program being timed.
    298. ;
    299.      pushf
    300.      push ax
    301.      push cx
    302. ;
    303. ; In case interrupts are disabled, enable interrupts briefly to allow
    304. ; any pending timer interrupt to be handled. Interrupts must be
    305. ; enabled for at least 210 ns to allow time for that interrupt to
    306. ; occur. Here, 10 jumps are used for the delay to ensure that the
    307. ; delay time will be more than long enough even on a very fast PC.
    308. ;
    309.      sti
    310.      rept 10
    311.      jmp  $+2
    312.      endm
    314. ;
    315. ; Latch the timer count.
    316. ;
    318. if PS2
    320.      mov  al,00000000b
    321.      out  MODE_8253,al     ;latch timer 0 count
    322. ;
    323. ; This is where a one-instruction-long window exists on the PS/2.
    324. ; The timer count and the BIOS count can lose synchronization;
    325. ; since the timer keeps counting after it's latched, it can turn
    326. ; over right after it's latched and cause the BIOS count to turn
    327. ; over before interrupts are disabled, leaving us with the timer
    328. ; count from before the timer turned over coupled with the BIOS
    329. ; count from after the timer turned over. The result is a count
    330. ; that's 54 ms too long.
    331. ;
    332.  
    333. else
    334.  
    335. ;
    336. ; Set timer 0 to mode 2 (divide-by-N), waiting for a 2-byte count
    337. ; load, which stops timer 0 until the count is loaded. (Only works
    338. ; on fully 8253-compatible chips.)
    339. ;
    340.      mov   al,00110100b;     mode 2
    341.      out   MODE_8253,al
    342.      DELAY
    343.      mov   al,00000000b      ;latch timer 0 count
    344.      out   MODE_8253,al
    345.  
    346. endif
    347.  
    348.      cli                     ;stop the BIOS count
    349. ;
    350. ; Read the BIOS count. (Since interrupts are disabled, the BIOS
    351. ; count won't change.)
    352. ;
    353.      push ds
    354.      sub  ax,ax
    355.      mov  ds,ax
    356.      mov  ax,ds:[TIMER_COUNT+2]
    357.      mov  cs:[EndBIOSCountHigh],ax
    358.      mov  ax,ds:[TIMER_COUNT]
    359.      mov  cs:[EndBIOSCountLow],ax
    360.      pop  ds
    361. ;
    362. ; Read the timer count and save it.
    363. ;
    364.      in   al,TIMER_0_8253        ;lsb
    365.      DELAY
    366.      mov  ah,al
    367.      in   al,TIMER_0_8253        ;msb
    368.      xchg ah,al
    369.      neg  ax                     ;convert from countdown
    370.                                  ; remaining to elapsed
    371.                                  ; count
    372.      mov  cs:[EndTimedCount],ax
    373. ;
    374. ; Restart timer 0, which is still waiting for an initial count
    375. ; to be loaded.
    376. ;
    378. ife PS2
    380.      DELAY
    381.      mov  al,00110100b        ;mode 2, waiting to load a
    382.                               ; 2-byte count
    383.      out  MODE_8253,al
    384.      DELAY
    385.      sub  al,al
    386.      out  TIMER_0_8253,al     ;lsb
    387.      DELAY
    388.      mov  al,ah
    389.      out  TIMER_0_8253,al     ;msb
    390.      DELAY
    392. endif
    394.     sti                       ;let the BIOS count continue
    395. ;
    396. ; Time a zero-length code fragment, to get a reference for how
    397. ; much overhead this routine has. Time it 16 times and average it,
    398. ; for accuracy, rounding the result.
    399. ;
    400.      mov   cs:[ReferenceCount],0
    401.      mov   cx,16
    402.      cli                         ;interrupts off to allow a
    403.                                  ; precise reference count
    404. RefLoop:
    405.      call  ReferenceZTimerOn
    406.      call  ReferenceZTimerOff
    407.      loop  RefLoop
    408.      sti
    409.      add   cs:[ReferenceCount],8    ;total + (0.5 * 16)
    410.      mov   cl,4
    411.      shr   cs:[ReferenceCount],cl   ;(total) / 16 + 0.5
    412. ;
    413. ; Restore the context of the program being timed and return to it.
    414. ;
    415.      pop cx
    416.      pop ax
    417.      MPOPF
    418.      ret
    420. ZTimerOff endp
    422. ;
    423. ; Called by ZTimerOff to start the timer for overhead measurements.
    424. ;
    426. ReferenceZTimerOn proc near
    427. ;
    428. ; Save the context of the program being timed.
    429. ;
    430.      push ax
    431.      pushf
    432. ;
    433. ; Set timer 0 of the 8253 to mode 2 (divide-by-N), to cause
    434. ; linear counting rather than count-by-two counting.
    435. ;
    436.      mov    al,00110100b     ;mode 2
    437.      out    MODE_8253,al
    438. ;
    439. ; Set the timer count to 0.
    440. ;
    441.      DELAY
    442.      sub     al,al
    443.      out     TIMER_0_8253,al     ;lsb
    444.      DELAY
    445.      out     TIMER_0_8253,al     ;msb
    446. ;
    447. ; Restore the context of the program being timed and return to it.
    448. ;
    449.      MPOPF
    450.      pop   ax
    451.      ret
    453. ReferenceZTimerOn endp
    455. ;
    456. ; Called by ZTimerOff to stop the timer and add the result to
    457. ; ReferenceCount for overhead measurements. Doesn't need to look
    458. ; at the BIOS count because timing a zero-length code fragment
    459. ; isn't going to take anywhere near 54 ms.
    460. ;
    462. ReferenceZTimerOff proc near
    463. ;
    464. ; Save the context of the program being timed.
    465. ;
    466.      pushf
    467.      push ax
    468.      push cx
    470. ;
    471. ; Match the interrupt-window delay in ZTimerOff.
    472. ;
    473.      sti
    474.      rept 10
    475.      jmp $+2
    476.      endm
    478.      mov    al,00000000b
    479.      out    MODE_8253,al     ;latch timer
    480. ;
    481. ; Read the count and save it.
    482. ;
    483.      DELAY
    484.      in    al,TIMER_0_8253     ;lsb
    485.      DELAY
    486.      mov   ah,al
    487.      in    al,TIMER_0_8253     ;msb
    488.      xchg  ah,al
    489.      neg   ax                  ;convert from countdown
    490.                                ; remaining to elapsed
    491.                                ; count
    492.      add   cs:[ReferenceCount],ax
    493. ;
    494. ; Restore the context and return.
    495. ;
    496.      pop cx
    497.      pop ax
    498.      MPOPF
    499.      ret
    501. ReferenceZTimerOff endp
    503. ;********************************************************************
    504. ;* Routine called to report timing results.                           *
    505. ;********************************************************************
    507. ZTimerReport proc near
    509.      pushf
    510.      push    ax
    511.      push    bx
    512.      push    cx
    513.      push    dx
    514.      push    si
    515.      push    di
    516.      push    ds
    517. ;
    518.      push    cs     ;DOS functions require that DS point
    519.      pop     ds     ; to text to be displayed on the screen
    520.      assume  ds     :Code
    521. ;
    522. ; See if midnight or more than an hour passed during timing. If so,
    523. ; notify the user.
    524. ;
    525.      mov    ax,[StartBIOSCountHigh]
    526.      cmp    ax,[EndBIOSCountHigh]
    527.      jz     CalcBIOSTime     ;hour count didn't change,
    528.                              ; so everything's fine
    529.      inc    ax
    530.      cmp    ax,[EndBIOSCountHigh]
    531.      jnz    TestTooLong      ;midnight or two hour
    532.                              ; boundaries passed, so the
    533.                              ; results are no good
    534.      mov    ax,[EndBIOSCountLow]
    535.      cmp    ax,[StartBIOSCountLow]
    536.      jb     CalcBIOSTime     ;a single hour boundary
    537.                              ; passed--that's OK, so long as
    538.                              ; the total time wasn't more
    539.                              ; than an hour
    541. ;
    542. ; Over an hour elapsed or midnight passed during timing, which
    543. ; renders the results invalid. Notify the user. This misses the
    544. ; case where a multiple of 24 hours has passed, but we'll rely
    545. ; on the perspicacity of the user to detect that case.
    546. ;
    547. TestTooLong:
    548.      mov    ah,9
    549.      mov    dx,offset TurnOverStr
    550.      int    21h
    551.      jmp    short ZTimerReportDone
    552. ;
    553. ; Convert the BIOS time to microseconds.
    554. ;
    555. CalcBIOSTime:
    556.      mov    ax,[EndBIOSCountLow]
    557.      sub    ax,[StartBIOSCountLow]
    558.      mov    dx,54925          ;number of microseconds each
    559.                               ; BIOS count represents
    560.      mul    dx
    561.      mov    bx,ax             ;set aside BIOS count in
    562.      mov    cx,dx             ; microseconds
    563. ;
    564. ; Convert timer count to microseconds.
    565. ;
    566.      mov    ax,[EndTimedCount]
    567.      mov    si,8381
    568.      mul    si
    569.      mov    si,10000
    570.      div    si               ;* .8381 = * 8381 / 10000
    571. ;
    572. ; Add timer and BIOS counts together to get an overall time in
    573. ; microseconds.
    574. ;
    575.      add    bx,ax
    576.      adc    cx,0
    577. ;
    578. ; Subtract the timer overhead and save the result.
    579. ;
    580.      mov    ax,[ReferenceCount]
    581.      mov    si,8381          ;convert the reference count
    582.      mul    si               ; to microseconds
    583.      mov    si,10000
    584.      div    si               ;* .8381 = * 8381 / 10000
    585.      sub    bx,ax
    586.      sbb    cx,0
    587.      mov    [CurrentCountLow],bx
    588.      mov    [CurrentCountHigh],cx
    589. ;
    590. ; Convert the result to an ASCII string by trial subtractions of
    591. ; powers of 10.
    592. ;
    593.      mov    di,offset PowersOfTenEnd - offset PowersOfTen - 4
    594.      mov    si,offset TimedCountStr
    595. CTSNextDigit:
    596.      mov    bl,'0'
    597. CTSLoop:
    598.      mov    ax,[CurrentCountLow]
    599.      mov    dx,[CurrentCountHigh]
    600.      sub    ax,PowersOfTen[di]
    601.      sbb    dx,PowersOfTen[di+2]
    602.      jc     CTSNextPowerDown
    603.      inc    bl
    604.      mov    [CurrentCountLow],ax
    605.      mov    [CurrentCountHigh],dx
    606.      jmp    CTSLoop
    607. CTSNextPowerDown:
    608.      mov    [si],bl
    609.      inc    si
    610.      sub    di,4
    611.      jns    CTSNextDigit
    612. ;
    613. ;
    614. ; Print the results.
    615. ;
    616.      mov    ah,9
    617.      mov    dx,offset OutputStr
    618.      int    21h
    619. ;
    620. ZTimerReportDone:
    621.      pop    ds
    622.      pop    di
    623.      pop    si
    624.      pop    dx
    625.      pop    cx
    626.      pop    bx
    627.      pop    ax
    628.      MPOPF
    629.      ret
    630.  
    631. ZTimerReport    endp
    632.  
    633. Code   ends
    634.        end

    LZTEST.ASM

    1. ; Program to measure performance of code that takes longer than
    2. ; 54 ms to execute. (LZTEST.ASM)
    3. ;
    4. ; Link with LZTIMER.ASM (Listing 3.5). LZTIME.BAT (Listing 3.7)
    5. ; can be used to assemble and link both files. Code to be
    6. ; measured must be in the file TESTCODE; Listing 3.8 shows
    7. ; a sample file (LST3-8.ASM) which should be named TESTCODE.
    8. ;
    9. ; By Michael Abrash
    10. ;
    11. mystack   segment    para stack 'STACK'
    12.      db         512 dup(?)
    13. mystack   ends
    14. ;
    15. Code  segment   para public 'CODE'
    16.       assume    cs:Code, ds:Code
    17.       extrn     ZTimerOn:near, ZTimerOff:near, ZTimerReport:near
    18. Start proc near
    19.      push  cs
    20.      pop   ds      ;point DS to the code segment,
    21.                    ; so data as well as code can easily
    22.                    ; be included in TESTCODE
    23. ;
    24. ; Delay for 6-7 seconds, to let the Enter keystroke that started the
    25. ; program come back up.
    26. ;
    27.      mov   ah,2ch
    28.      int   21h                ;get the current time
    29.      mov   bh,dh              ;set the current time aside
    30. DelayLoop:
    31.      mov   ah,2ch
    32.      push  bx                 ;preserve start time
    33.      int   21h                ;get time
    34.      pop   bx                 ;retrieve start time
    35.      cmp   dh,bh              ;is the new seconds count less than
    36.                               ; the start seconds count?
    37.      jnb   CheckDelayTime     ;no
    38.      add   dh,60              ;yes, a minute must have turned over,
    39.                               ; so add one minute
    40. CheckDelayTime:
    41.      sub   dh,bh              ;get time that's passed
    42.      cmp   dh,7               ;has it been more than 6 seconds yet?
    43.      jb    DelayLoop          ;not yet
    44. ;
    45.      include   TESTCODE       ;code to be measured, including calls
    46.                               ; to ZTimerOn and ZTimerOff
    47. ;
    48. ; Display the results.
    49. ;
    50.      call  ZTimerReport
    51. ;
    52. ; Terminate the program.
    53. ;
    54.      mov   ah,4ch
    55.      int   21h
    56. Start endp
    57. Code  ends
    58.       end     Start

    LST3-8.ASM

    1. ;
    2. ; Measures the performance of 20,000 loads of AL from
    3. ; memory. (Use by renaming to TESTCODE, which is
    4. ; included by LZTEST.ASM (Listing 3.6). LZTIME.BAT
    5. ; (Listing 3.7) does this, along with all assembly
    6. ; and linking.)
    7. ;
    8. ; Note: takes about ten minutes to assemble on a slow PC if
    9. ;you are using MASM
    10. ;
    11.     jmp     Skip ;jump around defined data
    12. ;
    13. MemVar  db  ?
    14. ;
    15. Skip:
    16. ;
    17. ; Start timing.
    18. ;
    19.     call   ZTimerOn
    20. ;
    21.     rept   20000
    22.     mov    al,[MemVar]
    23.     endm
    24. ;
    25. ; Stop timing.
    26. ;
    27.     call   ZTimerOff

    LZTIME.BAT

    1. echo off
    2. rem
    3. rem *** Listing 3.7 ***
    4. rem
    5. rem ***************************************************************
    6. rem * Batch file LZTIME.BAT, which builds and runs the            *
    7. rem * long-period Zen timer program LZTEST.EXE to time the code   *
    8. rem * named as the command-line parameter. Listing 3.5 must be    *
    9. rem * named LZTIMER.ASM, and Listing 3.6 must be named            *
    10. rem * LZTEST.ASM. To time the code in LST3-8, you'd type the      *
    11. rem * DOS command:                                                *
    12. rem *                                                             *
    13. rem * lztime lst3-8                                               *
    14. rem *                                                             *
    15. rem * Note that MASM and LINK must be in the current directory or *
    16. rem * on the current path in order for this batch file to work.   *
    17. rem *                                                             *
    18. rem * This batch file can be speeded up by assembling LZTIMER.ASM *
    19. rem * once, then removing the lines:                              *
    20. rem *                                                             *
    21. rem * masm lztimer;                                               *
    22. rem * if errorlevel 1 goto errorend                               *
    23. rem *                                                             *
    24. rem * from this file.                                             *
    25. rem *                                                             *
    26. rem * By Michael Abrash                                           *
    27. rem ***************************************************************
    28. rem
    29. rem Make sure a file to test was specified.
    30. rem
    31. if not x%1==x goto ckexist
    32. echo ***************************************************************
    33. echo * Please specify a file to test.                              *
    34. echo ***************************************************************
    35. goto end
    36. rem
    37. rem Make sure the file exists.
    38. rem
    39. :ckexist
    40. if exist %1 goto docopy
    41. echo ***************************************************************
    42. echo * The specified file, "%1," doesn't exist.                    *
    43. echo ***************************************************************
    44. goto end
    45. rem
    46. rem copy the file to measure to TESTCODE.
    47. :docopy
    48. copy %1 testcode
    49. masm lztest;
    50. if errorlevel 1 goto errorend
    51. masm lztimer;
    52. if errorlevel 1 goto errorend
    53. link lztest+lztimer;
    54. if errorlevel 1 goto errorend
    55. lztest
    56. goto end
    57. :errorend
    58. echo ***************************************************************
    59. echo * An error occurred while building the long-period Zen timer. *
    60. echo ***************************************************************
    61. :end


     

  • 相关阅读:
    【Docker】容器连接到mysql（容器互联 超详细）
    python常用操作汇总
    下单小程序怎么做呢？
    21天学习挑战赛（2）图解设备树的使用
    三十六、java版 SpringCloud分布式微服务云架构之Java 泛型
    代码随想录-017-19.删除链表的倒数第N个节点
    【大数据】HDFS的使用与集群角色（学习笔记）
    【第62篇】DepGraph：适用任何结构的剪枝
    【MySQL】索引和事务(B树、B+树图解原理)
    HelloWorld - 从Houdini导出HDA到UE5
  • 原文地址：https://blog.csdn.net/hb_zxl/article/details/126845130