Utilizzo massimo della memoria di un processo linux / unix

Esiste uno strumento che eseguirà una riga di comando e segnalerà il picco di utilizzo totale della RAM?

Sto immaginando qualcosa di analogo a / usr / bin / time

Ecco un one-liner che non richiede alcuno script esterno o utility e non ti richiede di avviare il processo tramite un altro programma come Valgrind o time, quindi puoi usarlo per qualsiasi processo che è già in esecuzione:

grep VmPeak /proc/$PID/status

(sostituisci $PIDcon il PID del processo che ti interessa)

[ Modifica : funziona su Ubuntu 14.04: /usr/bin/time -v command assicurati di utilizzare il percorso completo.]

Sembra /usr/bin/timeche ti dia queste informazioni, se passi -v(questo è su Ubuntu 8.10). Vedi, ad esempio, di Maximum resident set sizeseguito:

$ / usr / bin / time -v ls /
....
        Comando temporizzato: "ls /"
        Tempo utente (secondi): 0.00
        Tempo di sistema (secondi): 0.01
        Percentuale di CPU ottenute da questo lavoro: 250%
        Tempo trascorso (orologio da parete) (h: mm: ss o m: ss): 0: 00.00
        Dimensione media del testo condiviso (kbyte): 0
        Dimensione media dei dati non condivisi (kbyte): 0
        Dimensione media dello stack (kbyte): 0
        Dimensione totale media (kbyte): 0
        Dimensione massima impostata per residenti (kbyte): 0
        Dimensione media residente impostata (kbyte): 0
        Errori di pagina principali (che richiedono I / O): 0
        Errori di pagina minori (recupero di una cornice): 315
        Interruttori di contesto volontari: 2
        Interruttori di contesto involontari: 0
        Swap: 0
        Input del file system: 0
        Output del file system: 0
        Messaggi socket inviati: 0
        Messaggi socket ricevuti: 0
        Segnali consegnati: 0
        Dimensione della pagina (byte): 4096
        Stato uscita: 0

(Questa è una vecchia domanda già risposta .. ma solo per la cronaca :)

Sono stato ispirato dalla sceneggiatura di Yang e ho ideato questo piccolo strumento, chiamato memusg . Ho semplicemente aumentato la frequenza di campionamento a 0,1 per gestire processi di vita molto brevi. Invece di monitorare un singolo processo, l'ho fatto misurare la somma rss del gruppo di processi. (Sì, scrivo molti programmi separati che lavorano insieme) Attualmente funziona su Mac OS X e Linux. L'utilizzo doveva essere simile a quello di time:

memusg ls -alR /> / dev / null

Mostra solo il picco per il momento, ma sono interessato a leggere estensioni per la registrazione di altre statistiche (approssimative).

È bello avere uno strumento così semplice per dare un'occhiata prima di iniziare una profilazione seria.

Valgrind one-liner:

valgrind --tool=massif --pages-as-heap=yes --massif-out-file=massif.out ./test.sh; grep mem_heap_B massif.out | sed -e 's/mem_heap_B=\(.*\)/\1/' | sort -g | tail -n 1

Nota l'uso di --pages-as-heap per misurare tutta la memoria in un processo. Maggiori informazioni qui: http://valgrind.org/docs/manual/ms-manual.html

Su Linux:

Utilizzare /usr/bin/time -v <program> <args>e cercare " Dimensione massima impostata per residenti ".

(Da non confondere con il timecomando integrato di Bash ! Quindi usa il percorso completo , /usr/bin/time)

Per esempio:

> /usr/bin/time -v ./myapp
        User time (seconds): 0.00
        . . .
        Maximum resident set size (kbytes): 2792
        . . .

Su BSD, MacOS:

Utilizzare /usr/bin/time -l <program> <args>, cercando " dimensione massima impostata per residenti ":

>/usr/bin/time -l ./myapp
        0.01 real         0.00 user         0.00 sys
      1440  maximum resident set size
      . . .

Forse (gnu) time (1) fa già quello che vuoi. Per esempio:

$ /usr/bin/time -f "%P %M" command
43% 821248

Ma altri strumenti di profilazione possono fornire risultati più accurati a seconda di ciò che stai cercando.

/ usr / bin / time forse fa quello che vuoi, in realtà. Qualcosa di simile a.

 / usr / bin / time --format = '(% Xtext +% Ddata% Mmax)'

Vedi tempo (1) per i dettagli ...

Su MacOS Sierra utilizzare:

/usr/bin/time -l commandToMeasure

Puoi usare grepper prendere quello che vuoi forse.

Se il processo viene eseguito per almeno un paio di secondi, è possibile utilizzare il seguente script bash, che eseguirà la riga di comando indicata, quindi stampa su stderr il picco RSS (in sostituzione di rssqualsiasi altro attributo che ti interessa). È in qualche modo leggero e funziona per me con psincluso in Ubuntu 9.04 (che non posso dire per time).

