PaperlayerView exact revision on arXiv

Source-linked AI summary

Performance Foundations of Parallel & Distributed Reasoning Language Models

Maciej Besta, Leonard Schmidt, Lara Nonino, Robert Gerstenberger, Pierre Pang, Patrik Okanovic, Ales Kubicek, Tiancheng Chen, Baraq Lipshitz, Torsten Hoefler

arXiv:2608.27046v1cs.LGcs.AIcs.DCcs.PF

TL;DR

RLM training delivers reasoning improvements but has massive compute demands and tightly coupled multi-model pipelines, creating a systems challenge beyond algorithm design. This paper systematizes RL-for-LLMs, analyzes their work–depth–memory characteristics, and develops an intra- and inter-model parallelism taxonomy. It provides a unified performance vocabulary, framework analysis, practical guidelines, and research directions for scalable and cost-effective RLMs.

  • Problem

    RLM training has massive computational requirements and tightly coupled multi-model pipelines that stress hardware beyond classical supervised LLM training.

  • Method

    The paper combines compute-centric analysis of PPO-, GRPO-, and DPO-like methods with a work–depth–memory taxonomy of intra- and inter-model parallelism.

  • Results

    The resulting taxonomy provides a unified performance vocabulary for locating computation, memory, and critical-path bottlenecks in RLM training and inference.

  • Takeaways & Limitations

    The framework analysis helps practitioners match existing systems to their needs while identifying optimization opportunities for scalable, fast, and cost-effective RLMs.

  • Takeaways & Limitations

    Disaggregation alone does not reduce iteration latency and introduces explicit communication across device-group boundaries unless combined with overlap or asynchronous execution.

Abstract

from arXiv · show

Reinforcement Learning with Verifiable Rewards (RLVR) and other RL-style post-training paradigms have been used for aligning large language models (LLMs) with reasoning standards. The resulting recent Reasoning Language Models (RLMs) such as DeepSeek-R1, o3, and Kimi k1.5 show that such RL-style post-training ("RL-for-LLMs") can substantially improve chain-of-thought reasoning, long-horizon planning, and self-correction. However, the computational footprint of these systems is massive: state-of-the-art RLM training requires millions of GPU-hours and tightly coupled multi-model pipelines that stress modern hardware far beyond classical supervised LLM training. This makes RLM training as much a parallel and distributed systems problem as an algorithmic one. In this work, to facilitate developing RLMs that are simultaneously high-performance, scalable, and cost-effective, we first systematize the RL-for-LLM paradigm and provide a compute-centric analysis of prominent post-training algorithmic frameworks: Proximal Policy Optimization (PPO), Group Relative Policy Optimization (GRPO), as well as their variants. Second, we develop a taxonomy of intra- and inter-model parallelism strategies for RL-for-LLMs, covering both traditional techniques (data, tensor, pipeline, sequence, context, and expert parallelism) as well as novel forms of parallelism and optimization techniques for multi-model RLM training, for example disaggregated placement, stage fusion, hybrid parallelism, and asynchronous execution. We harness the work-depth model of parallel computing to make our taxonomy and its insights rigorous and portable. Finally, we analyze existing RLM frameworks and we distill practical guidelines and outline open research directions for building scalable, fast, and cost-effective RLMs.

1 INTRODUCTION

RLMs deliver stronger reasoning but impose massive computational and systems demands. This paper addresses those demands by systematizing RL-for-LLMs, developing a parallelism taxonomy, and analyzing existing frameworks with portable complexity models.

  • Motivation: RLM training has become a parallel and distributed systems problem because multi-model RL pipelines stress hardware beyond classical supervised training.The workflow requires coordinated reasoning about model placement, inter-model scheduling, and heterogeneous workloads.
  • Contributions: The paper systematizes RL-for-LLM methods, including PPO-style, GRPO-like, and preference-gradient approaches such as DPO.The analysis is compute-centric and covers prominent post-training frameworks.
  • Contributions: The taxonomy covers intra-model data, tensor, pipeline, sequence, context, and expert parallelism across RL pipeline components.It examines how traditional parallelism interacts with different RL stages and model roles.
  • Contributions: Inter-model optimization includes model restructuring, placement, stage and sub-task fusion, hybrid configurations, and asynchronous execution.These choices expose concurrency opportunities and reduce end-to-end iteration time by changing component interactions.
  • Analysis framework: The work-depth model formalizes parallelism trade-offs by relating total operations, sequential depth, and memory requirements.Depth bounds execution time, while memory includes parameters, gradients, optimizer state, and activations.
  • Framework analysis: A systematic framework analysis catalogs supported intra- and inter-model techniques and identifies gaps such as underexplored stage fusion and placement policies.The catalog is intended to help practitioners match frameworks to requirements and guide new optimizations.

