Runtime Data Flow Graph Refactoring Without Source Code Changes
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Developing data flow graph applications often requires iterative tuning of the graph structure to achieve optimal performance and scalability, which can be time-consuming and requires modifying source code, especially in distributed memory implementations.
Innovation Solution
A system that uses a data flow interface, an outliner controller, and a graph library to profile and refactor the data flow graph application without modifying the source code, by creating a map file that describes how the original graph structure and node properties can be mapped to a new structure, allowing the runtime system to transform the graph at runtime.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If developers manually modify source code to tune graph structure for optimal performance, then performance and scalability are improved, but development time increases and iterative tuning becomes time-consuming
Solution Approach 1:
The system performs preliminary profiling of the data flow graph application to automatically generate optimized graph structures. By pre-analyzing the application's execution characteristics and generating refactored graph configurations automatically, the system eliminates the need for manual iterative tuning, thus improving performance while reducing development time.
Solution Approach 2:
The patent introduces an intermediary system comprising a profiler, graph library, and runtime system that acts as a mediator between the original application code and the optimized graph structure. This intermediary automatically transforms the application into an optimized data flow graph without requiring direct manual modification of source code, resolving the contradiction between achieving optimal performance and minimizing development time.
2Adaptability or versatility
If developers iteratively tune graph structure to achieve optimal performance, then scalability is improved, but the process requires repeated source code modifications and recompilation
Solution Approach 1:
The system segments the graph structure optimization process into independent, parameterizable components. By allowing developers to specify optimization parameters (such as graph partitioning strategies, node aggregation rules, or edge routing preferences) without modifying source code, the system enables flexible scalability tuning while simplifying the overall process complexity.
Solution Approach 2:
The patent implements a dynamic graph transformation system where the graph structure can be adaptively refactored at runtime based on profiling data and specified optimization goals. This dynamic approach allows scalability to be tuned by changing runtime parameters rather than repeatedly modifying and recompiling source code, reducing process complexity while maintaining adaptability.
3Manufacturing precision
If source code is modified for each graph structure experiment, then graph structure optimization is achieved, but the frequency of modifications increases development overhead
Solution Approach 1:
The system creates a copy or representation of the application's data flow graph that can be independently optimized without modifying the original source code. The profiler generates a graphical representation of the application's execution flow, and the graph library operates on this copied structure to apply optimizations, allowing precise graph structure tuning while maintaining high development efficiency.
Data Source
AI summary
Systems and methods may provide refactoring data flow applications without source code changes or recompilation. An apparatus may create a map file that describes how an original graph structure and node properties are mapped to a new structure and set of properties. A runtime system aware of the mapping may transform a graph that is constructed by the data flow application into the new structure at runtime.