Compile-Time Execution for Graphical Code Optimization
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
High-performance applications in programmable hardware, such as FPGAs, face challenges in timing and resource constraints, making it difficult to predict and optimize code implementations, especially when converting high-level graphical code like LabVIEW into executable FPGA code, which requires significant manual analysis and is error-prone.
Innovation Solution
A method for compiling high-level graphical code that involves executing portions of the code during compilation to analyze and optimize variables, applying transformations such as loop pipelining, data type conversion, and dead code removal, to generate optimized machine code for FPGA implementation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If manual analysis and testing are used to validate code choices during compilation, then timing and resource constraints can be checked, but the process becomes difficult, tedious, and error-prone
Solution Approach 1:
The system performs self-validation by automatically executing the compiled code on the target device during the compilation process itself. The code validates its own timing and resource usage without requiring external manual testing, thereby improving reliability while reducing operational complexity.
Solution Approach 2:
The validation process is performed preliminarily during compilation rather than after. By executing the code on the target device during the compilation phase, timing and resource constraints are validated before final deployment, preventing errors rather than detecting them later.
2Productivity
If code is compiled to working FPGA implementation, then high-performance application can be deployed, but timing and resource constraints become difficult to predict at high-level modeling stage
Solution Approach 1:
The target device itself serves as an intermediary validation platform. By executing the compiled code on the actual FPGA hardware during compilation, the system obtains accurate measurements of timing and resource usage that bridge the gap between high-level modeling predictions and final deployment performance.
Solution Approach 2:
The patent replaces manual analysis and prediction methods with automated execution-based measurement. Instead of relying on theoretical calculations during high-level modeling, the actual code execution on target hardware provides empirical data about timing and resource constraints.
3Manufacturing precision
If compile time execution is performed to gather value information for optimization, then optimization accuracy improves, but compilation complexity increases
Solution Approach 1:
The compiled code performs self-measurement during execution on the target device. By automatically gathering value information about variables and array indices during runtime execution, the system eliminates the need for complex external analysis tools while achieving high optimization accuracy.
Solution Approach 2:
The validation and information gathering process occurs continuously during the normal execution of the code on the target device. Rather than requiring separate analysis phases, the useful action of code execution simultaneously performs validation and collects optimization data.
Data Source
AI summary
When compiling high level, graphical code (e.g. LabVIEW™ code) representative of a design, parts of the code that do not depend on external input data may be executed during the compilation process. Specific variables and/or value traces of specific variables in the program, e.g. constant values and/or repeating patterns may be recorded then analyzed, and certain transformations may be applied in the compilation process according to the results of the analysis, thereby optimizing the design. In one approach, the graph may be dynamically stepped through one node at a time, and it may be determined whether all inputs to the stepped-through node are known. If those inputs are known, type conversion and the operation corresponding to the stepped-through node may be dynamically performed. In another approach, a subset of the graphical code not depending on external data may be compiled and executed, thereby obtaining the same results as described above.