Dynamic Package Parallelization for Uneven Execution Workloads
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Software development lifecycle operations, particularly in cloud environments, are resource-intensive and inefficient due to the varying execution times of objects within software projects, leading to suboptimal execution times and resource utilization.
Innovation Solution
A method for dynamic parallelization of operations across multiple threads, adjusting the number of objects per package based on historical data and execution times to optimize package size and execution order, using an execution engine and testing framework to schedule tasks efficiently.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If a fixed pre-defined number of objects per package is used for parallel execution, then the package structure is simple and easy to manage, but the execution time and resource utilization are suboptimal due to varying execution times of different objects
Solution Approach 1:
The patent implements dynamic package size adjustment during parallel execution. The execution engine monitors object execution times and dynamically modifies the number of objects per package based on historical data and current execution progress. This transforms the static package configuration into a dynamic adaptive structure that optimizes resource utilization and reduces overall execution time while maintaining manageable complexity through automated adjustment.
Solution Approach 2:
The system changes the parameter of package size (number of objects per package) based on execution characteristics. By analyzing historical execution data and object complexity metrics, the execution engine adjusts package parameters to match the actual workload distribution, thereby improving productivity without requiring manual reconfiguration of the entire package structure.
2Productivity
If objects with varying execution times are distributed evenly across packages, then the distribution is simple, but long-running objects cause bottlenecks and increase overall execution time
Solution Approach 1:
The patent applies local quality by distributing objects with similar execution characteristics to the same package. The execution engine analyzes individual object execution times and groups them accordingly, ensuring that packages contain objects with comparable resource requirements. This local optimization prevents bottlenecks caused by mixing fast and slow-executing objects in the same package, thereby improving overall resource utilization and reducing total execution time.
Solution Approach 2:
The system dynamically adjusts package composition during execution based on real-time performance data. When long-running objects are detected, the execution engine can redistribute workloads or adjust package sizes to balance the load across parallel threads, preventing any single package from becoming a bottleneck and optimizing resource utilization throughout the execution process.
3Productivity
If the number of parallel threads is increased to reduce execution time, then productivity improves, but resource consumption increases
Solution Approach 1:
The patent implements staged parallel execution where packages are executed in multiple stages with varying degrees of parallelization. Rather than maximizing thread count throughout, the system uses a moderate number of threads in initial stages and adjusts parallelization intensity based on execution progress and resource availability. This partial parallelization approach achieves good productivity while avoiding excessive resource consumption associated with full parallelization across all stages.
Data Source
AI summary
The present disclosure relates to computer-implemented methods, software, and systems for dynamic execution of operations over multiple parallel threads. An execution of objects through packages using parallel threads is triggered at an execution engine. Each package of a first set of packages defined for the execution includes a pre-defined number of objects. It is determined to adjust the pre-defined number of objects per package as defined for the first set of packages at the parallel threads to an adjusted number of objects per package to define a second set of packages. The execution at the parallel threads can be adjusted to execute the second set of packages through the execution engine, wherein each package of the second set of packages includes the adjusted number of objects.