Skip to main content

qualia_extensions/webgpu_extension/
tensor.rs

1//! Dense matrix multiply `C[m×n] = A[m×k] · B[k×n]` (row-major).
2//!
3//! `A` and `B` come from `input_data["matrix_a"]` / `["matrix_b"]`, with
4//! dimensions in `uniform_data` (`m`, `k`, `n`). This is the one direct (exact)
5//! solve — the residual is `0` and the test asserts the exact product.
6
7use super::{uniform, SolverReport, WebGpuJobParams};
8use std::collections::HashMap;
9
10/// Solves.
11pub fn solve(params: &WebGpuJobParams) -> SolverReport {
12    let m = uniform(params, "m", 4.0).max(1.0) as usize;
13    let k = uniform(params, "k", 4.0).max(1.0) as usize;
14    let n = uniform(params, "n", 4.0).max(1.0) as usize;
15
16    // Defaults (used when no input is supplied): A = identity(m×k bounded to a
17    // square), B = a deterministic ramp, so C is well-defined and non-trivial.
18    let sq = m.min(k).min(n);
19    let a = params
20        .input_data
21        .get("matrix_a")
22        .cloned()
23        .unwrap_or_else(|| {
24            let mut v = vec![0.0f32; m * k];
25            for i in 0..sq {
26                v[i * k + i] = 1.0;
27            }
28            v
29        });
30    let b = params
31        .input_data
32        .get("matrix_b")
33        .cloned()
34        .unwrap_or_else(|| (0..k * n).map(|i| i as f32).collect());
35
36    // Guard against malformed inputs by clamping to the declared shape.
37    let a_ok = a.len() >= m * k;
38    let b_ok = b.len() >= k * n;
39
40    let mut c = vec![0.0f32; m * n];
41    if a_ok && b_ok {
42        for i in 0..m {
43            for p in 0..k {
44                let aip = a[i * k + p];
45                if aip == 0.0 {
46                    continue;
47                }
48                let arow = &b[p * n..p * n + n];
49                let crow = &mut c[i * n..i * n + n];
50                for j in 0..n {
51                    crow[j] += aip * arow[j];
52                }
53            }
54        }
55    }
56
57    let mut output = HashMap::new();
58    output.insert("result_out".to_string(), c);
59
60    let flops = (2 * m * n * k).max(1) as u64;
61    SolverReport {
62        output,
63        iterations_used: 1,
64        final_residual: if a_ok && b_ok { 0.0 } else { 1.0 },
65        converged: a_ok && b_ok,
66        flops,
67    }
68}
69
70#[cfg(test)]
71mod tests {
72    use super::*;
73    use crate::webgpu_extension::DispatchParams;
74
75    fn gemm_params(a: Vec<f32>, b: Vec<f32>, m: u32, k: u32, n: u32) -> WebGpuJobParams {
76        let mut input = HashMap::new();
77        input.insert("matrix_a".to_string(), a);
78        input.insert("matrix_b".to_string(), b);
79        let mut uniforms = HashMap::new();
80        uniforms.insert("m".to_string(), m as f32);
81        uniforms.insert("k".to_string(), k as f32);
82        uniforms.insert("n".to_string(), n as f32);
83        WebGpuJobParams {
84            shader_name: "tensor_gemm".to_string(),
85            grid_size: (0, 0, 0),
86            input_data: input,
87            uniform_data: uniforms,
88            dispatch_params: DispatchParams::default(),
89        }
90    }
91
92    #[test]
93    fn computes_exact_2x2_product() {
94        // [[1,2],[3,4]] · [[5,6],[7,8]] = [[19,22],[43,50]].
95        let a = vec![1.0, 2.0, 3.0, 4.0];
96        let b = vec![5.0, 6.0, 7.0, 8.0];
97        let r = solve(&gemm_params(a, b, 2, 2, 2));
98        assert_eq!(r.output["result_out"], vec![19.0, 22.0, 43.0, 50.0]);
99        assert!(r.converged);
100        assert_eq!(r.final_residual, 0.0);
101    }
102
103    #[test]
104    fn identity_is_a_left_unit() {
105        let id = vec![1.0, 0.0, 0.0, 1.0];
106        let b = vec![2.0, 3.0, 4.0, 5.0];
107        let r = solve(&gemm_params(id, b.clone(), 2, 2, 2));
108        assert_eq!(r.output["result_out"], b);
109    }
110
111    #[test]
112    fn rectangular_shapes_multiply_correctly() {
113        // A is 2×3, B is 3×2 ⇒ C is 2×2.
114        // A = [[1,2,3],[4,5,6]], B = [[1,0],[0,1],[1,1]]
115        // C = [[1+0+3, 0+2+3],[4+0+6, 0+5+6]] = [[4,5],[10,11]]
116        let a = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
117        let b = vec![1.0, 0.0, 0.0, 1.0, 1.0, 1.0];
118        let r = solve(&gemm_params(a, b, 2, 3, 2));
119        assert_eq!(r.output["result_out"], vec![4.0, 5.0, 10.0, 11.0]);
120    }
121}