RDMA and DPU-Accelerated Cloud Data Planes

Modern cloud platforms are increasingly adopting high-performance network fabrics and programmable network devices such as RDMA-capable NICs, SmartNICs, and Data Processing Units (DPUs). These devices offer a new opportunity to rethink the cloud data plane: instead of relying on CPU-bound kernel networking and repeated software protocol processing, cloud systems can offload data movement, transport processing, and network orchestration to specialized hardware.

This is an ongoing research direction in my group. The goal is to design next-generation cloud data planes that combine RDMA, SmartNIC/DPU offloading, zero-copy communication, and multi-tenant resource isolation. We are particularly interested in how these techniques can benefit serverless computing, cloud-native microservices, service meshes, and distributed cloud applications.

Research Overview

Serverless and cloud-native applications are often composed of many loosely coupled functions or microservices. These components communicate frequently, and their communication paths often traverse heavyweight software layers, including sidecars, message brokers, kernel TCP/IP stacks, ingress gateways, and protocol adapters. This creates substantial overhead from data copies, context switches, interrupts, serialization/deserialization, and repeated protocol processing.

Earlier work on shared-memory serverless systems shows that intra-node communication can be made much faster by avoiding kernel networking. However, shared memory alone does not scale to distributed deployments where functions may be placed across multiple machines. RDMA provides a natural way to extend zero-copy communication across nodes, but using RDMA in a multi-tenant cloud environment is difficult: untrusted user functions should not directly access low-level RDMA Queue Pairs, and shared RNIC resources must be isolated and fairly shared across tenants.

DPUs provide an attractive place to manage these concerns. They combine an RDMA-capable NIC with programmable cores, allowing the system to move network orchestration away from the host CPU. However, DPU cores are much weaker than server CPUs, so simply moving CPU-side networking logic onto the DPU is not enough. The key research challenge is to identify what should run on the DPU, what should remain on the CPU, and what should be handled directly by the RNIC hardware.

Our first system in this direction is NADINO (Qi et al., 2026), a DPU-centric serverless data plane for multi-tenant serverless clouds.

Key Ideas

RDMA-Based Distributed Zero-Copy Communication

NADINO extends zero-copy communication from a single node to a distributed serverless cluster. It combines intra-node shared memory with inter-node RDMA transfers, allowing function chains to communicate efficiently even when functions are placed across multiple machines.

The key idea is to use a unified memory pool on each worker node. Local functions communicate through shared memory, while remote functions communicate through RDMA into the same memory pool. This avoids unnecessary data movement between separate local and remote buffers.

DPU Network Engine for Multi-Tenant RDMA

A major challenge in RDMA-based clouds is that RDMA Queue Pairs expose low-level control over the RNIC. Giving untrusted serverless functions direct access to QPs creates security and fairness problems, especially in a multi-tenant environment.

NADINO introduces a DPU Network Engine (DNE) as a trusted software layer running on the DPU. The DNE manages RDMA QPs on behalf of user functions, isolates RDMA resources from untrusted code, and enforces tenant-aware scheduling policies. This allows serverless functions to benefit from RDMA without directly controlling the RNIC.

Off-Path DPU Offloading with Cross-Processor Shared Memory

A naive DPU design places the DPU on the critical data path, forcing data to move through DPU memory before reaching host functions. This can overload the relatively weak DPU cores and introduce extra CPU-DPU data movement.

NADINO instead uses an off-path DPU design. The RNIC moves data directly into host memory, while the DPU manages control-path tasks such as RDMA connection management, buffer descriptor handling, and tenant scheduling. Cross-processor shared memory lets the DPU access host memory metadata without copying packet payloads through the DPU. This design keeps the DPU programmable while letting the RNIC handle fast data movement.

Two-Sided RDMA for Lock-Free Zero-Copy

One-sided RDMA is often considered faster, but it is not always the best fit for distributed serverless data planes. In a unified memory pool, one-sided writes can create races between remote RDMA access and local shared-memory access. Avoiding these races requires either distributed locking or a separate RDMA-only memory pool, both of which add overhead.

NADINO uses two-sided RDMA because the receiver explicitly posts buffers for incoming data. This naturally transfers buffer ownership and avoids data races without distributed locks or receiver-side copies. In NADINO’s evaluation, two-sided RDMA provides lower latency and higher throughput than one-sided alternatives with locks or receiver-side copying.

Early HTTP/TCP-to-RDMA Conversion at Cluster Ingress

External clients usually speak HTTP/TCP, while the internal serverless data plane can use RDMA. A common approach is to forward HTTP/TCP traffic into worker nodes and only then convert to a faster internal transport. This causes redundant TCP/IP processing inside the cluster.

NADINO performs early transport conversion at the cluster-wide ingress. The ingress terminates HTTP/TCP connections at the cluster edge and forwards payloads into the serverless cluster over RDMA. This removes unnecessary TCP/IP processing from worker nodes and aligns the ingress with the zero-copy data plane.