Type-based race detection for Java

Flanagan, Cormac; Freund, Stephen N.

doi:10.1145/349299.349328

Cited by 324 publications

(200 citation statements)

References 27 publications

Supporting

Mentioning

199

Contrasting

Order By: Relevance

“…These techniques either require manual effort and do not apply to GPUs. Others focus on multi-threaded programs synchronizing using locks and semaphores [8]. These methods are impractical for GPU kernels.…”

Section: Resultsmentioning

confidence: 99%

Parametric flows: Automated behavior equivalencing for symbolic analysis of races in CUDA programs

Gopalakrishnan

2012

2012 International Conference for High Performance Computing, Networking, Storage and Analysis

View full text Add to dashboard Cite

Abstract-The growing scale of concurrency requires automated abstraction techniques to cut down the effort in concurrent system analysis. In this paper, we show that the high degree of behavioral symmetry present in GPU programs allows CUDA race detection to be dramatically simplified through abstraction. Our abstraction techniques is one of automatically creating parametric flows-control-flow equivalence classes of threads that diverge in the same manner-and checking for data races only across a pair of threads per parametric flow. We have implemented this approach as an extension of our recently proposed GKLEE symbolic analysis framework and show that all our previous results are dramatically improved in that (i) the parametric flowbased analysis takes far less time, and (ii) because of the much higher scalability of the analysis, we can detect even more data race situations that were previously missed by GKLEE because it was forced to downscale examples to limit analysis complexity. Moreover, the parametric flow-based analysis is applicable to other programs with SPMD models.

show abstract

Section: Resultsmentioning

confidence: 99%

Parametric flows: Automated behavior equivalencing for symbolic analysis of races in CUDA programs

Gopalakrishnan

2012

2012 International Conference for High Performance Computing, Networking, Storage and Analysis

View full text Add to dashboard Cite

show abstract

“…The first attempt to address this problem focused on detecting race conditions 5 . Static analysis techniques addressing this issue include those based on type systems [6], model checking [16], and general program analysis [17]. There were also dynamic analysis techniques proposed like RecPlay [23] and Eraser [24] However, these techniques were subject to a significant number of false positives.…”

Section: Related Workmentioning

confidence: 99%

Spectrum-Based Fault Localization for Diagnosing Concurrency Faults

Koca

Sözer

Abreu

2013

Testing Software and Systems

View full text Add to dashboard Cite

Abstract. Concurrency faults are activated by specific thread interleavings at runtime. Traditional fault localization techniques and static analysis fall short to diagnose these faults efficiently. Existing dynamic fault-localization techniques focus on pinpointing data-access patterns that are subject to concurrency faults. In this paper, we propose a spectrum-based fault localization technique for localizing faulty code blocks instead. We systematically instrument the program to create versions that run in particular combinations of thread interleavings. We run tests on all these versions and utilize spectrum-based fault localization to correlate detected errors with concurrently executing code blocks. We have implemented a tool and applied our approach on several industrial case studies. Case studies show that our approach can effectively and efficiently localize concurrency faults.

show abstract

“…Several static type systems have been proposed that prevent races (e.g., [12,13,21]) and ensure stronger properties such as determinism [9]. By rejecting potentially racy programs, these type systems ensure that all program executions have SC semantics.…”

Section: Guaranteeing End-to-end Sequential Consistencymentioning

confidence: 99%

A case for an SC-preserving compiler

Marino

Singh

Millstein

et al. 2011

Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

The most intuitive memory consistency model for shared-memory multi-threaded programming is sequential consistency (SC). However, current concurrent programming languages support a relaxed model, as such relaxations are deemed necessary for enabling important optimizations. This paper demonstrates that an SC-preserving compiler, one that ensures that every SC behavior of a compiler-generated binary is an SC behavior of the source program, retains most of the performance benefits of an optimizing compiler. The key observation is that a large class of optimizations crucial for performance are either already SC-preserving or can be modified to preserve SC while retaining much of their effectiveness. An SC-preserving compiler, obtained by restricting the optimization phases in LLVM, a state-of-the-art C/C++ compiler, incurs an average slowdown of 3.8% and a maximum slowdown of 34% on a set of 30 programs from the SPLASH-2, PARSEC, and SPEC CINT2006 benchmark suites.While the performance overhead of preserving SC in the compiler is much less than previously assumed, it might still be unacceptable for certain applications. We believe there are several avenues for improving performance without giving up SC-preservation. In this vein, we observe that the overhead of our SC-preserving compiler arises mainly from its inability to aggressively perform a class of optimizations we identify as eager-load optimizations. This class includes common-subexpression elimination, constant propagation, global value numbering, and common cases of loop-invariant code motion. We propose a notion of interference checks in order to enable eager-load optimizations while preserving SC. Interference checks expose to the compiler a commonly used hardware speculation mechanism that can efficiently detect whether a particular variable has changed its value since last read.

show abstract

Type-based race detection for Java

Cited by 324 publications

References 27 publications

Parametric flows: Automated behavior equivalencing for symbolic analysis of races in CUDA programs

Parametric flows: Automated behavior equivalencing for symbolic analysis of races in CUDA programs

Spectrum-Based Fault Localization for Diagnosing Concurrency Faults

A case for an SC-preserving compiler

Contact Info

Product

Resources

About