Log In Sign Up

Co-KV: A Collaborative Key-Value Store Using Near-Data Processing to Improve Compaction for the LSM-tree

Log-structured merge tree (LSM-tree) based key-value stores are widely employed in large-scale storage systems. In the compaction of the key-value store, SSTables are merged with overlapping key ranges and sorted for data queries. This, however, incurs write amplification and thus degrades system performance, especially under update-intensive workloads. Current optimization focuses mostly on the reduction of the overload of compaction in the host, but rarely makes full use of computation in the device. To address these issues, we propose Co-KV, a Collaborative Key-Value store between the host and a near-data processing ( i.e., NDP) model based SSD to improve compaction. Co-KV offers three benefits: (1) reducing write amplification by a compaction offloading scheme between host and device; (2) relieving the overload of compaction in the host and leveraging computation in the SSD based on the NDP model; and (3) improving the performance of LSM-tree based key-value stores under update-intensive workloads. Extensive db_bench experiment show that Co-KV largely achieves a 2.0x overall throughput improvement, and a write amplification reduction by up to 36.0 the state-of-the-art LevelDB. Under YCSB workloads, Co-KV increases the throughput by 1.7x - 2.4x while decreases the write amplification and average latency by up to 30.0


Enabling Efficient Updates in KV Storage via Hashing: Design and Performance Evaluation

Persistent key-value (KV) stores mostly build on the Log-Structured Merg...

LUDA: Boost LSM Key Value Store Compactions with GPUs

Log-Structured-Merge (LSM) tree-based key value stores are facing critic...

SMORE: A Cold Data Object Store for SMR Drives (Extended Version)

Shingled magnetic recording (SMR) increases the capacity of magnetic har...

Authenticated Key-Value Stores with Hardware Enclaves

Authenticated data storage on an untrusted platform is an important comp...

CHoNDA: Near Data Acceleration with Concurrent Host Access

Near-data accelerators (NDAs) that are integrated with main memory have ...

Revitalizing Copybacks in Modern SSDs: Why and How

For modern flash-based SSDs, the performance overhead of internal data m...

Rearchitecting Kubernetes for the Edge

Recent years have seen Kubernetes emerge as a primary choice for contain...

I Introduction

Applications with many types of data are exploding in the big data era. IDC [25] reveals that the digital universe is large and is doubling in size every two years. Data-intensive applications must be supported by high performance. In relational databases, retrieval [2] is too inefficient to provide high performance for large-scale data processing. Key-value stores with high performance are widely employed in storage and memory systems [5]. Many famous IT companies built their data infrastructure using LSM-tree based key-value store [20], e.g., Google with LevelDB [15].

However, the compaction procedure, in which SSTables are merged with overlapping key ranges and ordered for data queries, is a weak link for LSM-tree based key-value stores. Compaction causes write amplification [20] and large amounts of data movement between host and device, which degrades performance, especially under update-intensive workloads. Current optimizations for LSM-tree based key-value stores concentrate mostly on two aspects. Firstly, the approaches on the host side aim to reduce I/O accesses to the device during compaction [27]. The host-side parallelism of CPU and I/O resources is used to improve compaction [29]. The CPU usage in the host increases while the computation resources in storage device are far from being fully utilized. Secondly, a prior method [13] offloads the whole compaction from the host into the devices to optimize compaction. This approach avoids frequent data movement but relies on CPU computation in the resource-constrained devices, thus its inability to maximize the overall system performance.

The popular framework moving computing close to source data is named near-data processing (i.e., NDP) in storage level [3] or processing-in-memory in memory level [12][19], respectively. This model aims to reduce the cost of data movement in the system under big-data workloads. In-storage computing model [13] applied in NAND flash-based storage system is widely studied. With computing ability increasing, new frameworks [9][10][11] with storage and computing pre-process the tasks collaboratively with the host, which reduces data movement and thus relieves the load of bandwidth and improves system performance. Our work aims to study the optimization of compaction in a key-value store using the storage-level NDP model.

A Collaborative Key-Value store, referred to hereafter as Co-KV, is proposed for compaction optimization. Contributions of this paper include: (1) NDP model-based Co-KV can leverage computation resources in host and device and the parallelism in the overall system; (2) Co-KV enables signification improvement in compaction by means of a compaction-offloading collaborative scheme between host and device; and (3) With Co-KV in place, overload of the host CPU and I/O resources is relieved and the overall performance is optimized in key-value stores.

Ii Background and Related Work

This section presents the background and related work on LSM-tree based key-value stores and storage-level near-data processing, which are helpful for us to design Co-KV.

