betaFeedback

WorksComputer Science

RegionFence: Adaptive Concurrency Control for Blockchain Parallel Transaction Execution

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 applied directly to blockchains because the block fixes the serial order, accesses emerge only at run time, and real workloads vary widely. We propose RegionFence, an adaptive concurrency control mechanism for blockchain parallel transaction execution, based on three key designs. First, we propose regions to refine the granularity of control from whole transactions to the parts that touch contended keys. Second, we design fences to decide at run time how each region handles a conflict. Third, we introduce intra-block and inter-block online learning to anticipate likely conflicts. At the same time, the system still produces the same result as serial execution in consensus order. We implement RegionFence in go-ethereum and evaluate it on real Ethereum mainnet blocks from different periods of the past five years. Experimental results show that RegionFence achieves an overall speedup of 9.2x over single-core execution on 64 cores and outperforms OCC by 2.9-5.4x and PCC by 3.9-9.4x in speedup across these periods.

Code Availability: Code and artifacts are available at https://github.com/ictbc-feng/RegionFence.

Introduction

Blockchains have evolved from ledgers of simple payments [1] into general platforms. With smart contracts [2], they now host token exchanges, lending markets, and a growing range of other applications. These platforms order transactions into blocks and then execute them, and each transaction runs contract code that reads and writes keys of a shared state. As consensus protocols have grown faster, the throughput of these blockchains is increasingly limited by transaction execution rather than by ordering [3, 4, 5]. Parallel execution is the established remedy for this bottleneck, as multi-core databases have shown at up to thousands of cores [6, 7, 8, 9]. However, many blockchain clients still execute the transactions of a block sequentially and leave the available cores unused [4, 10]. Moving these clients to parallel execution must preserve what sequential execution guarantees.

A blockchain is a replicated system: every node executes the blocks that consensus has ordered, and all nodes must arrive at the same states and receipts. Parallel execution must therefore produce the serial result, which consists of the states and receipts of executing the transactions sequentially in block order. This requirement is deterministic serializability with a preset serialization order [3, 4, 5, 11].

Existing parallel engines meet this requirement with optimistic or pessimistic concurrency control (OCC or PCC). OCC executes transactions speculatively, validates them in block order, and re-executes those that read stale values [3, 4, 5]. PCC instead serializes conflicting transactions, usually based on access sets known in advance [12, 13, 14]. A conflict therefore incurs wasted work under OCC and idle cores under PCC.

Figure 1 illustrates both costs with an example. Consider a block that contains transactions T1T_1 to T5T_5 of a decentralized exchange, where a swap trades tokens by updating the reserves of a pool. $T_1 is a price-feed update that reads key kPk_P, which stores the reserves of a popular pool PP. T2T_2 and T3T_3 are swaps routed through two pools. T2T_2 trades in P and then in a quiet pool, while T3T_3 trades in another quiet pool and then in P, so T3T_3 reads the value of kPk_P that T2T_2 writes. T4T_4 and T5T_5 are unrelated token transfers.

OCC runs T2T_2 and T3T_3 concurrently without waiting, so T3T_3 reads kPk_P before T2T_2 has written it. When T3T_3 is validated, kPk_P has changed since its read, so the engine aborts T3T_3 and re-executes it from the start (Figure 1(a)). PCC avoids this abort, but T1T_1, T2T_2, and T3T_3 all access kPk_P, so they run one after another while other cores remain idle (Figure 1(b)).

Figure 1. Example schedules of one block on three cores. T3T_3 depends on T2T_2 only through the hot key kpk_p: (a) OCC re-executes T3T_3, (b) PCC delays it, and (c) RegionFence resumes it at T2T_2’s last write.

In this example, both costs are unnecessary because T3T_3 needs only the value that T2T_2 writes to kPk_P. T3T_3 could execute its first hop concurrently with T2T_2, wait at its read of kPk_P, and resume once T2T_2 completes its last write, even though T2T_2 has not finished (Figure 1(c)). Neither family produces this schedule because most engines apply one policy to a whole block [5].

Recent blockchain studies reduce the cost of a conflict by re-executing only the operations or subtransactions it affects [4, 11, 15]. Others shorten execution with hardware acceleration [16, 17], and permissioned systems gain flexibility from reordering transactions or switching architectures [18, 19, 20]. These approaches lower the cost of conflicts and of execution, but how a public blockchain should handle each conflict during execution remains largely open.

Database research offers a starting point for this question, as it has explored more flexible concurrency control. Some studies combine multiple policies at finer granularities [21, 22, 23, 24, 25, 26, 27], some adapt to contention or the workload at run time [28, 29, 30], and others make writes visible before transactions finish [31, 32, 33]. However, these designs are difficult to adopt directly because blockchain execution differs from database transaction processing in three respects. First, the block fixes the serial order before execution, which leaves little room for techniques that choose the order at run time [22, 34]. Second, accesses emerge only at run time, so policies built on known access sets [35, 36], transaction types [24], or offline training [27] become less effective. Third, the actual workloads of mainstream blockchains are complex within a transaction, within a block, and across blocks, so a policy tuned for one case rarely fits another (§ 2.2).

These differences call for adaptive concurrency control designed for blockchain parallel transaction execution. Such a mechanism should produce such schedules on real workloads, and building it raises three challenges.

Challenge 1: granularity of control. A conflict involves only part of a transaction, so controlling an entire transaction delays operations that conflict with no other transaction. Conversely, controlling every access imposes overhead on the many accesses that never conflict.

Challenge 2: selection and composition of policies. A conflict can be resolved in several ways, and the most effective choice depends on costs that vary with the workload and the number of cores. Moreover, transactions under different policies coexist within a block and may read uncommitted values, yet they must remain free of deadlocks, limit cascading aborts, and still produce the serial result.

Challenge 3: online prediction of conflicts. A wait is beneficial only if it precedes the conflicting access, so the engine must anticipate which transactions will conflict. Such knowledge is rarely available in advance for open and evolving contract workloads, and it must therefore be acquired during block execution at low overhead. The same applies to how many blocks can usefully execute together.

To address these challenges, we control a transaction only where it touches a contended key, decide each wait from costs measured online, and learn conflicts from execution itself. We realize these ideas in RegionFence, an adaptive concurrency control mechanism for blockchain parallel transaction execution. This paper makes the following contributions:

  • Regions. We introduce the region as the unit of concurrency control. A region is the part of a transaction between its first read of a contended key and its last write to it. Concurrency control acts only at the two ends, so accesses that never conflict need no coordination during execution (§ 4.1).

  • Fences. We design fences that decide at the start of a region whether a read proceeds or waits for predicted writers. At the end of a region, a writer exposes its value early to waiting readers if the write is likely final, and an aborted writer marks the keys it wrote by how likely their values are to change. We prove that these decisions preserve the serial result and guarantee termination (§ 4.2).

  • Intra-block and inter-block online learning. We design conflict profiles that predict the likely writers of a contended key from features known before a transaction runs, such as its contract, function, and address arguments. They learn from the read and write sets that execution reveals, without declared access sets, static analysis, or offline training. Some contended keys are new to a block and others recur across blocks, so learning runs at two time scales. Intra-block learning reacts to conflicts as soon as they appear, and inter-block learning accumulates what recurs and sizes a window of blocks that execute together (§ 5).

  • Implementation and evaluation. We implement RegionFence in go-ethereum, along with the OCC (Block-STM) and PCC (runtime locking) baselines (§ 6.1). We design synthetic workloads for blockchains rather than reuse database benchmarks such as TPC-C [37] and SmallBank [38], and we replay real Ethereum mainnet blocks from different periods of the past five years (§ 6). Experimental results show that RegionFence achieves an overall speedup of 9.2× over single-core execution on 64 cores and outperforms OCC by 2.9–5.4× and PCC by 3.9–9.4× in speedup across these periods.

Background and Observations

This section reviews parallel transaction execution on blockchains and existing approaches (§ 2.1), and then characterizes mainnet workloads to derive design implications (§ 2.2).

Parallel Execution on Blockchains

A blockchain is a replicated state machine maintained by mutually distrusting nodes. Its state maps keys, namely account balances, nonces, code, and contract storage slots, to values. Consensus orders transactions into blocks, and every node executes them in block order. Each transaction invokes contract code, so its read and write sets are determined at run time and are difficult to predict before execution [11]. Because all nodes must reach identical states and receipts, a block defines a preset serialization order, and any concurrent execution must produce the serial result [3]. Sequential execution satisfies this requirement but cannot exploit multiple cores, which motivates parallel execution.

A parallel execution engine runs transactions concurrently and may execute a transaction multiple times, where each execution is an incarnation [3]. Incarnations publish their writes as versions in a multi-version store, and transactions commit in block order.

