Guaranteeing Recoverability via Partially Constrained Transaction Logs

TL;DR

This paper introduces Poplar, a scalable and parallel transaction logging scheme that relaxes traditional constraints, enabling efficient recovery and improved performance in multi-core in-memory database systems.

Contribution

It proposes a novel recoverable logging scheme, Poplar, that allows parallel log processing and reduces synchronization, improving scalability and recovery efficiency.

Findings

Poplar enables parallel log persistence across multiple storage devices.

It replaces centralized LSN allocation with distributed partial order numbering.

Poplar outperforms existing logging methods on SSDs and non-volatile memory.

Abstract

Transaction logging is an essential constituent to guarantee the atomicity and durability in online transaction processing (OLTP) systems. It always has a considerable impact on performance, especially in an in-memory database system. Conventional implementations of logging rely heavily on a centralized design, which guarantees the correctness of recovery by enforcing a total order of all operations such as log sequence number (LSN) allocation, log persistence, transaction committing and recovering. This strict sequential constraint seriously limits the scalability and parallelism of transaction logging and recovery, especially in the multi-core hardware environment. In this paper, we define recoverability for transaction logging and demonstrate its correctness for crash recovery. Based on recoverability, we propose a recoverable logging scheme named Poplar, which enables scalable and parallel log processing by easing the restrictions. Its main advantages are that (1) Poplar enables the parallel log persistence on multiple storage devices; (2) it replaces the centralized LSN allocation by calculating a partially ordered sequence number in a distributed manner, which allows log records to only track RAW and WAW dependencies among transactions; (3) it only demands transactions with RAW dependencies to be committed in serial order; (4) Poplar can concurrently restore a consistent database state based on the partially constrained logs after a crash. Experimental results show that Poplar scales well with the increase of IO devices and outperforms other logging approaches on both SSDs and emulated non-volatile memory.

Figures

Tables

Table 1. Table 1: A comparison of state-of-the-art transaction logging approaches

	Log type	Log record	Log insert	Log flush	Txn commit	Recovery	Level
ARIES [22]	value	totally-ordered	serial	serial	serial	serial	sequentiality
Aether [14] Eleda [16]	value	totally-ordered	parallel	serial	serial	serial	sequentiality
H-Store [17]	command	totally-ordered	parallel	serial	serial	serial, re-execute	sequentiality
Silo [24]	value	epoch-based totally-ordered	parallel	parallel	epoch-based serial	parallel	epoch-based sequentiality
NV-Log [13]	value	totally-ordered	N/A	parallel	serial	parallel	sequentiality
NVM-D [25]	value	RAW,WAW, WAR	N/A	parallel	RAW,WAW, WAR	parallel	rigorousness
Poplar	value	RAW,WAW	parallel	parallel	RAW	parallel	recoverability

Table 2. Table 2: Recovery performance for YCSB.

	CENTR	SILO	POPLAR
Checkpoint Recovery Time	10.91s	5.34s	5.35s
Log Recovery Time	93.25s	45.73s	45.75s
Total Time	104.16s	51.07s	51.10s

Table 3. Table 3: Recovery performance for TPCC.

	CENTR	SILO	POPLAR
Checkpoint Recovery Time	50.19s	24.25s	24.29s
Log Recovery Time	146.81s	70.93s	71.34s
Total Time	197.00s	95.18s	95.63s

Full text

In this paper, we define recoverability for transaction logging and demonstrate its correctness for crash recovery. Based on recoverability, we propose a recoverable logging scheme named Poplar, which enables scalable and parallel log processing by easing the restrictions. Its main advantages are that (1) Poplar enables the parallel log persistence on multiple storage devices; (2) it replaces the centralized LSN allocation by calculating a partially ordered sequence number in a distributed manner, which allows log records to only track RAW and WAW dependencies among transactions; (3) it only demands transactions with RAW dependencies to be committed in serial order; (4) Poplar can concurrently restore a consistent database state based on the partially constrained logs after a crash. Experimental results show that Poplar scales well with the increase of IO devices and outperforms other logging approaches on both SSDs and emulated non-volatile memory.

1 Introduction

Transaction logging as an established recovery method is widely used in database management systems (DBMSs) to ensure atomicity and durability of transactions. In in-memory DBMSs, it persists information of committed transactions in the form of log records and recovers them in a proper order to restore a consistent database state after a system crash. As the only component that involves persistence and dependency tracking, transaction logging often dominates the system throughput and latency when executing highly concurrent online transaction processing (OLTP) workloads. Most in-memory DBMSs implement a variant of ARIES-Logging [22], which first caches log records in a central, volatile log buffer and then forces them into a single storage device before transactions commit. Each log record is assigned with a unique and monotonically increasing log sequence number (LSN) that determines the order of persisting log records, the order of committing transactions and the order of recovering transactions.

The centralized design of transaction logging becomes the main performance bottleneck in multi-core platforms and new storage devices, such as non-volatile memory (NVM). There are three key obstacles: (1) LSN allocation based on the centralized log buffer is a notorious contention point that seriously hinders scalability; (2) flushing log records into a single storage device limits maximal performance due to the limited IO bandwidth, especially with a slower storage device; (3) there is a sequential constraint in centralized logging that demands LSN allocation, log persistence, transaction committing and recovering follow a same total order, which terribly limits the parallelism of logging and recovery. Prior works [14, 16] have addressed the first bottleneck with notable improvements, but the global contention still exists due to the central log buffer used in those proposed solutions. Other studies [25, 28] use multiple log buffers instead of the central log buffer and allow log records to be concurrently written into multiple storage devices, which eliminates centralized contention and IO bandwidth limitation. But these solutions either allow worker threads to force log records directly to storage devices, or use a coarse-grained commit protocol, which is not suitable for slower storage devices (e.g., SSD, HDD) and extends the commit latency.

So far, all previous researches have not addressed the third issue. Operations such as LSN allocation and transaction committing in their approaches are serial or at least follow all dependencies among transactions. But in fact, the strict sequential constraint for crash recovery is not necessary, especially for transactions without any dependencies. In this paper, we analyze comprehensively which constraints on transaction logging are essential for correctness during recovery, and gives a definition of recoverability for transaction logging. The recoverability requires that the commit order of transactions tracks the read-after-write (RAW) dependencies among transactions and the sequence number of log records complies with the write-after-write (WAW) dependencies among transactions.

Based on the definition of recoverability, we propose a scalable transaction logging, named as Poplar, that can perform both logging and recovery in parallel. The centerpiece of Poplar is to remove the sequential constraint, which allows (1) log records to be written into multiple storage devices in non-serial order; (2) only transactions with RAW dependencies to be committed in serial order; (3) sequence number of log records to track only WAW dependencies among transactions. To track these dependencies without additional overheads, we use a scalable sequence number (SSN) instead of centralized LSN to track the WAW and RAW dependencies. The SSN is calculated in a decentralized manner, which exhibits high scalability. Based on SSN, Poplar can identify directly whether transactions with RAW dependencies can be committed. After a system crash, Poplar can recover persistent log records in SSN order to restore a consistent database state. In addition, combined with optimistic concurrency control, SSN can be used as the commit timestamp of transactions to guarantee serializability, while removing the centralized contention on the timestamp allocation.

