Cargo fmt

Author: LegNeato

tests/difftests/tests/arch/atomic_ops/atomic_ops-rust/src/lib.rs

@@ -14,20 +14,20 @@ pub fn main_cs(
     const SEMANTICS: u32 = Semantics::NONE.bits();
 
     let tid = global_id.x;
-    
+
     // All threads participate in atomic operations
     // Each thread adds 1 to the first counter
     unsafe { atomic_i_add::<_, SCOPE, SEMANTICS>(&mut counters[0], 1) };
-    
-    // Each thread subtracts 1 from the second counter  
+
+    // Each thread subtracts 1 from the second counter
     unsafe { atomic_i_sub::<_, SCOPE, SEMANTICS>(&mut counters[1], 1) };
-    
+
     // Each thread tries to set minimum with their thread ID
     unsafe { atomic_u_min::<_, SCOPE, SEMANTICS>(&mut counters[2], tid) };
-    
+
     // Each thread tries to set maximum with their thread ID
     unsafe { atomic_u_max::<_, SCOPE, SEMANTICS>(&mut counters[3], tid) };
-    
+
     // Thread 0 stores the final values after all operations complete
     if tid == 0 {
         // Use atomic loads to ensure we read the final values

tests/difftests/tests/arch/memory_barriers/memory_barriers-rust/src/lib.rs

@@ -1,7 +1,7 @@
 #![no_std]
 
-use spirv_std::spirv;
 use spirv_std::arch::workgroup_memory_barrier_with_group_sync;
+use spirv_std::spirv;
 
 #[spirv(compute(threads(64)))]
 pub fn main_cs(
@@ -13,19 +13,19 @@ pub fn main_cs(
 ) {
     let tid = global_id.x as usize;
     let lid = local_id.x as usize;
-    
+
     if tid < input.len() && tid < output.len() && lid < 64 {
         // Load data into shared memory
         shared[lid] = input[tid];
-        
+
         // Workgroup barrier to ensure all threads have loaded their data
         unsafe {
             workgroup_memory_barrier_with_group_sync();
         }
-        
+
         // Perform operations on shared memory
         let mut result = shared[lid];
-        
+
         // Different threads perform different operations
         if lid % 4 == 0 {
             // Read from neighboring thread's data
@@ -46,21 +46,21 @@ pub fn main_cs(
             // XOR with wrapped neighbor
             result ^= shared[(lid + 32) % 64];
         }
-        
+
         // Another barrier before writing back
         unsafe {
             workgroup_memory_barrier_with_group_sync();
         }
-        
+
         // Write result back to shared memory
         shared[lid] = result;
-        
+
         // Memory barrier to ensure writes are visible
         unsafe {
             workgroup_memory_barrier_with_group_sync();
         }
-        
+
         // Final read and output
         output[tid] = shared[lid];
     }
-}
+}

tests/difftests/tests/arch/memory_barriers/memory_barriers-rust/src/main.rs

@@ -1,31 +1,27 @@
 use difftest::config::Config;
-use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTestMultiBuffer, BufferConfig, BufferUsage};
+use difftest::scaffold::compute::{
+    BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestMultiBuffer,
+};
 
 fn main() {
     let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap();
-    
+
     let buffer_size = 256;
     let initial_data: Vec<u32> = (0..64).collect();
-    let initial_bytes: Vec<u8> = initial_data.iter()
-        .flat_map(|&x| x.to_ne_bytes())
-        .collect();
-    
-    let test = WgpuComputeTestMultiBuffer::new(
-        RustComputeShader::default(),
-        [1, 1, 1],
-        vec![
-            BufferConfig {
-                size: buffer_size,
-                usage: BufferUsage::StorageReadOnly,
-                initial_data: Some(initial_bytes),
-            },
-            BufferConfig {
-                size: buffer_size,
-                usage: BufferUsage::Storage,
-                initial_data: None,
-            },
-        ],
-    );
-    
+    let initial_bytes: Vec<u8> = initial_data.iter().flat_map(|&x| x.to_ne_bytes()).collect();
+
+    let test = WgpuComputeTestMultiBuffer::new(RustComputeShader::default(), [1, 1, 1], vec![
+        BufferConfig {
+            size: buffer_size,
+            usage: BufferUsage::StorageReadOnly,
+            initial_data: Some(initial_bytes),
+        },
+        BufferConfig {
+            size: buffer_size,
+            usage: BufferUsage::Storage,
+            initial_data: None,
+        },
+    ]);
+
     test.run_test(&config).unwrap();
-}
+}

tests/difftests/tests/arch/memory_barriers/memory_barriers-wgsl/src/main.rs

@@ -1,31 +1,27 @@
 use difftest::config::Config;
-use difftest::scaffold::compute::{WgslComputeShader, WgpuComputeTestMultiBuffer, BufferConfig, BufferUsage};
+use difftest::scaffold::compute::{
+    BufferConfig, BufferUsage, WgpuComputeTestMultiBuffer, WgslComputeShader,
+};
 
 fn main() {
     let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap();
-    
+
     let buffer_size = 256;
     let initial_data: Vec<u32> = (0..64).collect();
-    let initial_bytes: Vec<u8> = initial_data.iter()
-        .flat_map(|&x| x.to_ne_bytes())
-        .collect();
-    
-    let test = WgpuComputeTestMultiBuffer::new(
-        WgslComputeShader::default(),
-        [1, 1, 1],
-        vec![
-            BufferConfig {
-                size: buffer_size,
-                usage: BufferUsage::StorageReadOnly,
-                initial_data: Some(initial_bytes),
-            },
-            BufferConfig {
-                size: buffer_size,
-                usage: BufferUsage::Storage,
-                initial_data: None,
-            },
-        ],
-    );
-    
+    let initial_bytes: Vec<u8> = initial_data.iter().flat_map(|&x| x.to_ne_bytes()).collect();
+
+    let test = WgpuComputeTestMultiBuffer::new(WgslComputeShader::default(), [1, 1, 1], vec![
+        BufferConfig {
+            size: buffer_size,
+            usage: BufferUsage::StorageReadOnly,
+            initial_data: Some(initial_bytes),
+        },
+        BufferConfig {
+            size: buffer_size,
+            usage: BufferUsage::Storage,
+            initial_data: None,
+        },
+    ]);
+
     test.run_test(&config).unwrap();
-}
+}

