Memória total usada pelo processo Python?


266

Existe uma maneira de um programa Python determinar quanta memória está usando atualmente? Vi discussões sobre o uso de memória para um único objeto, mas o que preciso é de uso total de memória para o processo, para poder determinar quando é necessário começar a descartar dados em cache.

Respostas:


303

Aqui está uma solução útil que funciona para vários sistemas operacionais, incluindo Linux, Windows 7, etc .:

import os
import psutil
process = psutil.Process(os.getpid())
print(process.memory_info().rss)  # in bytes 

Na minha instalação atual do Python 2.7 com o psutil 5.6.3, a última linha deve ser

print(process.memory_info()[0])

em vez disso (houve uma alteração na API).

Nota: faça pip install psutilse ainda não estiver instalado.


3
psutilé multiplataforma e pode retornar os mesmos valores como a psferramenta de linha de comando: pythonhosted.org/psutil/#psutil.Process.memory_info
amos

1
"( psutil) atualmente suporta Linux, Windows, OSX, FreeBSD e Sun Solaris, arquiteturas de 32 e 64 bits, com versões em Python de 2.6 a 3.4" da Documentação
Cecilia

2
Por que esse número não corresponde ao do explorador de processos? O número da psutil sempre parece ser maior em cerca de 10%.
wordsforthewise

39
Note-se que psutil não está na biblioteca padrão
grisaitis

12
Para versões recentes de psutil, psutil.Process()é equivalente a psutil.Process(os.getpid()). É uma coisa a menos que você precisa se lembrar de digitar.
Rnorris 26/04/19

208

Para sistemas baseados em Unix (Linux, Mac OS X, Solaris), você pode usar a getrusage()função no módulo de biblioteca padrão resource. O objeto resultante possui o atributo ru_maxrss, que fornece o pico de uso de memória para o processo de chamada:

>>> resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
2656  # peak memory usage (kilobytes on Linux, bytes on OS X)

Os documentos do Python não anotam as unidades. Consulte a página do seu sistema específico man getrusage.2para verificar o valor da unidade. No Ubuntu 18.04, a unidade é anotada como kilobytes. No Mac OS X, são bytes.

A getrusage()função também pode ser fornecida resource.RUSAGE_CHILDRENpara obter o uso para processos filho e (em alguns sistemas) resource.RUSAGE_BOTHpara o uso total (próprio e filho) do processo.

Se você se preocupa apenas com o Linux, pode ler alternativamente o arquivo /proc/self/statusou /proc/self/statmconforme descrito em outras respostas para esta pergunta e esta também.


2
OK vai fazer. Eu não tinha certeza se o SO tinha um processo para mesclar perguntas ou o quê. A postagem duplicada foi parcialmente para mostrar às pessoas que havia uma solução padrão de biblioteca para ambas as perguntas ... e parcialmente para o representante. ;) Devo excluir esta resposta?
Nathan Craike

6
O Mac OS definitivamente retorna o RSS em bytes, o Linux o retorna em kilobytes.
6113 Neil

