Професійний спосіб створити велику проблему без заповнення величезних масивів: C ++, вільна пам'ять з частини масиву

Я розвиваю фізичне моделювання, і оскільки я досить новачок у програмуванні, я постійно стикаюся з проблемами при створенні великих програм (в основному проблеми з пам'яттю). Я знаю про динамічне розподіл пам'яті та видалення пам'яті (new / delete тощо), але мені потрібен кращий підхід до того, як я структурую програму.

Скажімо, я моделюю експеримент, який триває кілька днів, з дуже великою швидкістю вибірки. Мені потрібно було б імітувати мільярд зразків та перебігти їх.

Як надзвичайно спрощена версія, ми скажемо, що програма приймає напруги V [i] і підсумовує їх у п'яти:

тобто NewV [0] = V [0] + V [1] + V [2] + V [3] + V [4]

то NewV [1] = V [1] + V [2] + V [3] + V [4] + V [5]

то NewV [2] = V [2] + V [3] + V [4] + V [5] + V [6] ... і це продовжується для мільярда проб.

Зрештою, я мав би V [0], V [1], ..., V [1000000000], а натомість єдиними, які мені потрібно буде зберігати для наступного кроку, є останні 5 В [i] с.

Як би я видалив / маніпулював частину масиву, щоб пам'ять знову могла використовуватись (скажімо V [0] після першої частини прикладу, де вона більше не потрібна)? Чи є альтернативи, як структурувати таку програму?

Я чув про malloc / free, але чув, що їх не слід використовувати в C ++ і що є кращі альтернативи.

Дуже дякую!

tldr; що робити з частинами масивів (окремими елементами), які мені більше не потрібні, що займають величезну кількість пам'яті?

Те, що ви описуєте, "згладжування п'яти" - це цифровий фільтр з кінцевою імпульсною характеристикою (FIR). Такі фільтри реалізуються круговими буферами. Ви зберігаєте лише останні N значень, ви зберігаєте індекс у буфері, який вказує вам, де знаходиться найдавніше значення, ви перезаписуєте поточне найдавніше значення з найновішим на кожному кроці, і ви кожен раз переходите до індексу круговим чином.

Ви зберігаєте зібрані дані, які збираєтеся розсипати, на диску.

Залежно від вашого оточення, це може бути одне з тих місць, де вам краще отримати досвідчену допомогу. В університеті ви поміщаєте записку на дошці оголошень у відділі комп’ютерних наук, пропонуючи заробітну плату студентам (або навіть курси консалтингу для студентів) за кілька годин роботи, щоб допомогти вам скоротити свої дані. Або, можливо, ви пропонуєте бали для бакалаврських досліджень. Або щось.

Кожну проблему можна вирішити, додавши додатковий рівень непрямості. Тож зробіть це.

Ви не можете видалити частину масиву в C ++. Але ви можете створити новий масив, що містить лише ті дані, які ви хочете зберегти, а потім видалити старий. Таким чином, ви можете створити структуру даних, яка дозволяє "вилучати" елементи, які ви не хочете, з фронту. Насправді це буде створити новий масив і скопіювати непогашені елементи на новий, а потім видалити старий.

Або ви могли просто скористатися std::deque, що вже ефективно може це зробити. dequeабо "двобічна черга" - це структура даних, призначена для випадків, коли ви видаляєте елементи з одного кінця, додаючи елементи в інший.

Відповіді FIR та SMA у вашому випадку хороші, проте я хотів би скористатися можливістю просунути більш загальний підхід.

Тут у вас є потік даних: замість того, щоб структурувати свою програму в 3 великі кроки (отримати дані, обчислити, вивести результат), які вимагають завантаження всіх даних в пам'ять одразу, ви можете замість цього структурувати її як конвеєр .

Трубопровід починається з потоку, перетворює його і підштовхує до раковини.

У вашому випадку трубопровід виглядає так:

1. Читайте предмети з диска, випромінюйте елементи по одному
2. Отримуйте елементи по одному, за кожен отриманий елемент випромінюйте останні 5 отриманих (куди надходить ваш круговий буфер)
3. Отримуйте елементи 5 за один раз, для кожної групи обчисліть результат
4. Отримавши результат, запишіть його на диск

C ++ має тенденцію використовувати ітератори, а не потоки, але, якщо чесно, потоки простіше моделювати (є пропозиція про діапазони, які були б схожі на потоки):

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;
};

І тоді, трубопровід виглядає так:

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";
}

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

Ще одна примітка: схоже, що ваша проблема може бути "бентежно паралельною", ви можете розділити великий файл на шматки (майте на увазі, для обробки Windows 5, що вам потрібно мати 4 загальних елемента на кожному кордоні) а потім обробити шматки паралельно.

Якщо CPU - це вузьке місце (а не введення-виведення), то ви можете прискорити його, запустивши один процес на ядро, який у вас після розбиття файлів приблизно в однаковій кількості.