2 OVERVIEW & FOUNDATIONS OF RLMS

RL-style reasoning post-training is organized around a recurring Generation–Assessment–Training loop involving policy and auxiliary models. The paper distinguishes online and offline variants and characterizes their computational roles and signals.

  • Pipeline overview: The RL-for-LLM pipeline repeatedly generates policy responses, assesses them, and trains the policy using resulting feedback.Assessment and Training may invoke reward, critic, and reference models.
  • Terminology: RL-style reasoning post-training is a broad umbrella covering RLVR, model-based online RL, and offline preference optimization.The umbrella includes methods using feedback beyond next-token prediction.
  • Terminology: Strict RLVR uses online RL with automatic-verifier rewards, including exact-answer matching, code execution, compilation, and theorem-proving checks.These rewards are produced by programmatic correctness mechanisms rather than learned reward models.
  • Assessment paradigms: Model-based assessment includes RLHF, RLAIF, and direct RLAIF, which derive feedback from learned reward models, AI preferences, critiques, or direct LLM evaluation.Learned process rewards can provide intermediate-step supervision but may require repeated evaluation.
  • Offline preference optimization: DPO removes online generation and explicit reward assessment from the inner loop while retaining policy/reference comparison and training over static preference pairs.This makes its systems profile closer to supervised fine-tuning, but limits exploration beyond the fixed dataset.
  • Auxiliary models: The reward model supplies fixed sequence-level quality signals, whereas the trainable critic estimates token-level future returns and supports advantage computation.The reference model is frozen and provides a baseline for stabilizing optimization.
  • Auxiliary models: Process-based reward models provide richer intermediate-step supervision but significantly increase computational cost and training difficulty.They may require multiple forward passes or Monte Carlo Tree Search integration.

Classes of schemes

The paper groups reasoning post-training schemes by how they obtain feedback and whether optimization uses online rollouts or offline preference pairs.

  • RL-Style Reasoning Post-Training: RL-style reasoning post-training uses feedback beyond next-token prediction and shares part of a common systems abstraction.The extracted scheme overview distinguishes offline preference optimization from online reward-based approaches.
  • Offline Preference Optimization: Offline preference optimization uses optimizing preference pairs rather than online reward production.Its pipeline is associated with static preference data.
  • Reinforcement Learning with Verifiable Rewards: Strict RLVR performs online RL with rewards produced by an automatic verifier.The verifier supplies programmatic correctness feedback.
  • Extensions of RLHF / RLAIF: RLHF and related extensions use a learned reward model and potentially a critic to assess policy outputs.These schemes rely on model-based feedback rather than only automatic verification.

Models

RL-for-LLM systems differ in their auxiliary models, execution stages, and computational trade-offs. PPO is the most expensive online design, GRPO removes critic costs but retains autoregressive generation, and DPO uses cheaper offline training without online exploration.

  • Models: PPO uses actor, reward, critic, and reference models across Generation, Assessment, and Training stages.Its actor and critic require forward and backward passes, while reward and reference models are evaluated forward-only.
  • Models: GRPO removes the critic, eliminating critic-dependent work and model-state memory while retaining online reward inference and generation.This reduces memory pressure and simplifies rollout training, but does not remove the dominant autoregressive generation depth.
  • Models: DPO uses only policy and reference models in an offline teacher-forced pipeline over pre-computed preference data.It removes online Generation and explicit reward-model inference, making its systems profile closer to supervised fine-tuning while limiting exploration beyond the dataset.
  • Computational analysis: PPO has the highest online computational cost because its per-iteration work includes all major model terms and both trainable-model states.GRPO removes the critic term, whereas DPO also removes online rollout generation from the optimization loop.
  • Computational analysis: Autoregressive generation creates an irreducible O(T) dependency within each PPO or GRPO rollout.Assessment and Training parallelism cannot eliminate this per-trajectory sequential chain, making efficient decoding important for latency and throughput.
  • Computational analysis: Reward granularity trades compute against credit assignment: outcome rewards are cheap, whereas process rewards can require step-level annotations, verification, or search.Process-level feedback can turn Assessment into a substantially heavier verification workload.