We implement Poplar in the open-source database system DBx1000 [2] and compare it with other transaction logging approaches. Experimental results show that both in YCSB and TPC-C benchmarks, Poplar is well scaled with the increase of IO devices and has the highest throughput with excellent commit latency of transactions. Moreover, our logging is generally applicable to all kinds of storage devices, such as SSD and NVM.

In summary, we make the following contributions:

• •

Based on the analysis of syntactical restrictions for correct recovery, we define three constraint levels for transaction logging and elaborate on recoverability in main-memory database systems.

• •

We categorize state-of-the-art transaction logging approaches according to these three levels and summarize the performance bottlenecks of centralized logging and popular parallel logging methods.

• •

We propose a scalable and parallel transaction logging that eliminates the sequential constraint of traditional logging, while guaranteeing that database systems can be recovered to a consistent state after a crash.

• •

Experimental results show that Poplar with only $2$ pieces of SSDs performs up to $2\times$ higher throughput than centralized logging, $\sim 280\times$ higher throughput than NVM-based logging and $\sim 6\times$ shorter commit latency of transactions than Silo.

The rest of this paper is organized as follows: Section 2 reviews the traditional logging and recovery and confirms the performance bottlenecks. Section 3 gives a definition of recoverability and compares our logging with other approaches. Section 4 presents the design of our parallel logging in detail, and the implementation of parallel recovery is shown in Section 5. Section 6 describes the experimental evaluation and Section 7 reviews the related work. Conclusion is shown in Section 8.

2 Background

To successfully survive from a system failure, a recovery manager should make a database behave as if it contains all of the effects of committed transactions (redo recovery) and none of the effects of uncommitted transactions (undo recovery). Typically, database management systems (DBMSs) adopt transaction logs to store redo and undo information of transactions in the non-volatile storage. In an in-memory database system, undo log is not necessary, because the system does not need to flush uncommitted data into the durable storage. Thus, the recovery manager does not need to erase any uncommitted writes. A log file is composed of a sequence of log entries, each one is called a log record that is assigned with a unique and monotonically increasing sequence number. Therefore, the sequence numbers can be used to order two different updates on the same tuple. In a nutshell, upon the system failures, a recovery manager can replay all redo log records in the sequence order to reconstruct the database state from the latest checkpoint.

Essentially, the goal of a recovery manager is to ensure that the recovered state preserves the effects of all committed updates in a serial order of the execution of transactions. It needs to ensure all the committed updates have been persisted before a crash and the sequence order of log records matches the original execution order of transactions. Any violation will definitely risk the correctness of recovery. To comply with these requirements, a variant of ARIES-Logging [22] in an in-memory database system is implemented as follows: (1) it calculates the sequence number (denoted as LSN) of each log record by using a global lock; (2) it caches log records in a centralized log buffer in total sequence order, and then forces them into a permanent storage device in batch [12]; (3) a transaction can be committed until its log records and all the log records preceding the last log entry of the transaction have been persistent. The logging approach has three main bottlenecks:

1. Contention on the centralized buffer. The LSN allocation by a global lock on the centralized log buffer is a dazzling serialization bottleneck. Because transaction processing—which requests the centralized data structure concurrently—is highly parallelized, contentions on the central log buffer waste a lot of CPU cycles and significantly limit the scalability.

2. Bandwidth limitation. All log records are required to be sequentially written to a storage device before their transactions commit. Even the sequential write makes full use of IO properties, the system throughput is bounded by the IO bandwidth of the device, especially when transaction produces large-size log records. Therefore, the database logging with a single IO device may be less performant due to its limited IO bandwidth.

3. Sequential constraint. A strong constraint imposed on the transaction logging is its sequentiality [16], which strictly requires that the order of log records, log flushing and transaction committing must be the same. In other words, all log records are totally-ordered and persisted with the global LSN, and transactions are also committed according to the LSN order. This somehow forces operations such as LSN allocation, log persistence and transaction committing to be serial in the logging process. Furthermore, during crash recovery, restoring database state in total LSN order also limits the level of parallelism of recovery.

Prior works [14, 16] address the contention on centralized log buffer by using a lightweight atomic instruction and copying transaction’s logs to the log buffer in parallel. But other bottlenecks still exist in these approaches due to its centralized design. In addition, H-store [17] uses command logging instead of value logging to reduce pressure on the IO device. While it significantly slows down the recovery processing, as the database system must redo all transactions to restore a consistent state after a crash.

To eliminate all above bottlenecks, a simple intuition is to adopt a parallel logging mechanism that forces log records over multiple stable storage devices. Historically, parallel logging has been prohibitive for a single node system due to the sequential constraint. In fact, a correct recovery manager does not need to guarantee the strong sequentiality, especially for transactions without any dependencies. In the next section, we mainly discuss the necessary restrictions on parallel logging for a recoverable database system. In this paper, we focus on the recoverability of in-memory database systems that use value logging. Without loss of generality, we assume that each transaction only produces a single log record containing all writes of the transaction.

3 Recoverability

3.1 Constraint Levels for Logging

To correctly recover from a system crash, a recovery manager of in-memory DBMSs should (1) identify which transactions have been committed before the crash, and (2) recover log records of committed transactions in a proper order to a most recent and consistent database state. The first point indicates that a transaction is considered to be committed only if its log record has been durable and transactions it depends on are committed. In other words, a transaction commits only after those transactions it depends on. For the second point, the relative order among log records of conflicting transactions must comply with their execution order. It indicates additional dependency tracking in the logging process. Based on different syntactical restrictions on the order of committing transactions and log records, we define three levels of constraints for the crash recovery manager. For ease of explanation, we use $C_{i}$ to present the commit operation of the transaction $T_{i}$ and use $L_{i}$ to denote the sequence number of this transaction’s log record. Let $C_{i}\prec C_{j}$ present that $C_{i}$ happens before $C_{j}$ in the sequence of commit operations. Next, we describe these three levels as follows.

Level** 1****.**

*(Recoverability). The manager is recoverable, for any two transactions $T_{i}$, $T_{j}$ ($i\neq j$): if $\textit{T}_{j}$ writes on a tuple $x$ and $\textit{T}_{i}$ reads $T_{j}$’s update on the tuple $x$, then $\textit{C}_{j}\prec\textit{C}_{i}$; and if $\textit{T}_{i}$ overwrites $\textit{T}_{j}$’s update, then $\textit{L}_{j}<\textit{L}_{i}$. *

Level** 2****.**

(Rigorousness). The manager is rigorous, for any two transactions $\textit{T}_{i}$, $\textit{T}_{j}$ ($i\neq j$), there are conflicts between them: if $\textit{T}_{i}$ depends on $\textit{T}_{j}$, then $\textit{C}_{j}\prec\textit{C}_{i}$ and $\textit{L}_{j}<\textit{L}_{i}$.

