Skip to content
Crypto.world

Research

RegionFence: Adaptive Concurrency Control for Blockchain Parallel Transaction Execution

Offers a contended-key region abstraction for adaptive concurrency control, a plausible route to higher parallel-execution throughput if the VLDB evaluation holds and code appears.

RegionFence: Adaptive Concurrency Control for Blockchain Parallel Transaction Execution
arXiv
2611.02164
Published
2026-11-01
Authors
Jiaying Feng, Linpeng Jia, Yi Sun

AI summary

Overview

Research area: Distributed systems and blockchain infrastructure, specifically parallel transaction execution and concurrency control for smart-contract blockchains.

Technical level: Advanced. The paper assumes familiarity with optimistic and pessimistic concurrency control, multi-version stores, serializability, and EVM execution.

One-sentence scope: RegionFence is an adaptive, conflict-level concurrency control mechanism that lets a blockchain node execute ordered blocks in parallel while producing exactly the same state and receipts as sequential execution, implemented and evaluated in go-ethereum on real Ethereum mainnet traces.

What This Paper Is About

Blockchain clients must execute transactions in the exact order consensus fixed, so parallel execution has to reproduce the serial result. Existing engines pick one policy for a whole block — optimistic (OCC, which re-executes conflicting transactions) or pessimistic (PCC, which delays them) — so every conflict either wastes work or idles cores. The paper asks whether control can instead be applied only to the small part of a transaction that actually touches a contended key, with the choice of waiting or proceeding decided online, per conflict, from measured costs and learned conflict patterns.

