Comment déterminer la consommation du CPU et de la mémoire à l'intérieur d'un processus ?

Question

J'ai eu un jour la tâche de déterminer les paramètres de performance suivants à partir d'une application en cours d'exécution :

• Mémoire virtuelle totale disponible

• Mémoire virtuelle actuellement utilisée

• Mémoire virtuelle actuellement utilisée par mon processus

• Total de la RAM disponible

• RAM actuellement utilisée

• RAM actuellement utilisée par mon processus

• % du CPU actuellement utilisé

• % du CPU actuellement utilisé par mon processus

Le code devait fonctionner sous Windows et Linux. Même si cela semble être une tâche standard, trouver les informations nécessaires dans les manuels (WIN32 API, GNU docs) ainsi que sur Internet m'a pris plusieurs jours, car il y a tellement d'informations incomplètes/incorrectes/désuètes sur ce sujet à trouver.

Afin d'éviter à d'autres de passer par les mêmes difficultés, j'ai pensé qu'il serait bon de rassembler en un seul endroit toutes les informations éparses et ce que j'ai trouvé par tâtonnement.

Answer 1

Windows

Certaines des valeurs ci-dessus sont facilement disponibles à partir de l'API Win32 appropriée, je les énumère ici par souci d'exhaustivité. D'autres, cependant, doivent être obtenues à partir de la bibliothèque Performance Data Helper (PDH), qui est un peu "non intuitive" et nécessite beaucoup d'essais et d'erreurs douloureuses pour arriver à fonctionner. (En tout cas, cela m'a pris pas mal de temps, peut-être ai-je été seulement un peu stupide...)

Note : pour plus de clarté, toutes les vérifications d'erreurs ont été omises dans le code suivant. Vérifiez bien les codes de retour... !

• Mémoire virtuelle totale :

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

  Note : Le nom "TotalPageFile" est un peu trompeur ici. En réalité, ce paramètre donne la "Taille de la mémoire virtuelle", qui est la taille du fichier d'échange plus la RAM installée.

• Mémoire virtuelle actuellement utilisée :

  Même code que dans "Mémoire virtuelle totale", puis

   DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;

• Mémoire virtuelle actuellement utilisée par le processus en cours :

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

• Mémoire physique totale (RAM) :

  Même code que dans "Mémoire virtuelle totale", puis

  DWORDLONG totalPhysMem = memInfo.ullTotalPhys;

• Mémoire physique actuellement utilisée :

  Même code que dans "Mémoire virtuelle totale" et ensuite

  DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;

• Mémoire physique actuellement utilisée par le processus en cours :

  Même code que dans "Mémoire virtuelle actuellement utilisée par le processus actuel" et ensuite

  SIZE_T physMemUsedByMe = pmc.WorkingSetSize;

• CPU actuellement utilisé :

  #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 actuellement utilisé par le processus en cours :

  #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

Sous Linux, le choix qui semblait évident au départ était d'utiliser les API POSIX comme getrusage() etc. J'ai passé un certain temps à essayer de faire fonctionner ce système, mais je n'ai jamais obtenu de valeurs significatives. Lorsque j'ai finalement vérifié les sources du noyau elles-mêmes, j'ai découvert qu'apparemment ces API ne sont pas encore complètement implémentées à partir du noyau Linux 2.6 !?

En fin de compte, j'ai obtenu toutes les valeurs par une combinaison de lecture du pseudo-système de fichiers /proc et les appels du noyau.

• Mémoire virtuelle totale :

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

• Mémoire virtuelle actuellement utilisée :

  Même code que dans "Mémoire virtuelle totale", puis

  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;

• Mémoire virtuelle actuellement utilisée par le processus en cours :

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

• Mémoire physique totale (RAM) :

  Même code que dans "Mémoire virtuelle totale", puis

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

• Mémoire physique actuellement utilisée :

  Même code que dans "Mémoire virtuelle totale", puis

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

• Mémoire physique actuellement utilisée par le processus en cours :

  Changez getValue() dans "Virtual Memory currently used by current process" comme suit :

  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 actuellement utilisé :

  #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 actuellement utilisé par le processus en cours :

  #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 : Autres plates-formes

Je suppose qu'une partie du code Linux fonctionne également pour les Unix, à l'exception des parties qui lisent le pseudo-système de fichiers /proc. Peut-être que sous Unix ces parties peuvent être remplacées par getrusage() et des fonctions similaires ?

Answer 2

Mac OS X

