Srikanth Ramamurthy

Real-time computing with lock-free shared objects

This article considers the use of lock-free shared objects within hard real-time systems. As the name suggests, lock-free shared objects are distinguished by the fact that they are accessed without locking. As such, they do not give rise to priority inversions, a key advantage over conventional, lock-based object-sharing approaches. Despite this advantage, it is not immediately apparent that lock-free shared objects can be employed if tasks must adhere to strict timing constraints. In particular, lock-free object implementations permit concurrent operations to interfere with each other, and repeated interferences can cause a given operation to take an arbitrarily long time to complete. The main contribution of this article is to show that such interferences can be bounded by judicious scheduling. This work pertains to periodic, hard real-time tasks that share lock-free objects on a uniprocessor. In the first part of the article, scheduling conditions are derived for such tasks, for both static and dynamic priority schemes. Based on these conditions, it is formally shown that lock-free shared objects often incur less overhead than object implementations based on wait-free algorithms or lock-based schemes. In the last part of the article, this conclusion is validated experimentally through work involving a real-time desktop videoconferencing system.

Pfair scheduling of fixed and migrating periodic tasks on multiple resources

This paper concerns the problem of scheduling sets of preemptable, periodic tasks on multiple resources. We consider a task model that allows arbitrary mixes of fixed and migratable tasks, and prove the existence of an optimal pfair scheduler in this model. Fixed tasks must always be scheduled on a given resource, while migratable tasks can be scheduled on different resources at different times. A pfair scheduler produces a periodic schedule in which the times each task is allocated a processor are approximately evenly spread throughout its period. This paper extends work of Baruah et al., who proved a similar result for systems in which all tasks are migratable.

Wait-free object-sharing schemes for real-time uniprocessors and multiprocessors

Several new wait-free object-sharing schemes for real-time uniprocessors and multiprocessors are presented. These schemes have characteristics in common with the priority inheritance and priority ceiling protocols, but are nonblocking and implemented at the user level. In total, six new object-sharing schemes are proposed: two for uniprocessors and four for multiprocessors. Breakdown utilization experiments are presented that show that the multiprocessor schemes entail less overhead than lock-based schemes.

Lock-Free Transactions for Real-Time Systems

Lock-free objects are an alternative to lock-based object sharing protocols such as the priority ceiling protocol [17, 21] in preemptive real-time uniprocessor systems. An object implementation is lock-free iff it guarantees the following: if several tasks concurrently perform operations on the object, and if some proper subset of these tasks stop taking steps, then at least one of the remaining tasks must complete its operation in a finite number of its own steps. This definition precludes the use of critical sections, because if a task stops taking steps while within a critical section, then other tasks are prevented from accessing that critical section. In several related papers, we have presented general techniques that can be used to implement lock-free objects in real-time uniprocessor systems [3, 18] and to schedule tasks that share such objects [3, 4]. Related research includes work on techniques for implementing specific lock-free objects (such as read/write buffers) [13, 19, 20], and work on synchronization mechanisms that are similar to lock-free objects but are implemented using kernel support [12, 19, 20].

Implementing wait-free objects on priority-based systems

Wait-free objects are often implemented through the use of a “helping scheme”, whereby one process “helps” one or more other processes to complete an operation. This paper presents severaf new helping schemes that can be generally applied to efficiently implement a variety of diflerent objects on priority-based uniprocessor and multiprocessor systems. Examples of such systems include lock-free multiprocessor kernels and real-time systems. Our helping schemes reduce overhead by exploiting the way in which processes are scheduled in priority-based systems. We illustrate the use of these schemes by presenting wait-free implementations of linked lists and a multi-word compare-and-swap primitive.

Real-time object sharing with minimal system support

We show that, for a large class of hard real-time systems, any object with consensus number P in Herlihy’s wait-free hierarchy is universal for any number of tasks executing on P processors. These results exploit characteristics of priority-based schedulers common to most hard real-time systems. An important special case of this result is that, for hard real-time applications on uniprocessors, reads and writes are universal. Thus, Herlihy’s hierarchy collapses for such applications.

Static-priority periodic scheduling on multiprocessors

Presents a new sufficient condition for the schedulability of preemptable, periodic, hard-real-time task sets using the very simple static-priority weight-monotonic scheduling scheme. Like a previous condition due to S. Baruah et al. (1996), our condition actually determines pfair schedulability. Pfairness requires that the schedule, in addition to being periodic, schedules each task at an approximately even rate. Our condition improves on the previous one in two important ways. First, it can determine that task sets with both high utilization and many tasks are schedulable, while the previous condition cannot. Second, our condition applies to both uniprocessors and multiprocessors, while the previous condition applies only to uniprocessors. We present simulations that show that our condition is highly accurate for many cases of interest.

Implementing Hard Real-Time Transactions on Multiprocessors

Many applications exist in which hard real-time transactions must be supported; examples include embedded control applications, defense systems, and avionics systems. With the recent advent of workstation-class multiprocessor systems, multiprocessor-based implementations of these systems are of growing importance. Unfortunately, the problem of implementing hard real-time transactions on multiprocessors has received relatively little attention. With most (if not all) previously-proposed schemes for implementing such transactions, the kind of transactions that can be supported is often limited, and worst-case performance is often poor, adversely impacting schedulability.

A simple proof technique for priority-scheduled systems

A simple proof method is presented for proving invariance properties of concurrent programs in priority-scheduled systems. This method is illustrated by using it to establish the correctness of a simple wait-free consensus algorithm for priority-scheduled uniprocessor systems. This consensus algorithm is of interest in its own right because is shows that atomic read and write operations are universal in priority-scheduled uniprocessor systems, i.e., they can be used to implement any shared object in such a system in a wait-free manner. This stands in contrast to fully asynchronous systems, where strong synchronization primitives such as compare-and-swap are needed for universality.

Synchronization mechanisms for SCRAMNet+ systems

SCRAMNet network cards provide a replicated shared memory via a high-speed, fiber-optic ring. Such systems combine the advantages of conventional shared-memory multiprocessors and message-passing networks by allowing a collection of different computers to access a shared memory with low latency. This paper presents several synchronization mechanisms both blocking and nonblocking for SCRAMNet systems. It is well known that, for general non-blocking synchronization, strong synchronization primitives such as compare-and-swap (CAS) or load-linked/storeconditional (LL/SC) are needed. SCRAMNet cards do not provide such primitives. However, we show that strong synchronization primitives can be implemented in software by exploiting certain features of SCRAMNet cards. In particular, we show that wait-free consensus can be solved in SCRAMNet systems, and we present a simple and efficient wait-free implementation of CAS. We also present new mutual exclusion and renaming algorithms for SCRAMNet systems.