Python'da hafızayı nasıl boşaltabilirim?

Üçgenleri temsil eden birkaç milyon nesne oluşturmak için büyük bir girdi dosyasına etki eden bir Python programı yazdım. Algoritma:

1. bir girdi dosyasını oku
2. dosyayı işleyin ve köşeleriyle gösterilen üçgenlerin bir listesini oluşturun
3. köşeleri OFF biçiminde çıktılar: köşelerin listesi ve ardından üçgen listesi. Üçgenler, dizinler listesinde endekslerle temsil edilir

Üçgenleri yazdırmadan önce köşelerin tam listesini yazdırmamın KAPALI olması, çıktıyı dosyaya yazmadan önce bellekte üçgen listesini tutmam gerektiği anlamına gelir. Bu arada listelerin boyutları nedeniyle bellek hataları alıyorum.

Python'a artık bazı verilere ihtiyacım olmadığını ve serbest bırakılabileceğini söylemenin en iyi yolu nedir?

Python Resmi Belgelerine göre , Çöp Toplayıcı'yı referanssız belleği serbest bırakmaya zorlayabilirsiniz gc.collect(). Misal:

import gc
gc.collect()

Maalesef (sürümünüze ve Python sürümünüze bağlı olarak) bazı nesne türleri, düzenli bir yerel optimizasyon olan ancak özellikle belirli bir tür nesneler için daha fazla bellek "ayrılmış" yaparak bellek parçalanmasına neden olabilecek "ücretsiz listeler" kullanır. dolayısıyla "genel fon" tarafından kullanılamaz.

Büyük ama geçici bir bellek kullanımının YAPILDIĞINDA tüm kaynakları sisteme geri döndürmesini sağlamanın tek güvenilir yolu, bu kullanımın belleğe aç çalışmaların sona erdiği bir alt işlemde gerçekleşmesini sağlamaktır. Bu koşullar altında, işletim sistemi işini YAPACAK ve alt sürecin kattığı tüm kaynakları memnuniyetle geri dönüştürecektir. Neyse ki, multiprocessingmodül Python'un modern versiyonlarında bu tür bir işlemi (eskiden bir acıydı) çok kötü değil.

Kullanım durumunuzda, alt işlemlerin bazı sonuçlar biriktirmesinin ve bu sonuçların ana işlem için kullanılabilir olmasını sağlamanın en iyi yolunun yarı geçici dosyaları kullanmak olduğu anlaşılmaktadır (yarı geçici olarak, yani tür dosyaları değil kapatıldığında otomatik olarak kaybolur, yalnızca işiniz bittiğinde açıkça sildiğiniz sıradan dosyalar).

delDeyimi kullanım olabilir, ama IIRC belleği boşaltmaya garanti edilmez . Docs burada ... ve bir o serbest bırakılmaz neden burada .

Linux ve Unix tipi sistemlerde insanların bir python işleminin biraz iş yapmasını, sonuç almasını ve sonra öldürmesini istediğini duydum.

Bu makalede Python çöp toplayıcı hakkında notlar var, ancak bellek kontrolü eksikliği yönetilen bellek için olumsuz olduğunu düşünüyorum

Python çöp toplanır, bu nedenle listenizin boyutunu küçültürseniz belleği geri kazanır. Bir değişkenten tamamen kurtulmak için "del" ifadesini de kullanabilirsiniz:

biglist = [blah,blah,blah]
#...
del biglist

Belleği açıkça boşaltamazsınız. Yapmanız gereken şey, nesnelere referans tutmamanızdır. Daha sonra çöp toplanacak ve hafızayı boşaltacaktır.

Sizin durumunuzda, büyük listelere ihtiyacınız olduğunda, genellikle kodu jeneratörler / yineleyiciler kullanarak yeniden düzenlemeniz gerekir. Bu şekilde büyük listelerin hafızada olmasına gerek kalmaz.

http://www.prasannatech.net/2009/07/introduction-python-generators.html

( delbaşka referans olmadığında nesneleri silinebilir olarak işaret ettiği için arkadaşınız olabilir. Şimdi, CPython yorumlayıcısı bu belleği daha sonra kullanmak üzere saklar, bu nedenle işletim sisteminiz "serbest" belleği görmeyebilir.)

