Localizar alocações de memória com tracemalloc

tracemalloc é um módulo da biblioteca padrão que registra blocos de memória alocados por mecanismos rastreados do Python. Para investigar uma operação, chame tracemalloc.start() antes das alocações que fazem parte da pergunta.

O rastreamento não é retroativo: blocos que já existiam quando start() foi chamado não entram nos rastros. Portanto, delimite conscientemente a janela: inclua a preparação se quiser medir seu custo; deixe-a fora se a pergunta for apenas sobre o processamento posterior.

A posição de start() define quais alocações podem ser observadas.

Neste caso, a preparação ocorre antes do rastreamento. A função cria strings distintas dinamicamente, mantém um resultado retornado e também cria uma lista temporária. Ainda não vamos consultar números: o objetivo agora é estabelecer uma fronteira confiável para as observações dos próximos passos.

Com o rastreamento já ativo, tracemalloc.get_traced_memory() retorna uma tupla em bytes:

atual, pico = tracemalloc.get_traced_memory()

• atual: tamanho dos blocos rastreados que ainda estão alocados no instante da consulta.
• pico: maior tamanho de blocos rastreados que coexistiu desde o início do rastreamento.

O pico não soma todas as alocações feitas ao longo do programa. Ele registra o maior ponto simultâneo observado.

Uma estrutura temporária pode aumentar o pico e depois desaparecer; o resultado mantido ainda contribui para a memória atual.

Crie um arquivo, por exemplo medir_pico.py, e execute-o no seu computador com python medir_pico.py. O rastreamento começa antes das alocações que queremos observar e é encerrado mesmo se houver falha.

As strings incluem o índice para que cada elemento seja criado dinamicamente. A lista temporarios deixa de ter referência depois do del, enquanto resultado continua vivo até o fim da medição.

O valor de pico é o maior tamanho rastreado desde o início do rastreamento — ou desde o último reinício. Se uma fase inicial já atingiu um valor alto, uma fase posterior pode aumentar a memória sem ultrapassar esse máximo; nesse caso, o pico global não revela o comportamento da nova fase.

Use tracemalloc.reset_peak() imediatamente antes da fase que você quer observar.

A segunda fase começa com memória ainda viva. Após reset_peak(), o novo pico parte desse nível atual, não de zero.

1. Consulte a memória atual para registrar a referência.
2. Chame reset_peak() imediatamente antes da fase investigada.
3. Execute a fase.
4. Consulte memória atual e pico logo depois.

reset_peak() redefine o pico para o tamanho atual rastreado. Ele não libera objetos, não chama coleta de lixo e não descarta os rastros dos blocos que permanecem alocados.

Execute este script localmente. Os valores variam conforme versão do Python e ambiente.

tracemalloc.take_snapshot() captura os rastros dos blocos que ainda estão alocados no instante da chamada. Portanto, uma estrutura temporária criada e liberada antes do snapshot não aparece nele, mesmo que tenha contribuído para o pico observado anteriormente.

Use o snapshot para perguntar: onde se concentra a memória rastreada que permanece viva agora?

A área destacada representa os blocos ainda vivos no momento da captura; os blocos temporários que já desapareceram ficam fora do retrato.

Execute este script localmente. Os valores, caminhos e números de linha variam conforme o ambiente.

No agrupamento por linha, duas linhas do mesmo arquivo permanecem separadas. No agrupamento por arquivo, seus tamanhos são reunidos.

No script, uma entrada atribuída à linha da compreensão que cria registros aponta para blocos ainda vivos associados àquela instrução. Isso é uma evidência de origem de alocação: confira o arquivo e a linha mostrados e relacione-os ao seu código local.

Caminhos, números de linha e tamanhos não são universais. Mudanças no arquivo, na versão do Python e no ambiente alteram a saída. Além disso, uma entrada grande mostra memória viva concentrada naquele local; ela não prova quando os blocos foram criados nem por que continuam vivos.

Capture um snapshot antes e outro depois da operação, sem interromper o rastreamento. Então use:

depois.compare_to(antes, "lineno")

Cada entrada compara o estado posterior com o anterior para uma linha de alocação. Assim, ela responde: o que ficou a mais ou a menos vivo ao final? Não responde tudo o que foi alocado durante o caminho.

A estrutura persistente aparece como crescimento líquido. A estrutura temporária pode aumentar o pico, mas, se já foi liberada antes do segundo snapshot, não aparecerá como crescimento na comparação.

