objetos - manejo de memoria en python

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

Question

Recientemente me interesaron los algoritmos y comencé a explorarlos escribiendo una implementación ingenua y luego optimizándola de varias maneras.

Ya estoy familiarizado con el módulo estándar de Python para perfilar el tiempo de ejecución (para la mayoría de las cosas he encontrado que la función timeit magic en IPython es suficiente), pero también me interesa el uso de la memoria para poder explorar esos intercambios también ( por ejemplo, el costo de almacenar en caché una tabla de valores previamente calculados versus volver a calcularlos según sea necesario). ¿Hay algún módulo que describa el uso de memoria de una función determinada para mí?

Answer 1

A continuación se muestra un decorador de funciones simple que permite rastrear la cantidad de memoria consumida antes de la llamada a la función, después de la llamada a la función, y cuál es la diferencia:

import time
import os
import psutil


def elapsed_since(start):
    return time.strftime("%H:%M:%S", time.gmtime(time.time() - start))


def get_process_memory():
    process = psutil.Process(os.getpid())
    return process.get_memory_info().rss


def profile(func):
    def wrapper(*args, **kwargs):
        mem_before = get_process_memory()
        start = time.time()
        result = func(*args, **kwargs)
        elapsed_time = elapsed_since(start)
        mem_after = get_process_memory()
        print("{}: memory before: {:,}, after: {:,}, consumed: {:,}; exec time: {}".format(
            func.__name__,
            mem_before, mem_after, mem_after - mem_before,
            elapsed_time))
        return result
    return wrapper

Aquí está mi blog que describe todos los detalles.

Answer 2

Este ya ha sido respondido aquí: Python memory profiler

Básicamente, haces algo así (citado de Guppy-PE ):

>>> from guppy import hpy; h=hpy()
>>> h.heap()
Partition of a set of 48477 objects. Total size = 3265516 bytes.
 Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0  25773  53  1612820  49   1612820  49 str
     1  11699  24   483960  15   2096780  64 tuple
     2    174   0   241584   7   2338364  72 dict of module
     3   3478   7   222592   7   2560956  78 types.CodeType
     4   3296   7   184576   6   2745532  84 function
     5    401   1   175112   5   2920644  89 dict of class
     6    108   0    81888   3   3002532  92 dict (no owner)
     7    114   0    79632   2   3082164  94 dict of type
     8    117   0    51336   2   3133500  96 type
     9    667   1    24012   1   3157512  97 __builtin__.wrapper_descriptor
<76 more rows. Type e.g. ''_.more'' to view.>
>>> h.iso(1,[],{})
Partition of a set of 3 objects. Total size = 176 bytes.
 Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
     0      1  33      136  77       136  77 dict (no owner)
     1      1  33       28  16       164  93 list
     2      1  33       12   7       176 100 int
>>> x=[]
>>> h.iso(x).sp
 0: h.Root.i0_modules[''__main__''].__dict__[''x'']
>>> 

Answer 3

Para un enfoque realmente simple, intente:

import resource
def using(point=""):
    usage=resource.getrusage(resource.RUSAGE_SELF)
    return ''''''%s: usertime=%s systime=%s mem=%s mb
           ''''''%(point,usage[0],usage[1],
                (usage[2]*resource.getpagesize())/1000000.0 )

Simplemente inserte using("Label") donde desea ver lo que está pasando.

Answer 4

Python 3.4 incluye un nuevo módulo: tracemalloc . Proporciona estadísticas detalladas sobre qué código está asignando la mayor cantidad de memoria. Aquí hay un ejemplo que muestra las tres líneas principales que asignan memoria.

from collections import Counter
import linecache
import os
import tracemalloc

def display_top(snapshot, key_type=''lineno'', limit=3):
    snapshot = snapshot.filter_traces((
        tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
        tracemalloc.Filter(False, "<unknown>"),
    ))
    top_stats = snapshot.statistics(key_type)

    print("Top %s lines" % limit)
    for index, stat in enumerate(top_stats[:limit], 1):
        frame = stat.traceback[0]
        # replace "/path/to/module/file.py" with "module/file.py"
        filename = os.sep.join(frame.filename.split(os.sep)[-2:])
        print("#%s: %s:%s: %.1f KiB"
              % (index, filename, frame.lineno, stat.size / 1024))
        line = linecache.getline(frame.filename, frame.lineno).strip()
        if line:
            print(''    %s'' % line)

    other = top_stats[limit:]
    if other:
        size = sum(stat.size for stat in other)
        print("%s other: %.1f KiB" % (len(other), size / 1024))
    total = sum(stat.size for stat in top_stats)
    print("Total allocated size: %.1f KiB" % (total / 1024))


tracemalloc.start()

counts = Counter()
fname = ''/usr/share/dict/american-english''
with open(fname) as words:
    words = list(words)
    for word in words:
        prefix = word[:3]
        counts[prefix] += 1
print(''Top prefixes:'', counts.most_common(3))

snapshot = tracemalloc.take_snapshot()
display_top(snapshot)

Y aquí están los resultados:

Top prefixes: [(''con'', 1220), (''dis'', 1002), (''pro'', 809)]
Top 3 lines
#1: scratches/memory_test.py:37: 6527.1 KiB
    words = list(words)
#2: scratches/memory_test.py:39: 247.7 KiB
    prefix = word[:3]
#3: scratches/memory_test.py:40: 193.0 KiB
    counts[prefix] += 1
4 other: 4.3 KiB
Total allocated size: 6972.1 KiB

Answer 5

Yo solo quiero ver el uso de memoria de un objeto ( respuesta a otra pregunta )

Hay un módulo llamado Pympler que contiene el módulo asizeof .

Use de la siguiente manera:

from pympler import asizeof
asizeof.asizeof(my_object)

A diferencia de sys.getsizeof , funciona para tus objetos creados por sys.getsizeof mismo.

>>> asizeof.asizeof(tuple(''bcd''))
200
>>> asizeof.asizeof({''foo'': ''bar'', ''baz'': ''bar''})
400
>>> asizeof.asizeof({})
280
>>> asizeof.asizeof({''foo'':''bar''})
360
>>> asizeof.asizeof(''foo'')
40
>>> asizeof.asizeof(Bar())
352
>>> asizeof.asizeof(Bar().__dict__)
280

>>> help(asizeof.asizeof)
Help on function asizeof in module pympler.asizeof:

asizeof(*objs, **opts)
    Return the combined size in bytes of all objects passed as positional arguments.

Answer 6

tal vez ayuda:
< ver más >

pip install gprof2dot
sudo apt-get install graphviz

gprof2dot -f pstats profile_for_func1_001 | dot -Tpng -o profile.png

def profileit(name):
    """
    @profileit("profile_for_func1_001")
    """
    def inner(func):
        def wrapper(*args, **kwargs):
            prof = cProfile.Profile()
            retval = prof.runcall(func, *args, **kwargs)
            # Note use of name from outer scope
            prof.dump_stats(name)
            return retval
        return wrapper
    return inner

@profileit("profile_for_func1_001")
def func1(...)