Windows C++ 如何提升 PCIe 读取与 NVMe 写入性能
结论
当前瓶颈主要是串行 I/O。每个数据块都要先等 ReadFile 完成,再等文件写入完成,PCIe 读取和 NVMe 写入无法重叠。软件层面可以先改成有界的生产者、消费者管线:
- 读取线程从 XDMA 获取数据。
- 写入线程把填满的缓冲区写入文件。
- 循环复用至少 2 个缓冲区,让 PCIe DMA 和磁盘写入并行。
- 适当增大块大小,通过实测确定合适的值。
- 分别测试 PCIe、文件写入和完整管线,排除 Windows 文件缓存对结果的干扰。
- 如果驱动支持,再使用 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 驱动支持异步请求,可以继续进行以下调整:
- 使用
FILE_FLAG_OVERLAPPED打开设备句柄。 - 为每个缓冲区准备独立的
OVERLAPPED。 - 同时提交多个
ReadFile。 - 使用 I/O completion port、事件或线程池等待请求完成。
- 为文件写入设置合适的队列深度。
用户态传入 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。
优化顺序
- 修正计时方式,记录实际读写字节数,并处理零字节读取。
- 分别测试 XDMA 读取和 NVMe 写入,确定哪一侧更慢。
- 删除
QtConcurrent内部创建后立即join()的线程。 - 使用双缓冲或有界环形缓冲,重叠读取和写入。
- 测试不同的
block_size和队列深度,记录稳定阶段的吞吐量。 - 已知文件大小时预先分配空间。
- 对比普通缓存 I/O 和正确对齐的
FILE_FLAG_NO_BUFFERING。 - 确认 XDMA 驱动支持后,再考虑同时提交多个 Overlapped I/O 请求。
如果单独测试 PCIe 读取和 NVMe 写入时速度都很快,但组合后的速度明显下降,应优先检查缓冲管线、内存复制、线程调度和文件缓存行为。如果单独读取已经很慢,优化文件写入无法解决 XDMA 读取路径的问题。单独写入很慢时也是同样的情况。
备注:内容仅供参考。
