AtomTracker: A Comprehensive Approach to Atomic Region Inference and Violation Detection

Muzahid, Abdullah; Otsuki, Norimasa; Torrellas, Josep

doi:10.1109/micro.2010.32

Cited by 26 publications

(32 citation statements)

References 24 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…This approach constrains program execution all the time to prevent potential manifestations of some concurrency bugs. For example, Atomtracker [21] and AtomAid [17] group instructions into chunks and execute every chunk atomically. This approach constrains interleavings even during correct runs and relies on transactional memory or other custom hardware to achieve good performance.…”

Section: Motivationmentioning

confidence: 99%

AI: a lightweight system for tolerating concurrency bugs

Zhang

et al. 2014

Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering

View full text Add to dashboard Cite

Concurrency bugs are notoriously difficult to eradicate during software testing because of their non-deterministic nature. Moreover, fixing concurrency bugs is time-consuming and error-prone. Thus, tolerating concurrency bugs during production runs is an attractive complementary approach to bug detection and testing. Unfortunately, existing bug-tolerating tools are usually either 1) constrained in types of bugs they can handle or 2) requiring roll-back mechanism, which can hitherto not be fully achieved efficiently without hardware supports.This paper presents a novel program invariant, called Anticipating Invariant (AI), which can help anticipate bugs before any irreversible changes are made. Benefiting from this ability of anticipating bugs beforehand, our software-only system is able to forestall the failures with a simple thread stalling technique, which does not rely on execution roll-back and hence has good performance Experiments with 35 real-world concurrency bugs demonstrate that AI is capable of detecting and tolerating most types of concurrency bugs, including both atomicity and order violations. Two new bugs have been detected and confirmed by the corresponding developers. Performance evaluation with 6 representative parallel programs shows that AI incurs negligible overhead (< 1%) for many nontrivial desktop and server applications.

show abstract

Section: Motivationmentioning

confidence: 99%

AI: a lightweight system for tolerating concurrency bugs

Zhang

et al. 2014

Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering

View full text Add to dashboard Cite

show abstract

“…LiteRace [21] and ReEnact [27] track concurrent programs' memory accesses to detect data races. AVIO [19] and AtomTracker [23] aim for atomicity violations. Our framework shares the idea of reducing runtime overheads by customizing the type of tracking information with these tools.…”

Section: Related Workmentioning

confidence: 99%

Practical lock/unlock pairing for concurrent programs

Cho

Kelly

Wang

et al. 2013

Proceedings of the 2013 IEEE/ACM International Symposium on Code Generation and Optimization (CGO)

View full text Add to dashboard Cite

In the multicore era, developers face increasing pressure to parallelize their programs. However, building correct and efficient concurrent programs is substantially more difficult than building sequential ones. To address the multicore challenge, numerous tools have been developed to assist multithreaded programmers, including static and dynamic bug detectors, automated bug fixers, and optimization tools. Many of these tools rely on or benefit from the precise identification of critical sections, i.e., sections where the thread of execution holds at least one lock. For languages where critical sections are not lexically scoped, e.g., C/C++, static analysis often fails to pair up lock and unlock calls correctly.In this paper, we propose a practical lock/unlock pairing mechanism that combines static analysis with dynamic instrumentation to identify critical sections in POSIX multithreaded C/C++ programs. Our method first applies a conservative inter-procedural path-sensitive dataflow analysis to pair up all lock and unlock calls. When the static analysis fails, our method makes assumptions about the pairing using common heuristics. These assumptions are checked at runtime using lightweight instrumentation. Our experiments show that only one out of 891 lock/unlock pairs violates our assumptions at runtime and the instrumentation imposes negligible overhead of 3.34% at most, for large open-source server programs. Overall, our mechanism can pair up 98.2% of all locks including 7.1% of them paired speculatively.

show abstract

“…Pacman is also related to the many software or hardware schemes that detect and avoid atomicity violations, such as AVIO [11], AtomAid [12], AtomTracker [15], or LifeTx [31]. While Pacman focuses on avoiding races rather than atomicity violations, its hardware is effectively being used to keep atomicity, albeit for only user-defined critical sections.…”

Section: Other Related Workmentioning

confidence: 99%

Pacman: Tolerating asymmetric data races with unintrusive hardware

Otsuki

Nogueira

et al. 2012

IEEE International Symposium on High-Performance Comp Architecture

Self Cite

View full text Add to dashboard Cite

Data races are a major contributor to parallel software unreliability. A type of race that is both common and typically harmful is the Asymmetric data race. It occurs when at least one of the racing threads is inside a critical section. Current proposals that target them are software-based. They slow down execution and require significant compiler, operating system (OS), or application changes.This paper proposes the first scheme to tolerate asymmetric data races in production runs with negligible execution overhead. The scheme, called Pacman, exploits cache coherence hardware to temporarily protect the variables that a thread accesses in a critical section from other threads' requests. Unlike previous schemes, Pacman induces negligible slowdown, needs no support from the compiler or (in the baseline design) from the OS, and requires no application source code changes. In addition, its hardware is relatively unintrusive. We test Pacman with the SPLASH-2, PARSEC, Sphinx3, and Apache codes, and discover two unreported asymmetric data races.

show abstract

AtomTracker: A Comprehensive Approach to Atomic Region Inference and Violation Detection

Cited by 26 publications

References 24 publications

AI: a lightweight system for tolerating concurrency bugs

AI: a lightweight system for tolerating concurrency bugs

Practical lock/unlock pairing for concurrent programs

Pacman: Tolerating asymmetric data races with unintrusive hardware

Contact Info

Product

Resources

About