Ii-a LSM-tree based Key-Value Stores

LSM-tree based key-value stores [5][15] provide high throughput in large-scale storage systems, LevelDB, for example. A key-value item is written into a commit log and buffered in a MemTable in memory. When the size of MemTable reaches its maximum capacity, it is transformed into an immutable MemTable and dumped into a disk as the SSTable. SSTables are organized into a series of levels that grow exponentially in size. An SSTable is migrated from to level, a process termed compaction. Compaction affects the performance of key-value store by incurring write amplification which is the ratio of the amount of data written to the underlying storage device to that requested by the from the user. Written data volume in level is about ten times as large as that in in the worst case during a compaction.

Most schemes have been proposed on the host side. bLSM [21] with the benefits of the LSM- and B-tree has a merge scheduler to improve performance. VT-tree [23] eliminates unnecessary copying SSTables into new ones in compaction. RocksDB [5] triggers more than two contiguous levels at once to sort and merge, which reduces compaction. LSM-trie [27] decreases write amplification by improving the random performance on multiple sorted tables in each level. The cLSM [4] and pipelined compaction procedure [29] employs concurrent or parallelism to improve the compaction performance. WiscKey [17] integrates the internal parallelism of SSD with the key-value separation method to achieve a high query performance. Atlas [14] is a distributed key-value store that stores keys and values on different HDDs. LSbM [24] introduces a buffer management in the disk to minimize cache invalidation caused by compaction in the device.

In contract, our Co-KV makes full use of computation in host-side and device-side subsystems to substantially improve the overall system performance degraded by compaction.

Ii-B Near-Data Processing Model

In the era of big data, large-scale systems change from a computing-intensive to a data-intensive processing model. In the computing-intensive model, performance and energy [28] of the system are increasingly consumed by the high overload of data movement [1]. The I/O interface between storage and memory is always the bottleneck in high-performance systems [13], which are evenly aggravated by data movement from storage to memory. To address these issues, a new notion of moving computation to data is proposed and named near-data processing (i.e., NDP) [10][16].

Our work focuses mainly on the storage-level NDP. The active disk [22] is a prior prototype of NDP model in storage level. With the advent of the flash memory, the framework of the active disk attracts attention from both academia and industry for two reasons: (1) The bandwidth of the flash memory is much higher than that required by the I/O between host and device [9]; (2) Inside a flash memory-based device, the computation controller, which mainly runs flash translation layer, can be enhanced to deal with computing-intensive tasks [6][26]. The notion of storage-level NDP (or in-storage computing [7][18]) has been increasingly employed in the big-data workloads.

Therefore the NDP model is applied into our novel Co-KV to improve the compaction of LSM-tree based key-value stores by host- and device-side collaboration.

Iii Co-KV Design

Iii-a Motivation

LSM-tree based key-value stores offer high performance and low latency. Compaction is the bottleneck of performance because of movement of huge amounts of data between host and device. The storage-level NDP model moves computation to data and gives the chance to process data in a storage device. The whole or part of the task is handled in the store, with the intermediate or final result passed to the host. Data are processed on both sides in parallel, as a result of which, CPU consumption and I/O resources of the host are relieved. But, how to divide compaction tasks into host and storage device? How to synchronize both-side tasks and manage data consistency? These challenges motivate us to design a collaborative compaction for LSM-tree based key-value store using the benefits of the NDP model.

Then, we propose a new key-value store prototype, called Co-KV, by collaboration of computation in host and device to perform compaction in parallel. It significantly improves the performance of the key-value store.

Iii-B Design Goals

Co-KV employs the NDP model to handle the challenges of compaction in LSM-tree based key-value stores. Co-KV is designed with the following goals in mind:

Low write amplification. Write amplification induces extra data movement from device to host during compaction. It largely impacts overall performance; thus, it is essential to minimize write amplification for better performance of the key-value store.

Reduction of CPU and I/O overload in host. Data moving from device for compaction consumes CPU and I/O resources in the host. Co-KV aims to reduce the burden of CPU and I/O resources on the host side by offloading compaction into the device to enhance the overall performance.

Optimized host- and device-side computation. Compaction costs computation in the host, while the computation in devices is rarely exploited. Based on the NDP model, Co-KV executes compaction between host and device using the computation resources of both for high performance.

Iii-C Prototype of the Co-KV System

We introduce the framework and implementation of Co-KV (see Figure 1) with emphasis on two key technologies: compaction offloading and collaborative management.

Iii-C1 Overall System of Co-KV