Two transactions conflict if they access the same key and at least one of the accesses is a write. Under a preset serialization order, only one of the three conflict types constrains execution. For i<ji < j, a write-after-write (WAW) conflict requires no coordination, because each transaction writes its own version and in-order commit makes the version of TjT_j the later one. A write-after-read (WAR) conflict, where TiT_i reads and TjT_j writes, also requires no coordination, because TiT_i reads only versions below ii. Only a read-after-write (RAW) conflict, where TjT_j reads what TiT_i writes, requires coordination, because TjT_j must observe the version of TiT_i.

We say that TjT_j depends on TiT_i, written Ti→TjT_i \to T_j, if TjT_j reads a key whose latest preceding writer is TiT_i. Because dependencies follow block order, they cannot form cycles, unlike those in a database that determines its own serialization order. Concurrency control therefore reduces to one question: how a reader should proceed when an earlier writer of the same key has not finished. We call such a key contended.

Optimistic concurrency control (OCC) [42] allows the reader to proceed and corrects the outcome afterwards. Transactions execute speculatively on the latest visible versions, validation in block order detects stale reads, and the affected transactions re-execute. In Block-STM [3], the writes of an aborted incarnation are marked as estimates, and a reader that encounters an estimate aborts and restarts after the writer’s next incarnation finishes. Later systems reduce the cost of repair: ParallelEVM [4] re-executes only the affected operations, Spectrum [11] rolls back to the conflicting read, and Reddio [43] defers conflicting transactions to a later batch. In all of these systems, a conflict is detected only after speculative work has been performed.

Pessimistic concurrency control (PCC) instead blocks the reader by ordering conflicting transactions in advance. Following deterministic concurrency control [35, 36], Sealevel [12] and Sui Lutris [13] schedule transactions from declared accounts or objects, ParBlockchain [14] from known read and write sets, dBTM [10] from conflict specifications, and MTPU [16] from a dependency graph, and other designs let validators replay a miner’s schedule [44, 45]. Runtime locking, in contrast, acquires locks at each access and releases them at commit in block order. These designs serialize conflicting transactions in their entirety, which delays non-conflicting operations, and schedules fixed in advance require access information that smart contracts rarely expose.

Between these two extremes, some systems use partial information to decide which reads wait. Spectrum blocks reads of hot keys until writers in pre-acquired sets reach final commit, NEMO [5] extends Block-STM with static hints and priorities, and DMVCC [46] exposes writes once program analysis shows that no abortable statement remains. This information must still be obtained before execution, and apart from DMVCC, readers are held until the writer commits or passes validation.

Other systems prevent such conflicts from arising. Permissioned systems and block builders reorder or recompose blocks [15, 18, 19, 41, 47, 48, 49], which validators of an already ordered block cannot do. Semantic approaches eliminate specific classes of conflicts [39, 40, 50], often by rewriting contracts, but other read-modify-write conflicts remain. AdaChain [20] learns a system-wide architecture for permissioned blockchains, a decision much coarser than a single conflict.

Table 1 compares representative systems, which leave three limitations. Most systems decide per block, transaction, or architecture rather than per conflict. Readers typically wait until a writer finishes or commits, even when its last write to the key occurs much earlier. Waits also rely on access information supplied before execution rather than learned from it.

SystemControl unitConflict informationDecision timeWait condition
Block-STM [3]TransactionWrites of aborted incarnationsUpon abortWriter re-execution
ParallelEVM [4]OperationNoneValidation phaseNone
Sui Lutris [13]Object versionDeclared objectsBefore executionCompletion of earlier versions
Spectrum [11]Hot-key readPartial pre-acquired setsBefore executionFinal commit of writers
OCToPus [39]Atomic operationTransfer semanticsUpon insufficient fundsSerial fallback
Crystality [40]Function fragmentProgrammer-defined scopesDevelopment timeNone
Fabric++ [19]TransactionSimulated read and write setsOrdering phaseNone
NeuChain [41]TransactionReserve tableEpoch endNone
Loom [15]SubtransactionBlock pre-executionAfter pre-executionConflicting subtransactions
AdaChain [20]Entire systemWorkload features, throughputPer episodeDetermined by architecture
RegionFenceRegion on a contended keyLearned from executionRun time, at region startWriter’s last write

Table 1. Representative parallel execution systems. Control unit: the scope of one decision.

Observations on Mainnet Workloads

Whether these limitations matter in practice depends on real-world workloads, which prior studies show to be complex [15, 16, 20]. We therefore characterize how conflicts arise within a transaction, within a block, and across blocks. We replay Ethereum mainnet blocks on their recorded pre-states, derive dependencies from the recorded read and write sets, and locate each access by the fraction of instructions executed before it. Table 2 lists the nine traces used in both the measurements and the evaluation. We consider accesses to storage slots, account balances, and nonces, excluding those of the beneficiary, and only writes that change a value.

TraceFirst blockDateTxs
A12,499,9002021-05-2420,171
B13,809,9002021-12-1517,167
C14,500,0002022-04-0116,810
D14,999,9002022-06-2118,408
E16,619,9002023-02-1315,308
F17,873,6002023-08-0814,968
G20,079,9002024-06-1317,011
H22,449,9002025-05-1018,232
I26,060,7002026-09-2623,260

Table 2. Mainnet traces of 100 consecutive blocks each, oldest to newest.

Observation 1: conflicts cover only part of a transaction. A dependency constrains only a span of the reader’s and the writer’s execution, and their other operations are unaffected by it. For example, the reader’s first access to the key occurs at a median of 35% of its execution and the writer’s last write at 72% (Figure 2(a)). Transaction-level control therefore delays unrelated operations, so control must be finer-grained.

Figure 2. Workload measurements on the traces of Table 2: (a) positions of the reader’s first access and the writer’s last write, (b) conflict-free transactions and dependencies on hot keys, (c) recurring keys and writers identified by contract and function, and (d) dependency width as WW grows. Panel (c) uses blocks 50–99 for recurrence and blocks 20–99 for writers, with 128 transactions in flight, and (d) includes every account load.

Observation 2: conflicts are concentrated on a few keys. Within a block, many independent transactions coexist with a few hot keys that attract most conflicts. For example, about half of a block’s transactions conflict with no other transaction, and the ten hottest keys account for 46%–72% of its dependencies (Figure 2(b)). A single policy suits only one of these two groups, so speculation and blocking must coexist within a block.

Observation 3: conflicts recur but are hard to attribute. Contended keys recur across blocks, which makes conflicts learnable, but new keys continue to emerge and coarse-grained information does not identify their writers. For example, 79%–92% of a block’s dependencies involve keys that carried a dependency in the previous 50 blocks, whereas the contract and function selector identify only 7%–51% of the active storage writers at a read (Figure 2(c)). Writers should therefore be predicted from finer features, learned online within and across blocks.

Observation 4: parallelism lies across blocks. A single block offers limited parallelism, and executing blocks concurrently exposes more of it only if reads wait for the correct writers. For example, the dependency width of a trace, its total execution time divided by the summed critical-path lengths of its blocks, has a median of 3.15 and reaches only 4.77 with W=32W = 32 concurrent blocks, whereas the region-level bound reaches 12.26 (Figure 2(d)). Execution should therefore span blocks, and the number of concurrent blocks must be determined online.

RegionFence Overview

RegionFence is a conflict-level concurrency control mechanism: it takes each conflict, rather than a transaction or a block, as the unit of decision. It replaces sequential execution on a node: it executes the transactions of blocks ordered by consensus in parallel and produces the same state and receipts, so consensus, contracts, and the state format remain unchanged. Because a node replays blocks that are already ordered, RegionFence cannot reorder or drop transactions, and all of its control lies in the timing of reads.

Core Abstractions. RegionFence builds a schedule from three abstractions: regions, fences, and releases. A region defines what is controlled: the span of a transaction that a dependency constrains, a unit of control between an operation and a transaction. A fence defines how it is controlled: an ordering constraint, established at run time, between a reader and a predicted writer. A release defines when control ends: the constraint dissolves at the writer’s last write to the key rather than at its commit. A schedule is thus the result of ordering constraints that are established and removed during execution. Certification at commit is separate from these constraints: it checks every transaction in block order, so any combination of constraints is safe, and wrong estimates cannot affect the result.

System Architecture. RegionFence consists of five components, shown in Figure 3. The execution window admits the next WW blocks for concurrent execution. The workers execute transactions under region control and suspend a transaction that must wait, so that a blocked transaction does not occupy a core. They serve the lowest-indexed ready transaction first, so the commit frontier always progresses. The multi-version store holds the versions of each key together with their registered readers. Blocks in the window form one transaction sequence, so a transaction may read a version written by an uncommitted transaction of an earlier block. The committer certifies transactions in block order and commits them. The learning module maintains conflict profiles, which estimate the likely writers of each contended key, and the window width.

Figure 3. RegionFence workflow on the running example. Numbered steps follow one block, in which T3T_3 waits at its first read of the hot key kPk_P until T2T_2’s last write to it.

