A GameCube/Wii emulator and debugger written in Rust.
cold blocks, dl no copy, bigger lookup table, diags, idle shit. vertex decode left, maybe also texture decode+hash improvement
Layle76b70d11df56
diff --git a/Cargo.toml b/Cargo.tomlindex 0fc93ba..19f2195 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -48,6 +48,7 @@ egui-winit = { git = "https://github.com/ioncodes/egui.git" }codegen-units = 1lto = "fat"debug = true+panic = "abort"[profile.dev]opt-level = 3diff --git a/crates/backend-wgpu/src/action.rs b/crates/backend-wgpu/src/action.rsindex c72d909..1bc4760 100644--- a/crates/backend-wgpu/src/action.rs+++ b/crates/backend-wgpu/src/action.rs@@ -449,14 +449,16 @@ impl GxRenderer {});}+ let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {+ label: Some("gx_draw_flush_encoder"),+ });+ #[cfg(feature = "renderdoc-capture")]let group_label = format!("GX FIFO Execution / EFB Rendering: draws={} vertices={}",self.scratch_draws.len(),self.scratch_vertices.len());- let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {- label: Some("gx_draw_flush_encoder"),- });+ #[cfg(feature = "renderdoc-capture")]encoder.push_debug_group(&group_label);{let needs_initial_clear = self.efb_needs_clear;@@ -504,40 +506,44 @@ impl GxRenderer {multiview_mask: None,});rpass.set_vertex_buffer(0, self.vertex_buffer.slice(..));- if needs_initial_clear {- rpass.insert_debug_marker("EFB initial clear: color=black depth=1.0");- } else {- rpass.insert_debug_marker("EFB load existing color/depth");- }- if crate::EFB_SAMPLE_COUNT == 1 {- rpass.insert_debug_marker("EFB target: resolved color, no MSAA resolve");- } else {- rpass.insert_debug_marker("EFB target: MSAA color, resolve to efb_color_resolved");+ #[cfg(feature = "renderdoc-capture")]+ {+ if needs_initial_clear {+ rpass.insert_debug_marker("EFB initial clear: color=black depth=1.0");+ } else {+ rpass.insert_debug_marker("EFB load existing color/depth");+ }+ if crate::EFB_SAMPLE_COUNT == 1 {+ rpass.insert_debug_marker("EFB target: resolved color, no MSAA resolve");+ } else {+ rpass.insert_debug_marker("EFB target: MSAA color, resolve to efb_color_resolved");+ }}for (index, (first_vertex, vertex_count)) in self.scratch_draws.iter().copied().enumerate() {#[cfg(feature = "renderdoc-capture")]- let draw_label = {+ {let primitive = self.draw_primitives[index];- format!(+ let draw_label = format!("GX Primitive Batch {index}: primitive={primitive:?} first_vertex={first_vertex} vertex_count={vertex_count}"- )- };- #[cfg(not(feature = "renderdoc-capture"))]- let draw_label = format!("GX Draw {index}: first_vertex={first_vertex} vertex_count={vertex_count}");- rpass.push_debug_group(&draw_label);+ );+ rpass.push_debug_group(&draw_label);+ }let pipeline_key = &self.draw_pipeline_keys[index];let pipeline = &self.pipeline_cache[pipeline_key];rpass.set_pipeline(pipeline);- let pipeline_marker = format!(- "Pipeline: blend={} z={} z_write={} color_update={} alpha_update={}",- pipeline_key.blend_enable,- pipeline_key.z_enable,- pipeline_key.z_write,- pipeline_key.color_update,- pipeline_key.alpha_update- );- rpass.insert_debug_marker(&pipeline_marker);+ #[cfg(feature = "renderdoc-capture")]+ {+ let pipeline_marker = format!(+ "Pipeline: blend={} z={} z_write={} color_update={} alpha_update={}",+ pipeline_key.blend_enable,+ pipeline_key.z_enable,+ pipeline_key.z_write,+ pipeline_key.color_update,+ pipeline_key.alpha_update+ );+ rpass.insert_debug_marker(&pipeline_marker);+ }let bg_key = &self.draw_bg_keys[index];let bind_group = &self.bind_group_cache[bg_key];@@ -545,8 +551,11 @@ impl GxRenderer {let frame_offset = (index * frame_stride) as u32;let draw_offset = (index as u64 * self.draw_uniform_stride) as u32;rpass.set_bind_group(0, bind_group, &[frame_offset, draw_offset]);- let bind_marker = format!("Bind group offsets: frame={frame_offset} draw={draw_offset}");- rpass.insert_debug_marker(&bind_marker);+ #[cfg(feature = "renderdoc-capture")]+ {+ let bind_marker = format!("Bind group offsets: frame={frame_offset} draw={draw_offset}");+ rpass.insert_debug_marker(&bind_marker);+ }let vp = &self.draw_viewports[index];let max_dim = target_width.max(target_height) as f32;@@ -570,16 +579,21 @@ impl GxRenderer {let sc_w = sc.w.min(target_width - sc_x);let sc_h = sc.h.min(target_height - sc_y);rpass.set_scissor_rect(sc_x, sc_y, sc_w, sc_h);- let raster_marker = format!(- "Raster state: viewport=({:.1},{:.1} {:.1}x{:.1}) scissor=({},{} {}x{})",- vp.x, vp.y, vp_w, vp_h, sc_x, sc_y, sc_w, sc_h- );- rpass.insert_debug_marker(&raster_marker);+ #[cfg(feature = "renderdoc-capture")]+ {+ let raster_marker = format!(+ "Raster state: viewport=({:.1},{:.1} {:.1}x{:.1}) scissor=({},{} {}x{})",+ vp.x, vp.y, vp_w, vp_h, sc_x, sc_y, sc_w, sc_h+ );+ rpass.insert_debug_marker(&raster_marker);+ }rpass.draw(first_vertex..first_vertex + vertex_count, 0..1);+ #[cfg(feature = "renderdoc-capture")]rpass.pop_debug_group();}}+ #[cfg(feature = "renderdoc-capture")]encoder.pop_debug_group();queue.submit([encoder.finish()]);diff --git a/crates/backend-wgpu/src/sink.rs b/crates/backend-wgpu/src/sink.rsindex 753ba19..4685f55 100644--- a/crates/backend-wgpu/src/sink.rs+++ b/crates/backend-wgpu/src/sink.rs@@ -3,11 +3,12 @@ use crossbeam_channel::{Receiver, Sender, bounded};#[cfg(feature = "efb-writeback")]use gecko::host::EfbWriteback;use gecko::host::{GxAction, RenderSink};+use std::sync::atomic::{AtomicU64, Ordering};use std::sync::{Arc, Mutex};#[cfg(feature = "renderdoc-capture")]use std::time::Duration;-const CHANNEL_CAPACITY: usize = 8192;+const CHANNEL_CAPACITY: usize = 65536;/// Holds the XFB output texture view that the worker updates and the main/// thread reads for blitting.@@ -113,6 +114,7 @@ pub struct Renderer {blit_bind_group_layout: wgpu::BindGroupLayout,blit_sampler: wgpu::Sampler,target_aspect: TargetAspect,+ actions_sent: Arc<AtomicU64>,/// Receiver end of the EFB-to-texture writeback channel. Taken by the/// emulator setup code (via [`Renderer::take_writeback_rx`]) and/// installed into `GraphicsProcessor::efb_writeback_rx`. Wrapped in@@ -236,6 +238,7 @@ impl Renderer {blit_bind_group_layout,blit_sampler,target_aspect,+ actions_sent: Arc::new(AtomicU64::new(0)),#[cfg(feature = "efb-writeback")]writeback_rx: Arc::new(Mutex::new(Some(writeback_rx))),}@@ -348,8 +351,21 @@ impl Renderer {impl RenderSink for Renderer {fn exec(&mut self, action: GxAction) {+ self.actions_sent.fetch_add(1, Ordering::Relaxed);let _ = self.tx.send(WorkerMsg::Action(action));}++ fn actions_sent_total(&self) -> u64 {+ self.actions_sent.load(Ordering::Relaxed)+ }++ fn channel_len(&self) -> usize {+ self.tx.len()+ }++ fn channel_capacity(&self) -> Option<usize> {+ self.tx.capacity()+ }}/// Snap a requested window size to the largest rectangle withdiff --git a/crates/gecko/src/flipper/gx.rs b/crates/gecko/src/flipper/gx.rsindex 1d3160c..b0f49c2 100644--- a/crates/gecko/src/flipper/gx.rs+++ b/crates/gecko/src/flipper/gx.rs@@ -17,8 +17,7 @@ use crate::flipper::gx::regs::{};#[cfg(feature = "efb-writeback")]use crate::host::EfbWriteback;-use crate::host::{DrawVertex, GxAction, LightData, RenderSink, TextureKey, XfbPart};-use crate::mmio::Mmio;+use crate::host::{DrawVertex, GxAction, LightData, TextureKey, XfbPart};use crate::system::{System, SystemId};use rustc_hash::FxHashMap;@@ -32,6 +31,7 @@ pub struct GraphicsProcessor {pub cp_regs: Vec<u32>,pub xf_mem: Vec<u32>,pub fifo: Vec<u8>,+ pub dl_scratch: Vec<u8>,// Current GX state to snapshot into a Draw action laterpub cur_textures: [Option<draw::TextureDescriptor>; 8],@@ -72,9 +72,9 @@ pub struct GraphicsProcessor {// XFB copies accumulated since the last vblank. `present_xfb()` drains// this at each field boundary to emit a PresentXfb action.pub xfb_copies: Vec<XfbCopy>,- pub vertices_scratch: Vec<draw::Vertex>,pub draw_vertices_scratch: Vec<DrawVertex>,pub lighting_dirty: bool,+ pub konst_dirty: bool,pub cached_color_ctrl: [ChanCtrl; 2],pub cached_alpha_ctrl: [ChanCtrl; 2],pub cached_ambient_color: [[f32; 4]; 2],@@ -128,6 +128,7 @@ impl GraphicsProcessor {cp_regs: vec![0; CP_REG_SIZE],xf_mem: vec![0; XF_MEM_SIZE],fifo: Vec::with_capacity(256),+ dl_scratch: Vec::with_capacity(4096),projection: Matrix4::default(),cur_textures: Default::default(),cur_tluts: [draw::TlutRef::default(); 8],@@ -156,9 +157,9 @@ impl GraphicsProcessor {cur_scissor_offset_x: 0,cur_scissor_offset_y: 0,xfb_copies: Vec::new(),- vertices_scratch: Vec::with_capacity(256),draw_vertices_scratch: Vec::with_capacity(256),lighting_dirty: true,+ konst_dirty: true,cached_color_ctrl: [ChanCtrl::default(); 2],cached_alpha_ctrl: [ChanCtrl::default(); 2],cached_ambient_color: [[0.0; 4]; 2],@@ -171,18 +172,6 @@ impl GraphicsProcessor {efb_writeback_rx: None,}}-- fn execute_display_list<const SYSTEM: SystemId>(- &mut self,- mmio: &mut Mmio<SYSTEM>,- renderer: &mut dyn RenderSink,- data: &[u8],- ) {- let saved = std::mem::take(&mut self.fifo);- self.fifo = data.to_vec();- self.drain_fifo(mmio, renderer);- self.fifo = saved;- }}pub fn present_xfb<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {diff --git a/crates/gecko/src/flipper/gx/bp.rs b/crates/gecko/src/flipper/gx/bp.rsindex a3a384e..47f1be6 100644--- a/crates/gecko/src/flipper/gx/bp.rs+++ b/crates/gecko/src/flipper/gx/bp.rs@@ -115,7 +115,7 @@ impl GraphicsProcessor {);self.cur_num_tev_stages = stages;self.cur_num_indirect_stages = indirect_stages;- self.resolve_konst_colors();+ self.konst_dirty = true;renderer.exec(GxAction::SetCullMode(gen_mode.cull_mode()));}@@ -159,12 +159,12 @@ impl GraphicsProcessor {// TEV KSEL (constant color selection) registers: recalculate konst colorsif idx >= BP_TEV_KSEL_0 && idx <= BP_TEV_KSEL_0 + 7 {- self.resolve_konst_colors();+ self.konst_dirty = true;}// TEV color register writes also affect konst colorsif idx >= BP_TEV_REGISTERL_0 && idx <= BP_TEV_REGISTERL_0 + 7 {- self.resolve_konst_colors();+ self.konst_dirty = true;}// PE finishdiff --git a/crates/gecko/src/flipper/gx/fifo.rs b/crates/gecko/src/flipper/gx/fifo.rsindex 221d467..37f7984 100644--- a/crates/gecko/src/flipper/gx/fifo.rs+++ b/crates/gecko/src/flipper/gx/fifo.rs@@ -6,134 +6,164 @@ use crate::mmio::Mmio;use crate::system::SystemId;impl GraphicsProcessor {- /// Streaming GP FIFO command processor: parses and dispatches each- /// command inline so state writes (CP/XF/BP) take effect before the- /// next command's parse decisions read them.- ///- /// Partial commands are left in `self.fifo` for the next push to- /// complete: when a command's payload isn't fully present, we `break`- /// without advancing `pos`, then drain only the consumed prefix below.pub fn drain_fifo<const SYSTEM: SystemId>(&mut self, mmio: &mut Mmio<SYSTEM>, renderer: &mut dyn RenderSink) {- let mut pos = 0usize;- loop {- let remaining = self.fifo.len() - pos;- if remaining == 0 {- break;- }- let cmd = self.fifo[pos];+ let mut fifo = std::mem::take(&mut self.fifo);++ let pos = self::drain_buf::<SYSTEM>(self, mmio, renderer, &fifo);+ if pos > 0 {+ fifo.drain(..pos);+ }++ self.fifo = fifo;+ }+}++fn drain_buf<const SYSTEM: SystemId>(+ gp: &mut GraphicsProcessor,+ mmio: &mut Mmio<SYSTEM>,+ renderer: &mut dyn RenderSink,+ fifo: &[u8],+) -> usize {+ let mut pos = 0usize;+ loop {+ let remaining = fifo.len() - pos;+ if remaining == 0 {+ break;+ }- match cmd {- NOP_CMD | INV_VTX_CACHE_CMD => {- pos += 1;+ let cmd = fifo[pos];++ match cmd {+ NOP_CMD | INV_VTX_CACHE_CMD => {+ pos += 1;+ }+ CP_CMD => {+ if remaining < 6 {+ break;}- CP_CMD => {- if remaining < 6 {- break;- }- let mut data = [0u8; 5];- data.copy_from_slice(&self.fifo[pos + 1..pos + 6]);- pos += 6;- self.load_cp(&data);++ let mut data = [0u8; 5];+ data.copy_from_slice(&fifo[pos + 1..pos + 6]);++ pos += 6;++ gp.load_cp(&data);+ }+ XF_CMD => {+ if remaining < 5 {+ break;}- XF_CMD => {- if remaining < 5 {- break;- }- let length = u16::from_be_bytes([self.fifo[pos + 1], self.fifo[pos + 2]]) as usize;- let n = length + 1;- let total = 5 + n * 4;- if remaining < total {- break;- }- let data = self.fifo[pos + 1..pos + total].to_vec();- pos += total;- self.load_xf(renderer, &data);++ let length = u16::from_be_bytes([fifo[pos + 1], fifo[pos + 2]]) as usize;+ let n = length + 1;+ let total = 5 + n * 4;+ if remaining < total {+ break;}- BP_CMD => {- if remaining < 5 {- break;- }- let mut data = [0u8; 4];- data.copy_from_slice(&self.fifo[pos + 1..pos + 5]);- pos += 5;- let mut view = mmio.ram_view_mut();- self.load_bp(renderer, &mut view, &data);++ let data = &fifo[pos + 1..pos + total];++ gp.load_xf(renderer, data);++ pos += total;+ }+ BP_CMD => {+ if remaining < 5 {+ break;}- LOAD_INDX_A_CMD | LOAD_INDX_B_CMD | LOAD_INDX_C_CMD | LOAD_INDX_D_CMD => {- if remaining < 5 {- break;- }- let payload: [u8; 4] = self.fifo[pos + 1..pos + 5].try_into().unwrap();- pos += 5;-- let index = u16::from_be_bytes([payload[0], payload[1]]);- let descriptor = u16::from_be_bytes([payload[2], payload[3]]);- let xf_addr = descriptor & 0x0FFF;- let xf_count = ((descriptor >> 12) & 0xF) as u8 + 1;-- let cp_array_index = match cmd {- LOAD_INDX_A_CMD => ARRAY_POS_NRM_MTX,- LOAD_INDX_B_CMD => ARRAY_NRM_MTX,- LOAD_INDX_C_CMD => ARRAY_POST_MTX,- LOAD_INDX_D_CMD => ARRAY_LIGHT,- _ => unreachable!(),- } as u8;-- let view = mmio.ram_view();- self.load_indexed_xf(renderer, &view, cp_array_index, index, xf_addr, xf_count);++ let mut data = [0u8; 4];+ data.copy_from_slice(&fifo[pos + 1..pos + 5]);++ pos += 5;++ let mut view = mmio.ram_view_mut();+ gp.load_bp(renderer, &mut view, &data);+ }+ LOAD_INDX_A_CMD | LOAD_INDX_B_CMD | LOAD_INDX_C_CMD | LOAD_INDX_D_CMD => {+ if remaining < 5 {+ break;}- CALL_DL_CMD => {- if remaining < 9 {- break;- }- let phys_addr = u32::from_be_bytes(self.fifo[pos + 1..pos + 5].try_into().unwrap());- let nbytes = u32::from_be_bytes(self.fifo[pos + 5..pos + 9].try_into().unwrap());- pos += 9;-- let addr = (phys_addr & 0x3FFFFFFF) as usize;- let len = nbytes as usize;- let dl = match mmio.ram_view().slice(addr, len) {- Some(slice) => slice.to_vec(),- None => {- tracing::warn!(- addr = format!("{addr:#010X}"),- len,- "CallDisplayList: source not mapped to MEM1/MEM2, skipping"- );- continue;- }- };- self.execute_display_list(mmio, renderer, &dl);++ let payload: [u8; 4] = fifo[pos + 1..pos + 5].try_into().unwrap();+ pos += 5;++ let index = u16::from_be_bytes([payload[0], payload[1]]);+ let descriptor = u16::from_be_bytes([payload[2], payload[3]]);+ let xf_addr = descriptor & 0x0FFF;+ let xf_count = ((descriptor >> 12) & 0xF) as u8 + 1;++ let cp_array_index = match cmd {+ LOAD_INDX_A_CMD => ARRAY_POS_NRM_MTX,+ LOAD_INDX_B_CMD => ARRAY_NRM_MTX,+ LOAD_INDX_C_CMD => ARRAY_POST_MTX,+ LOAD_INDX_D_CMD => ARRAY_LIGHT,+ _ => unreachable!(),+ } as u8;++ let view = mmio.ram_view();+ gp.load_indexed_xf(renderer, &view, cp_array_index, index, xf_addr, xf_count);+ }+ CALL_DL_CMD => {+ if remaining < 9 {+ break;}- DRAW_COMMANDS_START..=DRAW_COMMANDS_END => {- if remaining < 3 {- break;++ let phys_addr = u32::from_be_bytes(fifo[pos + 1..pos + 5].try_into().unwrap());+ let nbytes = u32::from_be_bytes(fifo[pos + 5..pos + 9].try_into().unwrap());+ pos += 9;++ let addr = (phys_addr & 0x3FFFFFFF) as usize;+ let len = nbytes as usize;+ let dl_buf: Vec<u8> = match mmio.ram_view().slice(addr, len) {+ Some(slice) => {+ let mut buf = std::mem::take(&mut gp.dl_scratch);+ buf.clear();+ buf.extend_from_slice(slice);+ buf}- let count = u16::from_be_bytes([self.fifo[pos + 1], self.fifo[pos + 2]]) as usize;- let vertex_format_index = (cmd & 0b111) as usize;- let vertex_data_len = count * self.vertex_stride(vertex_format_index);- let total = 3 + vertex_data_len;- if remaining < total {- break;+ None => {+ tracing::warn!(+ addr = format_args!("{addr:#010X}").to_string(),+ len,+ "CallDisplayList: source not mapped"+ );+ continue;}- let vertex_data = self.fifo[pos + 3..pos + total].to_vec();- pos += total;- self.create_draw_call(mmio, renderer, cmd, vertex_data);+ };++ let _ = self::drain_buf::<SYSTEM>(gp, mmio, renderer, &dl_buf);+ gp.dl_scratch = dl_buf;+ }+ DRAW_COMMANDS_START..=DRAW_COMMANDS_END => {+ if remaining < 3 {+ break;}- _ => {- tracing::error!(cmd = format!("{cmd:02X}"), "unknown FIFO command");- pos += 1;++ let count = u16::from_be_bytes([fifo[pos + 1], fifo[pos + 2]]) as usize;+ let vertex_format_index = (cmd & 0b111) as usize;+ let vertex_data_len = count * gp.vertex_stride(vertex_format_index);+ let total = 3 + vertex_data_len;+ if remaining < total {+ break;}- }- }- if pos > 0 {- self.fifo.drain(..pos);+ let vertex_data = &fifo[pos + 3..pos + total];+ gp.create_draw_call(mmio, renderer, cmd, vertex_data);+ pos += total;+ }+ _ => {+ tracing::error!(cmd = cmd, "unknown FIFO command");+ pos += 1;+ }}}+ pos+}++impl GraphicsProcessor {fn vertex_stride(&self, vertex_format_index: usize) -> usize {- // VCD is global state (single register), VAT is per-formatlet vcd_lo = VcdLo::from_raw(self.cp_regs[VCD_LO_REG]);let vcd_hi = VcdHi::from_raw(self.cp_regs[VCD_HI_REG]);let vat_a = VatA::from_raw(self.cp_regs[VATA_REG + vertex_format_index]);diff --git a/crates/gecko/src/flipper/gx/vertex.rs b/crates/gecko/src/flipper/gx/vertex.rsindex 9f85bd8..4200c28 100644--- a/crates/gecko/src/flipper/gx/vertex.rs+++ b/crates/gecko/src/flipper/gx/vertex.rs@@ -46,7 +46,7 @@ impl GraphicsProcessor {mmio: &mut Mmio<SYSTEM>,renderer: &mut dyn RenderSink,cmd: u8,- data: Vec<u8>,+ data: &[u8],) {#[cfg(feature = "gx-stats")]let _gx_stats_t0 = std::time::Instant::now();@@ -73,46 +73,29 @@ impl GraphicsProcessor {self.stats.draws_by_primitive[(primitive as usize) & 0x7] += 1;}- self.vertices_scratch.clear();- self.vertices_scratch.reserve(vertex_count);-- let mut cur = Cursor::new(&data);+ self.draw_vertices_scratch.clear();+ self.draw_vertices_scratch.reserve(vertex_count);+ let mut cur = Cursor::new(data);let view = mmio.ram_view();- for i in 0..vertex_count {- let vertex = self.decode_vertex(&mut cur, &data, &view, &vf, i);- self.vertices_scratch.push(vertex);++ for _ in 0..vertex_count {+ let v = self.decode_vertex(&mut cur, data, &view, &vf);+ self.draw_vertices_scratch.push(v);}let modelview = self.build_modelview_matrix(vf.default_pos_mtx_idx);- tracing::debug!(- primitive = format!("{:?}", primitive),- vertices = format!("{:?}", self.vertices_scratch),- pos_mtx_idx = vf.default_pos_mtx_idx,- modelview = format!("{:?}", modelview),- projection = format!("{:?}", self.projection),- "draw call created"- );-- // Resolve TEV color registers to f32 arrays for the snapshotlet tev_color_regs = self.resolve_tev_color_regs();let tev_orders = self.resolve_tev_orders();self.rebuild_lighting_cache_if_dirty();- self.draw_vertices_scratch.clear();- self.draw_vertices_scratch.reserve(self.vertices_scratch.len());- for v in &self.vertices_scratch {- self.draw_vertices_scratch.push(DrawVertex {- position: v.position,- normal: v.normal,- color0: v.color0,- color1: v.color1,- pos_view: v.pos_view,- texcoords: std::array::from_fn(|i| v.texcoords[i].unwrap_or([0.0, 0.0, 1.0])),- });+ if self.konst_dirty {+ self.resolve_konst_colors();+ self.konst_dirty = false;}+let draw_vertices = std::mem::take(&mut self.draw_vertices_scratch);// Flatten the three indirect matrices to 6 rows. Row 2M is row@@ -165,7 +148,7 @@ impl GraphicsProcessor {alpha_ctrl: self.cached_alpha_ctrl,ambient_color: self.cached_ambient_color,material_color: self.cached_material_color,- lights: self.cached_lights.clone(),+ lights: self.cached_lights,}));#[cfg(feature = "gx-stats")]@@ -326,14 +309,7 @@ impl GraphicsProcessor {}}- fn decode_vertex(- &self,- cur: &mut Cursor<&Vec<u8>>,- data: &[u8],- ram: &RamView<'_>,- vf: &VertexFormat,- vertex_idx: usize,- ) -> draw::Vertex {+ fn decode_vertex(&self, cur: &mut Cursor<&[u8]>, data: &[u8], ram: &RamView<'_>, vf: &VertexFormat) -> DrawVertex {// Resolve an indexed vertex attribute (positions, normals, colors,// texcoords) to a slice in whichever bank holds it. If the address// falls outside both MEM1 and MEM2, fall back to a zero-filled@@ -482,27 +458,20 @@ impl GraphicsProcessor {let normal_view = Vec3::from(normal).transform(&nrm_mtx).normalize();let pos_view = self.xf_transform_3x4(pos_mtx_base, position);- // Texture coordinate generation (XF texgen)- // compute_texgen now returns [f32; 3] (s, t, q) with perspective- // divide deferred to the fragment shader.let num_texgens = (self.xf_mem[XF_NUM_TEXGENS] as usize).min(8);- let mut texcoords: [Option<[f32; 3]>; 8] = [None; 8];+ let mut texcoords: [[f32; 3]; 8] = [[0.0, 0.0, 1.0]; 8];+for tg_idx in 0..num_texgens {- texcoords[tg_idx] = Some(self.compute_texgen(tg_idx, position, normal, &raw_texcoords, &tex_mtx_idx));+ texcoords[tg_idx] = self.compute_texgen(tg_idx, position, normal, &raw_texcoords, &tex_mtx_idx);}- // For texcoords beyond num_texgens, pass through raw values with q=1+for tg_idx in num_texgens..8 {- texcoords[tg_idx] = raw_texcoords[tg_idx].map(|st| [st[0], st[1], 1.0]);+ if let Some(st) = raw_texcoords[tg_idx] {+ texcoords[tg_idx] = [st[0], st[1], 1.0];+ }}- tracing::debug!(- vertex = vertex_idx,- position = format!("{:02X?}", position),- color0 = format!("{:?}", color0),- "Vertex"- );-- draw::Vertex {+ DrawVertex {position,color0,color1,@@ -605,7 +574,7 @@ impl GraphicsProcessor {}}-fn read_index(cur: &mut Cursor<&Vec<u8>>, attr: AttributeType) -> usize {+fn read_index(cur: &mut Cursor<&[u8]>, attr: AttributeType) -> usize {match attr {AttributeType::Index8 => {let mut buf = [0u8; 1];diff --git a/crates/gecko/src/fps.rs b/crates/gecko/src/fps.rsindex 831aa75..75b14b0 100644--- a/crates/gecko/src/fps.rs+++ b/crates/gecko/src/fps.rs@@ -1,3 +1,4 @@+use std::path::PathBuf;use std::sync::Arc;use std::sync::atomic::{AtomicU64, Ordering};use std::time::Instant;@@ -11,15 +12,20 @@ pub type FpsShared = Arc<AtomicU64>;pub struct FpsCounter {pub vsync_count: u32,pub last_tick: Instant,+ pub run_start: Instant,pub shared: FpsShared,+ pub log_path: Option<PathBuf>,}impl FpsCounter {pub fn new() -> Self {+ let now = Instant::now();Self {vsync_count: 0,- last_tick: Instant::now(),+ last_tick: now,+ run_start: now,shared: Arc::new(AtomicU64::new(0)),+ log_path: None,}}@@ -71,6 +77,15 @@ pub fn fps_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {"emu fps");+ if let Some(path) = sys.fps_counter.log_path.clone() {+ use std::io::Write;++ let t = now.duration_since(sys.fps_counter.run_start).as_secs_f64();+ if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open(&path) {+ let _ = writeln!(f, "{t:.3},{fps:.2},{native_pct:.2},{vsyncs}");+ }+ }+sys.fps_counter.shared.store(self::pack(fps as f32, native_pct as f32), Ordering::Relaxed);diff --git a/crates/gecko/src/gekko/jit.rs b/crates/gecko/src/gekko/jit.rsindex 7e0d836..8bad7dc 100644--- a/crates/gecko/src/gekko/jit.rs+++ b/crates/gecko/src/gekko/jit.rs@@ -39,7 +39,7 @@ pub struct BlockLookupSlot {pub entry: usize,}-pub const BLOCK_LOOKUP_TABLE_SIZE: usize = 8192;+pub const BLOCK_LOOKUP_TABLE_SIZE: usize = 131072;pub const BLOCK_LOOKUP_TABLE_MASK: u32 = (BLOCK_LOOKUP_TABLE_SIZE as u32) - 1;#[derive(Clone, Copy)]@@ -93,6 +93,7 @@ pub struct JitEngine<const SYSTEM: SystemId> {trampoline_fn: TrampolineFn,block_lookup_table_addr: usize,block_seq: u64,+ dump_pc: Option<u32>,}impl<const SYSTEM: SystemId> JitEngine<SYSTEM> {@@ -487,6 +488,9 @@ impl<const SYSTEM: SystemId> JitEngine<SYSTEM> {trampoline_fn,block_lookup_table_addr,block_seq: 0,+ dump_pc: std::env::var("GECKO_DUMP_PC")+ .ok()+ .and_then(|s| u32::from_str_radix(s.trim().trim_start_matches("0x"), 16).ok()),}}@@ -839,10 +843,54 @@ impl<const SYSTEM: SystemId> JitEngine<SYSTEM> {self.pending_chain_slots.entry(target_pc).or_default().push(slot_addr);}+ let want_dump = self.dump_pc == Some(spec.start_pc);+ if want_dump {+ self.ctx.set_disasm(true);+ }+self.module.define_function(func_id, &mut self.ctx).expect("define block");+ if want_dump {+ if let Some(cc) = self.ctx.compiled_code() {+ let path = format!("./profile-dumps/jit-disasm-{:08x}.txt", spec.start_pc);+ let mut s = String::new();++ use std::fmt::Write as _;++ let _ = writeln!(+ s,+ "; PPC block at {:#010x}, len={} instrs, terminator={:?}",+ spec.start_pc,+ spec.instrs.len(),+ spec.terminator+ );++ for (i, &raw) in spec.instrs.iter().enumerate() {+ let pc = spec.pc_of(i);+ let _ = writeln!(s, "; {:08x} {:08x}", pc, raw);+ }++ let _ = writeln!(s, "; --- cranelift vcode ---");+ if let Some(vcode) = cc.vcode.as_ref() {+ s.push_str(vcode);+ }++ let _ = writeln!(s, "\n; --- emitted bytes ({} bytes) ---", cc.code_buffer().len());+ for chunk in cc.code_buffer().chunks(16) {+ s.push_str("; ");+ for b in chunk {+ let _ = write!(s, "{:02x} ", b);+ }+ s.push('\n');+ }++ let _ = std::fs::write(&path, s);+ tracing::info!(pc = format_args!("{:#010x}", spec.start_pc).to_string(), %path, "dumped JIT disasm");+ }+ }+self.module.finalize_definitions().expect("finalize");let entry = self.module.get_finalized_function(func_id) as usize;diff --git a/crates/gecko/src/gekko/jit/block.rs b/crates/gecko/src/gekko/jit/block.rsindex e2d155d..90d7771 100644--- a/crates/gecko/src/gekko/jit/block.rs+++ b/crates/gecko/src/gekko/jit/block.rs@@ -1,7 +1,7 @@use crate::gekko::instruction::Instruction;use crate::system::{System, SystemId};-pub const MAX_BLOCK_INSTRS: usize = 64;+pub const MAX_BLOCK_INSTRS: usize = 256;#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum TermKind {@@ -46,7 +46,7 @@ impl BlockSpec {}pub fn discover<const SYSTEM: SystemId>(sys: &System<SYSTEM>, start_pc: u32) -> BlockSpec {- const EXTENSION_MAX_FORWARD_BYTES: u32 = 256;+ const EXTENSION_MAX_FORWARD_BYTES: u32 = 1024;let mut instrs: Vec<u32> = Vec::with_capacity(8);let mut pcs: Vec<u32> = Vec::with_capacity(8);diff --git a/crates/gecko/src/gekko/jit/idle.rs b/crates/gecko/src/gekko/jit/idle.rsindex b370509..e3b5b74 100644--- a/crates/gecko/src/gekko/jit/idle.rs+++ b/crates/gecko/src/gekko/jit/idle.rs@@ -5,6 +5,7 @@ pub enum IdleClass {None,BranchToSelf,PollingLoop,+ PointerIterLoop { gpr: u8, stride: i32 },}pub fn classify<const SYSTEM: crate::system::SystemId>(spec: &BlockSpec, gprs: &[u32; 32]) -> IdleClass {@@ -14,6 +15,10 @@ pub fn classify<const SYSTEM: crate::system::SystemId>(spec: &BlockSpec, gprs: &return class;}+ if let Some(p) = self::classify_pointer_iter_loop(spec) {+ return p;+ }+if classify_polling_loop(spec) {return IdleClass::PollingLoop;}@@ -21,6 +26,68 @@ pub fn classify<const SYSTEM: crate::system::SystemId>(spec: &BlockSpec, gprs: &IdleClass::None}+fn classify_pointer_iter_loop(spec: &BlockSpec) -> Option<IdleClass> {+ if spec.terminator != TermKind::BranchCond || spec.instrs.len() != 3 {+ return None;+ }++ let i0 = crate::gekko::instruction::Instruction(spec.instrs[0]);+ let i1 = crate::gekko::instruction::Instruction(spec.instrs[1]);+ let i2 = crate::gekko::instruction::Instruction(spec.instrs[2]);++ if !self::is_cache_op_no_side_effect(i0) {+ return None;+ }++ if i1.primary_opcode() != 14 {+ return None;+ }+ let addi_ra = i1.ra();+ let addi_rd = i1.rd();+ if addi_ra == 0 || addi_ra != addi_rd {+ return None;+ }+ let stride = i1.simm();++ if i2.primary_opcode() != 16 {+ return None;+ }+ if i2.lk() {+ return None;+ }+ let bo = i2.bo();+ if bo & 0b10000 == 0 {+ return None;+ }+ if bo & 0b00100 != 0 {+ return None;+ }+ if bo & 0b00010 != 0 {+ return None;+ }+ let branch_pc = spec.start_pc.wrapping_add(8);+ let target = if i2.aa() {+ i2.bd() as u32+ } else {+ branch_pc.wrapping_add_signed(i2.bd())+ };+ if target != spec.start_pc {+ return None;+ }++ Some(IdleClass::PointerIterLoop {+ gpr: addi_ra,+ stride: stride as i32,+ })+}++fn is_cache_op_no_side_effect(instr: crate::gekko::instruction::Instruction) -> bool {+ if instr.primary_opcode() != 31 {+ return false;+ }+ matches!(instr.xo10(), 86 | 470 | 54 | 278 | 246 | 1014 | 982 | 758)+}+fn classify_branch_to_self(spec: &BlockSpec) -> Option<IdleClass> {if spec.terminator != TermKind::Branch || spec.instrs.len() != 1 {return None;diff --git a/crates/gecko/src/gekko/jit/translator.rs b/crates/gecko/src/gekko/jit/translator.rsindex 17305aa..238e0da 100644--- a/crates/gecko/src/gekko/jit/translator.rs+++ b/crates/gecko/src/gekko/jit/translator.rs@@ -168,8 +168,48 @@ pub fn translate<const SYSTEM: SystemId>(let exit_block = builder.create_block();builder.append_block_param(exit_block, types::I32);+ if let IdleClass::PointerIterLoop { gpr, stride } = idle_class {+ let rb_off = self::gpr_offset::<SYSTEM>(gpr);+ let ctr_off = abi::ctr_offset::<SYSTEM>() as i32;+ let cyc_off = abi::cycles_offset::<SYSTEM>() as i32;++ let rb_val = builder.ins().load(types::I32, MemFlags::trusted(), ctx_ptr, rb_off);+ let ctr_val = builder.ins().load(types::I32, MemFlags::trusted(), ctx_ptr, ctr_off);++ let stride_v = builder.ins().iconst(types::I32, stride as i64);+ let delta = builder.ins().imul(ctr_val, stride_v);+ let new_rb = builder.ins().iadd(rb_val, delta);+ builder.ins().store(MemFlags::trusted(), new_rb, ctx_ptr, rb_off);++ let zero_v = builder.ins().iconst(types::I32, 0);+ builder.ins().store(MemFlags::trusted(), zero_v, ctx_ptr, ctr_off);++ let cyc_val = builder.ins().load(types::I64, MemFlags::trusted(), ctx_ptr, cyc_off);+ let ctr_64 = builder.ins().uextend(types::I64, ctr_val);+ let per_iter = builder.ins().iconst(types::I64, 3 * CYCLES_PER_INSTR);+ let cyc_delta = builder.ins().imul(ctr_64, per_iter);+ let new_cyc = builder.ins().iadd(cyc_val, cyc_delta);+ builder.ins().store(MemFlags::trusted(), new_cyc, ctx_ptr, cyc_off);++ let final_nia = builder.ins().iconst(types::I32, spec.start_pc.wrapping_add(12) as i64);++ if let Some(slot_addr) = chain_fall_addr {+ emit_chain_or_exit::<SYSTEM>(&mut builder, ctx_ptr, slot_addr, block_sig_ref, final_nia, exit_block);+ } else {+ builder.ins().jump(exit_block, &[final_nia.into()]);+ }++ builder.switch_to_block(exit_block);+ builder.seal_block(exit_block);+ let exit_nia = builder.block_params(exit_block)[0];+ builder.ins().return_(&[exit_nia]);+ builder.finalize();+ return;+ }+let mut last_terminator_nia: Option<Value> = None;let mut chained = false;+ let mut pending_cycles: i64 = 0;let mut t = JitTranslator {builder_ptr: &mut builder as *mut FunctionBuilder<'_> as *mut () as usize,@@ -197,11 +237,16 @@ pub fn translate<const SYSTEM: SystemId>(t.handled_natively = false;let chained_before = t.chained;+ if is_terminator && pending_cycles > 0 {+ emit_cycles_add::<SYSTEM>(&mut builder, ctx_ptr, pending_cycles);+ pending_cycles = 0;+ }+super::dispatch::<SYSTEM>(&mut t, instr);if t.handled_natively {if !t.chained || chained_before {- emit_cycles_add::<SYSTEM>(&mut builder, ctx_ptr, CYCLES_PER_INSTR);+ pending_cycles += CYCLES_PER_INSTR;}if t.chained && !chained_before {@@ -212,6 +257,11 @@ pub fn translate<const SYSTEM: SystemId>(last_terminator_nia = Some(nia);}} else {+ if pending_cycles > 0 {+ emit_cycles_add::<SYSTEM>(&mut builder, ctx_ptr, pending_cycles);+ pending_cycles = 0;+ }+let pc_const = builder.ins().iconst(types::I32, pc as i64);let raw_const = builder.ins().iconst(types::I32, instr.0 as i64);let call = builder@@ -236,6 +286,10 @@ pub fn translate<const SYSTEM: SystemId>(}drop(t);+ if pending_cycles > 0 {+ self::emit_cycles_add::<SYSTEM>(&mut builder, ctx_ptr, pending_cycles);+ }+if !chained {if idle_class != IdleClass::None {builder.ins().call(local.advance_to_deadline, &[ctx_ptr]);@@ -323,6 +377,7 @@ pub(crate) fn emit_divwu<const SYSTEM: SystemId>(let div_block = builder.create_block();let zero_block = builder.create_block();+ builder.set_cold_block(zero_block);let merge = builder.create_block();builder.append_block_param(merge, types::I32);@@ -355,6 +410,7 @@ pub(crate) fn emit_divw<const SYSTEM: SystemId>(let div_block = builder.create_block();let bad_block = builder.create_block();+ builder.set_cold_block(bad_block);let merge = builder.create_block();builder.append_block_param(merge, types::I32);@@ -586,6 +642,7 @@ pub(crate) fn emit_trap_check<const SYSTEM: SystemId>(if let Some(c) = cond {let trap_block = builder.create_block();+ builder.set_cold_block(trap_block);let cont_block = builder.create_block();builder.ins().brif(c, trap_block, &[], cont_block, &[]);@@ -1412,6 +1469,7 @@ pub(crate) fn emit_inline_cache_dispatch<const SYSTEM: SystemId>(let hit_block = builder.create_block();let miss_block = builder.create_block();+ builder.set_cold_block(miss_block);builder.ins().brif(ok, hit_block, &[], miss_block, &[]);builder.switch_to_block(miss_block);@@ -1682,6 +1740,7 @@ pub(crate) fn emit_chain_or_exit<const SYSTEM: SystemId>(let target_ptr = builder.ins().load(types::I64, MemFlags::trusted(), slot_const, 0);let is_null = builder.ins().icmp_imm(IntCC::Equal, target_ptr, 0);let dispatch_block = builder.create_block();+ builder.set_cold_block(dispatch_block);let tailcall_block = builder.create_block();builder.ins().brif(is_null, dispatch_block, &[], tailcall_block, &[]);@@ -1722,6 +1781,7 @@ pub(crate) fn emit_call_or_exit<const SYSTEM: SystemId>(let is_null = builder.ins().icmp_imm(IntCC::Equal, target_ptr, 0);let dispatch_block = builder.create_block();+ builder.set_cold_block(dispatch_block);let call_block = builder.create_block();builder.ins().brif(is_null, dispatch_block, &[], call_block, &[]);@@ -2002,6 +2062,7 @@ pub(crate) fn emit_lha_d_form<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.append_block_param(merge, types::I32);@@ -2096,6 +2157,7 @@ pub(crate) fn emit_u32_store_at_ea<const SYSTEM: SystemId>() {let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();let (host_ptr, page_off) = emit_fastmem_lookup::<SYSTEM>(builder, ctx_ptr, ea);@@ -2136,6 +2198,7 @@ pub(crate) fn emit_psq_x<const SYSTEM: SystemId>(let easy = emit_gqr_type_zero_check::<SYSTEM>(builder, ctx_ptr, instr.i_22_24(), store);let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.ins().brif(easy, fast_block, &[], slow_block, &[]);@@ -2310,6 +2373,7 @@ pub(crate) fn emit_lha_xform<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.append_block_param(merge, types::I32);@@ -2356,6 +2420,7 @@ pub(crate) fn emit_load_xform_brx<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.append_block_param(merge, types::I32);@@ -2410,6 +2475,7 @@ pub(crate) fn emit_store_xform_brx<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();let (host_ptr, page_off) = emit_fastmem_lookup::<SYSTEM>(builder, ctx_ptr, ea);@@ -2513,6 +2579,7 @@ pub(crate) fn emit_msr_fp_guard<const SYSTEM: SystemId>(let fp_bit = builder.ins().band_imm(msr, 0x2000);let fp_disabled = builder.ins().icmp_imm(IntCC::Equal, fp_bit, 0);let trap_block = builder.create_block();+ builder.set_cold_block(trap_block);let cont_block = builder.create_block();builder.ins().brif(fp_disabled, trap_block, &[], cont_block, &[]);@@ -2577,6 +2644,7 @@ pub(crate) fn emit_lfs<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.append_block_param(merge, types::F64);@@ -2619,6 +2687,7 @@ pub(crate) fn emit_lfd<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.append_block_param(merge, types::F64);@@ -2661,6 +2730,7 @@ pub(crate) fn emit_stfs<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();let (host_ptr, page_off) = emit_fastmem_lookup::<SYSTEM>(builder, ctx_ptr, ea);@@ -2699,6 +2769,7 @@ pub(crate) fn emit_stfd<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();let (host_ptr, page_off) = emit_fastmem_lookup::<SYSTEM>(builder, ctx_ptr, ea);@@ -2774,6 +2845,7 @@ pub(crate) fn emit_lfs_at_ea<const SYSTEM: SystemId>() {let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.append_block_param(merge, types::F64);@@ -2814,6 +2886,7 @@ pub(crate) fn emit_lfd_at_ea<const SYSTEM: SystemId>() {let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.append_block_param(merge, types::F64);@@ -2855,6 +2928,7 @@ pub(crate) fn emit_stfs_at_ea<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();let (host_ptr, page_off) = emit_fastmem_lookup::<SYSTEM>(builder, ctx_ptr, ea);@@ -2893,6 +2967,7 @@ pub(crate) fn emit_stfd_at_ea<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();let (host_ptr, page_off) = emit_fastmem_lookup::<SYSTEM>(builder, ctx_ptr, ea);@@ -2935,6 +3010,7 @@ pub(crate) fn emit_psq_l<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.ins().brif(easy, fast_block, &[], slow_block, &[]);@@ -2990,6 +3066,7 @@ pub(crate) fn emit_psq_st<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.ins().brif(easy, fast_block, &[], slow_block, &[]);@@ -3356,6 +3433,7 @@ pub(crate) fn emit_read_f32<const SYSTEM: SystemId>() -> Value {let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.append_block_param(merge, types::F64);@@ -3395,6 +3473,7 @@ pub(crate) fn emit_write_f32<const SYSTEM: SystemId>() {let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();let (host_ptr, page_off) = emit_fastmem_lookup::<SYSTEM>(builder, ctx_ptr, ea);@@ -4146,6 +4225,7 @@ pub(crate) fn emit_load_at_ea<const SYSTEM: SystemId>() {let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();builder.append_block_param(merge, types::I32);@@ -4225,6 +4305,7 @@ pub(crate) fn emit_store_at_ea<const SYSTEM: SystemId>(let fast_block = builder.create_block();let slow_block = builder.create_block();+ builder.set_cold_block(slow_block);let merge = builder.create_block();let (host_ptr, page_off) = emit_fastmem_lookup::<SYSTEM>(builder, ctx_ptr, ea);diff --git a/crates/gecko/src/host.rs b/crates/gecko/src/host.rsindex d8c05cc..0b15592 100644--- a/crates/gecko/src/host.rs+++ b/crates/gecko/src/host.rs@@ -211,7 +211,7 @@ pub struct DrawVertex {}/// Per-light snapshot for the draw call.-#[derive(Debug, Clone, Default)]+#[derive(Debug, Clone, Copy, Default)]pub struct LightData {pub color: [f32; 4],pub cosatt: [f32; 4],@@ -226,6 +226,18 @@ pub trait RenderSink: Send {/// Submit a single action. Implementations should not block unless/// back-pressure from the renderer requires it.fn exec(&mut self, action: GxAction);++ fn actions_sent_total(&self) -> u64 {+ 0+ }++ fn channel_len(&self) -> usize {+ 0+ }++ fn channel_capacity(&self) -> Option<usize> {+ None+ }}/// Swallows every action. Used by headless runners (tinybench, tinytracer)diff --git a/crates/gecko/src/profile.rs b/crates/gecko/src/profile.rsindex 47ede80..2df2a09 100644--- a/crates/gecko/src/profile.rs+++ b/crates/gecko/src/profile.rs@@ -72,6 +72,7 @@ pub struct PprofConfig {pub hz: u32,pub secs: u32,pub out: PathBuf,+ pub delay_vsyncs: u32,}#[cfg(all(feature = "profile", windows))]diff --git a/crates/gecko/src/system.rs b/crates/gecko/src/system.rsindex 1e66ece..6ee3e8e 100644--- a/crates/gecko/src/system.rs+++ b/crates/gecko/src/system.rs@@ -334,10 +334,13 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {0};+ let actions_sent = self.render_sink.actions_sent_total();+ let channel_len = self.render_sink.channel_len();+ let channel_cap = self.render_sink.channel_capacity().unwrap_or(0);let result = crate::profile::write_file_atomic(&path, |f| {writeln!(f,- "vsync_count={}\ndraw_calls={}\nvertices={}\nfifo_bytes={}\ntexture_loads={}\nxfb_presents={}\nbp_writes={}\nxf_writes={}\ncreate_draw_call_ns={}\navg_draw_call_ns={}",+ "vsync_count={}\ndraw_calls={}\nvertices={}\nfifo_bytes={}\ntexture_loads={}\nxfb_presents={}\nbp_writes={}\nxf_writes={}\ncreate_draw_call_ns={}\navg_draw_call_ns={}\nrender_actions_sent={}\nrender_channel_len={}\nrender_channel_cap={}",self.vsync_count,s.draw_calls,s.vertices,@@ -348,6 +351,9 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {s.xf_writes,s.create_draw_call_ns,avg_draw_ns,+ actions_sent,+ channel_len,+ channel_cap,)?;writeln!(f, "\n--- draws by primitive ---")?;@@ -458,18 +464,21 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {#[cfg(feature = "profile")]fn tick_pprof_session(&mut self) {if self.pprof_session.is_none() {- if let Some(cfg) = self.pprof_config.take() {- match crate::profile::IpSampler::start_for_current_thread(cfg.hz, cfg.secs, cfg.out.clone()) {- Ok(s) => {- tracing::info!(- "pprof: sampling at {} Hz for {} s, writing to {}",- cfg.hz,- cfg.secs,- cfg.out.display()- );- self.pprof_session = Some(s);+ if let Some(cfg) = self.pprof_config.as_ref() {+ if self.vsync_count >= cfg.delay_vsyncs as u64 {+ let cfg = self.pprof_config.take().unwrap();+ match crate::profile::IpSampler::start_for_current_thread(cfg.hz, cfg.secs, cfg.out.clone()) {+ Ok(s) => {+ tracing::info!(+ hz = cfg.hz,+ secs = cfg.secs,+ out = %cfg.out.display(),+ "pprof: sampling started",+ );+ self.pprof_session = Some(s);+ }+ Err(err) => tracing::warn!(?err, "failed to start pprof sampler"),}- Err(err) => tracing::warn!(?err, "failed to start pprof sampler"),}}}diff --git a/crates/tinyapp/src/app.rs b/crates/tinyapp/src/app.rsindex 43e604f..790fd3d 100644--- a/crates/tinyapp/src/app.rs+++ b/crates/tinyapp/src/app.rs@@ -92,7 +92,7 @@ impl State {let frame = match self.surface.get_current_texture() {Ok(f) => f,Err(e) => {- eprintln!("surface error: {e}");+ tracing::error!(?e, "surface error");return;}};diff --git a/crates/tinyapp/src/main.rs b/crates/tinyapp/src/main.rsindex 1082ede..eca9f72 100644--- a/crates/tinyapp/src/main.rs+++ b/crates/tinyapp/src/main.rs@@ -113,6 +113,16 @@ struct Args {#[cfg(feature = "profile")]#[arg(long, default_value = "./profile-dumps/pprof-samples.csv")]pprof_out: String,++ /// Delay starting pprof for N emulated vsyncs (e.g. 3600 = 60s of in-game vsyncs)+ #[cfg(feature = "profile")]+ #[arg(long, default_value_t = 0)]+ pprof_delay: u32,++ /// Append per-second emu FPS samples to a CSV at this path (requires --features fps-counter)+ #[cfg(feature = "fps-counter")]+ #[arg(long)]+ fps_log: Option<String>,}fn resolve_aspect(arg: &str, system: SystemId) -> TargetAspect {@@ -185,7 +195,7 @@ fn main() {let dvd = image::load_dvd(dvd_data);let game_id = self::game_id_from_header(dvd.header());if dvd.header().is_wii() {- println!("Detected Wii disc, booting via apploader HLE");+ tracing::info!("Detected Wii disc, booting via apploader HLE");let builder = Wii::apploader_hle(dvd);#[cfg(feature = "scripting")]let builder = if let Some(ref path) = args.script {@@ -198,7 +208,7 @@ fn main() {configure(&mut emulator, &args);run(emulator, present_mode, &args, Some(game_id));} else {- println!("Detected GameCube disc, booting via IPL HLE");+ tracing::info!("Detected GameCube disc, booting via IPL HLE");let mut emulator = GameCube::with_ipl_hle(dvd);configure(&mut emulator, &args);run(emulator, present_mode, &args, Some(game_id));@@ -261,6 +271,7 @@ fn configure<const SYSTEM: SystemId>(emulator: &mut System<SYSTEM>, args: &Args)hz: args.pprof_hz,secs,out: std::path::PathBuf::from(&args.pprof_out),+ delay_vsyncs: args.pprof_delay,});}}@@ -302,6 +313,11 @@ fn run<const SYSTEM: SystemId>(#[cfg(feature = "fps-counter")]let fps_shared = emulator.fps_counter.shared();+ #[cfg(feature = "fps-counter")]+ if let Some(ref path) = args.fps_log {+ emulator.fps_counter.log_path = Some(std::path::PathBuf::from(path));+ let _ = std::fs::write(path, "wall_secs,fps,native_pct,vsyncs\n");+ }let input = Arc::new(Mutex::new(HostInput::neutral_for(SYSTEM)));@@ -334,12 +350,12 @@ fn run<const SYSTEM: SystemId>(let (ppc_c, ppc_s, dsp_c, dsp_s) = emulator.load_jit_cache(id);if ppc_c > 0 || dsp_c > 0 || ppc_s > 0 || dsp_s > 0 {tracing::info!(+ game = id.as_str(),ppc_compiled = ppc_c,ppc_skipped = ppc_s,dsp_compiled = dsp_c,dsp_skipped = dsp_s,- game = id.as_str(),- "pre-compiled JIT blocks from cache"+ "JIT cache loaded",);}}