Persistent Buffer Management with Optimistic Consistency

TL;DR

This paper proposes a novel persistent buffer management approach that leverages non-volatile memory as both memory and storage, enabling efficient direct access and recovery in modern database systems.

Contribution

It introduces a persistent buffer pool design that uses NVM as both memory and storage, improving integration, cost, and recovery speed.

Findings

Enables direct CPU access to NVM pages like memory.

Allows recovery of corrupted pages post-failure.

Reduces costs by replacing DRAM with NVM.

Abstract

Finding the best way to leverage non-volatile memory (NVM) on modern database systems is still an open problem. The answer is far from trivial since the clear boundary between memory and storage present in most systems seems to be incompatible with the intrinsic memory-storage duality of NVM. Rather than treating NVM either solely as memory or solely as storage, in this work we propose how NVM can be simultaneously used as both in the context of modern database systems. We design a persistent buffer pool on NVM, enabling pages to be directly read/written by the CPU (like memory) while recovering corrupted pages after a failure (like storage). The main benefits of our approach are an easy integration in the existing database architectures, reduced costs (by replacing DRAM with NVM), and faster peak-performance recovery.

Figures

Full text

††journalyear: 2019††copyright: acmlicensed††conference: International Workshop on Data Management on New Hardware; July 1, 2019; Amsterdam, Netherlands††booktitle: International Workshop on Data Management on New Hardware (DaMoN’19), July 1, 2019, Amsterdam, Netherlands††price: 15.00††doi: 10.1145/3329785.3329931††isbn: 978-1-4503-6801-8/19/07

1. Introduction

NVM is a persistent media promising higher bandwidth (2$\times$) and lower latency (10$\times$) than modern NAND-flash SSDs. Furthermore, NVM can be attached to the memory bus, thus allowing it to be directly accessed by the CPU through its caches in a much smaller granularity (cache-lines) than regular block devices. Therefore, NVM introduces not only a new layer within the storage hierarchy (Bonnet, 2017), but it also enables more flexibility regarding data placement.

While a few factors slower, reading data directly from NVM can be done the same way as with DRAM. However, writing data directly to NVM imposes challenges in terms of data consistency. The root of these challenges is the lack of control the application has over data movement between CPU cache and NVM in comparison to the data movement between DRAM and SSD. In other words, the programmer cannot prevent cache lines from being evicted from the CPU cache and written-back to NVM at arbitrary points in time.

Related work address these challenges with solutions that fall in one of three categories (also identified by previous work (van Renen et al., 2018)). First, early proposals leverage NVM as a cheaper alternative to extend DRAM, enabling larger buffer pools (Wu et al., 2014; Ou et al., 2014). These approaches focus on reducing write amplification and improving wear leveling on NVM, but they do not enforce any consistency when writing data, and therefore do not leverage persistency. Second, persistent data structures (Oukid et al., 2016; Yang et al., 2015; Chen and Jin, 2015; Arulraj et al., 2018; Lee et al., 2017) enable direct fine-grained writes to NVM by issuing out-of-place writes and relying on instruction ordering (SFENCE) and eagerly flushing cache lines (CLFLUSH/CLWB) to make the operation visible (usually by flipping a validity bit). Third, buffer managers were proposed to integrate NVM with the storage hierarchy below DRAM and above SSD (Pelley et al., 2013; van Renen et al., 2018; Eisenman et al., 2018). These approaches access data on DRAM, and therefore they have full control of when data is persisted. Optimizations can be made regarding block sizes, but they still impose movement of data between DRAM and NVM.

The first two categories treat NVM more like traditional memory, while the last one treats NVM more like traditional storage. However, NVM is actually both. We consider that a database system should allow NVM to be read and written directly, thus exploring its memory-storage duality to its full potential. Our system accesses NVM like memory, but it guarantees consistency of writes to NVM like storage. We achieve that by integrating NVM in the buffer pool of a database system to either extend DRAM or completely replace it, while still leveraging its persistency in an optimistic way. In other words, we never enforce ordering of writes or eagerly flush cache lines. The main motivation is that corruption occurs when a write operation is partially evicted from the CPU cache to NVM. With the capacity of NVM being significantly higher than CPU caches, the probability of corruption tends to be low and therefore pessimistically enforcing consistency of every write introduces a relatively high overhead by not leveraging the CPU cache.

Recent work (Arulraj et al., 2019) has gone into the same direction of allowing data to be accessed directly on NVM. This approach complements our approach by focusing on cost models for optimizing data movement, while we focus on enabling direct writes to NVM to be consistent.

2. Background

We give an overview of the techniques that we use to implement a persistent buffer management in a database system.

Buffer Management: We assume a traditional transactional storage manager having a B+Tree as its workhorse data structure. The B+tree is organized such that nodes are represented by pages, which are the unit of data movement and buffering. Optimizations like pointer swizzling (Graefe et al., 2014b) and low-overhead replacement policies (Leis et al., 2018) may apply. The atomicity and durability of writes to pages buffered in DRAM is guaranteed by write-ahead logging (WAL).

