Atomic invariants verification and deadlock detection at compile-time

Abstract

Modern systems must take full advantage of the underlying hardware paradigms in order to yield higher throughput and lower latency. A common way of maximizing the hardware usage in a system is by leveraging multithreaded techniques. These techniques however are very hard to reason by and can yield hard to detect bugs, such as deadlocks, livelocks or race conditions from unwanted interleavings of threads in the system's execution. Atomic locks are a standard mechanism to provide a safe way to alleviate such issues by specifying what regions of code need to be executed atomically such that regardless of the threads interleavings the shared memory remains in a consistent state and makes the code execution as a simple serial execution that easy to analyze and reason by, yielding increased programmer productivity and system efficiency. Our paper proposes a system that allows user to easily verify if a C# codebase has correctly implemented the way shared memory (field or properties) are modified and is able to detect race conditions or deadlocks for the specified shared memory. The main goal is to improve developer productivity and to improve the system codebase by specifying the atomicity constraints as unit or integration tests. We present the overall architecture of the system and how it detects the way certain atomic invariants are checked and deadlocks are identified, as well as the integration with an existing codebase. We also describe how the system proves correctness in checking these invariants. We have verified our system against multithreaded C# codebases and the system successfully checks the atomicity invariants and deadlock cases outputting the correct scenarios of how these can happen. We have also provided a way to decrease the risk of concurrency bugs regressions and improving the code quality, thus proving that our system achieves the proposed goals of providing a way for increased developer productivity, correct detection of deadlocks, atomic invariants checking and concurrency bugs mitigation.