suma - Seguimiento*uso de memoria*máximo por una función de Python

mclibre funciones python

Question

Quiero averiguar cuál es la cantidad máxima de RAM asignada durante la llamada a una función (en Python). Hay otras preguntas sobre SO relacionadas con el seguimiento del uso de RAM:

¿Qué perfil de memoria Python se recomienda?

¿Cómo perfilo el uso de la memoria en Python?

pero parece que le permiten seguir el uso de la memoria en el momento en que se llama al método de heap() (en el caso de guppy). Sin embargo, lo que quiero rastrear es una función en una biblioteca externa que no puedo modificar, y que crece para usar mucha RAM, pero luego la libera una vez que se completa la ejecución de la función. ¿Hay alguna forma de averiguar cuál era la cantidad total de RAM utilizada durante la llamada a la función?

Answer 1

Es posible hacer esto con memory_profiler . La función memory_usage devuelve una lista de valores, estos representan el uso de la memoria a lo largo del tiempo (por defecto en fragmentos de .1 segundo). Si necesita el máximo, solo tome el máximo de esa lista. Pequeño ejemplo:

from memory_profiler import memory_usage
from time import sleep

def f():
    # a function that with growing
    # memory consumption
    a = [0] * 1000
    sleep(.1)
    b = a * 100
    sleep(.1)
    c = b * 100
    return a

mem_usage = memory_usage(f)
print(''Memory usage (in chunks of .1 seconds): %s'' % mem_usage)
print(''Maximum memory usage: %s'' % max(mem_usage))

En mi caso (memory_profiler 0.25) si imprime el siguiente resultado:

Memory usage (in chunks of .1 seconds): [45.65625, 45.734375, 46.41015625, 53.734375]
Maximum memory usage: 53.734375

Answer 2

Esta pregunta me pareció bastante interesante y me dio una razón para mirar a Guppy / Heapy, por eso te agradezco.

Intenté durante aproximadamente 2 horas hacer que Heapy supervisara una llamada / proceso de función sin modificar su fuente sin suerte.

Encontré una manera de lograr su tarea usando el resource biblioteca incorporado de Python. Tenga en cuenta que la documentación no indica qué RU_MAXRSS valor RU_MAXRSS . Otro usuario de SO noted que estaba en kB. Ejecutando Mac OSX 7.3 y observando los recursos de mi sistema subir durante el código de prueba a continuación, creo que los valores devueltos están en Bytes , no en kBytes.

Una vista de 10000 pies sobre cómo utilicé la biblioteca de resource para monitorear la llamada a la biblioteca fue para iniciar la función en un subproceso independiente (monitorizable) y rastrear los recursos del sistema para ese proceso en el hilo principal. A continuación tengo los dos archivos que necesitaría ejecutar para probarlo.

Monitor de recursos de biblioteca - whatever_you_want.py

import resource
import time

from stoppable_thread import StoppableThread


class MyLibrarySniffingClass(StoppableThread):
    def __init__(self, target_lib_call, arg1, arg2):
        super(MyLibrarySniffingClass, self).__init__()
        self.target_function = target_lib_call
        self.arg1 = arg1
        self.arg2 = arg2
        self.results = None

    def startup(self):
        # Overload the startup function
        print "Calling the Target Library Function..."

    def cleanup(self):
        # Overload the cleanup function
        print "Library Call Complete"

    def mainloop(self):
        # Start the library Call
        self.results = self.target_function(self.arg1, self.arg2)

        # Kill the thread when complete
        self.stop()

def SomeLongRunningLibraryCall(arg1, arg2):
    max_dict_entries = 2500
    delay_per_entry = .005

    some_large_dictionary = {}
    dict_entry_count = 0

    while(1):
        time.sleep(delay_per_entry)
        dict_entry_count += 1
        some_large_dictionary[dict_entry_count]=range(10000)

        if len(some_large_dictionary) > max_dict_entries:
            break

    print arg1 + " " +  arg2
    return "Good Bye World"

if __name__ == "__main__":
    # Lib Testing Code
    mythread = MyLibrarySniffingClass(SomeLongRunningLibraryCall, "Hello", "World")
    mythread.start()

    start_mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
    delta_mem = 0
    max_memory = 0
    memory_usage_refresh = .005 # Seconds

    while(1):
        time.sleep(memory_usage_refresh)
        delta_mem = (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss) - start_mem
        if delta_mem > max_memory:
            max_memory = delta_mem

        # Uncomment this line to see the memory usuage during run-time 
        # print "Memory Usage During Call: %d MB" % (delta_mem / 1000000.0)

        # Check to see if the library call is complete
        if mythread.isShutdown():
            print mythread.results
            break;

    print "/nMAX Memory Usage in MB: " + str(round(max_memory / 1000.0, 3))

Hilo stoppable_thread.py - stoppable_thread.py

import threading
import time

class StoppableThread(threading.Thread):
    def __init__(self):
        super(StoppableThread, self).__init__()
        self.daemon = True
        self.__monitor = threading.Event()
        self.__monitor.set()
        self.__has_shutdown = False

    def run(self):
        ''''''Overloads the threading.Thread.run''''''
        # Call the User''s Startup functions
        self.startup()

        # Loop until the thread is stopped
        while self.isRunning():
            self.mainloop()

        # Clean up
        self.cleanup()

        # Flag to the outside world that the thread has exited
        # AND that the cleanup is complete
        self.__has_shutdown = True

    def stop(self):
        self.__monitor.clear()

    def isRunning(self):
        return self.__monitor.isSet()

    def isShutdown(self):
        return self.__has_shutdown


    ###############################
    ### User Defined Functions ####
    ###############################

    def mainloop(self):
        ''''''
        Expected to be overwritten in a subclass!!
        Note that Stoppable while(1) is handled in the built in "run".
        ''''''
        pass

    def startup(self):
        ''''''Expected to be overwritten in a subclass!!''''''
        pass

    def cleanup(self):
        ''''''Expected to be overwritten in a subclass!!''''''
        pass

Answer 3

Esto parece funcionar en Windows. No sé sobre otros sistemas operativos.

In [50]: import os

In [51]: import psutil

In [52]: process = psutil.Process(os.getpid())

In [53]: process.get_ext_memory_info().peak_wset
Out[53]: 41934848

Answer 4

He estado luchando con esta tarea también. Después de experimentar con psutil y métodos de Adam, escribí una función (créditos a Adam Lewis) para medir la memoria utilizada por una función específica. Las personas pueden encontrar más fácil de agarrar y usar.

1) measure_memory_usage

2) prueba measure_memory_usage

Descubrí que los materiales sobre el uso de subprocesos y la superclase primordial son realmente útiles para comprender lo que Adam está haciendo en sus guiones. Lo siento, no puedo publicar los enlaces debido a mi limitación máxima de "2 enlaces".

Answer 5

Puede usar el recurso de la biblioteca de Python para obtener el uso de la memoria.

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

Dará uso de memoria en kilobytes, para convertir en MB divide por 1000.