Concurrent Object Runtime for Dynamic Task Distribution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing parallel and concurrent programming models struggle to efficiently utilize all available compute resources in large-scale distributed computing systems, particularly for dynamic and irregular applications with unknown data sizes or task numbers at runtime, leading to suboptimal performance and complex workload management.
Innovation Solution
A method for decomposing task-oriented computer programs into tasks dynamically at runtime, creating a tree structure with parent-child relationships, and managing task execution and distribution across compute nodes using a shared global memory, allowing non-blocking task creation and migration with reduced communication overhead.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Quantity of substance
If multi-threaded programming is used to utilize shared memory resources, then memory utilization is improved, but communication overhead increases significantly in distributed memory systems
Solution Approach 1:
The system segments the distributed computing system into compute nodes with private memory spaces, eliminating the need for shared memory communication. Each compute node operates independently with its own memory, removing the communication overhead associated with shared memory access in distributed systems.
Solution Approach 2:
The patent introduces a message passing interface as an intermediary for communication between compute nodes. This mediator handles all inter-node communication explicitly, replacing implicit shared memory access and allowing efficient utilization of distributed memory resources without the overhead of shared memory protocols.
2Reliability
If locks and synchronization primitives are used to control memory access, then memory access control is improved, but performance degrades significantly in distributed memory systems
Solution Approach 1:
By segmenting memory into private spaces at each compute node, the patent eliminates the need for locks and synchronization primitives. Each node has exclusive access to its own memory, removing the performance degradation caused by synchronization overhead in distributed systems.
Solution Approach 2:
Each compute node independently manages its own memory access without requiring external synchronization. The system achieves memory access control through explicit message passing rather than through locks, allowing each node to service its own memory operations autonomously and improving overall performance.
3Ease of operation
If static distribution schemes are used for workload management, then programming simplicity is improved, but adaptability to dynamic and irregular applications deteriorates
Solution Approach 1:
The patent implements dynamic workload distribution where tasks can be migrated between compute nodes at runtime based on system state and application needs. This dynamic approach maintains programming simplicity through a unified memory model while adapting to irregular and dynamic application patterns that static schemes cannot handle.
Solution Approach 2:
The virtual memory system provides a universal interface that works for both static and dynamic workloads. The same memory management mechanisms handle regular and irregular applications uniformly, eliminating the need for different programming approaches while maintaining adaptability through runtime task migration and load balancing.
4Productivity
If fine-grained parallelism is implemented to improve computational efficiency, then productivity is improved, but complexity of managing processes and dependencies increases tremendously
Solution Approach 1:
The patent introduces a runtime system as an intermediary that automatically manages fine-grained parallelism. This mediator handles task creation, migration, and dependency management, allowing developers to specify parallelism without directly managing the complexity of process coordination and synchronization.
Solution Approach 2:
Tasks automatically manage their own execution context and dependencies through the virtual memory system. The runtime system provides self-service mechanisms for task migration and load balancing, reducing the complexity of managing fine-grained parallel processes while maintaining high computational efficiency.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
A method (300) of executing a concurrent task-oriented computer program and related distributed computing system (100) for program execution are disclosed. Multiple compute nodes (110a-d) of the computing system are coupled to a shared global computer memory (120). The method comprises decomposing the task-oriented computer program into a plurality of tasks at runtime and adding dependencies (307) to created tasks to constrain an execution order thereof. Tasks with resolved start dependencies are distributed (313) across the different compute nodes and then executed (303) on the different compute nodes. Tasks that have finished execution and no child tasks outstanding are terminated. Task outputs are stored (316) as immutable objects in the shared global memory. Tasks are created dynamically in a parent-child relationship and according to a tree structure while executing.