Level** 3****.**

(Sequentiality). The manager is sequential if it is rigorous and additionally satisfies the following condition: for any two transactions $\textit{T}_{i}$, $\textit{T}_{j}$ without any conflict ($i\neq j$): $\textit{C}_{j}\prec\textit{C}_{i}$ and $\textit{L}_{j}<\textit{L}_{i}$, or $\textit{C}_{i}\prec\textit{C}_{j}$ and $\textit{L}_{i}<\textit{L}_{j}$.

In summary, recoverability requires the commit order of transactions to track read-after-write (RAW) dependencies among transactions, and the sequence number of log records to track write-after-write (WAW) dependencies. Rigorousness demands that both the commit order and sequence number should guarantee RAW, WAW and write-after-read (WAR) dependencies among transactions. And sequentiality claims that the commit order of all transactions and sequence number of all log records must be in total order. Although the implementation of recovery manager is simplified by forcing more restrictions on the order of committing transactions and log records, these restrictions limit the potential capability of parallelism in logging process.

Note that it is worthwhile to discuss the order of committing transactions in logging process. In-memory DBMSs that use early lock release (ELR) allow a pre-committed transaction111A pre-committed transaction can not be committed only if a crash happens, never because of transaction failure. [8] releases its locks before it commits. This way leads to a result that other transactions observe the pre-committed transaction’s dirty tuples. To avoid an inconsistent database state after a crash, the recovery manager must ensure that a pre-committed transaction commits before transactions depend on it.

3.2 Illustrative Examples

In this section, we demonstrate how recoverability guarantees the correctness of databases.

Figure 1 shows possible execution scenarios of four transaction in logging process. The dependencies between different transactions are shown as arrows. In the figure, all transactions are pre-committed transactions that write their log records in log buffers but none is persistent. A correct symbol indicates that under the scenario, database system can be reconstructed to a consistent state in the presence of a crash, and the meaning of an error symbol is the opposite.

For $\textit{T}_{1}$ and $\textit{T}_{2}$ with RAW dependency, if we ignore the constraint on the commit order of transactions, $\textit{T}_{2}$ can be committed before $\textit{T}_{1}$, as shown in scenario(c). Then if the system crashes at the same time, only $\textit{T}_{2}$ will be recovered but $\textit{T}_{1}$ will not due to $\textit{T}_{1}$’s log record is not durable. This leads to an incorrect state as $\textit{T}_{2}$ observes a value of tuple $x$ that does not exist in the reconstructed database system. But if only the sequence number of their log records does not track the RAW dependency, the recovered state is alway consistent. As shown in scenario(b), $\textit{T}_{1}$ commits before $\textit{T}_{2}$ and $\textit{T}_{1}$’s sequence number is larger than that of $\textit{T}_{2}$. If a crash happens after $\textit{T}_{1}$ commits but $\textit{T}_{2}$ is not persistent, it does not result in an inconsistent state. And if a crash happens after two transactions are committed, $\textit{T}_{2}$ might be recovered before $\textit{T}_{1}$ due to its smaller sequence number. The restored state is still consistent because a read-only operation does not have any side-effect on tuples during recovery. Therefore, for $\textit{T}_{1}$ and $\textit{T}_{2}$, only $\textit{C}_{1}\prec\textit{C}_{2}$ must be guarantee.

For $\textit{T}_{2}$ and $\textit{T}_{3}$ with WAW dependency, $\textit{T}_{2}$ and $\textit{T}_{3}$ can be committed after their own log record has been persistent, but sequence number of their log records must follow the WAW dependency. That is to say, when $\textit{T}_{3}$ overwrites $\textit{T}_{2}$’s update, only $\textit{L}_{2}<\textit{L}_{3}$ must be ensured. If a crash happens between commit operations of two transactions in scenario(d),(e) and (f), only the committed transaction ($\textit{T}_{2}$ or $\textit{T}_{3}$) will be recovered but the other is not. The reconstructed state is consistent as if the uncommitted transaction has never existed. But, if the system crashes after all transactions have been committed, $\textit{T}_{2}$ and $\textit{T}_{3}$ are recovered in the sequence number order of their log records. In scenario(e), $\textit{T}_{2}$ will be recovered after $\textit{T}_{3}$, which leads to an inconsistent state since $\textit{T}_{2}$ overwrites the value of tuple $y$ previously written by $\textit{T}_{3}$ so that $\textit{T}_{3}$’s update is lost. If their log records tracks the WAW dependency as scenario(d) and (f), the recovery manager can avoid the inconsistence..

Unlike RAW and WAW dependency, the order of committing transactions and log records do not need to track the WAR dependency. For $\textit{T}_{2}$ and $\textit{T}_{4}$, $\textit{T}_{4}$ can be committed before $\textit{T}_{2}$ and its sequence number can be smaller than that of $\textit{T}_{2}$. As shown in scenario(h), if the system crashes after $\textit{T}_{4}$ is committed but $\textit{T}_{2}$ is not, only $\textit{T}_{4}$ will be recovered during recovery. The database system can be reconstructed to a consistent state as if $\textit{T}_{2}$ has never existed. And if the crash happens after two transactions have been committed, $\textit{T}_{2}$ might be recovered after $\textit{T}_{4}$ due to sequence number order of their log records. The recovered database state is still consistent as a read does not have side-effects in tuples and does not affect the following write on the same tuples.

Overall, in order to recover to a consistent database state after a crash, the crash recovery manager only needs to ensure that the commit order of transactions tracks the RAW dependencies among transactions and the sequence number of log records tracks the WAW dependencies among transactions. Therefore, the recoverability level is able to guarantee system correctness after a crash.

3.3 Comparison of Existing Approaches

Recoverability breaks thoroughly the sequential constraint of centralized logging, which makes it possible to implement parallel logging in a single node system. Based on the recoverability level, we propose a scalable and parallel transaction logging (named as Poplar). So far, there are some other parallel logging approaches [24, 28, 25, 13] based on different recovery levels. Table 1 provides a summary comparing our method with various logging approaches.

Silo [24, 28] proposes a parallel transaction logging that belongs to sequentiality as defined in Section 3.1. It uses multiple log buffers to cache transactions’ log records, and enables them to be concurrently written into multiple storage devices. To avoid all centralized contentions of in-memory databases, Silo utilizes coarse-grained epochs instead of centralized LSN to track sequentiality among transactions, which exhibits excellent performance and high scalability. However, Silo only ensures transactions across epoch boundaries are in a serial order, while transactions in a same epoch can be out of order. To guarantee the correct recovery, it adopts an epoch-based group commit that persists and commits transactions in epoch units. Unfortunately, this way significantly increases the commit latency of transactions.

