use std::{
path::{Path, PathBuf},
process::Command,
};
fn buildc() -> Command {
Command::new(env!("CARGO_BIN_EXE_buildc"))
}
fn repo_root() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.parent()
.expect("compiler manifest should have a repository parent")
.to_path_buf()
}
fn vec_add_example() -> PathBuf {
repo_root().join("examples").join("gpu").join("vec_add.bld")
}
fn saxpy_example() -> PathBuf {
repo_root().join("examples").join("gpu").join("saxpy.bld")
}
fn matmul_example() -> PathBuf {
repo_root().join("examples").join("gpu").join("matmul.bld")
}
fn stencil_example() -> PathBuf {
repo_root().join("examples").join("gpu").join("stencil.bld")
}
fn spirv_val_available() -> Option<&'static str> {
let ok = Command::new("spirv-val")
.arg("--version")
.output()
.map(|o| o.status.success())
.unwrap_or(false);
if ok {
Some("spirv-val")
} else {
None
}
}
fn temp_spv(label: &str) -> PathBuf {
std::env::temp_dir().join(format!(
"buildlang_gpu_{}_{}.spv",
label,
std::process::id()
))
}
fn spv_words(bytes: &[u8]) -> Vec<u32> {
assert!(
bytes.len() >= 20 && bytes.len() % 4 == 0,
"SPIR-V module must be word-aligned and at least a 5-word header"
);
bytes
.chunks_exact(4)
.map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]]))
.collect()
}
fn contains_opcode(words: &[u32], opcode: u16) -> bool {
let mut i = 5usize;
while i < words.len() {
let word_count = (words[i] >> 16) as usize;
let op = (words[i] & 0xFFFF) as u16;
if word_count == 0 {
break; }
if op == opcode {
return true;
}
i += word_count;
}
false
}
fn count_workgroup_variables(words: &[u32]) -> usize {
const OP_VARIABLE: u16 = 59;
const STORAGE_CLASS_WORKGROUP: u32 = 4;
let mut count = 0usize;
let mut i = 5usize; while i < words.len() {
let word_count = (words[i] >> 16) as usize;
let op = (words[i] & 0xFFFF) as u16;
if word_count == 0 {
break; }
if op == OP_VARIABLE && word_count >= 4 && words[i + 3] == STORAGE_CLASS_WORKGROUP {
count += 1;
}
i += word_count;
}
count
}
fn compile_kernel_spirv(src: &Path, out: &Path) {
let output = buildc()
.arg(src)
.arg("--target")
.arg("spirv")
.arg("-o")
.arg(out)
.output()
.expect("run buildc to compile a compute kernel");
assert!(
output.status.success(),
"buildc should compile {} to SPIR-V\nstdout:\n{}\nstderr:\n{}",
src.display(),
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
assert!(out.exists(), "expected .spv output at {}", out.display());
}
fn compile_vec_add_spirv(out: &Path) {
compile_kernel_spirv(&vec_add_example(), out);
}
fn spirv_val_ok(tool: &str, spv: &Path) -> (bool, String) {
let output = Command::new(tool)
.arg("--target-env")
.arg("vulkan1.0")
.arg(spv)
.output()
.expect("run spirv-val");
(
output.status.success(),
String::from_utf8_lossy(&output.stderr).to_string(),
)
}
#[test]
fn emits_valid_compute_spirv() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping emits_valid_compute_spirv: spirv-val not on PATH");
return;
};
let out = temp_spv("valid");
compile_vec_add_spirv(&out);
let (ok, stderr) = spirv_val_ok(tool, &out);
assert!(
ok,
"spirv-val should accept the emitted compute module:\n{stderr}"
);
let _ = std::fs::remove_file(&out);
}
#[test]
fn spirv_val_rejects_corrupt_module() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping spirv_val_rejects_corrupt_module: spirv-val not on PATH");
return;
};
let out = temp_spv("corrupt");
compile_vec_add_spirv(&out);
let (ok, stderr) = spirv_val_ok(tool, &out);
assert!(ok, "pristine module should validate first:\n{stderr}");
let mut bytes = std::fs::read(&out).expect("read valid spv");
assert!(bytes.len() > 40, "module unexpectedly tiny");
bytes[32] ^= 0xFF;
bytes[33] ^= 0xFF;
let corrupt = temp_spv("corrupt_out");
std::fs::write(&corrupt, &bytes).expect("write corrupt spv");
let (ok, _stderr) = spirv_val_ok(tool, &corrupt);
assert!(
!ok,
"spirv-val must REJECT a corrupted module (non-zero exit); if it accepts, the gate does not discriminate"
);
let _ = std::fs::remove_file(&out);
let _ = std::fs::remove_file(&corrupt);
}
#[test]
fn saxpy_emits_valid_compute_spirv() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping saxpy_emits_valid_compute_spirv: spirv-val not on PATH");
return;
};
let out = temp_spv("saxpy_valid");
compile_kernel_spirv(&saxpy_example(), &out);
let (ok, stderr) = spirv_val_ok(tool, &out);
assert!(
ok,
"spirv-val should accept the emitted saxpy compute module:\n{stderr}"
);
let _ = std::fs::remove_file(&out);
}
#[test]
fn matmul_emits_valid_compute_spirv() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping matmul_emits_valid_compute_spirv: spirv-val not on PATH");
return;
};
let out = temp_spv("matmul_valid");
compile_kernel_spirv(&matmul_example(), &out);
let (ok, stderr) = spirv_val_ok(tool, &out);
assert!(
ok,
"spirv-val should accept the emitted matmul compute module:\n{stderr}"
);
let _ = std::fs::remove_file(&out);
}
#[test]
fn stencil_emits_valid_compute_spirv() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping stencil_emits_valid_compute_spirv: spirv-val not on PATH");
return;
};
let out = temp_spv("stencil_valid");
compile_kernel_spirv(&stencil_example(), &out);
let (ok, stderr) = spirv_val_ok(tool, &out);
assert!(
ok,
"spirv-val should accept the emitted stencil compute module:\n{stderr}"
);
let _ = std::fs::remove_file(&out);
}
#[test]
fn loop_in_selection_emits_valid_spirv() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping loop_in_selection_emits_valid_spirv: spirv-val not on PATH");
return;
};
let dir = std::env::temp_dir().join(format!("buildlang_gpu_nestcf_{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("create temp dir");
let loop_in_if = dir.join("loop_in_if.bld");
std::fs::write(
&loop_in_if,
"#[compute]\n\
fn k(a: &mut [f32]) ~ Gpu {\n\
\x20 let i = gl_GlobalInvocationID.x;\n\
\x20 if i < 4 {\n\
\x20 let mut s: f32 = 0.0;\n\
\x20 let mut j: u32 = 0;\n\
\x20 while j < 3 {\n\
\x20 s = s + a[i];\n\
\x20 j = j + 1;\n\
\x20 }\n\
\x20 a[i] = s;\n\
\x20 }\n\
}\n",
)
.expect("write loop_in_if.bld");
let out1 = dir.join("loop_in_if.spv");
compile_kernel_spirv(&loop_in_if, &out1);
let (ok1, stderr1) = spirv_val_ok(tool, &out1);
assert!(
ok1,
"a `while` loop nested inside an `if` must emit valid structured control flow:\n{stderr1}"
);
let and_loop = dir.join("and_loop.bld");
std::fs::write(
&and_loop,
"#[compute]\n\
fn k(a: &mut [f32]) ~ Gpu {\n\
\x20 let i = gl_GlobalInvocationID.x;\n\
\x20 let n: u32 = 4;\n\
\x20 let m: u32 = 8;\n\
\x20 if i < n && i < m {\n\
\x20 let mut s: f32 = 0.0;\n\
\x20 let mut j: u32 = 0;\n\
\x20 while j < 3 {\n\
\x20 s = s + a[i];\n\
\x20 j = j + 1;\n\
\x20 }\n\
\x20 a[i] = s;\n\
\x20 }\n\
}\n",
)
.expect("write and_loop.bld");
let out2 = dir.join("and_loop.spv");
compile_kernel_spirv(&and_loop, &out2);
let (ok2, stderr2) = spirv_val_ok(tool, &out2);
assert!(
ok2,
"an `&&`-guarded nested loop (the matmul in-kernel bounds-guard shape) must \
emit valid structured control flow:\n{stderr2}"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn selection_in_loop_emits_valid_spirv() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping selection_in_loop_emits_valid_spirv: spirv-val not on PATH");
return;
};
let dir = std::env::temp_dir().join(format!("buildlang_gpu_selloop_{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("create temp dir");
let if_in_while = dir.join("if_in_while.bld");
std::fs::write(
&if_in_while,
"#[compute]\n\
fn k(a: &mut [f32]) ~ Gpu {\n\
\x20 let i = gl_GlobalInvocationID.x;\n\
\x20 let mut s: f32 = 0.0;\n\
\x20 let mut j: u32 = 0;\n\
\x20 while j < 8 {\n\
\x20 if j < 4 {\n\
\x20 s = s + a[i];\n\
\x20 }\n\
\x20 j = j + 1;\n\
\x20 }\n\
\x20 a[i] = s;\n\
}\n",
)
.expect("write if_in_while.bld");
let out1 = dir.join("if_in_while.spv");
compile_kernel_spirv(&if_in_while, &out1);
let (ok1, stderr1) = spirv_val_ok(tool, &out1);
assert!(
ok1,
"an `if` (no else) nested inside a `while` loop body must emit valid \
structured control flow:\n{stderr1}"
);
let if_else_in_while = dir.join("if_else_in_while.bld");
std::fs::write(
&if_else_in_while,
"#[compute]\n\
fn k(a: &mut [f32]) ~ Gpu {\n\
\x20 let i = gl_GlobalInvocationID.x;\n\
\x20 let mut s: f32 = 0.0;\n\
\x20 let mut j: u32 = 0;\n\
\x20 while j < 8 {\n\
\x20 if j < 4 {\n\
\x20 s = s + a[i];\n\
\x20 } else {\n\
\x20 s = s - a[i];\n\
\x20 }\n\
\x20 j = j + 1;\n\
\x20 }\n\
\x20 a[i] = s;\n\
}\n",
)
.expect("write if_else_in_while.bld");
let out2 = dir.join("if_else_in_while.spv");
compile_kernel_spirv(&if_else_in_while, &out2);
let (ok2, stderr2) = spirv_val_ok(tool, &out2);
assert!(
ok2,
"an `if / else` nested inside a `while` loop body must emit valid \
structured control flow:\n{stderr2}"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn readonly_buffer_write_is_rejected() {
let dir = std::env::temp_dir().join(format!("buildlang_gpu_ro_{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("create temp dir");
let src = dir.join("readonly_write.bld");
std::fs::write(
&src,
"#[compute]\n\
fn ro_write(a: &[f32], out: &mut [f32]) ~ Gpu {\n\
\x20 let i = gl_GlobalInvocationID.x;\n\
\x20 a[i] = out[i];\n\
}\n",
)
.expect("write readonly_write.bld");
let out = dir.join("readonly_write.spv");
let output = buildc()
.arg(&src)
.arg("--target")
.arg("spirv")
.arg("-o")
.arg(&out)
.output()
.expect("run buildc on the read-only-write kernel");
assert!(
!output.status.success(),
"writing into a read-only `&[f32]` buffer MUST be rejected at compile time; \
if it compiles, the writability inference is decorative\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.to_lowercase().contains("read-only")
|| stderr.to_lowercase().contains("writable")
|| stderr.to_lowercase().contains("non-writable"),
"the rejection should name the writability cause; got:\n{stderr}"
);
let _ = std::fs::remove_dir_all(&dir);
}
fn reduce_example() -> PathBuf {
repo_root().join("examples").join("gpu").join("reduce.bld")
}
fn two_scratch_example() -> PathBuf {
repo_root()
.join("examples")
.join("gpu")
.join("reduce_two_scratch.bld")
}
#[test]
fn two_same_shape_workgroup_arrays_do_not_alias() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping two_same_shape_workgroup_arrays_do_not_alias: spirv-val not on PATH");
return;
};
let out = temp_spv("two_scratch");
compile_kernel_spirv(&two_scratch_example(), &out);
let (ok, stderr) = spirv_val_ok(tool, &out);
assert!(
ok,
"spirv-val should accept the two-scratch compute module:\n{stderr}"
);
let bytes = std::fs::read(&out).expect("read two_scratch spv");
let words = spv_words(&bytes);
let workgroup_vars = count_workgroup_variables(&words);
assert_eq!(
workgroup_vars, 2,
"two distinct workgroupArray(64) locals must lower to two distinct \
Workgroup-class OpVariables (found {workgroup_vars}); if this is 1 the \
backend aliased two logically independent scratch buffers into one, a \
silent data-corruption bug"
);
let _ = std::fs::remove_file(&out);
}
#[test]
fn reduce_emits_valid_compute_spirv() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping reduce_emits_valid_compute_spirv: spirv-val not on PATH");
return;
};
let out = temp_spv("reduce_valid");
compile_kernel_spirv(&reduce_example(), &out);
let (ok, stderr) = spirv_val_ok(tool, &out);
assert!(
ok,
"spirv-val should accept the emitted sum_reduce compute module:\n{stderr}"
);
let bytes = std::fs::read(&out).expect("read reduce spv");
let words = spv_words(&bytes);
assert!(
contains_opcode(&words, 224),
"the emitted sum_reduce module must contain an OpControlBarrier (224); \
if it does not, the workgroup barrier was silently dropped"
);
let _ = std::fs::remove_file(&out);
}
#[test]
fn reduce_corrupt_barrier_is_rejected() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping reduce_corrupt_barrier_is_rejected: spirv-val not on PATH");
return;
};
let out = temp_spv("reduce_corrupt_barrier");
compile_kernel_spirv(&reduce_example(), &out);
let (ok, stderr) = spirv_val_ok(tool, &out);
assert!(
ok,
"pristine reduce module should validate first:\n{stderr}"
);
let mut bytes = std::fs::read(&out).expect("read reduce spv");
let words = spv_words(&bytes);
let mut i = 5usize;
let mut operand_word_index: Option<usize> = None;
while i < words.len() {
let word_count = (words[i] >> 16) as usize;
let op = (words[i] & 0xFFFF) as u16;
if word_count == 0 {
break;
}
if op == 224 {
operand_word_index = Some(i + 1);
break;
}
i += word_count;
}
let operand_word_index =
operand_word_index.expect("emitted reduce module must contain an OpControlBarrier");
let byte_off = operand_word_index * 4;
bytes[byte_off] = 0;
bytes[byte_off + 1] = 0;
bytes[byte_off + 2] = 0;
bytes[byte_off + 3] = 0;
let corrupt = temp_spv("reduce_corrupt_barrier_out");
std::fs::write(&corrupt, &bytes).expect("write corrupt reduce spv");
let (ok, _stderr) = spirv_val_ok(tool, &corrupt);
assert!(
!ok,
"spirv-val must REJECT a reduce module whose OpControlBarrier scope operand \
was corrupted; if it accepts, the barrier gate does not discriminate on the barrier"
);
let _ = std::fs::remove_file(&out);
let _ = std::fs::remove_file(&corrupt);
}
#[test]
fn left_literal_unsigned_binop_emits_valid_spirv() {
let Some(tool) = spirv_val_available() else {
eprintln!("skipping left_literal_unsigned_binop_emits_valid_spirv: spirv-val not on PATH");
return;
};
let dir = std::env::temp_dir().join(format!("buildlang_gpu_litleft_{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("create temp dir");
let src = dir.join("left_literal.bld");
std::fs::write(
&src,
"#[compute]\n\
fn k(n: u32, a: &[f32], out: &mut [f32]) ~ Gpu {\n\
\x20 let gid = gl_GlobalInvocationID.x;\n\
\x20 let mut z: u32 = 5;\n\
\x20 z = 100 - z;\n\
\x20 if gid < n {\n\
\x20 out[gid] = a[gid] + (z as f32);\n\
\x20 }\n\
}\n",
)
.expect("write left_literal.bld");
let out = dir.join("left_literal.spv");
compile_kernel_spirv(&src, &out);
let (ok, stderr) = spirv_val_ok(tool, &out);
assert!(
ok,
"a `literal - unsigned_var` binop whose result is stored into a u32 local \
must emit valid SPIR-V (the operation type must come from the unsigned \
variable operand, not the signed-i32 literal):\n{stderr}"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[cfg(feature = "gpu")]
mod device {
use super::*;
fn vulkan_device_available() -> bool {
let output = buildc().arg("doctor").output().expect("run buildc doctor");
let stdout = String::from_utf8_lossy(&output.stdout);
stdout.contains("gpu ready")
}
#[test]
fn gpu_matches_cpu_within_tolerance() {
if !vulkan_device_available() {
eprintln!("skipping gpu_matches_cpu_within_tolerance: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(vec_add_example())
.arg("--gpu")
.output()
.expect("run buildc run --gpu");
assert!(
output.status.success(),
"buildc run --gpu should agree with CPU-C within tolerance\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
stdout.contains("gpu-cpu agreement") || stdout.contains("PASS"),
"expected an agreement verdict in output:\n{stdout}"
);
}
#[test]
fn wrong_gpu_result_is_caught() {
if !vulkan_device_available() {
eprintln!("skipping wrong_gpu_result_is_caught: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(vec_add_example())
.arg("--gpu")
.env("BUILDLANG_GPU_CORRUPT_READBACK", "1")
.output()
.expect("run buildc run --gpu with a corrupted readback");
assert!(
!output.status.success(),
"a divergent GPU readback MUST be caught (non-zero exit); if it passes, the gate does not discriminate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
}
#[test]
fn saxpy_gpu_matches_cpu() {
if !vulkan_device_available() {
eprintln!("skipping saxpy_gpu_matches_cpu: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(saxpy_example())
.arg("--gpu")
.output()
.expect("run buildc run --gpu on saxpy");
assert!(
output.status.success(),
"buildc run --gpu on saxpy should agree with CPU-C within tolerance\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
stdout.contains("gpu-cpu agreement") || stdout.contains("PASS"),
"expected an agreement verdict in output:\n{stdout}"
);
}
#[test]
fn wrong_saxpy_result_is_caught() {
if !vulkan_device_available() {
eprintln!("skipping wrong_saxpy_result_is_caught: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(saxpy_example())
.arg("--gpu")
.env("BUILDLANG_GPU_CORRUPT_READBACK", "1")
.output()
.expect("run buildc run --gpu on saxpy with a corrupted readback");
assert!(
!output.status.success(),
"a divergent saxpy readback MUST be caught (non-zero exit)\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
}
#[test]
fn matmul_gpu_matches_cpu() {
if !vulkan_device_available() {
eprintln!("skipping matmul_gpu_matches_cpu: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(matmul_example())
.arg("--gpu")
.output()
.expect("run buildc run --gpu on matmul");
assert!(
output.status.success(),
"buildc run --gpu on matmul should agree with CPU-C within tolerance\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
stdout.contains("gpu-cpu agreement") && stdout.contains("PASS"),
"expected a gpu-cpu agreement verdict in output:\n{stdout}"
);
assert!(
stdout.contains("matmul identity sanity: PASS"),
"expected the closed-form identity(m) x B == B sanity to PASS:\n{stdout}"
);
}
#[test]
fn wrong_matmul_result_is_caught() {
if !vulkan_device_available() {
eprintln!("skipping wrong_matmul_result_is_caught: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(matmul_example())
.arg("--gpu")
.env("BUILDLANG_GPU_CORRUPT_READBACK", "1")
.output()
.expect("run buildc run --gpu on matmul with a corrupted readback");
assert!(
!output.status.success(),
"a divergent matmul readback MUST be caught (non-zero exit)\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
}
#[test]
fn matmul_nonmultiple_dims_match_cpu() {
if !vulkan_device_available() {
eprintln!("skipping matmul_nonmultiple_dims_match_cpu: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(matmul_example())
.arg("--gpu")
.env("BUILDLANG_MM_DIMS", "40x40x40")
.output()
.expect("run buildc run --gpu on a non-multiple matmul");
assert!(
output.status.success(),
"a NON-workgroup-multiple matmul must dispatch and agree with CPU-C within \
tolerance (the in-kernel bounds guard makes the edge invocations safe)\n\
stdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
stdout.contains("gpu-cpu agreement") && stdout.contains("PASS"),
"expected a gpu-cpu agreement verdict for the 40x40x40 matmul:\n{stdout}"
);
assert!(
stdout.contains("40x40x40"),
"the agreement verdict should report the overridden 40x40x40 dims:\n{stdout}"
);
assert!(
stdout.contains("matmul identity sanity: PASS"),
"the identity(m) x B == B sanity must still PASS at the non-multiple dim, \
proving the guard dropped no in-range output:\n{stdout}"
);
}
#[test]
fn wrong_nonmultiple_matmul_result_is_caught() {
if !vulkan_device_available() {
eprintln!("skipping wrong_nonmultiple_matmul_result_is_caught: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(matmul_example())
.arg("--gpu")
.env("BUILDLANG_MM_DIMS", "40x40x40")
.env("BUILDLANG_GPU_CORRUPT_READBACK", "1")
.output()
.expect("run buildc run --gpu on a corrupted non-multiple matmul");
assert!(
!output.status.success(),
"a divergent readback at a non-multiple dim MUST be caught (non-zero exit)\n\
stdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
}
#[test]
fn stencil_gpu_matches_cpu() {
if !vulkan_device_available() {
eprintln!("skipping stencil_gpu_matches_cpu: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(stencil_example())
.arg("--gpu")
.output()
.expect("run buildc run --gpu on stencil");
assert!(
output.status.success(),
"buildc run --gpu on stencil should agree with CPU-C within tolerance\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
stdout.contains("gpu-cpu agreement") && stdout.contains("PASS"),
"expected a gpu-cpu agreement verdict in output:\n{stdout}"
);
assert!(
stdout.contains("stencil clamped-edge sanity: PASS"),
"expected the closed-form clamped-edge sanity to PASS:\n{stdout}"
);
}
#[test]
fn stencil_clamped_boundary_is_exact() {
if !vulkan_device_available() {
eprintln!("skipping stencil_clamped_boundary_is_exact: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(stencil_example())
.arg("--gpu")
.env("BUILDLANG_STENCIL_N", "5")
.output()
.expect("run buildc run --gpu on stencil with n=5");
assert!(
output.status.success(),
"n=5 stencil should agree + pass the clamped-edge sanity\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
let stdout = String::from_utf8_lossy(&output.stdout);
let line = stdout
.lines()
.find(|l| l.contains("stencil boundary"))
.unwrap_or_else(|| panic!("expected a `stencil boundary` line:\n{stdout}"));
let parse_after = |key: &str| -> f64 {
let seg = line
.split(key)
.nth(1)
.unwrap_or_else(|| panic!("missing {key} in: {line}"));
seg.split_whitespace()
.next()
.unwrap()
.parse::<f64>()
.unwrap_or_else(|e| panic!("parse {key} value from '{line}': {e}"))
};
let out0 = parse_after("out[0]=");
let out_last = parse_after("out[n-1]=");
let expected_0 = (1.0 + 1.0 + 2.0) / 3.0; let expected_last = (4.0 + 5.0 + 5.0) / 3.0; assert!(
(out0 - expected_0).abs() <= 1e-6,
"clamped out[0] must be (a[0]+a[0]+a[1])/3 = 4/3 = {expected_0}; got {out0}"
);
assert!(
(out_last - expected_last).abs() <= 1e-6,
"clamped out[n-1] must be (a[n-2]+a[n-1]+a[n-1])/3 = 14/3 = {expected_last}; got {out_last}"
);
}
#[test]
fn wrong_stencil_result_is_caught() {
if !vulkan_device_available() {
eprintln!("skipping wrong_stencil_result_is_caught: no Vulkan device");
return;
}
let output = buildc()
.arg("run")
.arg(stencil_example())
.arg("--gpu")
.env("BUILDLANG_GPU_CORRUPT_READBACK", "1")
.output()
.expect("run buildc run --gpu on stencil with a corrupted readback");
assert!(
!output.status.success(),
"a divergent stencil readback MUST be caught (non-zero exit)\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
}
#[test]
fn f64_kernel_is_refused_on_gpu_path() {
let dir = std::env::temp_dir().join(format!("buildlang_gpu_f64_{}", std::process::id()));
std::fs::create_dir_all(&dir).expect("create temp dir");
let src = dir.join("f64_kernel.bld");
std::fs::write(
&src,
"#[compute]\n\
fn f64_scale(alpha: f64, a: &[f32], out: &mut [f32]) ~ Gpu {\n\
\x20 let i = gl_GlobalInvocationID.x;\n\
\x20 out[i] = a[i];\n\
}\n",
)
.expect("write f64_kernel.bld");
let output = buildc()
.arg("run")
.arg(&src)
.arg("--gpu")
.output()
.expect("run buildc run --gpu on an f64 kernel");
assert!(
!output.status.success(),
"an f64 parameter on the f32-only GPU path MUST be refused (non-zero exit); \
if it passes, precision would be silently coerced\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("f32") && stderr.contains("f64"),
"the refusal should name the f32/f64 mismatch; got:\n{stderr}"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn gpu_receipt_verifies_and_detects_tamper() {
if !vulkan_device_available() {
eprintln!("skipping gpu_receipt_verifies_and_detects_tamper: no Vulkan device");
return;
}
let receipt =
std::env::temp_dir().join(format!("buildlang_gpu_receipt_{}.json", std::process::id()));
let output = buildc()
.arg("run")
.arg(vec_add_example())
.arg("--gpu")
.arg("--emit-receipt")
.arg(&receipt)
.output()
.expect("emit gpu receipt");
assert!(
output.status.success(),
"emitting a passing gpu receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&output.stderr),
);
let verify = buildc()
.arg("receipt")
.arg("verify")
.arg(&receipt)
.output()
.expect("verify gpu receipt");
assert!(
verify.status.success(),
"a pristine gpu receipt should verify\nstderr:\n{}",
String::from_utf8_lossy(&verify.stderr),
);
let text = std::fs::read_to_string(&receipt).expect("read receipt");
let mut json: serde_json::Value = serde_json::from_str(&text).expect("receipt is json");
let series = json
.pointer_mut("/body/measurement/series")
.and_then(|v| v.as_array_mut())
.expect("gpu receipt has /body/measurement/series");
*series.first_mut().expect("series is non-empty") = serde_json::json!(999999.0);
std::fs::write(&receipt, serde_json::to_string_pretty(&json).unwrap())
.expect("write tampered receipt");
let verify = buildc()
.arg("receipt")
.arg("verify")
.arg(&receipt)
.output()
.expect("verify tampered receipt");
assert!(
!verify.status.success(),
"a tampered gpu receipt MUST fail verification (seal/status)"
);
let _ = std::fs::remove_file(&receipt);
}
}