Griffin: grouping suspicious memory-access patterns to improve understanding of concurrency bugs

Abstract

This paper presents Griffin, a new fault-comprehension technique. Griffin provides a way to explain concurrency bugs using additional information over existing fault-localization techniques, and thus, bridges the gap between faultlocalization and fault-fixing techniques. Griffin inputs a list of memory-access patterns and a coverage matrix, groups those patterns responsible for the same concurrency bug, and outputs the grouped patterns along with suspicious methods and bug graphs. Griffin is the first technique that handles multiple concurrency bugs. This paper also describes the implementation of Griffin in Java and C++, and shows the empirical evaluation of Griffin on a set of subjects. The results show that, for our subjects, Griffin clusters failing executions and memory-access patterns for the same bug with few false positives, provides suspicious methods that contain the locations to be fixed, and runs e ciently.

Debugging non-deadlock concurrency bugs

“…Step 3, we have implemented the technique in a tool, called Griffin [14], and evaluated it on a set of Java and C++ programs with multiple concurrency bugs. To assist understanding of the concurrency bugs, the technique generates a graph, called a bug graph, that shows the context of accesses surrounding the concurrency bugs.…”

Effective fault localization and context‐aware debugging for concurrent programs

“…Griffin [22] is the most closely related work to Coadec-it first collects concurrency interthread read-write patterns and then generates a sequence of methods containing these patterns. However, the execution context output by Griffin is coarse grained (i.e., method) and may not provide enough information.…”

“…However, these techniques focus on sequential software and have not considered concurrent software systems. Griffin [22] generates context information of buggy locations in concurrent programs, which is mostly related to Coadec. However, the context is a sequence of methods within individual threads and does not describe communication across multiple threads and thus may not provide enough information for developers to understand the bugs.…”

“…F I G U R E 1 The overview of our Coadec framework Coadec differs from existing context-aware debugging techniques [16,21,22] because most existing techniques focus on sequential programs and do not consider control and data flow across multiple threads. Griffin [22] is the only work that uses contextual information to improve comprehension of concurrency bugs. Griffin clusters the faulty access patterns and outputs the grouped patterns along with suspicious methods.…”

Spectrum-Based Fault Localization for Diagnosing Concurrency Faults

“…Traditional fault localization techniques and static analysis fall short to detect these faults efficiently. Existing dynamic fault-localization techniques focus on pinpointing data-access patterns that are subject to concurrency faults [9,12,19,20,25]. Although these techniques are effective in capturing faulty data-access patterns, the corresponding code blocks should still be identified by the programmer to locate and fix the defect.…”