เขียนไฟล์ไบนารีใน C ++ อย่างรวดเร็ว

ฉันกำลังพยายามเขียนข้อมูลจำนวนมากบน SSD ของฉัน (โซลิดสเตทไดรฟ์) และโดยจำนวนมากฉันหมายถึง 80GB

ฉันเรียกค้นเว็บเพื่อหาแนวทางแก้ไข แต่สิ่งที่ดีที่สุดที่ฉันพบคือ:

#include <fstream>
const unsigned long long size = 64ULL*1024ULL*1024ULL;
unsigned long long a[size];
int main()
{
    std::fstream myfile;
    myfile = std::fstream("file.binary", std::ios::out | std::ios::binary);
    //Here would be some error handling
    for(int i = 0; i < 32; ++i){
        //Some calculations to fill a[]
        myfile.write((char*)&a,size*sizeof(unsigned long long));
    }
    myfile.close();
}

คอมไพล์ด้วย Visual Studio 2010 และการเพิ่มประสิทธิภาพเต็มรูปแบบและทำงานภายใต้ Windows7 โปรแกรมนี้มีขนาดสูงสุด 20MB / s สิ่งที่รบกวนจิตใจฉันจริงๆคือ Windows สามารถคัดลอกไฟล์จาก SSD อื่นไปยัง SSD นี้ได้ที่ระหว่าง 150MB / s และ 200MB / s ดังนั้นอย่างน้อย 7 ครั้งเร็วขึ้น นั่นเป็นเหตุผลที่ฉันคิดว่าฉันควรจะไปได้เร็วขึ้น

ความคิดใดที่ฉันสามารถเพิ่มความเร็วในการเขียนของฉันได้อย่างไร

นี่เป็นงาน (ในปี 2012):

#include <stdio.h>
const unsigned long long size = 8ULL*1024ULL*1024ULL;
unsigned long long a[size];

int main()
{
    FILE* pFile;
    pFile = fopen("file.binary", "wb");
    for (unsigned long long j = 0; j < 1024; ++j){
        //Some calculations to fill a[]
        fwrite(a, 1, size*sizeof(unsigned long long), pFile);
    }
    fclose(pFile);
    return 0;
}

ฉันเพิ่งตั้งเวลา 8GB ใน 36 วินาทีซึ่งเป็นประมาณ 220MB / s และฉันคิดว่า SSD ของฉันมีประสิทธิภาพสูงสุด นอกจากนี้ควรทราบรหัสในคำถามใช้หนึ่งคอร์ 100% ในขณะที่รหัสนี้ใช้ 2-5% เท่านั้น

ขอบคุณมากสำหรับทุกคน

อัปเดต : 5 ปีผ่านไปแล้วในปี 2017 ในขณะนี้ คอมไพเลอร์ฮาร์ดแวร์ไลบรารีและข้อกำหนดของฉันมีการเปลี่ยนแปลง นั่นเป็นสาเหตุที่ฉันทำการเปลี่ยนแปลงรหัสและทำการวัดใหม่

ก่อนรหัส:

#include <fstream>
#include <chrono>
#include <vector>
#include <cstdint>
#include <numeric>
#include <random>
#include <algorithm>
#include <iostream>
#include <cassert>

std::vector<uint64_t> GenerateData(std::size_t bytes)
{
    assert(bytes % sizeof(uint64_t) == 0);
    std::vector<uint64_t> data(bytes / sizeof(uint64_t));
    std::iota(data.begin(), data.end(), 0);
    std::shuffle(data.begin(), data.end(), std::mt19937{ std::random_device{}() });
    return data;
}

long long option_1(std::size_t bytes)
{
    std::vector<uint64_t> data = GenerateData(bytes);

    auto startTime = std::chrono::high_resolution_clock::now();
    auto myfile = std::fstream("file.binary", std::ios::out | std::ios::binary);
    myfile.write((char*)&data[0], bytes);
    myfile.close();
    auto endTime = std::chrono::high_resolution_clock::now();

    return std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
}

