Make backends return errors (#38)

Annoyingly, Results don't cover all errors and we need this hacky
error handler dance.

See gfx-rs/wgpu#3767.

Author: LegNeato

blog/2024-11-21-optimizing-matrix-mul/code/Cargo.lock

@@ -48,6 +48,7 @@ spirv-std = { git = "https://github.com/rust-gpu/rust-gpu", rev = "0da80f8a61867
 futures = "0.3"
 glam = { version = "0.29.2", features = ["cuda", "bytemuck"] }
 tracing = "0.1.40"
+wgpu = { version = "23.0", features = ["spirv", "vulkan-portability"] }
 
 # Enable incremental by default in release mode.
 [profile.release]

blog/2024-11-21-optimizing-matrix-mul/code/Cargo.toml

@@ -29,17 +29,17 @@ const SIZES: &[(u32, u32, u32)] = &[
     (64, 32, 128),      // A: 64x32, B: 32x128, Result: 64x128
     (1024, 512, 2048),  // A: 1024x512, B: 512x2048, Result: 1024x2048
     (2048, 1024, 4096), // A: 2048x1024, B: 1024x4096, Result: 2048x4096
+    */
 ];
 
 fn bench_all_variants(c: &mut Criterion) {
     // Initialize all variants outside the loop
-    let multiplier_naive = matmul::naive::wgpu();
-    let multiplier_workgroup_256 = matmul::workgroup_256::wgpu();
-    let multiplier_workgroup_2d = matmul::workgroup_2d::wgpu();
-    let multiplier_tiling_1d = matmul::tiling_1d::wgpu();
-    let multiplier_tiling_1d_loop = matmul::tiling_1d_loop::wgpu();
-    let multiplier_tiling_2d = matmul::tiling_2d::wgpu();
-    let multiplier_isomorphic_gpu = matmul::isomorphic::wgpu();
+    let multiplier_naive = matmul::naive::wgpu().unwrap();
+    let multiplier_workgroup_256 = matmul::workgroup_256::wgpu().unwrap();
+    let multiplier_workgroup_2d = matmul::workgroup_2d::wgpu().unwrap();
+    let multiplier_tiling_1d = matmul::tiling_1d::wgpu().unwrap();
+    let multiplier_tiling_1d_loop = matmul::tiling_1d_loop::wgpu().unwrap();
+    let multiplier_tiling_2d = matmul::tiling_2d::wgpu().unwrap();
 
     for &(m, k, n) in SIZES {
         // Calculate FLOPs for this size
@@ -134,22 +134,6 @@ fn bench_all_variants(c: &mut Criterion) {
                 });
             },
         );
-
-        group.bench_with_input(
-            BenchmarkId::new("isomorphic:wgpu", format!("{}x{}x{}", m, k, n)),
-            &(m, k, n),
-            |bench, &(m, k, n)| {
-                bench.iter(|| {
-                    black_box(multiplier_isomorphic_gpu.multiply(
-                        black_box(&a),
-                        black_box(&b),
-                        m,
-                        k,
-                        n,
-                    ))
-                });
-            },
-        );
     }
 }
 

blog/2024-11-21-optimizing-matrix-mul/code/benches/gpu_bench.rs

@@ -6,7 +6,6 @@ use rand::Rng;
 use std::time::Duration;
 
 const WARMUP_TIME: Duration = Duration::from_secs(2);
-const MEASUREMENT_TIME: Duration = Duration::from_secs(5 * 60);
 const SAMPLE_SIZE: usize = 10;
 
 /// Matrix sizes to benchmark
@@ -34,19 +33,18 @@ const SIZES: &[(u32, u32, u32)] = &[
 
 fn bench_isomorphic_variants(c: &mut Criterion) {
     // Initialize isomorphic variants
-    let multiplier_isomorphic_gpu = matmul::isomorphic::wgpu();
-    let multiplier_isomorphic_cpu_single = matmul::isomorphic::cpu::single_threaded();
-    let multiplier_isomorphic_cpu_multi = matmul::isomorphic::cpu::multi_threaded();
+    let multiplier_isomorphic_gpu = matmul::isomorphic::wgpu().unwrap();
+    let multiplier_isomorphic_cpu_single = matmul::isomorphic::cpu::single_threaded().unwrap();
+    let multiplier_isomorphic_cpu_multi = matmul::isomorphic::cpu::multi_threaded().unwrap();
 
     for &(m, k, n) in SIZES {
-        // Calculate FLOPs for this size
-        let flops = 2.0 * (m as f64 * n as f64 * k as f64);
-
-        let mut group = c.benchmark_group(format!("isomorphic_matmul{}x{}x{}", m, k, n));
+        let mut group = c.benchmark_group("isomorphic");
         group.sampling_mode(SamplingMode::Flat);
         group.warm_up_time(WARMUP_TIME);
-        //group.measurement_time(MEASUREMENT_TIME);
         group.sample_size(SAMPLE_SIZE);
+
+        // Calculate FLOPs for this size
+        let flops = 2.0 * (m as f64 * n as f64 * k as f64);
         group.throughput(Throughput::Elements(flops as u64));
 
         // Create matrices for the given size

blog/2024-11-21-optimizing-matrix-mul/code/benches/isomorphic_bench.rs

@@ -10,6 +10,7 @@ path = "src/bin.rs"
 [dependencies]
 matmul = { path = "../../crates/cpu/matmul" }
 settings = { path = "../../crates/shared/settings" }
+wgpu.workspace = true
 futures.workspace = true
 tracing.workspace = true
 tracing-subscriber = { version = "0.3.18", features = ["env-filter", "std"] }