Normalize renderer rayon thresholds

Author: DoubleStyx

crates/renderide-test/src/scene_dsl/suite.rs

@@ -139,13 +139,21 @@ fn run_suite_with(
         .map_err(|e| HarnessError::QueueOptions(format!("build suite thread pool: {e}")))?;
 
     let runner = &config.runner;
-    let case_reports = pool.install(|| {
+    let case_reports = if jobs >= 2 && config.cases.len() >= 2 {
+        pool.install(|| {
+            config
+                .cases
+                .par_iter()
+                .map(|case| run_case(case, runner))
+                .collect::<Vec<_>>()
+        })
+    } else {
         config
             .cases
-            .par_iter()
+            .iter()
             .map(|case| run_case(case, runner))
             .collect::<Vec<_>>()
-    });
+    };
 
     let report = SuiteReport::from_cases(case_reports);
     let report_path = write_suite_report(&config.runner.output_root, &report)?;

crates/renderide/src/assets/mesh/gpu_mesh/tangent_generation.rs

@@ -22,11 +22,14 @@ const DEFAULT_TANGENT: [f32; 4] = [1.0, 0.0, 0.0, 1.0];
 const DEFAULT_TANGENT_VEC: Vec4 = Vec4::new(1.0, 0.0, 0.0, 1.0);
 const DEFAULT_RAW_TANGENT_PAYLOAD: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
 const TANGENT_EPSILON_SQUARED: f32 = 1.0e-20;
+/// Vertices assigned to one tangent extraction or encoding worker chunk.
+const VERTEX_STREAM_PARALLEL_CHUNK_VERTICES: usize = 512;
+
 /// Vertex count above which vertex-stream extraction and tangent encoding fan out across rayon.
 ///
-/// Production meshes cluster around 1k-8k vertices, so a threshold of 2048 lets medium avatar and
-/// prop meshes use the worker pool while tiny meshes stay serial.
-const VERTEX_STREAM_PARALLEL_MIN: usize = 1_024;
+/// Production meshes cluster around 1k-8k vertices, so a two-chunk threshold lets medium avatar
+/// and prop meshes use the worker pool while tiny meshes stay serial.
+const VERTEX_STREAM_PARALLEL_MIN: usize = VERTEX_STREAM_PARALLEL_CHUNK_VERTICES * 2;
 
 /// CPU-side mesh source used to extract or generate tangent streams.
 #[derive(Copy, Clone)]
@@ -134,6 +137,7 @@ fn host_tangent_stream_bytes(
     };
     if vertex_count >= VERTEX_STREAM_PARALLEL_MIN {
         out.par_chunks_exact_mut(16)
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
             .enumerate()
             .for_each(|(vertex, slot)| copy_one(slot, vertex));
     } else {
@@ -231,7 +235,11 @@ fn read_vertex_stream3(
             .unwrap_or(Vec3::ZERO)
     };
     let out: Vec<Vec3> = if vertex_count >= VERTEX_STREAM_PARALLEL_MIN {
-        (0..vertex_count).into_par_iter().map(read_one).collect()
+        (0..vertex_count)
+            .into_par_iter()
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
+            .map(read_one)
+            .collect()
     } else {
         (0..vertex_count).map(read_one).collect()
     };
@@ -255,7 +263,11 @@ fn read_vertex_stream2(
             .unwrap_or(Vec2::ZERO)
     };
     let out: Vec<Vec2> = if vertex_count >= VERTEX_STREAM_PARALLEL_MIN {
-        (0..vertex_count).into_par_iter().map(read_one).collect()
+        (0..vertex_count)
+            .into_par_iter()
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
+            .map(read_one)
+            .collect()
     } else {
         (0..vertex_count).map(read_one).collect()
     };
@@ -337,7 +349,12 @@ fn encode_tangents(tangents: &[Vec4]) -> Vec<u8> {
     };
     if tangents.len() >= VERTEX_STREAM_PARALLEL_MIN {
         out.par_chunks_exact_mut(16)
-            .zip(tangents.par_iter())
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
+            .zip(
+                tangents
+                    .par_iter()
+                    .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES),
+            )
             .for_each(|(slot, tangent)| write_one(slot, tangent));
     } else {
         for (slot, tangent) in out.chunks_exact_mut(16).zip(tangents.iter()) {

crates/renderide/src/assets/mesh/layout/streams.rs

@@ -7,8 +7,10 @@ use crate::shared::{VertexAttributeDescriptor, VertexAttributeFormat, VertexAttr
 use super::super::gpu_mesh::attribute_reader::AttributeReader;
 use super::buffer_layout::vertex_format_size;
 
+/// Vertices assigned to one stream expansion worker chunk.
+const VERTEX_STREAM_PARALLEL_CHUNK_VERTICES: usize = 512;
 /// Vertex count above which stream expansion fans out across Rayon workers.
-const VERTEX_STREAM_PARALLEL_MIN: usize = 1_024;
+const VERTEX_STREAM_PARALLEL_MIN: usize = VERTEX_STREAM_PARALLEL_CHUNK_VERTICES * 2;
 
 /// Host UV channels exposed through the mesh-forward vertex path.
 pub const UV_VERTEX_ATTRIBUTE_TYPES: [VertexAttributeType; 8] = [
@@ -98,7 +100,12 @@ pub fn extract_float3_position_normal_as_vec4_streams(
     if should_parallelize_vertex_stream(vertex_count) {
         pos_out
             .par_chunks_exact_mut(16)
-            .zip(nrm_out.par_chunks_exact_mut(16))
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
+            .zip(
+                nrm_out
+                    .par_chunks_exact_mut(16)
+                    .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES),
+            )
             .enumerate()
             .try_for_each(|(i, (pos_slot, nrm_slot))| {
                 write_position_normal_vertex(
@@ -163,7 +170,9 @@ fn fill_normal_stream_with_forward_z(out: &mut [u8]) {
         chunk[12..16].copy_from_slice(&zero);
     };
     if should_parallelize_vertex_stream(out.len() / 16) {
-        out.par_chunks_exact_mut(16).for_each(write_chunk);
+        out.par_chunks_exact_mut(16)
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
+            .for_each(write_chunk);
     } else {
         out.chunks_exact_mut(16).for_each(write_chunk);
     }
@@ -220,6 +229,7 @@ pub fn vertex_float2_stream_bytes(
     };
     if should_parallelize_vertex_stream(vertex_count) {
         out.par_chunks_exact_mut(8)
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
             .enumerate()
             .try_for_each(|(i, slot)| write_vertex_float2(&reader, i, slot))?;
     } else {
@@ -269,6 +279,7 @@ pub fn wide_uv_stream_bytes(
 
     if should_parallelize_vertex_stream(vertex_count) {
         out.par_chunks_exact_mut(WIDE_UV_VERTEX_STRIDE_BYTES)
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
             .enumerate()
             .try_for_each(|(vertex, slot)| write_wide_uv_vertex(&readers, vertex, slot))?;
     } else {
@@ -327,6 +338,7 @@ fn vertex_float4_stream_bytes_with_kind(
     };
     if should_parallelize_vertex_stream(vertex_count) {
         out.par_chunks_exact_mut(16)
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
             .enumerate()
             .try_for_each(|(i, slot)| write_vertex_float4(&reader, i, slot, default))?;
     } else {
@@ -428,6 +440,7 @@ pub fn color_float4_stream_bytes(
 
     if should_parallelize_vertex_stream(vertex_count) {
         out.par_chunks_exact_mut(16)
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
             .enumerate()
             .try_for_each(|(i, slot)| write_vertex_float4(&reader, i, slot, [1.0; 4]))?;
     } else {
@@ -448,7 +461,9 @@ fn fill_float4_stream_with_default(out: &mut [u8], default: [f32; 4]) {
         }
     };
     if should_parallelize_vertex_stream(out.len() / 16) {
-        out.par_chunks_exact_mut(16).for_each(write_chunk);
+        out.par_chunks_exact_mut(16)
+            .with_min_len(VERTEX_STREAM_PARALLEL_CHUNK_VERTICES)
+            .for_each(write_chunk);
     } else {
         out.chunks_exact_mut(16).for_each(write_chunk);
     }

crates/renderide/src/assets/texture/upload/write_mip_chain/conversion.rs

@@ -11,11 +11,17 @@ use super::super::mip_write_common::{
     mip_src_to_upload_pixels as shared_mip_src_to_upload_pixels,
 };
 
-const DOWNSAMPLE_PARALLEL_MIN_TEXELS: usize = 8_192;
+/// Destination texels assigned to one downsample worker chunk.
+const DOWNSAMPLE_PARALLEL_CHUNK_TEXELS: usize = 4_096;
+/// Destination texel count above which downsampling may use Rayon.
+const DOWNSAMPLE_PARALLEL_MIN_TEXELS: usize = DOWNSAMPLE_PARALLEL_CHUNK_TEXELS * 2;
+/// Destination rows required before row-parallel downsampling can produce multiple chunks.
+const DOWNSAMPLE_PARALLEL_MIN_ROWS: usize = 2;
 
 #[inline]
 fn should_parallelize_downsample(dst_w: usize, dst_h: usize) -> bool {
-    dst_w.saturating_mul(dst_h) >= DOWNSAMPLE_PARALLEL_MIN_TEXELS
+    dst_h >= DOWNSAMPLE_PARALLEL_MIN_ROWS
+        && dst_w.saturating_mul(dst_h) >= DOWNSAMPLE_PARALLEL_MIN_TEXELS
 }
 
 /// Converts host mip bytes into a buffer suitable for [`write_one_mip`] (decode, optional row flip).

crates/renderide/src/mesh_deform/per_draw_uniforms.rs

@@ -148,12 +148,13 @@ impl PaddedPerDrawUniforms {
     }
 }
 
+/// Draw slots assigned to one slab-copy worker chunk.
+const PER_DRAW_SLAB_PARALLEL_CHUNK_SLOTS: usize = 64;
 /// Slot count above which slab writes fan out to a rayon worker pool.
 ///
-/// Each slot is a 256-byte copy. At 256 slots the slab is already 64 KiB, large enough for
+/// Each slot is a 256-byte copy. Two 64-slot chunks make the slab large enough for
 /// memory-bandwidth fan-out to pay off on typical desktop CPUs.
-const PER_DRAW_SLAB_PARALLEL_MIN: usize = 256;
-const PER_DRAW_SLAB_PARALLEL_CHUNK_SLOTS: usize = 64;
+const PER_DRAW_SLAB_PARALLEL_MIN: usize = PER_DRAW_SLAB_PARALLEL_CHUNK_SLOTS * 2;
 
 /// Writes `count` consecutive [`PaddedPerDrawUniforms`] into `out` (must be `count * 256` bytes).
 ///

crates/renderide/src/mesh_deform/skinning_palette.rs

@@ -6,11 +6,13 @@ use rayon::prelude::*;
 use crate::scene::{RenderSpaceId, SceneCoordinator};
 use crate::shared::RenderingContext;
 
+/// Bone count assigned to one palette construction worker chunk.
+const SKINNING_PALETTE_PARALLEL_CHUNK_BONES: usize = 64;
 /// Bone count above which palette construction fans out across rayon.
 ///
-/// Per-bone work is one world lookup plus a Mat4 multiply, so medium skinned meshes can amortize
-/// worker dispatch once the palette reaches a few hundred bones.
-const SKINNING_PALETTE_PARALLEL_MIN: usize = 128;
+/// Per-bone work is one world lookup plus a Mat4 multiply, so two chunks are enough to amortize
+/// worker dispatch once the palette reaches medium sizes.
+const SKINNING_PALETTE_PARALLEL_MIN: usize = SKINNING_PALETTE_PARALLEL_CHUNK_BONES * 2;
 
 /// Bytes per column-major `mat4<f32>` slot in the GPU-facing palette buffer.
 const PALETTE_BONE_BYTES: usize = 64;
@@ -104,6 +106,7 @@ pub fn build_skinning_palette(params: SkinningPaletteParams<'_>) -> Option<Vec<M
         params
             .skinning_bind_matrices
             .par_iter()
+            .with_min_len(SKINNING_PALETTE_PARALLEL_CHUNK_BONES)
             .enumerate()
             .map(|(bi, bind_mat)| resolver.matrix(bi, bind_mat))
             .collect()
@@ -146,7 +149,14 @@ pub fn write_skinning_palette_bytes(
             out.set_len(total_bytes);
         }
         out.par_chunks_exact_mut(PALETTE_BONE_BYTES)
-            .zip(params.skinning_bind_matrices.par_iter().enumerate())
+            .with_min_len(SKINNING_PALETTE_PARALLEL_CHUNK_BONES)
+            .zip(
+                params
+                    .skinning_bind_matrices
+                    .par_iter()
+                    .with_min_len(SKINNING_PALETTE_PARALLEL_CHUNK_BONES)
+                    .enumerate(),
+            )
             .for_each(|(slot, (bi, bind_mat))| {
                 let pal = resolver.matrix(bi, bind_mat);
                 slot.copy_from_slice(bytemuck::cast_slice(&pal.to_cols_array()));

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

@@ -16,14 +16,14 @@ 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 = 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 = 512;
+/// Light count at which CPU froxel assignment fans out across worker chunks.
+const CPU_FROXEL_PARALLEL_MIN_LIGHTS: usize = CPU_FROXEL_LIGHT_CHUNK_SIZE * 2;
 /// Cluster-count stride for local prefix-sum chunks.
-const CPU_FROXEL_PREFIX_CHUNK_SIZE: usize = 512;
+const CPU_FROXEL_PREFIX_CHUNK_SIZE: usize = 256;
+/// Froxel count at which count merge, offset, and prefix work uses Rayon.
+const CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS: usize = CPU_FROXEL_PREFIX_CHUNK_SIZE * 2;
 
 /// Point light tag in [`GpuLight::light_type`].
 const LIGHT_TYPE_POINT: u32 = 0;
@@ -298,6 +298,7 @@ fn merge_parallel_chunk_counts(
     let counts = if should_parallelize_cpu_froxel_prefix(total_clusters) {
         (0..total_clusters)
             .into_par_iter()
+            .with_min_len(CPU_FROXEL_PREFIX_CHUNK_SIZE)
             .map(|cluster_id| {
                 chunks.iter().fold(0u32, |total, chunk| {
                     total.saturating_add(chunk.counts[cluster_id])
@@ -329,6 +330,7 @@ fn build_parallel_chunk_offsets(
     if should_parallelize_cpu_froxel_prefix(total_clusters) && chunk_count >= 2 {
         let per_cluster_offsets = (0..total_clusters)
             .into_par_iter()
+            .with_min_len(CPU_FROXEL_PREFIX_CHUNK_SIZE)
             .map(|cluster_id| {
                 let mut next = ranges[cluster_id][0];
                 chunks
@@ -841,7 +843,7 @@ mod tests {
     fn cpu_froxel_prefix_parallel_gate_starts_at_prefix_chunk() {
         assert_eq!(
             CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS,
-            CPU_FROXEL_PREFIX_CHUNK_SIZE
+            CPU_FROXEL_PREFIX_CHUNK_SIZE * 2
         );
         assert!(!should_parallelize_cpu_froxel_prefix(
             CPU_FROXEL_PREFIX_PARALLEL_MIN_CLUSTERS - 1

crates/renderide/src/passes/mesh_deform.rs

@@ -116,10 +116,10 @@ struct MeshDeformDispatchCtx<'a> {
     head_output_transform: glam::Mat4,
 }
 
-/// 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;
+/// Renderer count above which deform work collection fans out across two chunks.
+const DEFORM_COLLECT_PARALLEL_MIN_RENDERERS: usize = DEFORM_COLLECT_RENDERER_CHUNK_SIZE * 2;
 
 #[derive(Clone, Copy)]
 enum DeformCollectChunkKind {

crates/renderide/src/passes/world_mesh_forward/slab.rs

@@ -16,12 +16,10 @@ use crate::world_mesh::draw_prep::WorldMeshDrawItem;
 
 use super::vp::compute_per_draw_vp_matrices;
 
-/// Minimum draws before parallelizing per-draw VP / model uniform packing (rayon overhead).
-///
-/// Each draw performs scene lookups and matrix packing, so medium draw lists can amortize worker
-/// dispatch earlier than the raw slab copy path.
-const PER_DRAW_VP_PARALLEL_MIN_DRAWS: usize = 128;
+/// Draws assigned to one per-draw VP / model uniform packing worker chunk.
 const PER_DRAW_VP_PARALLEL_CHUNK_DRAWS: usize = 64;
+/// Minimum draws before parallelizing per-draw VP / model uniform packing.
+const PER_DRAW_VP_PARALLEL_MIN_DRAWS: usize = PER_DRAW_VP_PARALLEL_CHUNK_DRAWS * 2;
 
 /// Per-frame inputs to [`pack_and_upload_per_draw_slab`].
 ///

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

@@ -464,17 +464,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.
+/// Prepared-draw count above which two outer-parallel views keep inner chunk parallelism enabled.
 ///
-/// 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;
+/// The gate is two prepared 64-draw chunks per view.
+const MIN_DRAWS_FOR_TWO_VIEW_INNER_PARALLELISM: usize = 128;
 
 /// Estimated total prepared draws above which view-level parallel collection pays for itself.
 ///
-/// 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;
+/// Two non-empty view chunks can overlap cull and draw collection work.
+const MIN_TOTAL_DRAWS_FOR_PARALLEL_VIEW_COLLECTION: usize = 2;
 
 /// Refines the frame-level inner parallelism once the backend has built the prepared draw list.
 ///