Seamless Compiler Integration of Variable Precision Floating-Point Arithmetic

Jost, Tiago Trevisan; Durand, Yves; Fabre, Christian; Cohen, Albert; Perrot, Frederic

doi:10.1109/cgo51591.2021.9370331

Cited by 4 publications

(2 citation statements)

References 31 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Figure 4 illustrates the compiler-based approach as we have implemented it in an initial prototype. The compilation aspects of the VPfloat system [35,36] are similar, except they make the "pluggable float" type explicit in the language (C++). The programmer also needs to modify the source to use it.…”

Section: Compiler-basedmentioning

confidence: 99%

“…A nightmare scenario is having to rewrite the application using a new API. A more pleasant scenario is when the programming language supports pluggable number representations, such as Fortran 90's kind parameter for type specification, or the recent VPFloat [35,36] extension to C++. In this case, the programmer needs to modify much less source code, but they still must deal with cross-language issues (if even possible) and update and rebuild any libraries their codebase uses.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

FPVM

Dinda

Wanninger

et al. 2022

Proceedings of the 31st International Symposium on High-Performance Parallel and Distributed Computing

View full text Add to dashboard Cite

Alternatives to IEEE floating point arithmetic have become all the rage. Some extract more representational power out of the available bits. Others offer the potential for lower or higher precision than is available in IEEE-compatible hardware. Even an "interface to the real numbers" has recently been proposed. Using such alternative arithmetic systems within an existing scientific or other significant codebase is a major challenge, however. We explore how to address this challenge through virtualizing the IEEE floating point hardware, specifically on x64. The goal of the floating point virtual machine (FPVM) is to allow an existing application binary to be seamlessly extended to support the desired alternative arithmetic system with overheads determined by that system and not the virtualization mechanisms. We describe the prospects, issues, and tradeoffs for four different approaches for building FPVM: trap-and-emulate, trap-and-patch, binary transformation, and IR transformation. We then describe the design and implementation of our current design, which combines static binary analysis/translation and trap-and-emulate execution. We evaluate our FPVM implementation on several benchmarks, virtualizing them to use posits and MPFR. Finally, we comment on kernel-and hardwarelevel innovations that could further reduce overheads for floating point virtualization.

show abstract

Section: Compiler-basedmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%