Key-value Store Research Articles

An LSM Tree Augmented with B + Tree on Nonvolatile Memory

Modern log-structured merge (LSM) tree-based key-value stores are widely used to process update-heavy workloads effectively as the LSM tree sequentializes write requests to a storage device to maximize storage performance. However, this append-only approach leaves many outdated copies of frequently updated key-value pairs, which need to be routinely cleaned up through the operation called compaction . When the system load is modest, compaction happens in background. However, at a high system load, it can quickly become the major performance bottleneck. To address this compaction bottleneck and further improve the write throughput of LSM tree-based key-value stores, we propose LAB-DB, which augments the existing LSM tree with a pair of B + trees on byte-addressable nonvolatile memory (NVM). The auxiliary B + trees on NVM reduce both compaction frequency and compaction time, hence leading to lower compaction overhead for writes and fewer storage accesses for reads. According to our evaluation of LAB-DB on RocksDB with YCSB benchmarks, LAB-DB achieves 94% and 67% speedups on two write-intensive workloads (Workload A and F), and also a 43% geomean speedup on read-intensive YCSB Workload B, C, D, and E. This performance gain comes with a low cost of NVM whose size is just 0.6% of the entire dataset to demonstrate the scalability of LAB-DB with an ever increasing volume of future datasets.

Rcmp: Reconstructing RDMA-Based Memory Disaggregation via CXL

Memory disaggregation is a promising architecture for modern datacenters that separates compute and memory resources into independent pools connected by ultra-fast networks, which can improve memory utilization, reduce cost, and enable elastic scaling of compute and memory resources. However, existing memory disaggregation solutions based on remote direct memory access (RDMA) suffer from high latency and additional overheads including page faults and code refactoring. Emerging cache-coherent interconnects such as CXL offer opportunities to reconstruct high-performance memory disaggregation. However, existing CXL-based approaches have physical distance limitation and cannot be deployed across racks. In this article, we propose Rcmp, a novel low-latency and highly scalable memory disaggregation system based on RDMA and CXL. The significant feature is that Rcmp improves the performance of RDMA-based systems via CXL, and leverages RDMA to overcome CXL’s distance limitation. To address the challenges of the mismatch between RDMA and CXL in terms of granularity, communication, and performance, Rcmp (1) provides a global page-based memory space management and enables fine-grained data access, (2) designs an efficient communication mechanism to avoid communication blocking issues, (3) proposes a hot-page identification and swapping strategy to reduce RDMA communications, and (4) designs an RDMA-optimized RPC framework to accelerate RDMA transfers. We implement a prototype of Rcmp and evaluate its performance by using micro-benchmarks and running a key-value store with YCSB benchmarks. The results show that Rcmp can achieve 5.2× lower latency and 3.8× higher throughput than RDMA-based systems. We also demonstrate that Rcmp can scale well with the increasing number of nodes without compromising performance.

Towards flexibility and robustness of LSM trees

Log-structured merge trees (LSM trees) are increasingly used as part of the storage engine behind several data systems, and are frequently deployed in the cloud. As the number of applications relying on LSM-based storage backends increases, the problem of performance tuning of LSM trees receives increasing attention. We consider both nominal tunings—where workload and execution environment are accurately known a priori—and robust tunings—which consider uncertainty in the workload knowledge. This type of workload uncertainty is common in modern applications, notably in shared infrastructure environments like the public cloud. To address this problem, we introduce Endure, a new paradigm for tuning LSM trees in the presence of workload uncertainty. Specifically, we focus on the impact of the choice of compaction policy, size ratio, and memory allocation on the overall performance. Endure considers a robust formulation of the throughput maximization problem and recommends a tuning that offers near-optimal throughput when the executed workload is not the same, instead in a neighborhood of the expected workload. Additionally, we explore the robustness of flexible LSM designs by proposing a new unified design called K-LSM that encompasses existing designs. We deploy our robust tuning system, Endure, on a state-of-the-art key-value store, RocksDB, and demonstrate throughput improvements of up to 5×\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$\ imes $$\\end{document} in the presence of uncertainty. Our results indicate that the tunings obtained by Endure are more robust than tunings obtained under our expanded LSM design space. This indicates that robustness may not be inherent to a design, instead, it is an outcome of a tuning process that explicitly accounts for uncertainty.

