Qual perfilador de memória de Python é recomendado? [fechadas]

Quero saber o uso de memória do meu aplicativo Python e quero especificamente saber quais blocos / partes de código ou objetos estão consumindo mais memória. A pesquisa do Google mostra que uma comercial é o Python Memory Validator (somente Windows).

E os de código aberto são PySizer e Heapy .

Eu não tentei ninguém, então eu queria saber qual é o melhor, considerando:

1. Dá mais detalhes.

2. Eu tenho que fazer poucas ou nenhuma alteração no meu código.

Heapy é bastante simples de usar. Em algum momento do seu código, você deve escrever o seguinte:

from guppy import hpy
h = hpy()
print(h.heap())

Isso fornece uma saída como esta:

Partition of a set of 132527 objects. Total size = 8301532 bytes.
Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
0  35144  27  2140412  26   2140412  26 str
1  38397  29  1309020  16   3449432  42 tuple
2    530   0   739856   9   4189288  50 dict (no owner)

Você também pode descobrir de onde os objetos são referenciados e obter estatísticas sobre isso, mas de alguma forma os documentos são um pouco esparsos.

Também existe um navegador gráfico, escrito em Tk.

Como ninguém o mencionou, aponto para o meu módulo memory_profiler, que é capaz de imprimir relatórios linha a linha do uso de memória e funciona no Unix e no Windows (precisa de psutil neste último). A saída não é muito detalhada, mas o objetivo é fornecer uma visão geral de onde o código está consumindo mais memória e não uma análise exaustiva dos objetos alocados.

Depois de decorar sua função @profilee executar seu código com o -m memory_profilersinalizador, ele imprimirá um relatório linha por linha como este:

Line #    Mem usage  Increment   Line Contents
==============================================
     3                           @profile
     4      5.97 MB    0.00 MB   def my_func():
     5     13.61 MB    7.64 MB       a = [1] * (10 ** 6)
     6    166.20 MB  152.59 MB       b = [2] * (2 * 10 ** 7)
     7     13.61 MB -152.59 MB       del b
     8     13.61 MB    0.00 MB       return a

Eu recomendo Dowser . É muito fácil de configurar e você precisa de zero alterações no seu código. Você pode visualizar a contagem de objetos de cada tipo ao longo do tempo, visualizar a lista de objetos ativos, ver referências a objetos ativos, tudo a partir da interface da web simples.

# memdebug.py

import cherrypy
import dowser

def start(port):
    cherrypy.tree.mount(dowser.Root())
    cherrypy.config.update({
        'environment': 'embedded',
        'server.socket_port': port
    })
    cherrypy.server.quickstart()
    cherrypy.engine.start(blocking=False)

Você importa o memdebug e chama o memdebug.start. Isso é tudo.

Eu não tentei o PySizer ou o Heapy. Eu apreciaria as opiniões dos outros.

ATUALIZAR

O código acima é para CherryPy 2.X, CherryPy 3.Xo server.quickstartmétodo foi removido e engine.startnão recebe o blockingsinalizador. Então, se você estiver usandoCherryPy 3.X

# memdebug.py

import cherrypy
import dowser

def start(port):
    cherrypy.tree.mount(dowser.Root())
    cherrypy.config.update({
        'environment': 'embedded',
        'server.socket_port': port
    })
    cherrypy.engine.start()

Considere o objetivo biblioteca (consultehttp://www.lshift.net/blog/2008/11/14/tracing-python-memory-leaks para um exemplo de caso de uso).

Muppy é (mais um) Profiler de uso de memória para Python. O foco deste conjunto de ferramentas é colocado na identificação de vazamentos de memória.

Muppy tenta ajudar os desenvolvedores a identificar vazamentos de memória de aplicativos Python. Permite o rastreamento do uso da memória durante o tempo de execução e a identificação de objetos que estão vazando. Além disso, são fornecidas ferramentas que permitem localizar a origem dos objetos não liberados.

Estou desenvolvendo um criador de perfil de memória para Python chamado memprof:

http://jmdana.github.io/memprof/

Permite registrar e plotar o uso de memória de suas variáveis ​​durante a execução dos métodos decorados. Você apenas precisa importar a biblioteca usando:

from memprof import memprof

E decore seu método usando:

@memprof

Este é um exemplo de como os gráficos se parecem:

O projeto está hospedado no GitHub:

https://github.com/jmdana/memprof

Eu achei as melias muito mais funcionais que o Heapy ou o PySizer. Se você estiver executando um aplicativo Web wsgi, o Dozer é um bom pacote de middleware da Dowser

Experimente também o projeto pytracemalloc que fornece o uso da memória por número de linha do Python.

EDIT (2014/04): Agora ele possui uma interface gráfica Qt para analisar snapshots.