On-the-fly detection of instability problems in floating-point program execution

Abstract

The machine representation of floating point values has limited precision such that errors may be introduced during execution. These errors may get propagated and magnified by the following operations, leading to instability problems, e.g., control flow path may be undesirably altered and faulty output may be emitted. In this paper, we develop an onthe-fly efficient monitoring technique that can predict if an execution is stable. The technique does not explicitly compute errors as doing so incurs high overhead. Instead, it detects possible places where an error becomes substantially inflated regarding the corresponding value, and then tags the value with one bit to denote that it has an inflated error. It then tracks inflation bit propagation, taking care of operations that may cut off such propagation. It reports instability if any inflation bit reaches a critical execution point, such as a predicate, where the inflated error may induce substantial execution difference, such as different execution paths. Our experiment shows that with appropriate thresholds, the technique can correctly detect that over 99.999996% of the inputs of all the programs we studied are stable while a traditional technique relying solely on inflation detection mistakenly classifies majority of the inputs as unstable for some of the programs. Compared to the state of the art technique that is based on high precision computation and causes several hundred times slowdown, our technique only causes 7.91 times slowdown on average and can report all the true unstable executions with the appropriate thresholds.

A Genetic Algorithm for Detecting Significant Floating-Point Inaccuracies

“…Even in the worst case, we still have more than 28% of the significands invoking errors that are within two orders of magnitude difference of the largest error. Note that this result is consistent with the existing study [6]: Although a large portion of significands may invoke large errors, the probability of a random input invoking a large error is still very small, as both the significand and the exponent need to invoke large errors.…”

“…However, as reported by Bao and Zhang [6], there may be only a small portion of inputs among all possible inputs causing significant inaccuracies in the output. Thus, it would be quite difficult for developers to obtain such an input manually.…”

“…However, it is not easy to discover significant inaccuracies through searching. First, as our motivating example and an existing study [6] have shown, often only a very small portion among all possible floating-point numbers may lead to serious inaccuracies. When there is more than one input parameter for a floating-point function, the probability of hitting a large error becomes very low.…”

“…Second, precision-specific treatments are not very commonly used in practice. As a matter of fact, precision adjustment has been used in different approaches [6], [23]- [25], and no problem is reported as far as we know.…”

“…The difference between the standard result and the result in high-precision is the error of the result. Bao and Zhang [6] proposes to reduce the cost of detection by not computing the precise error but marking and tracking potentially inaccurate values. Based on similar ideas of tuning precision, Lam et al [24], Rubio-González [25], and Schkufza et al [23] propose approaches that automatically reduce the precision of floatingpoint computation to enhance performance with an acceptable loss of precision.…”