¿Cómo medir el uso de memoria real de una aplicación o proceso?


712

Esta pregunta está cubierta aquí con gran detalle.

¿Cómo se mide el uso de memoria de una aplicación o proceso en Linux?

Del artículo de blog de Comprender el uso de memoria en Linux , psno es una herramienta precisa para usar con este propósito.

¿Por qué psestá "mal"

Dependiendo de cómo lo mire, psno informa el uso de memoria real de los procesos. Lo que realmente está haciendo es mostrar cuánta memoria real ocuparía cada proceso si fuera el único proceso en ejecución . Por supuesto, una máquina Linux típica tiene varias docenas de procesos ejecutándose en un momento dado, lo que significa que los números VSZ y RSS informados por psson casi definitivamente incorrectos .


66
Esta pregunta probablemente pertenece a serverfault.com en su lugar hoy en día, aunque me dice que es "demasiado vieja para migrar". Aunque en realidad no quiero cerrarlo ...
thomasrutter

Refiérase a esta pregunta. stackoverflow.com/questions/669438/…
Bloodmoon

2
En realidad ps, ni siquiera muestra eso: muestra números de memoria virtual y residente, donde virtual es la cantidad máxima de memoria que el proceso podría usar teóricamente, era el único proceso (nunca), usaba cada página que asignaba (nunca sucede) y no asignó ni desasignó ninguna página (poco probable). Mientras que el residente muestra la cantidad de memoria virtual asignada a la física en este momento. virt > usage > resSin embargo, típicamente en un sistema de 64 bits virt ~= res*10es un rango muy amplio.
Dima Tisnek

55
El extracto del artículo vinculado es una tontería total. El RSS es la memoria física realmente utilizada, y el VSZ puede o no traducirse al uso de la memoria física, incluso si el proceso fue el único en ejecución.
David Schwartz

Respuestas:


356

Con psherramientas similares o similares, solo obtendrá la cantidad de páginas de memoria asignadas por ese proceso. Este número es correcto, pero:

  • no refleja la cantidad real de memoria utilizada por la aplicación, solo la cantidad de memoria reservada para ella

  • puede ser engañoso si las páginas se comparten, por ejemplo, por varios hilos o mediante el uso de bibliotecas vinculadas dinámicamente

Si realmente desea saber qué cantidad de memoria utiliza realmente su aplicación, debe ejecutarla dentro de un generador de perfiles. Por ejemplo, valgrindpuede brindarle información sobre la cantidad de memoria utilizada y, lo que es más importante, sobre las posibles pérdidas de memoria en su programa. La herramienta de perfil de montón de valgrind se llama 'macizo':

Massif es un perfilador de montón. Realiza perfiles detallados de almacenamiento dinámico tomando instantáneas regulares del almacenamiento dinámico de un programa. Produce un gráfico que muestra el uso del montón a lo largo del tiempo, que incluye información sobre qué partes del programa son responsables de la mayoría de las asignaciones de memoria. El gráfico se complementa con un archivo de texto o HTML que incluye más información para determinar dónde se asigna la mayor cantidad de memoria. Massif ejecuta programas aproximadamente 20 veces más lento de lo normal.

Como se explica en la documentación de valgrind , debe ejecutar el programa a través de valgrind:

valgrind --tool=massif <executable> <arguments>

Massif escribe un volcado de instantáneas de uso de memoria (por ejemplo massif.out.12345). Estos proporcionan, (1) una línea de tiempo del uso de la memoria, (2) para cada instantánea, un registro de dónde se asignó la memoria de su programa. Una gran herramienta gráfica para analizar estos archivos es el visualizador macizo . Pero encontréms_print una herramienta simple basada en texto enviada con valgrind ya es de gran ayuda.

Para encontrar pérdidas de memoria, use la memcheckherramienta (predeterminada) de valgrind.


44
Para interpretar los resultados generados por valgrind, puedo recomendar alleyoop. No es demasiado elegante, y le dice simplemente lo que necesita saber para localizar las fuentes de fugas. Un buen par de utilidades.
Dan

66
El artículo (a) es correcto. Hay una diferencia entre las páginas utilizadas y la memoria realmente asignada por la aplicación a través de llamadas a malloc (), nuevas, etc. El uso residente solo muestra la cantidad de memoria paginada que reside en la RAM.
jcoffland el

63
¿Esto realmente no dice cómo obtener el uso de memoria usando valgrind?
Matt Joiner

