What is the fundamental trade-off between Leveled Compaction (LCS) and Size-Tiered Compaction (STCS) in LSM-trees?

The design of Log-Structured Merge-tree (LSM-tree) storage engines (RocksDB, Cassandra, ScyllaDB) is governed by the RUM Conjecture (Read, Update, Memory/Space overhead). Leveled Compaction Strategy (LCS, default in RocksDB) prioritizes READ performance and SPACE efficiency: SSTables within each level (L1, L2, ...) have non-overlapping key ranges, meaning a point lookup visits at most ONE SSTable per level. Space amplification is minimal (~1.1x to 1.2x). However, this comes at the cost of high Write Amplification Factor (WAF, typically 15x to 35x) because data is rewritten multiple times as it cascades down levels. In contrast, Size-Tiered Compaction Strategy (STCS, default in Cassandra) prioritizes WRITE throughput: incoming SSTables are grouped into tiers of similar sizes and merged together, achieving low WAF (4x to 8x). However, key ranges overlap heavily across SSTables, degrading read performance and causing catastrophic Space Amplification (requiring up to 50% free disk headroom during large tier compactions).

What causes Write Stalls in RocksDB and how do L0 file counts trigger backpressure on incoming writes?

In RocksDB, incoming writes append to an in-memory SkipList (MemTable) and the WAL. When a MemTable reaches write_buffer_size, it freezes and is flushed to Level 0 (L0) on disk. Because L0 files are direct dumps of MemTables, their key ranges overlap. If client write throughput exceeds the speed at which background threads can compact L0 files down into L1, L0 file count accumulates rapidly. To prevent read amplification from exploding (since point reads must check every L0 file), RocksDB applies progressive Write Stalls: (1) When L0 files hit level0_slowdown_writes_trigger (default 20), RocksDB artificially injects microsecond sleep delays into client write calls; (2) When L0 files hit level0_stop_writes_trigger (default 36), RocksDB completely halts all incoming writes until background compaction drains the backlog.

Why does Size-Tiered Compaction require 50% free disk space to operate safely without out-of-disk crashes?

Under Size-Tiered Compaction (STCS), when four SSTables in a tier reach similar sizes (e.g. four 50 GB files totaling 200 GB), the compaction thread begins merging them into a single 200 GB SSTable. Because the original four files cannot be deleted until the new merged file is completely written, fsynced, and atomic directory metadata is updated, the storage engine temporarily requires 200 GB + 200 GB = 400 GB of total disk space. If a disk is 60% full, triggering a major tier compaction will immediately run out of disk space, crashing the database node. Systems running STCS must maintain a hard rule of never allowing disk utilization to exceed 50%.

How do Prefix Bloom Filters optimize range queries on composite primary keys in RocksDB?

Standard Bloom filters hash the entire full key (e.g. user_id:timestamp). While highly effective for point lookups (Get(key)), a standard Bloom filter cannot assist range scans (Iterator::Seek(prefix)) because the hash of "user_123:*" is completely unrelated to the hash of "user_123:1700000000". RocksDB Prefix Bloom Filters resolve this through a SliceTransform extractor: the engine hashes only the prefix portion of the key (user_id) into the Bloom filter. When an application executes Seek("user_123"), the iterator queries the Prefix Bloom filter first: if the prefix is absent from an SSTable, RocksDB skips reading the data blocks from disk entirely. This transforms expensive table-scanning range queries into single-I/O operations.

What is the mathematical formula for optimal Bloom filter bits-per-key and how does it affect false-positive rates?

The optimal number of bits m for n keys given a target false-positive probability p is derived from: m / n = -ln(p) / (ln 2)^2 ≈ -1.44 * log2(p). For example: (1) At 10 bits per key, the false-positive rate is approximately 1.0% (99% of non-existent key lookups avoid disk I/O); (2) At 14 bits per key, the false-positive rate drops to ~0.1% (99.9% filter efficacy); (3) Increasing beyond 16 bits yields diminishing returns while bloating the Block Cache footprint. In memory-constrained deployments, allocating 10 bits per key achieves the optimal balance between RAM consumption and disk I/O reduction.

