Tôi đã từng có nhiệm vụ xác định các tham số hiệu suất sau từ bên trong một ứng dụng đang chạy:

• Tổng bộ nhớ ảo khả dụng
• Bộ nhớ ảo hiện đang được sử dụng
• Bộ nhớ ảo hiện đang được sử dụng bởi quá trình của tôi

  ---

• Tổng RAM có sẵn
• RAM hiện đang được sử dụng
• RAM hiện đang được sử dụng bởi quy trình của tôi

  ---

• % CPU hiện đang được sử dụng
• % CPU hiện đang được sử dụng bởi quy trình của tôi

Mã phải chạy trên Windows và Linux. Mặc dù đây có vẻ là một nhiệm vụ tiêu chuẩn, nhưng việc tìm kiếm thông tin cần thiết trong hướng dẫn sử dụng (WIN32 API, tài liệu GNU) cũng như trên Internet đã khiến tôi mất vài ngày, bởi vì có quá nhiều thông tin không đầy đủ / không chính xác / lỗi thời về chủ đề này. tìm ra đó

Để cứu những người khác gặp phải rắc rối tương tự, tôi nghĩ rằng sẽ là một ý tưởng tốt để thu thập tất cả các thông tin phân tán cộng với những gì tôi tìm thấy bằng cách dùng thử và lỗi ở một nơi.

các cửa sổ

Một số giá trị trên có sẵn dễ dàng từ API WIN32 thích hợp, tôi chỉ liệt kê chúng ở đây cho đầy đủ. Tuy nhiên, những người khác cần phải được lấy từ thư viện Trình trợ giúp dữ liệu hiệu suất (PDH), một chút "không trực quan" và phải mất rất nhiều thử nghiệm và lỗi đau đớn để làm việc. (Ít nhất là tôi đã mất khá nhiều thời gian, có lẽ tôi chỉ hơi ngu ngốc một chút ...)

Lưu ý: để rõ ràng, tất cả các kiểm tra lỗi đã được bỏ qua từ đoạn mã sau. Hãy kiểm tra mã trả lại ...!

• Tổng bộ nhớ ảo:

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

  Lưu ý: Tên "TotalPageFile" hơi sai lệch ở đây. Trong thực tế, tham số này cung cấp "Kích thước bộ nhớ ảo", là kích thước của tệp hoán đổi cộng với RAM được cài đặt.

• Bộ nhớ ảo hiện đang được sử dụng:

  Cùng mã như trong "Tổng bộ nhớ ảo" và sau đó

  DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;

• Bộ nhớ ảo hiện đang được sử dụng bởi quy trình hiện tại:

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

• Tổng bộ nhớ vật lý (RAM):

  Cùng mã như trong "Tổng bộ nhớ ảo" và sau đó

  DWORDLONG totalPhysMem = memInfo.ullTotalPhys;

• Bộ nhớ vật lý hiện đang được sử dụng:

  Same code as in "Total Virtual Memory" and then
  
  DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;

• Bộ nhớ vật lý hiện đang được sử dụng bởi quy trình hiện tại:

  Cùng mã như trong "Bộ nhớ ảo hiện đang được sử dụng bởi quy trình hiện tại" và sau đó

  SIZE_T physMemUsedByMe = pmc.WorkingSetSize;

• CPU hiện đang được sử dụng:

  #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 hiện đang được sử dụng bởi quy trình hiện tại:

  #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

Trên Linux, lựa chọn ban đầu có vẻ hiển nhiên là sử dụng API POSIX như getrusage() v.v. Tôi đã dành thời gian cố gắng để làm việc này, nhưng không bao giờ có được các giá trị có ý nghĩa. Cuối cùng khi tôi tự kiểm tra các nguồn kernel, tôi phát hiện ra rằng rõ ràng các API này chưa được triển khai hoàn toàn kể từ kernel Linux 2.6!?

Cuối cùng, tôi đã nhận được tất cả các giá trị thông qua việc kết hợp đọc các /proclệnh gọi hệ thống tập tin giả và kernel.

• Tổng bộ nhớ ảo:

  #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;

• Bộ nhớ ảo hiện đang được sử dụng:

  Cùng mã như trong "Tổng bộ nhớ ảo" và sau đó

  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;

• Bộ nhớ ảo hiện đang được sử dụng bởi quy trình hiện tại:

  #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;
  }

• Tổng bộ nhớ vật lý (RAM):

  Cùng mã như trong "Tổng bộ nhớ ảo" và sau đó

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

