Gatling: Rapid-Fire Consensus from Parallel Composition

Abstract: Consensus protocols form the core of blockchains and other replicated state machines, ensuring that all correct nodes process the same totally ordered log of input transactions. In fault-free executions, performance is driven by the good-case transaction latency -- the time between a transaction becoming known to all nodes and its confirmation by the consensus protocol -- which depends on both how frequently proposals are made and, once made, how quickly they are confirmed. While prior work has established tight lower bounds on confirmation latency that modern protocols already achieve, it remains open whether the inter-proposal time can be further reduced below the state-of-the-art of one network delay. We introduce Gatling, an atomic broadcast protocol that achieves arbitrarily small inter-proposal times under rotating leader schedules; in particular, smaller than the network delay. Gatling runs multiple parallel instances of a black-box atomic broadcast protocol and staggers their proposal schedules to generate proposals in faster succession than state-of-the-art protocols. A deterministic interleaving rule merges the outputs of these instances into a single global log. We analyze the effects of head-of-line blocking caused by crashed leaders, and derive Gatling's optimal number of parallel instances. We further study the impact of Gatling on predictable validity and present two variants that retain this property. Finally, our experiments confirm that Gatling can be used with off-the-shelf component protocols to achieve low latency without fine-tuning the component protocol for minimum latency.

• The paper’s main contribution is Gatling, which reduces inter-proposal latency below network delays by parallelizing black-box atomic broadcast instances.
• It employs staggered scheduling and a deterministic merge rule to maintain Byzantine fault-tolerance while synthesizing rapid proposal streams.
• Empirical results on a 10-node cluster show transaction finality as low as 244ms, demonstrating the practical potential for high-performance blockchains.

Gatling: Achieving Sub-Network Delay Consensus via Parallel Atomic Broadcast Composition

Overview

The paper "Gatling: Rapid-Fire Consensus from Parallel Composition" (2606.18220) introduces Gatling, a protocol that achieves arbitrarily small inter-proposal times—including sub-network delay intervals—in Byzantine fault-tolerant atomic broadcast. Unlike prior approaches, Gatling demonstrates that by parallelizing $K$ instances of any black-box atomic broadcast protocol and carefully scheduling proposal offsets, the effective inter-proposal time can be reduced below the network delay, leading to significant reductions in transaction latency without requiring intrusive optimizations of the base protocol.

Motivation and Problem Statement

The historical progression of block production intervals in blockchains plateaued at hundreds of milliseconds, with protocols like Solana, Moonshot, and Hydrangea++ reaching the prevailing lower bound derived from network delays and protocol round requirements. Prior literature established that, under partial synchrony with standard resilience, the confirmation latency is lower-bounded by three rounds of communication. With recent pipelined protocols already saturating this bound, the only remaining lever for further reduction in transaction latency is the inter-proposal time.

Existing protocols argue, often implicitly, that proposal intervals are bottlenecked by the time required for the proposal to propagate across the network—the so-called "network delay" ($\Delta$). The key innovation in Gatling is the observation that by composing multiple protocol instances in parallel, each with staggered schedule, one can synthesize an inter-proposal stream with intervals much smaller than $\Delta$, even as each instance individually conforms to the classically assumed lower bounds.

Protocol Construction

Gatling is parameterized by a base atomic broadcast protocol (e.g., PBFT, Tendermint, Simplex), an inter-proposal timing $T_{\text{ipt}}$, and the number of parallel instances $K$. Each instance operates independently and without knowledge of the other instances' internal state (closed-box). Schedules are offset so that the proposal windows partition the proposal timeline at intervals of $T_{\text{ipt}}/K$. At each time tick of $T_{\text{ipt}}/K$, a leader from some instance is issuing a proposal.

To yield a single totally ordered log, Gatling employs a deterministic merge rule: proposals at the same slot across all instances are interleaved in fixed order. Confirmation is subject to all preceding proposals in this order being confirmed to guarantee consistency.

This compositional approach is agnostic to the details of the base protocol and requires only a minimal extension: an interface that exposes per-instance annotated logs with slot numbers.

Security and Latency Analysis

Gatling retains the security of its component protocol. Consistency (safety) follows via monotonicity of per-instance logs and the deterministic merge rule. Liveness is assured because every input is delivered to all instances, and, assuming at least one honest leader in each slot, will eventually be included and confirmed.

