Parallel Loop Execution via Dynamic Private Public Range Partitioning
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Efficient parallel execution of loops over integer index ranges on multiple processors is hindered by challenges in load balancing, synchronization overheads, and data locality, particularly due to the need for knowledge of workload characteristics and the impact of blocking code on processor utilization.
Innovation Solution
A dynamic range partitioning scheme is implemented, where index subsets are divided into private and public ranges, allowing threads to process private ranges without synchronization and public ranges with synchronization, with the ability to move boundary points and steal indices from other threads to maintain load balancing and reduce synchronization overheads.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If loop ranges are partitioned across processors for parallel execution, then processing speed is improved, but synchronization overheads increase
Solution Approach 1:
The loop index range is segmented into private ranges and public ranges. Private ranges are processed without synchronization, while public ranges are processed with synchronization. This segmentation allows most of the loop to execute in parallel without synchronization overhead, while still maintaining correctness for iterations that require coordination between threads.
Solution Approach 2:
Different parts of the loop are treated differently: iterations in private ranges are executed with local quality (no synchronization), while iterations in public ranges are executed with global coordination (synchronization). This allows each part of the loop to be optimized according to its specific requirements.
2Productivity
If loop ranges are partitioned across processors for parallel execution, then processing speed is improved, but load balancing becomes difficult
Solution Approach 1:
The partitioning of loop ranges is made dynamic rather than static. Threads can steal iterations from public ranges of other threads, and the boundary between private and public ranges can be adjusted during execution. This dynamic approach allows the system to adapt to varying workload characteristics and achieve better load balancing without requiring prior knowledge of workload distribution.
3Reliability
If synchronization is used for all loop iterations, then correctness is maintained, but processor utilization decreases due to thread blocking
Solution Approach 1:
The loop is segmented into private ranges that can be executed without synchronization and public ranges that require synchronization. By isolating only the necessary portions that require coordination, the majority of the loop can execute in parallel without blocking, thereby maintaining correctness while improving processor utilization.
Solution Approach 2:
Synchronization requirements are extracted and isolated to only those specific iterations that need coordination (public ranges). This allows the rest of the loop iterations to proceed without synchronization overhead, preventing unnecessary thread blocking and improving overall processor utilization.
Data Source
AI summary
A method of executing a loop over an integer index range of indices in a parallel manner includes assigning a plurality of index subsets of the integer index range to a corresponding plurality of threads, and defining for each index subset a start point of the index subset, an end point of the index subset, and a boundary point of the index subset positioned between the start point and the end point of the index subset. A portion of the index subset between the start point and the boundary point represents a private range and the portion of the index subset between the boundary point and the end point represents a public range. Loop code is executed by each thread based on the index subset of the integer index range assigned to the thread.