• Bộ nhớ vật lý hiện đang được sử dụng:

  Cùng mã như trong "Tổng bộ nhớ ảo" và sau đó

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

• Bộ nhớ vật lý hiện đang được sử dụng bởi quy trình hiện tại:

  Thay đổi getValue () trong "Bộ nhớ ảo hiện đang được sử dụng bởi quy trình hiện tại" như sau:

  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 hiện đang được sử dụng:

  #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 hiện đang được sử dụng bởi quy trình hiện tại:

  #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: Các nền tảng khác

Tôi giả sử rằng một số mã Linux cũng hoạt động cho Unix, ngoại trừ các phần đọc hệ thống tập tin giả / Proc. Có lẽ trên Unix những phần này có thể được thay thế bởi getrusage()và các chức năng tương tự? Nếu ai đó có kiến ​​thức về Unix có thể chỉnh sửa câu trả lời này và điền thông tin chi tiết?!

Mac OS X

Tôi đã hy vọng tìm thấy thông tin tương tự cho Mac OS X. Vì nó không ở đây, tôi ra ngoài và tự đào nó lên. Dưới đây là một số trong những điều tôi tìm thấy. Nếu bất cứ ai có bất kỳ đề nghị nào khác, tôi rất muốn nghe họ.

Tổng bộ nhớ ảo

Điều này là khó khăn trên Mac OS X vì nó không sử dụng phân vùng hoặc tệp trao đổi được cài đặt sẵn như Linux. Đây là một mục từ tài liệu của Apple:

Lưu ý: Không giống như hầu hết các hệ điều hành dựa trên Unix, Mac OS X không sử dụng phân vùng trao đổi preallocated cho bộ nhớ ảo. Thay vào đó, nó sử dụng tất cả không gian có sẵn trên phân vùng khởi động của máy.

Vì vậy, nếu bạn muốn biết bộ nhớ ảo vẫn còn bao nhiêu, bạn cần lấy kích thước của phân vùng gốc. Bạn có thể làm điều đó như thế này:

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

Tổng số ảo hiện đang được sử dụng

Gọi systcl bằng phím "vm.swapusage" cung cấp thông tin thú vị về việc sử dụng trao đổi:

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

Không phải là tổng mức sử dụng trao đổi được hiển thị ở đây có thể thay đổi nếu cần thêm trao đổi như được giải thích trong phần trên. Vì vậy, tổng số thực sự là tổng số trao đổi hiện tại . Trong C ++, dữ liệu này có thể được truy vấn theo cách này:

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\",...)" );
}

Lưu ý rằng "xsw_usage", được khai báo trong sysctl.h, dường như không được ghi lại và tôi nghi ngờ có một cách dễ dàng hơn để truy cập các giá trị này.

Bộ nhớ ảo hiện đang được sử dụng bởi quy trình của tôi

Bạn có thể lấy số liệu thống kê về quy trình hiện tại của mình bằng cách sử dụng task_infochức năng. Điều đó bao gồm kích thước cư trú hiện tại của quy trình của bạn và kích thước ảo hiện tại.

#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;

Tổng RAM có sẵn

Dung lượng RAM vật lý có sẵn trong hệ thống của bạn khả dụng bằng sysctlchức năng hệ thống như thế này:

#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 hiện đang được sử dụng

Bạn có thể lấy số liệu thống kê bộ nhớ chung từ host_statisticschức năng hệ thống.

#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;
}

Một điều cần lưu ý ở đây là có năm loại trang bộ nhớ trong Mac OS X. Chúng như sau:

1. Các trang có dây bị khóa tại chỗ và không thể hoán đổi
2. Các trang hoạt động đang tải vào bộ nhớ vật lý và sẽ tương đối khó để trao đổi
3. Các trang không hoạt động được tải vào bộ nhớ, nhưng gần đây không được sử dụng và thậm chí có thể không cần thiết. Đây là những ứng cử viên tiềm năng cho việc hoán đổi. Bộ nhớ này có lẽ sẽ cần phải được xóa.
4. Các trang được lưu trong bộ nhớ cache đã được lưu trữ lại một cách dễ dàng. Bộ nhớ đệm có lẽ sẽ không cần phải xả. Các trang được lưu trong bộ nhớ cache vẫn có thể được kích hoạt lại
5. Các trang miễn phí hoàn toàn miễn phí và sẵn sàng để sử dụng.

