Come misurare l'utilizzo effettivo della memoria di un'applicazione o di un processo?

Prova il comando pmap :

Sudo pmap -x <process pid>

Difficile dirlo con certezza, ma qui ci sono due cose "vicine" che possono aiutarti.

$ ps aux 

ti darà Virtual Size (VSZ)

Puoi anche ottenere statistiche dettagliate dal/file system proc andando a /proc/$pid/status

Il più importante è VmSize, che dovrebbe essere vicino a ciò che ps aux dà.

/proc/19420 $ stato del gatto 
 Nome: firefox 
 Stato: S (addormentato) 
 Tgid: 19420 
 Pid: 19420 
 PPid: 1 
 TracerPid: 0 
 Uid: 1000 1000 1000 1000 
 Gid: 1000 1000 1000 1000 
 FDSize: 256 
 Gruppi: 4 6 20 24 25 29 30 44 46 107 109 115 124 1000 
 VmPeak: 222956 kB 
 VmDimensioni: 212520 kB 
 VmLck: 0 kB 
 VmHWM: 127912 kB 
 VmRSS: 118768 kB 
 VmData: 170180 kB 
 VmStk: 228 kB 
 VmExe: 28 kB 
 VmLib: 35424 kB 
 VmPTE: 184 kB 
 Discussioni: 8 
 SigQ: 0/16382 
 SigPnd: 0000000000000000 
 ShdPnd: 0000000000000000 
 SigBlk: 0000000000000000 
 SigIgn: 0000000020001000 
 SigCgt: 000000018000442f 
 CapInh: 0000000000000000 
 CapPrm: 0000000000000000 
 CapEff: 0000000000000000 
 Cpus_allowed: 03 
 Mems_allowed : 1 
 Voluntary_ctxt_switches: 63422 
 nonvoluntary_ctxt_switches: 7171 
 

Nelle ultime versioni di Linux, usa smaps subsystem. Ad esempio, per un processo con un PID di 1234:

cat /proc/1234/smaps

Vi dirà esattamente quanta memoria sta usando in quel momento. Ancora più importante, dividerà la memoria in privato e condivisa, in modo che tu possa sapere quanta memoria usi instance del programma, senza includere la memoria condivisa tra più istanze del programma.

Non esiste un modo semplice per calcolare questo. Ma alcune persone hanno cercato di ottenere delle buone risposte:

• ps_mem.py
• ps_mem.py a github

Usa smem , che è un'alternativa a ps che calcola USS e PSS per processo. Quello che vuoi è probabilmente il PSS.

• USS- Dimensione del set univoco. Questa è la quantità di memoria non condivisa che è unica per quel processo (si pensi a U per unique memoria). Non include la memoria condivisa. Pertanto, in under -reportare la quantità di memoria utilizzata da un processo, ma è utile quando si desidera ignorare la memoria condivisa.

• PSS- Dimensione proporzionale proporzionale. Questo è quello che vuoi. Aggiunge insieme la memoria univoca (USS), insieme ad una parte della sua memoria condivisa divisa per il numero di altri processi che condividono quella memoria. In questo modo fornirà una rappresentazione accurata della quantità di memoria fisica utilizzata per processo, con la memoria condivisa realmente rappresentata come condivisa. Pensa al P essere per physical memoria.

Come questo si confronta con RSS come riportato da ps e altri utilities:

• RSS- Dimensioni set residenti. Questa è la quantità di memoria condivisa più memoria non condivisa utilizzata da ciascun processo. Se alcuni processi condividono la memoria, questo over -reporta la quantità di memoria effettivamente utilizzata, poiché la stessa memoria condivisa verrà conteggiata più di una volta - comparendo nuovamente in ogni altro processo che condivide la stessa memoria. Pertanto è quite inaffidabile, specialmente quando i processi di memoria alta hanno molte forcelle - cosa comune in un server, con processi come Apache o PHP (fastcgi/FPM).

Avviso: smem può anche (facoltativamente) generare grafici come grafici a torta e simili. IMO non hai bisogno di niente di tutto ciò. Se si desidera semplicemente utilizzarlo dalla riga di comando come se fosse possibile utilizzare ps -A v, non è necessario installare la dipendenza consigliata da python-matplotlib.

ps -eo size,pid,user,command --sort -size | \
    awk '{ hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" }' |\
    cut -d "" -f2 | cut -d "-" -f1

