Graphical Program Execution Contexts for Distributed Target Allocation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current graphical programming environments lack efficient methods for distributing graphical programs across multiple execution targets, leading to difficulties in load balancing, communication bandwidth management, and optimal component distribution, especially as application size and complexity increase.
Innovation Solution
A system and method for creating graphical programs that allow users to specify execution contexts for different code portions, enabling targeting of specific execution targets such as CPUs or remote platforms, with configuration options for resources and dependencies, and dynamic reconfiguration during runtime.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If graphical programs are distributed across multiple execution targets, then load balancing and execution efficiency are improved, but device complexity and difficulty of managing communication bandwidth increase
Solution Approach 1:
The patent introduces execution contexts as intermediary structures that manage the distribution of graphical program code across multiple execution targets. These contexts act as mediators between the graphical program and the underlying execution targets, handling load balancing and resource allocation automatically, thereby improving execution efficiency without significantly increasing user-facing complexity.
Solution Approach 2:
The patent segments the graphical program into multiple code portions that can be distributed across different execution targets. Each code portion is associated with a specific execution context that manages its execution on a particular target, enabling parallel execution and load balancing while maintaining manageable complexity through structured organization.
2Adaptability or versatility
If execution contexts are established for each code portion, then precise targeting and dynamic adaptation are enhanced, but device complexity and configuration overhead increase
Solution Approach 1:
The patent implements dynamic execution contexts that can be reconfigured at runtime based on system conditions and requirements. Execution contexts can dynamically allocate code portions to different execution targets, adjust resource allocation, and adapt to changing system states, providing high adaptability while the system manages the complexity of dynamic reconfiguration automatically.
3Power
If graphical programs are created with multiple execution targets, then resource utilization and processing capacity are improved, but ease of operation and programming difficulty increase
Solution Approach 1:
The patent enables the system to automatically manage the distribution and execution of graphical programs across multiple targets without requiring users to manually configure each execution context. The system self-services by automatically allocating code portions to appropriate execution targets, managing communication bandwidth, and optimizing resource utilization, thereby maintaining programming ease while utilizing high processing capacity.
Data Source
AI summary
System and method for creating a graphical program (GP) having portions that execute on different targets. A GP including a plurality of interconnected nodes visually indicating functionality of the program is created in response to user input, including a first graphical code portion with a first execution context specifying execution of the first graphical code portion on a first target. A second execution context indicating a second target for execution of a second graphical code portion of the GP is established in response to user input, e.g., by displaying a context structure indicating the second execution context and associating the second graphical code portion with the context structure in response to user input. During execution of the GP, the first graphical code portion executes on the first target using the first execution context, and the second graphical code portion executes on the second target using the second execution context.