trace: add dummy implementation of the tracing object

src/node.zig

@@ -4,6 +4,7 @@ const Allocator = std.mem.Allocator;
 const FileSystem = @import("file_system.zig");
 const Network = @import("network.zig");
 const Scheduler = @import("scheduler.zig");
+const Trace = @import("trace.zig").Trace;
 const ioInterface = @import("io_interface.zig");
 
 const MAX_DESCRIPTORS = 1 << 10;
@@ -62,6 +63,7 @@ const Descriptor = struct {
 };
 
 gpa: Allocator,
+trace: *Trace,
 prng: *std.Random.DefaultPrng,
 local_time: u64,
 arena: std.heap.ArenaAllocator,
@@ -112,8 +114,9 @@ fn splitCommandArguments(command: []const u8, arena: Allocator) Allocator.Error!
     return result;
 }
 
-pub fn init(self: *Node, real_io: std.Io, prng: *std.Random.DefaultPrng, scheduler: *Scheduler, network: *Network, command: []const u8, addresses: []const u32, gpa: Allocator) !void {
+pub fn init(self: *Node, real_io: std.Io, trace: *Trace, prng: *std.Random.DefaultPrng, scheduler: *Scheduler, network: *Network, command: []const u8, addresses: []const u32, gpa: Allocator) !void {
     self.gpa = gpa;
+    self.trace = trace;
     self.prng = prng;
     self.local_time = 0;
     self.arena = .init(gpa);

src/scheduler.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const Node = @import("node.zig");
+const Trace = @import("trace.zig").Trace;
 
 const Scheduler = @This();
 
@@ -70,6 +71,7 @@ const Task = struct {
 };
 
 gpa: Allocator,
+trace: *Trace,
 prng: *std.Random.DefaultPrng,
 tasks: std.ArrayList(Task),
 regs: Registers,
@@ -77,8 +79,9 @@ current_id: ?TaskID,
 current_time: u64,
 next_task_id: u64,
 
-pub fn init(self: *Scheduler, gpa: Allocator, prng: *std.Random.DefaultPrng) void {
+pub fn init(self: *Scheduler, gpa: Allocator, trace: *Trace, prng: *std.Random.DefaultPrng) void {
     self.gpa = gpa;
+    self.trace = trace;
     self.prng = prng;
     self.tasks = .empty;
     self.current_id = null;

src/simulator.zig

@@ -3,6 +3,7 @@ const Simulator = @This();
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 
+const Trace = @import("trace.zig").Trace;
 const Scheduler = @import("scheduler.zig");
 const Network   = @import("network.zig");
 const Node      = @import("node.zig");
@@ -25,6 +26,7 @@ const ExecutableName = struct {
 };
 
 gpa: Allocator,
+trace: Trace,
 prng: std.Random.DefaultPrng,
 scheduler: Scheduler,
 network: Network,
@@ -34,8 +36,9 @@ real_io: std.Io,
 
 pub fn init(self: *Simulator, gpa: Allocator, real_io: std.Io, seed: u64) void {
     self.gpa = gpa;
+    self.trace.init();
     self.prng = std.Random.DefaultPrng.init(seed);
-    self.scheduler.init(gpa, &self.prng);
+    self.scheduler.init(gpa, &self.trace, &self.prng);
     self.network.init(gpa);
     self.nodes = .empty;
     self.executables = .empty;
@@ -51,6 +54,7 @@ pub fn deinit(self: *Simulator) void {
     self.nodes.deinit(self.gpa);
     self.network.deinit();
     self.scheduler.deinit();
+    self.trace.deinit();
 }
 
 pub fn addExecutable(self: *Simulator, name: []const u8, entry: EntryPoint) Allocator.Error!void {
@@ -67,7 +71,7 @@ pub fn spawn(self: *Simulator, command: []const u8, options: SpawnOptions) Spawn
     const node = try self.gpa.create(Node);
     errdefer self.gpa.destroy(node);
 
-    try node.init(self.real_io, &self.prng, &self.scheduler, &self.network, command, options.addresses, self.gpa);
+    try node.init(self.real_io, &self.trace, &self.prng, &self.scheduler, &self.network, command, options.addresses, self.gpa);
 
     try self.nodes.append(self.gpa, node);
     errdefer _ = self.nodes.swapRemove(self.nodes.items.len-1);

src/trace.zig

@@ -0,0 +1,32 @@
+const std = @import("std");
+
+const PendingTrace = struct {};
+
+pub const Trace = struct {
+    pub fn init(self: *Trace) void {
+        _ = self;
+    }
+
+    pub fn deinit(self: *Trace) void {
+        _ = self;
+    }
+
+    pub fn beginIO(self: *Trace, disk: bool, source: std.builtin.SourceLocation) PendingTrace {
+        _ = self;
+        _ = disk;
+        _ = source;
+        return .{};
+    }
+
+    pub fn failIO(self: *Trace, pending_trace: PendingTrace, e: anyerror) void {
+        _ = self;
+        _ = pending_trace;
+        _ = e;
+    }
+
+    pub fn completeIO(self: *Trace, pending_trace: PendingTrace, result: anytype) void {
+        _ = self;
+        _ = pending_trace;
+        _ = result;
+    }
+};