Fixed-priority preemptive scheduler

src/tests.zig

@@ -14,6 +14,7 @@ const danos = @import("danos");
 const arch = @import("arch");
 const pmm = @import("pmm.zig");
 const heap = @import("heap.zig");
+const sched = @import("sched.zig");
 
 /// Formatted write straight to serial, independent of the framebuffer console.
 fn log(comptime fmt: []const u8, args: anytype) void {
@@ -55,6 +56,10 @@ pub fn run(case: []const u8, boot_info: *const BootInfo) void {
         vmm();
     } else if (eql(case, "heap")) {
         heapTest();
+    } else if (eql(case, "sched")) {
+        schedTest();
+    } else if (eql(case, "priority")) {
+        priorityTest();
     } else if (eql(case, "fault-ud")) {
         faultInvalidOpcode();
     } else if (eql(case, "fault-pf")) {
@@ -227,6 +232,82 @@ fn clock() void {
     result();
 }
 
+// --- scheduler tests ------------------------------------------------------
+
+var counters = [_]u64{0} ** 3;
+
+fn spin0() void {
+    const p: *volatile u64 = &counters[0];
+    while (true) p.* = p.* +% 1;
+}
+fn spin1() void {
+    const p: *volatile u64 = &counters[1];
+    while (true) p.* = p.* +% 1;
+}
+fn spin2() void {
+    const p: *volatile u64 = &counters[2];
+    while (true) p.* = p.* +% 1;
+}
+
+/// Preemption: spawn three tasks that busy-loop *without* yielding. If they all
+/// make progress, the timer must be preempting between them (and the context
+/// switch works) — because nothing yields voluntarily.
+fn schedTest() void {
+    log("DANOS-TEST-BEGIN: sched\n", .{});
+    counters = .{ 0, 0, 0 };
+    sched.spawn(spin0, 4);
+    sched.spawn(spin1, 4);
+    sched.spawn(spin2, 4);
+
+    const c0: *volatile u64 = &counters[0];
+    const c1: *volatile u64 = &counters[1];
+    const c2: *volatile u64 = &counters[2];
+    var spins: u64 = 0;
+    while ((c0.* == 0 or c1.* == 0 or c2.* == 0) and spins < 5_000_000_000) spins +%= 1;
+
+    check("all three non-yielding tasks made progress (preemption)", c0.* > 0 and c1.* > 0 and c2.* > 0);
+    result();
+}
+
+var run_order = [_]u8{0} ** 4;
+var run_n: usize = 0;
+
+fn recordExit(priority: u8) void {
+    run_order[run_n] = priority;
+    run_n += 1;
+    sched.exit();
+}
+fn taskHigh() void {
+    recordExit(6);
+}
+fn taskMid() void {
+    recordExit(4);
+}
+fn taskLow() void {
+    recordExit(2);
+}
+
+/// Fixed priority: with preemption off (deterministic), spawn tasks at three
+/// priorities and let them run cooperatively. They must run highest-first.
+fn priorityTest() void {
+    log("DANOS-TEST-BEGIN: priority\n", .{});
+    sched.setPreemption(false);
+    sched.setPriority(0); // run this observer task last, after all workers
+    run_n = 0;
+
+    sched.spawn(taskLow, 2);
+    sched.spawn(taskMid, 4);
+    sched.spawn(taskHigh, 6);
+
+    while (run_n < 3) sched.yield(); // regain control only once the workers are done
+
+    check("tasks ran highest-priority first", run_order[0] == 6 and run_order[1] == 4 and run_order[2] == 2);
+
+    sched.setPriority(4);
+    sched.setPreemption(true);
+    result();
+}
+
 fn faultInvalidOpcode() void {
     log("DANOS-TEST-BEGIN: fault-ud\n", .{});
     asm volatile ("ud2");