Skip to content

armgit / gecko

Public Imported from GitHub
0

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.toml
index 0fc93ba..19f2195 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -48,6 +48,7 @@ egui-winit = { git = "https://github.com/ioncodes/egui.git" }
codegen-units = 1
lto = "fat"
debug = true
+panic = "abort"
[profile.dev]
opt-level = 3
diff --git a/crates/backend-wgpu/src/action.rs b/crates/backend-wgpu/src/action.rs
index 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.rs
index 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 with
diff --git a/crates/gecko/src/flipper/gx.rs b/crates/gecko/src/flipper/gx.rs
index 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 later
pub 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.rs
index 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 colors
if 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 colors
if idx >= BP_TEV_REGISTERL_0 && idx <= BP_TEV_REGISTERL_0 + 7 {
- self.resolve_konst_colors();
+ self.konst_dirty = true;
}
// PE finish
diff --git a/crates/gecko/src/flipper/gx/fifo.rs b/crates/gecko/src/flipper/gx/fifo.rs
index 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-format
let 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.rs
index 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 snapshot
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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",
);
}
}