(Nov 27, 2014 03:19 AM)S1L3NZ Wrote:  Hi,

This is my code:

Code

#include "pdh.h"

static PDH_HQUERY cpuQuery;
static PDH_HCOUNTER cpuTotal;

void init() {
    PdhOpenQuery(NULL, NULL, &cpuQuery);
    PdhAddCounter(cpuQuery, (LPCSTR)"\\Processor(_Total)\\% Processor Time", NULL, &cpuTotal);
    PdhCollectQueryData(cpuQuery);
}

long getCurrentValue() {
    PDH_FMT_COUNTERVALUE counterVal;

    PdhCollectQueryData(cpuQuery);
    PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_LONG, NULL, &counterVal);
    return counterVal.longValue;
}

Cheers 🤝

(Nov 30, 2014 02:46 PM)Førtune Wrote:  Try this:

Code

#include <Windows.h>

static float CalculateCPULoad(unsigned long long idleTicks, unsigned long long totalTicks)
{
   static unsigned long long _previousTotalTicks = 0;
   static unsigned long long _previousIdleTicks = 0;

   unsigned long long totalTicksSinceLastTime = totalTicks-_previousTotalTicks;
   unsigned long long idleTicksSinceLastTime  = idleTicks-_previousIdleTicks;

   float ret = 1.0f-((totalTicksSinceLastTime > 0) ? ((float)idleTicksSinceLastTime)/totalTicksSinceLastTime : 0);

   _previousTotalTicks = totalTicks;
   _previousIdleTicks  = idleTicks;
   return ret;
}

static unsigned long long FileTimeToInt64(const FILETIME & ft) {return (((unsigned long long)(ft.dwHighDateTime))<<32)|((unsigned long long)ft.dwLowDateTime);}

float GetCPULoad()
{
   FILETIME idleTime, kernelTime, userTime;
   return GetSystemTimes(&idleTime, &kernelTime, &userTime) ? CalculateCPULoad(FileTimeToInt64(idleTime), FileTimeToInt64(kernelTime)+FileTimeToInt64(userTime)) : -1.0f;
}

____
I am not sure if thats is what you're looking for so here is the second choice (you can edit the source) 😁____

CpuUsage.h:

Code

#pragma once
#include <windows.h>

class CpuUsage{
    public:
        CpuUsage(void);
        short  GetUsage();
        private:
            ULONGLONG SubtractTimes(const FILETIME& ftA, const FILETIME& ftB);
            bool EnoughTimePassed();
            inline bool IsFirstRun() const { return (m_dwLastRun == 0); }
            FILETIME m_ftPrevSysKernel;
            FILETIME m_ftPrevSysUser;
            FILETIME m_ftPrevProcKernel;
            FILETIME m_ftPrevProcUser;
            short m_nCpuUsage;
            ULONGLONG m_dwLastRun;
            volatile LONG m_lRunCount;
};

Now the main cpp file:

Code

#include "StdAfx.h"
#include <windows.h>
#include "CpuUsage.h"

CpuUsage::CpuUsage(void)
:m_nCpuUsage(-1)
, m_dwLastRun(0)
, m_lRunCount(0){

    ZeroMemory(&m_ftPrevSysKernel, sizeof(FILETIME));
    ZeroMemory(&m_ftPrevSysUser, sizeof(FILETIME));
    ZeroMemory(&m_ftPrevProcKernel, sizeof(FILETIME));
    ZeroMemory(&m_ftPrevProcUser, sizeof(FILETIME));
}

short CpuUsage::GetUsage(){
    short nCpuCopy = m_nCpuUsage;
    if (::InterlockedIncrement(&m_lRunCount) == 1){
        if (!EnoughTimePassed()){

            ::InterlockedDecrement(&m_lRunCount);
            return nCpuCopy;

        }

    FILETIME ftSysIdle, ftSysKernel, ftSysUser;
    FILETIME ftProcCreation, ftProcExit, ftProcKernel, ftProcUser;

    if (!GetSystemTimes(&ftSysIdle, &ftSysKernel, &ftSysUser) ||
            !GetProcessTimes(GetCurrentProcess(), &ftProcCreation,
            &ftProcExit, &ftProcKernel, &ftProcUser)){

        ::InterlockedDecrement(&m_lRunCount);
         return nCpuCopy;
        }

    if (!IsFirstRun()){
        ULONGLONG ftSysKernelDiff =
        SubtractTimes(ftSysKernel, m_ftPrevSysKernel);
        ULONGLONG ftSysUserDiff = SubtractTimes(ftSysUser, m_ftPrevSysUser);
        ULONGLONG ftProcKernelDiff = SubtractTimes(ftProcKernel, m_ftPrevProcKernel);
        ULONGLONG ftProcUserDiff = SubtractTimes(ftProcUser, m_ftPrevProcUser);
        ULONGLONG nTotalSys = ftSysKernelDiff + ftSysUserDiff;
        ULONGLONG nTotalProc = ftProcKernelDiff + ftProcUserDiff;
        if (nTotalSys > 0){

            m_nCpuUsage = (short)((100.0 * nTotalProc) / nTotalSys);

            }

        }

    m_ftPrevSysKernel = ftSysKernel;
    m_ftPrevSysUser = ftSysUser;
    m_ftPrevProcKernel = ftProcKernel;
    m_ftPrevProcUser = ftProcUser;
    m_dwLastRun = GetTickCount64();
    nCpuCopy = m_nCpuUsage;

    }
    ::InterlockedDecrement(&m_lRunCount);
    return nCpuCopy;
}

ULONGLONG CpuUsage::SubtractTimes(const FILETIME& ftA, const FILETIME& ftB){

    LARGE_INTEGER a, b;
    a.LowPart = ftA.dwLowDateTime;
    a.HighPart = ftA.dwHighDateTime;
    b.LowPart = ftB.dwLowDateTime;
    b.HighPart = ftB.dwHighDateTime;
    return a.QuadPart - b.QuadPart;
}

bool CpuUsage::EnoughTimePassed(){
    const int minElapsedMS = 250;//milliseconds
    ULONGLONG dwCurrentTickCount = GetTickCount64();
    return (dwCurrentTickCount - m_dwLastRun) > minElapsedMS;
}

DWORD WINAPI EatItThreadProc(LPVOID lpParam);
DWORD WINAPI WatchItThreadProc(LPVOID lpParam);
CpuUsage usage;
int _tmain(int argc, _TCHAR* argv[]){

    CreateThread(NULL, 0, EatItThreadProc, NULL, 0, NULL);
    CreateThread(NULL, 0, EatItThreadProc, NULL, 0, NULL);
    CreateThread(NULL, 0, WatchItThreadProc, NULL, 0, NULL);
    CreateThread(NULL, 0, WatchItThreadProc, NULL, 0, NULL);
    while (true){

        Sleep(1000);

    }
        return 0;
}

DWORD WINAPI WatchItThreadProc(LPVOID lpParam){
    while (true){
        short cpuUsage = usage.GetUsage();
        printf("Thread id %d: %d%% cpu usage\n", ::GetCurrentThreadId(), cpuUsage);
        Sleep(1000);
        }
}
DWORD WINAPI EatItThreadProc(LPVOID lpParam){

    ULONGLONG accum = 0;
    while (true){

        accum++;
        }
        printf("%64d\n", accum);
}

Give these a shot and tell me what you think 🙂

(Dec 1, 2014 01:32 PM)Rodaxoleaux Wrote:  And not a single thing was learned that day.

(Dec 1, 2014 01:32 PM)Rodaxoleaux Wrote:  And not a single thing was learned that day.

(Dec 1, 2014 02:10 PM)_Stoner Wrote:  You seem to be unaware of the fact that not everybody goes to school to learn, but rather to collect the tools they need in order to do what they want.

The same applies to this forum, and the rest of the entire internet.

Now you have learned something Rodaxoleaux.

EDIT: It's also worth mentioning that different people have different learning methods. Some learn by example and I would say most people learn coding by example.