11
la herramienta valgrind predeterminada, memcheck, es útil para detectar pérdidas de memoria, pero en realidad no es un generador de perfiles de memoria. Para eso, quieres valgrind --tool = massif.
Todd liberado el

3
@DavidSchwartz No veo cómo su declaración contradice la mía. Tengo la sensación de que está demasiado preocupado por su punto de que yo esté "equivocado" en lugar de leer lo que estoy diciendo. Mi punto principal aquí es que RSS es una medida inadecuada para el uso de memoria real de la aplicación, y está haciendo el mismo punto en sus últimas dos oraciones. Realmente, ¿cuál pensaste que era la razón por la que mencioné la reducción de RSS en primer lugar? ¿De modo que me lo deletreas para demostrar que estoy "equivocado" por la cosa exacta a la que me refiero? Tu actitud hacia mí es aburrida.
ypnos

280

Pruebe el comando pmap :

sudo pmap -x <process pid>

45
ejecuta con sudo o no da ningún error y no muestra memoria consumida.
Matt

22
No existe en OSX (para cualquiera que venga de Google)
jcollum

3
Esa es una respuesta completa a la pregunta! PD. En mi shell, pmap puede leer el proceso sin sudo.
MasterControlProgram

77
Re OS X (aparentemente no es asunto del OP), puede ver algunos datos similares usando vmmap (1)
jrg

nota: da una respuesta completamente diferente degnome-system-monitor
ribamar

190

Es difícil decirlo con certeza, pero aquí hay dos cosas "cercanas" que pueden ayudar.

$ ps aux 

le dará tamaño virtual (VSZ)

También puede obtener estadísticas detalladas del sistema de archivos / proc yendo a /proc/$pid/status

Lo más importante es el VmSize, que debe estar cerca de lo que ps auxda.

/ proc / 19420 $ estado del gato
Nombre: firefox
Estado: S (durmiendo)
Tgid: 19420
Pid: 19420
PPid: 1
TracerPid: 0
Uid: 1000 1000 1000 1000
Gid: 1000 1000 1000 1000
FDSize: 256
Grupos: 4 6 20 24 25 29 30 44 46107109115124 1000 
Pico Vm: 222956 kB
Tamaño de Vm: 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
Subprocesos: 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
voluntario_ctxt_interruptores: 63422
nonvoluntary_ctxt_switches: 7171


21
¿Me estoy perdiendo de algo? La pregunta preguntaba cómo medir mejor el uso de memoria por un proceso, dado que VSZ y RSS informados en ps son engañosos. Su respuesta detalla cómo buscar VSZ: el mismo valor que se mencionó como engañoso.
thomasrutter

16
@thomasrutter Sí, te estás perdiendo la pregunta original (rev 1), se ha editado varias veces y es bastante antigua (2008). La pregunta original solo preguntaba cómo medir el uso de memoria de un proceso. Sin embargo, siéntase libre de editar preguntas y respuestas si las cosas están desactualizadas. :)
DustinB

1
nota: da una respuesta completamente diferente degnome-system-monitor
ribamar

131

En versiones recientes de Linux, use el subsistema smaps . Por ejemplo, para un proceso con un PID de 1234:

cat /proc/1234/smaps

Le dirá exactamente cuánta memoria está usando en ese momento. Más importante aún, dividirá la memoria en privada y compartida, para que pueda saber cuánta memoria está usando su instancia del programa, sin incluir la memoria compartida entre múltiples instancias del programa.


Supongo que pmapes una interfaz más simple.
ribamar

126

No hay una manera fácil de calcular esto. Pero algunas personas han tratado de obtener algunas buenas respuestas:


nice genera una lista limpia de memoria y proceso
Rubytastic

Muy agradable, con agrupación bastante inteligente.
Rohmer

Yeap, bastante agradable de hecho. Encuentro ps_memy smemmuy útil para las medidas del usuario final, por ejemplo. pmapLa salida muy detallada está orientada a los desarrolladores ... permite recuperar el uso de la memoria de Firefox para cada fuente, complementos, bibliotecas, por ejemplo. Gracias a todos. @Bash, @thomasruther.
tuk0z

este es hasta ahora el único que coincide con la salida degnome-system-monitor
ribamar

110

