Efficient and Reliable Lock-Free Memory Reclamation Based on Reference Counting

Gidenstam, Anders; Papatriantafilou, Marina; Sundell, Håkan; Tsigas, Philippas

doi:10.1109/ispan.2005.42

Cited by 24 publications

(25 citation statements)

References 14 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…The demand for automated verification remains. Beware&Cleanup [Gidenstam et al 2005] combines HP and RC. Isolde [Yang and Wrigstad 2017] combines EBR and RC.…”

Section: Related Workmentioning

confidence: 99%

Pointer life cycle types for lock-free data structures with memory reclamation

Meyer

Wolff

2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

We consider the verification of lock-free data structures that manually manage their memory with the help of a safe memory reclamation (SMR) algorithm. Our first contribution is a type system that checks whether a program properly manages its memory. If the type check succeeds, it is safe to ignore the SMR algorithm and consider the program under garbage collection. Intuitively, our types track the protection of pointers as guaranteed by the SMR algorithm. There are two design decisions. The type system does not track any shape information, which makes it extremely lightweight. Instead, we rely on invariant annotations that postulate a protection by the SMR. To this end, we introduce angels, ghost variables with an angelic semantics. Moreover, the SMR algorithm is not hard-coded but a parameter of the type system definition. To achieve this, we rely on a recent specification language for SMR algorithms. Our second contribution is to automate the type inference and the invariant check. For the type inference, we show a quadratic-time algorithm. For the invariant check, we give a source-to-source translation that links our programs to off-the-shelf verification tools. It compiles away the angelic semantics. This allows us to infer appropriate annotations automatically in a guess-and-check manner. To demonstrate the effectiveness of our type-based verification approach, we check linearizability for various list and set implementations from the literature with both hazard pointers and epoch-based memory reclamation. For many of the examples, this is the first time they are verified automatically. For the ones where there is a competitor, we obtain a speed-up of up to two orders of magnitude.Proving lock-free data structures linearizable has received a lot of attention (cf. Section 10). Doherty et al. [2004], for instance, give a mechanized proof of a practical lock-free queue. Such proofs require plenty of manual work and take a considerable amount of time. Moreover, they require an understanding of the proof method and the data structure under consideration. To overcome this drawback, we are interested in automated verification. The cave tool by Vafeiadis [2010a,b], for example, is able to establish linearizability for singly-linked data structures fully automatically.The problem with automated verification for lock-free data structures is its limited applicability. Most techniques are restricted to implementations that assume a garbage collector (GC). This assumption, however, does not apply to all programming languages. Take C/C++ as an example. It does not provide an automatic garbage collector that is running in the background. Instead, it is the programmer's obligation to avoid memory leaks by reclaiming memory that is no longer in use (using delete). In lock-free data structures, this task is much harder than it may seem at first glance. The root of the problem is that threads typically traverse the data structure without synchronization. Hence, there may be threads holding pointers to records that have alread...

show abstract

“…The demand for automated verification remains. Beware&Cleanup [Gidenstam et al 2005] combines HP and RC. Isolde [Yang and Wrigstad 2017] combines EBR and RC.…”

Section: Related Workmentioning

confidence: 99%

Pointer life cycle types for lock-free data structures with memory reclamation

Meyer

Wolff

2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…Herlihy, Luchangco, and Moir proposed a lock-free technique that overcomes this problem, but requires CAS [14]. Gidenstam, Papatriantafilou, Sundell, and Tsigas proposed a lock-free memory reclamation method that combines aspects of reference counting and hazard pointers, and requires both FAA and CAS [10].…”

Section: Related Workmentioning

confidence: 99%

Making objects writable

Aghazadeh

Golab

Woelfel

2014

Proceedings of the 2014 ACM Symposium on Principles of Distributed Computing

View full text Add to dashboard Cite

We devise a technique for augmenting shared objects in the standard n-process shared memory model with a linearizable write() operation, using bounded space and optimal worstcase step complexity. We provide a transformation of any shared object SW supporting only sequential write() operations into an object W that supports concurrent write() operations. This transformation requires O(n 2 ) SW objects and O(n 2 ) O(log n)-bit registers, and each method (including write()) has, up to a constant additive term, the same time complexity as the corresponding method on object SW . Our implementation is deterministic, wait-free, and uses only shared registers (supporting atomic read and write operations). To the best of our knowledge, similarly efficient general constructions are not known even if stronger primitives such as CAS or LL/SC are available.Applying our transformation, we obtain an implementation of a k-word register from O(n 2 · k) single-word registers. As another application we can transform one-time TAS objects (e.g., randomized wait-free implementations that use a bounded number of registers [8,9]), into long-lived ones using also a bounded number of registers. The transformation preserves the time complexity of TAS() operations and allows resets in constant worst-case time.Our transformation employs a novel memory reclamation technique, which can replace Hazard Pointers [20] and is more efficient.

show abstract

“…[7,14,24], employed reference counts to track the accesses of each node. Each node is associated with a counter, which is incremented/decremented by threads as they access/drop references to the node.…”

Section: Related Workmentioning

confidence: 99%

“…Moreover, a thread crash can result in an unbounded amount of unreclaimed memory. Reference counting schemes [7,14,24], while easy to implement, have been observed to require expensive synchronization overhead [16]. Finally, pointerbased schemes, such as hazard pointers [22], pass-thebuck [20], or drop-the-anchor [4], explicitly mark live nodes (nodes accessible by other threads) which should not be de-allocated.…”

Section: Introductionmentioning

confidence: 99%

StackTrack

Alistarh¹,

Eugster

Herlihy

et al. 2014

Proceedings of the Ninth European Conference on Computer Systems

View full text Add to dashboard Cite

Dynamic memory reclamation is arguably the biggest open problem in concurrent data structure design: all known solutions induce high overhead, or must be customized to the specific data structure by the programmer, or both. This paper presents StackTrack, the first concurrent memory reclamation scheme that can be applied automatically by a compiler, while maintaining efficiency. StackTrack eliminates most of the expensive bookkeeping required for memory reclamation by leveraging the power of hardware transactional memory (HTM) in a new way: it tracks thread variables dynamically, and in an atomic fashion. This effectively makes all memory references visible without having threads pay the overhead of writing out this information. Our empirical results show that this new approach matches or outperforms prior, non-automated, techniques.

show abstract

Efficient and Reliable Lock-Free Memory Reclamation Based on Reference Counting

Cited by 24 publications

References 14 publications

Pointer life cycle types for lock-free data structures with memory reclamation

Pointer life cycle types for lock-free data structures with memory reclamation

Making objects writable

StackTrack

Contact Info

Product

Resources

About