Wang et al. [25] present a distributed logging based on the non-volatile memory (NVM), which is called NVM-D in our paper. It establishes multiple log buffers on NVM and allows each worker thread to persist transactions’ log records directly with the mfence instruction. To ensure correctness, NVM-D uses a global sequence number (GSN) to track all dependencies between transactions. Both the sequence number order of log records and commit order of transactions are in the GSN order, which provides a rigorous recovery manager. The GSN of a transaction is calculated in a distributed manner based on tuples accessed by the transaction and a log buffer stores the transaction’s log record. NVM-D provides near-linear scalability in the NVM, but it is not suitable for slower storage devices because frequent mfence will seriously hurt performance.

NV-Logging [13] is a decentralized logging, which allocates each worker thread a private log buffer on NVM. Although it allows worker threads to concurrently persist log records, NV-Logging also use a total LSN to track the order of log records and the commit order of transactions. After a system crash, log records are recovered in total LSN order to restore a consistent database state. Hence, it is also a sequential recovery manager.

Design principle. To address bottleneck issues of centralized transaction logging, we need to design a scalable and parallel transaction logging, which belongs to the recoverability level. In this paper, the new logging approach is referred to as Poplar, whose design principles are as follows. It uses multiple log buffers to first cache log records in memory and then forces concurrently them to multiple storage devices in batch. For the correctness of recovery, Poplar uses a scalable sequence number (SSN) to track the WAW dependencies among transactions and allows the commit order of transactions to follow only RAW dependencies among transactions. To avoid additional overhead of transaction committing, SSN also tracks RAW dependencies. To further address the issue of centralization bottleneck, the SSN is calculated in a decentralized manner, which makes Poplar highly scalable.

Comparison. Compared with Silo, Poplar uses fine-grained SSN to track indispensable dependencies among transactions, which achieves excellent scalability, while significantly shortening the commit latency of transactions. Compared with NVM-D and NV-Logging, Poplar uses full-time logger threads responsible for persisting log records. Due to effective batching mechanism (e.g. group commit [12]), this can avoid flushing frequently, which significantly impacts performance when the database system is deployed on a server with slower IO devices. And this way also exhibits good performance for database systems deployed on NVM-based machines. Moreover, compared with GSN of NVM-D, SSN does not track the WAR dependencies among transactions. In other words, a transaction does not need to modify the special field (i.e., SSN) of each tuple read by the transaction itself. Consequently, Poplar exhibits higher performance in hybrid workloads.

4 Logging for Recoverability

In this section, we describe detailed designs of our logging approach named Poplar. We first provide an overview and then present how we address technical challenges to achieve scalable and parallel logging with guaranteed atomicity and durability of transactions.

4.1 Overview

The architecture of our logging Poplar is illustrated in Figure 2. Multiple log buffers are utilized to cache transaction updates in the form of log records. It includes two types of threads: worker threads and logger threads. There is a one-to-one mapping between logger threads and log buffers and a many-to-one mapping between worker threads and log buffers. Each worker thread produces its log records and copies them into its mapped log buffer. In Figure 2 there are two log buffers LA and LB, two logger threads and four worker threads. Worker thread $1$, $3$ are mapped to LA and worker thread $2$, $4$ are mapped to LB. Each worker thread has two private commit queues (Qww and Qwr), the Qww is used to commit transactions only contain WAW dependencies and the Qwr is used for transactions with potential RAW dependencies. The whole process of logging is based on a three-staged logging pipeline: a prepare stage, a persistence stage and a commit stage.

In the prepare stage, each worker thread independently generates a log record for its own transaction and writes it into its mapped log buffer. Before copying the log record, each worker thread allocates a scalable sequence number (SSN) to the transaction and log record. The SSN provides a partial order, which tracks the RAW and WAW dependencies among transactions. When log record has been filled, the transaction is pushed to a commit queue and waits to be committed. If it is a read-only or read-write transaction, the worker thread push it into Qwr. If the transaction only contains write operations, it is pushed into Qww. As shown in Figure 2, since all transactions’ log records have been cached in their log buffers, $\textit{T}_{1}$ with SSN $=6$, $\textit{T}_{2}$ with SSN $=7$ and $\textit{T}_{4}$ with SSN $=8$ are pushed into their own Qww, and $\textit{T}_{3}$ with SSN $=8$ is pushed into its Qwr. In this stage, all steps are completely lock-free and can be done concurrently.

In the persistence stage, each logger thread independently flushes buffered log records into a bound storage device and advances its own durable SSN (denoted by DSN). That is to say, each logger thread or log buffer owns a DSN, and a DSN is the most recently flushed SSN, which is a durability indicator of log records for that log buffer. As illustrated in Figure 2, log buffer LA’s DSN is $6$ and log buffer LB’s DSN is $8$. Due to concurrent SSN allocation and memory copying in the prepare stage, it inevitably creates buffer slots which have been occupied by transactions but not yet completely filled in each log buffer. If log records with buffer slots become persistent, the database system cannot be restored to a correct state. To prevent the fatal error, each logger thread tracks buffer slots and advances its DSN by only forcing sequentially buffered log records to storage devices with a segment-based approach.

In the commit stage, Poplar needs to determine which transactions can be committed. According to recoverability defined in Section 3.1, a transaction can be committed if ($1$) its log record has been persistent; ($2$) the log records of its RAW predecessors have been persistent. Transactions with RAW dependencies are committable only if they satisfy the condition ($1$) and condition ($2$) at the same time; other transactions can be committed when they meet the condition ($1$). Checking the first condition is straightforward by simply comparing the assigned SSN of the transaction with the DSN of the corresponding log buffer. However, checking the second condition is nontrivial. That is because log records from transactions with RAW dependencies may be distributed in different log buffers. Hence, we calculate a global committable SSN (denoted as CSN). The CSN is the committability indicator for transactions with RAW dependencies. When entering commit stage, each worker thread first checks its Qww and commits transactions whose SSNs are smaller than DSN of their mapped log buffer, then checks the Qwr and commits transactions whose SSNs $\leq$ CSN. As shown in Figure 2, the CSN is equal to $6$. $\textit{T}_{3}$ in Qwr can not be committed because its SSN $=8$ is larger than CSN. But $\textit{T}_{1}$, $\textit{T}_{2}$ and $\textit{T}_{4}$ in Qww can be committed as their log records have been persistent.

4.2 Scalable Sequence Number

We only need to focus on the WAW and RAW dependencies among transactions according to the definition of recoverability. For WAW dependency, if a transaction $T_{j}$ is WAW dependent on $T_{i}$, then the assigned log sequence number of $T_{i}$ should be less than that of $T_{j}$. To ensure this, we develop a scalable sequence number (SSN) in Poplar. Note that SSN tracks both the WAW and RAW dependencies among transactions. RAW dependency is necessary. Maintaining this dependency in SSN don’t introduce additional overhead. Different from previous approaches, we do not calculate the sequence number using a centralized allocator [14, 15, 16, 24, 9]. Instead, a transaction’s SSN is allocated in a distributed manner based on its accessing tuples and the log buffer caching its log record. The distributed nature avoids the serialization bottleneck, making the algorithm highly scalable.

