Megazine/Megazine-1.iso/PROGRAMA/C/ZTIMER23/SRC/ZTIMER/LZTIMER.ASM

Assembly Source File | 1996-02-05 | 11.9 KB | 424 lines

;****************************************************************************
;*
;*                           Long Period Zen Timer
;*
;*                               From the book
;*                         "Zen of Assembly Language"
;*                            Volume 1, Knowledge
;*
;*                             by Michael Abrash
;*
;*                      Modifications by Kendall Bennett
;*                  Copyright (C) 1996 SciTech Software
;*
;* Filename:    $Workfile:   lztimer.asm  $
;* Version:        $Revision:   1.0  $
;*
;* Language:    80386 Assembler
;* Environment:    IBM PC (MS DOS)
;*
;* Description:    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.
;*
;*                The routines in this package only works with interrupts
;*                enabled, and in fact will explicitly turn interrupts on
;*                in order to ensure we get accurate results from the timer.
;*
;*    Externally 'C' callable routines:
;*
;*    LZTimerOn:        Saves the BIOS time of day count and starts the
;*                    long period Zen Timer.
;*
;*    LZTimerLap:        Latches the current count, and keeps the timer running
;*
;*    LZTimerOff:        Stops the long-period Zen Timer and saves the timer
;*                    count and the BIOS time of day count.
;*
;*    LZTimerCount:    Returns an unsigned long representing the timed count
;*                    in microseconds. If more than an hour passed during
;*                    the timing interval, LZTimerCount will return the
;*                    value 0xFFFFFFFF (an invalid count).
;*
;*    Note:    If either more than an hour passes between calls to LZTimerOn
;*            and LZTimerOff, an error is reported. For timing code that takes
;*            more than a few minutes to execute, use the low resolution
;*            Ultra Long Period Zen Timer code, which should be accurate
;*            enough for most purposes.
;*
;*    Note:    Each block of code being timed should ideally be run several
;*            times, with at least two similar readings required to
;*            establish a true measurement, in order to eliminate any
;*            variability caused by interrupts.
;*
;*    Note:    Interrupts must not be disabled for more than 54 ms at a
;*            stretch during the timing interval. Because interrupts are
;*            enabled, key, mice, and other devices that generate interrupts
;*            should not be used during the timing interval.
;*
;*    Note:    Any extra code running off the timer interrupt (such as
;*            some memory resident utilities) will increase the time
;*            measured by the Zen Timer.
;*
;*    Note:    These routines can introduce inaccuracies of up to a few
;*            tenths of a second into the system clock count for each
;*            code section being timed. Consequently, it's a good idea to
;*            reboot at the conclusion of timing sessions. (The
;*            battery-backed clock, if any, is not affected by the Zen
;*            timer.)
;*
;*  All registers and all flags are preserved by all routines, except
;*    interrupts which are always turned on
;*
;* $Date:   05 Feb 1996 14:35:54  $ $Author:   KendallB  $
;*
;****************************************************************************

        IDEAL

INCLUDE "model.mac"                ; Memory model macros

header    lztimer                    ; Set up memory model

ifndef  __WINDOWS16__
ifndef  __WINDOWS32__

;****************************************************************************
;
; Equates used by long period Zen Timer
;
;****************************************************************************

; Base address of 8253 timer chip

BASE_8253        =        40h

; The address of the timer 0 count registers in the 8253

TIMER_0_8253    =        BASE_8253 + 0

; The address of the mode register in the 8253

MODE_8253        =        BASE_8253 + 3

; The address of the BIOS timer count variable in the BIOS data area.

TIMER_COUNT        =        6Ch

; Macro to delay briefly to ensure that enough time has elapsed between
; successive I/O accesses so that the device being accessed can respond
; to both accesses even on a very fast PC.

macro    DELAY
        jmp        $+2
        jmp        $+2
        jmp        $+2
endm

begdataseg    lztimer

        $EXTRN  __ZTimerBIOS,USHORT

StartBIOSCount      dd  ?       ; Starting BIOS count dword
EndBIOSCount        dd    ?        ; Ending BIOS count dword
EndTimedCount        dw    ?        ; Timer 0 count at the end of timing period

enddataseg    lztimer

begcodeseg    lztimer                ; Start of code segment