SplitDB: Closing the Performance Gap for LSM-Tree-Based Key-Value Stores

SplitDB: Closing the Performance Gap for LSM-Tree-Based Key-Value Stores

Blockchain-based key-value store to support dynamic smart contract interaction in the agricultural sector

<span>In the era of supply chain digitalization, adaptability and transparency are key to enhancing efficiency and trust. Although blockchain technology and smart contract offer innovative solutions, the limitations of static smart contract hinder their full potential. This article introduces a new approach using dynamic smart contract capable of managing various commodities in the supply chain with a key-value store. While this advantage provides flexibility, it still poses challenges in managing increasingly complex interactions among various actors, especially when the number of commodities increases. To address these challenges, this study introduces the concept of smart contract interaction that facilitates the automation and management of interactions with high efficiency. The implementation results show that smart contract interaction outperforms conventional approaches in terms of speed, resilience, and ease of management. Through the combination of dynamic smart contract and smart contract interaction, demonstrating how efficiency, transparency, adaptability, and scalability can be achieved in the supply chain, providing new insights into the utilization of blockchain technology for the modern industry.</span>

TrickleKV: A High-Performance Key-Value Store on Disaggregated Storage With Low Network Traffic

TrickleKV: A High-Performance Key-Value Store on Disaggregated Storage With Low Network Traffic

Encrypted and Compressed Key-Value Store With Pattern-Analysis Security in Cloud Systems

Encrypted and Compressed Key-Value Store With Pattern-Analysis Security in Cloud Systems

MirrorKV: An Efficient Key-Value Store on Hybrid Cloud Storage with Balanced Performance of Compaction and Querying

LSM-based key-value stores have been leveraged in many state-of-the-art data-intensive applications as storage engines. As data volume scales up, a cost-efficient approach is to deploy these applications on hybrid cloud storage with hot/cold separation, which splits the LSM-tree into two parts and thus brings new challenges on how to split and how to close the significant performance gap between these two parts. Existing LSM-tree key-value stores mainly focus on the optimizations of local storage, which incurs sub-optimal performance when directly applied to hybrid storage. In this paper, we present MirrorKV for efficient compaction and querying on hybrid cloud storage. First, based on the capacities of fast and slow cloud storage, MirrorKV vertically separates hot/cold data of different levels stored in different cloud storage with different compaction mechanisms. To avoid compaction in slow storage being the bottleneck of the write path, MirrorKV proposes a novel virtual split to only compact the metadata during the compaction, which postpones the actual compaction until it reaches deep enough levels. Second, to reduce accessing slow storage during querying, MirrorKV horizontally separates keys and values into two mirrored LSM-trees to differentiate caching priorities; the maintained tree structures preserve the data locality for efficient sequential reading without incurring the overhead of the traditional key-value separation solutions. Finally, MirrorKV leverages cached data to guide the compaction where the hot data is retained in the fast storage while the cold data is compacted to deeper levels in slow storage. Compared with RocksDB-cloud, MirrorKV achieves 2.4× higher random insertion throughput, 29% higher random read throughput, and 99% less compaction time.

ChainKV: A Semantics-Aware Key-Value Store for Ethereum System