When should an architecture use FIFO Compaction instead of Leveled or Size-Tiered compaction?

FIFO (First-In, First-Out) Compaction is designed specifically for immutable time-series data, telemetry metrics, and append-only logs with fixed Time-To-Live (TTL) retention (such as Prometheus TSDB or Kafka-like storage). FIFO compaction never re-sorts or merges SSTables down multiple levels. When total database size exceeds max_table_size_sum, FIFO simply unlinks and deletes the oldest SSTable on disk. Because data is written exactly once and never rewritten, Write Amplification Factor is strictly 1.0 (zero compaction write overhead), and SSD flash endurance is extended by 20x to 30x compared to Leveled compaction.

LSM-Tree Advanced: Leveled vs Tiered Compaction, Bloom Filters & Write Stall Studio

Verified Specification | Standardized Formulas | Instant Precision

Secure & Private (Zero Data Retention) Free Access • No Sign-Up

RocksDB / Cassandra / ScyllaDB Leveled vs Tiered Compaction Write Stall Mitigation Prefix Bloom Filter Math

LSM-Tree Advanced: Compaction, Bloom Filters & Write Stall Studio

Simulate Leveled (LCS) vs Size-Tiered (STCS) vs FIFO compaction dynamics, calculate Write Amplification Factor (WAF) and disk space overhead, model L0 backlog write stall throttling, and size optimal Prefix Bloom Filter bits-per-key.

100% Client-Side Engine

Compaction Strategy Parameters

Compaction Architecture

Total Data Ingested (GB)

250 GB

Level Size Multiplier (max_bytes_for_level_multiplier)

Amplification & Resource Telemetry

Write Amplification (WAF)

22.5x

Bytes written to flash / Ingested

Space Amplification

1.12x (280 GB)

Disk usage vs logical dataset

Level 0 Accumulation & Throttle Triggers

Active Level 0 (L0) SSTable File Count

12 Files

Slowdown Trigger (level0_slowdown_writes_trigger)

Hard Stop Trigger (level0_stop_writes_trigger)

Write Backpressure & Latency Impact

Ingest Throttle Rate

100% (No Delay)

Full client throughput

Injected Sleep Penalty

0 μs

Zero write stall delay

Bloom Filter Configuration Math

Target Total Keys in Database e.g. 100 Million Keys

Allocated Bits Per Key (m/n)

10 bits

LSM-Tree Advanced: Compaction, Bloom Filters & Write Stall Studio

Compaction Strategy Parameters

Amplification & Resource Telemetry

Level 0 Accumulation & Throttle Triggers

Write Backpressure & Latency Impact

Bloom Filter Configuration Math

False Positive Probability & RAM Footprint

Production Database Compaction Configs

LSM-Tree Advanced: Compaction, Bloom Filters & Write Stall Studio

Compaction Strategy Parameters

Amplification & Resource Telemetry

Level 0 Accumulation & Throttle Triggers

Write Backpressure & Latency Impact

Bloom Filter Configuration Math

False Positive Probability & RAM Footprint

Production Database Compaction Configs

🔍 Companion Workbenches & Verification Tools

Apache Iceberg & Parquet Columnar Lakehouse Storage Studio

Linux eBPF CO-RE & BTF Field Offset Relocation Studio

URL Parser & Query String Parameter Inspector

WebAssembly Linear Memory, Heap Paging & Detached Buffer Architecture Studio

Why Smart Users Are Switching to This Free Toolkit

The Browser Feature Most People Never Use

Stop Paying for Software You Can Get Free

File Conversion Tricks That Save Hours Every Week

This Free Tool Replaced 5 Paid Apps for Our Team

What Your Browser Can Do Without Any Extensions