As informações sobre a marca d'água máxima da RAM de um processo já foram coletadas para você pelo kernel (de man proc ):
/proc/[pid]/status
Provides much of the information in /proc/[pid]/stat and /proc/[pid]/statm in a format that's easier for humans to parse.
(...)
* VmHWM: Peak resident set size ("high water mark").
(...)
A parte complicada é que esse valor deve ser lido um instante antes de o processo terminar .
Eu tentei abordagens diferentes (mais sobre isso no final da resposta) e a que funcionou para mim foi uma implementação em C:
-
logmemory chama fork() para criar um processo filho.
-
O processo filho chama ptrace() para que o processo pai (que é logmemory ) seja notificado toda vez que o filho executar uma chamada do sistema.
-
O processo filho usa execvp() para executar mycmd .
-
logmemory espera pacientemente por uma notificação. Quando esse é o caso, ele verifica se mycmd invocou exit_group . Se for esse o caso, ele lê /proc/<pid>/status , copia os valores para mem.log e desanexa do filho. Caso contrário, logmemory permite que mycmd continue e aguarde até a próxima notificação.
A desvantagem é que ptrace() atrasa o programa monitorado , eu mostro algumas comparações abaixo.
Esta versão do logmemory não registra apenas VmHWM , mas também:
-
VmPeak (tamanho de pico da memória virtual, que inclui todo o código, dados e bibliotecas compartilhadas, além de páginas que foram trocadas e páginas que foram mapeadas, mas não usadas)
-
um registro de data e hora
-
o nome do comando e os argumentos
Este é o código, que certamente pode ser melhorado - não sou proficiente em C. Funciona como pretendido (testado em um Ubuntu 12.04 de 32 bits e um SuSE Linux Enterprise Server 10 SP4 de 64 bits):
// logmemory.c
#include <stdio.h>
#include <sys/ptrace.h>
#include <unistd.h>
#include <syscall.h>
#include <sys/reg.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define STRINGLENGTH 2048
int main(int argc, char **argv)
{
pid_t child_pid;
long syscall;
int status, index;
FILE *statusfile, *logfile;
char opt, statusfile_path[STRINGLENGTH], line[STRINGLENGTH], command[STRINGLENGTH], logfile_path[STRINGLENGTH] = "";
time_t now;
extern char *optarg;
extern int optind;
// Error checking
if (argc == 1) {
printf("Error: program to execute is missing. Exiting...\n");
return 0;
}
// Get options
while ((opt = getopt (argc, argv, "+o:")) != -1)
switch (opt) {
case 'o':
strncpy(logfile_path, optarg, 2048);
break;
case ':':
fprintf (stderr, "Aborting: argument for option -o is missing\n");
return 1;
case '?':
fprintf (stderr, "Aborting: only valid option is -o\n");
return 1;
}
// More error checking
if (!strcmp(logfile_path, "")) {
fprintf(stderr, "Error: log filename can't be empty\n");
return 1;
}
child_pid = fork();
// The child process executes this:
if (child_pid == 0) {
// Trace child process:
ptrace(PTRACE_TRACEME, 0, NULL, NULL);
// Execute command using $PATH
execvp(argv[optind], (char * const *)(argv+optind));
// The parent process executes this:
} else {
// Loop until child process terminates
do {
// Set ptrace to stop when syscall is executed
ptrace(PTRACE_SYSCALL, child_pid, NULL, NULL);
wait(&status);
// Get syscall number
syscall = ptrace(PTRACE_PEEKUSER, child_pid,
#ifdef __i386__
4 * ORIG_EAX,
#else
8 * ORIG_RAX,
#endif
NULL);
} while (syscall != SYS_exit_group);
// Construct path to status file and check whether status and log file can be opened
snprintf(statusfile_path, STRINGLENGTH, "/proc/%d/status", child_pid);
if ( !(logfile = fopen(logfile_path, "a+")) || !(statusfile = fopen(statusfile_path, "r")) ) {
ptrace(PTRACE_DETACH, child_pid, NULL, NULL);
return 1;
}
// Copy timestamp and command to logfile
now = time(NULL);
fprintf(logfile, "Date: %sCmd: ", asctime(localtime(&now)));
for (index = optind; index < argc; index++)
fprintf(logfile, " %s", argv[index]);
fprintf(logfile, "\n");
// Read status file line by line and copy lines containing VmPeak and VmHWM to logfile
while (fgets(line, STRINGLENGTH, statusfile)) {
if (strstr(line,"VmPeak") || strstr(line,"VmHWM"))
fprintf(logfile, "%s", line);
}
fprintf(logfile, "\n");
// Close files
fclose(statusfile);
fclose(logfile);
// Detach from child process
ptrace(PTRACE_DETACH, child_pid, NULL, NULL);
}
return 0;
}
Salve como logmemory.c e compile assim:
$ gcc logmemory.c -o logmemory
Execute assim:
$ ./logmemory
Error: program to execute is missing. Exiting...
$ ./logmemory -o mem.log ls -l
(...)
$ ./logmemory -o mem.log free
total used free shared buffers cached
Mem: 1025144 760660 264484 0 6644 143980
-/+ buffers/cache: 610036 415108
Swap: 1046524 544228 502296
$ ./logmemory -o mem.log find /tmp -name \*txt
(...)
$ cat mem.log
Date: Mon Feb 11 21:17:55 2013
Cmd: ls -l
VmPeak: 5004 kB
VmHWM: 1284 kB
Date: Mon Feb 11 21:18:01 2013
Cmd: free
VmPeak: 2288 kB
VmHWM: 448 kB
Date: Mon Feb 11 21:18:26 2013
Cmd: find /tmp -name *txt
VmPeak: 4700 kB
VmHWM: 908 kB
Eu escrevi este programa em C para testar a precisão de logmemory :
// bigmalloc.c
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define ITERATIONS 200
int main(int argc, char **argv)
{
int i=0;
for (i=0; i<ITERATIONS; i++) {
void *m = malloc(1024*1024);
memset(m,0,1024*1024);
}
return 0;
}
Compile como de costume e execute-o dentro de logmemory :
$ gcc bigmalloc.c -o bigmalloc
$ ./logmemory -o mem.log ./bigmalloc
$ tail mem.log
Date: Mon Feb 11 21:26:01 2013
Cmd: ./bigmalloc
VmPeak: 207604 kB
VmHWM: 205932 kB
que relata corretamente 200 MB usados.
Como uma observação: time (pelo menos no Ubuntu 12.04) produz um valor surpreendentemente muito diferente do que o kernel reporta:
$ /usr/bin/time --format %M ./bigmalloc
823872
onde M (de man time ):
M Maximum resident set size of the process during its lifetime, in Kilobytes.
Como mencionado acima, isso chega a um preço, porque logmemory atrasa a execução do programa monitorado, por exemplo:
$ time ./logmemory -o mem.log ./bigmalloc
real 0m0.288s
user 0m0.000s
sys 0m0.004s
$ time ./bigmalloc
real 0m0.104s
user 0m0.008s
sys 0m0.092s
$ time find /var -name \*log
(...)
real 0m0.036s
user 0m0.000s
sys 0m0.032s
$ time ./logmemory -o mem.log find /var -name \*log
(...)
real 0m0.124s
user 0m0.000s
sys 0m0.052s
Outras abordagens que eu (sem sucesso) tentei foram:
-
Um script de shell que cria um processo em segundo plano para ler /proc/<pid>/status enquanto mycmd é executado.
-
Um programa em C que bifurca e executa mycmd do executável, mas faz uma pausa até que o filho seja um zumbi, evitando assim ptrace e a sobrecarga criada. Boa idéia, pensei, infelizmente VmHWM e VmPeak não estão mais disponíveis em /proc/<pid>/status para um zumbi.