Transaction Processing via Precedence Graph Concurrency Control
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional transaction processing systems face inefficiencies due to repeated access and update of the same data items by multiple transactions, leading to increased aborts and rollbacks, which decrease processing speed and cause deadlocks.
Innovation Solution
A transaction processing system using multi-operation processing, where transactions are grouped and executed sequentially, with a precedence graph determining the order of operations to minimize locks and avoid deadlocks, and employing two-phase locking or timestamp protocols for concurrent execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If multiple transactions are executed concurrently on the same data items, then transaction processing speed is improved, but data inconsistency may occur
Solution Approach 1:
The system performs preliminary actions by creating a precedence graph before executing transactions. The precedence graph is constructed by analyzing all transactions and determining the correct execution order based on data dependencies. This preliminary analysis allows the system to execute multiple transactions concurrently while guaranteeing serializability, as the execution order is predetermined and enforced through the graph structure.
Solution Approach 2:
The precedence graph acts as an intermediary structure between transactions and the execution engine. Instead of using traditional locking mechanisms that directly constrain transaction execution, the system uses the precedence graph to mediate and coordinate concurrent transactions. The graph represents data dependencies and guides the execution order, allowing concurrency while maintaining consistency without direct transaction-to-transaction blocking.
2Reliability
If serial scheduling is used to execute transactions one by one, then data consistency is maintained, but CPU processing time is wasted
Solution Approach 1:
The system performs preliminary analysis to construct a precedence graph that captures all data dependencies between transactions. This graph is built before execution by analyzing which transactions read or write the same data items. Once the graph is constructed, the system can identify independent transactions that can execute in parallel, thereby utilizing CPU time efficiently while still maintaining serializability through the graph's execution order constraints.
Solution Approach 2:
The system dynamically determines the execution schedule based on the precedence graph structure. Rather than rigidly executing transactions in a fixed serial order, the system can dynamically identify and execute independent transactions concurrently. The precedence graph provides a flexible framework that adapts to the specific dependency patterns of the transaction set, allowing maximum parallelization while preserving consistency.
3Reliability
If locking methods are used to achieve serializable scheduling, then data inconsistency is avoided, but deadlocks may occur
Solution Approach 1:
The system extracts the locking mechanism from the concurrency control process and replaces it with a precedence graph-based approach. Instead of acquiring and releasing locks on data items during transaction execution, the system uses the pre-computed precedence graph to determine execution order. This extraction eliminates deadlocks entirely, as there are no locks to be contested, while still achieving serializable scheduling through the graph's dependency representation.
Solution Approach 2:
The system replaces the mechanical locking system with a graph-theoretic approach. Traditional locking relies on hardware and software mechanisms for acquiring, holding, and releasing locks, which can lead to deadlocks. The precedence graph method substitutes this mechanical system with a computational model based on directed acyclic graphs, where execution order is determined by topological sorting and data dependencies, eliminating the need for lock management infrastructure.
4Reliability
If transactions are restarted repeatedly when cycles appear in the dependency graph, then serializable scheduling may be achieved, but processing efficiency decreases
Solution Approach 1:
The system takes preliminary anti-action by detecting and preventing cycle formation in the precedence graph before transaction execution begins. During the graph construction phase, the system analyzes all transaction operations and identifies potential cycles. If cycles are detected, the system can adjust the transaction schedule or execution order in advance, rather than allowing transactions to execute and then failing due to detected cycles. This prevents the need for repeated restarts and maintains high processing efficiency.
Data Source
AI summary
Instead of executing a plurality of submitted transactions separately, each data item to be processed by the plurality of submitted transactions is retrieved only once, update operations of the plurality of transactions are executed consecutively on the retrieved data item in main memory, and only the last updated result is written in a database once.Two-phase locking technique and timestamp technique are used for multi-operation processing providing concurrency control of transactions in order to execute multiple synthetic transactions concurrently.