Fig. 1: Overall System of Co-KV.

We present the main components related to the collaborative compaction in and levels between host and device. Co-KV is mainly composed of the host-side compaction manager (i.e., Co-K manager), the device-side compaction manager (Co-K manager for short), the compaction offloading manager (i.e., Offload manager), and the Semantic manager.

Offload Manager: The Offload manager is an essential element in Co-KV. A scheme of offloading compaction named Compaction-SSTables-Aware (CSA for short) is implemented. The Offload manager splits meta-data of compaction into host- and device-side ones. Meta-data, as the semantic format, is transmitted to the host- and device-side managers respectively through the semantic manager. Meanwhile, the Offload manager receives the meta-data from the two compaction managers and integrates them into a new one, which maintains meta-data consistency during the compaction. The Offload manager deals with the compaction overload between the host-side and device-side systems, and therefore reduces write amplification and enhances the system performance.

Co-K Manager: A host-side compaction manager in Co-KV (i.e., Co-K in Figure 1) is fully compatible with application interfaces (put, get, delete, etc.) in LevelDB. The Co-K manager is responsible for host-side compaction, data consistency, and meta-data management. Meta-data for compaction is offloaded from the Offload manager (see Offload in Figure 1) to the Co-K manager, which performs host-side compaction operations. Performance in the host can be improved by reducing the scale of compaction operations with respect to that in LevelDB. Results of compaction (e.g., FileMetaData) are returned to the Offload manager via semantic messages by a semantic manager.

Co-K Manager: The device-side compaction manager (Co-K) exemplifies the near-data processing model in the device level. The Co-K manager receives a portion of the meta-data in a semantic message from the Offload manager via the semantic manager. In this way, the Co-K manager locally performs compaction using the NDP model rather than sends more SSTables to the host. A portion of compactions in the device contributes to low write amplification in Co-KV and high overall system performance. File meta-data (key range, file number, and file size) of new SSTables produced from device-side compaction is returned to the host.

Semantic Manager: The Semantic manager is an important part of Co-KV for the collaborative compaction between the host and the device, i.e., the collaborative compaction in the Co-K manager and the Co-K manager. The Semantic message is the basic data transmission unit of meta-data for compaction between the Offload manager and the Co-K manager (or the Co-K manager). The semantic manager plays an important role in keeping the data consistency and optimizing parallel compaction operations between the above two compaction managers.

Details of the implementation for these components in Co-KV are demonstrated in the following section.

Iv Co-KV Implementation

We introduce the scheme of compaction offloading for the Co-K manager and the Co-K manager. The collaborative compaction between these two managers is described.

In LevelDB, an SSTable (e.g., SSTable) in level and a number of SSTables in level are read from the device when a compaction is triggered. Meta-data are updated after SSTables being written back to the device. In comparison, Co-KV offloads a portion of compaction onto the device. The NDP model is employed by the Co-K manager in the device to perform compaction by using its computation and a lightweight run-time library .

It should be noted how the collaborative compaction managers between two sides handle SSTables during compaction. Two challenges must be handled:
  How can the Offload manager select SSTables as action objects during compaction? (Problem 1)
  How can the Offload manager split and offload SSTables to Co-K and Co-K managers? (Problem 2)

Problem 1. Experiments are conducted to analyze the characteristics of compaction in LevelDB and find how many SSTables should be selected from and levels by the Offload manager. Since compaction in LevelDB results mainly from the random workload, db_bench in LevelDB is employed in this test. Under fillrandom workload, a data set with one billion key-value items is configured to test the number of SSTables from level in compaction.

Observation: We find in most cases that more than 93.0% single SSTables in level and no less than 80% double SSTables in level are selected to be compacted. These observations lead us to (1) select one SSTable from as the number of SSTables in our Co-KV; and (2) design an approach to offloading half of the SSTables in to the device-side compaction manager by the Offload manager. The total of compaction SSTables is reduced on the host side. Meanwhile, host- and device-side compactions are executed in parallel, which greatly improves the performance. This approach makes full use of computation in the overall system and proves to be efficient in this section and in Section V. This approach is used in most cases to improve compaction for the overall system, with the original method employed for the rest ones.

Problem 2. We design a scheme of offloading compaction in Offload manager to (1) improve compaction and lower write amplification; and (2) employ the NDP model in the device to achieve maximum parallelism in compaction. This scheme refered to as Compaction-SSTables-Aware (CSA) offloads compaction to the host- and device-side compaction managers. The Offload manager obtains meta-data of SSTables across its levels and SSTables in the current version for compaction. The CSA scheme is illustrated as follows.

