[turbopack] use zero copy qfilter deserialization (#90574)

## What

Switch turbo-persistence AMQF filters from owned `qfilter::Filter` (heap-allocated) to zero-copy `qfilter::FilterRef` that borrows directly from the memory-mapped meta file.

## Why

- **Lower memory usage** — no heap copy of filter data; `FilterRef` is just a pointer into the mmap
- **Faster open time** — no deserialization/allocation, just pointer math over the mmap
- **OS-managed memory** — mmap pages can be cheaply evicted under pressure (free LRU behavior), unlike heap-allocated `Filter` data which needs to be swapped

## How

- Update `qfilter` dependency to the latest alpha release with `FilterRef` support 
- Switch per-entry AMQF serialization from `turbo_bincode` to `pot` format, which supports zero-copy deserialization 
- Store `qfilter::FilterRef<'static>` directly in `MetaEntry` (lifetime transmuted from the mmap borrow)
- Rely on Rust's struct field drop order guarantee: `MetaFile::entries` is declared before `MetaFile::mmap`, so all `FilterRef`s are dropped before the mmap is unmapped
- Update compaction code to work with `FilterRef` avoiding many allocations when merging

### Safety invariants

The `FilterRef<'static>` lifetime is transmuted 🙀 — the actual borrow is from `MetaFile::mmap`. This is safe because:

1. `MetaEntry` is never moved out of `MetaFile` (only accessed by `&` reference via `entries()` / `entry()`)
2. Rust drops struct fields in declaration order, and `entries` is declared before `mmap`
3. This is the same pattern used by `ArcBytes`/`RcBytes` in this crate (raw pointer into backing storage)

## Benchmark Results

I ran a number of the Read benchmarks and compaction benchmarks and it is all in the noise, which makes sense.  We might get a slight benefit from avoiding the `OnceLock` and lazy initialization, we should also have slightly lower maxrss and offer the OS more flexibility during memory pressure

From measuring vercel-site, a warm build saves ~40m of MaxRSS

Author: lukesandberg

Cargo.lock

@@ -14,7 +14,6 @@ verbose_log = []
 
 [dependencies]
 anyhow = { workspace = true }
-bincode = { workspace = true }
 bitfield = { workspace = true }
 byteorder = { workspace = true }
 crc32fast = { workspace = true }
@@ -25,15 +24,15 @@ lzzzz = { workspace = true }
 memmap2 = "0.9.5"
 nohash-hasher = { workspace = true }
 parking_lot = { workspace = true }
-pot = "3.0.0"
 # See https://github.com/vercel/next.js/issues/91708 for why we need the legacy_x86_64_support feature
-qfilter = { version = "0.3.0-alpha.2", features = ["serde", "legacy_x86_64_support"] }
+qfilter = { version = "0.3.0-alpha.3", features = ["serde", "legacy_x86_64_support"] }
+postcard = { workspace = true, features = ["alloc", "use-std"] }
+zerocopy = { version = "0.8", features = ["derive"] }
 quick_cache = { workspace = true }
 rustc-hash = { workspace = true }
 smallvec = { workspace = true }
 thread_local = { workspace = true }
 tracing = { workspace = true }
-turbo-bincode= { workspace = true }
 xxhash-rust = { workspace = true }
 
 [dev-dependencies]

turbopack/crates/turbo-persistence/Cargo.toml

@@ -26,6 +26,9 @@ enum Backing {
 #[derive(Clone)]
 pub struct ArcBytes {
     data: *const [u8],
+    // Safety: Backing should come last so that it is dropped after the data pointer so we don't
+    // create a dangling pointer.  This isn't really a problem since it is technically ok to have
+    // dangling _pointers_.
     backing: Backing,
 }
 

turbopack/crates/turbo-persistence/src/arc_bytes.rs

@@ -528,6 +528,11 @@ impl<S: ParallelScheduler, const FAMILIES: usize> TurboPersistence<S, FAMILIES>
             // len is only a snapshot at that time and it can change while we create the filter.
             // So we give it 5% more space to make resizes less likely.
             let initial_capacity = set.len() * 20 / 19;
+            // TODO: Using u64::BITS as fingerprint size is wasteful for a
+            // probabilistic membership filter. A smaller fingerprint (e.g. via
+            // Filter::new with a target fp_rate) would significantly reduce size,
+            // but would make merging slower since mismatched fingerprint sizes
+            // fall back to one-by-one insertion instead of sorted merge.
             let mut amqf =
                 qfilter::Filter::with_fingerprint_size(initial_capacity as u64, u64::BITS as u8)
                     .unwrap();
@@ -987,7 +992,7 @@ impl<S: ParallelScheduler, const FAMILIES: usize> TurboPersistence<S, FAMILIES>
                     // during the merge loop. Empty filters (from commits with no
                     // reads) are discarded.
                     let used_key_hashes: Option<qfilter::Filter> = {
-                        let filters: Vec<qfilter::Filter> = meta_files
+                        let filters: Vec<qfilter::FilterRef<'_>> = meta_files
                             .iter()
                             .filter(|m| m.family() == family)
                             .filter_map(|meta_file| {
@@ -1001,9 +1006,11 @@ impl<S: ParallelScheduler, const FAMILIES: usize> TurboPersistence<S, FAMILIES>
                             None
                         } else if filters.len() == 1 {
                             // Just directly use the single item
-                            filters.into_iter().next()
+                            Some(filters[0].to_owned())
                         } else {
                             let total_len: u64 = filters.iter().map(|f| f.len()).sum();
+                            // Fingerprint size must match the source filters to
+                            // enable the efficient sorted merge path in qfilter.
                             let mut merged =
                                 qfilter::Filter::with_fingerprint_size(total_len, u64::BITS as u8)
                                     .expect("Failed to create merged AMQF filter");