Compiler Approximation via Tile Segmentation for Accuracy-Speed Trade-off
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Compute-bound programs face challenges in optimizing performance due to the introduction of computation errors when replacing precise functions with approximations, which can affect execution time, energy consumption, and parallelization, especially in applications like ISR kernels and SAR applications.
Innovation Solution
The system automates transformations to reduce the number of computations by approximating function evolution within a bounded domain, allowing for tradeoffs between approximation, execution time, energy, and power, while ensuring tolerable computation errors through dynamic precision guarantees and adaptive tile sizing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If precise numerical library functions are used for every loop iteration, then computation accuracy is maintained, but execution time and energy consumption increase significantly
Solution Approach 1:
The patent segments the computation domain into tiles, where each tile contains multiple loop iterations. Within each tile, only the first iteration uses the precise numerical library function while subsequent iterations use approximate computations. This segmentation allows the system to maintain accuracy where needed (first iteration of each tile) while improving performance (subsequent iterations), directly resolving the contradiction between computation accuracy and execution time.
Solution Approach 2:
The patent changes the computation parameter from always-precise to conditionally-precise based on the iteration position within a tile. By introducing a tile structure with a threshold parameter, the system dynamically adjusts the precision level: precise computation is applied when the iteration index is less than the tile size, while approximate computation is used otherwise. This parameter change enables the system to balance accuracy and execution time effectively.
2Productivity
If approximate procedures are used to reduce computation cost, then execution time decreases, but computation errors increase and may produce erroneous results
Solution Approach 1:
The patent applies preliminary action by computing the precise value in the first iteration of each tile before applying approximate computations to subsequent iterations. This preliminary precise computation establishes a reference point that ensures accuracy is maintained at critical positions, while allowing approximate computations to improve overall execution time. The tile-based structure ensures that approximate computations are bounded and controlled.
Solution Approach 2:
The system implicitly uses feedback by structureuring computations in tiles where each tile's first iteration provides a precise reference that feeds into subsequent approximate iterations. This creates a feedback mechanism where precise computations periodically correct and bound the accumulation of approximation errors, ensuring that reliability is maintained while benefiting from faster approximate computations.
3Productivity
If ad hoc approximation replacements are applied, then computation speed improves, but loop tiling and memory locality optimizations are adversely affected
Solution Approach 1:
The patent creates a universal tile-based framework that simultaneously enables multiple optimization goals. The same tile structure that facilitates approximate computations also supports loop tiling, memory locality optimization, and parallelization. By making the approximation mechanism universal and integrated into the tile structure rather than ad hoc, the system achieves computation speed improvement without adversely affecting other optimizations. The tile size parameter can be tuned to balance approximation benefits with memory and parallelization requirements.
Data Source
AI summary
A compilation system can apply a smoothness constraint to the arguments of a compute-bound function invoked in a software program, to ensure that the value(s) of one or more function arguments are within specified respective threshold(s) from selected nominal value(s). If the constraint is satisfied, the function invocation is replaced with an approximation thereof. The smoothness constraint may be determined for a range of value(s) of function argument(s) so as to determine a neighborhood within which the function can be replaced with an approximation thereof. The replacement of the function with an approximation thereof can facilitate simultaneous optimization of computation accuracy, performance, and energy/power consumption.