Blelloch, Guy E.

Wei, Yuanhao

English

Dagstuhl Research Online Publication Server

Brief Announcement: Concurrent Fixed-SizeAllocation and Free in Constant TimeGuy E. BlellochCarnegie Mellon University, Pittsburgh, PA, USAguyb@cs.cmu.eduYuanhao WeiCarnegie Mellon University, Pittsburgh, PA, USAyuanhao1@cs.cmu.eduAbstractWe describe an algorithm for supporting allocation and free for fixed-sized blocks, for p asynchronousprocessors, with O(1) worst-case time per operation, Θ(p2) additive space overhead, and using onlysingle-word read, write, and CAS. While many algorithms rely on having constant-time fixed-sizeallocate and free, we present the first implementation of these two operations that is constanttime with reasonable space overhead.2012 ACM Subject Classification Computing methodologies → Concurrent algorithmsKeywords and phrases malloc, free, fixed-size, concurrent, constant timeDigital Object Identifier 10.4230/LIPIcs.DISC.2020.51Related Version A full version of the paper is available at https://arxiv.org/abs/2008.04296.Funding This work was supported in part by NSF grants CCF-1901381, CCF-1910030, and CCF-1919223. Yuanhao Wei was also supported by a NSERC PGS-D Scholarship.1 IntroductionDynamic memory allocation is an important problem that plays a role in many data structures.Although some data structures require variable sized memory blocks, many are built on fixedsized blocks, including linked lists and trees.Our goal is to efficiently solve the dynamic memory allocation problem for fixed sizedmemory blocks in a concurrent setting. An allocate() returns a reference to a block, anda free(p) takes a reference p to an block. We say a block is live at some point in theexecution history if the last operation that used it (either a free that took it, or allocatethat returned it) was an allocate. Otherwise the block is available. As would be expected,an allocate must transition the returned block from available to live (i.e., the operationcannot return a block that is already live), and a free(p) must be applied to a live block p(i.e., the operation cannot free a block that is already available). In our setting, processesrun asynchronously and may be delayed arbitrarily.We describe a concurrent linearizable implementation of the fixed-sized memory allocationproblem with the following properties.I Result 1 (Fixed-sized Allocate/Free). Given m as the maximum number of live blocks, on pprocesses, we can support linearizable allocate and free for fixed sized blocks of k ≥ 2 words,with1. references that are just pointers to the block (i.e., memory addresses),2. O(1) worst-case time for each operation,3. k(m + Θ(p2)) space,4. single-word (at least pointer-width) read, write, and CAS.© Guy E. Blelloch and Yuanhao Wei;licensed under Creative Commons License CC-BY34th International Symposium on Distributed Computing (DISC 2020).Editor: Hagit Attiya; Article No. 51; pp. 51:1–51:3Leibniz International Proceedings in InformaticsSchloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany51:2 Concurrent Fixed-Size Allocation and Free in Constant TimeOur notion of time/space complexity includes both local and shared instructions/words.Limiting ourselves to pointer-width atomic instructions means that we do not use unboundedsequence numbers or hide bits in pointers. Achieving the last property of Result 1 requiresusing a recent result on implementing LL/SC from pointer-width CAS objects [3].We are not addressing the problem of supporting an unbounded number of allocated cells.Indeed this would seem to be impossible without some assumption of how the operatingsystem gives out large chunks of memory to allocate from. In our algorithm, the memoryallocator could potentially read from a memory block that is live, but it works correctlyregardless of what the user writes into the memory blocks. We believe these kinds of accessesare reasonable.There has been recent progress in designing memory reclamation algorithms that arewait-free [9, 2, 7, 1]. With wait-free memory reclamation, the memory allocation part becomesthe new limiting factor. While there has been work on lock-free memory allocation [6, 5, 8],the only work that we know of that is wait-free is by Aghazadeh and Woelfel [1]. Aghazadehand Woelfel’s GetFree and Release operations can be used to implement allocate andfree in constant time, but their algorithm requires Ω(mp3) space, making it impracticalin many applications. We guarantee the same time complexity and wait-freedom whileusing significantly less space. While our algorithm is mostly a theoretical contribution, theconstants are small and we believe it will be fast in practice as well.2 Algorithm OverviewOur algorithm is fairly simple. For some constant l ∈ Θ(p), our data structure consists oflocal private pools that each hold Θ(l) blocks and a shared pool that maintains a stack ofbatches, each containing l blocks. The high level idea of maintaining separate private andshared pools is widely used and has been shown to be fast in practice [6, 5, 8]. In the commoncase, most calls to allocate and free will be handled directly by the private pools. Batchesare transferred between shared and private pools occasionally to make sure there are not toomany or too few free blocks in each private pool. Having too many private blocks weakensthe bound in Item 3 of Result 1 because these blocks cannot be allocated by other processes.Pushing to and popping from the shared stack takes O(p) time which is fairly expensive.To amortize this cost, push and pop can be broken up into p steps of O(1) time each andperformed across multiple calls to allocate or free. In the full version of our paper, weshow how to manage the private pools so that there is at most one ongoing push or pop perprocess. For our shared pool, we start with Fatourou and Kallimanis’s P-SIM stack [4] andmodify it to achieve the following bounds:I Result 2 (Shared Stack). Given a concurrent allocator satisfying Result 1 with parameterk ≥ 2, assuming that reading from a memory block that has already been freed returns anarbitrary value, on p processes, we can support linearizable push and pop with1. O(p) worst-case time for each operation,2. at most 2p calls to allocate and 2p calls to free in each operation,3. Mk + Θ(p2k) space (where M is the number of nodes in the stack),4. single-word (at least pointer-width) read, write, and CAS.At first glance, it may seem circular that Results 1 and 2 are used to implement eachother. However, this is the key trick in our algorithm. We observe that it is safe for the datastructures in the shared pool to allocate memory from the same private pools as the user.Special care is needed to ensure that the private pools always have enough blocks to serviceboth the user and the shared pool. For this to work, Property 2 of Result 2 is crucial.G. E. Blelloch and Y. Wei 51:3In the P-SIM stack, push and pop operations help each other to ensure that eachoperation completes within O(p) time (Property 1). The P-SIM stack can be modified tosatisfy Property 4 using a recent simulation of LL/SC from CAS [3]. While there has been alot of work on simulating LL/SC from CAS, [3] is the only one we are aware of that maintainsthe other properties in Result 2. To satisfy Properties 2 and 3, we add memory managementwhile ensuring that each push or pop calls free at most 2p times. In the P-SIM stack, eachprocess performs push and pop operations on its local copy of the shared stack, and thentries to set its local copy as the new shared stack using an SC. We modify this algorithm sothat after each successful SC, the process frees all the nodes that it locally popped, and aftereach unsuccessful SC, the process frees all the nodes that it locally pushed. This modificationsounds straightforward but it has a complication. It is possible for a process working on aoutdated copy of a shared stack to read a node that is already freed by this approach. Inmost settings, accessing freed memory is not allowed, however, these accesses are reasonablein our setting because they are internal to our memory allocator. Whenever a node is poppedoff the shared stack and freed, the memory is not freed back to the operating system, insteadit is made available to the user. Accessing memory that has been allocated to the user mayreturn an arbitrary value, so such accesses are still dangerous. We protect against this byperforming VL after every potentially dangerous access. If the VL returns true, then therehas not been an SC on the shared stack since the process’s last LL, so the process is workingon an up-to-date view of the shared stack. This means that the earlier memory access wassafe. If the VL returns false, then the process’s subsequent SC is guaranteed to fail. In thiscase, the process restarts its operation and frees any nodes that it locally pushed. With thesemodifications, the P-SIM stack satisfies all the properties in Result 2.References1 Zahra Aghazadeh and Philipp Woelfel. Upper bounds for boundless tagging with boundedobjects. In International Symposium on Distributed Computing (DISC), pages 442–457, 2016.2 Guy E. Blelloch and Yuanhao Wei. Concurrent reference counting and resource managementin wait-free constant time, 2020. arXiv:2002.07053.3 Guy E Blelloch and Yuanhao Wei. LL/SC and atomic copy: Constant time, space efficientimplementations using only pointer-width CAS. In International Symposium on DistributedComputing (DISC), 2020.4 Panagiota Fatourou and Nikolaos D Kallimanis. A highly-efficient wait-free universal con-struction. In ACM Symposium on Parallelism in Algorithms and Architectures (SPAA), pages325–334, 2011.5 Anders Gidenstam, Marina Papatriantafilou, and Philippas Tsigas. NBmalloc: Allocatingmemory in a lock-free manner. Algorithmica, 58(2):304–338, 2010.6 Maged M Michael. Scalable lock-free dynamic memory allocation. In Proceedings of the ACMSIGPLAN 2004 conference on Programming language design and implementation, pages 35–46,2004.7 Ruslan Nikolaev and Binoy Ravindran. Universal wait-free memory reclamation. In ACMSymposium on Principles and Practice of Parallel Programming (PPoPP), page 130–143, 2020.8 Sangmin Seo, Junghyun Kim, and Jaejin Lee. SFMalloc: A lock-free and mostlysynchronization-free dynamic memory allocator for manycores. In International Conferenceon Parallel Architecture and Compilation Techniques (PACT), pages 253–263, 2011.9 Håkan Sundell. Wait-free reference counting and memory management. In InternationalParallel and Distributed Processing Symposium (IPDPS), 2005.DISC 2020

Brief Announcement: Concurrent Fixed-Size Allocation and Free in Constant Time

https://drops.dagstuhl.de/opus/volltexte/2020/13129/pdf/LIPIcs-DISC-2020-51.pdf

Brief Announcement: Concurrent Fixed-Size Allocation and Free in Constant Time

Abstract

Similar works

Full text

Available Versions

Dagstuhl Research Online Publication Server