How to determine CPU and memory consumption from inside a process

Question

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 1

Windows

Some of the above values are easily available from the appropriate Win32 API, I just list them here for completeness. Others, however, need to be obtained from the Performance Data Helper library (PDH), which is a bit "unintuitive" and takes a lot of painful trial and error to get to work. (At least it took me quite a while, perhaps I've been only a bit stupid...)

Note: for clarity all error checking has been omitted from the following code. Do check the return codes...!

• Total Virtual Memory:

  #include "windows.h"  MEMORYSTATUSEX memInfo; memInfo.dwLength = sizeof(MEMORYSTATUSEX); GlobalMemoryStatusEx(&memInfo); DWORDLONG totalVirtualMem = memInfo.ullTotalPageFile; 

  Note: The name "TotalPageFile" is a bit misleading here. In reality this parameter gives the "Virtual Memory Size", which is size of swap file plus installed RAM.

• Virtual Memory currently used:

  Same code as in "Total Virtual Memory" and then

   DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile; 

• Virtual Memory currently used by current process:

  #include "windows.h" #include "psapi.h"  PROCESS_MEMORY_COUNTERS_EX pmc; GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc)); SIZE_T virtualMemUsedByMe = pmc.PrivateUsage; 

• Total Physical Memory (RAM):

  Same code as in "Total Virtual Memory" and then

  DWORDLONG totalPhysMem = memInfo.ullTotalPhys; 

• Physical Memory currently used:

  Same code as in "Total Virtual Memory" and then

  DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys; 

• Physical Memory currently used by current process:

  Same code as in "Virtual Memory currently used by current process" and then

  SIZE_T physMemUsedByMe = pmc.WorkingSetSize; 

• CPU currently used:

  #include "TCHAR.h" #include "pdh.h"  static PDH_HQUERY cpuQuery; static PDH_HCOUNTER cpuTotal;  void init(){     PdhOpenQuery(NULL, NULL, &cpuQuery);     // You can also use L"\\Processor(*)\\% Processor Time" and get individual CPU values with PdhGetFormattedCounterArray()     PdhAddEnglishCounter(cpuQuery, L"\\Processor(_Total)\\% Processor Time", NULL, &cpuTotal);     PdhCollectQueryData(cpuQuery); }  double getCurrentValue(){     PDH_FMT_COUNTERVALUE counterVal;      PdhCollectQueryData(cpuQuery);     PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_DOUBLE, NULL, &counterVal);     return counterVal.doubleValue; } 

• CPU currently used by current process:

  #include "windows.h"  static ULARGE_INTEGER lastCPU, lastSysCPU, lastUserCPU; static int numProcessors; static HANDLE self;  void init(){     SYSTEM_INFO sysInfo;     FILETIME ftime, fsys, fuser;      GetSystemInfo(&sysInfo);     numProcessors = sysInfo.dwNumberOfProcessors;      GetSystemTimeAsFileTime(&ftime);     memcpy(&lastCPU, &ftime, sizeof(FILETIME));      self = GetCurrentProcess();     GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);     memcpy(&lastSysCPU, &fsys, sizeof(FILETIME));     memcpy(&lastUserCPU, &fuser, sizeof(FILETIME)); }  double getCurrentValue(){     FILETIME ftime, fsys, fuser;     ULARGE_INTEGER now, sys, user;     double percent;      GetSystemTimeAsFileTime(&ftime);     memcpy(&now, &ftime, sizeof(FILETIME));      GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);     memcpy(&sys, &fsys, sizeof(FILETIME));     memcpy(&user, &fuser, sizeof(FILETIME));     percent = (sys.QuadPart - lastSysCPU.QuadPart) +         (user.QuadPart - lastUserCPU.QuadPart);     percent /= (now.QuadPart - lastCPU.QuadPart);     percent /= numProcessors;     lastCPU = now;     lastUserCPU = user;     lastSysCPU = sys;      return percent * 100; } 

---

Linux

On Linux the choice that seemed obvious at first was to use the POSIX APIs like getrusage() etc. I spent some time trying to get this to work, but never got meaningful values. When I finally checked the kernel sources themselves, I found out that apparently these APIs are not yet completely implemented as of Linux kernel 2.6!?

In the end I got all values via a combination of reading the pseudo-filesystem /proc and kernel calls.

• Total Virtual Memory:

  #include "sys/types.h" #include "sys/sysinfo.h"  struct sysinfo memInfo;  sysinfo (&memInfo); long long totalVirtualMem = memInfo.totalram; //Add other values in next statement to avoid int overflow on right hand side... totalVirtualMem += memInfo.totalswap; totalVirtualMem *= memInfo.mem_unit; 

• Virtual Memory currently used:

  Same code as in "Total Virtual Memory" and then

  long long virtualMemUsed = memInfo.totalram - memInfo.freeram; //Add other values in next statement to avoid int overflow on right hand side... virtualMemUsed += memInfo.totalswap - memInfo.freeswap; virtualMemUsed *= memInfo.mem_unit; 

• Virtual Memory currently used by current process:

  #include "stdlib.h" #include "stdio.h" #include "string.h"  int parseLine(char* line){     // This assumes that a digit will be found and the line ends in " Kb".     int i = strlen(line);     const char* p = line;     while (*p <'0' || *p > '9') p++;     line[i-3] = '\0';     i = atoi(p);     return i; }  int getValue(){ //Note: this value is in KB!     FILE* file = fopen("/proc/self/status", "r");     int result = -1;     char line[128];      while (fgets(line, 128, file) != NULL){         if (strncmp(line, "VmSize:", 7) == 0){             result = parseLine(line);             break;         }     }     fclose(file);     return result; } 

• Total Physical Memory (RAM):

  Same code as in "Total Virtual Memory" and then

  long long totalPhysMem = memInfo.totalram; //Multiply in next statement to avoid int overflow on right hand side... totalPhysMem *= memInfo.mem_unit; 

• Physical Memory currently used:

  Same code as in "Total Virtual Memory" and then

  long long physMemUsed = memInfo.totalram - memInfo.freeram; //Multiply in next statement to avoid int overflow on right hand side... physMemUsed *= memInfo.mem_unit; 

• Physical Memory currently used by current process:

  Change getValue() in "Virtual Memory currently used by current process" as follows:

  int getValue(){ //Note: this value is in KB!     FILE* file = fopen("/proc/self/status", "r");     int result = -1;     char line[128];      while (fgets(line, 128, file) != NULL){         if (strncmp(line, "VmRSS:", 6) == 0){             result = parseLine(line);             break;         }     }     fclose(file);     return result; } 

• CPU currently used:

  #include "stdlib.h" #include "stdio.h" #include "string.h"  static unsigned long long lastTotalUser, lastTotalUserLow, lastTotalSys, lastTotalIdle;  void init(){     FILE* file = fopen("/proc/stat", "r");     fscanf(file, "cpu %llu %llu %llu %llu", &lastTotalUser, &lastTotalUserLow,         &lastTotalSys, &lastTotalIdle);     fclose(file); }  double getCurrentValue(){     double percent;     FILE* file;     unsigned long long totalUser, totalUserLow, totalSys, totalIdle, total;      file = fopen("/proc/stat", "r");     fscanf(file, "cpu %llu %llu %llu %llu", &totalUser, &totalUserLow,         &totalSys, &totalIdle);     fclose(file);      if (totalUser < lastTotalUser || totalUserLow < lastTotalUserLow ||         totalSys < lastTotalSys || totalIdle < lastTotalIdle){         //Overflow detection. Just skip this value.         percent = -1.0;     }     else{         total = (totalUser - lastTotalUser) + (totalUserLow - lastTotalUserLow) +             (totalSys - lastTotalSys);         percent = total;         total += (totalIdle - lastTotalIdle);         percent /= total;         percent *= 100;     }      lastTotalUser = totalUser;     lastTotalUserLow = totalUserLow;     lastTotalSys = totalSys;     lastTotalIdle = totalIdle;      return percent; } 

• CPU currently used by current process:

  #include "stdlib.h" #include "stdio.h" #include "string.h" #include "sys/times.h" #include "sys/vtimes.h"  static clock_t lastCPU, lastSysCPU, lastUserCPU; static int numProcessors;  void init(){     FILE* file;     struct tms timeSample;     char line[128];      lastCPU = times(&timeSample);     lastSysCPU = timeSample.tms_stime;     lastUserCPU = timeSample.tms_utime;      file = fopen("/proc/cpuinfo", "r");     numProcessors = 0;     while(fgets(line, 128, file) != NULL){         if (strncmp(line, "processor", 9) == 0) numProcessors++;     }     fclose(file); }  double getCurrentValue(){     struct tms timeSample;     clock_t now;     double percent;      now = times(&timeSample);     if (now <= lastCPU || timeSample.tms_stime < lastSysCPU ||         timeSample.tms_utime < lastUserCPU){         //Overflow detection. Just skip this value.         percent = -1.0;     }     else{         percent = (timeSample.tms_stime - lastSysCPU) +             (timeSample.tms_utime - lastUserCPU);         percent /= (now - lastCPU);         percent /= numProcessors;         percent *= 100;     }     lastCPU = now;     lastSysCPU = timeSample.tms_stime;     lastUserCPU = timeSample.tms_utime;      return percent; } 

---

TODO: Other Platforms

I would assume, that some of the Linux code also works for the Unixes, except for the parts that read the /proc pseudo-filesystem. Perhaps on Unix these parts can be replaced by getrusage() and similar functions?

Answer 2

Mac OS X

Total Virtual Memory

This one is tricky on Mac OS X because it doesn't use a preset swap partition or file like Linux. Here's an entry from Apple's documentation:

Note: Unlike most Unix-based operating systems, Mac OS X does not use a preallocated swap partition for virtual memory. Instead, it uses all of the available space on the machine’s boot partition.

So, if you want to know how much virtual memory is still available, you need to get the size of the root partition. You can do that like this:

struct statfs stats; if (0 == statfs("/", &stats)) {     myFreeSwap = (uint64_t)stats.f_bsize * stats.f_bfree; } 

Total Virtual Currently Used

Calling systcl with the "vm.swapusage" key provides interesting information about swap usage:

sysctl -n vm.swapusage vm.swapusage: total = 3072.00M  used = 2511.78M  free = 560.22M  (encrypted) 

Not that the total swap usage displayed here can change if more swap is needed as explained in the section above. So the total is actually the current swap total. In C++, this data can be queried this way:

xsw_usage vmusage = {0}; size_t size = sizeof(vmusage); if( sysctlbyname("vm.swapusage", &vmusage, &size, NULL, 0)!=0 ) {    perror( "unable to get swap usage by calling sysctlbyname(\"vm.swapusage\",...)" ); } 

Note that the "xsw_usage", declared in sysctl.h, seems not documented and I suspect there there is a more portable way of accessing these values.

Virtual Memory Currently Used by my Process

You can get statistics about your current process using the task_info function. That includes the current resident size of your process and the current virtual size.

#include<mach/mach.h>  struct task_basic_info t_info; mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;  if (KERN_SUCCESS != task_info(mach_task_self(),                               TASK_BASIC_INFO, (task_info_t)&t_info,                               &t_info_count)) {     return -1; } // resident size is in t_info.resident_size; // virtual size is in t_info.virtual_size; 

Total RAM available

The amount of physical RAM available in your system is available using the sysctl system function like this:

#include <sys/types.h> #include <sys/sysctl.h> ... int mib[2]; int64_t physical_memory; mib[0] = CTL_HW; mib[1] = HW_MEMSIZE; length = sizeof(int64_t); sysctl(mib, 2, &physical_memory, &length, NULL, 0); 

RAM Currently Used

You can get general memory statistics from the host_statistics system function.

#include <mach/vm_statistics.h> #include <mach/mach_types.h> #include <mach/mach_init.h> #include <mach/mach_host.h>  int main(int argc, const char * argv[]) {     vm_size_t page_size;     mach_port_t mach_port;     mach_msg_type_number_t count;     vm_statistics64_data_t vm_stats;      mach_port = mach_host_self();     count = sizeof(vm_stats) / sizeof(natural_t);     if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&         KERN_SUCCESS == host_statistics64(mach_port, HOST_VM_INFO,                                         (host_info64_t)&vm_stats, &count))     {         long long free_memory = (int64_t)vm_stats.free_count * (int64_t)page_size;          long long used_memory = ((int64_t)vm_stats.active_count +                                  (int64_t)vm_stats.inactive_count +                                  (int64_t)vm_stats.wire_count) *  (int64_t)page_size;         printf("free memory: %lld\nused memory: %lld\n", free_memory, used_memory);     }      return 0; } 

One thing to note here are that there are five types of memory pages in Mac OS X. They are as follows:

1. Wired pages that are locked in place and cannot be swapped out
2. Active pages that are loading into physical memory and would be relatively difficult to swap out
3. Inactive pages that are loaded into memory, but haven't been used recently and may not even be needed at all. These are potential candidates for swapping. This memory would probably need to be flushed.
4. Cached pages that have been some how cached that are likely to be easily reused. Cached memory probably would not require flushing. It is still possible for cached pages to be reactivated
5. Free pages that are completely free and ready to be used.

It is good to note that just because Mac OS X may show very little actual free memory at times that it may not be a good indication of how much is ready to be used on short notice.

RAM Currently Used by my Process

See the "Virtual Memory Currently Used by my Process" above. The same code applies.