This work addresses the capture of concurrency bugs that can occur in parallel software, focusing on four types of concurrency bugs that are frequent, have received little attention, and are hard to fix.
The first type is atomicity violations -- bugs that occurs when the programmer fails to enclose in the same critical section all of the memory accesses that should occur atomically. As a result, during execution, such accesses get interleaved with accesses from another thread that make the program state inconsistent.
The second type is over-synchronization -- a defect that implies that there are redundant synchronization operations or that the synchronization operations are performed at a grain that is too coarse. As a result, the program's performance is poor.
The third type is ordering violations ? these occur when there is a correct order between memory accesses from different threads and, in an execution, such order is flipped, usually due to not using the correct form of synchronization.
The final type is asymmetric data races ? bugs that occur when a thread accesses shared variables inside a critical section with appropriate synchronization. However, a second thread concurrently accesses the same shared variables without synchronization, and makes the state inconsistent.
The approach taken by this project involves characterizing these bugs and proposing techniques to detect and fix them. A deliverable of this work is a unified framework for bug detection.
The realization of parallel programming is a Grand Research Challenge and is crucial to our computer industry's ability to continue to make progress. The University of Illinois is a leader in parallel computing and the outcomes of this proposal will be used to enhance courses on parallel computing. In addition, this project will involve close collaboration with Intel and provide students with the opportunity to engage in internships at Intel.