Single-page Recovery: Similar to traditional ARIES (Mohan et al., 1992), we assume a page-level physiological logging. This implies that pages are not only a unit of data movement, but also of fault containment and repair (Graefe and Kuno, 2012). This enables techniques such as write-elision, on-demand instant restart and restore, and single-page repair (Graefe et al., 2014a). These techniques are the base to enable direct writes directly made to NVM to be consistent without eagerly flushing cache lines.

3. System Design

The pages of our system are primarily located on SSD and only the warm pages are buffered in NVM. Hot pages might be buffered in a DRAM portion of the buffer pool, as seen in Figure 1.

**Normal Processing: ** During normal transactional processing, a page to be updated will be either on SSD, NVM, or DRAM. In case the page is on SSD, it is loaded to the buffer pool (either to DRAM or NVM, to be decided by a placement policy). In case the page is on DRAM, we have a hit and the page is updated normally. If the page is on NVM, two actions might occur. First, the page might be identified as ”heating up” by a placement policy such as 2Q (Lersch et al., 2017), in which case it will be copied to DRAM and updated there. Second, the page might be simply warm, in which case the update is done directly on NVM. In the last case, since atomicity and durability is guaranteed by WAL, issuing CLFLUSH/CLWB after updating the page is not necessary as the log serves as the single source of truth. However, when restarting after a system failure, pages that were on NVM might be corrupted because updates were not properly persisted. As a consequence, the current state of a page on NVM is unknown and therefore persistency of NVM cannot be leveraged.

We address this challenge by dividing it in two dimensions: corruption detection and page repair. Each page contains an 8 Byte checksum of the whole page. Whenever the content of a page is modified directly on NVM, the page checksum is re-calculated and updated. At this point, the modifications and the checksum of a page might be persistent or not, since we do not explicitly flush them from the CPU cache to NVM. In case the overhead of calculating the checksum for the whole page after every update is too high, it can be reduced either by updating the checksum only after a certain number of updates (at the cost of higher corruption ratio) or by introducing multiple checksums per page corresponding to fractions of the page (at the cost of higher space consumption).

Corruption Detection After a system failure, the restart process starts with log analysis, which identifies the state (not the content) of pages right before the crash. We assume state-of-the-art page-based on-demand restart (Graefe et al., 2014a), therefore a page being requested might still be lingering in the NVM portion of the buffer pool since before the crash. Two steps are required to determine if the page can be used. First, its checksum is calculated and compared to the checksum stored within the page. If the checksums do not match, it is because either the checksum or the updated data were not evicted from the CPU cache to NVM. Second, if the checksums match, the log sequence number of the last update in the page (pageLSN) is compared to the LSN retrieved during log analysis (expectedLSN). To summarize, a page might be in one of the following states:

• •

Corrupted, if checksum does not match

• •

Behind, if checksum matches and $pageLSN<expectedLSN$

• •

Current, if checksum matches and $pageLSN=expectedLSN$

• •

Ahead, if checksum matches and $pageLSN>expectedLSN$

The page is behind, if it was updated by a committed transaction (the log records were flushed) but neither the update nor the checksum were evicted from the CPU cache. In this case, the page is in a consistent but outdated state since it violated the write-ahead rule. However, this violation is tolerated on NVM as long as it is guaranteed not to happen on SSD. Analogously, the page is ahead if both update and checksum were persisted to NVM but the transactions that made these updates did not commit. Finally, if both checksum and LSNs match, the page is in its most current state and ready to be accessed. Except for the current state, all other states must be recovered by replaying log records.

Page Repair No assumption can be made about a corrupted page, and therefore the only alternative is to retrieve its more recent version from SSD (which acts as a backup) and replay the log records referring to this page to bring it up to its most recent state. A behind page is missing committed updates, therefore it can be used as the basis for replaying the log records, not requiring an older version of the page to be fetched from SSD. Ahead pages are consistent but contain updates made by uncommitted transactions. Since ARIES-style recovery only allows logical UNDO on a transaction level, the updates of a single page cannot be independently rolled back. Therefore, the same procedure of a corrupted page applies for rolling forward. Since it is required that an older version of the page is read from the database, it is convenient that frequently modified pages are flushed to the database often to bound the recovery time in such cases. Fortunately, this can be achieved by an asynchronous cleaning job that iterates through the buffer pool and picks dirty pages to be flushed to the database.

4. Conclusion

In this work we propose extending database systems with a persistent buffer pool on NVM. We consider such extension to impose a low implementation effort, since NVM is treated very similarly to DRAM during runtime, while leveraging well-understood recovery algorithms to enforce its consistency. The consequence is that the persistency aspect can be leveraged in an optimistic way, without major changes in the code base to enforce ordering of writes to NVM. Furthermore, cache lines do not have to be eagerly flushed, which enables write operations to be cached in the CPU and amortize the higher latencies of NVM. We also consider that in the short and medium term, NVM will not replace neither DRAM or SSD, but should act in synergy with both. Our design also enables the user to explore different proportions of DRAM and NVM in the buffer pool: more DRAM will lead to higher performance, while more NVM will lead to reduced costs and faster recovery (higher availability). This adds more flexibility for analyzing trade-offs and navigating the performance continuum between modern expensive in-memory databases and more traditional low-cost disk-based systems.