;----------------------------------------------------------------------------
; void LZTimerOn(void);
;----------------------------------------------------------------------------
; Starts the Long period Zen timer counting.
;----------------------------------------------------------------------------
procstart        _LZTimerOn

; Set the timer 0 of the 8253 to mode 2 (divide-by-N), to cause
; linear counting rather than count-by-two counting. Also stops
; timer 0 until the timer count is loaded, except on PS/2 computers.

        mov        al,00110100b        ; mode 2
        out        MODE_8253,al

; Set the timer count to 0, so we know we won't get another timer
; interrupt right away. Note: this introduces an inaccuracy of up to 54 ms
; in the system clock count each time it is executed.

        DELAY
        sub        al,al
        out        TIMER_0_8253,al        ; lsb
        DELAY
        out        TIMER_0_8253,al        ; msb

; Store the timing start BIOS count

        push    es
        mov        ax,[__ZTimerBIOS]
        mov        es,ax
        cli                            ; No interrupts while we grab the count
        mov        eax,[es:TIMER_COUNT]
        sti
        mov        [StartBIOSCount],eax
        pop        es

; Set the timer count to 0 again to start the timing interval.

        mov        al,00110100b        ; set up to load initial
        out        MODE_8253,al        ; timer count
        DELAY
        sub        al,al
        out        TIMER_0_8253,al        ; load count lsb
        DELAY
        out        TIMER_0_8253,al        ; load count msb

        ret

procend        _LZTimerOn

;----------------------------------------------------------------------------
; void LZTimerOff(void);
;----------------------------------------------------------------------------
; Stops the long period Zen timer and saves count.
;----------------------------------------------------------------------------
procstart        _LZTimerOff

; Latch the timer count.

        mov        al,00000000b        ; latch timer 0
        out        MODE_8253,al
        cli                            ; Stop the BIOS count

