Bottleneck Patching Strategies

• Bottleneck patching is a strategy that intervenes around a limiting constraint to optimize global system performance without directly removing the bottleneck.
• It spans applications from traffic flow and GPU architectures to language models and malware epidemic controls, adapting interventions to specific system variables.
• Quantitative improvements—such as increased throughput, reduced energy consumption, or lower failure indices—demonstrate its practical impact across heterogeneous domains.

Bottleneck patching is a cross-domain label for interventions that do not remove a limiting constraint directly, but alter the states, flows, or computations immediately around that constraint so that system-level degradation is reduced. In the cited literature, the term is used for upstream velocity control before a periodically closing exit in exclusion-process traffic models, assist-warps that repurpose idle GPU resources against a saturated subsystem, transient scratchpads that refine patch-level context in byte-level LLMs without enlarging persistent KV state, sender-side modifications to BBR under CPU contention, prompt-level repairs of diagnosed modules in multi-stage LLM agents, optimal patch dissemination in clustered malware epidemics, and augmenting-path rewiring in bottleneck assignment [(Yamamoto et al., 2019); (Vijaykumar et al., 2016); (Zheng et al., 10 May 2026); (Elmenhorst et al., 9 Jan 2026); (Jeonghun et al., 21 May 2026); (Eshghi et al., 2014); (Khoo et al., 2020)]. This breadth suggests a recurring design principle rather than a single algorithm: identify the effective bottleneck state, intervene at the interface that governs it, and optimize the intervention against the induced secondary effects.

1. Cross-domain semantics and recurrent structure

Across these works, the bottleneck itself is represented in markedly different mathematical objects. In traffic flow, it is a time-periodic boundary capacity constraint at the exit, with $\beta(t)\in\{0,1\}$ switching between open and closed phases. In GPU architecture, it is a saturated subsystem such as off-chip memory bandwidth or compute pipelines. In patch-based byte models, it is the coarse patch state that refreshes too slowly relative to the underlying byte stream. In BBR, it is the sender’s CPU time rather than the path bandwidth. In modular LLM agents, it is the module with the largest causal contribution to system failure. In clustered epidemics, it is the type-dependent transmission structure; in bottleneck assignment, it is the maximum-weight edge in a maximum-cardinality matching [(Yamamoto et al., 2019); (Vijaykumar et al., 2016); (Zheng et al., 10 May 2026); (Elmenhorst et al., 9 Jan 2026); (Jeonghun et al., 21 May 2026); (Eshghi et al., 2014); (Khoo et al., 2020)].

The corresponding patch acts on equally different control variables. The traffic model varies the hopping probability $v$ through the control parameter $p$. CABA deploys assist warps through the Assist Warp Store, Assist Warp Controller, and Assist Warp Buffer. Scratchpad Patching introduces transient states $z_\ell^t$ triggered by entropy. The BBR patch conditionally overwrites $\text{pacing\_gain}$ with the existing high-gain constant. Counterfactual Correction Patching appends few-shot “Wrong/Correct” demonstrations to one module’s prompt. Epidemic control varies $u_i(t)$, the patch transmission intensity for each type. The distributed BAP algorithm updates $\mathcal{M}$ by symmetric difference with an augmenting path, $\mathcal{M}\oplus\mathcal{P}$ [(Yamamoto et al., 2019); (Vijaykumar et al., 2016); (Zheng et al., 10 May 2026); (Elmenhorst et al., 9 Jan 2026); (Jeonghun et al., 21 May 2026); (Eshghi et al., 2014); (Khoo et al., 2020)].

A further commonality is that the intervention is almost never evaluated only locally. The relevant objective is global throughput $Q$, end-to-end performance and energy, downstream evaluation quality, aggregate failure index $F(E)$, aggregate epidemic cost, or the maximal cost in a complete assignment. This suggests that bottleneck patching is fundamentally about indirect control: local intervention is judged by a nonlocal objective.