The Log-Structure Merged tree (LSM-tree) based key-value (KV) store has been widely adopted as the storage engine for blockchain systems, such as Ethereum, in which blockchain data are uniformly transformed into randomly distributed KV items for persistence. However, blockchain semantics are ignored during this process, making the blockchain storage suffer from heavy read/write amplification problems. Moreover, as the Ethereum network scales up, tremendous data further exacerbates its storage burden. Until now, most studies have focused on sharding, data archiving, decentralized distributed storage, etc., to mitigate the burden of the storage layer. However, the incompatibility between Ethereum semantics and the characteristics of the storage engine is ignored. In this paper, we present ChainKV, a new semantics-aware storage paradigm to improve the storage management performance for the Ethereum system. Firstly, based on Ethereum blockchain semantics, ChainKV separately stores different types of data in multiple storage zones in the KV store to mitigate the read/write amplification problem. Secondly, following the mechanism of the verification process in the authenticated data structure (ADS), a new ADS data transformer is proposed to exploit the data locality when persisting ADS. Moreover, a new space gaming caching policy is adopted to coordinate the cache space management for two independent storage zones. Finally, we propose an optional lightweight node crash recovery mechanism to eliminate functional redundancy between the Ethereum protocol and the storage engine. The experimental results indicate that ChainKV outperforms the prior Ethereum systems by up to 1.99× and 4.20× for synchronization and query operations, respectively

BonsaiKV: Towards Fast, Scalable, and Persistent Key-Value Stores with Tiered, Heterogeneous Memory System

Emerging NUMA/CXL-based tiered memory systems with heterogeneous memory devices such as DRAM and NVMM deliver ultrafast speed, large capacity, and data persistence all at once, offering great promise to high-performance in-memory key-value stores. To fully unleash the performance potential of such memory systems, this paper presents BonsaiKV, a key-value store that makes the best use of different components in a tiered memory system. The core of BonsaiKV is a tri-layer hierarchical storage architecture that separates data indexing, persistence, and scalability from each other and realizes each of them within a specialized software-hardware layer. We design BonsaiKV with a set of novel techniques, including collaborative tiered indexing, NVMM congestion control mechanisms, fine-grained data striping, and NUMA-aware data management, to leverage hardware strengths and tackle device deficiencies. We compare BonsaiKV with state-of-the-art NVMM-optimized key-value stores and persistent index structures using a variety of YCSB workloads. Evaluation results demonstrate that BonsaiKV outperforms others by up to 7.69×, 19.59×, and 12.86× in read-, write- and scan-intensive scenarios, respectively.

Consistent Low Latency Scheduler for Distributed Key-Value Stores

Consistent Low Latency Scheduler for Distributed Key-Value Stores

Practical and Malicious Multiparty Private Set Intersection for Small Sets

Private set intersection (PSI) is a pivotal subject in the realm of privacy computation. Numerous research endeavors have concentrated on situations involving vast and imbalanced sets. Nevertheless, there is a scarcity of existing PSI protocols tailored for small sets. Those that exist are either restricted to interactions between two parties or necessitate resource-intensive homomorphic operations. To bring forth practical multiparty private set intersection solutions for small sets, we present two multiparty PSI protocols founded on the principles of Oblivious Key–Value Stores (OKVSs), polynomials, and gabled cuckoo tables. Our security analysis underscores the resilience of these protocols against malicious models and collision attacks. Through experimental evaluations, we establish that, in comparison to related endeavors, our protocols excel in small-set contexts, particularly in low-bandwidth wide area network (WAN) settings.

An efficient flattened index structure with lazy restructuring and hotness awareness

Hotspot issue is ubiquitous in the in-memory key-value stores, which seriously affects its performance. The efficiency of the index structure is the key to the performance of the in-memory key-value store, and the access of hotspot data must be through the search of the index structure. However, the existing index structures do not consider the hotspot issue, they treat and manage all the data equally, and cannot break through the performance bottleneck of the system. Index structures of type B＋-Tree are common in in-memory key-value stores, but the existing B＋-tree index structures do not consider the frequent structure change caused by node restructuring, which will seriously degrade the performance of the index structure. In this paper, we propose LH-Index, an efficient flattened index structure with lazy restructuring and hotness awareness. First, we use a search method combining linear search and binary search based on a partitioning strategy and endow nodes in LH-Index with a hotness awareness ability to search hotspot data quickly. Meanwhile, we use a lazy restructuring strategy for LH-Index to reduce the performance degradation due to frequent structure change. In addition, in order to meet the requirements of most scenarios, LH-Index is extended to DRAM/NVM hybrid memory by separate storage. Our evaluation shows that LH-Index achieves up to 1.85× search throughput and the lowest tail latency relative to other index structures under highly-skewed workloads, and it also has the highest throughput under mixed workloads.

