feat: add analysis instrument

Author: not-matthias

src/instruments/analysis.zig

@@ -0,0 +1,6 @@
+const shared = @import("../shared.zig");
+const fifo_instrument = @import("fifo_instrument.zig");
+
+const AnalysisError = error{ModeError};
+
+pub const AnalysisInstrument = fifo_instrument.FifoInstrument(.Analysis, AnalysisError);

src/instruments/fifo_instrument.zig

@@ -0,0 +1,58 @@
+const std = @import("std");
+const runner_fifo = @import("../runner_fifo.zig");
+const shared = @import("../shared.zig");
+
+/// Creates a complete FIFO-based instrument struct that validates a specific integration mode
+pub fn FifoInstrument(comptime mode: shared.IntegrationMode, comptime error_type: anytype) type {
+    return struct {
+        fifo: runner_fifo.RunnerFifo,
+
+        const Self = @This();
+
+        pub fn init(allocator: std.mem.Allocator) !Self {
+            var fifo = try runner_fifo.RunnerFifo.init(allocator);
+
+            // Get the instrumentation mode from the runner
+            const detected_mode = fifo.get_integration_mode() catch |err| {
+                fifo.deinit();
+                return err;
+            };
+
+            // Only accept if the runner is in the correct mode
+            if (detected_mode != mode) {
+                fifo.deinit();
+                return error_type.ModeError;
+            }
+
+            return Self{ .fifo = fifo };
+        }
+
+        pub fn deinit(self: *Self) void {
+            self.fifo.deinit();
+        }
+
+        pub fn send_version(self: *Self, protocol_version: u64) !void {
+            try self.fifo.send_version(protocol_version);
+        }
+
+        pub fn start_benchmark(self: *Self) !void {
+            try self.fifo.start_benchmark();
+        }
+
+        pub fn stop_benchmark(self: *Self) !void {
+            try self.fifo.stop_benchmark();
+        }
+
+        pub fn set_executed_benchmark(self: *Self, pid: u32, uri: [*c]const u8) !void {
+            try self.fifo.set_executed_benchmark(pid, uri);
+        }
+
+        pub fn set_integration(self: *Self, name: [*c]const u8, version: [*c]const u8) !void {
+            try self.fifo.set_integration(name, version);
+        }
+
+        pub fn add_marker(self: *Self, pid: u32, marker: shared.MarkerType) !void {
+            try self.fifo.add_marker(pid, marker);
+        }
+    };
+}

src/instruments/perf.zig

@@ -1,6 +1,6 @@
-const std = @import("std");
-const fifo = @import("../fifo.zig");
 const shared = @import("../shared.zig");
-const runner_fifo = @import("../runner_fifo.zig");
+const fifo_instrument = @import("fifo_instrument.zig");
 
-pub const PerfInstrument = runner_fifo.RunnerFifo;
+const PerfError = error{ModeError};
+
+pub const PerfInstrument = fifo_instrument.FifoInstrument(.Perf, PerfError);

src/instruments/root.zig

@@ -1,28 +1,32 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const perf = @import("perf.zig");
+const analysis = @import("analysis.zig");
 const valgrind = @import("valgrind.zig");
 const shared = @import("../shared.zig");
 const ValgrindInstrument = valgrind.ValgrindInstrument;
