Kebocoran memori Python [tertutup]

Saya memiliki skrip yang berjalan lama yang, jika dibiarkan berjalan cukup lama, akan menghabiskan semua memori pada sistem saya.

Tanpa merinci skrip, saya punya dua pertanyaan:

1. Apakah ada "Praktik Terbaik" untuk diikuti, yang akan membantu mencegah kebocoran terjadi?
2. Teknik apa yang ada untuk men-debug kebocoran memori di Python?

Lihat artikel ini: Menelusuri kebocoran memori python

Juga, perhatikan bahwa modul pengumpulan sampah sebenarnya dapat memiliki flag debug yang ditetapkan. Lihatlah set_debugfungsinya. Selain itu, lihat kode ini oleh Gnibbler untuk menentukan jenis objek yang telah dibuat setelah panggilan.

Saya mencoba sebagian besar opsi yang disebutkan sebelumnya tetapi menemukan paket kecil dan intuitif ini menjadi yang terbaik: pympler

Cukup mudah untuk melacak objek yang tidak dikumpulkan oleh sampah, periksa contoh kecil ini:

instal paket via pip install pympler

from pympler.tracker import SummaryTracker
tracker = SummaryTracker()

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

tracker.print_diff()

Output menunjukkan kepada Anda semua objek yang telah ditambahkan, ditambah memori yang mereka konsumsi.

Output sampel:

                                 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

Paket ini menyediakan sejumlah fitur lainnya. Periksa dokumentasi pympler , khususnya bagian Mengidentifikasi kebocoran memori .

Biarkan saya merekomendasikan alat mem_top yang saya buat

Itu membantu saya untuk memecahkan masalah serupa

Itu hanya langsung menunjukkan tersangka atas kebocoran memori dalam program Python

Modul Tracemalloc diintegrasikan sebagai modul bawaan mulai dari Python 3.4, dan tampaknya, itu juga tersedia untuk versi sebelumnya dari Python sebagai perpustakaan pihak ketiga (belum mengujinya).

Modul ini dapat menampilkan file dan jalur yang tepat yang mengalokasikan sebagian besar memori. IMHO, informasi ini jauh lebih berharga daripada jumlah instance yang dialokasikan untuk setiap jenis (yang akhirnya menjadi banyak tuple 99% dari waktu, yang merupakan petunjuk, tetapi hampir tidak membantu dalam kebanyakan kasus).

Saya sarankan Anda menggunakan tracemalloc dalam kombinasi dengan pyrasite . 9 kali dari 10, menjalankan potongan 10 teratas dalam cangkang pyrasite akan memberi Anda informasi dan petunjuk yang cukup untuk memperbaiki kebocoran dalam waktu 10 menit. Namun, jika Anda masih tidak dapat menemukan penyebab kebocorannya, shell-pyrasite yang dikombinasikan dengan alat-alat lain yang disebutkan di utas ini mungkin akan memberi Anda beberapa petunjuk lagi. Anda juga harus melihat pada semua pembantu tambahan yang disediakan oleh pyrasite (seperti penampil memori).

Anda harus secara khusus melihat data global atau statis Anda (data yang berumur panjang).

Ketika data ini tumbuh tanpa batasan, Anda juga bisa mendapatkan masalah dengan Python.

Pengumpul sampah hanya dapat mengumpulkan data, yang tidak dirujuk lagi. Tetapi data statis Anda dapat menghubungkan elemen data yang harus dibebaskan.

Masalah lain dapat berupa siklus memori, tetapi setidaknya secara teori pengumpul sampah harus menemukan dan menghilangkan siklus - setidaknya selama mereka tidak terikat pada beberapa data yang hidup lama.

Jenis data umur panjang apa yang secara khusus menyusahkan? Lihatlah daftar dan kamus - mereka dapat tumbuh tanpa batas. Dalam kamus Anda bahkan mungkin tidak melihat masalah yang datang karena ketika Anda mengakses dicts, jumlah kunci dalam kamus mungkin tidak memiliki visibilitas besar kepada Anda ...

Untuk mendeteksi dan menemukan kebocoran memori untuk proses yang berjalan lama, misalnya di lingkungan produksi, Anda sekarang dapat menggunakan stackimpact . Ini menggunakan tracemalloc di bawahnya. Info lebih lanjut di posting ini .

Sejauh praktik terbaik, perhatikan fungsi rekursif. Dalam kasus saya, saya mengalami masalah dengan rekursi (di mana tidak perlu). Contoh sederhana dari apa yang saya lakukan:

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()

beroperasi dengan cara rekursif ini tidak akan memicu pengumpulan sampah dan membersihkan sisa-sisa fungsi, sehingga setiap kali melalui penggunaan memori tumbuh dan tumbuh.

Solusi saya adalah dengan menarik panggilan rekursif dari my_function () dan memiliki main () menangani kapan harus memanggilnya lagi. dengan cara ini fungsi berakhir secara alami dan membersihkan sendiri.

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()

Tidak yakin tentang "Praktik Terbaik" untuk kebocoran memori di python, tetapi python harus menghapus memori sendiri oleh pengumpul sampah itu. Jadi terutama saya akan mulai dengan memeriksa daftar bundar beberapa pendek, karena mereka tidak akan diambil oleh pengumpul sampah.

Ini tidak berarti saran lengkap. Tetapi hal pertama yang perlu diingat ketika menulis dengan pemikiran untuk menghindari kebocoran memori masa depan adalah untuk memastikan bahwa apa pun yang menerima referensi untuk panggilan balik, harus menyimpan panggilan kembali itu sebagai referensi yang lemah.