Transaction Manager Using Conditional Entries
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing data storage systems face performance issues due to long lock durations, potential deadlocks, and increased recovery time caused by locking and journaling mechanisms during transactions, which hinder concurrency and scalability.
Innovation Solution
A transaction management system that assigns a unique identifier to transactions, updates the identifier based on the transaction state, and uses conditional entries in objects to manage modifications without requiring locks or journaling, allowing for implicit rollback in case of failures.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If locking and journaling mechanisms are used to ensure atomic transactions, then data consistency is maintained, but system performance and concurrency are reduced due to long lock durations
Solution Approach 1:
The patent applies preliminary action by pre-allocating transaction identifiers and preparing conditional entries in advance. Objects are updated with conditional entries that specify what modifications should be applied if the transaction commits, allowing the system to prepare for potential transactions without holding locks during the entire transaction duration.
Solution Approach 2:
The patent extracts the journaling mechanism from the transaction execution process. Instead of writing to a journal and then executing transactions with locks, the system directly applies conditional modifications to objects. The journaling function is replaced by conditional entries embedded in the objects themselves, eliminating the need for separate journal writes and lock management.
2Reliability
If multiple objects are locked for atomic transaction execution, then transaction integrity is ensured, but deadlocks occur and lock order complexity increases
Solution Approach 1:
The patent applies self-service by making each object self-describing through conditional entries. Each object contains information about what modifications are conditional on specific transaction identifiers, allowing the object itself to manage its own state transitions without external lock management. The system automatically applies or rejects modifications based on transaction commitment status.
Solution Approach 2:
The patent prepares conditional entries in objects before transactions execute. These entries pre-specify the conditions under which modifications should be applied, eliminating the need for complex lock ordering during transaction execution. The system only needs to check transaction commitment status rather than manage intricate lock hierarchies.
3Reliability
If a journal is used to log transaction operations, then recovery after failure is possible, but recovery time is prolonged due to reading and processing the journal
Solution Approach 1:
The patent extracts the recovery information from a separate journal structure and embeds it directly within the objects themselves. Conditional entries in objects contain all necessary information about what modifications were attempted and under what transaction identifiers. During recovery, the system simply checks the commitment status of transaction identifiers against conditional entries, eliminating the need to read and process a separate journal.
Solution Approach 2:
The patent prepares all recovery information in advance by embedding conditional entries in objects during normal operation. When a failure occurs, the system has already have all necessary recovery information prepared and organized within the objects themselves, requiring only a status check rather than extensive journal processing.
4Reliability
If journaling is implemented to track transaction states, then atomicity is ensured, but at least two additional operations are added to each transaction
Solution Approach 1:
The patent merges the journaling function with the object structure itself. Conditional entries are embedded directly within objects, combining the data storage and transaction logging functions into a single structure. This eliminates the need for separate journal write operations while maintaining atomicity through the conditional entry mechanism.
Solution Approach 2:
The patent extracts the journaling operation from the transaction process and replaces it with inline conditional entries. Instead of writing to a journal and then executing transactions, the system directly applies conditional modifications. The journaling function is taken out and replaced by embedded conditional logic within the objects.
Data Source
AI summary
A system and method for transaction management. The system includes a processing circuitry; and a memory, the memory containing instructions that, when executed by the processing circuitry, configure the system to: assign a transaction identifier (ID) to a transaction, wherein the transaction includes at least one modification to at least one object stored in a storage system, each object having a persistent state, wherein the transaction ID indicates a state of the transaction, wherein the state of the transaction initially indicates that the transaction is in progress; modify the at least one object, wherein the modifying further comprises adding at least one conditional entry to each object, wherein each conditional entry includes one of the at least one modification that is conditional on the state of the transaction; and update the transaction ID when a termination event occurs, wherein the updating further includes changing the state of the transaction.