C++ 如何加速C++；写入速度是否为CrystalDiskMark测试的速度？

现在我在内存中每秒获得大约3.6GB的数据，我需要将它们连续写入SSD。我用CrystalDiskMark测试我的SSD的写入速度，它几乎是每秒6GB，所以我认为这项工作应该不会那么难

!！[我的SSD测试结果][1]：

[1] “测试结果”：

我的电脑是Windows 10，使用Visual Studio 2017社区

我找到并尝试了投票率最高的答案。不幸的是，他的选项_2的写入速度只有1s/GB左右，远远低于CrystalDiskMark测试的速度。然后我尝试了内存映射，这次写入速度变快了，大约630ms/GB，但仍然慢得多。然后我尝试了多线程内存映射，似乎当线程数为4时，速度约为350ms/GB，当我添加线程数时，写入速度不再提高

内存映射代码：

#include <fstream>
#include <chrono>
#include <vector>
#include <cstdint>
#include <numeric>
#include <random>
#include <algorithm>
#include <iostream>
#include <cassert>
#include <thread>
#include <windows.h>
#include <sstream>


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

// Memory mapping
int map_write(int* data, int size, int id){
    char* name = (char*)malloc(100);
    sprintf_s(name, 100, "D:\\data_%d.bin",id);
    HANDLE hFile = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);//
    if (hFile == INVALID_HANDLE_VALUE){
        return -1;
    }

    Sleep(0);

    DWORD dwFileSize = size;

    char* rname = (char*)malloc(100);
    sprintf_s(rname, 100, "data_%d.bin", id);

    HANDLE hFileMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, dwFileSize, rname);//create file  
    if (hFileMap == NULL) {
        CloseHandle(hFile);
        return -2;
    }

    PVOID pvFile = MapViewOfFile(hFileMap, FILE_MAP_WRITE, 0, 0, 0);//Acquire the address of file on disk
    if (pvFile == NULL) {
        CloseHandle(hFileMap);
        CloseHandle(hFile);
        return -3;
}

    PSTR pchAnsi = (PSTR)pvFile;
    memcpy(pchAnsi, data, dwFileSize);//memery copy 

    UnmapViewOfFile(pvFile);

    CloseHandle(hFileMap);
    CloseHandle(hFile);

    return 0;
}

