Monitoreo del uso de memoria de un programa de Python en ejecución

Administrar la memoria es importante en cualquier lógica de programación, pero esto se vuelve necesario para python. Como python se usa en Ml e AI, donde se usan grandes cantidades de datos que deben administrarse. Pérdidas de memoria, es decir, el programa se queda sin memoria después de ejecutarse durante varias horas. Para administrar estas fugas de memoria, el monitoreo de la memoria es esencial. Supervisar la memoria también se denomina creación de perfiles. Como desarrollador, es necesario que perfilemos nuestro programa y usemos menos asignación de memoria tanto como sea posible.

Método 1: Usar Tracemalloc

Tracemalloc es un módulo de biblioteca que rastrea cada bloque de memoria en python. El rastreo comienza usando start() durante el tiempo de ejecución. Este módulo de biblioteca también puede brindar información sobre el tamaño total, el número y el tamaño promedio de los bloques de memoria asignados. Permite su función con un ejemplo apropiado-

# importing the module
import tracemalloc
 
# code or function for which memory
# has to be monitored
def app():
    lt = []
    for i in range(0, 100000):
        lt.append(i)
 
# starting the monitoring
tracemalloc.start()
 
# function call
app()
 
# displaying the memory
print(tracemalloc.get_traced_memory())
 
# stopping the library
tracemalloc.stop()

Producción:

La salida se da en forma de (actual, pico), es decir, la memoria actual es la memoria que el código está usando actualmente y la memoria pico es el espacio máximo que usó el programa durante la ejecución.

(0,3617252)

Método 2: Usando Psutil

Psutil es una biblioteca del sistema Python que se utiliza para realizar un seguimiento de varios recursos en el sistema y su utilización. La biblioteca se utiliza para generar perfiles, limitar y administrar los recursos del proceso. Para instalar esto, haga lo siguiente:

sudo pip install psutil [Linux]
pip install psutill [Windows]

Veamos esto con un ejemplo. Todo lo que tiene que hacer es agregar la función decoradora y la función process_memory en su código y esto le dará la memoria consumida por el código y es antes y después.

# importing libraries
import os
import psutil
 
# inner psutil function
def process_memory():
    process = psutil.Process(os.getpid())
    mem_info = process.memory_info()
    return mem_info.rss
 
# decorator function
def profile(func):
    def wrapper(*args, **kwargs):
 
        mem_before = process_memory()
        result = func(*args, **kwargs)
        mem_after = process_memory()
        print("{}:consumed memory: {:,}".format(
            func.__name__,
            mem_before, mem_after, mem_after - mem_before))
 
        return result
    return wrapper
 
# instantiation of decorator function
@profile
 
# main code for which
# memory has to be monitored
def func():
    x = [1] * (10 ** 7)
    y = [2] * (4 * 10 ** 8)
    del x
    return y
 
func()

Producción:

func: consumed memory: 307,261,440

Método 3: usar el perfilador de memoria clásico 

El perfilador de memoria de PyPI es un módulo de biblioteca de Python que se utiliza para monitorear la memoria del proceso. Utiliza código psutil para crear un decorador y luego lo usa para obtener la distribución de la memoria. Con este módulo pypi al importar uno puede ahorrar líneas y llamar directamente al decorador. Para instalar use lo siguiente-

pip install -U memory_profiler

Veamos esto a través de un código-

# importing the library
from memory_profiler import profile
 
# instantiating the decorator
@profile
# code for which memory has to
# be monitored
def my_func():
    x = [x for x in range(0, 1000)]
    y = [y*100 for y in range(0, 1500)]
    del x
    return y
 
if __name__ == '__main__':
    my_func()

Producción:

La salida muestra la memoria consumida por cada línea del código. La implementación de encontrar el consumo de memoria es muy fácil usando un generador de perfiles de memoria ya que llamamos directamente al decorador en lugar de escribir un código completamente nuevo. 

Line #    Mem usage    Increment  Occurences   Line Contents
============================================================
     2     30.5 MiB     30.5 MiB           1   @profile
     3                                         def my_func():
     4     30.6 MiB      0.1 MiB        1003       x = [x for x in range(0,1000)]
     5     30.7 MiB      0.1 MiB        1503       y = [y*100 for y in range(0,1500)]
     6     30.7 MiB      0.0 MiB           1       del x
     7     30.7 MiB      0.0 MiB           1       return y