Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

hazel's fps counter

Layle14b56fd982e3
diff --git a/Cargo.lock b/Cargo.lock
index 40a9941..5e4002f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1238,17 +1238,6 @@ dependencies = [
"winit",
]
-[[package]]
-name = "egui_plot"
-version = "0.34.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67fc9b427a837264e55381a5cade6e28fe83ac5b165a61b9c888548c732a9c95"
-dependencies = [
- "ahash",
- "egui",
- "emath",
-]
-
[[package]]
name = "either"
version = "1.15.0"
@@ -3928,12 +3917,10 @@ dependencies = [
"backend-wgpu",
"clap",
"cpal",
- "crossbeam-channel",
"ctrlc",
"egui",
"egui-wgpu",
"egui-winit",
- "egui_plot",
"gecko",
"image 0.1.0",
"pollster",
diff --git a/crates/gecko/Cargo.toml b/crates/gecko/Cargo.toml
index ea790d3..626ee38 100644
--- a/crates/gecko/Cargo.toml
+++ b/crates/gecko/Cargo.toml
@@ -24,6 +24,7 @@ jit = [
"dep:cranelift-native",
]
jit-stats = ["jit"]
+fps-counter = []
[build-dependencies]
chipi-build = "0.9.1"
diff --git a/crates/gecko/src/fps.rs b/crates/gecko/src/fps.rs
new file mode 100644
index 0000000..831aa75
--- /dev/null
+++ b/crates/gecko/src/fps.rs
@@ -0,0 +1,82 @@
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Instant;
+
+use crate::flipper::vi::regs::RefreshRate;
+use crate::scheduler::cpu_clock;
+use crate::system::{System, SystemId};
+
+pub type FpsShared = Arc<AtomicU64>;
+
+pub struct FpsCounter {
+ pub vsync_count: u32,
+ pub last_tick: Instant,
+ pub shared: FpsShared,
+}
+
+impl FpsCounter {
+ pub fn new() -> Self {
+ Self {
+ vsync_count: 0,
+ last_tick: Instant::now(),
+ shared: Arc::new(AtomicU64::new(0)),
+ }
+ }
+
+ pub fn shared(&self) -> FpsShared {
+ Arc::clone(&self.shared)
+ }
+}
+
+impl Default for FpsCounter {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+#[inline(always)]
+fn pack(fps: f32, native_pct: f32) -> u64 {
+ ((fps.to_bits() as u64) << 32) | native_pct.to_bits() as u64
+}
+
+#[inline(always)]
+pub fn read(shared: &FpsShared) -> (f32, f32) {
+ let packed = shared.load(Ordering::Relaxed);
+ let fps = f32::from_bits((packed >> 32) as u32);
+ let native_pct = f32::from_bits(packed as u32);
+ (fps, native_pct)
+}
+
+pub fn fps_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {
+ let now = Instant::now();
+ let elapsed = now.duration_since(sys.fps_counter.last_tick).as_secs_f64();
+ let vsyncs = sys.fps_counter.vsync_count;
+ let fps = if elapsed > 0.0 { vsyncs as f64 / elapsed } else { 0.0 };
+
+ let native_hz = match sys.vi.dcr.video_format().refresh_rate() {
+ RefreshRate::Hz60 => 60.0,
+ RefreshRate::Hz50 => 50.0,
+ };
+ let native_pct = if native_hz > 0.0 {
+ (fps / native_hz) * 100.0
+ } else {
+ 0.0
+ };
+
+ tracing::info!(
+ vsyncs,
+ elapsed_s = elapsed,
+ fps = format!("{fps:.2}"),
+ pct = format!("{native_pct:.1}"),
+ "emu fps"
+ );
+
+ sys.fps_counter
+ .shared
+ .store(self::pack(fps as f32, native_pct as f32), Ordering::Relaxed);
+
+ sys.fps_counter.vsync_count = 0;
+ sys.fps_counter.last_tick = now;
+ sys.scheduler
+ .schedule_in(cpu_clock(SYSTEM), self::fps_handler::<SYSTEM>);
+}
diff --git a/crates/gecko/src/lib.rs b/crates/gecko/src/lib.rs
index 6c98a21..0f7ab2c 100644
--- a/crates/gecko/src/lib.rs
+++ b/crates/gecko/src/lib.rs
@@ -2,6 +2,8 @@ pub mod audio;
pub mod common;
pub mod dvd;
pub mod flipper;
+#[cfg(feature = "fps-counter")]
+pub mod fps;
pub mod gamecube;
pub mod gekko;
pub mod hollywood;
diff --git a/crates/gecko/src/scheduler.rs b/crates/gecko/src/scheduler.rs
index a13da97..425e5a4 100644
--- a/crates/gecko/src/scheduler.rs
+++ b/crates/gecko/src/scheduler.rs
@@ -148,6 +148,8 @@ impl<const SYSTEM: SystemId> Scheduler<SYSTEM> {
crate::flipper::cp::PUMP_INTERVAL_CYCLES,
crate::flipper::cp::pump_handler::<SYSTEM>,
);
+ #[cfg(feature = "fps-counter")]
+ s.schedule_at(self::cpu_clock(SYSTEM), crate::fps::fps_handler::<SYSTEM>);
s
}
}
@@ -155,6 +157,10 @@ impl<const SYSTEM: SystemId> Scheduler<SYSTEM> {
/// Reschedules itself every frame.
pub fn vsync_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {
sys.vsync_pending = true;
+ #[cfg(feature = "fps-counter")]
+ {
+ sys.fps_counter.vsync_count += 1;
+ }
let rate = sys.vi.dcr.video_format().refresh_rate();
sys.scheduler
.schedule_in(rate.cycles_per_frame(SYSTEM), self::vsync_handler::<SYSTEM>);
diff --git a/crates/gecko/src/system.rs b/crates/gecko/src/system.rs
index 98ecd0b..df15d76 100644
--- a/crates/gecko/src/system.rs
+++ b/crates/gecko/src/system.rs
@@ -11,6 +11,8 @@ use crate::flipper::pe::PixelEngine;
use crate::flipper::pi::ProcessorInterface;
use crate::flipper::si::SerialInterface;
use crate::flipper::vi::VideoInterface;
+#[cfg(feature = "fps-counter")]
+use crate::fps::FpsCounter;
use crate::gekko::Gekko;
use crate::hollywood::Hollywood;
#[cfg(feature = "hooks")]
@@ -62,6 +64,9 @@ pub struct System<const SYSTEM: SystemId> {
#[cfg(feature = "jit")]
pub jit: Option<Box<crate::gekko::jit::JitEngine<SYSTEM>>>,
+
+ #[cfg(feature = "fps-counter")]
+ pub fps_counter: FpsCounter,
}
impl<const SYSTEM: SystemId> System<SYSTEM> {
@@ -98,6 +103,9 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {
#[cfg(feature = "jit")]
jit: None,
+
+ #[cfg(feature = "fps-counter")]
+ fps_counter: FpsCounter::new(),
}
}
diff --git a/crates/tinyapp/Cargo.toml b/crates/tinyapp/Cargo.toml
index 1b003b0..5f4920d 100644
--- a/crates/tinyapp/Cargo.toml
+++ b/crates/tinyapp/Cargo.toml
@@ -4,10 +4,12 @@ version = "0.1.0"
edition = "2024"
[features]
+default = ["fps-counter"]
scripting = ["gecko/hooks", "dep:scripting"]
scripting-mut-traps = ["scripting", "gecko/hooks-mut-traps", "scripting/hooks-mut-traps"]
efb-writeback = ["backend-wgpu/efb-writeback"]
audio-wav-dump = ["gecko/audio-wav-dump"]
+fps-counter = ["gecko/fps-counter"]
[dependencies]
gecko = { path = "../gecko" }
@@ -20,11 +22,9 @@ pollster = "0.4.0"
egui = "0.33.3"
egui-wgpu = "0.33.3"
egui-winit = { version = "0.33.3", features = ["wayland", "x11"] }
-egui_plot = "0.34.1"
tracing = "0.1.44"
tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
clap = { version = "4.6.0", features = ["derive"] }
-crossbeam-channel = "0.5.15"
cpal = "0.17.3"
ringbuf = "0.5.0"
ctrlc = "3.5.2"
diff --git a/crates/tinyapp/src/app.rs b/crates/tinyapp/src/app.rs
index 3efd7d2..43e604f 100644
--- a/crates/tinyapp/src/app.rs
+++ b/crates/tinyapp/src/app.rs
@@ -1,12 +1,12 @@
-use crate::thread::FrameMessage;
use backend_wgpu::capture::{self, CaptureRequest, ScreenshotControl};
-use crossbeam_channel::Receiver;
use egui::ViewportId;
use gecko::HostInput;
+#[cfg(feature = "fps-counter")]
+use gecko::fps::{self, FpsShared};
use gecko::hollywood::ipc::usb;
-use std::collections::VecDeque;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
+#[cfg(not(feature = "fps-counter"))]
use std::time::Instant;
use winit::application::ApplicationHandler;
use winit::event::{MouseButton, WindowEvent};
@@ -24,11 +24,11 @@ pub struct State {
egui_ctx: egui::Context,
egui_renderer: egui_wgpu::Renderer,
egui_winit: egui_winit::State,
- fps_history: VecDeque<[f64; 2]>,
- start_time: Instant,
+ #[cfg(not(feature = "fps-counter"))]
last_frame: Instant,
- last_native_hz: f64,
screenshots: ScreenshotControl,
+ #[cfg(feature = "fps-counter")]
+ fps_shared: FpsShared,
}
impl State {
@@ -39,6 +39,7 @@ impl State {
surface: wgpu::Surface<'static>,
surface_config: wgpu::SurfaceConfiguration,
renderer: backend_wgpu::sink::Renderer,
+ #[cfg(feature = "fps-counter")] fps_shared: FpsShared,
) -> Self {
let egui_ctx = egui::Context::default();
let egui_renderer =
@@ -54,11 +55,11 @@ impl State {
egui_ctx,
egui_renderer,
egui_winit,
- fps_history: VecDeque::new(),
- start_time: Instant::now(),
+ #[cfg(not(feature = "fps-counter"))]
last_frame: Instant::now(),
- last_native_hz: 60.0,
screenshots: ScreenshotControl::new(),
+ #[cfg(feature = "fps-counter")]
+ fps_shared,
}
}
@@ -78,25 +79,15 @@ impl State {
self.surface.configure(&self.device, &self.surface_config);
}
- fn render(&mut self, frame_rx: &Receiver<FrameMessage>, window: &Window) {
- let mut msg: Option<FrameMessage> = None;
- while let Ok(newer) = frame_rx.try_recv() {
- msg = Some(newer);
- }
-
- let Some(msg) = msg else { return };
-
- // FPS bookkeeping
- let delta = self.last_frame.elapsed().as_secs_f64();
- self.last_frame = Instant::now();
- let fps = if delta > 0.0 { 1.0 / delta } else { 0.0 };
- let elapsed = self.start_time.elapsed().as_secs_f64();
- self.fps_history.push_back([elapsed, fps]);
- while self.fps_history.front().is_some_and(|e| elapsed - e[0] > 5.0) {
- self.fps_history.pop_front();
- }
- self.last_native_hz = msg.native_hz;
- let native_pct = (fps / self.last_native_hz) * 100.0;
+ fn render(&mut self, window: &Window) {
+ #[cfg(feature = "fps-counter")]
+ let (fps, native_pct) = fps::read(&self.fps_shared);
+ #[cfg(not(feature = "fps-counter"))]
+ let fps = {
+ let delta = self.last_frame.elapsed().as_secs_f64();
+ self.last_frame = Instant::now();
+ if delta > 0.0 { 1.0 / delta } else { 0.0 }
+ };
let frame = match self.surface.get_current_texture() {
Ok(f) => f,
@@ -126,7 +117,6 @@ impl State {
// egui overlay
let raw_input = self.egui_winit.take_egui_input(window);
- let fps_points: Vec<[f64; 2]> = self.fps_history.iter().copied().collect();
let full_output = self.egui_ctx.run_ui(raw_input, |ui| {
let ctx = ui.ctx().clone();
let frame =
@@ -138,21 +128,10 @@ impl State {
.anchor(egui::Align2::RIGHT_TOP, [-8.0, 8.0])
.frame(frame)
.show(&ctx, |ui| {
+ #[cfg(feature = "fps-counter")]
ui.label(egui::RichText::new(format!("{fps:.1} FPS {native_pct:.1}%")).monospace());
- egui_plot::Plot::new("fps_plot")
- .height(60.0)
- .width(180.0)
- .show_axes(false)
- .show_grid(false)
- .allow_zoom(false)
- .allow_drag(false)
- .allow_scroll(false)
- .show(ui, |plot_ui| {
- plot_ui.line(
- egui_plot::Line::new("fps", egui_plot::PlotPoints::from(fps_points.clone()))
- .color(egui::Color32::from_rgb(100, 200, 100)),
- );
- });
+ #[cfg(not(feature = "fps-counter"))]
+ ui.label(egui::RichText::new(format!("{fps:.1} FPS")).monospace());
});
});
@@ -213,7 +192,6 @@ impl State {
}
pub struct App {
- pub frame_rx: Receiver<FrameMessage>,
pub input: Arc<Mutex<HostInput>>,
pub window: Option<Arc<Window>>,
pub state: Option<State>,
@@ -221,6 +199,8 @@ pub struct App {
pub init: Option<AppInit>,
pub _audio_stream: Option<cpal::Stream>,
pub shutdown_requested: Arc<AtomicBool>,
+ #[cfg(feature = "fps-counter")]
+ pub fps_shared: FpsShared,
}
pub struct AppInit {
@@ -284,6 +264,8 @@ impl ApplicationHandler for App {
surface,
surface_config,
init.renderer,
+ #[cfg(feature = "fps-counter")]
+ self.fps_shared.clone(),
);
window.request_redraw();
self.window = Some(window);
@@ -361,7 +343,7 @@ impl ApplicationHandler for App {
}
WindowEvent::RedrawRequested => {
if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
- state.render(&self.frame_rx, window);
+ state.render(window);
}
}
_ => {}
diff --git a/crates/tinyapp/src/main.rs b/crates/tinyapp/src/main.rs
index f9b1f03..b0ac142 100644
--- a/crates/tinyapp/src/main.rs
+++ b/crates/tinyapp/src/main.rs
@@ -4,7 +4,6 @@ mod thread;
use backend_wgpu::sink::TargetAspect;
use clap::Parser;
-use crossbeam_channel::bounded;
use gecko::HostInput;
#[cfg(feature = "audio-wav-dump")]
use gecko::audio::WavAudioSink;
@@ -102,13 +101,20 @@ fn main() {
wgpu::PresentMode::Fifo
};
+ let env_filter = tracing_subscriber::EnvFilter::try_from_default_env()
+ .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("warn"))
+ .add_directive("cranelift_jit=warn".parse().unwrap())
+ .add_directive("cranelift_codegen=warn".parse().unwrap())
+ .add_directive("cranelift_frontend=warn".parse().unwrap())
+ .add_directive("regalloc2=warn".parse().unwrap())
+ .add_directive("wgpu_core=warn".parse().unwrap())
+ .add_directive("wgpu_hal=warn".parse().unwrap())
+ .add_directive("naga=warn".parse().unwrap());
+
tracing_subscriber::fmt()
.without_time()
.with_ansi(!args.no_ansi)
- .with_env_filter(
- tracing_subscriber::EnvFilter::try_from_default_env()
- .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("warn")),
- )
+ .with_env_filter(env_filter)
.init();
// Boot dispatch:
@@ -216,9 +222,10 @@ fn run<const SYSTEM: SystemId>(mut emulator: System<SYSTEM>, present_mode: wgpu:
let audio_stream = install_audio_sink(args, &mut emulator);
- let input = Arc::new(Mutex::new(HostInput::neutral_for(SYSTEM)));
+ #[cfg(feature = "fps-counter")]
+ let fps_shared = emulator.fps_counter.shared();
- let (frame_tx, frame_rx) = bounded::<thread::FrameMessage>(2);
+ let input = Arc::new(Mutex::new(HostInput::neutral_for(SYSTEM)));
let event_loop = EventLoop::new().unwrap();
let proxy = event_loop.create_proxy();
@@ -247,11 +254,10 @@ fn run<const SYSTEM: SystemId>(mut emulator: System<SYSTEM>, present_mode: wgpu:
let emu_input = input.clone();
let emu_handle = std::thread::Builder::new()
.name("emu".into())
- .spawn(move || thread::emu_thread::<SYSTEM>(emulator, frame_tx, emu_input, proxy))
+ .spawn(move || thread::emu_thread::<SYSTEM>(emulator, emu_input, proxy))
.expect("failed to spawn emulator thread");
let mut app = app::App {
- frame_rx,
input,
window: None,
state: None,
@@ -266,6 +272,8 @@ fn run<const SYSTEM: SystemId>(mut emulator: System<SYSTEM>, present_mode: wgpu:
}),
_audio_stream: audio_stream,
shutdown_requested,
+ #[cfg(feature = "fps-counter")]
+ fps_shared,
};
event_loop.run_app(&mut app).unwrap();
diff --git a/crates/tinyapp/src/thread.rs b/crates/tinyapp/src/thread.rs
index 2f7c098..213d84e 100644
--- a/crates/tinyapp/src/thread.rs
+++ b/crates/tinyapp/src/thread.rs
@@ -1,17 +1,10 @@
-use crossbeam_channel::Sender;
use gecko::HostInput;
-use gecko::flipper::vi::regs::RefreshRate;
use gecko::system::{System, SystemId};
use std::sync::{Arc, Mutex};
use winit::event_loop::EventLoopProxy;
-pub struct FrameMessage {
- pub native_hz: f64,
-}
-
pub fn emu_thread<const SYSTEM: SystemId>(
mut emulator: System<SYSTEM>,
- frame_tx: Sender<FrameMessage>,
input: Arc<Mutex<HostInput>>,
proxy: EventLoopProxy<()>,
) {
@@ -20,14 +13,8 @@ pub fn emu_thread<const SYSTEM: SystemId>(
emulator.apply_host_input(&input);
emulator.run_until_vsync();
- let native_hz = match emulator.vi.dcr.video_format().refresh_rate() {
- RefreshRate::Hz60 => 60.0,
- RefreshRate::Hz50 => 50.0,
- };
-
- if frame_tx.send(FrameMessage { native_hz }).is_err() {
+ if proxy.send_event(()).is_err() {
break;
}
- let _ = proxy.send_event(());
}
}