long long option_2(std::size_t bytes)
{
    std::vector<uint64_t> data = GenerateData(bytes);

    auto startTime = std::chrono::high_resolution_clock::now();
    FILE* file = fopen("file.binary", "wb");
    fwrite(&data[0], 1, bytes, file);
    fclose(file);
    auto endTime = std::chrono::high_resolution_clock::now();

    return std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
}

long long option_3(std::size_t bytes)
{
    std::vector<uint64_t> data = GenerateData(bytes);

    std::ios_base::sync_with_stdio(false);
    auto startTime = std::chrono::high_resolution_clock::now();
    auto myfile = std::fstream("file.binary", std::ios::out | std::ios::binary);
    myfile.write((char*)&data[0], bytes);
    myfile.close();
    auto endTime = std::chrono::high_resolution_clock::now();

    return std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
}

int main()
{
    const std::size_t kB = 1024;
    const std::size_t MB = 1024 * kB;
    const std::size_t GB = 1024 * MB;

    for (std::size_t size = 1 * MB; size <= 4 * GB; size *= 2) std::cout << "option1, " << size / MB << "MB: " << option_1(size) << "ms" << std::endl;
    for (std::size_t size = 1 * MB; size <= 4 * GB; size *= 2) std::cout << "option2, " << size / MB << "MB: " << option_2(size) << "ms" << std::endl;
    for (std::size_t size = 1 * MB; size <= 4 * GB; size *= 2) std::cout << "option3, " << size / MB << "MB: " << option_3(size) << "ms" << std::endl;

    return 0;
}

รหัสนี้คอมไพล์ด้วย Visual Studio 2017 และ g ++ 7.2.0 (ข้อกำหนดใหม่) ฉันรันโค้ดด้วยการตั้งค่าสองแบบ:

• แล็ปท็อป, Core i7, SSD, Ubuntu 16.04, g ++ เวอร์ชั่น 7.2.0 พร้อม -std = c ++ 11 -march = native -O3
• เดสก์ท็อป, คอร์ i7, SSD, Windows 10, Visual Studio 2017 เวอร์ชัน 15.3.1 พร้อม / Ox / Ob2 / Oi / Ot / GT / GL / Gy

ซึ่งให้การวัดต่อไปนี้ (หลังจากทิ้งค่า 1MB เพราะมันเป็นค่าผิดปกติที่เห็นได้ชัด): ทั้งตัวเลือกที่ 1 และตัวเลือกที่ 3 สูงสุด SSD ของฉัน ฉันไม่ได้คาดหวังว่าสิ่งนี้จะเห็นเพราะตัวเลือก 2 เคยเป็นรหัสที่เร็วที่สุดในเครื่องเก่าของฉันแล้ว

TL; DR : การวัดของฉันบ่งชี้ในการใช้มากกว่าstd::fstreamFILE

ลองวิธีต่อไปนี้ตามลำดับ:

• ขนาดบัฟเฟอร์ที่เล็กลง การเขียนครั้งละ ~ 2 MiB อาจเป็นการเริ่มต้นที่ดี ในแล็ปท็อปตัวสุดท้ายของฉัน ~ 512 KiB เป็นจุดที่น่าสนใจ แต่ฉันยังไม่ได้ทดสอบกับ SSD เลย

  หมายเหตุ:ฉันสังเกตเห็นว่าบัฟเฟอร์ที่มีขนาดใหญ่มากมักจะลดประสิทธิภาพลง ฉันสังเกตเห็นการสูญเสียความเร็วด้วยการใช้ 16-MiB บัฟเฟอร์แทน 512-KiB บัฟเฟอร์ก่อน

• การใช้งาน_open(หรือ_topenถ้าคุณต้องการที่จะใช้ Windows ที่ถูกต้อง) _writeเพื่อเปิดไฟล์การใช้งานแล้ว นี่อาจจะหลีกเลี่ยงการบัฟเฟอร์จำนวนมาก แต่ก็ไม่แน่นอน

