medición de memoria de pico del proceso de larga ejecución en Linux

Question

¿Cómo puedo controlar la memoria pico consumida por un proceso en Linux? Este no es un programa que pueda modificar internamente para medir el uso máximo de la memoria.

Realmente no quiero mediciones detalladas, ni quiero que ralenticen excesivamente mi programa ... así que valgrind o cualquier cosa pesada no es lo que estoy buscando ... Y como otras publicaciones anteriores [Peak memory usage of a linux/unix process, time -v no parece informar la memoria para mi máquina ...

Puedo simplemente ejecutar top o ps y extraer las cadenas de memoria consumidas para mi ID de proceso usando una secuencia de comandos simple. Sin embargo, mi proceso se ejecuta durante unos 20-30 minutos, así que quiero poder registrarme y obtener el máximo. Puedo tolerar muestras de grano grueso ... cada 1 minuto más o menos ... Específicamente, ¿cómo hago yo-> 1. horquilla este simple script de mem-measure en zsh? 2. matarlo cuando finaliza el proceso bajo prueba?

Answer 1

En realidad, lo que dije antes:

"""

tratar

/usr/bin/time -v yourcommand 

que debería ayudar si se utiliza solamente. "Tiempo", golpe del ejecutará el built-in (que no tiene "-v")

"""

no funciona (0 devuelve).

me hizo el siguiente script Perl (que llamé 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 
} 

Y entonces yo lo llamo (por ejemplo, para ver el uso de memoria de qgit):

bash -c './smaps $$ & exec qgit' 

Use comillas simples por lo que el shell "hija" interpreta $$ (que será el mismo PID de qgit después del exec). esta respuesta, me probó :-D

HTH

Answer 2

Se puede usar un plugin de Munin-nodo para hacer esto, pero es un poco pesado. http://munin.projects.linpro.no/

Answer 3

Utilice top -n para repetir un número específico de veces, y -d para demorar entre las actualizaciones. También se puede tomar sólo la salida relevantes para su proceso por el grepping su PID, como:

top -n 30 -d 60 | grep <process-id> 

Lea la página de manual de la parte superior para más información

man top 

Por supuesto, también puede agarrar la columna que necesidad usando awk.

Answer 4

/proc/pid/smaps, como/proc/pid/maps, solo proporciona información acerca de las asignaciones de memoria virtual, no el uso real de la memoria física. top y ps dan el RSS, que (dependiendo de lo que desee saber) puede no ser un buen indicador del uso de la memoria.

Una buena apuesta, si se está ejecutando en un kernel de Linux posterior a 2.6.28.7, es utilizar la función Pagemap. Hay una discusión de esto y la fuente de algunas herramientas en www.eqware.net/Articles/CapturingProcessMemoryUsageUnderLinux.

La herramienta de recopilación de páginas está destinada a capturar el uso de memoria de TODOS los procesos y, por lo tanto, probablemente imponga una carga de CPU mayor a la que desea. Sin embargo, debe poder modificarlo fácilmente, de modo que capture datos solo para una ID de proceso específica. Eso reduciría los gastos generales lo suficiente para que pueda ejecutarlo fácilmente cada pocos segundos. No lo he intentado, pero creo que la herramienta de análisis de páginas debería ejecutarse sin cambios.

EQvan

Answer 5

Valgrind con massif no debe ser demasiado pesado, pero, me gustaría recomendar el uso de/proc. Puede escribir fácilmente su propio script de monitor. Aquí está el mío, para su conveniencia:

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

Answer 6

Esto depende del tipo de memoria que desea monitorear.

La supervisión de la siguiente M.a.p.d ordenando el número de todas las del proceso (no todas las del hilo) le permitirá controlar la memoria física de malloc que utiliza cada proceso.

Puede escribir un programa c para hacerlo aún más rápido pero pensé que awk era la elección mínima para este propósito.

• Ma anónima mapeado de memoria
  • .p privada
    • .D sucia == malloc/mmapped montón y pila asignado y escrita memoria
    • .c == limpia malloc/montón mmapped y pila de memoria una vez asignada, escrita, luego liberada, pero no reclamada todavía
  • .s shared
    • .D sucia == no debe haber ninguna
    • .c limpia == no debe haber ninguna
• Mn llamado memoria mapeada
  • .p privada
    • .d sucio == archivo mmapped memoria escrita privada
    • .c == limpias asignada texto del programa/biblioteca privada asignan
  • .s compartieron
    • .d archivo == sucia mmapped memoria compartida escrita
    • .c == limpias texto biblioteca compartida asignada asignada

yo preferiría para obtener los números de la siguiente manera para obtener los números reales en menos gastos generales.
Tienes que resumir esto para dividir lo que ps muestra como RSS y obtener números más precisos para no confundir.

MAPD:

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 

Mapc:

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 

Mnpd: ... y así sucesivamente

Answer 7

En lugar de sondeo/proc de mil millones de veces por segundo, ¿por qué no procesar la salida de strace?

http://tstarling.com/blog/2010/06/measuring-memory-usage-with-strace/

Answer 8

métricas precisas de memoria se pueden administrar por interfaz del núcleo pagemap - utilizado en la biblioteca libpagemap https://fedorahosted.org/libpagemap/. La biblioteca también proporciona utilidades de espacio de usuario para que pueda iniciar la memoria del monitor de inmediato.

Answer 9

Una mejor alternativa para medir el uso pico/memoria RSS de pleamar es la herramienta cgmemtime disponible aquí:

https://github.com/gsauthof/cgmemtime

Es tan fácil de usar como /usr/bin/tiempo y sin la ralentización de Valgrind's macizo. Además, está basado en un kernel función llamada cgroups, por lo que es incluso más preciso que otros métodos de votación.