The Repeat Offender Problem: A Mechanism for Supporting Dynamic-Sized, Lock-Free Data Structures

Herlihy, Maurice; Luchangco, Victor; Moir, Mark

doi:10.1007/3-540-36108-1_23

Cited by 80 publications

(98 citation statements)

References 14 publications

(34 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Due to space constraints, the development for epochs is deferred to [7, §D]. As far as we know, the only other algorithm that allows explicitly returning memory to the OS in non-blocking algorithms is the Repeat-Offender algorithm [8]. Our preliminary investigations show that our method is applicable to it as well; we leave formalisation for future work.…”

Section: Introductionmentioning

confidence: 99%

Verifying Concurrent Memory Reclamation Algorithms with Grace

Gotsman

Rinetzky

Yang

2013

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. Memory management is one of the most complex aspects of modern concurrent algorithms, and various techniques proposed for it-such as hazard pointers, read-copy-update and epoch-based reclamation-have proved very challenging for formal reasoning. In this paper, we show that different memory reclamation techniques actually rely on the same implicit synchronisation pattern, not clearly reflected in the code, but only in the form of assertions used to argue its correctness. The pattern is based on the key concept of a grace period, during which a thread can access certain shared memory cells without fear that they get deallocated. We propose a modular reasoning method, motivated by the pattern, that handles all three of the above memory reclamation techniques in a uniform way. By explicating their fundamental core, our method achieves clean and simple proofs, scaling even to realistic implementations of the algorithms without a significant increase in proof complexity. We formalise the method using a combination of separation logic and temporal logic and use it to verify example instantiations of the three approaches to memory reclamation.

show abstract

Section: Introductionmentioning

confidence: 99%

Verifying Concurrent Memory Reclamation Algorithms with Grace

Gotsman

Rinetzky

Yang

2013

Lecture Notes in Computer Science

View full text Add to dashboard Cite

show abstract

“…Inter-stage fairness follows from Java thread execution fairness. While the current implementation uses synchronization around the use Java's LinkedList class for a mailbox, performance may potentially be further improved by using lock-free data structures [14,[21][22][23][24], which will be investigated as future work.…”

Section: Safe Message Passingmentioning

confidence: 99%

SALSA Lite: A Hash-Based Actor Runtime for Efficient Local Concurrency

Desell

Varela

2014

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. As modern computer processors continue becoming more parallel, the actor model plays an increasingly important role in helping develop correct concurrent systems. In this paper, we consider efficient runtime strategies for non-distributed actor programming languages. While the focus is on a non-distributed implementation, it serves as a platform for a future efficient distributed implementation. Actors extend the object model by combining state and behavior with a thread of control, which can significantly simplify concurrent programming. Further, with asynchronous communication, no shared memory, and the fact an actor only processes one message at a time, it is possible to easily implement transparent distributed message passing and actor mobility. This paper discusses SALSA Lite, a completely re-designed actor runtime system engineered to maximize performance. The new runtime consists of a highly optimized core for lightweight actor creation, message passing, and message processing, which is used to implement more advanced coordination constructs. This new runtime is novel in two ways. First, by default the runtime automatically maps the lightweight actors to threads, allowing the number of threads used by a program to be specified at runtime transparently, without any changes to the code. Further, language constructs allow programmers to have first class control over how actors are mapped to threads (creating new threads if needed). Second, the runtime directly maps actor garbage collection to object garbage collection, allowing non-distributed SALSA programs to use Java's garbage collection "for free". This runtime is shown to have comparable or better performance for basic actor constructs (message passing and actor creation) than other popular actor languages: Erlang, Scala, and Kilim.

show abstract

“…Our demands on the memory management consequently rules out the SMR or ROP methods by Michael [26,27] and Herlihy et al [28] respectively, as they can only guarantee a limited number of nodes to be safe, and these guarantees are also related to individual threads and never to an individual node structure. However, stronger memory management schemes, as for example reference counting, would be sufficient for our needs.…”

Section: Memory Managementmentioning

confidence: 99%

Lock-free deques and doubly linked lists

Sundell

Tsigas

2008

Journal of Parallel and Distributed Computing

View full text Add to dashboard Cite

a b s t r a c tWe present a practical lock-free shared data structure that efficiently implements the operations of a concurrent deque as well as a general doubly linked list. The implementation supports parallelism for disjoint accesses and uses atomic primitives which are available in modern computer systems. Previously known lock-free algorithms of doubly linked lists are either based on non-available atomic synchronization primitives, only implement a subset of the functionality, or are not designed for disjoint accesses. Our algorithm only requires single-word compare-and-swap atomic primitives, supports fully dynamic list sizes, and allows traversal also through deleted nodes and thus avoids unnecessary operation retries. We have performed an empirical study of our new algorithm on two different multiprocessor platforms. Results of the experiments performed under high contention show that the performance of our implementation scales linearly with increasing number of processors. Considering deque implementations and systems with low concurrency, the algorithm by Michael shows the best performance. However, as our algorithm is designed for disjoint accesses, it performs significantly better on systems with high concurrency and non-uniform memory architecture.

show abstract

The Repeat Offender Problem: A Mechanism for Supporting Dynamic-Sized, Lock-Free Data Structures

Cited by 80 publications

References 14 publications

Verifying Concurrent Memory Reclamation Algorithms with Grace

Verifying Concurrent Memory Reclamation Algorithms with Grace

SALSA Lite: A Hash-Based Actor Runtime for Efficient Local Concurrency

Lock-free deques and doubly linked lists

Contact Info

Product

Resources

About