The Inherent Cost of Remembering Consistently

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 \em 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.

[1]  Youjip Won,et al.  NVWAL: Exploiting NVRAM in Write-Ahead Logging , 2016, ASPLOS.

[2]  Onur Mutlu,et al.  NVMOVE: Helping Programmers Move to Byte-Based Persistence , 2016, INFLOW@OSDI.

[3]  Maurice Herlihy,et al.  Linearizability: a correctness condition for concurrent objects , 1990, TOPL.

[4]  Marcos K. Aguilera,et al.  Black-box Concurrent Data Structures for NUMA Architectures , 2017, ASPLOS.

[5]  Eran Yahav,et al.  Verifying atomicity via data independence , 2014, ISSTA 2014.

[6]  Qin Jin,et al.  Persistent B+-Trees in Non-Volatile Main Memory , 2015, Proc. VLDB Endow..

[7]  Jens Palsberg,et al.  Automatic Atomicity Verification for Clients of Concurrent Data Structures , 2014, CAV.

[8]  Seyong Lee,et al.  Language-Based Optimizations for Persistence on Nonvolatile Main Memory Systems , 2017, 2017 IEEE International Parallel and Distributed Processing Symposium (IPDPS).

[9]  Nir Shavit,et al.  Flat combining and the synchronization-parallelism tradeoff , 2010, SPAA '10.

[10]  Sam H. Noh,et al.  WORT: Write Optimal Radix Tree for Persistent Memory Storage Systems , 2017, FAST.

[11]  Nachshon Cohen,et al.  The Inherent Cost of Remembering Consistently [ Technical Report ] , 2017 .

[12]  Vijayalakshmi Srinivasan,et al.  Scalable high performance main memory system using phase-change memory technology , 2009, ISCA '09.

[13]  Maurice Herlihy,et al.  A persistent lock-free queue for non-volatile memory , 2018, PPoPP.

[14]  Erez Petrank,et al.  Wait-free queues with multiple enqueuers and dequeuers , 2011, PPoPP '11.

[15]  Maurice Herlihy,et al.  Wait-free synchronization , 1991, TOPL.

[16]  Steven Swanson,et al.  A study of application performance with non-volatile main memory , 2015, 2015 31st Symposium on Mass Storage Systems and Technologies (MSST).

[17]  Hans-Juergen Boehm,et al.  Persistence programming models for non-volatile memory , 2016, ISMM.

[18]  Amar Phanishayee,et al.  Atomic In-place Updates for Non-volatile Main Memories with Kamino-Tx , 2017, EuroSys.

[19]  MutluOnur,et al.  Architecting phase change memory as a scalable dram alternative , 2009 .

[20]  K QureshiMoinuddin,et al.  Scalable high performance main memory system using phase-change memory technology , 2009 .

[21]  Maurice Herlihy,et al.  The Art of Multiprocessor Programming, Revised Reprint , 2012 .

[22]  Weimin Zheng,et al.  DudeTM: Building Durable Transactions with Decoupling for Persistent Memory , 2017, ASPLOS.

[23]  James R. Larus,et al.  Efficient logging in non-volatile memory by exploiting coherency protocols , 2017, Proc. ACM Program. Lang..

[24]  Song Jiang,et al.  Wormhole: A Fast Ordered Index for In-memory Data Management , 2018 .

[25]  Thomas F. Wenisch,et al.  High-Performance Transactions for Persistent Memories , 2016, ASPLOS.

[26]  Dahlia Malkhi,et al.  CORFU: A distributed shared log , 2013, TOCS.

[27]  Terence Kelly,et al.  Failure-Atomic Persistent Memory Updates via JUSTDO Logging , 2016 .

[28]  Maurice Herlihy,et al.  A Methodology for Implementing Highly Concurrent Data Objects , 1992, OPSR.

[29]  Michael Factor,et al.  Using Storage Class Memory Efficiently for an In-memory Database , 2016, SYSTOR.

[30]  Michael M. Swift,et al.  Mnemosyne: lightweight persistent memory , 2011, ASPLOS XVI.

[31]  Erez Petrank,et al.  A practical wait-free simulation for lock-free data structures , 2014, PPoPP '14.

[32]  Hans-Juergen Boehm,et al.  Atlas: leveraging locks for non-volatile memory consistency , 2014, OOPSLA.

[33]  Michael L. Scott,et al.  Linearizability of Persistent Memory Objects Under a Full-System-Crash Failure Model , 2016, DISC.

[34]  Maged M. Michael,et al.  Simple, fast, and practical non-blocking and blocking concurrent queue algorithms , 1996, PODC '96.

[35]  Onur Mutlu,et al.  Architecting phase change memory as a scalable dram alternative , 2009, ISCA '09.

[36]  Ismail Oukid,et al.  FPTree: A Hybrid SCM-DRAM Persistent and Concurrent B-Tree for Storage Class Memory , 2016, SIGMOD Conference.

[37]  Rachid Guerraoui,et al.  Laws of order: expensive synchronization in concurrent algorithms cannot be eliminated , 2011, POPL '11.

[38]  Rachid Guerraoui,et al.  Robust emulations of shared memory in a crash-recovery model , 2004, 24th International Conference on Distributed Computing Systems, 2004. Proceedings..

[39]  Patrick Th. Eugster,et al.  NVthreads: Practical Persistence for Multi-threaded Applications , 2017, EuroSys.

[40]  Eran Yahav,et al.  Automatic scalable atomicity via semantic locking , 2015, PPoPP.

[41]  Stratis Viglas,et al.  REWIND: Recovery Write-Ahead System for In-Memory Non-Volatile Data-Structures , 2015, Proc. VLDB Endow..

[42]  Rajesh K. Gupta,et al.  NV-Heaps: making persistent objects fast and safe with next-generation, non-volatile memories , 2011, ASPLOS XVI.

[43]  Tao Zou,et al.  Tango: distributed data structures over a shared log , 2013, SOSP.

[44]  Bingsheng He,et al.  NV-Tree: Reducing Consistency Cost for NVM-based Single Level Systems , 2015, FAST.

[45]  Wojciech M. Golab,et al.  Robust Shared Objects for Non-Volatile Main Memory , 2015, OPODIS.