Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

draw coalesc, improved shader specialization, ubershader fallback, action batching, improved gx profiler

Layle30379d299279
diff --git a/crates/backend-wgpu/Cargo.toml b/crates/backend-wgpu/Cargo.toml
index 598571a..6a88e9f 100644
--- a/crates/backend-wgpu/Cargo.toml
+++ b/crates/backend-wgpu/Cargo.toml
@@ -8,6 +8,7 @@ renderdoc-capture = ["dep:renderdoc"]
hotpath = ["dep:hotpath", "hotpath/hotpath", "hotpath/crossbeam"]
# Write every compiled WGSL shader variant to cache/wgsl/ for debugging.
dump-wgsl = []
+gx-stats = ["gecko/gx-stats"]
[dependencies]
wgpu = "29.0.3"
diff --git a/crates/backend-wgpu/src/action.rs b/crates/backend-wgpu/src/action.rs
index bd4d761..8df9434 100644
--- a/crates/backend-wgpu/src/action.rs
+++ b/crates/backend-wgpu/src/action.rs
@@ -1,5 +1,5 @@
-use crate::pipeline::{FullPipelineKey, PipelineKey};
-use crate::shader_specialization::{self, ShaderKey};
+use crate::pipeline::{FullPipelineKey, PipelineKey, UberPipelineKey};
+use crate::shader_specialization::{self, ShaderKey, ShaderSpecializationKey};
use crate::{
BindGroupCacheKey, DRAW_UNIFORMS_SIZE, DrawUniforms, FRAME_UNIFORMS_SIZE, FrameUniforms, GxRenderer, SamplerKey,
helpers,
@@ -9,6 +9,8 @@ use gecko::flipper::gx::regs::{CullMode, MagFilter, MinFilter, WrapMode};
use gecko::flipper::gx::texture::CopyFormat;
use gecko::host::{DrawData, GxAction};
use glam::{Mat4, UVec4, Vec4};
+#[cfg(feature = "gx-stats")]
+use std::sync::atomic::Ordering;
fn draw_active_slot_mask(draw: &DrawData) -> u8 {
let mut mask: u8 = 0;
@@ -246,7 +248,7 @@ impl GxRenderer {
self.return_to_pool(tex, view);
}
self.bind_group_cache.clear();
- self.pipeline_cache.clear();
+ self.invalidate_pipeline_caches();
}
#[cfg(not(target_arch = "wasm32"))]
GxAction::DumpTextures { dir } => {
@@ -278,29 +280,57 @@ impl GxRenderer {
let shader_key = ShaderKey::from_draw(draw, self.current_alpha_compare);
if !self.shader_cache.contains_key(&shader_key) {
+ #[cfg(feature = "gx-stats")]
+ let shader_started = std::time::Instant::now();
let wgsl = shader_specialization::compile_variant(shader_key);
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some(&format!("gx_shader_{shader_key:?}")),
source: wgpu::ShaderSource::Wgsl(wgsl.into()),
});
self.shader_cache.insert(shader_key, module);
+ #[cfg(feature = "gx-stats")]
+ {
+ self.stats.shader_modules_created.fetch_add(1, Ordering::Relaxed);
+ self.stats
+ .shader_create_cpu_ns
+ .fetch_add(shader_started.elapsed().as_nanos() as u64, Ordering::Relaxed);
+ }
tracing::info!(?shader_key, "compiled specialized shader variant");
}
let pipeline_key = self.current_pipeline_key(draw.ztex_op != 0);
let full_key = FullPipelineKey {
shader: shader_key,
+ specialization: ShaderSpecializationKey::from_draw(draw, self.current_alpha_compare, shader_key),
fixed: pipeline_key,
};
if !self.pipeline_cache.contains_key(&full_key) {
- let module = &self.shader_cache[&shader_key];
- let pipeline = self.create_pipeline(device, module, &full_key);
- self.pipeline_cache.insert(full_key, pipeline);
+ let uber_key = UberPipelineKey::from(full_key);
+ if !self.uber_pipeline_cache.contains_key(&uber_key) {
+ #[cfg(feature = "gx-stats")]
+ let pipeline_started = std::time::Instant::now();
+ let module = &self.shader_cache[&shader_key];
+ let pipeline = crate::pipeline::create_uber_pipeline(
+ device,
+ &self.pipeline_layout,
+ self.surface_format,
+ module,
+ &uber_key,
+ );
+ self.uber_pipeline_cache.insert(uber_key, pipeline);
+ #[cfg(feature = "gx-stats")]
+ {
+ self.stats.pipelines_created.fetch_add(1, Ordering::Relaxed);
+ self.stats
+ .pipeline_create_cpu_ns
+ .fetch_add(pipeline_started.elapsed().as_nanos() as u64, Ordering::Relaxed);
+ }
+ }
+ self.request_specialized_pipeline(full_key);
}
let first_vertex = draw.base_vertex;
- let first_index = self.scratch_indices.len() as u32;
- let (vertex_count, index_count) = emit_draw_indices(draw, &mut self.scratch_indices);
- if vertex_count == 0 {
+ let vertex_count = draw.vertex_count;
+ if !draw_emits_triangles(draw) {
tracing::warn!("draw call produced zero vertices, skipping");
return;
}
@@ -330,15 +360,18 @@ impl GxRenderer {
}
let draw_uniform = DrawUniforms { mvp, tex_dims };
-
- let start = self.scratch_draws.len() * draw_stride;
- self.scratch_uniform_bytes.resize(start + draw_stride, 0);
- self.scratch_uniform_bytes[start..start + draw_struct_size]
- .copy_from_slice(bytemuck::bytes_of(&draw_uniform));
+ let draw_uniform_bytes = bytemuck::bytes_of(&draw_uniform);
+ let bg_key = trim_bg_key(self.current_bind_group_key(), active);
+ // Matches the WESL `VsIn` layout gated by
+ // `TEXCOORD_N_ENABLED`: 5 fixed attrs (68b) + N texcoord
+ // attrs (12 bytes each).
+ let stride = 68 + 12 * shader_key.active_texcoords as u32;
// Build a fresh FrameUniforms slot only when the producer
// signaled state changed since the last draw or this is the
// first draw of the flush.
+ let frame_bytes_len_before = self.frame_uniform_bytes.len();
+ let mut frame_was_pushed = false;
let frame_idx = if draw.frame_dirty || self.last_frame_uniform_index.is_none() {
let alpha_cmp = self.current_alpha_compare;
let frame_uniform = FrameUniforms {
@@ -387,38 +420,82 @@ impl GxRenderer {
.copy_from_slice(bytemuck::bytes_of(&frame_uniform));
let idx = (fstart / frame_stride) as u32;
self.last_frame_uniform_index = Some(idx);
+ frame_was_pushed = true;
idx
} else {
self.last_frame_uniform_index.unwrap()
};
- self.draw_pipeline_keys.push(full_key);
- self.draw_bg_keys
- .push(trim_bg_key(self.current_bind_group_key(), active));
- self.draw_viewports.push(self.current_viewport);
- self.draw_scissors.push(self.current_scissor);
- self.draw_frame_indices.push(frame_idx);
- #[cfg(feature = "renderdoc-capture")]
- self.draw_primitives.push(draw.primitive);
-
- // Compute packed vertex stride/offset for this draw. Stride
- // matches the WESL `VsIn` layout gated by
- // `TEXCOORD_N_ENABLED`: 5 fixed attrs (68b) + N texcoord
- // attrs (12 byteroos each).
- let stride = 68 + 12 * shader_key.active_texcoords as u32;
- let packed_byte_offset = self
- .scratch_draws
- .last()
- .map(|d| d.packed_vertex_byte_offset + d.vertex_count * d.packed_vertex_stride)
- .unwrap_or(0);
- self.scratch_draws.push(crate::DrawRecord {
- src_vertex_index: first_vertex,
- vertex_count,
- first_index,
- index_count,
- packed_vertex_byte_offset: packed_byte_offset,
- packed_vertex_stride: stride,
+ let previous_index = self.scratch_draws.len().checked_sub(1);
+ let can_merge = previous_index.is_some_and(|previous| {
+ let previous_draw = self.scratch_draws[previous];
+ let previous_draw_start = previous * draw_stride;
+ previous_draw.src_vertex_index + previous_draw.vertex_count == first_vertex
+ && previous_draw.packed_vertex_stride == stride
+ && self.draw_pipeline_keys[previous] == full_key
+ && self.draw_bg_keys[previous] == bg_key
+ && self.draw_viewports[previous] == self.current_viewport
+ && self.draw_scissors[previous] == self.current_scissor
+ && uniform_slots_equal(
+ &self.frame_uniform_bytes,
+ frame_stride,
+ frame_struct_size,
+ self.draw_frame_indices[previous],
+ frame_idx,
+ )
+ && self.scratch_uniform_bytes[previous_draw_start..previous_draw_start + draw_struct_size]
+ == *draw_uniform_bytes
});
+
+ if let Some(previous) = previous_index.filter(|_| can_merge) {
+ let previous_frame_idx = self.draw_frame_indices[previous];
+ if frame_was_pushed {
+ self.frame_uniform_bytes.truncate(frame_bytes_len_before);
+ self.last_frame_uniform_index = Some(previous_frame_idx);
+ frame_was_pushed = false;
+ }
+
+ let vertex_bias = self.scratch_draws[previous].vertex_count;
+ let (_, additional_indices) = emit_draw_indices(draw, &mut self.scratch_indices, vertex_bias);
+ let merged = &mut self.scratch_draws[previous];
+ merged.vertex_count += vertex_count;
+ merged.index_count += additional_indices;
+ #[cfg(feature = "renderdoc-capture")]
+ {
+ self.draw_primitives[previous] = Primitive::Triangles;
+ }
+ } else {
+ let first_index = self.scratch_indices.len() as u32;
+ let (_, index_count) = emit_draw_indices(draw, &mut self.scratch_indices, 0);
+
+ let start = self.scratch_draws.len() * draw_stride;
+ self.scratch_uniform_bytes.resize(start + draw_stride, 0);
+ self.scratch_uniform_bytes[start..start + draw_struct_size].copy_from_slice(draw_uniform_bytes);
+
+ self.draw_pipeline_keys.push(full_key);
+ self.draw_bg_keys.push(bg_key);
+ self.draw_viewports.push(self.current_viewport);
+ self.draw_scissors.push(self.current_scissor);
+ self.draw_frame_indices.push(frame_idx);
+ #[cfg(feature = "renderdoc-capture")]
+ self.draw_primitives.push(draw.primitive);
+
+ let packed_byte_offset = self
+ .scratch_draws
+ .last()
+ .map(|d| d.packed_vertex_byte_offset + d.vertex_count * d.packed_vertex_stride)
+ .unwrap_or(0);
+ self.scratch_draws.push(crate::DrawRecord {
+ src_vertex_index: first_vertex,
+ vertex_count,
+ first_index,
+ index_count,
+ packed_vertex_byte_offset: packed_byte_offset,
+ packed_vertex_stride: stride,
+ });
+ }
+
+ debug_assert!(!frame_was_pushed || self.last_frame_uniform_index == Some(frame_idx));
}
GxAction::CopyXfb {
@@ -541,10 +618,21 @@ impl GxRenderer {
/// Flush accumulated draw calls into a render pass.
pub fn flush_pending_draws(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
+ self.poll_compiled_pipelines();
if self.scratch_draws.is_empty() {
return;
}
+ debug_assert_eq!(self.scratch_draws.len(), self.draw_pipeline_keys.len());
+ debug_assert_eq!(self.scratch_draws.len(), self.draw_bg_keys.len());
+ debug_assert_eq!(self.scratch_draws.len(), self.draw_viewports.len());
+ debug_assert_eq!(self.scratch_draws.len(), self.draw_scissors.len());
+ debug_assert_eq!(self.scratch_draws.len(), self.draw_frame_indices.len());
+ debug_assert_eq!(
+ self.scratch_uniform_bytes.len(),
+ self.scratch_draws.len() * self.draw_uniform_stride as usize
+ );
+
if self.draw_bufs_write_pending {
self.submit_pending(queue);
}
@@ -571,6 +659,27 @@ impl GxRenderer {
}
fn execute_action_render_pass(&mut self, device: &wgpu::Device) {
+ #[cfg(feature = "gx-stats")]
+ let encode_started = std::time::Instant::now();
+ #[cfg(feature = "gx-stats")]
+ let mut pipeline_changes = 0u64;
+ #[cfg(feature = "gx-stats")]
+ let mut viewport_changes = 0u64;
+ #[cfg(feature = "gx-stats")]
+ let mut scissor_changes = 0u64;
+ #[cfg(feature = "gx-stats")]
+ let mut bind_groups_created = 0u64;
+ #[cfg(feature = "gx-stats")]
+ let mut bind_group_key_changes = 0u64;
+ #[cfg(feature = "gx-stats")]
+ let mut frame_uniform_changes = 0u64;
+ #[cfg(feature = "gx-stats")]
+ let mut draw_uniform_changes = 0u64;
+ #[cfg(feature = "gx-stats")]
+ let mut vertex_stride_changes = 0u64;
+ #[cfg(feature = "gx-stats")]
+ let mut potential_merged_draws = 0u64;
+
let target_width = self.scaled(crate::EFB_WIDTH);
let target_height = self.scaled(crate::EFB_HEIGHT);
let scale = self.efb_scale as f32;
@@ -651,6 +760,10 @@ impl GxRenderer {
})
};
self.bind_group_cache.insert(self.draw_bg_keys[i].clone(), new_bg);
+ #[cfg(feature = "gx-stats")]
+ {
+ bind_groups_created += 1;
+ }
}
let mut encoder = self.take_or_create_encoder(device);
@@ -735,6 +848,16 @@ impl GxRenderer {
let mut last_vertex_slice: Option<(u64, u64)> = None;
let mut last_viewport: Option<(f32, f32, f32, f32, f32, f32)> = None;
let mut last_scissor: Option<(u32, u32, u32, u32)> = None;
+ #[cfg(feature = "gx-stats")]
+ let mut last_profile_index: Option<usize> = None;
+ #[cfg(feature = "gx-stats")]
+ let mut last_profile_pipeline_ptr: *const wgpu::RenderPipeline = std::ptr::null();
+ #[cfg(feature = "gx-stats")]
+ let mut last_profile_viewport: Option<(f32, f32, f32, f32, f32, f32)> = None;
+ #[cfg(feature = "gx-stats")]
+ let mut last_profile_scissor: Option<(u32, u32, u32, u32)> = None;
+ #[cfg(feature = "gx-stats")]
+ let mut last_profile_vertex_end: Option<u64> = None;
for (index, draw) in self.scratch_draws.iter().copied().enumerate() {
let crate::DrawRecord {
@@ -764,11 +887,18 @@ impl GxRenderer {
rpass.push_debug_group(&draw_label);
}
let full_key = &self.draw_pipeline_keys[index];
- let pipeline = &self.pipeline_cache[full_key];
+ let pipeline = self
+ .pipeline_cache
+ .get(full_key)
+ .unwrap_or_else(|| &self.uber_pipeline_cache[&UberPipelineKey::from(*full_key)]);
let pipeline_ptr = pipeline as *const wgpu::RenderPipeline;
if pipeline_ptr != last_pipeline_ptr {
rpass.set_pipeline(pipeline);
last_pipeline_ptr = pipeline_ptr;
+ #[cfg(feature = "gx-stats")]
+ {
+ pipeline_changes += 1;
+ }
}
#[cfg(feature = "renderdoc-capture")]
@@ -814,6 +944,10 @@ impl GxRenderer {
if last_viewport != Some(vp_tuple) {
rpass.set_viewport(vp_x, vp_y, vp_w, vp_h, min_d, max_d);
last_viewport = Some(vp_tuple);
+ #[cfg(feature = "gx-stats")]
+ {
+ viewport_changes += 1;
+ }
}
} else {
tracing::warn!(
@@ -834,6 +968,70 @@ impl GxRenderer {
if last_scissor != Some(sc_tuple) {
rpass.set_scissor_rect(sc_x, sc_y, sc_w, sc_h);
last_scissor = Some(sc_tuple);
+ #[cfg(feature = "gx-stats")]
+ {
+ scissor_changes += 1;
+ }
+ }
+
+ #[cfg(feature = "gx-stats")]
+ {
+ let draw_stride = self.draw_uniform_stride as usize;
+ let draw_size = DRAW_UNIFORMS_SIZE.get() as usize;
+ let frame_size = FRAME_UNIFORMS_SIZE.get() as usize;
+ let draw_start = index * draw_stride;
+ let frame_start = self.draw_frame_indices[index] as usize * frame_stride;
+
+ let (pipeline_same, bind_group_same, frame_uniform_same, draw_uniform_same, stride_same) =
+ if let Some(previous) = last_profile_index {
+ let previous_draw_start = previous * draw_stride;
+ let previous_frame_start = self.draw_frame_indices[previous] as usize * frame_stride;
+ (
+ pipeline_ptr == last_profile_pipeline_ptr,
+ self.draw_bg_keys[index] == self.draw_bg_keys[previous],
+ self.draw_frame_indices[index] == self.draw_frame_indices[previous]
+ || self.frame_uniform_bytes[frame_start..frame_start + frame_size]
+ == self.frame_uniform_bytes
+ [previous_frame_start..previous_frame_start + frame_size],
+ self.scratch_uniform_bytes[draw_start..draw_start + draw_size]
+ == self.scratch_uniform_bytes[previous_draw_start..previous_draw_start + draw_size],
+ packed_vertex_stride == self.scratch_draws[previous].packed_vertex_stride,
+ )
+ } else {
+ (false, false, false, false, false)
+ };
+
+ if !bind_group_same {
+ bind_group_key_changes += 1;
+ }
+ if !frame_uniform_same {
+ frame_uniform_changes += 1;
+ }
+ if !draw_uniform_same {
+ draw_uniform_changes += 1;
+ }
+ if !stride_same {
+ vertex_stride_changes += 1;
+ }
+
+ let compatible = last_profile_index.is_some()
+ && pipeline_same
+ && bind_group_same
+ && frame_uniform_same
+ && draw_uniform_same
+ && stride_same
+ && last_profile_viewport == last_viewport
+ && last_profile_scissor == Some(sc_tuple)
+ && last_profile_vertex_end == Some(vertex_slice_start);
+ if !compatible {
+ potential_merged_draws += 1;
+ }
+
+ last_profile_index = Some(index);
+ last_profile_pipeline_ptr = pipeline_ptr;
+ last_profile_viewport = last_viewport;
+ last_profile_scissor = Some(sc_tuple);
+ last_profile_vertex_end = Some(vertex_slice_end);
}
#[cfg(feature = "renderdoc-capture")]
@@ -861,6 +1059,43 @@ impl GxRenderer {
self.current_encoder = Some(encoder);
self.draw_bufs_write_pending = true;
+
+ #[cfg(feature = "gx-stats")]
+ {
+ self.stats.draws_encoded.fetch_add(num_draws as u64, Ordering::Relaxed);
+ self.stats.draw_render_passes.fetch_add(1, Ordering::Relaxed);
+ self.stats
+ .pipeline_changes
+ .fetch_add(pipeline_changes, Ordering::Relaxed);
+ self.stats
+ .bind_group_sets
+ .fetch_add(num_draws as u64, Ordering::Relaxed);
+ self.stats
+ .bind_groups_created
+ .fetch_add(bind_groups_created, Ordering::Relaxed);
+ self.stats
+ .bind_group_key_changes
+ .fetch_add(bind_group_key_changes, Ordering::Relaxed);
+ self.stats
+ .frame_uniform_changes
+ .fetch_add(frame_uniform_changes, Ordering::Relaxed);
+ self.stats
+ .draw_uniform_changes
+ .fetch_add(draw_uniform_changes, Ordering::Relaxed);
+ self.stats
+ .vertex_stride_changes
+ .fetch_add(vertex_stride_changes, Ordering::Relaxed);
+ self.stats
+ .potential_merged_draws
+ .fetch_add(potential_merged_draws, Ordering::Relaxed);
+ self.stats
+ .viewport_changes
+ .fetch_add(viewport_changes, Ordering::Relaxed);
+ self.stats.scissor_changes.fetch_add(scissor_changes, Ordering::Relaxed);
+ self.stats
+ .draw_pass_encode_ns
+ .fetch_add(encode_started.elapsed().as_nanos() as u64, Ordering::Relaxed);
+ }
}
fn ensure_sampler(&mut self, device: &wgpu::Device, key: &SamplerKey) {
@@ -877,22 +1112,42 @@ impl GxRenderer {
}
}
-/// Emit indices for a draw whose vertices already live in the renderer's
-/// `scratch_vertices` at `[base_vertex .. base_vertex + n]`. Indices are
-/// written into `indices_out` as offsets relative to `base_vertex`, since
-/// `draw_indexed` is called with `base_vertex` as `first_vertex`. Returns
-/// `(vertex_count, index_count)`.
-fn emit_draw_indices(draw: &DrawData, indices_out: &mut Vec<u32>) -> (u32, u32) {
+fn uniform_slots_equal(bytes: &[u8], stride: usize, size: usize, a: u32, b: u32) -> bool {
+ if a == b {
+ return true;
+ }
+ let a = a as usize * stride;
+ let b = b as usize * stride;
+ bytes[a..a + size] == bytes[b..b + size]
+}
+
+fn draw_emits_triangles(draw: &DrawData) -> bool {
+ use gecko::flipper::gx::draw::Primitive;
+
+ match draw.primitive {
+ Primitive::Triangles | Primitive::TriangleStrip | Primitive::TriangleFan => draw.vertex_count >= 3,
+ Primitive::Quads => draw.vertex_count >= 4,
+ _ => {
+ tracing::error!(?draw.primitive, "draw_emits_triangles: skipping unsupported primitive");
+ false
+ }
+ }
+}
+
+fn emit_draw_indices(draw: &DrawData, indices_out: &mut Vec<u32>, vertex_bias: u32) -> (u32, u32) {
use gecko::flipper::gx::draw::Primitive;
let n = draw.vertex_count;
match draw.primitive {
- Primitive::Triangles => (n, 0),
+ Primitive::Triangles => {
+ indices_out.extend((0..n).map(|i| vertex_bias + i));
+ (n, n)
+ }
Primitive::Quads => {
let chunks = n / 4;
for q in 0..chunks {
- let base = q * 4;
+ let base = vertex_bias + q * 4;
indices_out.extend_from_slice(&[base, base + 1, base + 2, base, base + 2, base + 3]);
}
(n, chunks * 6)
@@ -901,12 +1156,13 @@ fn emit_draw_indices(draw: &DrawData, indices_out: &mut Vec<u32>) -> (u32, u32)
if n < 3 {
return (0, 0);
}
+
let tris = n - 2;
for i in 0..tris {
if i & 1 == 0 {
- indices_out.extend_from_slice(&[i, i + 1, i + 2]);
+ indices_out.extend_from_slice(&[vertex_bias + i, vertex_bias + i + 1, vertex_bias + i + 2]);
} else {
- indices_out.extend_from_slice(&[i + 1, i, i + 2]);
+ indices_out.extend_from_slice(&[vertex_bias + i + 1, vertex_bias + i, vertex_bias + i + 2]);
}
}
(n, tris * 3)
@@ -915,9 +1171,10 @@ fn emit_draw_indices(draw: &DrawData, indices_out: &mut Vec<u32>) -> (u32, u32)
if n < 3 {
return (0, 0);
}
+
let tris = n - 2;
for i in 0..tris {
- indices_out.extend_from_slice(&[0, i + 1, i + 2]);
+ indices_out.extend_from_slice(&[vertex_bias, vertex_bias + i + 1, vertex_bias + i + 2]);
}
(n, tris * 3)
}
diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rs
index 2f3fc19..d4a3f8f 100644
--- a/crates/backend-wgpu/src/lib.rs
+++ b/crates/backend-wgpu/src/lib.rs
@@ -19,13 +19,96 @@ use gecko::flipper::gx::regs::{AlphaCompare, BlendMode, CompareFunc, CullMode, M
use gecko::host::TextureKey;
use glam::Mat4;
-use pipeline::FullPipelineKey;
+use pipeline::{FullPipelineKey, UberPipelineKey};
use rustc_hash::FxHashMap;
+#[cfg(not(target_arch = "wasm32"))]
+use rustc_hash::FxHashSet;
use shader_specialization::ShaderKey;
use std::num::NonZeroU64;
+#[cfg(feature = "gx-stats")]
+use std::sync::{
+ Arc,
+ atomic::{AtomicU64, Ordering},
+};
pub(crate) type GpuVertex = gecko::host::DrawVertex;
+#[cfg(feature = "gx-stats")]
+#[derive(Default)]
+pub(crate) struct RendererStats {
+ pub(crate) actions_sent: AtomicU64,
+ pub(crate) batches_sent: AtomicU64,
+ pub(crate) channel_high_water: AtomicU64,
+ pub(crate) queue_wait_ns: AtomicU64,
+ pub(crate) efb_drain_wait_ns: AtomicU64,
+ pub(crate) efb_drain_requests: AtomicU64,
+ pub(crate) efb_drain_nonempty: AtomicU64,
+ pub(crate) efb_writebacks: AtomicU64,
+ pub(crate) efb_writeback_cpu_ns: AtomicU64,
+ pub(crate) worker_batch_cpu_ns: AtomicU64,
+ pub(crate) draws_encoded: AtomicU64,
+ pub(crate) draw_render_passes: AtomicU64,
+ pub(crate) pipeline_changes: AtomicU64,
+ pub(crate) pipelines_created: AtomicU64,
+ pub(crate) pipeline_create_cpu_ns: AtomicU64,
+ pub(crate) shader_modules_created: AtomicU64,
+ pub(crate) shader_create_cpu_ns: AtomicU64,
+ pub(crate) bind_group_sets: AtomicU64,
+ pub(crate) bind_groups_created: AtomicU64,
+ pub(crate) bind_group_key_changes: AtomicU64,
+ pub(crate) frame_uniform_changes: AtomicU64,
+ pub(crate) draw_uniform_changes: AtomicU64,
+ pub(crate) vertex_stride_changes: AtomicU64,
+ pub(crate) potential_merged_draws: AtomicU64,
+ pub(crate) viewport_changes: AtomicU64,
+ pub(crate) scissor_changes: AtomicU64,
+ pub(crate) draw_pass_encode_ns: AtomicU64,
+ pub(crate) queue_submits: AtomicU64,
+ pub(crate) command_buffers_submitted: AtomicU64,
+ pub(crate) queue_submit_cpu_ns: AtomicU64,
+}
+
+#[cfg(feature = "gx-stats")]
+impl RendererStats {
+ pub(crate) fn snapshot(&self, channel_len: usize, channel_cap: usize) -> gecko::host::RenderStats {
+ let load = |counter: &AtomicU64| counter.load(Ordering::Relaxed);
+ gecko::host::RenderStats {
+ actions_sent: load(&self.actions_sent),
+ batches_sent: load(&self.batches_sent),
+ channel_len,
+ channel_cap,
+ channel_high_water: load(&self.channel_high_water) as usize,
+ queue_wait_ns: load(&self.queue_wait_ns),
+ efb_drain_wait_ns: load(&self.efb_drain_wait_ns),
+ efb_drain_requests: load(&self.efb_drain_requests),
+ efb_drain_nonempty: load(&self.efb_drain_nonempty),
+ efb_writebacks: load(&self.efb_writebacks),
+ efb_writeback_cpu_ns: load(&self.efb_writeback_cpu_ns),
+ worker_batch_cpu_ns: load(&self.worker_batch_cpu_ns),
+ draws_encoded: load(&self.draws_encoded),
+ draw_render_passes: load(&self.draw_render_passes),
+ pipeline_changes: load(&self.pipeline_changes),
+ pipelines_created: load(&self.pipelines_created),
+ pipeline_create_cpu_ns: load(&self.pipeline_create_cpu_ns),
+ shader_modules_created: load(&self.shader_modules_created),
+ shader_create_cpu_ns: load(&self.shader_create_cpu_ns),
+ bind_group_sets: load(&self.bind_group_sets),
+ bind_groups_created: load(&self.bind_groups_created),
+ bind_group_key_changes: load(&self.bind_group_key_changes),
+ frame_uniform_changes: load(&self.frame_uniform_changes),
+ draw_uniform_changes: load(&self.draw_uniform_changes),
+ vertex_stride_changes: load(&self.vertex_stride_changes),
+ potential_merged_draws: load(&self.potential_merged_draws),
+ viewport_changes: load(&self.viewport_changes),
+ scissor_changes: load(&self.scissor_changes),
+ draw_pass_encode_ns: load(&self.draw_pass_encode_ns),
+ queue_submits: load(&self.queue_submits),
+ command_buffers_submitted: load(&self.command_buffers_submitted),
+ queue_submit_cpu_ns: load(&self.queue_submit_cpu_ns),
+ }
+ }
+}
+
pub(crate) fn align_up(value: u64, alignment: u64) -> u64 {
(value + alignment - 1) & !(alignment - 1)
}
@@ -175,8 +258,17 @@ pub(crate) struct DrawBufferLayout {
}
pub struct GxRenderer {
+ #[cfg(feature = "gx-stats")]
+ pub(crate) stats: Arc<RendererStats>,
pub(crate) pipeline_cache: FxHashMap<FullPipelineKey, wgpu::RenderPipeline>,
+ pub(crate) uber_pipeline_cache: FxHashMap<UberPipelineKey, wgpu::RenderPipeline>,
pub(crate) shader_cache: FxHashMap<ShaderKey, wgpu::ShaderModule>,
+ #[cfg(not(target_arch = "wasm32"))]
+ pub(crate) pipeline_compiler: pipeline::PipelineCompiler,
+ #[cfg(not(target_arch = "wasm32"))]
+ pub(crate) pending_pipeline_keys: FxHashSet<FullPipelineKey>,
+ #[cfg(not(target_arch = "wasm32"))]
+ pub(crate) pipeline_generation: u64,
pub(crate) pipeline_layout: wgpu::PipelineLayout,
pub(crate) surface_format: wgpu::TextureFormat,
pub(crate) bind_group_layout: wgpu::BindGroupLayout,
@@ -784,10 +876,24 @@ impl GxRenderer {
let pipeline_cache: FxHashMap<pipeline::FullPipelineKey, wgpu::RenderPipeline> =
FxHashMap::with_capacity_and_hasher(64, Default::default());
+ let uber_pipeline_cache: FxHashMap<pipeline::UberPipelineKey, wgpu::RenderPipeline> =
+ FxHashMap::with_capacity_and_hasher(64, Default::default());
+ #[cfg(not(target_arch = "wasm32"))]
+ let pipeline_compiler =
+ pipeline::PipelineCompiler::new(device.clone(), pipeline_layout.clone(), surface_format);
GxRenderer {
+ #[cfg(feature = "gx-stats")]
+ stats: Arc::new(RendererStats::default()),
pipeline_cache,
+ uber_pipeline_cache,
shader_cache,
+ #[cfg(not(target_arch = "wasm32"))]
+ pipeline_compiler,
+ #[cfg(not(target_arch = "wasm32"))]
+ pending_pipeline_keys: FxHashSet::default(),
+ #[cfg(not(target_arch = "wasm32"))]
+ pipeline_generation: 0,
pipeline_layout,
surface_format,
bind_group_layout,
@@ -957,8 +1063,24 @@ impl GxRenderer {
return;
}
+ #[cfg(feature = "gx-stats")]
+ let command_buffer_count = self.pending_command_buffers.len() as u64;
+ #[cfg(feature = "gx-stats")]
+ let submit_started = std::time::Instant::now();
+
queue.submit(self.pending_command_buffers.drain(..));
+ #[cfg(feature = "gx-stats")]
+ {
+ self.stats.queue_submits.fetch_add(1, Ordering::Relaxed);
+ self.stats
+ .command_buffers_submitted
+ .fetch_add(command_buffer_count, Ordering::Relaxed);
+ self.stats
+ .queue_submit_cpu_ns
+ .fetch_add(submit_started.elapsed().as_nanos() as u64, Ordering::Relaxed);
+ }
+
self.draw_bufs_write_pending = false;
self.xfb_copy_uniform_write_pending = false;
self.efb_color_readback_uniform_write_pending = false;
@@ -1107,6 +1229,44 @@ impl GxRenderer {
Ok(keys.len())
}
+ #[cfg(not(target_arch = "wasm32"))]
+ pub(crate) fn poll_compiled_pipelines(&mut self) {
+ while let Some(result) = self.pipeline_compiler.try_recv() {
+ if result.generation != self.pipeline_generation {
+ continue;
+ }
+ self.pending_pipeline_keys.remove(&result.key);
+ self.pipeline_cache.insert(result.key, result.pipeline);
+ }
+ }
+
+ #[cfg(target_arch = "wasm32")]
+ pub(crate) fn poll_compiled_pipelines(&mut self) {}
+
+ #[cfg(not(target_arch = "wasm32"))]
+ pub(crate) fn request_specialized_pipeline(&mut self, key: FullPipelineKey) {
+ if self.pipeline_cache.contains_key(&key) || self.pending_pipeline_keys.contains(&key) {
+ return;
+ }
+ let shader = self.shader_cache[&key.shader].clone();
+ if self.pipeline_compiler.request(self.pipeline_generation, key, shader) {
+ self.pending_pipeline_keys.insert(key);
+ }
+ }
+
+ #[cfg(target_arch = "wasm32")]
+ pub(crate) fn request_specialized_pipeline(&mut self, _key: FullPipelineKey) {}
+
+ pub(crate) fn invalidate_pipeline_caches(&mut self) {
+ self.pipeline_cache.clear();
+ self.uber_pipeline_cache.clear();
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ self.pipeline_generation = self.pipeline_generation.wrapping_add(1);
+ self.pending_pipeline_keys.clear();
+ }
+ }
+
pub fn prewarm_pipeline_cache(&mut self, device: &wgpu::Device) {
let path = std::path::Path::new(pipeline::PIPELINE_CACHE_PATH);
let keys: Vec<pipeline::FullPipelineKey> = pipeline::load_cached_pipeline_keys(path)
@@ -1141,7 +1301,16 @@ impl GxRenderer {
.iter()
.map(|&k| {
let module = &self_ref.shader_cache[&k.shader];
- (k, self_ref.create_pipeline(device, module, &k))
+ (
+ k,
+ pipeline::create_specialized_pipeline(
+ device,
+ &self_ref.pipeline_layout,
+ self_ref.surface_format,
+ module,
+ &k,
+ ),
+ )
})
.collect::<Vec<_>>()
})
@@ -1156,7 +1325,16 @@ impl GxRenderer {
.iter()
.map(|&k| {
let module = &self.shader_cache[&k.shader];
- (k, self.create_pipeline(device, module, &k))
+ (
+ k,
+ pipeline::create_specialized_pipeline(
+ device,
+ &self.pipeline_layout,
+ self.surface_format,
+ module,
+ &k,
+ ),
+ )
})
.collect();
diff --git a/crates/backend-wgpu/src/pipeline.rs b/crates/backend-wgpu/src/pipeline.rs
index 2f1ab5a..bf1c7a5 100644
--- a/crates/backend-wgpu/src/pipeline.rs
+++ b/crates/backend-wgpu/src/pipeline.rs
@@ -1,5 +1,7 @@
-use crate::shader_specialization::{KEY_BYTES as SHADER_KEY_BYTES, ShaderKey};
-use crate::{GxRenderer, helpers};
+use crate::helpers;
+use crate::shader_specialization::{
+ KEY_BYTES as SHADER_KEY_BYTES, SPECIALIZATION_KEY_BYTES, ShaderKey, ShaderSpecializationKey,
+};
use chapa::BitField;
use gecko::flipper::gx::regs::{BlendFactor, CompareFunc, CullMode, LogicOp};
@@ -107,10 +109,26 @@ impl PipelineKey {
#[derive(Clone, Copy, Hash, PartialEq, Eq)]
pub(crate) struct FullPipelineKey {
pub shader: ShaderKey,
+ pub specialization: ShaderSpecializationKey,
pub fixed: PipelineKey,
}
-pub(crate) const FULL_PIPELINE_KEY_BYTES: usize = SHADER_KEY_BYTES + PipelineKey::BYTES;
+#[derive(Clone, Copy, Hash, PartialEq, Eq)]
+pub(crate) struct UberPipelineKey {
+ pub shader: ShaderKey,
+ pub fixed: PipelineKey,
+}
+
+impl From<FullPipelineKey> for UberPipelineKey {
+ fn from(key: FullPipelineKey) -> Self {
+ Self {
+ shader: key.shader,
+ fixed: key.fixed,
+ }
+ }
+}
+
+pub(crate) const FULL_PIPELINE_KEY_BYTES: usize = SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES + PipelineKey::BYTES;
const PIPELINE_CACHE_MAGIC: [u8; 4] = *b"GPKC";
const PIPELINE_CACHE_VERSION: u32 = crate::shader_specialization::CACHE_VERSION;
pub(crate) const PIPELINE_CACHE_PATH: &str = "cache/pipeline_keys.bin";
@@ -119,7 +137,9 @@ impl FullPipelineKey {
fn to_bytes(self) -> [u8; FULL_PIPELINE_KEY_BYTES] {
let mut out = [0u8; FULL_PIPELINE_KEY_BYTES];
out[..SHADER_KEY_BYTES].copy_from_slice(&self.shader.to_bytes());
- out[SHADER_KEY_BYTES..].copy_from_slice(&self.fixed.to_bytes());
+ out[SHADER_KEY_BYTES..SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES]
+ .copy_from_slice(&self.specialization.to_bytes());
+ out[SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES..].copy_from_slice(&self.fixed.to_bytes());
out
}
@@ -127,11 +147,15 @@ impl FullPipelineKey {
let mut shader_bytes = [0u8; SHADER_KEY_BYTES];
shader_bytes.copy_from_slice(&b[..SHADER_KEY_BYTES]);
+ let mut specialization_bytes = [0u8; SPECIALIZATION_KEY_BYTES];
+ specialization_bytes.copy_from_slice(&b[SHADER_KEY_BYTES..SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES]);
+
let mut fixed_bytes = [0u8; PipelineKey::BYTES];
- fixed_bytes.copy_from_slice(&b[SHADER_KEY_BYTES..]);
+ fixed_bytes.copy_from_slice(&b[SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES..]);
Self {
shader: ShaderKey::from_bytes(&shader_bytes),
+ specialization: ShaderSpecializationKey::from_bytes(&specialization_bytes),
fixed: PipelineKey::from_bytes(&fixed_bytes),
}
}
@@ -186,155 +210,298 @@ pub(crate) fn save_pipeline_keys(path: &Path, keys: &[FullPipelineKey]) -> std::
Ok(())
}
-impl GxRenderer {
- pub(crate) fn create_pipeline(
- &self,
- device: &wgpu::Device,
- shader: &wgpu::ShaderModule,
- full_key: &FullPipelineKey,
- ) -> wgpu::RenderPipeline {
- let key = &full_key.fixed;
- let active_texcoords = full_key.shader.active_texcoords.min(8) as usize;
-
- const BASE_ATTRS: [wgpu::VertexAttribute; 5] = [
- wgpu::VertexAttribute {
- format: wgpu::VertexFormat::Float32x3,
- offset: 0,
- shader_location: 0,
- },
- wgpu::VertexAttribute {
- format: wgpu::VertexFormat::Float32x4,
- offset: 12,
- shader_location: 1,
- },
- wgpu::VertexAttribute {
- format: wgpu::VertexFormat::Float32x4,
- offset: 28,
- shader_location: 2,
- },
- wgpu::VertexAttribute {
- format: wgpu::VertexFormat::Float32x3,
- offset: 44,
- shader_location: 3,
- },
- wgpu::VertexAttribute {
- format: wgpu::VertexFormat::Float32x3,
- offset: 56,
- shader_location: 4,
- },
- ];
+pub(crate) fn create_specialized_pipeline(
+ device: &wgpu::Device,
+ pipeline_layout: &wgpu::PipelineLayout,
+ surface_format: wgpu::TextureFormat,
+ shader: &wgpu::ShaderModule,
+ full_key: &FullPipelineKey,
+) -> wgpu::RenderPipeline {
+ let constants = full_key.specialization.pipeline_constants(full_key.shader);
+ create_pipeline(
+ device,
+ pipeline_layout,
+ surface_format,
+ shader,
+ full_key.shader,
+ &full_key.fixed,
+ &constants,
+ "gx_pipeline_specialized",
+ )
+}
- let mut attrs: Vec<wgpu::VertexAttribute> = Vec::with_capacity(5 + active_texcoords);
- attrs.extend_from_slice(&BASE_ATTRS);
+pub(crate) fn create_uber_pipeline(
+ device: &wgpu::Device,
+ pipeline_layout: &wgpu::PipelineLayout,
+ surface_format: wgpu::TextureFormat,
+ shader: &wgpu::ShaderModule,
+ key: &UberPipelineKey,
+) -> wgpu::RenderPipeline {
+ create_pipeline(
+ device,
+ pipeline_layout,
+ surface_format,
+ shader,
+ key.shader,
+ &key.fixed,
+ &[("gx_ubershader", 1.0)],
+ "gx_pipeline_uber",
+ )
+}
- for i in 0..active_texcoords {
- attrs.push(wgpu::VertexAttribute {
- format: wgpu::VertexFormat::Float32x3,
- offset: 68 + (i as u64) * 12,
- shader_location: 5 + i as u32,
- });
- }
+#[allow(clippy::too_many_arguments)]
+fn create_pipeline(
+ device: &wgpu::Device,
+ pipeline_layout: &wgpu::PipelineLayout,
+ surface_format: wgpu::TextureFormat,
+ shader: &wgpu::ShaderModule,
+ shader_key: ShaderKey,
+ key: &PipelineKey,
+ constants: &[(&str, f64)],
+ label: &str,
+) -> wgpu::RenderPipeline {
+ let active_texcoords = shader_key.active_texcoords.min(8) as usize;
+
+ const BASE_ATTRS: [wgpu::VertexAttribute; 5] = [
+ wgpu::VertexAttribute {
+ format: wgpu::VertexFormat::Float32x3,
+ offset: 0,
+ shader_location: 0,
+ },
+ wgpu::VertexAttribute {
+ format: wgpu::VertexFormat::Float32x4,
+ offset: 12,
+ shader_location: 1,
+ },
+ wgpu::VertexAttribute {
+ format: wgpu::VertexFormat::Float32x4,
+ offset: 28,
+ shader_location: 2,
+ },
+ wgpu::VertexAttribute {
+ format: wgpu::VertexFormat::Float32x3,
+ offset: 44,
+ shader_location: 3,
+ },
+ wgpu::VertexAttribute {
+ format: wgpu::VertexFormat::Float32x3,
+ offset: 56,
+ shader_location: 4,
+ },
+ ];
+
+ let mut attrs: Vec<wgpu::VertexAttribute> = Vec::with_capacity(5 + active_texcoords);
+ attrs.extend_from_slice(&BASE_ATTRS);
+
+ for i in 0..active_texcoords {
+ attrs.push(wgpu::VertexAttribute {
+ format: wgpu::VertexFormat::Float32x3,
+ offset: 68 + (i as u64) * 12,
+ shader_location: 5 + i as u32,
+ });
+ }
- let vertex_layout = wgpu::VertexBufferLayout {
- array_stride: 68 + (active_texcoords as u64) * 12,
- step_mode: wgpu::VertexStepMode::Vertex,
- attributes: &attrs,
- };
+ let vertex_layout = wgpu::VertexBufferLayout {
+ array_stride: 68 + (active_texcoords as u64) * 12,
+ step_mode: wgpu::VertexStepMode::Vertex,
+ attributes: &attrs,
+ };
- let blend = if key.blend_enable {
- // In subtract mode the hardware ignores the configured src/dst
- // factors and computes `dst = dst - src` with ONE/ONE.
- let (src_factor, dst_factor, operation) = if key.subtract {
- (
- wgpu::BlendFactor::One,
- wgpu::BlendFactor::One,
- wgpu::BlendOperation::ReverseSubtract,
- )
- } else {
- (
- helpers::map_src_blend_factor(key.src_factor),
- helpers::map_dst_blend_factor(key.dst_factor),
- wgpu::BlendOperation::Add,
- )
- };
- Some(make_blend_state(src_factor, dst_factor, operation))
- } else if key.logic_op_enable {
- let (be, sub, sf, df) = logic_op_approximation(key.logic_op);
- be.then(|| {
- let operation = if sub {
- wgpu::BlendOperation::ReverseSubtract
- } else {
- wgpu::BlendOperation::Add
- };
- make_blend_state(sf, df, operation)
- })
+ let blend = if key.blend_enable {
+ // In subtract mode the hardware ignores the configured src/dst
+ // factors and computes `dst = dst - src` with ONE/ONE.
+ let (src_factor, dst_factor, operation) = if key.subtract {
+ (
+ wgpu::BlendFactor::One,
+ wgpu::BlendFactor::One,
+ wgpu::BlendOperation::ReverseSubtract,
+ )
} else {
- None
+ (
+ helpers::map_src_blend_factor(key.src_factor),
+ helpers::map_dst_blend_factor(key.dst_factor),
+ wgpu::BlendOperation::Add,
+ )
};
+ Some(make_blend_state(src_factor, dst_factor, operation))
+ } else if key.logic_op_enable {
+ let (be, sub, sf, df) = logic_op_approximation(key.logic_op);
+ be.then(|| {
+ let operation = if sub {
+ wgpu::BlendOperation::ReverseSubtract
+ } else {
+ wgpu::BlendOperation::Add
+ };
+ make_blend_state(sf, df, operation)
+ })
+ } else {
+ None
+ };
- let depth_stencil = if key.z_enable {
- Some(wgpu::DepthStencilState {
- format: wgpu::TextureFormat::Depth24Plus,
- depth_write_enabled: Some(key.z_write),
- depth_compare: Some(helpers::map_compare_func(key.z_func)),
- stencil: wgpu::StencilState::default(),
- bias: wgpu::DepthBiasState::default(),
- })
- } else {
- Some(wgpu::DepthStencilState {
- format: wgpu::TextureFormat::Depth24Plus,
- depth_write_enabled: Some(false),
- depth_compare: Some(wgpu::CompareFunction::Always),
- stencil: wgpu::StencilState::default(),
- bias: wgpu::DepthBiasState::default(),
- })
- };
+ let depth_stencil = if key.z_enable {
+ Some(wgpu::DepthStencilState {
+ format: wgpu::TextureFormat::Depth24Plus,
+ depth_write_enabled: Some(key.z_write),
+ depth_compare: Some(helpers::map_compare_func(key.z_func)),
+ stencil: wgpu::StencilState::default(),
+ bias: wgpu::DepthBiasState::default(),
+ })
+ } else {
+ Some(wgpu::DepthStencilState {
+ format: wgpu::TextureFormat::Depth24Plus,
+ depth_write_enabled: Some(false),
+ depth_compare: Some(wgpu::CompareFunction::Always),
+ stencil: wgpu::StencilState::default(),
+ bias: wgpu::DepthBiasState::default(),
+ })
+ };
- let mut write_mask = wgpu::ColorWrites::empty();
- if key.color_update {
- write_mask |= wgpu::ColorWrites::RED | wgpu::ColorWrites::GREEN | wgpu::ColorWrites::BLUE;
- }
- if key.alpha_update {
- write_mask |= wgpu::ColorWrites::ALPHA;
- }
+ let mut write_mask = wgpu::ColorWrites::empty();
+ if key.color_update {
+ write_mask |= wgpu::ColorWrites::RED | wgpu::ColorWrites::GREEN | wgpu::ColorWrites::BLUE;
+ }
+ if key.alpha_update {
+ write_mask |= wgpu::ColorWrites::ALPHA;
+ }
- device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
- label: Some("gx_pipeline"),
- layout: Some(&self.pipeline_layout),
- vertex: wgpu::VertexState {
- module: shader,
- entry_point: Some("vs_main"),
- buffers: &[vertex_layout],
- compilation_options: Default::default(),
+ device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+ label: Some(label),
+ layout: Some(pipeline_layout),
+ vertex: wgpu::VertexState {
+ module: shader,
+ entry_point: Some("vs_main"),
+ buffers: &[vertex_layout],
+ compilation_options: wgpu::PipelineCompilationOptions {
+ constants,
+ ..Default::default()
},
- fragment: Some(wgpu::FragmentState {
- module: shader,
- entry_point: Some(if key.ztex { "fs_main_ztex" } else { "fs_main" }),
- targets: &[Some(wgpu::ColorTargetState {
- format: self.surface_format,
- blend,
- write_mask,
- })],
- compilation_options: Default::default(),
- }),
- primitive: wgpu::PrimitiveState {
- topology: wgpu::PrimitiveTopology::TriangleList,
- front_face: wgpu::FrontFace::Cw,
- cull_mode: match key.cull_mode {
- CullMode::Back => Some(wgpu::Face::Back),
- CullMode::Front => Some(wgpu::Face::Front),
- CullMode::None | CullMode::All => None,
- },
+ },
+ fragment: Some(wgpu::FragmentState {
+ module: shader,
+ entry_point: Some(if key.ztex { "fs_main_ztex" } else { "fs_main" }),
+ targets: &[Some(wgpu::ColorTargetState {
+ format: surface_format,
+ blend,
+ write_mask,
+ })],
+ compilation_options: wgpu::PipelineCompilationOptions {
+ constants,
..Default::default()
},
- depth_stencil,
- multisample: wgpu::MultisampleState {
- count: crate::EFB_SAMPLE_COUNT,
- mask: !0,
- alpha_to_coverage_enabled: false,
+ }),
+ primitive: wgpu::PrimitiveState {
+ topology: wgpu::PrimitiveTopology::TriangleList,
+ front_face: wgpu::FrontFace::Cw,
+ cull_mode: match key.cull_mode {
+ CullMode::Back => Some(wgpu::Face::Back),
+ CullMode::Front => Some(wgpu::Face::Front),
+ CullMode::None | CullMode::All => None,
},
- multiview_mask: None,
- cache: None,
- })
+ ..Default::default()
+ },
+ depth_stencil,
+ multisample: wgpu::MultisampleState {
+ count: crate::EFB_SAMPLE_COUNT,
+ mask: !0,
+ alpha_to_coverage_enabled: false,
+ },
+ multiview_mask: None,
+ cache: None,
+ })
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) struct PipelineCompiler {
+ request_tx: crossbeam_channel::Sender<PipelineCompileRequest>,
+ result_rx: crossbeam_channel::Receiver<PipelineCompileResult>,
+ shutdown_tx: crossbeam_channel::Sender<()>,
+ thread: Option<std::thread::JoinHandle<()>>,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+struct PipelineCompileRequest {
+ generation: u64,
+ key: FullPipelineKey,
+ shader: wgpu::ShaderModule,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) struct PipelineCompileResult {
+ pub generation: u64,
+ pub key: FullPipelineKey,
+ pub pipeline: wgpu::RenderPipeline,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl PipelineCompiler {
+ const QUEUE_LIMIT: usize = 64;
+
+ pub(crate) fn new(
+ device: wgpu::Device,
+ pipeline_layout: wgpu::PipelineLayout,
+ surface_format: wgpu::TextureFormat,
+ ) -> Self {
+ let (request_tx, request_rx) = crossbeam_channel::bounded::<PipelineCompileRequest>(Self::QUEUE_LIMIT);
+ let (result_tx, result_rx) = crossbeam_channel::unbounded::<PipelineCompileResult>();
+ let (shutdown_tx, shutdown_rx) = crossbeam_channel::bounded::<()>(1);
+ let thread = std::thread::Builder::new()
+ .name("gx pipeline compiler".into())
+ .spawn(move || {
+ loop {
+ crossbeam_channel::select_biased! {
+ recv(shutdown_rx) -> _ => break,
+ recv(request_rx) -> request => {
+ let Ok(request) = request else { break };
+ let pipeline = create_specialized_pipeline(
+ &device,
+ &pipeline_layout,
+ surface_format,
+ &request.shader,
+ &request.key,
+ );
+ let result = PipelineCompileResult {
+ generation: request.generation,
+ key: request.key,
+ pipeline,
+ };
+ if result_tx.send(result).is_err() {
+ break;
+ }
+ }
+ }
+ }
+ })
+ .expect("failed to start GX pipeline compiler");
+
+ Self {
+ request_tx,
+ result_rx,
+ shutdown_tx,
+ thread: Some(thread),
+ }
+ }
+
+ pub(crate) fn request(&self, generation: u64, key: FullPipelineKey, shader: wgpu::ShaderModule) -> bool {
+ self.request_tx
+ .try_send(PipelineCompileRequest {
+ generation,
+ key,
+ shader,
+ })
+ .is_ok()
+ }
+
+ pub(crate) fn try_recv(&self) -> Option<PipelineCompileResult> {
+ self.result_rx.try_recv().ok()
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl Drop for PipelineCompiler {
+ fn drop(&mut self) {
+ let _ = self.shutdown_tx.try_send(());
+ if let Some(thread) = self.thread.take() {
+ let _ = thread.join();
+ }
}
}
diff --git a/crates/backend-wgpu/src/shader_specialization.rs b/crates/backend-wgpu/src/shader_specialization.rs
index 57eb53e..1f7e6b5 100644
--- a/crates/backend-wgpu/src/shader_specialization.rs
+++ b/crates/backend-wgpu/src/shader_specialization.rs
@@ -14,8 +14,9 @@ const LIGHTING_WESL: &str = include_str!("shaders/lighting.wesl");
const MAIN_WESL: &str = include_str!("shaders/main.wesl");
pub(crate) const KEY_BYTES: usize = 6;
+pub(crate) const SPECIALIZATION_KEY_BYTES: usize = 82 * size_of::<u32>();
const CACHE_MAGIC: [u8; 4] = *b"GSKC";
-pub(crate) const CACHE_VERSION: u32 = 7;
+pub(crate) const CACHE_VERSION: u32 = 8;
pub(crate) const SHADER_CACHE_PATH: &str = "cache/shader_keys.bin";
#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
@@ -28,6 +29,283 @@ pub(crate) struct ShaderKey {
pub active_texcoords: u8,
}
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug, Default)]
+pub(crate) struct ShaderSpecializationKey {
+ pub tev_color_env: [u32; 16],
+ pub tev_alpha_env: [u32; 16],
+ pub tev_orders: [u32; 16],
+ pub tev_ksel: [u32; 8],
+ pub indirect_refs: u32,
+ pub tev_indirect: [u32; 16],
+ pub color_ctrl: [u32; 2],
+ pub alpha_ctrl: [u32; 2],
+ pub alpha_comp0: u32,
+ pub alpha_comp1: u32,
+ pub alpha_op: u32,
+ pub ztex_type: u32,
+ pub ztex_op: u32,
+}
+
+const TEV_COLOR_ENV_NAMES: [&str; 16] = [
+ "gx_tev_color_env_0",
+ "gx_tev_color_env_1",
+ "gx_tev_color_env_2",
+ "gx_tev_color_env_3",
+ "gx_tev_color_env_4",
+ "gx_tev_color_env_5",
+ "gx_tev_color_env_6",
+ "gx_tev_color_env_7",
+ "gx_tev_color_env_8",
+ "gx_tev_color_env_9",
+ "gx_tev_color_env_10",
+ "gx_tev_color_env_11",
+ "gx_tev_color_env_12",
+ "gx_tev_color_env_13",
+ "gx_tev_color_env_14",
+ "gx_tev_color_env_15",
+];
+const TEV_ALPHA_ENV_NAMES: [&str; 16] = [
+ "gx_tev_alpha_env_0",
+ "gx_tev_alpha_env_1",
+ "gx_tev_alpha_env_2",
+ "gx_tev_alpha_env_3",
+ "gx_tev_alpha_env_4",
+ "gx_tev_alpha_env_5",
+ "gx_tev_alpha_env_6",
+ "gx_tev_alpha_env_7",
+ "gx_tev_alpha_env_8",
+ "gx_tev_alpha_env_9",
+ "gx_tev_alpha_env_10",
+ "gx_tev_alpha_env_11",
+ "gx_tev_alpha_env_12",
+ "gx_tev_alpha_env_13",
+ "gx_tev_alpha_env_14",
+ "gx_tev_alpha_env_15",
+];
+const TEV_ORDER_NAMES: [&str; 16] = [
+ "gx_tev_order_0",
+ "gx_tev_order_1",
+ "gx_tev_order_2",
+ "gx_tev_order_3",
+ "gx_tev_order_4",
+ "gx_tev_order_5",
+ "gx_tev_order_6",
+ "gx_tev_order_7",
+ "gx_tev_order_8",
+ "gx_tev_order_9",
+ "gx_tev_order_10",
+ "gx_tev_order_11",
+ "gx_tev_order_12",
+ "gx_tev_order_13",
+ "gx_tev_order_14",
+ "gx_tev_order_15",
+];
+const TEV_KSEL_NAMES: [&str; 8] = [
+ "gx_tev_ksel_0",
+ "gx_tev_ksel_1",
+ "gx_tev_ksel_2",
+ "gx_tev_ksel_3",
+ "gx_tev_ksel_4",
+ "gx_tev_ksel_5",
+ "gx_tev_ksel_6",
+ "gx_tev_ksel_7",
+];
+const TEV_INDIRECT_NAMES: [&str; 16] = [
+ "gx_tev_indirect_0",
+ "gx_tev_indirect_1",
+ "gx_tev_indirect_2",
+ "gx_tev_indirect_3",
+ "gx_tev_indirect_4",
+ "gx_tev_indirect_5",
+ "gx_tev_indirect_6",
+ "gx_tev_indirect_7",
+ "gx_tev_indirect_8",
+ "gx_tev_indirect_9",
+ "gx_tev_indirect_10",
+ "gx_tev_indirect_11",
+ "gx_tev_indirect_12",
+ "gx_tev_indirect_13",
+ "gx_tev_indirect_14",
+ "gx_tev_indirect_15",
+];
+
+impl ShaderSpecializationKey {
+ pub(crate) fn from_draw(draw: &DrawData, alpha_cmp: AlphaCompare, shader: ShaderKey) -> Self {
+ let tev_stages = usize::from(shader.num_tev_stages.min(16));
+ let indirect_stages = u32::from(shader.num_indirect_stages.min(4));
+
+ let mut key = Self {
+ tev_ksel: draw.tev_ksel.map(|value| value & 0x0f),
+ indirect_refs: draw.indirect_refs & ((1u32 << (indirect_stages * 6)) - 1),
+ color_ctrl: draw.color_ctrl.map(|ctrl| ctrl.raw() & 0x7fff),
+ alpha_ctrl: draw.alpha_ctrl.map(|ctrl| ctrl.raw() & 0x7fff),
+ ztex_type: u32::from(draw.ztex_type & 3),
+ ztex_op: u32::from(draw.ztex_op & 3),
+ ..Self::default()
+ };
+
+ fn masked_copy(dst: &mut [u32], src: &[u32], mask: u32) {
+ for (d, &s) in dst.iter_mut().zip(src) {
+ *d = s & mask;
+ }
+ }
+
+ masked_copy(&mut key.tev_color_env[..tev_stages], &draw.tev_color_env, 0x00ff_ffff);
+ masked_copy(&mut key.tev_alpha_env[..tev_stages], &draw.tev_alpha_env, 0x00ff_ffff);
+ masked_copy(&mut key.tev_orders[..tev_stages], &draw.tev_orders, 0x03ff);
+
+ if indirect_stages != 0 {
+ masked_copy(&mut key.tev_indirect[..tev_stages], &draw.tev_indirect, 0x001f_ffff);
+ }
+
+ if shader.alpha_test_enabled {
+ key.alpha_comp0 = alpha_cmp.comp0() as u32;
+ key.alpha_comp1 = alpha_cmp.comp1() as u32;
+ key.alpha_op = alpha_cmp.op() as u32;
+ }
+
+ if draw.ztex_op == 0 {
+ key.ztex_type = 0;
+ }
+
+ key
+ }
+
+ pub(crate) fn pipeline_constants(&self, shader: ShaderKey) -> Vec<(&'static str, f64)> {
+ let tev_stages = usize::from(shader.num_tev_stages.min(16));
+
+ let mut constants = Vec::with_capacity(83);
+ constants.push(("gx_ubershader", 0.0));
+ constants.extend(
+ TEV_COLOR_ENV_NAMES
+ .iter()
+ .take(tev_stages)
+ .zip(self.tev_color_env)
+ .map(|(&name, value)| (name, f64::from(value))),
+ );
+ constants.extend(
+ TEV_ALPHA_ENV_NAMES
+ .iter()
+ .take(tev_stages)
+ .zip(self.tev_alpha_env)
+ .map(|(&name, value)| (name, f64::from(value))),
+ );
+ constants.extend(
+ TEV_ORDER_NAMES
+ .iter()
+ .take(tev_stages)
+ .zip(self.tev_orders)
+ .map(|(&name, value)| (name, f64::from(value))),
+ );
+ constants.extend(
+ TEV_KSEL_NAMES
+ .iter()
+ .zip(self.tev_ksel)
+ .map(|(&name, value)| (name, f64::from(value))),
+ );
+ constants.push(("gx_indirect_refs", f64::from(self.indirect_refs)));
+ constants.extend(
+ TEV_INDIRECT_NAMES
+ .iter()
+ .take(tev_stages)
+ .zip(self.tev_indirect)
+ .map(|(&name, value)| (name, f64::from(value))),
+ );
+ constants.extend([
+ ("gx_color_ctrl_0", f64::from(self.color_ctrl[0])),
+ ("gx_color_ctrl_1", f64::from(self.color_ctrl[1])),
+ ("gx_alpha_ctrl_0", f64::from(self.alpha_ctrl[0])),
+ ("gx_alpha_ctrl_1", f64::from(self.alpha_ctrl[1])),
+ ("gx_ztex_type", f64::from(self.ztex_type)),
+ ("gx_ztex_op", f64::from(self.ztex_op)),
+ ]);
+
+ if shader.alpha_test_enabled {
+ constants.extend([
+ ("gx_alpha_comp_0", f64::from(self.alpha_comp0)),
+ ("gx_alpha_comp_1", f64::from(self.alpha_comp1)),
+ ("gx_alpha_op", f64::from(self.alpha_op)),
+ ]);
+ }
+
+ constants
+ }
+
+ pub(crate) fn to_bytes(self) -> [u8; SPECIALIZATION_KEY_BYTES] {
+ let mut out = [0u8; SPECIALIZATION_KEY_BYTES];
+ let mut offset = 0;
+ let mut write = |value: u32| {
+ out[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
+ offset += 4;
+ };
+ for values in [
+ self.tev_color_env,
+ self.tev_alpha_env,
+ self.tev_orders,
+ self.tev_indirect,
+ ] {
+ values.into_iter().for_each(&mut write);
+ }
+ self.tev_ksel.into_iter().for_each(&mut write);
+ write(self.indirect_refs);
+ self.color_ctrl.into_iter().for_each(&mut write);
+ self.alpha_ctrl.into_iter().for_each(&mut write);
+ [
+ self.alpha_comp0,
+ self.alpha_comp1,
+ self.alpha_op,
+ self.ztex_type,
+ self.ztex_op,
+ ]
+ .into_iter()
+ .for_each(&mut write);
+ debug_assert_eq!(offset, SPECIALIZATION_KEY_BYTES);
+ out
+ }
+
+ pub(crate) fn from_bytes(bytes: &[u8; SPECIALIZATION_KEY_BYTES]) -> Self {
+ let mut offset = 0;
+
+ let mut read = || {
+ let value = u32::from_le_bytes(bytes[offset..offset + 4].try_into().unwrap());
+ offset += 4;
+ value
+ };
+
+ let tev_color_env = std::array::from_fn(|_| read());
+ let tev_alpha_env = std::array::from_fn(|_| read());
+ let tev_orders = std::array::from_fn(|_| read());
+ let tev_indirect = std::array::from_fn(|_| read());
+ let tev_ksel = std::array::from_fn(|_| read());
+ let indirect_refs = read();
+ let color_ctrl = std::array::from_fn(|_| read());
+ let alpha_ctrl = std::array::from_fn(|_| read());
+ let alpha_comp0 = read();
+ let alpha_comp1 = read();
+ let alpha_op = read();
+ let ztex_type = read();
+ let ztex_op = read();
+
+ debug_assert_eq!(offset, SPECIALIZATION_KEY_BYTES);
+
+ Self {
+ tev_color_env,
+ tev_alpha_env,
+ tev_orders,
+ tev_ksel,
+ indirect_refs,
+ tev_indirect,
+ color_ctrl,
+ alpha_ctrl,
+ alpha_comp0,
+ alpha_comp1,
+ alpha_op,
+ ztex_type,
+ ztex_op,
+ }
+ }
+}
+
impl ShaderKey {
pub(crate) fn from_draw(draw: &DrawData, alpha_cmp: AlphaCompare) -> Self {
let num_tev_stages = draw.num_tev_stages.clamp(1, 16);
diff --git a/crates/backend-wgpu/src/shaders/main.wesl b/crates/backend-wgpu/src/shaders/main.wesl
index 763ed33..34044bb 100644
--- a/crates/backend-wgpu/src/shaders/main.wesl
+++ b/crates/backend-wgpu/src/shaders/main.wesl
@@ -5,18 +5,129 @@ import super::tev_combiners::{tev_combine_color, tev_combine_alpha};
import super::alpha_test::{alpha_compare, alpha_combine};
import super::lighting::{compute_lighting_c0, compute_lighting_c1};
+override gx_ubershader: bool = false;
+override gx_tev_color_env_0: u32 = 0u;
+override gx_tev_color_env_1: u32 = 0u;
+override gx_tev_color_env_2: u32 = 0u;
+override gx_tev_color_env_3: u32 = 0u;
+override gx_tev_color_env_4: u32 = 0u;
+override gx_tev_color_env_5: u32 = 0u;
+override gx_tev_color_env_6: u32 = 0u;
+override gx_tev_color_env_7: u32 = 0u;
+override gx_tev_color_env_8: u32 = 0u;
+override gx_tev_color_env_9: u32 = 0u;
+override gx_tev_color_env_10: u32 = 0u;
+override gx_tev_color_env_11: u32 = 0u;
+override gx_tev_color_env_12: u32 = 0u;
+override gx_tev_color_env_13: u32 = 0u;
+override gx_tev_color_env_14: u32 = 0u;
+override gx_tev_color_env_15: u32 = 0u;
+
+override gx_tev_alpha_env_0: u32 = 0u;
+override gx_tev_alpha_env_1: u32 = 0u;
+override gx_tev_alpha_env_2: u32 = 0u;
+override gx_tev_alpha_env_3: u32 = 0u;
+override gx_tev_alpha_env_4: u32 = 0u;
+override gx_tev_alpha_env_5: u32 = 0u;
+override gx_tev_alpha_env_6: u32 = 0u;
+override gx_tev_alpha_env_7: u32 = 0u;
+override gx_tev_alpha_env_8: u32 = 0u;
+override gx_tev_alpha_env_9: u32 = 0u;
+override gx_tev_alpha_env_10: u32 = 0u;
+override gx_tev_alpha_env_11: u32 = 0u;
+override gx_tev_alpha_env_12: u32 = 0u;
+override gx_tev_alpha_env_13: u32 = 0u;
+override gx_tev_alpha_env_14: u32 = 0u;
+override gx_tev_alpha_env_15: u32 = 0u;
+
+override gx_tev_order_0: u32 = 0u;
+override gx_tev_order_1: u32 = 0u;
+override gx_tev_order_2: u32 = 0u;
+override gx_tev_order_3: u32 = 0u;
+override gx_tev_order_4: u32 = 0u;
+override gx_tev_order_5: u32 = 0u;
+override gx_tev_order_6: u32 = 0u;
+override gx_tev_order_7: u32 = 0u;
+override gx_tev_order_8: u32 = 0u;
+override gx_tev_order_9: u32 = 0u;
+override gx_tev_order_10: u32 = 0u;
+override gx_tev_order_11: u32 = 0u;
+override gx_tev_order_12: u32 = 0u;
+override gx_tev_order_13: u32 = 0u;
+override gx_tev_order_14: u32 = 0u;
+override gx_tev_order_15: u32 = 0u;
+
+override gx_tev_indirect_0: u32 = 0u;
+override gx_tev_indirect_1: u32 = 0u;
+override gx_tev_indirect_2: u32 = 0u;
+override gx_tev_indirect_3: u32 = 0u;
+override gx_tev_indirect_4: u32 = 0u;
+override gx_tev_indirect_5: u32 = 0u;
+override gx_tev_indirect_6: u32 = 0u;
+override gx_tev_indirect_7: u32 = 0u;
+override gx_tev_indirect_8: u32 = 0u;
+override gx_tev_indirect_9: u32 = 0u;
+override gx_tev_indirect_10: u32 = 0u;
+override gx_tev_indirect_11: u32 = 0u;
+override gx_tev_indirect_12: u32 = 0u;
+override gx_tev_indirect_13: u32 = 0u;
+override gx_tev_indirect_14: u32 = 0u;
+override gx_tev_indirect_15: u32 = 0u;
+
+override gx_tev_ksel_0: u32 = 0u;
+override gx_tev_ksel_1: u32 = 0u;
+override gx_tev_ksel_2: u32 = 0u;
+override gx_tev_ksel_3: u32 = 0u;
+override gx_tev_ksel_4: u32 = 0u;
+override gx_tev_ksel_5: u32 = 0u;
+override gx_tev_ksel_6: u32 = 0u;
+override gx_tev_ksel_7: u32 = 0u;
+override gx_indirect_refs: u32 = 0u;
+
+override gx_color_ctrl_0: u32 = 0u;
+override gx_color_ctrl_1: u32 = 0u;
+override gx_alpha_ctrl_0: u32 = 0u;
+override gx_alpha_ctrl_1: u32 = 0u;
+override gx_alpha_comp_0: u32 = 7u;
+override gx_alpha_comp_1: u32 = 7u;
+override gx_alpha_op: u32 = 0u;
+override gx_ztex_type: u32 = 0u;
+override gx_ztex_op: u32 = 0u;
+
+fn shader_state(specialized: u32, dynamic: u32) -> u32 {
+ return select(specialized, dynamic, gx_ubershader);
+}
+
+fn dynamic_tev_color_env(stage: u32) -> u32 {
+ return frame.tev_color_env[stage / 4u][stage % 4u];
+}
+
+fn dynamic_tev_alpha_env(stage: u32) -> u32 {
+ return frame.tev_alpha_env[stage / 4u][stage % 4u];
+}
+
+fn dynamic_tev_order(stage: u32) -> u32 {
+ return frame.tev_orders[stage / 4u][stage % 4u];
+}
+
+fn dynamic_tev_indirect(stage: u32) -> u32 {
+ return frame.tev_indirect[stage / 4u][stage % 4u];
+}
+
@vertex
fn vs_main(in: VsIn) -> VsOut {
var out: VsOut;
out.clip_pos = draw.mvp * vec4<f32>(in.pos_view, 1.0);
out.clip_pos.z = out.clip_pos.z + out.clip_pos.w;
out.color = compute_lighting_c0(
- frame.color_ctrl0, frame.alpha_ctrl0,
+ shader_state(gx_color_ctrl_0, frame.color_ctrl0),
+ shader_state(gx_alpha_ctrl_0, frame.alpha_ctrl0),
frame.ambient_color0, frame.material_color0,
in.color, in.normal, in.pos_view,
);
out.color1 = compute_lighting_c1(
- frame.color_ctrl1, frame.alpha_ctrl1,
+ shader_state(gx_color_ctrl_1, frame.color_ctrl1),
+ shader_state(gx_alpha_ctrl_1, frame.alpha_ctrl1),
frame.ambient_color1, frame.material_color1,
in.color1, in.normal, in.pos_view,
);
@@ -44,20 +155,32 @@ struct TevState {
last_raw_tex: vec4<f32>,
}
+fn specialized_tev_ksel(idx: u32) -> u32 {
+ var specialized: u32;
+ switch idx {
+ case 0u: { specialized = gx_tev_ksel_0; }
+ case 1u: { specialized = gx_tev_ksel_1; }
+ case 2u: { specialized = gx_tev_ksel_2; }
+ case 3u: { specialized = gx_tev_ksel_3; }
+ case 4u: { specialized = gx_tev_ksel_4; }
+ case 5u: { specialized = gx_tev_ksel_5; }
+ case 6u: { specialized = gx_tev_ksel_6; }
+ default: { specialized = gx_tev_ksel_7; }
+ }
+ return shader_state(specialized, frame.tev_ksel[idx / 4u][idx % 4u]);
+}
+
fn run_stage(
stage: u32,
+ order: u32,
+ cenv: u32,
+ aenv: u32,
+ ind_cmd: u32,
in: VsOut,
color0: vec4<f32>,
presampled: IndirectSamples,
state: ptr<function, TevState>,
) {
- let row = stage / 4u;
- let col = stage % 4u;
- let order = frame.tev_orders[row][col];
- let cenv = frame.tev_color_env[row][col];
- let aenv = frame.tev_alpha_env[row][col];
- let ind_cmd = frame.tev_indirect[row][col];
-
let texmap_idx = order & 7u;
let texcoord_idx = (order >> 3u) & 7u;
let tex_enabled = ((order >> 6u) & 1u) != 0u;
@@ -89,8 +212,18 @@ fn run_stage(
tex_color = vec4<f32>(1.0, 1.0, 1.0, 1.0);
}
- ras_color = swizzle_tev_color(extract_bits(aenv, 0u, 2u), ras_color);
- tex_color = swizzle_tev_color(extract_bits(aenv, 2u, 2u), tex_color);
+ let ras_swap = extract_bits(aenv, 0u, 2u) * 2u;
+ let tex_swap = extract_bits(aenv, 2u, 2u) * 2u;
+ ras_color = swizzle_tev_color(
+ specialized_tev_ksel(ras_swap),
+ specialized_tev_ksel(ras_swap + 1u),
+ ras_color,
+ );
+ tex_color = swizzle_tev_color(
+ specialized_tev_ksel(tex_swap),
+ specialized_tev_ksel(tex_swap + 1u),
+ tex_color,
+ );
let c_d = extract_bits(cenv, 0u, 4u);
let c_c = extract_bits(cenv, 4u, 4u);
@@ -151,31 +284,31 @@ fn run_tev(in: VsOut) -> TevResult {
state.last_raw_tex = vec4<f32>(0.0, 0.0, 0.0, 0.0);
let color0 = in.color;
- let presampled = sample_indirect_textures(in);
-
- @if(TEV_STAGE_1_ENABLED) { run_stage( 0u, in, color0, presampled, &state); }
- @if(TEV_STAGE_2_ENABLED) { run_stage( 1u, in, color0, presampled, &state); }
- @if(TEV_STAGE_3_ENABLED) { run_stage( 2u, in, color0, presampled, &state); }
- @if(TEV_STAGE_4_ENABLED) { run_stage( 3u, in, color0, presampled, &state); }
- @if(TEV_STAGE_5_ENABLED) { run_stage( 4u, in, color0, presampled, &state); }
- @if(TEV_STAGE_6_ENABLED) { run_stage( 5u, in, color0, presampled, &state); }
- @if(TEV_STAGE_7_ENABLED) { run_stage( 6u, in, color0, presampled, &state); }
- @if(TEV_STAGE_8_ENABLED) { run_stage( 7u, in, color0, presampled, &state); }
- @if(TEV_STAGE_9_ENABLED) { run_stage( 8u, in, color0, presampled, &state); }
- @if(TEV_STAGE_10_ENABLED) { run_stage( 9u, in, color0, presampled, &state); }
- @if(TEV_STAGE_11_ENABLED) { run_stage(10u, in, color0, presampled, &state); }
- @if(TEV_STAGE_12_ENABLED) { run_stage(11u, in, color0, presampled, &state); }
- @if(TEV_STAGE_13_ENABLED) { run_stage(12u, in, color0, presampled, &state); }
- @if(TEV_STAGE_14_ENABLED) { run_stage(13u, in, color0, presampled, &state); }
- @if(TEV_STAGE_15_ENABLED) { run_stage(14u, in, color0, presampled, &state); }
- @if(TEV_STAGE_16_ENABLED) { run_stage(15u, in, color0, presampled, &state); }
+ let presampled = sample_indirect_textures(in, shader_state(gx_indirect_refs, frame.indirect_refs));
+
+ @if(TEV_STAGE_1_ENABLED) { run_stage( 0u, shader_state(gx_tev_order_0, dynamic_tev_order( 0u)), shader_state(gx_tev_color_env_0, dynamic_tev_color_env( 0u)), shader_state(gx_tev_alpha_env_0, dynamic_tev_alpha_env( 0u)), shader_state(gx_tev_indirect_0, dynamic_tev_indirect( 0u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_2_ENABLED) { run_stage( 1u, shader_state(gx_tev_order_1, dynamic_tev_order( 1u)), shader_state(gx_tev_color_env_1, dynamic_tev_color_env( 1u)), shader_state(gx_tev_alpha_env_1, dynamic_tev_alpha_env( 1u)), shader_state(gx_tev_indirect_1, dynamic_tev_indirect( 1u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_3_ENABLED) { run_stage( 2u, shader_state(gx_tev_order_2, dynamic_tev_order( 2u)), shader_state(gx_tev_color_env_2, dynamic_tev_color_env( 2u)), shader_state(gx_tev_alpha_env_2, dynamic_tev_alpha_env( 2u)), shader_state(gx_tev_indirect_2, dynamic_tev_indirect( 2u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_4_ENABLED) { run_stage( 3u, shader_state(gx_tev_order_3, dynamic_tev_order( 3u)), shader_state(gx_tev_color_env_3, dynamic_tev_color_env( 3u)), shader_state(gx_tev_alpha_env_3, dynamic_tev_alpha_env( 3u)), shader_state(gx_tev_indirect_3, dynamic_tev_indirect( 3u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_5_ENABLED) { run_stage( 4u, shader_state(gx_tev_order_4, dynamic_tev_order( 4u)), shader_state(gx_tev_color_env_4, dynamic_tev_color_env( 4u)), shader_state(gx_tev_alpha_env_4, dynamic_tev_alpha_env( 4u)), shader_state(gx_tev_indirect_4, dynamic_tev_indirect( 4u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_6_ENABLED) { run_stage( 5u, shader_state(gx_tev_order_5, dynamic_tev_order( 5u)), shader_state(gx_tev_color_env_5, dynamic_tev_color_env( 5u)), shader_state(gx_tev_alpha_env_5, dynamic_tev_alpha_env( 5u)), shader_state(gx_tev_indirect_5, dynamic_tev_indirect( 5u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_7_ENABLED) { run_stage( 6u, shader_state(gx_tev_order_6, dynamic_tev_order( 6u)), shader_state(gx_tev_color_env_6, dynamic_tev_color_env( 6u)), shader_state(gx_tev_alpha_env_6, dynamic_tev_alpha_env( 6u)), shader_state(gx_tev_indirect_6, dynamic_tev_indirect( 6u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_8_ENABLED) { run_stage( 7u, shader_state(gx_tev_order_7, dynamic_tev_order( 7u)), shader_state(gx_tev_color_env_7, dynamic_tev_color_env( 7u)), shader_state(gx_tev_alpha_env_7, dynamic_tev_alpha_env( 7u)), shader_state(gx_tev_indirect_7, dynamic_tev_indirect( 7u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_9_ENABLED) { run_stage( 8u, shader_state(gx_tev_order_8, dynamic_tev_order( 8u)), shader_state(gx_tev_color_env_8, dynamic_tev_color_env( 8u)), shader_state(gx_tev_alpha_env_8, dynamic_tev_alpha_env( 8u)), shader_state(gx_tev_indirect_8, dynamic_tev_indirect( 8u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_10_ENABLED) { run_stage( 9u, shader_state(gx_tev_order_9, dynamic_tev_order( 9u)), shader_state(gx_tev_color_env_9, dynamic_tev_color_env( 9u)), shader_state(gx_tev_alpha_env_9, dynamic_tev_alpha_env( 9u)), shader_state(gx_tev_indirect_9, dynamic_tev_indirect( 9u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_11_ENABLED) { run_stage(10u, shader_state(gx_tev_order_10, dynamic_tev_order(10u)), shader_state(gx_tev_color_env_10, dynamic_tev_color_env(10u)), shader_state(gx_tev_alpha_env_10, dynamic_tev_alpha_env(10u)), shader_state(gx_tev_indirect_10, dynamic_tev_indirect(10u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_12_ENABLED) { run_stage(11u, shader_state(gx_tev_order_11, dynamic_tev_order(11u)), shader_state(gx_tev_color_env_11, dynamic_tev_color_env(11u)), shader_state(gx_tev_alpha_env_11, dynamic_tev_alpha_env(11u)), shader_state(gx_tev_indirect_11, dynamic_tev_indirect(11u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_13_ENABLED) { run_stage(12u, shader_state(gx_tev_order_12, dynamic_tev_order(12u)), shader_state(gx_tev_color_env_12, dynamic_tev_color_env(12u)), shader_state(gx_tev_alpha_env_12, dynamic_tev_alpha_env(12u)), shader_state(gx_tev_indirect_12, dynamic_tev_indirect(12u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_14_ENABLED) { run_stage(13u, shader_state(gx_tev_order_13, dynamic_tev_order(13u)), shader_state(gx_tev_color_env_13, dynamic_tev_color_env(13u)), shader_state(gx_tev_alpha_env_13, dynamic_tev_alpha_env(13u)), shader_state(gx_tev_indirect_13, dynamic_tev_indirect(13u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_15_ENABLED) { run_stage(14u, shader_state(gx_tev_order_14, dynamic_tev_order(14u)), shader_state(gx_tev_color_env_14, dynamic_tev_color_env(14u)), shader_state(gx_tev_alpha_env_14, dynamic_tev_alpha_env(14u)), shader_state(gx_tev_indirect_14, dynamic_tev_indirect(14u)), in, color0, presampled, &state); }
+ @if(TEV_STAGE_16_ENABLED) { run_stage(15u, shader_state(gx_tev_order_15, dynamic_tev_order(15u)), shader_state(gx_tev_color_env_15, dynamic_tev_color_env(15u)), shader_state(gx_tev_alpha_env_15, dynamic_tev_alpha_env(15u)), shader_state(gx_tev_indirect_15, dynamic_tev_indirect(15u)), in, color0, presampled, &state); }
let color = vec4<f32>(state.regs[state.last_color_dest].rgb, state.regs[state.last_alpha_dest].a);
@if(ALPHA_TEST_ENABLED) {
- let c0 = alpha_compare(color.a, frame.alpha_ref0, frame.alpha_comp0);
- let c1 = alpha_compare(color.a, frame.alpha_ref1, frame.alpha_comp1);
- if !alpha_combine(c0, c1, frame.alpha_op) {
+ let c0 = alpha_compare(color.a, frame.alpha_ref0, shader_state(gx_alpha_comp_0, frame.alpha_comp0));
+ let c1 = alpha_compare(color.a, frame.alpha_ref1, shader_state(gx_alpha_comp_1, frame.alpha_comp1));
+ if !alpha_combine(c0, c1, shader_state(gx_alpha_op, frame.alpha_op)) {
discard;
}
}
@@ -201,12 +334,12 @@ fn fs_main_ztex(in: VsOut) -> FsOutZtex {
let r = run_tev(in);
let texel = vec4<u32>(round(r.raw_tex * 255.0));
var z: u32 = frame.ztex_bias;
- switch frame.ztex_type {
+ switch shader_state(gx_ztex_type, frame.ztex_type) {
case 0u: { z += texel.a; }
case 1u: { z += (texel.a << 8u) | texel.r; }
default: { z += (texel.r << 16u) | (texel.g << 8u) | texel.b; }
}
- if frame.ztex_op == 1u {
+ if shader_state(gx_ztex_op, frame.ztex_op) == 1u {
z += u32(round(in.clip_pos.z * 16777215.0));
}
z = z & 0x00FFFFFFu;
diff --git a/crates/backend-wgpu/src/shaders/tev_helpers.wesl b/crates/backend-wgpu/src/shaders/tev_helpers.wesl
index f61e8d5..f2b2805 100644
--- a/crates/backend-wgpu/src/shaders/tev_helpers.wesl
+++ b/crates/backend-wgpu/src/shaders/tev_helpers.wesl
@@ -1,11 +1,4 @@
-import super::common::{VsOut, frame, tex0, tex1, tex2, tex3, tex4, tex5, tex6, tex7, samp0, samp1, samp2, samp3, samp4, samp5, samp6, samp7};
-
-// Index into a packed array<vec4<u32>, 4> by flat index
-fn read_packed(arr: array<vec4<u32>, 4>, idx: u32) -> u32 {
- let vi = idx / 4u;
- let ci = idx % 4u;
- return arr[vi][ci];
-}
+import super::common::{VsOut, tex0, tex1, tex2, tex3, tex4, tex5, tex6, tex7, samp0, samp1, samp2, samp3, samp4, samp5, samp6, samp7};
fn extract_bits(val: u32, lo: u32, width: u32) -> u32 {
return (val >> lo) & ((1u << width) - 1u);
@@ -20,9 +13,7 @@ fn select_color_channel(color: vec4<f32>, channel: u32) -> f32 {
}
}
-fn swizzle_tev_color(swap_table: u32, color: vec4<f32>) -> vec4<f32> {
- let rg = read_packed(frame.tev_ksel, swap_table * 2u);
- let ba = read_packed(frame.tev_ksel, swap_table * 2u + 1u);
+fn swizzle_tev_color(rg: u32, ba: u32, color: vec4<f32>) -> vec4<f32> {
let r = extract_bits(rg, 0u, 2u);
let g = extract_bits(rg, 2u, 2u);
let b = extract_bits(ba, 0u, 2u);
diff --git a/crates/backend-wgpu/src/shaders/tev_indirect.wesl b/crates/backend-wgpu/src/shaders/tev_indirect.wesl
index d527f1d..2836b4a 100644
--- a/crates/backend-wgpu/src/shaders/tev_indirect.wesl
+++ b/crates/backend-wgpu/src/shaders/tev_indirect.wesl
@@ -1,5 +1,5 @@
-import super::common::{VsOut, FrameUniforms, frame, draw};
-import super::tev_helpers::{select_texcoord, stq_to_uv, sample_texmap, read_packed};
+import super::common::{VsOut, frame, draw};
+import super::tev_helpers::{select_texcoord, stq_to_uv, sample_texmap};
fn texmap_size(texmap: u32) -> vec2<f32> {
let pair = draw.tex_dims[texmap / 2u];
@@ -65,10 +65,10 @@ struct IndirectSamples {
samples: array<vec3<f32>, 4>,
}
-fn sample_indirect_one(i: u32, in: VsOut, result: ptr<function, IndirectSamples>) {
+fn sample_indirect_one(i: u32, in: VsOut, indirect_refs: u32, result: ptr<function, IndirectSamples>) {
let shift = i * 6u;
- let texmap = (frame.indirect_refs >> shift) & 7u;
- let texcoord = (frame.indirect_refs >> (shift + 3u)) & 7u;
+ let texmap = (indirect_refs >> shift) & 7u;
+ let texcoord = (indirect_refs >> (shift + 3u)) & 7u;
let scale_pair = frame.indirect_scales[i / 2u];
let scale_s: u32 = select(scale_pair.x, scale_pair.z, (i & 1u) == 1u);
let scale_t: u32 = select(scale_pair.y, scale_pair.w, (i & 1u) == 1u);
@@ -83,17 +83,17 @@ fn sample_indirect_one(i: u32, in: VsOut, result: ptr<function, IndirectSamples>
(*result).samples[i] = sample.abg;
}
-fn sample_indirect_textures(in: VsOut) -> IndirectSamples {
+fn sample_indirect_textures(in: VsOut, indirect_refs: u32) -> IndirectSamples {
var result: IndirectSamples;
result.samples[0] = vec3<f32>(0.0);
result.samples[1] = vec3<f32>(0.0);
result.samples[2] = vec3<f32>(0.0);
result.samples[3] = vec3<f32>(0.0);
- @if(IND_STAGE_0_ENABLED) { sample_indirect_one(0u, in, &result); }
- @if(IND_STAGE_1_ENABLED) { sample_indirect_one(1u, in, &result); }
- @if(IND_STAGE_2_ENABLED) { sample_indirect_one(2u, in, &result); }
- @if(IND_STAGE_3_ENABLED) { sample_indirect_one(3u, in, &result); }
+ @if(IND_STAGE_0_ENABLED) { sample_indirect_one(0u, in, indirect_refs, &result); }
+ @if(IND_STAGE_1_ENABLED) { sample_indirect_one(1u, in, indirect_refs, &result); }
+ @if(IND_STAGE_2_ENABLED) { sample_indirect_one(2u, in, indirect_refs, &result); }
+ @if(IND_STAGE_3_ENABLED) { sample_indirect_one(3u, in, indirect_refs, &result); }
return result;
}
diff --git a/crates/backend-wgpu/src/sink.rs b/crates/backend-wgpu/src/sink.rs
index a649d0f..a323f60 100644
--- a/crates/backend-wgpu/src/sink.rs
+++ b/crates/backend-wgpu/src/sink.rs
@@ -4,6 +4,8 @@ use gecko::host::GxAction;
use crate::GxRenderer;
#[cfg(not(target_arch = "wasm32"))]
use gecko::host::{DrawData, DrawVertex, RenderSink};
+#[cfg(all(not(target_arch = "wasm32"), feature = "gx-stats"))]
+use std::sync::atomic::Ordering;
#[cfg(not(target_arch = "wasm32"))]
use std::sync::{Arc, Mutex, OnceLock};
#[cfg(not(target_arch = "wasm32"))]
@@ -15,7 +17,10 @@ use std::time::Instant;
pub type FrameReadyCallback = Box<dyn Fn(Instant) + Send + Sync>;
#[cfg(not(target_arch = "wasm32"))]
-const WORK_QUEUE_LIMIT: usize = 4096;
+// Keep only a few GX batches in flight. This used to count individual actions,
+// so leaving it at 4096 after batching would allow thousands of whole frames to
+// accumulate behind the render worker.
+const WORK_QUEUE_LIMIT: usize = 8;
/// Holds the XFB output texture that the render worker updates and the
/// windowing thread reads for blitting and screenshots.
@@ -55,9 +60,12 @@ impl TargetAspect {
pub struct ThreadedSink {
work_tx: crossbeam_channel::Sender<WorkerCommand>,
recycled_draw_data_rx: crossbeam_channel::Receiver<Box<DrawData>>,
+ recycled_batches_rx: crossbeam_channel::Receiver<ActionBatch>,
+ #[cfg(feature = "gx-stats")]
+ stats: Arc<crate::RendererStats>,
worker_thread: Option<JoinHandle<()>>,
+ pending_actions: Vec<GxAction>,
scratch: Vec<DrawVertex>,
- scratch_sent_len: usize,
}
#[cfg(not(target_arch = "wasm32"))]
@@ -68,14 +76,16 @@ struct RenderWorker {
shared: Arc<Shared>,
frame_ready_cb: Arc<OnceLock<FrameReadyCallback>>,
recycled_draw_data_tx: crossbeam_channel::Sender<Box<DrawData>>,
+ recycled_batches_tx: crossbeam_channel::Sender<ActionBatch>,
#[cfg(feature = "renderdoc-capture")]
renderdoc: Arc<Mutex<crate::renderdoc_capture::RenderDocCapture>>,
}
#[cfg(not(target_arch = "wasm32"))]
-struct ActionMessage {
- action: GxAction,
+struct ActionBatch {
+ actions: Vec<GxAction>,
vertices: Vec<DrawVertex>,
+ resets_scratch: bool,
}
#[cfg(not(target_arch = "wasm32"))]
@@ -84,12 +94,13 @@ struct EfbDrainRequest {
mem1_len: usize,
mem2_addr: usize,
mem2_len: usize,
- done_tx: crossbeam_channel::Sender<()>,
+ batch: ActionBatch,
+ done_tx: crossbeam_channel::Sender<ActionBatch>,
}
#[cfg(not(target_arch = "wasm32"))]
enum WorkerCommand {
- Action(ActionMessage),
+ Actions(ActionBatch),
DrainEfbCopies(EfbDrainRequest),
Shutdown,
}
@@ -99,13 +110,14 @@ impl RenderWorker {
fn run(mut self, work_rx: crossbeam_channel::Receiver<WorkerCommand>) {
while let Ok(command) = work_rx.recv() {
match command {
- WorkerCommand::Action(message) => self.exec(message),
+ WorkerCommand::Actions(batch) => self.exec_batch(batch),
WorkerCommand::DrainEfbCopies(request) => self.drain_efb_copies(request),
WorkerCommand::Shutdown => break,
}
}
self.gx.submit_pending(&self.queue);
+ self.gx.poll_compiled_pipelines();
#[cfg(feature = "renderdoc-capture")]
if let Ok(mut rd) = self.renderdoc.lock() {
rd.end_emulated_frame();
@@ -120,15 +132,10 @@ impl RenderWorker {
}
}
- fn exec(&mut self, message: ActionMessage) {
- if !message.vertices.is_empty() {
- self.gx.scratch_vertices.extend_from_slice(&message.vertices);
- }
-
- let resets_scratch = action_resets_vertex_scratch(&message.action);
- self.gx.process_action(&self.device, &self.queue, &message.action);
+ fn exec_action(&mut self, action: GxAction) {
+ self.gx.process_action(&self.device, &self.queue, &action);
- match message.action {
+ match action {
GxAction::PresentXfb { .. } | GxAction::PresentRawXfb { .. } => {
#[cfg(feature = "renderdoc-capture")]
if let Ok(mut rd) = self.renderdoc.lock() {
@@ -146,13 +153,50 @@ impl RenderWorker {
}
_ => {}
}
+ }
- if resets_scratch {
- self.gx.scratch_vertices.clear();
+ fn exec_batch_returning_vertices(&mut self, batch: &mut ActionBatch) {
+ let worker_scratch = self.gx.replace_vertex_scratch(std::mem::take(&mut batch.vertices));
+ for action in batch.actions.drain(..) {
+ self.exec_action(action);
+ }
+ batch.vertices = self.gx.replace_vertex_scratch(worker_scratch);
+ }
+
+ fn exec_batch(&mut self, mut batch: ActionBatch) {
+ #[cfg(feature = "gx-stats")]
+ let batch_started = std::time::Instant::now();
+
+ if batch.resets_scratch {
+ self.exec_batch_returning_vertices(&mut batch);
+ batch.vertices.clear();
+
+ debug_assert!(batch.actions.is_empty());
+ debug_assert!(batch.vertices.is_empty());
+
+ let _ = self.recycled_batches_tx.send(batch);
+ } else {
+ let _old_scratch = self.gx.replace_vertex_scratch(batch.vertices);
+ for action in batch.actions {
+ self.exec_action(action);
+ }
}
+
+ #[cfg(feature = "gx-stats")]
+ self.gx
+ .stats
+ .worker_batch_cpu_ns
+ .fetch_add(batch_started.elapsed().as_nanos() as u64, Ordering::Relaxed);
}
- fn drain_efb_copies(&mut self, request: EfbDrainRequest) {
+ fn drain_efb_copies(&mut self, mut request: EfbDrainRequest) {
+ #[cfg(feature = "gx-stats")]
+ let batch_started = std::time::Instant::now();
+
+ let expected_vertex_len = request.batch.vertices.len();
+ self.exec_batch_returning_vertices(&mut request.batch);
+ debug_assert_eq!(request.batch.vertices.len(), expected_vertex_len);
+
let mut ram = unsafe {
// The emu thread blocks on `done_tx` and holds the only mutable
// RamViewMut while this command runs. FIFO channel ordering also
@@ -161,40 +205,91 @@ impl RenderWorker {
let mem2 = std::slice::from_raw_parts_mut(request.mem2_addr as *mut u8, request.mem2_len);
gecko::mmio::RamViewMut { mem1, mem2 }
};
+ #[cfg(feature = "gx-stats")]
+ let writeback_count = self.gx.pending_writebacks.len() as u64;
+ #[cfg(feature = "gx-stats")]
+ let writeback_started = std::time::Instant::now();
self.gx.drain_pending_writebacks(&self.device, &self.queue, &mut ram);
- let _ = request.done_tx.send(());
+
+ #[cfg(feature = "gx-stats")]
+ {
+ self.gx.stats.efb_drain_requests.fetch_add(1, Ordering::Relaxed);
+ if writeback_count != 0 {
+ self.gx.stats.efb_drain_nonempty.fetch_add(1, Ordering::Relaxed);
+ self.gx
+ .stats
+ .efb_writebacks
+ .fetch_add(writeback_count, Ordering::Relaxed);
+ self.gx
+ .stats
+ .efb_writeback_cpu_ns
+ .fetch_add(writeback_started.elapsed().as_nanos() as u64, Ordering::Relaxed);
+ }
+ self.gx
+ .stats
+ .worker_batch_cpu_ns
+ .fetch_add(batch_started.elapsed().as_nanos() as u64, Ordering::Relaxed);
+ }
+
+ let _ = request.done_tx.send(request.batch);
}
}
#[cfg(not(target_arch = "wasm32"))]
impl ThreadedSink {
- fn pending_vertices(&mut self) -> Vec<DrawVertex> {
- if self.scratch.len() <= self.scratch_sent_len {
- return Vec::new();
+ fn reclaim_batch(&mut self) {
+ if !self.pending_actions.is_empty() || !self.scratch.is_empty() {
+ return;
}
- let vertices = self.scratch[self.scratch_sent_len..].to_vec();
- self.scratch_sent_len = self.scratch.len();
- vertices
+ if let Ok(batch) = self.recycled_batches_rx.try_recv() {
+ debug_assert!(batch.actions.is_empty());
+ debug_assert!(batch.vertices.is_empty());
+ self.pending_actions = batch.actions;
+ self.scratch = batch.vertices;
+ }
+ }
+
+ fn take_batch(&mut self, resets_scratch: bool) -> ActionBatch {
+ ActionBatch {
+ actions: std::mem::take(&mut self.pending_actions),
+ vertices: std::mem::take(&mut self.scratch),
+ resets_scratch,
+ }
+ }
+
+ fn send_reset_batch(&mut self) {
+ let batch = self.take_batch(true);
+ #[cfg(feature = "gx-stats")]
+ let send_started = std::time::Instant::now();
+ self.work_tx
+ .send(WorkerCommand::Actions(batch))
+ .expect("render worker thread stopped");
+ #[cfg(feature = "gx-stats")]
+ {
+ self.stats.batches_sent.fetch_add(1, Ordering::Relaxed);
+ self.stats
+ .channel_high_water
+ .fetch_max(self.work_tx.len() as u64, Ordering::Relaxed);
+ self.stats
+ .queue_wait_ns
+ .fetch_add(send_started.elapsed().as_nanos() as u64, Ordering::Relaxed);
+ }
+ self.reclaim_batch();
}
}
#[cfg(not(target_arch = "wasm32"))]
impl RenderSink for ThreadedSink {
fn exec(&mut self, action: GxAction) {
- let resets_scratch = action_resets_vertex_scratch(&action);
- let message = ActionMessage {
- action,
- vertices: self.pending_vertices(),
- };
+ #[cfg(feature = "gx-stats")]
+ self.stats.actions_sent.fetch_add(1, Ordering::Relaxed);
- self.work_tx
- .send(WorkerCommand::Action(message))
- .expect("render worker thread stopped");
+ let resets_scratch = action_resets_vertex_scratch(&action);
+ self.pending_actions.push(action);
if resets_scratch {
- self.scratch.clear();
- self.scratch_sent_len = 0;
+ self.send_reset_batch();
}
}
@@ -205,28 +300,64 @@ impl RenderSink for ThreadedSink {
mem1_len: ram.mem1.len(),
mem2_addr: ram.mem2.as_mut_ptr() as usize,
mem2_len: ram.mem2.len(),
+ batch: self.take_batch(false),
done_tx,
};
+ #[cfg(feature = "gx-stats")]
+ let drain_started = std::time::Instant::now();
self.work_tx
.send(WorkerCommand::DrainEfbCopies(request))
.expect("render worker thread stopped");
- done_rx.recv().expect("render worker thread stopped");
+ let batch = done_rx.recv().expect("render worker thread stopped");
+ #[cfg(feature = "gx-stats")]
+ {
+ self.stats.batches_sent.fetch_add(1, Ordering::Relaxed);
+ self.stats
+ .channel_high_water
+ .fetch_max(self.work_tx.len() as u64, Ordering::Relaxed);
+ self.stats
+ .efb_drain_wait_ns
+ .fetch_add(drain_started.elapsed().as_nanos() as u64, Ordering::Relaxed);
+ }
+ debug_assert!(batch.actions.is_empty());
+ self.pending_actions = batch.actions;
+ self.scratch = batch.vertices;
}
fn vertex_scratch(&mut self) -> &mut Vec<DrawVertex> {
+ self.reclaim_batch();
&mut self.scratch
}
fn take_draw_data(&mut self) -> Box<DrawData> {
+ self.reclaim_batch();
self.recycled_draw_data_rx.try_recv().unwrap_or_default()
}
+
+ fn render_stats(&self) -> gecko::host::RenderStats {
+ #[cfg(feature = "gx-stats")]
+ {
+ return self
+ .stats
+ .snapshot(self.work_tx.len(), self.work_tx.capacity().unwrap_or(0));
+ }
+
+ #[cfg(not(feature = "gx-stats"))]
+ gecko::host::RenderStats::default()
+ }
}
#[cfg(not(target_arch = "wasm32"))]
impl Drop for ThreadedSink {
fn drop(&mut self) {
if let Some(worker_thread) = self.worker_thread.take() {
+ if !self.pending_actions.is_empty() || !self.scratch.is_empty() {
+ let batch = self.take_batch(false);
+ let _ = self.work_tx.send(WorkerCommand::Actions(batch));
+ #[cfg(feature = "gx-stats")]
+ self.stats.batches_sent.fetch_add(1, Ordering::Relaxed);
+ }
let _ = self.work_tx.send(WorkerCommand::Shutdown);
if let Err(err) = worker_thread.join() {
tracing::error!(?err, "render worker thread panicked");
@@ -337,6 +468,8 @@ impl Renderer {
) -> (Self, ThreadedSink) {
let mut gx = GxRenderer::new(&device, &queue, surface_format, efb_scale);
gx.prewarm_pipeline_cache(&device);
+ #[cfg(feature = "gx-stats")]
+ let stats = gx.stats.clone();
// Initial shared output: the XFB texture (black until first PresentXfb).
let shared = Arc::new(Shared {
@@ -416,6 +549,7 @@ impl Renderer {
let (work_tx, work_rx) = crossbeam_channel::bounded(WORK_QUEUE_LIMIT);
let (recycled_draw_data_tx, recycled_draw_data_rx) = crossbeam_channel::unbounded();
+ let (recycled_batches_tx, recycled_batches_rx) = crossbeam_channel::unbounded();
let worker = RenderWorker {
gx,
device: device.clone(),
@@ -423,6 +557,7 @@ impl Renderer {
shared: shared.clone(),
frame_ready_cb: frame_ready_cb.clone(),
recycled_draw_data_tx,
+ recycled_batches_tx,
#[cfg(feature = "renderdoc-capture")]
renderdoc: renderdoc.clone(),
};
@@ -434,9 +569,12 @@ impl Renderer {
let sink = ThreadedSink {
work_tx,
recycled_draw_data_rx,
+ recycled_batches_rx,
+ #[cfg(feature = "gx-stats")]
+ stats,
worker_thread: Some(worker_thread),
+ pending_actions: Vec::new(),
scratch: Vec::new(),
- scratch_sent_len: 0,
};
let renderer = Renderer {
diff --git a/crates/gecko/src/flipper/gx/draw.rs b/crates/gecko/src/flipper/gx/draw.rs
index 325638e..4147b65 100644
--- a/crates/gecko/src/flipper/gx/draw.rs
+++ b/crates/gecko/src/flipper/gx/draw.rs
@@ -116,7 +116,7 @@ pub struct TextureDescriptor {
pub min_filter: MinFilter,
}
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Viewport {
pub x: f32,
pub y: f32,
@@ -139,7 +139,7 @@ impl Default for Viewport {
}
}
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Scissor {
pub x: u32,
pub y: u32,
diff --git a/crates/gecko/src/host.rs b/crates/gecko/src/host.rs
index 90ce0de..245d47f 100644
--- a/crates/gecko/src/host.rs
+++ b/crates/gecko/src/host.rs
@@ -227,6 +227,44 @@ pub struct LightData {
pub direction: [f32; 4],
}
+/// Cumulative renderer-side profiling counters. Backends that do not expose
+/// profiling data return the all-zero default through [`RenderSink`].
+#[derive(Clone, Copy, Debug, Default)]
+pub struct RenderStats {
+ pub actions_sent: u64,
+ pub batches_sent: u64,
+ pub channel_len: usize,
+ pub channel_cap: usize,
+ pub channel_high_water: usize,
+ pub queue_wait_ns: u64,
+ pub efb_drain_wait_ns: u64,
+ pub efb_drain_requests: u64,
+ pub efb_drain_nonempty: u64,
+ pub efb_writebacks: u64,
+ pub efb_writeback_cpu_ns: u64,
+ pub worker_batch_cpu_ns: u64,
+ pub draws_encoded: u64,
+ pub draw_render_passes: u64,
+ pub pipeline_changes: u64,
+ pub pipelines_created: u64,
+ pub pipeline_create_cpu_ns: u64,
+ pub shader_modules_created: u64,
+ pub shader_create_cpu_ns: u64,
+ pub bind_group_sets: u64,
+ pub bind_groups_created: u64,
+ pub bind_group_key_changes: u64,
+ pub frame_uniform_changes: u64,
+ pub draw_uniform_changes: u64,
+ pub vertex_stride_changes: u64,
+ pub potential_merged_draws: u64,
+ pub viewport_changes: u64,
+ pub scissor_changes: u64,
+ pub draw_pass_encode_ns: u64,
+ pub queue_submits: u64,
+ pub command_buffers_submitted: u64,
+ pub queue_submit_cpu_ns: u64,
+}
+
/// One-way sink for GX actions. The emulator pushes actions here.
pub trait RenderSink: Send {
/// Submit a single action.
@@ -254,6 +292,11 @@ pub trait RenderSink: Send {
fn take_draw_data(&mut self) -> Box<DrawData> {
Box::default()
}
+
+ /// Return a cheap, non-blocking snapshot of cumulative renderer metrics.
+ fn render_stats(&self) -> RenderStats {
+ RenderStats::default()
+ }
}
/// Swallows every action. Used by headless runners (tinybench, tinytracer)
diff --git a/crates/gecko/src/system.rs b/crates/gecko/src/system.rs
index 5239666..a5ac7ac 100644
--- a/crates/gecko/src/system.rs
+++ b/crates/gecko/src/system.rs
@@ -37,6 +37,14 @@ pub enum ExecutionMode {
Interpreter,
}
+#[cfg(feature = "gx-stats")]
+#[derive(Clone, Default)]
+struct GxStatsDumpState {
+ vsync_count: u64,
+ gx: crate::flipper::gx::GxStats,
+ render: crate::host::RenderStats,
+}
+
pub struct System<const SYSTEM: SystemId> {
pub vsync_pending: bool,
pub vi_present_seen_this_frame: bool,
@@ -88,6 +96,9 @@ pub struct System<const SYSTEM: SystemId> {
#[cfg(any(feature = "jit-stats", feature = "profile", feature = "gx-stats"))]
pub vsync_count: u64,
+ #[cfg(feature = "gx-stats")]
+ gx_stats_dump_state: Option<GxStatsDumpState>,
+
#[cfg(feature = "profile")]
pub pprof_config: Option<crate::profile::PprofConfig>,
@@ -142,6 +153,9 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {
#[cfg(any(feature = "jit-stats", feature = "profile", feature = "gx-stats"))]
vsync_count: 0,
+ #[cfg(feature = "gx-stats")]
+ gx_stats_dump_state: None,
+
#[cfg(feature = "profile")]
pprof_config: None,
@@ -377,7 +391,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {
}
#[cfg(feature = "gx-stats")]
- fn dump_gx_stats_if_due(&self) {
+ fn dump_gx_stats_if_due(&mut self) {
if !self.heatmap.enabled || self.heatmap.interval_frames == 0 {
return;
}
@@ -389,20 +403,32 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {
use std::io::Write;
let path = self.heatmap.out_dir.join("gx-stats.txt");
- let s = &self.gx.stats;
+ let s = self.gx.stats.clone();
let avg_draw_ns = if s.draw_calls > 0 {
s.create_draw_call_ns / s.draw_calls
} else {
0
};
- let actions_sent: u64 = 0;
- let channel_len: usize = 0;
- let channel_cap: usize = 0;
+ let render = self.render_sink.render_stats();
+ let presents = s.xfb_presents.max(1) as f64;
+ let previous = self.gx_stats_dump_state.clone().unwrap_or_default();
+ let delta = |current: u64, prior: u64| current.saturating_sub(prior);
+ let interval_vsyncs = delta(self.vsync_count, previous.vsync_count);
+ let interval_presents = delta(s.xfb_presents, previous.gx.xfb_presents);
+ let interval_divisor = interval_presents.max(1) as f64;
+ let interval_renderer_draws = delta(render.draws_encoded, previous.render.draws_encoded);
+ let interval_potential_draws = delta(render.potential_merged_draws, previous.render.potential_merged_draws);
+ let interval_reduction_pct = interval_renderer_draws.saturating_sub(interval_potential_draws) as f64
+ / interval_renderer_draws.max(1) as f64
+ * 100.0;
+ let cumulative_reduction_pct = render.draws_encoded.saturating_sub(render.potential_merged_draws) as f64
+ / render.draws_encoded.max(1) as f64
+ * 100.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={}\nrender_actions_sent={}\nrender_channel_len={}\nrender_channel_cap={}",
+ "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_batches_sent={}\nrender_channel_len={}\nrender_channel_cap={}\nrender_channel_high_water={}\nrender_queue_wait_ns={}\nrender_efb_drain_wait_ns={}\nrender_efb_drain_requests={}\nrender_efb_drain_nonempty={}\nrender_efb_writebacks={}\nrender_efb_writeback_cpu_ns={}\nrender_worker_batch_cpu_ns={}\nrender_draws_encoded={}\nrender_draw_passes={}\nrender_pipeline_changes={}\nrender_pipelines_created={}\nrender_pipeline_create_cpu_ns={}\nrender_shader_modules_created={}\nrender_shader_create_cpu_ns={}\nrender_bind_group_sets={}\nrender_bind_groups_created={}\nrender_bind_group_key_changes={}\nrender_frame_uniform_changes={}\nrender_draw_uniform_changes={}\nrender_vertex_stride_changes={}\nrender_potential_merged_draws={}\nrender_viewport_changes={}\nrender_scissor_changes={}\nrender_draw_pass_encode_ns={}\nrender_queue_submits={}\nrender_command_buffers_submitted={}\nrender_queue_submit_cpu_ns={}",
self.vsync_count,
s.draw_calls,
s.vertices,
@@ -413,9 +439,118 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {
s.xf_writes,
s.create_draw_call_ns,
avg_draw_ns,
- actions_sent,
- channel_len,
- channel_cap,
+ render.actions_sent,
+ render.batches_sent,
+ render.channel_len,
+ render.channel_cap,
+ render.channel_high_water,
+ render.queue_wait_ns,
+ render.efb_drain_wait_ns,
+ render.efb_drain_requests,
+ render.efb_drain_nonempty,
+ render.efb_writebacks,
+ render.efb_writeback_cpu_ns,
+ render.worker_batch_cpu_ns,
+ render.draws_encoded,
+ render.draw_render_passes,
+ render.pipeline_changes,
+ render.pipelines_created,
+ render.pipeline_create_cpu_ns,
+ render.shader_modules_created,
+ render.shader_create_cpu_ns,
+ render.bind_group_sets,
+ render.bind_groups_created,
+ render.bind_group_key_changes,
+ render.frame_uniform_changes,
+ render.draw_uniform_changes,
+ render.vertex_stride_changes,
+ render.potential_merged_draws,
+ render.viewport_changes,
+ render.scissor_changes,
+ render.draw_pass_encode_ns,
+ render.queue_submits,
+ render.command_buffers_submitted,
+ render.queue_submit_cpu_ns,
+ )?;
+ writeln!(
+ f,
+ "\n--- last dump interval ---\nvsyncs={}\nxfb_presents={}\ndraw_calls={}\nvertices={}\nrenderer_draws={}\nactions={}\nbatches={}\ndraws_per_present={:.2}\nvertices_per_present={:.2}\ndraw_passes_per_present={:.2}\npipeline_changes_per_present={:.2}\npipelines_created_per_present={:.2}\npipeline_create_cpu_us_per_present={:.2}\nshader_modules_created_per_present={:.2}\nshader_create_cpu_us_per_present={:.2}\nbind_group_sets_per_present={:.2}\nbind_groups_created_per_present={:.2}\nbind_group_key_changes_per_present={:.2}\nframe_uniform_changes_per_present={:.2}\ndraw_uniform_changes_per_present={:.2}\nvertex_stride_changes_per_present={:.2}\npotential_merged_draws_per_present={:.2}\npotential_draw_reduction_pct={:.2}\nviewport_changes_per_present={:.2}\nscissor_changes_per_present={:.2}\ndraw_pass_encode_cpu_us_per_present={:.2}\nworker_cpu_us_per_present={:.2}\nqueue_wait_us_per_present={:.2}\nefb_drain_wait_us_per_present={:.2}\nefb_drain_requests_per_present={:.2}\nefb_drain_nonempty_per_present={:.2}\nefb_writebacks_per_present={:.2}\nefb_writeback_cpu_us_per_present={:.2}\nqueue_submit_cpu_us_per_present={:.2}",
+ interval_vsyncs,
+ interval_presents,
+ delta(s.draw_calls, previous.gx.draw_calls),
+ delta(s.vertices, previous.gx.vertices),
+ interval_renderer_draws,
+ delta(render.actions_sent, previous.render.actions_sent),
+ delta(render.batches_sent, previous.render.batches_sent),
+ delta(render.draws_encoded, previous.render.draws_encoded) as f64 / interval_divisor,
+ delta(s.vertices, previous.gx.vertices) as f64 / interval_divisor,
+ delta(render.draw_render_passes, previous.render.draw_render_passes) as f64 / interval_divisor,
+ delta(render.pipeline_changes, previous.render.pipeline_changes) as f64 / interval_divisor,
+ delta(render.pipelines_created, previous.render.pipelines_created) as f64 / interval_divisor,
+ delta(render.pipeline_create_cpu_ns, previous.render.pipeline_create_cpu_ns,) as f64
+ / interval_divisor
+ / 1_000.0,
+ delta(render.shader_modules_created, previous.render.shader_modules_created,) as f64 / interval_divisor,
+ delta(render.shader_create_cpu_ns, previous.render.shader_create_cpu_ns) as f64
+ / interval_divisor
+ / 1_000.0,
+ delta(render.bind_group_sets, previous.render.bind_group_sets) as f64 / interval_divisor,
+ delta(render.bind_groups_created, previous.render.bind_groups_created) as f64 / interval_divisor,
+ delta(render.bind_group_key_changes, previous.render.bind_group_key_changes,) as f64 / interval_divisor,
+ delta(render.frame_uniform_changes, previous.render.frame_uniform_changes,) as f64 / interval_divisor,
+ delta(render.draw_uniform_changes, previous.render.draw_uniform_changes,) as f64 / interval_divisor,
+ delta(render.vertex_stride_changes, previous.render.vertex_stride_changes,) as f64 / interval_divisor,
+ interval_potential_draws as f64 / interval_divisor,
+ interval_reduction_pct,
+ delta(render.viewport_changes, previous.render.viewport_changes) as f64 / interval_divisor,
+ delta(render.scissor_changes, previous.render.scissor_changes) as f64 / interval_divisor,
+ delta(render.draw_pass_encode_ns, previous.render.draw_pass_encode_ns) as f64
+ / interval_divisor
+ / 1_000.0,
+ delta(render.worker_batch_cpu_ns, previous.render.worker_batch_cpu_ns) as f64
+ / interval_divisor
+ / 1_000.0,
+ delta(render.queue_wait_ns, previous.render.queue_wait_ns) as f64 / interval_divisor / 1_000.0,
+ delta(render.efb_drain_wait_ns, previous.render.efb_drain_wait_ns) as f64 / interval_divisor / 1_000.0,
+ delta(render.efb_drain_requests, previous.render.efb_drain_requests) as f64 / interval_divisor,
+ delta(render.efb_drain_nonempty, previous.render.efb_drain_nonempty) as f64 / interval_divisor,
+ delta(render.efb_writebacks, previous.render.efb_writebacks) as f64 / interval_divisor,
+ delta(render.efb_writeback_cpu_ns, previous.render.efb_writeback_cpu_ns) as f64
+ / interval_divisor
+ / 1_000.0,
+ delta(render.queue_submit_cpu_ns, previous.render.queue_submit_cpu_ns) as f64
+ / interval_divisor
+ / 1_000.0,
+ )?;
+ writeln!(
+ f,
+ "\n--- renderer averages per XFB present ---\ndraws={:.2}\ndraw_passes={:.2}\npipeline_changes={:.2}\npipelines_created={:.2}\npipeline_create_cpu_us={:.2}\nshader_modules_created={:.2}\nshader_create_cpu_us={:.2}\nbind_group_sets={:.2}\nbind_groups_created={:.2}\nbind_group_key_changes={:.2}\nframe_uniform_changes={:.2}\ndraw_uniform_changes={:.2}\nvertex_stride_changes={:.2}\npotential_merged_draws={:.2}\npotential_draw_reduction_pct={:.2}\nviewport_changes={:.2}\nscissor_changes={:.2}\ndraw_pass_encode_cpu_us={:.2}\nworker_cpu_us={:.2}\nqueue_wait_us={:.2}\nefb_drain_wait_us={:.2}\nefb_drain_requests={:.2}\nefb_drain_nonempty={:.2}\nefb_writebacks={:.2}\nefb_writeback_cpu_us={:.2}\nqueue_submit_cpu_us={:.2}",
+ render.draws_encoded as f64 / presents,
+ render.draw_render_passes as f64 / presents,
+ render.pipeline_changes as f64 / presents,
+ render.pipelines_created as f64 / presents,
+ render.pipeline_create_cpu_ns as f64 / presents / 1_000.0,
+ render.shader_modules_created as f64 / presents,
+ render.shader_create_cpu_ns as f64 / presents / 1_000.0,
+ render.bind_group_sets as f64 / presents,
+ render.bind_groups_created as f64 / presents,
+ render.bind_group_key_changes as f64 / presents,
+ render.frame_uniform_changes as f64 / presents,
+ render.draw_uniform_changes as f64 / presents,
+ render.vertex_stride_changes as f64 / presents,
+ render.potential_merged_draws as f64 / presents,
+ cumulative_reduction_pct,
+ render.viewport_changes as f64 / presents,
+ render.scissor_changes as f64 / presents,
+ render.draw_pass_encode_ns as f64 / presents / 1_000.0,
+ render.worker_batch_cpu_ns as f64 / presents / 1_000.0,
+ render.queue_wait_ns as f64 / presents / 1_000.0,
+ render.efb_drain_wait_ns as f64 / presents / 1_000.0,
+ render.efb_drain_requests as f64 / presents,
+ render.efb_drain_nonempty as f64 / presents,
+ render.efb_writebacks as f64 / presents,
+ render.efb_writeback_cpu_ns as f64 / presents / 1_000.0,
+ render.queue_submit_cpu_ns as f64 / presents / 1_000.0,
)?;
writeln!(f, "\n--- draws by primitive ---")?;
@@ -440,7 +575,13 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {
});
if let Err(err) = result {
- tracing::warn!(?err, "gx-stats sidecar write failed");
+ tracing::warn!(?err, "gx-stats write failed");
+ } else {
+ self.gx_stats_dump_state = Some(GxStatsDumpState {
+ vsync_count: self.vsync_count,
+ gx: s,
+ render,
+ });
}
}
@@ -468,11 +609,11 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {
}
#[cfg(feature = "jit")]
- self.dump_idle_skip_sidecar();
+ self.dump_idle_skip();
}
#[cfg(all(feature = "jit-stats", feature = "jit"))]
- fn dump_idle_skip_sidecar(&self) {
+ fn dump_idle_skip(&self) {
use std::io::Write;
use std::sync::atomic::Ordering;
@@ -561,7 +702,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {
Ok(())
});
if let Err(err) = result {
- tracing::warn!(?err, "idle-skip sidecar write failed");
+ tracing::warn!(?err, "idle-skip write failed");
}
}
diff --git a/crates/tinyapp/Cargo.toml b/crates/tinyapp/Cargo.toml
index 28e382c..e57feba 100644
--- a/crates/tinyapp/Cargo.toml
+++ b/crates/tinyapp/Cargo.toml
@@ -11,7 +11,7 @@ renderdoc-capture = ["backend-wgpu/renderdoc-capture"]
audio-wav-dump = ["gecko/audio-wav-dump"]
fps-counter = ["gecko/fps-counter"]
jit-stats = ["gecko/jit-stats"]
-gx-stats = ["gecko/gx-stats"]
+gx-stats = ["gecko/gx-stats", "backend-wgpu/gx-stats"]
profile = ["gecko/profile"]
hotpath = ["dep:hotpath", "gecko/hotpath", "backend-wgpu/hotpath"]
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
diff --git a/crates/tinyapp/src/main.rs b/crates/tinyapp/src/main.rs
index 45a0a9c..b27b594 100644
--- a/crates/tinyapp/src/main.rs
+++ b/crates/tinyapp/src/main.rs
@@ -121,23 +121,23 @@ struct Args {
#[arg(long)]
no_cap: bool,
- /// Enable per-block JIT heatmap CSV dumps (requires --features jit-stats)
- #[cfg(feature = "jit-stats")]
+ /// Enable periodic profiling dumps.
+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]
#[arg(long)]
heatmap: bool,
/// Frames between heatmap CSV writes
- #[cfg(feature = "jit-stats")]
+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]
#[arg(long, default_value_t = 60)]
heatmap_interval_frames: u32,
/// Output directory for heatmap CSV files
- #[cfg(feature = "jit-stats")]
+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]
#[arg(long, default_value = "./profile-dumps")]
heatmap_out: String,
/// Top-K rows per heatmap CSV
- #[cfg(feature = "jit-stats")]
+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]
#[arg(long, default_value_t = 64)]
heatmap_top_k: usize,
@@ -322,7 +322,7 @@ fn configure<const SYSTEM: SystemId>(emulator: &mut System<SYSTEM>, args: &Args)
emulator.apply_host_input(&HostInput::neutral_for(SYSTEM));
- #[cfg(feature = "jit-stats")]
+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]
{
emulator.heatmap = gecko::profile::HeatmapConfig {
enabled: args.heatmap,