refactor: rename CurrentBenchmark to ExecutedBenchmark

Author: not-matthias

README.md

@@ -30,7 +30,7 @@ codspeed run -- <your_cmd>
 To make sure your integration is fully working, you have to implement all these hooks:
 - start_benchmark: Call this when the benchmark starts, to start measuring the performance.
 - stop_benchmark: Stop measuring the performance after the benchmark stopped.
-- current_benchmark: Provide metadata about which benchmark was executed.
+- executed_benchmark: Provide metadata about which benchmark was executed.
 - set_integration: Provide metadata about the integration.
 
 ## Run tests

dist/core.c

@@ -15,7 +15,7 @@ void instrument_hooks_deinit(InstrumentHooks *);
 bool instrument_hooks_is_instrumented(InstrumentHooks *);
 void instrument_hooks_start_benchmark(InstrumentHooks *);
 void instrument_hooks_stop_benchmark(InstrumentHooks *);
-void instrument_hooks_current_benchmark(InstrumentHooks *, int32_t pid, const char *uri);
+void instrument_hooks_executed_benchmark(InstrumentHooks *, int32_t pid, const char *uri);
 void instrument_hooks_set_integration(InstrumentHooks *, const char *name, const char *version);
 
 void callgrind_start_instrumentation();

includes/core.h

@@ -50,10 +50,10 @@ pub export fn instrument_hooks_stop_benchmark(hooks: ?*InstrumentHooks) void {
     }
 }
 
