ke/timer: make DPC parameter explicit

src/ex/work.zig

@@ -221,7 +221,7 @@ fn work_dpc(dpc: *ke.Dpc, _: ?*anyopaque) void {
 
 /// Enqueue a work item in `time`.
 pub fn enqueue_in(item: *DelayedWorkItem, time: r.Nanoseconds) void {
-    ke.timer.set(&item.timer, time, &item.dpc);
+    ke.timer.set(&item.timer, time, .{ .dpc = &item.dpc });
 }
 
 /// Enqueue a work item to be executed eventually.

src/kern/dpc.zig

@@ -111,13 +111,21 @@ fn dispatch_queue(cpu: u32) void {
     }
 
     if (sched_cpu.start_timer) {
-        ke.timer.set(&sched_cpu.resched_timer, std.time.ns_per_ms * config.sched_timeslice, &sched_cpu.resched_dpc);
+        ke.timer.set(
+            &sched_cpu.resched_timer,
+            std.time.ns_per_ms * config.sched_timeslice,
+            .{ .dpc = &sched_cpu.resched_dpc },
+        );
     }
 
     if (sched_cpu.preemption_reason == .HigherPriority) {
         // Reload the quantum for the new thread.
         ke.timer.cancel(&sched_cpu.resched_timer);
-        ke.timer.set(&sched_cpu.resched_timer, std.time.ns_per_ms * config.sched_timeslice, &sched_cpu.resched_dpc);
+        ke.timer.set(
+            &sched_cpu.resched_timer,
+            std.time.ns_per_ms * config.sched_timeslice,
+            .{ .dpc = &sched_cpu.resched_dpc },
+        );
     }
 
     sched_cpu.start_timer = false;

src/kern/sched.zig

@@ -683,7 +683,11 @@ comptime {
 /// Called on CPU 0 to initialize load balancing mechanisms.
 pub fn late_init() linksection(r.init) void {
     balance_timer.init();
-    ke.timer.set(&balance_timer, balance_interval * std.time.ns_per_ms, &balance_dpc);
+    ke.timer.set(
+        &balance_timer,
+        balance_interval * std.time.ns_per_ms,
+        .{ .dpc = &balance_dpc },
+    );
 }
 
 fn calendar_queue_increment(cpu: *PerCpu) void {
@@ -1451,5 +1455,5 @@ fn balance(_: *ke.Dpc, _: ?*anyopaque) void {
     const offset = lcg.next() % balance_interval;
     const ms = (balance_interval) + offset;
 
-    ke.timer.set(&balance_timer, ms * std.time.ns_per_ms, &balance_dpc);
+    ke.timer.set(&balance_timer, ms * std.time.ns_per_ms, .{ .dpc = &balance_dpc });
 }

src/kern/timer.zig

@@ -58,9 +58,13 @@ const percpu = ke.CpuLocal(PerCpu, .{
     .dpc = .init(handle_expiry),
 });
 
+const Options = struct {
+    dpc: ?*ke.Dpc = null,
+};
+
 /// Start a timer with an expiration time.
 /// A DPC that will be enqueued upon expiration can be passed.
-pub fn set(timer: *Timer, time: r.Nanoseconds, dpc: ?*ke.Dpc) void {
+pub fn set(timer: *Timer, time: r.Nanoseconds, opts: Options) void {
     const ipl = timer.hdr.lock.acquire();
     defer timer.hdr.lock.release(ipl);
 
@@ -78,7 +82,7 @@ pub fn set(timer: *Timer, time: r.Nanoseconds, dpc: ?*ke.Dpc) void {
     timer.deadline = ke.time.read_time() + time;
 
     timer.cpu = cpu;
-    timer.dpc = dpc;
+    timer.dpc = opts.dpc;
     timer.hdr.signaled = 0;
 
     cpu.timers.insert(&timer.node);

src/tests/fireworks.zig

@@ -100,7 +100,7 @@ fn get_random_color() u32 {
 fn perform_delay(ms: usize) void {
     var timer: ke.Timer = undefined;
     timer.init();
-    ke.timer.set(&timer, std.time.ns_per_ms * ms, null);
+    ke.timer.set(&timer, std.time.ns_per_ms * ms, .{});
     _ = ke.wait.wait_one(&timer.hdr, null) catch unreachable;
 }
 

src/tests/mutex.zig

@@ -34,7 +34,7 @@ fn rand(state: *u64) u64 {
 fn delay_ms(ms: usize) void {
     var timer: ke.Timer = undefined;
     timer.init();
-    ke.timer.set(&timer, std.time.ns_per_ms * ms, null);
+    ke.timer.set(&timer, std.time.ns_per_ms * ms, .{});
     _ = ke.wait.wait_one(&timer.hdr, null) catch unreachable;
 }
 

src/tests/smr.zig

@@ -41,7 +41,7 @@ fn seed_from(param: ?*anyopaque) u64 {
 fn delay_ms(ms: usize) void {
     var timer: ke.Timer = undefined;
     timer.init();
-    ke.timer.set(&timer, std.time.ns_per_ms * ms, null);
+    ke.timer.set(&timer, std.time.ns_per_ms * ms, .{});
     _ = ke.wait.wait_one(&timer.hdr, null) catch unreachable;
 }
 

src/tests/smr_pi.zig

@@ -63,7 +63,7 @@ fn seed_from(param: ?*anyopaque) u64 {
 fn delay_ms(ms: usize) void {
     var timer: ke.Timer = undefined;
     timer.init();
-    ke.timer.set(&timer, std.time.ns_per_ms * ms, null);
+    ke.timer.set(&timer, std.time.ns_per_ms * ms, .{});
     _ = ke.wait.wait_one(&timer.hdr, null) catch unreachable;
 }
 

src/tests/turnstile.zig

@@ -45,7 +45,7 @@ fn rand(state: *u64) u64 {
 fn delay_ms(ms: usize) void {
     var timer: ke.Timer = undefined;
     timer.init();
-    ke.timer.set(&timer, std.time.ns_per_ms * ms, null);
+    ke.timer.set(&timer, std.time.ns_per_ms * ms, .{});
     _ = ke.wait.wait_one(&timer.hdr, null) catch unreachable;
 }