Architecture-aware Precision Tuning with Multiple Number Representation Systems

Abstract

Precision tuning trades accuracy for speed and energy savings, usually by reducing the data width, or by switching from floating point to fixed point representations. However, comparing the precision across different representations is a difficult task. We present a metric that enables this comparison, and employ it to build a methodology based on Integer Linear Programming for tuning the data type selection. We apply the proposed metric and methodology to a range of processors, demonstrating an improvement in performance (up to 9×) with a very limited precision loss (<2.8% for 90% of the benchmarks) on the PolyBench benchmark suite.

Mixed Precision in Heterogeneous Parallel Computing Platforms via Delayed Code Analysis

“…dta then determines which reduced-precision data type to use. The dta pass comes in two operation modes: a peepholebased algorithm in which each variable is assigned a fixed-point data type with the highest valid point position; and an ILP-based technique [1]. conv modifies the llvm-ir accordingly with the data type chosen by the previous passes, optionally replacing trigonometric function calls with higher-efficiency custom implementations [2].…”

“…In open loop mode, the final ranges for every buffer subject to DA are already known, therefore the only analysis being suspended is the data type allocation. Since the data type allocation depends primarily on the ranges [1], the first execution of taffo decides the data types for all variables, while the subsequent executions read the correct types from the auxiliary files. In closed loop mode, the value ranges of the buffer ID variables are not known a-priori.…”

Towards EXtreme scale technologies and accelerators for euROhpc hw/Sw supercomputing applications for exascale: The TEXTAROSSA approach

“…Based on programmer hints expressed as attributes, TAFFO performs value range analysis, data type and code conversion, and static estimation of the performance impact, automatically producing a mixed-precision application with statically-guaranteed error bounds. TAFFO is language-independent, supports data types ranging from fixed-point to standard floating-point formats, and allows the user to finely tune the performance-precision trade-off to their needs [28]. The extensions to TAFFO will allow it to cover a wider range of target platforms, such as FPGAs through integration with the TEXTAROSSA High Level Synthesis (HLS) toolchain.…”

TAFFO: The compiler-based precision tuner

“…A customisable cost function can take into account the overhead introduced by type cast operations only, which varies depending on the target architecture. A second more complex algorithm [11] builds a partial mathematical model of the program that describes the variation in execution time and output error for a given architecture depending on the data type selection. This model is fed into an integer-linear-programming constraint solver to select the optimal data types for each variable that must be optimized.…”

“…Thanks to the precision tuning optimization performed by taffo, the operating system scheduler state machine update function achieved a speedup up to 80%, the activity classification workload gained a speed-up of approximately 500%, and the algorithm for field-oriented control obtained a speedup of approximately 250%. The effectiveness of taffo has also been proven on well-known benchmark suites such as AxBench [24] and PolyBench [25] in works such as [11,26]. In particular, in [12] the usage of taffo for optimizing the implementation of trigonometric functions in the benchmarks of the AxBench suite resulted in energy savings of up to 60%.…”