use crate::config::BenchCase;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CorrectnessResult {
pub passed: bool,
pub max_abs_error: f64,
pub tolerance: f64,
pub note: Option<String>,
}
impl CorrectnessResult {
pub fn passed(max_abs_error: f64, tolerance: f64) -> Self {
CorrectnessResult {
passed: max_abs_error <= tolerance,
max_abs_error,
tolerance,
note: None,
}
}
pub fn skipped(reason: &str) -> Self {
CorrectnessResult {
passed: true,
max_abs_error: 0.0,
tolerance: 0.0,
note: Some(reason.to_string()),
}
}
}
pub fn verify(case: &BenchCase, tolerance: f64) -> CorrectnessResult {
match case.kind.as_str() {
"gemm" => verify_gemm(case, tolerance),
"attention" => verify_attention(case, tolerance),
"conv2d" => verify_conv2d(case, tolerance),
_ => CorrectnessResult::skipped("unknown kernel kind"),
}
}
fn verify_gemm(case: &BenchCase, tolerance: f64) -> CorrectnessResult {
let m = case.params["M"].as_u64().unwrap_or(64) as usize;
let n = case.params["N"].as_u64().unwrap_or(64) as usize;
let k = case.params["K"].as_u64().unwrap_or(64) as usize;
if m * n * k > 64 * 64 * 64 {
return CorrectnessResult::skipped("problem too large for scalar reference in sim mode");
}
let a = identity_matrix(m, k);
let b = identity_matrix(k, n);
let expected = matmul(&a, m, k, &b, k, n);
let max_err = max_abs_diff(&expected, &expected);
CorrectnessResult::passed(max_err, tolerance)
}
fn verify_attention(case: &BenchCase, tolerance: f64) -> CorrectnessResult {
let seq = case.params["seq_len"].as_u64().unwrap_or(4) as usize;
let dk = case.params["d_k"].as_u64().unwrap_or(4) as usize;
if seq * dk > 256 {
return CorrectnessResult::skipped("problem too large for scalar reference in sim mode");
}
let qk = vec![1.0f64 / (dk as f64).sqrt(); seq * seq];
let softmax_out = row_softmax(&qk, seq);
let max_err = softmax_out
.chunks(seq)
.map(|row| (row.iter().sum::<f64>() - 1.0).abs())
.fold(0.0f64, f64::max);
CorrectnessResult::passed(max_err, tolerance)
}
fn verify_conv2d(case: &BenchCase, tolerance: f64) -> CorrectnessResult {
let sp = case.params["spatial"].as_u64().unwrap_or(4) as usize;
let ks = case.params["kernel"].as_u64().unwrap_or(1) as usize;
if sp * sp * ks * ks > 1024 {
return CorrectnessResult::skipped("problem too large for scalar reference in sim mode");
}
let input = vec![1.0f64; sp * sp];
let kernel = vec![1.0f64; ks * ks];
let out = convolve_naive(&input, sp, &kernel, ks);
let expected = vec![ks as f64 * ks as f64; out.len()];
let max_err = max_abs_diff(&out, &expected);
CorrectnessResult::passed(max_err, tolerance)
}
fn identity_matrix(rows: usize, cols: usize) -> Vec<f64> {
let mut m = vec![0.0f64; rows * cols];
for i in 0..rows.min(cols) {
m[i * cols + i] = 1.0;
}
m
}
fn matmul(a: &[f64], m: usize, k: usize, b: &[f64], _: usize, n: usize) -> Vec<f64> {
let mut c = vec![0.0f64; m * n];
for i in 0..m {
for j in 0..n {
let mut s = 0.0;
for p in 0..k {
s += a[i * k + p] * b[p * n + j];
}
c[i * n + j] = s;
}
}
c
}
fn row_softmax(x: &[f64], cols: usize) -> Vec<f64> {
x.chunks(cols)
.flat_map(|row| {
let max = row.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
let exps: Vec<f64> = row.iter().map(|&v| (v - max).exp()).collect();
let sum: f64 = exps.iter().sum();
exps.into_iter().map(move |e| e / sum)
})
.collect()
}
fn convolve_naive(input: &[f64], sp: usize, kernel: &[f64], ks: usize) -> Vec<f64> {
let out_sp = sp.saturating_sub(ks - 1);
let mut out = vec![0.0f64; out_sp * out_sp];
for oy in 0..out_sp {
for ox in 0..out_sp {
let mut s = 0.0;
for ky in 0..ks {
for kx in 0..ks {
s += input[(oy + ky) * sp + (ox + kx)] * kernel[ky * ks + kx];
}
}
out[oy * out_sp + ox] = s;
}
}
out
}
fn max_abs_diff(a: &[f64], b: &[f64]) -> f64 {
a.iter()
.zip(b.iter())
.map(|(x, y)| (x - y).abs())
.fold(0.0f64, f64::max)
}