Mémoire virtuelle totale

Cette opération est délicate sous Mac OS X car elle n'utilise pas de partition ou de fichier swap prédéfini comme sous Linux. Voici une entrée de la documentation d'Apple :

Note : Contrairement à la plupart des systèmes d'exploitation basés sur Unix, Mac OS X n'utilise pas de partition d'échange préallouée pour la mémoire virtuelle. Au lieu de cela, il utilise tout l'espace disponible sur la partition de démarrage de la machine.

Donc, si vous voulez savoir combien de mémoire virtuelle est encore disponible, vous devez obtenir la taille de la partition racine. Vous pouvez le faire comme ceci :

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

Total virtuel actuellement utilisé

L'appel de systcl avec la clé "vm.swapusage" fournit des informations intéressantes sur l'utilisation de l'espace de pagination :

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

Il est à noter que l'utilisation totale de swap affichée ici peut changer si plus de swap est nécessaire comme expliqué dans la section ci-dessus. Le total est donc en fait le actuel échange total. En C++, ces données peuvent être interrogées de la manière suivante :

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

Notez que le "xsw_usage", déclaré dans sysctl.h, ne semble pas documenté et je soupçonne qu'il existe un moyen plus portable d'accéder à ces valeurs.

Mémoire virtuelle actuellement utilisée par mon processus

Vous pouvez obtenir des statistiques sur votre processus actuel en utilisant la fonction task_info fonction. Cela inclut la taille résidente actuelle de votre processus et la taille virtuelle actuelle.

#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 de la RAM disponible

La quantité de RAM physique disponible dans votre système est disponible à l'aide de la fonction sysctl Le système fonctionne comme suit :

#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 actuellement utilisée

Vous pouvez obtenir des statistiques générales sur la mémoire à partir du host_statistics fonction du système.

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

Il faut savoir qu'il existe cinq types de pages mémoire dans Mac OS X. Elles sont les suivantes :

1. Câblé des pages qui sont verrouillées en place et ne peuvent pas être échangées
2. Actif des pages qui sont chargées dans la mémoire physique et qu'il serait relativement difficile de remplacer.
3. Inactif les pages qui sont chargées en mémoire, mais qui n'ont pas été utilisées récemment et qui peuvent même ne pas être nécessaires du tout. Ce sont des candidats potentiels pour le swapping. Cette mémoire devra probablement être vidée.
4. En cachette les pages qui ont été mises en cache d'une manière ou d'une autre et qui sont susceptibles d'être facilement réutilisées. La mémoire en cache ne nécessiterait probablement pas de vidage. Il est toujours possible que les pages mises en cache soient réactivées
5. Gratuit qui sont entièrement gratuites et prêtes à être utilisées.

Il est bon de noter que le fait que Mac OS X affiche parfois très peu de mémoire libre n'est pas forcément une bonne indication de la quantité de mémoire prête à être utilisée à court terme.

RAM actuellement utilisée par mon processus

Voir la section "Mémoire virtuelle actuellement utilisée par mon processus" ci-dessus. Le même code s'applique.

Answer 3

Linux

Sous Linux, ces informations sont disponibles dans le système de fichiers /proc. Je ne suis pas un grand fan du format de fichier texte utilisé, car chaque distribution Linux semble personnaliser au moins un fichier important. Un rapide coup d'oeil à la source de 'ps' révèle le désordre.

Mais voici où trouver les informations que vous cherchez :

/proc/meminfo contient la majorité des informations relatives au système que vous recherchez. Voici à quoi cela ressemble sur mon système ; je pense que vous êtes intéressé par MemTotal , MemFree , SwapTotal y 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

Pour l'utilisation du CPU, il faut faire un peu de travail. Linux met à disposition l'utilisation globale du CPU depuis le démarrage du système ; ce n'est probablement pas ce qui vous intéresse. Si vous voulez savoir quelle a été l'utilisation du CPU au cours de la dernière seconde, ou des 10 dernières secondes, vous devez interroger l'information et la calculer vous-même.

Les informations sont disponibles dans /proc/stat qui est très bien documenté à l'adresse http://www.linuxhowtos.org/System/procstat.htm Voici à quoi ça ressemble sur ma boîte à 4 fils :

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

