feat: add analysis instrument

Author: not-matthias

src/instruments/analysis.zig

@@ -0,0 +1,55 @@
+const std = @import("std");
+const runner_fifo = @import("../runner_fifo.zig");
+const shared = @import("../shared.zig");
+
+pub const AnalysisInstrument = 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 mode = fifo.get_integration_mode() catch |err| {
+            fifo.deinit();
+            return err;
+        };
+
+        // Only accept if the runner is in Analysis mode
+        if (mode != .Analysis) {
+            fifo.deinit();
+            return error.NotAnalysisMode;
+        }
+
+        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,55 @@
 const std = @import("std");
-const fifo = @import("../fifo.zig");
-const shared = @import("../shared.zig");
 const runner_fifo = @import("../runner_fifo.zig");
+const shared = @import("../shared.zig");
+
+pub const PerfInstrument = 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 mode = fifo.get_integration_mode() catch |err| {
+            fifo.deinit();
+            return err;
+        };
+
+        // Only accept if the runner is in Perf mode
+        if (mode != .Perf) {
+            fifo.deinit();
+            return error.NotPerfMode;
+        }
+
+        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 const PerfInstrument = runner_fifo.RunnerFifo;
+    pub fn add_marker(self: *Self, pid: u32, marker: shared.MarkerType) !void {
+        try self.fifo.add_marker(pid, marker);
+    }
+};

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,17 @@ 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 {
+        try self.send_cmd(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" {