Bạn nên lưu ý rằng chỉ vì Mac OS X có thể hiển thị rất ít bộ nhớ trống thực tế vào những thời điểm mà nó có thể không phải là một dấu hiệu tốt về mức độ sẵn sàng sử dụng trong thông báo ngắn.

RAM hiện được sử dụng bởi quy trình của tôi

Xem "Bộ nhớ ảo hiện đang được sử dụng bởi quy trình của tôi" ở trên. Mã tương tự được áp dụng.

Linux

Trong Linux, thông tin này có sẵn trong hệ thống tệp / Proc. Tôi không phải là một fan hâm mộ lớn của định dạng tệp văn bản được sử dụng, vì mỗi bản phân phối Linux dường như tùy chỉnh ít nhất một tệp quan trọng. Một cái nhìn nhanh chóng khi nguồn đến 'ps' cho thấy sự lộn xộn.

Nhưng đây là nơi để tìm thông tin bạn tìm kiếm:

/ Proc / meminfo chứa phần lớn thông tin trên toàn hệ thống mà bạn tìm kiếm. Ở đây có vẻ như trên hệ thống của tôi; Tôi nghĩ rằng bạn quan tâm đến MemTotal , MemFree , SwapTotal và 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

Để sử dụng CPU, bạn phải làm một công việc nhỏ. Linux cung cấp khả năng sử dụng CPU tổng thể kể từ khi hệ thống khởi động; đây có lẽ không phải là điều bạn quan tâm. Nếu bạn muốn biết việc sử dụng CPU là gì trong giây cuối cùng hoặc 10 giây, thì bạn cần phải truy vấn thông tin và tự tính toán.

Thông tin có sẵn trong / Proc / stat , được ghi lại khá tốt tại http://www.linuxhowtos.org/System/procstat.htmlm ; Đây là những gì nó trông giống như trên hộp 4 lõi của tôi:

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

Trước tiên, bạn cần xác định có bao nhiêu CPU (hoặc bộ xử lý hoặc lõi xử lý) có sẵn trong hệ thống. Để làm điều này, hãy đếm số lượng mục 'cpuN', trong đó N bắt đầu từ 0 và tăng dần. Đừng đếm dòng 'cpu', là sự kết hợp của các dòng cpuN. Trong ví dụ của tôi, bạn có thể thấy cpu0 đến cpu3, ​​với tổng số 4 bộ xử lý. Từ giờ trở đi, bạn có thể bỏ qua cpu0..cpu3 và chỉ tập trung vào dòng 'cpu'.

Tiếp theo, bạn cần biết rằng số thứ tư trong các dòng này là thước đo thời gian nhàn rỗi và do đó, số thứ tư trên dòng 'cpu' là tổng thời gian nhàn rỗi cho tất cả các bộ xử lý kể từ khi khởi động. Thời gian này được đo bằng "jiffies" của Linux, tức là 1/100 giây.

Nhưng bạn không quan tâm đến tổng thời gian nhàn rỗi; bạn quan tâm đến thời gian nhàn rỗi trong một khoảng thời gian nhất định, ví dụ: giây cuối cùng. Hãy tính toán rằng, bạn cần đọc tệp này hai lần, cách nhau 1 giây. Sau đó, bạn có thể thực hiện một giá trị khác của giá trị thứ tư của dòng. Ví dụ: nếu bạn lấy mẫu và nhận:

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

Sau đó một giây bạn sẽ có được mẫu này:

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

Trừ hai số đó và bạn nhận được chênh lệch 396, điều đó có nghĩa là CPU của bạn không hoạt động trong 3,96 giây trong 1,00 giây cuối cùng. Thủ thuật, tất nhiên, là bạn cần chia cho số lượng bộ xử lý. 3,96 / 4 = 0,99 và có phần trăm nhàn rỗi của bạn; 99% nhàn rỗi, và 1% bận rộn.

Trong mã của tôi, tôi có bộ đệm vòng gồm 360 mục và tôi đọc tệp này mỗi giây. Điều đó cho phép tôi nhanh chóng tính toán mức độ sử dụng CPU trong 1 giây, 10 giây, v.v., cho đến hết 1 giờ.

Để biết thông tin cụ thể về quy trình, bạn phải xem trong / Proc / pid ; nếu bạn không quan tâm đến pid của mình, bạn có thể xem / Proc / self.

CPU được sử dụng bởi quy trình của bạn có sẵn trong / Proc / self / stat . Đây là một tập tin trông kỳ lạ bao gồm một dòng duy nhất; ví dụ:

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