3 INTRA-MODEL PARALLELISM

Intra-model parallelism partitions a single RL-LLM model's data, operators, sequences, stages, or experts across devices. The paper organizes established techniques around their execution and communication implications in the multi-model RL pipeline.

  • 3 INTRA-MODEL PARALLELISM: Intra-model parallelism distributes one model's parameters, activations, or computation graph across multiple devices.The main families are data, tensor/operator, sequence, context, pipeline, and expert parallelism, plus memory-centric optimizations.
  • Data parallelism: Data parallelism replicates the model, shards the input batch, and synchronizes gradients with an all-reduce after local forward and backward passes.It scales throughput nearly linearly when the model fits on one device and communication is not limiting.
  • Data parallelism: Naive data parallelism becomes memory-limited for very large models, motivating ZeRO/FSDP-style sharding of parameters, gradients, and optimizer state.Gradient synchronization can also become a major overhead as device count or communication distance increases.
  • RL-LLM pipeline implications: Forward-only models can use replicated-weight batched inference, while trainable models require gradient synchronization and sharded data-parallel variants.This distinction applies across actor, reward, reference, and critic roles in different RL stages.
  • Tensor parallelism: Tensor parallelism shards layer operators across devices and reconciles partial results through all-reduce or all-gather communication.It commonly partitions both feed-forward projections and multi-head attention projections.
  • Tensor parallelism: Communication-computation overlap in tensor parallelism can reduce idle time during forward and backward execution.Megatron-LM-style operators use different communication behavior across the two passes.

Data parallelism (DP)

Data parallelism replicates weights while dividing inputs across devices, but its best configuration depends on whether each RL component is trainable or forward-only. RL-LLM pipelines therefore commonly combine pure DP with DP plus ZeRO.

  • Forward-only components: For frozen models, data parallelism becomes batched inference without gradient all-reduce overhead, supporting high throughput in Generation and Assessment.This regime applies to forward-only actor, reward, and reference executions.
  • Trainable components: Replicated parameters, gradients, and optimizer states create severe memory bottlenecks for large trainable models.Combining DP with ZeRO and FSDP mitigates this pressure by sharding states across devices.
  • Communication: Gradient all-reduce can bottleneck training, whereas inference requires no communication; gradient bucketing overlaps backward computation with communication.The optimization targets the collective synchronization cost of trainable components.
  • RL-LLM pipeline pattern: RL-LLM pipelines typically use DP plus ZeRO for trainable components and pure DP for forward-only components.This separates memory-efficient training from replicated batched inference according to stage requirements.
  • Data parallelism: Data parallelism replicates weights, shards the global input batch, and synchronizes gradients after backward computation.This uses collective all-reduce communication across replicas.

Pipeline parallelism (PP)

Pipeline parallelism partitions model execution into stages connected by point-to-point transfers, reducing per-device memory but introducing scheduling bubbles and generation-specific sequential limits.

  • Pipeline structure: Pipeline parallelism splits inputs across stages and transfers activations and gradients between consecutive stages.Point-to-point communication avoids global collectives between pipeline stages.
  • Scheduling: Mode-aware pipeline parallelism uses tailored configurations because RL components have heterogeneous execution characteristics.The paper identifies stage heterogeneity as a reason to customize pipeline settings per component.
  • Memory: Partitioning parameters, gradients, and optimizer states across stages reduces per-device memory pressure and helps deep models fit in aggregate HBM.The memory benefit comes from distributing model state across the pipeline.
  • Assessment/Training: Assessment and Training on complete sequences can use standard micro-batched pipeline schedules.These stages expose more regular work units for pipeline execution.
  • Generation: Generation retains an O(T) critical path under pipeline parallelism because tokens traverse all stages sequentially.Incomplete sequences also cause pipeline bubbles under naive schedules.
  • Scheduling: Sequential stage dependencies create idle hardware bubbles, motivating 1F1B, Zero Bubble, and DualPipe schedules.These schedules interleave forward and backward passes to improve hardware utilization.

Tensor parallelism (TP)

