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 to 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 , which stores the reserves of a popular pool . and are swaps routed through two pools. trades in P and then in a quiet pool, while trades in another quiet pool and then in P, so reads the value of that writes. and are unrelated token transfers.
OCC runs and concurrently without waiting, so reads before has written it. When is validated, has changed since its read, so the engine aborts and re-executes it from the start (Figure 1(a)). PCC avoids this abort, but , , and all access , so they run one after another while other cores remain idle (Figure 1(b)).
Figure 1. Example schedules of one block on three cores. depends on only through the hot key : (a) OCC re-executes , (b) PCC delays it, and (c) RegionFence resumes it at ’s last write.
In this example, both costs are unnecessary because needs only the value that writes to . could execute its first hop concurrently with , wait at its read of , and resume once completes its last write, even though 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 , a write-after-write (WAW) conflict requires no coordination, because each transaction writes its own version and in-order commit makes the version of the later one. A write-after-read (WAR) conflict, where reads and writes, also requires no coordination, because reads only versions below . Only a read-after-write (RAW) conflict, where reads what writes, requires coordination, because must observe the version of .
We say that depends on , written , if reads a key whose latest preceding writer is . 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.
| System | Control unit | Conflict information | Decision time | Wait condition |
| Block-STM [3] | Transaction | Writes of aborted incarnations | Upon abort | Writer re-execution |
| ParallelEVM [4] | Operation | None | Validation phase | None |
| Sui Lutris [13] | Object version | Declared objects | Before execution | Completion of earlier versions |
| Spectrum [11] | Hot-key read | Partial pre-acquired sets | Before execution | Final commit of writers |
| OCToPus [39] | Atomic operation | Transfer semantics | Upon insufficient funds | Serial fallback |
| Crystality [40] | Function fragment | Programmer-defined scopes | Development time | None |
| Fabric++ [19] | Transaction | Simulated read and write sets | Ordering phase | None |
| NeuChain [41] | Transaction | Reserve table | Epoch end | None |
| Loom [15] | Subtransaction | Block pre-execution | After pre-execution | Conflicting subtransactions |
| AdaChain [20] | Entire system | Workload features, throughput | Per episode | Determined by architecture |
| RegionFence | Region on a contended key | Learned from execution | Run time, at region start | Writer’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.
| Trace | First block | Date | Txs |
| A | 12,499,900 | 2021-05-24 | 20,171 |
| B | 13,809,900 | 2021-12-15 | 17,167 |
| C | 14,500,000 | 2022-04-01 | 16,810 |
| D | 14,999,900 | 2022-06-21 | 18,408 |
| E | 16,619,900 | 2023-02-13 | 15,308 |
| F | 17,873,600 | 2023-08-08 | 14,968 |
| G | 20,079,900 | 2024-06-13 | 17,011 |
| H | 22,449,900 | 2025-05-10 | 18,232 |
| I | 26,060,700 | 2026-09-26 | 23,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 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 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 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 waits at its first read of the hot key until ’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 blocks. ② Workers execute the transactions: , , and proceed without waiting, and completes its swap through pool Y. ③ When first reads , it enters a region, and its fence consults the conflict profile of . The profile identifies as a likely writer, so the fence orders after , and suspends and frees its worker, which then executes .
The remaining steps release the reader, commit the transactions, and return evidence to the learning module. ④ Because is waiting, releases immediately after its last write to it. resumes while is still executing its swap through pool X, and 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 through key therefore constrains exactly one pair of points: must observe after the last write of 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 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 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 , such as a predicted writer writing the key. Acting on the event costs if it does not occur, and not acting costs if it does. Comparing the expected costs and , acting is beneficial when
The rule combines a probability from learning with a threshold from run-time measurements. The probability depends on the key (§ 5), whereas the threshold depends on the machine and the workload, so RegionFence measures and in time during execution. Delays are weighted by , 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 instead, because a re-execution consumes processors only while they are busy. Because 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, is the commit frontier, the lowest uncommitted transaction, and is the value that a read of by returns: the latest version published below in the block of , else the value set by the state changes applied at the start of that block , 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 for predicted writers, namely unfinished earlier transactions that are likely to write (§ 5.1), each with an estimate (line 5). For the second part, (1) compares two errors. Waiting for a transaction that does not write loses , and proceeding past one that does loses to a re-execution. Thus waits for a predicted writer if , where (line 7).
| Algorithm 1 Fence: a reader at the start of a region | |
| 1: function Fence(, ) | starts a region on |
| 2: if is globally written then | |
| 3: wait until | |
| 4: else | |
| 5: the nearest predicted writers of below | §5.1 |
| 6: for , nearest first do | |
| 7: if is unfinished and then | |
| 8: yield until releases or publishes , or finishes | |
| 9: if wrote then break | |
| 10: lower the feature that predicted ▷ unnecessary wait | |
| 11: | ▷ waits if the version is labelled |
| 12: if some , is unfinished then register on | |
| 13: return |
Table 1 (PDF p. 6).
| Algorithm 2 Release and recovery: a writer | |
| 1: function OnWrite(, , ) | ▷ -th write of |
| 2: if the write changes and then | |
| 3: if a reader waits for then | |
| 4: release : publish its value, wake the readers | |
| 5: else | |
| 6: hold it; release it once a reader waits | |
| 7: function OnAbort() | |
| 8: for each key that wrote do | |
| 9: if failed or rewrites, and reaches its threshold then | |
| 10: label failed or rewrite: readers wait | |
| 11: if is high enough then invalidate its readers | |
| 12: else | |
| 13: leave tentative: readers proceed |
Table 2 (PDF p. 6).
A fence examines predicted writers in order of proximity. 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 , 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, 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 reaches the commit frontier (line 3).
Early Release. A writer applies the same rule to decide whether to release a value. When writes for the -th time, it does not know whether the write is final. A release fails if writes again or its incarnation aborts, and in either case the readers re-execute. Let be the time a release saves waiting readers if the value is final, the time they lose if it is not, and the writer’s own cost. With the estimated probability that this write is the last, and the fraction of releases whose incarnation survives, (1) becomes
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 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, 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 be the transactions of consecutive blocks, and let and be the state and receipt after 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 . Once have committed with state , every version below is committed and no longer changes. The certification rule requires the observations of to equal those on , so by determinism produces the writes and receipt of serial execution, which yields and .
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 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 , 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 denote the probability that a transaction with feature writes key , the probability that the -th write of by an execution is its last, and the probability that a version left at 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. and 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 . The combination of that address with the router is largely specific to swaps on P, so it identifies but not .
The conflict profile of a contended key stores a bounded number of writer features together with their estimates . The estimate of a transaction is the maximum over its features. Because only features can identify a writer that has not yet accessed , 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 is a likely writer, with a probability given by the fraction of readers of 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 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 and from completed and committed transactions. Each completed execution adds its number of writes to each contended key to a histogram, from which is the fraction of executions with at least writes that have exactly writes. This estimate depends on how the code updates the key rather than on the caller. The estimate 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 , 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 changed is a Bernoulli trial, and with hits in trials the estimate is
the posterior mean under a prior with mean and fixed strength . The prior mean is derived from the record of 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 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 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, , with the cost of the outermost block, . The term 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 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 blocks to execute, the width is updated as
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 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 cores is pinned to physical cores of one socket, without SMT. Each configuration runs three times, and we report the median. Each trace starts with empty profiles and .
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 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 workers, serial transaction times, and the measured serial commit, relative to RegionFence’s single core and capped at . 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 , about twice OCC, because most transactions are independent (Figure 8(a)–(Figure 8b)). The two systems perform equally at , and OCC outperforms RegionFence at higher skew, with 6.9× against 4.8× at 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]Satoshi Nakamoto. 2008. Bitcoin: A Peer-to-Peer Electronic Cash System. Whitepaper. https://bitcoin.org/bitcoin.pdf
- [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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]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]Transaction Processing Performance Council. 2010. TPC Benchmark C Standard Specification, Revision 5.11. https://www.tpc.org/tpcc/.
- [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]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]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]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]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]Qiaodong Qi, Xinran Chen, Asiy, and Neil Han. 2025. Boosting Blockchain Throughput: Parallel EVM Execution with Asynchronous Storage for Reddio. arXiv:2503.04595.
- [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]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]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]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]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]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]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]Philip A. Bernstein, Vassos Hadzilacos, and Nathan Goodman. 1987. Concurrency Control and Recovery in Database Systems. Addison-Wesley.
- [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]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]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.