The components interact through a control path, a data path, and a feedback path. On the control path, a transaction consults the conflict profile of a key at a fence and decides whether to proceed or to wait. Writers and aborted transactions make the corresponding decisions, namely whether to release a value and whether their versions stay visible. On the data path, transactions publish their writes to the store, which wakes waiting readers and invalidates registered readers of changed versions. On the feedback path, finished incarnations and measured costs flow to the learning module.

Transaction Lifecycle. The lifecycle of a transaction consists of six steps, illustrated here on the block of Figure 1. ① The execution window admits the next WW blocks. ② Workers execute the transactions: T1T_1, T4T_4, and T5T_5 proceed without waiting, and T3T_3 completes its swap through pool Y. ③ When T3T_3 first reads kPk_P, it enters a region, and its fence consults the conflict profile of kPk_P. The profile identifies T2T_2 as a likely writer, so the fence orders T3T_3 after T2T_2, and T3T_3 suspends and frees its worker, which then executes T5T_5.

The remaining steps release the reader, commit the transactions, and return evidence to the learning module. ④ Because T3T_3 is waiting, T2T_2 releases kPk_P immediately after its last write to it. T3T_3 resumes while T2T_2 is still executing its swap through pool X, and T2T_2 publishes its remaining writes when it finishes. ⑤ The committer certifies each transaction in block order and commits it, and an incarnation that fails certification re-executes. ⑥ Finished incarnations reveal which keys they wrote, invalidations reveal which keys are contended, and waits and re-executions reveal what they cost. RegionFence feeds this evidence into the conflict profiles, its cost estimates, and the window width, so that later decisions follow the workload.

Handling Mispredictions. RegionFence handles three kinds of constraint error. A superfluous constraint, on a predicted writer that does not write the key, delays the reader until that writer finishes and lowers the estimate behind it. A constraint removed too early, by the release of a value that later changes, invalidates the readers of that value, which re-execute. A missing constraint, on a writer that was not predicted, is detected when the writer publishes, which invalidates the registered readers and adds the key to the contended set. These errors therefore affect performance but not correctness.

Regions and Fences

This section presents regions, fences, and releases, the mechanisms that control a conflict, and proves their correctness. Regions address Challenge 1 (§ 4.1), and fences and their composition address Challenge 2 (§ 4.2 and § 4.3).

Region Model

Region Definition. A region is the part of a transaction that a dependency constraints. We model a transaction as a sequence of observations and writes on a key-value state, where an observation is an access whose outcome depends on the value of a key. Observations determine a transaction’s writes and result, so a schedule produces the serial result if every observation returns what it returns in serial execution [51]. A dependency Ti→TjT_i \to T_j through key kk therefore constrains exactly one pair of points: TjT_j must observe kk after the last write of TiT_i to it. All other parts of the two transactions may overlap.

RegionFence confines concurrency control to the two ends of each region. A transaction has one region for each contended key it observes, which extends from its first observation of the key to its last write to the key, or to its end if it never writes the key. Whereas two-phase locking holds a key until commit, a region ends at the last write. A transaction makes decisions only at the ends of its regions and is unconstrained outside them.

Contended Key Detection. RegionFence infers contended keys from conflicts rather than from access frequency. A frequently read key need not be contended, because its reads may rarely precede an earlier writer’s publication. A key joins the set KcK_c of contended keys the first time an earlier writer invalidates a read of it. The other keys of the same object that the writer changed join as well, because a contended object rarely occupies one key.

Only reads of keys in KcK_c pass through a fence, with one exception for re-executed transactions. The failure of such a transaction is direct evidence: its read of a key on which an earlier incarnation failed, or of a version from an uncommitted writer, also enters a region. Accesses that never conflict therefore incur no coordination.

Region Entry. A region starts at a transaction’s first observation of a key. An access is an observation only if the transaction’s outcome depends on the value it returns, so many conflicts between reads and writes impose no constraint.

RegionFence excludes three classes of accesses from regions through semantic concurrency control. Independent fields of an object are separate keys, so an access to one does not conflict with a write to another. An update to a value that the transaction does not read is a commutative update, applied in block order [39, 50]. A predicate read observes only its outcome, which is re-evaluated at commit, so it conflicts only if the outcome changes [50]. § 6.1 maps these classes to the EVM.

Region Exit. A region ends at the writer’s last write, where a release exposes the value to readers. The value is then final for the writer’s incarnation, so a reader need not wait for the writer to finish. A release is a form of early write visibility, as in early lock release and Bamboo [31]. However, a writer cannot determine whether a write is its last, and its incarnation may still abort. The end of a region is therefore a prediction, which § 4.2 treats as a decision.

Fence Protocol

Cost Model. RegionFence makes every decision at a region with one cost-based rule. Each decision determines whether a transaction should read an uncommitted version or wait for it. OCC and PCC fix this choice for a whole block, whereas RegionFence makes it for each conflict.

The rule applies at three points in the life of a transaction. At the start of a region, an earlier writer may not have written the key yet, so the reader can proceed on the visible version or wait for that writer. At the end of a region, the writer may write the key again or abort, so it can release the value or hold it until it publishes. After an abort, the next incarnation may change the versions of the aborted one, so readers can proceed on them or wait for that incarnation. At each point, one choice risks a re-execution and the other a delay.

The rule compares the expected costs of the two possible errors. Consider an event of estimated probability π\pi, such as a predicted writer writing the key. Acting on the event costs AA if it does not occur, and not acting costs BB if it does. Comparing the expected costs (1−π)A(1-\pi)A and πB\pi B, acting is beneficial when

π≥τ=AA+B.(1)\pi\ge\tau= \frac{A}{A+B}. \tag*{(1)}

The rule combines a probability from learning with a threshold from run-time measurements. The probability π\pi depends on the key (§ 5), whereas the threshold τ\tau depends on the machine and the workload, so RegionFence measures AA and BB in time during execution. Delays are weighted by uu, the idle share of worker time: while other work occupies the cores a delay costs little, and while they idle it costs nearly its duration. A needless invalidation is weighted by 1−u1-u instead, because a re-execution consumes processors only while they are busy. Because τ\tau follows these measurements, the choice adapts to the workload and the number of cores.

Read Fences. A fence decides whether a transaction entering a region proceeds or waits (Algorithm 1). In the algorithm, Tmin⁡T_{\min} is the commit frontier, the lowest uncommitted transaction, and vis⁡j(k)\operatorname{vis}_j(k) is the value that a read of kk by TjT_j returns: the latest version published below jj in the block of TjT_j, else the value set by the state changes Γb\Gamma_b applied at the start of that block bb, else the latest earlier version.

The fence decides whom to wait for and whether waiting is beneficial. For the first part, it asks the conflict profile of kk for predicted writers, namely unfinished earlier transactions that are likely to write kk (§ 5.1), each with an estimate p^k\hat p_k (line 5). For the second part, (1) compares two errors. Waiting for a transaction that does not write kk loses cwc_w, and proceeding past one that does loses crc_r to a re-execution. Thus TjT_j waits for a predicted writer if p^k≥p∗\hat p_k \ge p^*, where p∗=ucw/(ucw+cr)p^* = u c_w/(u c_w+c_r) (line 7).

Algorithm 1 Fence: a reader at the start of a region
1: function Fence(TjT_j, kk)TjT_j starts a region on kk
2: if kk is globally written then
3: wait until Tj=Tmin⁡T_j = T_{\min}
4: else
5: C←C \leftarrow the nearest predicted writers of kk below jj§5.1
6: for Ti∈CT_i \in C, nearest first do
7: if TiT_i is unfinished and p^k(Ti)≥p∗\hat p_k(T_i) \ge p^* then
8: yield until TiT_i releases or publishes kk, or finishes
9: if TiT_i wrote kk then break
10: lower the feature that predicted TiT_i ▷ unnecessary wait
11: v←vis⁡j(k)v \leftarrow\operatorname{vis}_j(k)▷ waits if the version is labelled
12: if some Ti<jT_i < j, is unfinished then register TjT_j on vv
13: return vv

Table 1 (PDF p. 6).

Algorithm 2 Release and recovery: a writer
1: function OnWrite(TiT_i, kk, mm)▷ mm-th write of k∈Kck \in K_c
2: if the write changes kk and q^k(m)≥θ\hat q_k(m) \ge\theta then
3: if a reader waits for TiT_i then
4: release kk: publish its value, wake the readers
5: else
6: hold it; release it once a reader waits
7: function OnAbort(TiT_i)
8: for each key kk that TiT_i wrote do
9: if kk failed or rewrites, and r^k\hat r_k reaches its threshold then
10: label kk failed or rewrite: readers wait
11: if r^k\hat r_k is high enough then invalidate its readers
12: else
13: leave kk tentative: readers proceed

Table 2 (PDF p. 6).