Use smem , que es una alternativa a ps que calcula el USS y el PSS por proceso. Lo que quieres es probablemente el PSS.

  • USS : tamaño de conjunto único. Esta es la cantidad de memoria no compartida única para ese proceso (piense en ella como U para memoria única ). No incluye memoria compartida. Así, esta voluntad bajo -report la cantidad de memoria que un proceso de usos, pero es muy útil cuando se quiere hacer caso omiso de memoria compartida.

  • PSS : tamaño de conjunto proporcional. Esto es lo que quieres. Agrega la memoria única (USS), junto con una proporción de su memoria compartida dividida por el número de procesos que comparten esa memoria. Por lo tanto, le dará una representación precisa de cuánta memoria física real se está utilizando por proceso, con la memoria compartida realmente representada como compartida. Piense en el P para la memoria física .

Cómo se compara esto con RSS según lo informado por ps y otras utilidades:

  • RSS - Tamaño de conjunto residente. Esta es la cantidad de memoria compartida más memoria no compartida utilizada por cada proceso. Si alguno de los procesos comparte memoria, esto informará en exceso la cantidad de memoria realmente utilizada, porque la misma memoria compartida se contará más de una vez, apareciendo de nuevo en otro proceso que comparte la misma memoria. Por lo tanto, es poco confiable, especialmente cuando los procesos de alta memoria tienen muchos tenedores, lo cual es común en un servidor, con procesos como Apache o PHP (fastcgi / FPM).

Aviso: smem también puede (opcionalmente) generar gráficos como gráficos circulares y similares. OMI, no necesitas nada de eso. Si solo quiere usarlo desde la línea de comando como si fuera ps -A v, entonces no necesita instalar la dependencia recomendada de python-matplotlib.


2
Un punto crítico sobre RSS es que la mayoría de las aplicaciones en estos días comparten muchas páginas de códigos. Cada biblioteca compartida (por ejemplo, libc y libstdc ++) se contará para cada proceso que la use. Y si hay varias instancias de un proceso en ejecución, todo ese código se contará dos veces.
David C.

1
Precisamente, es por eso que RSS sobre-informa en términos de memoria física real por proceso.
thomasrutter

3
Smem es lo que necesitaba. Al ejecutarlo con -t cada vez que inicio una nueva instancia de proceso, puedo ver la memoria que consume cada instancia. Para Chrome: smem -t -P '/ opt / google / chrome'
xtian

Me está costando trabajo encontrar documentación para smem ... ¿sale en bytes, kilobytes o megabytes por defecto?
ZN13

44
TL; DR: USS = Cantidad de memoria física que se liberará si se mata el proceso, PSS = Cantidad de memoria física que este proceso necesita del sistema si no se matará ningún proceso existente, RSS = Cantidad de memoria física a la que puede acceder este proceso (pero no siempre acceso exclusivo).
Mikko Rantalainen

95
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

Use esto como root y puede obtener una salida clara para el uso de memoria por cada proceso.

EJEMPLO DE SALIDA:

     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] 

1
¿Alguna forma de filtrar la lista para tener solo procesos que usen más del 25% de la memoria durante unos 30 años? Estoy tratando de ver procesos que se escapan, como el navegador Chrome cuando utilizo un depurador PHPEclipse.
Stephane

ese filtro sería increíble
aleix

1
Lo publicaré tan pronto como pueda.
Lokendra Singh Rawat

2
¡Excelente! Pero el bucle debe comenzar desde x=2también a la salida pid y user.
Boris Brodski

70

¿Qué hay de time?

No el Bash incorporado timesino el que puedes encontrar which time, por ejemplo/usr/bin/time

Esto es lo que cubre, en un simple 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

Yo soy también. Es la forma en que uso para perfilar tareas en powercron.eu :)
Moonchild

55
brew install gnu-timeluego úsalo gtimesi estás en macOS.
Nobu

44
Inconveniente: no obtendrá los resultados hasta que el proceso complete su ejecución. No se puede utilizar para la supervisión en tiempo real del proceso en ejecución.
Makesh

/ usr / bin / time -f '% M'
infomaniac

1
También puede invocarlo usando \ time (con una barra invertida para evitar usar el tiempo interno del shell).
Raúl Salinas-Monteagudo

39

Este es un excelente resumen de las herramientas y problemas: enlace archive.org

Lo citaré, para que más desarrolladores lo lean.

Si desea analizar el uso de memoria de todo el sistema o analizar a fondo el uso de memoria de una aplicación (no solo su uso de almacenamiento dinámico), use exmap . Para el análisis de todo el sistema, encuentre procesos con el mayor uso efectivo, toman la mayor cantidad de memoria en la práctica, encuentran procesos con el mayor uso de escritura, crean la mayor cantidad de datos (y, por lo tanto, posiblemente pierden o son muy ineficaces en su uso de datos). Seleccione dicha aplicación y analice sus asignaciones en la segunda vista de lista. Vea la sección exmap para más detalles. También use xrestop para verificar el alto uso de los recursos X, especialmente si el proceso del servidor X requiere mucha memoria. Vea la sección xrestop para más detalles.

