lenguaje - Python equivalente de memory_get_usage()?

python wikipedia

Question

Ya encontré la siguiente pregunta , pero me preguntaba si habría una forma más rápida y más sucia de obtener una estimación de la cantidad de memoria que el intérprete de Python está usando actualmente para mi script que no depende de bibliotecas externas.

Vengo de PHP y solía usar memory_get_usage() y memory_get_peak_usage() mucho para este propósito y esperaba encontrar un equivalente.

Answer 1

Reglas de respuesta aceptadas, pero podría ser más fácil (y más portátil) usar psutil . Hace lo mismo y mucho más.

ACTUALIZACIÓN: muppy también es muy conveniente (y está mucho mejor documentado que guppy / heapy).

Answer 2

También puede usar la función getrusage() del resource módulo de biblioteca estándar. El objeto resultante tiene el atributo ru_maxrss , que proporciona el uso de memoria total para el proceso de llamada:

>>> import resource
>>> resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
2656

Los documentos de Python no tienen claro cuáles son exactamente las unidades, pero la página de getrusage(2) Mac OS X para getrusage(2) describe las unidades como kilobytes.

La página de manual de Linux no está clara, pero parece ser equivalente a la información de /proc/self/status (es decir, kilobytes) descrita en la respuesta aceptada. Para el mismo proceso anterior, que se ejecuta en Linux, la función enumerada en la respuesta aceptada proporciona:

>>> memory_usage()
{''peak'': 6392, ''rss'': 2656}

Puede que no sea tan fácil de usar como la solución /proc/self/status , pero es una biblioteca estándar, por lo que (siempre que las unidades sean estándar) debe ser multiplataforma y se puede utilizar en sistemas que carecen de /proc/ ( por ejemplo, Mac OS X y otros Unixes, tal vez Windows).

Además, a la función getrusage() también se le puede getrusage() resource.RUSAGE_CHILDREN para obtener el uso para procesos secundarios, y (en algunos sistemas) resource.RUSAGE_BOTH para el uso total del proceso (propio y secundario).

Esto cubrirá el caso memory_get_usage() , pero no incluye el uso máximo. No estoy seguro de si alguna otra función del módulo de resource puede dar un uso máximo.

Answer 3

prueba heapy

Answer 4

/proc/self/status tiene las siguientes claves relevantes:

• VmPeak : Tamaño máximo de memoria virtual.
• VmSize : Tamaño de memoria virtual.
• VmHWM : Tamaño máximo del conjunto residente ("marca de límite superior").
• VmRSS : Tamaño del conjunto residente.

Entonces, si la preocupación es la memoria residente, el siguiente código puede usarse para recuperarla:

def get_proc_status(keys = None):
with open(''/proc/self/status'') as f:
data = dict(map(str.strip, line.split('':'', 1)) for line in f)
return tuple(data[k] for k in keys) if keys else data
peak, current = get_proc_status((''VmHWM'', ''VmRSS''))
print(peak, current) # outputs: 14280 kB 13696 kB

Aquí hay un artículo del autor de memory_profiler que explica que getrusage de ru_maxrss no es siempre una medida práctica. También tenga en cuenta que, VmHWM puede diferir de ru_maxrss (lo que veo en algunos casos ru_maxrss es mayor). Pero en el caso simple son lo mismo:

import resource
def report():
maxrss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
peak, current = get_proc_status((''VmHWM'', ''VmRSS''))
print(current, peak, maxrss)
report()
s = '' '' * 2 ** 28 # 256MiB
report()
s = None
report()

Además, aquí hay un estudio de caso muy comprensible pero informativo por parte de autores que explica qué es el kernel, la memoria virtual y la memoria residente, y cómo son interdependientes.

Answer 5

Una solución simple para Linux y otros sistemas con /proc/self/status es el siguiente código, que uso en un proyecto mío:

def memory_usage():
"""Memory usage of the current process in kilobytes."""
status = None
result = {''peak'': 0, ''rss'': 0}
try:
# This will only work on systems with a /proc file system
# (like Linux).
status = open(''/proc/self/status'')
for line in status:
parts = line.split()
key = parts[0][2:-1].lower()
if key in result:
result[key] = int(parts[1])
finally:
if status is not None:
status.close()
return result

Devuelve el tamaño actual y máximo de la memoria residente (que es probablemente lo que las personas quieren decir cuando hablan de la cantidad de RAM que usa una aplicación). Es fácil extenderlo para obtener otros datos del archivo /proc/self/status .

Para los curiosos: la salida completa de cat /proc/self/status ve así:

% cat /proc/self/status
Name: cat
State: R (running)
Tgid: 4145
Pid: 4145
PPid: 4103
TracerPid: 0
Uid: 1000 1000 1000 1000
Gid: 1000 1000 1000 1000
FDSize: 32
Groups: 20 24 25 29 40 44 46 100 1000
VmPeak: 3580 kB
VmSize: 3580 kB
VmLck: 0 kB
VmHWM: 472 kB
VmRSS: 472 kB
VmData: 160 kB
VmStk: 84 kB
VmExe: 44 kB
VmLib: 1496 kB
VmPTE: 16 kB
Threads: 1
SigQ: 0/16382
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: 0000000000000000
SigIgn: 0000000000000000
SigCgt: 0000000000000000
CapInh: 0000000000000000
CapPrm: 0000000000000000
CapEff: 0000000000000000
CapBnd: ffffffffffffffff
Cpus_allowed: 03
Cpus_allowed_list: 0-1
Mems_allowed: 1
Mems_allowed_list: 0
voluntary_ctxt_switches: 0
nonvoluntary_ctxt_switches: 0