perf(storage): borrow values on read, make has_state skip snapshot reads, keep states in blob files

[MegaRedHand]

Motivation

On the Hoodi follower, the import guard's has_state(parent) check costs 0-1 ms on most blocks but p50 180 ms, p90 332 ms, max 536 ms on the block after each epoch's first block (48h of import timings, 10-03 to 10-05):

slot % 32	guards p50	guards p90
0	0 ms	1 ms
1	180 ms	332 ms
2	0 ms	177 ms (when slot 1 is empty)
3..31	0 ms	1-8 ms

An epoch-crossing block's state is stored as a full snapshot only, and has_state did get(States) on it: RocksDB read and copied the whole ~150 MB state to answer a yes/no question, although that state was still in the store's state cache. On Plataberget the same function costs ~30 ms on every block, since States has no bloom filter and a miss still reads a snapshot-sized data block per L0 file.

Changes

1. has_state is an existence check. It consults the state cache (peek, so the LRU order is untouched), then StateDiffs before States, through contains, and never copies a value. A cached BlockState always means the state is pending or persisted, and nothing deletes a persisted state, so the answer is unchanged.
2. StorageReadView::read is the one required lookup. It lends the value to a &mut dyn FnMut(&[u8]) callback, which keeps the trait usable as dyn StorageReadView. get and contains are default methods on top of it, so both backends implement read only. RocksDB uses get_pinned_cf.
3. Decodes read from the backend's buffer. StorageReadViewExt::read_with decodes inside the borrow, and every get-then-decode site uses it. Beacon state reconstruction folds its deltas while the snapshot is still borrowed and hands the result over as a Cow: a snapshot root decodes straight from RocksDB's buffer, and the writer's parent-bytes path takes ownership without a second copy. get(..).is_some() checks became contains. get stays where the bytes outlive the read (the beacon walk's delta records, the pending-column take) and for the stored config, which must not be decoded before the version and preset checks.
4. States and StateDiffs use RocksDB blob files.

setting	value	why
min_blob_size	4 KiB	one default data block; anything larger gets an oversized block anyway
blob compression	LZ4	blob files default to none, while SST blocks get Snappy; the values are raw SSZ
blob GC	off	nothing deletes or overwrites a state, so GC would only relocate live blobs
blob cache	none	the store caches decoded states, and a snapshot-sized entry would evict the whole block cache

Compatibility

No DB_VERSION bump. RocksDB applies the blob options to an existing directory as it goes: new writes land in blob files, and inline values move out as compaction rewrites their SSTs. a_directory_written_without_blob_files_still_reads opens a directory written with plain options and reads both old inline and new blob values. estimate_table_bytes now adds rocksdb.live-blob-file-size, which estimate-live-data-size leaves out, so the table-size metric keeps counting state bytes.

Testing

• New tests: has_state on cached, diff, snapshot-only and absent roots, through a counting backend that proves the cached path reads neither table; read on both backends (value, absent key, callback error); a cold-cache beacon reconstruction across a whole snapshot interval; blob placement and the pre-blob directory.
• cargo test --workspace --profile release-fast --lib --bins: 0 failures. Clippy -D warnings clean.
• Spec-test suites not run locally.

Not covered

• A bloom filter on States: blob files make misses cheap here, but other large-value tables still have none.
• The live effect on guards: worth re-measuring on a follower after deploy.

[github-actions]

🤖 Claude Code Review

Review: RocksDB blob files for States and StateDiffs

The change is small and well scoped. The code is in crates/storage/src/backend/rocksdb.rs. I found nothing blocking. Nothing was compiled or run here. I read the code and the two new tests.

What's good

• Enabling blob files per column family only for States and StateDiffs is targeted. MIN_BLOB_SIZE of 4 KiB is a reasonable threshold.
• LZ4 for blobs avoids the on-disk growth you'd get from RocksDB's default of no blob compression. The comment explains this.
• Reads go through the normal get/contains paths, so StorageReadView needs no changes.
• Existing directories open unchanged, so skipping a DB_VERSION bump is sound. a_directory_written_without_blob_files_still_reads covers it.
• estimate_table_bytes now adds rocksdb.live-blob-file-size. Without that, the metric would drop to almost nothing for these tables.

Points to consider (minor)

