use std::sync::atomic::{AtomicU64, Ordering};
use sesmesh_gpu::hip::{
ArrangementRef, Batch, BatchParams, Device, EDGE_CONVERGED, FEATURE_BEYOND, FEATURE_CIRCLE,
FEATURE_SHIFT, FEATURE_SOLVENT, FEATURE_SPHERE, FEATURE_VERTEX, GridRef, RefineRef, Resident,
};
use super::{Engine, INSIDE_TOL};
use crate::control::{Control, Stage};
use crate::error::{Error, Result};
use crate::field::lattice::CLASSIFY_EPS;
use crate::field::{Feature, SurfaceKind};
use crate::geom::{CellGrid, Status, Vec3};
use crate::mesh::extract::{MAX_BISECT, MAX_ITER, TOL};
use crate::par;
const DEVICE_CHUNK: usize = 64;
pub(crate) fn device_chunk(bricks: usize) -> usize {
par::chunk_len(bricks).min(DEVICE_CHUNK)
}
const FAST_BATCH_BRICKS: usize = 8192;
#[derive(Debug, Clone, Copy)]
pub(crate) struct Batching {
pub(crate) chunks: usize,
}
impl Batching {
pub(crate) fn mesh(refine: bool, chunk: usize) -> Self {
let threads = par::threads();
Self {
chunks: if refine {
threads.max(FAST_BATCH_BRICKS / chunk.max(1))
} else {
threads
},
}
}
}
impl Default for Batching {
fn default() -> Self {
Self {
chunks: par::threads(),
}
}
}
fn device_error(e: &sesmesh_gpu::Error) -> Error {
Error::Backend(format!("hip: {e}"))
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct DeviceEdges<'a> {
pub(crate) offsets: &'a [u32],
t: &'a [f32],
features: &'a [u32],
closest: &'a [f32],
evals: &'a [u32],
}
impl<'a> DeviceEdges<'a> {
pub(super) fn of(batch: &'a Batch<'_>, i: usize) -> Option<Self> {
batch.refined().then(|| Self {
offsets: &batch.edge_offsets()[8 * i..8 * i + 9],
t: batch.edge_params(),
features: batch.edge_features(),
closest: batch.edge_closest(),
evals: batch.edge_evals(),
})
}
pub(crate) fn get(&self, engine: &Engine, k: usize) -> Option<(f64, Feature, Vec3, u32)> {
let evals = *self.evals.get(k)?;
if evals & EDGE_CONVERGED == 0 {
return None;
}
let t = f64::from(*self.t.get(k)?);
if !(0.0..=1.0).contains(&t) {
return None;
}
let f = self.features[k];
let id = f & ((1 << FEATURE_SHIFT) - 1);
let a = &engine.field.arr;
let below = |n: usize| (id as usize) < n;
let feature = match f >> FEATURE_SHIFT {
FEATURE_SOLVENT => Feature::Solvent,
FEATURE_BEYOND => Feature::Beyond,
FEATURE_SPHERE if below(a.centers.len()) => Feature::Sphere(id),
FEATURE_CIRCLE if below(a.circles.len()) => Feature::Circle(id),
FEATURE_VERTEX if below(a.vertices.len()) => Feature::Vertex(id),
_ => return None,
};
let q = &self.closest[3 * k..3 * k + 3];
let q = Vec3::new(f64::from(q[0]), f64::from(q[1]), f64::from(q[2]));
Some((t, feature, q, evals & !EDGE_CONVERGED))
}
}
struct Residuals([[Vec<f32>; 3]; 3]);
impl Residuals {
fn new(e: &Engine) -> Self {
let frame = e.lattice.frame_origin();
let lo = |points: &mut dyn Iterator<Item = Vec3>| {
let mut out: [Vec<f32>; 3] = Default::default();
for c in points {
let d = c - frame;
for (v, x) in out.iter_mut().zip([d.x, d.y, d.z]) {
v.push((x - f64::from(x as f32)) as f32);
}
}
out
};
let a = &e.field.arr;
Self([
lo(&mut a.centers.iter().copied()),
lo(&mut a.circles.iter().map(|c| c.center)),
lo(&mut a.vertices.iter().map(|v| v.position)),
])
}
fn as_ref(&self, e: &Engine) -> RefineRef<'_> {
let h = e.lattice.h;
let h_hi = h as f32;
let r = |k: usize| std::array::from_fn(|i| self.0[k][i].as_slice());
RefineRef {
sphere_lo: r(0),
circle_lo: r(1),
vertex_lo: r(2),
h_hi,
h_lo: (h - f64::from(h_hi)) as f32,
tol: TOL as f32,
max_iter: MAX_ITER as u32,
max_bisect: MAX_BISECT as u32,
}
}
}
pub(super) struct HostArrangement {
sphere: [Vec<f32>; 7],
status: Vec<u32>,
circle: [Vec<f32>; 10],
vertex: [Vec<f32>; 3],
}
fn grid(g: &CellGrid, frame: Vec3) -> GridRef<'_> {
let (origin, cell, dims, starts, items) = g.parts();
let o = origin - frame;
GridRef {
origin: [o.x as f32, o.y as f32, o.z as f32],
cell: cell as f32,
dims: dims.map(|d| u32::try_from(d).expect("fewer than 2^32 cells per axis")),
starts,
items,
}
}
impl Engine {
pub(crate) fn device_ok(&self) -> bool {
self.f32_ok && self.sub_blocks() == 8
}
pub(super) fn host_arrangement(&self) -> HostArrangement {
let a = &self.field.arr;
let frame = self.lattice.frame_origin();
let mut sphere: [Vec<f32>; 7] = Default::default();
for v in &mut sphere {
v.reserve_exact(a.centers.len());
}
for k in 0..a.centers.len() {
let c = a.centers[k] - frame;
let r32 = a.expanded[k] as f32;
let rt = (r32 - INSIDE_TOL).max(0.0);
let row = [
c.x as f32,
c.y as f32,
c.z as f32,
r32,
r32 * r32,
rt * rt,
a.radii[k] as f32,
];
for (v, x) in sphere.iter_mut().zip(row) {
v.push(x);
}
}
let status = a
.status
.iter()
.map(|s| match s {
Status::Exposed => 0,
Status::Buried => 1,
Status::Contained => 2,
})
.collect();
let mut circle: [Vec<f32>; 10] = Default::default();
for c in &a.circles {
let m = c.center - frame;
let row = [
m.x as f32,
m.y as f32,
m.z as f32,
c.axis.x as f32,
c.axis.y as f32,
c.axis.z as f32,
c.e1.x as f32,
c.e1.y as f32,
c.e1.z as f32,
c.radius as f32,
];
for (v, x) in circle.iter_mut().zip(row) {
v.push(x);
}
}
let mut vertex: [Vec<f32>; 3] = Default::default();
for v in &a.vertices {
let q = v.position - frame;
for (d, x) in vertex.iter_mut().zip([q.x as f32, q.y as f32, q.z as f32]) {
d.push(x);
}
}
HostArrangement {
sphere,
status,
circle,
vertex,
}
}
pub(super) fn resident_for<'d>(
&self,
device: &'d Device,
refine: bool,
) -> Result<Resident<'d>> {
let mut r = self.resident(device)?;
if refine {
let lo = Residuals::new(self);
r.set_refinement(&lo.as_ref(self))
.map_err(|e| device_error(&e))?;
}
Ok(r)
}
pub(super) fn resident<'d>(&self, device: &'d Device) -> Result<Resident<'d>> {
let host = self.host_arrangement();
let a = &self.field.arr;
let fo = self.lattice.frame_origin();
let aref = ArrangementRef {
sphere: std::array::from_fn(|i| host.sphere[i].as_slice()),
status: &host.status,
neighbors: a.neighbors.parts(),
circle: std::array::from_fn(|i| host.circle[i].as_slice()),
circle_blockers: a.circle_blockers.parts(),
vertex: std::array::from_fn(|i| host.vertex[i].as_slice()),
sphere_grid: grid(&a.cells, fo),
circle_grid: grid(&self.field.circle_cells, fo),
vertex_grid: grid(&self.field.vertex_cells, fo),
max_expanded: a.max_expanded as f32,
rho_max: self.field.rho_max as f32,
};
Resident::new(device, &aref).map_err(|e| device_error(&e))
}
pub(super) fn batch_params(&self) -> BatchParams {
let b = u32::try_from(self.lattice.b).expect("brick edge fits u32");
let sub = b / 2;
let h = self.lattice.h;
let probe = self.field.probe;
let band = self.band;
let rho = 0.5 * 3f64.sqrt() * f64::from(sub) * h;
let ses = self.field.kind == SurfaceKind::Ses;
let reach = if ses { probe + band + rho } else { band + rho };
let margin = rho + CLASSIFY_EPS;
let cutoffc = (probe + margin + CLASSIFY_EPS) as f32;
let cutoff = (probe + band) as f32;
let m = self.coord_max.clamp(1.0, 1e6) as f32;
let ulp = f32::from_bits(m.to_bits() + 1) - m;
BatchParams {
ses,
probe: probe as f32,
band: band as f32,
cutoff2: cutoff * cutoff,
rho: rho as f32,
reach: reach as f32,
margin: margin as f32,
slack: 1e-3 + 16.0 * ulp,
cutoffc2: cutoffc * cutoffc,
h: h as f32,
b,
sub,
near: false,
}
}
pub(super) fn frame_origins(&self, bricks: &[[i32; 3]]) -> Vec<[i32; 3]> {
let frame = self.lattice.frame();
bricks
.iter()
.map(|&k| {
let o = self.lattice.brick_origin(k);
[0, 1, 2].map(|a| {
i32::try_from(o[a] - frame[a]).expect("frame-local brick origins fit i32")
})
})
.collect()
}
}
struct Progress<'a, 'c> {
control: &'a Control<'c>,
stage: Stage,
done: AtomicU64,
step: u64,
total: u64,
}
impl Progress<'_, '_> {
fn brick(&self) {
if self.control.has_progress() {
let d = self.done.fetch_add(1, Ordering::Relaxed) + 1;
if d.is_multiple_of(self.step) && d < self.total {
self.control.report(self.stage, d, self.total);
}
}
}
}
const RING: usize = 3;
#[derive(Default)]
struct Pipeline {
ready: usize,
meshed: Vec<usize>,
stopped: bool,
error: Option<Error>,
}
fn wait<'a, T>(
cv: &std::sync::Condvar,
g: std::sync::MutexGuard<'a, T>,
) -> std::sync::MutexGuard<'a, T> {
cv.wait_timeout(g, std::time::Duration::from_millis(5))
.unwrap_or_else(std::sync::PoisonError::into_inner)
.0
}
fn lock<T>(m: &std::sync::Mutex<T>) -> std::sync::MutexGuard<'_, T> {
m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
impl Engine {
#[allow(clippy::too_many_arguments)]
pub(crate) fn fold_brick_chunks_hip<A, I, F>(
&self,
device: &Device,
batching: Batching,
refine: bool,
bricks: &[[i32; 3]],
chunk: usize,
control: &Control<'_>,
stage: Stage,
init: I,
f: F,
) -> Result<Vec<A>>
where
A: Send,
I: Fn() -> A + Sync + Send,
F: Fn(&mut A, [i32; 3], &[f32], Option<&DeviceEdges<'_>>) + Sync + Send,
{
use std::sync::atomic::AtomicUsize;
use std::sync::{Condvar, Mutex, RwLock};
debug_assert!(self.device_ok(), "no device path for this engine");
let total = bricks.len() as u64;
let progress = Progress {
control,
stage,
done: AtomicU64::new(0),
step: (total / 100).max(1),
total,
};
control.report(stage, 0, total);
let chunk = chunk.max(1);
let chunks = bricks.len().div_ceil(chunk);
if chunks == 0 {
control.report(stage, total, total);
return Ok(Vec::new());
}
let resident = self.resident_for(device, refine)?;
let p = self.batch_params();
control.check()?;
let per_batch = batching.chunks.clamp(1, chunks);
let batches = chunks.div_ceil(per_batch);
let chunks_of = |k: usize| (k * per_batch)..chunks.min((k + 1) * per_batch);
let bricks_of = |k: usize| {
let c = chunks_of(k);
(c.start * chunk)..bricks.len().min(c.end * chunk)
};
let ring = (0..RING.min(batches))
.map(|_| Batch::new(device).map(RwLock::new))
.collect::<std::result::Result<Vec<_>, _>>()
.map_err(|e| device_error(&e))?;
let state = Mutex::new(Pipeline {
meshed: vec![0; batches],
..Pipeline::default()
});
let cv = Condvar::new();
let next = AtomicUsize::new(0);
let produce = || {
for k in 0..batches {
let mut g = lock(&state);
while k >= RING
&& g.meshed[k - RING] < chunks_of(k - RING).len()
&& !g.stopped
&& !control.is_cancelled()
{
g = wait(&cv, g);
}
if g.stopped || control.is_cancelled() {
break;
}
drop(g);
let origins = self.frame_origins(&bricks[bricks_of(k)]);
let mut slot = ring[k % RING]
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let ran = resident.run(&p, &origins, &mut slot).and_then(|_| {
if refine {
resident.refine(&p, &mut slot)?;
}
Ok(())
});
drop(slot);
let mut g = lock(&state);
match ran {
Ok(_) => g.ready = k + 1,
Err(e) => {
g.error = Some(device_error(&e));
break;
}
}
drop(g);
cv.notify_all();
}
lock(&state).stopped = true;
cv.notify_all();
};
let consume = |_: usize| {
let mut mine = Vec::new();
let n = self.samples_per_brick();
'chunks: loop {
if control.is_cancelled() {
break;
}
let c = next.fetch_add(1, Ordering::Relaxed);
if c >= chunks {
break;
}
let k = c / per_batch;
let mut g = lock(&state);
while g.ready <= k {
if g.stopped || control.is_cancelled() {
break 'chunks;
}
g = wait(&cv, g);
}
drop(g);
let slot = ring[k % RING]
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let first = bricks_of(k).start;
let mut acc = init();
for i in par::chunk_range(bricks.len(), chunk, c) {
if control.is_cancelled() {
break 'chunks;
}
let edges = DeviceEdges::of(&slot, i - first);
f(
&mut acc,
bricks[i],
&slot.brick_values(i - first)[..n],
edges.as_ref(),
);
progress.brick();
}
drop(slot);
mine.push((c, acc));
let mut g = lock(&state);
g.meshed[k] += 1;
let free = g.meshed[k] == chunks_of(k).len();
drop(g);
if free {
cv.notify_all();
}
}
mine
};
let parts = std::thread::scope(|scope| {
let device_side = scope.spawn(produce);
let parts = par::map(par::threads(), consume);
cv.notify_all();
if device_side.join().is_err() {
lock(&state).error = Some(Error::Internal("hip: device thread panicked".into()));
}
parts
});
if let Some(e) = lock(&state).error.take() {
return Err(e);
}
control.check()?;
let mut parts: Vec<(usize, A)> = parts.into_iter().flatten().collect();
if parts.len() != chunks {
return Err(Error::Internal(format!(
"hip: {} of {chunks} chunks meshed",
parts.len()
)));
}
parts.sort_unstable_by_key(|p| p.0);
control.report(stage, total, total);
Ok(parts.into_iter().map(|p| p.1).collect())
}
}
#[cfg(test)]
mod tests {
use sesmesh_gpu::hip::Runtime;
use sesmesh_testkit::clusters::{Cluster, Rng, cage, random_box, random_chain};
use super::*;
use crate::field::{ScratchPool, SesField, SimdLevel};
use crate::geom::Sphere;
use crate::mesh::extract::{BrickMesh, ChunkMesh, assemble, mesh_brick, mesh_brick_device};
use crate::surface::RefineMode;
fn device() -> Option<Device> {
match Runtime::load().and_then(|r| r.open(0)) {
Ok(d) => Some(d),
Err(_) if std::env::var("SESMESH_GPU_REQUIRE").as_deref() != Ok("1") => None,
Err(e) => panic!("{e}"),
}
}
fn spheres(c: &Cluster) -> (Vec<Sphere>, f64) {
let s = c
.centers
.iter()
.zip(&c.radii)
.map(|(&p, &r)| Sphere::new(p, r))
.collect();
(s, c.probe)
}
fn crambin() -> (Vec<Sphere>, f64) {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data/1crn.cif");
let structure = crate::io::read_path(&path, &crate::io::ReadOptions::default()).unwrap();
let mut d = crate::Diagnostics::new();
let atoms = structure
.select(&crate::Selection::default(), &mut d)
.unwrap();
let radii =
crate::radii::assign(&atoms, &crate::radii::RadiusOptions::default(), &mut d).unwrap();
(Sphere::from_atoms(&atoms, &radii).unwrap(), 1.4)
}
fn engine((spheres, probe): &(Vec<Sphere>, f64), kind: SurfaceKind, h: f64) -> Engine {
let field = SesField::new(spheres, *probe, kind).unwrap();
Engine::new(field, h, 10, SimdLevel::Auto).unwrap()
}
fn clusters() -> Vec<(Vec<Sphere>, f64)> {
let mut rng = Rng::new(11);
vec![
spheres(&random_chain(&mut rng, 60)),
spheres(&random_box(&mut rng, 80, 14.0)),
spheres(&cage(7.0, 1.6, 1.4)),
crambin(),
]
}
const BATCHINGS: [Batching; 3] = [
Batching { chunks: 1 },
Batching { chunks: 2 },
Batching { chunks: usize::MAX },
];
#[test]
fn fast_mode_has_larger_batches() {
let threads = par::threads();
assert_eq!(Batching::mesh(false, 64).chunks, threads);
assert_eq!(Batching::mesh(true, 64).chunks, threads.max(128));
assert_eq!(
Batching::mesh(true, 0).chunks,
threads.max(FAST_BATCH_BRICKS)
);
}
fn collect(acc: &mut Vec<Vec<f32>>, _: [i32; 3], v: &[f32]) {
acc.push(v.to_vec());
}
fn collect_dev(acc: &mut Vec<Vec<f32>>, k: [i32; 3], v: &[f32], _: Option<&DeviceEdges<'_>>) {
collect(acc, k, v);
}
#[test]
fn device_values_match_cpu_values() {
let Some(device) = device() else { return };
let pool = ScratchPool::default();
let control = Control::new();
for c in &clusters() {
for kind in [SurfaceKind::Ses, SurfaceKind::Sas, SurfaceKind::Vdw] {
for h in [0.3, 0.7] {
let e = engine(c, kind, h);
let band = e.band as f32;
let (_, bricks) = e.surface_bricks().unwrap();
let chunk = par::chunk_len(bricks.len()).max(3);
let cpu = e
.fold_brick_chunks_with(
&bricks,
chunk,
&control,
Stage::Mesh,
&pool,
Vec::new,
collect,
)
.unwrap();
let (mut same, mut uniform) = (0usize, 0usize);
for batching in BATCHINGS.into_iter().chain([Batching::default()]) {
let gpu = e
.fold_brick_chunks_hip(
&device,
batching,
false,
&bricks,
chunk,
&control,
Stage::Mesh,
Vec::new,
collect_dev,
)
.unwrap();
assert_eq!(gpu.len(), cpu.len());
for (g, c) in gpu.iter().flatten().zip(cpu.iter().flatten()) {
for (&d, &v) in g.iter().zip(c) {
assert_eq!(d < 0.0, v < 0.0, "{kind:?} h {h} {batching:?}");
if d.to_bits() == v.to_bits() {
same += 1;
} else {
assert_eq!(v.abs(), band, "{kind:?} h {h} {batching:?}");
uniform += 1;
}
}
}
}
assert!(same > 20 * uniform, "{kind:?} h {h}: {same} {uniform}");
}
}
}
}
#[test]
fn device_meshes_equal_cpu_meshes() {
let Some(device) = device() else { return };
let pool = ScratchPool::default();
let control = Control::new();
for c in &clusters() {
for kind in [SurfaceKind::Ses, SurfaceKind::Sas, SurfaceKind::Vdw] {
let e = engine(c, kind, 0.4);
let (_, bricks) = e.surface_bricks().unwrap();
let push = |m: &mut ChunkMesh, key, values: &[f32]| {
m.push(&e, key, values, RefineMode::Exact);
};
let chunk = par::chunk_len(bricks.len());
let parts = e
.fold_brick_chunks_with(
&bricks,
chunk,
&control,
Stage::Mesh,
&pool,
ChunkMesh::default,
push,
)
.unwrap();
let cpu = assemble(&bricks, chunk, parts).unwrap();
assert!(!cpu.triangles.is_empty());
let chunk = device_chunk(bricks.len());
for batching in BATCHINGS {
let parts = e
.fold_brick_chunks_hip(
&device,
batching,
false,
&bricks,
chunk,
&control,
Stage::Mesh,
ChunkMesh::default,
|m, key, values, edges| {
assert!(edges.is_none());
push(m, key, values);
},
)
.unwrap();
let gpu = assemble(&bricks, chunk, parts).unwrap();
let what = format!("{kind:?} {batching:?}");
assert_eq!(gpu.positions, cpu.positions, "{what}");
assert_eq!(gpu.normals, cpu.normals, "{what}");
assert_eq!(gpu.triangles, cpu.triangles, "{what}");
assert_eq!(gpu.vertex_atom, cpu.vertex_atom, "{what}");
assert_eq!(gpu.vertex_patch, cpu.vertex_patch, "{what}");
}
}
}
}
#[test]
fn cancellation_stops_device_batches() {
let Some(device) = device() else { return };
let mut rng = Rng::new(3);
let e = engine(
&spheres(&random_box(&mut rng, 60, 12.0)),
SurfaceKind::Ses,
0.4,
);
let (_, bricks) = e.surface_bricks().unwrap();
let flag = std::sync::atomic::AtomicBool::new(true);
let control = Control::new().with_cancel(&flag);
for refine in [false, true] {
let r = e.fold_brick_chunks_hip(
&device,
Batching::default(),
refine,
&bricks,
4,
&control,
Stage::Mesh,
Vec::new,
collect_dev,
);
assert!(matches!(r, Err(Error::Cancelled)));
}
}
#[test]
fn fast_meshes_match_exact_meshes() {
let Some(device) = device() else { return };
let pool = ScratchPool::default();
let control = Control::new();
for c in &clusters() {
for kind in [SurfaceKind::Ses, SurfaceKind::Sas, SurfaceKind::Vdw] {
let e = engine(c, kind, 0.4);
let (_, bricks) = e.surface_bricks().unwrap();
let chunk = par::chunk_len(bricks.len());
let parts = e
.fold_brick_chunks_with(
&bricks,
chunk,
&control,
Stage::Mesh,
&pool,
ChunkMesh::default,
|m: &mut ChunkMesh, key, values: &[f32]| {
m.push(&e, key, values, RefineMode::Exact);
},
)
.unwrap();
let cpu = assemble(&bricks, chunk, parts).unwrap();
let chunk = device_chunk(bricks.len());
let mut first: Option<crate::mesh::Mesh> = None;
for batching in BATCHINGS {
let parts = e
.fold_brick_chunks_hip(
&device,
batching,
true,
&bricks,
chunk,
&control,
Stage::Mesh,
ChunkMesh::default,
|m, key, values, edges| {
m.push_device(&e, key, values, edges.expect("refined batch"));
},
)
.unwrap();
let fast = assemble(&bricks, chunk, parts).unwrap();
let what = format!("{kind:?} {batching:?}");
assert_eq!(fast.triangles, cpu.triangles, "{what}");
let f = |p: [f32; 3]| e.field.value(p.map(f64::from)).abs();
let worst = |m: &crate::mesh::Mesh| {
m.positions.iter().map(|&p| f(p)).fold(0.0, f64::max)
};
assert!(worst(&fast) <= worst(&cpu) + 1e-5, "{what}");
let far = fast
.positions
.iter()
.zip(&cpu.positions)
.filter(|(a, b)| {
let d = (0..3).map(|i| f64::from(a[i] - b[i]).powi(2)).sum::<f64>();
d.sqrt() > 1e-4
})
.count();
assert!(far * 1000 <= cpu.positions.len(), "{what}: {far}");
match &first {
None => first = Some(fast),
Some(m) => {
assert_eq!(fast.positions, m.positions, "{what}");
assert_eq!(fast.normals, m.normals, "{what}");
assert_eq!(fast.vertex_atom, m.vertex_atom, "{what}");
assert_eq!(fast.vertex_patch, m.vertex_patch, "{what}");
}
}
}
}
}
}
#[test]
fn unconverged_edges_are_refined_exactly() {
let e = engine(&crambin(), SurfaceKind::Ses, 0.4);
let (_, bricks) = e.surface_bricks().unwrap();
let mut s = e.scratch();
let n = e.samples_per_brick();
let (t, feat, q) = (vec![0.5f32; 3000], vec![0u32; 3000], vec![0f32; 9000]);
let evals = vec![3u32; 3000];
for &key in bricks.iter().step_by(7) {
e.evaluate(key, &mut s);
let values = &s.values[..n];
let mut exact = BrickMesh::default();
mesh_brick(&e, key, values, RefineMode::Exact, &mut exact);
let offsets: Vec<u32> = (0..9).map(|sb| sb * 375).collect();
let edges = DeviceEdges {
offsets: &offsets,
t: &t,
features: &feat,
closest: &q,
evals: &evals,
};
let mut fast = BrickMesh::default();
mesh_brick_device(&e, key, values, &edges, &mut fast);
assert_eq!(fast.vertices(), exact.vertices());
assert_eq!(fast.triangles(), exact.triangles());
assert_eq!(fast.evals, exact.evals);
assert_eq!(fast.cpu_refined as usize, exact.vertices().0.len());
}
}
}