Tensor parallelism shards model weights and computation across ranks, reducing per-rank memory but introducing frequent collective communication. Its usefulness depends on whether memory capacity or inference throughput is the dominant constraint.

  • Memory: TP reduces per-rank memory by distributing weights, activations, and optimizer states across the TP group.The memory reduction is proportional to the TP size for the sharded components.
  • Communication: Four All-Reduce collectives per forward-backward pass restrict TP groups to high-bandwidth intra-node interconnects.High-performance runtimes overlap communication with chunked matrix computation using custom kernels.
  • Mechanism: TP shards weight matrices across ranks, distributing hidden-dimension, column-wise, and row-wise computation within MHA and FFN layers.Partial results are aggregated during the forward pass.
  • Trade-offs: TP introduces inference overhead because frequent collectives can bottleneck and degrade throughput when memory does not require sharding.The text therefore recommends avoiding TP in Generation and Assessment whenever memory permits.

Expert parallelism (EP)

The supplied passages provide limited EP-specific detail: they show a row-wise weight-splitting operation and identify memory-constrained training as a motivation for tensor sharding. A general intra-model-parallelism figure is also referenced.

  • Mechanism: Weights can be split row-wise across ranks as one model-parallel sharding operation.
  • Motivation: Memory-constrained training motivates sharding because gradients inflate memory by 3x.The passage attributes this motivation to tensor parallelism rather than explicitly to expert parallelism.
  • Coverage: Figure 6 covers data, pipeline, tensor, and expert parallelism for each RLM model execution.The supplied caption points to Figure 4 for the legend.

Sequence parallelism (SP)

Sequence parallelism shards sequence-dependent work to reduce activation memory while preserving tensor-parallelized MHA and FFN operations. Its communication can match TP while enabling longer reasoning traces and contexts.

  • Mechanism: SP partitions Norm and Dropout along the sequence dimension while keeping MHA and FFN tensor-parallelized.This reduces activation memory linearly by the TP group size.
  • Mechanism: Sequence sharding keeps the sequence distributed across operations, with FFN and Norm local and MHA handling global dependencies through Ring Attention.Ring-style transfers can overlap fetching the next KV block with current QK computation.
  • Communication: TP+SP replaces four TP All-Reduces with four All-Gathers and four Reduce-Scatters, yielding zero net communication overhead.The equivalence follows from All-Reduce = All-Gather + Reduce-Scatter.
  • Benefits: Activation sharding reduces memory during policy and critic training, enabling longer reasoning traces or larger batches.
  • Long context: Blockwise attention reduces peak per-rank attention activation memory from O(T^2) to O(T^2/p^2).This supports long-context processing by limiting per-rank attention-memory requirements.
  • Boundary: Context parallelism reduces per-device context memory and attention work but does not remove sequential token sampling during online Generation.It therefore addresses feasibility and long-context scaling more directly than rollout latency.

4 INTER-MODEL PARALLELISM

Inter-model parallelism reshapes RLM execution by changing placement, fusion, layouts, and synchronization, primarily reducing critical-path depth or co-resident memory rather than total work. These techniques introduce trade-offs involving communication, memory, scheduling complexity, latency, and policy drift, while actor generation remains the dominant bottleneck.

  • Taxonomy: Inter-model parallelism spans structure configurations, placement, stage fusion, hybrid execution, and asynchronous execution, which can be combined in high-performance RLM systems.Structure configurations alter model sharing; placement controls co-location; fusion streams partial outputs; hybrid execution varies layouts; asynchrony permits bounded-stale reads.
  • Stage Fusion: Up to 3.7× throughput improvement was reported for RLHFuse by fusing sample-level generation and assessment with microbatch-level training, mitigating long-tail skew and pipeline bubbles.Fusion does not reduce total work and can increase single-sample latency through queueing and downstream backpressure.
  • Hybrid Parallelism and Adaptive Scheduling: Hybrid execution uses role-specific parallel layouts, but its gains must exceed resharding costs when parameters or optimizer state move between training and inference configurations.Examples include DeepSpeed-Chat Hybrid Engine, ReaL parameter reallocation, HybridFlow/verl’s 3D-HybridEngine, and NeMo RL’s distinct training and inference layouts.
  • Hybrid Parallelism and Adaptive Scheduling: Adaptive scheduling improves utilization through computation-mode-aware layouts, but requires profiling, cost modeling, memory checks, and robust orchestration, especially at scales where static layouts leave hardware idle.Pipe-RLHF uses stage-specific parallelization, while ReaL and HybridFlow represent the pipeline as a dataflow or execution plan.
  • Asynchronous Execution: Asynchronous execution introduces policy-drift risk when trajectories sampled by π_beh train a newer π_θ, although PPO clipping and AReaL’s policy separation provide mitigation mechanisms.Relevant monitoring statistics include staleness, token-level KL, ratio variance, clip fraction, effective sample size, and reward or advantage shifts.
  • Complexity Analysis: Most inter-model techniques reduce depth rather than work by replacing sequential sums with maxima or overlapping stages; shared actor–critic also reduces work and trainable model-state memory.Inter-model methods cannot remove the actor’s autoregressive decode chain, whose reduction requires inference parallelism, faster decoding, batching, KV-cache management, shorter trajectories, or algorithmic changes.
  • Model Placement Strategies: Disaggregation reduces co-resident memory and enables concurrency, but requires fusion, streaming, or asynchrony to reduce iteration depth rather than merely relocating idle time.Separated device groups exchange rollouts, token IDs, log-probabilities, rewards, values, and sometimes updated parameters.