• การใช้ฟังก์ชั่นที่ใช้ Windows ที่เฉพาะเจาะจงเช่นและCreateFile WriteFileที่จะหลีกเลี่ยงการบัฟเฟอร์ใด ๆ ในไลบรารีมาตรฐาน

ฉันไม่เห็นความแตกต่างระหว่าง std :: stream / FILE / device ระหว่างการบัฟเฟอร์และการไม่บัฟเฟอร์

ทราบด้วย:

• ไดรฟ์ SSD "มีแนวโน้ม" ที่จะชะลอตัวลง (ลดอัตราการถ่ายโอน) ในขณะที่เติม
• ไดรฟ์ SSD "มีแนวโน้ม" ที่จะชะลอตัวลง (ลดอัตราการถ่ายโอน) เนื่องจากพวกเขามีอายุมากขึ้น (เนื่องจากบิตที่ไม่ทำงาน)

ฉันเห็นรหัสทำงานใน 63 วินาที
ดังนั้นอัตราการถ่ายโอนของ: 260M / s (SSD ของฉันดูเร็วกว่าของคุณเล็กน้อย)

64 * 1024 * 1024 * 8 /*sizeof(unsigned long long) */ * 32 /*Chunks*/

= 16G
= 16G/63 = 260M/s

ฉันไม่ได้รับอะไรเพิ่มเมื่อย้ายไปที่ FILE * จาก std :: fstream

#include <stdio.h>

using namespace std;

int main()
{
    
    FILE* stream = fopen("binary", "w");

    for(int loop=0;loop < 32;++loop)
    {
         fwrite(a, sizeof(unsigned long long), size, stream);
    }
    fclose(stream);

}

ดังนั้นสตรีม C ++ จึงทำงานได้เร็วเท่าที่ไลบรารีพื้นฐานจะอนุญาต

แต่ฉันคิดว่ามันไม่ยุติธรรมเมื่อเทียบกับระบบปฏิบัติการกับแอปพลิเคชันที่สร้างขึ้นบนระบบปฏิบัติการ แอปพลิเคชันไม่สามารถทำการสันนิษฐานได้ (ไม่ทราบว่าไดรฟ์เป็น SSD) และใช้กลไกไฟล์ของระบบปฏิบัติการสำหรับการถ่ายโอน

ในขณะที่ระบบปฏิบัติการไม่จำเป็นต้องตั้งสมมติฐานใด ๆ สามารถบอกประเภทของไดรฟ์ที่เกี่ยวข้องและใช้เทคนิคที่ดีที่สุดสำหรับการถ่ายโอนข้อมูล ในกรณีนี้หน่วยความจำโดยตรงการถ่ายโอนหน่วยความจำ ลองเขียนโปรแกรมที่คัดลอก 80G จาก 1 ตำแหน่งในหน่วยความจำไปยังที่อื่นและดูว่ารวดเร็วแค่ไหน

แก้ไข

ฉันเปลี่ยนรหัสเพื่อใช้การโทรระดับต่ำกว่า:
เช่นไม่มีการบัฟเฟอร์

#include <fcntl.h>
#include <unistd.h>


const unsigned long long size = 64ULL*1024ULL*1024ULL;
unsigned long long a[size];
int main()
{
    int data = open("test", O_WRONLY | O_CREAT, 0777);
    for(int loop = 0; loop < 32; ++loop)
    {   
        write(data, a, size * sizeof(unsigned long long));
    }   
    close(data);
}

สิ่งนี้ทำให้ไม่มีความแตกต่าง

หมายเหตุ : ไดรฟ์ของฉันเป็นไดรฟ์ SSD หากคุณมีไดรฟ์ปกติคุณอาจเห็นความแตกต่างระหว่างสองเทคนิคด้านบน แต่อย่างที่ฉันคาดไว้ไม่ใช่การบัฟเฟอร์และการบัฟเฟอร์ (เมื่อเขียนชิ้นใหญ่มากกว่าขนาดบัฟเฟอร์) ก็ไม่ได้สร้างความแตกต่าง

แก้ไข 2:

คุณได้ลองวิธีคัดลอกไฟล์ที่เร็วที่สุดใน C ++ แล้วหรือยัง

int main()
{
    std::ifstream  input("input");
    std::ofstream  output("ouptut");

    output << input.rdbuf();
}

ทางออกที่ดีที่สุดคือการใช้การเขียนแบบ async ด้วยการบัฟเฟอร์คู่

ดูที่เส้นเวลา:

------------------------------------------------>
FF|WWWWWWWW|FF|WWWWWWWW|FF|WWWWWWWW|FF|WWWWWWWW|

'F' หมายถึงเวลาสำหรับการเติมบัฟเฟอร์และ 'W' หมายถึงเวลาสำหรับการเขียนบัฟเฟอร์ไปยังดิสก์ ดังนั้นปัญหาในการเสียเวลาระหว่างการเขียนบัฟเฟอร์ลงไฟล์ อย่างไรก็ตามโดยการเขียนบนเธรดแยกคุณสามารถเริ่มเติมบัฟเฟอร์ถัดไปได้ทันทีเช่นนี้

------------------------------------------------> (main thread, fills buffers)
FF|ff______|FF______|ff______|________|
------------------------------------------------> (writer thread)
  |WWWWWWWW|wwwwwwww|WWWWWWWW|wwwwwwww|

F - การกรอกบัฟเฟอร์ที่ 1
f - การเติมบัฟเฟอร์ที่ 2
W - การเขียนบัฟเฟอร์ที่ 1 ลงในไฟล์
W - การเขียนบัฟเฟอร์ที่สองไปยังไฟล์
_ - รอในขณะที่การดำเนินการเสร็จสมบูรณ์

วิธีนี้พร้อมการแลกเปลี่ยนบัฟเฟอร์มีประโยชน์มากเมื่อเติมบัฟเฟอร์ต้องใช้การคำนวณที่ซับซ้อนมากขึ้น (ดังนั้นเวลามากขึ้น) ฉันมักจะใช้คลาส CSequentialStreamWriter ที่ซ่อนการเขียนแบบอะซิงโครนัสภายในดังนั้นสำหรับผู้ใช้ปลายทางอินเทอร์เฟซที่มีเพียงฟังก์ชั่นการเขียน

และขนาดบัฟเฟอร์ต้องเป็นขนาดของดิสก์คลัสเตอร์หลายขนาด มิฉะนั้นคุณจะจบลงด้วยประสิทธิภาพที่ไม่ดีโดยการเขียนบัฟเฟอร์เดียวไปยังดิสก์ 2 คลัสเตอร์ที่อยู่ติดกัน

เขียนบัฟเฟอร์สุดท้าย
เมื่อคุณเรียกใช้ฟังก์ชั่นการเขียนเป็นครั้งสุดท้ายคุณต้องตรวจสอบให้แน่ใจว่าบัฟเฟอร์ปัจจุบันถูกเติมเต็มแล้วควรจะถูกเขียนไปยังดิสก์เช่นกัน ดังนั้น CSequentialStreamWriter ควรมีวิธีที่แยกกันสมมุติว่า Finalize (final buffer flush) ซึ่งควรเขียนลงดิสก์ส่วนสุดท้ายของข้อมูล

การจัดการข้อผิดพลาด
ในขณะที่โค้ดเริ่มเติมบัฟเฟอร์ที่ 2 และอันที่ 1 กำลังถูกเขียนบนเธรดแยกต่างหาก แต่การเขียนล้มเหลวด้วยเหตุผลบางอย่างเธรดหลักควรทราบถึงความล้มเหลวนั้น

------------------------------------------------> (main thread, fills buffers)
FF|fX|
------------------------------------------------> (writer thread)
__|X|

สมมติว่าอินเทอร์เฟซของ CSequentialStreamWriter นั้นมีฟังก์ชั่นเขียนส่งคืนบูลหรือมีข้อผิดพลาดดังนั้นจึงมีข้อผิดพลาดในเธรดแยกต่างหากคุณต้องจำสถานะนั้นดังนั้นครั้งต่อไปที่คุณเรียกใช้ Write หรือ Finilize บนเธรดหลัก เท็จหรือจะโยนข้อยกเว้น และมันก็ไม่สำคัญว่าคุณจะหยุดเติมบัฟเฟอร์ที่ใดแม้ว่าคุณจะเขียนข้อมูลไปข้างหน้าหลังจากความล้มเหลว - ไฟล์ส่วนใหญ่จะเสียหายและไร้ประโยชน์

ผมขอแนะนำให้พยายามแมปแฟ้ม ฉันใช้mmapในอดีตในสภาพแวดล้อม UNIX และฉันประทับใจในประสิทธิภาพที่ฉันสามารถทำได้

คุณสามารถใช้FILE*แทนและวัดประสิทธิภาพที่คุณได้รับ? มีสองตัวเลือกให้ใช้fwrite/writeแทนfstream:

#include <stdio.h>

int main ()
{
  FILE * pFile;
  char buffer[] = { 'x' , 'y' , 'z' };
  pFile = fopen ( "myfile.bin" , "w+b" );
  fwrite (buffer , 1 , sizeof(buffer) , pFile );
  fclose (pFile);
  return 0;
}

หากคุณตัดสินใจที่จะใช้writeลองสิ่งที่คล้ายกัน:

#include <unistd.h>
#include <fcntl.h>

int main(void)
{
    int filedesc = open("testfile.txt", O_WRONLY | O_APPEND);

    if (filedesc < 0) {
        return -1;
    }

    if (write(filedesc, "This will be output to testfile.txt\n", 36) != 36) {
        write(2, "There was an error writing to testfile.txt\n", 43);
        return -1;
    }

    return 0;
}

memory mapฉันยังอยากจะแนะนำให้คุณมองเข้าไปใน นั่นอาจเป็นคำตอบของคุณ เมื่อฉันต้องประมวลผลไฟล์ 20GB ในอื่น ๆ เพื่อเก็บไว้ในฐานข้อมูลและไฟล์ที่ไม่ได้เปิด ดังนั้นวิธีการแก้ปัญหาที่จะใช้แผนที่แบบ Moemory ผมว่าในPythonแต่

ลองใช้ open () / write () / close () การเรียก API และทดสอบด้วยขนาดบัฟเฟอร์เอาต์พุต ฉันหมายความว่าอย่าส่งบัฟเฟอร์ "หลายหลายไบต์" ทั้งหมดในครั้งเดียวให้ทำการเขียนสองสามครั้ง (เช่น TotalNumBytes / OutBufferSize) OutBufferSize สามารถจาก 4096 ไบต์ถึงเมกะไบต์

ลองอีกครั้ง - ใช้ WinAPI OpenFile / CreateFile และใช้บทความ MSDN นี้เพื่อปิดการบัฟเฟอร์ (FILE_FLAG_NO_BUFFERING) และบทความ MSDN นี้บน WriteFile ()แสดงวิธีรับขนาดบล็อกสำหรับไดรฟ์เพื่อทราบขนาดบัฟเฟอร์ที่เหมาะสม

อย่างไรก็ตาม std :: ofstream เป็น wrapper และอาจมีการบล็อกในการดำเนินการ I / O โปรดทราบว่าการสำรวจอาร์เรย์ N-กิกะไบต์ทั้งหมดนั้นต้องใช้เวลาพอสมควรเช่นกัน ในขณะที่คุณกำลังเขียนบัฟเฟอร์ขนาดเล็กมันจะเข้าสู่แคชและทำงานได้เร็วขึ้น

fstreams ไม่ช้ากว่าสตรีม C ต่อ se แต่ใช้CPU มากขึ้น (โดยเฉพาะถ้าบัฟเฟอร์ไม่ได้รับการกำหนดค่าอย่างเหมาะสม) เมื่อ CPU อิ่มตัวจะ จำกัด อัตรา I / O

