Unified Instruction Set Generation for Concurrent Data Object Updates
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing systems for generating instruction sets to update objects based on application data models often result in a large number of instruction sets, leading to increased processing time and potential conflicts due to exclusive access requirements, and lack user control over rule merging.
Innovation Solution
The system processes rules to form buckets with no inter-dependency, determines subsets of rules updating common objects, and generates a single instruction set for each subset, allowing for concurrent execution and user-controlled merging of rules, with precedence data used to ensure correct execution order.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If multiple instruction sets are generated for updating data objects based on rules, then each rule can be executed independently, but the processing time increases and conflicting contention occurs due to exclusive access requirements
Solution Approach 1:
The patent merges multiple instruction sets into a single instruction set that updates multiple data objects simultaneously. Instead of generating separate instruction sets for each rule (e.g., UPDATE TABLE1, UPDATE TABLE2), the system creates a unified instruction set that can execute all updates in one operation, thereby reducing processing time and eliminating conflicts from sequential exclusive access.
Solution Approach 2:
The single instruction set is designed to perform multiple functions by updating different data objects (tables) within one execution. This universal instruction set can handle various update operations simultaneously, making the system more efficient and eliminating the need for multiple separate execution cycles.
2Reliability
If exclusive access is required for each instruction set update, then data integrity is maintained, but processing time increases due to sequential execution requirements
Solution Approach 1:
The patent combines multiple exclusive access operations into a single atomic operation. The unified instruction set is designed to execute all data object updates simultaneously in one transaction, maintaining data integrity through atomicity while eliminating the sequential time penalty of multiple exclusive locks.
Solution Approach 2:
The single instruction set maintains continuous useful action by executing all updates within one atomic transaction. This ensures that data integrity is preserved through consistent locking mechanisms while the entire update process completes in one continuous operation rather than multiple sequential steps.
3Reliability
If rules are executed sequentially to ensure correct execution order, then dependency conflicts are avoided, but processing time increases
Solution Approach 1:
The system performs preliminary analysis of rule dependencies before generating the unified instruction set. By pre-determining the execution order and identifying which rules can be executed simultaneously, the system creates a single instruction set that respects dependency constraints while maximizing parallel execution, thereby maintaining correctness without sequential time penalties.
Solution Approach 2:
The instruction set is designed to be dynamic in its execution strategy, allowing simultaneous execution of independent rules while maintaining proper order for dependent rules. The system dynamically determines which updates can occur in parallel based on rule dependencies, optimizing both correctness and performance.
Data Source
Figure 1
Figure 2
Figure 3A
AI summary
An aspect of the present disclosure generates instruction sets implementing rules designed to update objects specified according to an application data model. In one embodiment, rules designed to update objects are processed to form a set of buckets (of rules) such that each bucket contains rules that do not have inter-dependency in execution order. Then, for each bucket, subsets of rules designed to update a common object are determined, and a corresponding single instruction set is generated for each determined subset of rules. The instruction sets generated for the subsets of rules contained in each bucket are then executed concurrently.