; Read the BIOS count. (Since interrupts are disabled, the BIOS
; count won't change).

        push    es
        mov     ax,[__ZTimerBIOS]
        mov        es,ax
        mov        eax,[es:TIMER_COUNT]
        mov        [EndBIOSCount],eax
        pop        es

; Read out the count we latched earlier.

        in        al,TIMER_0_8253        ; least significant byte
        DELAY
        mov        ah,al
        in        al,TIMER_0_8253        ; most significant byte
        xchg    ah,al
        neg        ax                    ; Convert from countdown remaining
                                    ;  to elapsed count
        mov        [EndTimedCount],ax
        sti                            ; Let the BIOS count continue

        ret

procend        _LZTimerOff

;----------------------------------------------------------------------------
; unsigned long LZTimerLap(void)
;----------------------------------------------------------------------------
; Latches the current count and converts it to a microsecond timing value,
; but leaves the timer still running. We dont check for and overflow,
; where the time has gone over an hour in this routine, since we want it
; to execute as fast as possible.
;----------------------------------------------------------------------------
procstart        _LZTimerLap

        use_ebx                        ; Save EBX for 32 bit code

; Latch the timer count.

        mov     al,00000000b        ; latch timer 0
        out        MODE_8253,al
        cli                         ; Stop the BIOS count

; Read the BIOS count. (Since interrupts are disabled, the BIOS
; count won't change).

        push    es
        mov        ax,[__ZTimerBIOS]
        mov        es,ax
        mov        eax,[es:TIMER_COUNT]
        mov        [EndBIOSCount],eax
        pop        es

; Read out the count we latched earlier.

        in        al,TIMER_0_8253        ; least significant byte
        DELAY
        mov        ah,al
        in        al,TIMER_0_8253        ; most significant byte
        xchg    ah,al
        neg        ax                    ; Convert from countdown remaining
                                    ;  to elapsed count
        mov        [EndTimedCount],ax
        sti                            ; Let the BIOS count continue

; See if a midnight boundary has passed and adjust the finishing BIOS
; count by the number of ticks in 24 hours. We wont be able to detect
; more than 24 hours, but at least we can time across a midnight
; boundary

        mov        eax,[EndBIOSCount]        ; Is end < start?
        cmp        eax,[StartBIOSCount]
        jae        @@CalcBIOSTime            ; No, calculate the time taken

; Adjust the finishing time by adding the number of ticks in 24 hours
; (1573040).

        add        [EndBIOSCount],1800B0h

; Convert the BIOS time to microseconds

@@CalcBIOSTime:
        mov        ax,[WORD EndBIOSCount]
        sub        ax,[WORD StartBIOSCount]
        mov        dx,54925            ; Number of microseconds each
                                    ;  BIOS count represents.
        mul        dx
        mov        bx,ax                ; set aside BIOS count in
        mov        cx,dx                ;  microseconds

; Convert timer count to microseconds

        push    _si
        mov        ax,[EndTimedCount]
        mov        si,8381
        mul        si
        mov        si,10000
        div        si                    ; * 0.8381 = * 8381 / 10000
        pop        _si

; Add the timer and BIOS counts together to get an overall time in
; microseconds.

        add        ax,bx
        adc        cx,0
if flatmodel
        shl        ecx,16
        mov        cx,ax
        mov        eax,ecx                ; EAX := timer count
else
        mov        dx,cx
endif
        unuse_ebx                    ; Restore EBX for 32 bit code
        ret

procend        _LZTimerLap

;----------------------------------------------------------------------------
; unsigned long LZTimerCount(void);
;----------------------------------------------------------------------------
; Returns an unsigned long representing the net time in microseconds.
;
; If an hour has passed while timing, we return 0xFFFFFFFF as the count
; (which is not a possible count in itself).
;----------------------------------------------------------------------------
procstart        _LZTimerCount

        use_ebx                        ; Save EBX for 32 bit code

; See if a midnight boundary has passed and adjust the finishing BIOS
; count by the number of ticks in 24 hours. We wont be able to detect
; more than 24 hours, but at least we can time across a midnight
; boundary

        mov        eax,[EndBIOSCount]        ; Is end < start?
        cmp        eax,[StartBIOSCount]
        jae        @@CheckForHour            ; No, check for hour passing

; Adjust the finishing time by adding the number of ticks in 24 hours
; (1573040).

        add        [EndBIOSCount],1800B0h

; See if more than an hour passed during timing. If so, notify the user.

@@CheckForHour:
        mov        ax,[WORD StartBIOSCount+2]
        cmp        ax,[WORD EndBIOSCount+2]
        jz        @@CalcBIOSTime        ; Hour count didn't change, so
                                    ;  everything is fine

        inc        ax
        cmp        ax,[WORD EndBIOSCount+2]
        jnz        @@TestTooLong        ; Two hour boundaries passed, so the
                                    ;  results are no good
        mov     ax,[WORD EndBIOSCount]
        cmp        ax,[WORD StartBIOSCount]
        jb        @@CalcBIOSTime        ; a single hour boundary passed. That's
                                    ; OK, so long as the total time wasn't
                                    ; more than an hour.

; Over an hour elapsed passed during timing, which renders
; the results invalid. Notify the user. This misses the case where a
; multiple of 24 hours has passed, but we'll rely on the perspicacity of
; the user to detect that case :-).

@@TestTooLong:
if    flatmodel
        mov        eax,0FFFFFFFFh
else
        mov        ax,0FFFFh
        mov        dx,0FFFFh
endif
        jmp        short @@Done

; Convert the BIOS time to microseconds

@@CalcBIOSTime:
        mov        ax,[WORD EndBIOSCount]
        sub        ax,[WORD StartBIOSCount]
        mov        dx,54925            ; Number of microseconds each
                                    ;  BIOS count represents.
        mul        dx
        mov        bx,ax                ; set aside BIOS count in
        mov        cx,dx                ;  microseconds

; Convert timer count to microseconds

        push    _si
        mov        ax,[EndTimedCount]
        mov        si,8381
        mul        si
        mov        si,10000
        div        si                    ; * 0.8381 = * 8381 / 10000
        pop        _si

; Add the timer and BIOS counts together to get an overall time in
; microseconds.

        add        ax,bx
        adc        cx,0
if flatmodel
        shl        ecx,16
        mov        cx,ax
        mov        eax,ecx                ; EAX := timer count
else
        mov        dx,cx
endif

@@Done:
        unuse_ebx                    ; Restore EBX for 32 bit code
        ret

procend        _LZTimerCount

procstart   _LZ_disable
        cli
        ret
procend     _LZ_disable

procstart   _LZ_enable
        sti
        ret
procend     _LZ_enable

endcodeseg    lztimer

endif
endif

        END                            ; End of module