Key Contributions

  1. Regions as the unit of control. A region is the span of a transaction from its first read of a contended key to its last write to that key (or to the transaction's end if it never writes). Concurrency control acts only at the two ends of a region, so non-conflicting accesses need no coordination, and a region ends at the writer's last write rather than at its commit.
  2. Fences and releases. A fence decides at the start of a region whether a read proceeds on the visible version or waits for predicted writers, using a cost-based threshold. At the end of a region a writer may release its value early to waiting readers, and an aborted writer labels each key it wrote as failed, rewrite, or tentative to limit cascading aborts. The authors prove the serial result (Theorem 1) and termination (Theorem 2), and show both hold for any mixture of policies within a block (Corollary 1).
  3. Intra-block and inter-block online learning. Conflict profiles predict likely writers of a contended key from features known before execution — contract, function, and address arguments — learned from read and write sets revealed at run time, without declared access sets, static analysis, or offline training. Learning runs at two time scales, and inter-block learning also sizes the window of blocks executed together.
  4. Implementation and evaluation. RegionFence is implemented in go-ethereum alongside OCC (Block-STM) and PCC (runtime locking) baselines, evaluated on purpose-built synthetic blockchain workloads rather than database benchmarks such as TPC-C and SmallBank, plus replay of real Ethereum mainnet blocks from nine traces spanning the past five years.

Main Findings

  • Overall speedup: RegionFence achieves an overall speedup of 9.2× over single-core execution on 64 cores.
  • Against OCC and PCC: It outperforms OCC by 2.9–5.4× and PCC by 3.9–9.4× in speedup across the evaluated periods.
  • Conflicts touch only part of a transaction: The reader's first access to a dependent key occurs at a median of 35% of its execution, and the writer's last write at 72%, so transaction-level control delays unrelated work.
  • Conflicts concentrate on few keys: About half of a block's transactions conflict with no other transaction, while the ten hottest keys account for 46%–72% of its dependencies — meaning speculation and blocking must coexist within a block.
  • Conflicts recur but are poorly attributed by coarse features: 79%–92% of a block's dependencies involve keys that already carried a dependency in the previous 50 blocks, yet contract and function selector identify only 7%–51% of the active storage writers at a read.
  • Parallelism lies across blocks: Dependency width has a median of 3.15 and reaches only 4.77 with W = 32 concurrent blocks, whereas the region-level bound reaches 12.26.
  • Correctness is decoupled from policy: Because scheduling is separated from certification in block order, mispredictions (a superfluous wait, an early release, or a missed constraint) affect performance but not correctness.
  • Mainnet traces used: Nine traces (A–I) of 100 consecutive blocks each, from block 12,499,900 (2021-05-24, 20,171 txs) to block 26,060,700 (2026-09-26, 23,260 txs).

Methodology in Plain English

The authors first characterize how conflicts actually behave on Ethereum mainnet. They replay recorded blocks on their pre-states, derive dependencies from the recorded read and write sets, and note where inside a transaction each conflicting access falls. That measurement motivates the design: control must be finer than a transaction, must let speculation and blocking coexist, must learn writers from fine features, and must span blocks.

They then build the mechanism around three ideas. A region narrows control to the part of a transaction that touches a contended key. A fence compares two expected costs — the delay from waiting on a writer that turns out not to write the key, versus the re-execution from proceeding past one that does — using a probability learned per key and a threshold measured at run time in wall-clock time, weighted by how idle the cores are. A release lets a writer expose its value as soon as it makes its last write to the key, rather than waiting to commit, but only if a reader is actually waiting and the write is likely final.

Learning supplies the probabilities. Conflict profiles track, per contended key, which earlier transactions are likely to write it, using features available before the transaction runs. Intra-block learning reacts to conflicts as they appear; inter-block learning accumulates what recurs across blocks and decides how many blocks to admit into the execution window. Correctness is kept separate: transactions commit in block order under a single certification rule, so any mixture of waits, releases, and speculation still yields the serial result.

Why This Matters

Impact on research. Database systems have explored hybrid and adaptive concurrency control, but those designs assume the system can choose its own serialization order, that access sets are known, or that offline training applies. Blockchains break all three assumptions. RegionFence shows how to move adaptive control into a setting where the order is fixed before execution and accesses emerge only at run time, and it does so with a proof that arbitrary policy mixtures remain correct.

Real-world applications:

  • Decentralized exchange and AMM traffic. The paper's running example is a swap that updates pool reserves; a handful of pool keys concentrate conflicts, which is exactly the case regions and fences target.
  • Ethereum execution clients. The implementation lives in go-ethereum, so the technique is directly applicable to nodes that currently execute blocks sequentially and leave cores idle.
  • High-throughput and modular chains. Any chain whose bottleneck has shifted from consensus ordering to transaction execution can use the approach without changing consensus, contracts, or the state format.
  • Block builders and validators. Any party that must execute an already-ordered block and reproduce the exact serial state and receipts benefits from faster replay.

Industry relevance. The mechanism requires no contract rewrites and no declared access lists, which matters for public chains with open, evolving contract workloads. It also degrades gracefully: wrong predictions cost time, not correctness.

Future Directions

  • Richer prediction features. Contract and function selector identify only 7%–51% of active storage writers, so improving conflict profiles with finer features — or with address arguments and other pre-execution signals — is an open lever.
  • Better last-write and abort prediction. The release decision rests on estimating whether a write is the writer's last and whether its incarnation survives; more accurate estimates would reduce unnecessary invalidation and re-execution.
  • Window sizing across workloads. Inter-block learning currently sizes the number of concurrent blocks; how that width should adapt to rapidly changing contract populations, and how far it can scale, remains open.
  • Generalization beyond Ethereum. Testing on chains with declared access sets or object models, and combining regions with hardware acceleration or semantic conflict elimination, are natural extensions.

Target Audience

Blockchain client and infrastructure engineers working on execution-layer performance; distributed-systems researchers interested in concurrency control under a preset serialization order; and graduate students or advanced practitioners who already understand OCC, PCC, multi-version storage, and EVM semantics and want to see how adaptive, conflict-level control can be made both practical and provably correct.

Authors’ abstract

Smart contracts have turned blockchains into general platforms, and their throughput is increasingly limited by transaction execution. Parallel execution can relieve this bottleneck. However, most existing engines apply a single policy within a block, typically optimistic (OCC) or pessimistic (PCC) concurrency control, and thus re-execute or delay whole transactions. Although some database studies have proposed hybrid and adaptive mechanisms, these mechanisms cannot be…

The full abstract on arXiv
Read the original paper