A GameCube/Wii emulator and debugger written in Rust.
benchmark and pgo. slow/fast mmio/ram
Laylef2b89535cc73
diff --git a/.cargo/config.toml b/.cargo/config.tomlindex a0e5c9d..de98183 100644--- a/.cargo/config.toml+++ b/.cargo/config.toml@@ -13,4 +13,4 @@ rustflags = [# disabled for iOS Safari support (relaxed-simd not supported, tail-call requires a new version of Safari)# "-C", "target-feature=+relaxed-simd","-C", "target-feature=+tail-call",-]+]\ No newline at end of filediff --git a/Cargo.lock b/Cargo.lockindex d5d0e01..1ecfcd1 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -3241,6 +3241,15 @@ dependencies = ["winit",]+[[package]]+name = "tinybench"+version = "0.1.0"+dependencies = [+ "clap",+ "gecko",+ "image 0.1.0",+]+[[package]]name = "tinyemu"version = "0.1.0"diff --git a/Cargo.toml b/Cargo.tomlindex 5db8fed..8d23b58 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -5,6 +5,7 @@ members = ["crates/disasm","crates/gecko","crates/tinyemu",+ "crates/tinybench","crates/image","crates/tinyapp","crates/backend-wgpu",@@ -26,7 +27,7 @@ egui-winit = { git = "https://github.com/ioncodes/egui.git" }[profile.release]lto = "fat"codegen-units = 1-debug = false+debug = trueopt-level = 3debug-assertions = falsediff --git a/Justfile b/Justfilenew file mode 100644index 0000000..355e0f6--- /dev/null+++ b/Justfile@@ -0,0 +1,23 @@+pgo_dir := "/tmp/gecko-pgo-data"+base_flags := "-Ctarget-cpu=native -Ccodegen-units=1"++pgo package +training_args:+ @echo "=== PGO build for {{package}} ==="+ @echo "[1/4] Building instrumented binary..."+ rm -rf {{pgo_dir}}+ mkdir -p {{pgo_dir}}+ RUSTFLAGS="{{base_flags}} -Cprofile-generate={{pgo_dir}}" cargo build -p {{package}} --release+ @echo "[2/4] Training run..."+ ./target/release/{{package}} {{training_args}}+ @echo "[3/4] Merging profile data..."+ llvm-profdata merge -o {{pgo_dir}}/merged.profdata {{pgo_dir}}+ @echo "[4/4] Building PGO-optimized binary..."+ RUSTFLAGS="{{base_flags}} -Cprofile-use={{pgo_dir}}/merged.profdata" cargo build -p {{package}} --release+ @echo ""+ @echo "Done. Binary at: target/release/{{package}}"++pgo-tinybench frames="500":+ just pgo tinybench --ipl private/IPL.decoded.bin --dsp private/dsp_rom.bin --frames {{frames}}++pgo-tinyapp:+ just pgo tinyapp --ipl private/IPL.decoded.bin --dsp private/dsp_rom.bindiff --git a/crates/gecko/src/mmio/bus.rs b/crates/gecko/src/mmio/bus.rsindex c687616..48607bb 100644--- a/crates/gecko/src/mmio/bus.rs+++ b/crates/gecko/src/mmio/bus.rs@@ -1,15 +1,13 @@use crate::gamecube::GameCube;use crate::mmio::constants::{AI_BASE, AI_END, CP_BASE, CP_END, DI_BASE, DI_END, DSP_BASE, DSP_END, EXI_BASE, EXI_END, GX_FIFO_BASE, GX_FIFO_END,- IPL_BASE, IPL_END, MI_BASE, MI_END, PE_BASE, PE_END, PI_BASE, PI_END, RAM_BASE, RAM_END, SI_BASE, SI_END, VI_BASE,- VI_END,+ IPL_BASE, IPL_END, MI_BASE, MI_END, PE_BASE, PE_END, PI_BASE, PI_END, RAM_END, SI_BASE, SI_END, VI_BASE, VI_END,};use crate::mmio::{Mmio, MmioRw};#[cfg(feature = "scripting")]use crate::scripting::HookFlags;enum BusTarget {- Ram,Cp,Vi,Pe,@@ -27,9 +25,8 @@ enum BusTarget {#[rustfmt::skip]#[inline(always)]-fn route(phys: u32) -> (BusTarget, u32) {+fn route_mmio(phys: u32) -> (BusTarget, u32) {match phys {- RAM_BASE..=RAM_END => (BusTarget::Ram, phys),CP_BASE..=CP_END => (BusTarget::Cp, phys - CP_BASE),PE_BASE..=PE_END => (BusTarget::Pe, phys - PE_BASE),VI_BASE..=VI_END => (BusTarget::Vi, phys - VI_BASE),@@ -117,322 +114,376 @@ macro_rules! bus_write_hooks {}impl GameCube {- #[rustfmt::skip]+ // Read fast path for RAM access+#[inline(always)]pub fn read_u8(&mut self, addr: u32) -> u8 {let phys = Mmio::virt_to_phys(addr);bus_read_hooks!(self, addr, phys, 1, {- let (target, offset) = route(phys);- match target {- BusTarget::Ram => self.mmio.ram_read_u8(offset),- BusTarget::Cp => self.cp.mmio_read_u8(offset),- BusTarget::Vi => {- if offset == 0x2E {- return (self.vi.dph_value(self.scheduler.cycles) >> 8) as u8;- }- if offset == 0x2F {- return self.vi.dph_value(self.scheduler.cycles) as u8;- }- self.vi.mmio_read_u8(offset)- }- BusTarget::Pe => self.pe.mmio_read_u8(offset),- BusTarget::Pi => self.pi.mmio_read_u8(offset),- BusTarget::Mi => self.mi.mmio_read_u8(offset),- BusTarget::Dsp => self.dsp.mmio_read_u8(offset),- BusTarget::Di => self.di.mmio_read_u8(offset),- BusTarget::Si => self.si.mmio_read_u8(offset),- BusTarget::Exi => self.exi.mmio_read_u8(offset),- BusTarget::Ai => {- if offset == 0x08 {- return self.ai.sample_count(self.scheduler.cycles) as u8;- }- self.ai.mmio_read_u8(offset)- }- BusTarget::Gx => {- tracing::error!(addr = format!("{:08X}", addr), "Invalid GX FIFO read");- 0- }- BusTarget::Ipl => self.mmio.phys_read_u8(offset),- BusTarget::Fallback => self.mmio.phys_read_u8(offset),+ if phys <= RAM_END {+ self.mmio.ram_read_u8(phys)+ } else {+ self.read_u8_mmio(phys, addr)}})}- #[rustfmt::skip]#[inline(always)]pub fn read_u16(&mut self, addr: u32) -> u16 {let phys = Mmio::virt_to_phys(addr);bus_read_hooks!(self, addr, phys, 2, {- let (target, offset) = route(phys);- match target {- BusTarget::Ram => self.mmio.ram_read_u16(offset),- BusTarget::Cp => self.cp.mmio_read_u16(offset),- BusTarget::Vi => {- if offset == 0x2E {- return self.vi.dph_value(self.scheduler.cycles);- }- self.vi.mmio_read_u16(offset)- }- BusTarget::Pe => self.pe.mmio_read_u16(offset),- BusTarget::Pi => self.pi.mmio_read_u16(offset),- BusTarget::Mi => self.mi.mmio_read_u16(offset),- BusTarget::Dsp => self.dsp.mmio_read_u16(offset),- BusTarget::Di => self.di.mmio_read_u16(offset),- BusTarget::Si => self.si.mmio_read_u16(offset),- BusTarget::Exi => self.exi.mmio_read_u16(offset),- BusTarget::Ai => {- if offset == 0x08 || offset == 0x0A {- return self.ai.sample_count(self.scheduler.cycles) as u16;- }- self.ai.mmio_read_u16(offset)- }- BusTarget::Gx => {- tracing::error!(addr = format!("{:08X}", addr), "Invalid GX FIFO read");- 0- }- BusTarget::Ipl => self.mmio.phys_read_u16(offset),- BusTarget::Fallback => self.mmio.phys_read_u16(offset),+ if phys <= RAM_END - 1 {+ self.mmio.ram_read_u16(phys)+ } else {+ self.read_u16_mmio(phys, addr)}})}- #[rustfmt::skip]#[inline(always)]pub fn read_u32(&mut self, addr: u32) -> u32 {let phys = Mmio::virt_to_phys(addr);bus_read_hooks!(self, addr, phys, 4, {- let (target, offset) = route(phys);- match target {- BusTarget::Ram => self.mmio.ram_read_u32(offset),- BusTarget::Cp => self.cp.mmio_read_u32(offset),- BusTarget::Vi => {- if offset == 0x2C {- let dpv = self.vi.mmio_read_u16(0x2C) as u32;- let dph = self.vi.dph_value(self.scheduler.cycles) as u32;- return (dpv << 16) | dph;- }- self.vi.mmio_read_u32(offset)- }- BusTarget::Pe => self.pe.mmio_read_u32(offset),- BusTarget::Pi => self.pi.mmio_read_u32(offset),- BusTarget::Mi => self.mi.mmio_read_u32(offset),- BusTarget::Dsp => self.dsp.mmio_read_u32(offset),- BusTarget::Di => self.di.mmio_read_u32(offset),- BusTarget::Si => self.si.mmio_read_u32(offset),- BusTarget::Exi => self.exi.mmio_read_u32(offset),- BusTarget::Ai => {- if offset == 0x08 {- return self.ai.sample_count(self.scheduler.cycles);- }- self.ai.mmio_read_u32(offset)- }- BusTarget::Gx => {- tracing::error!(addr = format!("{:08X}", addr), "Invalid GX FIFO read");- 0- }- BusTarget::Ipl => self.mmio.phys_read_u32(offset),- BusTarget::Fallback => self.mmio.phys_read_u32(offset),+ if phys <= RAM_END - 3 {+ self.mmio.ram_read_u32(phys)+ } else {+ self.read_u32_mmio(phys, addr)}})}- #[rustfmt::skip]+ // Write fast path for RAM access+#[inline(always)]pub fn write_u8(&mut self, addr: u32, val: u8) {let phys = Mmio::virt_to_phys(addr);bus_write_hooks!(self, addr, phys, 1, val, {- let (target, offset) = route(phys);- match target {- BusTarget::Ram => self.mmio.ram_write_u8(offset, val),- BusTarget::Cp => {- self.cp.mmio_write_u8(offset, val);- self.check_cp_interrupts();- }- BusTarget::Vi => {- self.vi.mmio_write_u8(offset, val);- self.maybe_schedule_vi_half_line();- if (0x30..=0x3F).contains(&offset) {- self.check_vi_interrupts();- }- }- BusTarget::Pe => {- self.pe.mmio_write_u8(offset, val);- self.check_pe_interrupts();- }- BusTarget::Pi => self.pi.mmio_write_u8(offset, val),- BusTarget::Mi => self.mi.mmio_write_u8(offset, val),- BusTarget::Dsp => {- self.dsp.mmio_write_u8(offset, val);- self.dsp.process_pending_dma(&mut self.mmio);- self.check_dsp_interrupts();- }- BusTarget::Di => {- self.di.mmio_write_u8(offset, val);- self.start_dvd_transfer();- self.check_di_interrupts();- }- BusTarget::Si => {- self.si.mmio_write_u8(offset, val);- self.check_si_interrupts();- }- BusTarget::Exi => {- self.exi.mmio_write_u8(offset, val);- self.exi.process_cs_changes();- self.exi.process_dma_transfers(&mut self.mmio);- self.check_exi_interrupts();- }- BusTarget::Ai => {- self.ai.mmio_write_u8(offset, val);- self.check_sample_counter_reset();- self.check_ai_interrupts();- }- BusTarget::Gx => {- if self.pi.is_fifo_redirected() {- let wptr = self.pi.fifo_wptr as usize;- self.mmio.ram[wptr] = val;- self.pi.fifo_wptr = self.pi.fifo_wptr.wrapping_add(1);- } else {- self.gx.mmio_write_u8(&mut self.mmio, val);- self.check_gx_pe_finish();- }- }- BusTarget::Ipl => self.mmio.phys_write_u8(offset, val),- BusTarget::Fallback => self.mmio.phys_write_u8(offset, val),+ if phys <= RAM_END {+ self.mmio.ram_write_u8(phys, val);+ } else {+ self.write_u8_mmio(phys, val);}});}- #[rustfmt::skip]#[inline(always)]pub fn write_u16(&mut self, addr: u32, val: u16) {let phys = Mmio::virt_to_phys(addr);bus_write_hooks!(self, addr, phys, 2, val, {- let (target, offset) = route(phys);- match target {- BusTarget::Ram => self.mmio.ram_write_u16(offset, val),- BusTarget::Cp => {- self.cp.mmio_write_u16(offset, val);- self.check_cp_interrupts();- }- BusTarget::Vi => {- self.vi.mmio_write_u16(offset, val);- self.maybe_schedule_vi_half_line();- if (0x30..=0x3F).contains(&offset) {- self.check_vi_interrupts();- }- }- BusTarget::Pe => {- self.pe.mmio_write_u16(offset, val);- self.check_pe_interrupts();- }- BusTarget::Pi => self.pi.mmio_write_u16(offset, val),- BusTarget::Mi => self.mi.mmio_write_u16(offset, val),- BusTarget::Dsp => {- self.dsp.mmio_write_u16(offset, val);- self.dsp.process_pending_dma(&mut self.mmio);- self.check_dsp_interrupts();- }- BusTarget::Di => {- self.di.mmio_write_u16(offset, val);- self.start_dvd_transfer();- self.check_di_interrupts();- }- BusTarget::Si => {- self.si.mmio_write_u16(offset, val);- self.check_si_interrupts();- }- BusTarget::Exi => {- self.exi.mmio_write_u16(offset, val);- self.exi.process_cs_changes();- self.exi.process_dma_transfers(&mut self.mmio);- self.check_exi_interrupts();- }- BusTarget::Ai => {- self.ai.mmio_write_u16(offset, val);- self.check_sample_counter_reset();- self.check_ai_interrupts();- }- BusTarget::Gx => {- if self.pi.is_fifo_redirected() {- let wptr = self.pi.fifo_wptr as usize;- let bytes = val.to_be_bytes();- self.mmio.ram[wptr..wptr + 2].copy_from_slice(&bytes);- self.pi.fifo_wptr = self.pi.fifo_wptr.wrapping_add(2);- } else {- self.gx.mmio_write_u16(&mut self.mmio, val);- self.check_gx_pe_finish();- }- }- BusTarget::Ipl => self.mmio.phys_write_u16(offset, val),- BusTarget::Fallback => self.mmio.phys_write_u16(offset, val),+ if phys <= RAM_END - 1 {+ self.mmio.ram_write_u16(phys, val);+ } else {+ self.write_u16_mmio(phys, val);}});}- #[rustfmt::skip]#[inline(always)]pub fn write_u32(&mut self, addr: u32, val: u32) {let phys = Mmio::virt_to_phys(addr);bus_write_hooks!(self, addr, phys, 4, val, {- let (target, offset) = route(phys);- match target {- BusTarget::Ram => self.mmio.ram_write_u32(offset, val),- BusTarget::Cp => {- self.cp.mmio_write_u32(offset, val);- self.check_cp_interrupts();- }- BusTarget::Vi => {- self.vi.mmio_write_u32(offset, val);- self.maybe_schedule_vi_half_line();- if (0x30..=0x3F).contains(&offset) {- self.check_vi_interrupts();- }- }- BusTarget::Pe => {- self.pe.mmio_write_u32(offset, val);- self.check_pe_interrupts();- }- BusTarget::Pi => self.pi.mmio_write_u32(offset, val),- BusTarget::Mi => self.mi.mmio_write_u32(offset, val),- BusTarget::Dsp => {- self.dsp.mmio_write_u32(offset, val);- self.dsp.process_pending_dma(&mut self.mmio);- self.check_dsp_interrupts();+ if phys <= RAM_END - 3 {+ self.mmio.ram_write_u32(phys, val);+ } else {+ self.write_u32_mmio(phys, val);+ }+ });+ }++ // Slow path for MMIO++ #[rustfmt::skip]+ #[inline(never)]+ fn read_u8_mmio(&mut self, phys: u32, addr: u32) -> u8 {+ let (target, offset) = route_mmio(phys);+ match target {+ BusTarget::Cp => self.cp.mmio_read_u8(offset),+ BusTarget::Vi => {+ if offset == 0x2E {+ return (self.vi.dph_value(self.scheduler.cycles) >> 8) as u8;+ }+ if offset == 0x2F {+ return self.vi.dph_value(self.scheduler.cycles) as u8;+ }+ self.vi.mmio_read_u8(offset)+ }+ BusTarget::Pe => self.pe.mmio_read_u8(offset),+ BusTarget::Pi => self.pi.mmio_read_u8(offset),+ BusTarget::Mi => self.mi.mmio_read_u8(offset),+ BusTarget::Dsp => self.dsp.mmio_read_u8(offset),+ BusTarget::Di => self.di.mmio_read_u8(offset),+ BusTarget::Si => self.si.mmio_read_u8(offset),+ BusTarget::Exi => self.exi.mmio_read_u8(offset),+ BusTarget::Ai => {+ if offset == 0x08 {+ return self.ai.sample_count(self.scheduler.cycles) as u8;+ }+ self.ai.mmio_read_u8(offset)+ }+ BusTarget::Gx => {+ tracing::error!(addr = format!("{:08X}", addr), "Invalid GX FIFO read");+ 0+ }+ BusTarget::Ipl => self.mmio.phys_read_u8(phys),+ BusTarget::Fallback => self.mmio.phys_read_u8(phys),+ }+ }++ #[rustfmt::skip]+ #[inline(never)]+ fn read_u16_mmio(&mut self, phys: u32, addr: u32) -> u16 {+ let (target, offset) = route_mmio(phys);+ match target {+ BusTarget::Cp => self.cp.mmio_read_u16(offset),+ BusTarget::Vi => {+ if offset == 0x2E {+ return self.vi.dph_value(self.scheduler.cycles);+ }+ self.vi.mmio_read_u16(offset)+ }+ BusTarget::Pe => self.pe.mmio_read_u16(offset),+ BusTarget::Pi => self.pi.mmio_read_u16(offset),+ BusTarget::Mi => self.mi.mmio_read_u16(offset),+ BusTarget::Dsp => self.dsp.mmio_read_u16(offset),+ BusTarget::Di => self.di.mmio_read_u16(offset),+ BusTarget::Si => self.si.mmio_read_u16(offset),+ BusTarget::Exi => self.exi.mmio_read_u16(offset),+ BusTarget::Ai => {+ if offset == 0x08 || offset == 0x0A {+ return self.ai.sample_count(self.scheduler.cycles) as u16;+ }+ self.ai.mmio_read_u16(offset)+ }+ BusTarget::Gx => {+ tracing::error!(addr = format!("{:08X}", addr), "Invalid GX FIFO read");+ 0+ }+ BusTarget::Ipl => self.mmio.phys_read_u16(phys),+ BusTarget::Fallback => self.mmio.phys_read_u16(phys),+ }+ }++ #[rustfmt::skip]+ #[inline(never)]+ fn read_u32_mmio(&mut self, phys: u32, addr: u32) -> u32 {+ let (target, offset) = route_mmio(phys);+ match target {+ BusTarget::Cp => self.cp.mmio_read_u32(offset),+ BusTarget::Vi => {+ if offset == 0x2C {+ let dpv = self.vi.mmio_read_u16(0x2C) as u32;+ let dph = self.vi.dph_value(self.scheduler.cycles) as u32;+ return (dpv << 16) | dph;+ }+ self.vi.mmio_read_u32(offset)+ }+ BusTarget::Pe => self.pe.mmio_read_u32(offset),+ BusTarget::Pi => self.pi.mmio_read_u32(offset),+ BusTarget::Mi => self.mi.mmio_read_u32(offset),+ BusTarget::Dsp => self.dsp.mmio_read_u32(offset),+ BusTarget::Di => self.di.mmio_read_u32(offset),+ BusTarget::Si => self.si.mmio_read_u32(offset),+ BusTarget::Exi => self.exi.mmio_read_u32(offset),+ BusTarget::Ai => {+ if offset == 0x08 {+ return self.ai.sample_count(self.scheduler.cycles);+ }+ self.ai.mmio_read_u32(offset)+ }+ BusTarget::Gx => {+ tracing::error!(addr = format!("{:08X}", addr), "Invalid GX FIFO read");+ 0+ }+ BusTarget::Ipl => self.mmio.phys_read_u32(phys),+ BusTarget::Fallback => self.mmio.phys_read_u32(phys),+ }+ }++ #[rustfmt::skip]+ #[inline(never)]+ fn write_u8_mmio(&mut self, phys: u32, val: u8) {+ let (target, offset) = route_mmio(phys);+ match target {+ BusTarget::Cp => {+ self.cp.mmio_write_u8(offset, val);+ self.check_cp_interrupts();+ }+ BusTarget::Vi => {+ self.vi.mmio_write_u8(offset, val);+ self.maybe_schedule_vi_half_line();+ if (0x30..=0x3F).contains(&offset) {+ self.check_vi_interrupts();}- BusTarget::Di => {- self.di.mmio_write_u32(offset, val);- self.start_dvd_transfer();- self.check_di_interrupts();+ }+ BusTarget::Pe => {+ self.pe.mmio_write_u8(offset, val);+ self.check_pe_interrupts();+ }+ BusTarget::Pi => self.pi.mmio_write_u8(offset, val),+ BusTarget::Mi => self.mi.mmio_write_u8(offset, val),+ BusTarget::Dsp => {+ self.dsp.mmio_write_u8(offset, val);+ self.dsp.process_pending_dma(&mut self.mmio);+ self.check_dsp_interrupts();+ }+ BusTarget::Di => {+ self.di.mmio_write_u8(offset, val);+ self.start_dvd_transfer();+ self.check_di_interrupts();+ }+ BusTarget::Si => {+ self.si.mmio_write_u8(offset, val);+ self.check_si_interrupts();+ }+ BusTarget::Exi => {+ self.exi.mmio_write_u8(offset, val);+ self.exi.process_cs_changes();+ self.exi.process_dma_transfers(&mut self.mmio);+ self.check_exi_interrupts();+ }+ BusTarget::Ai => {+ self.ai.mmio_write_u8(offset, val);+ self.check_sample_counter_reset();+ self.check_ai_interrupts();+ }+ BusTarget::Gx => {+ if self.pi.is_fifo_redirected() {+ let wptr = self.pi.fifo_wptr as usize;+ self.mmio.ram[wptr] = val;+ self.pi.fifo_wptr = self.pi.fifo_wptr.wrapping_add(1);+ } else {+ self.gx.mmio_write_u8(&mut self.mmio, val);+ self.check_gx_pe_finish();}- BusTarget::Si => {- self.si.mmio_write_u32(offset, val);- self.check_si_interrupts();+ }+ BusTarget::Ipl => self.mmio.phys_write_u8(phys, val),+ BusTarget::Fallback => self.mmio.phys_write_u8(phys, val),+ }+ }++ #[rustfmt::skip]+ #[inline(never)]+ fn write_u16_mmio(&mut self, phys: u32, val: u16) {+ let (target, offset) = route_mmio(phys);+ match target {+ BusTarget::Cp => {+ self.cp.mmio_write_u16(offset, val);+ self.check_cp_interrupts();+ }+ BusTarget::Vi => {+ self.vi.mmio_write_u16(offset, val);+ self.maybe_schedule_vi_half_line();+ if (0x30..=0x3F).contains(&offset) {+ self.check_vi_interrupts();}- BusTarget::Exi => {- self.exi.mmio_write_u32(offset, val);- self.exi.process_cs_changes();- self.exi.process_dma_transfers(&mut self.mmio);- self.check_exi_interrupts();+ }+ BusTarget::Pe => {+ self.pe.mmio_write_u16(offset, val);+ self.check_pe_interrupts();+ }+ BusTarget::Pi => self.pi.mmio_write_u16(offset, val),+ BusTarget::Mi => self.mi.mmio_write_u16(offset, val),+ BusTarget::Dsp => {+ self.dsp.mmio_write_u16(offset, val);+ self.dsp.process_pending_dma(&mut self.mmio);+ self.check_dsp_interrupts();+ }+ BusTarget::Di => {+ self.di.mmio_write_u16(offset, val);+ self.start_dvd_transfer();+ self.check_di_interrupts();+ }+ BusTarget::Si => {+ self.si.mmio_write_u16(offset, val);+ self.check_si_interrupts();+ }+ BusTarget::Exi => {+ self.exi.mmio_write_u16(offset, val);+ self.exi.process_cs_changes();+ self.exi.process_dma_transfers(&mut self.mmio);+ self.check_exi_interrupts();+ }+ BusTarget::Ai => {+ self.ai.mmio_write_u16(offset, val);+ self.check_sample_counter_reset();+ self.check_ai_interrupts();+ }+ BusTarget::Gx => {+ if self.pi.is_fifo_redirected() {+ let wptr = self.pi.fifo_wptr as usize;+ let bytes = val.to_be_bytes();+ self.mmio.ram[wptr..wptr + 2].copy_from_slice(&bytes);+ self.pi.fifo_wptr = self.pi.fifo_wptr.wrapping_add(2);+ } else {+ self.gx.mmio_write_u16(&mut self.mmio, val);+ self.check_gx_pe_finish();}- BusTarget::Ai => {- self.ai.mmio_write_u32(offset, val);- self.check_sample_counter_reset();- self.check_ai_interrupts();+ }+ BusTarget::Ipl => self.mmio.phys_write_u16(phys, val),+ BusTarget::Fallback => self.mmio.phys_write_u16(phys, val),+ }+ }++ #[rustfmt::skip]+ #[inline(never)]+ fn write_u32_mmio(&mut self, phys: u32, val: u32) {+ let (target, offset) = route_mmio(phys);+ match target {+ BusTarget::Cp => {+ self.cp.mmio_write_u32(offset, val);+ self.check_cp_interrupts();+ }+ BusTarget::Vi => {+ self.vi.mmio_write_u32(offset, val);+ self.maybe_schedule_vi_half_line();+ if (0x30..=0x3F).contains(&offset) {+ self.check_vi_interrupts();}- BusTarget::Gx => {- if self.pi.is_fifo_redirected() {- let wptr = self.pi.fifo_wptr as usize;- let bytes = val.to_be_bytes();- self.mmio.ram[wptr..wptr + 4].copy_from_slice(&bytes);- self.pi.fifo_wptr = self.pi.fifo_wptr.wrapping_add(4);- } else {- self.gx.mmio_write_u32(&mut self.mmio, val);- self.check_gx_pe_finish();- }+ }+ BusTarget::Pe => {+ self.pe.mmio_write_u32(offset, val);+ self.check_pe_interrupts();+ }+ BusTarget::Pi => self.pi.mmio_write_u32(offset, val),+ BusTarget::Mi => self.mi.mmio_write_u32(offset, val),+ BusTarget::Dsp => {+ self.dsp.mmio_write_u32(offset, val);+ self.dsp.process_pending_dma(&mut self.mmio);+ self.check_dsp_interrupts();+ }+ BusTarget::Di => {+ self.di.mmio_write_u32(offset, val);+ self.start_dvd_transfer();+ self.check_di_interrupts();+ }+ BusTarget::Si => {+ self.si.mmio_write_u32(offset, val);+ self.check_si_interrupts();+ }+ BusTarget::Exi => {+ self.exi.mmio_write_u32(offset, val);+ self.exi.process_cs_changes();+ self.exi.process_dma_transfers(&mut self.mmio);+ self.check_exi_interrupts();+ }+ BusTarget::Ai => {+ self.ai.mmio_write_u32(offset, val);+ self.check_sample_counter_reset();+ self.check_ai_interrupts();+ }+ BusTarget::Gx => {+ if self.pi.is_fifo_redirected() {+ let wptr = self.pi.fifo_wptr as usize;+ let bytes = val.to_be_bytes();+ self.mmio.ram[wptr..wptr + 4].copy_from_slice(&bytes);+ self.pi.fifo_wptr = self.pi.fifo_wptr.wrapping_add(4);+ } else {+ self.gx.mmio_write_u32(&mut self.mmio, val);+ self.check_gx_pe_finish();}- BusTarget::Ipl => self.mmio.phys_write_u32(offset, val),- BusTarget::Fallback => self.mmio.phys_write_u32(offset, val),}- });+ BusTarget::Ipl => self.mmio.phys_write_u32(phys, val),+ BusTarget::Fallback => self.mmio.phys_write_u32(phys, val),+ }}}diff --git a/crates/tinybench/Cargo.toml b/crates/tinybench/Cargo.tomlnew file mode 100644index 0000000..6b5e215--- /dev/null+++ b/crates/tinybench/Cargo.toml@@ -0,0 +1,12 @@+[package]+name = "tinybench"+version = "0.1.0"+edition = "2024"++[features]+idle-skip = ["gecko/idle-skip"]++[dependencies]+gecko = { path = "../gecko" }+image = { path = "../image" }+clap = { version = "4.6.0", features = ["derive"] }diff --git a/crates/tinybench/src/main.rs b/crates/tinybench/src/main.rsnew file mode 100644index 0000000..a2e0e6c--- /dev/null+++ b/crates/tinybench/src/main.rs@@ -0,0 +1,128 @@+use clap::Parser;+use gecko::flipper::si::pad::PadStatus;+use gecko::gamecube::GameCube;+use gecko::scheduler::CYCLES_PER_VSYNC;+use std::time::Instant;++const CPU_CLOCK_HZ: f64 = 486_000_000.0;++#[derive(Parser)]+#[command(about = "Benchmark tool")]+struct Args {+ /// Path to IPL ROM+ #[arg(long)]+ ipl: String,++ /// Path to DSP IROM binary+ #[arg(long)]+ dsp: String,++ /// Path to a GameCube ISO+ #[arg(long)]+ iso: Option<String>,++ /// Number of frames to run (0 = unlimited)+ #[arg(long, default_value_t = 0)]+ frames: u64,++ /// Report stats every N frames (0 = summary only)+ #[arg(long, default_value_t = 60)]+ report_interval: u64,+}++fn main() {+ let args = Args::parse();++ let ipl_data = std::fs::read(&args.ipl).expect("failed to read IPL");+ let mut emulator = GameCube::with_ipl(&ipl_data);++ let dsp_data = std::fs::read(&args.dsp).expect("failed to read DSP IROM");+ emulator.dsp.load_irom(&dsp_data);++ if let Some(ref iso_path) = args.iso {+ let iso_data = std::fs::read(iso_path).expect("failed to read ISO");+ let dvd = image::dvd::Dvd::parse(iso_data);+ emulator.insert_dvd(dvd);+ }++ emulator.add_primary_controller(PadStatus {+ connected: true,+ ..PadStatus::default()+ });++ run_bench(&mut emulator, &args);+}++fn run_bench(emulator: &mut GameCube, args: &Args) {+ let mut frame_count: u64 = 0;+ let mut interval_frame_count: u64 = 0;++ let bench_start = Instant::now();+ let mut interval_start = Instant::now();++ let mut interval_min = f64::MAX;+ let mut interval_max = 0.0_f64;++ if args.frames > 0 {+ println!("Running {} frames...", args.frames);+ } else {+ println!("Running indefinitely (Ctrl-C to stop)");+ }+ println!();++ loop {+ let frame_start = Instant::now();++ emulator.run_until_vsync();+ emulator.gx.draw_commands.commands.clear();++ let frame_time = frame_start.elapsed().as_secs_f64();+ frame_count += 1;+ interval_frame_count += 1;++ if frame_time < interval_min {+ interval_min = frame_time;+ }+ if frame_time > interval_max {+ interval_max = frame_time;+ }++ if args.report_interval > 0 && interval_frame_count >= args.report_interval {+ let interval_elapsed = interval_start.elapsed().as_secs_f64();+ let avg_fps = interval_frame_count as f64 / interval_elapsed;+ let native_pct = (avg_fps / 60.0) * 100.0;+ let avg_ms = (interval_elapsed / interval_frame_count as f64) * 1000.0;+ let min_ms = interval_min * 1000.0;+ let max_ms = interval_max * 1000.0;++ println!(+ "frame {:>8} | {:6.1} fps ({:5.1}%) | {:.2}ms avg, {:.2}ms min, {:.2}ms max",+ frame_count, avg_fps, native_pct, avg_ms, min_ms, max_ms+ );++ interval_start = Instant::now();+ interval_frame_count = 0;+ interval_min = f64::MAX;+ interval_max = 0.0;+ }++ if args.frames > 0 && frame_count >= args.frames {+ break;+ }+ }++ let total_elapsed = bench_start.elapsed().as_secs_f64();+ let total_fps = frame_count as f64 / total_elapsed;+ let emulated_cycles = frame_count * CYCLES_PER_VSYNC;+ let emulated_seconds = emulated_cycles as f64 / CPU_CLOCK_HZ;+ let speed_pct = (emulated_seconds / total_elapsed) * 100.0;++ println!();+ println!("=== Summary ===");+ println!("Frames: {}", frame_count);+ println!("Wall time: {:.3}s", total_elapsed);+ println!("Emulated time: {:.3}s", emulated_seconds);+ println!("Average FPS: {:.1}", total_fps);+ println!("Speed: {:.1}% of native", speed_pct);+ println!("Cycles: {}", emulated_cycles);+}