Як явно можна звільнити пам'ять у Python?

Я написав програму Python, яка діє на великий вхідний файл, щоб створити кілька мільйонів об'єктів, що представляють трикутники. Алгоритм:

1. читати вхідний файл
2. обробіть файл і створіть список трикутників, представлений їх вершинами
3. вивести вершини у форматі OFF: список вершин, а потім список трикутників. Трикутники представлені індексами до списку вершин

Вимога OFF, щоб я надрукував повний список вершин перед тим, як надрукувати трикутники, означає, що я повинен утримувати список трикутників у пам'яті, перш ніж записати вихід у файл. Тим часом я отримую помилки в пам'яті через розміри списків.

Який найкращий спосіб сказати Python, що я більше не потребую деяких даних, і їх можна звільнити?

Згідно з офіційною документацією Python , ви можете змусити колектор сміття звільнити невідповідну пам'ять gc.collect(). Приклад:

import gc
gc.collect()

На жаль (залежно від вашої версії та випуску Python) деякі типи об’єктів використовують "безкоштовні списки", які є акуратною локальною оптимізацією, але можуть викликати фрагментацію пам'яті, зокрема, роблячи все більше пам'яті "виділеною" лише для об'єктів певного типу та тим самим недоступний до "загального фонду".

Єдиний дійсно надійний спосіб забезпечити, що велике, але тимчасове використання пам’яті НЕ повертає всі ресурси до системи, коли це зроблено, - це використовувати це в підпроцесі, який виконує роботу пам'яті. За таких умов операційна система БУДЕ виконувати свою роботу і з радістю переробляє всі ресурси, які, можливо, підробити. На щастя, multiprocessingмодуль робить подібну операцію (яка раніше була біль) не надто погано в сучасних версіях Python.

У вашому випадку використання, здається, що найкращий спосіб для підпроцесів накопичувати певні результати, але при цьому забезпечити доступність цих результатів для основного процесу - це використання напів тимчасових файлів (я маю на увазі НЕ типові файли, які автоматично закриваються, коли закриваються, просто звичайні файли, які ви явно видаляєте, коли все закінчите з ними).

delЗаява може бути корисним, але IIRC не гарантовано , щоб звільнити пам'ять . Ці документи тут ... і чому він не позбавлений тут .

Я чув, як люди в системах типу Linux і Unix змушували процес python виконувати якусь роботу, отримуючи результати, а потім вбиваючи його.

У цій статті є примітки про збирач сміття Python, але я думаю, що недостатній контроль пам'яті - це мінус керованої пам'яті

Python збирає сміття, тому якщо ви зменшите розмір списку, він поверне пам'ять. Ви також можете використовувати оператор "del", щоб повністю позбутися змінної:

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

Ви не можете явно звільнити пам'ять. Що вам потрібно зробити, це переконатися, що ви не зберігаєте посилання на об’єкти. Потім вони будуть збирати сміття, звільняючи пам’ять.

У вашому випадку, коли вам потрібні великі списки, вам зазвичай потрібно реорганізувати код, як правило, використовуючи замість цього генератори / ітератори. Таким чином, вам зовсім не потрібно мати великі списки в пам'яті.

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

( delможе бути вашим другом, оскільки він позначає об'єкти як видалені, коли на них немає інших посилань. Зараз часто інтерпретатор CPython зберігає цю пам'ять для подальшого використання, тому ваша операційна система може не бачити "звільненої" пам'яті.)

Можливо, ви б не зіткнулися з будь-якою проблемою пам'яті, використовуючи більш компактну структуру для своїх даних. Таким чином, списки чисел набагато менш ефективні в пам'яті, ніж формат, використовуваний стандартним arrayмодулем або стороннім numpyмодулем. Ви б економили пам’ять, розміщуючи вершини у масиві NumPy 3xN, а трикутники - у масиві N-елементів.

У мене була схожа проблема при читанні графіка з файлу. Обробка включала обчислення поплавкової матриці площею 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

Інші опублікували деякі способи, завдяки яким ви могли б примусити інтерпретатора Python звільнити пам'ять (або інакше уникнути проблем із пам'яттю). Швидше за все, ви повинні спробувати їх ідеї спочатку. Однак я вважаю важливим дати вам пряму відповідь на ваше запитання.

Насправді немає жодного способу прямо сказати Python звільнити пам'ять. Справа в тому, що якщо вам потрібен такий низький рівень контролю, вам доведеться написати розширення на C або C ++.

Однак, є кілька інструментів, які допоможуть у цьому допомогти:

• цитон
• свиг
• прискорити пітон

Якщо вас не хвилює повторне використання вершин, у вас можуть бути два вихідні файли - один для вершин і один для трикутників. Потім додайте файл трикутника до вершинного файлу, коли закінчите.