PAYATHON 2026

Windows C++ 如何提升 PCIe 读取与 NVMe 写入性能

技术老齐

结论

当前瓶颈主要是串行 I/O。每个数据块都要先等 ReadFile 完成,再等文件写入完成,PCIe 读取和 NVMe 写入无法重叠。软件层面可以先改成有界的生产者、消费者管线:

  1. 读取线程从 XDMA 获取数据。
  2. 写入线程把填满的缓冲区写入文件。
  3. 循环复用至少 2 个缓冲区,让 PCIe DMA 和磁盘写入并行。
  4. 适当增大块大小,通过实测确定合适的值。
  5. 分别测试 PCIe、文件写入和完整管线,排除 Windows 文件缓存对结果的干扰。
  6. 如果驱动支持,再使用 Overlapped I/O,同时提交多个请求。

QtConcurrent::run(start_read_thread) 已经将任务放入工作线程。start_read_thread() 内部再次创建线程并立即 join(),不会增加并行度,可以直接调用管线函数。

当前实现吞吐量较低的原因

循环中的执行顺序是固定的:

PCIe ReadFile
    ↓ 等待完成
outfile.write
    ↓ 等待完成
下一次 PCIe ReadFile

假设读取一个数据块需要 Tr,写入需要 Tw,串行处理每个数据块大约需要:

Tr + Tw

使用双缓冲或环形缓冲后,稳定阶段可以重叠这两个操作,每个数据块的耗时更接近:

max(Tr, Tw)

实际吞吐量还受 XDMA 驱动、内存带宽、文件系统、Windows 缓存和 CPU 调度影响,不能只用 PCIe 或 NVMe 的标称带宽推算。

代码中还有一些需要先处理的问题:

  • std::thread read_thread(...); read_thread.join(); 是多余的线程包装。
  • 同一个缓冲区既用于读取又用于写入,两个操作无法重叠。
  • 如果 read_from_engine() 返回 0,bytes_remaining 不会减少,循环也就无法结束。
  • 吞吐量按请求的 size 计算,发生短读或异常时结果会不准确。
  • 除以 1048576 得到的是 MiB/s,而非十进制 MB/s。
  • 计时从文件打开后开始,在 close() 前结束,因此没有计入文件打开、关闭和最终刷新时间。
  • ReadFile 的长度参数是 DWORD。单次传输不能直接超过 MAXDWORD,转换前必须检查。
  • std::vector<uint32_t>(dma_array_elements, 0) 会初始化整个缓冲区。对于持续流式处理,通常不必分配与完整采集量一样大的数组。

分开测量各处瓶颈

优化前至少要做三组测试。

单独测试 PCIe 读取

持续从设备读取数据,暂时不写文件。复用几个固定大小的缓冲区,避免每轮重新分配。测试结果可以反映 XDMA 读取路径的上限。

单独测试 NVMe 写入

把内存中准备好的数据持续写入文件。测试文件应明显大于可用内存,否则测到的可能主要是 Windows 文件缓存速度,而非 NVMe 的持续写入能力。

测试完整管线

同时执行读取和写入,并统计实际成功写入的字节数。这一结果才能代表应用可以长期维持的采集速度。

计时可使用单调时钟:

const auto begin = std::chrono::steady_clock::now();
// I/O
const auto end = std::chrono::steady_clock::now();

吞吐量应按实际写入量计算:

const double mib_per_second =
    static_cast<double>(bytes_written) /
    std::chrono::duration<double>(end - begin).count() /
    (1024.0 * 1024.0);

如果要测试数据写入 Windows 文件缓存的速度,可以在写线程完成后停止计时。如果要测试数据真正刷新到存储设备所需的时间,应先调用 FlushFileBuffers(),然后再停止计时。后一种测试的结果通常会低很多,但更接近持久化语义。

使用环形缓冲区重叠读取和写入

下面的简化 C++20 示例使用多个缓冲区。当前线程负责读取 XDMA,另一个线程调用同步 WriteFile。即使两个句柄都使用同步 I/O,只要使用不同的缓冲区,设备读取和文件写入仍可并行。

#include <Windows.h>

#include <algorithm>
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <exception>
#include <limits>
#include <semaphore>
#include <stdexcept>
#include <system_error>
#include <thread>
#include <vector>

struct Slot {
    std::vector<std::byte> data;
    std::size_t used = 0;
};