+const PerfInstrument = perf.PerfInstrument;
+const AnalysisInstrument = analysis.AnalysisInstrument;
 
 pub const InstrumentHooks = union(enum) {
     valgrind: ValgrindInstrument,
-    perf: perf.PerfInstrument,
+    perf: PerfInstrument,
+    analysis: AnalysisInstrument,
     none: void,
 
     const Self = @This();
 
     pub fn init(allocator: std.mem.Allocator) !Self {
-        if (ValgrindInstrument.is_instrumented()) {
-            return Self{ .valgrind = ValgrindInstrument.init(allocator) };
-        }
+        if (ValgrindInstrument.init(allocator)) |valgrind_inst| {
+            return Self{ .valgrind = valgrind_inst };
+        } else |_| {}
 
-        var perf_inst = perf.PerfInstrument.init(allocator) catch {
-            return Self{ .none = {} };
-        };
-        if (perf_inst.is_instrumented()) {
+        if (AnalysisInstrument.init(allocator)) |analysis_inst| {
+            return Self{ .analysis = analysis_inst };
+        } else |_| {}
+
+        if (PerfInstrument.init(allocator)) |perf_inst| {
             return Self{ .perf = perf_inst };
-        }
+        } else |_| {}
 
         return Self{ .none = {} };
     }
@@ -31,17 +35,16 @@ pub const InstrumentHooks = union(enum) {
         switch (self.*) {
             .valgrind => {},
             .perf => self.perf.deinit(),
+            .analysis => self.analysis.deinit(),
             .none => {},
         }
     }
 
     pub inline fn is_instrumented(self: *Self) bool {
         return switch (self.*) {
             .valgrind => ValgrindInstrument.is_instrumented(),
-            .perf => |perf_inst| {
-                var mutable_perf = perf_inst;
-                return mutable_perf.is_instrumented();
-            },
+            .perf => true,
+            .analysis => true,
             .none => false,
         };
     }
@@ -51,6 +54,8 @@ pub const InstrumentHooks = union(enum) {
             return self.perf.start_benchmark();
         } else if (self.* == .valgrind) {
             return ValgrindInstrument.start_benchmark();
+        } else if (self.* == .analysis) {
+            return self.analysis.start_benchmark();
         }
     }
 
@@ -59,13 +64,16 @@ pub const InstrumentHooks = union(enum) {
             return ValgrindInstrument.stop_benchmark();
         } else if (self.* == .perf) {
             return self.perf.stop_benchmark();
+        } else if (self.* == .analysis) {
+            return self.analysis.stop_benchmark();
         }
     }
 
     pub inline fn set_executed_benchmark(self: *Self, pid: u32, uri: [*c]const u8) !void {
         switch (self.*) {
             .valgrind => ValgrindInstrument.set_executed_benchmark(pid, uri),
             .perf => try self.perf.set_executed_benchmark(pid, uri),
+            .analysis => try self.analysis.set_executed_benchmark(pid, uri),
             .none => {},
         }
     }
@@ -74,13 +82,16 @@ pub const InstrumentHooks = union(enum) {
         switch (self.*) {
             .valgrind => try self.valgrind.set_integration(name, version),
             .perf => try self.perf.set_integration(name, version),
+            .analysis => try self.analysis.set_integration(name, version),
             .none => {},
         }
     }
 
     pub inline fn add_marker(self: *Self, pid: u32, marker: shared.MarkerType) !void {
         if (self.* == .perf) {
             return self.perf.add_marker(pid, marker);
+        } else if (self.* == .analysis) {
+            return self.analysis.add_marker(pid, marker);
         }
     }
 };

src/instruments/valgrind.zig

@@ -6,7 +6,11 @@ pub const ValgrindInstrument = struct {
     allocator: std.mem.Allocator,
     const Self = @This();
 
-    pub fn init(allocator: std.mem.Allocator) Self {
+    pub fn init(allocator: std.mem.Allocator) !Self {
+        if (!ValgrindInstrument.is_instrumented()) {
+            return error.NotInstrumented;
+        }
+
         return Self{
             .allocator = allocator,
         };

src/runner_fifo.zig

@@ -91,6 +91,19 @@ pub const RunnerFifo = struct {
         try self.writer.sendCmd(fifo.Command{ .SetVersion = protocol_version });
         try self.reader.waitForAck(null);
     }
+
+    pub fn get_integration_mode(self: *Self) !shared.IntegrationMode {
+        // NOTE: Other messages send data to the runner, and expect an ACK response (see `sendCmd`). This
+        // command expects the runner to respond with data, so have to write and read directly.
+        try self.writer.sendCmd(fifo.Command.GetIntegrationMode);
+        const response = try self.reader.waitForResponse(null);
+        defer response.deinit(self.allocator);
+
+        if (response == .IntegrationModeResponse) {
+            return response.IntegrationModeResponse;
+        }
+        return error.UnexpectedResponse;
+    }
 };
 
 test "test runner fifo" {