It is supposed that SSTable in level is involved in compaction. The key range of SSTable is given by


which is applied to compare with the key range of every SSTable in level to find the SSTable with overlapping one by


where and as shown in Figure1.

Then, the key-range set of SSTables that have an overlapping key range with SSTable is involved in the process of compaction. These ranges of key in level can be expressed as


where v = k+1.

By the CSA scheme, elements in are divided into two subsets:


where there is v = k+1 and


where v = k+1 and .

Then key range for SSTable is split by the value of the lower range of (i.e., ), and can be expressed as


where is rewritten into


where and .

Finally, two sets of SSTables are obtained by the Offload manager using a CSA scheme:




When compaction is offloaded into the two managers, the collaborative compaction is performed on both sides. A semantic manager is designed to handle the semantic transmission between the host- and device-side compaction managers. When the meta-data of SSTables in compaction is dispatched to the device, the semantic manager is triggered to send the meta-data to the device. In compaction, the Co-K manager (or Co-K manager) receives and checks the semantic requests or responses from its counterpart. The semantic manager goes inactive upon the completion of the semantic transmission from both sides. An example is given to illustrate the semantic management in compaction.

When the device-side compaction completes, the Co-K manager generates a semantic with the completion flag and send it to Co-K. The meta-data after compaction is sent to the Offload manager by the semantic manager. When Co-K compaction is done, Co-K sends its new meta-data to the Offload manager and checks the completion flag in an incoming semantic from the device. If compaction has not been completed, the Co-K manager continues to check the completion flag of semantic from the device until the compaction in device finishes. Owing to the semantic manager, the semantics from both compaction manager can cooperate with each other in real time. The parallelism of collaborative compaction between host and device can keep data consistent. It is stated that the semantic manager a lightweight management software, which has little impacts on system performance.

Both the Compaction-SSTables-Aware scheme and the semantic manager play an important role in our Co-KV. We put forward the procedures for Co-K and Co-K (see Algorithm 1 and 2) combining two aspects.

1:procedure Co-K Compaction
2:      if  == TRUE then
3: Select SSTable in
4: keyRange =
5: m = Numbers of SSTables in this compaction in
6: Set ,
7: Set
8: Set
9: OffloadManager(ToCo-KV_H, , )
10: OffloadManager(ToCo-KV_D, , )
11: SemanticManager(SEND, Co-K, CompMetadata_H)
12: SemanticManager(SEND, Co-K, CompMetadata_D)
13: Co-KV_HmanagerDoCompaction()
14: SemanticManager(SEND, Offload, Co-KnewMetadata)
15:            while DCompFinish == FALSE do
16:     continue
17:            end while
18: DCompFinish = FALSE
19: SemanticManager(RECV, Offload, Co-KnewMetadata)
20: SemanticManager(RECV, Offload, Co-KnewMetadata)
21: Update meta-data and delete obsoleteFile by Offload manager
22:      end if
23:end procedure
Algorithm 1 Compaction in host-side Co-KV
1:procedure Co-K Compaction
2: SemanticManager(RECV, Co-K, CompMetadata_D)
3: Co-KV_DmanagerDoCompaction()
4: DCompFinish = TRUE
5: SemanticManager(SEND, Offload, Co-KnewMetadata)
6:end procedure
Algorithm 2 Compaction in device-side Co-KV

V Experiment and Evaluation

Experiments are conducted to evaluate the benefits of Co-KV under workloads: (1) the collaborative feasibility of Co-KV and availability of the offloading compaction between host and device; and (2) the superiority of Co-KV in compaction improvement under workloads.

V-a Experimental Settings

Hardware: We designed an experiment platform to evaluate Co-KV. Experiment is conducted on a system with four Intel(R) Core(TM) CPU i5-6500@3.20GHz processors and 16GB memory. An Intel 535 SSD is employed as the storage device featured with 180GB capacity, 540MB/s Seq. Read, and 490MB/s Seq. Write.

Software: The operating system is Ubuntu 16.04 LTS with ext4 as the default file system. LevelDB a popular LSM-tree key-value store is employed as the baseline in experiment. The Co-KV framework extended from LevelDB consists of two components: the host- and device-side software frameworks. On the host side, the software framework is derived mainly from LevelDB. The APIs in Co-KV are compatible with those in LevelDB. The Runtime library inside LevelDB is applied in the Co-K manager.