A fence examines predicted writers in order of proximity. TjT_j visits them from nearest to farthest, because the nearest writer’s value is the one it will read. It stops at the first that wrote kk, and an unnecessary wait lowers the estimate of the feature that predicted the writer within this fence (lines 9–10). If no wait is warranted, TjT_j proceeds: it reads the visible version and, while some earlier transaction is unfinished, registers as a reader of that version, so that a later change invalidates it. A globally written key, which nearly every earlier transaction writes, rarely has a stable version before the frontier, so a read of it waits until TjT_j reaches the commit frontier (line 3).

Early Release. A writer applies the same rule to decide whether to release a value. When TiT_i writes kk for the mm-th time, it does not know whether the write is final. A release fails if TiT_i writes kk again or its incarnation aborts, and in either case the readers re-execute. Let GG be the time a release saves waiting readers if the value is final, LL the time they lose if it is not, and oo the writer’s own cost. With q^k(m)\hat q_k(m) the estimated probability that this write is the last, and η\eta the fraction of releases whose incarnation survives, (1) becomes

q^k(m)≥θ=L+o(L+G)η.(2)\hat q_k(m) \ge\theta= \frac{L+o}{(L+G)\eta}. \tag*{(2)}

RegionFence performs releases on demand, because a release has value only for readers that need it (Algorithm 2, lines 3–6). The writer releases immediately if a reader waits. Otherwise, it holds that the value, sends it at a later access once a reader waits, and discards it if it writes the key again.

Cascading Abort Control. RegionFence limits cascading aborts with version states. Releases expose uncommitted values, so schedules are recoverable but do not avoid cascading aborts [51]. An invalidated incarnation re-executes from the start, but the versions it wrote remain. Hiding them blocks later readers unnecessarily if the values do not change, whereas exposing them propagates the abort if they do. When TiT_i aborts, it therefore assigns each key it wrote one of three version states (lines 9–13). Readers wait for the next incarnation on a failed key, the written key on which a publication invalidated the incarnation, and on a rewrite key, whose versions from aborted incarnations usually differ from the committed ones. Any other key is tentative: its version stays visible and readers proceed on it, so they remain valid if the next incarnation writes the same value.

Two further mechanisms handle readers that have already read such a version. Without intervention, earlier readers of such a version would abort one at a time along a dependency chain, so an abort invalidates them immediately when the key is likely to change (line 11). A key that most transactions read and write forms a chain in which a finished writer may depend on a stale read. Before observing such a key, TiT_i follows the writers’ reads of it, invalidates a writer whose read has changed, and waits for it to finish.

Correctness

RegionFence mixes multiple policies within one block: one read may wait for a predicted writer, another may read a released value, and a third may proceed on the version of an unfinished transaction. We show that every such mixture produces the serial result and terminates.

We assume that a transaction is deterministic in its observations, so that they determine its writes and receipt, and that every execution terminates, even on an inconsistent state. Let T1,T2,…T_1,T_2,\ldots be the transactions of consecutive blocks, and let σj\sigma_j and ρj\rho_j be the state and receipt after TjT_j in serial execution. Correctness is independent of the policy applied to each conflict, because RegionFence separates scheduling from certification. Every transaction is subject to one certification rule [3, 11, 52]: a transaction may commit only if every observation it made equals the same observation on the committed state at its commit point. Forward validation keeps registered reads current, and backward validation checks every other observation against the committed state. Because commits follow block order, reads of released values remain recoverable, and execution needs no consistent state (no opacity).

Theorem 1 (Serial result). The committed states and receipts are the serial result.

Proof sketch. The proof is by induction on jj. Once T1,…,Tj−1T_1,\ldots,T_{j-1} have committed with state σj−1\sigma_{j-1}, every version below jj is committed and no longer changes. The certification rule requires the observations of TjT_j to equal those on σj−1\sigma_{j-1}, so by determinism TjT_j produces the writes and receipt of serial execution, which yields σj\sigma_j and ρj\rho_j.

Theorem 2 (Progress). The waits-for graph is acyclic, and every transaction commits.

Proof sketch. Every wait targets a lower index or the commit frontier, so the waits-for graph is acyclic. The frontier transaction Tmin⁡T_{\min} therefore cannot wait indefinitely, and it is scheduled first. Because it observes only committed values, which are stable, it passes certification, and the frontier advances. □

Corollary 1 (Policy composition). Theorems 1 and 2 hold for every mixture of policies within a block, that is, for every contended set, fence action, threshold, release, version state, estimate, and window width W≥1W \ge1, so nodes whose estimates differ commit the same result.

The proofs rely only on the certification of every observation and on waits that target lower indices, and they make no assumption about the policy applied to a conflict.

Intra-Block and Inter-Block Learning

RegionFence estimates three probabilities during execution to address Challenge 3, the online prediction of conflicts. At a fence, the reader of a dependency is known, whereas most writers have not yet accessed the key. Let p^k(ϕ)\hat{p}_k(\phi) denote the probability that a transaction with feature ϕ\phi writes key kk, q^k(m)\hat{q}_k(m) the probability that the mm-th write of kk by an execution is its last, and r^k\hat{r}_k the probability that a version left at kk by an aborted execution changes.

These estimates constitute an online estimation problem with full-information feedback. A completed transaction reveals its write set regardless of whether a reader waited for it, so the feedback is independent of the decision. RegionFence therefore requires no exploration, in contrast to the bandit-based tuning of AdaChain [20].

RegionFence learns at two time scales, because some contended keys are new and others recur. Intra-block learning captures new conflicts (§ 5.1), and inter-block learning accumulates recurring ones (§ 5.2). The same feedback determines the number of concurrent blocks (§ 5.3). Figure 4 illustrates the three mechanisms on the running example.

Figure 4. Intra-block learning (top), inter-block learning (middle), and window adaptation (bottom) on the running example.

Intra-Block Learning

Conflict Profiles. RegionFence predicts writers from features that are available before execution and finer-grained than the invoked code. Each feature corresponds to one reason for which a transaction may write a key. Code identity captures execution paths that always update the same state, and transaction arguments capture state selected by the input. Because an argument alone is shared with transactions that only read that state, RegionFence also combines arguments with code identity. All of these features are derived from the transaction itself, so every node can compute them before execution (§ 6.1).

The running example illustrates the need for combined features. T2T_2 and T3T_3 invoke the same router, so code identity does not distinguish swaps on P from swaps on other pools, and the address of P is also an argument of readers such as the price feed T1T_1. The combination of that address with the router is largely specific to swaps on P, so it identifies T2T_2 but not T1T_1.

The conflict profile of a contended key kk stores a bounded number of writer features ϕ\phi together with their estimates p^k(ϕ)\hat{p}_k(\phi). The estimate of a transaction is the maximum over its features. Because only features can identify a writer that has not yet accessed kk, RegionFence uses them as the primary predictor and complements them with two kinds of direct evidence. Keys updated by read-modify-write are read before they are written, so an unfinished transaction that has read kk is a likely writer, with a probability given by the fraction of readers of kk that change it. An aborted transaction also provides exact evidence: its next execution treats earlier unfinished readers of the keys that invalidated it as predicted writers.

Profile Maintenance. RegionFence updates a profile as soon as evidence appears, because a key may become contended in the middle of a block. When a publication invalidates a read, the key joins KcK_c immediately, and the features of the writer enter its profile. When a transaction first finishes, it records a trial for every tracked feature it carries on each contended key, and a hit if it changed the key. Each update is visible to the next fence, so a key that becomes contended within a block can identify its subsequent writers.

Write and Abort Statistics. RegionFence derives q^k\hat{q}_k and r^k\hat{r}_k from completed and committed transactions. Each completed execution adds its number of writes to each contended key to a histogram, from which q^k(m)\hat{q}_k(m) is the fraction of executions with at least mm writes that have exactly mm writes. This estimate depends on how the code updates the key rather than on the caller. The estimate r^k\hat{r}_k is computed at commit by comparing the versions of aborted executions with the committed values, because an execution that read such a version may itself publish a transient value.

Inter-Block Learning

Cross-Block State. RegionFence retains its learned state across blocks, because contended keys largely recur. This state comprises KcK_c, the profiles, the write counts, and the change statistics. Retention introduces two problems: a key-feature pair initially has few samples, and old samples become misleading when the writers of a key change.

Empirical Priors. RegionFence addresses sparse samples with empirical Bayes shrinkage. Each observation of whether a finished transaction carrying feature ϕ\phi changed kk is a Bernoulli trial, and with hk,ϕh_{k,\phi} hits in tk,ϕt_{k,\phi} trials the estimate is

p^k(ϕ)=hk,ϕ+sμk,ϕtk,ϕ+s,(3)\hat{p}_k(\phi)=\frac{h_{k,\phi}+s\mu_{k,\phi}}{t_{k,\phi}+s}, \tag*{(3)}

