chore: create different types of emuloops
This commit is contained in:
parent
5579643d65
commit
bdea19f280
142
src/emu.zig
142
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));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue