IT-Swarm.Net

用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倍。这就是为什么我认为我应该能够更快。

我有什么想法可以加快我的写作速度?

215
Dominic Hofer

这样做了:

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

我只是在36秒内定时8GB,大约220MB/s,我认为这最大化了我的SSD。另外值得注意的是,问题中的代码使用100%的核心,而此代码仅使用2-5%。

非常感谢大家。

更新 :5年过去了。编译器,硬件,库和我的要求已经改变。这就是为什么我对代码进行了一些更改并进行了一些测量。

首先是代码:

#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(现在是我的要求之一)。我让代码运行两个设置:

  • 笔记本电脑,酷睿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的值后,因为它们是明显的异常值): enter image description here enter image description here 两次选项1和选项3最大化我的SSD。我没想到这会看到,因为option2曾经是我机器上最快的代码。

TL; DR :我的测量表明使用std::fstream而不是FILE

192
Dominic Hofer

请按顺序尝试以下操作:

  • 较小的缓冲区大小。一次写~2 MiB可能是一个好的开始。在我的最后一台笔记本电脑上,~512 KiB是最佳选择,但我尚未在我的SSD上测试过。

    注意: 我注意到非常大的缓冲区趋于 减少 性能。我注意到之前使用16-MiB缓冲区而不是512-KiB缓冲区的速度损失。

  • 使用_open(或_topen,如果你想要Windows正确)打开文件,然后使用_write。这将 可能 避免大量缓冲,但它不确定。

  • 使用特定于Windows的函数,如CreateFileWriteFile。这将避免标准库中的任何缓冲。

23
Mehrdad

我看到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

通过从std :: fstream移动到FILE *,我得到了不增加。

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

这没有任何差别。

_ note _ :我的驱动器是SSD驱动器,如果你有一个普通的驱动器,你可能会看到上述两种技术之间的差异。但正如我所期望的那样,非缓冲和缓冲(当写入大块大于缓冲区大小时)没有任何区别。

编辑2:

您是否尝试过使用C++复制文件的最快方法

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

    output << input.rdbuf();
}
21
Martin York

最好的解决方案是使用双缓冲实现异步写入。

看时间线:

------------------------------------------------>
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 - 填充第一个缓冲区
f - 填充第二个缓冲区
W - 将第一个缓冲区写入文件
w - 将第二个缓冲区写入文件
_ - 等待操作完成

当填充缓冲区需要更复杂的计算(因此,更多时间)时,这种具有缓冲交换的方法非常有用。我总是实现一个隐藏异步写入的CSequentialStreamWriter类,所以对于最终用户来说,接口只有Write函数。

并且缓冲区大小必须是磁盘簇大小的倍数。否则,通过向2个相邻磁盘集群写入单个缓冲区,最终会导致性能下降。

写最后一个缓冲区。
当你最后一次调用Write函数时,你必须确保当前缓冲区的填充也应该写入磁盘。因此,CSequentialStreamWriter应该有一个单独的方法,比如Finalize(最终缓冲区刷新),它应该将最后一部分数据写入磁盘。

错误处理。
当代码开始填充第二个缓冲区,并且第一个缓冲区正在写入第一个缓冲区时,但由于某种原因写入失败,主线程应该知道该失败。

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

让我们假设一个CSequentialStreamWriter的接口有Write函数返回bool或抛出一个异常,因此在一个单独的线程上有一个错误,你必须记住那个状态,所以下次你在主线程上调用Write或Finilize时,该方法将返回假或将抛出异常。即使你在失败后提前写了一些数据,你停止填充缓冲区的时间并不重要 - 很可能文件会被破坏和无用。

12
HandMadeOX

我建议尝试 文件映射 。过去,我在UNIX环境中使用了mmap,我对可以实现的高性能印象深刻

10
Ralph

您可以使用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 map。我在Python中做到了这一点。

8
cybertextron

尝试使用open()/ write()/ close()API调用并尝试输出缓冲区大小。我的意思是不要一次传递整个“多字节”缓冲区,做几次写操作(即TotalNumBytes/OutBufferSize)。 OutBufferSize可以从4096字节到兆字节。

另一个尝试 - 使用WinAPI OpenFile/CreateFile并使用 这篇MSDN文章 关闭缓冲(FILE_FLAG_NO_BUFFERING)。和 这篇关于WriteFile()的MSDN文章 展示了如何获得驱动器的块大小以了解最佳缓冲区大小。

无论如何,std :: ofstream是一个包装器,I/O操作可能会阻塞。请记住,遍历整个N-gigabyte阵列也需要一些时间。在编写一个小缓冲区时,它会进入缓存并更快地运行。

6
Viktor Latypov

如果在资源管理器中将某些内容从磁盘A复制到磁盘B,则Windows使用DMA。这意味着对于大多数复制过程而言,除了告诉磁盘控制器放置位置和从中获取数据之外,CPU基本上什么都不做,从而消除了整个链中的一个步骤,并且根本没有针对移动大量数据进行优化数据 - 我的意思是硬件。

什么do涉及CPU很多。我想指出“一些计算来填补[]”部分。我认为这是至关重要的。你生成一个[],然后从[]复制到输出缓冲区(这就是fstream :: write的作用),然后你再次生成,等等。

该怎么办?多线程! (我希望你有一个多核处理器)

  • 叉子。
  • 使用一个线程生成[]数据
  • 使用另一个将数据从[]写入磁盘
  • 您将需要两个数组a1 []和a2 []并在它们之间切换
  • 您需要在线程之间进行某种同步(信号量,消息队列等)
  • 使用较低级别的无缓冲函数,如Mehrdad提到的 WriteFile 函数
3
dualed

fstreamname__s本身并不慢于C流,但它们使用更多CPU(特别是如果没有正确配置缓冲)。当CPU饱和时,它会限制I/O速率。

当未设置流缓冲区时,至少MSVC 2015实现将一次1个字符复制到输出缓冲区(请参阅streambuf::xsputn)。所以 确保设置流缓冲区(> 0)

使用此代码,我可以使用fstreamname__获得1500MB/s的写入速度(我的M.2 SSD的全速):

#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(fstreamname__使用CPU的8倍 )。所以可以想象,如果我的磁盘速度更快,fstreamname__写入速度会比stdioname__版本更慢。

3
rustyx

尝试使用内存映射文件。

3
qehgt

如果你想快速写入文件流,那么你可以使读取缓冲区流更大:

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

此外,在向文件写入大量数据时,有时更快 逻辑 扩展文件大小而不是物理上,这是因为在逻辑上扩展文件时,文件系统在写入之前不会将新空间清零。它。逻辑上扩展文件比实际需要更加智能,以防止大量文件扩展。 Windows上通过在XFS系统上使用XFS_IOC_RESVSP64调用SetFileValidDataxfsctl来支持逻辑文件扩展。

1
user152949

即时编译我的程序在gcc GNU/Linux mingw 在win 7中赢​​得xp并且运行良好

您可以使用我的程序并创建一个80 GB的文件,只需将第33行更改为

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

退出程序时,文件将被销毁,然后在文件运行时检查文件

拥有你想要的程序只需更改程序

第一个是Windows程序,第二个是GNU/Linux

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

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

0
MostafaJF