Uncommitted State Caching to Reduce EOV Transaction Aborts
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The Execute-Order-Validate (EOV) blockchain transaction model experiences high transaction aborts due to serializability violations caused by a time gap between the execution and validation phases, leading to reduced goodput when multiple conflicting transactions are submitted in a short time-span.
Innovation Solution
Implementing an uncommitted state cache at each node to cache the write-set after the execution phase, allowing subsequent transactions to read from this cache instead of the committed version, ensuring deterministic execution and reducing aborts.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If transactions are executed and validated with a time gap between phases, then transaction processing flexibility is improved, but serializability violations increase causing transaction aborts
Solution Approach 1:
The patent applies preliminary action by caching the write-set during the execution phase before validation occurs. This pre-caching of state changes allows the validation phase to check serializability against the cached execution state rather than the committed state, preventing serializability violations while maintaining processing flexibility
Solution Approach 2:
The patent introduces an intermediary mechanism - the uncommitted state cache - that mediates between the execution phase and validation phase. This cache serves as an intermediate storage layer that holds write-sets during the time gap between phases, allowing both phases to operate independently while maintaining consistency
2Productivity
If multiple conflicting transactions are processed in a short time-span, then transaction throughput is improved, but transaction aborts due to serializability violations increase
Solution Approach 1:
By caching write-sets during execution before validation, the system can process multiple conflicting transactions in parallel during the execution phase without immediate serializability checks. The cached state allows batch validation later, enabling high throughput while maintaining commit reliability
Solution Approach 2:
The uncommitted state cache maintains continuous state information throughout the execution-validation time gap, allowing the system to continuously process transactions without interruption. This continuous caching mechanism ensures that serializability can be validated against the correct execution state even as multiple transactions are processed rapidly
3Stability of the object's composition
If the read-set is validated against the committed version, then data consistency is maintained, but subsequent transactions may be aborted due to time-gap state changes
Solution Approach 1:
The patent uses the uncommitted state cache as an intermediary that allows validation to check against execution state rather than committed state. This intermediary layer decouples the validation process from the committed version, preventing false serializability violations while maintaining data consistency
Solution Approach 2:
By validating against the cached execution state (preliminarily captured write-set) rather than the committed version, the system performs validation at the appropriate point in time. This preliminary state capture ensures that transactions are validated against the state they actually executed against, preventing unnecessary aborts
Data Source
AI summary
A processor may store a write set of a transaction in a cache. The cache may include state information, and the cache may be uncommitted to a blockchain. The processor may identify a subsequent transaction. The subsequent transaction may read from the cache when a requested key is present in the cache. The processor may order the transaction and the subsequent transaction based on what is read from the cache. Ordering the transaction and the subsequent transaction may avoid an abort of the subsequent transaction.