FAST '27 Spring Accepted Papers

Computational storage devices (CSDs) promise to reduce host--storage data movement by executing computation inside the storage device. This is especially appealing for LSM-tree-based key--value stores, whose reads and background maintenance move large amounts of data through the host. In practice, however, in-storage LSM-tree operations often fail to deliver their full benefit. Existing CSDs largely follow a host-managed, copy-then-execute model that drives in-storage operators through synchronous or weakly overlapped I/O paths. This serializes compute-flash interactions, underutilizes device-side compute resources, and forces host storage software to handle complex coordination logic. As a result, the expected benefits of in-storage processing are often limited or even negated on realistic workloads.

We argue that the missing abstraction is asynchronous execution with device-resident dependency management. We present FLAX, a computational storage architecture that makes asynchronous, overlapped in-device I/O execution a first-class design goal for LSM-tree operations. FLAX tracks fine-grained dependencies inside the device, allowing the host to issue large batches of work while the CSD schedules and executes commands asynchronously. To further improve utilization, FLAX combines adaptive data loading with dynamic on-device buffer management, enabling higher concurrency under limited device resources. We integrate FLAX into RocksDB and offload both compaction and reads. FLAX improves throughput by up to 3.1× over host-only execution and 1.8× over a host-managed CSD baseline.

Heterogeneous cloud storage relies on tiering to balance performance and cost. However, intra- and inter-node tiering face three major challenges: limited flexibility in redundancy and scaling; excessive disk and network traffic amplification; inefficiency in handling small I/Os. We propose ByteTier, a pool-based tiering system. Based on decoupled performance and capacity pools, ByteTier designs a cross-pool two-phase write mechanism: writes are cached and stored in the performance pool in the foreground, and re-encoded from the cache to the capacity pool in the background, providing flexibility and reducing disk and network overhead. Within this mechanism, ByteTier performs a workload-aware I/O aggregation method, adaptively merging small writes and batching them into device-friendly patterns to enhance throughput and reduce latency. ByteTier has been deployed in production at ByteDance for three years, serving diverse workloads. Evaluation shows that it significantly reduces both average and P99 write latency while improving write and read throughput.

Fail-slow failures, characterized by prolonged performance degradation without complete system crashes, pose a significant threat to the reliability of large-scale cloud storage systems. However, the scarcity of high-quality labeled datasets limits the development of effective detection and diagnosis techniques, while manual labeling at cloud scale is labor-intensive and error-prone. In this paper, we present SlowSight, a novel tool designed to enable efficient and accurate labeling of fail-slow failures in cloud environments. SlowSight employs a multi-view framework that jointly models temporal deviations of individual components and behavioral divergence among peer components. To reduce spurious detections, a knowledge-driven filtering module removes anomaly candidates inconsistent with fail-slow meanings. Furthermore, SlowSight adopts pattern-centric aggregation to capture multi-metric degradation patterns and propagate consistent labels across similar anomaly instances, improving labeling accuracy and consistency. We deploy and evaluate SlowSight at Huawei Cloud on two production-scale disk fail-slow datasets, achieving F₁-scores of 0.851 and 0.903, and on a fail-slow dataset generated via failure injection with an F₁-score of 0.945, demonstrating its effectiveness and generalizability. To the best of our knowledge, SlowSight is the first framework designed for scalable fail-slow failure labeling in cloud storage systems. Additionally, we have publicly made the code available to facilitate further research.

Buffered I/O is the dominant storage interface, but its synchronous and monolithic write path limits performance for write-intensive applications. Prior work either applies narrow optimizations to individual steps of the write path or adopts asynchronous designs that require application changes.

In this paper, we present PipeBWrite, a transparent buffered write scheme that retains the synchronous interface while extracting the performance benefits of asynchronous execution. Based on data dependency analysis, PipeBWrite decomposes buffered writes into a two-stage pipeline: the foreground thread performs only the critical data copy needed for immediate user-buffer reuse, while non-critical kernel bookkeeping is offloaded to background threads. To ensure correctness, PipeBWrite introduces a lightweight inter-request visibility tracker that preserves POSIX semantics despite decoupled execution. It also employs holistic optimizations, including adaptive allocation, inline zeroing, and request batching, to minimize coordination overhead. PipeBWrite is implemented in the Linux Virtual File System layer and requires no application changes. Across four applications with the ext4 and XFS filesystems, PipeBWrite improves throughput by up to 25% for RocksDB and 21% for Kafka over vanilla Linux and StreamCache. For FIO synthetic workloads, it achieves up to 2.34× higher throughput and reduces write latency by up to 58%.

Content-defined Chunking (CDC) algorithms are critical to data deduplication and can be categorized into two families: hash-based and hashless. Hashless chunking algorithms are faster than their hash-based counterparts, especially when accelerated using the Single Instruction Multiple Data (SIMD) capabilities of modern CPUs. However, they achieve lower deduplication space savings on certain datasets.

