A survey of race bug detection techniques for multithreaded programmes

Hong, Shin; Kim, Moonzoo

doi:10.1002/stvr.1564

Cited by 27 publications

(13 citation statements)

References 73 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…This is in line with classic static and dynamic analyses of concurrent programs [38][39][40][41]. However, our notion of lock summary slightly differs from the classic notion of lockset [42], largely adopted by dynamic and static concurrency bug detectors [24,25,39,40,[43][44][45]. The classic lockset is defined at the granularity level of single instructions, while we define lock summary at the granularity level of sets of instructions.…”

Section: Definitionmentioning

confidence: 74%

Statically driven generation of concurrent tests for thread‐safe classes

Terragni

Pezzè

2021

Software Testing Verif & Rel

View full text Add to dashboard Cite

Concurrency testing is an important activity to expose concurrency faults in thread-safe classes. A concurrent test for a thread-safe class is a set of method call sequences that exercise the public interface of the class from multiple threads. Automatically generating fault-revealing concurrent tests within an affordable time budget is difficult due to the huge search space of possible concurrent tests. In this paper, we present DEPCON + , a novel approach that reduces the search space of concurrent tests by leveraging statically computed dependencies among public methods. DEPCON + exploits the intuition that concurrent tests can expose thread-safety violations that manifest exceptions or deadlocks, only if they exercise some specific method dependencies. DEPCON + provides an efficient way to identify such dependencies by statically analysing the code and relies on the computed dependencies to steer the test generation towards those concurrent tests that exhibit the computed dependencies. We developed a prototype DEPCON + implementation for Java and evaluated the approach on 19 known concurrency faults of thread-safe classes that lead to thread-safety violations of either exception or deadlock type. The results presented in this paper show that DEPCON + is more effective than state-of-the-art approaches in exposing the concurrency faults. The search space pruning of DEPCON + dramatically reduces the search space of possible concurrent tests, without missing any thread-safety violations.

show abstract

Section: Definitionmentioning

confidence: 74%

Statically driven generation of concurrent tests for thread‐safe classes

Terragni

Pezzè

2021

Software Testing Verif & Rel

View full text Add to dashboard Cite

show abstract

“…Note that while the threads share global memory locations (a source of dependency), the accesses are not concurrent in any interleaving. For instance in Figure 1, although the main thread and the first thread access the first slot in arr at lines 5 and 21, there can be no other execution of the program where line 21 is executed before line 5 due to the explicit synchronization call pthread_join (line 19).…”

Section: Motivating Examplementioning

confidence: 99%

“…The problem of whether a program is thread safe is outside the scope of this work, and is covered elsewhere [19], [7].…”

Section: Motivating Examplementioning

confidence: 99%

“…If a new scope event for thread t is encountered, e.g., entering a function, the current global index is stored in sp[t] for later use (line 17). In case e is an exit scope event, the algorithm updates the validity of all objects that were added after sp[t] and restores the previous stack pointer (lines [19][20][21]. Objects that were added after sp[t] represent the objects that have to be de-allocated because the program is leaving the scope where they were defined.…”

Section: Algorithmsmentioning

confidence: 99%

See 1 more Smart Citation

TraceSanitizer - Eliminating the Effects of Non-Determinism on Error Propagation Analysis

Saissi

Winter

Schwahn

et al. 2020

2020 50th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN)

View full text Add to dashboard Cite

Modern computing systems typically relax execution determinism, for instance by allowing the CPU scheduler to interleave the execution of several threads. While beneficial for performance, execution non-determinism affects programs' execution traces and hampers the comparability of repeated executions. We present TraceSanitizer, a novel approach for execution trace comparison in Error Propagation Analyses (EPA) of multi-threaded programs. TraceSanitizer can identify and compensate for nondeterminisms caused either by dynamic memory allocation or by non-deterministic scheduling. We formulate a condition under which TraceSanitizer is guaranteed to achieve a 0% false positive rate and automate its verification using Satisfiability Modulo Theory (SMT) solving techniques. TraceSanitizer is comprehensively evaluated using execution traces from the PARSEC and Phoenix benchmarks. In contrast with other approaches, Trace-Sanitizer eliminates false positives without increasing the false negative rate (for a specific class of programs), with reasonable performance overheads.

show abstract

“…Yu et al [2005] believe that łdata races almost always indicate a programming error and such errors are notoriously diicult to ind and debug, due to the non-deterministic nature of multi-threaded programmingž. There is a large body of research on tools to discover and remove races (for example, Hong and Kim [2015]). Other than the Java language feature mentioned above, data races in programmes running over Sapphire are type-safe, and at worst may leave an old value in a non-volatile ield.…”

Section: The Original Sapphire Algorithmmentioning

confidence: 99%