Srdjan Petrovic

Efficient and practical constructions of LL/SC variables

Over the past decade, a pair of synchronization instructions known as LL/SC has emerged as the most suitable set of instructions to be used in the design of lock-free algorithms. However, no existing multiprocessor system supports these instructions in hardware. Instead, most modern multiprocessors support instructions such as CAS or RLL/RSC (e.g. POWER4, MIPS, SPARC, IA-64). This paper presents two efficient algorithms that implement 64-bit LL/SC from 64-bit CAS or RLL/RSC. Our results are summarized as follows.We present a practical algorithm for implementing a 64-bit LL/SC object from 64-bit CAS or RLL/RSC objects. Our result shows, for the first time, a practical way of simulating a 64-bit LL/SC memory word using 64-bit CAS memory words (or 64-bit RLL/RSC memory words), incurring only a small constant space overhead per process and a small constant factor slowdown.Although our first solution performs correctly in any practical system, its theoretical correctness depends on unbounded sequence numbers. We present a bounded algorithm that implements a 64-bit LL/SC object from 64-bit CAS or RLL/RSC objects, and has the same time and space complexities as the first algorithm.This and the previous algorithm improve on existing implementations of LL/SC objects by Anderson and Moir in 1995, and Moir in 1997.

Efficient Wait-Free Implementation of Multiword LL/SC Variables

Since the design of lock-free data structures often poses a formidable intellectual challenge, researchers are constantly in search of abstractions and primitives that simplify this design. The multiword LL/SC object is such a primitive: many existing algorithms are based on this primitive, including the nonblocking and wait-free universal constructions (Anderson et. al., 1995), the closed objects construction (Chandra et. al., 1998) and the snap-shot algorithms (Jayanti, 2005, 2002). In this paper, the authors considered the problem of implementing a W-word LL/SC object shared by N processes. The previous best algorithm, due to Anderson and Moir, is time optimal (LL and SC operations run in O(W) time), but has a space complexity of O(N2 W). An algorithm that uses novel buffer management ideas to cut down the space complexity by a factor of N to O(NW), while still being time optimal was presented

Logarithmic-time single deleter, multiple inserter wait-free queues and stacks

Despite the ubiquitous need for shared FIFO queues in parallel applications and operating systems, there are no sublinear-time wait-free queue algorithms that can support more than a single enqueuer and a single dequeuer. Two independently designed algorithms—Davids recent algorithm [1] and the algorithm in this paper—break this barrier. While Davids algorithm is capable of supporting multiple dequeuers (but only one enqueuer), our algorithm can support multiple enqueuers (but only one dequeuer). Davids algorithm achieves O(1) time complexity for both enqueue and dequeue operations, but its space complexity is infinite because of the use of infinite sized arrays. The author states that he can bound the space requirement, but only at the cost of increasing the time complexity to O(n), where n is the number of dequeuers. A significant feature of our algorithm is that its time and space complexities are both bounded and small: enqueue and dequeue operations run in

Efficiently implementing LL/SC objects shared by an unknown number of processes

O(\lg n)

Space-efficient FCFS group mutual exclusion

time, and the space complexity is O(n+m), where n is the number of enqueuers and m is the actual number of items currently present in the queue. Davids algorithm uses fetch&increment and swap instructions, which are both at level 2 of Herlihys Consensus hierarchy, along with queue. Our algorithm uses the LL/SC instructions, which are universal. However, since these instructions have constant time wait-free implementation from CAS and restricted LL/SC that are widely supported on modern architectures, our algorithms can run efficiently on current machines. Thus, in applications where there are multiple producers and a single consumer (e.g., certain server queues and resource queues), our algorithm provides the best known solution to implementing a wait-free queue. Using similar ideas, we can also efficiently implement a stack that supports multiple pushers and a single popper.

Fair group mutual exclusion

Over the past decade, a pair of instructions called load-linked (LL) and store-conditional (SC) have emerged as the most suitable synchronization instructions for the design of lock-free algorithms. However, current architectures do not support these instructions; instead, they support either CAS (e.g., UltraSPARC, Itanium) or restricted versions of LL/SC (e.g., POWER4, MIPS, Alpha). To bridge this gap, a flurry of algorithms that implement LL/SC from CAS have appeared in the literature. Some of these algorithms assume that N, the maximum number of participating processes, is fixed and known in advance. Others make no such assumption, but are either non-blocking (not wait-free), implement small LL/SC objects, or require that a process performs O(N) work to join the algorithm. Specifically, no constant-time, word-sized, wait-free LL/SC algorithm that does not require the knowledge of N exists. In this paper, we present such an algorithm.

Read/Write based fast-path transformation for FCFS mutual exclusion

In the group mutual exclusion problem [Y. Joung, Asynchronous group mutual exclusion, Distrib. Comput. 13 (2000) 189], which generalizes mutual exclusion [E. Dijkstra, Solution of a problem in concurrent programming control, Comm. ACM 8 (9) (1965) 569], a process chooses a session when it requests entry into the Critical Section. A group mutual exclusion algorithm must ensure that the mutual exclusion property holds: if two processes are in the Critical Section at the same time, then they request the same session. In addition to mutual exclusion, lockout freedom, bounded exit, and concurrent entering are basic properties that are desirable in any group mutual exclusion algorithm. Hadzilacos in [Proc. 20th Annual Symp. on Principles of Distributed Computing, 2001, pp. 100-106] first introduced a fairness condition, called first-come-first-served (FCFS), for group mutual exclusion. The only known FCFS group mutual exclusion algorithm is due to Hadzilacos [Proc. 20th Annual Symp. on Principles of Distributed Computing, 2001, pp. 100-106], and requires @Q(N^2) bounded shared registers, where N is the number of processes. We present a FCFS group mutual exclusion algorithm that uses only @Q(N) bounded shared registers. (The existence of such an algorithm was posed as an open problem by Hadzilacos.)