From bdea19f280c5ef31aad4023bde069e009c839ffc Mon Sep 17 00:00:00 2001 From: Rekai Musuka Date: Tue, 15 Mar 2022 02:29:18 -0300 Subject: [PATCH] chore: create different types of emuloops --- src/emu.zig | 142 ++++++++++++++++++++++++++++++++++++--------------- src/main.zig | 2 +- 2 files changed, 102 insertions(+), 42 deletions(-) diff --git a/src/emu.zig b/src/emu.zig index 7489e5a..011881a 100644 --- a/src/emu.zig +++ b/src/emu.zig @@ -8,17 +8,32 @@ const Timer = std.time.Timer; const Thread = std.Thread; const Atomic = std.atomic.Atomic; +// One frame operates at 59.7275005696Hz const cycles_per_frame: u64 = 228 * (308 * 4); const clock_rate: u64 = 1 << 24; const clock_period: u64 = std.time.ns_per_s / clock_rate; const frame_period = (clock_period * cycles_per_frame); -const sync_to_video: bool = true; - -// One frame operates at 59.7275005696Hz - const log = std.log.scoped(.Emulation); +const RunKind = enum { + Unlimited, + UnlimitedFPS, + Limited, + LimitedFPS, + LimitedBusy, +}; + +pub fn run(kind: RunKind, quit: *Atomic(bool), pause: *Atomic(bool), fps: *Atomic(u64), sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void { + switch (kind) { + .Unlimited => runUnSync(quit, pause, sched, cpu, bus), + .Limited => runSync(quit, pause, sched, cpu, bus), + .UnlimitedFPS => runUnSyncFps(quit, pause, fps, sched, cpu, bus), + .LimitedFPS => runSyncFps(quit, pause, fps, sched, cpu, bus), + .LimitedBusy => runBusyLoop(quit, pause, sched, cpu, bus), + } +} + pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void { var cycles: u64 = 0; while (cycles < cycles_per_frame) : (cycles += 1) { @@ -31,63 +46,108 @@ pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void { } } -pub fn runEmuThread(quit: *Atomic(bool), pause: *Atomic(bool), fps: *Atomic(u64), sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void { - var timer = Timer.start() catch unreachable; - var fps_timer = Timer.start() catch unreachable; +pub fn runUnSync(quit: *Atomic(bool), pause: *Atomic(bool), sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void { + log.info("Unsynchronized EmuThread has begun", .{}); + while (!quit.load(.Unordered)) if (!pause.load(.Unordered)) runFrame(sched, cpu, bus); +} +pub fn runSync(quit: *Atomic(bool), pause: *Atomic(bool), sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void { + log.info("Synchronized EmuThread has begun", .{}); + var timer = Timer.start() catch unreachable; var wake_time: u64 = frame_period; - log.info("EmuThread has begun execution", .{}); + while (!quit.load(.Unordered)) if (!pause.load(.Unordered)) { + runFrame(sched, cpu, bus); - while (!quit.load(.Unordered)) { - if (!pause.load(.Unordered)) { - runFrame(sched, cpu, bus); + // Put the Thread to Sleep + Backup Spin Loop + // This saves on resource usage when frame limiting + sleep(&timer, &wake_time); - const timestamp = timer.read(); - fps.store(emuFps(fps_timer.lap()), .Unordered); + // Update to the new wake time + wake_time += frame_period; + }; +} - // ns_late is non zero if we are late. - var ns_late = timestamp -| wake_time; +pub fn runUnSyncFps(quit: *Atomic(bool), pause: *Atomic(bool), fps: *Atomic(u64), sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void { + log.info("Unsynchronized EmuThread with FPS Tracking has begun", .{}); + var fps_timer = Timer.start() catch unreachable; - // log.info("timestamp: {} | late: {}", .{ timestamp, ns_late }); + while (!quit.load(.Unordered)) if (!pause.load(.Unordered)) { + runFrame(sched, cpu, bus); + fps.store(emuFps(fps_timer.lap()), .Unordered); + }; +} - // If we're more than a frame late, skip the rest of this loop - // Recalculate what our new wake time should be so that we can - // get "back on track" - if (ns_late > frame_period) { - wake_time = timestamp + frame_period; - continue; - } +pub fn runSyncFps(quit: *Atomic(bool), pause: *Atomic(bool), fps: *Atomic(u64), sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void { + log.info("Synchronized EmuThread has begun", .{}); + var timer = Timer.start() catch unreachable; + var fps_timer = Timer.start() catch unreachable; + var wake_time: u64 = frame_period; - if (sync_to_video) { - // Employ several sleep calls in periods of 10ms - // By doing this the behaviour should average out to be - // more consistent + while (!quit.load(.Unordered)) if (!pause.load(.Unordered)) { + runFrame(sched, cpu, bus); - const sleep_for = frame_period - ns_late; - const loop_count = sleep_for / (std.time.ns_per_ms * 10); // How many groups of 10ms + // Put the Thread to Sleep + Backup Spin Loop + // This saves on resource usage when frame limiting + sleep(&timer, &wake_time); - var i: usize = 0; - while (i < loop_count) : (i += 1) { - std.time.sleep(std.time.ns_per_ms * 10); - } + // Determine FPS + fps.store(emuFps(fps_timer.lap()), .Unordered); - // Spin to make up the difference if there is a need - // Make sure that we're using the old wake time and not the onne we recalcualted - spinLoop(&timer, wake_time); - } + // Update to the new wake time + wake_time += frame_period; + }; +} - // Update to the new wake time - wake_time += frame_period; - } +pub fn runBusyLoop(quit: *Atomic(bool), pause: *Atomic(bool), sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void { + log.info("Run EmuThread with spin-loop sync", .{}); + var timer = Timer.start() catch unreachable; + var wake_time: u64 = frame_period; + + while (!quit.load(.Unordered)) if (!pause.load(.Unordered)) { + runFrame(sched, cpu, bus); + spinLoop(&timer, wake_time); + + // Update to the new wake time + wake_time += frame_period; + }; +} + +fn sleep(timer: *Timer, wake_time: *u64) void { + const step = std.time.ns_per_ms * 10; + const timestamp = timer.read(); + + // ns_late is non zero if we are late. + const ns_late = timestamp -| wake_time.*; + + // If we're more than a frame late, skip the rest of this loop + // Recalculate what our new wake time should be so that we can + // get "back on track" + if (ns_late > frame_period) { + wake_time.* = timestamp + frame_period; + return; } + + const sleep_for = frame_period - ns_late; + + // Employ several sleep calls in periods of 10ms + // By doing this the behaviour should average out to be + // more consistent + const loop_count = sleep_for / step; // How many groups of 10ms + + var i: usize = 0; + while (i < loop_count) : (i += 1) std.time.sleep(step); + + // Spin to make up the difference if there is a need + // Make sure that we're using the old wake time and not the onne we recalculated + spinLoop(timer, wake_time.*); } fn spinLoop(timer: *Timer, wake_time: u64) void { while (true) if (timer.read() > wake_time) break; } -fn emuFps(left: u64) u64 { +inline fn emuFps(left: u64) u64 { @setRuntimeSafety(false); return @floatToInt(u64, @intToFloat(f64, std.time.ns_per_s) / @intToFloat(f64, left)); } diff --git a/src/main.zig b/src/main.zig index 79beee9..37157b6 100644 --- a/src/main.zig +++ b/src/main.zig @@ -88,7 +88,7 @@ pub fn main() anyerror!void { var emu_fps = Atomic(u64).init(0); // Create Emulator Thread - const emu_thread = try Thread.spawn(.{}, emu.runEmuThread, .{ &quit, &pause, &emu_fps, &scheduler, &cpu, &bus }); + const emu_thread = try Thread.spawn(.{}, emu.run, .{ .LimitedFPS, &quit, &pause, &emu_fps, &scheduler, &cpu, &bus }); defer emu_thread.join(); // Initialize SDL