use super::*;
use crate::ast::{ScalarField, VectorField};
use burn::backend::{NdArray, Wgpu};
use burn::tensor::Tensor;
use burn::tensor::backend::{Backend, BackendTypes};
type Cpu = NdArray<f32>;
type Gpu = Wgpu<f32, i32>;
fn scalar_program() -> ScalarField {
ScalarField::Add(
Box::new(ScalarField::gaussian_at(0.0, 0.0, 10.0)),
Box::new(ScalarField::Scale(
Box::new(ScalarField::Mul(
Box::new(ScalarField::CoordX),
Box::new(ScalarField::linear(2.0, -3.0, 1.0)),
)),
0.25,
)),
)
}
fn vector_program() -> VectorField {
VectorField::Add(
Box::new(VectorField::Gradient(Box::new(ScalarField::gaussian_at(
0.0, 0.0, 10.0,
)))),
Box::new(VectorField::Perp(Box::new(VectorField::ConstVec {
x: 0.5,
y: 0.0,
}))),
)
}
fn points(n: usize) -> Vec<(f32, f32)> {
(0..n)
.map(|i| {
let t = i as f32;
((t * 0.37) % 40.0 - 20.0, (t * 0.73) % 40.0 - 20.0)
})
.collect()
}
fn tensors<B: Backend>(
pts: &[(f32, f32)],
dev: &<B as BackendTypes>::Device,
) -> (Tensor<B, 1>, Tensor<B, 1>) {
let xs: Vec<f32> = pts.iter().map(|(x, _)| *x).collect();
let ys: Vec<f32> = pts.iter().map(|(_, y)| *y).collect();
(
Tensor::<B, 1>::from_floats(xs.as_slice(), dev),
Tensor::<B, 1>::from_floats(ys.as_slice(), dev),
)
}
fn run_scalar<B: Backend>(f: &ScalarField, pts: &[(f32, f32)]) -> Vec<f32> {
let reg = FieldRegistry::new();
let dev = <B as BackendTypes>::Device::default();
let (xs, ys) = tensors::<B>(pts, &dev);
lower_scalar::<B>(f, ®, xs, ys, 0.0)
.unwrap()
.into_data()
.to_vec::<f32>()
.unwrap()
}
fn run_vector<B: Backend>(f: &VectorField, pts: &[(f32, f32)]) -> (Vec<f32>, Vec<f32>) {
let reg = FieldRegistry::new();
let dev = <B as BackendTypes>::Device::default();
let (xs, ys) = tensors::<B>(pts, &dev);
let (rx, ry) = lower_vector::<B>(f, ®, xs, ys, 0.0).unwrap();
(
rx.into_data().to_vec::<f32>().unwrap(),
ry.into_data().to_vec::<f32>().unwrap(),
)
}
fn approx(a: &[f32], b: &[f32], eps: f32) -> bool {
a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < eps)
}
#[test]
fn scalar_parity_ndarray_wgpu() {
let f = scalar_program();
let pts = points(257); let cpu = run_scalar::<Cpu>(&f, &pts);
let gpu = run_scalar::<Gpu>(&f, &pts);
assert!(
approx(&cpu, &gpu, 1.0e-3),
"cpu[..4]={:?} gpu[..4]={:?}",
&cpu[..4],
&gpu[..4]
);
}
#[test]
fn vector_parity_ndarray_wgpu() {
let f = vector_program();
let pts = points(257);
let (cx, cy) = run_vector::<Cpu>(&f, &pts);
let (gx, gy) = run_vector::<Gpu>(&f, &pts);
assert!(approx(&cx, &gx, 1.0e-3), "x diverged");
assert!(approx(&cy, &gy, 1.0e-3), "y diverged");
}
#[test]
#[ignore]
fn timing_scalar_cpu_vs_gpu() {
let f = scalar_program();
for n in [1_000usize, 10_000, 100_000] {
let pts = points(n);
let _warm = run_scalar::<Gpu>(&f, &pts);
let t = std::time::Instant::now();
let _cpu = run_scalar::<Cpu>(&f, &pts);
let cpu_us = t.elapsed().as_micros();
let t = std::time::Instant::now();
let _gpu = run_scalar::<Gpu>(&f, &pts);
let gpu_us = t.elapsed().as_micros();
println!("n={n}: ndarray={cpu_us}us wgpu={gpu_us}us");
}
}