MPI-SWS

Handling Concurrency Bugs

Overview

Modern CPUs no longer are limited to a single execution thread. In fact, many of the CPUs in use nowadays are dual-cores or even quad-cores. CPU manufacturers have announced that the number of cores, even in general-purpose CPUs, is likely to keep increasing. Given this trend of increasing parallelism in CPUs, software will have to become increasingly more parallel to take advantage of their full potential.

However, parallel software is prone to concurrency bugs, a specific class of software bugs that are triggered when and only when the operating system chooses certain thread interleavings. This makes such programming mistakes particularly hard to avoid in parallel programs and also very hard for developers to find and fix. Furthermore, it also has been shown that concurrency bugs can have a high impact on robustness of software. On the other hand, the dependence of concurrency bugs on thread interleavings means that concurrency bugs, with respect to the other classes of bugs, have very specific properties which opens doors to specific techniques to handle them.

Project goal and idea

The goal of this research project is to improve the testing of concurrent programs by developing techniques to automatically detect concurrency bugs in large, complex applications. These techniques would allow us to build a concurrency bug detector, which would have two important uses. First, such a detector can assist developers in debugging their applications with respect to concurrency bugs, thereby improving the quality of their software. Second, the possibility of reliably and efficiently detecting when concurrency bugs are triggered could be leveraged to recover from concurrency bugs during run-time, thereby improving user's experience in the presence of faulty software.

The key idea of our concurrency bug detector is to detect whether a concurrency bug was triggered by analysing the state and output of a concurrent execution of the program. The state and output would be compared against the state and output of a reference execution (i.e., the same program executing with different thread interleaving but with the same input). Controlling the thread interleaving of a program can be achieved by the use of specialized schedulers. However challenges arise from the difficulty in choosing the interleavings of the various executions and from trying to compare the state of different executions.

People

Publications


All rights reserved. Imprint | Data Protection