Calculating SSN. Our logging approach keeps SSNs co-located with each log buffer and tuple. Each log buffer maintains the SSN of the log record that has been most recently cached in it and each tuple contains the SSN of the transaction that has most recently modified it. Algorithm 1 shows the procedure how to calculate SSN for a transaction. Once a transaction T is ready to write its log record, it first computes its SSN as the smallest number that is ($i$) larger than the SSN of any tuple read or written by the transaction (line 1-4) and ($ii$) larger than the SSN of the log buffer serving the transaction (line 6-12). Next it advances the SSN of the log buffer to the transaction’s SSN. Then the SSN is written into each tuple updated by the transaction (line 13-15). In addition to the SSN, we also calculate an offset for each log record, which points the space of log buffer the log record will be cached. To address the contention on a log buffer, we use a compare-and-swap instruction to assign the SSN.

In particular, Figure 3 illustrates the procedure of four transactions to calculate their SSNs. As $\textit{T}_{1}$ updates tuple $a$ and its log record will be cached in log buffer LA, it gets the SSN of tuple $a$ ($a.ssn=2$) and the SSN of log buffer LA ($LA.ssn=5$), and calculates its SSN as $max(a.ssn,LA.ssn)+1=6$. Then the result is used to update the SSN of log buffer LA and is stored in tuple $a$. For the $\textit{T}_{2}$ that overwrites $\textit{T}_{1}$’s update in terms of tuple $a$, its SSN must track the WAW dependency between $\textit{T}_{1}$ and $\textit{T}_{2}$. When calculating the SSN, $\textit{T}_{2}$ acquires the largest SSN among tuple $a$, $b$ and log buffer LB, and then increments the value by one. As a result, the SSN of $\textit{T}_{2}$ is $7$ that is larger than that of $\textit{T}_{1}$. In the same way, $\textit{T}_{3}$ computes its SSN as $8$, which ensures the RAW dependency between $\textit{T}_{2}$ and $\textit{T}_{3}$. Since SSN does not track the WAR dependency between transactions, $\textit{T}_{3}$’s SSN is not written into tuple $a$ that is only read by $\textit{T}_{3}$. Therefore, SSN of $\textit{T}_{4}$ is $8$, which equals to that of its WAR predecessor $\textit{T}_{3}$.

4.3 Commit Protocol

Poplar proposes a fast commit protocol, which does not require sequential transaction committing. In the commit state, transactions in queue Qww can be safely committed by comparing their SSNs with corresponding DSNs, while transactions in queue Qwr are committed by tracking CSN. DSNs and CSN can be computed based on SSNs. Next, we describe how to advance the DSN of each log buffer and compute the CSN in detail.

Advancing DSN. To address the challenge caused by concurrent SSN allocating and log records copying, we use a segment-based approach to track buffer holes in each log buffer and advance the DSNs. The segment-based approach logically divide each log buffer into segments by different size, and each segment is treated as a tracking or flushing unit. Only when all the log records in a segment have been sequentially buffered, the bound logger thread can force them into its stable storage device and advance the DSN to the largest SSN of these log records.

We maintain a table called a segment index (or S in short) for each log buffer, as shown in Figure 4. Each entry of S is a segment. Each segment is a quintuple of $<$ssn,allocated_bytes, buffered_bytes, start_offset, stat $>$, where the ssn is the largest SSN of log records in a segment, the allocated_bytes and buffered_bytes denote the cumulative byte count of allocated and buffered log records, the start_offset points the starting offset of a segment in its log buffer and the stat indicates the segment’s status ($\textit{stat}=closed$ means that a segment has been established). Each segment is generated in two different ways based on the gap between procedures (e.g. worker threads) and the consumer (e.g. logger thread): (1) a segment is established by a worker thread if it finds the cumulative byte count of allocated log records is larger than I/O unit size; (2) a segment is established by a logger thread when the time waiting for flushing exceeds the flush time of the group commit strategy [12]. We call the worker thread or logger thread generates segments a segment thread. In Figure 4, $\textit{S}_{3}$ is the segment being generated, $\textit{S}_{1}$ and $\textit{S}_{2}$ are the segments have been established. In the generated segments, only $\textit{S}_{1}$ can be persisted but $\textit{S}_{2}$ can not.

As shown in Algorithm 2, once the generating condition of segments is triggered, the segment thread establishes a segment by updating the ssn and stat of the currently generating segment (pointed by a cur_generate_seg), then atomically increments the cur_generate_seg (line 2-7). Each logger thread periodically checks the state of segment that is about to be flushed (pointed by a cur_flush_seg). Only when the stat of the segment is closed and the allocated_bytes is equal to the buffered_bytes, the bound logger thread persists its log records and advances the DSN to the ssn of the segment (line 10-13). Then it resets the segment to the initial state and atomically increments the cur_flush_seg (line 15-16).

Computing CSN. The CSN keeps track of the smallest value of DSNs. Each logger thread reads the DSNs of log buffers and advances the CSN to the smallest DSN, as described in line $19-21$ of Algorithm 2. Transactions with RAW dependencies can be committed if their SSNs are less than CSN. Consider a transaction $\textit{T}_{j}$ is RAW dependent on $\textit{T}_{i}$, $\textit{T}_{j}$ can not be committed before $\textit{T}_{i}$. Based on the calculation of their SSNs, we always have $\textit{SSN}_{i}<\textit{SSN}_{j}$. Comparing their SSNs and CSN, we can ensure they are committed in a correct order: (1) if $\textit{SSN}_{i}<\textit{SSN}_{j}\leq\textit{CSN}$, where both the log records of $T_{i}$ and $T_{j}$ have been persistent, then $T_{i}$ and $T_{j}$ are committable; (2) if $\textit{SSN}_{i}\leq\textit{CSN}<\textit{SSN}_{j}$, then only $\textit{T}_{i}$ is allowed to be committed; (3) if $\textit{CSN}<\textit{SSN}_{i}<\textit{SSN}_{j}$, where log record of $T_{i}$ is not persistent, so none of $\textit{T}_{i}$ and $\textit{T}_{j}$ can be committed.

4.4 Integrating with OCC

Poplar can be smoothly embedded into in-memory database systems with any concurrency control mechanism. It is particularly suitable for OCC. To ensure correctness in the presence of failure, a schedule should be serializable and strict [6]. Strictness reinforces a serializable schedule with additional constraints on the commit order of all transactions, which requires that the transaction committing tracks RAW and WAW dependencies among transactions. Therefore, we can directly use SSN instead of traditional algorithm’s commit timestamp to guarantee the serializability and strictness. In Poplar, we implement a variant of optimistic concurrency control. We describe how to run transactions with SSN as follows. Under OCC, Poplar executes a transaction in three phases:

During the read phase, transactions can access database without acquiring any lock. And each transaction maintains a private read set and write set. Accessed tuples with their SSN are copied to the read set and modifies tuples with their new state are written into the write set.

