NVIDIA Open Source · Data Acquisition

DAQIRI for Sensor Data
in CPU or NVIDIA GPU Memory

DAQIRI (Data Acquisition for Integrated Real-time Instruments) moves high-bandwidth data between external sensors and CPU or NVIDIA GPU memory. 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. GPU-resident data can also write out through GPUDirect Storage.

Quick Start → Key Concepts API Reference Benchmarking

PCIe + Ethernet

Sensor Paths

Ingest + Egress

Data Direction

Zero-Copy

CPU/GPU Memory

Raw Ethernet, RoCE

Protocols

C++ / Python

Application API

Why DAQIRI

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.

Quick Start

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.

Full Guide →

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

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
}

Code Samples

Examples

Benchmark executables and YAML configs included in the examples/ directory.

Browse examples/ →

Transmit a Packet BurstC++

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);

GPU Packet ProcessingC++/CUDA

// 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);

Header-Data Split ConfigYAML

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  # payload

Hardware Flow SteeringYAML

rx:
  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}

Raw Ethernet Benchmarksbash

# 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 & Multi-Queue Benchmarksbash

# 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

DAQIRI for Sensor Data
in CPU or NVIDIA GPU Memory

Closing the Gap Between Sensor and GPU

Scalable, High Throughput

GPUDirect Zero-Copy

Hardware Flow Steering

RDMA over Converged Ethernet

YAML-Driven Configuration

Containerized Deployment

Build & Run in Minutes

Install Prerequisites

Build from Source

Or Build the Container

Tune the System

Run a Benchmark

Examples

Tutorials

News

Connect Your Sensors to the NVIDIA Ecosystem

DAQIRI Sensor Data and Storage Paths

DAQIRI for Sensor Datain CPU or NVIDIA GPU Memory

Closing the Gap Between Sensor and GPU

Scalable, High Throughput

GPUDirect Zero-Copy

Hardware Flow Steering

RDMA over Converged Ethernet

YAML-Driven Configuration

Containerized Deployment

Build & Run in Minutes

Install Prerequisites

Build from Source

Or Build the Container

Tune the System

Run a Benchmark

Examples

Tutorials

News

Connect Your Sensors to the NVIDIA Ecosystem

DAQIRI for Sensor Data
in CPU or NVIDIA GPU Memory