NDPsim emulation: In our work, a real-world device-side SSD with a near-data processing model inside is not available for us yet. We implement a function-level simulator for the near-data processing model (named NDPsim with 3,000 lines of code) which is emulated by a process on the host side by a software framework. In Col-KV, NDPsim should have two features: (1) the time consumption111In a real-world NDP-based SSD, the time consumption is largely dependent on the number of SSTables from flash memory to DRAM. from a device to NDPsim is subtracted to simulate the internal high throughput in compaction inside a NDP-based storage device; (2) NDPsim is configured with heavy compaction load to simulate the case where the computation ability inside NDP-based SSD is smaller than that in the host. NDPsim provides a runtime system for SSTables compaction by using a library similar to that in LevelDB.

In Co-KV, these host- and device-side frameworks execute their tasks in two different processes. As shown in Section III-C, Co-K and Co-K managers perform compaction, separately. The Co-K manager in a process perform compaction according to meta-data (see Eq.8) on the host side. Meanwhile, the Co-K manager inside NDPsim runs compaction by (see Eq.9) in the other process to simulate the real-world NDP runtime environment by a software framework. Therefore, there is no interference between the compactions in the host-side framework and device-side NDPsim. NDPsim invokes the Co-K manager to handle SSTables compaction on receiving mete-data sets (see Eq.9) for compaction from Offload manager. NDPsim performance can be influenced by the meta-data transmission between the Co-K manager in the host-side framework and its Co-K manager, which is mainly attributable to inter-process communication. The Offload manager collects meta-data for new SSTables on the completion of compaction by the two managers. Results from the Co-K and Co-K managers are written to different files in the device. The computation in the devices will not incur overloads on throughput of concurrent accessing the device. Finally, the meta-data from two compaction managers are written to a log file in the device by the Offload manager.

Our goal is to show that the NDP model inside an SSD can improve compaction better in Co-KV than in LevelDB. NDPsim indicates the benefits of Co-KV with the near-data processing model. Work on the real-world NDP framework is under way to add computing components into SSD-based storage for compaction improvement in key-value stores.

Fig. 2: Write Amplification (2), Throughput (MB/s, 2 and 2)) for LevelDB and Co-KV. 2 under fillseq and fillrandom workloads, 2 fillseq workload, 2 fillrandom workload.

V-B Workloads

Db_bench in LevelDB test-suite is used to test Co-KV. We compare Co-KV with LevelDB in terms of write amplification and throughput. The size of MemTable, SSTable, and data block is set to 4MB, 2MB and 4KB, respectively. The key-value item size is set to 16bytes and 100bytes which is the default configuration of LevelDB. Two workloads with ten types of key-value items (see Table II) are employed in evaluation.

db_bench - Workload in LevelDB
Type fillrandom fillseq Key-Value Items
db_bench_1 2x, 4x, 6x,
db_bench_2 8x, 10x
User-defined Workload in YCSB
OPS (Read%) Database Size (10GB) Value Size (1KB)
(Update : Read) Load (1x) Run (2x) 1x
10%, 30%, 1x, 2x 1x, 2x,
50%, 70%, 90% 3x, 4x, 5x -
TABLE I: Workload Characteristics

YCSB (Yahoo! Cloud Serving Benchmark) [8] is designed to evaluate performance of NoSQL databases. There are six default kinds of workloads. The impact of compaction on performance results mostly from random updates. Thus, the advantage of Co-KV is obvious where compaction is performed under update-intensive workloads. Five types of workload executors by extending workload class of YCSB are modified to simulate different update-intensive workloads. Configurations of the random key and value size, which have great impact on compaction, are employed in the experiment. We set the request distribution to Zipf (see Table II). In our experiment, YCSB is used to evaluate the operations per second (ops/sec), latency, and write amplification of Co-KV.

V-C Evaluation

V-C1 Experiment based on db_bench

Fig. 3: Throughput (3), Write amplification (3), and Average Latency (3) for LevelDB and Co-KV under YCSB workloads (load 20GB and run 20GB, 40GB, 60GB, 80GB, and 100GB). Throughput (3) for LevelDB and Co-KV based on different read and update ratio under YCSB.

In this section, we compare our Co-KV with LevelDB to analyze the experimental results in the aspects of write amplification and throughput under db_bench workload.

Write Amplification: Performance of a key-value store is largely dependent on write amplification, which is defined as the average of actual amount of written data to disk per user written data. Its ideal value is one. There are two kinds of compaction tasks in the Co-K and the Co-K, respectively. Write amplification, a terminology in the user level, is considered in Co-K rather than Co-K. Write amplification is much smaller in Co-KV than that in LevelDB. In this experiment, we use five kinds of data sets in db_bench_1 (i.e., 200 million, 400 million, 600 million, 800 million, and a billion key-value items).

