У мене була схожа проблема при читанні графіка з файлу. Обробка включала обчислення поплавкової матриці площею 200 000 x 200 000 (по одному рядку), яка не вкладалася в пам'ять. Спроба звільнити пам'ять між обчисленнями за допомогою gc.collect()
виправленого аспекту проблеми, пов’язаного з пам’яттю, але це призвело до проблем із продуктивністю: я не знаю чому, але, хоча кількість використовуваної пам’яті залишалася постійною, кожен новий дзвінок gc.collect()
забирав трохи більше часу, ніж попередній. Тож досить швидко збирання сміття зайняло більшу частину часу на обчислення.
Щоб виправити проблеми з пам'яттю та продуктивністю, я перейшов до використання багатопотокового трюку, який я десь прочитав (вибачте, більше не можу знайти відповідний пост). Перш ніж я читав кожен рядок файлу у великому for
циклі, обробляв його та працював gc.collect()
раз на час, щоб звільнити місце в пам'яті. Тепер я закликаю функцію, яка зчитує та обробляє фрагмент файлу в новому потоці. Як тільки нитка закінчується, пам'ять автоматично звільняється без дивної проблеми з продуктивністю.
Практично це працює так:
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