AutoPersist: an easy-to-use Java NVM framework based on reachability

Byte-addressable, non-volatile memory (NVM) is emerging as a revolutionary memory technology that provides persistency, near-DRAM performance, and scalable capacity. To facilitate its use, many NVM programming models have been proposed. However, most models require programmers to explicitly specify the data structures or objects that should reside in NVM. Such requirement increases the burden on programmers, complicates software development, and introduces opportunities for correctness and performance bugs. We believe that requiring programmers to identify the data structures that should reside in NVM is untenable. Instead, programmers should only be required to identify durable roots - the entry points to the persistent data structures at recovery time. The NVM programming framework should then automatically ensure that all the data structures reachable from these roots are in NVM, and stores to these data structures are persistently completed in an intuitive order. To this end, we present a new NVM programming framework, named AutoPersist, that only requires programmers to identify durable roots. AutoPersist then persists all the data structures that can be reached from the durable roots in an automated and transparent manner. We implement AutoPersist as a thread-safe extension to the Java language and perform experiments with a variety of applications running on Intel Optane DC persistent memory. We demonstrate that AutoPersist requires minimal code modifications, and significantly outperforms expert-marked Java NVM applications.

[1]  Yan Solihin,et al.  Proteus: A Flexible and Fast Software Supported Hardware Logging approach for NVM , 2017, 2017 50th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO).

[2]  Jian Huang,et al.  QuickCheck: using speculation to reduce the overhead of checks in NVM frameworks , 2019, VEE.

[3]  Stephen M. Blackburn,et al.  Concurrency - The Fly in the Ointment? , 1998, POS/PJW.

[4]  Satish Narayanasamy,et al.  Persistency for synchronization-free regions , 2018, PLDI.

[5]  Adam Silberstein,et al.  Benchmarking cloud serving systems with YCSB , 2010, SoCC '10.

[6]  Jeremy Manson,et al.  The Java memory model , 2005, POPL '05.

[7]  Satish Narayanasamy,et al.  Language-level persistency , 2017, 2017 ACM/IEEE 44th Annual International Symposium on Computer Architecture (ISCA).

[8]  Malcolm P. Atkinson,et al.  Orthogonal Persistence for the Java[tm] Platform: Specification and Rationale , 2000 .

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

[10]  Jian Huang,et al.  Defining a high-level programming model for emerging NVRAM technologies , 2018, ManLang '18.

[11]  David Detlefs,et al.  Garbage-first garbage collection , 2004, ISMM '04.

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

[13]  Michael J. Carey,et al.  The design of the E programming language , 1993, TOPL.

[14]  Malcolm P. Atkinson,et al.  PS-algol: an algol with a persistent heap , 1982, SIGP.

[15]  Alonso Marquez,et al.  Implementing Orthogonally Persistent Java , 2000, POS.

[16]  Seyong Lee,et al.  NVL-C: Static Analysis Techniques for Efficient, Correct Programming of Non-Volatile Main Memory Systems , 2016, HPDC.

[17]  Leslie Lamport,et al.  On-the-fly garbage collection: an exercise in cooperation , 1975, CACM.

[18]  Vivek Singhal,et al.  Texas: An Efficient, Portable Persistent Store , 1992, POS.

[19]  Michael M. Swift,et al.  An Analysis of Persistent Memory Use with WHISPER , 2017, ASPLOS.

[20]  V. T. Rajan,et al.  The Metronome: A Simpler Approach to Garbage Collection in Real-Time Systems , 2003, OTM Workshops.

[21]  Filip Pizlo,et al.  Stopless: a real-time garbage collector for multiprocessors , 2007, ISMM '07.

[22]  Luc Bläser,et al.  Persistent Oberon: A Programming Language with Integrated Persistence , 2007, APLAS.

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

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

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

[26]  Samira Manabi Khan,et al.  Programming for Non-Volatile Main Memory Is Hard , 2017, APSys.

[27]  Shih-Hung Chen,et al.  Phase-change random access memory: A scalable technology , 2008, IBM J. Res. Dev..

[28]  Brian T. Lewis,et al.  Architecture of the PEVM: A High-Performance Orthogonally Persistent Java Virtual Machine , 2000, POS.

[29]  Stratis Viglas,et al.  ATOM: Atomic Durability in Non-volatile Memory through Hardware Logging , 2017, 2017 IEEE International Symposium on High Performance Computer Architecture (HPCA).

[30]  Hisashi Shima,et al.  Resistive Random Access Memory (ReRAM) Based on Metal Oxides , 2010, Proceedings of the IEEE.

[31]  Malcolm P. Atkinson,et al.  A review of the rationale and architectures of PJama - a durable, flexible, evolvable and scalable orthogonally persistent programming platform , 2000, SMLI TR.

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

[33]  Michael Wolf,et al.  C4: the continuously concurrent compacting collector , 2011, ISMM '11.

[34]  Kathryn S. McKinley,et al.  Free-Me: a static analysis for automatic individual object reclamation , 2006, PLDI '06.

[35]  Kathryn S. McKinley,et al.  Pretenuring for Java , 2001, OOPSLA '01.

[36]  Christopher Frost,et al.  Better I/O through byte-addressable, persistent memory , 2009, SOSP '09.

[37]  Haibo Chen,et al.  Espresso: Brewing Java For More Non-Volatility with Non-volatile Memory , 2017, ASPLOS.

[38]  Antony L. Hosking,et al.  PM3: An Orthogonal Persistent Systems Programming Language - Design, Implementation, Performance , 1999, VLDB.

[39]  Youyou Lu,et al.  Loose-Ordering Consistency for persistent memory , 2014, 2014 IEEE 32nd International Conference on Computer Design (ICCD).

[40]  Michael Haupt,et al.  Maxine: An approachable virtual machine for, and in, java , 2013, TACO.

[41]  Ronald Morrison,et al.  Orthogonally persistent object systems , 1995, The VLDB Journal.

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

[43]  Guy L. Steele,et al.  The Java Language Specification, Java SE 8 Edition , 2013 .

[44]  Ellis Giles,et al.  Atomic persistence for SCM with a non-intrusive backend controller , 2016, 2016 IEEE International Symposium on High Performance Computer Architecture (HPCA).

[45]  Andrew Dinn,et al.  Shenandoah: An open-source concurrent compacting garbage collector for OpenJDK , 2016, PPPJ.

[46]  Thomas F. Wenisch,et al.  Memory persistency , 2014, 2014 ACM/IEEE 41st International Symposium on Computer Architecture (ISCA).

[47]  Karsten Schwan,et al.  NVRAM-aware Logging in Transaction Systems , 2014, Proc. VLDB Endow..

[48]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[49]  Guoqing Xu,et al.  Resurrector: a tunable object lifetime profiling technique for optimizing real-world programs , 2013, OOPSLA.

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