refactor(runner-shared): move the module event filter next to the decoder

The runner filtered the full memtrack event stream down to the Mapping,
Fork and Exec events inside read_mappings_from_artifact. Moving that filter
into MemtrackArtifact::decode_module_events puts it next to the decoder, so
it can be benchmarked and optimized in one place without changing the
runner's fork/exec replay.

Author: not-matthias

crates/runner-shared/src/artifacts/memtrack/mod.rs

@@ -36,6 +36,22 @@ impl MemtrackArtifact {
         })
     }
 
+    /// Stream only the events that place modules in processes: executable
+    /// mappings, and the forks and execs that inherit or drop them. Offline
+    /// stack attribution needs these few events out of the whole artifact.
+    pub fn decode_module_events<R: std::io::Read>(
+        reader: R,
+    ) -> anyhow::Result<impl Iterator<Item = MemtrackEvent>> {
+        Ok(Self::decode_streamed(reader)?.filter(|event| {
+            matches!(
+                event.kind,
+                MemtrackEventKind::Mapping { .. }
+                    | MemtrackEventKind::Fork { .. }
+                    | MemtrackEventKind::Exec
+            )
+        }))
+    }
+
     pub fn is_empty<R: std::io::Read>(reader: R) -> bool {
         let Ok(mut stream) = MemtrackArtifact::decode_streamed(BufReader::new(reader)) else {
             return true;

src/executor/memory/module_artifacts.rs

@@ -103,16 +103,7 @@ fn read_mappings(results_folder: &Path) -> Result<Vec<ProcessMapping>> {
 /// Reconstruct mappings across forks because inherited perf events do not
 /// synthesize mappings that already existed when a child was forked.
 fn read_mappings_from_artifact<R: std::io::Read>(reader: R) -> Result<Vec<ProcessMapping>> {
-    let mut timeline = MemtrackArtifact::decode_streamed(reader)?
-        .filter(|event| {
-            matches!(
-                &event.kind,
-                MemtrackEventKind::Exec
-                    | MemtrackEventKind::Mapping { .. }
-                    | MemtrackEventKind::Fork { .. }
-            )
-        })
-        .collect::<Vec<_>>();
+    let mut timeline = MemtrackArtifact::decode_module_events(reader)?.collect::<Vec<_>>();
 
     // Ties break so exec purges before mapping, while fork inherits that mapping.
     timeline.sort_by_key(|event| {