Private Set Intersection Based on Lightweight Oblivious Key-Value Storage Structure

At this stage, the application of Private Set Intersection (PSI) protocols is essential for smart homes. Oblivious Key-Value Stores (OKVS) can be used to design efficient PSI protocols. Constructing OKVS with a cuckoo hashing graph is a common approach. It increases the number of hash functions while reducing the possibility of collisions into rings. However, the existing OKVS construction scheme requires a high time overhead, and such an OKVS applied to PSI protocols would also have a high communication overhead. In this paper, we propose a method called 3-Hash Garbled Cuckoo Graph (3H-GCG) for constructing cuckoo hash graphs. Specifically, this method handles hash collisions between different keys more efficiently than existing methods, and it can also be used to construct an OKVS structure with less storage space. Based on the 3H-GCG, we design a PSI protocol using the Vector Oblivious Linear Evaluation (VOLE) and OKVS paradigm, which achieves semi-honest security and malicious security. Extensive experiments demonstrate the effectiveness of our method. When the set size is 218–220, our PSI protocol is less computationally intensive than other existing protocols. The experiments also show an increase in the ratio of raw to constructed data of about 7.5%. With the semi-honest security setting, our protocol achieves the fastest runtime with the set size of 218. With malicious security settings, our protocol has about 10% improvement in communication compared with other existing protocols.

Learning to Optimize LSM-trees: Towards A Reinforcement Learning based Key-Value Store for Dynamic Workloads

LSM-trees are widely adopted as the storage backend of key-value stores. However, optimizing the system performance under dynamic workloads has not been sufficiently studied or evaluated in previous work. To fill the gap, we present RusKey, a key-value store with the following new features: (1) RusKey is a first attempt to orchestrate LSM-tree structures online to enable robust performance under the context of dynamic workloads; (2) RusKey is the first study to use Reinforcement Learning (RL) to guide LSM-tree transformations; (3) RusKey includes a new LSM-tree design, named FLSM-tree, for an efficient transition between different compaction policies -- the bottleneck of dynamic key-value stores. We justify the superiority of the new design with theoretical analysis; (4) RusKey requires no prior workload knowledge for system adjustment, in contrast to state-of-the-art techniques. Experiments show that RusKey exhibits strong performance robustness in diverse workloads, achieving up to 4x better end-to-end performance than the RocksDB system under various settings.

Cloud Key-Value Storage

The paper represents all the stages of designing, architecting, and developing cloud-based key-value storage. This work aims to bring new approaches to distributed data systems. The authors focus on the security and productivity of the project as well as security and maintainability. The authors have studied the use of hash tables in a multi-threaded environment. Architectural approaches and tools have been described. The general structure of the key-value storage server has been presented. The server algorithm has been presented. Our research delves into the intricate nuances of utilizing hash tables in a multi-threaded environment, shedding light on the intricacies and challenges of managing concurrent access to key-value data structures. The authors have explored the trade-offs between lock-free designs and traditional locking approaches.

K2vTune: A workload-aware configuration tuning for RocksDB

The explosive growth in data has triggered the emergence of NoSQL databases, which can be used to efficiently deal with unstructured and semi-structured data. RocksDB is a widely used persistent key–value store developed by Facebook to support high-throughput storage environments. It provides flexible configuration knobs that can be tuned to optimize performance. However, optimizing the RocksDB performance for specific workloads is challenging because the knobs have complicated inner relationships and different impacts according to workload type. In addition, RocksDB performance is measured using multiple metrics, such as latency and space amplification, which should be simultaneously considered. To address these issues, we designed a workload-aware configuration tuning framework called K2vTune, which can recognize the configuration knobs of RocksDB according to the workload type and effectively consider multiple performance metrics using our knob2vec method. The knob2vec method learns feature vectors for knobs that can capture both the latent relationships between knobs and workload-specific features to develop an attention neural network for accurate configuration-based performance prediction. K2vTune converts multiple metrics into a single problem and optimizes the problem using a genetic algorithm. We evaluated the proposed method using six different RocksDB workloads and confirmed that K2vTune achieved significant tuning performance improvement compared to baselines, showing 8.83% improvements over the state-of-the-art baseline.

