Tune renderer rayon thresholds

Author: DoubleStyx

crates/renderide/src/passes/clustered_light.rs

@@ -143,7 +143,7 @@ impl ClusteredLightPass {
 
     /// Returns whether this pass should use CPU froxel assignment for the current view.
     fn should_use_cpu_froxel(&self, view_idx: usize, _stereo: bool, light_count: u32) -> bool {
-        view_idx == 0 && light_count >= AUTO_CPU_FROXEL_LIGHT_THRESHOLD
+        should_use_cpu_froxel_for_view(view_idx, light_count)
     }
 
     /// Selects and prepares the clustered-light work for the current graph view.
@@ -282,6 +282,11 @@ impl ClusteredLightPass {
     }
 }
 
+/// Returns whether a graph view should use CPU froxel assignment for clustered lights.
+fn should_use_cpu_froxel_for_view(view_idx: usize, light_count: u32) -> bool {
+    view_idx == 0 && light_count >= AUTO_CPU_FROXEL_LIGHT_THRESHOLD
+}
+
 impl ComputePass for ClusteredLightPass {
     fn name(&self) -> &str {
         "ClusteredLight"
@@ -352,3 +357,24 @@ impl ComputePass for ClusteredLightPass {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn cpu_froxel_auto_gate_uses_first_view_and_light_threshold() {
+        assert!(!should_use_cpu_froxel_for_view(
+            0,
+            AUTO_CPU_FROXEL_LIGHT_THRESHOLD - 1
+        ));
+        assert!(should_use_cpu_froxel_for_view(
+            0,
+            AUTO_CPU_FROXEL_LIGHT_THRESHOLD
+        ));
+        assert!(!should_use_cpu_froxel_for_view(
+            1,
+            AUTO_CPU_FROXEL_LIGHT_THRESHOLD
+        ));
+    }
+}

crates/renderide/src/passes/clustered_light/froxel_cpu.rs

@@ -15,13 +15,15 @@ use crate::world_mesh::cluster::{
 };
 
 /// Light count at which `Auto` mode starts considering CPU froxel assignment.
-pub(super) const AUTO_CPU_FROXEL_LIGHT_THRESHOLD: u32 = 128;
-const CPU_FROXEL_PARALLEL_MIN_LIGHTS: usize = 128;
-const CPU_FROXEL_LIGHT_CHUNK_SIZE: usize = 64;
+pub(super) const AUTO_CPU_FROXEL_LIGHT_THRESHOLD: u32 = 64;
+/// Light count at which CPU froxel assignment fans out across worker chunks.
+const CPU_FROXEL_PARALLEL_MIN_LIGHTS: usize = 64;
+/// Lights assigned to one CPU froxel worker chunk.
+const CPU_FROXEL_LIGHT_CHUNK_SIZE: usize = 32;
 /// Froxel count at which count merge, offset, and prefix work uses Rayon.
-const CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS: usize = 1_024;
+const CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS: usize = 512;
 /// Cluster-count stride for local prefix-sum chunks.
-const CPU_FROXEL_PREFIX_CHUNK_SIZE: usize = 1_024;
+const CPU_FROXEL_PREFIX_CHUNK_SIZE: usize = 512;
 
 /// Point light tag in [`GpuLight::light_type`].
 const LIGHT_TYPE_POINT: u32 = 0;
@@ -122,14 +124,26 @@ impl FroxelLightPlanner {
             return Some(CpuClusterAssignments::default());
         }
         let layouts = validated_eye_layouts(eye_params, clusters_per_eye)?;
-        if lights.len() >= CPU_FROXEL_PARALLEL_MIN_LIGHTS {
+        if should_parallelize_cpu_froxel_lights(lights.len()) {
             build_parallel(lights, eye_params, &layouts, clusters_per_eye)
         } else {
             build_serial(lights, eye_params, &layouts, clusters_per_eye)
         }
     }
 }
 
+/// Returns whether CPU froxel assignment should split light ranges over Rayon.
+#[inline]
+fn should_parallelize_cpu_froxel_lights(light_count: usize) -> bool {
+    light_count >= CPU_FROXEL_PARALLEL_MIN_LIGHTS
+}
+
+/// Returns whether CPU froxel prefix and merge helpers should use Rayon.
+#[inline]
+fn should_parallelize_cpu_froxel_prefix(cluster_count: usize) -> bool {
+    cluster_count >= CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS
+}
+
 fn validated_eye_layouts(
     eye_params: &[ClusterFrameParams],
     clusters_per_eye: u32,
@@ -281,7 +295,7 @@ fn merge_parallel_chunk_counts(
     chunks: &[CpuFroxelCountChunk],
     total_clusters: usize,
 ) -> (Vec<u32>, CpuFroxelStats) {
-    let counts = if total_clusters >= CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS {
+    let counts = if should_parallelize_cpu_froxel_prefix(total_clusters) {
         (0..total_clusters)
             .into_par_iter()
             .map(|cluster_id| {
@@ -312,7 +326,7 @@ fn build_parallel_chunk_offsets(
     total_clusters: usize,
 ) -> Vec<Vec<u32>> {
     let chunk_count = chunks.len();
-    if total_clusters >= CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS && chunk_count >= 2 {
+    if should_parallelize_cpu_froxel_prefix(total_clusters) && chunk_count >= 2 {
         let per_cluster_offsets = (0..total_clusters)
             .into_par_iter()
             .map(|cluster_id| {
@@ -639,7 +653,7 @@ fn assign_bounded_light(
 
 /// Converts per-froxel counts into compact `[offset, count]` rows.
 fn prefix_counts_to_ranges(counts: &[u32]) -> Option<(Vec<[u32; 2]>, usize)> {
-    if counts.len() >= CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS {
+    if should_parallelize_cpu_froxel_prefix(counts.len()) {
         return prefix_counts_to_ranges_parallel(counts);
     }
     prefix_counts_to_ranges_serial(counts)
@@ -809,6 +823,34 @@ mod tests {
         &assignments.indices[start..end]
     }
 
+    #[test]
+    fn cpu_froxel_light_parallel_gate_starts_at_two_chunks() {
+        assert_eq!(
+            CPU_FROXEL_PARALLEL_MIN_LIGHTS,
+            CPU_FROXEL_LIGHT_CHUNK_SIZE * 2
+        );
+        assert!(!should_parallelize_cpu_froxel_lights(
+            CPU_FROXEL_PARALLEL_MIN_LIGHTS - 1
+        ));
+        assert!(should_parallelize_cpu_froxel_lights(
+            CPU_FROXEL_PARALLEL_MIN_LIGHTS
+        ));
+    }
+
+    #[test]
+    fn cpu_froxel_prefix_parallel_gate_starts_at_prefix_chunk() {
+        assert_eq!(
+            CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS,
+            CPU_FROXEL_PREFIX_CHUNK_SIZE
+        );
+        assert!(!should_parallelize_cpu_froxel_prefix(
+            CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS - 1
+        ));
+        assert!(should_parallelize_cpu_froxel_prefix(
+            CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS
+        ));
+    }
+
     #[test]
     fn empty_lights_write_zero_ranges_without_indices() {
         let params = test_params();

crates/renderide/src/passes/mesh_deform.rs

@@ -116,7 +116,9 @@ struct MeshDeformDispatchCtx<'a> {
     head_output_transform: glam::Mat4,
 }
 
-const DEFORM_COLLECT_PARALLEL_MIN_RENDERERS: usize = 256;
+/// Renderer count above which deform work collection fans out across two 64-renderer chunks.
+const DEFORM_COLLECT_PARALLEL_MIN_RENDERERS: usize = 128;
+/// Renderer count assigned to one deform collection worker chunk.
 const DEFORM_COLLECT_RENDERER_CHUNK_SIZE: usize = 64;
 
 #[derive(Clone, Copy)]

crates/renderide/src/runtime/frame/extract.rs

@@ -466,10 +466,15 @@ pub(in crate::runtime) fn select_inner_parallelism(
 
 /// Prepared-draw count above which two outer-parallel views are allowed to keep inner chunk
 /// parallelism enabled. Below this, nested rayon scheduling usually costs more than it saves.
-const MIN_DRAWS_FOR_TWO_VIEW_INNER_PARALLELISM: usize = 512;
+///
+/// The gate is four prepared 64-draw chunks: enough independent work for two views without
+/// making small stereo frames recursively fan out.
+const MIN_DRAWS_FOR_TWO_VIEW_INNER_PARALLELISM: usize = 256;
 
 /// Estimated total prepared draws above which view-level parallel collection pays for itself.
-const MIN_TOTAL_DRAWS_FOR_PARALLEL_VIEW_COLLECTION: usize = 256;
+///
+/// Two views with one 64-draw chunk each can overlap cull and draw collection work.
+const MIN_TOTAL_DRAWS_FOR_PARALLEL_VIEW_COLLECTION: usize = 128;
 
 /// Refines the frame-level inner parallelism once the backend has built the prepared draw list.
 ///

crates/renderide/src/scene/lights/cache.rs

@@ -34,7 +34,9 @@ const LOCAL_LIGHT_PROPAGATION: Vec3 = Vec3::new(0.0, 0.0, 1.0);
 /// pass at the end of [`LightCache::fixup_for_transform_removals`].
 const DEAD_TRANSFORM_ID: usize = usize::MAX;
 /// Cached light count at which world-space light resolution uses Rayon.
-const LIGHT_RESOLVE_PARALLEL_MIN_LIGHTS: usize = 128;
+///
+/// Light resolution is math-heavy enough that two 32-light grains are a useful lower bound.
+const LIGHT_RESOLVE_PARALLEL_MIN_LIGHTS: usize = 64;
 
 /// Dense buffer-renderer entry. Position in the per-space [`Vec`] equals the host's
 /// `RenderableIndex`; the pointed-to [`LightData`] rows live in [`LightCache::buffers`] keyed by

crates/renderide/src/world_mesh/draw_prep/arrange.rs

@@ -13,7 +13,10 @@ use super::item::{WorldMeshDrawArrangementStats, WorldMeshDrawItem};
 use super::sort::sort_order_sensitive_draws;
 
 /// Draw count at which phase partitioning uses Rayon workers.
-const ARRANGE_PARALLEL_MIN_DRAWS: usize = 2_048;
+///
+/// Partitioning builds worker-local maps and then merges them, so this remains more conservative
+/// than simple per-renderer fan-out while still covering medium draw lists.
+const ARRANGE_PARALLEL_MIN_DRAWS: usize = 512;
 
 /// Key for one nontransparent bin.
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]

crates/renderide/src/world_mesh/draw_prep/prepared_renderables/expand.rs

@@ -31,8 +31,10 @@ const MATERIAL_KEY_SIGNATURE_OFFSET: u64 = 0xcbf2_9ce4_8422_2325;
 const MATERIAL_KEY_SIGNATURE_PRIME: u64 = 0x0000_0100_0000_01b3;
 
 /// Renderer count in one render space above which expansion fans out across Rayon chunks.
+///
+/// Two 64-renderer chunks provide real worker fan-out without waiting for very large spaces.
 #[cfg(test)]
-pub(in crate::world_mesh::draw_prep) const PREPARED_EXPAND_PARALLEL_MIN_RENDERERS: usize = 256;
+pub(in crate::world_mesh::draw_prep) const PREPARED_EXPAND_PARALLEL_MIN_RENDERERS: usize = 128;
 /// Renderer slice width used by aggressive prepared-renderable expansion.
 #[cfg(test)]
 pub(in crate::world_mesh::draw_prep) const PREPARED_EXPAND_RENDERER_CHUNK_SIZE: usize = 64;

crates/renderide/src/world_mesh/draw_prep/render_world.rs

@@ -29,7 +29,9 @@ const DIRTY_SPACE_REFRESH_PARALLEL_MIN_SPACES: usize = 2;
 /// Active render-space count required before snapshot rebuild fan-out is considered.
 const SNAPSHOT_REBUILD_PARALLEL_MIN_SPACES: usize = 2;
 /// Retained draw-template count required before snapshot rebuild fan-out is considered.
-const SNAPSHOT_REBUILD_PARALLEL_MIN_DRAWS: usize = 512;
+///
+/// Snapshot rebuild fans out by render space, so the draw gate only filters tiny two-space cases.
+const SNAPSHOT_REBUILD_PARALLEL_MIN_DRAWS: usize = 256;
 
 /// Maintenance counters for backend-owned retained render-world caches.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]

crates/renderide/src/world_mesh/draw_prep/render_world/refresh.rs

@@ -13,7 +13,9 @@ use super::super::prepared_renderables::{
 use super::state::{RenderWorldRendererRef, RenderWorldRendererTemplate, RenderWorldSpace};
 
 /// Renderer count above which retained-template refresh uses Rayon.
-const RENDER_WORLD_PARALLEL_MIN_RENDERERS: usize = 256;
+///
+/// Two 64-renderer chunks are enough independent retained-table work to cover dispatch overhead.
+const RENDER_WORLD_PARALLEL_MIN_RENDERERS: usize = 128;
 
 /// Records per worker chunk when refreshing dense retained renderer tables.
 const RENDER_WORLD_REFRESH_CHUNK_SIZE: usize = 64;

crates/renderide/src/world_mesh/draw_prep/render_world/state.rs

@@ -10,9 +10,11 @@ use crate::scene::{
 use super::super::prepared_renderables::{FramePreparedDraw, FramePreparedRenderables};
 
 /// Renderer count at which reverse-index rebuilds use worker-local indexes.
-const REVERSE_INDEX_PARALLEL_MIN_RENDERERS: usize = 256;
+///
+/// Reverse-index rebuilds merge worker-local maps, so they start at two 64-renderer chunks.
+const REVERSE_INDEX_PARALLEL_MIN_RENDERERS: usize = 128;
 /// Renderer count assigned to one reverse-index worker chunk.
-const REVERSE_INDEX_PARALLEL_CHUNK_RENDERERS: usize = 128;
+const REVERSE_INDEX_PARALLEL_CHUNK_RENDERERS: usize = 64;
 
 /// Retained draw-template storage for one render space.
 #[derive(Default)]