1. "Nothing deletes a state" assumption (rocksdb.rs:52-55). A grep of store.rs found no delete_batch on States or StateDiffs, so the assumption holds today. It is only a code comment, though. If state pruning is added, blob files would grow without bound until blob GC is enabled (set_enable_blob_gc). Consider a pointer to this from wherever state pruning would live, or from docs/data_storage.md. The "Revisit" comment partly covers it.
2. Compaction behaviour for existing directories. The doc comment says inline values move out "as compaction rewrites their SSTs". That happens lazily. A node upgraded in place will keep reading snapshot-sized data blocks from old SSTs until compaction reaches them. The has_state miss cost the PR targets therefore won't improve immediately on upgraded nodes. This is worth noting in the release notes, or a one-off compact_range_cf could be offered.
3. Blob file sizing. blob_file_size is left at the RocksDB default of 256 MiB. With 100+ MB snapshots that is fine. Checking that no tuning is needed for small-chain (lean) states is optional.
4. Test coverage. large_state_values_live_in_blob_files asserts num-blob-files == 1 after each flush. That depends on the default flush behaviour producing exactly one blob file per flush. It looks deterministic here (one key, one flush). Just be aware it would be brittle if blob-file sizing options change.

Verdict: Looks good. The only follow-up I'd suggest is to document the no-GC assumption (Point 1) and the lazy migration (Point 2).

---

Automated review by Claude (Anthropic) · sonnet · custom prompt

[github-actions]

🤖 Kimi Code Review

I'll review this PR which introduces zero-copy reads and RocksDB blob file optimization for large state values.

Summary

This is a well-architected performance PR that:

1. Replaces get() -> Vec<u8> with read() -> callback with borrowed bytes to eliminate copies for large state snapshots
2. Adds RocksDB blob files for States/StateDiffs tables to reduce compaction overhead
3. Optimizes has_state to use cache-aware existence checks without value materialization

---

Issues Found

1. Panic Safety in read_with — crates/storage/src/api/traits.rs:45-46

let decode = decode.take().expect("read calls read_fn at most once");

Problem: This expect is a correctness assumption about all implementors. A buggy StorageReadView implementation that calls read_fn twice will panic.

Suggestion: Consider a defensive fallback or document this as an explicit contract. For a consensus client, panics on storage paths are concerning. At minimum, add a debug assertion in test builds:

#[cfg(debug_assertions)]
if decode.is_none() {
    return Err(Error::Backend("read_fn called multiple times".into()));
}

Or change read_with to return Result<Option<T>, Error> with a proper error variant.

---

2. Potential Double-Panic in InMemoryReadView::read — crates/storage/src/backend/in_memory.rs:69-77

fn read(...) -> Result<bool, Error> {
    let Some(value) = self.guard.get(&table).expect("table exists").get(key) else {
        return Ok(false);
    };
    read_fn(value)?;  // If this panics, the RwLockReadGuard is poisoned
    Ok(true)
}

Problem: If read_fn panics, the RwLockReadGuard is poisoned. Subsequent accesses will panic on lock() calls elsewhere. This is acceptable for InMemoryBackend (test-only), but document it.

Verdict: Acceptable for test backend, but consider std::panic::catch_unwind if this were production storage.

---

3. RocksDB Blob File Compression Choice — crates/storage/src/backend/rocksdb.rs:34-40

cf_opts.set_blob_compression_type(DBCompressionType::Lz4);

Problem: The comment says "SST blocks get RocksDB's default Snappy, but blob files default to no compression." However, DBCompressionType::Lz4 is used, not Snappy. This is actually a good choice (LZ4 is faster than Snappy at similar ratios), but:

• Inconsistency: SSTs use Snappy, blobs use LZ4. Decompression path now has two codecs.
• Portability: LZ4 requires the lz4 feature in rust-rocksdb. Verify Cargo.toml has this enabled.

Check: Ensure Cargo.toml contains:

rocksdb = { version = "...", features = ["lz4"] }

Without this, compilation fails or falls back to no compression silently depending on rust-rocksdb version.

---

4. get_pinned_cf Lifetime — crates/storage/src/backend/rocksdb.rs:163-168

let Some(value) = self.db.get_pinned_cf(&cf, key)? else {
    return Ok(false);
};
read_fn(&value)?;
Ok(true)

Problem: DBPinnableSlice (the return type of get_pinned_cf) is dropped at the end of the let Some(...) scope, but read_fn is called synchronously within that scope. This is correct.

