Handling floating-point exceptions in numeric programs

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.

show abstract

“…divided-by-zero, overflow, and underflow) [3,8,18,24]. Particularly, [3] features solving floating point constraints.…”

Section: Related Workmentioning

confidence: 99%

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

BaoTao

ZhangXiangyu

2013

SIGPLAN Not.

View full text Add to dashboard Cite

show abstract

“…Note that addition and subtraction is exact near underflow [16], so we need no underflow unit in (2.2). More precisely, for a, b ∈ F we have…”

mentioning

confidence: 99%

Accurate Floating-Point Summation Part I: Faithful Rounding

Rump¹,

Ogita²,

Oishi³

2008

SIAM J. Sci. Comput.

162

199

View full text Add to dashboard Cite

Abstract. Given a vector of floating-point numbers with exact sum s, we present an algorithm for calculating a faithful rounding of s, i.e. the result is one of the immediate floating-point neighbors of s. If the sum s is a floating-point number, we prove that this is the result of our algorithm. The algorithm adapts to the condition number of the sum, i.e. it is fast for mildly conditioned sums with slowly increasing computing time proportional to the logarithm of the condition number. All statements are also true in the presence of underflow. The algorithm does not depend on the exponent range. Our algorithm is fast in terms of measured computing time because it allows good instruction-level parallelism, it neither requires special operations such as access to mantissa or exponent, it contains no branch in the inner loop, nor does it require some extra precision: The only operations used are standard floating-point addition, subtraction and multiplication in one working precision, for example double precision. Certain constants used in the algorithm are proved to be optimal.

show abstract

“…Note that underflow cannot hinder the result: this is a rather straightforward consequence of a fact that if x and y are radix-β floating-point numbers, and if the number RN (x + y) is subnormal, then RN (x + y) = x + y exactly (see [9] for a proof in radix 2, which easily generalizes to higher radices). Also, the only overflow that may occur is when adding a and b.…”

Section: B Previous Resultsmentioning

confidence: 99%

On the Computation of Correctly Rounded Sums

Kornerup

Lefèvre

Louvet

et al. 2012

IEEE Trans. Comput.

View full text Add to dashboard Cite

Abstract-This paper presents a study of some basic blocks needed in the design of floating-point summation algorithms. In particular, in radix-2 floating-point arithmetic, we show that among the set of the algorithms with no comparisons performing only floatingpoint additions/subtractions, the 2Sum algorithm introduced by Knuth is minimal, both in terms of number of operations and depth of the dependency graph. We investigate the possible use of another algorithm, Dekker's Fast2Sum algorithm, in radix-10 arithmetic. We give methods for computing, in radix 10, the floating-point number nearest the average value of two floating-point numbers. We also prove that under reasonable conditions, an algorithm performing only round-to-nearest additions/subtractions cannot compute the round-to-nearest sum of at least three floating-point numbers. Starting from an algorithm due to Boldo and Melquiond, we also present new results about the computation of the correctly-rounded sum of three floating-point numbers. For a few of our algorithms, we assume new operations defined by the recent IEEE 754-2008 Standard are available.

show abstract

Handling floating-point exceptions in numeric programs

Cited by 77 publications

References 27 publications

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

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

Accurate Floating-Point Summation Part I: Faithful Rounding

On the Computation of Correctly Rounded Sums

Contact Info

Product

Resources

About