Belki de verileriniz için daha kompakt bir yapı kullanarak ilk etapta herhangi bir hafıza problemi yaşamazsınız. Bu nedenle, numara listeleri standart arraymodül veya üçüncü taraf numpymodül tarafından kullanılan formattan çok daha az bellek verimlidir . Köşelerinizi bir NumPy 3xN dizisine ve üçgenlerinizi bir N öğesi dizisine koyarak bellekte tasarruf edersiniz.

Bir dosyadan grafik okuma benzer bir sorun vardı. İşleme, belleğe sığmayan 200 000x200 000 şamandıralı bir matrisin (her seferinde bir satır) hesaplanmasını içeriyordu. gc.collect()Sorunun belleğe bağlı yönünü kullanarak hesaplamalar arasında belleği boşaltmaya çalışmak, ancak performans sorunlarına neden oldu: Neden bilmiyorum ama kullanılan bellek miktarı sabit kalsa da, her yeni çağrı gc.collect()daha fazla zaman aldı bir önceki. Çok hızlı bir şekilde çöp toplama işlemi hesaplama süresinin çoğunu aldı.

Hem bellek hem de performans sorunlarını gidermek için bir kerede bir yerde okuduğum çok iş parçacıklı bir hile kullanımına geçtim (Üzgünüm, artık ilgili yazıyı bulamıyorum). Büyük bir fordöngü içinde dosyanın her satırını okumadan önce , onu işliyor ve gc.collect()bellek alanını boşaltmak için her seferinde çalışıyor . Şimdi yeni bir iş parçacığında dosyanın bir yığınını okuyan ve işleyen bir işlev çağırıyorum. İş parçacığı sona erdiğinde, garip performans sorunu olmadan bellek otomatik olarak serbest bırakılır.

Pratik olarak şu şekilde çalışır:

from dask import delayed  # this module wraps the multithreading
def f(storage, index, chunk_size):  # the processing function
    # read the chunk of size chunk_size starting at index in the file
    # process it using data in storage if needed
    # append data needed for further computations  to storage 
    return storage

partial_result = delayed([])  # put into the delayed() the constructor for your data structure
# I personally use "delayed(nx.Graph())" since I am creating a networkx Graph
chunk_size = 100  # ideally you want this as big as possible while still enabling the computations to fit in memory
for index in range(0, len(file), chunk_size):
    # we indicates to dask that we will want to apply f to the parameters partial_result, index, chunk_size
    partial_result = delayed(f)(partial_result, index, chunk_size)

    # no computations are done yet !
    # dask will spawn a thread to run f(partial_result, index, chunk_size) once we call partial_result.compute()
    # passing the previous "partial_result" variable in the parameters assures a chunk will only be processed after the previous one is done
    # it also allows you to use the results of the processing of the previous chunks in the file if needed

# this launches all the computations
result = partial_result.compute()

# one thread is spawned for each "delayed" one at a time to compute its result
# dask then closes the tread, which solves the memory freeing issue
# the strange performance issue with gc.collect() is also avoided

Diğerleri, Python yorumlayıcısını belleği boşaltmak için "koaksiyel" edebileceğiniz (veya bellek sorunlarından kaçınabileceğiniz) bazı yollar yayınladı. Muhtemelen ilk önce fikirlerini denemelisiniz. Ancak, sorunuza doğrudan cevap vermenin önemli olduğunu düşünüyorum.

Doğrudan Python'a hafızayı boşaltmasını söylemenin hiçbir yolu yoktur. Gerçek şu ki, bu kadar düşük bir kontrol seviyesi istiyorsanız, C veya C ++ 'da bir uzantı yazmak zorunda kalacaksınız.

Bununla birlikte, bu konuda yardımcı olacak bazı araçlar var:

• Cython
• yudum
• Python'u güçlendir

Köşe yeniden kullanımını umursamıyorsanız, biri köşe noktaları diğeri üçgenler için olmak üzere iki çıktı dosyanız olabilir. Ardından, işiniz bittiğinde üçgen dosyasını köşe dosyasına ekleyin.