typedef double                                  ADouble;
#define CALLQ           WINAPI
__int64 microseccounter;
__int64 Ticks() 
{
    __int64 cpu_count;
    DWORD h32, l32;
  _asm{
      rdtsc
      mov h32, eax
      mov l32, edx
    }
    cpu_count = h32;
    cpu_count <<= 32;
    cpu_count += l32; 
    return cpu_count;
}    

ADouble CALLQ AProcessorTicksPerSecond()
{
    static ADouble ticks = -1.0;

    if (ticks <= 0.0)
    {
        HKEY hKey;
        DWORD procSpeed;
        DWORD buflen;
        DWORD ret;

        if (!RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 0, KEY_READ, &hKey))
        {
            procSpeed = 0;
            buflen = sizeof(procSpeed);

            ret = RegQueryValueExW(hKey, L"~MHz", 0, 0, (LPBYTE)&procSpeed, &buflen);

            if (ret != ERROR_SUCCESS)
                ret = RegQueryValueExW(hKey, L"~Mhz", 0, 0, (LPBYTE)&procSpeed, &buflen);

            if (ret != ERROR_SUCCESS)
                ret = RegQueryValueExW(hKey, L"~mhz", 0, 0, (LPBYTE)&procSpeed, &buflen);

            RegCloseKey(hKey);

            if (ret == ERROR_SUCCESS)
                ticks = (ADouble)procSpeed * 1000000.0;
        }
    }

    return ticks;
}    

int main()
{
    SetThreadAffinityMask(GetCurrentThread, 1);
    int tpriorityX;

    tpriorityX = GetThreadPriority(GetCurrentThread());

    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
   
    __int64 count1 = Ticks();
    Sleep(1000);
    microseccounter = (Ticks() - count1) / AProcessorTicksPerSecond();
    SetThreadPriority(GetCurrentThread(), tpriorityX);
    HWND hwnd;
    system("pause");
    hwnd = GetConsoleWindow();
    ShowWindow(hwnd, SW_HIDE);
    system("pause");
    return microseccounter;
}    

rdtsc, it can't be used as a measurement of real time (i.e. seconds, minutes etc.) because the clock speed to the CPU will change frequency depending upon the workload.

The behavior of the RDTSC instruction is implementation dependent. The TSC counts at a constant rate, but may be affected by power management events (such as frequency changes), depending on the processor implementation. If CPUID Fn8000_0007_EDX[TscInvariant] = 1, then the TSC rate is ensured to be invariant across all P-States, C-States, and stop-grant transitions (such as STPCLK Throttling); therefore, the TSC is suitable for use as a source of time.

int testrdtsc() {
        __int64 count_per_microsec;
        const ULONG numberOfProcessors = KeQueryActiveProcessorCountEx(ALL_PROCESSOR_GROUPS);
        PROCESSOR_NUMBER processorNumber;
        

        NTSTATUS status = KeGetProcessorNumberFromIndex(numberOfProcessors - 1, &processorNumber);
        if (!NT_SUCCESS(status))
        {
                
                return 0;
        }

        GROUP_AFFINITY affinity, oldAffinity;
        affinity.Group = processorNumber.Group;
        affinity.Mask = 1ULL << processorNumber.Number;
        affinity.Reserved[0] = affinity.Reserved[1] = affinity.Reserved[2] = 0;
        KeSetSystemGroupAffinityThread(&affinity, &oldAffinity);

        KIRQL originalIrql;
        KeRaiseIrql(HIGH_LEVEL, &originalIrql);
        _disable();

        __int64 count1 = __rdtsc();
        LARGE_INTEGER waitTime;
        waitTime.QuadPart = -10000000; // 1 second
        KeDelayExecutionThread(KernelMode, FALSE, &waitTime);
        count_per_microsec = (__rdtsc() - count1) / (1.0E+63 / (60 * 60 * 24 * 365)) / 1.0E+9; // cycle will end when its reach 584.94 Ghz 
        KeLowerIrql(originalIrql);
        return count_per_microsec;
}

this one give me amazing precision in kernel !    

Save and restore esi with push/pop. But the major problem is the calling convention is completely wrong. For 64-bit you need FASTCALL registers, so RCX is the first parameter.

But how does it cause BSOD? Is that a kernel bug?! At the worst it should only cause the process to crash.

BTW: I would hesitate to call it "sleep". Your CPU will still run at full power. More like an anxious person waiting at the dentist, it burns through energy and makes itself exhausted.

Save and restore esi with push/pop. But the major problem is the calling convention is completely wrong. For 64-bit you need FASTCALL registers, so RCX is the first parameter.

But how does it cause BSOD? Is that a kernel bug?! At the worst it should only cause the process to crash.

