Dynamic floating-point cancellation detection

Lam, Michael O.; Hollingsworth, Jeffrey K.; Stewart, G. W.

doi:10.1016/j.parco.2012.08.002

Cited by 40 publications

(22 citation statements)

References 10 publications

(10 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Cancelled bits have been used as an indicator for instability in existing works [4,25], in which executions are considered unstable if there is any operation causing a large number of cancelled bits. However, this causes a lot of false warnings because a lot of inflated errors are suppressed and thus do not cause any problems.…”

Section: The Essence Of Cancelled Bitsmentioning

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

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

Section: The Essence Of Cancelled Bitsmentioning

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

“…Recently, some floating-point precision estimation efforts have focused on detecting specific phenomena such as catastrophic cancellation [5,29]. BGRT can complement such efforts.…”

Section: Background and Microbenchmarkingmentioning

confidence: 99%

“…Recently proposed tools [5,29] pin-point the critical instructions of a program that cause high floating-point errors. They employ shadow value execution and keep track of each value's shadow value.…”

Section: Applicationsmentioning

confidence: 99%

Efficient search for inputs causing high floating-point errors

Chiang

Gopalakrishnan

Rakamarić

et al. 2014

Proceedings of the 19th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

View full text Add to dashboard Cite

Tools for floating-point error estimation are fundamental to program understanding and optimization. In this paper, we focus on tools for determining the input settings to a floating point routine that maximizes its result error. Such tools can help support activities such as precision allocation, performance optimization, and auto-tuning. We benchmark current abstraction-based precision analysis methods, and show that they often do not work at scale, or generate highly pessimistic error estimates, often caused by non-linear operators or complex input constraints that define the set of legal inputs. We show that while concrete-testing-based error estimation methods based on maintaining shadow values at higher precision can search out higher error-inducing inputs, suitable heuristic search guidance is key to finding higher errors. We develop a heuristic search algorithm called Binary Guided Random Testing (BGRT). In 45 of the 48 total benchmarks, including many real-world routines, BGRT returns higher guaranteed errors. We also evaluate BGRT against two other heuristic search methods called ILS and PSO, obtaining better results.

show abstract

“…Similarly, the function cost(P, ∆) transforms the program P according to ∆ and returns the cost of the transformed program. If a change set with a lower cost exists, the algorithm recurses with that smaller change set (lines 12-13 and 19); otherwise it restarts the algorithm with a finer-grained partition (lines [17][18][19]. In the special case where the granularity can no longer be increased, the algorithm returns the current ∆, which is a local minimum type configuration (lines 15-16).…”

Section: Figure 4: Lower Cost Configuration Search Algorithmmentioning

confidence: 99%

“…It also computes a shadow value side by side, but it stores an absolute error in double precision instead. Lam et al [19] propose a tool for detecting cancellation. Cancellation is detected by first computing the exponent of the result and the operands.…”

Section: Related Workmentioning

confidence: 99%

Precimonious

Rubio-González

Nguyen

et al. 2013

Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis

208

View full text Add to dashboard Cite

Given the variety of numerical errors that can occur, floatingpoint programs are difficult to write, test and debug. One common practice employed by developers without an advanced background in numerical analysis is using the highest available precision. While more robust, this can degrade program performance significantly. In this paper we present Precimonious, a dynamic program analysis tool to assist developers in tuning the precision of floating-point programs. Precimonious performs a search on the types of the floating-point program variables trying to lower their precision subject to accuracy constraints and performance goals. Our tool recommends a type instantiation that uses lower precision while producing an accurate enough answer without causing exceptions. We evaluate Precimonious on several widely used functions from the GNU Scientific Library, two NAS Parallel Benchmarks, and three other numerical programs. For most of the programs analyzed, Precimonious reduces precision, which results in performance improvements as high as 41%.

show abstract

Dynamic floating-point cancellation detection

Cited by 40 publications

References 10 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

Efficient search for inputs causing high floating-point errors

Precimonious

Contact Info

Product

Resources

About