Si desea detectar fugas, use valgrind o posiblemente kmtrace .

Si desea analizar el uso del montón (malloc, etc.) de una aplicación, ejecútelo en memprof o con kmtrace , perfile la aplicación y busque en el árbol de llamadas de función las asignaciones más grandes. Vea sus secciones para más detalles.


28

Además de las soluciones enumeradas en tus respuestas, puedes usar el comando de Linux "top"; Proporciona una vista dinámica en tiempo real del sistema en ejecución, proporciona el uso de la CPU y la memoria, para todo el sistema junto con cada programa, en porcentaje:

top

filtrar por un programa pid:

top -p <PID>

para filtrar por un nombre de programa:

top | grep <PROCESS NAME>

"top" también proporciona algunos campos como:

VIRT - Imagen virtual (kb): la cantidad total de memoria virtual utilizada por la tarea

RES - Tamaño residente (kb): la memoria física no intercambiada que una tarea ha utilizado; RES = CÓDIGO + DATOS.

DATOS - Tamaño de datos + pila (kb): la cantidad de memoria física dedicada a otro código que no sea ejecutable, también conocido como el tamaño de 'conjunto residente de datos' o DRS.

SHR - Tamaño de memoria compartida (kb): la cantidad de memoria compartida utilizada por una tarea. Simplemente refleja la memoria que podría compartirse potencialmente con otros procesos.

La referencia aquí .


20

No hay una respuesta única para esto porque no puede determinar con precisión la cantidad de memoria que utiliza un proceso. La mayoría de los procesos en Linux utilizan bibliotecas compartidas. Por ejemplo, supongamos que desea calcular el uso de memoria para el proceso 'ls'. ¿Cuenta solo la memoria utilizada por el ejecutable 'ls' (si pudiera aislarlo)? ¿Qué tal libc? ¿O todas estas otras librerías que se requieren para ejecutar '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)

Se podría argumentar que son compartidos por otros procesos, pero 'ls' no se puede ejecutar en el sistema sin que se carguen.

Además, si necesita saber cuánta memoria necesita un proceso para planificar la capacidad, debe calcular cuánto utiliza cada copia adicional del proceso. Creo que / proc / PID / status podría brindarle suficiente información sobre el uso de la memoria EN una sola vez. Por otro lado, valgrind le dará un mejor perfil del uso de la memoria durante toda la vida útil del programa.


Estoy tratando de encontrar cuánta memoria está tomando un proceso en una VM y quiero usar eso para configurar el límite de memoria en kubernetes, estoy de acuerdo con esta respuesta, por lo que usaré la memoria mostrada porpmap
Deepak Deore

16

Si su código está en C o C ++, puede usarlo, getrusage()que le devuelve varias estadísticas sobre el uso de memoria y tiempo de su proceso.

Sin embargo, no todas las plataformas admiten esto y devolverán valores 0 para las opciones de uso de memoria.

En su lugar, puede mirar el archivo virtual creado en /proc/[pid]/statm(donde [pid]se reemplaza por su ID de proceso. Puede obtenerlo de getpid()).

Este archivo se verá como un archivo de texto con 7 enteros. Probablemente esté más interesado en los números primero (uso de memoria) y sexto (uso de memoria de datos) en este archivo.


Tenga en cuenta que esto no es compatible con todas las plataformas.
CashCow

De acuerdo con la página de manual de Linux ( linux.die.net/man/2/getrusage ), getrusage es parte de las especificaciones SVr4, 4.3BSD y POSIX.1-2001 (señalando que POSIX solo especifica los campos de tiempo y tiempo). I no esperaría que funcione en plataformas que no sean UNIX (excepto, tal vez, a través de un entorno como Cygwin que proporciona capacidades UNIX para otras plataformas)
David C.

@DavidC. el OP pregunta sobre Linux.
Alexis Wilke

@CashCow, quiso decir getpid(), porque no conozco una getprocessid()función en C / C ++ en Linux.
Alexis Wilke

12

Valgrind puede mostrar información detallada, pero ralentiza significativamente la aplicación de destino, y la mayoría de las veces cambia el comportamiento de la aplicación.
Exmap era algo que aún no sabía, pero parece que necesita un módulo del núcleo para obtener la información, lo que puede ser un obstáculo.

