Cách chuyên nghiệp để tạo ra một vấn đề lớn mà không cần lấp đầy các mảng lớn: C ++, bộ nhớ trống từ một phần của mảng

Tôi đang phát triển một mô phỏng vật lý, và vì tôi khá mới mẻ với lập trình, tôi tiếp tục gặp vấn đề khi sản xuất các chương trình lớn (chủ yếu là vấn đề bộ nhớ). Tôi biết về phân bổ và xóa bộ nhớ động (mới / xóa, v.v.), nhưng tôi cần một cách tiếp cận tốt hơn về cách tôi cấu trúc chương trình.

Giả sử tôi đang mô phỏng một thử nghiệm đang chạy trong vài ngày, với tỷ lệ lấy mẫu rất lớn. Tôi cần mô phỏng một tỷ mẫu và chạy qua chúng.

Là một phiên bản siêu đơn giản, chúng tôi sẽ nói rằng một chương trình có điện áp V [i] và tính tổng chúng trong các mệnh đề:

tức là NewV [0] = V [0] + V [1] + V [2] + V [3] + V [4]

sau đó NewV [1] = V [1] + V [2] + V [3] + V [4] + V [5]

sau đó NewV [2] = V [2] + V [3] + V [4] + V [5] + V [6] ... và điều này diễn ra trong một tỷ mẫu.

Cuối cùng, tôi có V [0], V [1], ..., V [1000000000], khi thay vào đó, những thứ duy nhất tôi cần lưu trữ cho bước tiếp theo là 5 V cuối cùng [i] S.

Làm thế nào tôi có thể xóa / sắp xếp lại một phần của mảng để bộ nhớ được sử dụng lại miễn phí (giả sử V [0] sau phần đầu tiên của ví dụ khi không còn cần thiết)? Có những lựa chọn thay thế cho cách cấu trúc một chương trình như vậy?

Tôi đã nghe nói về malloc / miễn phí, nhưng nghe nói rằng chúng không nên được sử dụng trong C ++ và có những lựa chọn thay thế tốt hơn.

Cảm ơn rất nhiều!

tldr; Phải làm gì với các phần của mảng (các phần tử riêng lẻ) Tôi không cần nữa mà đang chiếm một lượng lớn bộ nhớ?

Những gì bạn mô tả, "làm mịn bởi các cặp vợ chồng", là một bộ lọc kỹ thuật số đáp ứng xung hữu hạn (FIR). Bộ lọc như vậy được thực hiện với bộ đệm tròn. Bạn chỉ giữ các giá trị N cuối cùng, bạn giữ một chỉ mục vào bộ đệm cho bạn biết giá trị cũ nhất ở đâu, bạn ghi đè giá trị cũ nhất hiện tại với giá trị mới nhất ở mỗi bước và mỗi lần bạn lập chỉ mục.

Bạn giữ dữ liệu đã thu thập của mình, rằng bạn sẽ giảm xuống, trên đĩa.

Tùy thuộc vào môi trường của bạn, đây có thể là một trong những nơi mà bạn tốt hơn nên nhận trợ giúp có kinh nghiệm. Tại một trường đại học, bạn ghi chú lên bảng thông báo ở Khoa Khoa học Máy tính, đưa ra mức lương sinh viên (hoặc thậm chí là giá tư vấn của sinh viên) trong vài giờ làm việc, để giúp bạn xử lý dữ liệu. Hoặc có thể bạn cung cấp điểm Cơ hội nghiên cứu đại học. Hoặc một cái gì đó.

Mọi vấn đề có thể được giải quyết bằng cách thêm một mức độ bổ sung. Vì vậy, làm điều đó.

Bạn không thể xóa một phần của một mảng trong C ++. Nhưng bạn có thể tạo một mảng mới chỉ giữ dữ liệu bạn muốn giữ, sau đó xóa dữ liệu cũ. Vì vậy, bạn có thể xây dựng cấu trúc dữ liệu cho phép bạn "xóa" các yếu tố bạn không muốn từ phía trước. Những gì nó thực sự sẽ làm là tạo ra một mảng mới và sao chép các phần tử không được yêu thích sang cái mới, sau đó xóa cái cũ.

Hoặc bạn chỉ có thể sử dụng std::deque, có thể thực hiện điều này một cách hiệu quả. dequehoặc "hàng đợi hai đầu", là cấu trúc dữ liệu dành cho các trường hợp bạn xóa các phần tử từ một đầu trong khi thêm các phần tử vào đầu kia.

Các câu trả lời FIR và SMA mà bạn nhận được rất tốt trong trường hợp của bạn, tuy nhiên tôi muốn tận dụng cơ hội để đưa ra một cách tiếp cận chung chung hơn.

Những gì bạn có ở đây là một luồng dữ liệu: thay vì cấu trúc chương trình của bạn theo 3 bước lớn (lấy dữ liệu, tính toán, kết quả đầu ra) yêu cầu tải tất cả dữ liệu vào bộ nhớ cùng một lúc, thay vào đó bạn có thể cấu trúc nó như một đường ống dẫn .

Một đường ống bắt đầu với một luồng, biến đổi nó và đẩy nó vào một bồn rửa.

Trong trường hợp của bạn, đường ống trông giống như:

1. Đọc các mục từ đĩa, phát ra từng mục một
2. Nhận từng mục một, cho mỗi mục nhận được phát ra 5 mục cuối nhận được (trong đó bộ đệm tròn của bạn xuất hiện)
3. Nhận các mục 5 tại một thời điểm, cho mỗi nhóm tính kết quả
4. Nhận kết quả, ghi nó vào đĩa

C ++ có xu hướng sử dụng các trình vòng lặp hơn là các luồng, nhưng thành thật mà nói các luồng dễ mô hình hóa hơn (có một đề xuất cho các phạm vi tương tự như các luồng):

template <typename T>
class Stream {
public:
    virtual boost::optional<T> next() = 0;
    virtual ~Stream() {}
};

class ReaderStream: public Stream<Item> {
public:
    boost::optional<Item> next() override final;

private:
    std::ifstream file;
};

class WindowStream: public Stream<Window> {
public:
    boost::optional<Window> next() override final;

private:
    Window window;
    Stream<Item>& items;
};

class ResultStream: public Stream<Result> {
public:
    boost::optional<Result> next() override final;

private:
    Stream<Window>& windows;
};

Và sau đó, đường ống trông giống như:

ReaderStream itemStream("input.txt");
WindowStream windowStream(itemsStream, 5);
ResultStream resultStream(windowStream);
std::ofstream results("output.txt", std::ios::binary);

while (boost::optional<Result> result = resultStream.next()) {
    results << *result << "\n";
}

Các luồng không phải lúc nào cũng có thể áp dụng (chúng không hoạt động khi bạn cần truy cập ngẫu nhiên vào dữ liệu), nhưng khi có, chúng sẽ rung chuyển: bằng cách hoạt động trên một lượng bộ nhớ rất nhỏ, bạn giữ tất cả trong bộ nhớ cache của CPU.

Một lưu ý khác: có vẻ như vấn đề của bạn có thể là "song song lúng túng", bạn có thể muốn chia tệp lớn của mình thành từng phần (lưu ý, để xử lý bởi các cửa sổ 5, bạn cần phải có 4 yếu tố chung ở mỗi ranh giới) và sau đó xử lý các khối song song.

Nếu CPU là nút cổ chai (chứ không phải I / O), thì bạn có thể tăng tốc nó bằng cách khởi chạy một tiến trình cho mỗi lõi mà bạn có sau khi chia các tệp với số lượng gần bằng nhau.