2. Flow regulation in traffic and transport protocols

In the controlled TASEP with a slow-to-start rule, the bottleneck is encoded by a periodic right-boundary extraction probability

$v$0

with time-averaged exit probability $v$1. The upstream control is the state-dependent hopping rule

$v$2

combined with a slow-to-start coefficient $v$3 that reduces restart probability after blocking. The mechanism is explicit: when the bottleneck is closed, upstream particles decelerate, which stretches spacing and reduces the discharge penalty induced by slow-to-start when the exit reopens (Yamamoto et al., 2019).

The paper distinguishes low-density and high-density regimes. In the high-density regime with $v$4, the uncontrolled discharge is strongly reduced: at the exit, one particle leaves every $v$5 steps when congested, and for opening duration $v$6 the discharged count per cycle is $v$7, yielding

$v$8

With control, the theoretical high-density bounds are $v$9 and $p$0, so the improvement factor can in principle reach $p$1, i.e. $p$2. For $p$3, $p$4, and $p$5, simulations reach $p$6 at an optimal $p$7. The approximate design rules are

$p$8

with a realistic estimate that a VSL-type control based on the scheme could improve intersection throughput by about $p$9 (Yamamoto et al., 2019).

An analogous logic appears in 2BRobust, but the bottleneck is not a road exit; it is sender CPU time inside a VM. Standard BBR maintains

$z_\ell^t$0

Under CPU contention, the VM is frequently descheduled, BBR misses pacing opportunities, inflight stays below $z_\ell^t$1 BDP, the measured delivery rate drops, and the controller enters a downward spiral in which $z_\ell^t$2, $z_\ell^t$3, and throughput collapse. The measurements show that CPU-limited BBR senders are capped at very low throughput levels below $z_\ell^t$4–$z_\ell^t$5 Mbps under any hypervisor and all tested BDP conditions, whereas Cubic remains robust (Elmenhorst et al., 9 Jan 2026).

The patch is intentionally minimal. Let

$z_\ell^t$6

If the socket is not app-limited and

$z_\ell^t$7

the implementation overrides the current phase gain by setting $z_\ell^t$8 inside bbr_update_gains(). This raises both pacing rate and TSO burst size during on-CPU windows. At $z_\ell^t$9 Mbps, with $\text{pacing\_gain}$0 ms timeslice, original BBRv3 needs about $\text{pacing\_gain}$1 CPU share before median throughput reaches at least $\text{pacing\_gain}$2 Mbps, while patched BBRv3 recovers near line rate already at about $\text{pacing\_gain}$3 CPU share; with $\text{pacing\_gain}$4 ms timeslice the corresponding threshold shifts from about $\text{pacing\_gain}$5 to about $\text{pacing\_gain}$6. The patch does not solve the most severe cases of scheduling, but it solves the problem for the most critical cases and is inert when no inflight deficit occurs (Elmenhorst et al., 9 Jan 2026).

These two cases instantiate the same systems-level idea at different abstraction levels. In both, the patch does not enlarge the bottleneck directly; it reshapes arrivals into it.

3. Architectural bottleneck patching in GPUs

Core-Assisted Bottleneck Acceleration treats bottleneck patching as dynamic conversion of slack in one GPU subsystem into relief for another. The motivating observation is empirical: for $\text{pacing\_gain}$7 out of $\text{pacing\_gain}$8 applications, the GPU is memory-bound, and at baseline bandwidth memory plus data-dependence stalls constitute about $\text{pacing\_gain}$9 of issue cycles; doubling bandwidth reduces that to about $u_i(t)$0. At the same time, occupancy constraints leave substantial on-chip state unused; for a $u_i(t)$1 KB register file, around $u_i(t)$2 of registers are statically unallocated on average. CABA exploits precisely this mismatch between the saturated subsystem and idle resources (Vijaykumar et al., 2016).

