SUNDAY, JULY 21
7:00 pm – whenever
Informal Gathering
Some of us will be hanging out at Galaxy Taco (2259 Avenida De La Playa, La Jolla, CA 92037; map). Come join us!
MONDAY, JULY 22
8:00 am – 9:00 am | Foyer
Breakfast
9:00 am – 10:00 am | Samuel H. Scripps Auditorium
Keynote I
The 3rd Rail of Linux Filesystems: A Survival Story
The 3rd Rail of Linux Filesystems: A Survival Story
Speaker: Dan Williams, Intel Corporation
Video
Abstract
It has been long established fact that Linux filesystems reserve the right to discard any and all file/directory updates prior to the last fsync(). However, with PMEM, where persisting data can be achieved with a handful of instructions, a system call, that takes several orders of magnitude more instructions, to persist data is untenable. This talk tells the story of the technical, practical, and interpersonal concerns of grabbing the 3rd rail of Linux filesystems and not only live to tell the tale, but succeed in delivering the full promise of PMEM programming to applications.
Speaker bio
Dan is a Principal Engineer on the team responsible for Intel’s persistent memory (PMEM) enabling in the Linux kernel. Specifically, he established and maintains the “libnvdimm” sub-system tasked with managing platform PMEM resources. Current work involves completing the integration of DAX semantics into Linux filesystems and ongoing development of hardware platform features that intersect with PMEM. His 18-year career spans many facets of storage system-software across Intel and Facebook.
10:00 am – 10:30 am
Break
10:30 am – 12:00 pm | Samuel H. Scripps Auditorium
Session 1a
Chair: Jim Fister
Persistent Memory Programming on Conventional Hardware
Real PMEM in Research: “How-Tos” and “How To?-s”
Persistent Memory Programming on Conventional Hardware
Speaker: Terence Kelly, Unaffiliated
Slides
Video
Abstract
This talk shows how a software abstraction of persistent memory (p-mem), together with failure-atomic msync (FAMS), allows us to program confidently in “the NVM style” on conventional hardware, without actual NVM. We will illustrate p-mem programming with working code, cover three past FAMS implementations and two new ones, and discuss several open problems and challenges surrounding p-mem.
Real PMEM in Research: “How-Tos” and “How To?-s”
Speaker: Ada Gavrilovska, Georgia Tech
Video
Abstract
For years the research community has been developing new software technologies and application stacks for the much anticipated high-capacity persistent memories using simulation, emulation, and a combination of both. Migrating research projects to the real hardware uncovers a number of new questions – from how to understand performance results, to how to interface PMEM with other aspects of the research testbeds, such as support for hardware transactional memory or for high-performance networking. In this talk, we will share the How-Tos we resolved, and raise some open How To?-s.
10:30 am – 12:00 pm | Edward H. “Ted” Scripps II Room
Session 1b
Chair: Joe Izraelevitz
Adding Persistence to Java
Protecting SW From Itself: Powerfail Atomicity for Block Writes
Persistent Memory for Java
Adding Persistence to Java
Speaker: Mario Wolczko, Oracle Labs
Slides
Video
Abstract
I have been exploring options for how persistence can be integrated into the Java platform. My current direction involves a partitioned heap (following NVM-Direct) and checkpointing. I can talk about the design and the rationale behind it. For more details see https://medium.com/@mwolczko/non-volatile-memory-and-java-7ba80f1e730c.
Protecting SW From Itself: Powerfail Atomicity for Block Writes
Speaker: Andy Rudoff, Intel
Slides
Video
Abstract
Support for legacy applications and file systems is an important part of persistent memory enabling. This is the story of one of the most misunderstood aspects of the storage APIs: whether writes can be torn by a power failure. These torn writes are possible, but so rare that SW bugs in this area have gone unfixed, not just in applications, but in commonly-used file systems as well. Since fixing the SW bugs overnight was impractical, we designed an algorithm to provide write atomicity with much lower overhead than the standard logging or allocating-write algorithms. We will describe the challenges faced, the implementation, and how we standardized the result which has been shipping in major operating systems for some time now.
Persistent Memory for Java
Speaker: Jonathan Halliday, Andrew Dinn, Red Hat
Slides
Abstract
We describe how, through a community open source process, we’re evolving OpenJDK to natively support operations on pmem, removing the need to access C libraries via JNI. We show code at the JVM (i.e. bytecode and C) and user library (Java) levels and discuss issues of cross-platform use, performance, testing and middleware evolution.
12:00 pm – 12:05 pm | Foyer
Group Photo
12:05 pm – 1:00 pm | Foyer
Lunch
1:00 pm – 2:00 pm | Samuel H. Scripps Auditorium
Keynote II
Programming Persistent Memory in A Virtualized Environment using Golang
Programming Persistent Memory in A Virtualized Environment using Golang
Speaker: Pratap Subrahmanyam, VMWare
Slides
Video
Abstract
Writing crash consistent applications that use the byte addressable load/store mode of persistent memory, is difficult and error-prone. To make this mode accessible to normal developers we (1) enhanced Golang, and (2) virtualized persistent memory. To put these two improvements to test, we developed Go-Redis, a partial re-implementation of Redis in enhanced Golang, in a virtual machine. We share performance data from Go-Redis on standard Redis benchmarks, and also describe the unique beneficial aspects of programming persistent memory from within a virtualized environment.
Speaker bio
Pratap Subrahmanyam helped develop the software emulation for the x86’s MMU, a key part of the virtual machine monitor, that got VMware started. He then helped the effort in VMware to virtualize byte addressable persistent memory, and also make it usable by developing language features, runtime libraries, and enhancing garbage collectors. Over the last several years, Pratap has been focusing on using FPGAs to enhance the performance of the vSphere virtualization platform.
2:00 pm – 2:45 pm
Break
2:45 pm – 3:45 pm | Samuel H. Scripps Auditorium
Keynote III
Persistent Memory in Feature Animation Production
Persistent Memory in Feature Animation Production
Speaker: Scott Miller, Dreamworks Animation
Abstract
Feature Animated films require hundreds of artists, thousands of assets, millions of files and 150 Million CPU hours. How might Persistent Memory alter the way these films are created? This talk will describe the production process and the resources required to create a feature film, and discuss current and proposed projects involving Persistent Memory and the effect on the Artists.
Speaker bio
Scott Miller is currently a Technology Fellow at DreamWorks Feature Animation, where he is involved in both Daily Operation and long-term strategy for High-Performance Computing, High-Performance Storage and Networking used in the computational visualization required for Computer Generated Animated Films. Mr. Miller has been with DreamWorks Animation since 1999, and has credits on more than 35 films, most recently “How to Train Your Dragon: The Hidden World”.
3:45 pm – 4:30 pm
Break
4:30 pm – 5:30 pm | Samuel H. Scripps Auditorium
Session 2a
Chair: Jishen Zhao
ZUFS Overview
An Empirical Guide to Using 3DXPoint Memory
ZUFS Overview
Speaker: Shachar Sharon, NetApp
Slides
Video
Abstract
Development of pmem-based file-system in user-space with ZUFS (MaxData)
An Empirical Guide to Using 3DXPoint Memory
Speaker: Joe Izraelevitz, UCSD
Slides
Video
Abstract
We have explored the performance properties and characteristics of Intel’s new 3DXPoint DIMMs at the micro and macro level. First, we investigate the basic characteristics of the device, taking special note of the particular ways in which its performance is peculiar relative to traditional DRAM. From these observations, we recommend a set of best practices to maximize the performance of the device. With our improved understanding, we then explore the performance of prior art in application-level software for persistent memory, taking note of where their performance was influenced by our guidelines.
4:30 pm – 5:30 pm | Edward H. “Ted” Scripps II Room
Session 2b
Chair: Jim Fister
Benchmarking Persistent Range Indexes
PMTest: A Fast and Flexible Testing Framework for Persistent Memory Programs
Benchmarking Persistent Range Indexes
Speaker: Lucas Lersch, TU Dresden
Slides
Video
Abstract
In the past years, several data structures were proposed to take full advantage of, by the time, upcoming persistent memory technologies (PM). Most of these data structures are of major importance in the context of database systems as they are widely used both as indexes and building blocks of more complex components. At that time, specifics of non-volatile memory could only be speculated, which lead these works to use different programming models and base performance evaluation either on plain DRAM or emulated PM.
In recent work [1] we have revisited some of these data structures in view of the freshly released Intel Optane DC Persistent Memory. We picked four persistent B+Tree-based data structures [2,3,4,5] and re-implemented them in a unified way by using PMDK [6], as it is the most mature PM programming library available today. Furthermore, we have developed an extensible benchmark framework that integrates Processor Counter Monitor [7] and ipmwatch (a DCPMM performance profiling tool to be release by Intel but already made available to the authors) to provide specific PM metrics (such as memory traffic, DCPMM-buffered accesses, and cache-misses) in addition to regular performance metrics (such average throughput and standard deviation). We used our benchmark framework to evaluate the performance of our data structures on real DCPMM.
In this talk will share our experience and lessons learned from this work. The talk will be divided into three parts. First, we will discuss the challenges of adapting the original data structures to the PMDK programming model. We will highlight how assumptions made by previous work (such as 8 Bytes persistent pointers, cheap persistent allocations, and handling of persistent memory leaks) differ from the reality of PMDK, leading to the unfeasibility of many original optimizations. Second, we will briefly present our benchmark framework (to be soon open-sourced) with possibly a coding demonstration on how to write a wrapper to adapt an existing data structure to conform to the API required by the framework, thus enabling an easy performance evaluation. Finally, we will present some of our evaluation results comparing the performance of the data structures. These results allowed us to derive valuable insights that can hopefully serve as general guidelines for the design of future PM-based data structures.
[1] Lersch, L., Hao, X., Oukid, I., Wang, T., Willhalm, T., 2019. Evaluating Persistent Memory based Range Indexes. (Under submission)
[2] Chen, S. and Jin, Q., 2015. Persistent B+-Trees in Non-Volatile Main Memory. Proceedings of the VLDB Endowment, 8(7), pp.786-797.
[3] Yang, J., Wei, Q., Chen, C., Wang, C., Yong, K.L. and He, B., 2015. NV-Tree: Reducing Consistency Cost for NVM-based Single Level Systems. In FAST’15
(pp. 167-181).
[4] Oukid, I., Lasperas, J., Nica, A., Willhalm, T. and Lehner, W., 2016, June. FPTree: A Hybrid SCM-DRAM Persistent and Concurrent B-Tree for Storage Class Memory. In SIGMOD’16 (pp. 371-386).
[5] Arulraj, J., Levandoski, J., Minhas, U.F. and Larson, P.A., 2018. BzTree: A High-Performance Latch-free Range Index for Non-Volatile Memory. Proceedings of the VLDB Endowment, 11(5), pp.553-565.
[6] Available at: https://github.com/pmem/pmdk
[7] Available at: https://github.com/opcm/pcm
PMTest: A Fast and Flexible Testing Framework for Persistent Memory Programs
Speaker: Samira Khan, University of Virginia
Slides
Video
Abstract
Recent non-volatile memory technologies such as 3D XPoint and NVDIMMs have enabled persistent memory (PM) systems that can manipulate persistent data directly in memory. This advancement of memory technology has spurred the development of a new set of crash-consistent software (CCS) for PM – applications that can recover persistent data from memory in a consistent state in the event of a crash (e.g., power failure). CCS developed for persistent memory ranges from kernel modules to user-space libraries and custom applications. However, ensuring crash consistency in CCS is difficult and error-prone. Programmers typically employ low-level hardware primitives or transactional libraries to en- force ordering and durability guarantees that are required for ensuring crash consistency. Unfortunately, hardware can reorder instructions at runtime, making it difficult for the programmers to test whether the implementation enforces the correct ordering and durability guarantees.
We believe that there is an urgent need for developing a testing framework that helps programmers identify crash consistency bugs in their CCS. We find that prior testing tools lack generality, i.e., they work only for one specific CCS or memory persistency model and/or introduce significant performance overhead. To overcome these drawbacks, we propose PMTest (https://pmtest.persistentmemory.org), a crash consistency testing framework that is both flexible and fast. PMTest provides flexibility by providing two basic assertion-like software checkers to test two fundamental characteristics of all CCS: the ordering and durability guarantee. These checkers can also serve as the building blocks of other application-specific, high-level checkers. PMTest enables fast testing by deducing the persist order without exhausting all possible orders. In the evaluation with eight programs, PMTest not only identified 45 synthetic crash consistency bugs, but also detected 3 new bugs in a file system (PMFS) and in applications developed using a transactional library (PMDK), while on average being 7.1× faster than the state-of-the-art tool.
5:30 pm – 6:00 pm
Break
6:00 pm – 8:30 pm
Banquet
La Jolla Shores Hotel (map).
The banquet venue is a short walk from Scripps Forum. If you need transport assistance please contact swanson@cs.ucsd.edu.
There will be a beer and wine bar (don’t forget your drink tickets!) starting at 6:00. Dinner at 6:45 or so.
TUESDAY, JULY 23
8:00 am – 9:00 am | Foyer
Breakfast
9:00 am – 10:00 am | Samuel H. Scripps Auditorium
Keynote IV
Successfully Deploying Persistent Memory and Acceleration via Compute Express Link
Successfully Deploying Persistent Memory and Acceleration via Compute Express Link
Speaker: Stephen Bates, Eideticom
Slides
Video
Abstract
Compute Express Link (CXL) is an open standard for coherently attaching devices to Central Processing Units (CPUs). In this talk, we will discuss how CXL will be an innovation driver for the deployment of Persistent Memory and how CXL compares with other methods of coherently connecting Persistent Memory in a system.
Speaker bio
Stephen is an expert in performance storage, persistent and non-volatile memory, computer networking, signal processing and error correction coding and has worked on some of the most complicated communication and storage solutions in the industry.
10:00 am – 10:30 am
Break
10:30 am – 12:00 pm | Samuel H. Scripps Auditorium
Session 3a
Chair: Jishen Zhao
Developing Programmer-Friendly Frameworks for NVM
MOD: Minimally Ordered Durable Data Structures for Persistent Memory
Storing STL Containers on NVM
Developing Programmer-Friendly Frameworks for NVM
Speaker: Thomas Shull, University of Illinois at Urbana-Champaign
Slides
Video
Abstract
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, I believe that most existing models place too many burdens on the programmer. Programmer-intrusive requirements complicate software development and introduce opportunities for correctness and performance bugs.
In my talk, I will highlight my work towards designing a new programmer-friendly Java NVM framework which I have named AutoPersist. Contrary to other frameworks, in AutoPersist the language runtime is tasked with performing much of the heavy lifting involved with creating persistent applications. Specifically, in AutoPersist, the runtime dynamically identifies which objects should reside in NVM, ensures stores to these objects are persistently performed, and provides straightforward failure-atomic support. In addition, by amending the JVM bytecode semantics, while using AutoPersist in many cases it is not necessary to modify pre-existing code at all, enabling Java’s vast built-in libraries to be used in a persistent manner.
In addition to the overview of AutoPersist, in my talk I will also highlight some of the lessons I have learned while designing persistent applications. I first will compare and contrast my experience of designing persistent applications in traditional NVM frameworks and AutoPersist. After that, I will discuss many of the performance pitfalls of designing persistent applications within managed languages. Finally, I will motivate the need for NVM frameworks to be directly integrated into the language virtual machine implementations.
MOD: Minimally Ordered Durable Data Structures for Persistent Memory
Speaker: Swapnil Haria, University of Wisconsin-Madison
Slides
Video
Abstract
In this work, we introduce minimally ordered durable (MOD) datastructures to lower flushing overheads by overlapping long-latency flushes to PM. We define MOD datastructures as those that enable failure-atomic sections (similar to transactions) with only a single ordering point in the common case. We present a simple recipe to create MOD datastructures from existing purely functional datastructures, allowing us to leverage significant research efforts from a different domain as opposed to handcrafting recoverable datastructures. We implement MOD datastructures using nondestructive updates and out-of-place writes to eliminate logging and most ordering points. On an update, a new updated copy (shadow) of the original datastructure is created without overwriting the original data.
We develop a C++ library of MOD datastructures with vector, map, set, stack and queue implementations. Our evaluation on systems with real persistent memory—Intel Optane DC Persistent Memory Modules—shows that MOD datastructures improve application performance by 60% on average compared to state-of-the-art STM systems for PM.
Storing STL Containers on NVM
Speaker: Markus Dreseler, Hasso Plattner Institute, Germany
Slides
Video
Abstract
For in-memory databases with Multi-Version Concurrency Control, many data structures are written only once. Requirements other than persistent and consistent support for updates become more important: (1) Minimizing the code changes for NVM support and instant recovery, (2) Hiding the intricacies of the NVM-aware implementation from non-NVM-aware developers, and (3) Enabling the use of data structures that do not yet have an NVM equivalent.
In our talk, we will show how the write-once property of these data structures enables us to use existing containers from the C++ standard library. For this, we use polymorphic memory resources, fancy pointers, and representation-aware containers. As a result, we can make existing code NVM-aware with only little changes at the point of creation and no changes at the point of access.
We will show code both from the implementation and from the perspective of a user. Additionally, we will present benchmarks performed on Intel Optane PM, showing that the runtime is dominated by the cost of persistent allocations but is still considerably lower than that of a fully NVM-aware implementation, which provides unused consistency guarantees.
10:30 am – 12:00 pm | Edward H. “Ted” Scripps II Room
Session 3b
Chair: Andy Rudoff
Evolution of Persistent Memory Development Kit
Experience on Building a Lock-free B+-tree in Persistent Memory
NVM Direct – A Persistent Memory API
Evolution of Persistent Memory Development Kit
Speaker: Piotr Balcer, Intel
Slides
Video
Abstract
The first commit to the public repository of Persistent Memory Development Kit was made on September 2014. A lot has changed since then. The name, the scope, and most importantly – the code. Its `git log` is a history of mistakes, wrong assumptions and lessons learned.
This talk will discuss that history, describing why and how PMDK evolved over time. The main focus will be on the performance and usability aspects of persistent memory programming.
Experience on Building a Lock-free B+-tree in Persistent Memory
Speaker: Tianzheng Wang, Simon Fraser University
Slides
Video
Abstract
Building lock-free data structures for persistent memory (PM) requires extra efforts in handling crash consistency, race conditions and memory management issues. This requires support from new PM programming libraries. One of them is the persistent multi-word compare-and-swap (PMwCAS): it allows programmers to atomically change multiple 8-byte words in PM with crash consistency guarantees. PMwCAS potentially eases the making of lock-free data structures in PM and frees programmers from handling various race conditions explicitly.
Recently, we implemented the BzTree—a new persistent, lock-free B+-tree based on PMwCAS. We integrated PMwCAS and PMDK to properly handle persistent memory management, and found that despite PMwCAS does ease the handling of race conditions and crash consistency, and with the help of PMDK it also eases the handling of durability, our experience showed a number of new restrictions and pitfalls these PM libraries may impose, that may potentially render the BzTree even harder to implement.
The presentation will start with the background of our work on implementing the BzTree using PMwCAS. Then we will show what the actual code looks like in our implementation and highlight the caveats and pitfalls new PM libraries may impose on the data structure, and summarize the lessons learned and future directions.
NVM Direct – A Persistent Memory API
Speaker: Bill Bridge, Oracle
Slides
Video
Abstract
Oracle has developed an open source C library and a set of C extensions for managing consistent application state in persistent memory. This library and the C extensions implement a multi-threaded application interface (API) that supports arbitrary data structures in persistent memory. It is used in the Oracle RDBMS to manage database data in persistent memory.
12:00 pm – 1:00 pm | Foyer
Lunch
1:00 pm – 2:00 pm | Samuel H. Scripps Auditorium
Keynote V
Exadata with Persistent Memory – An Epic Journey
Exadata with Persistent Memory – An Epic Journey
Speaker: Zuoyu Tao, Oracle
Slides
Video
Abstract
This presentation will introduce background information on Oracle Exadata, a database machine. I will cover how persistent memory is used in Exadata to speed up database IOs. I will describe various technical challenges and common pitfalls encountered, as well as measures in place to handle persistent memory failures.
Speaker bio
Zuoyu Tao is a development manager at Oracle who is currently working on various persistent memory projects for the Exadata database machines, such as using persistent memory as a cache for database workloads, handling persistent memory failures without loss of database availability, and using persistent memory as a staging buffer to speed up database writes.
2:00 pm – 2:30 pm
Break
2:30 pm – 3:30 pm | Samuel H. Scripps Auditorium
Session 4
Chair: Jishen Zhao
Persistent Memory Evaluation and Experiments
Memory vs. Storage: Is There a Difference and Do We Care Anymore?
Persistent Memory Evaluation and Experiments
Speaker: Maya Gokhale, Lawrence Livermore National Laboratory
Slides
Video
Abstract
We will discuss on-going projects to optimize parallel graph algorithms for the AP platform. The existing open source framework has been tuned for SSD. The optimizations will be incorporated into the open source framework as they are developed.
Memory vs. Storage: Is There a Difference and Do We Care Anymore?
Speaker: Jay Lofstead, Sandia National Labs
Slides
Video
Abstract
As new tiers between DRAM and centralized storage are being introduced into our platforms, how to view and use those resources varies depending on who you ask. Using it as slow memory or fast storage each address a different problem area for programming, but introduce new challenges for long term data management, workflows, and data interoperability formerly addressed through storage specific interfaces. Which of these should remain and which are obsolete is not as clearcut as one might like to believe. This talk focuses on the challenges and opportunities for PM from a storage and workflow perspective.