#!/usr/bin/env bash
"$@" & # Run the given command line in the background.
pid=$! peak=0
while true; do
  sleep 1
  sample="$(ps -o rss= $pid 2> /dev/null)" || break
  let peak='sample > peak ? sample : peak'
done
echo "Peak: $peak" 1>&2

time -f '%M' <run_program>

Bene, se vuoi davvero mostrare il picco di memoria e alcune statistiche più approfondite, ti consiglio di usare un profiler come valgrind . Un bel front-end valgrind è alleyoop .

Puoi usare uno strumento come Valgrind per farlo.

Ecco (in base alle altre risposte) uno script molto semplice che osserva un processo già in esecuzione. Lo esegui semplicemente con il pid del processo che vuoi guardare come argomento:

#!/usr/bin/env bash

pid=$1

while ps $pid >/dev/null
do
    ps -o vsz= ${pid}
    sleep 1
done | sort -n | tail -n1

Esempio di utilizzo:

max_mem_usage.sh 23423

Usa il massiccio: http://valgrind.org/docs/manual/ms-manual.html

Heaptrack è lo strumento di KDE che ha una GUI e un'interfaccia di testo. Trovo più adatto di valgrind capire l'uso della memoria di un processo perché fornisce maggiori dettagli e flamegraph. È anche più veloce perché controlla meno quel valgrind. E ti dà il massimo utilizzo della memoria.

Ad ogni modo, il monitoraggio di rss e vss è fuorviante perché le pagine potrebbero essere condivise, ecco perché memusg. Quello che dovresti davvero fare è monitorare la somma di Pssin /proc/[pid]/smapso use pmap. Il monitor di sistema GNOME era solito farlo, ma era troppo costoso.

Reinventare la ruota, con script bash fatti a mano. Veloce e pulito.

Il mio caso d'uso: volevo monitorare una macchina linux che ha meno RAM e volevo fare un'istantanea dell'utilizzo per container quando viene eseguita in condizioni di utilizzo intenso.

#!/usr/bin/env bash

threshold=$1

echo "$(date '+%Y-%m-%d %H:%M:%S'): Running free memory monitor with threshold $threshold%.."

while(true)
    freePercent=`free -m | grep Mem: | awk '{print ($7/$2)*100}'`    
  do

  if (( $(awk 'BEGIN {print ("'$freePercent'" < "'$threshold'")}') ))
  then
       echo "$(date '+%Y-%m-%d %H:%M:%S'): Free memory $freePercent% is less than $threshold%"
       free -m
       docker stats --no-stream
       sleep 60  
       echo ""  
  else
       echo "$(date '+%Y-%m-%d %H:%M:%S'): Sufficient free memory available: $freePercent%"
  fi
  sleep 30

done

Uscita campione:

12-10-2017 13:29:33: Esecuzione di monitor di memoria libera con soglia del 30% ..

12-10-2017 13:29:33: memoria disponibile sufficiente: 69.4567%

12-10-2017 13:30:03: memoria disponibile sufficiente: 69.4567%

12-10-2017 16:47:02: memoria libera 18.9387% è inferiore al 30%

l'output del comando personalizzato

Su macOS, puoi invece usare DTrace. L'app "Instruments" è una bella GUI per questo, viene fornita con XCode afaik.

'htop' è il miglior comando per vedere quale processo sta usando quanta RAM .....

per maggiori dettagli http://manpages.ubuntu.com/manpages/precise/man1/htop.1.html

Assicurati di rispondere alla domanda. Fornisci dettagli e condividi le tue ricerche!

Scusa, sono la prima volta qui e posso solo fare domande ...

Usato suggerito:

valgrind --tool=massif --pages-as-heap=yes --massif-out-file=massif.out ./test.sh; grep mem_heap_B massif.out | sed -e 's/mem_heap_B=\(.*\)/\1/' | sort -g | tail -n 1

poi:

grep mem_heap_B massif.out
...
mem_heap_B=1150976
mem_heap_B=1150976
...

questo è molto diverso da quello che topmostra il comando in un momento simile:

14673 gu27mox   20   0 3280404 468380  19176 R 100.0  2.9   6:08.84 pwanew_3pic_com

quali sono le unità misurate da Valgrind ??

Il /usr/bin/time -v ./test.shmai risposto: devi alimentare direttamente l'eseguibile per /usr/bin/timepiacere:

/usr/bin/time -v  pwanew_3pic_compass_2008florian3_dfunc.static  card_0.100-0.141_31212_resubmit1.dat_1.140_1.180   1.140 1.180 31212


    Command being timed: "pwanew_3pic_compass_2008florian3_dfunc.static card_0.100-0.141_31212_resubmit1.dat_1.140_1.180 1.140 1.180 31212"

    User time (seconds): 1468.44
    System time (seconds): 7.37
    Percent of CPU this job got: 99%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 24:37.14
    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): 574844
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 74
    Minor (reclaiming a frame) page faults: 468880
    Voluntary context switches: 1190
    Involuntary context switches: 20534
    Swaps: 0
    File system inputs: 81128
    File system outputs: 1264
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0