- Rating
- 1
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 3
Read review
Paper summary
This work proposes LZIP-P2P, a lossless compression framework for GPU point-to-point (P2P) communication to reduce communication overhead without introducing numerical errors. The proposed method introduces a split-send pipeline that overlaps compression and communication. Unlike conventional pipelining methods that divide tensors into smaller chunks, LZIP-P2P exploits the internal stages of floating-point compression. Specifically, it transmits the uncompressed portion of a tensor immediately after the splitting stage while the remaining portion undergoes compression. This allows the method to overlap communication with compression while maintaining GPU efficiency.
The proposed method is integrated into UCCL-P2P without requiring application changes. It also supports different floating-point formats and GPU platforms, including NVIDIA and AMD GPUs. The experimental evaluation covers different tensor sizes, floating-point formats, and resource-constrained settings. The proposed method achieves up to 52.9% higher P2P communication throughput and 47.5% higher weight synchronization throughput for LLM reinforcement learning workloads compared to the baseline.
Critical strengths
- The proposed method preserves numerical correctness while reducing GPU communication overhead. This is beneficial for distributed training workloads where lossy compression may introduce numerical errors.
- The evaluation covers multiple GPU architectures, floating-point formats, and communication settings. The implementation also requires no application changes, which improves its practicality.
Critical weaknesses
- The technical novelty of the proposed method seems limited. The main contribution is a relatively simple split-send pipeline. In addition, the paper does not provide experimental comparisons with recent lossless compression methods, such as ZipNN, NeuZip, DFloat11, and ZipCCL, under comparable settings. This makes it difficult to assess the advantages of the proposed design over alternative lossless compression approaches.
- The paper does not demonstrate improvements in overall RL training performance. Section 5.3 only evaluates the communication throughput of individual weight tensors, so it is unclear how much the reported throughput improvements contribute to reducing total training time.
Questions for authors
- Can the authors provide experimental comparisons with recent lossless compression methods, such as ZipNN, NeuZip, DFloat11, and ZipCCL, under comparable settings where feasible, to better demonstrate the effectiveness of the proposed method?
- Can the authors evaluate the end-to-end performance improvement of RL training, rather than only measuring the communication throughput of individual weight tensors?
4 comments
continued
Q2 (continued): End-to-end RL training performance, not only per-tensor throughput.
We added Section 5.5 and Table 4. We integrated LZip-P2P into the open-source miles RL framework as a P2P weight-transfer backend:
We run GRPO on Qwen3-4B on two nodes with one GH200 each: the Megatron trainer on one node, a single SGLang engine on the other, so every update crosses the network. Each step generates 2 prompts × 4 samples with responses of at most 32 tokens and trains on a global batch of 8, in synchronous GRPO and in asynchronous RL. The only difference between runs is the weight-transfer backend: miles' default Mooncake or LZip-P2P:
| Setting | Backend | Weight update (s) | Rollout (s) | Train (s) | Step (s) |
|---|---|---|---|---|---|
| Qwen3-4B, sync | Mooncake (miles default) | 0.220 | 0.243 | 0.612 | 2.134 ± 0.049 |
| LZip-P2P | 0.173 (−21.4%) | 0.244 | 0.600 | 1.979 ± 0.054 (−7.3%) | |
| Qwen3-4B, async | Mooncake | 0.217 | 0.248* | 0.488 | 1.087 ± 0.042 |
| LZip-P2P | 0.178 (−18.0%) | 0.237* | 0.464 | 0.955 ± 0.024 (−12.1%) |
The weight update includes format conversion and the completion fence. *In asynchronous runs, rollout overlaps with training and is off the critical path.
Findings:
- Weight updates are 18–21% faster than with Mooncake. The gain is smaller than in the per-tensor benchmark because the update also converts weights to the engine's layout, sends small tensors uncompressed, and waits for each 1 GB bucket to be decompressed before converting the next.
- Step time. The end-to-end effect scales with the share of the step spent in weight updates. We use small batches, as in asynchronous RL that updates the weights after every small batch to keep rollouts nearly on-policy. With LZip-P2P, step time drops by 7.3% in synchronous GRPO and 12.1% in asynchronous RL.
- No effect on the training trajectory. The transfer is lossless, and miles' per-step weight-equality check confirms the engine receives bit-identical weights.
We have narrowed the application-level claims in the paper accordingly.
Thank you for the additional experiments.
In Table 4, the reductions in total RL step time (155 ms and 132 ms) are substantially larger than the reductions in weight-update time (47 ms and 39 ms). Could the authors clarify which additional components account for these differences?
Clarify additional components account
Thank you for checking these numbers. The step-time reductions in Table 4 (155 / 132 ms) include the effect of replacing the transport backend, not only of compression. To separate the two, the table below adds a run with the same UCCL P2P transport and compression disabled:
| Setting | Backend | Weight update (s) | Rollout (s) | Train (s) | Step (s) |
|---|---|---|---|---|---|
| Qwen3-4B, sync | Mooncake | 0.220 | 0.243 | 0.612 | 2.134 |
| UCCL P2P (no compression) | 0.208 | 0.244 | 0.612 | 2.030 | |
| LZip-P2P | 0.173 | 0.244 | 0.600 | 1.979 | |
| Qwen3-4B, async | Mooncake | 0.217 | 0.248* | 0.488 | 1.087 |
| UCCL P2P (no compression) | 0.207 | 0.233* | 0.456 | 1.035 | |
| LZip-P2P | 0.178 | 0.237* | 0.464 | 0.955 |
* In asynchronous runs, rollout overlaps with training and is off the critical path.
- Replacing Mooncake with UCCL P2P (no compression) shortens the step by 104 ms (sync) and 52 ms (async). Besides the three columns above, a step also includes the log-probability pass, releasing training memory before the update, and framework work around the update. Replacing the Mooncake backend with UCCL P2P reduces these additional overheads. A likely reason: in miles, the Mooncake backend keeps the trainer's copy of the model in host memory, copies it from the GPU at every update, and runs its own transfer engine next to the trainer process. UCCL P2P keeps the copy in GPU memory and writes it directly with GPUDirect RDMA, which leaves less host-side work to slow down the other phases.
- Adding compression (UCCL P2P → LZip-P2P) shortens the update by 35 ms (sync) and 29 ms (async).
Why the end-to-end effect is modest here. Our added experiments train on a single GH200 (96 GB). Full-parameter training with Adam needs about 18 bytes per parameter, so Qwen3-4B is the largest model that fits; each update transfers 8.0 GB of weights. At this scale the weight update is only about 10% (sync) to 20% (async) of the step, so an 18–21% faster update gives a small step-time saving.
In large-scale RL, the update takes a much larger share of the step. Every step must move the full model from the trainers to all inference engines, and this takes seconds to minutes:
- SGLang reports 53 s with NCCL broadcast for Kimi-K2 (1T parameters) and 10.8 s for Qwen3-235B-A22B, noting that "during weight transfer, the entire RL training comes to a halt" [1].
- Prime Intellect reports that syncing weights after every step "stayed stuck at 60–90 seconds" while their step times were under five minutes, which puts the update at roughly 20–30% of the step [2].
Asynchronous RL, which updates the weights after every small batch to stay nearly on-policy, makes updates even more frequent. In these settings the update-time saving of LZip-P2P translates into a larger end-to-end saving.
[1] https://lmsys.org/blog/2026-04-29-p2p-update/
[2] https://primeintellect.ai/blog/nixl-modelexpress-weight-transfer
Response to Reviewer
We thank the reviewer for the careful reading and the two concrete requests. Both new experiments are now in the revised PDF. Due to the OpenReview length limit, this response may be split into two posts.
Q1: Comparison with recent lossless compression methods (ZipNN, NeuZip, DFloat11, ZipCCL) under comparable settings.
We added Section 5.3 and Table 3. Like LZip-P2P, all of these methods exploit the low entropy of the BF16 exponent and leave sign and mantissa largely uncompressed. They differ in where and when compression runs, and that is what matters for communication.
Setting: we run each method's released code on one GH200 on the first 32 BF16 weight tensors of at least 16 MB in the released checkpoints of GLM4-9B (32 MiB–1.16 GiB, 4.1 GiB in total) and Qwen3.5-35B-A3B (1 GiB each, 32 GiB in total).
("Transfer" = compression + compressed bytes over one 400 Gb/s NIC + decompression)
Findings:
On novelty: we agree the split-send pipeline is simple, and we see that as a strength. The key step is aligning the pipeline with the compressor's internal stages instead of with data size. That alignment is what makes lossless compression profitable for P2P transfers, and Table 3 shows that a codec alone does not provide this benefit.