10,895 research outputs found
Universal Wait-Free Memory Reclamation
In this paper, we present a universal memory reclamation scheme, Wait-Free
Eras (WFE), for deleted memory blocks in wait-free concurrent data structures.
WFE's key innovation is that it is completely wait-free. Although some prior
techniques provide similar guarantees for certain data structures, they lack
support for arbitrary wait-free data structures. Consequently, developers are
typically forced to marry their wait-free data structures with lock-free Hazard
Pointers or (potentially blocking) epoch-based memory reclamation. Since both
these schemes provide weaker progress guarantees, they essentially forfeit the
strong progress guarantee of wait-free data structures. Though making the
original Hazard Pointers scheme or epoch-based reclamation completely wait-free
seems infeasible, we achieved this goal with a more recent, (lock-free) Hazard
Eras scheme, which we extend to guarantee wait-freedom. As this extension is
non-trivial, we discuss all challenges pertaining to the construction of
universal wait-free memory reclamation.
WFE is implementable on ubiquitous x86_64 and AArch64 (ARM) architectures.
Its API is mostly compatible with Hazard Pointers, which allows easy
transitioning of existing data structures into WFE. Our experimental
evaluations show that WFE's performance is close to epoch-based reclamation and
almost matches the original Hazard Eras scheme, while providing the stronger
wait-free progress guarantee
Lock-free Concurrent Data Structures
Concurrent data structures are the data sharing side of parallel programming.
Data structures give the means to the program to store data, but also provide
operations to the program to access and manipulate these data. These operations
are implemented through algorithms that have to be efficient. In the sequential
setting, data structures are crucially important for the performance of the
respective computation. In the parallel programming setting, their importance
becomes more crucial because of the increased use of data and resource sharing
for utilizing parallelism.
The first and main goal of this chapter is to provide a sufficient background
and intuition to help the interested reader to navigate in the complex research
area of lock-free data structures. The second goal is to offer the programmer
familiarity to the subject that will allow her to use truly concurrent methods.Comment: To appear in "Programming Multi-core and Many-core Computing
Systems", eds. S. Pllana and F. Xhafa, Wiley Series on Parallel and
Distributed Computin
The ERA Theorem for Safe Memory Reclamation
Safe memory reclamation (SMR) schemes for concurrent data structures offer
trade-offs between three desirable properties: ease of integration, robustness,
and applicability. In this paper we rigorously define SMR and these three
properties, and we present the ERA theorem, asserting that any SMR scheme can
only provide at most two of the three properties
VBR: Version Based Reclamation
Safe lock-free memory reclamation is a difficult problem. Existing solutions follow three basic methods (or their combinations): epoch based reclamation, hazard pointers, and optimistic reclamation. Epoch-based methods are fast, but do not guarantee lock-freedom. Hazard pointer solutions are lock-free but typically do not provide high performance. Optimistic methods are lock-free and fast, but previous optimistic methods did not go all the way. While reads were executed optimistically, writes were protected by hazard pointers. In this work we present a new reclamation scheme called version based reclamation (VBR), which provides a full optimistic solution to lock-free memory reclamation, obtaining lock-freedom and high efficiency. Speculative execution is known as a fundamental tool for improving performance in various areas of computer science, and indeed evaluation with a lock-free linked-list, hash-table and skip-list shows that VBR outperforms state-of-the-art existing solutions
- …