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

Une fois, j’ai eu la tâche de déterminer les parameters de performance suivants dans 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 RAM disponible
  • RAM actuellement utilisé
  • RAM actuellement utilisée par mon processus

  • % CPU actuellement utilisé
  • % 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 (API WIN32, documents GNU) et sur Internet m’a pris plusieurs jours, car les informations sur ce sujet sont incomplètes / incorrectes / obsolètes. trouvé là-bas.

Afin d’éviter aux autres d’être confrontés aux mêmes problèmes, j’ai pensé que ce serait une bonne idée de collecter toutes les informations dispersées ainsi que ce que j’ai trouvé par essais et erreurs ici, au même endroit.

les fenêtres

Certaines des valeurs ci-dessus sont facilement disponibles à partir de l’API WIN32 appropriée, je les énumère simplement ici pour les compléter. D’autres, cependant, doivent être obtenus à partir de la bibliothèque PDH (Performance Data Helper), qui est un peu “non intuitive” et nécessite beaucoup d’essais et d’erreurs pénibles pour se mettre au travail. (Au moins ça m’a pris pas mal de temps, peut-être que je suis un peu bête …)

Remarque: pour plus de clarté, toutes les vérifications d’erreur ont été omises du code suivant. Vérifiez les codes 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”, c’est-à-dire la taille du fichier d’échange et de la mémoire vive 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 actuel:

     #include "windows.h" #include "psapi.h" PROCESS_MEMORY_COUNTERS_EX pmc; GetProcessMemoryInfo(GetCurrentProcess(), &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:

     Same code as in "Total Virtual Memory" and then 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 en cours”, puis

     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; } 
  • Processeur 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ébut était d’utiliser les API POSIX comme getrusage (), etc. J’ai essayé de faire fonctionner ceci, mais je n’ai jamais obtenu de valeurs significatives. Quand j’ai finalement vérifié les sources du kernel, j’ai découvert qu’apparemment, ces API n’étaient pas encore complètement implémentées à partir du kernel Linux 2.6!

Au final, j’ai obtenu toutes les valeurs en combinant la lecture du pseudo-système de fichiers / proc et les appels au kernel.

  • 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 actuel:

     #include "stdlib.h" #include "stdio.h" #include "ssortingng.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 “Mémoire virtuelle actuellement utilisée par le processus en cours” 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 "ssortingng.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; } 
  • Processeur actuellement utilisé par le processus en cours:

     #include "stdlib.h" #include "stdio.h" #include "ssortingng.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 sur Unix ces parties peuvent être remplacées par getrusage () et des fonctions similaires? Si quelqu'un avec un savoir-faire Unix pouvait modifier cette réponse et compléter les détails?!

Mac OS X

J’espérais trouver des informations similaires pour Mac OS X également. Comme ce n’était pas là, je suis sorti et je me suis creusé moi-même. Voici certaines des choses que j’ai trouvées. Si quelqu’un a d’autres suggestions, j’aimerais les entendre.

Mémoire virtuelle totale

Celui-ci est délicat sous Mac OS X car il n’utilise pas de partition d’échange ou de fichier prédéfini comme Linux. Voici une entrée de la documentation d’Apple:

Remarque: Contrairement à la plupart des systèmes d’exploitation basés sur Unix, Mac OS X n’utilise pas de partition de swap 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 faire ça comme ça:

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

Total virtuel actuellement utilisé

L’appel systcl avec la clé “vm.swapusage” fournit des informations intéressantes sur l’utilisation du swap:

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

Non pas que l’utilisation totale du swap affichée ici puisse changer si plus de swap est nécessaire, comme expliqué dans la section ci-dessus. Le total est donc le total actuel des swaps. En C ++, ces données peuvent être interrogées de cette manière:

 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 pense 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 à l’aide de la fonction task_info . Cela inclut la taille actuelle de votre processus et la taille virtuelle actuelle.

 #include 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 disponible

La quantité de RAM physique disponible dans votre système est disponible en utilisant la fonction système sysctl comme ceci:

 #include  #include  ... 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é

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

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

Une chose à noter ici est qu’il existe cinq types de pages de mémoire dans Mac OS X. Ils sont les suivants:

  1. Pages câblées qui sont verrouillées et ne peuvent pas être échangées
  2. Pages actives chargées dans la mémoire physique et difficiles à échanger
  3. Pages inactives chargées en mémoire, mais qui n’ont pas été utilisées récemment et peuvent même ne pas être nécessaires du tout. Ce sont des candidats potentiels pour l’échange. Cette mémoire devrait probablement être vidée.
  4. Les pages en cache qui ont été mises en cache sont susceptibles d’être facilement réutilisées. La mémoire en cache ne nécessiterait probablement pas de vidage. Il est toujours possible de réactiver les pages en cache
  5. Pages gratuites entièrement gratuites et prêtes à être utilisées.

Il est bon de noter que le simple fait que Mac OS X affiche parfois très peu de mémoire libre réelle peut ne pas être une bonne indication de la quantité de données à utiliser rapidement.

RAM actuellement utilisé par mon processus

