Abstract
There is an increasing body of literature proposing new and efficient persistent versions of concurrent data structures ensuring that a consistent state can be recovered after a power failure or a crash. Their correctness is typically stated in terms of durable linearizability (DL), which requires that individual library operations appear to be executed atomically in a sequence consistent with the real-time order and, moreover, that recovering from a crash return a state corresponding to a prefix of that sequence. Sadly, however, there are hardly any formal DL proofs, and those that do exist cover the correctness of rather simple persistent algorithms on specific (simplified) persistency models. In response, we propose a general, powerful, modular, and incremental proof technique that can be used to guide the development and establish DL. Our technique is (1) general, in that it is not tied to a specific persistency and/or consistency model, (2) powerful, in that it can handle the most advanced persistent algorithms in the literature, (3) modular, in that it allows the reuse of an existing linearizability argument, and (4) incremental, in that the additional requirements for establishing DL depend on the complexity of the algorithm to be verified. We illustrate this technique on various versions of a persistent set, leading to the link-free set of Zuriel et al.
- Marcos K. Aguilera and Svend Frolund. 2003. Strict Linearizability and the Power of Aborting. https://www.hpl.hp.com/ techreports/2003/HPL-2003-241.html
Google Scholar
- Jade Alglave. 2012. A formal hierarchy of weak memory models. Formal Methods Syst. Des. 41, 2 ( 2012 ), 178-210. https: //doi.org/10.1007/S10703-012-0161-5
Google Scholar
Digital Library
- Mark Batty, Mike Dodds, and Alexey Gotsman. 2013. Library abstraction for C/C++ concurrency. In POPL 2013. ACM, New York, NY, USA, 235-248. https://doi.org/10.1145/2429069.2429099
Google Scholar
Digital Library
- Mark Batty, Scott Owens, Susmit Sarkar, Peter Sewell, and Tjark Weber. 2011. Mathematizing C+ + Concurrency. In Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (Austin, Texas, USA) ( POPL '11). Association for Computing Machinery, New York, NY, USA, 55-66. https://doi.org/10.1145/1926385.1926394
Google Scholar
Digital Library
- Sebastian Burckhardt, Alexey Gotsman, Madanlal Musuvathi, and Hongseok Yang. 2012. Concurrent Library Correctness on the TSO Memory Model. In ESOP 2012 (LNCS, Vol. 7211 ). Springer, Heidelberg, Germany, 87-107. https://doi.org/10. 1007/978-3-642-28869-2_5
Google Scholar
Digital Library
- Nachshon Cohen, Rachid Guerraoui, and Igor Zablotchi. 2018. The Inherent Cost of Remembering Consistently. In SPAA. ACM, 259-269. https://doi.org/10.1145/3210377.3210400
Google Scholar
Digital Library
- John Derrick, Simon Doherty, Brijesh Dongol, Gerhard Schellhorn, and Heike Wehrheim. 2021. Verifying correctness of persistent concurrent data structures: a sound and complete method. Formal Aspects Comput. 33, 4-5 ( 2021 ), 547-573. https://doi.org/10.1007/s00165-021-00541-8
Google Scholar
Digital Library
- Emanuele D'Osualdo, Azalea Raad, and Viktor Vafeiadis. 2022. The Path to Durable Linearizability (Extended Version). CoRR arxiv:2211.07631 ( 2022 ). https://doi.org/10.48550/arxiv.2211.07631
Google Scholar
- Michal Friedman, Naama Ben-David, Yuanhao Wei, Guy E. Blelloch, and Erez Petrank. 2020. NVTraverse: in NVRAM data structures, the destination is more important than the journey. In PLDI. ACM, 377-392. https://doi.org/10.1145/3385412. 3386031
Google Scholar
Digital Library
- Michal Friedman, Maurice Herlihy, Virendra Marathe, and Erez Petrank. 2018. A Persistent Lock-Free Queue for Non-Volatile Memory. In Proceedings of the 23rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (Vienna, Austria) ( PPoPP '18). Association for Computing Machinery, New York, NY, USA, 28-40. https://doi.org/10.1145/3178487. 3178490
Google Scholar
Digital Library
- Michal Friedman, Erez Petrank, and Pedro Ramalhete. 2021. Mirror: making lock-free data structures persistent. In PLDI. ACM, 1218-1232. https://doi.org/10.1145/3453483.3454105
Google Scholar
Digital Library
- Timothy L. Harris. 2001. A Pragmatic Implementation of Non-blocking Linked-Lists. In DISC (Lecture Notes in Computer Science, Vol. 2180 ). Springer, 300-314. https://doi.org/10.1007/3-540-45414-4_21
Google Scholar
Cross Ref
- Maurice Herlihy and Jeannette M. Wing. 1990. Linearizability: A correctness condition for concurrent objects. ACM Trans. Program. Lang. Syst. 12, 3 ( 1990 ), 463-492. https://doi.org/10.1145/78969.78972
Google Scholar
Digital Library
- Intel. 2015. Persistent Memory Programming. http://pmem.io/
Google Scholar
- Joseph Izraelevitz, Hammurabi Mendes, and Michael L. Scott. 2016. Linearizability of Persistent Memory Objects Under a Full-System-Crash Failure Model. In DISC (Lecture Notes in Computer Science, Vol. 9888 ), Cyril Gavoille and David Ilcinkas (Eds.). 313-327. https://doi.org/10.1007/978-3-662-53426-7_23
Google Scholar
Cross Ref
- Takayuki Kawahara, Kenchi Ito, Riichiro Takemura, and Hideo Ohno. 2012. Spin-transfer torque RAM technology: Review and prospect. Microelectron. Reliab. 52, 4 ( 2012 ), 613-627. https://doi.org/10.1016/J.MICROREL. 2011. 09.028
Google Scholar
Cross Ref
- Leslie Lamport. 1979. How to make a multiprocessor computer that correctly executes multiprocess programs. IEEE Trans. Computers 28, 9 (Sept. 1979 ), 690-691. https://doi.org/10.1109/TC. 1979.1675439
Google Scholar
Digital Library
- Benjamin C. Lee, Engin Ipek, Onur Mutlu, and Doug Burger. 2009. Architecting phase change memory as a scalable DRAM alternative. In ISCA. ACM, 2-13. https://doi.org/10.1145/1555754.1555758
Google Scholar
Digital Library
- Maged M. Michael and Michael L. Scott. 1996. Simple, Fast, and Practical Non-blocking and Blocking Concurrent Queue Algorithms. In Proceedings of the Fifteenth Annual ACM Symposium on Principles of Distributed Computing (Philadelphia, Pennsylvania, USA) ( PODC '96). ACM, New York, NY, USA, 267-275. https://doi.org/10.1145/248052.248106
Google Scholar
Digital Library
- Peter W. O'Hearn, Noam Rinetzky, Martin T. Vechev, Eran Yahav, and Greta Yorsh. 2010. Verifying linearizability with hindsight. In PODC. 85-94. https://doi.org/10.1145/1835698.1835722
Google Scholar
Digital Library
- Steven Pelley, Peter M. Chen, and Thomas F. Wenisch. 2014. Memory persistency. In ISCA. IEEE Computer Society, 265-276. https://doi.org/10.1109/ISCA. 2014.6853222
Google Scholar
Cross Ref
- Azalea Raad, Marko Doko, Lovro Rožić, Ori Lahav, and Viktor Vafeiadis. 2019a. On Library Correctness under Weak Memory Consistency: Specifying and Verifying Concurrent Libraries under Declarative Consistency Models. 3, POPL ( 2019 ). https://doi.org/10.1145/3290381
Google Scholar
Digital Library
- Azalea Raad and Viktor Vafeiadis. 2018. Persistence Semantics for Weak Memory: Integrating Epoch Persistency with the TSO Memory Model. Proc. ACM Program. Lang. 2, OOPSLA, Article 137 (Oct. 2018 ), 27 pages. https://doi.org/10.1145/3276507
Google Scholar
Digital Library
- Azalea Raad, John Wickerson, Gil Neiger, and Viktor Vafeiadis. 2020. Persistency semantics of the Intel-x86 architecture. Proc. ACM Program. Lang. 4, POPL ( 2020 ), 11 : 1-11 : 31. https://doi.org/10.1145/3371079
Google Scholar
Digital Library
- Azalea Raad, John Wickerson, and Viktor Vafeiadis. 2019b. Weak Persistency Semantics from the Ground Up: Formalising the Persistency Semantics of ARMv8 and Transactional Models. Proc. ACM Program. Lang. 3, OOPSLA, Article 135, 27 pages. https://doi.org/10.1145/3360561
Google Scholar
Digital Library
- Gerhard Schellhorn, John Derrick, and Heike Wehrheim. 2014. A Sound and Complete Proof Technique for Linearizability of Concurrent Data Structures. ACM Trans. Comput. Log. 15, 4 ( 2014 ), 31 : 1-31 : 37. https://doi.org/10.1145/2629496
Google Scholar
Digital Library
- Peter Sewell, Susmit Sarkar, Scott Owens, Francesco Zappa Nardelli, and Magnus O. Myreen. 2010. X86-TSO: A Rigorous and Usable Programmer's Model for X86 Multiprocessors. Commun. ACM 53, 7 (jul 2010 ), 89-97. https://doi.org/10. 1145/1785414.1785443
Google Scholar
Digital Library
- Storage Networking Industry Association (SNIA). 2017. NVM Programming Model (NPM). SNIA Technical Position. https://www.snia.org/sites/default/files/technical_work/final/NVMProgrammingModel_v1.2.pdf Version 1.2.
Google Scholar
- Dmitri B Strukov, Gregory S Snider, Duncan R Stewart, and R Stanley Williams. 2008. The missing memristor found. Nature 453, 7191 ( 2008 ), 80-83. https://doi.org/10.1109/IOLTS. 2019.8854427
Google Scholar
Cross Ref
- Yuanhao Wei, Naama Ben-David, Michal Friedman, Guy E. Blelloch, and Erez Petrank. 2022. FliT: a library for simple and eficient persistent algorithms. In PPoPP. ACM, 309-321. https://doi.org/10.1145/3503221.3508436
Google Scholar
Digital Library
- Yoav Zuriel, Michal Friedman, Gali Shefi, Nachshon Cohen, and Erez Petrank. 2019. Eficient lock-free durable sets. Proc. ACM Program. Lang. 3, OOPSLA ( 2019 ), 128 : 1-128 : 26. https://doi.org/10.1145/3360554
Google Scholar
Digital Library
Index Terms
The Path to Durable Linearizability
Recommendations
Checking Linearizability of Encapsulated Extended Operations
Proceedings of the 23rd European Symposium on Programming Languages and Systems - Volume 8410Linearizable objects data-structures provide operations that appear to execute atomically. Modern mainstream languages provide many linearizable data-structures, simplifying concurrent programming. In practice, however, programmers often find a need to ...
Help when needed, but no more: Efficient read/write partial snapshot
An atomic snapshot object is an object that can be concurrently accessed by asynchronous processes prone to crash. It is made of m components (base atomic registers) and is defined by two operations: an update operation that allows a process to ...
Help when needed, but no more: efficient read/write partial snapshot
DISC'09: Proceedings of the 23rd international conference on Distributed computingAn atomic snapshot object is an object that can be concurrently accessed by asynchronous processes prone to crash. It is made of m components (base atomic registers) and is defined by two operations: an update operation that allows a process to ...






Comments