Utilizzare questo come root e si può ottenere un chiaro output per l'utilizzo della memoria da parte di ciascun processo.

ESEMPIO DI USCITA:

     0.00 Mb COMMAND 
  1288.57 Mb /usr/lib/firefox
   821.68 Mb /usr/lib/chromium/chromium 
   762.82 Mb /usr/lib/chromium/chromium 
   588.36 Mb /usr/sbin/mysqld 
   547.55 Mb /usr/lib/chromium/chromium 
   523.92 Mb /usr/lib/tracker/tracker
   476.59 Mb /usr/lib/chromium/chromium 
   446.41 Mb /usr/bin/gnome
   421.62 Mb /usr/sbin/libvirtd 
   405.11 Mb /usr/lib/chromium/chromium 
   302.60 Mb /usr/lib/chromium/chromium 
   291.46 Mb /usr/lib/chromium/chromium 
   284.56 Mb /usr/lib/chromium/chromium 
   238.93 Mb /usr/lib/tracker/tracker
   223.21 Mb /usr/lib/chromium/chromium 
   197.99 Mb /usr/lib/chromium/chromium 
   194.07 Mb conky 
   191.92 Mb /usr/lib/chromium/chromium 
   190.72 Mb /usr/bin/mongod 
   169.06 Mb /usr/lib/chromium/chromium 
   155.11 Mb /usr/bin/gnome
   136.02 Mb /usr/lib/chromium/chromium 
   125.98 Mb /usr/lib/chromium/chromium 
   103.98 Mb /usr/lib/chromium/chromium 
    93.22 Mb /usr/lib/tracker/tracker
    89.21 Mb /usr/lib/gnome
    80.61 Mb /usr/bin/gnome
    77.73 Mb /usr/lib/evolution/evolution
    76.09 Mb /usr/lib/evolution/evolution
    72.21 Mb /usr/lib/gnome
    69.40 Mb /usr/lib/evolution/evolution
    68.84 Mb nautilus
    68.08 Mb zeitgeist
    60.97 Mb /usr/lib/tracker/tracker
    59.65 Mb /usr/lib/evolution/evolution
    57.68 Mb apt
    55.23 Mb /usr/lib/gnome
    53.61 Mb /usr/lib/evolution/evolution
    53.07 Mb /usr/lib/gnome
    52.83 Mb /usr/lib/gnome
    51.02 Mb /usr/lib/udisks2/udisksd 
    50.77 Mb /usr/lib/evolution/evolution
    50.53 Mb /usr/lib/gnome
    50.45 Mb /usr/lib/gvfs/gvfs
    50.36 Mb /usr/lib/packagekit/packagekitd 
    50.14 Mb /usr/lib/gvfs/gvfs
    48.95 Mb /usr/bin/Xwayland :1024 
    46.21 Mb /usr/bin/gnome
    42.43 Mb /usr/bin/zeitgeist
    42.29 Mb /usr/lib/gnome
    41.97 Mb /usr/lib/gnome
    41.64 Mb /usr/lib/gvfs/gvfsd
    41.63 Mb /usr/lib/gvfs/gvfsd
    41.55 Mb /usr/lib/gvfs/gvfsd
    41.48 Mb /usr/lib/gvfs/gvfsd
    39.87 Mb /usr/bin/python /usr/bin/chrome
    37.45 Mb /usr/lib/xorg/Xorg vt2 
    36.62 Mb /usr/sbin/NetworkManager 
    35.63 Mb /usr/lib/caribou/caribou 
    34.79 Mb /usr/lib/tracker/tracker
    33.88 Mb /usr/sbin/ModemManager 
    33.77 Mb /usr/lib/gnome
    33.61 Mb /usr/lib/upower/upowerd 
    33.53 Mb /usr/sbin/gdm3 
    33.37 Mb /usr/lib/gvfs/gvfsd
    33.36 Mb /usr/lib/gvfs/gvfs
    33.23 Mb /usr/lib/gvfs/gvfs
    33.15 Mb /usr/lib/at
    33.15 Mb /usr/lib/at
    30.03 Mb /usr/lib/colord/colord 
    29.62 Mb /usr/lib/apt/methods/https 
    28.06 Mb /usr/lib/zeitgeist/zeitgeist
    27.29 Mb /usr/lib/policykit
    25.55 Mb /usr/lib/gvfs/gvfs
    25.55 Mb /usr/lib/gvfs/gvfs
    25.23 Mb /usr/lib/accountsservice/accounts
    25.18 Mb /usr/lib/gvfs/gvfsd 
    25.15 Mb /usr/lib/gvfs/gvfs
    25.15 Mb /usr/lib/gvfs/gvfs
    25.12 Mb /usr/lib/gvfs/gvfs
    25.10 Mb /usr/lib/gnome
    25.10 Mb /usr/lib/gnome
    25.07 Mb /usr/lib/gvfs/gvfsd 
    24.99 Mb /usr/lib/gvfs/gvfs
    23.26 Mb /usr/lib/chromium/chromium 
    22.09 Mb /usr/bin/pulseaudio 
    19.01 Mb /usr/bin/pulseaudio 
    18.62 Mb (sd
    18.46 Mb (sd
    18.30 Mb /sbin/init 
    18.17 Mb /usr/sbin/rsyslogd 
    17.50 Mb gdm
    17.42 Mb gdm
    17.09 Mb /usr/lib/dconf/dconf
    17.09 Mb /usr/lib/at
    17.06 Mb /usr/lib/gvfs/gvfsd
    16.98 Mb /usr/lib/at
    16.91 Mb /usr/lib/gdm3/gdm
    16.86 Mb /usr/lib/gvfs/gvfsd
    16.86 Mb /usr/lib/gdm3/gdm
    16.85 Mb /usr/lib/dconf/dconf
    16.85 Mb /usr/lib/dconf/dconf
    16.73 Mb /usr/lib/rtkit/rtkit
    16.69 Mb /lib/systemd/systemd
    13.13 Mb /usr/lib/chromium/chromium 
    13.13 Mb /usr/lib/chromium/chromium 
    10.92 Mb anydesk 
     8.54 Mb /sbin/lvmetad 
     7.43 Mb /usr/sbin/Apache2 
     6.82 Mb /usr/sbin/Apache2 
     6.77 Mb /usr/sbin/Apache2 
     6.73 Mb /usr/sbin/Apache2 
     6.66 Mb /usr/sbin/Apache2 
     6.64 Mb /usr/sbin/Apache2 
     6.63 Mb /usr/sbin/Apache2 
     6.62 Mb /usr/sbin/Apache2 
     6.51 Mb /usr/sbin/Apache2 
     6.25 Mb /usr/sbin/Apache2 
     6.22 Mb /usr/sbin/Apache2 
     3.92 Mb bash 
     3.14 Mb bash 
     2.97 Mb bash 
     2.95 Mb bash 
     2.93 Mb bash 
     2.91 Mb bash 
     2.86 Mb bash 
     2.86 Mb bash 
     2.86 Mb bash 
     2.84 Mb bash 
     2.84 Mb bash 
     2.45 Mb /lib/systemd/systemd
     2.30 Mb (sd
     2.28 Mb /usr/bin/dbus
     1.84 Mb /usr/bin/dbus
     1.46 Mb ps 
     1.21 Mb openvpn hackthebox.ovpn 
     1.16 Mb /sbin/dhclient 
     1.16 Mb /sbin/dhclient 
     1.09 Mb /lib/systemd/systemd 
     0.98 Mb /sbin/mount.ntfs /dev/sda3 /media/n0bit4/Data 
     0.97 Mb /lib/systemd/systemd 
     0.96 Mb /lib/systemd/systemd 
     0.89 Mb /usr/sbin/smartd 
     0.77 Mb /usr/bin/dbus
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.75 Mb Sudo su 
     0.75 Mb Sudo su 
     0.75 Mb Sudo su 
     0.75 Mb Sudo su 
     0.75 Mb Sudo su 
     0.75 Mb Sudo su 
     0.74 Mb /usr/bin/dbus
     0.71 Mb /usr/lib/apt/methods/http 
     0.68 Mb /bin/bash /usr/bin/mysqld_safe 
     0.68 Mb /sbin/wpa_supplicant 
     0.66 Mb /usr/bin/dbus
     0.61 Mb /lib/systemd/systemd
     0.54 Mb /usr/bin/dbus
     0.46 Mb /usr/sbin/cron 
     0.45 Mb /usr/sbin/irqbalance 
     0.43 Mb logger 
     0.41 Mb awk { hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" } 
     0.40 Mb /usr/bin/ssh
     0.34 Mb /usr/lib/chromium/chrome
     0.32 Mb cut 
     0.32 Mb cut 
     0.00 Mb [kthreadd] 
     0.00 Mb [ksoftirqd/0] 
     0.00 Mb [kworker/0:0H] 
     0.00 Mb [rcu_sched] 
     0.00 Mb [rcu_bh] 
     0.00 Mb [migration/0] 
     0.00 Mb [lru
     0.00 Mb [watchdog/0] 
     0.00 Mb [cpuhp/0] 
     0.00 Mb [cpuhp/1] 
     0.00 Mb [watchdog/1] 
     0.00 Mb [migration/1] 
     0.00 Mb [ksoftirqd/1] 
     0.00 Mb [kworker/1:0H] 
     0.00 Mb [cpuhp/2] 
     0.00 Mb [watchdog/2] 
     0.00 Mb [migration/2] 
     0.00 Mb [ksoftirqd/2] 
     0.00 Mb [kworker/2:0H] 
     0.00 Mb [cpuhp/3] 
     0.00 Mb [watchdog/3] 
     0.00 Mb [migration/3] 
     0.00 Mb [ksoftirqd/3] 
     0.00 Mb [kworker/3:0H] 
     0.00 Mb [kdevtmpfs] 
     0.00 Mb [netns] 
     0.00 Mb [khungtaskd] 
     0.00 Mb [oom_reaper] 
     0.00 Mb [writeback] 
     0.00 Mb [kcompactd0] 
     0.00 Mb [ksmd] 
     0.00 Mb [khugepaged] 
     0.00 Mb [crypto] 
     0.00 Mb [kintegrityd] 
     0.00 Mb [bioset] 
     0.00 Mb [kblockd] 
     0.00 Mb [devfreq_wq] 
     0.00 Mb [watchdogd] 
     0.00 Mb [kswapd0] 
     0.00 Mb [vmstat] 
     0.00 Mb [kthrotld] 
     0.00 Mb [ipv6_addrconf] 
     0.00 Mb [acpi_thermal_pm] 
     0.00 Mb [ata_sff] 
     0.00 Mb [scsi_eh_0] 
     0.00 Mb [scsi_tmf_0] 
     0.00 Mb [scsi_eh_1] 
     0.00 Mb [scsi_tmf_1] 
     0.00 Mb [scsi_eh_2] 
     0.00 Mb [scsi_tmf_2] 
     0.00 Mb [scsi_eh_3] 
     0.00 Mb [scsi_tmf_3] 
     0.00 Mb [scsi_eh_4] 
     0.00 Mb [scsi_tmf_4] 
     0.00 Mb [scsi_eh_5] 
     0.00 Mb [scsi_tmf_5] 
     0.00 Mb [bioset] 
     0.00 Mb [kworker/1:1H] 
     0.00 Mb [kworker/3:1H] 
     0.00 Mb [kworker/0:1H] 
     0.00 Mb [kdmflush] 
     0.00 Mb [bioset] 
     0.00 Mb [kdmflush] 
     0.00 Mb [bioset] 
     0.00 Mb [jbd2/sda5
     0.00 Mb [ext4
     0.00 Mb [kworker/2:1H] 
     0.00 Mb [kauditd] 
     0.00 Mb [bioset] 
     0.00 Mb [drbd
     0.00 Mb [irq/27
     0.00 Mb [i915/signal:0] 
     0.00 Mb [i915/signal:1] 
     0.00 Mb [i915/signal:2] 
     0.00 Mb [ttm_swap] 
     0.00 Mb [cfg80211] 
     0.00 Mb [kworker/u17:0] 
     0.00 Mb [hci0] 
     0.00 Mb [hci0] 
     0.00 Mb [kworker/u17:1] 
     0.00 Mb [iprt
     0.00 Mb [iprt
     0.00 Mb [kworker/1:0] 
     0.00 Mb [kworker/3:0] 
     0.00 Mb [kworker/0:0] 
     0.00 Mb [kworker/2:0] 
     0.00 Mb [kworker/u16:0] 
     0.00 Mb [kworker/u16:2] 
     0.00 Mb [kworker/3:2] 
     0.00 Mb [kworker/2:1] 
     0.00 Mb [kworker/1:2] 
     0.00 Mb [kworker/0:2] 
     0.00 Mb [kworker/2:2] 
     0.00 Mb [kworker/0:1] 
     0.00 Mb [scsi_eh_6] 
     0.00 Mb [scsi_tmf_6] 
     0.00 Mb [usb
     0.00 Mb [bioset] 
     0.00 Mb [kworker/3:1] 
     0.00 Mb [kworker/u16:1] 

Che dire di time?

Non il Bash builtin time ma quello che puoi trovare con which time, ad esempio /usr/bin/time

Ecco cosa copre, su un semplice ls:

$ /usr/bin/time --verbose ls
(...)
Command being timed: "ls"
User time (seconds): 0.00
System time (seconds): 0.00
Percent of CPU this job got: 0%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.00
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): 2372
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 1
Minor (reclaiming a frame) page faults: 121
Voluntary context switches: 2
Involuntary context switches: 9
Swaps: 0
File system inputs: 256
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0

Questo è un eccellente riassunto degli strumenti e dei problemi: archive.org link

Lo citerò, in modo che più sviluppatori lo leggeranno effettivamente.

Se si desidera analizzare l'utilizzo della memoria dell'intero sistema o analizzare a fondo l'utilizzo della memoria di una applicazione (non solo l'utilizzo dell'heap), utilizzare exmap . Per l'analisi di tutto il sistema, trova i processi con il massimo utilizzo effettivo, impiegano la maggior parte della memoria nella pratica, trovano i processi con il più alto utilizzo scrivibile, creano la maggior parte dei dati (e quindi possono perdere o sono molto inefficaci nell'utilizzo dei dati). Seleziona tale applicazione e analizza i suoi mapping nella seconda listview. Vedi la sezione exmap per maggiori dettagli. Usa anche xrestop per controllare l'utilizzo elevato delle risorse X, specialmente se il processo del server X occupa molta memoria. Vedi la sezione xrestop per i dettagli.

Se vuoi rilevare perdite, usa valgrind o possibilmente kmtrace .

Se si desidera analizzare l'utilizzo di heap (malloc, ecc.) Di un'applicazione, eseguirlo in memprof o con kmtrace , tracciare l'applicazione e cercare l'albero delle chiamate della funzione per le allocazioni più grandi. Vedi le loro sezioni per maggiori dettagli.

Oltre alle soluzioni elencate nelle tue risposte, puoi usare il comando Linux "top"; Fornisce una visualizzazione dinamica in tempo reale del sistema in esecuzione, fornisce l'utilizzo della CPU e della memoria, per l'intero sistema insieme per ogni programma, in percentuale:

top

filtrare da un programma pid:

top -p <PID>

filtrare in base al nome di un programma:

top | grep <PROCESS NAME>

"top" fornisce anche alcuni campi come:

VIRT - Immagine virtuale (kb): la quantità totale di memoria virtuale utilizzata dall'attività

RES - Dimensione residente (kb): la memoria fisica non scambiata utilizzata da un'attività; RES = CODICE + DATI.

DATA - Dati + Dimensione dello stack (kb): quantità di memoria fisica dedicata al codice diverso da eseguibile, nota anche come dimensione del "set di dati dei dati" o DRS.

SHR - Shared Mem size (kb): la quantità di memoria condivisa utilizzata da un'attività. Riflette semplicemente la memoria che potrebbe essere potenzialmente condivisa con altri processi.

Riferimento qui .

Non c'è una sola risposta per questo perché non si può puntare con precisione la quantità di memoria utilizzata da un processo. La maggior parte dei processi sotto Linux usano librerie condivise. Ad esempio, supponiamo di voler calcolare l'utilizzo della memoria per il processo "ls". Contate solo la memoria usata dall'eseguibile 'ls' (se poteste isolarlo)? Che ne dici di libc? O tutte queste altre librerie richieste per eseguire "ls"?

linux-gate.so.1 =>  (0x00ccb000)
librt.so.1 => /lib/librt.so.1 (0x06bc7000)
libacl.so.1 => /lib/libacl.so.1 (0x00230000)
libselinux.so.1 => /lib/libselinux.so.1 (0x00162000)
libc.so.6 => /lib/libc.so.6 (0x00b40000)
libpthread.so.0 => /lib/libpthread.so.0 (0x00cb4000)
/lib/ld-linux.so.2 (0x00b1d000)
libattr.so.1 => /lib/libattr.so.1 (0x00229000)
libdl.so.2 => /lib/libdl.so.2 (0x00cae000)
libsepol.so.1 => /lib/libsepol.so.1 (0x0011a000)

Si potrebbe obiettare che sono condivisi da altri processi, ma 'ls' non può essere eseguito sul sistema senza che vengano caricati.

Inoltre, se è necessario conoscere la quantità di memoria necessaria per eseguire la pianificazione della capacità, è necessario calcolare la quantità di ciascuna copia aggiuntiva del processo utilizzata. Penso che/proc/PID/status possa fornire sufficienti informazioni sull'uso della memoria AT una sola volta. D'altra parte, valgrind ti darà un profilo migliore dell'uso della memoria per tutta la durata del programma

Se il tuo codice è in C o C++ potresti essere in grado di usare getrusage() che restituisce varie statistiche sulla memoria e sull'utilizzo del tempo del tuo processo.

Tuttavia, non tutte le piattaforme supportano questo e restituiranno valori 0 per le opzioni di utilizzo della memoria.

Invece puoi guardare il file virtuale creato in /proc/[pid]/statm (dove [pid] è sostituito dal tuo id di processo. Puoi ottenerlo da getpid()).

Questo file apparirà come un file di testo con 7 numeri interi. Probabilmente siete più interessati al primo (tutti gli usi della memoria) e al sesto (utilizzo della memoria dei dati) in questo file.

Valgrind può mostrare informazioni dettagliate ma/ rallenta l'applicazione di destinazione in modo significativo e il più delle volte cambia il comportamento dell'app.
Exmap era qualcosa che non sapevo ancora, ma sembra che tu abbia bisogno di un modulo kernel per ottenere le informazioni, il che può essere un ostacolo.

Presumo che ciò che tutti vogliono sapere WRT "utilizzo della memoria" è il seguente ...
In Linux, la quantità di memoria fisica che un singolo processo potrebbe utilizzare può essere approssimativamente suddivisa in categorie successive.

• M.a memoria mappata anonima

  • .p privato
    • .d dirty == malloc/mmapped heap e stack memoria allocata e scritta
    • .c clean == malloc/mmapped heap e stack di memoria una volta allocati, scritti, quindi liberati, ma non ancora recuperati
  • .s condiviso
    • .d dirty == L'heap malloc/mmaped può ottenere copia-su-scrittura e condiviso tra i processi (modificato)
    • .c clean == L'heap malloc/mmaped può ottenere copia-su-scrittura e condiviso tra i processi (modificato)

• Memoria mappata con nome M.n

  • .p privato
    • .d dirty == file mmapped memoria scritta privata
    • .c clean == mappato programma/libreria testo privato mappato
  • .s condiviso
    • .d dirty == file mmapped memoria scritta condivisa
    • .c clean == testo della libreria mappato condiviso mappato

Utilità inclusa in Android chiamata showmap è abbastanza utile

virtual                    shared   shared   private  private
size     RSS      PSS      clean    dirty    clean    dirty    object
-------- -------- -------- -------- -------- -------- -------- ------------------------------
       4        0        0        0        0        0        0 0:00 0                  [vsyscall]
       4        4        0        4        0        0        0                         [vdso]
      88       28       28        0        0        4       24                         [stack]
      12       12       12        0        0        0       12 7909                    /lib/ld-2.11.1.so
      12        4        4        0        0        0        4 89529                   /usr/lib/locale/en_US.utf8/LC_IDENTIFICATION
      28        0        0        0        0        0        0 86661                   /usr/lib/gconv/gconv-modules.cache
       4        0        0        0        0        0        0 87660                   /usr/lib/locale/en_US.utf8/LC_MEASUREMENT
       4        0        0        0        0        0        0 89528                   /usr/lib/locale/en_US.utf8/LC_TELEPHONE
       4        0        0        0        0        0        0 89527                   /usr/lib/locale/en_US.utf8/LC_ADDRESS
       4        0        0        0        0        0        0 87717                   /usr/lib/locale/en_US.utf8/LC_NAME
       4        0        0        0        0        0        0 87873                   /usr/lib/locale/en_US.utf8/LC_PAPER
       4        0        0        0        0        0        0 13879                   /usr/lib/locale/en_US.utf8/LC_MESSAGES/SYS_LC_MESSAGES
       4        0        0        0        0        0        0 89526                   /usr/lib/locale/en_US.utf8/LC_MONETARY
       4        0        0        0        0        0        0 89525                   /usr/lib/locale/en_US.utf8/LC_TIME
       4        0        0        0        0        0        0 11378                   /usr/lib/locale/en_US.utf8/LC_NUMERIC
    1156        8        8        0        0        4        4 11372                   /usr/lib/locale/en_US.utf8/LC_COLLATE
     252        0        0        0        0        0        0 11321                   /usr/lib/locale/en_US.utf8/LC_CTYPE
     128       52        1       52        0        0        0 7909                    /lib/ld-2.11.1.so
    2316       32       11       24        0        0        8 7986                    /lib/libncurses.so.5.7
    2064        8        4        4        0        0        4 7947                    /lib/libdl-2.11.1.so
    3596      472       46      440        0        4       28 7933                    /lib/libc-2.11.1.so
    2084        4        0        4        0        0        0 7995                    /lib/libnss_compat-2.11.1.so
    2152        4        0        4        0        0        0 7993                    /lib/libnsl-2.11.1.so
    2092        0        0        0        0        0        0 8009                    /lib/libnss_nis-2.11.1.so
    2100        0        0        0        0        0        0 7999                    /lib/libnss_files-2.11.1.so
    3752     2736     2736        0        0      864     1872                         [heap]
      24       24       24        0        0        0       24 [anon]
     916      616      131      584        0        0       32                         /bin/bash
-------- -------- -------- -------- -------- -------- -------- ------------------------------
   22816     4004     3005     1116        0      876     2012 TOTAL

Altri tre metodi da provare:

1. ps aux --sort pmem
   Ordina l'output con %MEM.
2. ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
   Ordina le pipe.
3. top -a
   Inizia l'ordinamento in alto per %MEM

(Estratto da qui )

Sto usando htop; è un ottimo programma di console simile al Task Manager di Windows.

Valgrind è fantastico se hai il tempo di eseguirlo. valgrind --tool=massif è la soluzione giusta.

Tuttavia, sto iniziando a eseguire esempi più grandi e l'uso di valgrind non è più pratico. C'è un modo per dire l'utilizzo massimo della memoria (dimensione della pagina modulo e pagine condivise) di un programma?

Su un vero sistema unix, /usr/bin/time -v funziona. Su Linux, tuttavia, questo fa non funziona.

#!/bin/ksh
#
# Returns total memory used by process $1 in kb.
#
# See /proc/NNNN/smaps if you want to do something
# more interesting.
#

IFS=$'\n'

for line in $(</proc/$1/smaps)
do
   [[ $line =~ ^Size:\s+(\S+) ]] && ((kb += ${.sh.match[1]}))
done

print $kb

Un buon test dell'uso più "reale" è quello di aprire l'applicazione, quindi eseguire vmstat -s e controllare la statistica "memoria attiva". Chiudi l'applicazione, attendi qualche secondo ed esegui di nuovo vmstat -s. Comunque molta memoria attiva è stata liberata in evidentemente in uso dall'app.

Sotto la riga di comando ti darà la memoria totale utilizzata dai vari processi in esecuzione sulla macchina Linux in MB

ps -eo size,pid,user,command --sort -size | awk '{ hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" }' | awk '{total=total + $1} END {print total}'

Se il processo non sta consumando troppa memoria (o perché ci si aspetta che sia così, o qualche altro comando ha dato questa indicazione iniziale), e il processo può sopportare di essere fermato per un breve periodo di tempo, si può provare a usa il comando gcore.

gcore <pid>

Controlla la dimensione del file core generato per avere un'idea di quanta memoria usi un determinato processo.

Questo non funzionerà molto bene se il processo sta usando centinaia di meg, o concerti, poiché la generazione del core potrebbe richiedere diversi secondi o minuti per essere creata a seconda delle prestazioni di I/O. Durante la creazione del core, il processo viene arrestato (o "congelato") per impedire modifiche alla memoria. Quindi sii attento.

Assicurarsi inoltre che il punto di montaggio in cui viene generato il core abbia molto spazio su disco e che il sistema non reagisca negativamente al file principale creato in quella particolare directory.

Sto usando Arch Linux e c'è questo meraviglioso pacchetto chiamato ps_mem

ps_mem -p <pid>

Esempio di output

$ ps_mem -S -p $(pgrep firefox)

Private   +   Shared  =  RAM used   Swap used   Program

355.0 MiB +  38.7 MiB = 393.7 MiB    35.9 MiB   firefox
---------------------------------------------
                        393.7 MiB    35.9 MiB
=============================================

Ottieni valgrind. dargli il tuo programma per l'esecuzione, e ti dirà molto sul suo utilizzo della memoria.

Questo si applicherebbe solo per il caso di un programma che funziona per un po 'di tempo e si ferma. Non so se valgrind possa mettere le mani su un processo già in esecuzione o non dovrebbe interrompere processi come i demoni.

Modifica: funziona al 100% solo quando aumenta il consumo di memoria

Se si desidera monitorare l'utilizzo della memoria in base al processo specificato (o al gruppo di nomi comuni di condivisione elaborati, ad esempio google-chrome, è possibile utilizzare il mio script di bash:

while true; do ps aux | awk ‚{print $5, $11}’ | grep chrome | sort -n > /tmp/a.txt; sleep 1; diff /tmp/{b,a}.txt; mv /tmp/{a,b}.txt; done;

questo cercherà continuamente le modifiche e le stamperà.

Se vuoi qualcosa di più veloce del profiling con Valgrind e il tuo kernel è più vecchio e non puoi usare gli smaps, un ps con le opzioni per mostrare il set residente del processo (con ps -o rss,command) può darti un _aproximation_ rapido e ragionevole del reale quantità di memoria non scambiata utilizzata.

Ti suggerirei di usare in cima. Puoi trovare tutto su di esso su questa pagina . È in grado di fornire tutti i KPI necessari per i processi e può anche acquisire su un file.

Controllare lo script Shell per verificare l'utilizzo della memoria per applicazione in linux . Disponibile anche su github e in una versione senza paste e bc .

Un altro voto per valgrind here, ma vorrei aggiungere che puoi usare uno strumento come Alleyoop per aiutarti a interpretare i risultati generati da valgrind.

Uso sempre i due strumenti e ho sempre un codice snello e senza perdita di tempo da mostrare orgogliosamente;)

Mentre questa domanda sembra riguardare l'esame dei processi attualmente in esecuzione, volevo vedere il picco di memoria utilizzato da un'applicazione dall'inizio alla fine. Oltre a valgrind, puoi usare tstime , che è molto più semplice. Misura l'utilizzo della memoria "highwater" (RSS e virtuale). Da questa risposta .

Utilizzare lo strumento integrato ' system monitor ' GUI disponibile in ubuntu

/ prox/xxx/numa_maps fornisce alcune informazioni lì: N0 = ??? N1 = ???. Ma questo risultato potrebbe essere inferiore al risultato reale, in quanto conta solo quelli che sono stati toccati.

In base alla risposta a una domanda domanda .

È possibile utilizzare SNMP per ottenere l'utilizzo della memoria e della CPU di un processo in un particolare dispositivo nella rete :)

Requisiti:

• il dispositivo che esegue il processo dovrebbe avere snmp installato e funzionante
• snmp deve essere configurato per accettare richieste da cui verrà eseguito lo script di seguito (potrebbe essere configurato in snmpd.conf)
• dovresti conoscere l'id (pid) del processo che vuoi monitorare

Note:

• Host-RESOURCES-MIB :: hrSWRunPerfCPUè il numero di centi-secondi delle risorse della CPU del sistema totale consumate da questo processo. Si noti che su un sistema multiprocessore, questo valore può aumentare di più di un secondo di secondo in un secondo di tempo reale (orologio a muro).

• Host-RESOURCES-MIB :: hrSWRunPerfMemè la quantità totale di memoria di sistema reale allocata a questo processo.

**

Script di monitoraggio del processo:

**

echo "IP: "
read ip
echo "specfiy pid: "
read pid
echo "interval in seconds:"
read interval

while [ 1 ]
do
    date
    snmpget -v2c -c public $ip Host-RESOURCES-MIB::hrSWRunPerfCPU.$pid
    snmpget -v2c -c public $ip Host-RESOURCES-MIB::hrSWRunPerfMem.$pid
    sleep $interval;
done