วิธีการอย่างมืออาชีพในการสร้างปัญหาใหญ่โดยไม่ต้องกรอกอาร์เรย์ขนาดใหญ่: C ++ หน่วยความจำฟรีจากส่วนหนึ่งของอาร์เรย์

ฉันกำลังพัฒนาแบบจำลองทางฟิสิกส์และเนื่องจากฉันค่อนข้างใหม่กับการเขียนโปรแกรมฉันยังคงพบปัญหาเมื่อผลิตโปรแกรมขนาดใหญ่ ฉันรู้เกี่ยวกับการจัดสรรและลบหน่วยความจำแบบไดนามิก (ใหม่ / ลบ ฯลฯ ) แต่ฉันต้องการวิธีที่ดีกว่าในการจัดโครงสร้างโปรแกรม

สมมติว่าฉันกำลังจำลองการทดสอบที่ใช้งานมาสองสามวันด้วยอัตราการสุ่มตัวอย่างที่ใหญ่มาก ฉันต้องการจำลองตัวอย่างเป็นพันล้านตัวอย่าง

ในฐานะเวอร์ชั่นที่เรียบง่ายที่สุดเราจะกล่าวว่าโปรแกรมใช้แรงดันไฟฟ้า V [i] และรวมเข้าด้วยกันเป็นห้า:

ie 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 V สุดท้าย [i] s

ฉันจะลบ / ยกเลิกการจัดสรรส่วนหนึ่งของอาเรย์เพื่อให้หน่วยความจำสามารถใช้งานได้อีกครั้ง (เช่น V [0] หลังจากส่วนแรกของตัวอย่างที่ไม่จำเป็นต้องใช้อีกต่อไป)? มีทางเลือกอื่นในการจัดโครงสร้างของโปรแกรมเช่นนี้หรือไม่?

ฉันเคยได้ยินเกี่ยวกับ malloc / free แต่ได้ยินมาว่าพวกเขาไม่ควรใช้ใน C ++ และมีทางเลือกที่ดีกว่า

ขอบคุณมาก ๆ!

TLDR; จะทำอย่างไรกับส่วนของอาร์เรย์ (แต่ละองค์ประกอบ) ฉันไม่ต้องการอีกต่อไปที่ใช้หน่วยความจำจำนวนมาก?

สิ่งที่คุณอธิบายว่า "การทำให้ราบรื่นโดย fives" คือตัวกรองดิจิตัลการตอบสนองต่อแรงกระตุ้น จำกัด (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";
}

สตรีมไม่สามารถใช้งานได้ตลอดเวลา (มันไม่ทำงานเมื่อคุณต้องการเข้าถึงข้อมูลแบบสุ่ม) แต่เมื่อมันเข้ามาก็จะสั่นเมื่อทำงานบนหน่วยความจำขนาดเล็กมากที่คุณเก็บไว้ใน CPU cache

ในหมายเหตุอื่น: ดูเหมือนว่าปัญหาของคุณอาจเป็น "ขนานที่น่าอับอาย" คุณอาจต้องการแยกไฟล์ขนาดใหญ่เป็นชิ้น ๆ (โปรดจำไว้ว่าสำหรับการประมวลผลโดยหน้าต่าง 5 ซึ่งคุณต้องมีองค์ประกอบทั่วไป 4 ข้อในแต่ละขอบเขต) จากนั้นประมวลผลชิ้นส่วนแบบขนาน

หาก CPU เป็นคอขวด (ไม่ใช่ I / O) คุณสามารถเร่งความเร็วได้โดยเปิดหนึ่งกระบวนการต่อหนึ่งคอร์ที่คุณมีหลังจากแยกไฟล์ในจำนวนที่เท่ากันโดยประมาณ