test(memtrack): validate anon RSS reconstruction against rss_stat

Add a gated integration test that ramps anon RSS via mmap/munmap, reconstructs it from RmapAnon page-count deltas, and asserts the estimate tracks the rss_stat MM_ANONPAGES peak within 25%.

Author: not-matthias

crates/memtrack/tests/rss_reconstruction_tests.rs

@@ -0,0 +1,118 @@
+#[macro_use]
+mod shared;
+
+use runner_shared::artifacts::{ArtifactExt, MemtrackArtifact, MemtrackEventKind};
+use std::fs::File;
+use std::path::PathBuf;
+use std::process::Command;
+use tempfile::TempDir;
+
+const RSS_TRIANGLE_SOURCE: &str = r#"
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+int main(void) {
+    const size_t chunk = 16UL * 1024 * 1024;
+    void* bufs[4];
+    for (int i = 0; i < 4; i++) {
+        bufs[i] = mmap(NULL, chunk, PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+        if (bufs[i] == MAP_FAILED) return 1;
+        memset(bufs[i], 0x42, chunk);
+        usleep(50 * 1000);
+    }
+    for (int i = 0; i < 4; i++) {
+        munmap(bufs[i], chunk);
+        usleep(50 * 1000);
+    }
+    return 0;
+}
+"#;
+
+#[test_with::env(GITHUB_ACTIONS)]
+#[test_log::test]
+fn test_rss_reconstruction() -> Result<(), Box<dyn std::error::Error>> {
+    unsafe {
+        std::env::set_var("CODSPEED_MEMTRACK_TRACK_RMAP", "1");
+    }
+
+    let temp_dir = TempDir::new()?;
+    let binary = shared::compile_c_source(RSS_TRIANGLE_SOURCE, "rss_triangle", temp_dir.path())?;
+
+    let (mut events, thread_handle) = shared::track_command(Command::new(&binary), &[], false)?;
+
+    let artifact_path = PathBuf::from(env!("CARGO_TARGET_TMPDIR"))
+        .join("rss_reconstruction.MemtrackArtifact.msgpack");
+    let artifact = MemtrackArtifact {
+        events: events.clone(),
+    };
+    artifact.encode_to_writer(File::create(&artifact_path)?)?;
+    eprintln!("rss artifact: {}", artifact_path.display());
+
+    events.sort_by_key(|e| e.timestamp);
+
+    const PAGE_SIZE: i64 = 4096;
+
+    let real_anon: Vec<i64> = events
+        .iter()
+        .filter_map(|e| match e.kind {
+            MemtrackEventKind::Rss { member: 1, size } => Some(size as i64),
+            _ => None,
+        })
+        .collect();
+
+    let rmap_deltas: Vec<i64> = events
+        .iter()
+        .filter_map(|e| match e.kind {
+            MemtrackEventKind::RmapAnon { delta } => Some(delta),
+            _ => None,
+        })
+        .collect();
+
+    assert!(
+        !real_anon.is_empty(),
+        "expected at least one MM_ANONPAGES rss_stat event; got none (rss_stat hook did not fire)"
+    );
+    assert!(
+        !rmap_deltas.is_empty(),
+        "expected at least one RmapAnon event; got none (folio rmap fentry hooks did not attach/fire)"
+    );
+
+    let real_peak = *real_anon.iter().max().unwrap();
+    let real_base = *real_anon.iter().min().unwrap();
+    let real_amplitude = real_peak - real_base;
+
+    let mut cum: i64 = 0;
+    let mut est_peak: i64 = 0;
+    for delta in &rmap_deltas {
+        cum += delta;
+        est_peak = est_peak.max(cum * PAGE_SIZE);
+    }
+
+    eprintln!(
+        "real anon amplitude = {} MiB, estimated peak = {} MiB",
+        real_amplitude / (1024 * 1024),
+        est_peak / (1024 * 1024)
+    );
+
+    const MIN_BYTES: i64 = 48 * 1024 * 1024;
+    assert!(
+        real_amplitude >= MIN_BYTES,
+        "real anon RSS amplitude {real_amplitude} bytes < {MIN_BYTES}"
+    );
+    assert!(
+        est_peak >= MIN_BYTES,
+        "estimated anon RSS peak {est_peak} bytes < {MIN_BYTES}"
+    );
+
+    let low = (real_amplitude as f64 * 0.75) as i64;
+    let high = (real_amplitude as f64 * 1.25) as i64;
+    assert!(
+        (low..=high).contains(&est_peak),
+        "estimated peak {est_peak} not within [0.75, 1.25] x real amplitude {real_amplitude} ([{low}, {high}])"
+    );
+
+    thread_handle.join().unwrap();
+    Ok(())
+}