我曾经有一个任务，从一个运行中的应用程序内部确定以下性能参数:
可用虚拟内存总数 当前使用的虚拟内存 进程当前使用的虚拟内存 可用总RAM 目前使用的RAM 内存目前被我的进程使用 当前CPU使用百分比 %进程当前使用的CPU
这些代码必须在Windows和Linux上运行。尽管这似乎是一个标准的任务，但在手册(WIN32 API, GNU文档)和互联网上找到必要的信息花了我好几天，因为在那里有太多关于这个主题的不完整/不正确/过时的信息。
为了避免别人经历同样的麻烦，我想把所有分散的信息加上我在这里反复试验发现的信息收集在一个地方会是一个好主意。
当前回答
在Windows中，你可以通过下面的代码获取CPU使用情况:
#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;
}
其他回答
在Linux上，你不能/不应该通过SysInfo的freeram或在totalram上做一些算术来获得“总的可用物理内存”。
推荐的方法是读取proc/meminfo，引用kernel/git/torvalds/linux。Git， /proc/meminfo提供估计可用内存:
许多负载平衡和工作负载放置程序检查/proc/meminfo到 估计有多少可用的空闲内存。他们通常这样做 把"免费"和"缓存"加起来，十年前还好，但现在 今天肯定是错的。
在/proc/meminfo中提供这样的估计更方便。如果将来事情发生改变，我们只需要在一个地方改变它。
一种方法是亚当·罗森菲尔德(Adam Rosenfield)对“如何确定c++中Linux系统RAM的数量?”建议:读取文件，并使用fscanf抓取行(但不是去MemTotal，去MemAvailable)
同样，如果你想要得到使用的物理内存总量，这取决于你对“使用”的定义，你可能不想从totalram中减去freeram，而是从memtotal中减去memavailable来得到top或htop告诉你的东西。
在Windows中，你可以通过下面的代码获取CPU使用情况:
#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;
}
Mac OS X
总虚拟内存
这在Mac OS X上很棘手，因为它不像Linux那样使用预设的交换分区或文件。以下是苹果公司文档中的一段:
注意:与大多数基于unix的操作系统不同，Mac OS X不为虚拟内存使用预先分配的交换分区。相反，它会使用机器引导分区上的所有可用空间。
因此，如果想知道还有多少虚拟内存可用，就需要知道根分区的大小。你可以这样做:
struct statfs stats;
if (0 == statfs("/", &stats))
{
myFreeSwap = (uint64_t)stats.f_bsize * stats.f_bfree;
}
当前使用的虚拟总数
使用“vm. conf”调用systcl。Swapusage "键提供有关交换使用的有趣信息:
sysctl -n vm.swapusage
vm.swapusage: total = 3072.00M used = 2511.78M free = 560.22M (encrypted)
如果如上一节所述需要更多的交换空间，这里显示的总交换空间使用情况不会发生变化。总的就是当前掉期的总和。在c++中，可以这样查询这些数据:
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\",...)" );
}
请注意，在sysctl.h中声明的“xsw_usage”似乎没有文档，我怀疑有一种更可移植的方式来访问这些值。
进程当前使用的虚拟内存
可以使用task_info函数获取当前进程的统计信息。这包括进程的当前驻留大小和当前虚拟大小。
#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;
可用总RAM
使用sysctl系统函数，系统中可用的物理RAM数量如下所示:
#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
可以从host_statistics系统函数获得一般内存统计信息。
#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;
}
这里需要注意的是，在Mac OS x中有五种类型的内存页，它们如下所示:
Wired pages that are locked in place and cannot be swapped out Active pages that are loading into physical memory and would be relatively difficult to swap out 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. 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 Free pages that are completely free and ready to be used.
值得注意的是，仅仅因为Mac OS X可能会显示很少的实际空闲内存，这可能不是一个很好的指示有多少准备在短时间内使用。
内存当前被我的进程使用
请参阅上面的“进程当前使用的虚拟内存”。同样的代码也适用。
Linux
在Linux中，该信息在/proc文件系统中可用。我不太喜欢使用文本文件格式，因为每个Linux发行版似乎都自定义了至少一个重要文件。快速看一下'ps'的来源，就会发现混乱。
但你可以在这里找到你想要的信息:
/proc/meminfo包含您要查找的大部分系统范围的信息。在我的系统中是这样的;我想你对MemTotal, MemFree, SwapTotal和SwapFree感兴趣:
Anderson cxc # more /proc/meminfo
MemTotal: 4083948 kB
MemFree: 2198520 kB
Buffers: 82080 kB
Cached: 1141460 kB
SwapCached: 0 kB
Active: 1137960 kB
Inactive: 608588 kB
HighTotal: 3276672 kB
HighFree: 1607744 kB
LowTotal: 807276 kB
LowFree: 590776 kB
SwapTotal: 2096440 kB
SwapFree: 2096440 kB
Dirty: 32 kB
Writeback: 0 kB
AnonPages: 523252 kB
Mapped: 93560 kB
Slab: 52880 kB
SReclaimable: 24652 kB
SUnreclaim: 28228 kB
PageTables: 2284 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
CommitLimit: 4138412 kB
Committed_AS: 1845072 kB
VmallocTotal: 118776 kB
VmallocUsed: 3964 kB
VmallocChunk: 112860 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
Hugepagesize: 2048 kB
对于CPU利用率，您必须做一些工作。Linux提供了自系统启动以来的整体CPU利用率;这可能不是你感兴趣的。如果您想知道前一秒或前10秒的CPU利用率是多少，那么您需要查询信息并自己计算。
这些信息可以在/proc/stat中找到，在http://www.linuxhowtos.org/System/procstat.htm上有很好的文档;下面是它在我的4核盒子上的样子:
Anderson cxc # more /proc/stat
cpu 2329889 0 2364567 1063530460 9034 9463 96111 0
cpu0 572526 0 636532 265864398 2928 1621 6899 0
cpu1 590441 0 531079 265949732 4763 351 8522 0
cpu2 562983 0 645163 265796890 682 7490 71650 0
cpu3 603938 0 551790 265919440 660 0 9040 0
intr 37124247
ctxt 50795173133
btime 1218807985
processes 116889
procs_running 1
procs_blocked 0
首先，您需要确定系统中有多少cpu(或处理器或处理核)可用。为此，计算'cpuN'条目的数量，其中N从0开始，然后递增。不要计算“cpu”行，它是cpuN行的组合。在我的示例中，您可以看到cpu0到cpu3，总共有4个处理器。从现在开始，可以忽略cpu0..Cpu3，并且只关注“cpu”行。
接下来，您需要知道这些行中的第四个数字是空闲时间的度量，因此“cpu”行中的第四个数字是自启动时以来所有处理器的总空闲时间。这个时间以Linux“jiffies”来衡量，每个jiffies是1/100秒。
但你不关心总空闲时间;您关心的是给定时间段内的空闲时间，例如，最后一秒。请计算一下，您需要读取该文件两次，间隔1秒。然后你可以对这条线的第四个值做diff。例如，如果你取一个样本，得到:
cpu 2330047 0 2365006 1063853632 9035 9463 96114 0
一秒钟后，你会得到这个样本:
cpu 2330047 0 2365007 1063854028 9035 9463 96114 0
减去这两个数字，就会得到一个差值396，这意味着在过去的1.00秒中，CPU已经空闲了3.96秒。当然，诀窍在于需要除以处理器的数量。3.96 / 4 = 0.99，有你的空闲百分比;99%空闲，1%忙碌。
在我的代码中，我有一个包含360个条目的循环缓冲区，并且我每秒钟都会读取这个文件。这让我可以快速计算1秒、10秒等，一直到1小时的CPU利用率。
对于进程特定的信息，你必须在/proc/pid;如果你不关心pid，你可以在/proc/self
进程使用的CPU在/proc/self/stat中可用。这是一个由单行组成的奇怪的文件;例如:
19340 (whatever) S 19115 19115 3084 34816 19115 4202752 118200 607 0 0 770 384 2
7 20 0 77 0 266764385 692477952 105074 4294967295 134512640 146462952 321468364
8 3214683328 4294960144 0 2147221247 268439552 1276 4294967295 0 0 17 0 0 0 0
这里的重要数据是第13和第14个令牌(这里是0和770)。第13个令牌是进程在用户模式下执行的jiffies的数量，第14个令牌是进程在内核模式下执行的jiffies的数量。将两者加在一起，就得到了它的总CPU利用率。
同样，您必须定期对该文件进行采样，并计算差异，以便确定进程在一段时间内的CPU使用情况。
编辑:请记住，当您计算进程的CPU利用率时，您必须考虑1)进程中的线程数，2)系统中的处理器数。例如，如果您的单线程进程只使用25%的CPU，这可能是好也可能是坏。在单处理器系统上很好，但在四处理器系统上很差;这意味着您的进程一直在运行，并且使用了100%的可用CPU周期。
对于进程特定的内存信息，你必须查看/proc/self/status，它看起来像这样:
Name: whatever
State: S (sleeping)
Tgid: 19340
Pid: 19340
PPid: 19115
TracerPid: 0
Uid: 0 0 0 0
Gid: 0 0 0 0
FDSize: 256
Groups: 0 1 2 3 4 6 10 11 20 26 27
VmPeak: 676252 kB
VmSize: 651352 kB
VmLck: 0 kB
VmHWM: 420300 kB
VmRSS: 420296 kB
VmData: 581028 kB
VmStk: 112 kB
VmExe: 11672 kB
VmLib: 76608 kB
VmPTE: 1244 kB
Threads: 77
SigQ: 0/36864
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: fffffffe7ffbfeff
SigIgn: 0000000010001000
SigCgt: 20000001800004fc
CapInh: 0000000000000000
CapPrm: 00000000ffffffff
CapEff: 00000000fffffeff
Cpus_allowed: 0f
Mems_allowed: 1
voluntary_ctxt_switches: 6518
nonvoluntary_ctxt_switches: 6598
以“Vm”开头的条目很有趣:
VmPeak is the maximum virtual memory space used by the process, in kB (1024 bytes). VmSize is the current virtual memory space used by the process, in kB. In my example, it's pretty large: 651,352 kB, or about 636 megabytes. VmRss is the amount of memory that have been mapped into the process' address space, or its resident set size. This is substantially smaller (420,296 kB, or about 410 megabytes). The difference: my program has mapped 636 MB via mmap(), but has only accessed 410 MB of it, and thus only 410 MB of pages have been assigned to it.
我唯一不确定的项目是进程当前使用的Swapspace。我不知道这里是否有空位。
窗户
上面的一些值可以很容易地从适当的Win32 API中获得，为了完整起见，我只是在这里列出它们。但是，其他的需要从Performance Data Helper库(PDH)中获得，这有点“不直观”，并且需要大量痛苦的试验和错误才能开始工作。(至少我花了不少时间，也许我只是有点笨…)
注意:为了清晰起见，以下代码省略了所有错误检查。检查返回码…!
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
在Linux上，一开始似乎显而易见的选择是使用getrusage()等POSIX api。我花了一些时间试图让它工作，但从未得到有意义的值。当我最终检查内核源代码本身时，我发现显然这些api在Linux内核2.6中还没有完全实现!?
最后，通过读取伪文件系统/进程和内核调用，我得到了所有的值。
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; }
待办事项:其他平台
我假设，除了读取/proc伪文件系统的部分之外，一些Linux代码也适用于unix。也许在Unix上，这些部分可以用getrusage()和类似的函数代替?