The mechanism is the assist warp. An assist warp shares warp ID and context with its parent warp, executes code sequences stored in the Assist Warp Store, is managed by the Assist Warp Controller through entries in the Assist Warp Table, and is staged in the Assist Warp Buffer. High-priority assist warps, such as decompression on a compressed load return, can block the parent until completion; low-priority assist warps, such as compression or memoization maintenance, are scheduled only in otherwise idle cycles. The AWC also monitors pipeline utilization so that assist deployment is throttled when it would compete with the currently saturated resource (Vijaykumar et al., 2016).

The most detailed instantiation is bandwidth compression. Between L2 and DRAM, data are stored in compressed form, while L1 is left uncompressed by default. For BDI, a $u_i(t)$3 B line can be compressed to $u_i(t)$4 B, yielding

$u_i(t)$5

Decompression is implemented as a vector add of base and deltas by a high-priority assist warp; compression is off the critical path and is handled by low-priority assist warps. CABA also adapts FPC and C-Pack, despite their variable-length encodings, by restructuring metadata and enforcing more SIMD-friendly layouts (Vijaykumar et al., 2016).

The reported performance figures are specific. Across memory-bandwidth-sensitive applications, CABA-BDI improves performance by $u_i(t)$6 on average, up to $u_i(t)$7; it is only $u_i(t)$8 slower than Ideal-BDI and $u_i(t)$9 slower than HW-BDI, while outperforming HW-BDI-Mem by about $\mathcal{M}$0. Average DRAM bus utilization is reduced from about $\mathcal{M}$1 to about $\mathcal{M}$2. Total system energy is reduced by about $\mathcal{M}$3, including about $\mathcal{M}$4 average DRAM power reduction, and EDP is reduced by $\mathcal{M}$5, even though average power increases by about $\mathcal{M}$6. The framework is also described as applicable to memoization, prefetching, redundant multithreading, speculative precomputation, profiling, and reliability tasks, provided that the helper work is mapped onto non-bottleneck resources (Vijaykumar et al., 2016).

CABA therefore exemplifies bottleneck patching as microarchitectural work migration: compute is spent to simulate bandwidth, or memory activity is spent to relieve compute.

4. Representational bottlenecks in patch-based LLMs

Scratchpad Patching addresses a different bottleneck: the coarse update schedule induced by patch-based byte modeling. A byte-level autoregressive LM is factored into an encoder $\mathcal{M}$7, a patchifier $\mathcal{M}$8, a main trunk $\mathcal{M}$9 running on patch states, an unpatchifier $\mathcal{M}\oplus\mathcal{P}$0, and a decoder $\mathcal{M}\oplus\mathcal{P}$1. In the baseline unpatchifier, for byte position $\mathcal{M}\oplus\mathcal{P}$2 in patch $\mathcal{M}\oplus\mathcal{P}$3,

$\mathcal{M}\oplus\mathcal{P}$4

Hence every nonterminal byte in a patch must use stale context from the previous patch. The paper identifies this as patch lag: as average patch size grows, compute and KV cache decrease, but modeling quality degrades because patch-level context is refreshed too infrequently (Zheng et al., 10 May 2026).

Scratchpad Patching inserts transient scratchpads inside each patch. With binary trigger $\mathcal{M}\oplus\mathcal{P}$5, the number of scratchpads in patch $\mathcal{M}\oplus\mathcal{P}$6 is

$\mathcal{M}\oplus\mathcal{P}$7

and the $\mathcal{M}\oplus\mathcal{P}$8-th scratchpad state is

$\mathcal{M}\oplus\mathcal{P}$9

During training, the trunk sees

$Q$0

under a specialized mask: states belonging to patch $Q$1 may attend to themselves and committed states of earlier patches only; scratchpads neither attend to each other nor are attended to by other elements. During inference, scratchpads are computed on the fly and immediately discarded; only the final committed patch state remains in the KV cache (Zheng et al., 10 May 2026).