Dữ liệu quan trọng ở đây là mã thông báo thứ 13 và 14 (0 và 770 tại đây). Mã thông báo thứ 13 là số lượng jiffies mà quy trình đã thực hiện trong chế độ người dùng và thứ 14 là số lượng jiffies mà quy trình đã thực hiện trong chế độ kernel. Thêm hai cái lại với nhau và bạn có tổng mức sử dụng CPU của nó.

Một lần nữa, bạn sẽ phải lấy mẫu tệp này định kỳ và tính toán độ lệch để xác định mức sử dụng CPU của quy trình theo thời gian.

Biên tập: hãy nhớ rằng khi bạn tính toán mức sử dụng CPU của quy trình, bạn phải tính đến 1) số lượng luồng trong quy trình của mình và 2) số lượng bộ xử lý trong hệ thống. Ví dụ: nếu quy trình đơn luồng của bạn chỉ sử dụng 25% CPU, điều đó có thể tốt hoặc xấu. Tốt trên hệ thống xử lý đơn, nhưng xấu trên hệ thống 4 bộ xử lý; điều này có nghĩa là quá trình của bạn đang chạy liên tục và sử dụng 100% các chu kỳ CPU có sẵn cho nó.

Đối với thông tin bộ nhớ dành riêng cho quá trình, bạn phải xem / Proc / self / status, trông giống như sau:

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

Các mục bắt đầu bằng 'Vm' là những mục thú vị:

• VmPeak là không gian bộ nhớ ảo tối đa được quá trình sử dụng, tính bằng kB (1024 byte).
• VmSize là không gian bộ nhớ ảo hiện tại được sử dụng bởi quy trình, tính bằng kB. Trong ví dụ của tôi, nó khá lớn: 651.352 kB, tương đương khoảng 636 megabyte.
• VmRss là dung lượng bộ nhớ đã được ánh xạ vào không gian địa chỉ của quy trình hoặc kích thước cài đặt thường trú của nó. Con số này nhỏ hơn đáng kể (420.296 kB, tương đương khoảng 410 megabyte). Sự khác biệt: chương trình của tôi đã ánh xạ 636 MB qua mmap (), nhưng chỉ truy cập 410 MB của nó và do đó chỉ có 410 MB trang được gán cho nó.

Mục duy nhất tôi không chắc chắn là Swapspace hiện đang được sử dụng bởi quy trình của tôi . Tôi không biết nếu điều này có sẵn.

trong windows bạn có thể sử dụng cpu bằng mã dưới đây:

#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 on 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

Một cách di động để đọc bộ nhớ và tải số là sysinfocuộc gọi

Sử dụng

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

SỰ MIÊU TẢ

   Until Linux 2.3.16, sysinfo() used to return information in the
   following structure:

       struct sysinfo {
           long uptime;             /* Seconds since boot */
           unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
           unsigned long totalram;  /* Total usable main memory size */
           unsigned long freeram;   /* Available memory size */
           unsigned long sharedram; /* Amount of shared memory */
           unsigned long bufferram; /* Memory used by buffers */
           unsigned long totalswap; /* Total swap space size */
           unsigned long freeswap;  /* swap space still available */
           unsigned short procs;    /* Number of current processes */
           char _f[22];             /* Pads structure to 64 bytes */
       };

   and the sizes were given in bytes.

   Since Linux 2.3.23 (i386), 2.3.48 (all architectures) the structure
   is:

       struct sysinfo {
           long uptime;             /* Seconds since boot */
           unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
           unsigned long totalram;  /* Total usable main memory size */
           unsigned long freeram;   /* Available memory size */
           unsigned long sharedram; /* Amount of shared memory */
           unsigned long bufferram; /* Memory used by buffers */
           unsigned long totalswap; /* Total swap space size */
           unsigned long freeswap;  /* swap space still available */
           unsigned short procs;    /* Number of current processes */
           unsigned long totalhigh; /* Total high memory size */
           unsigned long freehigh;  /* Available high memory size */
           unsigned int mem_unit;   /* Memory unit size in bytes */
           char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
       };

   and the sizes are given as multiples of mem_unit bytes.

QNX

Vì đây giống như một "wikipage của mã", tôi muốn thêm một số mã từ cơ sở Kiến thức QNX (lưu ý: đây không phải là công việc của tôi, nhưng tôi đã kiểm tra nó và nó hoạt động tốt trên hệ thống của tôi):