However: If read_fn were to leak the reference (e.g., via std::mem::forget or send to another thread), this would be UB. The &mut dyn FnMut bound prevents Send, but std::mem::forget is still possible.

Verdict: Acceptable — the API contract is clear and read_fn is synchronous.

---

5. reconstruct_beacon_state_bytes Complexity — crates/storage/src/state_writer.rs:264-295

The closure-capture pattern with Option<impl FnOnce> inside a loop is clever but fragile:

let mut consume = Some(consume);
// ...
let folded = view
    .read_with(Table::States, &key, |snapshot| {
        let consume = consume.take().expect("the walk ends at its first snapshot");
        // ...
        fold_beacon_state_deltas(snapshot, &records, consume)
    })

Problem: If the loop exits via return Ok(None) (missing diff), consume is never called — this is correct (returns None). But the expect message is misleading: it's not that "the walk ends at its first snapshot," it's that we expect the walk to end at a snapshot. If there's a bug where States has a key but read_with returns None (impossible with current impl), this panics.

Suggestion: The expect is actually unreachable because read_with returns Some(T) iff the key exists. But consider making this more explicit:

let Some(folded) = folded else {
    // Key existed but read_with returned None — impossible per API
    unreachable!("read_with returned None for existing key");
};

Actually, re-reading: read_with returns Result<Option<T>>, so folded is Option<T>. If key exists, read_with returns Ok(Some(T)). The if folded.is_some() check is correct.

---

6. has_state Cache Check Race — crates/storage/src/store.rs:2694-2705

if self.pending_states.get(root).is_some() {
    return Ok(true);
}
// ...
if self.state_cache.lock().unwrap().peek(&CacheKey::BlockState(*root)).is_some() {
    return Ok(true);
}

Problem: pending_states is checked before state_cache. If a state is in pending_states being written, and has_state returns true, but then the write fails/rolls back, subsequent get_state calls may return None. This is pre-existing behavior, not new in this PR.

New Issue: The peek check avoids LRU reordering, but pending_states.get() may reorder its underlying structure. What is pending_states? If it's a HashMap, no reordering. If it's an LRU, same concern applies.

---

7. Test has_state_does_not_reorder_the_state_cache Fragility — crates/storage/src/store.rs:5415-5428

for root in [first, second] {
    let state = BeaconState::Lean(sample_state(1, H256::ZERO, vec![]));
    store.cache_state(CacheKey::BlockState(root), Arc::new(state));
}
assert!(store.has_state(&first).expect("has_state"));
let cache = store.state_cache.lock().unwrap();
let (lru_key, _) = cache.iter().next_back().expect("non-empty");
assert_eq!(*lru_key, CacheKey::BlockState(first));

Problem: This test assumes cache.iter() yields LRU order. The lru crate's iter() yields from most-recent to least-recent (or reverse). next_back() gets least-recent. After cache_state(first) then cache_state(second), order is [second, first] (MRU to LRU). next_back() → first. After has_state(&first) with peek, order should remain [second, first]. This test verifies peek behavior.

However: If cache_state promotes on duplicate insert, this could change. The test is correct for current behavior but tightly coupled to lru crate internals.

---

8. Missing StorageReadViewExt Import in lib.rs — Already Fixed

The pub use addition is correct and complete.

---

Consensus-Critical Concerns

9. SSZ Decode from Borrowed Bytes — Multiple Locations

All read_with calls decode SSZ directly from backend buffers:

view.read_with(Table::BlockHeaders, &key, |bytes| {
    BlockHeader::from_ssz_bytes(bytes).expect("valid header")
})

Risk: If RocksDB's get_pinned_cf returns aliased memory (e.g., due to mmap or cache eviction during read), this is undefined behavior. However, DBPinnableSlice pins the value in RocksDB's block cache for its lifetime, so this is safe.

Verification: Confirmed — rocksdb::DBPinnableSlice holds a reference-counted pin on the source block.

---

10. fold_beacon_state_deltas Memory Amplification — crates/storage/src/state_writer.rs:305-320

fn fold_beacon_state_deltas<T>(...) -> T {
    // ...
    let mut bytes = beacon_state_delta::decode(delta, snapshot, target_len as usize);
    for record in records {
        bytes = beacon_state_delta::decode(delta, &bytes, target_len as usize);
    }
    consume(Cow::Owned(bytes))
}