The trigger policy most emphasized in the paper is entropy-based. An auxiliary LM head predicts next-byte entropy

$Q$2

and a scratchpad fires when

$Q$3

This makes scratchpad density an inference-time compute knob: lower $Q$4 yields more transient refinement and less patch lag; higher $Q$5 yields fewer scratchpads and lower compute (Zheng et al., 10 May 2026).

The key claim is decoupling. Patch size still controls the number of committed states $Q$6 and thus the KV-cache footprint, but scratchpad density controls additional compute without increasing persistent memory. The reported results are concrete. At $Q$7 bytes per patch, SP-augmented models match or closely approach the byte-level baseline on downstream evaluations while using a $Q$8 smaller KV cache over patches and $Q$9–$F(E)$0 less inference compute. On natural-language NLU, fixed-size $F(E)$1 without SP yields average score about $F(E)$2, whereas fixed $F(E)$3 with SP yields about $F(E)$4, matching the byte-level baseline at $F(E)$5. On MBPP pass@1, byte-level reaches $F(E)$6, fixed $F(E)$7 reaches $F(E)$8, and fixed $F(E)$9 with SP reaches $v$00. The paper also reports that H-Net + SP can trigger redundant compute because scratchpads often fire right before learned boundaries, and that very dense scratchpads give diminishing returns and can even slightly hurt NL BPB (Zheng et al., 10 May 2026).

Within this literature, SP is a particularly explicit formulation of bottleneck patching: the bottleneck state is not removed but supplemented by transient, nonpersistent refinements.

5. Diagnostic bottlenecks and patching hazards in modular LLM pipelines

In multi-module LLM agents, bottleneck patching is not presented as a throughput optimization but as a prescription problem after causal diagnosis. The studied agent family has four modules,

$v$01

corresponding to Query Rewriter, Planner, Router, and Response Generator. System performance is summarized by the failure index

$v$02

and the causal responsibility of module $v$03 is

$v$04

On $v$05-bench retail with the gpt-4o-mini agent, the average effects are $v$06, $v$07, $v$08, and $v$09, so the router $v$10 is the diagnosed primary bottleneck; the same qualitative pattern holds across retail, airline, Llama 4 Scout, and Qwen3-32b (Jeonghun et al., 21 May 2026).

The central result is that diagnosis does not identify the best patch location. Counterfactual Correction Patching constructs a correction pool from diagnosis data, filters examples with $v$11, keeps the top $v$12, and appends them to one module’s prompt in the form $v$93 while leaving instructions and output schema unchanged. Applied to the diagnosed bottleneck $v$13, this consistently fails as a prescription. On retail, Pop CCP at $v$14 changes mean failure index by $v$15 for gpt-4o-mini, with Holm $v$16; by $v$17 for Qwen3-32b, with raw $v$18; and by $v$19 for Llama 4 Scout, i.e. neutral. By contrast, Pop CCP at the upstream Query Rewriter $v$20 changes mean failure index by $v$21, $v$22, and $v$23, respectively. Tool-match shows the same asymmetry: for gpt-4o-mini, baseline is $v$24, CCP at $v$25 gives $v$26, and CCP at $v$27 gives $v$28; for Qwen3-32b, baseline is $v$29, CCP at $v$30 stays at $v$31, and CCP at $v$32 drops to $v$33 (Jeonghun et al., 21 May 2026).

The paper explains this through the Linguistic Contract hypothesis. Downstream modules adapt to the characteristic error distribution of upstream modules, so correcting the bottleneck may break that co-adaptation. The mediation quantity is the Natural Indirect Effect,

$v$34

where World A re-executes $v$35 on oracle upstream and World B freezes $v$36 to its original output while upstream is corrected. Tasks are then classified as amplifier, propagator, or compensator according to the sign and magnitude of $v$37. For gpt-4o-mini retail, $v$38 has $v$39 and fate counts $v$40 for amplifier/propagator/compensator. The per-agent co-adaptation proxy is the compensator rate at $v$41: $v$42 for gpt-4o-mini, $v$43 for Qwen3-32b, and $v$44 for Llama 4 Scout. High co-adaptation co-occurs with CCP hazard; zero co-adaptation co-occurs with neutrality (Jeonghun et al., 21 May 2026).