Cách nhận mức sử dụng CPU theo%: http://www.qnx.com/support/ledgeledridease.html?id=50130000000P9b5

#include <atomic.h>
#include <libc.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/iofunc.h>
#include <sys/neutrino.h>
#include <sys/resmgr.h>
#include <sys/syspage.h>
#include <unistd.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/debug.h>
#include <sys/procfs.h>
#include <sys/syspage.h>
#include <sys/neutrino.h>
#include <sys/time.h>
#include <time.h>
#include <fcntl.h>
#include <devctl.h>
#include <errno.h>

#define MAX_CPUS 32

static float Loads[MAX_CPUS];
static _uint64 LastSutime[MAX_CPUS];
static _uint64 LastNsec[MAX_CPUS];
static int ProcFd = -1;
static int NumCpus = 0;


int find_ncpus(void) {
    return NumCpus;
}

int get_cpu(int cpu) {
    int ret;
    ret = (int)Loads[ cpu % MAX_CPUS ];
    ret = max(0,ret);
    ret = min(100,ret);
    return( ret );
}

static _uint64 nanoseconds( void ) {
    _uint64 sec, usec;
    struct timeval tval;
    gettimeofday( &tval, NULL );
    sec = tval.tv_sec;
    usec = tval.tv_usec;
    return( ( ( sec * 1000000 ) + usec ) * 1000 );
}

int sample_cpus( void ) {
    int i;
    debug_thread_t debug_data;
    _uint64 current_nsec, sutime_delta, time_delta;
    memset( &debug_data, 0, sizeof( debug_data ) );

    for( i=0; i<NumCpus; i++ ) {
        /* Get the sutime of the idle thread #i+1 */
        debug_data.tid = i + 1;
        devctl( ProcFd, DCMD_PROC_TIDSTATUS,
        &debug_data, sizeof( debug_data ), NULL );
        /* Get the current time */
        current_nsec = nanoseconds();
        /* Get the deltas between now and the last samples */
        sutime_delta = debug_data.sutime - LastSutime[i];
        time_delta = current_nsec - LastNsec[i];
        /* Figure out the load */
        Loads[i] = 100.0 - ( (float)( sutime_delta * 100 ) / (float)time_delta );
        /* Flat out strange rounding issues. */
        if( Loads[i] < 0 ) {
            Loads[i] = 0;
        }
        /* Keep these for reference in the next cycle */
        LastNsec[i] = current_nsec;
        LastSutime[i] = debug_data.sutime;
    }
    return EOK;
}

int init_cpu( void ) {
    int i;
    debug_thread_t debug_data;
    memset( &debug_data, 0, sizeof( debug_data ) );
/* Open a connection to proc to talk over.*/
    ProcFd = open( "/proc/1/as", O_RDONLY );
    if( ProcFd == -1 ) {
        fprintf( stderr, "pload: Unable to access procnto: %s\n",strerror( errno ) );
        fflush( stderr );
        return -1;
    }
    i = fcntl(ProcFd,F_GETFD);
    if(i != -1){
        i |= FD_CLOEXEC;
        if(fcntl(ProcFd,F_SETFD,i) != -1){
            /* Grab this value */
            NumCpus = _syspage_ptr->num_cpu;
            /* Get a starting point for the comparisons */
            for( i=0; i<NumCpus; i++ ) {
                /*
                * the sutime of idle thread is how much
                * time that thread has been using, we can compare this
                * against how much time has passed to get an idea of the
                * load on the system.
                */
                debug_data.tid = i + 1;
                devctl( ProcFd, DCMD_PROC_TIDSTATUS, &debug_data, sizeof( debug_data ), NULL );
                LastSutime[i] = debug_data.sutime;
                LastNsec[i] = nanoseconds();
            }
            return(EOK);
        }
    }
    close(ProcFd);
    return(-1);
}

void close_cpu(void){
    if(ProcFd != -1){
        close(ProcFd);
        ProcFd = -1;
    }
}

int main(int argc, char* argv[]){
    int i,j;
    init_cpu();
    printf("System has: %d CPUs\n", NumCpus);
    for(i=0; i<20; i++) {
        sample_cpus();
        for(j=0; j<NumCpus;j++)
        printf("CPU #%d: %f\n", j, Loads[j]);
        sleep(1);
    }
    close_cpu();
}

