Respuestas:
Aquí hay una línea que no requiere scripts o utilidades externas y no requiere que inicie el proceso a través de otro programa como Valgrind o tiempo, por lo que puede usarlo para cualquier proceso que ya se esté ejecutando:
grep VmPeak /proc/$PID/status
(reemplazar $PID
con el PID del proceso que le interesa)
[ Editar : funciona en Ubuntu 14.04: /usr/bin/time -v command
asegúrese de utilizar la ruta completa.]
Parece /usr/bin/time
que te da esa información, si la pasas -v
(esto está en Ubuntu 8.10). Ver, por ejemplo, a Maximum resident set size
continuación:
$ / usr / bin / time -v ls / .... Comando cronometrado: "ls /" Tiempo de usuario (segundos): 0.00 Tiempo del sistema (segundos): 0.01 Porcentaje de CPU que obtuvo este trabajo: 250% Tiempo transcurrido (reloj de pared) (h: mm: ss o m: ss): 0: 00.00 Tamaño promedio de texto compartido (kbytes): 0 Tamaño promedio de datos no compartidos (kbytes): 0 Tamaño de pila promedio (kbytes): 0 Tamaño total promedio (kbytes): 0 Tamaño máximo del conjunto residente (kbytes): 0 Tamaño promedio del conjunto residente (kbytes): 0 Fallos de página principales (que requieren E / S): 0 Fallos de página menores (reclamar un marco): 315 Cambios de contexto voluntarios: 2 Cambios de contexto involuntarios: 0 Swaps: 0 Entradas del sistema de archivos: 0 Salidas del sistema de archivos: 0 Mensajes de socket enviados: 0 Mensajes de socket recibidos: 0 Señales entregadas: 0 Tamaño de página (bytes): 4096 Estado de salida: 0
/bin/time -v
lo resuelve
time -l
en MacOS, ofrece resultados similares.
(Esta es una pregunta antigua ya respondida ... pero solo para el registro :)
Me inspiró el guión de Yang y se me ocurrió esta pequeña herramienta, llamada memusg . Simplemente aumenté la frecuencia de muestreo a 0.1 para manejar procesos de vida muy cortos. En lugar de monitorear un solo proceso, lo hice medir la primera suma del grupo de procesos. (Sí, escribo muchos programas separados que funcionan juntos) Actualmente funciona en Mac OS X y Linux. El uso tenía que ser similar al de time
:
memusg ls -alR /> / dev / null
Solo muestra el pico por el momento, pero estoy interesado en pequeñas extensiones para registrar otras estadísticas (aproximadas).
Es bueno tener una herramienta tan simple para echar un vistazo antes de comenzar cualquier perfil serio.
ps -o rss=
donde rss es el tamaño de la memoria real (conjunto residente) del proceso (en unidades de 1024 bytes) desde mi página de manual de BSD.
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
Tenga en cuenta el uso de --pages-as-heap para medir toda la memoria en un proceso. Más información aquí: http://valgrind.org/docs/manual/ms-manual.html
time
, Te estoy dejando.
valgrind --massif
. También puede usar la ms_print
herramienta que viene con ella para obtener resultados útiles (incluyendo gráficos ascii de uso a lo largo del tiempo)
time
sin embargo, tomando al menos 10 veces más tiempo en un comando como ls
.
En Linux:
Use /usr/bin/time -v <program> <args>
y busque " Tamaño máximo de conjunto residente ".
(No debe confundirse con el Golpe time
comando integrado! Así que utilice la ruta completa , /usr/bin/time
)
Por ejemplo:
> /usr/bin/time -v ./myapp
User time (seconds): 0.00
. . .
Maximum resident set size (kbytes): 2792
. . .
En BSD, MacOS:
Uso /usr/bin/time -l <program> <args>
, buscando " tamaño máximo de conjunto residente ":
>/usr/bin/time -l ./myapp
0.01 real 0.00 user 0.00 sys
1440 maximum resident set size
. . .
sudo apt-get install time
Quizás (gnu) el tiempo (1) ya hace lo que quieres. Por ejemplo:
$ /usr/bin/time -f "%P %M" command
43% 821248
Pero otras herramientas de creación de perfiles pueden proporcionar resultados más precisos según lo que esté buscando.
time
es un comando integrado cuando se usa csh
. Si usa la ruta exacta, le permitirá ejecutar el comando externo. Hasta donde sé, solo la versión GNU admite la opción de formato.
/ usr / bin / time tal vez hace lo que quieres, en realidad. Algo como.
/ usr / bin / time --format = '(% Xtext +% Ddata% Mmax)'
Vea el tiempo (1) para más detalles ...
En MacOS Sierra use:
/usr/bin/time -l commandToMeasure
Puede usar grep
para tomar lo que quiera, tal vez.
command time -l
lugar de lo /usr/bin/time -l
que hará que su shell realmente llame a un binario llamado en time
lugar de la función incorporada. (Sí, command
no es un marcador de posición, command time
es diferente de solo time
).
Si el proceso se ejecuta durante al menos un par de segundos, puede usar el siguiente script bash, que ejecutará la línea de comando dada y luego imprimirá para stderr el pico RSS (sustituya rss
cualquier otro atributo que le interese). Es algo ligero y funciona para mí con el ps
incluido en Ubuntu 9.04 (que no puedo decir 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
Puede usar una herramienta como Valgrind para hacer esto.
Aquí hay (basado en las otras respuestas) un script muy simple que observa un proceso que ya se está ejecutando. Simplemente lo ejecuta con el pid del proceso que desea ver como argumento:
#!/usr/bin/env bash
pid=$1
while ps $pid >/dev/null
do
ps -o vsz= ${pid}
sleep 1
done | sort -n | tail -n1
Ejemplo de uso:
max_mem_usage.sh 23423
Use Massif: http://valgrind.org/docs/manual/ms-manual.html
Heaptrack es una herramienta de KDE que tiene una interfaz gráfica de usuario y una interfaz de texto. Me parece más adecuado que valgrind comprender el uso de memoria de un proceso porque proporciona más detalles y gráficos de llamas. También es más rápido porque controla menos ese valor. Y te da el uso máximo de memoria.
De todos modos, el seguimiento de rss y vss es engañoso porque las páginas podrían compartirse, por eso memusg
. Lo que realmente debe hacer es realizar un seguimiento de la suma de Pss
in /proc/[pid]/smaps
o use pmap
. El monitor de sistema GNOME solía hacerlo, pero era demasiado costoso.
Reinventar la rueda, con guión de bash hecho a mano. Rápido y limpio.
Mi caso de uso: quería monitorear una máquina Linux que tiene menos RAM y quería tomar una instantánea del uso por contenedor cuando se ejecuta bajo un uso intensivo.
#!/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
Salida de muestra:
2017-10-12 13:29:33: Ejecución de monitor de memoria libre con umbral 30%.
2017-10-12 13:29:33: Suficiente memoria libre disponible: 69.4567%
2017-10-12 13:30:03: Suficiente memoria libre disponible: 69.4567%
2017-10-12 16:47:02: memoria libre 18.9387% es inferior al 30%
su salida de comando personalizado
En macOS, puede usar DTrace en su lugar. La aplicación "Instrumentos" es una buena GUI para eso, viene con XCode afaik.
'htop' es el mejor comando para ver qué proceso está usando cuánta RAM .....
para más detalles http://manpages.ubuntu.com/manpages/precise/man1/htop.1.html
Asegúrate de responder la pregunta. ¡Proporcione detalles y comparta su investigación!
Lo siento, estoy aquí por primera vez y solo puedo hacer preguntas ...
Usado sugerido:
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
entonces:
grep mem_heap_B massif.out
...
mem_heap_B=1150976
mem_heap_B=1150976
...
Esto es muy diferente de lo que top
muestra el comando en un momento similar:
14673 gu27mox 20 0 3280404 468380 19176 R 100.0 2.9 6:08.84 pwanew_3pic_com
¿Cuáles son las unidades medidas de Valgrind?
La /usr/bin/time -v ./test.sh
contestado a - debe alimentar directamente ejecutable /usr/bin/time
como:
/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