We present WideCDC, a technique to improve the deduplication efficiency of hashless CDC algorithms by using wide regions of multiple bytes to determine chunk boundaries instead of individual bytes. Existing SIMD acceleration techniques for hashless CDC miss chunk boundaries when using wide regions, as they do not account for overlaps. To address this while preserving performance, WideCDC uses novel Accumulated Extreme Byte Searches and Gated Range Scans. By evaluating WideCDC on real-world datasets, we show that it improves the deduplication ratios of hashless chunking algorithms up to 2.95× while achieving 2.04× higher chunking throughput than existing vector-accelerated techniques.

Modern distributed databases frequently rely on key-value storage engines as durable backends for replicated state machines. While prior work extensively studies storage engine internals, far less attention has been given to the system-level constraints that arise when such engines are deployed at scale under strict resource limits. In production, storage design directly impacts tail latency, availability, recovery time, and multi-tenant stability.

This paper presents operational insights from running a log-structured merge-tree (LSM-tree)-derived key-value engine as the storage foundation of eBay's cloud-native distributed database, which serves trillions of requests per day. We describe practical challenges and operational responses in snapshot binding and installation, scan overhead caused by visibility checks and predicate evaluation, CPU-constrained compaction, write amplification and noisy-neighbor effects in multi-tenant environments, and programmable compaction for unified maintenance. These experiences show that when the storage layer underpins a distributed database, priorities shift from peak throughput to latency stability, predictable recovery, and bounded background work. Some mechanisms in our system rely on properties of our storage engine, but the underlying integration lessons are more broadly applicable to replicated database deployments.

HTAP systems increasingly need to support analytics over fresh transactional data. In row-columnar HTAP architectures, this raises a visibility-management problem: analytical queries must observe the latest updates. Addressing this, existing designs struggle with a three-way tradeoff among transactional update throughput, analytical scan efficiency, and memory overhead.

This paper presents CakeMask, a visibility-management design for fresh-data HTAP. To balance performance and memory overhead, CakeMask preserves bitmap as the compact, scan-efficient base visibility representation, while moving recent visibility changes into a delta visibility layer to avoid concurrent update overhead on the bitmap. It further combines an LSM-inspired delta structure, an optimized concurrent B+ tree with non-blocking scans, optimized bitmap–delta merging via vectorization, parallelism, and caching, and dynamic consolidation to bound long-term scan overhead. We implement CakeMask in a commercial cloud HTAP database and evaluate it on diverse workloads. The results show that CakeMask delivers scan performance comparable to in-memory version array at 1.6% of its memory usage, and outperforms existing on-disk visibility-management solutions up to 79× in write throughput. CakeMask has been deployed in production in a commercial HTAP system and has been validated on real-world workloads over three years.

Time series databases (TSDBs) are crucial for performance monitoring in Internet applications and infrastructure. As the scale of time series grows, the storage overhead of metadata (labels) and data points (samples) increases significantly. In spite of prior efforts in hybrid storage to reduce storage costs, they still require large-capacity, expensive, high-bandwidth storage devices to deliver superior performance.

We propose PromTCS, which introduces two novel techniques: (1) Two-dimensional metadata management. We propose a two-dimensional metadata model and a suite of indexes to reduce metadata overhead while ensuring high performance. (2) Tailored hybrid storage architecture. We place hot data on DRAM and NVMe SSDs and cold data on HDDs, and present three optimizations: (i) a compaction-free time series storage engine for NVMe SSDs, TreeSeries, to reduce write amplification (WA) and optimize performance; (ii) hardware-aware write strategies, early migration and lazy flushing, to mitigate the adverse impact of bandwidth cross-tier bandwidth gaps; and (iii) a metadata-driven parallel write-ahead logging (WAL) on SSD, to reduce thread contention during writes and shorten crash recovery time. We implement a PromTCS prototype and evaluate it on synthetic and real-world datasets using both benchmark and production workloads. Compared with advanced TSDBs on pure NVMe SSDs, PromTCS achieves comparable performance at much lower deployment cost. Under the same hybrid storage, it delivers 3.2--5.9× higher insertion throughput and 38.1%--82.1% lower query latency than the advanced TSDBs.

With the rise of NVMe SSDs, the performance gap between random and sequential I/O has narrowed, renewing interest in B+-tree-based key-value stores (KVSs) for modern data systems. In larger-than-memory B+-tree KVSs, performance critically depends on cache eviction decisions. However, existing page-cache eviction policies treat each page independently using only its own access history. As a result, they fail to exploit subtree-level hotness arising from key-range locality or preserve accumulated history across out-of-place updates, causing pages in hot subtrees to be misclassified and prematurely evicted. We observe that B+-tree operations naturally expose lightweight, address-independent signals for subtree hotness and future page invalidation. Based on these insights, we propose TreePass, a lightweight caching system that augments CLOCK eviction with per-pivot counters embedded in the B+-tree. With these counters, TreePass performs early eviction of cold-subtree pages and differentiated reference-counter initialization for newly created pages, suppressing unnecessary writebacks without additional metadata. We implement TreePass in SplinterDB and evaluate it across YCSB and real-world workloads. Across all evaluated workloads, TreePass achieves up to 101% higher throughput, 70% fewer page writes, and 15% lower P99 tail latency than state-of-the-art caching policies.