Problem: Each decode allocates a new Vec<u8>. For interval deltas (default 32 epochs × 32 slots = 1024 slots on mainnet), this could allocate ~100MB × 1024 = 100GB temporaries if not optimized.

However: The comment notes this is "the whole cost that delta layer exists to avoid" compared to per-hop SSZ decode. The actual beacon_state_delta::decode likely reuses or incrementally builds — verify target_len is the final size, not per-delta growth.

Check: beacon_state_delta::decode signature and implementation should be reviewed separately. The PR's approach is correct (single final decode), but the intermediate bytes growth should be confirmed bounded.

---

Minor Issues

11. Documentation Inconsistency — docs/data_storage.md:72

| `RocksDBBackend` | ... `States` and `StateDiffs` keep values of 4 KiB and up in LZ4-compressed blob files ... |

The MIN_BLOB_SIZE is 4 * 1024 = 4096 bytes, but the comment in code says "4 KiB and up" — correct. However, the threshold is actually >= 4 KiB or > 4 KiB? RocksDB's set_min_blob_size uses >= semantics per RocksDB docs. Clarify if exact.

---

12. Redundant drop(view) Calls Removed — Good

The PR correctly removes drop(view) calls where the view's lifetime is naturally bounded by the enclosing scope. This is cleaner.

---

Positive Acknowledgments

1. Zero-copy design is correct: The &mut dyn FnMut trait object approach preserves dyn usability while avoiding monomorphization bloat.
2. Blob file integration is well-reasoned: Comments explain why no GC, no blob cache, and LZ4 compression.
3. has_state optimization is significant: Avoids 100MB+ copies for existence checks on snapshot-only states.
4. Backward compatibility handled: Existing databases without blob files open correctly; new writes use blobs.
5. Test coverage is thorough: Including the counting backend to verify zero-copy paths.

---

Final Verdict

Severity	Count	Items
Must Fix	1	Verify rocksdb crate has lz4 feature enabled (Item 3)
Should Fix	1	Defensive handling for read_fn multi-call in read_with (Item 1)
Nice to Have	2	Documentation clarity on blob threshold; fold_beacon_state_deltas temp allocation audit
Informational	4	Remaining items

The PR is well-architected, correctly implements zero-copy reads, and the RocksDB blob optimization is appropriate for consensus state storage. The main action item is confirming the lz4 feature flag.

---

Automated review by Kimi (Moonshot AI) · kimi-k2.6 · custom prompt

[github-actions]

🤖 Codex Code Review

Looks good overall. The PR’s direction is solid: read/read_with removes avoidable copies on large state reads, has_state avoids materializing snapshots for existence checks, and the added cold-read tests cover the new reconstruction path well.

• No correctness bug stood out in fork choice / attestation / justification logic because this PR stays in storage-state access paths, and the Store::get_state API still delegates to the same reconstruction logic in read_state (crates/storage/src/store.rs:2644, crates/storage/src/state_writer.rs:269).
• The RocksDB get_pinned_cf change is idiomatic and safe here because the borrowed slice never escapes read_fn (crates/storage/src/backend/rocksdb.rs:154).
• Performance-wise this is a meaningful win for large States / StateDiffs, especially the new contains fast path in has_state (crates/storage/src/store.rs:2691) and blob-file storage for large values (crates/storage/src/backend/rocksdb.rs:27).

One thing I would change:

• Store::has_state now panics on backend read errors instead of propagating them. The function returns Result<bool, Error>, but it uses begin_read().expect("read view") and contains(...).expect("contains") (crates/storage/src/store.rs:2712, crates/storage/src/store.rs:2716). If RocksDB returns an error or a backend implementation fails, this turns a recoverable storage failure into a process abort. In consensus code, especially around block import/fork choice gating, that is a real availability risk. I’d strongly prefer:
  • let view = self.backend.begin_read()?;
  • Ok(view.contains(Table::StateDiffs, &key)? || view.contains(Table::States, &key)?)

Aside from that, I don’t see a security or memory-safety issue in the diff. The tests added around cache non-promotion and diff-first existence checks are especially helpful (crates/storage/src/store.rs:5396, crates/storage/src/store.rs:5427).

---

Automated review by OpenAI Codex · gpt-5.4 · custom prompt