Suivi de l'utilisation *maximale* de la mémoire par une fonction Python

Question

Je veux savoir quelle est la quantité maximale de RAM allouée pendant l'appel à une fonction (en Python). Il y a d'autres questions sur SO liées au suivi de l'utilisation de la RAM :

Quel profileur de mémoire Python est recommandé ?

Comment puis-je profiler l'utilisation de la mémoire en Python ?

mais ceux-ci semblent vous permettre de mieux suivre l'utilisation de la mémoire au moment où la heap() la méthode (dans le cas de guppy) est appelée. Cependant, ce que je veux suivre, c'est une fonction dans une bibliothèque externe que je ne peux pas modifier, et qui utilise beaucoup de RAM mais la libère une fois l'exécution de la fonction terminée. Existe-t-il un moyen de savoir quelle est la quantité totale de RAM utilisée pendant l'appel de la fonction ?

Answer 1

Utilitaire Unix standard time suit l'utilisation maximale de la mémoire du processus ainsi que d'autres statistiques utiles pour votre programme.

Exemple de sortie ( maxresident est l'utilisation maximale de la mémoire, en Kilo-octets.) :

> time python ./scalabilty_test.py
45.31user 1.86system 0:47.23elapsed 99%CPU (0avgtext+0avgdata 369824maxresident)k
0inputs+100208outputs (0major+99494minor)pagefaults 0swaps

Answer 2

Lire la source de free de l'information, /proc/meminfo sur un système linux :

~ head /proc/meminfo
MemTotal:        4039168 kB
MemFree:         2567392 kB
MemAvailable:    3169436 kB
Buffers:           81756 kB
Cached:           712808 kB
SwapCached:            0 kB
Active:           835276 kB
Inactive:         457436 kB
Active(anon):     499080 kB
Inactive(anon):    17968 kB

J'ai créé une classe décorateur pour mesurer la consommation de mémoire d'une fonction.

class memoryit:

    def FreeMemory():
        with open('/proc/meminfo') as file:
            for line in file:
                if 'MemFree' in line:
                    free_memKB = line.split()[1]
                    return (float(free_memKB)/(1024*1024))    # returns GBytes float

    def __init__(self, function):    # Decorator class to print the memory consumption of a 
        self.function = function     # function/method after calling it a number of iterations

    def __call__(self, *args, iterations = 1, **kwargs):
        before = memoryit.FreeMemory()
        for i in range (iterations):
            result = self.function(*args, **kwargs)
        after = memoryit.FreeMemory()
        print ('%r memory used: %2.3f GB' % (self.function.__name__, (before - after) / iterations))
        return result

Fonction permettant de mesurer la consommation :

@memoryit
def MakeMatrix (dim):
    matrix = []   
    for i in range (dim):
        matrix.append([j for j in range (dim)])
    return (matrix)

Utilisation :

print ("Starting memory:", memoryit.FreeMemory()) 
m = MakeMatrix(10000)    
print ("Ending memory:", memoryit.FreeMemory() )

Imprimé :

Starting memory: 10.58599853515625
'MakeMatrix' memory used: 3.741 GB
Ending memory: 6.864116668701172

Answer 3

Je me suis également débattu avec cette tâche. Après avoir expérimenté avec psutil et les méthodes d'Adam, j'ai écrit une fonction (crédits à Adam Lewis) pour mesurer la mémoire utilisée par une fonction spécifique. Les gens peuvent trouver cela plus facile à saisir et à utiliser.

1) mesure_de_la_mémoire

2) test measure_memory_usage

J'ai trouvé que les documents sur le threading et la surcharge de la superclasse sont vraiment utiles pour comprendre ce que fait Adam dans ses scripts. Désolé, je ne peux pas poster les liens en raison de ma limitation à "2 liens" maximum.