use crate::buffers::PREFIX_SUM_BLOCK;
use crate::RenderError;
const RADIX_BITS: u32 = 4;
const NUM_BUCKETS: u32 = 1 << RADIX_BITS;
const SORT_WG_SIZE: u32 = 256;
const NUM_PASSES: u32 = 64 / RADIX_BITS;
fn radix_pass_count(num_tiles: u32) -> u32 {
let max_tile_id = num_tiles.saturating_sub(1);
let tile_bits = u32::BITS - max_tile_id.leading_zeros();
let key_bits = 32 + tile_bits;
let passes = key_bits.div_ceil(RADIX_BITS).min(NUM_PASSES);
if passes.is_multiple_of(2) {
passes
} else {
passes + 1
}
}
struct SortBuffers {
scratch_keys: wgpu::Buffer,
scratch_values: wgpu::Buffer,
histogram_buf: wgpu::Buffer,
histogram_prefix_buf: wgpu::Buffer,
hist_block_sums: wgpu::Buffer,
hist_block_sums_scanned: wgpu::Buffer,
hist_block_sums_l2: wgpu::Buffer,
hist_block_sums_l2_scanned: wgpu::Buffer,
}
struct SortBindGroups {
histogram: Vec<wgpu::BindGroup>,
scatter: Vec<wgpu::BindGroup>,
scan_l0: wgpu::BindGroup,
scan_l1: wgpu::BindGroup,
scan_l2: wgpu::BindGroup,
add_l1: wgpu::BindGroup,
add_l0: wgpu::BindGroup,
}
pub struct RadixSorter {
histogram_pipeline: wgpu::ComputePipeline,
scatter_pipeline: wgpu::ComputePipeline,
prefix_sum_pipeline: wgpu::ComputePipeline,
prefix_sum_add_pipeline: wgpu::ComputePipeline,
histogram_bgl: wgpu::BindGroupLayout,
scatter_bgl: wgpu::BindGroupLayout,
prefix_sum_bgl: wgpu::BindGroupLayout,
prefix_sum_add_bgl: wgpu::BindGroupLayout,
pub scratch_keys: wgpu::Buffer,
pub scratch_values: wgpu::Buffer,
pub histogram_buf: wgpu::Buffer,
pub histogram_prefix_buf: wgpu::Buffer,
pub hist_block_sums: wgpu::Buffer,
pub hist_block_sums_scanned: wgpu::Buffer,
pub hist_block_sums_l2: wgpu::Buffer,
pub hist_block_sums_l2_scanned: wgpu::Buffer,
dummy_block_sums: wgpu::Buffer,
pass_params: Vec<wgpu::Buffer>,
ps_params_count: wgpu::Buffer,
ps_params_wg: wgpu::Buffer,
ps_params_wg2: wgpu::Buffer,
bind_groups: Option<SortBindGroups>,
max_elements: u32,
}
impl RadixSorter {
pub fn new(device: &wgpu::Device, max_elements: u32) -> Result<Self, RenderError> {
let histogram_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("radix_histogram_bgl"),
entries: &[
bgl_entry(0, true), bgl_entry(1, false), uniform_bgl_entry(2), ],
});
let histogram_pipeline = compile_pipeline(
device,
"radix_histogram",
include_str!("../shaders/radix_histogram.wgsl"),
"radix_histogram",
&histogram_bgl,
)?;
let scatter_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("radix_scatter_bgl"),
entries: &[
bgl_entry(0, true), bgl_entry(1, true), bgl_entry(2, false), bgl_entry(3, false), bgl_entry(4, true), bgl_entry(5, true), uniform_bgl_entry(6), ],
});
let scatter_pipeline = compile_pipeline(
device,
"radix_scatter",
include_str!("../shaders/radix_scatter.wgsl"),
"radix_scatter",
&scatter_bgl,
)?;
let prefix_sum_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("sort_prefix_sum_bgl"),
entries: &[
bgl_entry(0, true), bgl_entry(1, false), uniform_bgl_entry(2), bgl_entry(3, false), ],
});
let prefix_sum_pipeline = compile_pipeline(
device,
"sort_prefix_sum",
include_str!("../shaders/prefix_sum.wgsl"),
"prefix_sum",
&prefix_sum_bgl,
)?;
let prefix_sum_add_bgl =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("sort_prefix_sum_add_bgl"),
entries: &[
bgl_entry(0, false), bgl_entry(1, true), uniform_bgl_entry(2), ],
});
let prefix_sum_add_pipeline = compile_pipeline(
device,
"sort_prefix_sum_add",
include_str!("../shaders/prefix_sum_add.wgsl"),
"prefix_sum_add",
&prefix_sum_add_bgl,
)?;
let max_elements = max_elements.max(1);
let bufs = allocate_sort_buffers(device, max_elements);
let dummy_block_sums = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_dummy_block_sums"),
size: (PREFIX_SUM_BLOCK as u64) * 4,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let uniform = wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST;
let pass_params: Vec<wgpu::Buffer> = (0..NUM_PASSES)
.map(|_| {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_pass_params"),
size: 16, usage: uniform,
mapped_at_creation: false,
})
})
.collect();
let ps_params_count = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_ps_params_count"),
size: 16,
usage: uniform,
mapped_at_creation: false,
});
let ps_params_wg = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_ps_params_wg"),
size: 16,
usage: uniform,
mapped_at_creation: false,
});
let ps_params_wg2 = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_ps_params_wg2"),
size: 16,
usage: uniform,
mapped_at_creation: false,
});
Ok(Self {
histogram_pipeline,
scatter_pipeline,
prefix_sum_pipeline,
prefix_sum_add_pipeline,
histogram_bgl,
scatter_bgl,
prefix_sum_bgl,
prefix_sum_add_bgl,
scratch_keys: bufs.scratch_keys,
scratch_values: bufs.scratch_values,
histogram_buf: bufs.histogram_buf,
histogram_prefix_buf: bufs.histogram_prefix_buf,
hist_block_sums: bufs.hist_block_sums,
hist_block_sums_scanned: bufs.hist_block_sums_scanned,
hist_block_sums_l2: bufs.hist_block_sums_l2,
hist_block_sums_l2_scanned: bufs.hist_block_sums_l2_scanned,
dummy_block_sums,
pass_params,
ps_params_count,
ps_params_wg,
ps_params_wg2,
bind_groups: None,
max_elements,
})
}
pub fn prepare(
&mut self,
device: &wgpu::Device,
keys: &wgpu::Buffer,
values: &wgpu::Buffer,
max_elements: u32,
) {
let max_elements = max_elements.max(1);
if max_elements > self.max_elements {
let bufs = allocate_sort_buffers(device, max_elements);
self.scratch_keys = bufs.scratch_keys;
self.scratch_values = bufs.scratch_values;
self.histogram_buf = bufs.histogram_buf;
self.histogram_prefix_buf = bufs.histogram_prefix_buf;
self.hist_block_sums = bufs.hist_block_sums;
self.hist_block_sums_scanned = bufs.hist_block_sums_scanned;
self.hist_block_sums_l2 = bufs.hist_block_sums_l2;
self.hist_block_sums_l2_scanned = bufs.hist_block_sums_l2_scanned;
tracing::debug!(
old_capacity = self.max_elements,
new_capacity = max_elements,
"Grew radix sorter scratch buffers"
);
self.max_elements = max_elements;
}
let bind_groups = self.build_bind_groups(device, keys, values);
self.bind_groups = Some(bind_groups);
}
fn build_bind_groups(
&self,
device: &wgpu::Device,
keys: &wgpu::Buffer,
values: &wgpu::Buffer,
) -> SortBindGroups {
let mut histogram = Vec::with_capacity(NUM_PASSES as usize);
let mut scatter = Vec::with_capacity(NUM_PASSES as usize);
for pass in 0..NUM_PASSES {
let (k_in, k_out, v_in, v_out) = if pass.is_multiple_of(2) {
(keys, &self.scratch_keys, values, &self.scratch_values)
} else {
(&self.scratch_keys, keys, &self.scratch_values, values)
};
let params = &self.pass_params[pass as usize];
histogram.push(device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("radix_histogram_bg"),
layout: &self.histogram_bgl,
entries: &[
bg_entry(0, k_in),
bg_entry(1, &self.histogram_buf),
bg_entry(2, params),
],
}));
scatter.push(device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("radix_scatter_bg"),
layout: &self.scatter_bgl,
entries: &[
bg_entry(0, k_in),
bg_entry(1, v_in),
bg_entry(2, k_out),
bg_entry(3, v_out),
bg_entry(4, &self.histogram_buf),
bg_entry(5, &self.histogram_prefix_buf),
bg_entry(6, params),
],
}));
}
let scan_l0 = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("hist_scan_l0_bg"),
layout: &self.prefix_sum_bgl,
entries: &[
bg_entry(0, &self.histogram_buf),
bg_entry(1, &self.histogram_prefix_buf),
bg_entry(2, &self.ps_params_count),
bg_entry(3, &self.hist_block_sums),
],
});
let scan_l1 = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("hist_scan_l1_bg"),
layout: &self.prefix_sum_bgl,
entries: &[
bg_entry(0, &self.hist_block_sums),
bg_entry(1, &self.hist_block_sums_scanned),
bg_entry(2, &self.ps_params_wg),
bg_entry(3, &self.hist_block_sums_l2),
],
});
let scan_l2 = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("hist_scan_l2_bg"),
layout: &self.prefix_sum_bgl,
entries: &[
bg_entry(0, &self.hist_block_sums_l2),
bg_entry(1, &self.hist_block_sums_l2_scanned),
bg_entry(2, &self.ps_params_wg2),
bg_entry(3, &self.dummy_block_sums),
],
});
let add_l1 = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("hist_add_l1_bg"),
layout: &self.prefix_sum_add_bgl,
entries: &[
bg_entry(0, &self.hist_block_sums_scanned),
bg_entry(1, &self.hist_block_sums_l2_scanned),
bg_entry(2, &self.ps_params_wg),
],
});
let add_l0 = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("hist_add_l0_bg"),
layout: &self.prefix_sum_add_bgl,
entries: &[
bg_entry(0, &self.histogram_prefix_buf),
bg_entry(1, &self.hist_block_sums_scanned),
bg_entry(2, &self.ps_params_count),
],
});
SortBindGroups {
histogram,
scatter,
scan_l0,
scan_l1,
scan_l2,
add_l1,
add_l0,
}
}
pub fn sort(
&self,
encoder: &mut wgpu::CommandEncoder,
queue: &wgpu::Queue,
count: u32,
num_tiles: u32,
) -> Result<(), RenderError> {
if count == 0 {
return Ok(());
}
if count > self.max_elements {
return Err(RenderError::TooManyTilePairs {
count,
allocated: self.max_elements,
});
}
let bgs = self.bind_groups.as_ref().ok_or_else(|| {
RenderError::Rasterize(
"RadixSorter::sort called before RadixSorter::prepare".to_string(),
)
})?;
let num_wg = count.div_ceil(SORT_WG_SIZE);
let histogram_count = NUM_BUCKETS * num_wg;
let ps_num_wg = histogram_count.div_ceil(PREFIX_SUM_BLOCK);
let ps_num_wg2 = ps_num_wg.div_ceil(PREFIX_SUM_BLOCK);
if ps_num_wg2 > PREFIX_SUM_BLOCK {
return Err(RenderError::Rasterize(format!(
"radix sort histogram for {count} elements needs more than three scan levels"
)));
}
let passes = radix_pass_count(num_tiles);
for pass in 0..passes {
queue.write_buffer(
&self.pass_params[pass as usize],
0,
bytemuck::cast_slice(&[count, pass, RADIX_BITS, num_wg]),
);
}
queue.write_buffer(
&self.ps_params_count,
0,
bytemuck::cast_slice(&[histogram_count, 0u32, 0u32, 0u32]),
);
queue.write_buffer(
&self.ps_params_wg,
0,
bytemuck::cast_slice(&[ps_num_wg, 0u32, 0u32, 0u32]),
);
queue.write_buffer(
&self.ps_params_wg2,
0,
bytemuck::cast_slice(&[ps_num_wg2, 0u32, 0u32, 0u32]),
);
for pass in 0..passes {
let p = pass as usize;
encoder.clear_buffer(&self.histogram_buf, 0, Some(u64::from(histogram_count) * 4));
{
let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("radix_histogram"),
timestamp_writes: None,
});
cpass.set_pipeline(&self.histogram_pipeline);
cpass.set_bind_group(0, &bgs.histogram[p], &[]);
cpass.dispatch_workgroups(num_wg, 1, 1);
}
{
let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("hist_scan_l0"),
timestamp_writes: None,
});
cpass.set_pipeline(&self.prefix_sum_pipeline);
cpass.set_bind_group(0, &bgs.scan_l0, &[]);
cpass.dispatch_workgroups(ps_num_wg, 1, 1);
}
if ps_num_wg > 1 {
{
let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("hist_scan_l1"),
timestamp_writes: None,
});
cpass.set_pipeline(&self.prefix_sum_pipeline);
cpass.set_bind_group(0, &bgs.scan_l1, &[]);
cpass.dispatch_workgroups(ps_num_wg2, 1, 1);
}
if ps_num_wg2 > 1 {
{
let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("hist_scan_l2"),
timestamp_writes: None,
});
cpass.set_pipeline(&self.prefix_sum_pipeline);
cpass.set_bind_group(0, &bgs.scan_l2, &[]);
cpass.dispatch_workgroups(1, 1, 1);
}
let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("hist_add_l1"),
timestamp_writes: None,
});
cpass.set_pipeline(&self.prefix_sum_add_pipeline);
cpass.set_bind_group(0, &bgs.add_l1, &[]);
cpass.dispatch_workgroups(ps_num_wg2, 1, 1);
}
let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("hist_add_l0"),
timestamp_writes: None,
});
cpass.set_pipeline(&self.prefix_sum_add_pipeline);
cpass.set_bind_group(0, &bgs.add_l0, &[]);
cpass.dispatch_workgroups(ps_num_wg, 1, 1);
}
{
let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("radix_scatter"),
timestamp_writes: None,
});
cpass.set_pipeline(&self.scatter_pipeline);
cpass.set_bind_group(0, &bgs.scatter[p], &[]);
cpass.dispatch_workgroups(num_wg, 1, 1);
}
}
Ok(())
}
pub fn capacity(&self) -> u32 {
self.max_elements
}
}
fn allocate_sort_buffers(device: &wgpu::Device, max_elements: u32) -> SortBuffers {
let storage = wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST;
let elements = max_elements.max(1);
let num_wg = elements.div_ceil(SORT_WG_SIZE).max(1);
let histogram_count = (NUM_BUCKETS * num_wg).max(NUM_BUCKETS);
let ps_wg = histogram_count.div_ceil(PREFIX_SUM_BLOCK).max(1);
let ps_wg2 = ps_wg.div_ceil(PREFIX_SUM_BLOCK).max(1);
let scratch_keys = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_scratch_keys"),
size: u64::from(elements) * 8,
usage: storage,
mapped_at_creation: false,
});
let scratch_values = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_scratch_values"),
size: u64::from(elements) * 4,
usage: storage,
mapped_at_creation: false,
});
let histogram_buf = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_histogram"),
size: u64::from(histogram_count) * 4,
usage: storage,
mapped_at_creation: false,
});
let histogram_prefix_buf = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_histogram_prefix"),
size: u64::from(histogram_count) * 4,
usage: storage,
mapped_at_creation: false,
});
let hist_block_sums = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_hist_block_sums"),
size: u64::from(ps_wg) * 4,
usage: storage,
mapped_at_creation: false,
});
let hist_block_sums_scanned = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_hist_block_sums_scanned"),
size: u64::from(ps_wg) * 4,
usage: storage,
mapped_at_creation: false,
});
let hist_block_sums_l2 = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_hist_block_sums_l2"),
size: u64::from(ps_wg2) * 4,
usage: storage,
mapped_at_creation: false,
});
let hist_block_sums_l2_scanned = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("sort_hist_block_sums_l2_scanned"),
size: u64::from(ps_wg2) * 4,
usage: storage,
mapped_at_creation: false,
});
SortBuffers {
scratch_keys,
scratch_values,
histogram_buf,
histogram_prefix_buf,
hist_block_sums,
hist_block_sums_scanned,
hist_block_sums_l2,
hist_block_sums_l2_scanned,
}
}
fn poll_ready_now<F: std::future::Future>(fut: F) -> Option<F::Output> {
use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
fn no_op(_: *const ()) {}
fn clone_raw(_: *const ()) -> RawWaker {
RawWaker::new(std::ptr::null(), &VTABLE)
}
static VTABLE: RawWakerVTable = RawWakerVTable::new(clone_raw, no_op, no_op, no_op);
let raw_waker = RawWaker::new(std::ptr::null(), &VTABLE);
let waker = unsafe { Waker::from_raw(raw_waker) };
let mut cx = Context::from_waker(&waker);
let mut boxed = Box::pin(fut);
match boxed.as_mut().poll(&mut cx) {
Poll::Ready(v) => Some(v),
Poll::Pending => None,
}
}
fn compile_pipeline(
device: &wgpu::Device,
label: &str,
source: &str,
entry_point: &str,
bgl: &wgpu::BindGroupLayout,
) -> Result<wgpu::ComputePipeline, RenderError> {
let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some(label),
source: wgpu::ShaderSource::Wgsl(source.into()),
});
if let Some(err) = poll_ready_now(scope.pop()).flatten() {
return Err(RenderError::ShaderCompilation {
shader_name: label.to_string(),
error: err.to_string(),
});
}
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some(&format!("{label}_layout")),
bind_group_layouts: &[Some(bgl)],
immediate_size: 0,
});
let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some(&format!("{label}_pipeline")),
layout: Some(&layout),
module: &module,
entry_point: Some(entry_point),
compilation_options: Default::default(),
cache: None,
});
if let Some(err) = poll_ready_now(scope.pop()).flatten() {
return Err(RenderError::ShaderValidation {
shader_name: label.to_string(),
error: err.to_string(),
});
}
Ok(pipeline)
}
fn bgl_entry(binding: u32, read_only: bool) -> wgpu::BindGroupLayoutEntry {
wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}
}
fn uniform_bgl_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {
wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}
}
fn bg_entry(binding: u32, buffer: &wgpu::Buffer) -> wgpu::BindGroupEntry<'_> {
wgpu::BindGroupEntry {
binding,
resource: buffer.as_entire_binding(),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_pass_count_skips_all_zero_tile_digits() {
assert_eq!(radix_pass_count(120 * 68), 12);
assert!(radix_pass_count(120 * 68) < NUM_PASSES);
}
#[test]
fn test_pass_count_is_always_even() {
for num_tiles in [0u32, 1, 2, 3, 17, 255, 256, 4096, 8160, 65_535, u32::MAX] {
assert_eq!(
radix_pass_count(num_tiles) % 2,
0,
"odd pass count for num_tiles={num_tiles}"
);
}
}
#[test]
fn test_pass_count_single_tile_sorts_depth_only() {
assert_eq!(radix_pass_count(1), 8);
assert_eq!(radix_pass_count(0), 8);
}
#[test]
fn test_pass_count_never_exceeds_full_key() {
assert_eq!(radix_pass_count(u32::MAX), NUM_PASSES);
for num_tiles in [1u32, 100, 10_000, 1_000_000, u32::MAX] {
assert!(radix_pass_count(num_tiles) <= NUM_PASSES);
}
}
#[test]
fn test_pass_count_covers_the_highest_tile_bit() {
for num_tiles in [2u32, 3, 16, 17, 4096, 8160, 70_000] {
let passes = radix_pass_count(num_tiles);
let covered_bits = passes * RADIX_BITS;
let needed = 32 + (u32::BITS - (num_tiles - 1).leading_zeros());
assert!(
covered_bits >= needed,
"num_tiles={num_tiles}: {covered_bits} covered bits < {needed} needed"
);
}
}
#[test]
#[ignore = "requires GPU"]
fn test_compile_pipeline_invalid_wgsl_returns_error_not_panic() {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
..wgpu::InstanceDescriptor::new_without_display_handle()
});
let adapter =
match pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
apply_limit_buckets: false,
})) {
Ok(a) => a,
Err(_) => {
eprintln!("No GPU adapter available, skipping GPU test");
return;
}
};
let (device, _queue) =
match pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("sort_test_device"),
required_features: wgpu::Features::empty(),
required_limits: wgpu::Limits::default(),
memory_hints: wgpu::MemoryHints::Performance,
experimental_features: wgpu::ExperimentalFeatures::default(),
trace: wgpu::Trace::Off,
})) {
Ok(dq) => dq,
Err(_) => {
eprintln!("Failed to create GPU device, skipping GPU test");
return;
}
};
let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("test_bgl"),
entries: &[uniform_bgl_entry(0)],
});
let result = compile_pipeline(
&device,
"broken_shader",
"this is not valid wgsl {{{",
"main",
&bgl,
);
assert!(
matches!(
result,
Err(RenderError::ShaderCompilation { .. })
| Err(RenderError::ShaderValidation { .. })
),
"expected a ShaderCompilation or ShaderValidation error, got {result:?}"
);
}
}