In Figure 2, write amplification in LevelDB rises with growing scale of the data set under fillrandom workload in db_bench_1. For a size of data set of 1 billion, the write amplification for LevelDB reaches up to 20.7. In contrast, the Co-KV store improves the value by more than 36.0%. In Co-KV, compaction tasks are offloaded to the Co-K manager in the device by means of a compaction-SSTables-aware scheme. Compaction in the Co-K manager and the Co-K manager is performed in parallel, and compaction in device will not increase host-level write amplification. In db_bench_1, Co-K significantly reduces write amplification of the overall key-value store.

It is required/necessary that compaction does not occur under sequential fillseq workload (see db_bench_2 in Table II). There is no need to offload compaction to Co-K. Write amplification in Co-KV is depended on Co-K similar to that in LevelDB. Therefore, write amplification is of the same value (i.e., 2.1) in Co-KV and in LevelDB under this workload (see Figure 2). The value is higher than the ideal reference (i.e., one) because of meta-data update.

Throughput (MB/s): Throughput of key-value store is largely determined by write amplification. Write amplification decreases considerably and throughput is improved as well. We employ the same workloads in db_bench (see Table II) in this test. Db_bench_1 and db_bench_2 have identical data sets from 200 million to one billion key-value items with a key size of 16Bytes and a value size of 100Bytes. Results under fillseq workload in db_bench_2 are shown in Figure 2. The maximum throughputs for LevelDB and Co-KV rise up to 48.7MB/s and 48.9MB/s, respectively. Under fillseq workload, compaction will not be triggered in Co-KV and LevelDB; thus, they have similar throughputs. Figure 2 presents the throughputs of Co-KV and LevelDB under fillrandom workload. The size of the data set is approximately between 20GB and 110GB. Throughput for LevelDB ranges from 2.0MB/s to 3.1MB/s.

In contrast, the throughput in Co-KV is about twice as great as that in LevelDB. The value ranges from 3.5MB/s to 5.9MB/s, with a best improvement of about 2.0x. As data volume increases, much more compaction is triggered and write amplification becomes higher. In this case, throughput is degraded both in Co-KV and in LevelDB. Co-KV reduces write amplification by up to 36.0% due largely to its parallel and collaborative compactions in Co-K and Co-K. It is concluded that Co-KV relieves the run-time cost in the process of compaction to achieve better throughput compared with LevelDB.

V-C2 Experiment based on YCSB

A number of workloads are configured on the basis of varied ratios of read to write, size of data set (under load or run operations), and record size in YCSB. Throughput (operations per second, ops/sec), write amplification, and average latency in YCSB are employed to evaluate Co-KV under YCSB workloads.

Different Run Data Volumes (Load 20GB database, Record size = 1KB): A workload (in Table II) with 100 percent update operations and Zipf distribution is configured in YCSB. The record size is 1KB, load 20GB database and five types of databases are configured during running. As shown in Figure 3, Co-KV improves the throughput (ops/sec) to 2.0x at the least (run 100GB database) and 2.2x at the most (run 20GB database) compared with LevelDB. 100% update operations in this workload can cause lots of compaction for LevelDB or Co-KV to degrade its throughput. In Co-KV, the device-side Co-K runs about half of the compaction operations in LevelDB. The host- and device-side compaction operations can be executed in parallel. These features of Co-KV contribute to its better throughput than that in LevelDB.

Similarly, write amplification is noticeably improved in Co-KV in comparison with that in LevelDB (see Figure 3). In the best case, write amplification in Co-KV is decreased to about 71.0% what it is in LevelDB under load 20GB and run 80GB database based workload. Note that write amplification degrades the overall performance. As Figure 3 shows, the average latency of update in Co-KV is optimized by about 50.0% 54.0% compared to that in LevelDB.

Different Read and Update Ratios (Load 10GB, Run 20GB database, Record size = 1KB): In the experiment, we configure the ratio of read and update operations (get/put) in a workload to evaluate the throughput for Co-KV. This workload has 10GB load database, 20GB of run database, and 1KB of record size. The read operation is configured as 10%, 30%, 50%, 70%, and 90%, respectively. The throughput in Co-KV shows to be 7186ops/s, 8820ops/s, 11578ops/s, 15428ops/s, and 21415ops/s under 10%-, 30%-, 50%-, 70%-, and 90%-read workloads. Although the throughput in LevelDB has the same tendency, the value of throughput (ops/sec) is smaller than that in Co-KV under the same workload. Firstly, the update operations in Co-KV or LevelDB induce compaction which affects its throughput. More update operations (such as 90% update) can trigger compaction which cuts down the throughput for both Co-KV and LevelDB. Secondly, Co-KV with improved compaction has better throughput than LevelDB (see Figure 3).

