de acordo com o Stackoverflow survey de 2019, a linguagem de programação Python obteve 73.1% de aprovação entre os desenvolvedores. Ocupa o segundo lugar na ferrugem e continua a dominar na ciência da Informação e na aprendizagem de máquinas(ML).
Python é o favorito dos programadores. É uma linguagem de alto nível conhecida por sua robustez e sua filosofia central―simplicidade sobre complexidade. No entanto, o desempenho da aplicação Python é outra história. Tal como qualquer outra aplicação, tem a sua quota-parte de problemas de desempenho. na maioria das vezes, Ferramentas de APM como Retrace podem ajudar a resolver problemas de desempenho da aplicação. Mas, e se a sua aplicação Python estiver a funcionar há quatro horas e o servidor estiver sem memória? Trata-se de um problema específico que envolve recursos de memória. chama-se fuga de memória. Os desenvolvedores precisam encontrar o culpado. Isso é quando os profilers de memória Python entram. vamos explorar mais.
o que são perfis de memória Python?
As aplicações de perfis envolvem sempre questões como CPU, memória, etc. No entanto, as aplicações Python são propensas a problemas de gerenciamento de memória. Isso ocorre principalmente porque o Python é aplicado a aplicações de Ciência de Dados E ML e trabalha com grandes quantidades de dados. Além disso, o Python depende de seu sistema de gerenciamento de memória por padrão, em vez de deixá-lo para o usuário.como o código Python funciona dentro de recipientes através de uma estrutura de processamento distribuída, cada recipiente contém uma quantidade fixa de memória. Se a execução do Código exceder o limite de memória, então o contêiner terminará. Isto é quando o desenvolvimento experimenta erros de memória. no entanto, nem sempre é o caso. Há casos em que os desenvolvedores não sabem o que está acontecendo. Talvez um objeto esteja pendurado a uma referência quando não é suposto estar e se acumula ao longo do tempo. Uma vez que atinge o seu pico, problemas de memória ocorrem.
a solução de correção rápida é aumentar a alocação de memória. No entanto, não é prático, uma vez que isso pode resultar num desperdício de recursos. Além disso, pode comprometer a estabilidade da aplicação devido a picos de memória imprevisíveis. por isso, precisamos da ajuda dos profilers de memória Python. O objetivo dos profilers de memória Python é encontrar vazamentos de memória e otimizar o uso de memória em suas aplicações Python. Estes tipos de compiladores de memória Python entendem a eficiência de espaço do código e pacotes usados.
os perfis de memória em Python de topo
embora o Python gere automaticamente a memória, precisa de ferramentas porque as tarefas em Python de longa duração consomem muita memória. Na maioria dos casos, esses trabalhos não devolverão a memória ao sistema operacional até que o processo termine, mesmo que execute corretamente a coleta de lixo.
Aqui está uma lista de perfis de memória Python conhecidos:
Pympler
Jean Brouwers, Ludwig Haehne, and Robert Schuppenies built Pympler in August 2008. Eles introduziram o processo de pympling, onde Pympler obtém detalhes do tamanho e da vida útil dos objetos Python.
o profiler de memória Python do Python analisa o comportamento de memória do objeto Python dentro de uma aplicação em execução. Ele fornece uma solução completa e independente de análise de memória Python. Além disso, ele projeta um possível erro no comportamento em tempo de execução, como inchaço de memória e outros “pimples”.”
Existem três módulos separados dentro de Pympler.
- O módulo asizeof fornece a informação do tamanho do objecto Python.
- O módulo de disquete atende à monitorização on-line de uma aplicação em Python.
- O módulo de seguimento de classes fornece uma análise off-line do tempo de vida dos objectos Python seleccionados.
Primeiro, vamos usar asizeof para investigar a quantidade de memória que certos objetos Python consomem.
>>> from pympler import asizeof
>>> obj =
>>> asizeof.asizeof(obj)
>>> print (asizeof.asized(obj, detail=1).format())
tamanho=192 televisão=48
(6, 4) tamanho=64 televisão=32
” eu ” tamanho=32 plana=32
3 tamanho=16 plana=16
tamanho 2=16 plana=16
1 tamanho=16 plana=16
em Segundo lugar, vamos implementar o muppy módulo:
>>> a partir de pympler importar muppy
>>> allObjects = muppy.get_objects()
>>> len(allObjects)
>>> a partir de pympler importar resumo
>>> I = resumo.resumir(allObjects)
>>> resumo.print_(sum)
| types | | # objects | | total size |
| ========================== | | =========== | | ============ |
| str | | 13262 | | 1.01 MB |
| dict | | 2120 | | 659.99 KB |
| code | | 3362 | | 343.73 KB |
| list | | 2587 | | 247.46 KB |
| type | | 639 | | 242.61 KB |
| tuple | | 2069 | | 58.83 KB |
| set | | 86 | | 44.57 KB |
| wrapper_descriptor | | 1247 | | 43.84 KB |
| builtin_function_or_method | | 1014 | | 35.65 KB |
| method_descriptor | | 937 | | 32.94 KB |
| abc.ABCMeta | | 66 | | 32.38 KB |
| weakref | | 818 | | 28.76 KB |
| int | | 1612 | | 24.72 KB |
| getset_descriptor | | 555 | | 17.34 KB |
| frozenset | | 90 | | 16.87 KB |
Aqui, você pode ver todos os objetos Python em um heap usando o muppy módulo. Você pode chamar outro resumo e compará-lo para verificar se algumas arrays têm vazamentos de memória. Saiba mais sobre o módulo muppy aqui.
O terceiro módulo no perfil de Pympler é O Localizador de classes. Ele acompanha a vida de objetos de certas classes. Thus, it provides insight into instantiation patterns and helps developers understand how specific objects contribute to the memory footprint in the long run.
>>> tr = classtracker.ClassTracker()
>>> tr.track_class(Document)
>>> tr.create_snapshot(description=’Snapshot 1′)
>>> doc = create_document()
>>> tr.create_snapshot(description=’Snapshot 2′)
>>> tr.stats.print_summary()
— RESUMO ———————-
Instantâneo 1 0 ativo B média pct
Instantâneo 2 0 ativo B média pct
—————————
Para saber mais sobre a Classe Tracker, clique aqui.
Guppy3
Guppy3 (também conhecido como Heapy) é um ambiente de programação Python e um conjunto de ferramentas de análise heap. É um pacote que contém os seguintes sub-pacotes:
- etc-Este é um módulo de suporte que tem o módulo de Protocolo de cola.
- gsl-a sub-embalagem que contém a implementação da linguagem de especificação Guppy. Cria documentos e testes de uma fonte comum.
- heapy – a ferramenta de análise heap fornece informações sobre o objeto sobre o heap e mostra a informação.conjuntos
i – – isto contém Bitsets e nodesets.
Guppy3 é um fork de Guppy-PE e foi construído pelo Sverker Nilsson para o Python 2.
Nota: usar este perfil de memória Python requer Python 3.5, 3.6, 3.7, ou 3.8. Este pacote funciona apenas para o CPython. Assim, PyPy e outras implementações de compiladores Python não são suportadas. Além disso, para usar o navegador gráfico, ele precisa de Tkinter. Além disso, threading deve estar disponível ao usar um monitor remoto.
Aqui está como tirar partido deste profiler de memória Python. Você pode tirar uma foto do Monte antes e depois de um processo crítico. Em seguida, compare a memória total e identificar possíveis picos de memória envolvidos em objetos comuns.
>>> from guppy import hpy
>>> h=hpy()
>>> h.heap()
Partition of a set of 34090 objects. Total size = 2366226 bytes.
| Index | Count | % | Size | % | Cumulative | % | Kind (class / dict of class) |
| 0 | 10279 | 30 | 666873 | 28 | 666873 | 28 | str |
| 1 | 4697 | 14 | 259576 | 11 | 926449 | 39 | bytes |
| 2 | 2413 | 7 | 251684 | 11 | 1178133 | 50 | types.CodeType |
| 3 | 6825 | 20 | 238084 | 10 | 1416217 | 60 | tuple |
| 4 | 448 | 1 | 174868 | 7 | 1591085 | 67 | type |
| 5 | 2208 | 6 | 150144 | 6 | 1741229 | 74 | function |
| 6 | 448 | 1 | 130964 | 6 | 1872193 | 79 | dict of type |
| 7 | 94 | 0 | 83532 | 4 | 1955725 | 83 | dict of module |
| 8 | 242 | 1 | 56524 | 2 | 2012249 | 85 | dict (no owner) |
| 9 | 1133 | 3 | 40788 | 2 | 2053037 | 87 | types.WrapperDescriptorType |
<118 more rows. Type e.g. ‘_.more’ to view.>
Memory Profiler
Memory Profiler is a pure Python module that uses the psutil module. Ele monitora o consumo de memória de um processo de trabalho Python. Além disso, realiza uma análise linha-a-linha do consumo de memória da aplicação.
o modo de Utilização da memória linha-a-linha funciona da mesma forma que o perfil de linha.
- decora a função que deseja traçar usando a função @profile.
- pode executar o programa com um programa especial. Por exemplo, use argumentos específicos para o interpretador Python.
no exemplo seguinte, vamos ter uma função simples chamada my_func. Esta função cria uma lista com um intervalo especificado.
@profile
def my_func():
a=
for i in range(1000):
a.append(i)
my_func()
This outputs:
| Line # | Mem Usage | Increment | Line Contents |
| 1 | 13.859 MiB | 13.859 MiB | @profile |
| 2 | def my_func(): | ||
| 3 | 13.859 MiB | 0.000 MiB | a= |
| 4 | 13.859 MiB | 0.000 MiB | for i in range(1000): |
| 5 | 13.859 MiB | 0.000 MiB | um.append(i) |
A primeira coluna é o número da linha do perfilado código. Uso Mem é o uso de memória do interpretador Python após cada execução de código. A terceira coluna (incremento) representa a diferença na memória da linha atual para a última. A última coluna (Conteúdo da linha) mostra os códigos de perfil.
To see how this Python memory profiler works, let’s change the range value to 1000000 in the function above and execute it. Here is the output:
| Line # | Mem usage | Increment | Line Contents |
| 1 | 13.844 MiB | 13.844 MiB | @profile |
| 2 | def my_func(): | ||
| 3 | 13.844 MiB | 0.000 MiB | a= |
| 4 | 33.387 MiB | 0.016 MiB | for i in range(1000000): |
| 5 | 33.387 MiB | 0.293 MiB | um.append(i) |
Linha 4 e 5 mostram um aumento no uso da memória, provando que este profiler executa uma linha-por-linha de análise de consumo de memória.
Fil
profiler é um profiler de memória Python de código aberto. É adequado para aplicações de processamento de dados e computação científica. Atualmente, ele ainda está na fase de desenvolvimento e funciona apenas em Linux e macOS.
A maioria dos cientistas de dados e desenvolvedores Python enfrentam problemas de memória com o pipeline de dados Python. Quando ele usa muita memória, é difícil identificar onde exatamente toda a memória está indo.
por exemplo, vamos citar dois cenários:
servidores
como os servidores estão executando sem parar, vazamentos de memória são muitas vezes a causa de falha de desempenho. Os desenvolvedores negligenciam pequenas quantidades de vazamento de memória como a maioria dos servidores processam pequenas quantidades de dados de cada vez. No entanto, estes podem somar dezenas de milhares de chamadas. Como resultado, isso pode criar graves problemas de produção ao longo do tempo.
pipelines de dados
ao processar grandes blocos de dados, picos no uso da memória trazem enormes ameaças para pipelines de dados. Por exemplo, se a sua aplicação usa RAM 1GB por algum tempo e, de repente, precisa de RAM 16GB. Há uma grande necessidade de identificar o que causa picos de memória repentinos.
é o principal objetivo do Fil-diagnosticar picos de uso de memória, independentemente da quantidade de dados sendo processados. Ele aponta onde exatamente o pico de uso da memória é e qual o código é responsável por esse pico.
embora existam perfis de memória Python existentes que medem o uso de memória, ele tem limitações. Um dos quais está a lidar com grandes quantidades de processamento de dados em lotes. Aplicações Python são principalmente aplicações de processamento de lotes em que eles constantemente ler dados, processá-los, e sair o resultado.
esse problema é respondido pelo nosso próximo profiler.
Blackfire
para uma linguagem altamente dinâmica como o Python, a maioria dos desenvolvedores experimentam problemas de memória durante a implantação. Isso leva a alguma confusão sobre o que acontece com o uso da memória. Os desenvolvedores tendem a realizar otimizações, mas não têm as ferramentas certas para usar.
Blackfire é um perfil de memória Python proprietário (talvez o primeiro. Ele usa o Gerenciador de memória Python para rastrear todos os blocos de memória alocados por Python, incluindo extensões C. Blackfire é novo no campo e tem como objetivo resolver problemas em vazamentos de memória, tais como:
- objetos grandes na memória que não são liberados
- ciclos de referência
- Contagem de referência inválida em extensões C causando vazamentos de memória
- picos de memória repentinos
com estes casos de uso, Blackfire assegura aos usuários que ele tem uma sobrecarga muito limitada e não impacta os usuários finais porque ele mede o consumo de memória da aplicação Python no nível de chamada de função.
Blackfire Python memory profiler uses PyMem_SetAllocator API to trace memory allocations like tracemalloc. Atualmente, o Blackfire suporta versões Python 3.5 e up. Você pode visitar seu site para saber mais.
perfil com Retrace
Se você está trabalhando com Python, você de alguma forma experimentar que ele não libera imediatamente a memória de volta para o sistema operacional. Portanto, você executa-o em um processo separado para garantir que a memória é liberada após a execução de um pedaço de código. Isto é feito através de uma abordagem útil chamada “pequeno caso de teste.”Este processo permite executar apenas o código de fuga de memória em questão. ao lidar com grandes quantidades de dados, utilize um subconjunto dos dados amostrados aleatoriamente. Além disso, execute tarefas intensivas em memória em processos separados e use depuradores para adicionar referências a objetos. No entanto, considere que a utilização de um depurador de ponto de paragem como o pdb permite que quaisquer objectos criados e referenciados manualmente a partir do depurador permaneçam no perfil de memória. Isso resultará em um falso senso de vazamento de memória uma vez que os objetos não são liberados a tempo. Além disso, considere olhar para os pacotes que podem ser vazados. Existem bibliotecas Python que podem potencialmente ter vazamentos de memória.
Por esta altura, já sabe como funcionam os perfis de memória em Python e os problemas de memória comuns em Python. Mas ferramentas como Retrace com registro centralizado, rastreamento de erros e análise de código podem ajudá-lo a diagnosticar problemas em Python em uma escala maior. Retrace do Stackify irá ajudá-lo a lidar com qualquer tipo de armadilhas de desempenho e manter o seu código funcionando bem. Inicie o seu teste de Retrace livre de 14 dias hoje!