BTW: I would hesitate to call it "sleep". Your CPU will still run at full power. More like an anxious person waiting at the dentist, it burns through energy and makes itself exhausted.

.code

FasterSleep proc ticks : DWORD
        rdtsc
        shl rdx,32
        or rax,rdx
        add rcx,rax
        _loop:
        pause
        pause
        pause
        pause
        rdtsc
        shl rdx,32
        or rax,rdx
        cmp rax,rcx
        jb _loop
        ret
FasterSleep endp

end    

Number of CPU's 12, Run Time    27014uS 
0000007E56D3E14C
0000007E56D3E149
0000007E56D3E12D
0000007E56D3E127
0000007E56D3E16B
0000007E56D3E16E
0000007E56D3E1C1
0000007E56D3E1BB
0000007E56D3E199
0000007E56D3E193
Max difference 154 cycles    

        lea     rbx,[Go]
 @@:
        cmp     byte[rbx],0
        jz      @b

        rdtsc
        shl     rdx,32
        or      rax,rdx
        mov     [TS+rsi*8],rax     ; rsi is CPU number from WhoAmI
    

@sinsi how did you synchronize reading TSC? Even in UEFI best I could get is within 150 cycles such as

        xor     ebx,ebx
  @@:
        xor     ecx,ecx                                       ; pSecurity Attributes
        mov     edx,0x1000                                    ; Initial stack size
        lea     r8,[CpuThread]                                ; Thread start address
        mov     r9d,ebx                                       ; Parameter Processor Number
        mov     qword[rsp+20h],CREATE_SUSPENDED
        mov     qword[rsp+28h],0                              ; pThreadID
        call    [CreateThread]
        mov     [rbx*8+hThread],rax                           ; Thread handle

        mov     cl,bl
        mov     edx,4                                         ; start affinity from second core
        shl     edx,cl
        mov     rcx,rax
        call    [SetThreadAffinityMask]
        inc     ebx
        cmp     ebx,10                                        ; use 10 of 12 logical CPU's
        jb      @b

        xor     ebx,ebx                                       ; Resume threads
 @@:
        mov     rcx,[rbx*8+hThread]
        call    [ResumeThread]
        inc     ebx
        cmp     ebx,10
        jb      @b
    

extern "C" __forceinline void __fastcall Clocks(unsigned int dest);    

 .code

Clocks proc dest : DWORD
rdtsc
mov eax, dest
shl rdx, 32
or rax, rdx
ret
Clocks endp

end      

double RDTSCDirect(unsigned __int64 frequency)
{
        // returns < 0 on failure; otherwise, returns current cpu time, in seconds.
        // warning: watch out for wraparound!

        if (frequency == 0)
                return -1.0;

        // get high-precision time:
        __try
        {
                unsigned __int64 high_perf_time;
                unsigned __int64* dest = &high_perf_time;
                Clocks(dest);
                __int64 time_s = (__int64)(high_perf_time / frequency);  // unsigned->sign conversion should be safe here
                __int64 time_fract = (__int64)(high_perf_time % frequency);  // unsigned->sign conversion should be safe here
                // note: here, we wrap the timer more frequently (once per year) 
                // than it otherwise would (VERY RARELY - once every 585 years on
                // a 1 GHz), to alleviate floating-point precision errors that start 
                // to occur when you get to very high counter values.  
                double ret = (time_s % (60 * 60 * 24 * 365)) + (double)time_fract / (double)((__int64)frequency);
                return ret;
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
                return -1.0;
        }

        return -1.0;
}    

void testrdtsc(unsigned __int64 freq) {
        __int64 count_per_microsec;
        const ULONG numberOfProcessors = KeQueryActiveProcessorCountEx(ALL_PROCESSOR_GROUPS);
        PROCESSOR_NUMBER processorNumber;
        

        NTSTATUS status = KeGetProcessorNumberFromIndex(numberOfProcessors - 1, &processorNumber);
        if (!NT_SUCCESS(status))
        {
                
                return;
        }

        GROUP_AFFINITY affinity, oldAffinity;
        affinity.Group = processorNumber.Group;
        affinity.Mask = 1ULL << processorNumber.Number;
        affinity.Reserved[0] = affinity.Reserved[1] = affinity.Reserved[2] = 0;
        KeSetSystemGroupAffinityThread(&affinity, &oldAffinity);

        KIRQL originalIrql;
        KeRaiseIrql(HIGH_LEVEL, &originalIrql);
        _disable();

        ascwq(freq);

        _enable();
        KeLowerIrql(originalIrql);
}
    

Code:

rdtsc
mov eax, dest    

daniel02 wrote:

Code:

rdtsc
mov eax, dest    

You just overrode the lower 32-bits with the value of dest. That reduces your precision by 9 orders of magnitude.