perf(v8): memoize the snapshot cache key instead of re-digesting per exec

`snapshot_cache_key` SHA-256s the bridge bundle (~2.5 MB) plus the userland
bundle. Both are process-lifetime constants, and every execution derives the key
four times: the snapshot-cache lookup, the warm-worker pool key on the pre-warm
path, and again on the claim path inside session creation. Each digest measured
~7 ms, so a warm guest exec spent ~28 ms hashing two strings that never change —
the flat ~14 ms "snapshot-ready/pre-warm handshake" and the flat ~14 ms
"JS execution dispatch" on the launch path were almost entirely this.

Memoize by content: a bounded process-wide table keyed on full equality of the
bridge and userland text. A memcmp over the same bytes is ~35x cheaper than the
digest, and content equality means a lookup can only return the key of a bundle
byte-identical to the one asked for, so the memo is indistinguishable from
recomputing and cannot surface another caller's bundle. Also hash the two inputs
as streaming updates rather than concatenating them into a fresh 2.8 MB buffer
first; the digest is unchanged.

Sidecar phases for a warm `sh -c "echo x"`: snapshot-ready + pre-warm handshake
14.0 -> 0.3 ms, JS execution dispatch 14.3 -> 0.5 ms, execution finish
28.5 -> 1.1 ms.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: 2 people

crates/v8-runtime/src/snapshot.rs

@@ -3,7 +3,7 @@
 use std::collections::HashMap;
 use std::io::{Read, Write};
 use std::process::{Command, Stdio};
-use std::sync::{Arc, Condvar, Mutex};
+use std::sync::{Arc, Condvar, Mutex, OnceLock};
 
 use sha2::{Digest, Sha256};
 
@@ -746,26 +746,77 @@ impl SnapshotCache {
     }
 }
 
+/// How many distinct (bridge, userland) pairs keep a memoized digest. A process
+/// sees one bridge bundle and a handful of userland bundles, so this is sized for
+/// "all of them" rather than for eviction pressure.
+const SNAPSHOT_KEY_MEMO_CAPACITY: usize = 4;
+
+struct SnapshotKeyMemoEntry {
+    bridge_code: Box<str>,
+    userland_code: Option<Box<str>>,
+    key: SnapshotCacheKey,
+}
+
+impl SnapshotKeyMemoEntry {
+    fn matches(&self, bridge_code: &str, userland_code: Option<&str>) -> bool {
+        &*self.bridge_code == bridge_code && self.userland_code.as_deref() == userland_code
+    }
+}
+
+fn snapshot_key_memo() -> &'static Mutex<Vec<SnapshotKeyMemoEntry>> {
+    static MEMO: OnceLock<Mutex<Vec<SnapshotKeyMemoEntry>>> = OnceLock::new();
+    MEMO.get_or_init(|| Mutex::new(Vec::new()))
+}
+
 /// Cache key over bridge + optional userland code. With no userland this is just
 /// the sha256 of the bridge code (a NUL separator is only added when userland is
 /// present), so existing bridge-only entries keep their historical keys.
+///
+/// The digest is memoized by content. The bridge bundle alone is ~2.5 MB, and
+/// every execution derives this key several times (the snapshot-cache lookup plus
+/// the warm-worker pool key on both the pre-warm and the claim path), so the
+/// re-digesting cost ~7 ms per call. Matching by full content equality — a memcmp,
+/// roughly 35x cheaper than the digest — keeps the memo indistinguishable from
+/// recomputing: it can only return the key of a bundle byte-identical to the one
+/// asked for, so no caller can observe another caller's bundle through it.
 pub fn snapshot_cache_key(bridge_code: &str, userland_code: Option<&str>) -> SnapshotCacheKey {
-    match userland_code {
-        None => {
-            let mut hasher = Sha256::new();
-            hasher.update(bridge_code.as_bytes());
-            hasher.finalize().into()
-        }
-        Some(userland_code) => {
-            let mut buf = Vec::with_capacity(bridge_code.len() + 1 + userland_code.len());
-            buf.extend_from_slice(bridge_code.as_bytes());
-            buf.push(0);
-            buf.extend_from_slice(userland_code.as_bytes());
-            let mut hasher = Sha256::new();
-            hasher.update(&buf);
-            hasher.finalize().into()
+    if let Some(key) = snapshot_key_memo()
+        .lock()
+        .unwrap()
+        .iter()
+        .find(|entry| entry.matches(bridge_code, userland_code))
+        .map(|entry| entry.key)
+    {
+        return key;
+    }
+
+    let key = compute_snapshot_cache_key(bridge_code, userland_code);
+
+    let mut memo = snapshot_key_memo().lock().unwrap();
+    if !memo
+        .iter()
+        .any(|entry| entry.matches(bridge_code, userland_code))
+    {
+        if memo.len() >= SNAPSHOT_KEY_MEMO_CAPACITY {
+            memo.remove(0);
         }
+        memo.push(SnapshotKeyMemoEntry {
+            bridge_code: Box::from(bridge_code),
+            userland_code: userland_code.map(Box::from),
+            key,
+        });
     }
+    key
+}
+
+fn compute_snapshot_cache_key(bridge_code: &str, userland_code: Option<&str>) -> SnapshotCacheKey {
+    let mut hasher = Sha256::new();
+    hasher.update(bridge_code.as_bytes());
+    if let Some(userland_code) = userland_code {
+        hasher.update([0u8]);
+        hasher.update(userland_code.as_bytes());
+    }
+    hasher.finalize().into()
 }
 
 #[doc(hidden)]
@@ -2102,6 +2153,31 @@ mod tests {
         );
     }
 
+    #[test]
+    fn snapshot_cache_key_memo_agrees_with_a_fresh_digest() {
+        // The memo must be indistinguishable from recomputing, including after it
+        // has been filled past its capacity and the earliest entries evicted.
+        let inputs: Vec<(String, Option<String>)> = (0..SNAPSHOT_KEY_MEMO_CAPACITY + 3)
+            .flat_map(|index| {
+                let bridge = format!("memo-bridge-{index}");
+                [
+                    (bridge.clone(), None),
+                    (bridge, Some(format!("memo-userland-{index}"))),
+                ]
+            })
+            .collect();
+
+        for round in 0..3 {
+            for (bridge, userland) in &inputs {
+                assert_eq!(
+                    snapshot_cache_key(bridge, userland.as_deref()),
+                    compute_snapshot_cache_key(bridge, userland.as_deref()),
+                    "round {round}: memoized key must equal a fresh digest for {bridge}"
+                );
+            }
+        }
+    }
+
     #[test]
     fn create_snapshot_with_userland_rejects_oversized_userland_code() {
         let bridge_code = "(function(){})();";