use super::Clock;
use crate::{Emulator, Result};
pub const MAX_BEHIND_MS: f64 = 12.0 * 3600.0 * 1000.0;
const MAX_DELAY_MS: f64 = 2_147_483_647.0;
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Pacing {
pub pass_ms: f64,
pub pass_budget_ms: f64,
pub max_budget_ms: f64,
pub max_emulated_ms: f64,
pub max_wall_ms: f64,
pub wake_budget_ms: f64,
pub hidden_wake_budget_ms: f64,
pub frame_ms: f64,
pub typing_tick_ms: f64,
pub pauses_when_hidden: bool,
pub timer_slack_ms: f64,
}
impl Pacing {
pub const WORKER: Pacing = Pacing {
pass_ms: 1000.0 / 60.0,
pass_budget_ms: 22.0,
max_budget_ms: 11.0,
max_emulated_ms: 1000.0,
max_wall_ms: 100.0,
wake_budget_ms: 22.0,
hidden_wake_budget_ms: 200.0,
frame_ms: 0.0,
typing_tick_ms: 40.0,
pauses_when_hidden: true,
timer_slack_ms: 1.0,
};
pub const NATIVE: Pacing = Pacing {
pass_ms: 1.0,
pass_budget_ms: 4.0,
max_budget_ms: 11.0,
max_emulated_ms: 1000.0,
max_wall_ms: 100.0,
wake_budget_ms: 22.0,
hidden_wake_budget_ms: 22.0,
frame_ms: 16.0,
typing_tick_ms: 16.0,
pauses_when_hidden: false,
timer_slack_ms: 0.0,
};
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Speed {
#[default]
One,
Two,
Four,
Max,
}
impl Speed {
pub fn parse(s: &str) -> Speed {
match s {
"2" => Speed::Two,
"4" => Speed::Four,
"max" => Speed::Max,
_ => Speed::One,
}
}
pub fn name(self) -> &'static str {
match self {
Speed::One => "1",
Speed::Two => "2",
Speed::Four => "4",
Speed::Max => "max",
}
}
fn factor(self) -> f64 {
match self {
Speed::One | Speed::Max => 1.0,
Speed::Two => 2.0,
Speed::Four => 4.0,
}
}
}
impl serde::Serialize for Speed {
fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
s.serialize_str(self.name())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "lowercase")]
pub enum LoopState {
Frame,
Sleep,
Stopped,
}
pub(crate) trait Core {
fn run_slice(&mut self, left_ms: f64, keys: bool) -> Result<f64>;
fn idle_ms(&self) -> Option<f64>;
fn keys_busy(&self) -> bool;
fn keys_held(&self) -> bool;
fn cycles(&self) -> u64;
fn memory_changes(&self) -> Result<u64>;
}
impl Core for Emulator {
fn run_slice(&mut self, left_ms: f64, keys: bool) -> Result<f64> {
Emulator::run_slice(self, left_ms, keys)
}
fn idle_ms(&self) -> Option<f64> {
Emulator::idle_ms(self)
}
fn keys_busy(&self) -> bool {
Emulator::keys_busy(self)
}
fn keys_held(&self) -> bool {
Emulator::keys_held(self)
}
fn cycles(&self) -> u64 {
self.machine().cycles()
}
fn memory_changes(&self) -> Result<u64> {
Emulator::memory_changes(self)
}
}
pub(crate) fn asleep(core: &impl Core) -> bool {
core.idle_ms().is_some() && !core.keys_busy()
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum Timer {
Pass(f64),
Wake(f64),
}
#[derive(Clone, Debug)]
pub(crate) struct Loop {
pub pacing: Pacing,
pub running: bool,
pub speed: Speed,
pub hidden: bool,
timer: Option<Timer>,
last_pass: Option<f64>,
slept_at: f64,
behind_ms: f64,
pub work_ms: f64,
pub ticks: u64,
pub wakes: u64,
}
impl Loop {
pub fn new(pacing: Pacing) -> Loop {
Loop {
pacing,
running: false,
speed: Speed::One,
hidden: false,
timer: None,
last_pass: None,
slept_at: 0.0,
behind_ms: 0.0,
work_ms: 0.0,
ticks: 0,
wakes: 0,
}
}
pub fn due(&self) -> Option<f64> {
match self.timer {
Some(Timer::Pass(t) | Timer::Wake(t)) => Some(t),
None => None,
}
}
pub fn state(&self) -> LoopState {
match self.timer {
Some(Timer::Pass(_)) => LoopState::Frame,
Some(Timer::Wake(_)) => LoopState::Sleep,
None => LoopState::Stopped,
}
}
pub fn passing(&self) -> bool {
matches!(self.timer, Some(Timer::Pass(_)))
}
pub fn sleeping(&self) -> bool {
matches!(self.timer, Some(Timer::Wake(_)))
}
fn held(&self) -> bool {
self.hidden && self.pacing.pauses_when_hidden
}
pub fn owed_ms(&self, now: f64) -> f64 {
self.behind_ms
+ if self.sleeping() {
now - self.slept_at
} else {
0.0
}
}
pub fn behind_ms(&self) -> f64 {
self.behind_ms
}
pub fn stop(&mut self) {
self.timer = None;
self.last_pass = None;
self.behind_ms = 0.0;
}
pub fn start(&mut self, core: &impl Core, now: f64) {
if !self.running {
return;
}
if self.held() {
self.schedule(core, now);
} else {
self.timer = Some(Timer::Pass(now));
}
}
pub fn set_hidden(&mut self, hidden: bool, core: Option<&impl Core>, idle: bool, now: f64) {
if !self.pacing.pauses_when_hidden {
return;
}
self.hidden = hidden;
if let Some(core) = core
&& !hidden
&& self.running
&& self.timer.is_none()
&& idle
{
self.schedule(core, now);
}
}
pub fn clock_pace(&self) -> crate::clock::Pace {
let p = &self.pacing;
let (speed, budget) = if self.speed == Speed::Max {
(p.max_emulated_ms / p.pass_ms, p.max_budget_ms)
} else {
(self.speed.factor(), p.pass_budget_ms)
};
crate::clock::Pace {
speed,
share: (budget / p.pass_ms).min(1.0),
pass_ms: if self.speed == Speed::Max {
p.max_emulated_ms
} else {
p.pass_ms * speed
},
}
}
pub fn fire(&mut self, core: &mut impl Core, clock: &dyn Clock, now: f64) -> Result<()> {
let slack = self.pacing.timer_slack_ms;
match self.timer {
Some(Timer::Pass(t)) if t <= now + slack => self.pass(core, clock),
Some(Timer::Wake(t)) if t <= now + slack => self.wake(core, clock),
_ => Ok(()),
}
}
fn run_slices(
&mut self,
core: &mut impl Core,
clock: &dyn Clock,
ms: f64,
budget_ms: f64,
keys: bool,
until_sleep: bool,
) -> Result<f64> {
let start = clock.now_ms();
let mut left = ms;
let result = (|| {
while left > 0.0 && !(until_sleep && asleep(core)) {
left -= core.run_slice(left, keys)?;
if clock.now_ms() - start > budget_ms {
break;
}
}
Ok(())
})();
self.work_ms += clock.now_ms() - start;
result.map(|()| left.max(0.0))
}
fn pass(&mut self, core: &mut impl Core, clock: &dyn Clock) -> Result<()> {
self.timer = None;
let t = clock.now_ms();
let wall = self
.last_pass
.map_or(0.0, |l| (t - l).clamp(0.0, self.pacing.max_wall_ms));
self.last_pass = Some(t);
if !self.running {
return Ok(());
}
self.ticks += 1;
let speed = if core.keys_held() {
Speed::One
} else {
self.speed
};
let max = speed == Speed::Max;
let budget = if max {
self.pacing.max_budget_ms
} else {
self.pacing.pass_budget_ms
};
self.behind_ms = self.run_slices(core, clock, self.behind_ms, budget, true, false)?;
if self.behind_ms == 0.0 {
let factor = speed.factor();
let own = if max {
self.pacing.max_emulated_ms
} else {
wall * factor
};
let rest = (budget - (clock.now_ms() - t)).max(0.0);
let left = self.run_slices(core, clock, own, rest, true, true)?;
if !max && asleep(core) {
self.last_pass = Some(t - left / factor);
}
}
self.schedule(core, clock.now_ms());
Ok(())
}
pub fn schedule(&mut self, core: &impl Core, now: f64) {
if !self.running {
return;
}
match core.idle_ms() {
Some(idle) if !core.keys_busy() => {
if !(self.sleeping() && self.last_pass.is_none()) {
self.slept_at = self.last_pass.unwrap_or(now);
}
self.last_pass = None;
let delay = if self.behind_ms > 0.0 {
0.0
} else {
idle.min(MAX_DELAY_MS) + 1.0
};
self.timer = Some(Timer::Wake(now + delay));
}
_ => {
if !self.passing() && !self.held() {
let due = self
.last_pass
.map_or(now, |l| (l + self.pacing.pass_ms).max(now));
self.timer = Some(Timer::Pass(due));
}
}
}
}
pub fn wake(&mut self, core: &mut impl Core, clock: &dyn Clock) -> Result<()> {
if !self.running || !self.sleeping() {
return Ok(());
}
self.timer = None;
self.wakes += 1;
let now = clock.now_ms();
self.behind_ms = (self.behind_ms + (now - self.slept_at)).min(MAX_BEHIND_MS);
let budget = if self.hidden {
self.pacing.hidden_wake_budget_ms
} else {
self.pacing.wake_budget_ms
};
self.behind_ms = self.run_slices(core, clock, self.behind_ms, budget, false, false)?;
self.last_pass = Some(now);
self.schedule(core, clock.now_ms());
Ok(())
}
}