the posterior mean under a prior with mean μk,ϕ\mu_{k,\phi} and fixed strength ss. The prior mean is derived from the record of ϕ\phi on other keys, shrunk toward the mean of its group, where a group is defined by the feature type and the number of transactions in the batch that carry the feature. Because the cost in (1) is linear in the probability, comparing the posterior mean with p∗p^* is the Bayes decision.

Workload Shifts. RegionFence adapts to changes in the writers of a key in two ways. It discards the evidence of a pair once a run of misses becomes statistically unlikely under the earlier hit rate, and it periodically decays the counts so that recent blocks dominate.

Adaptive Execution Window

The window width controls the degree of concurrency across blocks. Because a single block offers limited parallelism, the blocks of a window [bmin⁡,bmin⁡+W−1][b_{\min}, b_{\min}+W-1] execute concurrently while transactions commit in block order. A narrow window leaves cores idle while the next block waits, whereas a wide one causes thrashing because more transactions read stale values and re-execute. The optimal width varies with the workload, so RegionFence derives it from execution feedback.

After each block commits, RegionFence compares the benefit of one more block, Δ+\Delta^+, with the cost of the outermost block, Δ−\Delta^-. The term Δ+\Delta^+ is the worker time per worker that the window bound left idle during that block, weighted by the smoothed fraction of first executions in the outermost block that committed without re-execution. The term Δ−\Delta^- is the time for which the commit frontier waited for re-executions of those transactions, plus the slowdown and additional re-execution caused by one more block, both predicted from recent measurements.

RegionFence changes the width by at most one block after each commit. With NN blocks to execute, the width is updated as

