Eraser

Savage, Stefan; Burrows, Michael T.; Nelson, Greg; Sobalvarro, Patrick; Anderson, Thomas E.

doi:10.1145/268998.266641

Cited by 163 publications

(4 citation statements)

References 13 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…(Coyote only instruments at the level of task APIs or synchronization operations.) Nonetheless, coyote rewrite is extensible, and the door is open for any contributor to take on this responsibility and implement race detection [22,49,23,51,50]. 3 Coyote Test Engine…”

Section: Architecture Extensibilitymentioning

confidence: 99%

“…For the assertion in this program to fail, an interleaving must essentially execute t1 to completion before t2 gets a chance. The chance of RW producing this interleaving is tiny: around 1 in 2 50 . If we imagine a thread-based scenario (ideal setting for PCT), where RunTest created two threads instead of tasks, then PCT (with d = 0) has 50% probability of hitting this bug.…”

Section: Exploration Strategiesmentioning

confidence: 99%

See 1 more Smart Citation

Industrial-Strength Controlled Concurrency Testing for $$\textsc {C}{} \texttt {\#} $$ Programs with $$\textsc {Coyote} $$

Deligiannis

Senthilnathan

Nayyar

et al. 2023

Lecture Notes in Computer Science

View full text Add to dashboard Cite

This paper describes the design and implementation of the open-source tool $$\textsc {Coyote} $$ C O Y O T E for testing concurrent programs written in the $$\textsc {C}{} \texttt {\#} $$ C # language. $$\textsc {Coyote} $$ C O Y O T E provides algorithmic capabilities to explore the state-space of interleavings of a concurrent program, with deterministic repro for any bug that it finds. $$\textsc {Coyote} $$ C O Y O T E encapsulates multiple ideas from the research community to offer state-of-the-art testing for $$\textsc {C}{} \texttt {\#} $$ C # programs, as well as an efficiently engineered implementation that has been shown robust enough to support industrial use.

show abstract

Section: Architecture Extensibilitymentioning

confidence: 99%

Section: Exploration Strategiesmentioning

confidence: 99%

Industrial-Strength Controlled Concurrency Testing for $$\textsc {C}{} \texttt {\#} $$ Programs with $$\textsc {Coyote} $$

Deligiannis

Senthilnathan

Nayyar

et al. 2023

Lecture Notes in Computer Science

View full text Add to dashboard Cite

show abstract

“…A large amount of research work has been devoted to detecting data races in OpenMP programs [2,3,5,6,14,16,18]. Based on the detection mechanisms, there are typically two types of race detection tools: static and dynamic.…”

Section: Related Workmentioning

confidence: 99%

“…That is, the two accesses may exhibit different execution results due to the lack of necessary synchronization to determine their happens-before order. To facilitate the detection of data races, a large amount of research effort has been devoted to automatic data race detection [2,3,5,6,14,18]. They typically employ a variety of static and dynamic program analysis techniques to figure out whether memory accesses issued by different threads may constitute data races.…”

mentioning

confidence: 99%

Does it matter?

Wang¹,

Lin

2021

Proceedings of the ACM International Conference on Supercomputing

View full text Add to dashboard Cite

Data races are a primary source of concurrency bugs in parallel programs. Yet, debugging data races is not easy, even with a large amount of data race detection tools. In particular, there still exists a manually-intensive and time-consuming investigation process after data races are reported by existing race detection tools. To address this issue, we present OMPSanitizer in this paper. OMPSanitizer employs a novel and semantic-aware impact analysis mechanism to assess the potential impact of detected data races so that developers can focus on data races with a high probability to produce a harmful impact. This way, OMPSanitizer can remove the heavy debugging burden of data races from developers and simultaneously enhance the debugging efficiency. We have implemented OMPSanitizer based on the widely-used dynamic binary instrumentation infrastructure, Intel Pin. Our evaluation results on a broad range of OpenMP programs from the DataRaceBench benchmark suite and an ECP Proxy application demonstrate that OMPSanitizer can precisely report the impact of data races detected by existing race detectors, e.g., Helgrind and ThreadSanitizer. We believe OMPSanitizer will provide a new perspective on automating the debugging support for data races in OpenMP programs. CCS CONCEPTS• Software and its engineering → Software testing and debugging; Parallel programming languages; Multithreading.

show abstract

Automated dynamic detection of busy–wait synchronizations

Tian¹,

Nagarajan²,

Gupta³

et al. 2009

Softw Pract Exp

View full text Add to dashboard Cite

With the advent of multicores, multithreaded programming has acquired increased importance. In order to obtain good performance, the synchronization constructs in multithreaded programs need to be carefully implemented. These implementations can be broadly classified into two categories: busy-wait and schedulebased. For shared memory architectures, busy-wait synchronizations are preferred over schedule-based synchronizations because they can achieve lower wakeup latency, especially when the expected wait time is much shorter than the scheduling time. While busy-wait synchronizations can improve the performance of multithreaded programs running on multicore machines, they create a challenge in program debugging, especially in detecting and identifying the causes of data races. Although significant research has been done on data race detection, prior works rely on one important assumption-the debuggers are aware of all the synchronization operations performed during a program run. This assumption is a significant limitation as multithreaded programs, including the popular SPLASH-2 benchmark have busy-wait synchronizations such as barriers and flag synchronizations implemented in the user code. We show that the lack of knowledge of these synchronization operations leads to unnecessary reporting of numerous races. To tackle this problem, we propose a dynamic technique for identifying user-defined synchronizations that are performed during a program run. Both software and hardware implementations are presented. Furthermore, our technique can be easily exploited by a record/replay system to significantly speedup the replay. It can also be leveraged by a transactional memory system to effectively resolve a livelock situation. Our evaluation confirms that our synchronization detector is highly accurate with no false negatives and very few false positives. We further observe that the knowledge of synchronization operations results in 23% reduction in replay time. Finally, we show that using synchronization knowledge livelocks can be efficiently avoided during runtime monitoring of programs.

show abstract

Eraser

Cited by 163 publications

References 13 publications

Industrial-Strength Controlled Concurrency Testing for $$\textsc {C}{} \texttt {\#} $$ Programs with $$\textsc {Coyote} $$

Industrial-Strength Controlled Concurrency Testing for $$\textsc {C}{} \texttt {\#} $$ Programs with $$\textsc {Coyote} $$

Does it matter?

Automated dynamic detection of busy–wait synchronizations

Contact Info

Product

Resources

About