The Design and Implementation of UniKV for Mixed Key-Value Storage Workloads

Persistent key-value (KV) stores are mainly designed based on the Log-Structured Merge-tree (LSM-tree), yet they suffer from large read and write amplifications, especially when KV stores grow in size. Existing design optimizations for LSM-tree-based KV stores often make certain trade-offs and fail to simultaneously improve both the read and write performance on large KV stores without sacrificing scan performance. We design UniKV, which unifies the key design ideas of hash indexing and the LSM-tree in a single system. Specifically, UniKV leverages data locality to differentiate the indexing management of KV pairs. It also develops multiple techniques (e.g., merge with partial KV separation, dynamic range partitioning) to tackle the issues caused by unifying the indexing techniques, so as to simultaneously improve the performance in reads and writes. Furthermore, it proposes a parallel optimization scheme to manage partitions in parallel and develops multiple strategies to optimize the scan performance. Experiments show that UniKV significantly outperforms several state-of-the-art KV stores (e.g., LevelDB, RocksDB, PebblesDB and Titan) in overall throughput under read-write mixed workloads.

Requirements and Trade-Offs of Compression Techniques in Key–Value Stores: A Survey

The prevalence of big data has caused a notable surge in both the diversity and magnitude of data. Consequently, this has prompted the emergence and advancement of two distinct technologies: unstructured data management and data volume reduction. Key–value stores, such as Google’s LevelDB and Meta’s RocksDB, have emerged as a popular solution for managing unstructured data due to their ability to handle diverse data types with a simple key–value abstraction. Simultaneously, a multitude of data management tools have actively adopted compression techniques, such as Snappy and Zstd, to effectively reduce data volume. The objective of this study is to explore how these two technologies influence each other. For this purpose, we first examine a classification of compression techniques and discuss their strength and weakness, especially those adopted by modern key–value stores. We also investigate the internal structures and operations, such as batch writing and compaction, in order to grasp the characteristics of key–value stores. Then, we quantitatively evaluate the compression ratio and performance using RocksDB under diverse compression techniques, block sizes, value sizes, and workloads. Our evaluation shows that compression not only saves storage space but also decreases compaction overhead. It also reveals that compression techniques have their inherent trade-offs, meaning that some provide a better compression ratio, while others yield better compression performance. Based on our evaluation, a number of potential avenues for further research have been identified. These include the exploration of a compression-aware compaction mechanism, selective compression, and revisiting compression granularity.

KVMod—A Novel Approach to Design Key-Value NoSQL Databases

The growth of structured, semi-structured, and unstructured data produced by the new applications is a result of the development and expansion of social networks, the Internet of Things, web technology, mobile devices, and other technologies. However, as traditional databases became less suitable to manage the rapidly growing quantity of data and variety of data structures, a new class of database management systems named NoSQL was required to satisfy the new requirements. Although NoSQL databases are generally schema-less, significant research has been conducted on their design. A literature review presented in this paper lets us claim the need to create modeling techniques to describe how to structure data in NoSQL databases. Key-value is one of the NoSQL families that has received too little attention, especially in terms of its design methodology. Most studies have focused on the other families, like column-oriented and document-oriented. This paper aims to present a design approach named KVMod (key-value modeling) specific to key-value databases. The purpose is to provide to the scientific community and engineers with a methodology for the design of key-value stores using the maximum automation and therefore the minimum human intervention, which equals the minimum number of errors. A software tool called KVDesign has been implemented to automate the proposed methodology and, thus, the most time-consuming database modeling tasks. The complexity is also discussed to assess the efficiency of our proposed algorithms.