// Multi-thread memory mapping
void Mem2SSD_write(int* data, int size){
    int part = size / sizeof(int) / 4;

    int index[4];

    index[0] = 0;
    index[1] = part;
    index[2] = part * 2;
    index[3] = part * 3;

    std::thread ta(map_write, data + index[0], size / 4, 10);
    std::thread tb(map_write, data + index[1], size / 4, 11);
    std::thread tc(map_write, data + index[2], size / 4, 12);
    std::thread td(map_write, data + index[3], size / 4, 13);

    ta.join();
    tb.join();
    tc.join();
    td.join();
 }

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

    for (int i = 0; i < 10; ++i) {
        std::vector<int> data = GenerateData(1 * GB);
        auto startTime = std::chrono::high_resolution_clock::now();
        Mem2SSD_write(&data[0], 1 * GB);
        auto endTime = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
        std::cout << "1G writing cost: " << duration << " ms" << std::endl;
    }

    system("pause");
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
//生成随机数据
std:：矢量生成数据（std:：大小字节）{
断言（字节%sizeof（int）==0）；
std：：矢量数据（字节/sizeof（int））；
std:：iota（data.begin（），data.end（），0）；
std:：shuffle（data.begin（）、data.end（）、std:：mt19937{std:：random_device{}（）}）；
返回数据；
}
//内存映射
int map_write（int*数据、int大小、int id）{
char*name=（char*）malloc（100）；
sprintf_s（名称，100，“D:\\data\uu%D.bin”，id）；
HANDLE hFile=CreateFile（名称、泛型读取、泛型写入、0、NULL、始终打开、文件属性、NULL）//
if（hFile==无效的句柄值）{
返回-1；
}
睡眠（0）；
DWORD dwFileSize=大小；
char*rname=（char*）malloc（100）；
sprintf_s（rname，100，“数据仓库”，id）；
HANDLE hFileMap=CreateFileMapping（hFile，NULL，PAGE_READWRITE，0，dwFileSize，rname）；//创建文件
if（hFileMap==NULL）{
闭合手柄（hFile）；
返回-2；
}
PVOID pvFile=MapViewOfFile（hFileMap，FILE_MAP_WRITE，0，0）；//获取磁盘上文件的地址
if（pvFile==NULL）{
CloseHandle（hFileMap）；
闭合手柄（hFile）；
返回-3；
}
PSTR pchAnsi=（PSTR）pvFile；
memcpy（pchAnsi，data，dwFileSize）；//memery copy
取消pviewoffile（pvFile）；
CloseHandle（hFileMap）；
闭合手柄（hFile）；
返回0；
}
//多线程内存映射
void Mem2SSD_写入（int*数据，int大小）{
内部零件=尺寸/尺寸（内部）/4；
int索引[4]；
指数[0]=0；
索引[1]=零件；
索引[2]=第*2部分；
索引[3]=第*3部分；
线程ta（映射写入，数据+索引[0]，大小/4，10）；
线程tb（映射写入，数据+索引[1]，大小/4，11）；
std：：线程tc（映射写入，数据+索引[2]，大小/4，12）；
std：：线程td（映射写入，数据+索引[3]，大小/4，13）；
ta.join（）；
tb.join（）；
tc.join（）；
td.join（）；
}
//测试：
int main（）{
常数std:：size\u t kB=1024；
常数std:：size_t MB=1024*kB；
常数std:：size\u t GB=1024*MB；
对于（int i=0；i<10；++i）{
标准：：矢量数据=生成数据（1*GB）；
自动启动时间=标准：：时钟：：高分辨率时钟：：现在（）；
Mem2SSD_写入（和数据[0]，1*GB）；
自动结束时间=标准：：时钟：：高分辨率时钟：：现在（）；
自动持续时间=std:：chrono:：duration_cast（endTime-startTime）.count（）；
std：：cout一个可能给您带来改进的方面是让您的线程不断运行，并且每个线程都从队列中读取数据

在每次编写时，您都会生成4个线程（这很慢），然后在函数末尾解构。如果您在开始时生成线程，并让它们在无限循环中从单独的队列读取，您将看到函数的cpu时间至少会加快

他们只需在稍有延迟后检查队列中是否有任何内容，如果有，他们将全部写入。唯一的问题是确保数据的顺序得到维护。
以下是我想到的建议：

停止正在使用磁盘的所有正在运行的进程，尤其是

禁用Windows Defender实时保护（或其他防病毒/恶意软件）
禁用页面文件

使用Windows资源监视器查找读取或写入磁盘的进程
确保在磁盘上写入连续扇区
不考虑文件打开和关闭时间
不要使用多线程（您的磁盘正在使用DMA，因此CPU无关紧要）
写入RAM中的数据（显然）
确保在生成（生成版本）时禁用所有调试功能
如果使用M.2 PCIe磁盘（似乎是您的情况），请确保使用其他PCIe磁盘
设备没有窃取到磁盘的PCIe通道（CPU有
数量有限，移动也有限）
不要从IDE运行测试
禁用Windows文件索引
<> P>最后，在这个问题的线程中如何找到C/C++快速代码编写的好提示：
< P>这不是C++问题，而是OS相关问题。为了获得最大的性能，需要使用OS中特定的低级别API调用，这在一般C++ LIBS中不存在。从代码中清晰可见，使用Windows API，所以搜索SOLU。windows的最低配置是多少

从功能：

当
FILE\u FLAG\u NO\u BUFFERING
与
FILE\u FLAG\u OVERLAPPED
组合时，
这些标志提供了最大的异步性能，因为I/O提供了最大的异步性能
不依赖内存管理器的同步操作

所以我们需要在调用中使用这两个标志的组合，或者在调用中使用
文件\u NO\u中间\u缓冲

此外，扩展文件大小和有效数据长度也需要一些时间，所以如果已知开始时的最终文件，则效果更好—只需通过设置文件最终大小即可
或通过。然后使用或通过设置有效数据长度。设置有效数据长度要求
SE\u MANAGE_
struct WriteTest 
{
    enum { opCompression, opWrite };

    struct REQUEST : IO_STATUS_BLOCK 
    {
        WriteTest* pTest;
        ULONG opcode;
        ULONG offset;
    };

    LONGLONG _TotalSize, _BytesLeft;
    HANDLE _hFile;
    ULONG64 _StartTime;
    void* _pData;
    REQUEST* _pRequests;
    ULONG _BlockSize;
    ULONG _ConcurrentRequestCount;
    ULONG _dwThreadId;
    LONG _dwRefCount;

    WriteTest(ULONG BlockSize, ULONG ConcurrentRequestCount) 
    {
        if (BlockSize & (BlockSize - 1))
        {
            __debugbreak();
        }
        _BlockSize = BlockSize, _ConcurrentRequestCount = ConcurrentRequestCount;
        _dwRefCount = 1, _hFile = 0, _pRequests = 0, _pData = 0;
        _dwThreadId = GetCurrentThreadId();
    }

    ~WriteTest()
    {
        if (_pData)
        {
            VirtualFree(_pData, 0, MEM_RELEASE);
        }

        if (_pRequests)
        {
            delete [] _pRequests;
        }

        if (_hFile)
        {
            NtClose(_hFile);
        }

        PostThreadMessageW(_dwThreadId, WM_QUIT, 0, 0);
    }

    void Release()
    {
        if (!InterlockedDecrement(&_dwRefCount))
        {
            delete this;
        }
    }

    void AddRef()
    {
        InterlockedIncrementNoFence(&_dwRefCount);
    }

    void StartWrite()
    {
        IO_STATUS_BLOCK iosb;

        FILE_VALID_DATA_LENGTH_INFORMATION fvdl;
        fvdl.ValidDataLength.QuadPart = _TotalSize;
        NTSTATUS status;

        if (0 > (status = NtSetInformationFile(_hFile, &iosb, &_TotalSize, sizeof(_TotalSize), FileEndOfFileInformation)) ||
            0 > (status = NtSetInformationFile(_hFile, &iosb, &fvdl, sizeof(fvdl), FileValidDataLengthInformation)))
        {
            DbgPrint("FileValidDataLength=%x\n", status);
        }

        ULONG offset = 0;
        ULONG dwNumberOfBytesTransfered = _BlockSize;

        _BytesLeft = _TotalSize + dwNumberOfBytesTransfered;

        ULONG ConcurrentRequestCount = _ConcurrentRequestCount;

        REQUEST* irp = _pRequests;

        _StartTime = GetTickCount64();

        do 
        {
            irp->opcode = opWrite;
            irp->pTest = this;
            irp->offset = offset;
            offset += dwNumberOfBytesTransfered;
            DoWrite(irp++);
        } while (--ConcurrentRequestCount);
    }

    void FillBuffer(PULONGLONG pu, LONGLONG ByteOffset)
    {
        ULONG n = _BlockSize / sizeof(ULONGLONG);
        do 
        {
            *pu++ = ByteOffset, ByteOffset += sizeof(ULONGLONG);
        } while (--n);
    }

    void DoWrite(REQUEST* irp)
    {
        LONG BlockSize = _BlockSize;

        LONGLONG BytesLeft = InterlockedExchangeAddNoFence64(&_BytesLeft, -BlockSize) - BlockSize;

        if (0 < BytesLeft)
        {
            LARGE_INTEGER ByteOffset;
            ByteOffset.QuadPart = _TotalSize - BytesLeft;

            PVOID Buffer = RtlOffsetToPointer(_pData, irp->offset);

            FillBuffer((PULONGLONG)Buffer, ByteOffset.QuadPart);

            AddRef();

            NTSTATUS status = NtWriteFile(_hFile, 0, 0, irp, irp, Buffer, BlockSize, &ByteOffset, 0);

            if (0 > status)
            {
                OnComplete(status, 0, irp);
            }
        }
        else if (!BytesLeft)
        {
            // write end
            ULONG64 time = GetTickCount64() - _StartTime;

            WCHAR sz[64];
            StrFormatByteSizeW((_TotalSize * 1000) / time, sz, RTL_NUMBER_OF(sz));
            DbgPrint("end:%S\n", sz);
        }
    }

    static VOID NTAPI _OnComplete(
        _In_    NTSTATUS status,
        _In_    ULONG_PTR dwNumberOfBytesTransfered,
        _Inout_ PVOID Ctx
        )
    {
        reinterpret_cast<REQUEST*>(Ctx)->pTest->OnComplete(status, dwNumberOfBytesTransfered, reinterpret_cast<REQUEST*>(Ctx));
    }

    VOID OnComplete(NTSTATUS status, ULONG_PTR dwNumberOfBytesTransfered, REQUEST* irp)
    {
        if (0 > status)
        {
            DbgPrint("OnComplete[%x]: %x\n", irp->opcode, status);
        }
        else 
        switch (irp->opcode)
        {
        default:
            __debugbreak();

        case opCompression:
            StartWrite();
            break;

        case opWrite:
            if (dwNumberOfBytesTransfered == _BlockSize)
            {
                DoWrite(irp);
            }
            else
            {
                DbgPrint(":%I64x != %x\n", dwNumberOfBytesTransfered, _BlockSize);
            }
        }

        Release();
    }

    NTSTATUS Create(POBJECT_ATTRIBUTES poa, ULONGLONG size)
    {
        if (!(_pRequests = new REQUEST[_ConcurrentRequestCount]) ||
            !(_pData = VirtualAlloc(0, _BlockSize * _ConcurrentRequestCount, MEM_COMMIT, PAGE_READWRITE)))
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        ULONGLONG sws = _BlockSize - 1;
        LARGE_INTEGER as;

        _TotalSize = as.QuadPart = (size + sws) & ~sws;

        HANDLE hFile;
        IO_STATUS_BLOCK iosb;

        NTSTATUS status = NtCreateFile(&hFile,
            DELETE|FILE_GENERIC_READ|FILE_GENERIC_WRITE&~FILE_APPEND_DATA,
            poa, &iosb, &as, 0, 0, FILE_OVERWRITE_IF, 
            FILE_NON_DIRECTORY_FILE|FILE_NO_INTERMEDIATE_BUFFERING, 0, 0);

        if (0 > status)
        {
            return status;
        }

        _hFile = hFile;

        if (0 > (status = RtlSetIoCompletionCallback(hFile, _OnComplete, 0)))
        {
            return status;
        }

        static USHORT cmp = COMPRESSION_FORMAT_NONE;

        REQUEST* irp = _pRequests;

        irp->pTest = this;
        irp->opcode = opCompression;

        AddRef();
        status = NtFsControlFile(hFile, 0, 0, irp, irp, FSCTL_SET_COMPRESSION, &cmp, sizeof(cmp), 0, 0);

        if (0 > status)
        {
            OnComplete(status, 0, irp);
        }

        return status;
    }
};

void WriteSpeed(POBJECT_ATTRIBUTES poa, ULONGLONG size, ULONG BlockSize, ULONG ConcurrentRequestCount)
{
    BOOLEAN b;
    NTSTATUS status = RtlAdjustPrivilege(SE_MANAGE_VOLUME_PRIVILEGE, TRUE, FALSE, &b);

    if (0 <= status)
    {
        status = STATUS_INSUFFICIENT_RESOURCES;

        if (WriteTest * pTest = new WriteTest(BlockSize, ConcurrentRequestCount))
        {
            status = pTest->Create(poa, size);

            pTest->Release();

            if (0 <= status)
            {
                MessageBoxW(0, 0, L"Test...", MB_OK|MB_ICONINFORMATION);
            }
        }
    }
}