Vi Discussion and Future Work

We hope that this work can provide insights into a new research field of compaction improvement using collaboration of host and device for LSM-tree based key-value stores in perspective of system-level parallelism. Our Co-KV is also applied into other LSM-tree based key-value stores on an SSD capable of near-data processing. Characterized by a compaction offloading scheme and the semantic management between host and device, Co-KV makes transparent to users the subsystem with the NDP model in the device, and is fully compatible with the application interfaces in LSM-tree based storage systems. Therefore, Co-KV enjoys flexibility for key-value storage system.

In this work, the Co-K is derived from LevelDB and demonstrates a relatively large compaction improvement in the host side. One of our future work is to design and implement a new dynamic Co-K-based scheme to improve compaction in the host for Co-KV. In addition, we will primarily address the implementation complexity in the Offload manager, Co-K manager, Co-K manager, and semantic manager to deploy Co-KV on a real-world platform in the future.

Vii Conclusion

Compaction has an adverse effect on the performance of LSM-tree based key-value stores. Existing work mostly concentrates on alleviating compaction in the host level. The collaborative improvement for compaction is rarely taken into account. We propose a system-level Co-KV to minimize the consumption of compaction in the LSM-tree based key-value stores. It employs the near-data processing model in the device and takes full advantage of the collaborative computation on both host and device. Co-KV divides a compaction into two portions, which are offloaded into host and device, respectively. Collaborative compactions are performed in parallel. Our Co-KV achieves better performance than LevelDB in terms of write amplification, throughput, and latency under db_bench and YCSB workloads.