During the validation phase, Poplar checks whether a transaction can be committed based on the SSNs stored in the transaction’s read and write set, then computes a new SSN as the commit timestamp of the transaction. At first, a worker thread, on behalf of a transaction, locks all the tuples in write set in their primary key order. Using the fixed locking order avoids deadlocks with other committing transactions at the same time. This tips is also used in other OCC algorithms [24, 26]. After all write locks are acquired, the worker thread begins to examine all the tuples in the read set. If (1) tuples in the read set are not locked by other transactions, and (2) the SSN of each tuple is not changed, the transaction is allowed to be committed. Otherwise, the worker thread releases all locks on the modified tuples and aborts the transaction. Once validation is successful, the transaction calculates a new SSN based on the allocation approach introduced earlier and enters the logging phase.

During the write phase, modified tuples with the new SSN computed in the validation phase are written to the database. After commit, all write locks are released, making the changes visible to other transactions. Combined with early lock release, a transaction enters the write phase once it acquires the new SSN. Although incoming transactions can read the uncommitted transaction’s dirty data, Poplar guarantees a consistent state as the transaction is actually committed before its RAW successors.

5 Recovery

In this section, we present the recovery algorithm based on our parallel logging. We rely on both checkpoints and log files to restore the database system into a consistent state.

Checkpoints. To accelerate recovery from a crash, in-memory database systems mandate periodic checkpoints of their state during logging process. The main challenge in checkpoint production is to produce checkpoints as quickly as possible without deteriorating logging throughput. As with parallel logging approach, Poplar uses multiple checkpoint threads to produce checkpoints and write concurrently them into multiple storage devices. There is a one-to-one mapping between checkpoint threads and storage devices. In our implementation, all tuples are evenly divided into multiple partitions and each partition is processed by a checkpoint thread. When starting checkpointing, a checkpoint deamon starts up $n$ checkpoint threads. Each checkpoint thread walks over its assigned partition in key order and writes them into $m$ checkpoint files, wherer $m\times n$ is the total number of checkpoint files for recovery, which can be configured as the the number of CPU cores. At the same time,the checkpoint deamon records current CSN as RSN, where RSN indicates the start time of the checkpointing, and writes it into a metadata files after the checkpointing has been completed.

In Poplar, we allow concurrent transactions to continue their execution during a checkpoint period. Transactions do not coordinate with checkpoint threads except per-tuple locks so that checkpoint threads might observe an inconsistent snapshot. This is usually called fuzzing checkpointing [20]. To recover a consistent database state, it is necessary both to restore the checkpoints and to replay log records whose SSN is larger than the RSN stored in the checkpoint metadata. Furthermore, if an in-memory database system adopts the early lock release method, each transaction can release locks before committing. Hence checkpoint threads can read the uncommitted transactions’ dirty data, which results in incorrect checkpoints. To avoid this problem, each checkpoint thread computes the largest SSN of tuples it observed during performing checkpointing. And the checkpointing is considered successful only if the latest CSN is larger than the calculated results of all checkpoint threads.

Failure recovery. There are two main stages to restore the database state after a crash:

In checkpoints recovery stage, a recovery deamon gets the RSN from the newest checkpoint metadata (named as RSNs), where the RSNs denotes the starting point for log recovery. Then the recovery deamon starts up $m\times n$ recovery threads to recover all checkpoints in parallel.

In log recovery stage, recovery threads can concurrently replay the persistent log records by applying the last-writer-wins rule [23]. As a durable log record may come from an uncommitted transaction, it is necessary to determine which persistent log records can be recovered. At the beginning of log recovery stage, the recovery deamon checks the most recently durable log record on each storage device and calculates the smallest SSN as RSNe, where RSNe is the ending point for log recovery. Transactions whose SSN $\leq$ RSNe can be guaranteed to be committed. As a result, log records contains SSNs are in $($RSNs, RSNe $]$ can be safely recovered. In addition, transactions only contain WAW dependencies are committed when their log records have been durable. For log records of those transactions, they can be replayed as long as they are persistent, regardless of whether their SSNs are larger than the RSNe. To reduce the overhead of computing RSNe, we shorten moderately the size of each log files. The recovery deamon calculates the RSNe based on the latest log files, while recovery threads can concurrently replay log records from other log files.

6 Evaluation

In this section, we present the experimental results of Poplar, which is implemented on the open-source codebase DBx1000 [2]. DBx1000 is an in-memory DBMS prototype that stores all database in main memory and provides different concurrency control protocols. We implement Poplar with the optimistic concurrency control of Silo and compare it with traditional approaches, and confirm the following:

• •

With the decentralized SSN management policy, Poplar maintains the highest throughput compared with other transaction logging approaches.

• •

The commit protocol requires only transactions with RAW dependencies to be committed in serial order gives super commit latency of transactions.

• •

Poplar breaks thoroughly the sequential constraints of traditional logging, making logging and recovery highly scalable.

6.1 Experimental Setup

Hardware. All experiments are executed on a server with 256GB DRAM and two Intel Xeon E5-2630 v4 processors clocked at 2.20GHz (20 physical cores in total). To reduce irrelevant lock contention, we run all experiments with hyperthreading being disabled. The server contains four pieces of PCIe SSDs of $1.6$ TB, each of which provides the peak sequential write throughput of $1.2$ GB/s with $21.5us$ delay for the sequential writes of $16$ KB block.

NVRAM emulation. The non-volatile memory module available on the market is designed to be integrated into NVDIMM enabled servers via DDR4 DIMM sockets [1, 4]. The NVDIMM provides a nearly latency of DRAM at runtime. So we use DRAM in our experiments to emulate the performance of NVM. We first estimate the data persistence costs of NVM based on Intel Labs’ persistent memory evaluation platform (PMEP) [27] that configured with CFLUSH instruction, then configure the NVM latency to be 2$\times$ that of DRAM. The extra latency is added through a loop that busy-waits for a specified number of CPU cycles.

Variants. We compare the performance of Poplar with other approaches in end-to-end experiments:

1. CENTR. The traditional logging uses a central log buffer and a single IO device to store transactions’ log records. Each transaction acquires its LSN using a fetch-add atomic instruction and is committed in the total LSN order.

2. NVM-D. The distributed logging [25] is based on emulated non-volatile memory (NVM), where worker threads directly force their log records to NVM. Each transaction calculates its GSN in a decentralized manner and is committed rigorously in the GSN order. The GSN tracks all dependencies among transactions.

3. SILO. The logging approach uses multiple log buffers bound with multiple IO devices to cache log records. All transactions are committed sequentially in the periodically-updated epoch order (epoch increments every $50$ ms).

4. POPLAR. Our logging uses SSN to track WAW and RAW dependencies among transactions, and only transactions with RAW dependencies are committed in serial order.

