trace: add backing file handle

src/scheduler.zig

@@ -1,9 +1,7 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const Node = @import("node.zig");
-const trace = @import("trace.zig");
+const Trace = @import("trace.zig").Trace;
-const Trace = trace.Trace;
-const TraceTaskState = trace.TraceTaskState;
 
 const Scheduler = @This();
 
@@ -98,7 +96,7 @@ pub fn deinit(self: *Scheduler) void {
     self.tasks.deinit(self.gpa);
 }
 
-fn traceTaskState(self: *Scheduler, task: *const Task, state: TraceTaskState, reason: []const u8) void {
+fn traceTaskState(self: *Scheduler, task: *const Task, state: Trace.TaskState, reason: []const u8) void {
     self.trace.taskState(task.id, task.node, state, reason);
 }
 

src/simulator.zig

@@ -36,7 +36,7 @@ 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.trace.init(real_io);
     self.prng = std.Random.DefaultPrng.init(seed);
     self.scheduler.init(gpa, &self.trace, &self.prng);
     self.network.init(gpa);

src/trace.zig

@@ -1,10 +1,13 @@
 const std = @import("std");
+const Io = std.Io;
 const Node = @import("node.zig");
 const TaskID = @import("scheduler.zig").TaskID;
 
 const PendingTrace = struct {};
 
-pub const TraceTaskState = enum {
+pub const Trace = struct {
+
+    pub const TaskState = enum {
         ready,
         running,
         sleeping,
@@ -12,42 +15,56 @@ pub const TraceTaskState = enum {
         waiting_task,
         failed,
         returned,
-};
+    };
 
-pub const Trace = struct {
+    io: Io,
-    pub fn init(self: *Trace) void {
+    file: ?Io.File,
-        _ = self;
+
+    pub fn init(self: *Trace, io: Io) void {
+        self.io = io;
+        self.file = null;
     }
 
     pub fn deinit(self: *Trace) void {
-        _ = self;
+        if (self.file == null) return;
+
+        self.file.?.close(self.io);
+    }
+
+    pub fn setOutputFile(self: *Trace, path: []const u8) void {
+        self.file = try Io.Dir.cwd().createFile(self.io, path, .{});
     }
 
     pub fn enterTask(self: *Trace, task_id: TaskID, node: *Node) void {
-        _ = self;
+        if (self.file == null) return;
+
         _ = task_id;
         _ = node;
     }
 
     pub fn leaveTask(self: *Trace) void {
-        _ = self;
+        if (self.file == null) return;
+
     }
 
     pub fn taskSpawned(self: *Trace, task_id: TaskID, node: *Node, parent_id: ?TaskID) void {
-        _ = self;
+        if (self.file == null) return;
+
         _ = task_id;
         _ = node;
         _ = parent_id;
     }
 
     pub fn taskRemoved(self: *Trace, task_id: TaskID, node: *Node) void {
-        _ = self;
+        if (self.file == null) return;
+
         _ = task_id;
         _ = node;
     }
 
-    pub fn taskState(self: *Trace, task_id: TaskID, node: *Node, state: TraceTaskState, reason: []const u8) void {
+    pub fn taskState(self: *Trace, task_id: TaskID, node: *Node, state: Trace.TaskState, reason: []const u8) void {
-        _ = self;
+        if (self.file == null) return;
+
         _ = task_id;
         _ = node;
         _ = state;
@@ -55,26 +72,30 @@ pub const Trace = struct {
     }
 
     pub fn timeAdvanced(self: *Trace, from: u64, to: u64) void {
-        _ = self;
+        if (self.file == null) return;
+
         _ = from;
         _ = to;
     }
 
     pub fn beginIO(self: *Trace, disk: bool, source: std.builtin.SourceLocation) PendingTrace {
-        _ = self;
+        if (self.file == null) return .{};
+
         _ = disk;
         _ = source;
         return .{};
     }
 
     pub fn failIO(self: *Trace, pending_trace: PendingTrace, e: anyerror) void {
-        _ = self;
+        if (self.file == null) return;
+
         _ = pending_trace;
-        _ = e;
+        _ = e catch {};
     }
 
     pub fn completeIO(self: *Trace, pending_trace: PendingTrace, result: anytype) void {
-        _ = self;
+        if (self.file == null) return;
+
         _ = pending_trace;
         _ = result;
     }