mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
811 lines
20 KiB
811 lines
20 KiB
/* + mmtimers.h
|
|
*
|
|
* Accurate timers using pentium cpu clock, QueryPerformanceCounter
|
|
* or GetTickCount depending on what system the code is run on
|
|
*
|
|
* Copyright (C) 1995, Microsoft Corporation, all rights reserved
|
|
*
|
|
*-========================================================================*/
|
|
|
|
#if !defined _INC_MMTIMERS_
|
|
#define _INC_MMTIMERS_
|
|
|
|
typedef struct {
|
|
DWORD dwlo;
|
|
DWORD dwhi;
|
|
} PCTIMER, NEAR * PPCTIMER;
|
|
|
|
struct _pctimer_global {
|
|
DWORD dwRawHz;
|
|
DWORD dwMicroAdjust;
|
|
union {
|
|
DWORD dwRawKhz;
|
|
WORD wRawKhz;
|
|
};
|
|
union {
|
|
DWORD dwRawMhz;
|
|
WORD wRawMhz;
|
|
};
|
|
DWORD dwTimerKhz;
|
|
PCTIMER base;
|
|
DWORD (WINAPI * DifTicks )(PCTIMER *);
|
|
DWORD (WINAPI * DifMicrosec )(PCTIMER *);
|
|
DWORD (WINAPI * DifMillisec )(PCTIMER *);
|
|
DWORD (WINAPI * DeltaTicks )(PCTIMER *);
|
|
DWORD (WINAPI * DeltaMicrosec)(PCTIMER *);
|
|
DWORD (WINAPI * DeltaMillisec)(PCTIMER *);
|
|
UINT uTimerType;
|
|
};
|
|
extern struct _pctimer_global pc;
|
|
|
|
extern VOID WINAPI InitPerformanceCounters ();
|
|
|
|
#define pcBegin() pc.DeltaTicks(&pc.base)
|
|
#define pcGetTime() pc.DifMillisec(&pc.base)
|
|
#define pcGetTicks() pc.DifMicrosec(&pc.base)
|
|
#define pcGetTickRate() (pc.dwTimerKhz * 1000)
|
|
#define pcBeginTimer(ppt) (pc.DeltaMicrosec(ppt), 0)
|
|
#define pcDeltaTicks(ppt) pc.DeltaMicrosec(ppt)
|
|
|
|
#endif //_INC_MMTIMERS_
|
|
|
|
// =============================================================================
|
|
|
|
//
|
|
// include this in only one module in a DLL or APP
|
|
//
|
|
#if (defined _INC_MMTIMERS_CODE_) && (_INC_MMTIMERS_CODE_ != FALSE)
|
|
#undef _INC_MMTIMERS_CODE_
|
|
#define _INC_MMTIMERS_CODE_ FALSE
|
|
|
|
static DWORD WINAPI tgtDeltaTime (PCTIMER *pctimer)
|
|
{
|
|
DWORD dwTime = timeGetTime();
|
|
DWORD dwDelta = dwTime - pctimer->dwlo;
|
|
pctimer->dwlo = dwTime;
|
|
return dwDelta;
|
|
}
|
|
|
|
static DWORD WINAPI tgtDiffTime (PCTIMER *pctimer)
|
|
{
|
|
return timeGetTime() - pctimer->dwlo;
|
|
}
|
|
|
|
struct _pctimer_global pc = {1000, 0, 1, 0, 1,
|
|
0, 0,
|
|
(LPVOID)tgtDiffTime,
|
|
(LPVOID)tgtDiffTime,
|
|
(LPVOID)tgtDiffTime,
|
|
(LPVOID)tgtDeltaTime,
|
|
(LPVOID)tgtDeltaTime,
|
|
(LPVOID)tgtDeltaTime,
|
|
0,
|
|
};
|
|
|
|
#if defined WIN32 || defined _WIN32
|
|
|
|
#if !defined _X86_
|
|
#define Scale(value,scalar) (DWORD)((value).QuadPart / (scalar))
|
|
#else
|
|
//
|
|
// c9 wants to do LARGE_INTEGER division by calling a library
|
|
// routine. We get a link error for projects that are not
|
|
// already using the C-runtime, so to avoid that, we do the division
|
|
// using x86 assembler
|
|
//
|
|
#pragma warning(disable:4704)
|
|
#pragma warning(disable:4035)
|
|
DWORD _inline Scale(
|
|
LARGE_INTEGER value,
|
|
DWORD scalar)
|
|
{
|
|
_asm {
|
|
mov ecx, scalar
|
|
mov eax, value.LowPart
|
|
mov edx, value.HighPart
|
|
jecxz bail
|
|
cmp edx, ecx
|
|
jb ok_to_divide
|
|
push eax
|
|
mov eax, edx
|
|
xor edx, edx
|
|
div ecx
|
|
pop eax
|
|
ok_to_divide:
|
|
div ecx
|
|
bail:
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static VOID WINAPI qpcInitTimer (PCTIMER * pbase)
|
|
{
|
|
QueryPerformanceCounter ((LPVOID)pbase);
|
|
}
|
|
|
|
static DWORD WINAPI qpcDiffTicks (PCTIMER * pbase)
|
|
{
|
|
LARGE_INTEGER *plarge = (LPVOID)pbase;
|
|
LARGE_INTEGER ticks;
|
|
|
|
QueryPerformanceCounter (&ticks);
|
|
ticks.QuadPart -= plarge->QuadPart;
|
|
return ticks.LowPart;
|
|
}
|
|
|
|
static DWORD WINAPI qpcDiffMicrosec (PCTIMER * pbase)
|
|
{
|
|
LARGE_INTEGER *plarge = (LPVOID)pbase;
|
|
LARGE_INTEGER ticks;
|
|
|
|
QueryPerformanceCounter (&ticks);
|
|
ticks.QuadPart -= plarge->QuadPart;
|
|
ticks.LowPart = Scale(ticks, pc.dwRawMhz);
|
|
if (pc.dwMicroAdjust)
|
|
return MulDiv (ticks.LowPart, 1000000, pc.dwMicroAdjust);
|
|
return ticks.LowPart;
|
|
}
|
|
|
|
static DWORD WINAPI qpcDiffMillisec (PCTIMER * pbase)
|
|
{
|
|
LARGE_INTEGER *plarge = (LPVOID)pbase;
|
|
LARGE_INTEGER ticks;
|
|
|
|
QueryPerformanceCounter (&ticks);
|
|
ticks.QuadPart -= plarge->QuadPart;
|
|
return Scale(ticks, pc.dwRawKhz);
|
|
}
|
|
|
|
static DWORD WINAPI qpcDeltaTicks (PCTIMER * pbase)
|
|
{
|
|
LARGE_INTEGER *plarge = (LPVOID)pbase;
|
|
LARGE_INTEGER ticks = *plarge;
|
|
|
|
QueryPerformanceCounter (plarge);
|
|
ticks.QuadPart = plarge->QuadPart - ticks.QuadPart;
|
|
return ticks.LowPart;
|
|
}
|
|
|
|
static DWORD WINAPI qpcDeltaMicrosec (PCTIMER * pbase)
|
|
{
|
|
LARGE_INTEGER *plarge = (LPVOID)pbase;
|
|
LARGE_INTEGER ticks = *plarge;
|
|
|
|
QueryPerformanceCounter (plarge);
|
|
ticks.QuadPart = plarge->QuadPart - ticks.QuadPart;
|
|
ticks.LowPart = Scale(ticks, pc.dwRawMhz);
|
|
if (pc.dwMicroAdjust)
|
|
return MulDiv (ticks.LowPart, 1000000, pc.dwMicroAdjust);
|
|
return ticks.LowPart;
|
|
}
|
|
|
|
static DWORD WINAPI qpcDeltaMillisec (PCTIMER * pbase)
|
|
{
|
|
LARGE_INTEGER *plarge = (LPVOID)pbase;
|
|
LARGE_INTEGER ticks = *plarge;
|
|
|
|
QueryPerformanceCounter (plarge);
|
|
ticks.QuadPart = plarge->QuadPart - ticks.QuadPart;
|
|
return Scale(ticks, pc.dwRawKhz);
|
|
}
|
|
|
|
static DWORD WINAPI qpcTimerFreq ()
|
|
{
|
|
LARGE_INTEGER freq;
|
|
if (QueryPerformanceFrequency (&freq))
|
|
return freq.LowPart;
|
|
return 0;
|
|
}
|
|
|
|
#ifdef _X86_
|
|
|
|
#pragma warning(disable:4704)
|
|
#pragma warning(disable:4035)
|
|
|
|
static VOID WINAPI p5InitTimer (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
mov ebx, pBase
|
|
mov [ebx], eax
|
|
mov [ebx+4], edx
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DiffTicks (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
mov ebx, pBase
|
|
sub eax, [ebx]
|
|
sbb edx, [ebx+4]
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DiffMicrosec (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
mov ebx, pBase
|
|
sub eax, [ebx]
|
|
sbb edx, [ebx+4]
|
|
|
|
mov ecx, pc.dwRawMhz
|
|
jecxz bail
|
|
cmp edx, ecx
|
|
jb ok_to_divide
|
|
push eax
|
|
mov eax, edx
|
|
xor edx, edx
|
|
div ecx
|
|
pop eax
|
|
ok_to_divide:
|
|
div ecx
|
|
bail:
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DiffMillisec (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
mov ebx, pBase
|
|
sub eax, [ebx]
|
|
sbb edx, [ebx+4]
|
|
|
|
mov ecx, pc.dwRawKhz
|
|
jecxz bail
|
|
cmp edx, ecx
|
|
jb ok_to_divide
|
|
push eax
|
|
mov eax, edx
|
|
xor edx, edx
|
|
div ecx
|
|
pop eax
|
|
ok_to_divide:
|
|
div ecx
|
|
bail:
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DeltaTicks (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
mov ebx, pBase
|
|
mov ecx, eax
|
|
sub eax, [ebx]
|
|
mov [ebx], ecx
|
|
mov ecx, edx
|
|
sbb edx, [ebx+4]
|
|
mov [ebx+4], ecx
|
|
}
|
|
}
|
|
static DWORD WINAPI p5DeltaMicrosec (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
mov ebx, pBase
|
|
mov ecx, eax
|
|
sub eax, [ebx]
|
|
mov [ebx], ecx
|
|
mov ecx, edx
|
|
sbb edx, [ebx+4]
|
|
mov [ebx+4], ecx
|
|
|
|
mov ecx, pc.dwRawMhz
|
|
jecxz bail
|
|
cmp edx, ecx
|
|
jb ok_to_divide
|
|
push eax
|
|
mov eax, edx
|
|
xor edx, edx
|
|
div ecx
|
|
pop eax
|
|
ok_to_divide:
|
|
div ecx
|
|
bail:
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DeltaMillisec (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
mov ebx, pBase
|
|
mov ecx, eax
|
|
sub eax, [ebx]
|
|
mov [ebx], ecx
|
|
mov ecx, edx
|
|
sbb edx, [ebx+4]
|
|
mov [ebx+4], ecx
|
|
|
|
mov ecx, pc.dwRawKhz
|
|
jecxz bail
|
|
cmp edx, ecx
|
|
jb ok_to_divide
|
|
push eax
|
|
mov eax, edx
|
|
xor edx, edx
|
|
div ecx
|
|
pop eax
|
|
ok_to_divide:
|
|
div ecx
|
|
bail:
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5TimerFreq ()
|
|
{
|
|
SYSTEM_INFO si;
|
|
|
|
GetSystemInfo(&si);
|
|
if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL &&
|
|
si.wProcessorLevel == 5
|
|
)
|
|
{
|
|
PCTIMER timer;
|
|
LARGE_INTEGER qpc1, qpc2;
|
|
DWORD dwTime;
|
|
DWORD dwTicks;
|
|
OSVERSIONINFO osv;
|
|
#define MS_INTERVAL 500
|
|
|
|
// pentium timers dont work correctly on NT so
|
|
// dont use them
|
|
//
|
|
{
|
|
osv.dwOSVersionInfoSize = sizeof(osv);
|
|
GetVersionEx (&osv);
|
|
}
|
|
|
|
// dont use pentium timers if they take more
|
|
// than about 12 microsec to execute
|
|
//
|
|
p5InitTimer (&timer);
|
|
if (p5DeltaTicks (&timer) > (60 * 12) &&
|
|
p5DeltaTicks (&timer) > (60 * 12))
|
|
{
|
|
// pentium timers are too slow to try and use them.
|
|
// just go with QueryPerformanceCounter instead
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
// for some reason, if you use timeBeginPeriod
|
|
// on NT. it decides that my 90mhz pentium is an 88mhz
|
|
// pentium.
|
|
//
|
|
//if (osv.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
|
|
// timeBeginPeriod (1);
|
|
|
|
p5InitTimer (&timer);
|
|
QueryPerformanceCounter (&qpc1);
|
|
Sleep(MS_INTERVAL);
|
|
QueryPerformanceCounter (&qpc2);
|
|
dwTicks = p5DiffTicks(&timer);
|
|
|
|
//if (osv.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
|
|
// timeEndPeriod (1);
|
|
|
|
dwTime = (DWORD)(qpc2.QuadPart - qpc1.QuadPart);
|
|
QueryPerformanceFrequency (&qpc1);
|
|
dwTime = MulDiv(dwTime, 1000, qpc1.LowPart);
|
|
|
|
if (dwTime < MS_INTERVAL * 9 / 10)
|
|
return 0;
|
|
|
|
pc.dwRawMhz = (dwTicks + dwTime * 1000/2) /dwTime /1000;
|
|
pc.dwRawKhz = pc.dwRawMhz * 1000;
|
|
pc.dwRawHz = pc.dwRawKhz * 1000;
|
|
pc.dwMicroAdjust = 0;
|
|
pc.dwTimerKhz = 1000;
|
|
|
|
return pc.dwRawHz;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
VOID WINAPI InitPerformanceCounters (void)
|
|
{
|
|
DWORD dwFreq;
|
|
|
|
#ifdef _X86_
|
|
if (p5TimerFreq())
|
|
{
|
|
pc.DifTicks = p5DiffTicks;
|
|
pc.DifMicrosec = p5DiffMicrosec;
|
|
pc.DifMillisec = p5DiffMillisec;
|
|
pc.DeltaTicks = p5DeltaTicks;
|
|
pc.DeltaMicrosec = p5DeltaMicrosec;
|
|
pc.DeltaMillisec = p5DeltaMillisec;
|
|
pc.uTimerType = 5;
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
if (dwFreq = qpcTimerFreq())
|
|
{
|
|
pc.dwRawKhz = dwFreq / 1000;
|
|
pc.dwRawMhz = pc.dwRawKhz / 1000;
|
|
pc.dwMicroAdjust = dwFreq / pc.dwRawMhz;
|
|
if (pc.dwMicroAdjust == 1000000)
|
|
pc.dwMicroAdjust = 0;
|
|
pc.dwTimerKhz = 1000;
|
|
|
|
pc.DifTicks = qpcDiffTicks;
|
|
pc.DifMicrosec = qpcDiffMicrosec;
|
|
pc.DifMillisec = qpcDiffMillisec;
|
|
pc.DeltaTicks = qpcDeltaTicks;
|
|
pc.DeltaMicrosec = qpcDeltaMicrosec;
|
|
pc.DeltaMillisec = qpcDeltaMillisec;
|
|
pc.uTimerType = 1;
|
|
}
|
|
}
|
|
|
|
#else // win16
|
|
|
|
#pragma warning(disable:4704)
|
|
#pragma warning(disable:4035)
|
|
|
|
static VOID WINAPI p5InitTimer (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
_emit 0x66
|
|
xor bx, bx
|
|
mov bx, pBase
|
|
_emit 0x66
|
|
mov [bx], ax
|
|
_emit 0x66
|
|
mov [bx+4], dx
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DiffTicks (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
_emit 0x66
|
|
xor bx, bx
|
|
mov bx, pBase
|
|
_emit 0x66
|
|
sub ax, [bx]
|
|
_emit 0x66
|
|
sbb dx, [bx+4]
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DiffMicrosec (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
_emit 0x66
|
|
xor bx, bx
|
|
mov bx, pBase
|
|
_emit 0x66
|
|
sub ax, [bx]
|
|
_emit 0x66
|
|
sbb dx, [bx+4]
|
|
|
|
//_emit 0x66
|
|
mov cx, pc.wRawMhz
|
|
_emit 0x66
|
|
jcxz bail
|
|
_emit 0x66
|
|
cmp dx, cx
|
|
jb ok_to_divide
|
|
_emit 0x66
|
|
push ax
|
|
_emit 0x66
|
|
mov ax, dx
|
|
_emit 0x66
|
|
xor dx, dx
|
|
_emit 0x66
|
|
div cx
|
|
_emit 0x66
|
|
pop ax
|
|
ok_to_divide:
|
|
_emit 0x66
|
|
div cx
|
|
bail:
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DiffMillisec (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
_emit 0x66
|
|
xor bx, bx
|
|
mov bx, pBase
|
|
_emit 0x66
|
|
sub ax, [bx]
|
|
_emit 0x66
|
|
sbb dx, [bx+4]
|
|
|
|
_emit 0x66
|
|
mov cx, pc.wRawKhz
|
|
_emit 0x66
|
|
jcxz bail
|
|
_emit 0x66
|
|
cmp dx, cx
|
|
jb ok_to_divide
|
|
_emit 0x66
|
|
push ax
|
|
_emit 0x66
|
|
mov ax, dx
|
|
_emit 0x66
|
|
xor dx, dx
|
|
_emit 0x66
|
|
div cx
|
|
_emit 0x66
|
|
pop ax
|
|
ok_to_divide:
|
|
_emit 0x66
|
|
div cx
|
|
bail:
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DeltaTicks (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
_emit 0x66
|
|
mov bx, pBase
|
|
_emit 0x66
|
|
mov cx, ax
|
|
_emit 0x66
|
|
sub ax, [bx]
|
|
_emit 0x66
|
|
mov [bx], cx
|
|
_emit 0x66
|
|
mov cx, dx
|
|
_emit 0x66
|
|
sbb dx, [bx+4]
|
|
_emit 0x66
|
|
mov [bx+4], cx
|
|
}
|
|
}
|
|
static DWORD WINAPI p5DeltaMicrosec (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
_emit 0x66
|
|
mov bx, pBase
|
|
_emit 0x66
|
|
mov cx, ax
|
|
_emit 0x66
|
|
sub ax, [bx]
|
|
_emit 0x66
|
|
mov [bx], cx
|
|
_emit 0x66
|
|
mov cx, dx
|
|
_emit 0x66
|
|
sbb dx, [bx+4]
|
|
_emit 0x66
|
|
mov [bx+4], cx
|
|
|
|
_emit 0x66
|
|
mov cx, pc.wRawMhz
|
|
_emit 0x66
|
|
jcxz bail
|
|
_emit 0x66
|
|
cmp dx, cx
|
|
jb ok_to_divide
|
|
_emit 0x66
|
|
push ax
|
|
_emit 0x66
|
|
mov ax, dx
|
|
_emit 0x66
|
|
xor dx, dx
|
|
_emit 0x66
|
|
div cx
|
|
_emit 0x66
|
|
pop ax
|
|
ok_to_divide:
|
|
_emit 0x66
|
|
div cx
|
|
bail:
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5DeltaMillisec (PCTIMER * pBase)
|
|
{
|
|
_asm {
|
|
_emit 0x0f
|
|
_emit 0x31
|
|
|
|
_emit 0x66
|
|
mov bx, pBase
|
|
_emit 0x66
|
|
mov cx, ax
|
|
_emit 0x66
|
|
sub ax, [bx]
|
|
_emit 0x66
|
|
mov [bx], cx
|
|
_emit 0x66
|
|
mov cx, dx
|
|
_emit 0x66
|
|
sbb dx, [bx+4]
|
|
_emit 0x66
|
|
mov [bx+4], cx
|
|
|
|
//_emit 0x66
|
|
mov cx, pc.wRawKhz
|
|
_emit 0x66
|
|
jcxz bail
|
|
_emit 0x66
|
|
cmp dx, cx
|
|
jb ok_to_divide
|
|
_emit 0x66
|
|
push ax
|
|
_emit 0x66
|
|
mov ax, dx
|
|
_emit 0x66
|
|
xor dx, dx
|
|
_emit 0x66
|
|
div cx
|
|
_emit 0x66
|
|
pop ax
|
|
ok_to_divide:
|
|
_emit 0x66
|
|
div cx
|
|
bail:
|
|
|
|
}
|
|
}
|
|
|
|
// 16 bit code for detecting CPU type so we can decide
|
|
// whether or not it is ok to use the pentium timing stuff
|
|
//
|
|
int WINAPI pcGetCpuID ()
|
|
{
|
|
_asm {
|
|
_emit 0x66
|
|
pushf ; save eflags
|
|
|
|
// check for 486 by attempting to set the 0x40000 bit
|
|
// in eflags. if we can set it, the processor is 486 or better
|
|
//
|
|
_emit 0x66
|
|
pushf ; push eflags
|
|
pop ax ; move eflags to dx:ax
|
|
pop dx
|
|
or dx, 4 ; set 0x40000 bit in eflags
|
|
push dx ; put back onto stack
|
|
push ax
|
|
_emit 0x66
|
|
popf ; pop modified flags back into eflags
|
|
_emit 0x66
|
|
pushf ; push eflags back onto stack
|
|
pop ax ; move eflags in to dx:bx
|
|
pop dx
|
|
|
|
_emit 0x66
|
|
popf ; restore origonal eflags
|
|
|
|
mov bx, 3 ; assume 386
|
|
test dx, 4 ; 486 will preserve 0x40000 bit on push/pop of eflags
|
|
jz ret_procid
|
|
inc bx ; this is a 486 or higher
|
|
|
|
// if we get to here it is a 486 or greater
|
|
|
|
// check for pentium or higher by attempting to toggle the
|
|
// ID bit (0x200000) in eflags.
|
|
// on a pentium, this bit will toggle, on 486 it will not
|
|
//
|
|
_emit 0x66
|
|
pushf ; save eflags
|
|
_emit 0x66
|
|
pushf ; get eflags
|
|
pop ax ; put eflags into dx:ax
|
|
pop dx
|
|
xor dx, 0x20 ; toggle 0x200000 bit in eflags
|
|
push dx
|
|
push ax ; push modified eflags from dx:ax
|
|
_emit 0x66
|
|
popf ; load changed eflags
|
|
_emit 0x66
|
|
pushf ; get eflags again
|
|
pop ax ; discard eflags lo
|
|
pop ax ; get eflags hi
|
|
xor dx, ax ; did anything change?
|
|
_emit 0x66 ; restore old eflags
|
|
popf
|
|
|
|
test dx, 0x20 ; did we change the 20 bit?
|
|
jz ret_procid ; if not, bx already has 4, return that
|
|
|
|
// if we get to here, it is a pentium or greater
|
|
|
|
// use the pentium CPUID instruction to detect exact processor
|
|
// type
|
|
//
|
|
_emit 0x0F ; cpuid instruction
|
|
_emit 0xA2
|
|
shr ax, 8 ; extract family field
|
|
and ax, 0x0F
|
|
mov bx, ax ; 5 is pentium, others are higher
|
|
|
|
ret_procid:
|
|
mov ax, bx
|
|
}
|
|
}
|
|
|
|
static DWORD WINAPI p5TimerFreq ()
|
|
{
|
|
if (pcGetCpuID() >= 5)
|
|
{
|
|
DWORD dw;
|
|
DWORD dwTicks;
|
|
static PCTIMER timer;
|
|
|
|
p5InitTimer (&timer);
|
|
dw = timeGetTime() + 200;
|
|
while (timeGetTime() < dw)
|
|
;
|
|
dw = timeGetTime() - dw;
|
|
dwTicks = p5DiffTicks(&timer);
|
|
|
|
pc.dwRawMhz = (dwTicks + dw * 1000/2) /dw /1000;
|
|
pc.dwRawKhz = pc.dwRawMhz * 1000;
|
|
pc.dwRawHz = pc.dwRawKhz * 1000;
|
|
pc.dwMicroAdjust = 0;
|
|
pc.dwTimerKhz = 1000;
|
|
|
|
return pc.dwRawHz;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
VOID WINAPI InitPerformanceCounters (void)
|
|
{
|
|
if (p5TimerFreq() != 0l)
|
|
{
|
|
pc.DifTicks = p5DiffTicks;
|
|
pc.DifMicrosec = p5DiffMicrosec;
|
|
pc.DifMillisec = p5DiffMillisec;
|
|
pc.DeltaTicks = p5DeltaTicks;
|
|
pc.DeltaMicrosec = p5DeltaMicrosec;
|
|
pc.DeltaMillisec = p5DeltaMillisec;
|
|
pc.uTimerType = 5;
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endif // WIN32
|
|
|
|
#endif // _INC_MMTIMERS_CODE_
|