The paper further isolates the hazard to correction injection rather than any intervention at the router. Instruction rewriting at $v$45 is essentially neutral, with $v$46 for gpt-4o-mini; a model upgrade at $v$47 is also neutral, with $v$48. Oracle injection at $v$49, however, strongly improves outcomes, with $v$50 for gpt-4o-mini and $v$51 for Llama 4 Scout. This indicates that the router is genuinely highly improvable, but that partial prompt-level correction is a hazardous way to intervene there. A further mechanistic observation is that the final-output sentence-embedding cosine is $v$52 for both CCP @ $v$53 and CCP @ $v$54, so the asymmetry is not explained by the magnitude of final distribution shift but by its direction: $v$55 perturbs executable-semantic variables such as tool name and argument patterns, whereas $v$56 perturbs a surface-linguistic layer that downstream modules tolerate better (Jeonghun et al., 21 May 2026).

6. Optimal-control and combinatorial formulations

The most explicit mathematical theory of patching appears in clustered malware epidemics. The network is partitioned into $v$57 types, with state fractions $v$58, $v$59, and $v$60, infection rates $v$61, patch dissemination rates $v$62, healing efficacies $v$63, and control inputs $v$64. The objective is to minimize aggregate damage and patching cost over $v$65, with cost functionals such as

$v$66

for non-replicative patching, and the analogous $v$67-weighted form for replicative patching. Applying Pontryagin’s Maximum Principle yields scalar minimization conditions of the form

$v$68

or

$v$69

with $v$70 strictly decreasing in time. This monotonicity drives the central structural result: if $v$71 is concave, the optimal control is bang-bang with at most one switch from $v$72 to $v$73; if $v$74 is strictly convex, the optimal control is continuous, strictly decreasing from $v$75 to $v$76, with at most one transition interval. Numerical examples on linear, star, and complete topologies show that the optimal stratified dynamic policy can reduce aggregate cost by about $v$77 versus the best static stratified policy and about $v$78 versus the homogeneous approximation for $v$79, while replicative patching can achieve up to about $v$80 cost reduction relative to non-replicative patching (Eshghi et al., 2014).

A combinatorial analogue appears in the distributed Bottleneck Assignment Problem. Here the objective is

$v$81

where $v$82 is the set of maximum-cardinality matchings. The pruneBAP algorithm starts from an MCM $v$83, selects a current bottleneck edge $v$84, forms the pruned edge set

$v$85

removes $v$86, and searches for an augmenting path relative to $v$87. If such a path exists, the matching is patched by symmetric difference; if not, $v$88 is critical and the current matching is optimal. The distributed implementation decomposes this into MaxEdge, local pruning, and distributed augmenting-path search via AugDFS or AugBFS over a communication graph of diameter $v$89. For $v$90, the worst-case complexity is $v$91. AugDFS tends to require fewer pruneBAP iterations, whereas AugBFS tends to require fewer time steps overall; the choice is therefore a communication-versus-time trade-off. The same augmenting-path logic also governs when two independently solved sub-BAPs can be merged directly: if no beneficial cross-cluster augmenting path exists, $v$92 is already a bottleneck assignment for the combined graph (Khoo et al., 2020).

Taken together, these formulations show that bottleneck patching can be cast either as continuous-time optimal control with monotone shadow prices or as discrete augmenting-path repair on a thresholded graph. A plausible implication is that the most transferable element across domains is not the surface mechanism—speed limit, assist warp, scratchpad, prompt correction, epidemic dispatcher, or matching update—but the underlying strategy of exploiting a local control surface whose marginal value can be tracked against a global bottleneck objective.