Tout d'abord, vous devez déterminer combien de CPU (ou processeurs, ou cœurs de traitement) sont disponibles dans le système. Pour ce faire, comptez le nombre d'entrées 'cpuN', où N commence à 0 et s'incrémente. Ne comptez pas la ligne 'cpu', qui est une combinaison des lignes 'cpuN'. Dans mon exemple, vous pouvez voir cpu0 à cpu3, pour un total de 4 processeurs. A partir de maintenant, vous pouvez ignorer les cpu0..cpu3, et vous concentrer uniquement sur la ligne 'cpu'.

Ensuite, vous devez savoir que le quatrième chiffre de ces lignes est une mesure du temps d'inactivité, et donc le quatrième chiffre de la ligne "cpu" est le temps d'inactivité total pour tous les processeurs depuis le démarrage. Ce temps est mesuré en "jiffies" Linux, qui sont de 1/100 de seconde chacun.

Mais vous ne vous souciez pas du temps d'inactivité total ; vous vous souciez du temps d'inactivité dans une période donnée, par exemple, la dernière seconde. Pour calculer cela, vous devez lire ce fichier deux fois, à une seconde d'intervalle, puis vous pouvez faire une comparaison de la quatrième valeur de la ligne. Par exemple, si vous prenez un échantillon et obtenez :

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

Puis, une seconde plus tard, vous obtenez cet échantillon :

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

Soustrayez les deux nombres, et vous obtenez une différence de 396, ce qui signifie que votre CPU a été inactif pendant 3,96 secondes sur les 1,00 dernières secondes. L'astuce, bien sûr, est que vous devez diviser par le nombre de processeurs. 3,96 / 4 = 0,99, et voilà votre pourcentage d'inactivité : 99% d'inactivité et 1% d'occupation.

Dans mon code, j'ai un tampon circulaire de 360 entrées, et je lis ce fichier toutes les secondes. Cela me permet de calculer rapidement l'utilisation du CPU pour 1 seconde, 10 secondes, etc., jusqu'à 1 heure.

Pour les informations spécifiques au processus, vous devez chercher dans /proc/pid si vous ne vous souciez pas de votre pid, vous pouvez regarder dans /proc/self.

Le CPU utilisé par votre processus est disponible dans /proc/self/stat . Il s'agit d'un fichier d'apparence étrange composé d'une seule ligne ; par exemple :

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

Les données importantes ici sont les 13ème et 14ème jetons (0 et 770 ici). Le 13e jeton est le nombre de jiffies que le processus a exécuté en mode utilisateur, et le 14e est le nombre de jiffies que le processus a exécuté en mode noyau. Additionnez les deux et vous obtenez son utilisation totale du CPU.

Encore une fois, vous devrez échantillonner ce fichier périodiquement, et calculer la différence, afin de déterminer l'utilisation du CPU du processus au fil du temps.

Editar: N'oubliez pas que lorsque vous calculez l'utilisation du CPU de votre processus, vous devez prendre en compte 1) le nombre de threads de votre processus, et 2) le nombre de processeurs du système. Par exemple, si votre processus à un seul thread n'utilise que 25 % du CPU, cela peut être bon ou mauvais. Bon sur un système à un seul processeur, mais mauvais sur un système à 4 processeurs ; cela signifie que votre processus fonctionne en permanence et utilise 100 % des cycles du CPU dont il dispose.

Pour les informations de mémoire spécifiques au processus, vous devez regarder /proc/self/status, qui ressemble à ceci :

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

Les entrées qui commencent par "Vm" sont les plus intéressantes :

• VmPeak est l'espace mémoire virtuel maximum utilisé par le processus, en kB (1024 octets).
• VmSize est l'espace mémoire virtuel actuel utilisé par le processus, en kB. Dans mon exemple, c'est assez grand : 651,352 kB, ou environ 636 mégaoctets.
• VmRss est la quantité de mémoire qui a été mappée dans l'espace d'adressage du processus, ou la taille de son ensemble résident. Celle-ci est sensiblement plus petite (420 296 kB, soit environ 410 mégaoctets). La différence : mon programme a mappé 636 MB via mmap(), mais n'a accédé qu'à 410 MB de cette mémoire, et donc seulement 410 MB de pages lui ont été assignées.

Le seul point sur lequel je ne suis pas sûr est Espace de permutation actuellement utilisé par mon processus . Je ne sais pas si cela est disponible.

Answer 4

Linux

Un moyen portable de lire les numéros de mémoire et de charge est la fonction sysinfo appelez

Utilisation

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

DESCRIPTION

   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.

Answer 5

Sous Windows, vous pouvez obtenir l'utilisation du CPU en utilisant le code ci-dessous :

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