Wycieki pamięci Pythona [zamknięte]

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

Jest całkiem prosto do śledzenia obiektów, które nie zostały zebrane śmieci, sprawdź ten mały przykład:

Zainstaluj pakiet poprzez pip install pympler

from pympler.tracker import SummaryTracker
tracker = SummaryTracker()

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

tracker.print_diff()

Wyjście pokazuje wszystkie obiekty, które zostały dodane, Plus pamięć, którą zużyły.

Przykładowe wyjście:

                                 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 wiele innych funkcji. Sprawdź dokumentacja pymplera , w szczególności sekcja identyfikująca wycieki pamięci .

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

Pomogło mi rozwiązać podobny problem

Od razu pokazuje listę podejrzanych o wycieki pamięci w programie Pythona

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

Ten moduł jest w stanie wypisać dokładne pliki i linie, które przydzieliły najwięcej pamięci. IMHO, ta informacja jest nieskończenie cenniejsza niż liczba przypisanych instancji dla każdego typu (co kończy się dużą ilością krotek 99% czasu, co jest wskazówka, ale w większości przypadków ledwo pomaga).

Zalecam stosowanie tracemalloc w połączeniu z pyrazytem . 9 razy na 10, uruchomienie Top 10 snippetw pyrasite-shell da ci wystarczająco dużo informacji i wskazówek, aby naprawić wyciek w ciągu 10 minut. Jeśli jednak nadal nie możesz znaleźć przyczyny wycieku, powłoka pyrazyt w połączeniu z innymi narzędziami wymienionymi w tym wątku prawdopodobnie da ci więcej wskazówek. Należy również spojrzeć na wszystkie dodatkowych pomocników dostarczanych przez pyrasite (np. przeglądarkę pamięci).

Powinieneś szczególnie spojrzeć na swoje dane globalne lub statyczne (long living data).

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

Garbage collector może zbierać tylko dane, które nie są już odwołane. Ale Twoje dane statyczne mogą łączyć elementy danych, które powinny zostać zwolnione.

Innym problemem mogą być cykle pamięci, ale przynajmniej teoretycznie Śmieciarz powinien znaleźć i wyeliminować cykle - przynajmniej tak długo, jak są nie jestem uzależniony od jakichś danych.

Jakie dane długo żyjące są szczególnie kłopotliwe? Dobrze przyjrzyj się wszelkim listom i słownikom-mogą rosnąć bez żadnych ograniczeń. W słownikach możesz nawet nie zauważyć problemów, ponieważ gdy uzyskasz dostęp do dict, Liczba klawiszy w słowniku może nie być dla Ciebie duża widoczność ...

Do wykrywania i lokalizowania wycieków pamięci dla długotrwałych procesów, np. w środowiskach produkcyjnych, można teraz użyć stackimpact. Używa tracemalloc pod spodem. Więcej informacji w ten post .

Jeśli chodzi o najlepsze praktyki, miej oko na funkcje rekurencyjne. W moim przypadku natknąłem się na problemy z rekurencją (gdzie nie było 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 rekurencyjny sposób nie uruchomi zbierania śmieci i nie usunie pozostałości funkcji, więc za każdym razem przez użycie pamięci rośnie i rośnie.

Moim rozwiązaniem było wyciągnięcie rekurencyjnego wywołania z my_function () i mieć main () uchwyt, kiedy go wywołać jeszcze raz. w ten sposób funkcja kończy się naturalnie i oczyszcza się 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" dla wycieków pamięci w Pythonie, ale python powinien wyczyścić własną pamięć przez garbage collector. Więc przede wszystkim chciałbym zacząć od sprawdzenia okrągłej listy niektórych krótkich, ponieważ nie zostaną one odebrane przez śmieciarza.

To nie jest wyczerpująca Rada. 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 odniesienie do połączenia zwrotnego, powinno przechowywać to wezwanie jako słabe odniesienie.