@@ -32,3 +32,7 @@ rand = "0.8"
 [[bench]]
 name = "memtrack_writer"
 harness = false
+
+[[bench]]
+name = "memtrack_reader"
+harness = false
@@ -0,0 +1,150 @@
+//! Finding the module events (mappings, forks, execs) the runner needs for
+//! offline stack attribution inside a full memtrack artifact. These are a
+//! handful of records among millions of allocation events, so the cost is
+//! dominated by everything the search has to read past.
+
+use divan::Bencher;
+use divan::counter::{BytesCount, ItemsCount};
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+use runner_shared::artifacts::{
+    MemtrackArtifact, MemtrackEvent, MemtrackEventKind, StackRecord, encode_events,
+};
+
+fn main() {
+    divan::main();
+}
+
+/// Four encoder frames: enough to cross frame boundaries, small enough to stay
+/// fast under the simulation instrument.
+const ARTIFACT_EVENTS: usize = 4 * 64 * 1024;
+/// Executable mappings memtrack appends after the event rings drain.
+const MAPPING_EVENTS: usize = 64;
+/// One fork or exec every this many events, spread through the stream like
+/// the BPF lifecycle tracepoints emit them.
+const LIFECYCLE_INTERVAL: usize = 16 * 1024;
+/// One captured stack every this many events.
+const STACK_INTERVAL: usize = 50;
+/// Raw stack bytes per record: memtrack's default stack copy budget.
+const STACK_BYTES: usize = 8192;
+/// Registers per record on x86_64.
+const STACK_REGS: usize = 33;
+const STACK_FP_FRAMES: usize = 16;
+const ENCODE_WORKERS: usize = 4;
+const ROOT_PID: i32 = 4242;
+
+#[derive(Clone, Copy)]
+enum Payload {
+    Allocations,
+    AllocationsAndStacks,
+}
+
+/// Search an artifact holding only allocation events, like a run without
+/// stack capture.
+#[divan::bench(max_time = 10.0)]
+fn find_module_events(bencher: Bencher) {
+    bench_find_module_events(bencher, Payload::Allocations);
+}
+
+/// Search an artifact that also carries captured stacks, which make up most of
+/// its bytes.
+#[divan::bench(max_time = 10.0)]
+fn find_module_events_with_stacks(bencher: Bencher) {
+    bench_find_module_events(bencher, Payload::AllocationsAndStacks);
+}
+
+fn bench_find_module_events(bencher: Bencher, payload: Payload) {
+    let artifact = generate_artifact(payload);
+    let lifecycle_events = (ARTIFACT_EVENTS - MAPPING_EVENTS).div_ceil(LIFECYCLE_INTERVAL);
+    let expected = MAPPING_EVENTS + lifecycle_events;
+    assert_eq!(count_module_events(&artifact), expected);
+
+    bencher
+        .counter(ItemsCount::new(ARTIFACT_EVENTS))
+        .counter(BytesCount::new(artifact.len()))
+        .bench_local(|| count_module_events(&artifact));
+}
+
+fn count_module_events(artifact: &[u8]) -> usize {
+    MemtrackArtifact::decode_module_events(artifact)
+        .unwrap()
+        .count()
+}
+
+/// An encoded artifact laid out like memtrack writes it: allocation events
+/// with forks and execs interleaved, followed by the mapping suffix.
+fn generate_artifact(payload: Payload) -> Vec<u8> {
+    let mut rng = StdRng::seed_from_u64(42);
+    let mut timestamp: u64 = 1_700_000_000_000_000_000;
+    let mut events = Vec::with_capacity(ARTIFACT_EVENTS);
+
+    for i in 0..ARTIFACT_EVENTS - MAPPING_EVENTS {
+        timestamp += rng.gen_range(50..2_000);
+        let child_pid = ROOT_PID + 1 + (i / (2 * LIFECYCLE_INTERVAL)) as i32;
+        let (pid, kind) = if i % (2 * LIFECYCLE_INTERVAL) == 0 {
+            (
+                child_pid,
+                MemtrackEventKind::Fork {
+                    parent_pid: ROOT_PID,
+                },
+            )
+        } else if i % LIFECYCLE_INTERVAL == 0 {
+            (child_pid, MemtrackEventKind::Exec)
+        } else if matches!(payload, Payload::AllocationsAndStacks) && i % STACK_INTERVAL == 0 {
+            (ROOT_PID, stack_event(&mut rng))
+        } else if rng.gen_bool(0.5) {
+            (
+                ROOT_PID,
+                MemtrackEventKind::Malloc {
+                    size: rng.gen_range(8..8192),
+                    stack_hash: rng.r#gen(),
+                },
+            )
+        } else {
+            (ROOT_PID, MemtrackEventKind::Free)
+        };
+
+        events.push(MemtrackEvent {
+            pid,
+            tid: pid,
+            timestamp,
+            addr: rng.r#gen(),
+            kind,
+        });
+    }
+
+    for i in 0..MAPPING_EVENTS {
+        events.push(MemtrackEvent {
+            pid: ROOT_PID,
+            tid: ROOT_PID,
+            timestamp: timestamp + i as u64,
+            addr: 0x7f00_0000_0000 + (i as u64) * 0x10_0000,
+            kind: MemtrackEventKind::Mapping {
+                path: format!("/usr/lib/x86_64-linux-gnu/libmodule{i}.so"),
+                dev: 0x0800_0001,
+                ino: i as u64,
+                file_offset: 0x1000,
+                len: 0x8_0000,
+            },
+        });
+    }
+
+    let mut artifact = Vec::new();
+    encode_events(events, &mut artifact, ENCODE_WORKERS).unwrap();
+    artifact
+}
+
+fn stack_event(rng: &mut StdRng) -> MemtrackEventKind {
+    let mut bytes = vec![0u8; STACK_BYTES];
+    rng.fill(&mut bytes[..]);
+    MemtrackEventKind::Stack {
+        record: Box::new(StackRecord {
+            hash: rng.r#gen(),
+            sp: 0x7fff_0000_0000 | (rng.gen_range(0..1u64 << 20) << 4),
+            regs: (0..STACK_REGS).map(|_| rng.r#gen()).collect(),
+            bytes,
+            fp_chain: (0..STACK_FP_FRAMES).map(|_| rng.r#gen()).collect(),
+            truncated: true,
+        }),
+    }
+}