Skip to content

armgit / gecko

Public Imported from GitHub
0

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.toml
index 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 file
diff --git a/Cargo.lock b/Cargo.lock
index 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.toml
index 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 = true
opt-level = 3
debug-assertions = false
diff --git a/Justfile b/Justfile
new file mode 100644
index 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.bin
diff --git a/crates/gecko/src/mmio/bus.rs b/crates/gecko/src/mmio/bus.rs
index 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.toml
new file mode 100644
index 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.rs
new file mode 100644
index 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);
+}