Lock-free data structures implement concurrent objects without the use of mutual exclusion. This approach can avoid performance problems due to unpredictable delays while processes are within critical sections. Although universal methods are known that give lock-free data structures for any abstract data type, the overhead of these methods makes them inefficient when compared to conventional techniques using mutual exclusion, such as spin locks. We give lock-free data structures and algorithms for implementing a shared singly-linked list, allowing concurrent traversal, insertion, and deletion by any number of processes. We also show how the basic data structure can be used as a building block for other lock-free data structures. Our algorithms use the single word Compare-and-Swap synchronization primitive to implement the linked list directly, avoiding the overhead of universal methods, and are thus a practical alternative to using spin locks. 1 Introduction A concurrent object is an...

A'(=$B#127$C7D-7E"#%9F< >$7'(-7:;<<"G$&%- 12-*#)+1+)H7IJ->0" ;<<":'(%- 1+687)29:K*,< B>0"$%L.M.D.&%<1+12%&%7< 'K)2$"#=$)2; >%"ON5<'.$D- '(="P6 9F%9:< '(IF9?B127)+/#'(<&=%$$< '($C->0"Q)2$A*0-$%"R<>S- >S%- '1+)2('C&%<1+12%&%7< ' -12;<')27D09UT VW84X.D)2&YDG/'(<Z)2"#%"R[@%"R*,<B#>"$\< >]7D0C7)29FC- >I 7D'(%-"R9CB0$7./- B$\N5< 'K&=< 1+12%&%7)2<>^LE_\<X.=Z3'4$)+>&%`< B'E%- '1+)23' -12;<')27D09aX.-$"#%$)2;>0="bN5<'K$)29c/12c->0-12I$)2$%40)27.D0-"R$<9Fd)29c6 /'(-&=7)2&%- 1.Ne%-7B'(%$%L`M.D#)2$C/0-/,3'C/'(%$3>7$`7D0`%@73>$)2< >$c>%&36 =$$- '(IfNe< 'G-!/#'(-&%7)2&%- 1`)29c/12%9:3>7-7)2< >hgi'(%"B0&()+>0;j%@&=%$$)2Z )+>7('12%-Z)+>0;4kD- >"1+)+>0;!$7-&l$\->0"!; 12<*0-1Z -')2- *12%$%4^'(%"B&3)+>0; "< B*12O-1+12<&%-7)2<>^4->0"G$/,=&3)2- 17'(%-79F3>7C< N12-'(;:->0"!$9:- 1+1 <*m%&%7$%LonK>i)29c/12%9:3>7-7)2< >o*-$%"j<>p7D0G9:<")+[%"q-12;<6 ')27D9r)2$G%Z- 1+B-7%"p< >p-J$=7R< NQstvuPwGxq*y3>0&D9:- 'l$G<>pu B>Jz>73'/')2$bs={{{{#4|-O}~ 68X.-IGd127'(-u/- '(&(6K9?B127)+/'(<&%%$6 $<'L!M<G7D0:*,%$7`< NE<B#':l><X.12%"#;4.7D)2$c)2$:7D:[#'($7`)29c/#12(6 9F3>7-7)2<>J<N-c/- '(-1+123154^'(%-1+67)29Fc;- '*-;`&%<1+12%&%7< 'L M.Dc-Z('(-;Q&%<1+12%&%7<':$/,=%"PB/J)2$FPL t:-7CO/'(<&%%$$<'($c->0" sPL -7FVb/'(<&%%$$<'($%LjwG-@)29CB09r/- B$G7)29:%$:'(- >;RN'(<9 j9F$7<ti9:$%Lr>o&%<>7'(-$7%4:-i>< >65)+>0&('(%9:3>7-1G&%<1+12%&%7< ' X.D%7D3'G;3>0('(-7)2< >- 1< 'R><7(:...

A future is a simple and elegant abstraction that allows concurrency to be expressed often through a relatively small rewrite of a sequential program. In the absence of side-effects, futures serve as benign annotations that mark potentially concurrent regions of code. Unfortunately, when computation relies heavily on mutation as is the case in Java, its meaning is less clear, and much of its intended simplicity lost. This paper explores the definition and implementation of safe futures for Java. One can think of safe futures as truly transparent annotations on method calls, which designate opportunities for concurrency. Serial programs can be made concurrent simply by replacing standard method calls with future invocations. Most significantly, even though some parts of the program are executed concurrently and may indeed operate on shared data, the semblance of serial execution is nonetheless preserved. Thus, program reasoning is simplified since data dependencies present in a sequential program are not violated in a version augmented with safe futures. Besides presenting a programming model and API for safe futures, we formalize the safety conditions that must be satisfied to ensure equivalence between a sequential Java program and its futureannotated counterpart. A detailed implementation study is also provided. Our implementation exploits techniques such as object versioning and task revocation to guarantee necessary safety conditions. We also present an extensive experimental evaluation of our implementation to quantify overheads and limitations. Our experiments indicate that for programs with modest mutation rates on shared data, applications can use futures to profitably exploit parallelism, without sacrificing safety.

We study practical techniques for implementing the FIFO queue abstract data type using lock-free data structures, which synchronize the operations of concurrent processes without the use of mutual exclusion. Two new algorithms based on linked lists and arrays are presented. We also propose a new solution to the ABA problem associated with the Compare&Swap instruction. The performance of our linked list algorithm is compared several other lock-free queue implementations, as well as more conventional locking techniques. 1 Introduction Concurrent access to a data structure shared among several processes must be synchronized in order to avoid conflicting updates. Conventionally this is done using mutual exclusion; processes modify the data structure only inside a critical section of code, within which the process is guaranteed exclusive access to the data structure. Typically, on a multiprocessor, critical sections are guarded with a spin-lock . We will refer to all methods using mutual ...

This paper describes the design and implementation of a concurrent compacting garbage collector for languages that distinguish mutable data from immutable data (e.g., ML) as well as for languages that manipulate only immutable data (e.g., pure functional languages such as Haskell). The collector runs on shared-memory parallel computers and requires minimal mutator/collector synchronization. No special hardware or operating system support is required. Our concurrent collector derives from sequential semi-space copying collectors. The collector requires that a heap object includes a forwarding pointer in addition to its data fields. An access to an immutable object can be satisfied either by the original or the forwarded copy of the object. A mutable object is always accessed through the forwarded copy, if one exists. Measurements of this collector in a Standard ML compiler on a shared-memory computer indicate that it eliminates perceptible garbage-collection pauses by reclaiming storage...

This thesis describes an implementation of a mark-sweep garbage collector (GC) for sharedmemory machines and reports its performance results. It is a simple `parallel' collector in which all processors cooperatively traverse objects in the global shared heap. The collector stops the application program during collection phase. Implementation is based on the Boehm-Demers-Weiser conservative GC library (Boehm GC). Experiments have been conducted on two systems. One is Ultra Enterprise 10000, a symmetric shared-memory machine with 64 Ultra SPARC processors, and the other is Origin 2000, a distributed shared memory machine with 16 R10000 processors. The application programs used for our experiments are BH (an N-body problem solver with Barnes-Hut algorithm), CKY (a context free grammar parser), Life (a life game simulator) and RNA (a program to predict RNA secondary structure). On both systems, load balancing is a key to achieving scalability; a naive collector without load redistribution ...

While uniprocessor garbage collection is relatively well understood, experience with collectors for large multiprocessor servers is limited and it is unknown which techniques best scale with large memories and large numbers of processors. In order to explore these issues we designed a modular garbage collection framework in the IBM Jalapeno Java virtual machine and implemented five different parallel garbage collectors: non-generational and generational versions of mark-and-sweep and semi-space copying collectors, as well as a hybrid of the two. We describe the optimizations necessary to achieve good performance across all of the collectors, including load balancing, fast synchronization, and inter-processor sharing of free lists. We then quantitatively compare the different collectors to find their asymptotic performance both with respect to how fast they can run applications as well as how little memory they can run them in. All of our collectors scale linearly up to sixteen processors. The least memory is usually required by the hybrid mark-sweep collector that uses a copying collector for its nursery, although sometimes the non-generational mark-sweep collector requires less memory. The fastest execution is more application-dependent. Our only application with a large working set performed best using the mark-sweep collector; with one exception, the rest of the applications ran fastest with one of the generational collectors.

Assuming the existence of garbage collection makes it easier to design implementations of concurrent data structures. However, this assumption limits their applicability. We present a methodology that, for a significant class of data structures, allows designers to first tackle the easier problem of designing a garbagecollection -dependent implementation, and then apply our methodology to achieve a garbage-collectionindependent one. Our methodology is based on the well-known reference counting technique, and employs the double compare-and-swap operation.

Concurrency management is a basic requirement for interprocess communication in any multitasking system. This usually takes the form of lock-based or other blocking algorithms. In real-time and/or time-sensitive systems, the less-predictable timing behavior of lock-based mechanisms and the additional task-execution dependency make synchronization undesirable. Recent research has provided non-blocking and wait-free algorithms for interprocess communication, particularly in the domain of single-writer, multiple-reader semantics, but these algorithms typically incur high costs in terms of computation or space complexity, or both. In this paper, we propose a general transformation mechanism that takes advantage of temporal characteristics of the system to reduce both time and space overheads of current single-writer, multiple-reader algorithms. We show a 17--66% execution time reduction along with a 14-- 70% memory space reduction when three wait-free algorithms are improved by applying our transformation. We present three new algorithms for wait-free, single-writer, multiple-reader communication along with detailed performance evaluation of nine algorithms under various experimental conditions.

model for garbage collection.