Dynamic program analyses for debugging concurrency bugs in large multi-threaded programs

Concurrency bugs are problems due to incorrect interleaving of parallel tasks. They are often caused by inadequate synchronization. Unlike bugs in sequential programs, manifestation of concurrency bugs is dependent not only on the program input but also on the scheduling of different tasks. Hence they are non-deterministic and consequently debugging concurrent programs is far more difficult than debugging sequential programs. In the real world, concurrency bugs have caused several disasters in the past and are generating increasingly severe problems in recent times with the prevalence of multi-core hardware. This thesis presents new dynamic techniques to debug concurrency bugs in large multithreaded programs. We make four main contributions. Our first and second contributions are two dynamic techniques that aid in reproducing concurrency bugs observed in production runs and in testing concurrent programs, respectively. Our bug reproduction technique uses information gleaned from crash coredumps to narrow down the set of schedules that needs to be explored by a bounded model checker. Our testing technique uses predicate switching to mutate correct single-threaded executions of a multi-threaded program to erroneous executions. We then use the switched predicates to identify a second conflicting input from a large regression test suite that if executed concurrently with the first input could trigger the same program failure. Once a bug has been reproduced, the next step in debugging involves identifying the root cause. Hence our third contribution is a new dynamic slicing technique that produces dynamic slices order of magnitude smaller than traditional slices by comparing correct and incorrect executions of a concurrent program. Through analysis of many concurrency bugs we observe that developers find it difficult to fix concurrency bugs successfully due to the complexity of reasoning that is required to develop a correct software patch. Hence in our forth contribution, we discuss a technique that can suppress certain latent concurrency bugs which avoids debugging altogether