tests/difftests/tests/arch/push_constants/push_constants-rust/src/lib.rs

@@ -1,8 +1,8 @@
 #![no_std]
 
-use spirv_std::spirv;
 #[allow(unused_imports)]
 use spirv_std::num_traits::Float;
+use spirv_std::spirv;
 
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
@@ -22,62 +22,62 @@ pub fn main_cs(
 ) {
     let tid = global_id.x as usize;
     let count = push_constants.count as usize;
-    
+
     if tid < input.len() && tid < output.len() && tid < count {
         let value = input[tid];
-        
+
         // Apply different operations based on flags
         let result = match push_constants.flags {
             0 => {
                 // Linear transformation
                 value * push_constants.multiplier + push_constants.offset
-            },
+            }
             1 => {
                 // Quadratic transformation
                 value * value * push_constants.multiplier + push_constants.offset
-            },
+            }
             2 => {
                 // Sine wave modulation
                 (value * push_constants.multiplier).sin() + push_constants.offset
-            },
+            }
             3 => {
                 // Exponential transformation
                 (value * push_constants.multiplier).exp() + push_constants.offset
-            },
+            }
             4 => {
                 // Logarithmic transformation (with protection against negative values)
                 if value > 0.0 {
                     (value * push_constants.multiplier).ln() + push_constants.offset
                 } else {
                     push_constants.offset
                 }
-            },
+            }
             5 => {
                 // Reciprocal transformation (with protection against division by zero)
                 if value.abs() > 0.001 {
                     push_constants.multiplier / value + push_constants.offset
                 } else {
                     push_constants.offset
                 }
-            },
+            }
             6 => {
                 // Power transformation
                 value.powf(push_constants.multiplier) + push_constants.offset
-            },
+            }
             7 => {
                 // Modulo operation (treating multiplier as divisor)
                 if push_constants.multiplier > 0.0 {
                     (value % push_constants.multiplier) + push_constants.offset
                 } else {
                     push_constants.offset
                 }
-            },
+            }
             _ => {
                 // Default: just add offset
                 value + push_constants.offset
             }
         };
