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

Please wait, while we are loading the content...

Empirical analysis of programming language adoption

Efficient context sensitivity for dynamic analyses via calling context uptrees and customized memory management

CDSchecker: checking concurrent data structures written with C/C++ atomics

Instant pickles: generating object-oriented pickler combinators for fast and extensible serialization

Set-based pre-processing for points-to analysis

Semi-automatic rename refactoring for JavaScript

Data-driven equivalence checking

Do developers benefit from generic types?: an empirical comparison of generic and raw types in java

Multiverse: efficiently supporting distributed high-level speculation

Barrier invariants: a shared state abstraction for the analysis of data-dependent GPU kernels

Input-covering schedules for multithreaded programs

Combining concern input with program analysis for bloat detection

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

Steering symbolic execution to less traveled paths

Miniboxing: improving the speed to code size tradeoff in parametric polymorphism translations

Effective race detection for event-driven programs

Interacting with dead objects

MrCrypt: static analysis for secure cloud computations

Refactoring with synthesis

Synthesis modulo recursive functions

Option contracts

Fully concurrent garbage collection of actors on many-core machines

Guided GUI testing of android apps with minimal restart and approximate learning

OCTET: capturing and controlling cross-thread dependences efficiently

Injecting mechanical faults to localize developer faults for evolving software

Bounded partial-order reduction

Verifying quantitative reliability for programs that execute on unreliable hardware

Taking off the gloves with reference counting Immix

Storage strategies for collections in dynamically typed languages

Python: the full monty

Ironclad C++: a library-augmented type-safe subset of c++

Bottle graphs: visualizing scalability bottlenecks in multi-threaded applications

Code optimizations using formally verified properties

Language support for dynamic, hierarchical data partitioning

Isolation for nested task parallelism

Targeted and depth-first exploration for systematic testing of android apps

Online feedback-directed optimizations for parallel Java code

Efficient concurrency-bug detection across inputs

On-the-fly capacity planning

Resurrector: a tunable object lifetime profiling technique for optimizing real-world programs

Forsaking inheritance: supercharged delegation in DelphJ

Flexible access control for javascript

Ball-Larus path profiling across multiple loop iterations

Inductive invariant generation via abductive inference

Class hierarchy complementation: soundly completing a partial type graph

Turning nondeterminism into parallelism

The latency, accuracy, and battery (LAB) abstraction: programmer productivity and energy efficiency for continuous mobile context sensing

River trail: a path to parallelism in JavaScript

Detecting API documentation errors

Relaxed separation logic: a program logic for C11 concurrency

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

Content Provider	ACM Digital Library
Author	Bao, Tao Zhang, Xiangyu
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 on-the-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.
Starting Page	817
Ending Page	832
Page Count	16
File Format	PDF
ISBN	9781450323741
DOI	10.1145/2509136.2509526
Language	English
Publisher	Association for Computing Machinery (ACM)
Publisher Date	2013-10-29
Publisher Place	New York
Access Restriction	Subscribed
Subject Keyword	Discrete factors Floating point representation Instability Continuity Floating point errors Sampling
Content Type	Text
Resource Type	Article

Sl.	Authority	Responsibilities	Communication Details
1	Ministry of Education (GoI), Department of Higher Education	Sanctioning Authority	https://www.education.gov.in/ict-initiatives
2	Indian Institute of Technology Kharagpur	Host Institute of the Project: The host institute of the project is responsible for providing infrastructure support and hosting the project	https://www.iitkgp.ac.in
3	National Digital Library of India Office, Indian Institute of Technology Kharagpur	The administrative and infrastructural headquarters of the project	Dr. B. Sutradhar bsutra@ndl.gov.in
4	Project PI / Joint PI	Principal Investigator and Joint Principal Investigators of the project	Dr. B. Sutradhar bsutra@ndl.gov.in Prof. Saswat Chakrabarti will be added soon
5	Website/Portal (Helpdesk)	Queries regarding NDLI and its services	support@ndl.gov.in
6	Contents and Copyright Issues	Queries related to content curation and copyright issues	content@ndl.gov.in
7	National Digital Library of India Club (NDLI Club)	Queries related to NDLI Club formation, support, user awareness program, seminar/symposium, collaboration, social media, promotion, and outreach	clubsupport@ndl.gov.in
8	Digital Preservation Centre (DPC)	Assistance with digitizing and archiving copyright-free printed books	dpc@ndl.gov.in
9	IDR Setup or Support	Queries related to establishment and support of Institutional Digital Repository (IDR) and IDR workshops	idr@ndl.gov.in

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

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

RAIVE: runtime assessment of floating-point instability by vectorization

Automatic detection of floating-point exceptions

White box sampling in uncertain data processing enabled by program analysis

A dynamic program analysis to find floating-point accuracy problems

Restructuring parallel programs for on-the-fly race detection.

Correct Handling of Floating-Point Computations in Symbolic Execution

Hotspot symbolic execution of floating-point programs

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

Similar Documents

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

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

RAIVE: runtime assessment of floating-point instability by vectorization

Automatic detection of floating-point exceptions

White box sampling in uncertain data processing enabled by program analysis

A dynamic program analysis to find floating-point accuracy problems

Restructuring parallel programs for on-the-fly race detection.

Correct Handling of Floating-Point Computations in Symbolic Execution

Hotspot symbolic execution of floating-point programs

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