Windows Scheduling

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#include <windows.h>
#include <iostream>
 
// Decode and display the current quantum configuration
void DisplayQuantumConfiguration() {
    HKEY hKey;
    DWORD result = RegOpenKeyExW(
        HKEY_LOCAL_MACHINE,
        L"SYSTEM\\CurrentControlSet\\Control\\PriorityControl",
        0, KEY_READ, &hKey
    );
    
    if (result != ERROR_SUCCESS) {
        std::cerr << "Cannot read registry\n";
        return;
    }
    
    DWORD prioritySep = 0;
    DWORD size = sizeof(prioritySep);
    
    result = RegQueryValueExW(hKey, L"Win32PrioritySeparation",
                              NULL, NULL, (LPBYTE)&prioritySep, &size);
    RegCloseKey(hKey);
    
    if (result != ERROR_SUCCESS) {
        std::cerr << "Cannot read Win32PrioritySeparation\n";
        return;
    }
    
    std::cout << "Win32PrioritySeparation: 0x" 
              << std::hex << prioritySep << std::dec << "\n\n";
    
    // Decode priority separation (bits 0-1)
    int priorityBits = prioritySep & 0x03;
    std::cout << "Priority Separation: ";
    switch (priorityBits) {
        case 0: std::cout << "None (no foreground boost)\n"; break;
        case 1: std::cout << "+1 for foreground\n"; break;
        default: std::cout << "+2 for foreground (desktop default)\n"; break;
    }
    
    // Decode quantum ratio (bits 2-3)
    int ratioBits = (prioritySep >> 2) & 0x03;
    std::cout << "Foreground Quantum: ";
    switch (ratioBits) {
        case 0: std::cout << "Equal to background (1:1)\n"; break;
        case 1: std::cout << "Double background (1:2)\n"; break;
        default: std::cout << "Triple background (1:3, desktop default)\n"; break;
    }
    
    // Decode quantum length (bits 4-5)
    int lengthBits = (prioritySep >> 4) & 0x03;
    std::cout << "Quantum Length: ";
    switch (lengthBits) {
        case 0: std::cout << "Short (optimized for responsiveness)\n"; break;
        case 1: std::cout << "Long/Fixed (optimized for throughput)\n"; break;
        default: std::cout << "Variable (adjusts based on behavior)\n"; break;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include <windows.h>
#include <iostream>
#include <thread>
#include <chrono>
 
// Monitor foreground status changes
void MonitorForegroundStatus() {
    DWORD lastForegroundPid = 0;
    
    while (true) {
        HWND foregroundWindow = GetForegroundWindow();
        
        if (foregroundWindow) {
            DWORD foregroundPid;
            GetWindowThreadProcessId(foregroundWindow, &foregroundPid);
            
            if (foregroundPid != lastForegroundPid) {
                char windowTitle[256] = {0};
                GetWindowTextA(foregroundWindow, windowTitle, sizeof(windowTitle));
                
                std::cout << "[" << std::chrono::system_clock::now()
                          .time_since_epoch().count() 
                          << "] Foreground changed\n"
                          << "  PID: " << foregroundPid << "\n"
                          << "  Window: " << windowTitle << "\n"
                          << "  (This process receives 3x quantum on desktop)\n\n";
                
                lastForegroundPid = foregroundPid;
            }
        }
        
        Sleep(100);  // Poll every 100ms
    }
}
 
// Check if current process is in foreground
bool IsCurrentProcessForeground() {
    HWND foregroundWindow = GetForegroundWindow();
    if (!foregroundWindow) return false;
    
    DWORD foregroundPid;
    GetWindowThreadProcessId(foregroundWindow, &foregroundPid);
    
    return (foregroundPid == GetCurrentProcessId());
}
 
// Measure quantum in a busy loop (rough approximation)
void MeasureApproximateQuantum() {
    // This is a crude measurement - actual quantum is complex to measure
    // because other factors (priority boosts, preemption) interfere
    
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
    
    const int SAMPLES = 10;
    for (int i = 0; i < SAMPLES; i++) {
        auto start = std::chrono::high_resolution_clock::now();
        
        // Busy loop until we're rescheduled
        volatile int counter = 0;
        DWORD startTick = GetTickCount();
        while (GetTickCount() - startTick < 1) {
            counter++;
        }
        
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        
        std::cout << "Sample " << i << ": ~" << duration.count() << " us\n";
    }
    
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

#include <windows.h>
#include <iostream>
#include <timeapi.h>  // Requires linking with winmm.lib
 
#pragma comment(lib, "winmm.lib")
 
// Query current timer resolution
void QueryTimerResolution() {
    TIMECAPS tc;
    if (timeGetDevCaps(&tc, sizeof(tc)) == TIMERR_NOERROR) {
        std::cout << "Timer Resolution Range:\n";
        std::cout << "  Minimum period: " << tc.wPeriodMin << " ms\n";
        std::cout << "  Maximum period: " << tc.wPeriodMax << " ms\n";
    }
    
    // Query current resolution using undocumented but stable API
    ULONG minRes, maxRes, currentRes;
    typedef NTSTATUS (NTAPI *NtQueryTimerResolution_t)(
        PULONG MinimumResolution,
        PULONG MaximumResolution,
        PULONG CurrentResolution
    );
    
    HMODULE ntdll = GetModuleHandleW(L"ntdll.dll");
    auto NtQueryTimerResolution = (NtQueryTimerResolution_t)
        GetProcAddress(ntdll, "NtQueryTimerResolution");
    
    if (NtQueryTimerResolution) {
        NtQueryTimerResolution(&minRes, &maxRes, &currentRes);
        // Values are in 100-nanosecond units
        std::cout << "Current Resolution: " 
                  << (currentRes / 10000.0) << " ms\n";
    }
}
 
// Request high timer resolution
class HighResolutionTimer {
private:
    UINT uResolution;
    bool active;
    
public:
    HighResolutionTimer(UINT resolutionMs = 1) : active(false) {
        TIMECAPS tc;
        if (timeGetDevCaps(&tc, sizeof(tc)) == TIMERR_NOERROR) {
            uResolution = max(tc.wPeriodMin, resolutionMs);
            
            if (timeBeginPeriod(uResolution) == TIMERR_NOERROR) {
                active = true;
                std::cout << "Timer resolution set to " 
                          << uResolution << " ms\n";
            }
        }
    }
    
    ~HighResolutionTimer() {
        if (active) {
            timeEndPeriod(uResolution);
            std::cout << "Timer resolution restored\n";
        }
    }
};
 
// Example usage
void HighResolutionWorkExample() {
    // Request 1ms timer resolution for this scope
    HighResolutionTimer hrt(1);
    
    // Work that benefits from high resolution
    // Sleep(1) will now actually sleep ~1ms instead of ~16ms
    for (int i = 0; i < 10; i++) {
        auto start = GetTickCount64();
        Sleep(1);
        auto elapsed = GetTickCount64() - start;
        std::cout << "Sleep(1) actual: " << elapsed << " ms\n";
    }
    
    // Resolution automatically restored when hrt goes out of scope
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#include <windows.h>
#include <iostream>
 
// Query thread cycle time
void QueryThreadCycleTime(HANDLE hThread) {
    ULONG64 cycleTime;
    
    if (QueryThreadCycleTime(hThread, &cycleTime)) {
        std::cout << "Thread cycle time: " << cycleTime << " cycles\n";
        
        // Convert to approximate time (varies by CPU frequency)
        // This is just for demonstration - actual frequency varies
        double ghz = 3.0;  // Assume 3 GHz
        double seconds = cycleTime / (ghz * 1e9);
        std::cout << "Approximate wall time: " << (seconds * 1000) << " ms\n";
    }
}
 
// Query process cycle time (all threads combined)
void QueryProcessCycleTime(HANDLE hProcess) {
    ULONG64 cycleTime;
    
    if (QueryProcessCycleTime(hProcess, &cycleTime)) {
        std::cout << "Process total cycle time: " << cycleTime << " cycles\n";
    }
}
 
// Demonstrate cycle-based timing precision
void DemonstrateCycleTiming() {
    HANDLE hThread = GetCurrentThread();
    
    ULONG64 startCycles, endCycles;
    QueryThreadCycleTime(hThread, &startCycles);
    
    // Do some work
    volatile int sum = 0;
    for (int i = 0; i < 10000000; i++) {
        sum += i;
    }
    
    QueryThreadCycleTime(hThread, &endCycles);
    
    std::cout << "Work consumed: " << (endCycles - startCycles) << " cycles\n";
    
    // Compare with wall time
    FILETIME create, exit, kernel, user;
    GetThreadTimes(hThread, &create, &exit, &kernel, &user);
    
    ULARGE_INTEGER userTime;
    userTime.LowPart = user.dwLowDateTime;
    userTime.HighPart = user.dwHighDateTime;
    
    std::cout << "User time: " << (userTime.QuadPart / 10000) << " ms\n";
}
 
// Using Kernel perforamce data
void QuerySchedulerMetrics() {
    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);
    
    std::cout << "Processors: " << sysInfo.dwNumberOfProcessors << "\n";
    std::cout << "Page size: " << sysInfo.dwPageSize << "\n";
    
    // GetSystemTimes provides overall CPU usage
    FILETIME idle, kernel, user;
    if (GetSystemTimes(&idle, &kernel, &user)) {
        std::cout << "System-wide CPU times retrieved\n";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <windows.h>
#include <iostream>
#include <thread>
#include <atomic>
 
std::atomic<int> turn{0};
std::atomic<bool> done{false};
LARGE_INTEGER frequency;
LARGE_INTEGER timestamps[100001];
int switchCount = 0;
 
// Measure context switch time between two threads
void ThreadPingPong(int id) {
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
    
    while (switchCount < 100000) {
        int expected = 1 - id;
        while (turn.load(std::memory_order_acquire) != expected) {
            if (done) return;
            // Spin wait
        }
        
        if (id == 0) {
            QueryPerformanceCounter(&timestamps[++switchCount]);
        }
        
        turn.store(id, std::memory_order_release);
    }
    
    done = true;
}
 
void MeasureContextSwitchTime() {
    QueryPerformanceFrequency(&frequency);
    
    std::thread t0(ThreadPingPong, 0);
    std::thread t1(ThreadPingPong, 1);
    
    t0.join();
    t1.join();
    
    // Calculate average switch time
    double totalMicroseconds = 0;
    for (int i = 1; i < switchCount; i++) {
        double delta = (double)(timestamps[i].QuadPart - timestamps[i-1].QuadPart);
        totalMicroseconds += (delta * 1000000.0 / frequency.QuadPart);
    }
    
    std::cout << "Context switches: " << switchCount << "\n";
    std::cout << "Average round-trip: " 
              << (totalMicroseconds / switchCount) << " µs\n";
    std::cout << "Average one-way: " 
              << (totalMicroseconds / switchCount / 2) << " µs\n";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#include <windows.h>
#include <powersetting.h>
#include <iostream>
 
#pragma comment(lib, "powrprof.lib")
 
// Query and set power scheme (affects scheduling behavior)
void QueryPowerScheme() {
    GUID* activeScheme = nullptr;
    
    if (PowerGetActiveScheme(NULL, &activeScheme) == ERROR_SUCCESS) {
        WCHAR buffer[MAX_PATH];
        DWORD bufSize = MAX_PATH;
        
        if (PowerReadFriendlyName(NULL, activeScheme, NULL, NULL, 
                                   (PUCHAR)buffer, &bufSize) == ERROR_SUCCESS) {
            std::wcout << L"Active power scheme: " << buffer << L"\n";
        }
        
        LocalFree(activeScheme);
    }
}
 
// Process quantum cannot be directly set, but we can query related metrics
void QueryQuantumRelatedMetrics() {
    // System quantum table (not directly accessible, but we can infer)
    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);
    
    std::cout << "Number of processors: " << sysInfo.dwNumberOfProcessors << "\n";
    std::cout << "Processor architecture: " << sysInfo.wProcessorArchitecture << "\n";
    
    // Performance counter frequency (related to timing precision)
    LARGE_INTEGER freq;
    QueryPerformanceFrequency(&freq);
    std::cout << "Performance counter frequency: " << freq.QuadPart << " Hz\n";
    std::cout << "Counter resolution: " << (1e9 / freq.QuadPart) << " ns\n";
}
 
// Use MMCSS for multimedia scheduling (includes quantum management)
void RegisterWithMMCSS() {
    typedef HANDLE (WINAPI *AvSetMmThreadCharacteristicsW_t)(
        LPCWSTR TaskName, LPDWORD TaskIndex
    );
    
    HMODULE avrt = LoadLibraryW(L"avrt.dll");
    if (!avrt) return;
    
    auto AvSetMmThreadCharacteristicsW = (AvSetMmThreadCharacteristicsW_t)
        GetProcAddress(avrt, "AvSetMmThreadCharacteristicsW");
    
    if (AvSetMmThreadCharacteristicsW) {
        DWORD taskIndex = 0;
        HANDLE mmcssHandle = AvSetMmThreadCharacteristicsW(L"Pro Audio", &taskIndex);
        
        if (mmcssHandle) {
            std::cout << "Thread registered with MMCSS (Pro Audio)\n";
            std::cout << "Will receive priority and quantum benefits\n";
            
            // Don't forget to revert when done:
            // AvRevertMmThreadCharacteristics(mmcssHandle);
        }
    }
    
    FreeLibrary(avrt);
}
 
// Monitoring context switches (system-wide)
void MonitorContextSwitches() {
    DWORD contextSwitchesPerSec[10];
    
    // Query performance counter
    PDH_HQUERY query;
    PDH_HCOUNTER counter;
    
    std::cout << "Use Performance Monitor (perfmon) for:\n";
    std::cout << "  - System\\Context Switches/sec\n";
    std::cout << "  - Thread(*)\\Context Switches/sec\n";
    std::cout << "  - Processor(*)\\Interrupts/sec\n";
}