All variants are implemented in the open sourced database DBx1000 with the optimistic concurrency control of Silo for a fair comparison. By default, we run each variant with 2 SSDs, except for CENTR. The number of SSDs is equal to the number of log buffers and logger threads. We use group commit for each logger thread which maintains a log buffer ($30$ MB) to cache log records. Log records are flushed every $5$ ms or if the buffer is half full, whichever happens first. For NVM-D, each worker thread maps to exactly one SSD and flushes log records into its own log files. For experiments with emulated NVM, we set the log buffer size to $1$ MB and flush the log every $5$ ms or the buffer is $1/10$ full.

6.2 Workloads

We use two benchmarks YCSB and TPC-C in our experiments to evaluate all variants.

YCSB. The Yahoo! Cloud Serving Benchmark (YCSB) is representative of large-scale on-line services [7]. It has a single table with a primary key and 10 additional columns with 100 bytes. The dataset in the table is initialized to 10 million records. In our experiments, we mainly adopt two different kinds of workloads:

1. Write-only workload. In this setting, there are only write transactions, each one updates all columns of one tuple accessed by the key value.

2. Hybrid workload. In this workload, each transaction consists of a write operation updating one column of a tuple, and a key-range scan operation with a fixed scan length. By default, the key accessed by each transaction follows uniformly random distribution. This way can eliminate the effect of other contention (e.g., concurrency control) and focus on the evaluation of the logging approach. For each transaction, we run $10$M transactions five times and the results are averaged over the five runnings.

TPC-C. This is a current industry-standard for OLTP applications that simulates a warehouse-centric order processing system [5]. It contains nine tables and five transactions that consist of three read-write transactions and two read-only transactions. We only model two transactions ( 50 % Payment and 50 % NewOrder) in our experiments. For each experiment, we populate the database with 20 warehouse and run $10$M transactions five times.

6.3 Logging Performance

In this section, we focus on evaluating the logging performance of all the variants. We first measure the throughput, commit latency, I/O bandwidth, runtime breakdown and scalability under YCSB with write-only workload and TPC-C. Then we further analyze the impact of commit protocol of all logging approaches under YCSB with hybrid workload.

Throughput. Figure 5 shows the throughput results. In this experiment, we use two pieces of SSDs to store log records and vary the number of worker threads to observe the peak throughput of each approach. For the YCSB workload, as the number of worker threads increases, the throughput of each method rises steadily at first, but eventually reaches a saturation value. This is because the IO bandwidth of SSDs becomes the primary bottleneck when the volume of transactions grows. Using a single SSD as the permanent storage, CENTR shows the lowest throughput due to its limited IO bandwidth. Owing to the decentralized SSN allocation and multiple SSDs, POPLAR exhibits the same excellent throughput as SILO, which improves near $2\times$ better performance than CENTR. For NVM-D, although the value of throughput increases with the number of worker threads, it can not rival the performance of other approaches at the same number of worker threads, where there is a wide performance gap ($\sim 280\times$) between POPLAR and NVM-D. The worse throughput is caused by the fact that worker threads of NVM-D write log records directly into stable storages, which produces additional scheduling and is not suitable for SSDs and HDDs. For the TPC-C workload, the throughput of all variants grows almost linearly at first due to the scalable design for LSN, GSN and SSN, and eventually reaches a steady state because of the limited I/O bandwidth. Similar to the YCSB workload, POPLAR and SILO show the highest throughput, which delivers $2\times$ better performance than CENTR and yields a $\sim 131\times$ gain over NVM-D.

I/O bandwidth. Next, we employ nmon to monitor the I/O bandwidth of each SSD used in all logging approaches. Figure 6 shows that for both YCSB and TPC-C, as the number of worker threads increases, the used I/O bandwidth of each method gradually grows and finally saturates the peak value of each SSDs. This demonstrates that limited I/O bandwidth is the primary bottleneck of logging. Therefore, POPLAR and SILO have better throughput than CENTR by leveraging two SSDs as shown in Figure 5 and their peak throughput can further increase given more I/O devices.

Commit latency. Figure 7 shows the commit latency of transactions in all logging approaches. We measure the commit latency by varying the number of worker threads. In all workloads, SILO has the longest latency ($\sim$ $6\times$) than that of other approaches all the time. Such poor performance of SILO is primarily owing to the epoch-based commit protocol demands a transaction can not be committed until log records of all transaction within the same epoch have been persisted. For POPLAR and CENTR, they have short latency at low worker thread count, which stays around $5$ ms that is the group commit time interval. As the number of worker threads increases, the commit latency continues to increase due to the growth of flushing time. When the thread count is $20$, where POPLAR and CENTR both saturate the I/O bandwidth, they have longer latency because a large number of transactions are waiting for flush and worker threads are blocked due the insufficient buffer space. Overall, POPLAR outperforms CENTR and the commit latency improvement that POPLAR contributes at low worker thread count is more than $2.5\times$. For NVM-D, the commit latency gradually increases in the graph. This is because more and more worker threads write log records to the same SSD.

Runtime breakdown. To investigate the effectiveness of SSN allocation, we collect the execution time of $20$ worker threads and turn them into time breakdown to identify the CPU cycles consumed by Log contention, Log work and Other. Log contention indicates sequence number (LSN, GSN and SSN) allocation, Log work includes log records inserting and waiting log buffer available, Other expresses the actual transaction logic and concurrency control. As shown in Figure 8, both in YCSB and TPC-C, Log contention of all variants consumes the least CPU time due to their highly scalable sequence number algorithms. The higher CPU time of Log work in CENTR, SILO and POPLAR is caused by the I/O bandwidth saturation. When the number of worker threads is $20$, each log buffer is quickly filled up which makes all worker threads to wait for available buffer space. This significantly increases the CPU execution cycles. It is obvious that the overhead of Log work can be reduced by adding I/O devices. Therefore, the CPU cycles of Log work of POPLAR and SILO are less than CENTR’s.

Scalability. Next, we measure the peak throughput to compare the scalability of different logging approaches by varying the number of SSDs. The experimental results of YCSB and TPC-C workloads are presented in Figure 9. When using a single SSD, the throughput of POPLAR and SILO is almost the same as that of CENTR. As the number of SSDs increases, more transactions can be flushed in parallel and more I/O bandwidth can be used, which makes the POPLAR and SILO scale well, except for CENTR. In the YCSB workload, when the number of SSDs is larger than $2$, the throughput of POPLAR and SILO does not keep increasing as that in the TPC-C workload. Obviously, this is caused by the limited CPU processing power. If we give more cores in each processor, the performance can scale well as in the TPC-C. The performance of NVM-D also grows when we increase the number of SSDs. But its peak throughput is seriously lower than POPLAR and SILO in all experiments due to its design based on NVM, which is not suitable for common I/O devices (e.g., SSDs).

Commit protocol with NVM emulation. To further investigate the impact of different commit protocols in logging approaches, we use YCSB with the hybrid workload in this experiment. The hybrid workload consists of a write query and a scan query with a fixed scan length. The scan length is used to indicate how many tuples might be accessed, which implies the proportion of RAW and WAR dependencies. In order to evaluate the impact of read operation on different commit protocols, we measure the performance of all variants by varying the scan length. All experiments are run on the emulated NVM that eliminates the effect of IO bandwidth on experiment results. In this experiment, we fix the number of worker threads to $20$ and the number of logger threads of POPLAR and SILO to $2$.

