Làm thế nào tôi có thể giải phóng bộ nhớ trong Python?

Tôi đã viết một chương trình Python hoạt động trên một tệp đầu vào lớn để tạo ra một vài triệu đối tượng đại diện cho hình tam giác. Thuật toán là:

1. đọc một tập tin đầu vào
2. xử lý tệp và tạo một danh sách các hình tam giác, được biểu thị bằng các đỉnh của chúng
3. xuất các đỉnh ở định dạng TẮT: một danh sách các đỉnh theo sau là danh sách các tam giác. Các tam giác được đại diện bởi các chỉ số vào danh sách các đỉnh

Yêu cầu TẮT mà tôi in ra danh sách đầy đủ các đỉnh trước khi tôi in ra các tam giác có nghĩa là tôi phải giữ danh sách các tam giác trong bộ nhớ trước khi tôi ghi đầu ra vào tệp. Trong khi đó, tôi đang gặp lỗi bộ nhớ do kích thước của danh sách.

Cách tốt nhất để nói với Python rằng tôi không còn cần một số dữ liệu nữa và nó có thể được giải phóng không?

Theo Tài liệu chính thức của Python , bạn có thể buộc Garbage Collector giải phóng bộ nhớ không được ước tính với gc.collect(). Thí dụ:

import gc
gc.collect()

Thật không may (tùy thuộc vào phiên bản và phát hành Python của bạn), một số loại đối tượng sử dụng "danh sách miễn phí" là một tối ưu hóa cục bộ gọn gàng nhưng có thể gây ra sự phân mảnh bộ nhớ, đặc biệt bằng cách tạo ra nhiều bộ nhớ hơn cho các đối tượng thuộc một loại nhất định và do đó không có sẵn cho "quỹ chung".

Cách thực sự đáng tin cậy duy nhất để đảm bảo rằng việc sử dụng bộ nhớ lớn nhưng tạm thời KHÔNG trả lại tất cả tài nguyên cho hệ thống khi hoàn thành, đó là việc sử dụng đó xảy ra trong một quy trình con, sau đó công việc đói bộ nhớ sẽ chấm dứt. Trong điều kiện như vậy, hệ điều hành SILL thực hiện công việc của mình và sẵn sàng tái chế tất cả các tài nguyên mà quy trình con có thể đã ngấu nghiến. May mắn thay,multiprocessing mô-đun làm cho loại hoạt động này (thường là một nỗi đau) không quá tệ trong các phiên bản hiện đại của Python.

Trong trường hợp sử dụng của bạn, có vẻ như cách tốt nhất để các quy trình con tích lũy một số kết quả và đảm bảo các kết quả đó có sẵn cho quy trình chính là sử dụng các tệp bán tạm thời (ý tôi là tạm thời, KHÔNG phải là loại tệp mà tự động biến mất khi đóng, chỉ là các tệp thông thường mà bạn xóa rõ ràng khi bạn hoàn thành tất cả với chúng).

Các deltuyên bố có thể sử dụng, nhưng IIRC nó không được đảm bảo để giải phóng bộ nhớ . Các tài liệu ở đây ... và tại sao nó không được phát hành ở đây .

Tôi đã nghe mọi người trên các hệ thống Linux và Unix yêu cầu một quy trình python thực hiện một số công việc, nhận kết quả và sau đó giết chết nó.

Bài viết này có ghi chú về trình thu gom rác Python, nhưng tôi nghĩ thiếu kiểm soát bộ nhớ là nhược điểm của bộ nhớ được quản lý

Python được thu gom rác, vì vậy nếu bạn giảm kích thước danh sách của mình, nó sẽ lấy lại bộ nhớ. Bạn cũng có thể sử dụng câu lệnh "del" để loại bỏ hoàn toàn một biến:

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

Bạn không thể giải phóng bộ nhớ rõ ràng. Điều bạn cần làm là đảm bảo rằng bạn không giữ các tham chiếu đến các đối tượng. Sau đó chúng sẽ được thu gom rác, giải phóng bộ nhớ.

