test(runner-shared): keep instrumented module event benches to 1M events

Generating and searching artifacts much larger than 1M events outlasts the
CI job under the simulation and memory instruments. Pick the sizes from
CODSPEED_RUNNER_MODE so these modes only search the smallest artifact,
leaving walltime and plain divan runs free to cover larger ones.

Author: not-matthias

crates/runner-shared/benches/memtrack_reader.rs

@@ -3,13 +3,16 @@
 //! handful of records among millions of allocation events, so the cost is
 //! dominated by everything the search has to read past.
 
+use clap::ValueEnum;
 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,
 };
+use runner_shared::measurement_mode::MeasurementMode;
+use runner_shared::runtime_env::RUNNER_MODE_ENV;
 use std::io::Write;
 
 fn main() {
@@ -20,20 +23,35 @@ fn main() {
 /// streamed decoder under the simulation instrument.
 const SIZES: &[usize] = &[1_000_000];
 
+/// Under the simulation and memory instruments, generating and searching
+/// larger artifacts outlasts the CI job, so these modes only search the
+/// smallest artifact.
+const INSTRUMENTED_SIZES: &[usize] = &[1_000_000];
+
+fn sizes() -> &'static [usize] {
+    let mode = std::env::var(RUNNER_MODE_ENV)
+        .ok()
+        .and_then(|mode| MeasurementMode::from_str(&mode, true).ok());
+    match mode {
+        Some(MeasurementMode::Simulation | MeasurementMode::Memory) => INSTRUMENTED_SIZES,
+        Some(MeasurementMode::Walltime) | None => SIZES,
+    }
+}
+
 #[derive(Clone, Copy)]
 enum Payload {
     Allocations,
     AllocationsAndStacks,
 }
 
 /// An artifact without stack capture.
-#[divan::bench(args = SIZES, max_time = 10.0)]
+#[divan::bench(args = sizes(), max_time = 10.0)]
 fn find_module_events(bencher: Bencher, n: usize) {
     bench(bencher, n, Payload::Allocations);
 }
 
 /// An artifact with captured stacks, which make up most of its bytes.
-#[divan::bench(args = SIZES, max_time = 10.0)]
+#[divan::bench(args = sizes(), max_time = 10.0)]
 fn find_module_events_with_stacks(bencher: Bencher, n: usize) {
     bench(bencher, n, Payload::AllocationsAndStacks);
 }