Espresso: Brewing Java For More Non-Volatility with Non-volatile Memory

@article{Wu2017EspressoBJ,
  title={Espresso: Brewing Java For More Non-Volatility with Non-volatile Memory},
  author={Mingyu Wu and Ziming Zhao and Haoyu Li and Heting Li and Haibo Chen and Binyu Zang and Haibing Guan},
  journal={Proceedings of the Twenty-Third International Conference on Architectural Support for Programming Languages and Operating Systems},
  year={2017}
}
  • Mingyu Wu, Ziming Zhao, +4 authors Haibing Guan
  • Published 2017
  • Computer Science
  • Proceedings of the Twenty-Third International Conference on Architectural Support for Programming Languages and Operating Systems
Fast, byte-addressable non-volatile memory (NVM) embraces both near-DRAM latency and disk-like persistence, which has generated considerable interests to revolutionize system software stack and programming models. [...] Key Method Espresso first provides a general persistent heap design called Persistent Java Heap (PJH) to manage persistent data as normal Java objects. The heap is then strengthened with a recoverable mechanism to provide crash consistency for heap metadata.Expand
JSNVM: Supporting Data Persistence in JavaScript Using Non-Volatile Memory
TLDR
JSNVM, an extension to JavaScript's runtime and execution engine, to support data persistence in JavaScript using NVM is presented and evaluated against two database-supported data persistence styles on micro-benchmarks and real-world applications. Expand
P-INSPECT: Architectural Support for Programmable Non-Volatile Memory Frameworks
TLDR
This paper introduces P-inspect, a novel hardware architecture targeted to speeding up persistence by reachability NVM programming frameworks, which uses bloom-filter hardware to perform various checks in a transparent and efficient manner and provides hardware for low-overhead persistent writes. Expand
GCPersist: an efficient GC-assisted lazy persistency framework for resilient Java applications on NVM
TLDR
GCPersist is proposed, an easy-to-use NVM programming framework atop a lazy persistency model to defer the persistency of user data for better performance, with the assistance of the garbage collection module in the managed runtime. Expand
QuickCheck: using speculation to reduce the overhead of checks in NVM frameworks
TLDR
This paper proposes QuickCheck, a technique that biases persistence checks based on their expected behavior, and exploits speculative optimizations to further reduce the overheads of these persistence checks. Expand
AutoPersist: an easy-to-use Java NVM framework based on reachability
TLDR
A new NVM programming framework, named AutoPersist, that only requires programmers to identify durable roots and persists all the data structures that can be reached from the durable roots in an automated and transparent manner is presented. Expand
Bridging the performance gap for copy-based garbage collectors atop non-volatile memory
TLDR
This paper proposes two NVM-aware optimizations: write cache and header map, to effectively manage the limited NVM bandwidth and improves the GC performance with hardware instructions like non-temporal memory accesses and prefetching. Expand
Compiler-support for Critical Data Persistence in NVM
TLDR
This article presents a compiler-support that automatically inserts complex instructions into kernels to achieve NVM data-persistence based on a simple programmer directive and shows that the proposed compiler- support outperforms the most recent checkpointing techniques while its performance overheads are insignificant. Expand
Persistent software transactional memory in Haskell
TLDR
It is shown in this paper how persistent software transactional memory (PSTM) can be tightly integrated into the runtime system of Haskell to atomically manage values of persistent transactional data types. Expand
End the Senseless Killing: Improving Memory Management for Mobile Operating Systems
TLDR
Marvin is a new memory manager for mobile platforms that efficiently supports swapping while meeting the strict performance requirements of mobile apps, and has a new swap mechanism, called ahead-of-time (AOT) swap, which pre-writes memory to disk, then harvests it quickly when needed. Expand
go-pmem: Native Support for Programming Persistent Memory in Go
TLDR
Go-pmem, an open-source extension to the Go language compiler and runtime that natively supports programming persistent memory, is contributed. Expand
...
1
2
3
4
...

References

SHOWING 1-10 OF 45 REFERENCES
NV-Heaps: making persistent objects fast and safe with next-generation, non-volatile memories
TLDR
A lightweight, high-performance persistent object system called NV-heaps is implemented that provides transactional semantics while preventing these errors and providing a model for persistence that is easy to use and reason about. Expand
NVthreads: Practical Persistence for Multi-threaded Applications
TLDR
NVthreads is a drop-in replacement for the pthreads library and requires only tens of lines of program changes to leverage non-volatile memory, and infers consistent states via synchronization points, uses the process memory to buffer uncommitted changes, and logs writes to ensure a program's data is recoverable even after a crash. Expand
Makalu: fast recoverable allocation of non-volatile memory
TLDR
This paper presents Makalu, a system that addresses non-volatile memory management and offers an integrated allocator and recovery-time garbage collector that maintains internal consistency, avoids NVRAM memory leaks, and is efficient, all in the face of failures. Expand
DudeTM: Building Durable Transactions with Decoupling for Persistent Memory
TLDR
DUDETM is presented, a crash-consistent durable transaction system that avoids the drawbacks of both undo logging and redo logging and can be implemented with existing hardware TMs with minor hardware modifications, leading to a further 1.7times speedup. Expand
Persistence programming models for non-volatile memory
TLDR
This work systematically explores what it considers to be the most promising part of the space, precisely defining semantics and identifying implementation costs, which allows for much more explicit and precise about semantic and implementation trade-offs that were usually glossed over in prior work. Expand
Atlas: leveraging locks for non-volatile memory consistency
TLDR
This paper identifies failure-atomic sections of code based on existing critical sections and describes a log-based implementation that can be used to recover a consistent state after a failure, and confirms the ability to rapidly flush CPU caches as a core implementation bottleneck and suggest partial solutions. Expand
An Analysis of Persistent Memory Use with WHISPER
TLDR
The Hands-off Persistence System (HOPS) is proposed to track updates to PM in hardware to provide high-level ISA primitives for applications to express durability and ordering constraints separately and enforces them automatically, while achieving 24.3% better performance over current approaches to persistence. Expand
High-Performance Transactions for Persistent Memories
TLDR
This work presents a comprehensive analysis contrasting two transaction designs across three NVRAM programming interfaces, demonstrating up to 2.5x speedup. Expand
Mnemosyne: lightweight persistent memory
TLDR
In tests emulating the performance characteristics of forthcoming SCMs, Mnemosyne can persist data as fast as 3 microseconds and can be up to 1400% faster than alternative persistence strategies, such as Berkeley DB or Boost serialization, that are designed for disks. Expand
Yak: A High-Performance Big-Data-Friendly Garbage Collector
TLDR
Yak is described, a "Big Data" friendly garbage collector that provides high throughput and low latency for all JVM-based languages and evaluation with three large systems shows very positive results. Expand
...
1
2
3
4
5
...