chore(runner-shared): add memtrack serialization benchmark

Author: not-matthias

.github/workflows/ci.yml

@@ -47,3 +47,18 @@ jobs:
       - name: Run tests
         run: sudo -E $(which cargo) test
         working-directory: crates/memtrack
+
+  benchmarks:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: moonrepo/setup-rust@v1
+        with:
+          bins: cargo-codspeed
+      - name: Build benchmarks
+        run: cargo codspeed build -p runner-shared
+      - name: Run benchmarks
+        uses: CodSpeedHQ/action@v4
+        with:
+          mode: instrumentation
+          run: cargo codspeed run -p runner-shared

Cargo.lock

@@ -14,3 +14,11 @@ rmp = "0.8.14"
 rmp-serde = "1.3.0"
 libc = { workspace = true }
 zstd = "0.13"
+
+[dev-dependencies]
+divan = { version = "4.2.0", package = "codspeed-divan-compat" }
+rand = "0.8"
+
+[[bench]]
+name = "memtrack_writer"
+harness = false

crates/runner-shared/Cargo.toml

@@ -0,0 +1,66 @@
+use divan::Bencher;
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+use runner_shared::artifacts::{MemtrackEvent, MemtrackEventKind, MemtrackWriter};
+
+fn main() {
+    divan::main();
+}
+
+/// Generate N random memtrack events with a seeded RNG
+fn generate_events(n: usize) -> Vec<MemtrackEvent> {
+    let mut rng = StdRng::seed_from_u64(12345);
+    let mut events = Vec::with_capacity(n);
+
+    for _ in 0..n {
+        let kind = match rng.gen_range(0..8) {
+            0 => MemtrackEventKind::Malloc {
+                size: rng.gen_range(8..8192),
+            },
+            1 => MemtrackEventKind::Free,
+            2 => MemtrackEventKind::Realloc {
+                size: rng.gen_range(8..8192),
+            },
+            3 => MemtrackEventKind::Calloc {
+                size: rng.gen_range(8..8192),
+            },
+            4 => MemtrackEventKind::AlignedAlloc {
+                size: rng.gen_range(8..8192),
+            },
+            5 => MemtrackEventKind::Mmap {
+                size: rng.gen_range(8..8192),
+            },
+            6 => MemtrackEventKind::Munmap {
+                size: rng.gen_range(8..8192),
+            },
+            7 => MemtrackEventKind::Brk {
+                size: rng.gen_range(8..8192),
+            },
+            _ => unreachable!(),
+        };
+
+        events.push(MemtrackEvent {
+            pid: rng.r#gen(),
+            tid: rng.r#gen(),
+            timestamp: rng.r#gen(),
+            addr: rng.r#gen(),
+            kind,
+        });
+    }
+
+    events
+}
+
+#[divan::bench(args = [10_000, 100_000, 500_000, 1_000_000])]
+fn write_events(bencher: Bencher, n: usize) {
+    let events = generate_events(n);
+
+    bencher.bench_local(|| {
+        let mut output = Vec::new();
+        let mut writer = MemtrackWriter::new(&mut output).unwrap();
+        for event in &events {
+            writer.write_event(event).unwrap();
+        }
+        writer.finish().unwrap();
+    });
+}