DWORD GetTickCount (void);

The returned DWORD is a count of system ticks (or milliseconds) since boot time.

#include <stdio.h>
#include <windows.h>

void CPUtick(DWORD* hi,DWORD* lo)
{
DWORD h,l;
__asm
    {
        #ifdef __BCPLUSPLUS__ 
        
    db 0fh        
    db 31h      
        
        #else

        RDTSC

        #endif

           mov [h],edx     
        mov [l],eax     
    }
*hi=h;
*lo=l;
}

DWORD MHZ() 
{
DWORD h,l,lasttick=0;
DWORD time1,time2;

time1=GetTickCount();
time2=time1;
CPUtick(&h,&l);
while(time2-time1<1000)
    {
    time2=GetTickCount();
        printf("\r%c\r%c\r%c\r%c",0x7c,0x2f,0x2d,0x5c);
    }
CPUtick(&h,&lasttick);
h=(lasttick-l)/1000000;
printf("\n");
return h;
}

void TIME(DWORD mhz)
{
DWORD h,l,hour,minute;
CPUtick(&h,&l);
h=h*(4294967296/(mhz*1000000));
hour=h/3600;
minute=(h%3600)/60;
printf("Time elapsed after last boot:\n%lu hour %lu minutes \n",hour,minute);
}

void main()
{
DWORD mhz;
printf(" Please wait few seconds....");
mhz=MHZ();
printf("Your computer operates approx. at: %lu MHZ\n", mhz);
TIME(mhz);
}

TC>Откуда такая цифра ???? . Почему не 40 и не 60?

DWORD
GetTickCount(
    VOID
    )

/*++

Routine Description:

    Win32 systems implement a free-running millisecond counter.  The
    value of this counter can be read using GetTickCount.

Arguments:

    None.

Return Value:

    This function returns the number of milliseconds that have elapsed
    since the system was started. If the system has been running for
    a long time, it is possible that the count will repeat. The value of
    the counter is accurate within 55 milliseconds.

--*/

{
    return (DWORD)NtGetTickCount();
}

TC>>Откуда такая цифра ???? . Почему не 40 и не 60?

MS>DWORD
MS>GetTickCount(
MS>    VOID
MS>    )

MS>/*++

MS>Routine Description:

MS>    Win32 systems implement a free-running millisecond counter.  The
MS>    value of this counter can be read using GetTickCount.

MS>Arguments:

MS>    None.

MS>Return Value:

MS>    This function returns the number of milliseconds that have elapsed
MS>    since the system was started. If the system has been running for
MS>    a long time, it is possible that the count will repeat. The value of
MS>    the counter is accurate within 55 milliseconds.

MS>--*/

MS>{
MS>    return (DWORD)NtGetTickCount();
MS>}
MS>

    DWORD        a = GetTickCount();
    DWORD        t1 = a;

    do {
    
    DWORD    t2 = GetTickCount();

    if ( t2 > t1 )
    {
        t1 = t2;
        printf( "%d\n", t1 - a );
    }

    } while ( 1 );

TC>>>Откуда такая цифра ???? . Почему не 40 и не 60?

TC>    DWORD        a = GetTickCount();
TC>    DWORD        t1 = a;

TC>    do {
    
TC>    DWORD    t2 = GetTickCount();

TC>    if ( t2 > t1 )
TC>    {
TC>        t1 = t2;
TC>        printf( "%d\n", t1 - a );
TC>    }

TC>    } while ( 1 );
TC>

ULONG
NtGetTickCount (
   VOID
   )

/*++

Routine Description:

    This function computes the number of milliseconds since the system
    was booted. The computation is performed by multiplying the clock
    interrupt count by a scaled fixed binary multiplier and then right
    shifting the 64-bit result to extract the 32-bit millisecond count.

    The multiplier fraction is scaled by 24 bits. Thus for a 100 Hz clock
    rate, there are 10 ticks per millisecond, and the multiplier is
    0x0a000000 (10 << 24). For a 128 Hz clock rate, there are 7.8125, or
    7 13/16 ticks per millisecond, and so the multiplier is 0x07d00000.

    This effectively replaces a (slow) divide instruction with a (fast)
    multiply instruction. The multiplier value is only calculated once
    based on the TimeIncrement value (clock tick interval in 100ns units).

    N.B. The tick count value wraps every 2^32 milliseconds (49.71 days).

Arguments:

    None.

Return Value:

    The number of milliseconds since the system was booted is returned
    as the function value.

--*/

{
    ULONGLONG Product;

    //
    // compute unsigned 64-bit product
    //

    Product = (ULONGLONG)KeTickCount * ExpTickCountMultiplier;

    //
    // shift off 24-bit fraction part and 
    // return the 32-bit canonical ULONG integer part.
    //
            
    return ((ULONG)(Product >> 24));
}