Tout ce que vous devez savoir sur le garbage collector en Python

En règle générale, vous n'avez pas à vous soucier du garbage collector et de l'utilisation de la mémoire lorsque vous écrivez du code Python. Dès que les objets ne sont plus nécessaires, Python libère automatiquement la mémoire d'eux. Malgré cela, comprendre comment GC fonctionne vous aidera à écrire un meilleur code.

Gestionnaire de mémoire

Contrairement à d'autres langages populaires, Python ne libère pas toute la mémoire sur le système d'exploitation dès qu'il supprime un objet. Au lieu de cela, il utilise un gestionnaire de mémoire supplémentaire conçu pour les petits objets (dont la taille est inférieure à 512 octets). Pour travailler avec de tels objets, il alloue de grands blocs de mémoire, dans lesquels de nombreux petits objets seront stockés à l'avenir.

Dès qu'un des petits objets est supprimé - la mémoire du dessous ne va pas au système d'exploitation, Python le laisse pour de nouveaux objets de même taille. S'il ne reste aucun objet dans l'un des blocs de mémoire alloués, Python peut le libérer sur le système d'exploitation. En règle générale, les blocs sont libérés lorsque le script crée de nombreux objets temporaires.

Ainsi, si un processus Python de longue durée commence à consommer plus de mémoire au fil du temps, cela ne signifie pas du tout que votre code a un problème de fuite de mémoire. Si vous voulez en savoir plus sur le gestionnaire de mémoire en Python, vous pouvez le lire dans mon autre article .

Algorithmes de collecte des ordures

L'interpréteur python standard (CPython) utilise deux algorithmes à la fois, le comptage des références et le récupérateur de place générationnel (ci-après GC), mieux connu sous le nom de module gc standard de Python.

L'algorithme de comptage de liens est très simple et efficace, mais il présente un gros inconvénient. Il ne sait pas définir les références circulaires. C'est pour cette raison qu'en python, il existe un collecteur supplémentaire appelé GC générationnel qui surveille les objets avec des références circulaires potentielles.

En Python, l'algorithme de comptage de référence est fondamental et ne peut pas être désactivé, tandis que le GC est facultatif et peut être désactivé.

Algorithme de comptage de liens

L'algorithme de comptage de liens est l'une des techniques de collecte de déchets les plus simples. Les objets sont supprimés dès qu'ils ne sont plus référencés.

En Python, les variables ne stockent pas de valeurs, mais agissent comme des références aux objets. C'est-à-dire que lorsque vous affectez une valeur à une nouvelle variable, d'abord un objet avec cette valeur est créé, et alors seulement la variable commence à s'y référer. Plusieurs variables peuvent référencer un seul objet.

Chaque objet en Python contient un champ supplémentaire (compteur de référence), qui stocke le nombre de liens vers celui-ci. Dès que quelqu'un fait référence à un objet, ce champ est incrémenté de un. Si, pour une raison quelconque, le lien disparaît, ce champ est réduit de un.

Exemples lorsque le nombre de liens augmente:

