logování paměti RAM je známkou nejvyšší úrovně linuxového procesu

Podívejte se na /proc/[pid]/status , konkrétně tento parametr.

• VmHWM:Maximální velikost rezidentní sady ("značka vysoké hladiny").

Případně můžete použít /usr/bin/time -v příkaz. Zde je příklad jeho výstupu:

Command exited with non-zero status 1
    Command being timed: "xz -9ek access_log.3 access_log.xz"
    User time (seconds): 6.96
    System time (seconds): 0.34
    Percent of CPU this job got: 99%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:07.34
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
  **Maximum resident set size (kbytes): 383456**
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 24000
    Voluntary context switches: 3
    Involuntary context switches: 225
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 1

Informace o značce RAM pro proces již pro vás shromažďuje jádro (z 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").
(...)

Záludná část je v tom, že tato hodnota by měla být načtena chvíli před ukončením procesu .

Zkoušel jsem různé přístupy (více o tom na konci odpovědi) a ten, který se mi osvědčil, byla implementace v C:

• logmemory vyvolá fork() vytvořit podřízený proces.

• Podřízený proces volá ptrace() takže nadřazený proces (což je logmemory ) je upozorněn pokaždé, když dítě provede systémové volání.

• Podřízený proces používá execvp() spustit mycmd .

• logmemory trpělivě čeká na oznámení. V takovém případě zkontroluje, zda mycmd vyvoláno exit_group . Pokud je to tento případ, je to /proc/<pid>/status , zkopíruje hodnoty do mem.log a odpoutá se od dítěte. Jinak logmemory umožňuje mycmd pokračovat a počká do dalšího upozornění.

Nevýhodou je, že ptrace() zpomaluje sledovaný program , níže uvádím některá srovnání.

Tato verze logmemory nejen protokoly VmHWM ale také:

• VmPeak (špičková velikost virtuální paměti, která zahrnuje veškerý kód, data a sdílené knihovny plus stránky, které byly vyměněny a stránky, které byly namapovány, ale nebyly použity)

• časové razítko

• název příkazu a argumenty

Toto je kód, který lze jistě vylepšit – nejsem zběhlý v C. Funguje to, jak bylo zamýšleno (testováno na 32bitovém Ubuntu 12.04 a 64bitovém SuSE Linux Enterprise Server 10 SP4):

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

Uložte jej jako logmemory.c a zkompilujte takto:

$ gcc logmemory.c -o logmemory

Spusťte to takto:

$ ./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

Napsal jsem tento program v C, abych otestoval logmemory přesnost:

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

Zkompilujte jako obvykle a spusťte jej v 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

který správně hlásí využitých 200 MB.

Jako okrajová poznámka:time (alespoň na Ubuntu 12.04) překvapivě vydává hodnotu, která se do značné míry liší od toho, co hlásí jádro:

$ /usr/bin/time --format %M ./bigmalloc
823872

kde M (od man time ):

M   Maximum resident set size of the process during its lifetime, in Kilobytes.

Jak bylo uvedeno výše, je to za cenu, protože logmemory zpomaluje provádění sledovaného programu, například:

$ 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

Další přístupy, které jsem (neúspěšně) vyzkoušel, byly:

• Shell skript, který vytváří proces na pozadí pro čtení /proc/<pid>/status zatímco mycmd běží.

• Program v jazyce C, který forkuje a exec's mycmd ale pozastaví se, dokud se dítě nestane zombie, takže se vyhnete ptrace a režii, kterou vytváří. Pěkný nápad, pomyslel jsem si, bohužel VmHWM a VmPeak již nejsou dostupné od /proc/<pid>/status pro zombie.

I když je téma poměrně staré, chci se podělit o další projekt, který vzešel z funkce cgroups linuxového jádra.

https://github.com/gsauthof/cgmemtime:

cgmemtime měří náročné využití paměti RSS+CACHE procesem a jeho následnými procesy.

Aby to bylo možné, umístí proces do své vlastní cgroup.

Například proces A přidělí 10 MiB a rozdělí dítě B, které přidělí 20 MiB, a rozdělí dítě C, které přidělí 30 MiB. Všechny tři procesy sdílejí časové okno, kde jejich alokace vedou k neodpovídajícímu využití paměti RSS (velikost rezidentní sady).

Otázka nyní zní:Kolik paměti je skutečně využito v důsledku spuštění A?

Odpověď:60 MiB

cgmemtime je nástroj k zodpovězení takových otázek.