This project is motivated by two important developments that are expanding the range of real-time applications that designers wish to support. The first is the growing availability and use of commodity multicore and multiprocessor platforms. The second is the recent shift in the Linux community specifically, and the software industry generally, to introduce real-time-oriented features that enhance predictability in settings that have not been conventionally viewed as ``real-time.'' Fueled by these developments, the need for ``real-time execution'' has moved beyond embedded devices into broader arenas, particularly arenas where multiprocessors will be used.
This realization has led to renewed interest in multiprocessor real-time systems, with considerable recent work directed at scheduling issues. Unfortunately, the equally-important topic of synchronization, in comparison, has been somewhat neglected. Indeed, the most influential work on this topic was done decades ago, at a time when multiprocessor real-time applications were deemed to be mostly of ``academic'' interest only. This early work resulted in mechanisms of questionable practical utility, due to designs that overly focus on complex scenarios that rarely arise in practice. Such designs result in pessimistic analysis for checking timing constraints, even for scenarios that are likely to occur.
The objective of the proposed project is to re-visit the issue of real-time synchronization in light of the ongoing multicore revolution, with the goal of devising mechanisms that can be practically applied. The fundamental thesis of this project is ``simplicity wins.'' Specifically, real-time synchronization mechanisms, though generally applicable, should be designed with common-case scenarios in mind, using simple techniques that can be reasonably analyzed. This begs the question: What is the common case? To determine this, trace data will be collected in this project concerning the synchronization behavior of a wide range of real-time applications. This data will be used to produce real-time synchronization benchmarks, which will guide development efforts. These efforts will consider: real-time multiprocessor locking protocols; techniques for supporting read-mostly synchronization; the use of transactional memory and non-blocking synchronization in real-time applications; and synchronization techniques that can be applied in settings where both real-time and non-real-time components co-exist. The synchronization mechanisms developed in this project will be implemented in a UNC-produced Linux extension called LITMUSRT (LInux Testbed for MUltiprocessor Scheduling in Real-Time systems) and evaluated on three different multiprocessor/ multicore test platforms. The largest of these is a Sun Niagara system with 32 logical CPUs (eight cores and four hardware threads per core). This is far larger than any platform considered in any experimental synchronization study conducted previously in the real-time-systems community. As such, issues of scale may likely arise in this project that have not been considered before.