zba/src/scheduler.zig

104 lines
3.0 KiB
Zig
Raw Normal View History

2021-12-29 21:09:00 +00:00
const std = @import("std");
2022-01-07 23:49:58 +00:00
const Bus = @import("Bus.zig");
2022-01-02 03:08:36 +00:00
const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
2022-01-08 00:00:42 +00:00
2021-12-29 21:09:00 +00:00
const Order = std.math.Order;
const PriorityQueue = std.PriorityQueue;
const Allocator = std.mem.Allocator;
2022-02-11 05:33:33 +00:00
const log = std.log.scoped(.Scheduler);
2021-12-29 21:09:00 +00:00
pub const Scheduler = struct {
2022-01-10 03:34:33 +00:00
const Self = @This();
2021-12-29 21:09:00 +00:00
tick: u64,
queue: PriorityQueue(Event, void, lessThan),
2022-01-10 03:34:33 +00:00
pub fn init(alloc: Allocator) Self {
var sched = Self{ .tick = 0, .queue = PriorityQueue(Event, void, lessThan).init(alloc, {}) };
sched.push(.HeatDeath, std.math.maxInt(u64));
2021-12-29 21:09:00 +00:00
2022-01-10 03:34:33 +00:00
return sched;
2021-12-29 21:09:00 +00:00
}
2022-01-10 03:34:33 +00:00
pub fn deinit(self: Self) void {
2022-01-04 02:08:55 +00:00
self.queue.deinit();
}
2022-03-13 08:28:51 +00:00
pub inline fn now(self: *const Self) u64 {
return self.tick;
}
pub fn handleEvent(self: *Self, cpu: *Arm7tdmi, bus: *Bus) void {
2022-03-15 07:34:13 +00:00
if (self.queue.removeOrNull()) |event| {
2021-12-29 21:09:00 +00:00
switch (event.kind) {
.HeatDeath => {
2022-03-13 08:28:51 +00:00
log.err("A u64 overflowered. This *actually* should never happen.", .{});
unreachable;
2021-12-29 21:09:00 +00:00
},
.Draw => {
2022-03-15 07:34:13 +00:00
// The end of a VDraw
bus.ppu.drawScanline();
2022-03-15 07:34:13 +00:00
bus.ppu.handleHDrawEnd(cpu);
},
2022-03-13 08:28:51 +00:00
.TimerOverflow => |id| {
switch (id) {
0 => bus.tim._0.handleOverflow(cpu),
1 => bus.tim._1.handleOverflow(cpu),
2 => bus.tim._2.handleOverflow(cpu),
3 => bus.tim._3.handleOverflow(cpu),
2022-03-13 08:28:51 +00:00
}
},
2022-03-15 07:34:13 +00:00
.HBlank => bus.ppu.handleHBlankEnd(cpu), // The end of a HBlank
.VBlank => bus.ppu.handleHDrawEnd(cpu), // The end of a VBlank
2022-03-13 08:28:51 +00:00
}
}
}
2022-04-08 05:13:58 +00:00
/// Removes the **first** scheduled event of type `needle`
2022-03-13 08:28:51 +00:00
pub fn removeScheduledEvent(self: *Self, needle: EventKind) void {
var it = self.queue.iterator();
var i: usize = 0;
while (it.next()) |event| : (i += 1) {
if (std.meta.eql(event.kind, needle)) {
// This invalidates the iterator
_ = self.queue.removeIndex(i);
// Since removing something from the PQ invalidates the iterator,
// this implementation can safely only remove the first instance of
// a Scheduled Event. Exit Early
break;
2021-12-29 21:09:00 +00:00
}
}
}
2022-01-10 05:24:14 +00:00
pub fn push(self: *Self, kind: EventKind, end: u64) void {
2022-01-10 03:34:33 +00:00
self.queue.add(.{ .kind = kind, .tick = end }) catch unreachable;
}
2022-01-10 05:24:14 +00:00
pub fn nextTimestamp(self: *Self) u64 {
2022-03-15 07:34:13 +00:00
if (self.queue.peek()) |e| return e.tick;
unreachable; // There's always the HeatDeath event scheduled
2021-12-29 21:09:00 +00:00
}
};
pub const Event = struct {
kind: EventKind,
tick: u64,
};
2022-01-02 03:08:36 +00:00
fn lessThan(_: void, a: Event, b: Event) Order {
2021-12-29 21:09:00 +00:00
return std.math.order(a.tick, b.tick);
}
2022-03-13 08:28:51 +00:00
pub const EventKind = union(enum) {
2021-12-29 21:09:00 +00:00
HeatDeath,
HBlank,
VBlank,
Draw,
2022-03-13 08:28:51 +00:00
TimerOverflow: u2,
2021-12-29 21:09:00 +00:00
};