A persistent transactional memory (PTM) library provides an easy-to-use interface to programmers for using byte-addressable non-volatile memory (NVM). Previously proposed PTMs have, so far, been blocking. We present OneFile, the first wait-free PTM with integrated wait-free memory reclamation. We have designed and implemented two variants of the OneFile, one with lock-free progress and the other with bounded wait-free progress. We additionally present software transactional memory (STM) implementations of the lock-free and wait-free algorithms targeting volatile memory. Each of our PTMs and STMs is implemented as a single C++ file with ∼1,000 lines of code, making them versatile to use. Equipped with these PTMs and STMs, non-expert developers can design and implement their own lock-free and wait-free data structures on NVM, thus making lock-free programming accessible to common software developers.

Abstract. We consider the Tree Augmentation problem: given a graph = ( , ) with edge-costs and a tree on disjoint to , find a minimum-cost edge-subset ⊆ such that ∪ is 2-edge-connected. Tree Augmentation is equivalent to the problem of finding a minimumcost edge-cover ⊆ of a laminar set-family. The best known approximation ratio for Tree Augmentation is 2, even for trees of radius 2. As laminar families play an important role in network design problems, obtaining a better ratio is a major open problem in network design. We give a (1 + ln 2)-approximation algorithm for trees of constant radius. Our algorithm is based on a new decomposition of problem solutions, which may be of independent interest.

Non-volatile memory is expected to co-exist or replace DRAM in upcoming architectures. Durable concurrent data structures for non-volatile memories are essential building blocks for constructing adequate software for use with these architectures. In this paper, we propose a new approach for durable concurrent sets and use this approach to build the most efficient durable hash tables available today. Evaluation shows a performance improvement factor of up to 3.3x over existing technology.

Non-volatile memory (NVM) promises fast, byte-addressable and durable storage, with raw access latencies in the same order of magnitude as DRAM. But in order to take advantage of the durability of NVM, programmers need to design persistent objects which maintain consistent state across system crashes and restarts. Concurrent implementations of persistent objects typically make heavy use of expensive persistent fence instructions to order NVM accesses, thus negating some of the performance benefits of NVM. This raises the question of the minimal number of persistent fence instructions required to implement a persistent object. We answer this question in the deterministic lock-free case by providing lower and upper bounds on the required number of fence instructions. We obtain our upper bound by presenting a new universal construction that implements durably any object using at most one persistent fence per update operation invoked. Our lower bound states that in the worst case, each process needs to issue at least one persistent fence per update operation invoked.

Non-volatile memory (NVM) technologies such as PCM, ReRAM and STT-RAM allow processors to directly write values to persistent storage at speeds that are signi cantly faster than previous durable media such as hard drives or SSDs. Many applications of NVM are constructed on a logging subsystem, which enables operations to appear to execute atomically and facilitates recovery from failures. Writes to NVM, however, pass through a processor's memory system, which can delay and reorder them and can impair the correctness and cost of logging algorithms.Reordering arises because of out-of-order execution in a CPU and the inter-processor cache coherence protocol. By carefully considering the properties of these reorderings, this paper develops a logging protocol that requires only one round trip to non-volatile memory while avoiding expensive computations. We show how to extend the logging protocol to building a persistent set (hash map) that also requires only a single round trip to non-volatile memory for insertion, updating, or deletion.

No abstract

Lock-free data structures achieve high responsiveness, aid scalability, and avoid deadlocks and livelocks. But providing memory management support for such data structures without foiling their progress guarantees is difficult. Often, designers employ the hazard pointers technique, which may impose a high performance overhead.In this work we propose a novel memory management scheme for lock-free data structures called optimistic access. This scheme provides efficient support for lock-free data structures that can be presented in the normalized form of [24]. Our novel memory manager breaks the traditional memory management invariant which never lets a program touch reclaimed memory. In other words, it allows the memory manager to reclaim objects that may still be accessed later by concurrently running threads. This broken invariant provides an opportunity to obtain high parallelism with excellent performance, but it also requires a careful design. The optimistic access memory management scheme is easy to employ and we implemented it for a linked list, a hash table, and a skip list. Measurements show that it dramatically outperforms known memory reclamation methods.

Memory-management support for lock-free data structures is well known to be a tough problem. Recent work has successfully reduced the overhead of such schemes. However, applying memory-management support to a data structure remains complex and, in many cases, requires redesigning the data structure. In this paper, we present the first lock-free memory-management scheme that is applicable to general (arbitrary) lock-free data structures and that can be applied automatically via a compiler plug-in. In addition to the simplicity of incorporating to data structures, this scheme provides low overhead and does not rely on the lock freedom of any OS services.Nachshon Cohen the data structure into a real application. However, state-of-the-art memory reclamation schemes require the data structure to satisfy certain algorithmic properties that are not met by many practical data-structures. If a data structure does not satisfy the required properties, there is no clear recipe for modifying it so that it would be amenable to memory reclamation. In general, applying a lock-free memory-reclamation scheme to a given data structure might requires expertise that is not available to all practitioners, might modify the properties of the data structure, or might not be possible at all.Consider, for example, Harris's linked list [Harris 2001] that stands at the core of many lock-free data structures. The original hazard pointers paper [Michael 2002a] states that Harris's linked list is "inherently incompatible" with the hazard-pointers scheme 1 . Instead, they designed a variation of this data structure -the Harris-Michael linked list [Michael 2002b] -on which hazard pointers can be applied. The differences between these data structures are subtle, hence it is easy to confuse them. Such confusion can lead even experienced researchers to apply hazard pointers on the wrong data structure, resulting in an incorrect design. Furthermore, it was later shown that the Harris-Herlihy-Shavit linked list [Herlihy and Shavit 2012] is also incompatible with the hazardpointers scheme. This data structure offers stronger progress guarantees (i.e., wait-free searches) and better performance than the Harris-Michael linked list [Cohen and Petrank 2015a]. Other recent memory-reclamation schemes [Alistarh et al. 2015;Balmau et al. 2016;Braginsky et al. 2013;Brown 2015;Cohen and Petrank 2015b;Dice et al. 2016] are similarly incompatible with the Harris and Harris-Herlihy-Shavit linked-list data structures.In this paper, we present Free Access: the first memory-reclamation scheme that stands up to the expectations of the data-structure designers. The Free Access scheme does not require the data structure to satisfy any algorithmic properties, hence making it generally applicable for existing and future lock-free data structures. Instead, it requires only that no instruction simultaneously reads a new pointer and writes to the shared memory. All lock-free data structures we are aware of satisfy this property without any modification. We cannot preclude a f...