Formally, if each base instance offers $(T_{\text{ipt}}, T_{\text{conf}})$ good-case latency, Gatling reduces the inter-proposal interval to $T_{\text{ipt}}/K$ while maintaining the confirmation interval $T_{\text{conf}}$. Thus, the transaction latency floor in the good-case can approach $\Delta$0 as $\Delta$1.

However, head-of-line blocking emerges as a significant new phenomenon: finalizing the merged log may be delayed by prior slots in any instance that have crashed or delayed leaders. A quantitative stochastic model is developed: for a proposal drop probability $\Delta$2, the optimal $\Delta$3 that minimizes expected latency trades off marginally reduced inter-proposal time against the compounded risk of blocking. The analysis is formalized via renewal theory and the $\Delta$4-Pochhammer symbol.

Key Numerical Results

• Empirical deployments on a 10-node global cluster confirm the theory: with a deliberately unoptimized Simplex base protocol (500ms per instance), Gatling achieves finality as low as 244ms at $\Delta$5 with a 1% proposal drop rate.
• As proposal failure probability increases, the optimal $\Delta$6 shrinks to mitigate compounding block-outages.
• Even with high proposal failure rates, Gatling outperforms standalone, optimally tuned, single-instance protocols on both confirmation and transaction latency.

Goodput and Validity Extensions

Gatling's approach of broadcasting each transaction to all instances can result in the same transaction appearing multiple times in the output log (deduplication issue). While this potentially reduces throughput, it is conceptually aligned with multi-proposer and DAG-based systems.

A fundamental challenge that emerges when the inter-proposal interval is sub-$\Delta$7 is the loss of predictable validity: proposers cannot guarantee that their view of prior transactions is globally consistent, which is essential for certain execution semantics (e.g., state machine replication with application-level dependencies). The paper introduces two Gatling variants to reintroduce this property:

• Empty-blocks variant: Alternates windows of dense proposals by a single leader with empty blocks (gaps) to allow network propagation, similar to PBFT with slowly-rotating leaders.
• Subprime-blocks variant: Allocates block space into high-priority (prime) and non-time-critical (subprime) tiers, decoupling execution from proposal and permitting maintainance of predictable validity for contentious transactions.

Comparison to Prior and Related Work

Gatling's rapid-fire scheduling is orthogonal to many established consensus protocol optimizations:

• Responsive protocols: Gatling does not rely on network-driven progress and is unaffected by strategic timing games that plague responsive designs.
• Fast-path/optimistic designs: It does not relax safety or resilience, unlike protocols such as Minimmit, Jolteon, or Hydrangea++.
• Multi-proposer/DAG-based/parallel Byzantine broadcast: Distinct from Narwhal, Bullshark, DAGs, and sharded consensus (Mir-BFT, ISS), Gatling eschews cross-references or transaction bucketing, instead synthesizing a single tightly coupled log from independent protocols.

The only comparable prior is Shoal++, which applies similar staggered-parallel composition, but only for DAG-based settings and does not provide closed-box guarantees or the predictable validity extensions that Gatling supports.

Implications and Future Directions

Gatling demonstrates that latency reduction in BFT atomic broadcast is not fundamentally bottlenecked by network delay; with sufficient hardware and reliability, transaction latency can approach confirmation time via parallel composition. This reframes prior assumptions on the inter-proposal interval floor and highlights the limited utility of further optimizing single-instance consensus.

Practically, Gatling enables blockchains to achieve ultra-low latency with commodity consensus components, and is compatible with further pipelining, speculative, or fast-path optimizations layered onto the base protocol. The framework provides a new direction for the construction of scalable, low-latency, and fair block production schedules.

Future research avenues include:

• Adaptive $\Delta$8 tuning given real-time reliability metrics
• Refined deduplication and goodput optimization strategies
• Incentive-compatible scheduling in the face of proposers' MEV-driven strategic behavior
• Further exploration of compatibility with stateful applications requiring predictable validity

Conclusion

Gatling provides a theoretically rigorous and practically validated path to sub-network delay consensus by composition, demonstrating that parallel instance scheduling, rather than further protocol micro-optimization, is the key lever for reducing transaction latency in BFT replicated state machines. This result has substantial implications for both protocol design and the architecture of high-performance blockchains.