Voir la “Mémoire virtuelle actuellement utilisée par mon processus” ci-dessus. Le même code s’applique.

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 dissortingbution Linux semble personnaliser au moins un fichier important. Un coup d’œil rapide comme source de “ps” révèle le gâchis.

Mais voici où trouver l’information que vous recherchez:

/ proc / meminfo contient la majorité des informations système que vous recherchez. Ici, ça ressemble à mon système; Je pense que vous êtes intéressé par MemTotal , MemFree , SwapTotal et 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 processeur, vous devez faire un peu de travail. Linux rend disponible l’utilisation globale du processeur depuis le démarrage du système; Ce n’est probablement pas ce qui vous intéresse. Si vous voulez savoir quelle était l’utilisation du processeur pendant la dernière seconde, ou 10 secondes, vous devez interroger les informations et les calculer vous-même.

Les informations sont disponibles dans / proc / stat , ce qui est assez bien documenté sur http://www.linuxhowtos.org/System/procstat.htm ; voici à quoi ça ressemble sur ma boîte à 4 coeurs:

 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 le nombre de processeurs (ou de processeurs ou de cœurs de traitement) 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 cpu0..cpu3 et vous concentrer uniquement sur la ligne ‘cpu’.

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

Mais vous ne vous souciez pas du temps d’inactivité total; vous vous souciez du temps mort au cours d’une période donnée, par exemple, la dernière seconde. Calculez cela, vous devez lire ce fichier deux fois, à une seconde d’intervalle. Ensuite, vous pouvez faire un diff de la quasortingè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 un diff de 396, ce qui signifie que votre processeur a été inactif pendant 3,96 secondes sur les 1,00 dernière seconde. L’astuce, bien sûr, est que vous devez diviser par le nombre de processeurs. 3,96 / 4 = 0,99, et il y a votre pourcentage d’inactivité; 99% inactif et 1% occupé.

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

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

Le processeur utilisé par votre processus est disponible dans / proc / self / stat . Ceci est un fichier é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 13ème jeton est le nombre de jiffies que le processus a exécuté en mode utilisateur, et le 14ème est le nombre de jiffies que le processus a exécuté en mode kernel. Ajoutez les deux ensemble, et vous avez sa consommation totale de CPU.

Encore une fois, vous devrez échantillonner ce fichier périodiquement et calculer le diff afin de déterminer l’utilisation du processeur dans le temps.

Edit: rappelez-vous que lorsque vous calculez l’utilisation du processeur de votre processus, vous devez prendre en compte 1) le nombre de threads dans votre processus et 2) le nombre de processeurs dans le système. Par exemple, si votre processus mono-thread utilise seulement 25% du processeur, cela peut être bon ou mauvais. Bon sur un système monoprocesseur, mais mauvais sur un système à 4 processeurs; Cela signifie que votre processus s’exécute en permanence et que 100% des cycles du processeur sont disponibles.

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 commençant par ‘Vm’ sont les plus intéressantes:

  • VmPeak est l’espace mémoire virtuel maximal utilisé par le processus, en Ko (1024 octets).
  • VmSize est l’espace mémoire virtuel actuel utilisé par le processus, en Ko. Dans mon exemple, c’est assez grand: 651 352 Ko, soit environ 636 Mo.
  • 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. Ceci est sensiblement plus petit (420 296 Ko, soit environ 410 Mo). La différence: mon programme a mappé 636 Mo via mmap (), mais n’a accédé qu’à 410 Mo, et donc seulement 410 Mo de pages lui ont été atsortingbuées.

Le seul élément dont je ne suis pas sûr est Swapspace actuellement utilisé par mon processus . Je ne sais pas si c’est disponible.

dans Windows, vous pouvez obtenir l’utilisation du processeur par code ci-dessous:

 #include  #include  //------------------------------------------------------------------------------------------------------------------ // 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

L’ appel sysinfo est un moyen portable de lire la mémoire et de charger les numéros sysinfo

Usage

  #include  int sysinfo(struct sysinfo *info); 

LA 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. 

QNX

Puisqu’il s’agit d’une “wikipage de code”, je souhaite append du code à partir de la base de connaissances QNX (note: ce n’est pas mon travail, mais je l’ai vérifié et cela fonctionne correctement sur mon système):

Comment obtenir l’utilisation du processeur en%: http://www.qnx.com/support/knowledgebase.html?id=50130000000P9b5

 #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #include  #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; inum_cpu; /* Get a starting point for the comparisons */ for( i=0; i 

Comment obtenir la mémoire gratuite (!): http://www.qnx.com/support/knowledgebase.html?id=50130000000mlbx

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

Utilisation globale du processeur:

De Récupérer les informations système sur MacOS X? :

 #include  #include  #include  #include  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 0) ? ((float)idleTicksSinceLastTime)/totalTicksSinceLastTime : 0); _previousTotalTicks = totalTicks; _previousIdleTicks = idleTicks; return ret; } 

I used this following code in my C++ project and it worked fine:

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

For Linux You can also use /proc/self/statm to get a single line of numbers containing key process memory information which is a faster thing to process than going through a long list of reported information as you get from proc/self/status

See 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 (ie, 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)