Programming multicore processors is a challenging task due to bugs resulting from concurrency and synchronization. A fundamental reason for the difficulty is that current programming mechanisms require programmers to manually coordinate synchronization between threads running on these systems. Consequently, concurrent systems are prone to bugs due to faulty synchronization problems such as missing, wrong, or lost notifications for threads. Moreover, these bugs are hard to find during testing because they may appear only under a rare schedule of events. Current programming mechanisms also limit the amount of concurrency in threads to ensure that a shared variable is not updated by multiple threads. As a result, many concurrent systems slow down due to sequential bottleneck of accessing shared variables. This project is expected to fundamentally change the way synchronization mechanisms (such as monitors) are written and implemented. It will lead to better understanding of how conditions in a multithreaded program can be evaluated efficiently. As a result, the concurrent programming systems will become more reliable and faster. The impact on society is expected to be large because all new systems are based on concurrent programs.
The project is developing new synchronization mechanisms with two fundamental goals. The first goal is to make synchronization as simple and intuitive as possible for programmers. Current (monitor based) synchronization mechanisms require programmers to explicitly signal threads that may be waiting on certain conditions. In the synchronization mechanism developed in this project, there is no notion of condition variables and it is the responsibility of the runtime system to automatically signal appropriate threads. Analogous to automatic garbage collection in Java, the project is designing efficient algorithms and techniques for automatic signaling. The project is investigating techniques to deal with fairness and exploitation of runtime information such as idle cores for effective and efficient automatic signaling. The second goal is to increase the concurrency in implementation of monitor without requiring programmers to do any additional work and without violating the guarantee provided by the monitor that execution of its methods is equivalent to one in which there is at most one thread in the monitor at any time.
There is also a strong educational component for this project. Synchronization is a fundamental topic in computer science education and is taught in all operating system courses. By eliminating manual signaling from these courses, students would get more time to focus on higher level concurrent programming concerns.
