RDMA can reduce communication overhead in distributed machine learning systems, but realizing these benefits in production requires more than replacing TCP. Variable-size messages, concurrent connections, bursty incasts, and service failures introduce challenges that hardware offload alone cannot address. This paper reports our experience deploying ByteExpress, a software communication layer over hardware RDMA, in ByteDance's parameter-server-based inference and training systems. We present three lessons from the deployment: efficient RDMA requires buffer management across application and transport layers; scalable communication requires coordinated management of connections, receive capacity, and outstanding data; and service availability requires recovery above the transport layer. ByteExpress combines an RDMA-aware allocator, zero-copy transfers, QP multiplexing, receive-credit flow control, a software send window, and RPC-assisted recovery. In production inference, ByteExpress reduces mean and P99 model parameter fetch latency by 35.7% and 43.7%, respectively, and total CPU usage by 10.69% compared with kernel TCP. In training, ByteExpress reduces P99 model parameter push latency by up to 74.0% compared with TCP, with no PFC pauses observed at runtime.
Figures & tables
Figure 1: Parameter-server architecture: rankers fetch sharded model parameters for inference; trainers also push parameter updates.
RC
UC
UD
SEND/RECV
✓
✓
✓
WRITE
✓
✓
✗
READ/ATOMIC
✓
✗
✗
Connection-oriented
✓
✓
✗
Reliable
✓
✗
✗
Maximum message size
2GB
2GB
MTU
Table 1: Comparison of RDMA transports.
Figure 2: Communication stack: Archon provides RPCs; ByteExpress manages buffers and message transfers over hardware RDMA.
Link rate
MTU
RC (Gbps)
UD (Gbps)
25G
1024B
23.15
22.97
100G
1024B
92.26
48.29
100G
4096B
97.03
95.74
200G
4096B
191.36
114.70
Table 2: RC and UD throughput measured with ib_send_bw at different link rates and MTUs.
Figure 4: Allocator operation rate and peak memory versus thread count. Large allocations span 64 KB–1 MB; small allocations span 16 B–16 KB.
Figure 5: Registered RDMA memory footprint on one inference node, sampled every 30 s from startup and stabilizing near 2.2 GB.
Figure 6: Large-message transfer: exchange destination-buffer metadata, write payload fragments, and notify the receiver with a final WRITE_WITH_IMM .
Figure 7: RDMA engine: one QP, receive resources, and a work-request chain partitioned into in-flight, pending, and free entries.
Figure 9
Figure 12: RDMA engine assignment—each engine (and its QPs) belongs to one I/O thread; one thread manages multiple engines.
Figure 11
Resource
Allocation
QP
One per remote address
RQ
One per QP, without SRQ
SRQ
One per thread, when enabled
CQ
One per thread
TD
One per thread
MR
One per registered block
Table 3: Allocation of RDMA resources in BE . Dedicated RQs and per-thread SRQs are alternative configurations.
Figure 15: PS performance in the synthetic inference workloads with no software window or 4, 8, and 16 KB windows.
Window size
Servers before PFC
4 KB
1,218
8 KB
567
16 KB
273
No software control
63
Table 4: Reported server count before PFC is observed, by software window size.
Figure 16: PS performance in a production recommendation inference workload: mean and P99 for TCP and RDMA in microseconds, sampled at one-minute intervals for the busiest rankers.
CPU metric
RDMA
TCP
Reduction
Total CPU usage
51.31%
57.45%
10.69%
Software interrupts
0.16%
1.70%
90.6%
System
4.18%
7.08%
41.0%
User
47.0%
48.7%
3.5%
Table 5: CPU usage during the peak-load Toutiao inference interval. Reductions are relative to TCP.
Latency
RDMA
TCP
Reduction
Mean
8.1 ms
12.6 ms
35.7%
P99
35.5 ms
63.1 ms
43.7%
Table 6: PS Pull latency at inference peak.
Metric
TCP
RDMA HW only
RDMA HW + SW
Fetch P99
650 ms
1.04 s
338 ms
Push P99
1.03 s
1.12 s
268 ms
PFC duration
N/A
1 s per 30 s
0
Loss indicator
1%–4%
3K NAKs per 30 s
0
Table 7: Metrics for the busiest trainers. HW: hardware congestion control; SW: software send window. TCP loss rates and RDMA NAK counts are not directly comparable.
Communication-efficient distributed training reduces the data exchanged among devices so models can be trained faster and over limited-bandwidth networks.