// PdhCPUCounter.h

    class PdhCPUCounter {
    public:
    
        // @param counter_name: "\\Process(*ProcessName*)\\% Processor Time"
        explicit PdhCPUCounter(const std::string& counter_name);
    
        // Release handles here
        virtual ~PdhCPUCounter();
    
        // Provide actual CPU usage value in range [0.0, 1.0]
        double getCPUUtilization() const;
    
    private:
    
        // Low-level query
        PDH_FMT_COUNTERVALUE getFormattedCounterValue() const;
    
        // Needed for calculation
        size_t m_threads;
    
        // Counter format: "\\Process(*ProcessName*)\\% Processor Time"
        std::string m_counter_name;
    
        // CPU counter handle
        PDH_HCOUNTER m_counter = INVALID_HANDLE_VALUE;
    
        // Query to PerfMon handle
        PDH_HQUERY m_query = INVALID_HANDLE_VALUE;
    };

    // PdhCPUCounter.cpp

    PdhCPUCounter::PdhCPUCounter(const std::string& counter_name) : 
        m_counter_name(counter_name),
        m_threads(std::thread::hardware_concurrency())
    {
        PdhOpenQuery(nullptr, 0, &m_query);
        PdhAddEnglishCounter(m_query, m_counter_name.c_str(), 0, &m_counter);
        PdhCollectQueryData(m_query);
    }
    
    PDH_FMT_COUNTERVALUE PdhCPUCounter::getFormattedCounterValue() const
    {
        PdhCollectQueryData(m_query);
    
        PDH_FMT_COUNTERVALUE val;
        PdhGetFormattedCounterValue(m_counter, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, nullptr, &val);
        return val;
    }
    
    double PdhCPUCounter::getCPUUtilization() const
    {
        const auto &val = getFormattedCounterValue();
        return val.doubleValue / m_threads;
    }

    // Usage
    // Monitor.exe is a test process here, which gives about 50-55% CPU usage in TaskManager
    processor_time = std::make_unique<PdhCPUCounter>("\\Process(Monitor)\\% Processor Time");
    // Here we're reported about 0.35 +/- 0.05
    double cpu_utilization = processor_time->getCPUUtilization();

NtQuerySystemInformation(SystemProcessInformation, processInfo, processInfoSize, NULL);

    typedef struct _SYSTEM_PROCESS_INFO
    {
        ULONG                   NextEntryOffset;
        ULONG                   NumberOfThreads;
        LARGE_INTEGER           Reserved[3];
        LARGE_INTEGER           CreateTime;
        LARGE_INTEGER           UserTime;
        LARGE_INTEGER           KernelTime;
        UNICODE_STRING          ImageName;
        ULONG                   BasePriority;
        HANDLE                  ProcessId;
        HANDLE                  InheritedFromProcessId;
    }SYSTEM_PROCESS_INFO,*PSYSTEM_PROCESS_INFO;

// cpu_counter.c

GetNativeSystemInfo(&systemInfo);
processorsAvailable = systemInfo.dwNumberOfProcessors;

NtQuerySystemInformation(SystemProcessInformation, processInformation, 1024 * 1024, NULL);

// ...

FILETIME currentMoment;
ZeroMemory(&currentMoment, sizeof(FILETIME));
GetSystemTimeAsFileTime(&currentMoment);
LONGLONG currentFiletime64 = (LONGLONG)(currentMoment.dwHighDateTime) << 32 | currentMoment.dwLowDateTime;

double totalTime = (double)(processInformation->KernelTime.QuadPart + processInformation->UserTime.QuadPart);
double passedTime = (double)(currentFiletime64 - processInformation->CreateTime.QuadPart);
double testPayload = totalTime / passedTime / processorsAvailable;
printf("TotalTime=%.6f; PassedTime=%.6f; Payload=%.6f\n", totalTime, passedTime, testPayload);