use crate::RenderError;
pub const RASTERIZE_TILE_SIZE: u32 = 16;
pub const RASTERIZER_STORAGE_BUFFERS_PER_STAGE: u32 = 16;
pub const RASTERIZE_FWD_WORKGROUP_STORAGE_BYTES: u32 = 17_408;
#[must_use]
pub fn rasterizer_device_limits(base: wgpu::Limits) -> wgpu::Limits {
wgpu::Limits {
max_storage_buffers_per_shader_stage: base
.max_storage_buffers_per_shader_stage
.max(RASTERIZER_STORAGE_BUFFERS_PER_STAGE),
max_compute_workgroup_storage_size: base
.max_compute_workgroup_storage_size
.max(RASTERIZE_FWD_WORKGROUP_STORAGE_BYTES),
..base
}
}
pub(super) fn check_rasterizer_limits(
limits: &wgpu::Limits,
what: &str,
) -> Result<(), RenderError> {
if limits.max_storage_buffers_per_shader_stage < RASTERIZER_STORAGE_BUFFERS_PER_STAGE {
return Err(RenderError::GpuInit(format!(
"{what} allows only {} storage buffers per shader stage, but the backward pass \
binds {RASTERIZER_STORAGE_BUFFERS_PER_STAGE}; build the device with \
oxigaf_render::rasterizer::rasterizer_device_limits(wgpu::Limits::default())",
limits.max_storage_buffers_per_shader_stage
)));
}
if limits.max_compute_workgroup_storage_size < RASTERIZE_FWD_WORKGROUP_STORAGE_BYTES {
return Err(RenderError::GpuInit(format!(
"{what} allows only {} bytes of compute workgroup storage, but rasterize_fwd.wgsl \
declares {RASTERIZE_FWD_WORKGROUP_STORAGE_BYTES}; build the device with \
oxigaf_render::rasterizer::rasterizer_device_limits(wgpu::Limits::default())",
limits.max_compute_workgroup_storage_size
)));
}
Ok(())
}
pub(super) fn check_linear_workgroup_size(
limits: &wgpu::Limits,
size: u32,
) -> Result<(), RenderError> {
let ceiling = limits
.max_compute_invocations_per_workgroup
.min(limits.max_compute_workgroup_size_x);
if size == 0 || size > ceiling {
return Err(RenderError::Rasterize(format!(
"RasterConfig's effective preprocess workgroup size {size} is outside the device's \
supported range 1..={ceiling}"
)));
}
if !size.is_power_of_two() {
return Err(RenderError::Rasterize(format!(
"RasterConfig's effective preprocess workgroup size {size} must be a power of two"
)));
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::RasterConfig;
use crate::workgroup::WorkgroupConfig;
fn wgsl_type_layout(name: &str) -> Option<(u32, u32)> {
Some(match name {
"u32" | "i32" | "f32" | "atomic<u32>" | "atomic<i32>" => (4, 4),
"vec2<u32>" | "vec2<i32>" | "vec2<f32>" => (8, 8),
"vec3<u32>" | "vec3<i32>" | "vec3<f32>" => (12, 16),
"vec4<u32>" | "vec4<i32>" | "vec4<f32>" => (16, 16),
_ => return None,
})
}
fn wgsl_workgroup_storage_bytes(src: &str) -> Option<u32> {
let mut offset: u32 = 0;
for line in src.lines() {
let Some(rest) = line.trim().strip_prefix("var<workgroup>") else {
continue;
};
let (_name, decl) = rest.split_once(':')?;
let decl = decl.trim().trim_end_matches(';').trim();
let inner = decl.strip_prefix("array<")?.strip_suffix('>')?;
let (elem, count) = inner.rsplit_once(',')?;
let count: u32 = count.trim().trim_end_matches('u').parse().ok()?;
let (size, align) = wgsl_type_layout(elem.trim())?;
let stride = size.next_multiple_of(align);
offset = offset.next_multiple_of(align) + stride * count;
}
Some(offset)
}
#[test]
fn test_rasterize_fwd_workgroup_storage_matches_shader() {
let src = include_str!("../../shaders/rasterize_fwd.wgsl");
let bytes = wgsl_workgroup_storage_bytes(src)
.expect("every var<workgroup> in rasterize_fwd.wgsl must be a recognised array type");
assert_eq!(
bytes, RASTERIZE_FWD_WORKGROUP_STORAGE_BYTES,
"rasterize_fwd.wgsl declares {bytes} bytes of workgroup storage but the constant says \
{RASTERIZE_FWD_WORKGROUP_STORAGE_BYTES}"
);
assert!(
bytes > wgpu::Limits::default().max_compute_workgroup_storage_size,
"this constant only exists because the shader exceeds the default limit"
);
}
#[test]
fn test_rasterizer_device_limits_raise_both_ceilings() {
let limits = rasterizer_device_limits(wgpu::Limits::default());
assert_eq!(
limits.max_storage_buffers_per_shader_stage,
RASTERIZER_STORAGE_BUFFERS_PER_STAGE
);
assert_eq!(
limits.max_compute_workgroup_storage_size,
RASTERIZE_FWD_WORKGROUP_STORAGE_BYTES
);
assert_eq!(
limits.max_buffer_size,
wgpu::Limits::default().max_buffer_size
);
}
#[test]
fn test_rasterizer_device_limits_never_lower_a_richer_base() {
let generous = wgpu::Limits {
max_storage_buffers_per_shader_stage: 64,
max_compute_workgroup_storage_size: 65_536,
..wgpu::Limits::default()
};
let limits = rasterizer_device_limits(generous);
assert_eq!(limits.max_storage_buffers_per_shader_stage, 64);
assert_eq!(limits.max_compute_workgroup_storage_size, 65_536);
}
#[test]
fn test_check_rasterizer_limits_rejects_defaults_and_accepts_raised() {
let err = check_rasterizer_limits(&wgpu::Limits::default(), "device")
.expect_err("default limits cannot host the rasterizer");
assert!(matches!(err, RenderError::GpuInit(_)));
check_rasterizer_limits(&rasterizer_device_limits(wgpu::Limits::default()), "device")
.expect("the limits Rasterizer::new requests must pass its own check");
}
#[test]
fn test_check_linear_workgroup_size_bounds() {
let limits = wgpu::Limits::default();
let ceiling = limits
.max_compute_invocations_per_workgroup
.min(limits.max_compute_workgroup_size_x);
for size in [32u32, 64, 128, 256] {
check_linear_workgroup_size(&limits, size)
.unwrap_or_else(|e| panic!("{size} threads must be accepted: {e}"));
}
assert!(check_linear_workgroup_size(&limits, 0).is_err());
assert!(check_linear_workgroup_size(&limits, ceiling + 1).is_err());
let msg = check_linear_workgroup_size(&limits, 48)
.expect_err("48 is not a power of two")
.to_string();
assert!(msg.contains("power of two"), "{msg}");
}
#[test]
fn test_every_gpu_preset_yields_a_usable_workgroup_size() {
use crate::config::GpuPreset;
let limits = wgpu::Limits::default();
for preset in [
GpuPreset::Auto,
GpuPreset::Nvidia,
GpuPreset::Amd,
GpuPreset::Apple,
GpuPreset::Intel,
GpuPreset::Generic,
] {
let config = RasterConfig::default().with_gpu_preset(preset);
let size = config.effective_preprocess_wg_size();
check_linear_workgroup_size(&limits, size)
.unwrap_or_else(|e| panic!("{preset:?} yields an unusable size {size}: {e}"));
WorkgroupConfig::for_linear_size(size)
.validate()
.unwrap_or_else(|e| panic!("{preset:?} yields an invalid config: {e}"));
}
}
#[test]
fn test_check_rasterizer_limits_names_the_failing_limit() {
let full = rasterizer_device_limits(wgpu::Limits::default());
let few_buffers = wgpu::Limits {
max_storage_buffers_per_shader_stage: 8,
..full.clone()
};
let msg = check_rasterizer_limits(&few_buffers, "device")
.expect_err("8 storage buffers is not enough")
.to_string();
assert!(msg.contains("storage buffers"), "{msg}");
let small_shared = wgpu::Limits {
max_compute_workgroup_storage_size: 16_384,
..full
};
let msg = check_rasterizer_limits(&small_shared, "adapter")
.expect_err("16 KiB of workgroup storage is not enough")
.to_string();
assert!(msg.contains("workgroup storage"), "{msg}");
assert!(msg.contains("adapter"), "{msg}");
}
}