5 PARALLELISM-FOCUSED SPECIFICATIONS

The paper gives unified specifications for PPO, GRPO, and DPO, then annotates their model operations with parallelism opportunities. These annotations distinguish sample-level data parallelism from conditional model-sharding strategies and stage-specific uses.

  • PPO and GRPO share a rollout-generation routine, while DPO provides an offline counterpart for preference optimization.
  • Data parallelism is the natural default for independent prompts, candidates, rollouts, and preference pairs because they have no semantic dependency.These units can be assigned to replicas and combined later through reductions for losses, statistics, or gradients.
  • Tensor and pipeline parallelism are conditional model-sharding options whose collectives, activation transfers, and bubbles can reduce throughput when models already fit on one device.They remain relevant when actor, critic, reward, or reference invocations require sharding for capacity or latency.
  • Context parallelism applies to long-context invocations, including autoregressive decoding, when rollout KV or attention memory exceeds single-device capacity.
  • Sequence parallelism is reserved for trainable teacher-forced forward/backward paths because it primarily reduces stored activation memory during training.It is not marked for ordinary forward-only assessment or decode-time generation.
  • Expert parallelism is an MoE-dependent option, while annotations attach only to Transformer invocations or operations that backpropagate through them.

6 ANALYSIS OF EXISTING MODELS & DESIGNS

The paper analyzes models and frameworks by their algorithmic specifications, reasoning targets, and parallel execution designs. It finds that high-throughput systems must account for rollout-dominated workloads, heterogeneous roles, and explicit inter-model scheduling rather than rely on conventional training parallelism alone.

  • Model comparison: RLMs are distinguished from general aligned LLMs by explicitly targeting reasoning trajectories, long-CoT, verifiable rewards, search, tools, or controllable test-time computation.
  • Algorithmic specifications: The specifications cover PPO, GRPO, and DPO, with PPO using actor–critic components and GRPO using critic-free grouped optimization.
  • Framework analysis: Rollout generation and forward assessment can dominate wall-clock time, so high-throughput frameworks maximize rollout throughput or overlap generation with evaluation and training.Table 11’s analysis identifies stage fusion and asynchronous execution as mechanisms for such overlap.
  • Framework analysis: Library-centric stacks emphasize ease of use and state sharding, whereas orchestrator-centric stacks expose multi-role dataflow, placement, resource management, and heterogeneous parallelism.
  • Practical guidance: Practical guidance favors library-centric stacks for small experiments, mature FSDP/ZeRO or Megatron backends for memory-bounded runs, disaggregated rollout for generation-heavy workloads, and asynchronous or streaming systems at frontier scale.

7 RESEARCH OPPORTUNITIES