Supongo que lo que todo el mundo quiere saber es el "uso de memoria" de WRT: ...
En Linux, la cantidad de memoria física que puede usar un solo proceso puede dividirse aproximadamente en las siguientes categorías.

  • Ma memoria anónima mapeada

    • .p privado
      • .d dirty == malloc / mmapped montón y pila asignada y memoria escrita
      • .c clean == malloc / mmapped heap and stack memory una vez asignado, escrito, luego liberado, pero aún no reclamado
    • .s compartido
      • .d dirty == malloc / mmaped heap podría ser copiado en escritura y compartido entre procesos (editado)
      • .c clean == malloc / mmaped heap podría ser copiado en escritura y compartido entre procesos (editado)
  • Mn llamado memoria asignada

    • .p privado
      • .d sucio == archivo mmapped memoria escrita privada
      • .c clean == programa mapeado / texto de biblioteca privado mapeado
    • .s compartido
      • .d sucio == archivo mmapped memoria escrita compartida
      • .c clean == texto de biblioteca mapeado compartido mapeado

La utilidad incluida en Android llamada showmap es bastante útil

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

10

Tres métodos más para probar:

  1. ps aux --sort pmem
    Ordena la salida por %MEM.
  2. ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
    Se ordena usando tuberías.
  3. top -a
    Comienza la clasificación superior por %MEM

(Extraído de aquí )


2
topy probablemente los otros no dan una representación precisa de la memoria realmente utilizada por el proceso. Por ejemplo, tengo 64GiB de RAM, y tengo 10 postgresprocesos que informan 16GiB RES y 25% MEM. Por supuesto, no todos pueden usar el 25% ... Cada uno también tiene 15GiB SHR, y parece que están compartiendo eso.
sudo

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

55
ksh es un shell estándar. Es posible que no se instale de forma predeterminada en distribuciones de Linux para usuarios de escritorio o para fines minimalistas, pero está a solo un comando de distancia en casi cualquier sistema operativo Unix / Linux. (es decir, en todos los BSD, en todos los UNIX reales, en RHEL, en SLES, en Debian, en Ubuntu, en OSX)
Florian Heigl

Este archivo es accesible, por defecto, solo para el usuario root.
Dmitry Ginzburg

Lo siguiente es solo lo anterior reescrito sed | awky funciona en Busybox v1.23.2: sed -n 's/^Size:\s\+\(\S\+\) .*/\1/p' /proc/$1/smaps | awk '{s+=$1} END {print s}'
Ján Sáreník

1
@Catskul: el estándar POSIX especifica su shell estándar como un subconjunto estricto del shell Korn, una versión mejorada del shell Bourne.
ceph3us

8

Estoy usando htop; Es un muy buen programa de consola similar al Administrador de tareas de Windows.


Utilicé htopy es mejor que top, pero aún así te mostrará todos los hilos de diferentes aplicaciones sin agruparlos, lo que lo hace casi tan inútil como top.
sorin

1
$ htop -p $ (pgrep <nombre de su proceso> | xargs | tr '' ',')
AAAfarmclub

6

Si el proceso no está usando demasiada memoria (ya sea porque espera que sea así, o algún otro comando haya dado esta indicación inicial), y el proceso puede soportar ser detenido por un corto período de tiempo, puede intentar usa el comando gcore.

gcore <pid>

Verifique el tamaño del archivo central generado para tener una buena idea de cuánta memoria está usando un proceso en particular.

Esto no funcionará demasiado bien si el proceso está utilizando cientos de megas o conciertos, ya que la generación del núcleo podría tardar varios segundos o minutos en crearse dependiendo del rendimiento de E / S. Durante la creación del núcleo, el proceso se detiene (o "congela") para evitar cambios en la memoria. Así que ten cuidado.

También asegúrese de que el punto de montaje donde se genera el núcleo tenga suficiente espacio en disco y que el sistema no reaccione negativamente al archivo central que se está creando en ese directorio en particular.


6

Estoy usando Arch Linux y hay este maravilloso paquete llamado ps_mem

ps_mem -p <pid>

Salida de ejemplo

$ 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
=============================================

5

La siguiente línea de comando le dará la memoria total utilizada por los distintos procesos que se ejecutan en la máquina Linux en 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}'

5

Una buena prueba del uso más "real" es abrir la aplicación, luego ejecutar vmstat -sy verificar la estadística de "memoria activa". Cierre la aplicación, espere unos segundos y vmstat -svuelva a ejecutar . Sin embargo, la memoria liberaba mucha memoria activa que evidentemente estaba en uso por la aplicación.


