FPchecker

This is a short description of FPChecker. A more detailed documentation can be found at github.com/LLNL/FPChecker and fpchecker.org/.

FPChecker (Floating-Point Checker) is a dynamic analysis tool to detect floating-point errors in HPC applications. It is the only tool of its class that supports the most common programming languages and models in HPC, including C/C++, MPI, OpenMP, and CUDA. It is designed to be easy to use and easy to integrate into applications. The tool provides a detailed HTML report that helps users identify the exact location of floating-point errors in the software.

Features

  • Easy to use: It only requires a few changes to the application build script, such as changing the compiler (e.g., clang++) by the FPChecker compiler wrappers (e.g., clang++-fpchecker). It automatically instruments the code at build time.
  • Accurate detection: It accurately detects errors dynamically (when code is executed) for specific inputs; it doesn’t give alarms for unused or invalid inputs.
  • Design for HPC: It supports the most used programming languages and models in HPC: C/C++, MPI, OpenMP, Pthreads, and CUDA.
  • Detailed report: It provides a detailed report that programmers can use to identify the exact location (file and line number) of floating-point errors in the software.

Errors and Warnings

FPChecker detects the following floating-point issues:

  • Infinity +: Detected when operations produce positive infinity, for example, when 1.0 / 0.0 occurs.
  • Infinity -: The same as infinity +, except that the sign of the resulting calculation is negative.
  • NaN (not a number): Results from invalid operations, such as 0/0 or sqrt(-1).
  • Division by zero: Occurs when a finite nonzero number is divided by zero. This typically produces either infinity or NaN.
  • Underflow (subnormal): Detected when an operation produces a subnormal number because the result was not representable as a normal number.
  • Comparison:  Occurs when two floating-point numbers are compared for equality. Sometimes checking if two floating-point numbers are equal can lead to inaccuracies.
  • Cancellation: Occurs when two nearly equal numbers are subtracted. By default, this event is detected when at least ten decimal digits are lost due to a subtraction.
  • Latent Infinity +: Detected when an operation produces a large normal and is close to positive infinity.
  • Latent Infinity -: Detected when an operation produces a large normal number and is close to negative infinity.
  • Latent underflow: Detected when an operation produces a small normal number and is close to becoming an underflow (subnormal number).

Contact

For questions, contact Ignacio Laguna at ilaguna@llnl.gov.

License

FPChecker is distributed under the terms of the Apache License (Version 2.0). All new contributions must be made under the Apache-2.0 license. See LICENSE and NOTICE on our FPChecker GitHub for details.