From 154923444a7ddc82daa51c04030b2a78edd933d5 Mon Sep 17 00:00:00 2001 From: firestar99 Date: Mon, 13 Apr 2026 17:27:16 +0200 Subject: [PATCH 1/7] difftest runner: cleanup wgpu runner, remove variants of runners, use shader passthrough for rust-gpu --- tests/difftests/runner/src/runner.rs | 3 - .../push_constants-rust/src/main.rs | 11 +- .../push_constants-wgsl/src/main.rs | 11 +- .../black_box_noop/with-black-box/src/main.rs | 8 +- .../without-black-box/src/main.rs | 8 +- .../compute/{ash.rs => ash_runner.rs} | 0 .../tests/lib/src/scaffold/compute/mod.rs | 12 +- .../tests/lib/src/scaffold/compute/wgpu.rs | 840 ------------------ .../lib/src/scaffold/compute/wgpu_runner.rs | 275 ++++++ .../tests/lib/src/scaffold/shader/mod.rs | 5 +- .../src/scaffold/shader/rust_gpu_shader.rs | 31 +- .../lib/src/scaffold/shader/wgsl_shader.rs | 16 +- .../simple-compute-rust/src/main.rs | 8 +- .../simple-compute-wgsl/src/main.rs | 8 +- 14 files changed, 358 insertions(+), 878 deletions(-) rename tests/difftests/tests/lib/src/scaffold/compute/{ash.rs => ash_runner.rs} (100%) delete mode 100644 tests/difftests/tests/lib/src/scaffold/compute/wgpu.rs create mode 100644 tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs diff --git a/tests/difftests/runner/src/runner.rs b/tests/difftests/runner/src/runner.rs index 5005418bc1c..25711e28a6c 100644 --- a/tests/difftests/runner/src/runner.rs +++ b/tests/difftests/runner/src/runner.rs @@ -1,7 +1,6 @@ use bytesize::ByteSize; use difftest_types::config::{OutputType, TestMetadata}; use serde::{Deserialize, Serialize}; -use std::process::Stdio; use std::{ collections::{HashMap, HashSet}, fs, @@ -292,8 +291,6 @@ impl Runner { let output = cmd .current_dir(&package.absolute_path) - .stdout(Stdio::inherit()) - .stderr(Stdio::inherit()) .output() .map_err(|e| RunnerError::Io { source: e })?; let exit_code = output.status.code().unwrap_or(-1); diff --git a/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs b/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs index 671f0a4974c..b30c57839e7 100644 --- a/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs +++ b/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs @@ -1,6 +1,7 @@ use difftest::config::Config; +use difftest::scaffold::compute::wgpu::Features; use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestPushConstants, + BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, }; #[repr(C)] @@ -30,7 +31,7 @@ fn main() { count: num_elements as u32, }; - let test = WgpuComputeTestPushConstants::new( + let test = WgpuComputeTestMultiBuffer::new( RustComputeShader::default(), [4, 1, 1], // 256 / 64 = 4 workgroups vec![ @@ -45,9 +46,9 @@ fn main() { initial_data: None, }, ], - std::mem::size_of::() as u32, - bytemuck::bytes_of(&push_constants).to_vec(), - ); + ) + .with_feature(Features::PUSH_CONSTANTS) + .with_push_constant(&push_constants); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs index 04f8b0ab79f..d077fa0ca55 100644 --- a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs +++ b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs @@ -1,6 +1,7 @@ use difftest::config::Config; +use difftest::scaffold::compute::wgpu::Features; use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestPushConstants, WgslComputeShader, + BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, }; #[repr(C)] @@ -30,7 +31,7 @@ fn main() { count: num_elements as u32, }; - let test = WgpuComputeTestPushConstants::new( + let test = WgpuComputeTestMultiBuffer::new( WgslComputeShader::default(), [4, 1, 1], // 256 / 64 = 4 workgroups vec![ @@ -45,9 +46,9 @@ fn main() { initial_data: None, }, ], - std::mem::size_of::() as u32, - bytemuck::bytes_of(&push_constants).to_vec(), - ); + ) + .with_feature(Features::PUSH_CONSTANTS) + .with_push_constant(&push_constants); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/lang/core/intrinsics/black_box_noop/with-black-box/src/main.rs b/tests/difftests/tests/lang/core/intrinsics/black_box_noop/with-black-box/src/main.rs index e6ea8d4b46f..9597e318dbb 100644 --- a/tests/difftests/tests/lang/core/intrinsics/black_box_noop/with-black-box/src/main.rs +++ b/tests/difftests/tests/lang/core/intrinsics/black_box_noop/with-black-box/src/main.rs @@ -1,9 +1,13 @@ use difftest::config::{Config, TestMetadata}; -use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTest}; +use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTestMultiBuffer}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); - let test = WgpuComputeTest::new(RustComputeShader::default(), [1, 1, 1], 12 * 4); + let test = WgpuComputeTestMultiBuffer::new_single_buffer( + RustComputeShader::default(), + [1, 1, 1], + 12 * 4, + ); test.run_test(&config).unwrap(); config .write_metadata(&TestMetadata::u32()) diff --git a/tests/difftests/tests/lang/core/intrinsics/black_box_noop/without-black-box/src/main.rs b/tests/difftests/tests/lang/core/intrinsics/black_box_noop/without-black-box/src/main.rs index e6ea8d4b46f..9597e318dbb 100644 --- a/tests/difftests/tests/lang/core/intrinsics/black_box_noop/without-black-box/src/main.rs +++ b/tests/difftests/tests/lang/core/intrinsics/black_box_noop/without-black-box/src/main.rs @@ -1,9 +1,13 @@ use difftest::config::{Config, TestMetadata}; -use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTest}; +use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTestMultiBuffer}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); - let test = WgpuComputeTest::new(RustComputeShader::default(), [1, 1, 1], 12 * 4); + let test = WgpuComputeTestMultiBuffer::new_single_buffer( + RustComputeShader::default(), + [1, 1, 1], + 12 * 4, + ); test.run_test(&config).unwrap(); config .write_metadata(&TestMetadata::u32()) diff --git a/tests/difftests/tests/lib/src/scaffold/compute/ash.rs b/tests/difftests/tests/lib/src/scaffold/compute/ash_runner.rs similarity index 100% rename from tests/difftests/tests/lib/src/scaffold/compute/ash.rs rename to tests/difftests/tests/lib/src/scaffold/compute/ash_runner.rs diff --git a/tests/difftests/tests/lib/src/scaffold/compute/mod.rs b/tests/difftests/tests/lib/src/scaffold/compute/mod.rs index 0c89c51837f..645c818873e 100644 --- a/tests/difftests/tests/lib/src/scaffold/compute/mod.rs +++ b/tests/difftests/tests/lib/src/scaffold/compute/mod.rs @@ -1,10 +1,10 @@ -mod ash; +mod ash_runner; mod backend; -mod wgpu; +mod wgpu_runner; pub use crate::scaffold::shader::*; -pub use ash::AshBackend; +pub use ash; +pub use ash_runner::AshBackend; pub use backend::{BufferConfig, BufferUsage, ComputeBackend, ComputeShaderTest, ComputeTest}; -pub use wgpu::{ - WgpuBackend, WgpuComputeTest, WgpuComputeTestMultiBuffer, WgpuComputeTestPushConstants, -}; +pub use wgpu; +pub use wgpu_runner::WgpuComputeTestMultiBuffer; diff --git a/tests/difftests/tests/lib/src/scaffold/compute/wgpu.rs b/tests/difftests/tests/lib/src/scaffold/compute/wgpu.rs deleted file mode 100644 index 4996e061160..00000000000 --- a/tests/difftests/tests/lib/src/scaffold/compute/wgpu.rs +++ /dev/null @@ -1,840 +0,0 @@ -use super::backend::{self, ComputeBackend}; -use crate::config::Config; -use crate::scaffold::shader::RustComputeShader; -use crate::scaffold::shader::WgpuShader; -use crate::scaffold::shader::WgslComputeShader; -use anyhow::Context; -use bytemuck::Pod; -use futures::executor::block_on; -use std::{borrow::Cow, sync::Arc}; -use wgpu::{ExperimentalFeatures, PipelineCompilationOptions, util::DeviceExt}; - -pub type BufferConfig = backend::BufferConfig; -pub type BufferUsage = backend::BufferUsage; - -/// Compute test that is generic over the shader type. -pub struct WgpuComputeTest { - shader: S, - dispatch: [u32; 3], - output_bytes: u64, -} - -/// More flexible compute test that supports multiple buffers. -pub struct WgpuComputeTestMultiBuffer { - shader: S, - dispatch: [u32; 3], - buffers: Vec, -} - -/// Compute test that supports push constants. -pub struct WgpuComputeTestPushConstants { - shader: S, - dispatch: [u32; 3], - buffers: Vec, - push_constants_size: u32, - push_constants_data: Vec, -} - -impl WgpuComputeTest -where - S: WgpuShader, -{ - pub fn new(shader: S, dispatch: [u32; 3], output_bytes: u64) -> Self { - Self { - shader, - dispatch, - output_bytes, - } - } - - fn init() -> anyhow::Result<(wgpu::Device, wgpu::Queue)> { - Self::init_with_features(wgpu::Features::empty()) - } - - fn init_with_features(features: wgpu::Features) -> anyhow::Result<(wgpu::Device, wgpu::Queue)> { - block_on(async { - let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor { - #[cfg(target_os = "linux")] - backends: wgpu::Backends::VULKAN, - #[cfg(not(target_os = "linux"))] - backends: wgpu::Backends::PRIMARY, - flags: Default::default(), - memory_budget_thresholds: Default::default(), - backend_options: wgpu::BackendOptions { - #[cfg(target_os = "windows")] - dx12: wgpu::Dx12BackendOptions { - shader_compiler: wgpu::Dx12Compiler::StaticDxc, - ..Default::default() - }, - ..Default::default() - }, - }); - let adapter = instance - .request_adapter(&wgpu::RequestAdapterOptions { - power_preference: wgpu::PowerPreference::HighPerformance, - compatible_surface: None, - force_fallback_adapter: false, - }) - .await - .context("Failed to find a suitable GPU adapter")?; - let (device, queue) = adapter - .request_device(&wgpu::DeviceDescriptor { - label: Some("wgpu Device"), - #[cfg(target_os = "linux")] - required_features: wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS | features, - #[cfg(not(target_os = "linux"))] - required_features: features, - required_limits: wgpu::Limits { - max_push_constant_size: 128, - ..wgpu::Limits::default() - }, - experimental_features: unsafe { ExperimentalFeatures::enabled() }, - memory_hints: Default::default(), - trace: Default::default(), - }) - .await - .context("Failed to create device")?; - Ok((device, queue)) - }) - } - - fn run_internal(self, input: Option) -> anyhow::Result> - where - I: Sized + Pod, - { - let (device, queue) = Self::init()?; - let (module, entrypoint) = self.shader.create_module(&device)?; - let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { - label: Some("Compute Pipeline"), - layout: None, - module: &module, - entry_point: entrypoint.as_deref(), - compilation_options: PipelineCompilationOptions::default(), - cache: None, - }); - - // Create the output buffer. - let output_buffer = device.create_buffer(&wgpu::BufferDescriptor { - label: Some("Output Buffer"), - size: self.output_bytes, - usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC, - mapped_at_creation: true, - }); - { - // Zero the buffer. - let initial_data = vec![0u8; self.output_bytes as usize]; - let mut mapping = output_buffer.slice(..).get_mapped_range_mut(); - mapping.copy_from_slice(&initial_data); - } - output_buffer.unmap(); - - // Build the bind group. - let bind_group = if let Some(input_val) = input { - let input_bytes = bytemuck::bytes_of(&input_val); - let input_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { - label: Some("Input Buffer"), - contents: input_bytes, - usage: wgpu::BufferUsages::UNIFORM, - }); - device.create_bind_group(&wgpu::BindGroupDescriptor { - layout: &pipeline.get_bind_group_layout(0), - entries: &[ - // Binding 0: uniform input. - wgpu::BindGroupEntry { - binding: 0, - resource: input_buffer.as_entire_binding(), - }, - // Binding 1: storage output. - wgpu::BindGroupEntry { - binding: 1, - resource: output_buffer.as_entire_binding(), - }, - ], - label: Some("Compute Bind Group (with input)"), - }) - } else { - device.create_bind_group(&wgpu::BindGroupDescriptor { - layout: &pipeline.get_bind_group_layout(0), - entries: &[ - // Binding 0: storage output. - wgpu::BindGroupEntry { - binding: 0, - resource: output_buffer.as_entire_binding(), - }, - ], - label: Some("Compute Bind Group (no input)"), - }) - }; - - let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { - label: Some("Compute Encoder"), - }); - { - let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { - label: Some("Compute Pass"), - timestamp_writes: Default::default(), - }); - pass.set_pipeline(&pipeline); - pass.set_bind_group(0, &bind_group, &[]); - pass.dispatch_workgroups(self.dispatch[0], self.dispatch[1], self.dispatch[2]); - } - - // Create a staging buffer. - let staging_buffer = device.create_buffer(&wgpu::BufferDescriptor { - label: Some("Staging Buffer"), - size: self.output_bytes, - usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, - mapped_at_creation: false, - }); - encoder.copy_buffer_to_buffer(&output_buffer, 0, &staging_buffer, 0, self.output_bytes); - queue.submit(Some(encoder.finish())); - - let buffer_slice = staging_buffer.slice(..); - let (sender, receiver) = futures::channel::oneshot::channel(); - buffer_slice.map_async(wgpu::MapMode::Read, move |res| { - let _ = sender.send(res); - }); - device.poll(wgpu::PollType::wait_indefinitely())?; - block_on(receiver) - .context("mapping canceled")? - .context("mapping failed")?; - let data = buffer_slice.get_mapped_range().to_vec(); - staging_buffer.unmap(); - Ok(data) - } - - /// Runs the compute shader with no input. - pub fn run(self) -> anyhow::Result> { - self.run_internal::<()>(None) - } - - /// Runs the compute shader with provided input. - pub fn run_with_input(self, input: I) -> anyhow::Result> - where - I: Sized + Pod, - { - self.run_internal(Some(input)) - } - - /// Runs the compute shader with no input and writes the output to a file. - pub fn run_test(self, config: &Config) -> anyhow::Result<()> { - let output = self.run()?; - config.write_result(&output)?; - Ok(()) - } - - /// Runs the compute shader with provided input and writes the output to a file. - pub fn run_test_with_input(self, config: &Config, input: I) -> anyhow::Result<()> - where - I: Sized + Pod, - { - let output = self.run_with_input(input)?; - config.write_result(&output)?; - Ok(()) - } -} - -/// wgpu backend implementation for the generic `ComputeBackend` trait -pub struct WgpuBackend { - device: Arc, - queue: Arc, -} - -impl ComputeBackend for WgpuBackend { - fn init() -> anyhow::Result { - let (device, queue) = WgpuComputeTest::::init()?; - Ok(Self { - device: Arc::new(device), - queue: Arc::new(queue), - }) - } - - fn run_compute( - &self, - spirv_bytes: &[u8], - entry_point: &str, - dispatch: [u32; 3], - buffers: Vec, - ) -> anyhow::Result>> { - // Convert bytes to u32 words - if !spirv_bytes.len().is_multiple_of(4) { - anyhow::bail!("SPIR-V binary length is not a multiple of 4"); - } - let spirv_words: Vec = bytemuck::cast_slice(spirv_bytes).to_vec(); - - // Create shader module - let module = self - .device - .create_shader_module(wgpu::ShaderModuleDescriptor { - label: Some("Compute Shader"), - source: wgpu::ShaderSource::SpirV(Cow::Owned(spirv_words)), - }); - - // Create pipeline - let pipeline = self - .device - .create_compute_pipeline(&wgpu::ComputePipelineDescriptor { - label: Some("Compute Pipeline"), - layout: None, - module: &module, - entry_point: Some(entry_point), - compilation_options: PipelineCompilationOptions::default(), - cache: None, - }); - - // Create buffers - let mut gpu_buffers = Vec::new(); - for (i, buffer_config) in buffers.iter().enumerate() { - let usage = match buffer_config.usage { - BufferUsage::Storage => wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC, - BufferUsage::StorageReadOnly => { - wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC - } - BufferUsage::Uniform => wgpu::BufferUsages::UNIFORM, - }; - - let buffer = if let Some(initial_data) = &buffer_config.initial_data { - self.device - .create_buffer_init(&wgpu::util::BufferInitDescriptor { - label: Some(&format!("Buffer {i}")), - contents: initial_data, - usage, - }) - } else { - let buffer = self.device.create_buffer(&wgpu::BufferDescriptor { - label: Some(&format!("Buffer {i}")), - size: buffer_config.size, - usage, - mapped_at_creation: true, - }); - { - // Zero the buffer - let initial_data = vec![0u8; buffer_config.size as usize]; - let mut mapping = buffer.slice(..).get_mapped_range_mut(); - mapping.copy_from_slice(&initial_data); - } - buffer.unmap(); - buffer - }; - gpu_buffers.push(buffer); - } - - // Create bind entries - let bind_entries: Vec<_> = gpu_buffers - .iter() - .enumerate() - .map(|(i, buffer)| wgpu::BindGroupEntry { - binding: i as u32, - resource: buffer.as_entire_binding(), - }) - .collect(); - - let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor { - layout: &pipeline.get_bind_group_layout(0), - entries: &bind_entries, - label: Some("Compute Bind Group"), - }); - - let mut encoder = self - .device - .create_command_encoder(&wgpu::CommandEncoderDescriptor { - label: Some("Compute Encoder"), - }); - - { - let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { - label: Some("Compute Pass"), - timestamp_writes: Default::default(), - }); - pass.set_pipeline(&pipeline); - pass.set_bind_group(0, &bind_group, &[]); - pass.dispatch_workgroups(dispatch[0], dispatch[1], dispatch[2]); - } - - // Create staging buffers and copy results - let mut staging_buffers = Vec::new(); - for (i, buffer_config) in buffers.iter().enumerate() { - if matches!( - buffer_config.usage, - BufferUsage::Storage | BufferUsage::StorageReadOnly - ) { - let staging_buffer = self.device.create_buffer(&wgpu::BufferDescriptor { - label: Some(&format!("Staging Buffer {i}")), - size: buffer_config.size, - usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, - mapped_at_creation: false, - }); - encoder.copy_buffer_to_buffer( - &gpu_buffers[i], - 0, - &staging_buffer, - 0, - buffer_config.size, - ); - staging_buffers.push(Some(staging_buffer)); - } else { - staging_buffers.push(None); - } - } - - self.queue.submit(Some(encoder.finish())); - - // Read back results - let mut results = Vec::new(); - for staging_buffer in staging_buffers { - if let Some(buffer) = staging_buffer { - let buffer_slice = buffer.slice(..); - let (sender, receiver) = futures::channel::oneshot::channel(); - buffer_slice.map_async(wgpu::MapMode::Read, move |res| { - let _ = sender.send(res); - }); - self.device.poll(wgpu::PollType::wait_indefinitely())?; - block_on(receiver) - .context("mapping canceled")? - .context("mapping failed")?; - let data = buffer_slice.get_mapped_range().to_vec(); - buffer.unmap(); - results.push(data); - } else { - results.push(Vec::new()); - } - } - - Ok(results) - } -} - -impl WgpuComputeTestMultiBuffer -where - S: WgpuShader, -{ - pub fn new(shader: S, dispatch: [u32; 3], buffers: Vec) -> Self { - Self { - shader, - dispatch, - buffers, - } - } - - pub fn new_with_sizes(shader: S, dispatch: [u32; 3], sizes: &[u64]) -> Self { - let buffers = sizes - .iter() - .map(|&size| BufferConfig { - size, - usage: BufferUsage::Storage, - initial_data: None, - }) - .collect(); - Self::new(shader, dispatch, buffers) - } - - pub fn run(self) -> anyhow::Result>> { - let (device, queue) = WgpuComputeTest::::init()?; - let (module, entrypoint) = self.shader.create_module(&device)?; - let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { - label: Some("Compute Pipeline"), - layout: None, - module: &module, - entry_point: entrypoint.as_deref(), - compilation_options: PipelineCompilationOptions::default(), - cache: None, - }); - - // Create buffers. - let mut gpu_buffers = Vec::new(); - - for (i, buffer_config) in self.buffers.iter().enumerate() { - let usage = match buffer_config.usage { - BufferUsage::Storage => wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC, - BufferUsage::StorageReadOnly => { - wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC - } - BufferUsage::Uniform => wgpu::BufferUsages::UNIFORM, - }; - - let buffer = if let Some(initial_data) = &buffer_config.initial_data { - device.create_buffer_init(&wgpu::util::BufferInitDescriptor { - label: Some(&format!("Buffer {i}")), - contents: initial_data, - usage, - }) - } else { - let buffer = device.create_buffer(&wgpu::BufferDescriptor { - label: Some(&format!("Buffer {i}")), - size: buffer_config.size, - usage, - mapped_at_creation: true, - }); - { - // Zero the buffer. - let initial_data = vec![0u8; buffer_config.size as usize]; - let mut mapping = buffer.slice(..).get_mapped_range_mut(); - mapping.copy_from_slice(&initial_data); - } - buffer.unmap(); - buffer - }; - - gpu_buffers.push(buffer); - } - - // Create bind entries after all buffers are created - let bind_entries: Vec<_> = gpu_buffers - .iter() - .enumerate() - .map(|(i, buffer)| wgpu::BindGroupEntry { - binding: i as u32, - resource: buffer.as_entire_binding(), - }) - .collect(); - - let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { - layout: &pipeline.get_bind_group_layout(0), - entries: &bind_entries, - label: Some("Compute Bind Group"), - }); - - let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { - label: Some("Compute Encoder"), - }); - { - let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { - label: Some("Compute Pass"), - timestamp_writes: Default::default(), - }); - pass.set_pipeline(&pipeline); - pass.set_bind_group(0, &bind_group, &[]); - pass.dispatch_workgroups(self.dispatch[0], self.dispatch[1], self.dispatch[2]); - } - - // Create staging buffers and copy results. - let mut staging_buffers = Vec::new(); - for (i, buffer_config) in self.buffers.iter().enumerate() { - if matches!( - buffer_config.usage, - BufferUsage::Storage | BufferUsage::StorageReadOnly - ) { - let staging_buffer = device.create_buffer(&wgpu::BufferDescriptor { - label: Some(&format!("Staging Buffer {i}")), - size: buffer_config.size, - usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, - mapped_at_creation: false, - }); - encoder.copy_buffer_to_buffer( - &gpu_buffers[i], - 0, - &staging_buffer, - 0, - buffer_config.size, - ); - staging_buffers.push(Some(staging_buffer)); - } else { - staging_buffers.push(None); - } - } - - queue.submit(Some(encoder.finish())); - - // Read back results. - let mut results = Vec::new(); - for staging_buffer in staging_buffers { - if let Some(buffer) = staging_buffer { - let buffer_slice = buffer.slice(..); - let (sender, receiver) = futures::channel::oneshot::channel(); - buffer_slice.map_async(wgpu::MapMode::Read, move |res| { - let _ = sender.send(res); - }); - device.poll(wgpu::PollType::wait_indefinitely())?; - block_on(receiver) - .context("mapping canceled")? - .context("mapping failed")?; - let data = buffer_slice.get_mapped_range().to_vec(); - buffer.unmap(); - results.push(data); - } else { - results.push(Vec::new()); - } - } - - Ok(results) - } - - pub fn run_test(self, config: &Config) -> anyhow::Result<()> { - let buffers = self.buffers.clone(); - let outputs = self.run()?; - // Write the first storage buffer output to the file. - for (output, buffer_config) in outputs.iter().zip(&buffers) { - if matches!(buffer_config.usage, BufferUsage::Storage) && !output.is_empty() { - config.write_result(output)?; - return Ok(()); - } - } - anyhow::bail!("No storage buffer output found") - } -} - -impl WgpuComputeTestPushConstants -where - S: WgpuShader, -{ - pub fn new( - shader: S, - dispatch: [u32; 3], - buffers: Vec, - push_constants_size: u32, - push_constants_data: Vec, - ) -> Self { - Self { - shader, - dispatch, - buffers, - push_constants_size, - push_constants_data, - } - } - - pub fn run(self) -> anyhow::Result>> { - let (device, queue) = - WgpuComputeTest::::init_with_features(wgpu::Features::PUSH_CONSTANTS)?; - let (module, entrypoint) = self.shader.create_module(&device)?; - - // Create pipeline layout with push constants - let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { - label: Some("Bind Group Layout"), - entries: &self - .buffers - .iter() - .enumerate() - .map(|(i, buffer_config)| wgpu::BindGroupLayoutEntry { - binding: i as u32, - visibility: wgpu::ShaderStages::COMPUTE, - ty: match buffer_config.usage { - BufferUsage::Storage => wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Storage { read_only: false }, - has_dynamic_offset: false, - min_binding_size: None, - }, - BufferUsage::StorageReadOnly => wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Storage { read_only: true }, - has_dynamic_offset: false, - min_binding_size: None, - }, - BufferUsage::Uniform => wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Uniform, - has_dynamic_offset: false, - min_binding_size: None, - }, - }, - count: None, - }) - .collect::>(), - }); - - let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { - label: Some("Pipeline Layout"), - bind_group_layouts: &[&bind_group_layout], - push_constant_ranges: &[wgpu::PushConstantRange { - stages: wgpu::ShaderStages::COMPUTE, - range: 0..self.push_constants_size, - }], - }); - - let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { - label: Some("Compute Pipeline"), - layout: Some(&pipeline_layout), - module: &module, - entry_point: entrypoint.as_deref(), - compilation_options: PipelineCompilationOptions::default(), - cache: None, - }); - - // Create buffers. - let mut gpu_buffers = Vec::new(); - - for (i, buffer_config) in self.buffers.iter().enumerate() { - let usage = match buffer_config.usage { - BufferUsage::Storage => wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC, - BufferUsage::StorageReadOnly => { - wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC - } - BufferUsage::Uniform => wgpu::BufferUsages::UNIFORM, - }; - - let buffer = if let Some(initial_data) = &buffer_config.initial_data { - device.create_buffer_init(&wgpu::util::BufferInitDescriptor { - label: Some(&format!("Buffer {i}")), - contents: initial_data, - usage, - }) - } else { - let buffer = device.create_buffer(&wgpu::BufferDescriptor { - label: Some(&format!("Buffer {i}")), - size: buffer_config.size, - usage, - mapped_at_creation: true, - }); - { - // Zero the buffer. - let initial_data = vec![0u8; buffer_config.size as usize]; - let mut mapping = buffer.slice(..).get_mapped_range_mut(); - mapping.copy_from_slice(&initial_data); - } - buffer.unmap(); - buffer - }; - - gpu_buffers.push(buffer); - } - - // Create bind entries after all buffers are created - let bind_entries: Vec<_> = gpu_buffers - .iter() - .enumerate() - .map(|(i, buffer)| wgpu::BindGroupEntry { - binding: i as u32, - resource: buffer.as_entire_binding(), - }) - .collect(); - - let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { - layout: &bind_group_layout, - entries: &bind_entries, - label: Some("Compute Bind Group"), - }); - - let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { - label: Some("Compute Encoder"), - }); - { - let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { - label: Some("Compute Pass"), - timestamp_writes: Default::default(), - }); - pass.set_pipeline(&pipeline); - pass.set_bind_group(0, &bind_group, &[]); - pass.set_push_constants(0, &self.push_constants_data); - pass.dispatch_workgroups(self.dispatch[0], self.dispatch[1], self.dispatch[2]); - } - - // Create staging buffers and copy results. - let mut staging_buffers = Vec::new(); - for (i, buffer_config) in self.buffers.iter().enumerate() { - if matches!( - buffer_config.usage, - BufferUsage::Storage | BufferUsage::StorageReadOnly - ) { - let staging_buffer = device.create_buffer(&wgpu::BufferDescriptor { - label: Some(&format!("Staging Buffer {i}")), - size: buffer_config.size, - usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, - mapped_at_creation: false, - }); - encoder.copy_buffer_to_buffer( - &gpu_buffers[i], - 0, - &staging_buffer, - 0, - buffer_config.size, - ); - staging_buffers.push(Some(staging_buffer)); - } else { - staging_buffers.push(None); - } - } - - queue.submit(Some(encoder.finish())); - - // Read back results. - let mut results = Vec::new(); - for staging_buffer in staging_buffers { - if let Some(buffer) = staging_buffer { - let buffer_slice = buffer.slice(..); - let (sender, receiver) = futures::channel::oneshot::channel(); - buffer_slice.map_async(wgpu::MapMode::Read, move |res| { - let _ = sender.send(res); - }); - device.poll(wgpu::PollType::wait_indefinitely())?; - block_on(receiver) - .context("mapping canceled")? - .context("mapping failed")?; - let data = buffer_slice.get_mapped_range().to_vec(); - buffer.unmap(); - results.push(data); - } else { - results.push(Vec::new()); - } - } - - Ok(results) - } - - pub fn run_test(self, config: &Config) -> anyhow::Result<()> { - let buffers = self.buffers.clone(); - let results = self.run()?; - // Write first storage buffer output to file. - for (data, buffer_config) in results.iter().zip(&buffers) { - if buffer_config.usage == BufferUsage::Storage && !data.is_empty() { - config.write_result(data)?; - return Ok(()); - } - } - anyhow::bail!("No storage buffer output found") - } -} - -// Convenience implementation for WgpuComputeTestPushConstants -impl WgpuComputeTestPushConstants { - pub fn new_with_data( - shader: RustComputeShader, - dispatch: [u32; 3], - sizes: &[u64], - push_constant_data: &T, - ) -> Self { - let buffers = sizes - .iter() - .map(|&size| BufferConfig { - size, - usage: BufferUsage::Storage, - initial_data: None, - }) - .collect(); - let push_constants_data = bytemuck::bytes_of(push_constant_data).to_vec(); - let push_constants_size = push_constants_data.len() as u32; - - Self::new( - shader, - dispatch, - buffers, - push_constants_size, - push_constants_data, - ) - } -} - -impl WgpuComputeTestPushConstants { - pub fn new_with_data( - shader: WgslComputeShader, - dispatch: [u32; 3], - sizes: &[u64], - push_constant_data: &T, - ) -> Self { - let buffers = sizes - .iter() - .map(|&size| BufferConfig { - size, - usage: BufferUsage::Storage, - initial_data: None, - }) - .collect(); - let push_constants_data = bytemuck::bytes_of(push_constant_data).to_vec(); - let push_constants_size = push_constants_data.len() as u32; - - Self::new( - shader, - dispatch, - buffers, - push_constants_size, - push_constants_data, - ) - } -} diff --git a/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs new file mode 100644 index 00000000000..9893a49cf82 --- /dev/null +++ b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs @@ -0,0 +1,275 @@ +use crate::config::Config; +use crate::scaffold::compute::{BufferConfig, BufferUsage}; +use crate::scaffold::shader::WgpuShader; +use anyhow::Context; +use bytemuck::NoUninit; +use futures::executor::block_on; +use wgpu::{ExperimentalFeatures, util::DeviceExt}; + +/// More flexible compute test that supports multiple buffers. +pub struct WgpuComputeTestMultiBuffer { + pub features: wgpu::Features, + pub shader: S, + pub dispatch: [u32; 3], + pub buffers: Vec, + pub push_constant: Option>, +} + +impl WgpuComputeTestMultiBuffer +where + S: WgpuShader, +{ + pub fn new(shader: S, dispatch: [u32; 3], buffers: Vec) -> Self { + Self { + features: wgpu::Features::empty(), + shader, + dispatch, + buffers, + push_constant: None, + } + } + + pub fn new_with_sizes(shader: S, dispatch: [u32; 3], sizes: &[u64]) -> Self { + let buffers = sizes + .iter() + .map(|&size| BufferConfig::writeback(size as usize)) + .collect(); + Self::new(shader, dispatch, buffers) + } + + pub fn new_single_buffer(shader: S, dispatch: [u32; 3], size: u64) -> Self { + Self::new_with_sizes(shader, dispatch, &[size]) + } + + pub fn with_feature(self, feature: wgpu::Features) -> Self { + Self { + features: self.features | feature, + ..self + } + } + + pub fn with_push_constant(self, data: &T) -> Self { + Self { + push_constant: Some(bytemuck::bytes_of(data).to_vec()), + ..self + } + } + + pub fn run(self) -> anyhow::Result>> { + let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor { + #[cfg(target_os = "linux")] + backends: wgpu::Backends::VULKAN, + #[cfg(not(target_os = "linux"))] + backends: wgpu::Backends::PRIMARY, + flags: Default::default(), + memory_budget_thresholds: Default::default(), + backend_options: wgpu::BackendOptions { + #[cfg(target_os = "windows")] + dx12: wgpu::Dx12BackendOptions { + shader_compiler: wgpu::Dx12Compiler::StaticDxc, + ..Default::default() + }, + ..Default::default() + }, + }); + let adapter = block_on(instance.request_adapter(&wgpu::RequestAdapterOptions { + power_preference: wgpu::PowerPreference::HighPerformance, + compatible_surface: None, + force_fallback_adapter: false, + })) + .context("Failed to find a suitable GPU adapter")?; + let (device, queue) = block_on(adapter.request_device(&wgpu::DeviceDescriptor { + label: Some("wgpu Device"), + required_features: wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS | self.features, + required_limits: wgpu::Limits { + max_push_constant_size: 128, + ..wgpu::Limits::default() + }, + experimental_features: unsafe { ExperimentalFeatures::enabled() }, + memory_hints: Default::default(), + trace: Default::default(), + })) + .context("Failed to create device")?; + + let buffers = &self.buffers; + let pipeline = self.shader.create_pipeline( + &device, + &device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("Pipeline Layout"), + bind_group_layouts: &[&device.create_bind_group_layout( + &wgpu::BindGroupLayoutDescriptor { + label: Some("Bind Group Layout"), + entries: &buffers + .iter() + .enumerate() + .map(|(i, buffer_config)| wgpu::BindGroupLayoutEntry { + binding: i as u32, + visibility: wgpu::ShaderStages::COMPUTE, + ty: match buffer_config.usage { + BufferUsage::Storage => wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Storage { read_only: false }, + has_dynamic_offset: false, + min_binding_size: None, + }, + BufferUsage::StorageReadOnly => wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Storage { read_only: true }, + has_dynamic_offset: false, + min_binding_size: None, + }, + BufferUsage::Uniform => wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: None, + }, + }, + count: None, + }) + .collect::>(), + }, + )], + push_constant_ranges: self + .push_constant + .as_ref() + .map(|data| wgpu::PushConstantRange { + stages: wgpu::ShaderStages::COMPUTE, + range: 0..data.len() as u32, + }) + .as_slice(), + }), + )?; + + // Create buffers. + let mut gpu_buffers = Vec::new(); + + for (i, buffer_config) in self.buffers.iter().enumerate() { + let usage = match buffer_config.usage { + BufferUsage::Storage => wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC, + BufferUsage::StorageReadOnly => { + wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC + } + BufferUsage::Uniform => wgpu::BufferUsages::UNIFORM, + }; + + let buffer = if let Some(initial_data) = &buffer_config.initial_data { + device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some(&format!("Buffer {i}")), + contents: initial_data, + usage, + }) + } else { + let buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: Some(&format!("Buffer {i}")), + size: buffer_config.size, + usage, + mapped_at_creation: true, + }); + { + // Zero the buffer. + let initial_data = vec![0u8; buffer_config.size as usize]; + let mut mapping = buffer.slice(..).get_mapped_range_mut(); + mapping.copy_from_slice(&initial_data); + } + buffer.unmap(); + buffer + }; + + gpu_buffers.push(buffer); + } + + // Create bind entries after all buffers are created + let bind_entries: Vec<_> = gpu_buffers + .iter() + .enumerate() + .map(|(i, buffer)| wgpu::BindGroupEntry { + binding: i as u32, + resource: buffer.as_entire_binding(), + }) + .collect(); + + let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { + layout: &pipeline.get_bind_group_layout(0), + entries: &bind_entries, + label: Some("Compute Bind Group"), + }); + + let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { + label: Some("Compute Encoder"), + }); + { + let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { + label: Some("Compute Pass"), + timestamp_writes: Default::default(), + }); + pass.set_pipeline(&pipeline); + pass.set_bind_group(0, &bind_group, &[]); + if let Some(push_constant) = self.push_constant { + pass.set_push_constants(0, &push_constant); + } + pass.dispatch_workgroups(self.dispatch[0], self.dispatch[1], self.dispatch[2]); + } + + // Create staging buffers and copy results. + let mut staging_buffers = Vec::new(); + for (i, buffer_config) in self.buffers.iter().enumerate() { + if matches!( + buffer_config.usage, + BufferUsage::Storage | BufferUsage::StorageReadOnly + ) { + let staging_buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: Some(&format!("Staging Buffer {i}")), + size: buffer_config.size, + usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + encoder.copy_buffer_to_buffer( + &gpu_buffers[i], + 0, + &staging_buffer, + 0, + buffer_config.size, + ); + staging_buffers.push(Some(staging_buffer)); + } else { + staging_buffers.push(None); + } + } + + queue.submit(Some(encoder.finish())); + + // Read back results. + let mut results = Vec::new(); + for staging_buffer in staging_buffers { + if let Some(buffer) = staging_buffer { + let buffer_slice = buffer.slice(..); + let (sender, receiver) = futures::channel::oneshot::channel(); + buffer_slice.map_async(wgpu::MapMode::Read, move |res| { + let _ = sender.send(res); + }); + device.poll(wgpu::PollType::wait_indefinitely())?; + block_on(receiver) + .context("mapping canceled")? + .context("mapping failed")?; + let data = buffer_slice.get_mapped_range().to_vec(); + buffer.unmap(); + results.push(data); + } else { + results.push(Vec::new()); + } + } + + Ok(results) + } + + pub fn run_test(self, config: &Config) -> anyhow::Result<()> { + let buffers = self.buffers.clone(); + let outputs = self.run()?; + // Write the first storage buffer output to the file. + for (output, buffer_config) in outputs.iter().zip(&buffers) { + if matches!(buffer_config.usage, BufferUsage::Storage) && !output.is_empty() { + config.write_result(output)?; + return Ok(()); + } + } + anyhow::bail!("No storage buffer output found") + } +} diff --git a/tests/difftests/tests/lib/src/scaffold/shader/mod.rs b/tests/difftests/tests/lib/src/scaffold/shader/mod.rs index cef42c40faf..53c0c8ac207 100644 --- a/tests/difftests/tests/lib/src/scaffold/shader/mod.rs +++ b/tests/difftests/tests/lib/src/scaffold/shader/mod.rs @@ -13,8 +13,9 @@ pub trait SpirvShader { /// Trait for shaders that can create wgpu modules. pub trait WgpuShader { /// Creates a wgpu shader module. - fn create_module( + fn create_pipeline( &self, device: &wgpu::Device, - ) -> anyhow::Result<(wgpu::ShaderModule, Option)>; + pipeline_layout: &wgpu::PipelineLayout, + ) -> anyhow::Result; } diff --git a/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs b/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs index e92f02a8474..eac40d66f21 100644 --- a/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs +++ b/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs @@ -70,21 +70,40 @@ impl SpirvShader for RustComputeShader { } impl WgpuShader for RustComputeShader { - fn create_module( + fn create_pipeline( &self, device: &wgpu::Device, - ) -> anyhow::Result<(wgpu::ShaderModule, Option)> { + layout: &wgpu::PipelineLayout, + ) -> anyhow::Result { let (shader_bytes, entry_point) = self.spirv_bytes()?; if !shader_bytes.len().is_multiple_of(4) { anyhow::bail!("SPIR-V binary length is not a multiple of 4"); } let shader_words: Vec = bytemuck::cast_slice(&shader_bytes).to_vec(); - let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { - label: Some("Compute Shader"), - source: wgpu::ShaderSource::SpirV(Cow::Owned(shader_words)), + let module = unsafe { + device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough { + entry_point: entry_point.clone(), + label: Some("Compute Shader"), + num_workgroups: (0, 0, 0), + runtime_checks: Default::default(), + spirv: Some(Cow::Owned(shader_words)), + dxil: None, + msl: None, + hlsl: None, + glsl: None, + wgsl: None, + }) + }; + let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some("Compute Pipeline"), + layout: Some(layout), + module: &module, + entry_point: Some(&entry_point), + compilation_options: wgpu::PipelineCompilationOptions::default(), + cache: None, }); - Ok((module, Some(entry_point))) + Ok(pipeline) } } diff --git a/tests/difftests/tests/lib/src/scaffold/shader/wgsl_shader.rs b/tests/difftests/tests/lib/src/scaffold/shader/wgsl_shader.rs index a7e3f354f97..8b7c248d7fe 100644 --- a/tests/difftests/tests/lib/src/scaffold/shader/wgsl_shader.rs +++ b/tests/difftests/tests/lib/src/scaffold/shader/wgsl_shader.rs @@ -20,17 +20,27 @@ impl WgslComputeShader { } impl WgpuShader for WgslComputeShader { - fn create_module( + fn create_pipeline( &self, device: &wgpu::Device, - ) -> anyhow::Result<(wgpu::ShaderModule, Option)> { + layout: &wgpu::PipelineLayout, + ) -> anyhow::Result { let shader_source = fs::read_to_string(&self.path) .with_context(|| format!("reading wgsl source file '{}'", &self.path.display()))?; let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Compute Shader"), source: wgpu::ShaderSource::Wgsl(Cow::Owned(shader_source)), }); - Ok((module, self.entry_point.clone())) + Ok( + device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some("Wgsl compute pipeline"), + layout: Some(layout), + module: &module, + entry_point: self.entry_point.as_ref().map(|s| s.as_str()), + compilation_options: Default::default(), + cache: None, + }), + ) } } diff --git a/tests/difftests/tests/simple-compute/simple-compute-rust/src/main.rs b/tests/difftests/tests/simple-compute/simple-compute-rust/src/main.rs index b98488302a2..3b6e4db3d77 100644 --- a/tests/difftests/tests/simple-compute/simple-compute-rust/src/main.rs +++ b/tests/difftests/tests/simple-compute/simple-compute-rust/src/main.rs @@ -1,12 +1,16 @@ use difftest::config::Config; -use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTest}; +use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTestMultiBuffer}; fn main() { // Load the config from the harness. let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); // Define test parameters, loading the rust shader from the current crate. - let test = WgpuComputeTest::new(RustComputeShader::default(), [1, 1, 1], 1024); + let test = WgpuComputeTestMultiBuffer::new_single_buffer( + RustComputeShader::default(), + [1, 1, 1], + 1024, + ); // Run the test and write the output to a file. test.run_test(&config).unwrap(); diff --git a/tests/difftests/tests/simple-compute/simple-compute-wgsl/src/main.rs b/tests/difftests/tests/simple-compute/simple-compute-wgsl/src/main.rs index cdb733fd3b3..4b64d3e48e8 100644 --- a/tests/difftests/tests/simple-compute/simple-compute-wgsl/src/main.rs +++ b/tests/difftests/tests/simple-compute/simple-compute-wgsl/src/main.rs @@ -1,12 +1,16 @@ use difftest::config::Config; -use difftest::scaffold::compute::{WgpuComputeTest, WgslComputeShader}; +use difftest::scaffold::compute::{WgpuComputeTestMultiBuffer, WgslComputeShader}; fn main() { // Load the config from the harness. let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); // Define test parameters, loading the wgsl shader from the crate directory. - let test = WgpuComputeTest::new(WgslComputeShader::default(), [1, 1, 1], 1024); + let test = WgpuComputeTestMultiBuffer::new_single_buffer( + WgslComputeShader::default(), + [1, 1, 1], + 1024, + ); // Run the test and write the output to a file. test.run_test(&config).unwrap(); From 71b102bd8b9819d03d19dc033ba632a92962dafb Mon Sep 17 00:00:00 2001 From: firestar99 Date: Mon, 27 Apr 2026 14:00:03 +0200 Subject: [PATCH 2/7] difftest: rename to WgpuComputeTest --- .../tests/arch/atomic_ops/atomic_ops-rust/src/main.rs | 6 ++---- .../tests/arch/atomic_ops/atomic_ops-wgsl/src/main.rs | 6 ++---- .../arch/memory_barriers/memory_barriers-rust/src/main.rs | 6 ++---- .../arch/memory_barriers/memory_barriers-wgsl/src/main.rs | 6 ++---- .../arch/push_constants/push_constants-rust/src/main.rs | 6 ++---- .../arch/push_constants/push_constants-wgsl/src/main.rs | 6 ++---- .../vector_extract_insert-rust/src/main.rs | 4 ++-- .../vector_extract_insert-wgsl/src/main.rs | 4 ++-- .../workgroup_memory/workgroup_memory-rust/src/main.rs | 4 ++-- .../workgroup_memory/workgroup_memory-wgsl/src/main.rs | 6 ++---- .../tests/lang/abi/vector_layout/cpu/src/shader_driver.rs | 4 ++-- .../tests/lang/control_flow/control_flow-rust/src/main.rs | 4 ++-- .../tests/lang/control_flow/control_flow-wgsl/src/main.rs | 6 ++---- .../control_flow_complex-rust/src/main.rs | 4 ++-- .../control_flow_complex-wgsl/src/main.rs | 4 ++-- .../intrinsics/black_box_noop/with-black-box/src/main.rs | 8 ++------ .../black_box_noop/without-black-box/src/main.rs | 8 ++------ .../core/ops/bitwise_ops/bitwise_ops-rust/src/main.rs | 4 ++-- .../core/ops/bitwise_ops/bitwise_ops-wgsl/src/main.rs | 4 ++-- .../const_fold_int/const-fold-cpu/src/shader_driver.rs | 4 ++-- .../lang/core/ops/math_ops/math_ops-rust/src/main.rs | 4 ++-- .../lang/core/ops/math_ops/math_ops-wgsl/src/main.rs | 6 ++---- .../lang/core/ops/matrix_ops/matrix_ops-rust/src/main.rs | 4 ++-- .../lang/core/ops/matrix_ops/matrix_ops-wgsl/src/main.rs | 6 ++---- .../lang/core/ops/trig_ops/trig_ops-rust/src/main.rs | 4 ++-- .../lang/core/ops/trig_ops/trig_ops-wgsl/src/main.rs | 4 ++-- .../lang/core/ops/vector_ops/vector_ops-rust/src/main.rs | 4 ++-- .../lang/core/ops/vector_ops/vector_ops-wgsl/src/main.rs | 6 ++---- .../ops/vector_swizzle/vector_swizzle-rust/src/main.rs | 4 ++-- .../ops/vector_swizzle/vector_swizzle-wgsl/src/main.rs | 4 ++-- tests/difftests/tests/lib/src/scaffold/compute/mod.rs | 2 +- .../tests/lib/src/scaffold/compute/wgpu_runner.rs | 4 ++-- .../tests/simple-compute/simple-compute-rust/src/main.rs | 8 ++------ .../tests/simple-compute/simple-compute-wgsl/src/main.rs | 8 ++------ .../array_access/array_access-rust/src/main.rs | 4 ++-- .../array_access/array_access-wgsl/src/main.rs | 6 ++---- 36 files changed, 71 insertions(+), 111 deletions(-) diff --git a/tests/difftests/tests/arch/atomic_ops/atomic_ops-rust/src/main.rs b/tests/difftests/tests/arch/atomic_ops/atomic_ops-rust/src/main.rs index 934f54ea3ca..61ba5cb8803 100644 --- a/tests/difftests/tests/arch/atomic_ops/atomic_ops-rust/src/main.rs +++ b/tests/difftests/tests/arch/atomic_ops/atomic_ops-rust/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTest}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -23,7 +21,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [1, 1, 1], // Single workgroup with 32 threads buffers, diff --git a/tests/difftests/tests/arch/atomic_ops/atomic_ops-wgsl/src/main.rs b/tests/difftests/tests/arch/atomic_ops/atomic_ops-wgsl/src/main.rs index 2221c6ed4e2..59004d7be73 100644 --- a/tests/difftests/tests/arch/atomic_ops/atomic_ops-wgsl/src/main.rs +++ b/tests/difftests/tests/arch/atomic_ops/atomic_ops-wgsl/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -23,7 +21,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( WgslComputeShader::default(), [1, 1, 1], // Single workgroup with 32 threads buffers, diff --git a/tests/difftests/tests/arch/memory_barriers/memory_barriers-rust/src/main.rs b/tests/difftests/tests/arch/memory_barriers/memory_barriers-rust/src/main.rs index 2be264b5bf1..4a703cb5874 100644 --- a/tests/difftests/tests/arch/memory_barriers/memory_barriers-rust/src/main.rs +++ b/tests/difftests/tests/arch/memory_barriers/memory_barriers-rust/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTest}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -10,7 +8,7 @@ fn main() { let initial_data: Vec = (0..64).collect(); let initial_bytes: Vec = initial_data.iter().flat_map(|&x| x.to_ne_bytes()).collect(); - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [1, 1, 1], vec![ diff --git a/tests/difftests/tests/arch/memory_barriers/memory_barriers-wgsl/src/main.rs b/tests/difftests/tests/arch/memory_barriers/memory_barriers-wgsl/src/main.rs index a8a8ce08a25..35f99c16095 100644 --- a/tests/difftests/tests/arch/memory_barriers/memory_barriers-wgsl/src/main.rs +++ b/tests/difftests/tests/arch/memory_barriers/memory_barriers-wgsl/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -10,7 +8,7 @@ fn main() { let initial_data: Vec = (0..64).collect(); let initial_bytes: Vec = initial_data.iter().flat_map(|&x| x.to_ne_bytes()).collect(); - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( WgslComputeShader::default(), [1, 1, 1], vec![ diff --git a/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs b/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs index b30c57839e7..b6398ef2694 100644 --- a/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs +++ b/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs @@ -1,8 +1,6 @@ use difftest::config::Config; use difftest::scaffold::compute::wgpu::Features; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTest}; #[repr(C)] #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] @@ -31,7 +29,7 @@ fn main() { count: num_elements as u32, }; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [4, 1, 1], // 256 / 64 = 4 workgroups vec![ diff --git a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs index d077fa0ca55..33df0963465 100644 --- a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs +++ b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs @@ -1,8 +1,6 @@ use difftest::config::Config; use difftest::scaffold::compute::wgpu::Features; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, WgpuComputeTest, WgslComputeShader}; #[repr(C)] #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] @@ -31,7 +29,7 @@ fn main() { count: num_elements as u32, }; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( WgslComputeShader::default(), [4, 1, 1], // 256 / 64 = 4 workgroups vec![ diff --git a/tests/difftests/tests/arch/vector_extract_insert/vector_extract_insert-rust/src/main.rs b/tests/difftests/tests/arch/vector_extract_insert/vector_extract_insert-rust/src/main.rs index 1aac06034c4..519be4cf223 100644 --- a/tests/difftests/tests/arch/vector_extract_insert/vector_extract_insert-rust/src/main.rs +++ b/tests/difftests/tests/arch/vector_extract_insert/vector_extract_insert-rust/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTest}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -26,7 +26,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_data.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(RustComputeShader::default(), [1, 1, 1], buffers); + let test = WgpuComputeTest::new(RustComputeShader::default(), [1, 1, 1], buffers); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/arch/vector_extract_insert/vector_extract_insert-wgsl/src/main.rs b/tests/difftests/tests/arch/vector_extract_insert/vector_extract_insert-wgsl/src/main.rs index 483c094ec2a..e0c0a89b097 100644 --- a/tests/difftests/tests/arch/vector_extract_insert/vector_extract_insert-wgsl/src/main.rs +++ b/tests/difftests/tests/arch/vector_extract_insert/vector_extract_insert-wgsl/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, WgpuComputeTestMultiBuffer, WgslComputeShader}; +use difftest::scaffold::compute::{BufferConfig, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -26,7 +26,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_data.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(WgslComputeShader::default(), [1, 1, 1], buffers); + let test = WgpuComputeTest::new(WgslComputeShader::default(), [1, 1, 1], buffers); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/arch/workgroup_memory/workgroup_memory-rust/src/main.rs b/tests/difftests/tests/arch/workgroup_memory/workgroup_memory-rust/src/main.rs index 9e58d86616c..55143e9e09f 100644 --- a/tests/difftests/tests/arch/workgroup_memory/workgroup_memory-rust/src/main.rs +++ b/tests/difftests/tests/arch/workgroup_memory/workgroup_memory-rust/src/main.rs @@ -2,7 +2,7 @@ fn main() { use difftest::config::Config; use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, + BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTest, }; let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -24,7 +24,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [1, 1, 1], // Single workgroup with 64 threads buffers, diff --git a/tests/difftests/tests/arch/workgroup_memory/workgroup_memory-wgsl/src/main.rs b/tests/difftests/tests/arch/workgroup_memory/workgroup_memory-wgsl/src/main.rs index 0d1e931df31..7ce46ece44e 100644 --- a/tests/difftests/tests/arch/workgroup_memory/workgroup_memory-wgsl/src/main.rs +++ b/tests/difftests/tests/arch/workgroup_memory/workgroup_memory-wgsl/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -23,7 +21,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( WgslComputeShader::default(), [1, 1, 1], // Single workgroup with 64 threads buffers, diff --git a/tests/difftests/tests/lang/abi/vector_layout/cpu/src/shader_driver.rs b/tests/difftests/tests/lang/abi/vector_layout/cpu/src/shader_driver.rs index e6d10ffa3db..2a293dc6aa8 100644 --- a/tests/difftests/tests/lang/abi/vector_layout/cpu/src/shader_driver.rs +++ b/tests/difftests/tests/lang/abi/vector_layout/cpu/src/shader_driver.rs @@ -1,13 +1,13 @@ use crate::glam_features::GlamFeatures; use crate::layout::{LAYOUT_LEN, LAYOUT_RANGE}; use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTest}; pub fn run(glam_feature: GlamFeatures) { glam_feature.assert(); let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); assert_eq!(0, LAYOUT_RANGE.start); - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [LAYOUT_RANGE.end as u32, 1, 1], Vec::from(&[BufferConfig::writeback(LAYOUT_LEN * size_of::())]), diff --git a/tests/difftests/tests/lang/control_flow/control_flow-rust/src/main.rs b/tests/difftests/tests/lang/control_flow/control_flow-rust/src/main.rs index 32587283847..2e77ce7187f 100644 --- a/tests/difftests/tests/lang/control_flow/control_flow-rust/src/main.rs +++ b/tests/difftests/tests/lang/control_flow/control_flow-rust/src/main.rs @@ -2,7 +2,7 @@ fn main() { use difftest::config::Config; use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, + BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTest, }; let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -24,7 +24,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [1, 1, 1], // Single workgroup with 64 threads buffers, diff --git a/tests/difftests/tests/lang/control_flow/control_flow-wgsl/src/main.rs b/tests/difftests/tests/lang/control_flow/control_flow-wgsl/src/main.rs index fc6e9feef5c..9379380d317 100644 --- a/tests/difftests/tests/lang/control_flow/control_flow-wgsl/src/main.rs +++ b/tests/difftests/tests/lang/control_flow/control_flow-wgsl/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -23,7 +21,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( WgslComputeShader::default(), [1, 1, 1], // Single workgroup with 64 threads buffers, diff --git a/tests/difftests/tests/lang/control_flow_complex/control_flow_complex-rust/src/main.rs b/tests/difftests/tests/lang/control_flow_complex/control_flow_complex-rust/src/main.rs index 6c42928bb9a..618b1b46add 100644 --- a/tests/difftests/tests/lang/control_flow_complex/control_flow_complex-rust/src/main.rs +++ b/tests/difftests/tests/lang/control_flow_complex/control_flow_complex-rust/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTest}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -24,7 +24,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_data.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(RustComputeShader::default(), [4, 1, 1], buffers); + let test = WgpuComputeTest::new(RustComputeShader::default(), [4, 1, 1], buffers); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/lang/control_flow_complex/control_flow_complex-wgsl/src/main.rs b/tests/difftests/tests/lang/control_flow_complex/control_flow_complex-wgsl/src/main.rs index 697efe77d49..9a067f0f4ef 100644 --- a/tests/difftests/tests/lang/control_flow_complex/control_flow_complex-wgsl/src/main.rs +++ b/tests/difftests/tests/lang/control_flow_complex/control_flow_complex-wgsl/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, WgpuComputeTestMultiBuffer, WgslComputeShader}; +use difftest::scaffold::compute::{BufferConfig, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -24,7 +24,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_data.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(WgslComputeShader::default(), [4, 1, 1], buffers); + let test = WgpuComputeTest::new(WgslComputeShader::default(), [4, 1, 1], buffers); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/lang/core/intrinsics/black_box_noop/with-black-box/src/main.rs b/tests/difftests/tests/lang/core/intrinsics/black_box_noop/with-black-box/src/main.rs index 9597e318dbb..e572285ce7c 100644 --- a/tests/difftests/tests/lang/core/intrinsics/black_box_noop/with-black-box/src/main.rs +++ b/tests/difftests/tests/lang/core/intrinsics/black_box_noop/with-black-box/src/main.rs @@ -1,13 +1,9 @@ use difftest::config::{Config, TestMetadata}; -use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTest}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); - let test = WgpuComputeTestMultiBuffer::new_single_buffer( - RustComputeShader::default(), - [1, 1, 1], - 12 * 4, - ); + let test = WgpuComputeTest::new_single_buffer(RustComputeShader::default(), [1, 1, 1], 12 * 4); test.run_test(&config).unwrap(); config .write_metadata(&TestMetadata::u32()) diff --git a/tests/difftests/tests/lang/core/intrinsics/black_box_noop/without-black-box/src/main.rs b/tests/difftests/tests/lang/core/intrinsics/black_box_noop/without-black-box/src/main.rs index 9597e318dbb..e572285ce7c 100644 --- a/tests/difftests/tests/lang/core/intrinsics/black_box_noop/without-black-box/src/main.rs +++ b/tests/difftests/tests/lang/core/intrinsics/black_box_noop/without-black-box/src/main.rs @@ -1,13 +1,9 @@ use difftest::config::{Config, TestMetadata}; -use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTest}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); - let test = WgpuComputeTestMultiBuffer::new_single_buffer( - RustComputeShader::default(), - [1, 1, 1], - 12 * 4, - ); + let test = WgpuComputeTest::new_single_buffer(RustComputeShader::default(), [1, 1, 1], 12 * 4); test.run_test(&config).unwrap(); config .write_metadata(&TestMetadata::u32()) diff --git a/tests/difftests/tests/lang/core/ops/bitwise_ops/bitwise_ops-rust/src/main.rs b/tests/difftests/tests/lang/core/ops/bitwise_ops/bitwise_ops-rust/src/main.rs index 2f2ba788c67..75b646cfa73 100644 --- a/tests/difftests/tests/lang/core/ops/bitwise_ops/bitwise_ops-rust/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/bitwise_ops/bitwise_ops-rust/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTest}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -21,7 +21,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_a.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(RustComputeShader::default(), [4, 1, 1], buffers); + let test = WgpuComputeTest::new(RustComputeShader::default(), [4, 1, 1], buffers); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/lang/core/ops/bitwise_ops/bitwise_ops-wgsl/src/main.rs b/tests/difftests/tests/lang/core/ops/bitwise_ops/bitwise_ops-wgsl/src/main.rs index f69ec8578a5..0ce744ccf45 100644 --- a/tests/difftests/tests/lang/core/ops/bitwise_ops/bitwise_ops-wgsl/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/bitwise_ops/bitwise_ops-wgsl/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, WgpuComputeTestMultiBuffer, WgslComputeShader}; +use difftest::scaffold::compute::{BufferConfig, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -21,7 +21,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_a.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(WgslComputeShader::default(), [4, 1, 1], buffers); + let test = WgpuComputeTest::new(WgslComputeShader::default(), [4, 1, 1], buffers); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/lang/core/ops/const_fold_int/const-fold-cpu/src/shader_driver.rs b/tests/difftests/tests/lang/core/ops/const_fold_int/const-fold-cpu/src/shader_driver.rs index 2b848b0bba4..ae1e2612f27 100644 --- a/tests/difftests/tests/lang/core/ops/const_fold_int/const-fold-cpu/src/shader_driver.rs +++ b/tests/difftests/tests/lang/core/ops/const_fold_int/const-fold-cpu/src/shader_driver.rs @@ -1,11 +1,11 @@ use crate::{EvalResult, INTERESTING_PATTERNS, Variants}; use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTest}; pub fn run(variant: Variants) { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [64, 1, 1], Vec::from(&[ diff --git a/tests/difftests/tests/lang/core/ops/math_ops/math_ops-rust/src/main.rs b/tests/difftests/tests/lang/core/ops/math_ops/math_ops-rust/src/main.rs index 13e6ee06995..9358fb37fc7 100644 --- a/tests/difftests/tests/lang/core/ops/math_ops/math_ops-rust/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/math_ops/math_ops-rust/src/main.rs @@ -2,7 +2,7 @@ fn main() { use difftest::config::Config; use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, + BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTest, }; let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -45,7 +45,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [1, 1, 1], // Single workgroup with 32 threads buffers, diff --git a/tests/difftests/tests/lang/core/ops/math_ops/math_ops-wgsl/src/main.rs b/tests/difftests/tests/lang/core/ops/math_ops/math_ops-wgsl/src/main.rs index 1c87d3fc9c5..50c6a693531 100644 --- a/tests/difftests/tests/lang/core/ops/math_ops/math_ops-wgsl/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/math_ops/math_ops-wgsl/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -44,7 +42,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( WgslComputeShader::default(), [1, 1, 1], // Single workgroup with 32 threads buffers, diff --git a/tests/difftests/tests/lang/core/ops/matrix_ops/matrix_ops-rust/src/main.rs b/tests/difftests/tests/lang/core/ops/matrix_ops/matrix_ops-rust/src/main.rs index ef1317bb8be..0d8b8d28a0d 100644 --- a/tests/difftests/tests/lang/core/ops/matrix_ops/matrix_ops-rust/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/matrix_ops/matrix_ops-rust/src/main.rs @@ -2,7 +2,7 @@ fn main() { use difftest::config::Config; use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, + BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTest, }; let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -45,7 +45,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [1, 1, 1], // Single workgroup with 32 threads buffers, diff --git a/tests/difftests/tests/lang/core/ops/matrix_ops/matrix_ops-wgsl/src/main.rs b/tests/difftests/tests/lang/core/ops/matrix_ops/matrix_ops-wgsl/src/main.rs index 76d715f53be..db77ee23346 100644 --- a/tests/difftests/tests/lang/core/ops/matrix_ops/matrix_ops-wgsl/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/matrix_ops/matrix_ops-wgsl/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -44,7 +42,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( WgslComputeShader::default(), [1, 1, 1], // Single workgroup with 32 threads buffers, diff --git a/tests/difftests/tests/lang/core/ops/trig_ops/trig_ops-rust/src/main.rs b/tests/difftests/tests/lang/core/ops/trig_ops/trig_ops-rust/src/main.rs index d6ff18bc0b1..b83c43d94db 100644 --- a/tests/difftests/tests/lang/core/ops/trig_ops/trig_ops-rust/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/trig_ops/trig_ops-rust/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTest}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -19,7 +19,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_data.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(RustComputeShader::default(), [4, 1, 1], buffers); + let test = WgpuComputeTest::new(RustComputeShader::default(), [4, 1, 1], buffers); config .write_metadata(&difftest::config::TestMetadata::f32(1e-4)) diff --git a/tests/difftests/tests/lang/core/ops/trig_ops/trig_ops-wgsl/src/main.rs b/tests/difftests/tests/lang/core/ops/trig_ops/trig_ops-wgsl/src/main.rs index d01e0c4d1ab..f5a88597c41 100644 --- a/tests/difftests/tests/lang/core/ops/trig_ops/trig_ops-wgsl/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/trig_ops/trig_ops-wgsl/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, WgpuComputeTestMultiBuffer, WgslComputeShader}; +use difftest::scaffold::compute::{BufferConfig, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -19,7 +19,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_data.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(WgslComputeShader::default(), [4, 1, 1], buffers); + let test = WgpuComputeTest::new(WgslComputeShader::default(), [4, 1, 1], buffers); config .write_metadata(&difftest::config::TestMetadata::f32(1e-4)) diff --git a/tests/difftests/tests/lang/core/ops/vector_ops/vector_ops-rust/src/main.rs b/tests/difftests/tests/lang/core/ops/vector_ops/vector_ops-rust/src/main.rs index 75364385acc..cee8540cd42 100644 --- a/tests/difftests/tests/lang/core/ops/vector_ops/vector_ops-rust/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/vector_ops/vector_ops-rust/src/main.rs @@ -2,7 +2,7 @@ fn main() { use difftest::config::Config; use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, + BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTest, }; let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -45,7 +45,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [1, 1, 1], // Single workgroup with 32 threads buffers, diff --git a/tests/difftests/tests/lang/core/ops/vector_ops/vector_ops-wgsl/src/main.rs b/tests/difftests/tests/lang/core/ops/vector_ops/vector_ops-wgsl/src/main.rs index 866826b76cb..7188b3f36f7 100644 --- a/tests/difftests/tests/lang/core/ops/vector_ops/vector_ops-wgsl/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/vector_ops/vector_ops-wgsl/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -44,7 +42,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( WgslComputeShader::default(), [1, 1, 1], // Single workgroup with 32 threads buffers, diff --git a/tests/difftests/tests/lang/core/ops/vector_swizzle/vector_swizzle-rust/src/main.rs b/tests/difftests/tests/lang/core/ops/vector_swizzle/vector_swizzle-rust/src/main.rs index 75b9b2ffeac..24374b419c1 100644 --- a/tests/difftests/tests/lang/core/ops/vector_swizzle/vector_swizzle-rust/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/vector_swizzle/vector_swizzle-rust/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTest}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -19,7 +19,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_data.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(RustComputeShader::default(), [1, 1, 1], buffers); + let test = WgpuComputeTest::new(RustComputeShader::default(), [1, 1, 1], buffers); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/lang/core/ops/vector_swizzle/vector_swizzle-wgsl/src/main.rs b/tests/difftests/tests/lang/core/ops/vector_swizzle/vector_swizzle-wgsl/src/main.rs index 6855a6928f6..650e6922b1f 100644 --- a/tests/difftests/tests/lang/core/ops/vector_swizzle/vector_swizzle-wgsl/src/main.rs +++ b/tests/difftests/tests/lang/core/ops/vector_swizzle/vector_swizzle-wgsl/src/main.rs @@ -1,5 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{BufferConfig, WgpuComputeTestMultiBuffer, WgslComputeShader}; +use difftest::scaffold::compute::{BufferConfig, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -19,7 +19,7 @@ fn main() { BufferConfig::writeback(size_of_val(input_data.as_slice())), ]; - let test = WgpuComputeTestMultiBuffer::new(WgslComputeShader::default(), [1, 1, 1], buffers); + let test = WgpuComputeTest::new(WgslComputeShader::default(), [1, 1, 1], buffers); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/lib/src/scaffold/compute/mod.rs b/tests/difftests/tests/lib/src/scaffold/compute/mod.rs index 645c818873e..e7bcae2a403 100644 --- a/tests/difftests/tests/lib/src/scaffold/compute/mod.rs +++ b/tests/difftests/tests/lib/src/scaffold/compute/mod.rs @@ -7,4 +7,4 @@ pub use ash; pub use ash_runner::AshBackend; pub use backend::{BufferConfig, BufferUsage, ComputeBackend, ComputeShaderTest, ComputeTest}; pub use wgpu; -pub use wgpu_runner::WgpuComputeTestMultiBuffer; +pub use wgpu_runner::WgpuComputeTest; diff --git a/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs index 9893a49cf82..f2621bbdd59 100644 --- a/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs +++ b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs @@ -7,7 +7,7 @@ use futures::executor::block_on; use wgpu::{ExperimentalFeatures, util::DeviceExt}; /// More flexible compute test that supports multiple buffers. -pub struct WgpuComputeTestMultiBuffer { +pub struct WgpuComputeTest { pub features: wgpu::Features, pub shader: S, pub dispatch: [u32; 3], @@ -15,7 +15,7 @@ pub struct WgpuComputeTestMultiBuffer { pub push_constant: Option>, } -impl WgpuComputeTestMultiBuffer +impl WgpuComputeTest where S: WgpuShader, { diff --git a/tests/difftests/tests/simple-compute/simple-compute-rust/src/main.rs b/tests/difftests/tests/simple-compute/simple-compute-rust/src/main.rs index 3b6e4db3d77..0941b974d12 100644 --- a/tests/difftests/tests/simple-compute/simple-compute-rust/src/main.rs +++ b/tests/difftests/tests/simple-compute/simple-compute-rust/src/main.rs @@ -1,16 +1,12 @@ use difftest::config::Config; -use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTestMultiBuffer}; +use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTest}; fn main() { // Load the config from the harness. let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); // Define test parameters, loading the rust shader from the current crate. - let test = WgpuComputeTestMultiBuffer::new_single_buffer( - RustComputeShader::default(), - [1, 1, 1], - 1024, - ); + let test = WgpuComputeTest::new_single_buffer(RustComputeShader::default(), [1, 1, 1], 1024); // Run the test and write the output to a file. test.run_test(&config).unwrap(); diff --git a/tests/difftests/tests/simple-compute/simple-compute-wgsl/src/main.rs b/tests/difftests/tests/simple-compute/simple-compute-wgsl/src/main.rs index 4b64d3e48e8..8502614428d 100644 --- a/tests/difftests/tests/simple-compute/simple-compute-wgsl/src/main.rs +++ b/tests/difftests/tests/simple-compute/simple-compute-wgsl/src/main.rs @@ -1,16 +1,12 @@ use difftest::config::Config; -use difftest::scaffold::compute::{WgpuComputeTestMultiBuffer, WgslComputeShader}; +use difftest::scaffold::compute::{WgpuComputeTest, WgslComputeShader}; fn main() { // Load the config from the harness. let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); // Define test parameters, loading the wgsl shader from the crate directory. - let test = WgpuComputeTestMultiBuffer::new_single_buffer( - WgslComputeShader::default(), - [1, 1, 1], - 1024, - ); + let test = WgpuComputeTest::new_single_buffer(WgslComputeShader::default(), [1, 1, 1], 1024); // Run the test and write the output to a file. test.run_test(&config).unwrap(); diff --git a/tests/difftests/tests/storage_class/array_access/array_access-rust/src/main.rs b/tests/difftests/tests/storage_class/array_access/array_access-rust/src/main.rs index 9248d1802e2..f3e1aedef15 100644 --- a/tests/difftests/tests/storage_class/array_access/array_access-rust/src/main.rs +++ b/tests/difftests/tests/storage_class/array_access/array_access-rust/src/main.rs @@ -2,7 +2,7 @@ fn main() { use difftest::config::Config; use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer, + BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTest, }; let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -33,7 +33,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( RustComputeShader::default(), [1, 1, 1], // Single workgroup with 64 threads buffers, diff --git a/tests/difftests/tests/storage_class/array_access/array_access-wgsl/src/main.rs b/tests/difftests/tests/storage_class/array_access/array_access-wgsl/src/main.rs index 3abc3113754..e7eebdbd368 100644 --- a/tests/difftests/tests/storage_class/array_access/array_access-wgsl/src/main.rs +++ b/tests/difftests/tests/storage_class/array_access/array_access-wgsl/src/main.rs @@ -1,7 +1,5 @@ use difftest::config::Config; -use difftest::scaffold::compute::{ - BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader, -}; +use difftest::scaffold::compute::{BufferConfig, BufferUsage, WgpuComputeTest, WgslComputeShader}; fn main() { let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap(); @@ -32,7 +30,7 @@ fn main() { }, ]; - let test = WgpuComputeTestMultiBuffer::new( + let test = WgpuComputeTest::new( WgslComputeShader::default(), [1, 1, 1], // Single workgroup with 64 threads buffers, From 7da4e8ba00dcfc1b77b65ab5a7452e47272940e4 Mon Sep 17 00:00:00 2001 From: firestar99 Date: Mon, 27 Apr 2026 12:46:29 +0200 Subject: [PATCH 3/7] difftest runner: allow direct access to SpirvBuilder --- .../src/scaffold/shader/rust_gpu_shader.rs | 39 +++++++------------ 1 file changed, 14 insertions(+), 25 deletions(-) diff --git a/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs b/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs index eac40d66f21..f1d01998cc9 100644 --- a/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs +++ b/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs @@ -7,47 +7,36 @@ use std::{env, fs}; /// A compute shader written in Rust compiled with spirv-builder. pub struct RustComputeShader { - pub path: PathBuf, - pub target: String, - pub capabilities: Vec, + pub builder: SpirvBuilder, } impl RustComputeShader { - pub fn new>(path: P) -> Self { - Self { - path: path.into(), - target: "spirv-unknown-vulkan1.1".to_string(), - capabilities: Vec::new(), - } + pub fn new(path: impl Into) -> Self { + Self::with_target(path, "spirv-unknown-vulkan1.3") } - pub fn with_target>(path: P, target: impl Into) -> Self { + pub fn with_target(path: impl Into, target: impl Into) -> Self { Self { - path: path.into(), - target: target.into(), - capabilities: Vec::new(), + builder: SpirvBuilder::new(path.into(), target) + .release(true) + .multimodule(false) + .shader_panic_strategy(spirv_builder::ShaderPanicStrategy::SilentExit) + .preserve_bindings(true), } } pub fn with_capability(mut self, capability: spirv_builder::Capability) -> Self { - self.capabilities.push(capability); + self.builder.capabilities.push(capability); self } } impl SpirvShader for RustComputeShader { fn spirv_bytes(&self) -> anyhow::Result<(Vec, String)> { - let mut builder = SpirvBuilder::new(&self.path, &self.target) - .release(true) - .multimodule(false) - .shader_panic_strategy(spirv_builder::ShaderPanicStrategy::SilentExit) - .preserve_bindings(true); - - for capability in &self.capabilities { - builder = builder.capability(*capability); - } - - let artifact = builder.build().context("SpirvBuilder::build() failed")?; + let artifact = self + .builder + .build() + .context("SpirvBuilder::build() failed")?; if artifact.entry_points.len() != 1 { anyhow::bail!( From f664b3176aaf31ec3b6146002ea487ff09ba836b Mon Sep 17 00:00:00 2001 From: firestar99 Date: Mon, 27 Apr 2026 12:49:21 +0200 Subject: [PATCH 4/7] difftest runner: make passthrough optional --- .../src/scaffold/shader/rust_gpu_shader.rs | 41 +++++++++++++------ 1 file changed, 29 insertions(+), 12 deletions(-) diff --git a/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs b/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs index f1d01998cc9..032183ce4c9 100644 --- a/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs +++ b/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs @@ -4,10 +4,12 @@ use spirv_builder::{ModuleResult, SpirvBuilder}; use std::borrow::Cow; use std::path::PathBuf; use std::{env, fs}; +use wgpu::ShaderSource; /// A compute shader written in Rust compiled with spirv-builder. pub struct RustComputeShader { pub builder: SpirvBuilder, + pub passthrough: bool, } impl RustComputeShader { @@ -22,6 +24,7 @@ impl RustComputeShader { .multimodule(false) .shader_panic_strategy(spirv_builder::ShaderPanicStrategy::SilentExit) .preserve_bindings(true), + passthrough: false, } } @@ -29,6 +32,13 @@ impl RustComputeShader { self.builder.capabilities.push(capability); self } + + pub fn passthrough(self) -> Self { + Self { + passthrough: true, + ..self + } + } } impl SpirvShader for RustComputeShader { @@ -70,18 +80,25 @@ impl WgpuShader for RustComputeShader { anyhow::bail!("SPIR-V binary length is not a multiple of 4"); } let shader_words: Vec = bytemuck::cast_slice(&shader_bytes).to_vec(); - let module = unsafe { - device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough { - entry_point: entry_point.clone(), - label: Some("Compute Shader"), - num_workgroups: (0, 0, 0), - runtime_checks: Default::default(), - spirv: Some(Cow::Owned(shader_words)), - dxil: None, - msl: None, - hlsl: None, - glsl: None, - wgsl: None, + let module = if self.passthrough { + unsafe { + device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough { + entry_point: entry_point.clone(), + label: Some("Rust-GPU Compute Shader"), + num_workgroups: (0, 0, 0), + runtime_checks: Default::default(), + spirv: Some(Cow::Owned(shader_words)), + dxil: None, + msl: None, + hlsl: None, + glsl: None, + wgsl: None, + }) + } + } else { + device.create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some("Rust-GPU Compute Shader"), + source: ShaderSource::SpirV(Cow::Owned(shader_words)), }) }; let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { From f1250b9ac64555f92e4b65dfd0c33a74178eba8f Mon Sep 17 00:00:00 2001 From: firestar99 Date: Mon, 27 Apr 2026 14:14:35 +0200 Subject: [PATCH 5/7] difftest runner: update wgu 27 -> 29, cargo update --- tests/difftests/tests/Cargo.lock | 1009 ++++++++++------- .../push_constants-rust/src/main.rs | 2 +- .../push_constants-wgsl/shader.wgsl | 2 +- .../push_constants-wgsl/src/main.rs | 2 +- tests/difftests/tests/lib/Cargo.toml | 2 +- .../lib/src/scaffold/compute/wgpu_runner.rs | 38 +- .../src/scaffold/shader/rust_gpu_shader.rs | 3 +- 7 files changed, 584 insertions(+), 474 deletions(-) diff --git a/tests/difftests/tests/Cargo.lock b/tests/difftests/tests/Cargo.lock index 7104d6799c9..32d5234f6d8 100644 --- a/tests/difftests/tests/Cargo.lock +++ b/tests/difftests/tests/Cargo.lock @@ -65,7 +65,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" dependencies = [ "cfg-if", - "getrandom", + "getrandom 0.3.4", "once_cell", "version_check", "zerocopy", @@ -97,9 +97,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.100" +version = "1.0.102" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" [[package]] name = "ar" @@ -162,30 +162,15 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" -[[package]] -name = "bit-set" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" -dependencies = [ - "bit-vec 0.8.0", -] - [[package]] name = "bit-set" version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "34ddef2995421ab6a5c779542c81ee77c115206f4ad9d5a8e05f4ff49716a3dd" dependencies = [ - "bit-vec 0.9.1", + "bit-vec", ] -[[package]] -name = "bit-vec" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" - [[package]] name = "bit-vec" version = "0.9.1" @@ -200,9 +185,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.10.0" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" dependencies = [ "serde_core", ] @@ -239,22 +224,25 @@ dependencies = [ ] [[package]] -name = "block" -version = "0.1.6" +name = "block2" +version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a" +checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5" +dependencies = [ + "objc2", +] [[package]] name = "bumpalo" -version = "3.19.1" +version = "3.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510" +checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" [[package]] name = "bytemuck" -version = "1.24.0" +version = "1.25.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" dependencies = [ "bytemuck_derive", ] @@ -321,9 +309,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.54" +version = "1.2.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6354c81bbfd62d9cfa9cb3c773c2b7b2a3a482d569de977fd0e961f6e7c00583" +checksum = "d16d90359e986641506914ba71350897565610e87ce0ad9e6f28569db3dd5c6d" dependencies = [ "find-msvc-tools", "jobserver", @@ -343,23 +331,14 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" -[[package]] -name = "codespan-reporting" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81" -dependencies = [ - "serde", - "termcolor", - "unicode-width", -] - [[package]] name = "codespan-reporting" version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681" dependencies = [ + "serde", + "termcolor", "unicode-width", ] @@ -456,33 +435,6 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" -[[package]] -name = "core-foundation" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "core-foundation-sys" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" - -[[package]] -name = "core-graphics-types" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb" -dependencies = [ - "bitflags 2.10.0", - "core-foundation", - "libc", -] - [[package]] name = "crc32fast" version = "1.5.0" @@ -539,6 +491,16 @@ dependencies = [ "serde_json", ] +[[package]] +name = "dispatch2" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" +dependencies = [ + "bitflags 2.11.1", + "objc2", +] + [[package]] name = "displaydoc" version = "0.2.5" @@ -583,9 +545,9 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] name = "erased-serde" -version = "0.4.9" +version = "0.4.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89e8918065695684b2b0702da20382d5ae6065cf3327bc2d6436bd49a71ce9f3" +checksum = "d2add8a07dd6a8d93ff627029c51de145e12686fbc36ecb298ac22e74cf02dec" dependencies = [ "serde", "serde_core", @@ -610,15 +572,15 @@ checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649" [[package]] name = "fastrand" -version = "2.3.0" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" [[package]] name = "find-msvc-tools" -version = "0.1.8" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" [[package]] name = "fixedbitset" @@ -628,9 +590,9 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" [[package]] name = "flate2" -version = "1.1.8" +version = "1.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b375d6465b98090a5f25b1c7703f3859783755aa9a80433b36e0379a3ec2f369" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" dependencies = [ "crc32fast", "miniz_oxide", @@ -648,33 +610,6 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" -[[package]] -name = "foreign-types" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" -dependencies = [ - "foreign-types-macros", - "foreign-types-shared", -] - -[[package]] -name = "foreign-types-macros" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "foreign-types-shared" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" - [[package]] name = "form_urlencoded" version = "1.2.2" @@ -686,9 +621,9 @@ dependencies = [ [[package]] name = "futures" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d" dependencies = [ "futures-channel", "futures-core", @@ -701,9 +636,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d" dependencies = [ "futures-core", "futures-sink", @@ -711,15 +646,15 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" [[package]] name = "futures-executor" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d" dependencies = [ "futures-core", "futures-task", @@ -728,15 +663,15 @@ dependencies = [ [[package]] name = "futures-io" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" +checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" [[package]] name = "futures-macro" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" dependencies = [ "proc-macro2", "quote", @@ -745,21 +680,21 @@ dependencies = [ [[package]] name = "futures-sink" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" [[package]] name = "futures-task" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" [[package]] name = "futures-util" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" dependencies = [ "futures-channel", "futures-core", @@ -769,7 +704,6 @@ dependencies = [ "futures-task", "memchr", "pin-project-lite", - "pin-utils", "slab", ] @@ -781,10 +715,23 @@ checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" dependencies = [ "cfg-if", "libc", - "r-efi", + "r-efi 5.3.0", "wasip2", ] +[[package]] +name = "getrandom" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" +dependencies = [ + "cfg-if", + "libc", + "r-efi 6.0.0", + "wasip2", + "wasip3", +] + [[package]] name = "gimli" version = "0.31.1" @@ -798,30 +745,24 @@ dependencies = [ [[package]] name = "glam" -version = "0.30.9" +version = "0.32.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd47b05dddf0005d850e5644cae7f2b14ac3df487979dbfff3b56f20b1a6ae46" +checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0" dependencies = [ "libm", ] [[package]] -name = "gpu-alloc" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbcd2dba93594b227a1f57ee09b8b9da8892c34d55aa332e034a228d0fe6a171" -dependencies = [ - "bitflags 2.10.0", - "gpu-alloc-types", -] - -[[package]] -name = "gpu-alloc-types" -version = "0.3.0" +name = "gpu-allocator" +version = "0.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "98ff03b468aa837d70984d55f5d3f846f6ec31fe34bbb97c4f85219caeee1ca4" +checksum = "51255ea7cfaadb6c5f1528d43e92a82acb2b96c43365989a28b2d44ee38f8795" dependencies = [ - "bitflags 2.10.0", + "ash", + "hashbrown 0.16.1", + "log", + "presser", + "thiserror", ] [[package]] @@ -830,7 +771,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b89c83349105e3732062a895becfc71a8f921bb71ecbbdd8ff99263e3b53a0ca" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "gpu-descriptor-types", "hashbrown 0.15.5", ] @@ -841,7 +782,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", ] [[package]] @@ -873,9 +814,17 @@ version = "0.16.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" dependencies = [ + "allocator-api2", + "equivalent", "foldhash 0.2.0", ] +[[package]] +name = "hashbrown" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51" + [[package]] name = "heck" version = "0.5.0" @@ -890,12 +839,13 @@ checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df" [[package]] name = "icu_collections" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43" +checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c" dependencies = [ "displaydoc", "potential_utf", + "utf8_iter", "yoke", "zerofrom", "zerovec", @@ -903,9 +853,9 @@ dependencies = [ [[package]] name = "icu_locale_core" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6" +checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29" dependencies = [ "displaydoc", "litemap", @@ -916,9 +866,9 @@ dependencies = [ [[package]] name = "icu_normalizer" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599" +checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4" dependencies = [ "icu_collections", "icu_normalizer_data", @@ -930,15 +880,15 @@ dependencies = [ [[package]] name = "icu_normalizer_data" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a" +checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38" [[package]] name = "icu_properties" -version = "2.1.2" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec" +checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de" dependencies = [ "icu_collections", "icu_locale_core", @@ -950,15 +900,15 @@ dependencies = [ [[package]] name = "icu_properties_data" -version = "2.1.2" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af" +checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14" [[package]] name = "icu_provider" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614" +checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421" dependencies = [ "displaydoc", "icu_locale_core", @@ -969,6 +919,12 @@ dependencies = [ "zerovec", ] +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + [[package]] name = "idna" version = "1.1.0" @@ -992,12 +948,14 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.12.1" +version = "2.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" dependencies = [ "equivalent", - "hashbrown 0.16.1", + "hashbrown 0.17.0", + "serde", + "serde_core", ] [[package]] @@ -1026,9 +984,9 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.15" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "jobserver" @@ -1036,16 +994,18 @@ version = "0.1.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" dependencies = [ - "getrandom", + "getrandom 0.3.4", "libc", ] [[package]] name = "js-sys" -version = "0.3.83" +version = "0.3.95" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8" +checksum = "2964e92d1d9dc3364cae4d718d93f227e3abb088e747d92e0395bfdedf1c12ca" dependencies = [ + "cfg-if", + "futures-util", "once_cell", "wasm-bindgen", ] @@ -1056,11 +1016,17 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + [[package]] name = "libc" -version = "0.2.178" +version = "0.2.186" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" [[package]] name = "libloading" @@ -1074,21 +1040,21 @@ dependencies = [ [[package]] name = "libm" -version = "0.2.15" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" [[package]] name = "linux-raw-sys" -version = "0.11.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" [[package]] name = "litemap" -version = "0.8.1" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77" +checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0" [[package]] name = "litrs" @@ -1117,15 +1083,6 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b3bd0dd2cd90571056fdb71f6275fada10131182f84899f4b2a916e565d81d86" -[[package]] -name = "malloc_buf" -version = "0.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" -dependencies = [ - "libc", -] - [[package]] name = "matchers" version = "0.2.0" @@ -1171,9 +1128,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.7.6" +version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" [[package]] name = "memory_barriers-rust" @@ -1190,21 +1147,6 @@ dependencies = [ "difftest", ] -[[package]] -name = "metal" -version = "0.32.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00c15a6f673ff72ddcc22394663290f870fb224c1bfce55734a75c414150e605" -dependencies = [ - "bitflags 2.10.0", - "block", - "core-graphics-types", - "foreign-types", - "log", - "objc", - "paste", -] - [[package]] name = "miniz_oxide" version = "0.8.9" @@ -1215,33 +1157,6 @@ dependencies = [ "simd-adler32", ] -[[package]] -name = "naga" -version = "27.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "066cf25f0e8b11ee0df221219010f213ad429855f57c494f995590c861a9a7d8" -dependencies = [ - "arrayvec", - "bit-set 0.8.0", - "bitflags 2.10.0", - "cfg-if", - "cfg_aliases", - "codespan-reporting 0.12.0", - "half", - "hashbrown 0.16.1", - "hexf-parse", - "indexmap", - "libm", - "log", - "num-traits", - "once_cell", - "petgraph", - "rustc-hash", - "spirv 0.3.0+sdk-1.3.268.0", - "thiserror", - "unicode-ident", -] - [[package]] name = "naga" version = "29.0.1" @@ -1249,13 +1164,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "aa2630921705b9b01dcdd0b6864b9562ca3c1951eecd0f0c4f5f04f61e412647" dependencies = [ "arrayvec", - "bit-set 0.9.1", - "bitflags 2.10.0", + "bit-set", + "bitflags 2.11.1", "cfg-if", "cfg_aliases", - "codespan-reporting 0.13.1", + "codespan-reporting", "half", "hashbrown 0.16.1", + "hexf-parse", "indexmap", "libm", "log", @@ -1265,6 +1181,7 @@ dependencies = [ "rustc-hash", "spirv 0.4.0+sdk-1.4.341.0", "thiserror", + "unicode-ident", ] [[package]] @@ -1288,9 +1205,9 @@ dependencies = [ [[package]] name = "num_enum" -version = "0.7.5" +version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c" +checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26" dependencies = [ "num_enum_derive", "rustversion", @@ -1298,9 +1215,9 @@ dependencies = [ [[package]] name = "num_enum_derive" -version = "0.7.5" +version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7" +checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8" dependencies = [ "proc-macro2", "quote", @@ -1308,12 +1225,65 @@ dependencies = [ ] [[package]] -name = "objc" -version = "0.2.7" +name = "objc2" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f" +dependencies = [ + "objc2-encode", +] + +[[package]] +name = "objc2-core-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" +dependencies = [ + "bitflags 2.11.1", + "dispatch2", + "objc2", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags 2.11.1", + "objc2", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-metal" +version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +checksum = "a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794" dependencies = [ - "malloc_buf", + "bitflags 2.11.1", + "block2", + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f" +dependencies = [ + "bitflags 2.11.1", + "objc2", + "objc2-core-foundation", + "objc2-foundation", + "objc2-metal", ] [[package]] @@ -1340,14 +1310,14 @@ dependencies = [ "hashbrown 0.15.5", "indexmap", "memchr", - "wasmparser", + "wasmparser 0.236.1", ] [[package]] name = "once_cell" -version = "1.21.3" +version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" [[package]] name = "ordered-float" @@ -1360,9 +1330,9 @@ dependencies = [ [[package]] name = "ordered-float" -version = "5.1.0" +version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f4779c6901a562440c3786d08192c6fbda7c1c2060edd10006b05ee35d10f2d" +checksum = "b7d950ca161dc355eaf28f82b11345ed76c6e1f6eb1f4f4479e0323b9e2fbd0e" dependencies = [ "num-traits", ] @@ -1390,12 +1360,6 @@ dependencies = [ "windows-link", ] -[[package]] -name = "paste" -version = "1.0.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" - [[package]] name = "percent-encoding" version = "2.3.2" @@ -1415,45 +1379,55 @@ dependencies = [ [[package]] name = "pin-project-lite" -version = "0.2.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" - -[[package]] -name = "pin-utils" -version = "0.1.0" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" [[package]] name = "portable-atomic" -version = "1.11.1" +version = "1.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" [[package]] name = "portable-atomic-util" -version = "0.2.4" +version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507" +checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618" dependencies = [ "portable-atomic", ] [[package]] name = "potential_utf" -version = "0.1.4" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77" +checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564" dependencies = [ "zerovec", ] +[[package]] +name = "presser" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa" + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn", +] + [[package]] name = "proc-macro2" -version = "1.0.103" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] @@ -1483,9 +1457,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.42" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -1496,6 +1470,12 @@ version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + [[package]] name = "raw-string" version = "0.3.5" @@ -1508,20 +1488,32 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" +[[package]] +name = "raw-window-metal" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40d213455a5f1dc59214213c7330e074ddf8114c9a42411eb890c767357ce135" +dependencies = [ + "objc2", + "objc2-core-foundation", + "objc2-foundation", + "objc2-quartz-core", +] + [[package]] name = "redox_syscall" version = "0.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", ] [[package]] name = "regex" -version = "1.12.2" +version = "1.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" dependencies = [ "aho-corasick", "memchr", @@ -1531,9 +1523,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.13" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" dependencies = [ "aho-corasick", "memchr", @@ -1542,9 +1534,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.8" +version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58" +checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" [[package]] name = "renderdoc-sys" @@ -1587,7 +1579,7 @@ dependencies = [ "lazy_static", "libc", "log", - "naga 29.0.1", + "naga", "object 0.37.3", "regex", "rspirv", @@ -1629,11 +1621,11 @@ dependencies = [ [[package]] name = "rustix" -version = "1.1.2" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "errno", "libc", "linux-raw-sys", @@ -1655,12 +1647,6 @@ dependencies = [ "twox-hash", ] -[[package]] -name = "ryu" -version = "1.0.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" - [[package]] name = "sanitize-filename" version = "0.6.0" @@ -1678,9 +1664,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" [[package]] name = "semver" -version = "1.0.27" +version = "1.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" dependencies = [ "serde", "serde_core", @@ -1740,15 +1726,15 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.145" +version = "1.0.149" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" dependencies = [ "itoa", "memchr", - "ryu", "serde", "serde_core", + "zmij", ] [[package]] @@ -1777,9 +1763,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" [[package]] name = "simd-adler32" -version = "0.3.8" +version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2" +checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214" [[package]] name = "simple-compute-rust" @@ -1798,9 +1784,9 @@ dependencies = [ [[package]] name = "slab" -version = "0.4.11" +version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" [[package]] name = "smallvec" @@ -1838,7 +1824,7 @@ version = "0.3.0+sdk-1.3.268.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "serde", ] @@ -1848,7 +1834,7 @@ version = "0.4.0+sdk-1.4.341.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9571ea910ebd84c86af4b3ed27f9dbdc6ad06f17c5f96146b2b671e2976744f" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", ] [[package]] @@ -1895,9 +1881,9 @@ version = "0.10.0-alpha.1" [[package]] name = "spirv-tools" -version = "0.13.0" +version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "863f14733a4ecb68c0bde9ea9b93bc58085a4172e76c8cefe7c810c940f02131" +checksum = "43bbd243a64a3ac7f87f8f026977285fc578698627337bd65a309576e89ad00f" dependencies = [ "memchr", "spirv-tools-sys", @@ -1906,9 +1892,9 @@ dependencies = [ [[package]] name = "spirv-tools-sys" -version = "0.13.0" +version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "219df977b2dd5a34a3529a7f7d2be12727abd87e4545abd0d54edd4fa2cfe5a8" +checksum = "3dbb2c54a9c790946820dd59163c63155e00204e0cbdc4d18374bee4d868ae66" dependencies = [ "cc", ] @@ -1948,9 +1934,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.111" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -1970,12 +1956,12 @@ dependencies = [ [[package]] name = "tempfile" -version = "3.23.0" +version = "3.27.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom", + "getrandom 0.4.2", "once_cell", "rustix", "windows-sys", @@ -1992,18 +1978,18 @@ dependencies = [ [[package]] name = "thiserror" -version = "2.0.17" +version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "2.0.17" +version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" dependencies = [ "proc-macro2", "quote", @@ -2033,9 +2019,9 @@ dependencies = [ [[package]] name = "tinystr" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869" +checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d" dependencies = [ "displaydoc", "zerovec", @@ -2137,9 +2123,9 @@ dependencies = [ [[package]] name = "tracing-subscriber" -version = "0.3.22" +version = "0.3.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e" +checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" dependencies = [ "matchers", "nu-ansi-term", @@ -2218,9 +2204,9 @@ checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c" [[package]] name = "unicode-ident" -version = "1.0.22" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "unicode-width" @@ -2236,9 +2222,9 @@ checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" [[package]] name = "url" -version = "2.5.7" +version = "2.5.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" dependencies = [ "form_urlencoded", "idna", @@ -2315,18 +2301,27 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "wasip2" -version = "1.0.1+wasi-0.2.4" +version = "1.0.3+wasi-0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" +checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" dependencies = [ - "wit-bindgen", + "wit-bindgen 0.57.1", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen 0.51.0", ] [[package]] name = "wasm-bindgen" -version = "0.2.106" +version = "0.2.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd" +checksum = "0bf938a0bacb0469e83c1e148908bd7d5a6010354cf4fb73279b7447422e3a89" dependencies = [ "cfg-if", "once_cell", @@ -2335,11 +2330,21 @@ dependencies = [ "wasm-bindgen-shared", ] +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.68" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f371d383f2fb139252e0bfac3b81b265689bf45b6874af544ffa4c975ac1ebf8" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + [[package]] name = "wasm-bindgen-macro" -version = "0.2.106" +version = "0.2.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3" +checksum = "eeff24f84126c0ec2db7a449f0c2ec963c6a49efe0698c4242929da037ca28ed" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -2347,9 +2352,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.106" +version = "0.2.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40" +checksum = "9d08065faf983b2b80a79fd87d8254c409281cf7de75fc4b773019824196c904" dependencies = [ "bumpalo", "proc-macro2", @@ -2360,27 +2365,61 @@ dependencies = [ [[package]] name = "wasm-bindgen-shared" -version = "0.2.106" +version = "0.2.118" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4" +checksum = "5fd04d9e306f1907bd13c6361b5c6bfc7b3b3c095ed3f8a9246390f8dbdee129" dependencies = [ "unicode-ident", ] +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser 0.244.0", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder", + "wasmparser 0.244.0", +] + [[package]] name = "wasmparser" version = "0.236.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a9b1e81f3eb254cf7404a82cee6926a4a3ccc5aad80cc3d43608a070c67aa1d7" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags 2.11.1", + "hashbrown 0.15.5", + "indexmap", + "semver", ] [[package]] name = "web-sys" -version = "0.3.83" +version = "0.3.95" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac" +checksum = "4f2dfbb17949fa2088e5d39408c48368947b86f7834484e87b73de55bc14d97d" dependencies = [ "js-sys", "wasm-bindgen", @@ -2388,24 +2427,29 @@ dependencies = [ [[package]] name = "wgpu" -version = "27.0.1" +version = "29.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfe68bac7cde125de7a731c3400723cadaaf1703795ad3f4805f187459cd7a77" +checksum = "72c239a9a747bbd379590985bac952c2e53cb19873f7072b3370c6a6a8e06837" dependencies = [ "arrayvec", - "bitflags 2.10.0", + "bitflags 2.11.1", + "bytemuck", "cfg-if", "cfg_aliases", "document-features", "hashbrown 0.16.1", + "js-sys", "log", - "naga 27.0.3", + "naga", "parking_lot", "portable-atomic", "profiling", "raw-window-handle", "smallvec", "static_assertions", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", "wgpu-core", "wgpu-hal", "wgpu-types", @@ -2413,21 +2457,21 @@ dependencies = [ [[package]] name = "wgpu-core" -version = "27.0.3" +version = "29.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "27a75de515543b1897b26119f93731b385a19aea165a1ec5f0e3acecc229cae7" +checksum = "1e80ac6cf1895df6342f87d975162108f9d98772a0d74bc404ab7304ac29469e" dependencies = [ "arrayvec", - "bit-set 0.8.0", - "bit-vec 0.8.0", - "bitflags 2.10.0", + "bit-set", + "bit-vec", + "bitflags 2.11.1", "bytemuck", "cfg_aliases", "document-features", "hashbrown 0.16.1", "indexmap", "log", - "naga 27.0.3", + "naga", "once_cell", "parking_lot", "portable-atomic", @@ -2439,75 +2483,90 @@ dependencies = [ "wgpu-core-deps-apple", "wgpu-core-deps-windows-linux-android", "wgpu-hal", + "wgpu-naga-bridge", "wgpu-types", ] [[package]] name = "wgpu-core-deps-apple" -version = "27.0.0" +version = "29.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0772ae958e9be0c729561d5e3fd9a19679bcdfb945b8b1a1969d9bfe8056d233" +checksum = "43acd053312501689cd92a01a9638d37f3e41a5fd9534875efa8917ee2d11ac0" dependencies = [ "wgpu-hal", ] [[package]] name = "wgpu-core-deps-windows-linux-android" -version = "27.0.0" +version = "29.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71197027d61a71748e4120f05a9242b2ad142e3c01f8c1b47707945a879a03c3" +checksum = "725d5c006a8c02967b6d93ef04f6537ec4593313e330cfe86d9d3f946eb90f28" dependencies = [ "wgpu-hal", ] [[package]] name = "wgpu-hal" -version = "27.0.4" +version = "29.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b21cb61c57ee198bc4aff71aeadff4cbb80b927beb912506af9c780d64313ce" +checksum = "89a47aef47636562f3937285af4c44b4b5b404b46577471411cc5313a921da7e" dependencies = [ "android_system_properties", "arrayvec", "ash", - "bitflags 2.10.0", - "block", + "bitflags 2.11.1", + "block2", "bytemuck", "cfg-if", "cfg_aliases", - "core-graphics-types", - "gpu-alloc", + "gpu-allocator", "gpu-descriptor", "hashbrown 0.16.1", "libc", "libloading", "log", - "metal", - "naga 27.0.3", - "objc", - "ordered-float 5.1.0", + "naga", + "objc2", + "objc2-core-foundation", + "objc2-foundation", + "objc2-metal", + "objc2-quartz-core", + "ordered-float 5.3.0", "parking_lot", "portable-atomic", "portable-atomic-util", "profiling", "raw-window-handle", + "raw-window-metal", "renderdoc-sys", "smallvec", "thiserror", + "wgpu-naga-bridge", "wgpu-types", "windows", ] +[[package]] +name = "wgpu-naga-bridge" +version = "29.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b4684f4410da0cf95a4cb63bb5edaac022461dedb6adf0b64d0d9b5f6890d51" +dependencies = [ + "naga", + "wgpu-types", +] + [[package]] name = "wgpu-types" -version = "27.0.1" +version = "29.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "afdcf84c395990db737f2dd91628706cb31e86d72e53482320d368e52b5da5eb" +checksum = "ec2675540fb1a5cfa5ef122d3d5f390e2c75711a0b946410f2d6ac3a0f77d1f6" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "bytemuck", "js-sys", "log", - "thiserror", + "raw-window-handle", "web-sys", ] @@ -2522,32 +2581,54 @@ dependencies = [ [[package]] name = "windows" -version = "0.58.0" +version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6" +checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" +dependencies = [ + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", +] + +[[package]] +name = "windows-collections" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" dependencies = [ "windows-core", - "windows-targets", ] [[package]] name = "windows-core" -version = "0.58.0" +version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ "windows-implement", "windows-interface", + "windows-link", "windows-result", "windows-strings", - "windows-targets", +] + +[[package]] +name = "windows-future" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" +dependencies = [ + "windows-core", + "windows-link", + "windows-threading", ] [[package]] name = "windows-implement" -version = "0.58.0" +version = "0.60.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", @@ -2556,9 +2637,9 @@ dependencies = [ [[package]] name = "windows-interface" -version = "0.58.0" +version = "0.59.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", @@ -2571,23 +2652,32 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" +[[package]] +name = "windows-numerics" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" +dependencies = [ + "windows-core", + "windows-link", +] + [[package]] name = "windows-result" -version = "0.2.0" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" dependencies = [ - "windows-targets", + "windows-link", ] [[package]] name = "windows-strings" -version = "0.1.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" dependencies = [ - "windows-result", - "windows-targets", + "windows-link", ] [[package]] @@ -2600,83 +2690,116 @@ dependencies = [ ] [[package]] -name = "windows-targets" -version = "0.52.6" +name = "windows-threading" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_gnullvm", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", + "windows-link", ] [[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.6" +name = "winnow" +version = "0.7.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" +dependencies = [ + "memchr", +] [[package]] -name = "windows_i686_gnullvm" -version = "0.52.6" +name = "wit-bindgen" +version = "0.51.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "wit-bindgen-rust-macro", +] [[package]] -name = "windows_i686_msvc" -version = "0.52.6" +name = "wit-bindgen" +version = "0.57.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" [[package]] -name = "windows_x86_64_gnu" -version = "0.52.6" +name = "wit-bindgen-core" +version = "0.51.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] [[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.6" +name = "wit-bindgen-rust" +version = "0.51.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] [[package]] -name = "windows_x86_64_msvc" -version = "0.52.6" +name = "wit-bindgen-rust-macro" +version = "0.51.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core", + "wit-bindgen-rust", +] [[package]] -name = "winnow" -version = "0.7.14" +name = "wit-component" +version = "0.244.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" dependencies = [ - "memchr", + "anyhow", + "bitflags 2.11.1", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser 0.244.0", + "wit-parser", ] [[package]] -name = "wit-bindgen" -version = "0.46.0" +name = "wit-parser" +version = "0.244.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser 0.244.0", +] [[package]] name = "workgroup_memory-ash" @@ -2706,15 +2829,15 @@ dependencies = [ [[package]] name = "writeable" -version = "0.6.2" +version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" +checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4" [[package]] name = "yoke" -version = "0.8.1" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954" +checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca" dependencies = [ "stable_deref_trait", "yoke-derive", @@ -2723,9 +2846,9 @@ dependencies = [ [[package]] name = "yoke-derive" -version = "0.8.1" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" +checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" dependencies = [ "proc-macro2", "quote", @@ -2735,18 +2858,18 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.31" +version = "0.8.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3" +checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.31" +version = "0.8.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a" +checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4" dependencies = [ "proc-macro2", "quote", @@ -2755,18 +2878,18 @@ dependencies = [ [[package]] name = "zerofrom" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df" dependencies = [ "zerofrom-derive", ] [[package]] name = "zerofrom-derive" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" dependencies = [ "proc-macro2", "quote", @@ -2776,9 +2899,9 @@ dependencies = [ [[package]] name = "zerotrie" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851" +checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf" dependencies = [ "displaydoc", "yoke", @@ -2787,9 +2910,9 @@ dependencies = [ [[package]] name = "zerovec" -version = "0.11.5" +version = "0.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002" +checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239" dependencies = [ "yoke", "zerofrom", @@ -2798,11 +2921,17 @@ dependencies = [ [[package]] name = "zerovec-derive" -version = "0.11.2" +version = "0.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3" +checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555" dependencies = [ "proc-macro2", "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs b/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs index b6398ef2694..f907394db1b 100644 --- a/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs +++ b/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs @@ -45,7 +45,7 @@ fn main() { }, ], ) - .with_feature(Features::PUSH_CONSTANTS) + .with_feature(Features::IMMEDIATES) .with_push_constant(&push_constants); test.run_test(&config).unwrap(); diff --git a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/shader.wgsl b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/shader.wgsl index 1977d38ff21..baf57dbbc1d 100644 --- a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/shader.wgsl +++ b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/shader.wgsl @@ -5,7 +5,7 @@ struct PushConstants { count: u32, } -var push_constants: PushConstants; +var push_constants: PushConstants; @group(0) @binding(0) var input: array; diff --git a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs index 33df0963465..b18857bbace 100644 --- a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs +++ b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs @@ -45,7 +45,7 @@ fn main() { }, ], ) - .with_feature(Features::PUSH_CONSTANTS) + .with_feature(Features::IMMEDIATES) .with_push_constant(&push_constants); test.run_test(&config).unwrap(); diff --git a/tests/difftests/tests/lib/Cargo.toml b/tests/difftests/tests/lib/Cargo.toml index 4b100508b8c..ba404135083 100644 --- a/tests/difftests/tests/lib/Cargo.toml +++ b/tests/difftests/tests/lib/Cargo.toml @@ -25,7 +25,7 @@ spirv-builder.workspace = true difftest-types.workspace = true serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" -wgpu = { version = "27.0.1", default-features = false, features = ["std", "parking_lot", "spirv", "wgsl", "vulkan", "vulkan-portability", "metal"] } +wgpu = { version = "29.0.1", default-features = false, features = ["std", "parking_lot", "spirv", "wgsl", "vulkan", "vulkan-portability", "metal"] } ash = { version = "0.38" } tempfile = "3.5" futures = "0.3.31" diff --git a/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs index f2621bbdd59..516aaa85728 100644 --- a/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs +++ b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs @@ -56,22 +56,7 @@ where } pub fn run(self) -> anyhow::Result>> { - let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor { - #[cfg(target_os = "linux")] - backends: wgpu::Backends::VULKAN, - #[cfg(not(target_os = "linux"))] - backends: wgpu::Backends::PRIMARY, - flags: Default::default(), - memory_budget_thresholds: Default::default(), - backend_options: wgpu::BackendOptions { - #[cfg(target_os = "windows")] - dx12: wgpu::Dx12BackendOptions { - shader_compiler: wgpu::Dx12Compiler::StaticDxc, - ..Default::default() - }, - ..Default::default() - }, - }); + let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); let adapter = block_on(instance.request_adapter(&wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, compatible_surface: None, @@ -80,9 +65,9 @@ where .context("Failed to find a suitable GPU adapter")?; let (device, queue) = block_on(adapter.request_device(&wgpu::DeviceDescriptor { label: Some("wgpu Device"), - required_features: wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS | self.features, + required_features: wgpu::Features::PASSTHROUGH_SHADERS | self.features, required_limits: wgpu::Limits { - max_push_constant_size: 128, + max_immediate_size: 128, ..wgpu::Limits::default() }, experimental_features: unsafe { ExperimentalFeatures::enabled() }, @@ -96,8 +81,8 @@ where &device, &device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("Pipeline Layout"), - bind_group_layouts: &[&device.create_bind_group_layout( - &wgpu::BindGroupLayoutDescriptor { + bind_group_layouts: &[Some( + &device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("Bind Group Layout"), entries: &buffers .iter() @@ -125,16 +110,13 @@ where count: None, }) .collect::>(), - }, + }), )], - push_constant_ranges: self + immediate_size: self .push_constant .as_ref() - .map(|data| wgpu::PushConstantRange { - stages: wgpu::ShaderStages::COMPUTE, - range: 0..data.len() as u32, - }) - .as_slice(), + .map(|data| data.len() as u32) + .unwrap_or(0), }), )?; @@ -203,7 +185,7 @@ where pass.set_pipeline(&pipeline); pass.set_bind_group(0, &bind_group, &[]); if let Some(push_constant) = self.push_constant { - pass.set_push_constants(0, &push_constant); + pass.set_immediates(0, &push_constant); } pass.dispatch_workgroups(self.dispatch[0], self.dispatch[1], self.dispatch[2]); } diff --git a/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs b/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs index 032183ce4c9..bac09d2e142 100644 --- a/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs +++ b/tests/difftests/tests/lib/src/scaffold/shader/rust_gpu_shader.rs @@ -83,16 +83,15 @@ impl WgpuShader for RustComputeShader { let module = if self.passthrough { unsafe { device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough { - entry_point: entry_point.clone(), label: Some("Rust-GPU Compute Shader"), num_workgroups: (0, 0, 0), - runtime_checks: Default::default(), spirv: Some(Cow::Owned(shader_words)), dxil: None, msl: None, hlsl: None, glsl: None, wgsl: None, + metallib: None, }) } } else { From 73ab877eb9504eca4dd0c2c70ebb059ca7eba249 Mon Sep 17 00:00:00 2001 From: firestar99 Date: Mon, 4 May 2026 13:43:49 +0200 Subject: [PATCH 6/7] difftest runner: eddyb's suggestions, cleanup wgpu AI code --- .../push_constants-rust/src/main.rs | 3 +- .../push_constants-wgsl/src/main.rs | 3 +- .../lib/src/scaffold/compute/wgpu_runner.rs | 210 ++++++++---------- 3 files changed, 98 insertions(+), 118 deletions(-) diff --git a/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs b/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs index f907394db1b..d52004643bf 100644 --- a/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs +++ b/tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs @@ -45,8 +45,7 @@ fn main() { }, ], ) - .with_feature(Features::IMMEDIATES) - .with_push_constant(&push_constants); + .with_immediates(&push_constants); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs index b18857bbace..9370a5320c1 100644 --- a/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs +++ b/tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs @@ -45,8 +45,7 @@ fn main() { }, ], ) - .with_feature(Features::IMMEDIATES) - .with_push_constant(&push_constants); + .with_immediates(&push_constants); test.run_test(&config).unwrap(); } diff --git a/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs index 516aaa85728..07de2f174e8 100644 --- a/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs +++ b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs @@ -48,14 +48,15 @@ where } } - pub fn with_push_constant(self, data: &T) -> Self { + pub fn with_immediates(self, data: &T) -> Self { Self { push_constant: Some(bytemuck::bytes_of(data).to_vec()), + features: self.features | wgpu::Features::IMMEDIATES, ..self } } - pub fn run(self) -> anyhow::Result>> { + pub fn run(&self) -> anyhow::Result>>> { let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle()); let adapter = block_on(instance.request_adapter(&wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, @@ -90,22 +91,18 @@ where .map(|(i, buffer_config)| wgpu::BindGroupLayoutEntry { binding: i as u32, visibility: wgpu::ShaderStages::COMPUTE, - ty: match buffer_config.usage { - BufferUsage::Storage => wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Storage { read_only: false }, - has_dynamic_offset: false, - min_binding_size: None, - }, - BufferUsage::StorageReadOnly => wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Storage { read_only: true }, - has_dynamic_offset: false, - min_binding_size: None, - }, - BufferUsage::Uniform => wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Uniform, - has_dynamic_offset: false, - min_binding_size: None, + ty: wgpu::BindingType::Buffer { + ty: match buffer_config.usage { + BufferUsage::Storage => { + wgpu::BufferBindingType::Storage { read_only: false } + } + BufferUsage::StorageReadOnly => { + wgpu::BufferBindingType::Storage { read_only: true } + } + BufferUsage::Uniform => wgpu::BufferBindingType::Uniform, }, + has_dynamic_offset: false, + min_binding_size: None, }, count: None, }) @@ -121,59 +118,55 @@ where )?; // Create buffers. - let mut gpu_buffers = Vec::new(); - - for (i, buffer_config) in self.buffers.iter().enumerate() { - let usage = match buffer_config.usage { - BufferUsage::Storage => wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC, - BufferUsage::StorageReadOnly => { - wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC - } - BufferUsage::Uniform => wgpu::BufferUsages::UNIFORM, - }; - - let buffer = if let Some(initial_data) = &buffer_config.initial_data { - device.create_buffer_init(&wgpu::util::BufferInitDescriptor { - label: Some(&format!("Buffer {i}")), - contents: initial_data, - usage, - }) - } else { - let buffer = device.create_buffer(&wgpu::BufferDescriptor { - label: Some(&format!("Buffer {i}")), - size: buffer_config.size, - usage, - mapped_at_creation: true, - }); - { - // Zero the buffer. - let initial_data = vec![0u8; buffer_config.size as usize]; - let mut mapping = buffer.slice(..).get_mapped_range_mut(); - mapping.copy_from_slice(&initial_data); - } - buffer.unmap(); - buffer - }; - - gpu_buffers.push(buffer); - } - - // Create bind entries after all buffers are created - let bind_entries: Vec<_> = gpu_buffers + let gpu_buffers = self + .buffers .iter() .enumerate() - .map(|(i, buffer)| wgpu::BindGroupEntry { - binding: i as u32, - resource: buffer.as_entire_binding(), + .map(|(i, buffer_config)| { + let usage = match buffer_config.usage { + BufferUsage::Storage => { + wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC + } + BufferUsage::StorageReadOnly => { + wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC + } + BufferUsage::Uniform => wgpu::BufferUsages::UNIFORM, + }; + + let buffer = if let Some(initial_data) = &buffer_config.initial_data { + device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some(&format!("Buffer {i}")), + contents: initial_data, + usage, + }) + } else { + device.create_buffer(&wgpu::BufferDescriptor { + label: Some(&format!("Buffer {i}")), + size: buffer_config.size, + usage, + mapped_at_creation: false, + }) + }; + + (buffer_config, buffer) }) - .collect(); + .collect::>(); + // Create bind entries after all buffers are created let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { layout: &pipeline.get_bind_group_layout(0), - entries: &bind_entries, + entries: &gpu_buffers + .iter() + .enumerate() + .map(|(i, (_, buffer))| wgpu::BindGroupEntry { + binding: i as u32, + resource: buffer.as_entire_binding(), + }) + .collect::>(), label: Some("Compute Bind Group"), }); + // record command encoder let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Compute Encoder"), }); @@ -184,72 +177,61 @@ where }); pass.set_pipeline(&pipeline); pass.set_bind_group(0, &bind_group, &[]); - if let Some(push_constant) = self.push_constant { + if let Some(push_constant) = &self.push_constant { pass.set_immediates(0, &push_constant); } pass.dispatch_workgroups(self.dispatch[0], self.dispatch[1], self.dispatch[2]); } - // Create staging buffers and copy results. - let mut staging_buffers = Vec::new(); - for (i, buffer_config) in self.buffers.iter().enumerate() { - if matches!( - buffer_config.usage, - BufferUsage::Storage | BufferUsage::StorageReadOnly - ) { - let staging_buffer = device.create_buffer(&wgpu::BufferDescriptor { - label: Some(&format!("Staging Buffer {i}")), - size: buffer_config.size, - usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, - mapped_at_creation: false, - }); - encoder.copy_buffer_to_buffer( - &gpu_buffers[i], - 0, - &staging_buffer, - 0, - buffer_config.size, - ); - staging_buffers.push(Some(staging_buffer)); - } else { - staging_buffers.push(None); - } - } - + // Create staging buffers, copy results and initiate mapping. + let download_buffers = gpu_buffers + .iter() + .enumerate() + .map(|(i, (buffer_config, buffer))| { + matches!(buffer_config.usage, BufferUsage::Storage).then(|| { + let staging_buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: Some(&format!("Staging Buffer {i}")), + size: buffer_config.size, + usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + encoder.copy_buffer_to_buffer( + &buffer, + 0, + &staging_buffer, + 0, + buffer_config.size, + ); + encoder.map_buffer_on_submit( + &staging_buffer, + wgpu::MapMode::Read, + .., + move |r| r.unwrap(), + ); + staging_buffer + }) + }) + .collect::>(); queue.submit(Some(encoder.finish())); + device.poll(wgpu::PollType::wait_indefinitely())?; - // Read back results. - let mut results = Vec::new(); - for staging_buffer in staging_buffers { - if let Some(buffer) = staging_buffer { - let buffer_slice = buffer.slice(..); - let (sender, receiver) = futures::channel::oneshot::channel(); - buffer_slice.map_async(wgpu::MapMode::Read, move |res| { - let _ = sender.send(res); - }); - device.poll(wgpu::PollType::wait_indefinitely())?; - block_on(receiver) - .context("mapping canceled")? - .context("mapping failed")?; - let data = buffer_slice.get_mapped_range().to_vec(); - buffer.unmap(); - results.push(data); - } else { - results.push(Vec::new()); - } - } - + // copy data from buffers into Vecs + let results = download_buffers + .into_iter() + .map(|buffer| buffer.map(|buffer| buffer.get_mapped_range(..).to_vec())) + .collect::>(); Ok(results) } pub fn run_test(self, config: &Config) -> anyhow::Result<()> { - let buffers = self.buffers.clone(); let outputs = self.run()?; // Write the first storage buffer output to the file. - for (output, buffer_config) in outputs.iter().zip(&buffers) { - if matches!(buffer_config.usage, BufferUsage::Storage) && !output.is_empty() { - config.write_result(output)?; - return Ok(()); + for output in &outputs { + if let Some(output) = output { + if !output.is_empty() { + config.write_result(output)?; + return Ok(()); + } } } anyhow::bail!("No storage buffer output found") From 6c892fd88aae90ff8af18e3532e681a1f3cabfab Mon Sep 17 00:00:00 2001 From: firestar99 Date: Mon, 4 May 2026 13:43:49 +0200 Subject: [PATCH 7/7] difftest runner: append multiple output buffers instead of just using the first one --- .../lib/src/scaffold/compute/wgpu_runner.rs | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs index 07de2f174e8..c10af5c2988 100644 --- a/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs +++ b/tests/difftests/tests/lib/src/scaffold/compute/wgpu_runner.rs @@ -225,15 +225,16 @@ where pub fn run_test(self, config: &Config) -> anyhow::Result<()> { let outputs = self.run()?; - // Write the first storage buffer output to the file. - for output in &outputs { - if let Some(output) = output { - if !output.is_empty() { - config.write_result(output)?; - return Ok(()); - } - } + let output = outputs + .iter() + .filter_map(Option::as_ref) + .flatten() + .copied() + .collect::>(); + if output.is_empty() { + anyhow::bail!("No storage buffer output found") } - anyhow::bail!("No storage buffer output found") + config.write_result(&output)?; + Ok(()) } }