Producer Graph Runtime for Parallel Application Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current programming techniques require significant programming skills and effort from application programmers to correctly write manual invocation sequencing code for parallelization, which can lead to errors and inefficiencies, especially in managing dependencies between methods and instances in object-oriented programming.
Innovation Solution
The introduction of a producer graph oriented programming framework that allows for the declaration of producer dependencies, enabling the runtime to automatically generate and execute producer graphs, thereby simplifying the parallelization and instrumentation of application programs by tracking and sequencing the execution of producers based on their dependencies.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If manual invocation sequencing code is written by application programmers to achieve parallelization, then the application program can be executed in parallel, but the programming complexity and effort increase significantly
Solution Approach 1:
The patent introduces a runtime system as an intermediary between the application program and the parallel execution environment. The runtime automatically generates invocation sequencing code based on producer dependency declarations, eliminating the need for programmers to manually write complex parallelization code while still achieving parallel execution capability
Solution Approach 2:
The application program declares producer dependencies in a simplified manner, and the runtime system automatically handles the complex task of generating and managing invocation sequencing code. This self-service approach allows the system to automatically resolve the parallelization complexity without requiring expert programming knowledge
2Reliability
If manual invocation sequencing code is written to manage producer dependencies, then execution sequencing can be controlled, but errors and inefficiencies increase
Solution Approach 1:
The runtime system automatically generates invocation sequencing code based on the declared producer dependencies, eliminating manual coding errors. The system self-sequences the execution of producers and their dependent methods, ensuring correctness without human intervention in the complex sequencing logic
Solution Approach 2:
The runtime system continuously monitors producer execution status and dynamically adjusts invocation sequencing based on actual execution progress and dependency satisfaction. This feedback mechanism ensures that sequencing decisions are based on real-time system state, improving reliability
3Ease of operation
If programmers manually manage dependencies between methods and instances, then execution control is achieved, but the burden on programmers increases
Solution Approach 1:
The runtime system acts as an intermediary that automatically manages the complex dependencies between producers, methods, and instances. Programmers only need to declare high-level producer dependencies, while the runtime handles the detailed tracking and sequencing of method invocations and instance creations
Solution Approach 2:
The runtime system creates and manages copies of producer dependency information in its internal data structures, allowing it to automatically track and manage dependencies without requiring programmers to manually replicate this complex information management task
Data Source
AI summary
Embodiments of parallelization and/or instrumentation in a producer graph oriented programming framework have been presented. In one embodiment, a request to run an application program is received, wherein object-oriented source code of the application program includes methods and producer dependency declarations, wherein the producer dependency declaration for a given method identifies a set of zero or more producers with outputs that are an input to the given method, wherein a producer is at least an instance and a method associated with that instance. Further, execution of the application program may be parallelized based on dependency between producers of the application program using the runtime. In some embodiments, the application program is instrumented using the runtime.