W←{min⁡(W+1,N)if Δ+>Δ−,max⁡(W−1,1)if Δ−>Δ+,Wotherwise.(4)W \leftarrow \begin{cases} \min(W+1,N) & \text{if } \Delta^+ > \Delta^-,\\ \max(W-1,1) & \text{if } \Delta^- > \Delta^+,\\ W & \text{otherwise.} \end{cases} \tag*{(4)}

and remains unchanged when no block is left to admit beyond the window. The width persists across blocks, and the single-step adjustment prevents overshooting after a burst.

Implementation and Evaluation

This section describes the implementation of RegionFence and evaluates it with respect to three questions.

Q1: overall performance. How does RegionFence perform on real workloads?

Q2: conflict structure. Which properties of conflicts determine the benefit of RegionFence? Q3: mechanism behavior. Does each mechanism behave as designed?

Implementation

We implement RegionFence as a package in go-ethereum v1.17.6, with a replay tool for recorded mainnet blocks and generated workloads.

EVM Instantiation. The general model of Section 4 maps to the EVM as follows. Storage reads and balance reads are observations, and balance, nonce, and code are separate keys. A transfer into or out of a balance that the transaction does not read, such as the fee paid to the block beneficiary (coinbase), is a commutative update, and fees accumulate in a per-block layer. A check that a balance covers a transfer is a predicate read. While an earlier transaction of the same sender is uncommitted, the sender’s nonce is taken from the transaction and checked at commit. The beneficiary’s balance is the globally written key, and the slots of a contract form one object for contended key detection. Code identity consists of the called contract and the function selector. Transaction arguments are the aligned addresses in the calldata and in the EIP-2930 access list, and combinations pair an address or the sender with the called contract. The gas limit guarantees termination, and Γb\Gamma_b applies the non-transaction state changes of a block.

Baselines. Both baselines are separate executors in their pure forms, and they share only the EVM, field-level keys, and the deferred fee with RegionFence. Both execute one block at a time. The OCC baseline follows Block-STM [3]: transactions execute on a multi-version memory, a read of an estimate aborts the execution until the writer re-executes, and validation tasks re-check read sets by version.

The PCC baseline uses strict two-phase locking with wound-wait. A transaction acquires shared locks for reads and exclusive locks for writes, and it holds them until it commits in block order. Locks are acquired at run time because the contracts of mainnet blocks declare no access sets, which precludes deterministic scheduling [35, 36]. We choose wound-wait because deadlock detection scales poorly under contention [8, 28], whereas block order provides a natural priority that avoids deadlock.

Experimental Setup

Platform. All experiments run on a server with two 128-core AMD EPYC 9754 processors. A run on PP cores is pinned to PP physical cores of one socket, without SMT. Each configuration runs three times, and we report the median. Each trace starts with empty profiles and τ=0.5\tau= 0.5.

Workloads. We use nine mainnet traces from different periods of the past five years, replayed on their recorded pre-states, and two synthetic workloads. Database benchmarks such as TPC-C [37] and SmallBank [38] do not model contract calls that route through hot keys, so we design workloads for blockchains. ERC-20 generates token transfers under Zipf skew. DeFi-Mix combines price-feed reads of a hot pool, two-hop swaps through it, and unrelated transfers. A synthetic block holds 200 transactions, and a run executes 100 blocks. By default, DeFi-Mix directs 20% of its transactions to the hot pool, half of them writing, with 16 storage accesses per transaction and the first hot read at 20% of execution.

Metrics. We report the speedup of each system over its own single-core execution, computed as total time on one core divided by total time on PP cores, and the abort rate, the fraction of executions that abort. Aggregate results over the nine traces are based on total execution time.

Performance on Mainnet Blocks

We answer Q1 with the nine mainnet traces. RegionFence outperforms both baselines on all of them.

Workload Diversity. The nine traces span the range of mainnet workloads. Their transactions differ in composition, with multi-contract DeFi at 8%–22% and NFTs at 1%–13% (Figure 5(a)). Their median blocks have dependency widths from 2.3 to 6.3 and 43%–61% conflict-free transactions, and they fall within the dense region of the distribution of sampled mainnet blocks (Figure 5(b)). The results are therefore not specific to a particular application mix.

Figure 5. Characteristics of the nine traces: (a) transaction composition, and (b) median per-block dependency width and conflict-free share, compared with about 1,400 sampled mainnet blocks.

Speedup. RegionFence scales to 32–64 cores, whereas both baselines saturate at 8 cores (Figure 6). Over the nine traces, it reaches 9.2× at 64 cores and 8.3× at 128, whereas OCC peaks at 2.6× and PCC at 2.0×. At 64 cores, RegionFence reaches 5.5–16.0× across traces, and its speedup is 2.9–5.4× that of OCC and 3.9–9.4× that of PCC on every trace.

Abort Rate. RegionFence converts most aborts into short waits. At 64 cores, its abort rate is 7%–32% across traces, against 45%–67% for OCC and 44%–90% for PCC (Figure 7(a)). OCC does not anticipate writers, so a reader that observes a stale version discards its entire execution. PCC also aborts transactions to resolve lock conflicts, which are frequent on hot keys. RegionFence instead delays a predicted reader until the writer’s last write, which costs less than re-executing the transaction.

Figure 7. Stability at 64 cores: (a) abort rate on each trace, and (b) CDF of speedup over sliding windows of 16 blocks.

Stability. The performance gain is consistent across blocks. Over windows of 16 consecutive blocks, the median speedup is 10.6×, and 95% of the windows exceed the best window of OCC (Figure 7(b)).

Scalability Limit. Further speedup is limited mainly by the parallelism of the blocks. The dashed lines show the limit without overhead, an ideal region-level schedule of each trace with PP workers, serial transaction times, and the measured serial commit, relative to RegionFence’s single core and capped at PP. This limit reaches 92%–100% of its 128-core value at 64 cores, so speedup levels off near 64 cores on eight of the nine traces. RegionFence reaches 37%–94% of the limit at 64 cores, and the remaining gap reflects system overhead, mispredictions, and suspended transactions. At 128 cores, speedup falls by about 10% in total because of overhead.

Figure 6. Speedup on the nine traces, relative to each engine’s own single-core execution. Dashed lines show the limit without overhead (§ 6.3).

Sensitivity to Conflict Structure

Mainnet traces exhibit a mix of conflict types, so we answer Q2 with two synthetic workloads that isolate them. A conflict covers most of a transaction in ERC-20 and only part of it in DeFi-Mix, and we vary one property at a time.

Contention Intensity. The advantage of RegionFence under contention depends on how much of a transaction a conflict covers. On ERC-20 at 64 cores, RegionFence reaches 21.0–25.9× up to θ=0.6\theta= 0.6, about twice OCC, because most transactions are independent (Figure 8(a)–(Figure 8b)). The two systems perform equally at θ=0.8\theta= 0.8, and OCC outperforms RegionFence at higher skew, with 6.9× against 4.8× at θ=0.99\theta= 0.99 and no reduction in aborts. Under heavy skew, a region covers nearly an entire transfer and nearly every transfer joins a dependency chain, so waiting yields little parallelism, whereas fences and the window still incur overhead.

Figure 8. Speedup (upper rows) and abort rate (lower rows) on synthetic workloads. Dotted lines mark the DeFi-Mix defaults.

On DeFi-Mix, a region covers only part of a transaction and the remaining operations stay parallel, so RegionFence stays 1.3–2.4× ahead of OCC as the hot share grows from 0% to 100% (Figure 8(d)). Its abort rate remains near zero, whereas OCC and PCC reach 78% and 88%, because the writers of the hot key are predictable and fences wait before the conflict occurs.

Core Scaling. The advantage of RegionFence grows with the number of cores. OCC scales better at low core counts, where conflicts are rare and the overhead of RegionFence dominates. As the number of cores increases, the re-execution cost of OCC grows, and RegionFence surpasses it at 32 cores and reaches 9.1× at 64 cores, against 6.3× for OCC and 3.3× for PCC (Figure 8(c)).

Write Ratio. The advantage persists across write ratios, with RegionFence 1.3–2.5× ahead of OCC (Figure 8(e)), because the write ratio changes the number of dependencies but not the fraction of a transaction that a region covers.

Conflict Position. A later conflict shortens the region and leaves more of a transaction independent. As the first hot read moves from the start to the end of a transaction, RegionFence rises from 8.7× to 12.7×, whereas OCC and PCC remain nearly constant (Figure 8(f)), because they control whole transactions regardless of where a conflict occurs. Only region-level control converts this independent work into parallelism.

The benefit of RegionFence thus depends on the fraction of a transaction that a conflict covers. It is largest when conflicts are partial, and it diminishes when nearly every transaction joins a dependency chain.

Mechanism Analysis

To answer Q3, we replay the nine traces at 64 cores and record each decision.

Regions. Regions confine control to a small part of a transaction. Figure 9(a) shows the dependency chain on the most contended key. Although each transaction depends on its predecessor, the transactions overlap, and the first release precedes the first commit. Figure 9(b) shows that this holds in general: for hot keys released early, the median region covers 4%–17% of execution time. Dependent transactions thus overlap without re-execution, which neither OCC nor PCC achieves.

Figure 9. Regions at 64 cores: (a) timeline of the first seven transactions in the dependency chain on the most contended key, and (b) region length relative to incarnation running time, for hot keys released early (boxes: quartiles; whiskers: 5th and 95th percentiles).

Policy Mixture. Fences apply different policies within one block (Figure 10(a)). Across 2,461 keys, the share of fences that wait rises with the rate at which a predicted writer wrote the key, from about 10% in the lowest bin to about 84% in the highest. The cost rule produces this mixture without any per-key configuration.

Figure 10. Fence decisions at 64 cores: (a) per-key share of fences that waited against the rate at which a named unfinished writer wrote the key (line: bin means), and (b) decision outcomes on each trace.

Decision Quality. Most fence decisions are correct (Figure 10(b)). In total, 62% proceeded correctly and 18% waited for a writer that wrote the key. Only 2.8% waited unnecessarily, a superfluous constraint, whereas 10.6% proceeded before a writer, a missing constraint, and 7.1% aborted after a wait.

Learning Effect. Learning reduces aborts and execution time (Figure 11(a)). Without inter-block learning, the mean abort rate increases from 20% to 25%, and without learned waits, to 34%. Total execution time increases by 24% and 22%, respectively, so predictions directly affect performance.

Figure 11. Learning at 64 cores: (a) abort rate with all learning, without inter-block learning, and without learned waits; (b) share of waits whose named writer wrote the key (10-block moving average); (c) window width. Panels (b) and (c) plot the traces in sequence.

Prediction Accuracy. Predictions recover after workload shifts (Figure 11(b)). Overall, 83% of waits target a writer that wrote the key. When this rate drops, as with trace F, it recovers within tens of blocks without an external signal, because evidence takes effect immediately and stale evidence is discarded.

Window Adaptation. The window follows the cost balance rather than the abort rate (Figure 11(c)). Its width ranges from 2 to 34 blocks, with typical values of about 5 on trace E and about 30 on trace H. Traces G and C have the highest and lowest abort rates but the same median width of 22. The width is thus derived from execution feedback rather than fixed in advance.

Related Work

Fine-Grained Concurrency Control. Prior work controls conflicts below the transaction level or exposes writes before commit. IC3 and PWV split transactions of known types into pieces that wait only for conflicting earlier pieces or expose writes early [32, 33], and Bamboo and Rebirth-Retire release a record after a transaction’s last write to it [28, 31]. These protocols locate conflicts from known transaction types, annotations, or program analysis. Smart contracts are open and change continually, so RegionFence obtains this information during execution.

Hybrid and Adaptive Concurrency Control. Hybrid protocols select among policies for classes of data or work. MOCC selects by record temperature [21], Sundial by conflict type [22], CormCC by partition [23], Tebaldi by transaction type [24], HDCC by transaction [25], and AOCC by operation [26], and TxnSails adapts to the workload at run time [30]. Each such choice covers a whole class. RegionFence instead applies one cost rule to each conflict, so different policies coexist within a block without predefined classes.

Learned Concurrency Control. Learned protocols derive the policy itself from the workload. Polyjuice trains a policy offline for stored procedures [27], and AdaChain learns a system-wide architecture for permissioned blockchains [20]. Both learn what to do for a workload, which requires offline training or repeated trials. RegionFence learns conflicts rather than policies: it predicts writers online, and the cost rule makes each decision, so it follows workload shifts.

Deterministic Concurrency Control. Deterministic databases also execute in a predetermined serial order. Calvin, BOHM, and Caracal rely on read or write sets known in advance [29, 35, 36], and Aria requires no such sets but reorders conflicting transactions across batches [34]. RegionFence follows a preset order without access sets and without reordering.

Orthogonal Blockchain Techniques. RegionFence determines when a conflicting read occurs, and several techniques improve other stages of block processing. Pre-execution [52, 53] and hardware acceleration [16] shorten each execution, and GPU-based state commitment [17] accelerates the stage after execution. Block-building systems [48, 49] reduce conflicts before a block forms, and semantic approaches [39, 40, 50] remove specific classes of conflicts, so RegionFence handles the remaining ones. Operation-level re-execution [4] could reduce the cost of its aborts, and block-level access lists [54] could seed conflict profiles.

Conclusion

This paper presents RegionFence, an adaptive concurrency control mechanism for blockchain parallel transaction execution. Regions confine control to the span of a transaction that a dependency constrains, and fences decide at run time, based on measured costs, whether each read proceeds or waits for the writer’s last write. Intra-block and inter-block online learning predicts writers and determines the number of concurrent blocks from execution itself. Because certification is separate from scheduling, any mixture of policies within a block produces the serial result. Our evaluation on real Ethereum mainnet blocks from different periods of the past five years shows that RegionFence achieves an overall speedup of 9.2× over single-core execution on 64 cores and outperforms OCC by 2.9–5.4× and PCC by 3.9–9.4× in speedup across these periods.

Acknowledgments

This work was supported by the National Natural Science Foundation of China No. 62602642 and No. U22B2032.

References

References

  1. [1]Satoshi Nakamoto. 2008. Bitcoin: A Peer-to-Peer Electronic Cash System. Whitepaper. https://bitcoin.org/bitcoin.pdf
  2. [2]Gavin Wood. 2025. Ethereum: A Secure Decentralised Generalised Transaction Ledger. Ethereum Yellow Paper, Shanghai version efc5f9a, 4 February 2025. https://ethereum.github.io/yellowpaper/paper.pdf
  3. [3]Rati Gelashvili, Alexander Spiegelman, Zhuolun Xiang, George Danezis, Zekun Li, Dahlia Malkhi, Yu Xia, and Ruantian Zhou. 2023. Block-STM: Scaling Blockchain Execution by Turning Ordering Curse to a Performance Blessing. In Proceedings of the 28th ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming (PPoPP). Association for Computing Machinery, New York, NY, USA, 232–244. https://doi.org/10.1145/3575284.3577524
  4. [4]Haoran Lin, Hang Feng, Yajin Zhou, and Lei Wu. 2025. ParallelEVM: Operation-Level Concurrent Transaction Execution for EVM-Compatible Blockchains. In Proceedings of the Twentieth European Conference on Computer Systems (EuroSys). Association for Computing Machinery, New York, NY, USA, 211–225. https://doi.org/10.1145/3689031.3696063
  5. [5]François Ezard, Can Umut Ileri, and Jérémie Decouchant. 2025. NEMO: Faster Parallel Execution for Highly Contended Blockchains. In Proceedings of the 7th Conference on Blockchain Research & Applications for Innovative Networks and Services (BRAINS). IEEE, Zurich, Switzerland, 1–5. https://doi.org/10.1109/BRAINS67003.2025.11302922 arXiv:2510.15122
  6. [6]Stephen Tu, Wenting Zheng, Eddie Kohler, Barbara Liskov, and Samuel Madden. 2013. Speedy Transactions in Multicore In-Memory Databases. In Proceedings of the Twenty-Fourth ACM Symposium on Operating Systems Principles (SOSP). Association for Computing Machinery, New York, NY, USA, 18–32. https://doi.org/10.1145/2517349.2522713
  7. [7]Xiangyao Yu, Andrew Pavlo, Daniel Sanchez, and Srinivas Devadas. 2016. TicToc: Time Traveling Optimistic Concurrency Control. In Proceedings of the 2016 International Conference on Management of Data (SIGMOD). Association for Computing Machinery, New York, NY, USA, 1629–1642. https://doi.org/10.1145/2882903.2882935
  8. [8]Xiangyao Yu, George Bezerra, Andrew Pavlo, Srinivas Devadas, and Michael Stonebraker. 2014. Staring into the Abyss: An Evaluation of Concurrency Control with One Thousand Cores. Proceedings of the VLDB Endowment 8, 3 (2014), 209–220. https://doi.org/10.14778/2735508.2735511
  9. [9]Claude Barthels, Ingo Müller, Konstantin Taranov, Gustavo Alonso, and Torsten Hoefler. 2017. Strong Consistency Is Not Hard to Get: Two-Phase Locking and Two-Phase Commit on Thousands of Cores. Proceedings of the VLDB Endowment 12, 13 (2019), 2325–2338. https://doi.org/10.14778/3358701.3358702
  10. [10]Parwat Singh Anjana, Matin Amini, Rohit Kapoor, Rahul Parmar, Raghavendra Ramesh, Srivatsan Ravi, and Joshua Tobkin. 2025. Efficient Parallel Execution of Blockchain Transactions Leveraging Conflict Specifications. In 7th Conference on Advances in Financial Technologies (AFT 2025) (LIPIcs), Vol. 354. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl, Germany, 29:1–29:26. https://doi.org/10.4230/LIPIcs.AFT.2025.29
  11. [11]Zhihao Chen, Tianji Yang, Yixiao Zheng, Zhao Zhang, Cheqing Jin, and Aoying Zhou. 2024. Speedy and Strictly-Deterministic Smart Contract Transactions for Blockchain Ledgers. Proceedings of the VLDB Endowment 17, 10 (2024), 2541–2554. https://doi.org/10.14778/3675045.3675045
  12. [12]Solana Foundation. 2019. Sealevel: Parallel Processing Thousands of Smart Contracts. Solana blog, 8 September 2019. https://solana.com/news/sealevel---parallel-processing-thousands-of-smart-contracts
  13. [13]Sam Blackshear, Andrey Chursin, George Danezis, Anastasios Kichidis, Lefteris Kokoris-Kogias, Xun Li, Mark Logan, Ashok Menon, Todd Nowacki, Alberto Sonnino, Brandon Williams, and Lu Zhang. 2024. Sui Litrus: A Blockchain Combining Broadcast and Consensus. In Proceedings of the 2024 ACM SIGSAC Conference on Computer and Communications Security (CCS). Association for Computing Machinery, New York, NY, USA, 2606–2620. https://doi.org/10.1145/3658644.3670286
  14. [14]Mohammad Javad Amiri, Divyakant Agrawal, and Amr El Abbadi. 2019. Par-Blockchain: Leveraging Transaction Parallelism in Permissioned Blockchain Systems. In Proceedings of the 39th IEEE International Conference on Distributed Computing Systems (ICDCS). IEEE, Dallas, TX, USA, 1337–1347. https://doi.org/10.1109/ICDCS.2019.00134
  15. [15]Huan Zhang, Xiaodong Qi, Haibo Tang, Zhao Zhang, Cheqing Jin, and Aoying Zhou. 2025. A Deterministic Execution Framework Towards Nested Contract Transactions. In Proceedings of the 41st IEEE International Conference on Data Engineering (ICDE). IEEE, Hong Kong, 2408–2421. https://doi.org/10.1109/ICDE65448.2025.00182
  16. [16]Rui Pan, Chubo Liu, Guoqing Xiao, Mingxing Duan, Keqin Li, and Kenli Li. 2023. An Algorithm and Architecture Co-design for Accelerating Smart Contracts in Blockchain. In Proceedings of the 50th Annual International Symposium on Computer Architecture (ISCA). Association for Computing Machinery, New York, NY, USA, 1–13. https://doi.org/10.1145/3579371.3589067
  17. [17]Yangshen Deng, Muxi Yan, and Bo Tang. 2024. Accelerating Merkle Patricia Trie with GPU. Proceedings of the VLDB Endowment 17, 8 (2024), 1856–1869. https://doi.org/10.14778/3659437.365943
  18. [18]Elli Androulaki, Artem Barger, Vita Bortnikov, Christian Cachin, Konstantinos Christidis, Angelo De Caro, David Enyeart, Christopher Ferris, Gennady Laventman, Yacov Manevich, Srinivasan Muralidharan, Chet Murthy, Binh Nguyen, Manish Sethi, Gari Singh, Keith Smith, Alessandro Sorniotti, Chrysoula Stathakopoulou, Marko Vukolic, Sharon Weed Cocco, and Jason Yellick. 2018. Hyperledger Fabric: A Distributed Operating System for Permissioned Blockchains. In Proceedings of the Thirteenth EuroSys Conference. Association for Computing Machinery, New York, NY, USA, Article 30, 15 pages. https://doi.org/10.1145/3190508.3190538
  19. [19]Ankur Sharma, Felix Martin Schuhknecht, Divya Agrawal, and Jens Dittrich. 2019. Blurring the Lines between Blockchains and Database Systems: The Case of Hyperledger Fabric. In Proceedings of the 2019 International Conference on Management of Data (SIGMOD). Association for Computing Machinery, New York, NY, USA, 105–122. https://doi.org/10.1145/3299869.3319883
  20. [20]Chenyuan Wu, Bhavana Mehta, Mohammad Javad Amiri, Ryan Marcus, and Boon Thau Loo. 2023. AdaChain: A Learned Adaptive Blockchain. Proceedings of the VLDB Endowment 16, 8 (2023), 2033–2046. https://doi.org/10.14778/3594512.3594531
  21. [21]Tianzhe Wang and Hideaki Kimura. 2016. Mostly Optimistic Concurrency Control for Highly Contended Dynamic Workloads on a Thousand Cores. Proceedings of the VLDB Endowment 10, 2 (2016), 49–60. https://doi.org/10.14778/3015274.3015276
  22. [22]Xiangyao Yu, Yu Xia, Andrew Pavlo, Daniel Sanchez, Larry Rudolph, and Srinivas Devadas. 2018. Sundial: Harmonizing Concurrency Control and Caching in a Distributed OLTP Database Management System. Proceedings of the VLDB Endowment 11, 10 (2018), 1289–1302. https://doi.org/10.14778/3233175.32331763
  23. [23]Dixin Tang and Aaron J. Elmore. 2018. Toward Coordination-free and Reconfigurable Mixed Concurrency Control. In 2018 USENIX Annual Technical Conference (USENIX ATC 18). USENIX Association, Berkeley, CA, USA, 809–822. https://www.usenix.org/conference/atc18/presentation/tang
  24. [24]Chunzhi Su, Natacha Crooks, Cong Ding, Lorenzo Alvisi, and Chao Xie. 2017. Bringing Modular Concurrency Control to the Next Level. In Proceedings of the 2017 ACM International Conference on Management of Data (SIGMOD). Association for Computing Machinery, New York, NY, USA, 283–297. https://doi.org/10.1145/3035918.3064031
  25. [25]Yinhao Hong, Hongyao Zhao, Wei Lu, Xiaoyong Du, Yuxing Chen, Anqun Pan, and Lixiong Zheng. 2025. A Hybrid Approach to Integrating Deterministic and Non-Deterministic Concurrency Control in Database Systems. Proceedings of the VLDB Endowment 18, 5 (2025), 1376–1389. https://doi.org/10.14778/3718057.3718066
  26. [26]Jinwei Guo, Peng Cai, Jiahao Wang, Weining Qian, and Aoying Zhou. 2019. Adaptive Optimistic Concurrency Control for Heterogeneous Workloads. Proceedings of the VLDB Endowment 12, 5 (2019), 584–596. https://doi.org/10.14778/3303753.3303763
  27. [27]Jiachen Wang, Ding Ding, Huan Wang, Conrad Christensen, Zhaoguo Wang, Haibo Chen, and Jinyang Li. 2021. Polyjuice: High-Performance Transactions via Learned Concurrency Control. In 15th USENIX Symposium on Operating Systems Design and Implementation (OSDI 21). USENIX Association, Berkeley, CA, USA, 198–216. https://www.usenix.org/conference/osdi21/presentation/wang-jiachenarxiv.org/abs/2105.10329
  28. [28]Qian Zhang, Yiwen Xiang, Jianhao Wei, Yang Yang, Yifan Li, Xueqing Gong, and Wangen Liu. 2025. Rebirth-Retire: A Concurrency Control Protocol Adaptable to Different Levels of Contention. Proceedings of the VLDB Endowment 18, 9 (2025), 3162–3174. https://doi.org/10.14778/3746405.3746435
  29. [29]Dai Qin, Angela Demke Brown, and Ashvin Goel. 2021. Caracal: Contention Management with Deterministic Concurrency Control. In Proceedings of the ACM SIGOPS 28th Symposium on Operating Systems Principles (SOSP). Association for Computing Machinery, New York, NY, USA, 180–194. https://doi.org/10.1145/3477132.3483591
  30. [30]Qiyu Zhuang, Wei Lu, Shuang Liu, Yuxing Chen, Xinyue Shi, Zhanhao Zhao, Yipeng Sun, Anqun Pan, and Xiaoyong Du. 2025. TxnSails: Achieving Serializable Transaction Scheduling with Self-Adaptive Isolation Level Selection. Proceedings of the VLDB Endowment 18, 11 (2025), 4227–4240. https://doi.org/10.14778/3749646.3749689
  31. [31]Zhihong Guan, Kan Wu, Cong Yan, and Xiangyao Yu. 2021. Releasing Locks As Early As You Can: Reducing Contention of Hotspots by Violating Two-Phase Locking. In Proceedings of the 2021 International Conference on Management of Data (SIGMOD). Association for Computing Machinery, New York, NY, USA, 658–670. https://doi.org/10.1145/3448016.3457294
  32. [32]Jose M. Faleiro, Daniel J. Abadi, and Joseph M. Hellerstein. 2017. High Performance Transactions via Early Write Visibility. Proceedings of the VLDB Endowment 10, 5 (2017), 613–624. https://doi.org/10.14778/3055540.3055553
  33. [33]Zhaoguo Wang, Shuai Mu, Yang Cui, Han Yi, Haibo Chen, and Jinyang Li. 2016. Scaling Multicore Databases via Constrained Parallel Execution. In Proceedings of the 2016 International Conference on Management of Data (SIGMOD). Association for Computing Machinery, New York, NY, USA, 1643–1658. https://doi.org/10.1145/2882903.2882934
  34. [34]Yi Lu, Xiangyou Yu, Lei Cao, and Samuel Madden. 2020. Aria: A Fast and Practical Deterministic OLTP Database. Proceedings of the VLDB Endowment 13, 12 (2020), 2047–2060. https://doi.org/10.14778/3407377.3407808
  35. [35]Alexander Thomson, Thaddeus Diamond, Shu-Chun Weng, Kun Ren, Philip Shao, and Daniel J. Abadi. 2012. Calvin: Fast Distributed Transactions for Partitioned Databases. In Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD). Association for Computing Machinery, New York, NY, USA, 1–12. https://doi.org/10.1145/2213836.2213838
  36. [36]Jose M. Faleiro and Daniel J. Abadi. 2015. Rethinking Serializable Multiversion Concurrency Control. Proceedings of the VLDB Endowment 8, 11 (2015), 1190–1201. https://doi.org/10.14778/2809981.2809981
  37. [37]Transaction Processing Performance Council. 2010. TPC Benchmark C Standard Specification, Revision 5.11. https://www.tpc.org/tpcc/.
  38. [38]Mohammad Alomari, Michael Cahill, Alan Fekete, and Uwe Röhm. 2008. The Cost of Serialization on Platforms That Use Snapshot Isolation. In Proceedings of the 24th IEEE International Conference on Data Engineering (ICDE). IEEE, 576–585. https://doi.org/10.1109/ICDE.2008.4497466
  39. [39]dePaul Miller, Henry F. Korth, and Roberto Palmieri. 2024. Poster: OCToPus: Semantic-aware Concurrency Control for Blockchain Transactions. In Proceedings of the 29th ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming (PPoPP). Association for Computing Machinery, New York, NY, USA, 463–465. https://doi.org/10.1145/3627535.3638494
  40. [40]Hao Wang, Minghao Pan, and Jiaping Wang. 2025. Crystalty: A Programming Model for Smart Contracts on Parallel EVMs. In Proceedings of the 30th ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming (PPoPP). Association for Computing Machinery, New York, NY, USA, 412–425. https://doi.org/10.1145/3710848.3710879
  41. [41]Zeshun Peng, Yanfeng Zhang, Qian Xu, Haixu Liu, Yuxiao Gao, Xiaohua Li, and Ge Yu. 2022. NeuChain: A Fast Permissioned Blockchain System with Deterministic Ordering. Proceedings of the VLDB Endowment 15, 11 (2022), 2585–2598. https://doi.org/10.14778/3551783.3551816
  42. [42]H. T. Kung and John T. Robinson. 1981. On Optimistic Methods for Concurrency Control. ACM Transactions on Database Systems 6, 2 (1981), 213–226. https://doi.org/10.1145/319566.319567
  43. [43]Qiaodong Qi, Xinran Chen, Asiy, and Neil Han. 2025. Boosting Blockchain Throughput: Parallel EVM Execution with Asynchronous Storage for Reddio. arXiv:2503.04595.
  44. [44]Thomas Dickerson, Paul Gazzillo, Maurice Herlihy, and Eric Koskinen. 2017. Adding Concurrency to Smart Contracts. In Proceedings of the ACM Symposium on Principles of Distributed Computing (PODC). Association for Computing Machinery, New York, NY, USA, 303–312. https://doi.org/10.1145/3087801.3087835
  45. [45]Parwat Singh Anjana, Sweta Kumari, Sathya Peri, Sachin Rathor, and Archit Somani. 2019. An Efficient Framework for Optimistic Concurrent Execution of Smart Contracts. In Proceedings of the 27th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP). IEEE, Pavia, Italy, 83–92. https://doi.org/10.1109/EMDP.2019.8761637
  46. [46]Xiaodong Qi, Jiao Jiao, and Yi Li. 2023. Smart Contract Parallel Execution with Fine-Grained State Accesses. In Proceedings of the 43rd IEEE International Conference on Distributed Computing Systems (ICDCS). IEEE, Hong Kong, 841–852. https://doi.org/10.1109/ICDCS57875.2023.00068
  47. [47]Zhibo Han, Zeshun Peng, Gang Wang, Mingyue He, Xiaohua Li, Yanfeng Zhang, and Ge Yu. 2025. An Optimized Deterministic Concurrency Control Approach for Geo-Distributed Transaction Processing on Permissioned Blockchains. Scientific Reports 15, 1, Article 19238 (2025). https://doi.org/10.1038/s41598-025-00478-5
  48. [48]Ryan Zarick, Isaac Zhang, Daniel Wong, Thomas Kim, Bryan Pellegrino, Mignon Li, and Kelvin Wong. 2025. FAFO: Over 1 Million TPS on a Single Node Running EVM While Still Merkleizing Every Block. arXiv:2507.10757.arxiv.org/abs/2507.10757
  49. [49]Ray Neiheiser and Eleftherios Kokoris-Kogias. 2026. Anthemius: Efficient and Modular Block Assembly for Concurrent Execution. In Financial Cryptography and Data Security (FC 2025) (Lecture Notes in Computer Science), Vol. 15751. Springer Nature Switzerland, Cham, 307–323. https://doi.org/10.1007/978-3-032-07024-1_18
  50. [50]George Mitenkov, Igor Kabjilo, Zekun Li, Alexander Spiegelman, Satyanarayana Vusirikala, Zhuolun Xiang, Aleksandar Zlateski, Nuno P. Lopes, and Rati Gelashvili. 2024. Deferred Objects to Enhance Smart Contract Programming with Optimistic Parallel Execution. arXiv:2405.06117.arxiv.org/abs/2405.06117
  51. [51]Philip A. Bernstein, Vassos Hadzilacos, and Nathan Goodman. 1987. Concurrency Control and Recovery in Database Systems. Addison-Wesley.
  52. [52]Shijie Zhang, Ru Cheng, Xinpeng Liu, Jiang Xiao, Hai Jin, and Bo Li. 2024. Seer: Accelerating Blockchain Transaction Execution by Fine-Grained Branch Prediction. Proceedings of the VLDB Endowment 18, 3 (2024), 822–835. https://doi.org/10.14778/3712221.3712245
  53. [53]Yang Chen, Zhongxin Guo, Runhuai Li, Shuo Chen, Lidong Zhou, Yajin Zhou, and Xian Zhang. 2021. Forerunner: Constraint-Based Speculative Transaction Execution for Ethereum. In Proceedings of the ACM SIGOPS 28th Symposium on Operating Systems Principles (SOSP). Association for Computing Machinery, New York, NY, USA, 570–587. https://doi.org/10.1145/3477132.3483564
  54. [54]Toni Wahrstätter, Dankrad Feist, Francesco D’Amato, Jochem Brouwer, Ignacio Hagopian, Felipe Selmo, et al. 2025. EIP-7928: Block-Level Access Lists. Ethereum Improvement Proposal 7928. https://eips.ethereum.org/EIPS/eip-7928. Last Call as of October 2026.

Paper details

vlnc:W_h9raxg82
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents