Edit - Stack Overflow

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Rev

Required fields*

How to determine CPU and memory consumption from inside a process

I once had the task of determining the following performance parameters from inside a running application:

Total virtual memory available
Virtual memory currently used
Virtual memory currently used by my process
Total RAM available
RAM currently used
RAM currently used by my process
% CPU currently used
% CPU currently used by my process

The code had to run on Windows and Linux. Even though this seems to be a standard task, finding the necessary information in the manuals (WIN32 API, GNU docs) as well as on the Internet took me several days, because there's so much incomplete/incorrect/outdated information on this topic to be found out there.

In order to save others from going through the same trouble, I thought it would be a good idea to collect all the scattered information plus what I found by trial and error here in one place.

Answer*

**In Windows you can get CPU usage by the code below:**

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

//------------------------------------------------------------------------------------------------------------------
    // Prototype(s)...
    //------------------------------------------------------------------------------------------------------------------
    CHAR cpuusage(void);

//-----------------------------------------------------
    typedef BOOL ( __stdcall * pfnGetSystemTimes)( LPFILETIME lpIdleTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
    static pfnGetSystemTimes s_pfnGetSystemTimes = NULL;

static HMODULE s_hKernel = NULL;
    //-----------------------------------------------------
    void GetSystemTimesAddress()
    {
        if(s_hKernel == NULL)
        {
            s_hKernel = LoadLibrary(L"Kernel32.dll");
            if(s_hKernel != NULL)
            {
                s_pfnGetSystemTimes = (pfnGetSystemTimes)GetProcAddress(s_hKernel, "GetSystemTimes");
                if(s_pfnGetSystemTimes == NULL)
                {
                    FreeLibrary(s_hKernel);
                    s_hKernel = NULL;
                }
            }
        }
    }
    //----------------------------------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------------------------------
    // cpuusage(void)
    // ==============
    // Return a CHAR value in the range 0 - 100 representing actual CPU usage in percent.
    //----------------------------------------------------------------------------------------------------------------
    CHAR cpuusage()
    {
        FILETIME               ft_sys_idle;
        FILETIME               ft_sys_kernel;
        FILETIME               ft_sys_user;

ULARGE_INTEGER         ul_sys_idle;
        ULARGE_INTEGER         ul_sys_kernel;
        ULARGE_INTEGER         ul_sys_user;

static ULARGE_INTEGER     ul_sys_idle_old;
        static ULARGE_INTEGER  ul_sys_kernel_old;
        static ULARGE_INTEGER  ul_sys_user_old;

CHAR usage = 0;

// We cannot directly use GetSystemTimes in the C language
        /* Add this line :: pfnGetSystemTimes */
        s_pfnGetSystemTimes(&ft_sys_idle,    /* System idle time */
            &ft_sys_kernel,  /* system kernel time */
            &ft_sys_user);   /* System user time */

CopyMemory(&ul_sys_idle  , &ft_sys_idle  , sizeof(FILETIME)); // Could been optimized away...
        CopyMemory(&ul_sys_kernel, &ft_sys_kernel, sizeof(FILETIME)); // Could been optimized away...
        CopyMemory(&ul_sys_user  , &ft_sys_user  , sizeof(FILETIME)); // Could been optimized away...

usage  =
            (
            (
            (
            (
            (ul_sys_kernel.QuadPart - ul_sys_kernel_old.QuadPart)+
            (ul_sys_user.QuadPart   - ul_sys_user_old.QuadPart)
            )
            -
            (ul_sys_idle.QuadPart-ul_sys_idle_old.QuadPart)
            )
            *
            (100)
            )
            /
            (
            (ul_sys_kernel.QuadPart - ul_sys_kernel_old.QuadPart)+
            (ul_sys_user.QuadPart   - ul_sys_user_old.QuadPart)
            )
            );

ul_sys_idle_old.QuadPart   = ul_sys_idle.QuadPart;
        ul_sys_user_old.QuadPart   = ul_sys_user.QuadPart;
        ul_sys_kernel_old.QuadPart = ul_sys_kernel.QuadPart;

return usage;
    }

//------------------------------------------------------------------------------------------------------------------
    // Entry point
    //------------------------------------------------------------------------------------------------------------------
    int main(void)
    {
        int n;
        GetSystemTimesAddress();
        for(n=0; n<20; n++)
        {
            printf("CPU Usage: %3d%%\r", cpuusage());
            Sleep(2000);
        }
        printf("\n");
        return 0;
    }

Edit Summary*

Cancel

can this be modified for an external DLL function I can later call in c#?
– Nico
Commented Dec 2, 2015 at 12:55
28

The formatting of usage = is the most creative thing i have seen in a while, not readable at all but creative
– ViRuSTriNiTy
Commented May 26, 2016 at 14:45
2

Warning: the expression in the code above that calculates 'usage' is way off. If the system was idle, it would divide by zero. In case the idle time was equal to the user+kernel time, it would produce 0 rather than 50% as one would expect.
– Andrei Belogortseff
Commented Dec 31, 2016 at 17:46
2

Also keep in mind that according to the current MSDN, kernel time also includes the idle time!
– Andrei Belogortseff
Commented Dec 31, 2016 at 19:38
1

@sayyedmohsenzahraee: I haven't looked into the logic of it, just a comment on the code itself. 1) Use plain 64-bit variables instead of a union, i.e. ULONGLONG for VS instead of ULARGE_INTEGER. 2) You're overcomplicating things by calling CopyMemory(), just do ULONGLONG ul_sys_idle = *(ULONGLONG*)&ft_sys_idle; instead. It will be translated into a single CPU mov (or lea) instruction.
– ahmd0
Commented Dec 9, 2017 at 1:44

Add a comment |

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>

formatting help »
answering help »

Collectives™ on Stack Overflow

How to determine CPU and memory consumption from inside a process

Answer*