Runtime Queue Synchronization for Parallel Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current methods for parallelizing software programs on multi-processor computers are difficult and costly, especially for programs written in a sequential programming model, as they struggle to identify and exploit parallelization opportunities due to data dependencies, leading to inefficiencies in performance improvement.
Innovation Solution
The solution involves using synchronizing operations to enqueue computational operations with dependencies, delaying their execution until preceding operations are completed, allowing for focused serialization without limiting broader parallelization opportunities, thus enabling decentralized coordination and minimizing overhead.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If computational operations are parallelized on multi-processor computers, then software performance is improved, but data dependencies cause execution errors when read-write or write-read operations change order
Solution Approach 1:
The system segments computational operations into different execution queues based on their data access patterns. Operations that access the same data are grouped into the same queue to maintain serial execution order, while operations on disjoint data can execute in parallel on different queues, thus preserving both performance and correctness.
Solution Approach 2:
The patent introduces serializers as intermediary components that manage the execution order of computational operations. These serializers intercept operations, assign them to appropriate queues, and coordinate their execution to ensure that dependent operations maintain their correct order while allowing independent operations to proceed in parallel.
2Productivity
If static analysis is used to parallelize sequential programs, then parallelization opportunities can be identified, but the analysis cannot identify opportunities determined only at execution time when data being read or written can be positively identified
Solution Approach 1:
The system performs preliminary static analysis to identify potential parallelization opportunities and set up execution queues before runtime. However, the final determination of data dependencies and queue assignment is deferred to runtime when actual data values are known, combining the benefits of both static and dynamic approaches.
Solution Approach 2:
The patent implements dynamic queue assignment based on runtime data values. The serializers examine actual data being read or written during execution to positively identify dependencies and make informed decisions about parallelization, rather than relying solely on static analysis of potential dependencies.
3Productivity
If computational operations are assigned to different queues for parallel execution, then performance is improved, but data dependencies between operations may cause errors
Solution Approach 1:
The system applies different execution strategies to different operations based on their local characteristics. Operations with data dependencies are assigned to the same queue with serial execution order, while operations on disjoint data are assigned to different queues for parallel execution. This local differentiation ensures correctness for dependent operations while maximizing parallelism for independent ones.
Data Source
AI summary
A system and method of parallelizing programs employs runtime instructions to identify data accessed by program portions and to assign those program portions to particular processors based on potential overlap between the access data. Data dependence between different program portions may be identified and used to look for pending “predicate” program portions that could create data dependencies and to postpone program portions that may be dependent while permitting parallel execution of other program portions.