# Enabling Real-Time AI for Scientific Instruments with GPU-Native Data Acquisition

> Source: <https://developer.nvidia.com/blog/enabling-real-time-ai-for-scientific-instruments-with-gpu-native-data-acquisition/>
> Published: 2026-11-19 17:00:00+00:00

**Key takeaway:** DAQIRI receives Ethernet detector packets directly into GPU memory, letting a 500+ Gbps electron microscopy camera stream be assembled, corrected and reduced to spectra during acquisition rather than written to disk first.

In science and industry, analyzing sensor measurements in real time can enable AI to adjust processes, guide experiments, and search for better operating conditions. Yet limits on how quickly the measured data can be moved and processed often shape how an instrument is designed, from readout electronics to acquisition timing. What could scientific instrument makers simplify—or make possible—if processing could keep pace with their sensors?

[NVIDIA DAQIRI](https://developer.nvidia.com/daqiri) is a software-defined data acquisition library that moves high-bandwidth instrument and sensor data into GPU-ready workflows. It enables developers to process measurements during acquisition without first writing them to disk. An [NVIDIA Holoscan](https://holoscan.org) platform library, DAQIRI bridges sensors optimized for measurement with programmable GPU platforms for scientific analysis, AI inference, and feedback applications.

For existing Ethernet-capable instruments, this opens opportunities to add processing and feedback capabilities, as described in the previous post, [Enable Real-Time AI for High-Speed Data Acquisition with NVIDIA DAQIRI](https://developer.nvidia.com/blog/enable-real-time-ai-for-high-speed-data-acquisition-with-daqiri/). For new instruments, it allows opportunities for reconsidering acquisition constraints from the start.

This post explores how a new electron microscopy camera and GPU processing enable analysis during acquisition. It then introduces new DAQIRI features, including hardware packet reordering, performance and throughput improvements in the library, and a low-latency NIC polling mode for time-sensitive packet processing.

## Case study: Connecting high-dynamic-range imaging to GPU processing

A high-dynamic-range electron microscopy camera developed at [Lawrence Berkeley National Laboratory’s](https://www.lbl.gov/) [Molecular Foundry](https://foundry.lbl.gov/) illustrates what becomes possible when advanced detectors and GPU processing are designed to work together.

Electron energy-loss spectroscopy (EELS) measures the energy electrons lose as they interact with a sample, helping scientists identify which elements are present and how they are bonded together. These measurements contain both strong and faint signals. To capture those differences in intensity, the conventional approach uses two separately optimized acquisition processes in rapid succession.

This requires precise coordination of the electron optics, exposure timing, and detector readout. The resulting measurements then need to be aligned and combined, adding complexity to both acquisition and processing. The new high-dynamic-range camera developed at the Molecular Foundry captures strong and faint signals together.

This advancement simplifies the experimental setup and microscope optics, but generates more than 500 gigabits of data per second (Gbps)—a stream that must be received and processed to make those measurements useful during acquisition. This is over 500x faster than conventional EELS data streams, which greatly enhances the raw detector information available for further processing and analysis.

Handling that stream requires an acquisition and processing pipeline designed to keep pace with the camera. This is where the collaboration between Berkeley Lab and NVIDIA brings together the camera, DAQIRI, and GPU-accelerated processing. FPGA readout electronics transmit detector data over Ethernet, DAQIRI receives the packets directly into GPU memory, and GPU processing assembles and corrects detector frames before reducing them to energy-loss spectra.

Computation also improves the spatial information recovered from the detector, enabling submicron spatial resolution from sensor pixels measuring 5 micrometers across. Through this pipeline, the team enables inspection of the data during the measurement and adjusting the acquisition parameters and regions of interest in real time, all while processing high bandwidth data incoming at more than 500 Gbps.

The benefits of this approach extend beyond electron microscopy. Connecting sensors to GPU processing can extract more information from measurements and give instrument makers greater flexibility in how they acquire, analyze, and act on data. Realizing those benefits requires efficient data movement, ordered payloads ready for processing, and low-latency communication for feedback.

## Designing acquisition paths for intelligent instruments

The [latest DAQIRI release](https://github.com/NVIDIA/daqiri/releases/tag/v2026.11.00) adds hardware packet reordering, an optimized library backend for improved throughput, and direct polling for low-latency packet transmission and reception.

### Reorder data as it arrives with NIC hardware

Most networks rely on protocol processing or receive-side buffering to handle out-of-order packets, which can add latency and memory overhead. DAQIRI can now offload packet reordering tasks to supported [NVIDIA ConnectX-7](https://www.nvidia.com/en-us/networking/ethernet-adapters/) or newer NICs, preserving CPU and GPU resources for analysis. For compatible sequence formats, the NIC parses sequence fields and places each payload directly into its ordered position in memory. The application receives the assembled, ordered data without requiring a separate software reorder copy step.

Hardware-based reordering is defined here for a specific receive queue. The configuration dictates how to parse the sequence number from the packet header, which reordering method to use, and how missing packets should be handled.

```
- name: "rx_reorder_seq_1024"
  reorder_engine: "hw"          # NIC places payloads in order
  cyclic_sequence: true         # Confirm compatible cyclic numbering
  missing_action: “drop”        # Drop partial batches on RX timeout
  reorder_type: "gpu"           # Deliver packets to GPU memory
  memory_region: "Reorder_RX_GPU"
  payload_byte_offset: 42       # Skip 42-byte Ethernet/IPv4/UDP header
  packet_size: 8192             # Payload bytes per output slot
  flow_ids: [201]               # Apply reorder to RX flow 201
  method:
    seq_packets_per_batch:      # Reorder by one sequence field
      sequence_number:
        bit_offset: 336         # Sequence starts at bit 336
        bit_width: 32           # 32-bit sequence field
      packets_per_batch: 1024   # 1024 packets per output buffer
```

### Use the ibverbs engine for efficient acquisition

DAQIRI introduces an ibverbs engine for high-rate receive and transmit of raw Ethernet packets. Built on libibverbs and NVIDIA DevX, the engine is selected by default for raw Ethernet streams. Developers can also select it explicitly by adding engine: “ibverbs” to their DAQIRI configuration, without changing how they use the application API. By reducing per-packet CPU overhead, the ibverbs engine delivers approximately twice the per-core throughput of the previous default DPDK backend at small packet sizes (up to 1024 bytes) and extreme data rates (greater than 200 Gbps), based on benchmark tests performed on the [NVIDIA DGX Spark](https://nvidia.github.io/daqiri/benchmarks/performance-dgx-spark/), [NVIDIA IGX Thor](https://nvidia.github.io/daqiri/benchmarks/performance-igx-thor/), and [NVIDIA RTX PRO](https://www.nvidia.com/en-us/products/workstations/) server platforms.

### Reduce feedback latency with direct polling

Intelligent instruments may require latency-sensitive feedback from GPU analysis to adjust acquisition or control settings. The DAQIRI direct polling mode reduces communication latency by letting the application thread receive and submit packets directly, eliminating the handoff to a separate I/O worker. In cabled loopback benchmark tests, application send-to-receive latency on the order of 2-4 µs has been demonstrated in direct polling mode. When using the ibverbs engine, developers can select direct polling for control queues while retaining batched processing for high-throughput data streams.

Set `poll_mode: "direct"` on the latency-sensitive TX and RX control queues so the application thread submits and receives packets directly.

```
# TX/RX queue settings in example configuration file
tx:
  queues:
  - name: "control_tx"
    id: 0
    poll_mode: "direct"         # App thread submits packets
    memory_regions: ["Control_TX"]

rx:
  queues:
  - name: "control_rx"
    id: 0
    poll_mode: "direct"         # App thread polls received packets
    memory_regions: ["Control_RX"]
```

Run the direct-polling latency benchmark using a cabled loopback between TX and RX ports on the same host.

First, replace the configuration’s hardware address placeholders and other system-specific settings with values for your system:

```
sudo ./build/examples/daqiri_bench_raw_latency 
examples/daqiri_bench_raw_latency_ibverbs.yaml --samples 
10000 --warmup 1000 --csv latency.csv
```

## Get started with GPU-native data acquisition

During the process of making scientific instruments, GPU-native data acquisition enables you to design around what will be measured and your desired means of response. Advanced detectors and GPU processing can work together for reconsidering acquisition constraints.

The latest DAQIRI capabilities extend the options for moving and organizing measurements efficiently and connecting analysis to experimental control. That means more engineering effort can focus on measurement quality and scientific insight.

To explore these capabilities, start with the [DAQIRI documentation](https://nvidia.github.io/daqiri/getting-started/) and [DAQIRI configuration examples](https://nvidia.github.io/daqiri/config-generation/). Then use the [DAQIRI benchmarks](https://nvidia.github.io/daqiri/benchmarks/performance-igx-thor/) to evaluate throughput and communication latency on your hardware.

To learn more, check out these related resources:

- Explore the [NVIDIA/daqiri](https://github.com/NVIDIA/daqiri) GitHub repo
- Browse the [DAQIRI plus TensorRT Streaming Inference Reference Application](https://nvidia.github.io/daqiri/tutorials/daqiri-resnet-inference/)
- Generate [DAQIRI Configurations](https://nvidia.github.io/daqiri/config-generation/) for your hardware
