Mémoire totale utilisée par le processus Python ?

Question

Existe-t-il un moyen pour un programme Python de déterminer la quantité de mémoire qu'il utilise actuellement ? J'ai vu des discussions sur l'utilisation de la mémoire pour un seul objet, mais ce dont j'ai besoin, c'est de l'utilisation totale de la mémoire pour le processus, afin de pouvoir déterminer quand il est nécessaire de commencer à jeter les données en cache.

Answer 1

Ici est une solution utile qui fonctionne pour divers systèmes d'exploitation, notamment Linux, Windows, etc :

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

Notes :

• hacer pip install psutil s'il n'est pas encore installé

• Une phrase très pratique si vous voulez savoir rapidement combien de MB prend votre processus :

  import os, psutil; print(psutil.Process(os.getpid()).memory_info().rss / 1024 ** 2)

• avec Python 2.7 et psutil 5.6.3, il était process.memory_info()[0] à la place (il y a eu un changement dans l'API plus tard).

Answer 2

Pour les systèmes basés sur Unix (Linux, Mac OS X, Solaris), vous pouvez utiliser la commande getrusage() du module de la bibliothèque standard resource . L'objet résultant a l'attribut ru_maxrss ce qui donne le pic l'utilisation de la mémoire pour le processus appelant :

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

El Documentation Python ne pas noter les unités. Reportez-vous à la notice de votre système spécifique man getrusage.2 pour vérifier l'unité de la valeur. Sur Ubuntu 18.04, l'unité est notée en kilo-octets. Sur Mac OS X, il s'agit d'octets.

El getrusage() peut également être donnée resource.RUSAGE_CHILDREN pour obtenir l'utilisation des processus enfants, et (sur certains systèmes) resource.RUSAGE_BOTH pour l'utilisation totale du processus (lui-même et enfant).

Si vous ne vous intéressez qu'à Linux, vous pouvez alternativement lire le document /proc/self/status ou /proc/self/statm comme décrit dans d'autres réponses à cette question et este un aussi.

Answer 3

Sous Windows, vous pouvez utiliser WMI ( page d'accueil , 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)

Sous Linux (à partir du livre de recettes 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

Answer 4

Sous unix, vous pouvez utiliser la commande ps pour le surveiller :

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

où 1347 est un identifiant de processus. De plus, le résultat est en Mo.

Answer 5

Heapy (et amis) peut être ce que vous recherchez.

En outre, les caches ont généralement une limite supérieure fixe pour leur taille afin de résoudre le type de problème dont vous parlez. Par exemple, regardez ceci Décorateur de cache LRU .