Megazine/Megazine-1.iso/PROGRAMA/C/ZTIMER23/SRC/ZTIMER/ULZTIMER.C

C/C++ Source or Header | 1996-02-05 | 5.3 KB | 208 lines

/****************************************************************************
*
*                          Ultra Long Period Timer
*
*                   Copyright (C) 1993-4 SciTech Software
*                            All rights reserved.
*
* Filename:        $Workfile:   ulztimer.c  $
* Version:        $Revision:   1.0  $
*
* Language:        ANSI C
* Environment:    IBM PC (MSDOS and Windows)
*
* Description:    Module to interface to the BIOS Timer Tick for timing
*                code that takes up to 24 hours (ray tracing etc). There
*                is a small overhead in calculating the time, this
*                will be negligible for such long periods of time.
*
* $Date:   05 Feb 1996 14:50:22  $ $Author:   KendallB  $
*
****************************************************************************/

#include "ztimer.h"
#include "pmode.h"

#ifdef  __WINDOWS32__
#undef    TRUE
#undef    FALSE
#define    WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <mmsystem.h>

/* Win32 compatability routines. Win32 apps cannot program the timer and
 * ToolHelp is not available. However we can use the timeGetTime() function
 * to get the current time in ms since Windows started
 */

PRIVATE ulong   tmStart,tmEnd;
PRIVATE    ulong    start,finish;

void ZTimerInit(void) {}

void _ASMAPI LZTimerOn(void)
{ tmStart = timeGetTime(); }

ulong _ASMAPI LZTimerLap(void)
{
    ulong tmLap = timeGetTime();
    return (tmLap - tmStart) * 1000L;
}

void _ASMAPI LZTimerOff(void)
{ tmEnd = timeGetTime(); }

ulong _ASMAPI LZTimerCount(void)
{ return (tmEnd - tmStart) * 1000L; }

void ULZTimerOn(void)
{ start = timeGetTime(); }

void ULZTimerOff(void)
{ finish = timeGetTime(); }

ulong ULZTimerLap(void)
{ return (timeGetTime() - start); }

ulong ULZTimerCount(void)
{ return (start - finish); }

float ULZTimerResolution(void)
{ return 0.001; }

#elif    defined(__WINDOWS16__)
#undef    TRUE
#undef    FALSE
#include <windows.h>
#include <toolhelp.h>

/* 16 bit Windows compatability routines. Rather than reading the timer
 * directly under Windows, we use the Windows API routines (which only
 * provide an accuracy of 1ms however). The timer interrupts are virtualised
 * under windows, which causes us to get incorrect results if we program
 * the timer directly.
 */

PRIVATE    TIMERINFO    tmStart,tmEnd,tmLap;
PRIVATE    TIMERINFO    start,finish;

void ZTimerInit(void)
{
    tmStart.dwSize = tmEnd.dwSize = tmLap.dwSize = sizeof(TIMERINFO);
    start.dwSize = finish.dwSize = sizeof(TIMERINFO);
}

void _ASMAPI LZTimerOn(void)
{ TimerCount(&tmStart); }

ulong _ASMAPI LZTimerLap(void)
{
    TimerCount(&tmLap);
    return (tmLap.dwmsSinceStart - tmStart.dwmsSinceStart) * 1000L;
}

void _ASMAPI LZTimerOff(void)
{ TimerCount(&tmEnd); }

ulong _ASMAPI LZTimerCount(void)
{ return (tmEnd.dwmsSinceStart - tmStart.dwmsSinceStart) * 1000L; }

void ULZTimerOn(void)
{ TimerCount(&start); }

void ULZTimerOff(void)
{ TimerCount(&finish); }

ulong ULZTimerLap(void)
{
    TimerCount(&tmLap);
    return (tmLap.dwmsSinceStart - start.dwmsSinceStart);
}

ulong ULZTimerCount(void)
{ return (finish.dwmsSinceStart - start.dwmsSinceStart); }

float ULZTimerResolution(void)
{ return 0.001; }

#else

PRIVATE    ulong    start,finish;
ushort             _ASMAPI _ZTimerBIOS;

void _ASMAPI LZ_disable(void);
void _ASMAPI LZ_enable(void);

void ZTimerInit(void)
{ _ZTimerBIOS = PM_getBIOSSelector(); }

void ULZTimerOn(void)
{ start = ULZReadTime(); }

void ULZTimerOff(void)
{ finish = ULZReadTime(); }

ulong ULZTimerLap(void)
{ return ULZElapsedTime(start,ULZReadTime()); }

ulong ULZTimerCount(void)
{ return ULZElapsedTime(start,finish); }

ulong ULZReadTime(void)
/****************************************************************************
*
* Function:        ULZReadTime
* Returns:        Current timer tick count.
*
* Description:    We turn of interrupts while we
*                get the value from the BIOS data area since it is stored
*                as two bytes and an interrupt COULD stuff up our reading.
*
****************************************************************************/
{
    ulong    ticks;

    LZ_disable();            /* Turn of interrupts               */
    ticks = PM_getLong(_ZTimerBIOS,0x6C);
    LZ_enable();             /* Turn on interrupts again         */

    return ticks;
}

ulong ULZElapsedTime(ulong start,ulong finish)
/****************************************************************************
*
* Function:        ULZElapsedTime
* Parameters:    start    - Starting timer tick value
*                finish    - Ending timer tick value
*
* Returns:        Elapsed timer between starting time and ending time in
*                1/18 ths of a second.
*
****************************************************************************/
{
    /* Check to see whether a midnight boundary has passed, and if so
     * adjust the finish time to account for this. We cannot detect if
     * more that one midnight boundary has passed, so if this happens
     * we will be generating erronous results.
     */

    if (finish < start)
        finish += 1573040L;            /* Number of ticks in 24 hours        */

    return finish - start;
}

float ULZTimerResolution(void)
/****************************************************************************
*
* Function:        ULZTimerResolution
* Returns:        Resolution of the ULZTimer routines (seconds in a tick)
*
****************************************************************************/
{
    return 0.054925;
}

#endif    /* DOS */