Parallel Dependency Execution via Pre-compiled Invocation Sequences
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Executing dependency problems on parallel processors is challenging due to the complexity of maintaining execution dependencies between processing elements, which often results in high computational complexity and long execution times.
Innovation Solution
A method and system that compile dependency problems into multiple execution sequences for concurrent execution on multiprocessor devices, such as GPUs, while preserving execution dependencies and scheduling processors to run these sequences in parallel, thereby bypassing internal scheduling policies and optimizing memory access.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If dependency problems are executed on parallel processors using conventional scheduling policies, then processor utilization is improved, but execution time increases and deterministic ordering cannot be guaranteed
Solution Approach 1:
The patent applies preliminary action by pre-arranging processing elements into execution sequences with deterministic ordering before execution begins. The compilation step creates a fixed invocation data structure that specifies the exact order of execution, eliminating the need for runtime scheduling decisions and ensuring predictable execution times while maintaining high processor utilization through parallel sequence execution.
2Reliability
If processing elements are arranged in execution sequences to preserve dependencies, then execution determinism is improved, but the complexity of arranging and synchronizing sequences increases
Solution Approach 1:
The patent extracts the scheduling complexity from the runtime execution phase and relocates it to the compilation phase. By creating execution sequences and invocation data structures during compilation, the runtime system only needs to follow predetermined instructions, significantly reducing runtime complexity while maintaining execution determinism. The synchronization mechanisms are also pre-configured rather than dynamically determined.
Solution Approach 2:
The invocation data structure serves as an intermediary between the dependency problem definition and the parallel execution. It captures the dependency relationships and transforms them into a format that can be efficiently executed on parallel processors, acting as a bridge that simplifies the interface between complex dependency management and parallel execution without requiring complex runtime scheduling.
3Reliability
If synchronization mechanisms are introduced to maintain execution dependencies, then dependency correctness is improved, but overhead and execution time increase
Solution Approach 1:
Synchronization mechanisms are introduced preliminarily during the compilation phase rather than being added dynamically at runtime. The compiler analyzes dependency relationships and inserts synchronization points only where necessary in the execution sequences, minimizing overhead. This approach ensures dependency correctness while reducing the impact of synchronization on overall execution time compared to dynamic synchronization approaches.
Data Source
AI summary
A computing method includes accepting a definition of a computing task (68), which includes multiple atomic Processing Elements (PEs—76) having execution dependencies (80). Each execution dependency specifies that a respective first PE is to be executed before a respective second PE. The computing task is compiled for concurrent execution on a multiprocessor device (32), which includes multiple processors (44) that are capable of executing a first number of the PEs simultaneously, by arranging the PEs, without violating the execution dependencies, in an invocation data structure (90) including a second number of execution sequences (98) that is greater than one but does not exceed the first number. The multiprocessor device is invoked to run software code that executes the execution sequences in parallel responsively to the invocation data structure, so as to produce a result of the computing task.