Trong trường hợp của bạn, khi bạn cần danh sách lớn, thông thường bạn cần tổ chức lại mã, thường sử dụng trình tạo / lặp thay thế. Bằng cách đó, bạn không cần phải có danh sách lớn trong bộ nhớ.

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

(del có thể là bạn của bạn, vì nó đánh dấu các đối tượng là có thể xóa khi không có tài liệu tham khảo nào khác về chúng. Bây giờ, thông thường CPython giữ bộ nhớ này để sử dụng sau này, vì vậy hệ điều hành của bạn có thể không thấy bộ nhớ "giải phóng".)

Có thể bạn sẽ không gặp phải bất kỳ vấn đề bộ nhớ nào ngay từ đầu bằng cách sử dụng cấu trúc nhỏ gọn hơn cho dữ liệu của bạn. Do đó, danh sách các số ít hiệu quả bộ nhớ hơn nhiều so với định dạng được sử dụng bởi arraymô-đun tiêu chuẩn hoặc mô-đun của bên thứ ba numpy. Bạn sẽ tiết kiệm bộ nhớ bằng cách đặt các đỉnh của bạn vào một mảng NumPy 3xN và các tam giác của bạn trong một mảng phần tử N.

Tôi đã có một vấn đề tương tự trong việc đọc một biểu đồ từ một tập tin. Việc xử lý bao gồm việc tính toán ma trận float 200 000x200 000 (một dòng tại một thời điểm) không phù hợp với bộ nhớ. Cố gắng giải phóng bộ nhớ giữa các tính toán bằng cách sử dụng gc.collect()cố định khía cạnh liên quan đến bộ nhớ của vấn đề nhưng nó dẫn đến các vấn đề về hiệu năng: Tôi không biết tại sao nhưng mặc dù lượng bộ nhớ đã sử dụng không đổi, mỗi cuộc gọi mới gc.collect()mất nhiều thời gian hơn cái trước đó. Vì vậy, khá nhanh chóng việc thu gom rác mất phần lớn thời gian tính toán.

Để khắc phục cả vấn đề về bộ nhớ và hiệu năng, tôi chuyển sang sử dụng thủ thuật đa luồng mà tôi đã đọc một lần ở đâu đó (tôi xin lỗi, tôi không thể tìm thấy bài đăng liên quan nữa). Trước khi tôi đọc từng dòng của tệp trong một forvòng lặp lớn , hãy xử lý nó và chạy gc.collect()mỗi lần một lần để giải phóng không gian bộ nhớ. Bây giờ tôi gọi một hàm đọc và xử lý một đoạn của tệp trong một luồng mới. Khi luồng kết thúc, bộ nhớ sẽ tự động được giải phóng mà không gặp vấn đề hiệu năng lạ.

Thực tế nó hoạt động như thế này:

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

Những người khác đã đăng một số cách mà bạn có thể "dỗ" trình thông dịch Python giải phóng bộ nhớ (hoặc nếu không tránh được vấn đề về bộ nhớ). Có thể bạn nên thử ý tưởng của họ trước. Tuy nhiên, tôi cảm thấy điều quan trọng là cung cấp cho bạn một câu trả lời trực tiếp cho câu hỏi của bạn.

Thực sự không có cách nào để nói trực tiếp với Python về bộ nhớ trống. Thực tế của vấn đề đó là nếu bạn muốn mức độ kiểm soát thấp như vậy, bạn sẽ phải viết một phần mở rộng bằng C hoặc C ++.

Điều đó nói rằng, có một số công cụ để giúp với điều này:

• con trăn
• swig
• tăng trăn

Nếu bạn không quan tâm đến việc sử dụng lại đỉnh, bạn có thể có hai tệp đầu ra - một cho đỉnh và một cho hình tam giác. Sau đó nối tệp tam giác vào tệp đỉnh khi bạn hoàn thành.