Em cada StatisticDiff, size e count descrevem o estado posterior daquele grupo. Já size_diff e count_diff são calculados como depois − antes.

• valor positivo: crescimento líquido;
• valor negativo: redução líquida;
• valor zero: nenhum saldo líquido naquele agrupamento — não ausência de alocações intermediárias.

A lista é ordenada pela magnitude absoluta de size_diff. Portanto, uma grande redução pode aparecer entre as primeiras entradas.

Execute em um arquivo .py. Os tamanhos, caminhos e números de linha variam conforme o ambiente.

O agrupamento por 'lineno' mostra onde ocorreu a alocação, mas não diferencia dois caminhos que chegam à mesma linha. Para isso, registre mais quadros ao iniciar o rastreamento: tracemalloc.start(10) guarda até 10 quadros do traceback de cada alocação.

Sem argumento, start() registra somente um quadro: o local imediato da alocação. A profundidade vale apenas para alocações futuras; quadros que não foram registrados não podem ser recuperados de um snapshot já capturado.

Os dois chamadores alcançam a mesma expressão que cria a lista. Por linha, eles se misturam; por traceback, permanecem separados.

Crie um arquivo, por exemplo contexto_alocacao.py, e execute-o no seu computador. As duas funções chamadoras usam a mesma função alocadora. O primeiro snapshot é a referência; o segundo registra os blocos que permanecem vivos após as duas chamadas.

Use depois.statistics('traceback') para ver blocos vivos agrupados pelo caminho completo de alocação. Para identificar crescimento líquido desde uma referência, use depois.compare_to(antes, 'traceback').

Cada estatistica.traceback pode ser percorrido com format(). No exemplo, você deve encontrar caminhos que passam por importar_dados e por aquecer_indice, embora ambos terminem na linha da compreensão em criar_lotes. Caminhos, números de linha, tamanhos e quantidades variam conforme a execução.

Os valores de tracemalloc descrevem blocos de memória que ele está rastreando no Python. Eles não representam automaticamente toda a memória residente do processo.

RSS (resident set size) é a memória do processo que está residente na RAM, conforme informada pelo sistema operacional. Portanto, um pico rastreado e o RSS podem ter valores bem diferentes sem que um deles esteja necessariamente errado.

Compare o escopo de cada medida.

Uma alocação nativa pode aparecer no relatório quando usa mecanismos rastreados pelo Python, mas memória nativa não rastreada fica fora dos resultados. Além disso, tracemalloc não agrega automaticamente a memória de outros processos.

A própria investigação tem custo: manter rastros, pedir mais quadros com start(n) e capturar snapshots consomem tempo e memória. Meça uma carga representativa e trate o resultado como evidência de diagnóstico, não como uma contabilidade exata.

Nesta aplicação, você vai manter a entrada fora da comparação, medir uma fase que cria dados temporários e preservar o resultado retornado. O roteiro é:

1. Iniciar o rastreamento antes da preparação relevante.
2. Registrar a memória atual de referência.
3. Chamar reset_peak() imediatamente antes da fase investigada.
4. Capturar snapshots antes e depois da operação.
5. Consultar memória atual e pico antes de formatar relatórios.
6. Procurar uma diferença positiva e seu traceback.

Os valores variam entre máquinas e execuções. O objetivo é interpretar relações entre as medidas, não obter um número específico.

A entrada já existe antes do snapshot inicial; por isso, a comparação destaca a mudança líquida provocada por processar. O pico da fase, por outro lado, pode incluir a estrutura temporária que deixou de existir antes do snapshot final.

Crie um arquivo chamado diagnostico_memoria.py, copie o código completo abaixo e execute python diagnostico_memoria.py no seu computador. A rotina não altera sua estratégia de processamento: ela apenas cria uma coleção temporária e devolve uma coleção que continua referenciada por resultado.

O relatório mostra a memória rastreada, as maiores diferenças por linha e uma origem agrupada por traceback.

No relatório, identifique uma entrada com size_diff positivo ligada à linha de resultado ou à criação de dados. Registre também seu count_diff. Se pico_da_fase for maior que atual, houve mais memória rastreada simultaneamente durante a fase do que permaneceu viva no final.

A maior entrada ordenada pode ter sinal negativo, pois compare_to ordena pela magnitude absoluta da diferença. Para investigar crescimento, confira explicitamente o sinal positivo de size_diff.

O traceback aponta o caminho que levou à alocação. Ele não informa, por si só, qual referência está mantendo um objeto vivo nem prova a existência de vazamento.