We introduce obstruction-freedom, a new nonblocking property for shared data structure implementations. This property is strong enough to avoid the problems associated with locks, but it is weaker than previous nonblocking properties—specifically lock-freedom and wait-freedom— allowing greater flexibility in the design of efficient implementations. Obstruction-freedom admits substantially simpler implementations, and we believe that in practice it provides the benefits of wait-free and lock-free implementations. To illustrate the benefits of obstruction-freedom, we present two obstruction-free CAS-based implementations of double-ended queues (deques); the first is implemented on a linear array, the second on a circular array. To our knowledge, all previous nonblocking deque implementations are based on unrealistic assumptions about hardware support for synchronization, have restricted functionality, or have operations that interfere with operations at the opposite end of the deque even when the deque has many elements in it. Our obstruction-free implementations have none of these drawbacks, and thus suggest that it is much easier to design obstruction-free implementations than lock-free and waitfree ones. We also briefly discuss other obstruction-free data structures and operations that we have implemented. 1.

We present an integrated framework for developing realtime systems in which lock-free algorithms are employed to implement shared objects. There are two key objectives of our work. The first is to enable functionality for object sharing in lock-free real-time systems that is comparable to that in lock-based systems. Our main contribution toward this objective is an efficient approach for implementing multiobject lock-free operations and transactions. A second key objective of our work is to improve upon previously proposed scheduling conditions for tasks that share lock-free objects. When developing such conditions, the key issue is to bound the cost of operation "interferences". We present a general approach for doing this, based on linear programming. 1. Introduction Mostworkon implementing shared objects in preemptive real-time uniprocessor systems has focused on using critical sections to ensure object consistency. The main problem that arises when using critical sections is that ...

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 several new helping schemes that can be generally applied to efficiently implement a variety of different 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. 1 Introduction We consider the implementation of wait-free shared objects on multiprogrammed systems in which processes are scheduled for execution based on priority. We assume that processes are scheduled on a per-processor basis and do not migrate between processors during object accesses. Our ...

We show that previous algorithmic and scheduling work concerning the use of lock-free objects in hard real-time systems can be extended to support real-time transactions on memory-resident data. Using our approach, transactions are not susceptible to priority inversion or deadlock, do not require complicated mechanisms for data-logging or for rolling back aborted transactions, and are implemented as library routines that require no special kernel support. 1 Introduction In most real-time database systems, conventional mechanisms suchaslocks, timestamps, and serialization graphs are used for concurrency control. The main problem when using any of these mechanisms is that of handling con#icting operations. If an operation of a transaction creates a con#ict, then one of two strategies may be used: either that transaction may be blocked, or one or more of the transactions involved in the con- #ict may be aborted. When using con#ict resolution schemes that employ blocking, deadlockisakey ...

Data sharing among tasks within multiprocessor real-time systems is a crucial issue. This report presents a fully asynchronous mechanism of sharing data between a single writer and multiple readers. The writer and all the readers are allowed to access the shared data asynchronously in a loop-free and wait-free manner because neither locking operations nor repeated actions of read-and-check are involved. Its implementation uses only (n + 2) buffer slots for n readers, and employs an atomic `Store-IfZero ' operation which can be easily simulated with the Compare-and-Swap instruction. Since neither writing nor reading the shared data imposes any effect upon other tasks in the system, this mechanism introduces no impact upon the timing behaviour of tasks. When employed by real-time applications, it helps to reduce blocking and priority inversion problems incurred by the commonly used lock-based synchronization mechanisms. 1 Introduction Data sharing is a basic approach to achieving inter...

Snap-shot mechanisms are used to read a globally consistent set of variable values. Such a mechanism can be used to solve a variety of communication and synchronization problems, including system monitoring and control of real-time applications. Methods based on locking (e.g. using semaphores) are penalized by blocking, which typically leads to difficulties in guaranteeing deadlines of high priority tasks. Lock-free methods, which take a snap-shot and then check if it corresponds to a consistent system state, have unpredictable timing-behavior, since they may have to retry an unpredictable number of times. Clearly, a method which combines the predictability of locking-based methods with the low interference (no blocking) of lock-free methods is desirable.

Abstract not found

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 SCR...

The Real-Time Specication for Java provides protected, non-blocking, shared access to objects used by both regular Java threads (java.lang.Threads) and the time-critical NoHeapRealtimeThreads. Such access is oered via a set of wait-free queue classes. These classes are provided explicitly to enable communication between the real-time NoHeapRealtimeThreads and the regular Java threads; they have a unidirectional nature with one side of the queue for the real-time threads and the other one for the non-real-time ones. This set of wait-free queue classes is of big importance not only to real time Java but also to any real-time synchronization system. Ecient algorithmic implementations of these queue classes are presented in this paper. The algorithms are designed to exploit the unidirectional nature of these queues and they are more ecient, with respect to space complexity, compared to previous wait-free implementations, without losing in time complexity. The space complexity of our algorithms is O(M + N) where N is the maximum number of concurrent tasks that the Queue supports and M is the size of the Queue. The space complexity of the previous best solution is O(N M). The time complexity of our algorithm and the previous best one is O(N) for each task. Experiments we've performed suggest that our algorithms are typically 9 % 36 % faster than the previous best one.

The Real-Time Specification for Java provides protected, non-blocking, shared access to objects accessed by both regular Java threads (java.lang.Threads) and the time-critical NoHeapRealtimeThreads. Such access is offered via a set of wait-free queue classes. These classes are provided explicitly to enable communication between the real-time NoHeapRealtimeThreads and the regular Java threads; they have a unidirectional nature with one side of the queue (read or write) for the real-time threads and the other one (write or read, respectively) for the non-real-time ones. Efficient implementations of these queue classes are presented in this paper. The implementations are designed to have the unidirectional nature of these queues in mind and they are more efficient, with respect to space complexity, compared to previous general bi-directional wait-free implementations, without losing in time complexity. 1