The paper identifies research opportunities spanning resource-aware reasoning, nonlinear execution structures, automated parallel design, richer rewards, asynchronous training, tool integration, hardware, and evaluation. These directions connect reasoning quality with execution efficiency and system-level control.

  • Resource-aware test-time compute: Resource-aware test-time compute could optimize expected utility subject to token, latency, memory, tool-call, and energy budgets.
  • Efficient execution structures: Nonlinear reasoning structures such as trees, graphs, and hypergraphs can improve in-context search and aggregation, motivating their integration into RL execution pipelines.
  • Automatic parallelization: Future systems could automatically select intra-model parallelization schemes for whole pipelines rather than optimizing only individual Transformer invocations.
  • Automatic reasoning topologies: Reasoning topologies and execution schedules could be derived from task difficulty, uncertainty, verifier availability, hardware, and performance properties.Open decisions include branch expansion, pruning, verifier calls, thought merging, and mapping the resulting DAG to device groups.
  • RLVR beyond final-answer rewards: Process-level RLVR rewards could extend beyond final-answer checks, but their many assessment nodes require caching, batching, placement, and overlap with generation.
  • Asynchronous and stale-data RL: Asynchronous and stale-data RL raises the need to characterize when stale rollouts remain useful, how to correct policy drift, and how to trade staleness against performance.
  • Retrieval, tools, and external state: Tools, retrieval, simulators, verifiers, and agent calls could be modeled as operators in the same execution graph as generation, reward evaluation, and training.
  • Evaluation and reproducibility: RLM evaluation must account for reasoning budget, sampling strategy, rollout length, staleness, and component-level metrics for tools, retrieval, and verification.

8 CONCLUSION

The paper frames RL-for-LLMs as a parallel and distributed systems challenge and systematizes its pipeline, costs, and optimization opportunities. Its work–depth–memory analysis covers model computation, iterative stages, and execution dependencies.

  • Pipeline and analysis: RL-for-LLM pipelines combine autoregressive generation, auxiliary-model assessment, and trainable updates with distinct inputs, outputs, and dependencies.The pipeline iterates by feeding updated policy parameters into the next Generation stage.
  • Pipeline and analysis: Generation separates prompt prefill from autoregressive decode, where each generated token attends to the prompt and previously generated tokens.Total generation cost is modeled as Cgen = Cprefill + Cdecode.
  • Pipeline and analysis: Assessment converts sampled sequences into rewards, reference probabilities, and token-level learning targets using reward, reference, and, for PPO, critic models.GRPO omits the critic and computes advantages from group-normalized rewards.
  • Pipeline and analysis: Training updates the policy and, for actor–critic methods, the critic through teacher-forced objectives before producing the next policy.PPO updates both actor and critic components, whereas GRPO updates only the actor.
  • Pipeline and analysis: The work–depth model defines depth as critical-path length under unbounded parallelism and accounts for forward, backward, attention, and autoregressive costs.The framework distinguishes parameter-dependent computation, token mixing, backward-pass approximation, and generation’s prefill–decode structure.

B.2 Results for RL-LLM Frameworks

Online PPO and GRPO repeatedly pay for Generation, Assessment, and Training, with autoregressive generation creating the main wall-clock bottleneck. Parallelism reduces per-device pressure and memory, but realized performance depends on communication, scheduling, placement, and execution conditions.

  • RL-LLM frameworks: Online PPO and GRPO incur the summed work of Generation, Assessment, and Training at every iteration.Offline DPO instead operates on static preference pairs using batched forward and backward passes.
  • RL-LLM frameworks: Autoregressive generation is the primary wall-clock bottleneck because token t + 1 depends on token t, making generation depth linear in T.Assessment and Training use non-autoregressive teacher-forced passes without the same factor-T token dependency.
  • RL-LLM frameworks: PPO updates both the policy and critic, whereas GRPO updates only the policy because it omits a learned critic.Assessment likewise uses the critic for PPO but not GRPO.
  • Intra-model parallelism: Data parallelism reduces per-rank work and activation memory while retaining the global batch-gradient dependency.Tensor parallelism preserves global work and memory order while reducing per-device pressure, excluding communication overheads.
  • Intra-model parallelism: Context parallelism improves sequence-work, memory, and long-context feasibility but does not reduce the global exact-attention reduction over S + T.Three-dimensional parallelism provides strong per-device memory reduction by partitioning batch, layers, and hidden computation, subject to communication and scheduling costs.
  • Inter-model parallelism: Shared actor–critic is the only listed inter-model configuration that reduces global work relative to separate-backbone PPO, with greatest benefit when actor and critic sizes are comparable.Disaggregated placement leaves total work unchanged, while combined strategies require sufficient hardware, careful scheduling, and acceptable staleness.
Loading 2608.27046v1…