Snapshot-Based Thread Limiters for Runtime Workload Hierarchies
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing systems face challenges in dynamically managing resource allocation during job execution in a hierarchical structure of workload classes due to synchronization issues and excessive resource usage, leading to performance overhead and errors.
Innovation Solution
Implementing a method that maintains snapshots of the workload class hierarchy and its associated limiters, allowing for dynamic modifications at runtime while ensuring resource allocation adheres to defined limits by using snapshot objects to track and manage resource usage across threads.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If dynamic modifications to the hierarchy of workload classes are made during runtime, then adaptability is improved, but system complexity and synchronization issues worsen
Solution Approach 1:
The patent segments the hierarchy of workload classes into snapshot objects that capture the state at specific points in time. Each snapshot object represents a discrete, self-contained view of the hierarchy structure, allowing modifications to occur without affecting ongoing operations. This segmentation enables dynamic adaptability while isolating synchronization complexity to specific snapshot transitions rather than affecting the entire system continuously.
Solution Approach 2:
The patent takes preliminary action by creating snapshot objects before modifications occur. These snapshots preserve the state of the hierarchy prior to changes, allowing the system to safely modify the workload class structure while maintaining a reference to the previous state. This preliminary capture of state enables runtime adaptability without causing synchronization conflicts during the modification process.
2Measurement precision
If snapshots of the workload class hierarchy are maintained for each thread, then resource allocation accuracy is improved, but memory usage increases
Solution Approach 1:
The patent implements universality by making snapshot objects reusable across multiple threads. Instead of creating dedicated snapshot copies for each thread, the same snapshot object can be shared and referenced by multiple threads simultaneously. This multi-functional approach maintains precise resource allocation tracking while significantly reducing memory consumption, as the snapshot structure serves multiple purposes and multiple threads without duplication.
3Reliability
If limiters are applied to workload classes to control thread execution, then resource management reliability is improved, but system performance overhead increases
Solution Approach 1:
The patent applies preliminary action by pre-calculating and storing the aggregate limits for each workload class and statement in the snapshot objects. Instead of performing complex limit calculations and aggregations during runtime for every thread execution, the system prepares the limit information in advance within the snapshot structure. This preliminary preparation ensures reliable resource management while minimizing performance overhead during actual job execution.
Solution Approach 2:
The patent uses copying by creating a snapshot copy of the hierarchy structure that includes embedded limit information. This snapshot copy contains the necessary limit data needed for resource management decisions, allowing threads to reference pre-computed limits rather than recalculating them. This approach maintains reliable resource control while improving performance by avoiding redundant calculations during execution.
Data Source
AI summary
The present disclosure relates to computer-implemented methods, software, and systems for flexibly managing limits for execution of jobs in parallel threads provided by a system. A request for the execution of a first statement at one or more threads associated with parallel processing at the system is received. A first snapshot object of an initial hierarchy of workload classes is obtained. The first snapshot object includes pointers to limiters defined for the workload classes and statements within the initial hierarchy. Each limiter defines an allowable number of threads for parallel execution of jobs. A modification to the hierarchy of workload classes is performed during runtime of the one or more jobs. A second snapshot object of a modified hierarchy of the workload classes. The execution of one or more created jobs is completed based on complying with limits as aggregately calculated for the first statement.