อย่างน้อยการนำ MSVC 2015 ไปใช้จะคัดลอก1 อักขระพร้อมกันไปยังบัฟเฟอร์เอาต์พุตเมื่อไม่ได้ตั้งค่าบัฟเฟอร์ของกระแสข้อมูล (ดูstreambuf::xsputn) ดังนั้นให้ตรวจสอบการตั้งค่าบัฟเฟอร์กระแส (> 0)

ฉันสามารถรับความเร็วในการเขียนที่ 1500MB / s (ความเร็วเต็มที่ของ M.2 SSD ของฉัน) ด้วยการfstreamใช้รหัสนี้:

#include <iostream>
#include <fstream>
#include <chrono>
#include <memory>
#include <stdio.h>
#ifdef __linux__
#include <unistd.h>
#endif
using namespace std;
using namespace std::chrono;
const size_t sz = 512 * 1024 * 1024;
const int numiter = 20;
const size_t bufsize = 1024 * 1024;
int main(int argc, char**argv)
{
  unique_ptr<char[]> data(new char[sz]);
  unique_ptr<char[]> buf(new char[bufsize]);
  for (size_t p = 0; p < sz; p += 16) {
    memcpy(&data[p], "BINARY.DATA.....", 16);
  }
  unlink("file.binary");
  int64_t total = 0;
  if (argc < 2 || strcmp(argv[1], "fopen") != 0) {
    cout << "fstream mode\n";
    ofstream myfile("file.binary", ios::out | ios::binary);
    if (!myfile) {
      cerr << "open failed\n"; return 1;
    }
    myfile.rdbuf()->pubsetbuf(buf.get(), bufsize); // IMPORTANT
    for (int i = 0; i < numiter; ++i) {
      auto tm1 = high_resolution_clock::now();
      myfile.write(data.get(), sz);
      if (!myfile)
        cerr << "write failed\n";
      auto tm = (duration_cast<milliseconds>(high_resolution_clock::now() - tm1).count());
      cout << tm << " ms\n";
      total += tm;
    }
    myfile.close();
  }
  else {
    cout << "fopen mode\n";
    FILE* pFile = fopen("file.binary", "wb");
    if (!pFile) {
      cerr << "open failed\n"; return 1;
    }
    setvbuf(pFile, buf.get(), _IOFBF, bufsize); // NOT important
    auto tm1 = high_resolution_clock::now();
    for (int i = 0; i < numiter; ++i) {
      auto tm1 = high_resolution_clock::now();
      if (fwrite(data.get(), sz, 1, pFile) != 1)
        cerr << "write failed\n";
      auto tm = (duration_cast<milliseconds>(high_resolution_clock::now() - tm1).count());
      cout << tm << " ms\n";
      total += tm;
    }
    fclose(pFile);
    auto tm2 = high_resolution_clock::now();
  }
  cout << "Total: " << total << " ms, " << (sz*numiter * 1000 / (1024.0 * 1024 * total)) << " MB/s\n";
}

ฉันลองใช้รหัสนี้บนแพลตฟอร์มอื่น ๆ (Ubuntu, FreeBSD) และสังเกตว่าไม่มีความแตกต่างของอัตรา I / O แต่ความแตกต่างของการใช้งาน CPUประมาณ 8: 1 ( fstreamใช้CPU มากกว่า 8 เท่า ) ดังนั้นหนึ่งสามารถจินตนาการได้ว่าฉันมีดิสก์ที่เร็วขึ้นการfstreamเขียนจะช้าลงเร็วกว่าstdioเวอร์ชั่น

ลองใช้ไฟล์ที่แม็พหน่วยความจำ

