Content area
Abstract
Multithreaded programming, where two or more processes operate simultaneously on the same data, introduces three specific classes of software bugs: data races, deadlocks and atomicity violations. Finding the code that is responsible for these bugs is difficult because programs may not execute the exact same way every time. This makes traditional debugging very difficult.
Two main approaches, static and dynamic, have been explored to detect such concurrency bugs. The static approach analyzes the source code of a program to search for potential errors. The strength of this approach is that, because all of the source code is analyzed, all potential errors can be caught. The weakness of this approach is that because the program has no run-time information, many warnings are false positives.
The dynamic approach monitors the program execution and analyzes resulting the traces for potential errors. The strength of this approach is that, because it contains specific run-time information, the warnings are usually true errors. The downfall of this approach is that potential errors in non-executed portions of code are not caught.
This thesis presents a novel hybrid approach which seeks to incorporate both the static and dynamic approaches so that the strengths of each approach are capitalized upon and the weaknesses of each approach are avoided. Specifically we add a static speculation analysis to a dynamic analysis so that when a dynamic analyzer approaches a branching structure in the code, it can statically analyze the branches that were not taken. This improves upon both approaches because the dynamic analyzer now has greater code coverage and the static analyzer has less code to examine (and therefore less false positives). This thesis also presents the experimental results.