static void write_all(HANDLE file, const std::byte* data, std::size_t size)
{
    while (size != 0) {
        const DWORD request = static_cast<DWORD>(
            std::min<std::size_t>(size, std::numeric_limits<DWORD>::max()));

        DWORD written = 0;
        if (!WriteFile(file, data, request, &written, nullptr)) {
            const DWORD error = GetLastError();
            throw std::system_error(
                static_cast<int>(error),
                std::system_category(),
                "WriteFile");
        }

        if (written == 0) {
            throw std::runtime_error("WriteFile returned zero bytes");
        }

        data += written;
        size -= written;
    }
}

std::uint64_t stream_to_file(
    xdma_device& dev,
    HANDLE file,
    std::uint64_t total_size,
    std::size_t block_size)
{
    constexpr std::ptrdiff_t queue_depth = 4;

    if (block_size == 0 ||
        block_size > std::numeric_limits<DWORD>::max()) {
        throw std::invalid_argument("Invalid block_size");
    }

    std::vector<Slot> slots(static_cast<std::size_t>(queue_depth));
    for (auto& slot : slots) {
        slot.data.resize(block_size);
    }

    std::counting_semaphore<queue_depth> free_slots(queue_depth);
    std::counting_semaphore<queue_depth> ready_slots(0);

    std::atomic<bool> failed = false;
    std::exception_ptr reader_error;
    std::exception_ptr writer_error;
    std::uint64_t bytes_written = 0;

    std::thread writer([&] {
        std::size_t index = 0;

        for (;;) {
            ready_slots.acquire();
            Slot& slot = slots[index];

            if (slot.used == 0) {
                free_slots.release();
                break;
            }

            if (!writer_error) {
                try {
                    write_all(file, slot.data.data(), slot.used);
                    bytes_written += slot.used;
                } catch (...) {
                    writer_error = std::current_exception();
                    failed.store(true, std::memory_order_release);
                }
            }

            slot.used = 0;
            free_slots.release();
            index = (index + 1) % slots.size();
        }
    });

    std::size_t index = 0;
    std::uint64_t bytes_read_total = 0;

    try {
        while (bytes_read_total < total_size &&
               !failed.load(std::memory_order_acquire)) {
            free_slots.acquire();

            Slot& slot = slots[index];
            const std::size_t request = static_cast<std::size_t>(
                std::min<std::uint64_t>(
                    block_size,
                    total_size - bytes_read_total));

            const std::size_t bytes_read =
                dev.read_from_engine(slot.data.data(), request);

            if (bytes_read == 0) {
                throw std::runtime_error(
                    "Device returned zero bytes before completion");
            }

            if (bytes_read > request) {
                throw std::runtime_error(
                    "Device returned more bytes than requested");
            }

            slot.used = bytes_read;
            bytes_read_total += bytes_read;

            ready_slots.release();
            index = (index + 1) % slots.size();
        }
    } catch (...) {
        reader_error = std::current_exception();
        failed.store(true, std::memory_order_release);
    }

    // 在下一个空闲槽中放入结束标记。
    free_slots.acquire();
    slots[index].used = 0;
    ready_slots.release();

    writer.join();

    if (reader_error) {
        std::rethrow_exception(reader_error);
    }
    if (writer_error) {
        std::rethrow_exception(writer_error);
    }

    return bytes_written;
}

示例中的 queue_depth = 4 只适合作为调试起点,最佳值仍要通过测试确定。应分别测试不同的队列深度和 block_size。块太小会增加系统调用、线程同步和驱动提交的开销;块太大会增加延迟和内存占用,还可能超过 XDMA 驱动允许的单次传输大小。

使用 Windows 文件 API 打开输出文件

流式写入时可以直接使用 CreateFileW 和 WriteFile,以便控制缓存、顺序访问和异步选项:

HANDLE file = CreateFileW(
    L"D:\\output.bin",
    GENERIC_WRITE,
    0,
    nullptr,
    CREATE_ALWAYS,
    FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
    nullptr);

if (file == INVALID_HANDLE_VALUE) {
    throw std::system_error(
        static_cast<int>(GetLastError()),
        std::system_category(),
        "CreateFileW");
}

完成写入后要关闭句柄。实际项目中最好用 RAII 封装 HANDLE。

