Comment mesurer l'utilisation de la mémoire à partir d'un programme c++?
Est-il possible, pour un programme C++, de suivre la quantité de mémoire utilisée par le programme à la fois?
Par exemple, une fonction avec un prototype:
int getEstimatedTotalMemoryUsage();
Je suppose que si ce n'est pas possible, alors il faudra sortir du programme, faire un appel système et vérifier les résultats à partir de là. Dans l'affirmative, quels sont les outils disponibles à ces fins? En supposant qu'une telle chose est possible, c'est.
Edit: j'utilise linux, des outils qui peuvent le faire pour vous?
3 réponses
Oui-utiliser POSIX getrusage. Depuis la page de manuel Linux :
Synopsis
#include <sys/time.h> #include <sys/resource.h> int getrusage(int who, struct rusage *usage);Description
getrusage()les rendements actuels de ressources, usages, pour un qui, soitRUSAGE_SELFouRUSAGE_CHILDREN. Le PREMIER demande des ressources utilisées par le processus en cours, le second des ressources utilisées par ceux de ses enfants qui ont pris fin et ont été attendus.struct rusage { struct timeval ru_utime; /* user time used */ struct timeval ru_stime; /* system time used */ long ru_maxrss; /* maximum resident set size */ long ru_ixrss; /* integral shared memory size */ long ru_idrss; /* integral unshared data size */ long ru_isrss; /* integral unshared stack size */ long ru_minflt; /* page reclaims */ long ru_majflt; /* page faults */ long ru_nswap; /* swaps */ long ru_inblock; /* block input operations */ long ru_oublock; /* block output operations */ long ru_msgsnd; /* messages sent */ long ru_msgrcv; /* messages received */ long ru_nsignals; /* signals received */ long ru_nvcsw; /* voluntary context switches */ long ru_nivcsw; /* involuntary context switches */ };
Je voulais cela aujourd'hui, moi-même, donc partager les résultats testés ici. Je crois qu'un appel à getmem() fera ce que l'OP a demandé, sur n'importe quelle boîte unix. Écrit en C très générique, il fonctionnera en C ou c++.
// Calling function must free the returned result.
char* exec(const char* command) {
FILE* fp;
char* line = NULL;
// Following initialization is equivalent to char* result = ""; and just
// initializes result to an empty string, only it works with
// -Werror=write-strings and is so much less clear.
char* result = (char*) calloc(1, 1);
size_t len = 0;
fflush(NULL);
fp = popen(command, "r");
if (fp == NULL) {
printf("Cannot execute command:\n%s\n", command);
return NULL;
}
while(getline(&line, &len, fp) != -1) {
// +1 below to allow room for null terminator.
result = (char*) realloc(result, strlen(result) + strlen(line) + 1);
// +1 below so we copy the final null terminator.
strncpy(result + strlen(result), line, strlen(line) + 1);
free(line);
line = NULL;
}
fflush(fp);
if (pclose(fp) != 0) {
perror("Cannot close stream.\n");
}
return result;
}
int getmem() {
pid_t pid = getpid();
char cmd[64];
snprintf(cmd, 64, "/bin/ps -p %d -o size", pid);
char* result = exec(cmd);
if (!result) {
return 0;
}
// Find first newline.
int pos = 0;
while (result[pos] != '\n') {
pos++;
}
// Remove the final newline.
result[strlen(result) - 1] = '\0';
// Convert to integer.
int size = atoi(result + pos + 1);
free(result);
return size;
}
Techniquement, je suppose que le printf(...) la ligne doit être fprintf (stderr, ...), mais j'ai tendance à avoir stderr redirigé pour certaines raisons de journalisation spécifiques à l'environnement, et c'est ainsi que j'ai compilé et testé le code, donc je copie verbatim pour éviter la casse.
Obtenez votre PID: pid_t getpid(void); // unistd.h
Analyse /proc/<id>/smaps
Si vous ne vous souciez pas des bibliothèques partagées dans mem total, cela peut être plus simple
Effectuer un appel système à ps -p <id> -o %mem