3,214 research outputs found
Fast and Robust Memory Reclamation for Concurrent Data Structures
In concurrent systems without automatic garbage collection, it is challenging to determine when it is safe to reclaim memory, especially for lock-free data structures. Existing concurrent memory reclamation schemes are either fast but do not tolerate process delays, robust to delays but with high overhead, or both robust and fast but narrowly applicable. This paper proposes QSense, a novel concurrent memory reclamation technique. QSense is a hybrid technique with a fast path and a fallback path. In the common case (without process delays), a high-performing memory reclamation scheme is used (fast path). If process delays block memory reclamation through the fast path, a robust fallback path is used to guarantee progress. The fallback path uses hazard pointers, but avoids their notorious need for frequent and expensive memory fences. QSense is widely applicable, as we illustrate through several lock-free data structure algorithms. Our experimental evaluation shows that QSense has an overhead comparable to the fastest memory reclamation techniques, while still tolerating prolonged process delays
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
ThreadScan: Automatic and Scalable Memory Reclamation
The concurrent memory reclamation problem is that of devising a way for a deallocating thread to verify that no other concurrent threads hold references to a memory block being deallocated. To date, in the absence of automatic garbage collection, there is no satisfactory solution to this problem. Existing tracking methods like hazard pointers, reference counters, or epoch-based techniques like RCU, are either prohibitively expensive or require significant programming expertise, to the extent that implementing them efficiently can be worthy of a publication. None of the existing techniques are automatic or even semi-automated. In this paper, we take a new approach to concurrent memory reclamation: instead of manually tracking access to memory locations as done in techniques like hazard pointers, or restricting shared accesses to specific epoch boundaries as in RCU, our algorithm, called ThreadScan, leverages operating system signaling to automatically detect which memory locations are being accessed by concurrent threads. Initial empirical evidence shows that ThreadScan scales surprisingly well and requires negligible programming effort beyond the standard use of Malloc and Free
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
Verifying Concurrent Stacks by Divergence-Sensitive Bisimulation
The verification of linearizability -- a key correctness criterion for
concurrent objects -- is based on trace refinement whose checking is
PSPACE-complete. This paper suggests to use \emph{branching} bisimulation
instead. Our approach is based on comparing an abstract specification in which
object methods are executed atomically to a real object program. Exploiting
divergence sensitivity, this also applies to progress properties such as
lock-freedom. These results enable the use of \emph{polynomial-time}
divergence-sensitive branching bisimulation checking techniques for verifying
linearizability and progress. We conducted the experiment on concurrent
lock-free stacks to validate the efficiency and effectiveness of our methods
- …