หากคุณคัดลอกบางสิ่งจากดิสก์ A ไปยังดิสก์ B ใน explorer Windows จะใช้ DMA นั่นหมายถึงกระบวนการคัดลอกส่วนใหญ่โดยทั่วไปแล้วซีพียูจะไม่ทำอะไรนอกจากบอกตัวควบคุมดิสก์ว่าจะวางที่ใดและรับข้อมูลจากกำจัดขั้นตอนทั้งหมดในโซ่และที่ไม่เหมาะสำหรับการย้ายจำนวนมาก ของข้อมูล - และฉันหมายถึงฮาร์ดแวร์

สิ่งที่คุณทำเกี่ยวข้องกับ CPU เป็นอย่างมาก ฉันต้องการให้คุณชี้ไปที่ส่วน "การคำนวณบางอย่างเพื่อเติม []" ซึ่งฉันคิดว่าเป็นสิ่งจำเป็น คุณสร้าง [] จากนั้นคัดลอกจาก [] ไปยังบัฟเฟอร์เอาต์พุต (นั่นคือสิ่งที่ fstream :: write ทำ) จากนั้นคุณสร้างอีกครั้งเป็นต้น

จะทำอย่างไร? Multithreading! (ฉันหวังว่าคุณจะมีหน่วยประมวลผลแบบมัลติคอร์)

• ส้อม.
• ใช้หนึ่งเธรดเพื่อสร้างข้อมูล []
• ใช้อีกอันเพื่อเขียนข้อมูลจาก [] ไปยังดิสก์
• คุณจะต้องมีสองอาร์เรย์ a1 [] และ a2 [] และสลับไปมาระหว่างกัน
• คุณจะต้องทำการซิงโครไนซ์ระหว่างเธรดของคุณ (เซมาฟอร์คิวข้อความ ฯลฯ )
• ใช้ระดับต่ำกว่า unbuffered ฟังก์ชั่นเช่นฟังก์ชั่นWriteFile ที่ Mehrdad พูดถึง

หากคุณต้องการเขียนสตรีมไฟล์อย่างรวดเร็วคุณสามารถเพิ่มสตรีมบัฟเฟอร์การอ่านให้ใหญ่ขึ้นได้:

wfstream f;
const size_t nBufferSize = 16184;
wchar_t buffer[nBufferSize];
f.rdbuf()->pubsetbuf(buffer, nBufferSize);

นอกจากนี้เมื่อเขียนข้อมูลจำนวนมากไปยังไฟล์บางครั้งก็เป็นได้เร็วขึ้นเพื่อเหตุผลขยายขนาดของไฟล์แทนร่างกายนี้เป็นเพราะเมื่อมีเหตุผลการขยายไฟล์ระบบไฟล์ไม่เป็นศูนย์พื้นที่ใหม่ออกมาก่อนที่จะเขียนมัน นอกจากนี้ยังเป็นการฉลาดที่จะขยายไฟล์อย่างมีเหตุผลมากกว่าที่คุณต้องการเพื่อป้องกันการขยายไฟล์จำนวนมาก การขยายไฟล์แบบลอจิคัลรองรับ Windows โดยการโทรSetFileValidDataหรือxfsctlด้วยXFS_IOC_RESVSP64ระบบ XFS

ฉันรวบรวมโปรแกรมของฉันใน gcc ในGNU / Linuxและmingwใน win 7 และชนะ xp และทำงานได้ดี

คุณสามารถใช้โปรแกรมของฉันและสร้างไฟล์ 80 GB เพียงแค่เปลี่ยนบรรทัด 33 เป็น

makeFile("Text.txt",1024,8192000);

เมื่อออกจากโปรแกรมไฟล์จะถูกทำลายจากนั้นตรวจสอบไฟล์เมื่อมันกำลังทำงาน

เพื่อให้โปรแกรมที่คุณต้องการเพียงแค่เปลี่ยนโปรแกรม

firt one เป็นโปรแกรม windows และที่สองสำหรับ GNU / Linux

http://mustafajf.persiangig.com/Projects/File/WinFile.cpp

http://mustafajf.persiangig.com/Projects/File/File.cpp