-pub export fn instrument_hooks_current_benchmark(hooks: ?*InstrumentHooks, pid: u32, uri: [*c]const u8) void {
+pub export fn instrument_hooks_executed_benchmark(hooks: ?*InstrumentHooks, pid: u32, uri: [*c]const u8) void {
     if (hooks) |h| {
-        h.current_benchmark(pid, uri) catch |err| {
-            std.debug.print("Failed to get current benchmark: {s}\n", .{@errorName(err)});
+        h.set_executed_benchmark(pid, uri) catch |err| {
+            std.debug.print("Failed to set executed benchmark: {s}\n", .{@errorName(err)});
         };
     }
 }
@@ -72,7 +72,7 @@ test "no crash when not instrumented" {
     _ = instrument_hooks_is_instrumented(instance);
     _ = instrument_hooks_start_benchmark(instance);
     _ = instrument_hooks_stop_benchmark(instance);
-    _ = instrument_hooks_current_benchmark(instance, 0, "test");
+    _ = instrument_hooks_executed_benchmark(instance, 0, "test");
     _ = instrument_hooks_set_integration(instance, "pytest-codspeed", "1.0");
 
     instrument_hooks_deinit(instance);

src/c.zig

@@ -49,8 +49,8 @@ pub const PerfInstrument = struct {
         try self.reader.waitForAck(null);
     }
 
-    pub fn current_benchmark(self: *Self, pid: u32, uri: [*c]const u8) !void {
-        try self.writer.sendCmd(fifo.Command{ .CurrentBenchmark = .{
+    pub fn set_executed_benchmark(self: *Self, pid: u32, uri: [*c]const u8) !void {
+        try self.writer.sendCmd(fifo.Command{ .ExecutedBenchmark = .{
             .pid = pid,
             .uri = std.mem.span(uri),
         } });
@@ -131,8 +131,8 @@ test "perf integration" {
     try std.testing.expect(si_result.equal(fifo.Command{ .SetIntegration = .{ .name = "zig", .version = "0.10.0" } }));
     si_result.deinit(allocator);
 
-    const cb_result = try tester.send(PerfInstrument.current_benchmark, .{ &perf, 42, "foo" });
-    try std.testing.expect(cb_result.equal(fifo.Command{ .CurrentBenchmark = .{ .pid = 42, .uri = "foo" } }));
+    const cb_result = try tester.send(PerfInstrument.set_executed_benchmark, .{ &perf, 42, "foo" });
+    try std.testing.expect(cb_result.equal(fifo.Command{ .ExecutedBenchmark = .{ .pid = 42, .uri = "foo" } }));
     cb_result.deinit(allocator);
 
     const start_result = try tester.send(PerfInstrument.start_benchmark, .{&perf});

src/instruments/perf.zig

@@ -61,10 +61,10 @@ pub const InstrumentHooks = union(enum) {
         }
     }
 
-    pub inline fn current_benchmark(self: *Self, pid: u32, uri: [*c]const u8) !void {
+    pub inline fn set_executed_benchmark(self: *Self, pid: u32, uri: [*c]const u8) !void {
         switch (self.*) {
-            .valgrind => ValgrindInstrument.current_benchmark(pid, uri),
-            .perf => try self.perf.current_benchmark(pid, uri),
+            .valgrind => ValgrindInstrument.set_executed_benchmark(pid, uri),
+            .perf => try self.perf.set_executed_benchmark(pid, uri),
             .none => {},
         }
     }

src/instruments/root.zig

@@ -35,7 +35,7 @@ pub const ValgrindInstrument = struct {
         valgrind.callgrind_stop_instrumentation();
     }
 
-    pub inline fn current_benchmark(pid: u32, uri: [*c]const u8) void {
+    pub inline fn set_executed_benchmark(pid: u32, uri: [*c]const u8) void {
         _ = pid;
         valgrind.callgrind_dump_stats_at(uri);
     }

src/instruments/valgrind.zig

@@ -6,7 +6,7 @@ pub const RUNNER_CTL_FIFO = "/tmp/runner.ctl.fifo";
 pub const RUNNER_ACK_FIFO = "/tmp/runner.ack.fifo";
 
 pub const Command = union(enum) {
-    CurrentBenchmark: struct {
+    ExecutedBenchmark: struct {
         pid: u32,
         uri: []const u8,
     },
@@ -26,7 +26,7 @@ pub const Command = union(enum) {
                 allocator.free(data.name);
                 allocator.free(data.version);
             },
-            .CurrentBenchmark => |data| allocator.free(data.uri),
+            .ExecutedBenchmark => |data| allocator.free(data.uri),
             else => {},
         }
     }
@@ -40,7 +40,7 @@ pub const Command = union(enum) {
         _ = fmt;
         _ = options;
         switch (self) {
-            .CurrentBenchmark => |data| try writer.print("CurrentBenchmark {{ pid: {d}, uri: {s} }}", .{ data.pid, data.uri }),
+            .ExecutedBenchmark => |data| try writer.print("ExecutedBenchmark {{ pid: {d}, uri: {s} }}", .{ data.pid, data.uri }),
             .StartBenchmark => try writer.writeAll("StartBenchmark"),
             .StopBenchmark => try writer.writeAll("StopBenchmark"),
             .Ack => try writer.writeAll("Ack"),
@@ -52,8 +52,8 @@ pub const Command = union(enum) {
 
     pub fn equal(self: Command, other: Command) bool {
         return switch (self) {
-            .CurrentBenchmark => |self_data| switch (other) {
-                .CurrentBenchmark => |other_data| self_data.pid == other_data.pid and
+            .ExecutedBenchmark => |self_data| switch (other) {
+                .ExecutedBenchmark => |other_data| self_data.pid == other_data.pid and
                     std.mem.eql(u8, self_data.uri, other_data.uri),
                 else => false,
             },

src/shared.zig

@@ -18,7 +18,7 @@
 mod shared {
     #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
     pub enum Command {
-        CurrentBenchmark { pid: u32, uri: String },
+        ExecutedBenchmark { pid: u32, uri: String },
         StartBenchmark,
         StopBenchmark,
         Ack,
@@ -47,7 +47,7 @@ fn main() {
 
     example(
         "cmd_cur_bench",
-        &shared::Command::CurrentBenchmark {
+        &shared::Command::ExecutedBenchmark {
             pid: 12345,
             uri: "http://example.com/benchmark".to_string(),
         },

src/tests/deserialize_rust/create_serialized.rs

@@ -15,7 +15,7 @@ fn assert_eq(serialized: []const u8, expected_cmd: Command) !void {
 test "rust deserialization" {
     const rust = @import("serialized.zig");
 
-    try assert_eq(rust.cmd_cur_bench, Command{ .CurrentBenchmark = .{
+    try assert_eq(rust.cmd_cur_bench, Command{ .ExecutedBenchmark = .{
         .pid = 12345,
         .uri = "http://example.com/benchmark",
     } });