use std::time::Instant;
use isomesh::{MeshBuffer, RuntimeShape3, Sdf};
use isomesh_gpu::headless::Gpu;
use isomesh_gpu::{FieldSampler, GpuField, GridParams, MarchingCubesGpu};
struct FieldOf(GpuField);
impl Sdf for FieldOf {
type Scalar = f32;
fn sample(&self, p: [f32; 3]) -> f32 {
self.0.sample_on_cpu(p)
}
}
fn median_ms(mut run: impl FnMut()) -> f64 {
run();
run();
let mut samples = [0.0f64; 3];
for slot in &mut samples {
let started = Instant::now();
run();
*slot = started.elapsed().as_secs_f64() * 1000.0;
}
samples.sort_by(f64::total_cmp);
samples[1]
}
fn main() {
let gpu = match Gpu::new() {
Ok(gpu) => gpu,
Err(e) => {
eprintln!("no GPU adapter: {e}");
eprintln!("this crate does not fall back to a software rasteriser -- see Gpu::new");
return;
}
};
let report = gpu.report();
println!(
"adapter: {} ({:?}, {:?}) driver {}",
report.name, report.backend, report.device_type, report.driver
);
if cfg!(debug_assertions) {
println!();
println!("*** DEBUG BUILD -- these numbers are not worth reading. Use --release. ***");
}
println!();
let field = GpuField::Sphere;
let Ok(sampler) = FieldSampler::new(gpu.device()) else {
eprintln!("field sampler");
return;
};
let Ok(mc) = MarchingCubesGpu::new(gpu.device(), gpu.queue()) else {
eprintln!("pipeline");
return;
};
println!(
"{:>6} {:>10} {:>12} {:>12} {:>12} {:>12} {:>9} {:>9}",
"n", "triangles", "cpu ms", "gpu+read ms", "gpu ms", "indirect ms", "vs cpu", "no-read"
);
for n in [17u32, 33, 49, 65, 97, 129] {
let cell = 3.0 / (n as f32 - 1.0);
let Ok(grid) = GridParams::new([n; 3], [-1.5; 3], cell) else {
eprintln!("{n}: grid");
continue;
};
let mut triangles = 0usize;
let gpu_read = median_ms(|| {
let Ok(buffer) = sampler.sample(gpu.device(), gpu.queue(), grid, field) else {
return;
};
if let Ok(mesh) = mc.extract(gpu.device(), gpu.queue(), &buffer) {
triangles = mesh.triangle_count();
}
});
let gpu_only = median_ms(|| {
let Ok(buffer) = sampler.sample(gpu.device(), gpu.queue(), grid, field) else {
return;
};
let _ = mc.extract_buffers(gpu.device(), gpu.queue(), &buffer);
});
let budget = u32::try_from(triangles).unwrap_or(u32::MAX);
let indirect = median_ms(|| {
let Ok(buffer) = sampler.sample(gpu.device(), gpu.queue(), grid, field) else {
return;
};
let _ = mc.extract_indirect(gpu.device(), gpu.queue(), &buffer, budget);
});
let Ok(shape) = RuntimeShape3::new(grid.samples()) else {
eprintln!("{n}: shape");
continue;
};
let mut out = MeshBuffer::<f32>::new();
let mut cpu_mc = isomesh::marching_cubes::MarchingCubes::<f32>::new();
let cpu = median_ms(|| {
out.reset();
let _ = cpu_mc.extract(
&FieldOf(field),
&shape,
grid.origin(),
grid.cell_size(),
&mut out,
);
});
let ratio = |a: f64, b: f64| {
if b <= a {
format!("{:.1}x", a / b.max(f64::EPSILON))
} else {
format!("{:.1}x slower", b / a.max(f64::EPSILON))
}
};
println!(
"{n:>6} {triangles:>10} {cpu:>12.3} {gpu_read:>12.3} {gpu_only:>12.3} \
{indirect:>12.3} {:>9} {:>9}",
ratio(cpu, gpu_read),
ratio(cpu, gpu_only),
);
if out.triangle_count() != triangles {
println!(
" ^ CPU produced {} triangles and the GPU {triangles} -- that is a defect, not a tolerance",
out.triangle_count()
);
}
}
println!();
println!("`vs cpu` is against the read-back path, `no-read` against leaving the");
println!("geometry on the device. A renderer pays the second and a CAD tool the first.");
}