FILE_FLAG_SEQUENTIAL_SCAN 会告诉 Windows 当前执行的是顺序访问,但不能保证提高吞吐量。它是否有效以及能提升多少,都要在目标机器上实测。

如果最终文件大小已知,可以预先分配文件空间,减少文件增长和文件系统元数据更新引起的波动。可使用 SetFileInformationByHandle() 配合 FileAllocationInfo,同时仍要正确设置最终文件长度。

选择缓存 I/O 还是非缓存 I/O

可以先用普通缓存 I/O 实现双缓冲或环形缓冲。这种方式实现简单,也便于验证正确性。完成后再与 FILE_FLAG_NO_BUFFERING 对比。

启用 FILE_FLAG_NO_BUFFERING 后,Windows 对以下内容有严格的对齐要求:

  • 缓冲区地址;
  • 文件偏移;
  • 每次传输长度;
  • 底层存储设备要求的扇区或对齐单位。

通常需要通过 VirtualAlloc() 或 _aligned_malloc() 分配缓冲区,并查询设备要求的对齐尺寸。文件末尾不足一个对齐单位的数据也要单独处理,必要时先填充,再把文件截断到真实长度。普通 std::vector 的地址不一定满足要求,不能直接假定它适用于非缓存 WriteFile。

FILE_FLAG_WRITE_THROUGH 提供更强的写入完成语义,通常也会降低吞吐量。如果数据不要求每个数据块立即持久化,就不应为了所谓的 “更快” 而启用它。

驱动支持时再使用 Overlapped I/O

双缓冲可以重叠 PCIe 读取和 NVMe 写入,但每个设备同一时刻仍只有一个请求。如果 XDMA 驱动支持异步请求,可以继续进行以下调整:

  1. 使用 FILE_FLAG_OVERLAPPED 打开设备句柄。
  2. 为每个缓冲区准备独立的 OVERLAPPED。
  3. 同时提交多个 ReadFile。
  4. 使用 I/O completion port、事件或线程池等待请求完成。
  5. 为文件写入设置合适的队列深度。

用户态传入 OVERLAPPED,不等于驱动一定能并行执行 DMA。XDMA 驱动还必须正确支持异步 I/O、请求排队和取消操作。应先查看所用驱动的接口说明,或通过测试确认。如果驱动内部仍会串行处理请求,增加请求数量只会提高复杂度和内存占用。

Qt 层面的调整

可以删掉创建后立即 join() 的内层线程:

void start_read_thread()
{
    try {
        const auto device_paths = get_device_paths(GUID_DEVINTERFACE_XDMA);
        if (device_paths.empty()) {
            throw std::runtime_error("Failed to find XDMA device!");
        }

        xdma_device dev(device_paths[0]);

        // 在这里打开文件并直接运行 stream_to_file()。
        // stream_to_file() 内部负责读取和写入的并行。
    } catch (const std::exception& e) {
        qDebug() << e.what();
    }
}

QtConcurrent::run() 已经可以避免阻塞 GUI。如果界面需要显示完成状态、错误或实时速率,可以保存 QFuture,也可以使用 QFutureWatcher。不要为每个数据块调用 qDebug(),也不要频繁发送界面信号,否则这些操作可能进入热点路径。进度更新可按时间节流,例如每隔一段时间汇报一次,无须每完成一次 DMA 就更新 GUI。

优化顺序

  1. 修正计时方式,记录实际读写字节数,并处理零字节读取。
  2. 分别测试 XDMA 读取和 NVMe 写入,确定哪一侧更慢。
  3. 删除 QtConcurrent 内部创建后立即 join() 的线程。
  4. 使用双缓冲或有界环形缓冲,重叠读取和写入。
  5. 测试不同的 block_size 和队列深度,记录稳定阶段的吞吐量。
  6. 已知文件大小时预先分配空间。
  7. 对比普通缓存 I/O 和正确对齐的 FILE_FLAG_NO_BUFFERING。
  8. 确认 XDMA 驱动支持后,再考虑同时提交多个 Overlapped I/O 请求。

如果单独测试 PCIe 读取和 NVMe 写入时速度都很快,但组合后的速度明显下降,应优先检查缓冲管线、内存复制、线程调度和文件缓存行为。如果单独读取已经很慢,优化文件写入无法解决 XDMA 读取路径的问题。单独写入很慢时也是同样的情况。

备注:内容仅供参考。