Figure 10 shows the performance in terms of throughput and commit latency of all variants. When the scan length equals to [math], all logging approaches have almost the same throughput, but SILO gets the commit latency of $25.7$ ms, whereas others have about $0.23$ ms. This huge performance gap ($\sim 112\times$) between SILO and other methods is mainly due to the epoch-based commit protocol used in SILO where transactions spend a lot of time waiting to be committed. As the scan length increases, the performance of all logging approaches declines. This is because worker threads need to handle increasing complex transaction logic when the scan length is larger. And when the scan length is larger than [math], NVM-D exhibits the worse throughput and logger commit latency than that of POPLAR. NVM-D requires that transactions with WAW, WAR or RAW dependencies must be committed in order, which increases the overhead of sequence number (GSN) allocation and extends unnecessary waiting time. The cost of GSN allocation is linearly proportional to the number of accessed tuples. Therefore, the throughput of NVM-D reduces linearly and commit latency grows linearly as the scan length increases. However, POPLAR only needs to track the WAW and RAW dependencies among transactions and its SSN allocation is not affected by the scan length. Hence, POPLAR maintains the super throughput and excellent commit latency. In this picture, CENTR also has a high performance due to the absent of any bottlenecks in our experiment environment. Obviously, if the processor has more cores (hundreds of thousands), contention over the centralized log buffer will become the primary bottleneck, whereas the contention can be addressed by increasing the number of log buffers in POPLAR.

6.4 Recovery Performance

We now evaluate the recovery performance of CENTR, SILO and POPLAR. We first measure the recovery time and then explore the scalability of the recovery subsystem in different logging approaches. We run YCSB with write-only workload and TPC-C and in each case, the number of recovery threads is fixed to $20$.

Recovery time. Table 2 and Table 3 show the recovery time of YCSB and TPC-C in detail. In this experiment, we use two pieces of SSDs to store checkpoint files and log files, except for CENTR. For YCSB workload, all logging approaches must recover $9$ GB of checkpoints and $77$ GB of logs to recreate a database. As shown in Table 2, the CENTR has the largest recovery time compared with the POPLAR and SILO. This is because in CENTR, only one recovery thread can load checkpoints and log files from the single I/O device at the same time, although recovery threads are able to concurrently replay the checkpoints and logs in memory. Therefore, the limited single I/O bandwidth seriously reduced the recovery performance. Owing to the parallel load, the POPLAR and SILO take less time ($\sim 51.10$ s) to recovery, which achieves more than $2.1\times$ better performance than CENTR. For TPC-C workload, there are a $40$ GB of checkpoints and $117$ GB of log files used to recovery. Table 3 shows the results that represent the same trends as the YCSB workload. And POPLAR takes about $95.63$ s to recovery the checkpoints and log files. In this experiment, it can be seen that recovery time is proportional to the amount of data that must be read to recover, and log recovery is the limiting factor in recovery. Thus, a reasonable decision to checkpoint frequently can effectively shorten recovery time without affecting normal transaction execution.

Recovery scalability. To investigate the scalability of the recovery algorithm in different logging approaches, we measure the total recovery time by varying the number of SSDs. For both YCSB and TPC-C, each experiment must recovery the same checkpoints and log files that evenly distributed across the used I/O devices. The results are presented in Figure 11. In all workloads, when only a single SSD exists, the recovery performance of POPLAR and SILO is almost the same as that of CENTR. As the number of SSDs increases, POPLAR and SILO significantly speed up the recovery process by leveraging parallelism of the multiple I/O devices. In the graph, the recovery time of approaches is proportional to the number of SSDs, except for CENTR. Hence, POPLAR and SILO have better scalability than CENTR.

7 Related Work

Centralized logging. ARIES-Logging [22] is widely used in many traditional database systems such as DB2, MySQL and PostgreSQL, but its centralized design seriously hurts performance of transactional database systems. Johnson et al. [14] adequately analyze bottlenecks of ARIES logging in the setting with multi-core processors, and indicate the contention on the centralized log buffer is the most important issue to scalability. To eliminate the serialization bottleneck, Aether [15] designs a scalable log buffer, which aggregates requests from multiple worker threads and supports parallel log insertion. Hekaton [9], ERMIA [18] and Deuteronomy [19] use an atomic instruction instead of a global lock to calculate LSN for each log record. And Eleda [16] proposes a highly concurrent data structure to track LSN holes caused by concurrent log insertion.

In addition, database systems must ensure that a transaction’s log records have been durable before the transaction commits. Flushing log records to a slower storage device damages the throughput and commit latency of transactions. Group commit [12] reduces pressure on storage device by aggregating multiple log records into a single IO operation. Asynchronous commit [3] allows transactions to be committed without waiting for their log records to be persisted. This method significantly promotes performance but at the cost of sacrificing the durability. Early lock release (ELR) [8] allows that a transaction releases locks before persisting its log records, which reduces the lock contention cased by log flushing.

As system load increases, database systems need to force a large number of log records to a single storage device, so that the limited bandwidth becomes the foremost impediment to performance. To address this problem, H-Store [17] employs command logging [21], which only records a procedure identifier and query parameters for a transaction. The logical log records incur low overhead for logging, but significantly slow down the recovery process as crash recovery manager needs to re-execute all transactions in a serial order.

Parallel logging. There are many approaches which enable parallel logging to eliminate the bottlenecks of centralized logging. Silo [24, 28] presents a fast logging and recovery algorithm by using multiple log buffers and storage devices. To avoid centralized contention and ensure the correctness of recovery, Silo adopts a group commit mechanism based on coarse-grained epoch. As the emergence of non-volatile memory (NVM), there are many NVM-based logging used to improve logging performance. PCMLogging [11], SCM-based Logging [10] and NV-Logging [13] establish log buffer in NVM and allow worker threads to write log records into NVM in parallel. Wang et al. [25] propose a distributed logging, which uses multiple log buffers on NVM to persist log records. To ensure correctness of recovery, it uses a global sequence number (GSN) to track all dependencies between transactions, and uses a passive group commit to protect transaction committing. All works manage to parallelize the transaction logging but is not suitable for slower storage devices due to frequent log flushing.

8 Conclusion

In this work, we proposed a new transaction logging Poplar based on our defined recoverability for a crash recovery manager. Poplar breaks the strongly sequential constraints in centralized logging and allows log records to be written into multiple storage devices in parallel. To guarantee the correctness of recovery, it uses a scalable sequence number (SSN) to track WAW and RAW dependencies between transactions and allows transactions to be committed after its log record, along with log records of its RAW predecessors, have been durable. After a system crash, Poplar can concurrently recover log records in SSN order to restore a consistent state. Our evaluation results demonstrate that Poplar can achieve high scalability and good performance in terms of throughput and commit latency.