redis

In cloud-native environments, mainstream in-memory key-value databases exhibit limitations in scalability, protocol compatibility, and long-term sustainability, while systematic empirical evaluations of emerging Redis alternatives remain absent. Method: This paper presents the first production-grade Kubernetes evaluation of Valkey, KeyDB, and Garnet, conducting multi-dimensional benchmarking—including throughput, P99 latency, and CPU/memory efficiency—alongside migration complexity analysis across containerized deployment, microservice integration, and data migration pathways. Contribution/Results: The study uncovers fundamental trade-offs among performance, ecosystem maturity, and operational maintainability, precisely delineating the applicability boundaries of each system under diverse workloads. It delivers the first empirically grounded, production-relevant evidence and actionable guidance for selecting in-memory data layer technologies in cloud-native architectures.

Modern distributed applications and cloud environments demand highly scalable, low-latency key-value (KV) stores. Method: This paper conducts a systematic, end-to-end empirical evaluation of three contemporary NoSQL KV databases—Redis, Aerospike, and Dragonfly—using the YCSB benchmark under read-heavy, write-heavy, and balanced workloads. We apply gradient stress testing across 1–32 concurrent clients and quantitatively analyze latency, throughput, and memory overhead. Contribution/Results: Our study is the first to empirically characterize performance trade-offs and scalability bottlenecks of these systems under high concurrency. Results show Dragonfly achieves superior write throughput; Aerospike delivers optimal memory efficiency and stable latency; Redis exhibits the lowest read latency at low concurrency. This work fills a critical gap in comparative, reproducible, fine-grained empirical assessment of mainstream modern KV stores, providing actionable, evidence-based guidance for production-grade technology selection.

This work addresses the high commit latency incurred when directly executing transactions on low-latency object storage systems—such as S3 Express One Zone—due to their decentralized logging mechanisms. To overcome this limitation, the paper proposes an in-memory OLTP engine specifically optimized for millisecond-level object storage. The design introduces a novel commit protocol, request-level optimizations, and a streamlined object access strategy, collectively reducing commit latency while preserving strong consistency, high availability, and durability. Experimental evaluation demonstrates that the proposed system significantly lowers latency compared to baseline approaches on standard benchmarks, all while sustaining high throughput.

Existing metadata catalogs (e.g., Hive Metastore, Iceberg, Delta Lake) face fundamental limitations in concurrent read/write throughput, strong consistency guarantees, and expressive query capabilities for hyperscale data systems. TreeCat addresses these challenges by introducing the first high-performance, purpose-built metadata catalog engine. It employs a hierarchical data model and a path-based query language; implements MVOCC—a multi-version optimistic concurrency control protocol ensuring serializable isolation; and pioneers an associative scan execution mechanism to accelerate metadata traversal and filtering. Its custom storage format is co-designed for efficient range queries and fine-grained version management. Experimental evaluation demonstrates that TreeCat delivers strict consistency under high concurrency while achieving up to 8.2× higher throughput for range queries compared to state-of-the-art systems, significantly outperforming existing solutions across key metadata management workloads.

To address the performance bottlenecks in insertion and random lookup throughput of key-value (KV) stores on flash-based SSDs under high-load workloads, this paper proposes a high-performance KV storage system co-designed with flash hardware characteristics. Our approach integrates log-structured storage, fine-grained hierarchical indexing aligned with flash page/block boundaries, asynchronous I/O scheduling, and an SSD-optimized memory-mapping mechanism—collectively reducing write amplification and enhancing I/O concurrency. The key innovation lies in synchronizing index updates with data writes while aligning index granularity precisely with flash physical units, thereby fully exploiting SSD parallelism and low-latency capabilities. Evaluated on a single datacenter server, the system achieves 19.8 M insertions/sec and 23.8 M random lookups/sec—outperforming state-of-the-art KV stores by 2–5× in throughput. It is particularly suited for high-concurrency applications such as caching, session management, and distributed systems.

This work addresses the challenge of reliably storing volatile data in MPI applications operating in environments prone to frequent hardware failures. The authors design and implement an elastic key-value store built upon MPI Remote Memory Access (RMA), leveraging MPI’s passive-target RMA for efficient one-sided data access. Fault detection is achieved through integration with Open MPI’s User-Level Failure Mitigation (ULFM) extension, while data and execution recovery are realized via redundant replicas maintained on surviving processes. This study presents the first systematic exploration of combining MPI RMA with ULFM for fault-tolerant storage, identifies critical missing features in current ULFM support for RMA, and proposes practical workarounds. Experimental evaluation of the prototype demonstrates the effectiveness and practicality of the proposed approach under realistic failure scenarios.

Existing non-volatile memory (NVM)-based key-value stores commonly lack support for modern database interfaces such as snapshots, consistent iterators, and atomic batch operations. To address this limitation, this work proposes and implements FlintKV, a skip-list-based NVM-optimized storage engine that natively supports a full production-grade transactional API while guaranteeing persistent linearizability. FlintKV achieves this through a novel concurrency protocol that integrates multi-version concurrency control with flat combining, leveraging byte-addressable NVM, custom persistence mechanisms, and highly efficient data structures. Experimental results demonstrate that FlintKV significantly enhances performance, achieving up to 75% higher end-to-end throughput compared to state-of-the-art alternatives. The system can be deployed standalone or integrated as a functional enhancement module into existing NVM-based storage systems.

This work proposes a serverless real-time data processing framework that integrates the MapReduce programming model with Function-as-a-Service (FaaS) to address the demand for efficient handling of massive, real-time data streams in modern logistics systems. Built on Kubernetes and Knative, the framework employs an event-driven architecture composed of five loosely coupled services for data ingestion, aggregation, and analysis. It leverages Apache Kafka for event transport, Redis for metadata management, and AWS S3 for durable storage. By innovatively combining MapReduce’s batch-processing semantics with FaaS’s elastic scaling capabilities, the system supports on-demand autoscaling and scale-to-zero functionality. Experimental results demonstrate that the proposed approach achieves low-latency processing while significantly improving resource efficiency, thereby fulfilling the requirements of highly elastic and highly available data pipelines.

This work addresses redundant I/O in distributed key-value stores caused by overlapping persistence operations between consensus protocols and storage engines, which limits performance. The authors propose an operation-level persistence strategy that deeply integrates log-structured merge (LSM)-style key-value separation into the Raft consensus protocol, eliminating redundant writes while preserving strong consistency. Key innovations include a co-designed architecture aligning Raft logs with key-value separation and a hierarchical garbage collection mechanism that balances safety and efficiency. Experimental results demonstrate significant performance improvements, with throughput gains of 460.2%, 12.5%, and 72.6% for Put, Get, and Scan operations, respectively.

This work proposes a production-oriented distributed rate-limiting architecture that balances precision, availability, and scalability in distributed systems. Built upon Redis sorted sets and a sliding window algorithm, the design leverages server-side Lua scripts to perform atomic operations, effectively eliminating concurrency contention while ensuring low latency and high accuracy. The system employs a three-tier rule management structure that enables dynamic updates to rate-limiting policies without requiring script modifications. Horizontal scalability and high availability are achieved through integration with Redis Cluster. Guided by the CAP theorem, the architecture explicitly adopts an AP model to prioritize practical engineering trade-offs between consistency and availability. Empirical deployment results demonstrate the system’s effectiveness, robustness, and scalability in real-world scenarios.