English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Plus annual

Presents the access of premium content as premium feature

Premium Content

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Plus monthly

Global: Zendy Tools annual

Global: Zendy Tools monthly

Global: Zendy Free Plan

Memory reclamation for lock-based data structures is typically easy. However,it is a significant challenge for lock-free data structures. Automatictechniques such as garbage collection are inefficient or use locks, andnon-automatic techniques either have high overhead, or do not work for manydata structures. For example, subtle problems can arise when hazard pointers,one of the most common non-automatic techniques, are applied to many lock-freedata structures. Epoch based reclamation (EBR), which is by far the mostefficient non-automatic technique, allows the number of unreclaimed objects togrow without bound, because one crashed process can prevent all other processesfrom reclaiming memory.  We develop a more efficient, distributed variant of EBR that solves thisproblem. It is based on signaling, which is provided by many operating systems,such as Linux and UNIX. Our new scheme takes $O(1)$ amortized steps perhigh-level operation on the data structure and $O(1)$ steps in the worst caseeach time an object is removed from the data structure. At any point, $O(mn^2)$objects are waiting to be freed, where $n$ is the number of processes and $m$is a small constant for most data structures. Experiments show that our schemehas very low overhead: on average 10\%, and at worst 28\%, for a balancedbinary search tree over many thread counts, operation mixes and contentionlevels. Our scheme also outperforms a highly tuned implementation of hazardpointers by an average of 75\%.  Typically, memory reclamation is tightly woven into lock-free data structurecode. To improve modularity and facilitate the comparison of different memoryreclamation schemes, we also introduce a highly flexible abstraction. It allowsa programmer to easily interchange schemes for reclamation, object pooling,allocation and deallocation with virtually no overhead, by changing a singleline of code.

Reclaiming memory for lock-free data structures: there has to be a better way