• opérateur d'affectation
• passer des arguments
• insérer un nouvel objet dans la feuille (le nombre de liens pour l'objet augmente)
• une construction de la forme foo = bar (foo commence à se référer au même objet que bar)

Dès que le compteur de référence pour un objet spécifique atteint zéro, l'interpréteur démarre le processus de destruction de l'objet. Si l'objet distant contient des liens vers d'autres objets, ces liens sont également supprimés. Ainsi, la suppression d'un objet peut entraîner la suppression d'autres.

Par exemple, si une liste est supprimée, le nombre de références dans tous ses éléments est réduit de un. Si tous les objets de la liste ne sont utilisés nulle part ailleurs, ils seront également supprimés.

Les variables déclarées en dehors des fonctions, classes et blocs sont appelées globales. En règle générale, le cycle de vie de ces variables est égal à la durée de vie du processus Python. Ainsi, le nombre de références à des objets référencés par des variables globales ne tombe jamais à zéro.

Les variables déclarées à l'intérieur d'un bloc (fonction, classe) ont une visibilité locale (c'est-à-dire qu'elles ne sont visibles qu'à l'intérieur du bloc). Dès que l'interpréteur python quitte le bloc, il détruit tous les liens créés par les variables locales à l'intérieur.

Vous pouvez toujours vérifier le nombre de liens à l'aide de la fonction sys.getrefcount .

Exemple de compteur de liens:

 foo = [] # 2 ,    foo    getrefcount print(sys.getrefcount(foo)) def bar(a): # 4  #  foo,   (a), getrefcount       print(sys.getrefcount(a)) bar(foo) # 2 ,      print(sys.getrefcount(foo)) 

La principale raison pour laquelle l'interpréteur standard (CPython) utilise un compteur de référence est historique. Il y a actuellement beaucoup de débats sur cette approche. Certaines personnes pensent qu'un ramasse-miettes peut être beaucoup plus efficace sans algorithme de comptage de liens. Cet algorithme a de nombreux problèmes, tels que des liens circulaires, des threads de blocage, ainsi que des frais supplémentaires pour la mémoire et le processeur.

Le principal avantage de cet algorithme est que les objets sont supprimés immédiatement dès qu'ils ne sont pas nécessaires.

Poubelle en option

Pourquoi avons-nous besoin d'un algorithme supplémentaire alors que nous avons déjà un comptage de références?

Malheureusement, l'algorithme de comptage de liens classique a un gros inconvénient - il ne sait pas comment trouver des liens circulaires. Les bouclages se produisent lorsqu'un ou plusieurs objets se référencent.

Deux exemples:



Comme vous pouvez le voir, le lst objet se réfère à lui-même, tandis que object1 et object1 réfèrent l'un à l'autre. Pour de tels objets, le nombre de références sera toujours 1.

Démo Python:

 import gc #  ctypes        class PyObject(ctypes.Structure): _fields_ = [("refcnt", ctypes.c_long)] gc.disable() #   GC lst = [] lst.append(lst) #    lst lst_address = id(lst) #   lst del lst object_1 = {} object_2 = {} object_1['obj2'] = object_2 object_2['obj1'] = object_1 obj_address = id(object_1) #   del object_1, object_2 #          # gc.collect() #    print(PyObject.from_address(obj_address).refcnt) print(PyObject.from_address(lst_address).refcnt) 

Dans l'exemple ci-dessus, l'instruction del supprime les références à nos objets (pas aux objets eux-mêmes). Une fois que Python a exécuté une instruction del, ces objets deviennent inaccessibles à partir du code Python. Cependant, avec le module gc désactivé, ils resteront toujours en mémoire, car ils avaient des références circulaires et leur compteur est toujours un. Vous pouvez explorer visuellement de telles relations en utilisant la bibliothèque objgraph .

Afin de résoudre ce problème, un algorithme supplémentaire appelé module gc a été ajouté en Python 1.5. La seule tâche dont est la suppression des objets cycliques auxquels le code n'a plus accès.

Les bouclages ne peuvent se produire que dans des objets «conteneurs». C'est-à-dire dans des objets qui peuvent stocker d'autres objets, tels que des listes, des dictionnaires, des classes et des tuples. GC ne garde pas trace des types simples et immuables, à l'exception des tuples. Certains tuples et dictionnaires sont également exclus de la liste de suivi lorsque certaines conditions sont remplies. Avec tous les autres objets, l'algorithme de comptage de référence est garanti pour faire face.

Lorsque le GC est déclenché

Contrairement à l'algorithme de comptage de référence, le GC cyclique ne fonctionne pas en temps réel et s'exécute périodiquement. Chaque exécution du collecteur crée des micro-pauses dans le code, donc CPython (l'interpréteur standard) utilise diverses heuristiques pour déterminer la fréquence du garbage collector.

Le ramasse-miettes cyclique divise tous les objets en 3 générations (générations). De nouveaux objets entrent dans la première génération. Si la nouvelle installation survit au processus de collecte des ordures, elle passe à la génération suivante. Plus la génération est élevée, moins il est scanné pour les déchets. Étant donné que les nouveaux objets ont souvent une durée de vie très courte (sont temporaires), il est logique de les interroger plus souvent que ceux qui ont déjà traversé plusieurs étapes de la collecte des ordures.

Chaque génération a un compteur spécial et un seuil de réponse, lorsque le processus de collecte des ordures est déclenché. Chaque compteur stocke le nombre d'allocations moins le nombre de désallocations dans une génération donnée. Dès qu'un objet conteneur est créé en Python, il vérifie ces compteurs. Si les conditions fonctionnent, le processus de récupération de place commence.

Si plusieurs générations ou plus ont franchi le seuil à la fois, la génération la plus âgée est sélectionnée. Cela est dû au fait que les générations plus anciennes analysent également toutes les précédentes. Pour réduire le nombre de pauses de récupération de place pour les objets à longue durée de vie, la génération la plus ancienne dispose d' un ensemble supplémentaire de conditions .

Les seuils standard pour les générations sont définis respectivement sur 700, 10 10 , mais vous pouvez toujours les modifier à l'aide des fonctions gc.get_threshold gc.set_threshold .

Algorithme de recherche de boucle

Une description complète de l'algorithme de recherche de boucle nécessitera un article séparé. En bref, GC parcourt chaque objet des générations sélectionnées et supprime temporairement tous les liens d'un seul objet (tous les liens auxquels cet objet fait référence). Après un passage complet, tous les objets avec un nombre de liens inférieur à deux sont considérés comme inaccessibles à partir de python et peuvent être supprimés.

Pour une compréhension plus approfondie, je recommande de lire (la note du traducteur: matériel en anglais) la description originale de l'algorithme de Neil Schemenauer et la fonction de collect des sources CPython . Une description de Quora et un article sur le garbage collector peuvent également être utiles.

Il convient de noter que le problème avec les destructeurs décrit dans la description originale de l'algorithme a été corrigé depuis Python 3.4 (plus de détails dans PEP 442 ).

Conseils d'optimisation

Les boucles se produisent souvent dans des tâches réelles; elles peuvent être trouvées dans des problèmes avec des graphiques, des listes liées ou dans des structures de données où vous devez garder une trace des relations entre les objets. Si votre programme a une charge élevée et demande des retards, il est préférable d'éviter les boucles si possible.

Dans les endroits où vous utilisez sciemment des liens circulaires, vous pouvez utiliser des liens "faibles". Les liens faibles sont implémentés dans le module faibles références et, contrairement aux liens réguliers, n'affectent en aucune façon le compteur de liens. Si l'objet avec des références faibles s'avère être supprimé, alors None renvoyé à la place.

Dans certains cas, il est utile de désactiver la construction automatique par le module gc et de l'appeler manuellement. Pour ce faire, il suffit d'appeler gc.disable() puis d'appeler gc.collect() manuellement.

Comment rechercher et déboguer des liens circulaires

Le débogage des boucles peut être pénible, surtout si votre code utilise de nombreux modules tiers.

Le module gc fournit des fonctions d'assistance qui peuvent aider au débogage. Si les paramètres GC sont définis sur l'indicateur DEBUG_SAVEALL , tous les objets inaccessibles seront ajoutés à la liste gc.garbage .

 import gc gc.set_debug(gc.DEBUG_SAVEALL) print(gc.get_count()) lst = [] lst.append(lst) list_id = id(lst) del lst gc.collect() for item in gc.garbage: print(item) assert list_id == id(item) 

Une fois que vous avez identifié le problème, il peut être visualisé en utilisant objgraph .

Conclusion

Le processus de récupération de place principal est effectué par un algorithme de comptage de liens, qui est très simple et sans paramètres. Un algorithme supplémentaire est utilisé uniquement pour rechercher et supprimer des objets avec des références circulaires.

Vous ne devez pas vous lancer dans une optimisation prématurée du code pour le garbage collector; en pratique, les problèmes de garbage collection sont assez rares.

PS: je suis l'auteur de cet article, vous pouvez poser toutes vos questions.