13
As unidades NÃO estão em kilobytes. É dependente da plataforma, então você deve usar o resource.getpagesize () para descobrir. Os documentos do Python fornecidos ( docs.python.org/2/library/resource.html#resource-usage ) são realmente muito claros sobre isso. É 4096 na minha caixa.
Ben Lin

5
@ BenLin Esses documentos do Python estão claramente errados ou há um erro na versão do Mac. A unidade usada pelo getrusage e o valor retornado pelo getpagesize são definitivamente diferentes.
Andrew

6
A pergunta fazia uso atual . Observe que esse é o uso máximo . (Ainda uma resposta útil, apenas as pessoas que erroneamente aviso copiar-colar.)
Luc

65

No Windows, você pode usar o WMI ( home page , cheeseshop ):


def memory():
    import os
    from wmi import WMI
    w = WMI('.')
    result = w.query("SELECT WorkingSet FROM Win32_PerfRawData_PerfProc_Process WHERE IDProcess=%d" % os.getpid())
    return int(result[0].WorkingSet)

No Linux (do livro de receitas python, http://code.activestate.com/recipes/286222/ :

import os
_proc_status = '/proc/%d/status' % os.getpid()

_scale = {'kB': 1024.0, 'mB': 1024.0*1024.0,
          'KB': 1024.0, 'MB': 1024.0*1024.0}

def _VmB(VmKey):
    '''Private.
    '''
    global _proc_status, _scale
     # get pseudo file  /proc/<pid>/status
    try:
        t = open(_proc_status)
        v = t.read()
        t.close()
    except:
        return 0.0  # non-Linux?
     # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
    i = v.index(VmKey)
    v = v[i:].split(None, 3)  # whitespace
    if len(v) < 3:
        return 0.0  # invalid format?
     # convert Vm value to bytes
    return float(v[1]) * _scale[v[2]]


def memory(since=0.0):
    '''Return memory usage in bytes.
    '''
    return _VmB('VmSize:') - since


def resident(since=0.0):
    '''Return resident memory usage in bytes.
    '''
    return _VmB('VmRSS:') - since


def stacksize(since=0.0):
    '''Return stack size in bytes.
    '''
    return _VmB('VmStk:') - since

14
O código do Windows não funciona para mim. Esta mudança faz:return int(result[0].WorkingSet)
John Fouhy

1
Esse código do Windows não funciona para mim no Windows 7 x64, mesmo após a modificação do comentário de John Fouhy.
Basj

Eu tenho esse erro: retorne [ wmi_object (obj, instance_of, fields) para obj em self._raw_query (wql)] Arquivo "C: \ Python27 \ lib \ pacotes de sites \ win32com \ client \ util.py", linha 84, no próximo retorno _get_good_object_ (self._iter .next (), resultCLSID = self.resultCLSID) pywintypes.com_error: (-2147217385, 'Erro OLE 0x80041017', nenhum, nenhum) se alguém puder me ajudar? Tenho ganhar 8 x64, mas python em x32
Radu Vlad

Nota: Atualizei o exemplo do Windows seguindo a sugestão de John Fouhy após inspecionar a (mais recente) fonte do módulo wmi. Veja também (1) , (2) .
Jedwards

33

No unix, você pode usar a psferramenta para monitorá-lo:

$ ps u -p 1347 | awk '{sum=sum+$6}; END {print sum/1024}'

onde 1347 é alguma identificação de processo. Além disso, o resultado está em MB.


8

Uso atual da memória do processo atual no Linux , para Python 2 , Python 3 e pypy , sem nenhuma importação:

def getCurrentMemoryUsage():
    ''' Memory usage in kB '''

    with open('/proc/self/status') as f:
        memusage = f.read().split('VmRSS:')[1].split('\n')[0][:-3]

    return int(memusage.strip())

Ele lê o arquivo de status do processo atual, pega tudo depois VmRSS:e depois tudo antes da primeira nova linha (isolando o valor do VmRSS) e, por fim, corta os últimos 3 bytes que são um espaço e a unidade (kB).
Para retornar, retira qualquer espaço em branco e o retorna como um número.

Testado no Linux 4.4 e 4.9, mas mesmo uma versão antiga do Linux deve funcionar: procurando man proce procurando as informações no /proc/$PID/statusarquivo, ele menciona versões mínimas para alguns campos (como Linux 2.6.10 para "VmPTE"), mas o "VmRSS "O campo (que eu uso aqui) não tem essa menção. Portanto, suponho que ele esteja lá desde uma versão inicial.


5

Eu gosto lo , obrigado por @bayer. Agora, recebo uma ferramenta específica de contagem de processos.

# Megabyte.
$ ps aux | grep python | awk '{sum=sum+$6}; END {print sum/1024 " MB"}'
87.9492 MB

# Byte.
$ ps aux | grep python | awk '{sum=sum+$6}; END {print sum " KB"}'
90064 KB

Anexe minha lista de processos.

$ ps aux  | grep python
root       943  0.0  0.1  53252  9524 ?        Ss   Aug19  52:01 /usr/bin/python /usr/local/bin/beaver -c /etc/beaver/beaver.conf -l /var/log/beaver.log -P /var/run/beaver.pid
root       950  0.6  0.4 299680 34220 ?        Sl   Aug19 568:52 /usr/bin/python /usr/local/bin/beaver -c /etc/beaver/beaver.conf -l /var/log/beaver.log -P /var/run/beaver.pid
root      3803  0.2  0.4 315692 36576 ?        S    12:43   0:54 /usr/bin/python /usr/local/bin/beaver -c /etc/beaver/beaver.conf -l /var/log/beaver.log -P /var/run/beaver.pid
jonny    23325  0.0  0.1  47460  9076 pts/0    S+   17:40   0:00 python
jonny    24651  0.0  0.0  13076   924 pts/4    S+   18:06   0:00 grep python

Referência


apenas uma otimização de código para evitar múltiplas tubulaçãops aux | awk '/python/{sum+=$6}; END {print sum/1024 " MB"}'
NeronLeVelu

4

Para Python 3.6 e psutil 5.4.5, é mais fácil usar a memory_percent()função listada aqui .

import os
import psutil
process = psutil.Process(os.getpid())
print(process.memory_percent())

1
isso requer lib psutil
confiq

4

Mais fácil, mesmo de usar do que /proc/self/status: /proc/self/statm. É apenas uma lista delimitada por espaço de várias estatísticas . Não consegui dizer se os dois arquivos estão sempre presentes.

/ proc / [pid] / statm

Fornece informações sobre o uso da memória, medido em páginas. As colunas são:

  • size (1) tamanho total do programa (o mesmo que VmSize em / proc / [pid] / status)
  • residentes (2) tamanho do conjunto de residentes (igual ao VmRSS em / proc / [pid] / status)
  • shared (3) número de páginas compartilhadas residentes (ou seja, apoiadas por um arquivo) (o mesmo que RssFile + RssShmem em / proc / [pid] / status)
  • texto (4) texto (código)
  • biblioteca lib (5) (não utilizada desde o Linux 2.6; sempre 0)
  • dados (6) dados + pilha
  • dt (7) páginas sujas (não utilizadas desde o Linux 2.6; sempre 0)

Aqui está um exemplo simples:

from pathlib import Path
from resource import getpagesize

PAGESIZE = getpagesize()
PATH = Path('/proc/self/statm')


def get_resident_set_size() -> int:
    """Return the current resident set size in bytes."""
    # statm columns are: size resident shared text lib data dt
    statm = PATH.read_text()
    fields = statm.split()
    return int(fields[1]) * PAGESIZE


data = []
start_memory = get_resident_set_size()
for _ in range(10):
    data.append('X' * 100000)
    print(get_resident_set_size() - start_memory)

Isso produz uma lista que se parece com isso:

0
0
368640
368640
368640
638976
638976
909312
909312
909312

Você pode ver que ele salta cerca de 300.000 bytes após aproximadamente três alocações de 100.000 bytes.


4

Abaixo está o meu decorador de funções, que permite rastrear quanta memória esse processo consumiu antes da chamada de função, quanta memória ele usa após a chamada de função e quanto tempo a função é executada.

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.memory_info().rss


def track(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

Então, quando você tem alguma função decorada com ela

from utils import track

@track
def list_create(n):
    print("inside list create")
    return [1] * n

Você poderá ver esta saída:

inside list create
list_create: memory before: 45,928,448, after: 46,211,072, consumed: 282,624; exec time: 00:00:00

3
import os, win32api, win32con, win32process
han = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION|win32con.PROCESS_VM_READ, 0, os.getpid())
process_memory = int(win32process.GetProcessMemoryInfo(han)['WorkingSetSize'])

7
Isso pode ser melhorado com algumas explicações sobre o que faz e como funciona.
ArtOfWarfare

2
Com base no grande número retornado (8 dígitos) e como não estou fazendo nada, acho que deve ser bytes? Portanto, tem cerca de 28,5 MB para uma instância interativa bastante inativa. (Uau ... eu nem sequer perceber o comentário acima era meu de 4 anos atrás ... isso é estranho.)
ArtOfWarfare

3

Para sistemas Unix, o comando time(/ usr / bin / time) fornece essas informações se você passar -v. Veja Maximum resident set sizeabaixo, qual é a memória real máxima (pico) real (não virtual) usada durante a execução do programa :

$ /usr/bin/time -v ls /

    Command being timed: "ls /"
    User time (seconds): 0.00
    System time (seconds): 0.01
    Percent of CPU this job got: 250%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.00
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 0
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 315
    Voluntary context switches: 2
    Involuntary context switches: 0
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0

1
Observe que isso pode falhar se você apenas tentar usar em timevez de /usr/bin/time. Veja: askubuntu.com/questions/434289/…
cancelado em

1

Usando sh e os para obter a resposta do python bayer.

float(sh.awk(sh.ps('u','-p',os.getpid()),'{sum=sum+$6}; END {print sum/1024}'))

A resposta está em megabytes.


4
Deve-se notar que `sh 'não é um módulo stdlib. É instalável com pip, no entanto.
Jürgen A. Erhard
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.