-        
+
         output[tid] = result;
     }
-}
+}

tests/difftests/tests/arch/push_constants/push_constants-rust/src/main.rs

@@ -1,5 +1,7 @@
 use difftest::config::Config;
-use difftest::scaffold::compute::{RustComputeShader, WgpuComputeTestPushConstants, BufferConfig, BufferUsage};
+use difftest::scaffold::compute::{
+    BufferConfig, BufferUsage, RustComputeShader, WgpuComputeTestPushConstants,
+};
 
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
@@ -12,26 +14,22 @@ pub struct PushConstants {
 
 fn main() {
     let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap();
-    
+
     let num_elements = 256;
     let buffer_size = num_elements * 4; // 4 bytes per f32
-    
+
     // Create input data
-    let input_data: Vec<f32> = (0..num_elements)
-        .map(|i| i as f32 * 0.1)
-        .collect();
-    let input_bytes: Vec<u8> = input_data.iter()
-        .flat_map(|&x| x.to_ne_bytes())
-        .collect();
-    
+    let input_data: Vec<f32> = (0..num_elements).map(|i| i as f32 * 0.1).collect();
+    let input_bytes: Vec<u8> = input_data.iter().flat_map(|&x| x.to_ne_bytes()).collect();
+
     // Create push constants data
     let push_constants = PushConstants {
         multiplier: 2.5,
         offset: 1.0,
         flags: 0, // Linear transformation
         count: num_elements as u32,
     };
-    
+
     let test = WgpuComputeTestPushConstants::new(
         RustComputeShader::default(),
         [4, 1, 1], // 256 / 64 = 4 workgroups
@@ -50,6 +48,6 @@ fn main() {
         std::mem::size_of::<PushConstants>() as u32,
         bytemuck::bytes_of(&push_constants).to_vec(),
     );
-    
+
     test.run_test(&config).unwrap();
-}
+}

tests/difftests/tests/arch/push_constants/push_constants-wgsl/src/main.rs

@@ -1,5 +1,7 @@
 use difftest::config::Config;
-use difftest::scaffold::compute::{WgslComputeShader, WgpuComputeTestPushConstants, BufferConfig, BufferUsage};
+use difftest::scaffold::compute::{
+    BufferConfig, BufferUsage, WgpuComputeTestPushConstants, WgslComputeShader,
+};
 
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
@@ -12,26 +14,22 @@ pub struct PushConstants {
 
 fn main() {
     let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap();
-    
+
     let num_elements = 256;
     let buffer_size = num_elements * 4; // 4 bytes per f32
-    
+
     // Create input data
-    let input_data: Vec<f32> = (0..num_elements)
-        .map(|i| i as f32 * 0.1)
-        .collect();
-    let input_bytes: Vec<u8> = input_data.iter()
-        .flat_map(|&x| x.to_ne_bytes())
-        .collect();
-    
+    let input_data: Vec<f32> = (0..num_elements).map(|i| i as f32 * 0.1).collect();
+    let input_bytes: Vec<u8> = input_data.iter().flat_map(|&x| x.to_ne_bytes()).collect();
+
     // Create push constants data
     let push_constants = PushConstants {
         multiplier: 2.5,
         offset: 1.0,
         flags: 0, // Linear transformation
         count: num_elements as u32,
     };
-    
+
     let test = WgpuComputeTestPushConstants::new(
         WgslComputeShader::default(),
         [4, 1, 1], // 256 / 64 = 4 workgroups
@@ -50,6 +48,6 @@ fn main() {
         std::mem::size_of::<PushConstants>() as u32,
         bytemuck::bytes_of(&push_constants).to_vec(),
     );
-    
+
     test.run_test(&config).unwrap();
-}
+}