use bytemuck::{Pod, Zeroable};
use cubecl::client::ComputeClient;
use cubecl::prelude::*;
use cubecl::server::Handle;
use cubecl::wgpu::WgpuRuntime;
mod chunk;
pub mod kernels;
pub use chunk::*;
#[repr(C)]
#[derive(Clone, Copy, Debug, Pod, Zeroable)]
pub struct Params {
pub n: u32,
pub dt: f32,
pub damping: f32,
pub repulsion: f32,
pub min_distance: f32,
pub spring_k: f32,
pub rest_length: f32,
pub centering: f32,
}
impl Default for Params {
fn default() -> Self {
Self {
n: 0,
dt: 1.0 / 60.0,
damping: 0.85,
repulsion: 4_000.0,
min_distance: 4.0,
spring_k: 0.08,
rest_length: 30.0,
centering: 0.05,
}
}
}
pub struct Adjacency<'a> {
pub offsets: &'a [u32],
pub targets: &'a [u32],
}
pub struct Resident {
client: ComputeClient<WgpuRuntime>,
params: Params,
positions: Handle,
velocities: Handle,
forces: Handle,
offsets: Handle,
targets: Handle,
settle: Handle,
revision: u64,
positions_alloc: (wgpu::Buffer, u64, u64),
forces_alloc: (wgpu::Buffer, u64, u64),
}
impl Resident {
pub fn new(
client: &ResidentClient,
positions: &[[f32; 4]],
adjacency: Adjacency<'_>,
params: Params,
) -> Self {
let n = positions.len() as u32;
assert_eq!(
adjacency.offsets.len(),
positions.len() + 1,
"CSR offsets must be one longer than the node count"
);
let params = Params { n, ..params };
let compute = client.compute_client().clone();
let zero = vec![[0.0f32; 4]; positions.len()];
let positions_handle = compute.create_from_slice(bytemuck::cast_slice(positions));
let velocities = compute.create_from_slice(bytemuck::cast_slice(&zero));
let forces = compute.create_from_slice(bytemuck::cast_slice(&zero));
let offsets = compute.create_from_slice(bytemuck::cast_slice(adjacency.offsets));
let targets = if adjacency.targets.is_empty() {
compute.create_from_slice(bytemuck::cast_slice(&[0u32]))
} else {
compute.create_from_slice(bytemuck::cast_slice(adjacency.targets))
};
let settle = compute.create_from_slice(bytemuck::bytes_of(&0u32));
let resolve = |handle: &Handle| {
let managed = compute
.get_resource(handle.clone())
.expect("resident allocation");
let resource = managed.resource();
(resource.buffer.clone(), resource.offset, resource.size)
};
let positions_alloc = resolve(&positions_handle);
let forces_alloc = resolve(&forces);
Self {
client: compute,
params,
positions: positions_handle,
velocities,
forces,
offsets,
targets,
settle,
revision: 0,
positions_alloc,
forces_alloc,
}
}
pub fn params(&self) -> Params {
self.params
}
pub fn set_params(&mut self, params: Params) {
self.params = Params {
n: self.params.n,
..params
};
}
pub fn revision(&self) -> u64 {
self.revision
}
pub fn step(&mut self) {
self.dispatch(true);
}
pub fn step_with_external_forces(&mut self) {
self.dispatch(false);
}
pub fn repulse_only(&self) {
let cubes = self.params.n.div_ceil(kernels::CUBE_DIM).max(1);
let count = self.params.n as usize;
unsafe {
kernels::repulse::launch_unchecked::<WgpuRuntime>(
&self.client,
CubeCount::Static(cubes, 1, 1),
CubeDim::new_1d(kernels::CUBE_DIM),
BufferArg::from_raw_parts(self.positions.clone(), count * 4),
BufferArg::from_raw_parts(self.forces.clone(), count * 4),
self.params.n,
self.params.repulsion,
self.params.min_distance,
(kernels::CUBE_DIM * kernels::STRIDE) as usize,
);
}
}
fn dispatch(&mut self, own_repulsion: bool) {
let cubes = self.params.n.div_ceil(kernels::CUBE_DIM).max(1);
let count = self.params.n as usize;
let dim = CubeDim::new_1d(kernels::CUBE_DIM);
unsafe {
kernels::clear_settle::launch_unchecked::<WgpuRuntime>(
&self.client,
CubeCount::Static(1, 1, 1),
CubeDim::new_1d(1),
BufferArg::from_raw_parts(self.settle.clone(), 1),
);
}
if own_repulsion {
self.repulse_only();
}
unsafe {
kernels::springs::launch_unchecked::<WgpuRuntime>(
&self.client,
CubeCount::Static(cubes, 1, 1),
dim,
BufferArg::from_raw_parts(self.positions.clone(), count * 4),
BufferArg::from_raw_parts(self.forces.clone(), count * 4),
BufferArg::from_raw_parts(self.offsets.clone(), count + 1),
BufferArg::from_raw_parts(self.targets.clone(), 1),
self.params.n,
self.params.spring_k,
self.params.rest_length,
);
kernels::integrate::launch_unchecked::<WgpuRuntime>(
&self.client,
CubeCount::Static(cubes, 1, 1),
dim,
BufferArg::from_raw_parts(self.positions.clone(), count * 4),
BufferArg::from_raw_parts(self.velocities.clone(), count * 4),
BufferArg::from_raw_parts(self.forces.clone(), count * 4),
BufferArg::from_raw_parts(self.settle.clone(), 1),
self.params.n,
self.params.dt,
self.params.damping,
self.params.centering,
);
}
self.revision += 1;
}
pub fn max_speed(&self) -> f32 {
let bytes = self
.client
.read_one(self.settle.clone())
.expect("settle readback");
f32::from_bits(u32::from_le_bytes(
bytes[..4].try_into().expect("four bytes"),
))
}
pub fn read_positions(&self) -> Vec<[f32; 4]> {
self.read_all(&self.positions)
}
pub fn read_forces(&self) -> Vec<[f32; 4]> {
self.read_all(&self.forces)
}
fn read_all(&self, handle: &Handle) -> Vec<[f32; 4]> {
let bytes = self
.client
.read_one(handle.clone())
.expect("field readback");
bytemuck::cast_slice(&bytes[..(self.params.n as usize) * 16]).to_vec()
}
pub fn positions_lease(&self) -> SpatialLease<'_> {
self.lease_of(&self.positions_alloc)
}
pub fn forces_lease(&self) -> SpatialLease<'_> {
self.lease_of(&self.forces_alloc)
}
fn lease_of<'a>(&'a self, alloc: &'a (wgpu::Buffer, u64, u64)) -> SpatialLease<'a> {
SpatialLease {
buffer: &alloc.0,
offset: alloc.1,
size: alloc.2,
shape: [self.params.n as usize, 4, 1],
element_type: PlaneElementType::F32,
stamp: ChunkStamp {
revision: self.revision,
valid_read_epoch: ReadEpoch::new(self.revision),
},
}
}
}