3
¿Cómo sería esto mejor que ps? Viene con todas las limitaciones de ps y es aún más inexacto ...
Lester Cheung

Un sistema Unix típico tiene muchos procesos de inicio y finalización todo el tiempo. No puedes predecir tu RAM libre.
Raúl Salinas-Monteagudo

4

Consigue valgrind. dele su programa para que se ejecute y le informará mucho sobre el uso de la memoria.

Esto se aplicaría solo para el caso de un programa que se ejecuta por un tiempo y se detiene. No sé si valgrind puede tener en sus manos un proceso que ya se está ejecutando o no debería detener procesos como los demonios.


No, no es posible "adjuntar" valgrind a un proceso en ejecución. Eso es por diseño.
Dima Tisnek

3

Editar: esto funciona 100% bien solo cuando aumenta el consumo de memoria

Si desea monitorear el uso de la memoria mediante un proceso determinado (o grupo de nombres comunes compartidos procesados, por ejemplo google-chrome, puede usar mi script 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;

esto buscará cambios continuamente y los imprimirá.

ingrese la descripción de la imagen aquí


3

Si desea algo más rápido que el perfil con Valgrind y su kernel es más antiguo y no puede usar smaps, un ps con las opciones para mostrar el conjunto residente del proceso (con ps -o rss,command) puede darle una cantidad rápida y razonable _aproximation_de la cantidad real de memoria no intercambiada en uso.


3

Te sugiero que lo uses encima. Puede encontrar todo al respecto en esta página . Es capaz de proporcionar todos los KPI necesarios para sus procesos y también puede capturar en un archivo.


2
Para mostrar el PSIZE ["tamaño de memoria proporcional de este proceso (o usuario)] inicie encima de usar atop -R. Para mostrar una inserción resumida por usuario p, para ordenar por uso de memoria, presione 'M' desde dentro. Esto proporciona números similares a smem.
Markus Strauss


1

Otro voto por aquí, pero me gustaría agregar que puede usar una herramienta como Alleyoop para ayudarlo a interpretar los resultados generados por valgrind.

Uso las dos herramientas todo el tiempo y siempre tengo un código delgado y sin fugas para mostrarlo con orgullo;)


1

Si bien esta pregunta parece ser sobre el examen de los procesos que se están ejecutando actualmente, quería ver el pico de memoria utilizado por una aplicación de principio a fin. Además de valgrind, puedes usar tstime , que es mucho más simple. Mide el uso de la memoria "highwater" (RSS y virtual). De esta respuesta .


La mayoría de las aplicaciones, es decir, aquellas que usan malloc () y bibliotecas de memoria similares a malloc, no devuelven páginas al sistema operativo hasta que finaliza el proceso. Por lo tanto, la cantidad que ve con PS (o cualquier otra herramienta que no profundice en el montón del proceso) será la marca más alta.
David C.

0

Basado en la respuesta a una pregunta relacionada .

Puede usar SNMP para obtener el uso de memoria y CPU de un proceso en un dispositivo en particular en la red :)

Requisitos:

  • el dispositivo que ejecuta el proceso debe tener snmp instalado y ejecutándose
  • snmp debe configurarse para aceptar solicitudes desde donde ejecutará el script a continuación (puede configurarse en snmpd.conf)
  • debe conocer la identificación del proceso (pid) del proceso que desea monitorear

Notas:

  • HOST-RESOURCES-MIB :: hrSWRunPerfCPU es la cantidad de centi-segundos de los recursos totales de CPU del sistema consumidos por este proceso. Tenga en cuenta que en un sistema multiprocesador, este valor puede aumentar en más de un centi-segundo en un centi-segundo de tiempo real (reloj de pared).

  • HOST-RESOURCES-MIB :: hrSWRunPerfMem es la cantidad total de memoria real del sistema asignada a este proceso.

** **

Script de monitoreo de procesos:

** **

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

0

/ prox / xxx / numa_maps da alguna información allí: N0 = ??? N1 = ??? Pero este resultado puede ser inferior al resultado real, ya que solo cuenta los que se han tocado.


-1

Use la herramienta GUI incorporada ' monitor de sistema ' disponible en ubuntu


1
Al menos desde 16.04 eso funciona muy bien. Sin embargo, es muy parecido a la parte superior, la memoria utilizada no es extremadamente precisa ...
Alexis Wilke
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.