diff --git a/Cargo.lock b/Cargo.lock
index b30c0b4a72c..85b771881dc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5781,6 +5781,7 @@ dependencies = [
"arrayvec",
"bench-harness",
"bytes",
+ "crossbeam-epoch",
"flate2",
"futures",
"hashbrown 0.17.1",
diff --git a/quest/m2/performance-survey/README.md b/quest/m2/performance-survey/README.md
index c25cce3d3b9..25f32f480a0 100644
--- a/quest/m2/performance-survey/README.md
+++ b/quest/m2/performance-survey/README.md
@@ -176,7 +176,6 @@ No duplicate quest or workflow edit belongs here.
- [Task capacity after bursts](/quest/m2/performance-survey/task-capacity.md) - polling and memory after peak task occupancy subsides
- [QUIC receive-state reuse](/quest/m2/performance-survey/quic-receive-reuse.md) - reassembly metadata retained by recycled completed streams
- [Cache metadata](/quest/m2/performance-survey/cache-metadata.md) - bookkeeping capacity after cached groups expire
-- [Cache backing amplification](/quest/m2/performance-survey/cache-backing.md) - small retained samples pinning large shared fragments
- [Bandwidth grants](/quest/m2/performance-survey/bandwidth-grants.md) - repeated full allocation in Rust and JS
- [Cached JS group joins](/quest/m2/performance-survey/js-cached-groups.md) - repeated sorting while replaying retained groups
- [PCM batch processing](/quest/m2/performance-survey/audio-batches.md) - repeated tail movement during encoding and resampling
diff --git a/quest/m2/performance-survey/cache-backing.md b/quest/m2/performance-survey/cache-backing.md
deleted file mode 100644
index 82eb01f58bc..00000000000
--- a/quest/m2/performance-survey/cache-backing.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# [M] Measure shared cache backing amplification
-
-## Goal
-
-Small retained media samples do not pin disproportionately large backing
-allocations when a measured alternative earns its copying cost.
-
-## Plan
-
-[Group storage](/rs/moq-net/src/model/group.rs) bills `Bytes::len()` and stores
-the supplied view. [fMP4 import](/rs/moq-mux/src/container/fmp4/import.rs)
-slices samples from a fragment. Selective expiry across groups or tracks can
-leave a small sample holding a large fragment after most logical charges
-disappear. Cache capacity is not a promised hard RSS limit; this is a backing
-amplification hypothesis, not proof of a broken capacity contract.
-
-Benchmark the actual importer and cache, sweeping fragment size × retained
-sample fraction × tracks. Include mixed audio/video, several keyframe groups
-in a fragment, selective expiry and independently allocated samples as a
-control. Measure uniquely owned backing bytes versus `Pool::used()`, copy
-volume, allocations, CPU and delivery latency. Do not double count shared
-backing or assume each slice owns a fresh allocation. Compare continued
-sharing with copying/compaction only where the workload warrants it.
-
-This covers completed reliable groups. Coordinate with
-receive leases ([moq-dev/moq#5878](https://github.com/moq-dev/moq/pull/5878))
-and [browser media copies](/quest/m2/performance-survey/browser-media-copies.md).
-Decoded datagrams are already billed to the cache pool
-([moq-dev/moq#6413](https://github.com/moq-dev/moq/pull/6413)) and the media
-reorder queues are bounded ([moq-dev/moq#6453](https://github.com/moq-dev/moq/pull/6453)).
-
-Follow the [survey benchmark contract](/quest/m2/performance-survey/README.md):
-baseline first, paired evidence, equivalent work and nightly coverage. A
-measured no-win is valid. No API or wire change is expected; report actual impact.
diff --git a/rs/moq-net/Cargo.toml b/rs/moq-net/Cargo.toml
index 405dc55c83e..f487413b9e9 100644
--- a/rs/moq-net/Cargo.toml
+++ b/rs/moq-net/Cargo.toml
@@ -45,6 +45,8 @@ uuid = { workspace = true }
[dev-dependencies]
criterion = { package = "bench-harness", path = "../bench-harness" }
+# Runs the group log's deferred frees before the backing bench reads the live heap.
+crossbeam-epoch = "0.9.21"
futures = { workspace = true }
# The tests' executor, with simulated time.
kio = { path = "../kio", features = ["runtime", "sim"] }
@@ -120,6 +122,12 @@ name = "frame"
harness = false
required-features = ["fuzz"]
+# Receives frames through the private session reader via the hidden `fuzz` module.
+[[bench]]
+name = "backing"
+harness = false
+required-features = ["fuzz"]
+
[[bench]]
name = "group"
harness = false
diff --git a/rs/moq-net/benches/backing.rs b/rs/moq-net/benches/backing.rs
new file mode 100644
index 00000000000..fbde04be899
--- /dev/null
+++ b/rs/moq-net/benches/backing.rs
@@ -0,0 +1,436 @@
+//! What cached frames received from the network keep alive beyond the bytes the cache bills.
+//!
+//! A receiving session hands each frame's payload to the cache as the transport delivered
+//! it. A frame that arrives whole in one chunk would be cached as that chunk, a slice of
+//! whatever receive allocation the packet was copied into, while a frame spanning packets is
+//! copied into storage of its own. The pool bills each frame's length, so a small frame could
+//! keep a much larger receive allocation alive, including the other frames' bytes that were
+//! copied out of it. The session's frame reader therefore copies a whole frame of at most
+//! 2 KiB out of its chunk, and this bench guards that every backing stays near the control.
+//!
+//! Each case receives [`SECONDS`] of media on `tracks` video and audio track pairs sharing one
+//! pool, through the session's frame reader ([`moq_net::fuzz::GroupRecv`]). Frames are
+//! interleaved by timestamp and packed back to back into packets of [`PACKET`] stream bytes,
+//! which arrive in one of three backings:
+//!
+//! - `exact`: every chunk in an allocation of its own, the control.
+//! - `datagram`: one allocation per datagram, as `moq-uring` copies a completion without GRO.
+//! - `recv64k`: consecutive datagrams share a 64 KiB allocation, as `moq-tokio`'s endpoint
+//! driver copies each receive into one reused `BytesMut` and splits datagrams off it.
+//! A `moq-uring` GRO completion is one allocation of up to 64 KiB as well.
+//!
+//! Then the oldest video groups are evicted, keeping `keep` of them, while every audio group
+//! stays cached: the selective expiry that leaves a small audio frame holding a receive
+//! allocation whose video bytes the cache already dropped.
+//!
+//! `BACKING_ALLOCS=1` prints, for every case, the live heap the cache retains against
+//! [`cache::Pool::used`], the payload bytes retained, how many frames arrived whole, and the
+//! allocations and bytes allocated per frame received, instead of timing. The live heap
+//! counts each allocation once, however many frames slice it. An argument filters the cases
+//! by name. Timing covers only the cases that keep every group, since eviction adds a few
+//! aborts. The first time a timed case runs, it prints the same line for itself and for the
+//! two cases that evict its video groups, so a timed run such as the nightly one logs every
+//! case's memory. The ratio is reported, not asserted: the reader's unit test pins the copy.
+//!
+//! Run with `cargo bench -p moq-net --features fuzz --bench backing`.
+
+use std::alloc::{GlobalAlloc, Layout, System};
+use std::sync::atomic::{AtomicBool, AtomicIsize, AtomicUsize, Ordering};
+
+use bytes::{Bytes, BytesMut};
+use criterion::{BatchSize, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
+use moq_net::{Timescale, Timestamp, broadcast, cache, fuzz::GroupRecv, group, track};
+
+/// Stream bytes per packet: a 1200-byte datagram less its QUIC overhead.
+const PACKET: usize = 1150;
+
+/// What `moq-tokio`'s receive buffer reallocates once a datagram split off it is still held:
+/// `bytes` keeps at most 64 KiB of a buffer's original capacity.
+const RECV_CAPACITY: usize = 64 * 1024;
+
+/// Media received per case.
+const SECONDS: u64 = 10;
+
+/// One group per track every two seconds: a video GOP, and the audio beside it.
+const GROUP_MS: u64 = 2000;
+
+const VIDEO_FPS: u64 = 30;
+/// A keyframe is this many delta frames.
+const KEYFRAME: u64 = 10;
+
+/// 20 ms Opus frames at 64 kbps.
+const AUDIO_FPS: u64 = 50;
+const AUDIO_FRAME: usize = 160;
+
+/// Video bitrates, in kbps. Only the lowest has delta frames small enough to arrive whole.
+const VIDEO_KBPS: [u64; 3] = [150, 1000, 4000];
+const TRACKS: [usize; 2] = [1, 4];
+
+#[derive(Clone, Copy, Debug)]
+enum Backing {
+ Exact,
+ Datagram,
+ Recv,
+}
+
+impl Backing {
+ const ALL: [Self; 3] = [Self::Exact, Self::Datagram, Self::Recv];
+
+ fn name(self) -> &'static str {
+ match self {
+ Self::Exact => "exact",
+ Self::Datagram => "datagram",
+ Self::Recv => "recv64k",
+ }
+ }
+}
+
+/// How many of each video track's groups stay cached: all, the newest quarter, or none.
+const KEEP: [(&str, u64, u64); 3] = [("all", 1, 1), ("quarter", 1, 4), ("none", 0, 1)];
+
+struct Counter;
+
+static COUNTING: AtomicBool = AtomicBool::new(false);
+static ALLOCATIONS: AtomicUsize = AtomicUsize::new(0);
+static ALLOCATED: AtomicUsize = AtomicUsize::new(0);
+static LIVE: AtomicIsize = AtomicIsize::new(0);
+
+#[global_allocator]
+static ALLOCATOR: Counter = Counter;
+
+impl Counter {
+ fn count(size: usize) {
+ if COUNTING.load(Ordering::Relaxed) {
+ ALLOCATIONS.fetch_add(1, Ordering::Relaxed);
+ ALLOCATED.fetch_add(size, Ordering::Relaxed);
+ }
+ }
+}
+
+// Counting only. Every call forwards to the system allocator unchanged.
+unsafe impl GlobalAlloc for Counter {
+ unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+ Self::count(layout.size());
+ LIVE.fetch_add(layout.size() as isize, Ordering::Relaxed);
+ unsafe { System.alloc(layout) }
+ }
+
+ unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+ Self::count(layout.size());
+ LIVE.fetch_add(layout.size() as isize, Ordering::Relaxed);
+ unsafe { System.alloc_zeroed(layout) }
+ }
+
+ unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+ Self::count(new_size);
+ LIVE.fetch_add(new_size as isize - layout.size() as isize, Ordering::Relaxed);
+ unsafe { System.realloc(ptr, layout, new_size) }
+ }
+
+ unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+ LIVE.fetch_sub(layout.size() as isize, Ordering::Relaxed);
+ unsafe { System.dealloc(ptr, layout) }
+ }
+}
+
+/// One frame of the workload, and the packets its payload landed in.
+struct Frame {
+ /// Index into [`Media::tracks`]: video tracks first, then audio.
+ track: usize,
+ timestamp: u64,
+ /// Opens a group.
+ start: bool,
+ /// `(packet, offset, len)` per chunk, in order.
+ chunks: Vec<(usize, usize, usize)>,
+}
+
+/// The workload of one case, packetized once.
+struct Media {
+ tracks: usize,
+ frames: Vec,
+ /// Stream bytes per packet.
+ packets: Vec,
+ payload: usize,
+}
+
+impl Media {
+ fn new(tracks: usize, video_kbps: u64) -> Self {
+ // A GOP of one keyframe and the deltas after it carries the bitrate.
+ let gop = VIDEO_FPS * GROUP_MS / 1000;
+ let delta = (video_kbps * 1000 / 8 * GROUP_MS / 1000 / (KEYFRAME + gop - 1)) as usize;
+
+ let mut frames = Vec::new();
+ for track in 0..tracks {
+ for index in 0..VIDEO_FPS * SECONDS {
+ let timestamp = index * 1000 / VIDEO_FPS;
+ let start = index % gop == 0;
+ let size = if start { delta * KEYFRAME as usize } else { delta };
+ frames.push((timestamp, track, start, size));
+ }
+ for index in 0..AUDIO_FPS * SECONDS {
+ let timestamp = index * 1000 / AUDIO_FPS;
+ let start = timestamp % GROUP_MS < 1000 / AUDIO_FPS;
+ frames.push((timestamp, tracks + track, start, AUDIO_FRAME));
+ }
+ }
+ frames.sort_by_key(|(timestamp, track, ..)| (*timestamp, *track));
+
+ // Back to back, each packet filled before the next.
+ let mut packets = vec![0];
+ let mut payload = 0;
+ let frames = frames
+ .into_iter()
+ .map(|(timestamp, track, start, mut size)| {
+ payload += size;
+ let mut chunks = Vec::new();
+ while size > 0 {
+ let packet = packets.len() - 1;
+ let offset = packets[packet];
+ let len = size.min(PACKET - offset);
+ chunks.push((packet, offset, len));
+ size -= len;
+ packets[packet] += len;
+ if packets[packet] == PACKET {
+ packets.push(0);
+ }
+ }
+ Frame {
+ track,
+ timestamp,
+ start,
+ chunks,
+ }
+ })
+ .collect();
+
+ Self {
+ tracks: 2 * tracks,
+ frames,
+ packets,
+ payload,
+ }
+ }
+
+ fn is_video(&self, track: usize) -> bool {
+ track < self.tracks / 2
+ }
+}
+
+/// The transport's receive path: copies each datagram into its backing and hands out slices.
+struct Driver {
+ backing: Backing,
+ recv: BytesMut,
+ /// The packet the last chunk came from.
+ current: Option<(usize, Bytes)>,
+}
+
+/// What every datagram's bytes are copied from: the content does not matter.
+static WIRE: [u8; PACKET] = [0; PACKET];
+
+impl Driver {
+ fn new(backing: Backing) -> Self {
+ Self {
+ backing,
+ recv: match backing {
+ Backing::Recv => BytesMut::with_capacity(RECV_CAPACITY),
+ _ => BytesMut::new(),
+ },
+ current: None,
+ }
+ }
+
+ fn chunk(&mut self, media: &Media, (packet, offset, len): (usize, usize, usize)) -> Bytes {
+ let bytes = media.packets[packet];
+ match self.backing {
+ Backing::Exact => Bytes::copy_from_slice(&WIRE[offset..offset + len]),
+ Backing::Datagram | Backing::Recv => {
+ if self.current.as_ref().is_none_or(|(current, _)| *current != packet) {
+ let datagram = match self.backing {
+ // As `moq-uring` copies a completion out of its receive pool.
+ Backing::Datagram => BytesMut::from(&WIRE[..bytes]).freeze(),
+ // As `moq-tokio` receives: reserve, copy in, split off.
+ _ => {
+ self.recv.reserve(bytes);
+ self.recv.extend_from_slice(&WIRE[..bytes]);
+ self.recv.split_to(bytes).freeze()
+ }
+ };
+ self.current = Some((packet, datagram));
+ }
+ let (_, datagram) = self.current.as_ref().expect("set above");
+ datagram.slice(offset..offset + len)
+ }
+ }
+ }
+}
+
+/// A receiving broadcast, its tracks sharing one pool.
+struct Cache {
+ pool: cache::Pool,
+ _broadcast: broadcast::Producer,
+ tracks: Vec,
+ /// Each track's finished groups, oldest first, with their payload bytes.
+ groups: Vec>,
+}
+
+impl Cache {
+ fn new(media: &Media) -> Self {
+ let mut info = broadcast::Info::new();
+ info.pool = cache::Pool::unbounded();
+ let pool = info.pool.clone();
+ let broadcast = info.produce();
+ let tracks = (0..media.tracks)
+ .map(|index| {
+ let info = track::Info::default().with_timescale(Timescale::MILLI);
+ broadcast.create_track(format!("{index}").as_str(), info).unwrap()
+ })
+ .collect();
+ Self {
+ pool,
+ _broadcast: broadcast,
+ tracks,
+ groups: (0..media.tracks).map(|_| Vec::new()).collect(),
+ }
+ }
+
+ /// Receive every frame, then evict all but `keep` of each video track's groups.
+ fn run(&mut self, media: &Media, backing: Backing, (_, num, den): (&str, u64, u64)) {
+ let mut driver = Driver::new(backing);
+ let mut open: Vec