Cách nhận bộ nhớ (!) Miễn phí: http://www.qnx.com/support/ledgeledridease.html?id=50130000000mlbx

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <err.h>
#include <sys/stat.h>
#include <sys/types.h>

int main( int argc, char *argv[] ){
    struct stat statbuf;
    paddr_t freemem;
    stat( "/proc", &statbuf );
    freemem = (paddr_t)statbuf.st_size;
    printf( "Free memory: %d bytes\n", freemem );
    printf( "Free memory: %d KB\n", freemem / 1024 );
    printf( "Free memory: %d MB\n", freemem / ( 1024 * 1024 ) );
    return 0;
} 

Mac OS X - CPU

Sử dụng CPU tổng thể:

Từ Lấy thông tin hệ thống trên MacOS X? :

#include <mach/mach_init.h>
#include <mach/mach_error.h>
#include <mach/mach_host.h>
#include <mach/vm_map.h>

static unsigned long long _previousTotalTicks = 0;
static unsigned long long _previousIdleTicks = 0;

// Returns 1.0f for "CPU fully pinned", 0.0f for "CPU idle", or somewhere in between
// You'll need to call this at regular intervals, since it measures the load between
// the previous call and the current one.
float GetCPULoad()
{
   host_cpu_load_info_data_t cpuinfo;
   mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
   if (host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO, (host_info_t)&cpuinfo, &count) == KERN_SUCCESS)
   {
      unsigned long long totalTicks = 0;
      for(int i=0; i<CPU_STATE_MAX; i++) totalTicks += cpuinfo.cpu_ticks[i];
      return CalculateCPULoad(cpuinfo.cpu_ticks[CPU_STATE_IDLE], totalTicks);
   }
   else return -1.0f;
}

float CalculateCPULoad(unsigned long long idleTicks, unsigned long long totalTicks)
{
  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;
}

Đối với Linux Bạn cũng có thể sử dụng / Proc / self / statm để nhận một dòng số duy nhất chứa thông tin bộ nhớ quy trình chính, đây là cách xử lý nhanh hơn so với việc xem qua một danh sách dài các thông tin được báo cáo khi bạn nhận được từ Proc / self / status

Xem http://man7.org/linux/man-pages/man5/proc.5.html

   /proc/[pid]/statm
          Provides information about memory usage, measured in pages.
          The columns are:

              size       (1) total program size
                         (same as VmSize in /proc/[pid]/status)
              resident   (2) resident set size
                         (same as VmRSS in /proc/[pid]/status)
              shared     (3) number of resident shared pages (i.e., backed by a file)
                         (same as RssFile+RssShmem in /proc/[pid]/status)
              text       (4) text (code)
              lib        (5) library (unused since Linux 2.6; always 0)
              data       (6) data + stack
              dt         (7) dirty pages (unused since Linux 2.6; always 0)

Tôi đã sử dụng mã sau đây trong dự án C ++ của mình và nó hoạt động tốt:

static HANDLE self;
static int numProcessors;
SYSTEM_INFO sysInfo;

double percent;

numProcessors = sysInfo.dwNumberOfProcessors;

//Getting system times information
FILETIME SysidleTime;
FILETIME SyskernelTime; 
FILETIME SysuserTime; 
ULARGE_INTEGER SyskernelTimeInt, SysuserTimeInt;
GetSystemTimes(&SysidleTime, &SyskernelTime, &SysuserTime);
memcpy(&SyskernelTimeInt, &SyskernelTime, sizeof(FILETIME));
memcpy(&SysuserTimeInt, &SysuserTime, sizeof(FILETIME));
__int64 denomenator = SysuserTimeInt.QuadPart + SyskernelTimeInt.QuadPart;  

//Getting process times information
FILETIME ProccreationTime, ProcexitTime, ProcKernelTime, ProcUserTime;
ULARGE_INTEGER ProccreationTimeInt, ProcexitTimeInt, ProcKernelTimeInt, ProcUserTimeInt;
GetProcessTimes(self, &ProccreationTime, &ProcexitTime, &ProcKernelTime, &ProcUserTime);
memcpy(&ProcKernelTimeInt, &ProcKernelTime, sizeof(FILETIME));
memcpy(&ProcUserTimeInt, &ProcUserTime, sizeof(FILETIME));
__int64 numerator = ProcUserTimeInt.QuadPart + ProcKernelTimeInt.QuadPart;
//QuadPart represents a 64-bit signed integer (ULARGE_INTEGER)

percent = 100*(numerator/denomenator);