DAQIRI Connects Sensor Data to the NVIDIA Compute Ecosystem
DAQIRI (Data Acquisition for Integrated Real-time Instruments) moves high-bandwidth data between external sensors and GPU, CPU, or storage devices. Streams can arrive from PCIe devices such as FPGAs or from network-capable sensors over Raw Ethernet (UDP/TCP) or RoCE/RDMA, giving applications one zero-copy path for ingest and egress. DAQIRI not only accelerates data movement and storage at the instrument but can also be used to connect sensor data to HPC and Cloud systems.
Closing the Gap Between Sensor and GPU
Scientific and industrial instruments generate data that is richest at the source — before it is filtered, decimated, or summarized. DAQIRI places NVIDIA GPU hardware directly in that data path, forging a tight bond between upstream sensors, their data converters, and the NVIDIA compute ecosystem. The result is a new foundation for developers: the ability to work with instrument data in its rawest form, at wire speed, and to build a new class of autonomous experiments where AI can observe phenomena directly at the source, augment human analysis, and steer experiments in real time. Stream data into and out of GPUs efficiently while leveraging common tensor-compute libraries.
Scalable, High Throughput
Hundreds of gigabits per second with proper hardware and CPU/NUMA tuning. Direct access to NIC ring buffers keeps latency at PCIe transit time only.
GPUDirect Zero-Copy
Two GPU receive modes: Header-data split (headers to CPU, payload to GPU — recommended) and Batched GPU (entire packets to GPU for maximum bandwidth).
Hardware Flow Steering
Route packets based on header matching to steer different streams to different GPUs or CPUs — entirely in NIC silicon, before any software runs.
RDMA over Converged Ethernet
Run RDMA READ, WRITE, and SEND over standard Ethernet via RoCE — no specialized InfiniBand fabric required. The same libibverbs API also supports InfiniBand for environments where it is available.
YAML-Driven Configuration
Define memory regions, NIC interfaces, TX/RX queues, and flow rules in a single YAML file — or build the same config in C++ code. Switch stream types, memory kinds, and buffer sizes without recompiling.
Containerized Deployment
A ready-to-run container bundles all userspace dependencies including a dmabuf-patched DPDK — no host-side dependency setup, no peermem kernel module. From docker pull to running benchmarks in minutes.
Build & Run in Minutes
Runs on Linux (kernel 5.4+) with the CUDA Toolkit 12.2+. The kernel-bypass and GPUDirect paths additionally require an NVIDIA ConnectX-6 Dx (or newer) NIC.
Install Prerequisites
Install the CUDA Toolkit (12.2 or newer).
For the Raw Ethernet / GPUDirect / RoCE path, you also need an NVIDIA ConnectX-6 Dx (or newer) NIC. The default Ubuntu kernel drivers are sufficient; we recommend additionally installing doca-ofed for the diagnostic utilities (ibstat, ibv_devinfo, mlxconfig, mlnx_perf, …).
Build from Source
Select optional engines with DAQIRI_ENGINE. Valid values: dpdk, ibverbs. Linux sockets are always built in.
# Configure, build, install cmake -S . -B build \ -DBUILD_SHARED_LIBS=ON \ -DDAQIRI_BUILD_PYTHON=OFF \ -DDAQIRI_ENGINE="dpdk ibverbs" cmake --build build -j cmake --install build --prefix /opt/daqiri
Or Build the Container
The Dockerfile builds DPDK from source with dmabuf patches — no peermem needed inside the container. Set BASE_IMAGE=torch to build on top of NGC PyTorch for Torch / TensorRT inference workflows.
BASE_TARGET=dpdk \
DAQIRI_ENGINE="dpdk ibverbs" \
scripts/build-container.sh
Tune the System
Run the diagnostic script to surface common networking bottlenecks (CPU governor, hugepages, MRRS, NUMA, GPU clocks, MTU, BAR1, PCIe topology):
sudo python3 python/tune_system.py --check all
Run a Benchmark
Edit the YAML to match your hardware (PCIe BDF, CPU cores, IPs), then:
./build/examples/daqiri_bench_raw_gpudirect \ examples/daqiri_bench_raw_tx_rx.yaml \ --seconds 10
Initialize & Receive PacketsC++
#include <daqiri/daqiri.h> // Init from YAML config daqiri::daqiri_init("config.yaml"); // Non-blocking burst receive daqiri::BurstParams *burst; auto s = daqiri::get_rx_burst( &burst, port_id, queue_id); if (s == daqiri::Status::SUCCESS) { int n = daqiri::get_num_packets(burst); for (int i = 0; i < n; i++) { void* p = daqiri::get_packet_ptr( burst, i); // process p ... } daqiri::free_all_packets_and_burst_rx( burst); }
Header-Data Split (GPU payload)C++
// Seg 0 = headers (CPU) // Seg 1 = payload (GPU) for (int i = 0; i < n; i++) { void* hdr = daqiri::get_segment_packet_ptr( burst, 0, i); void* pay = daqiri::get_segment_packet_ptr( burst, 1, i); // GPU ptr uint32_t hlen = daqiri::get_segment_packet_length( burst, 0, i); uint32_t plen = daqiri::get_segment_packet_length( burst, 1, i); // pay is already on GPU — no copy }
Examples
Get started with DAQIRI by exploring commonly used features when building real time sensor processing applications.
| Example | Type | Description |
|---|---|---|
| Raw TX/RX GPUDirect ↗ | C++ | The recommended starting point. Sends and receives packets with payloads landing directly in GPU memory, with no CPU in the data path. Use this to validate your hardware setup and measure baseline throughput. |
| Header-Data Split TX/RX ↗ | C++ | Splits each incoming packet into two segments: headers land in CPU memory for inspection, while the payload goes directly to the GPU. Useful when your application needs to read per-packet metadata without touching the payload on the CPU. |
| Sequence Reorder ↗ | C++/CUDA | Reassembles out-of-order UDP packets into a correctly ordered GPU buffer. A CUDA kernel reads the sequence number embedded in each packet header and places the packet at the right position, so downstream compute always sees a clean, ordered stream. |
| Sequence Reorder + Quantize ↗ | C++/CUDA | Extends sequence reorder with an in-kernel type conversion step (e.g., int4 → fp32), so the GPU buffer is both reordered and in the format your compute pipeline expects — all before your application code runs. |
| PCAP Writer ↗ | C++ | Captures live network traffic to a standard .pcap file you can open in Wireshark or tcpdump. Packets are received via GPUDirect and staged through pinned host memory to disk; capture continues until you press Ctrl+C. |
| RDMA Benchmark ↗ | C++ | Measures RoCE/RDMA throughput in client/server mode. Useful for comparing DAQIRI against standard tools like ib_send_bw, or when one endpoint is a third-party RDMA device such as an FPGA or instrument. |
| Socket Benchmark ↗ | C++ | Measures TCP and UDP throughput over standard Linux sockets — no ConnectX NIC or special privileges required. A good comparison baseline before moving to kernel-bypass, or for connecting to a peer that only speaks standard sockets. |
| GPUDirect Storage Write ↗ | C++/CUDA | Captures a burst of packets and writes them from GPU memory directly to NVMe storage via cuFile, in either raw binary or PCAP format. Supports both synchronous and asynchronous writes, demonstrating the full GPU-to-storage path without any CPU copy. |
Tutorials
Step-by-step guides from first build to production-grade deployment.
doca-ofed for diagnostics, and CUDA Toolkit 12.2+ on Linux 5.4+.DAQIRI_ENGINE / DAQIRI_BUILD_PYTHON / CMAKE_CUDA_ARCHITECTURES, install, smoke-test, troubleshoot.build-container.sh. The container ships a dmabuf-patched DPDK, so peermem is not required.python/tune_system.py to diagnose common configuration issues.huge, device, host_pinned), RX/TX queue setup, flow steering rules, flex items, and RDMA client/server config schemas.get_segment_packet_ptr(), and reorder scattered GPU buffers with the built-in CUDA kernel.accurate_send in the TX config and use set_packet_tx_time() for PTP-synchronized, hardware-scheduled packet transmission on ConnectX-7+.Connect Your Sensors to the NVIDIA Ecosystem
Clone the repo, build with CMake, and start streaming sensor data directly into your GPU-accelerated pipeline today.
# Clone and build git clone https://github.com/NVIDIA/daqiri cmake -S daqiri -B build \ -DBUILD_SHARED_LIBS=ON \ -DDAQIRI_ENGINE="dpdk ibverbs" cmake --build build -j
