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 implementations with DAQIRI_MGR. Valid values: dpdk, socket, rdma.
# Configure, build, install cmake -S . -B build \ -DBUILD_SHARED_LIBS=ON \ -DDAQIRI_BUILD_PYTHON=OFF \ -DDAQIRI_MGR="dpdk socket rdma" 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_MGR="dpdk socket rdma" \
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
#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); }
// 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
Benchmark executables and YAML configs included in the examples/ directory.
auto burst = daqiri::create_tx_burst_params(); daqiri::set_header(burst, port_id, queue_id, batch_size, num_segs); daqiri::get_tx_packet_burst(burst); for (int i = 0; i < batch_size; i++) { daqiri::set_eth_header(burst,i,dst_mac); daqiri::set_ipv4_header(burst,i, ip_len,IPPROTO_UDP,src_ip,dst_ip); daqiri::set_udp_header(burst,i, udp_len,src_port,dst_port); daqiri::set_udp_payload(burst,i, payload_ptr,payload_size); } daqiri::send_tx_burst(burst);
// Batched GPU: packets arrive in // CUDA-addressable buffers. Reordering // is configured with rx.reorder_configs. __global__ void noop_packet_kernel(void* pkt) { (void)pkt; } if (daqiri::get_num_packets(burst) > 0) { void* pkt = daqiri::get_packet_ptr(burst, 0); noop_packet_kernel<<<1, 1, 0, stream>>>(pkt); } daqiri::free_all_packets_and_burst_rx( burst);
daqiri:
cfg:
version: 1
manager: "dpdk"
master_core: 3
memory_regions:
- name: "RX_CPU"
kind: "huge"
affinity: 0
num_bufs: 51200
buf_size: 64 # headers (~42 B)
- name: "RX_GPU"
kind: "device"
affinity: 0
num_bufs: 51200
buf_size: 1000 # payloadrx: flow_isolation: true queues: - name: "rx_q_0" id: 0 cpu_core: 9 batch_size: 10240 memory_regions: - "Data_RX_GPU" - name: "rx_q_1" id: 1 cpu_core: 10 batch_size: 10240 memory_regions: - "Data_RX_GPU_2" flows: - name: "udp_4096" id: 0 action: {type: queue, id: 0} match: {udp_dst: 4096} - name: "udp_4097" id: 1 action: {type: queue, id: 1} match: {udp_dst: 4097}
# Build with examples cmake -S . -B build \ -DDAQIRI_BUILD_EXAMPLES=ON \ -DDAQIRI_MGR="dpdk socket rdma" cmake --build build -j # TX/RX throughput (10 s) ./build/examples/daqiri_bench_raw_gpudirect \ examples/daqiri_bench_raw_tx_rx.yaml \ --seconds 10 # Header-data split / GPUDirect ./build/examples/daqiri_bench_raw_hds \ examples/daqiri_bench_raw_tx_rx_hds.yaml \ --seconds 10
# RDMA client/server (10 s) ./build/examples/daqiri_bench_rdma \ examples/daqiri_bench_rdma_tx_rx.yaml \ --seconds 10 --mode both # Software loopback (no physical link) ./build/examples/daqiri_bench_raw_gpudirect \ examples/daqiri_bench_raw_sw_loopback.yaml \ --seconds 10 # Multi-queue RX ./build/examples/daqiri_bench_raw_gpudirect \ examples/daqiri_bench_raw_rx_multi_q.yaml \ --seconds 10
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_MGR / 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+.News
Announcements, publications, and community updates about DAQIRI.
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_MGR="dpdk socket rdma" cmake --build build -j