We thank the reviewers for their work on our paper. This work is supported in part by National Natural Science Foundation of China under Grants 61702004.


  • [1] Rajeev Balasubramonian, Jichuan Chang, Troy Manning, Jaime H Moreno, Richard Murphy, Ravi Nair, and Steven Swanson. Near-data processing: Insights from a micro-46 workshop. IEEE Micro, 34(4):36–42, 2014.
  • [2] Jing Han, E Haihong, Guan Le, and Jian Du. Survey on nosql database. In Pervasive computing and applications (ICPCA), 2011 6th international conference on, pages 363–366. IEEE, 2011.
  • [3] Rajeev Balasubramonian and Boris Grot. Near-data processing. IEEE Micro, 36(1):4–5, 2016.
  • [4] Guy Golan-Gueta, Edward Bortnikov, Eshcar Hillel, and Idit Keidar. Scaling concurrent log-structured data stores, 2015.
  • [5] Dhruba Borthakur. Under the hood: Building and open-sourcing rocksdb., 2013.
  • [6] Benjamin Y Cho, Won Seob Jeong, Doohwan Oh, and Won Woo Ro. Xsd: Accelerating mapreduce by harnessing the gpu inside an ssd. In Proceedings of the 1st Workshop on Near-Data Processing, 2013.
  • [7] Sangyeun Cho, Sanghoan Chang, and Insoon Jo. The solid-state drive technology, today and tomorrow. In Data Engineering (ICDE), 2015 IEEE 31st International Conference on, pages 1520–1522. IEEE, 2015.
  • [8] Brian F Cooper, Adam Silberstein, Erwin Tam, Raghu Ramakrishnan, and Russell Sears. Benchmarking cloud serving systems with ycsb. In Proceedings of the 1st ACM symposium on Cloud computing. ACM, June 2010.
  • [9] Jaeyoung Do, Yang-Suk Kee, Jignesh M Patel, Chanik Park, Kwanghyun Park, and David J DeWitt. Query processing on smart ssds: opportunities and challenges. In Proceedings of the 2013 ACM SIGMOD International Conference on Management of Data, pages 1221–1230. ACM, 2013.
  • [10] Boncheol Gu, Andre S Yoon, Duck-Ho Bae, Insoon Jo, Jinyoung Lee, Jonghyun Yoon, Jeong-Uk Kang, Moonsang Kwon, Chanho Yoon, Sangyeun Cho, et al. Biscuit: A framework for near-data processing of big data workloads. In Computer Architecture (ISCA), 2016 ACM/IEEE 43rd Annual International Symposium on, pages 153–165. IEEE, 2016.
  • [11] Yangwook Kang, Yang-suk Kee, Ethan L Miller, and Chanik Park. Enabling cost-effective data processing with smart ssd. In Mass Storage Systems and Technologies (MSST), 2013 IEEE 29th Symposium on, pages 1–12. IEEE, 2013.
  • [12] Soroosh Khoram, Yue Zha, Jialiang Zhang, and Jing Li. Challenges and opportunities: From near-memory computing to in-memory computing. In Proceedings of the 2017 ACM on International Symposium on Physical Design. ACM, 2017.
  • [13] Yang Seok Ki. In-storage compute: an ultimate solution for accelerating i/ointensive applications. In Flash Memory summit 2015, pages 1–30. FMS, 2015.
  • [14] Chunbo Lai, Song Jiang, Liqiong Yang, Shiding Lin, Guangyu Sun, Zhenyu Hou, Can Cui, and Jason Cong. Atlas: Baidu’s key-value storage system for cloud data. In 31st Symposium on Mass Storage Systems and Technologies (MSST), pages 1–14. IEEE, 2015.
  • [15] A Leveldb. fast and lightweight key/value database library by google., 2014.
  • [16] Ling Liu. Computing infrastructure for big data processing. Frontiers of Computer Science, 7(2):165–170, 2013.
  • [17] Lanyue Lu, Thanumalayan Sankaranarayana Pillai, Andrea C Arpaci-Dusseau, and Remzi H Arpaci-Dusseau. Wisckey: separating keys from values in ssd-conscious storage. In Proceedings of the 14th Usenix Conference on File and Storage Technologies, pages 133–148. USENIX Association, 2016.
  • [18] Dongchul Park, Jianguo Wang, and Yang Suk Kee. In-storage computing for hadoop mapreduce framework: Challenges and possibilities. IEEE Transactions on Computers, PP(99):1–1, 2016.
  • [19] Junwhan Ahn, Sungpack Hong, Sungjoo Yoo, Onur Mutlu, and Kiyoung Choi. A scalable processing-in-memory accelerator for parallel graph processing. Acm Sigarch Computer Architecture News, 43(3):105–117, 2015.
  • [20] Patrick P.OoNeil, Edward Cheng, Dieter Gawlick, and Elizabeth OoNeil. The log-structured merge-tree (lsm-tree). Acta Informatica, 33(4):351–385, 1996.
  • [21] Russell Sears and Raghu Ramakrishnan. blsm: a general purpose log structured merge tree. In Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data, pages 217–228. ACM, 2012.
  • [22] CALD Seminar. Active storage for large-scale data mining and multimedia. Center for Automated Learning and Discovery, pages 62–73, 1998.
  • [23] Pradeep Shetty, Richard Spillane, Ravikant Malpani, Binesh Andrews, Justin Seyster, and Erez Zadok. Building workload-independent storage with vt-trees. In Proceedings of the 11th USENIX conference on File and Storage Technologies, pages 17–30. USENIX Association, 2013.
  • [24] Dejun Teng, Lei Guo, Rubao Lee, Feng Chen, Siyuan Ma, Yanfeng Zhang, and Xiaodong Zhang. Lsbm-tree: Re-enabling buffer caching in data management for mixed reads and writes. In Proceedings of the 37th IEEE International Conference on Distributed Computing Systems, 2017.
  • [25] Vernon Turner, John F Gantz, David Reinsel, and Stephen Minton. The digital universe of opportunities: Rich data and the increasing value of the internet of things. IDC Analyze the Future, 2014.
  • [26] Jianguo Wang, Dongchul Park, Yang Suk Kee, Yannis Papakonstantinou, and Steven Swanson. Ssd in-storage computing for list intersection. In International Workshop on Data Management on New Hardware, pages 4:1–4:7, 2016.
  • [27] Xingbo Wu, Yuehai Xu, Zili Shao, and Song Jiang. Lsm-trie: an lsm-tree-based ultra-large key-value store for small data. In Proceedings of the 2015 USENIX Conference on Usenix Annual Technical Conference, pages 71–82, 2015.
  • [28] Wulf, Wm. A, McKee, and Sally A. Hitting the memory wall: implications of the obvious. Acm Sigarch Computer Architecture News, 23(1):20–24, 1995.
  • [29] Zigang Zhang, Yinliang Yue, Bingsheng He, Jin Xiong, Mingyu Chen, Lixin Zhang, and Ninghui Sun. Pipelined compaction for the lsm-tree. In Parallel and Distributed Processing Symposium, 2014 IEEE 28th International, pages 777–786. IEEE, 2014.