peak memory-Messung von lang Laufenden Prozess in linux

Wie kann ich überwachen Sie die maximale Speicher verbraucht ein Prozess in Linux?
Dies ist nicht ein Programm, ich kann intern ändern, um zu Messen, peak memory usage.

Ich nicht wirklich wollen, detaillierte Messungen, noch will ich Sie langsam nach unten mein Programm übermäßig.. so valgrind oder irgendetwas Schwergewicht ist nicht das, was ich Suche...
Und wie die anderen Beiträge weiter oben [Maximale Speichernutzung eines linux/unix-Prozess, Zeit -v scheint nicht zu berichten-Speicher für meinen Computer...

Kann ich nur ausführen, top oder ps, und extrahieren Sie die Speicher verbraucht-Saiten
meine Prozess-id mit einem einfachen Skript. Aber mein Prozess läuft für etwa 20-30 Minuten, so dass ich in der Lage sein möchten melden und bekommen die max.
Ich kann tolerieren, grobkörnigen Proben... jeder 1 minute oder so... wie genau muss ich tun->
1. Gabel mit diesem einfachen mem-Messen-Skript in der zsh?
2. töten Sie es, wenn die Prozess-unter-test beendet?

serverfault.com ?

InformationsquelleAutor badkya | 2009-07-03

linux memory

6

Nur mithilfe von top -n zu Durchlaufen, eine bestimmte Anzahl von Zeiten, und -d die Verzögerung zwischen den Aktualisierungen. Sie können auch schnappen Sie sich nur die Ausgabe der entsprechenden Prozess durch grepping der pid, wie:
```
top -n 30 -d 60 | grep <process-id>
```
Lesen Sie die top-Handbuchseite für weitere Informationen
```
man top
```
Natürlich können Sie auch greifen die Spalte, die Sie brauchen mit awk.

InformationsquelleAutor licorna
2

Eigentlich, was ich vorhin gesagt habe:

"""

versuchen
```
/usr/bin/time -v yourcommand
```
dass sollte helfen. wenn Sie nur "mal", bash ausführen wird, der eingebaute (das nicht haben "-v")

"""

funktioniert nicht (Rückgabe 0).

Machte ich das folgende perl-Skript (die ich rief die 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
}
```
Dann nenne ich es (zum Beispiel, zu beobachten, qgit, dass die Speicherauslastung):
```
bash -c './smaps $$ & exec qgit'
```
Verwenden Sie einfache Anführungszeichen, so dass die "Tochter" shell interpretiert $$ (welche die gleiche PID qgit nach der exec). diese Antwort, die ich getestet habe 😀

HTH
- Ausgabe in 2 Stücke... noch immer nicht brauchbar 🙁 User-Zeit (Sekunden): 16.50-System Zeit (Sekunden): 0,47 Prozent der CPU-diesen job bekam: 100% Elapsed (Wanduhr) Zeit (h:mm:ss oder m:ss): 0:16.96 Durchschnitt shared-text-Größe (Kb): 0
- Durchschnittliche ungeteilt Daten Größe (Kb): 0 Durchschnittliche stack size (kbytes): 0 Durchschnitt Gesamt Größe (Kb): 0 Maximum resident set size (kbytes): 0 Durchschnittliche resident set size (kbytes): 0 Große (die I/O -) Seitenfehler: 0 Moll (Aufbau eines frame) Seitenfehler: 255315 Voluntary context switches: 1211 Unfreiwillige Kontextwechsel: 1232-Swaps: 0 Datei-system Eingänge: 0 Datei-system-Ausgänge: 68472 Socket gesendeten Nachrichten: 0 Socket-Nachrichten empfangen: 0 Seite Größe (bytes): 4096
- Speichernutzung Felder nicht ändern, auch wenn ich es für mehr...
InformationsquelleAutor Massa

Valgrind mit Massiv sollte nicht zu schwer sein, aber ich würde empfehlen die Verwendung von /proc. Sie können einfach schreiben Sie Ihre eigenen monitor-Skript. Hier ist meins, für Ihre Bequemlichkeit:

#!/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"

InformationsquelleAutor Davide

1

Könnten Sie einen munin-node-plugin, um dies zu tun, aber es ist ein wenig Schwergewicht. http://munin.projects.linpro.no/

InformationsquelleAutor Michael Sofaer
1

/proc/pid/die smaps, wie /proc/pid/maps, gibt nur Informationen über den virtuellen Speicher-mappings, die nicht die tatsächliche, physikalische Speichernutzung. top und ps geben, die RSS-Feeds, die (je nachdem, was Sie wissen wollen) ist nicht unbedingt ein guter Indikator für die Speichernutzung.

Eine gute Wette, wenn Sie auf einem Linux-kernel, die später als 2.6.28.7, ist die Verwendung der Pagemap-Funktion. Es gibt die Diskussion dieser und die Quelle für einige Werkzeuge an http://www.eqware.net/Articles/CapturingProcessMemoryUsageUnderLinux.

Seite-sammeln-Werkzeug ist gedacht, um zu erfassen Speichernutzung ALLER Prozesse, und so wohl auch erlegt eine höhere CPU-Belastung, als Sie wollen. Sie sollten leicht in der Lage, es zu ändern, jedoch so, dass es erfasst, nur Daten für einen bestimmten Prozess-ID. Das würde den Aufwand zu verringern, genug, so dass Sie könnte leicht führen Sie es alle paar Sekunden. Ich habe es nicht ausprobiert, aber ich denke, die Seite-Analyse-tool ausgeführt werden soll, ohne Veränderung.

EQvan

InformationsquelleAutor
1

Diese hängt davon ab, welche Art von Speicher, den Sie überwachen möchten.

Überwachung der folgenden M. ein.p.d durch die Sortierung die Anzahl der Verfahren ist eins (nicht alle thread ' s) lassen Sie überwachen die malloc physischen Speicher pro Prozess verwendet.

Schreiben Sie ein c-Programm zu machen, noch schneller, aber ich dachte, awk wurde die minimale Wahl für diesen Zweck.
- M. ein anonymer mapped memory
  - .p private
    
    .d dirty == malloc/mmapped dem heap und dem stack reserviert und geschrieben-Speicher
    
    .c = säubern= malloc/mmapped heap-und stack-Speicher, einmal zugewiesen, wird geschrieben, dann befreit, aber nicht zurückgefordert noch
  - .s
    
    .d dirty == es sollte keine
    
    .c clean == es sollte keine
- M. n benannt zugeordneten Speicher
  - .p private
    
    .d dirty == Datei mmapped schriftliche Erinnerung private
    
    .c clean == zugeordnetes Programm/Bibliothek text private zugeordnet
  - .s
    
    .d dirty == Datei mmapped geschrieben Speicher,
    
    .c = säubern= zugeordnete Bibliothek text freigegebenen zugeordnet
Ich würde es vorziehen, um die zahlen wie folgt zu den tatsächlichen zahlen in den am wenigsten overhead.

Sie müssen diese Summe, um zu teilen, was ps zeigt, wie RSS-Feeds und bekommen genauere zahlen nicht zu verwirren.

M. ein.p.d:
```
 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
```
M. ein.p.c:
```
 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
```
M. n.p.d:... und so weiter

InformationsquelleAutor holmes
1

Anstatt polling /proc eine Milliarde mal in der Sekunde, warum nicht einfach ein Prozess der Ausgabe von strace?

http://tstarling.com/blog/2010/06/measuring-memory-usage-with-strace/
- diese berücksichtigen nicht die memory-mapped-Dateien, die wirklich nicht verbrauchen Speicher wie Residenten Speicher.
InformationsquelleAutor Tim Starling
1

Genaue Speicher-Metriken gegeben werden kann, die von pagemap kernel interface - eingesetzt in libpagemap Bibliothek https://fedorahosted.org/libpagemap/. Die Bibliothek bietet auch userspace-utils so können Sie beginnen, monitor, Speicher sofort.

InformationsquelleAutor Bill
1

Bessere alternative zur Messung der peak/high-water-RSS memory usage wird die cgmemtime tool finden Sie hier:

https://github.com/gsauthof/cgmemtime

Es ist so einfach zu bedienen wie /usr/bin/time und ohne die Drosselung von Valgrind ist Massiv.
Außerdem basiert es auf einer kernel feature namens cgroups, so ist es sogar genauer als andere polling-Methoden.

InformationsquelleAutor XICO2KX

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.