如何用Boost.Asio在C++中高速存储大体积三维矩阵？

当前的异步实现远未发挥硬件潜力，可以从多个方向针对性优化：

• 未满足FILE_FLAG_NO_BUFFERING的对齐要求：该标志强制要求写入缓冲区地址、写入大小、文件偏移必须是磁盘物理扇区大小（通常4KB，部分NVMe为8KB）的整数倍。你的代码直接写入超大缓冲区，大概率未对齐，系统会暗中做内存拷贝，严重拖慢速度。必须：
  • 用_aligned_malloc（Windows）或aligned_alloc分配对齐的缓冲区
  • 拆分写入块为扇区倍数的大小
  • 确保文件偏移（包括初始追加位置）也对齐
• 单线程执行IO上下文：仅调用ioContext.run()是单线程处理回调，无法利用多核CPU和NVMe的并行IO能力
• 一次性提交超大IO请求：单个1GB的IO会被系统被动拆分，不如主动拆分为64KB~2MB的中等块，让存储栈能并行调度
• 未预分配文件空间：追加写入会导致文件碎片化，且系统需动态扩展文件大小，额外消耗性能。建议先用SetFilePointerEx+SetEndOfFile预分配完整文件大小
• 错误处理缺失：未处理GetFileSize的溢出错误（文件超4GB时返回INVALID_FILE_SIZE），也未捕获异步写入的异常

优化核心思路：拆分对齐的IO块、预分配文件、多线程运行IO上下文。

Windows重叠IO（FILE_FLAG_OVERLAPPED）天然支持同一文件句柄的多线程异步操作，结合Boost.Asio可按以下步骤实现：

1. 拆分数据块：将大缓冲区拆分为满足FILE_FLAG_NO_BUFFERING对齐要求的小块，计算每个块的文件偏移
2. 多线程运行IO上下文：创建多个线程调用ioContext.run()，让Boost.Asio底层的Windows IOCP能并行调度IO请求
3. 线程安全的完成跟踪：用原子变量统计已完成的IO数，或用条件变量等待所有IO结束
4. 确保句柄线程安全：Boost.Asio的random_access_handle在Windows下是线程安全的，可在多线程中提交异步操作

示例代码片段：

#include <boost/asio.hpp>
#include <atomic>
#include <thread>
#include <vector>
#include <mutex>
#include <condition_variable>

const size_t SECTOR_SIZE = 4096; // 根据磁盘实际扇区大小调整
const size_t BLOCK_SIZE = 64 * 1024; // 64KB块，必须是SECTOR_SIZE的倍数
std::atomic<size_t> completed_io_count = 0;
std::mutex mtx;
std::condition_variable cv;
size_t total_blocks = 0;

void handle_write(const boost::system::error_code& ec, std::size_t bytes_transferred) {
    if (ec) {
        std::lock_guard<std::mutex> lock(mtx);
        std::cerr << "Write error: " << ec.message() << std::endl;
    }
    if (++completed_io_count == total_blocks) {
        cv.notify_one();
    }
}

bool save_boostAsio_multithread(char* i_data, const char* i_filePath, int64_t i_totalSize) {
    boost::asio::io_context ioContext;
    boost::asio::windows::random_access_handle handle(ioContext);

    // 打开文件，启用重叠IO与无缓冲
    HANDLE native_handle = ::CreateFileA(
        i_filePath,
        GENERIC_WRITE | GENERIC_READ,
        FILE_SHARE_WRITE,
        nullptr,
        CREATE_ALWAYS, // 直接创建新文件，避免追加偏移计算
        FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH, // WRITE_THROUGH跳过系统缓存
        nullptr
    );

    if (native_handle == INVALID_HANDLE_VALUE) {
        std::cerr << "Failed to open file, error: " << GetLastError() << std::endl;
        return false;
    }
    handle.assign(native_handle);

    // 预分配文件大小
    LARGE_INTEGER file_size;
    file_size.QuadPart = i_totalSize;
    if (!::SetFilePointerEx(handle.native_handle(), file_size, nullptr, FILE_BEGIN) ||
        !::SetEndOfFile(handle.native_handle())) {
        std::cerr << "Failed to preallocate file, error: " << GetLastError() << std::endl;
        handle.close();
        return false;
    }

    // 拆分数据块并提交异步写入
    total_blocks = (i_totalSize + BLOCK_SIZE - 1) / BLOCK_SIZE;
    completed_io_count = 0;

    for (size_t i = 0; i < total_blocks; ++i) {
        int64_t offset = static_cast<int64_t>(i) * BLOCK_SIZE;
        size_t current_block_size = std::min(BLOCK_SIZE, static_cast<size_t>(i_totalSize - offset));
        // 确保缓冲区地址已对齐（需提前用_aligned_malloc分配i_data）
        auto buffer = boost::asio::buffer(i_data + offset, current_block_size);
        handle.async_write_some_at(offset, buffer, handle_write);
    }

    // 启动多线程处理IO上下文
    std::vector<std::thread> threads;
    for (size_t i = 0; i < std::thread::hardware_concurrency(); ++i) {
        threads.emplace_back([&ioContext]() {
            ioContext.run();
        });
    }

    // 等待所有IO完成
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []() { return completed_io_count == total_blocks; });

    // 资源清理
    handle.close();
    for (auto& t : threads) {
        t.join();
    }

    return true;
}

注意事项：

• 必须确保i_data的内存地址是SECTOR_SIZE对齐的，否则FILE_FLAG_NO_BUFFERING会触发错误
• BLOCK_SIZE可根据实际测试调整（如128KB或2MB），找到最优值
• FILE_FLAG_WRITE_THROUGH适合大文件持续写入场景，可跳过系统缓存直接写入磁盘

NVMe多队列是硬件层面的并行IO机制，每个队列可独立处理IO请求，提升并发性能。在Windows下无需直接操作队列，只需通过以下方式触发系统利用多队列：

1. 并行提交足够多的IO请求：如问题2中的代码，拆分多个IO块并一次性提交，Windows存储栈会自动将请求分配到不同的NVMe队列
2. 选择合适的IO块大小：太小的请求（如4KB）会导致队列过载，太大的请求会浪费并行性，建议用64KB~2MB的块
3. 确认硬件与驱动支持：确保RAID卡和NVMe硬盘驱动支持多队列（现代NVMe设备基本都支持），可在设备管理器中查看NVMe控制器的MSI-X队列数
4. 避免IO串行化：不要等待一个IO完成再提交下一个，一次性提交所有并行请求，让存储栈充分调度
5. 依托IOCP机制：Boost.Asio底层基于Windows IOCP，这是适配NVMe多队列的高效异步调度机制，天然能发挥多队列优势

无需手动修改队列数，Windows会根据硬件自动配置最优队列数量。

内容的提问来源于stack exchange，提问作者FlorianS