misurazione della memoria di picco del processo a lunga esecuzione in linux

Question

Come si controlla la memoria di picco consumata da un processo in Linux? Questo non è un programma che posso modificare internamente per misurare l'utilizzo di memoria di picco.

non voglio davvero misure dettagliate, né voglio loro di rallentare eccessivamente il mio programma .. così valgrind o niente pesi massimi non è quello che sto cercando ... E come gli altri posti in precedenza [Peak memory usage of a linux/unix process, tempo -v non sembra segnalare memoria per la mia macchina ...

Posso solo eseguire in alto o ps ed estrarre le stringhe di memoria consumate per id mio processo utilizzando un semplice script. Tuttavia, il mio processo viene eseguito per circa 20-30 minuti, quindi voglio essere in grado di accedere e ottenere il massimo. Posso tollerare campioni a grana grossa ... ogni 1 minuto circa ... Specificamente come faccio a-> 1. forgiare questo semplice script mem-measure in zsh? 2. uccidere quando termina il processo sotto test?

Answer 1

In realtà, quello che ho detto prima:

"""

provare

/usr/bin/time -v yourcommand 

che dovrebbe aiutare se si utilizza solo. "Tempo", bash eseguirà il built-in (che non abbia "-v")

"""

non funziona (restituisce 0).

ho fatto il seguente script Perl (che ho chiamato smaps):

#!/usr/bin/perl 
use 5.010; 
use strict; 
use warnings; 
my $max = 0; 
while(open my $f, '<', "/proc/$ARGV[0]/smaps") { 
    local $/; $_ = <$f>; 
    $max = $1 if /Rss:\s*(\d+)/ and $1 > $max; 
    open my $g, '>', '/tmp/max'; 
    say $g $max 
} 

E poi lo chiamo io (per esempio, a guardare l'utilizzo della memoria del qgit):

bash -c './smaps $$ & exec qgit' 

Usa virgolette singole quindi la shell "figlia" interpreta $$ (che sarà lo stesso PID di qgit dopo lo exec). questo risposta, ho provato :-D

HTH

Answer 2

Si potrebbe utilizzare un plugin munin-node per fare questo, ma è un po 'pesante. http://munin.projects.linpro.no/

Answer 3

Basta usare top -n per iterare un determinato numero di volte e -d per ritardare tra gli aggiornamenti. Inoltre si può afferrare solo l'uscita rilevanti per il processo grep suo PID, come:

top -n 30 -d 60 | grep <process-id> 

Leggere la pagina di manuale all'inizio Per ulteriori informazioni

man top 

Naturalmente, è anche possibile afferrare la colonna bisogno di usare awk.

Answer 4

/proc/pid/smaps, come/proc/pid/maps, fornisce solo informazioni sui mapping della memoria virtuale, non sull'utilizzo effettivo della memoria fisica. top e ps danno l'RSS, che (a seconda di cosa vuoi sapere) potrebbe non essere un buon indicatore dell'uso della memoria.

Una buona scommessa, se si sta utilizzando un kernel Linux successivo alla 2.6.28.7, è di usare la funzione Pagemap. C'è una discussione su questo e sull'origine di alcuni strumenti allo www.eqware.net/Articles/CapturingProcessMemoryUsageUnderLinux.

Lo strumento di raccolta delle pagine ha lo scopo di catturare l'utilizzo della memoria di TUTTI i processi e quindi probabilmente impone un carico di CPU maggiore di quello che si desidera. Dovresti essere facilmente in grado di modificarlo, tuttavia, in modo da catturare i dati solo per un ID processo specifico. Ciò ridurrebbe il sovraccarico in modo tale da poterlo eseguire facilmente ogni pochi secondi. Non l'ho provato, ma penso che lo strumento di analisi della pagina debba funzionare senza modifiche.

EQvan

Answer 5

Valgrind con massif non dovrebbe essere troppo pesante, ma, mi consiglia di utilizzare/proc. Puoi facilmente scrivere il tuo script di monitoraggio. Ecco il mio, per comodità:

#!/bin/bash 

ppid=$$ 
maxmem=0 

$@ & 
pid=`pgrep -P ${ppid} -n -f $1` # $! may work here but not later 
while [[ ${pid} -ne "" ]]; do 
    #mem=`ps v | grep "^[ ]*${pid}" | awk '{print $8}'` 
     #the previous does not work with MPI 
     mem=`cat /proc/${pid}/status | grep VmRSS | awk '{print $2}'` 
    if [[ ${mem} -gt ${maxmem} ]]; then 
     maxmem=${mem} 
    fi 
    sleep 1 
    savedpid=${pid} 
    pid=`pgrep -P ${ppid} -n -f $1` 
done 
wait ${savedpid} # don't wait, job is finished 
exitstatus=$? # catch the exit status of wait, the same of $@ 
echo -e "Memory usage for $@ is: ${maxmem} KB. Exit status: ${exitstatus}\n" 

Answer 6

Dipende dal tipo di memoria che si desidera monitorare.

Il monitoraggio del seguente M.a.p.d tramite l'ordinamento del numero di tutto il processo (non di tutti i thread) consente di monitorare la memoria fisica malloc utilizzata da ciascun processo.

È possibile scrivere un programma c per renderlo ancora più veloce, ma ho pensato che awk fosse la scelta minima per questo scopo.

• Ma anonima mappata la memoria
  • .p privato
    • .d sporca == malloc/heap e stack mmapped assegnati e scritti di memoria
    • .c pulita == malloc/mucchio mmapped e impilare la memoria una volta allocata, scritta, poi liberata, ma non ancora recuperata
  • .s condiviso
    • .d sporco == ci dovrebbe essere nessuno
    • .c pulita == ci dovrebbe essere nessuno
• Mn chiamato memoria mappata
  • .p privato
    • .d dirty == file memoria stampata mmapped private
    • .c == pulite mappato testo del programma/biblioteca privata mappati
  • .s condivisi
    • .d di file == sporco mmapped memoria scritta condivisa
    • .c == Clean Text biblioteca mappata condivisa mappata

io preferirei per ottenere i numeri come segue per ottenere i numeri reali in almeno in testa.
Devi riassumerle per dividere ciò che ps mostra come RSS e ottenere numeri più precisi da non confondere.

MAPD:

awk '/^[0-9a-f]/{if ($6=="") {anon=1}else{anon=0}} /Private_Dirty/{if(anon) {asum+=$2}else{nasum+=$2}} END{printf "sum=%d\n",asum}' /proc/<pid>/smaps 

MAPC:

awk '/^[0-9a-f]/{if ($6=="") {anon=1}else{anon=0}} /Private_Clean/{if(anon) {asum+=$2}else{nasum+=$2}} END{printf "sum=%d\n",asum}' /proc/<pid>/smaps 

Mnpd: ... e così via

Answer 7

Invece di polling/proc un miliardo di volte al secondo, perché non solo elaborare il uscita da strace?

http://tstarling.com/blog/2010/06/measuring-memory-usage-with-strace/

Answer 8

metriche di memoria accurate possono essere dati da interfaccia del kernel PageMap - utilizzato nella libreria libpagemap https://fedorahosted.org/libpagemap/. La libreria fornisce anche utilità per lo spazio utente in modo da poter avviare immediatamente la memoria del monitor.

Answer 9

un'alternativa migliore per misurare l'uso di picco/acqua alta RSS memoria è lo strumento cgmemtime disponibile qui:

https://github.com/gsauthof/cgmemtime

E 'facile da usare come /usr/bin/tempo e senza il rallentamento da Il massiccio di Valgrind. Inoltre, si basa su un kernel cgroups, quindi è ancora più accurato di altri metodi di polling.