Task-Based Graph Execution Reducing Process Overhead
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing graph-based computation systems face inefficiencies in execution, particularly in reconfiguring data parallelism, load balancing, and startup times, due to unnecessary process initiation and resource wastage, and lack mechanisms for efficient data passing and scheduling between computation components.
Innovation Solution
A task-based computation system that uses a high-level program specification to control computation and storage resources, allowing for dynamic distribution and concurrent execution of fine-grained tasks across multiple servers, with a compiler/interpreter that identifies execution sets and prepares task-based specifications for efficient distribution and parallelization.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If processes are initiated at startup for each component in graph-based computation systems, then component execution is enabled, but startup time increases and memory is wasted due to unnecessary process initiation
Solution Approach 1:
The patent applies preliminary action by pre-compiling graph specifications into task-based specifications before execution, so that when the graph needs to run, the compilation work is already done. This eliminates compilation overhead during startup and reduces initialization time. The system prepares task specifications in advance rather than creating processes on-the-fly during execution.
Solution Approach 2:
The patent extracts the process creation overhead from the normal execution path by using a task-based model where tasks are invoked directly rather than through full process initialization. This separates the essential computation from the burdensome process startup ceremony, allowing lightweight task execution without the full overhead of process creation.
2Productivity
If multiple processes are used to host component instances in graph-based computation systems, then parallel execution is enabled, but memory consumption increases due to process overhead
Solution Approach 1:
The patent merges multiple component instances into a single process by using a task-based model where multiple tasks can be hosted within one process. Instead of requiring separate processes for each component instance, the system combines them, reducing the total number of processes and thereby reducing memory consumption while maintaining parallel execution capabilities through task-level parallelism.
Solution Approach 2:
The patent uses copying at the task level rather than process level. Multiple task instances can be created and executed in parallel within the same process, providing the necessary parallelism without duplicating entire process contexts. This allows efficient resource utilization by sharing process-level resources among multiple parallel tasks.
3Productivity
If graph specifications are compiled before execution, then execution efficiency is improved, but compilation time and complexity increase
Solution Approach 1:
The patent segments the compilation process into distinct phases: graph specification compilation into intermediate representation, and task-based specification generation. This segmentation allows the compilation to be done once and reused, reducing the perceived complexity. The intermediate representation serves as a stable bridge between graph and task models, making the compilation process more manageable and less error-prone.
4Productivity
If data flows are implemented using operating system data communication services, then data passing between components is enabled, but communication overhead and latency increase
Solution Approach 1:
The patent introduces task-based specifications as an intermediary layer between graph components and actual execution. This intermediary model allows for more efficient data passing mechanisms compared to direct OS data communication services, as tasks within the same process can share memory spaces and communicate more directly without the overhead of inter-process communication protocols.
Data Source
Figure 1
Figure 2A~2B
Figure 2C
AI summary
A graph-based program specification (110) includes components, at least one having at least one input port for receiving a collection of data elements, or at least one collection type output port for providing a collection of data elements. Executing a program specified by the graph-based program specification at a computing node (152), includes: receiving data elements of a first collection into a first storage in a first order via a link connected to a collection type output port of a first component and an input port of a second component, and invoking a plurality of instances of a task corresponding to the second component to process data elements of the first collection, including retrieving the data elements from the first storage in a second order, without blocking invocation of any of the instances until after any particular instance completes processing one or more data elements.