Wycieki pamięci w Pythonie [zamknięte]

Mam długo działający skrypt, który, jeśli zostanie uruchomiony wystarczająco długo, zajmie całą pamięć w moim systemie.

Nie wdając się w szczegóły scenariusza, mam dwa pytania:

1. Czy są jakieś „sprawdzone metody”, których należy przestrzegać, które pomogą zapobiegać wyciekom?
2. Jakie są techniki debugowania wycieków pamięci w Pythonie?

Przeczytaj ten artykuł: Śledzenie wycieków pamięci w języku Python

Należy również zauważyć, że moduł czyszczenia pamięci może mieć ustawione flagi debugowania. Spójrz na set_debugfunkcję. Dodatkowo spójrz na ten kod Gnibblera, aby określić typy obiektów, które zostały utworzone po wywołaniu.

Wypróbowałem większość wymienionych wcześniej opcji, ale ten mały i intuicyjny pakiet okazał się najlepszy: pympler

Śledzenie obiektów, które nie zostały zebrane jako śmieci, jest dość proste, sprawdź ten mały przykład:

zainstaluj pakiet za pośrednictwem pip install pympler

from pympler.tracker import SummaryTracker
tracker = SummaryTracker()

# ... some code you want to investigate ...

tracker.print_diff()

Dane wyjściowe pokazują wszystkie dodane obiekty oraz ilość zużytej przez nie pamięci.

Przykładowe dane wyjściowe:

                                 types |   # objects |   total size
====================================== | =========== | ============
                                  list |        1095 |    160.78 KB
                                   str |        1093 |     66.33 KB
                                   int |         120 |      2.81 KB
                                  dict |           3 |       840 B
      frame (codename: create_summary) |           1 |       560 B
          frame (codename: print_diff) |           1 |       480 B

Ten pakiet zawiera szereg dodatkowych funkcji. Zapoznaj się z dokumentacją pymplera , w szczególności z rozdziałem Identyfikacja wycieków pamięci .

Polecam narzędzie mem_top , które stworzyłem

Pomogło mi to rozwiązać podobny problem

Po prostu natychmiast pokazuje głównych podejrzanych o wycieki pamięci w programie w języku Python

Moduł Tracemalloc został zintegrowany jako moduł wbudowany począwszy od Pythona 3.4 i najwyraźniej jest również dostępny dla wcześniejszych wersji Pythona jako biblioteka innej firmy (chociaż go nie testowałem).

Ten moduł jest w stanie wyświetlać dokładne pliki i wiersze, które przydzieliły najwięcej pamięci. IMHO, ta informacja jest nieskończenie cenniejsza niż liczba przydzielonych instancji dla każdego typu (co kończy się na wielu krotkach w 99% przypadków, co jest wskazówką, ale w większości przypadków ledwo pomaga).

Polecam użycie tracemalloc w połączeniu z piryzytem . 9 razy na 10, uruchomienie 10 najlepszych fragmentów w powłoce pirazytu dostarczy Ci wystarczających informacji i wskazówek, jak naprawić wyciek w ciągu 10 minut. Jeśli jednak nadal nie możesz znaleźć przyczyny wycieku, skorupa pirazytu w połączeniu z innymi narzędziami wymienionymi w tym wątku prawdopodobnie da ci więcej wskazówek. Powinieneś także przyjrzeć się wszystkim dodatkowym pomocnikom zapewnianym przez pirasyt (takim jak przeglądarka pamięci).

W szczególności powinieneś spojrzeć na swoje globalne lub statyczne dane (dane długo żyjące).

Kiedy te dane rosną bez ograniczeń, możesz również mieć problemy w Pythonie.

Garbage collector może zbierać tylko dane, do których już się nie odwołuje. Jednak dane statyczne mogą łączyć elementy danych, które powinny zostać zwolnione.

Innym problemem mogą być cykle pamięci, ale przynajmniej w teorii Garbage collector powinien znaleźć i wyeliminować cykle - przynajmniej tak długo, jak długo nie są one uzależnione od jakichś długowiecznych danych.

Jakie rodzaje długowiecznych danych są szczególnie kłopotliwe? Przyjrzyj się dobrze listom i słownikom - mogą rosnąć bez ograniczeń. W słownikach możesz nawet nie zauważyć nadchodzących problemów, ponieważ kiedy korzystasz z dyktowania, liczba kluczy w słowniku może nie być dla ciebie zbyt widoczna ...

Aby wykryć i zlokalizować wycieki pamięci dla długotrwałych procesów, np. W środowiskach produkcyjnych, możesz teraz użyć stackimpact . Używa tracemalloc pod spodem. Więcej informacji w tym poście .

Jeśli chodzi o najlepsze praktyki, miej oko na funkcje rekurencyjne. W moim przypadku napotkałem problemy z rekurencją (gdzie nie było takiej potrzeby). Uproszczony przykład tego, co robiłem:

def my_function():
    # lots of memory intensive operations
    # like operating on images or huge dictionaries and lists
    .....
    my_flag = True
    if my_flag:  # restart the function if a certain flag is true
        my_function()

def main():
    my_function()

działanie w ten sposób rekurencyjny nie wyzwoli wyrzucania elementów bezużytecznych i nie usunie pozostałości funkcji, więc za każdym razem użycie pamięci rośnie i rośnie.

Moim rozwiązaniem było wyciągnięcie rekurencyjnego wywołania z funkcji my_function () i posiadanie uchwytu main (), kiedy wywołać je ponownie. w ten sposób funkcja kończy się naturalnie i oczyszcza po sobie.

def my_function():
    # lots of memory intensive operations
    # like operating on images or huge dictionaries and lists
    .....
    my_flag = True
    .....
    return my_flag

def main():
    result = my_function()
    if result:
        my_function()

Nie jestem pewien co do „Najlepszych praktyk” dotyczących wycieków pamięci w Pythonie, ale Python powinien wyczyścić swoją własną pamięć przez swój moduł odśmiecania pamięci. Więc głównie zacząłbym od sprawdzania okólnej listy jakichś krótkich, ponieważ nie zostaną one odebrane przez śmieciarza.

Nie jest to bynajmniej rada wyczerpująca. Ale najważniejszą rzeczą, o której należy pamiętać, pisząc z myślą o unikaniu przyszłych wycieków pamięci (pętli), jest upewnienie się, że wszystko, co akceptuje odwołanie do wywołania zwrotnego, powinno przechowywać to wezwanie jako słabe odniesienie.