use crate::device::WgpuDevice;
use crate::device::capabilities::WORKGROUP_SIZE_1D;
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::Result;
use bytemuck::{Pod, Zeroable};
use std::sync::Arc;
#[repr(C)]
#[derive(Copy, Clone, Pod, Zeroable)]
struct GillespieParamsGpu {
n_reactions: u32,
n_species: u32,
n_trajectories: u32,
max_steps: u32,
t_max: f64,
_pad0: u32,
_pad1: u32,
}
#[derive(Debug, Clone)]
pub struct GillespieConfig {
pub t_max: f64,
pub max_steps: u32,
}
impl Default for GillespieConfig {
fn default() -> Self {
Self {
t_max: 100.0,
max_steps: 100_000,
}
}
}
pub struct GillespieModel<'a> {
pub rate_k: &'a [f64],
pub stoich_react: &'a [u32],
pub stoich_net: &'a [i32],
}
pub struct GillespieResult {
pub states: Vec<f64>,
pub times: Vec<f64>,
pub n_trajectories: usize,
pub n_species: usize,
}
pub struct GillespieGpu {
device: Arc<WgpuDevice>,
}
impl GillespieGpu {
#[must_use]
pub fn new(device: &WgpuDevice) -> Self {
Self::with_device(Arc::new(device.clone()))
}
#[must_use]
pub fn with_device(device: Arc<WgpuDevice>) -> Self {
Self { device }
}
pub fn simulate(
&self,
model: &GillespieModel<'_>,
initial_states: &[f64],
prng_seeds: &[u32],
n_trajectories: usize,
config: &GillespieConfig,
) -> Result<GillespieResult> {
let dev = &self.device;
let n_r = model.rate_k.len();
let n_s = model.stoich_net.len() / n_r;
let n_t = n_trajectories;
assert_eq!(
initial_states.len(),
n_t * n_s,
"initial_states must be [T×S]"
);
assert_eq!(prng_seeds.len(), n_t * 4, "prng_seeds must be [T×4]");
let rate_buf = dev
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Gillespie rates"),
contents: bytemuck::cast_slice(model.rate_k),
usage: wgpu::BufferUsages::STORAGE,
});
let sreact_buf = dev
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Gillespie stoich_react"),
contents: bytemuck::cast_slice(model.stoich_react),
usage: wgpu::BufferUsages::STORAGE,
});
let snet_buf = dev
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Gillespie stoich_net"),
contents: bytemuck::cast_slice(model.stoich_net),
usage: wgpu::BufferUsages::STORAGE,
});
let states_buf = dev
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Gillespie states"),
contents: bytemuck::cast_slice(initial_states),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
});
let prng_buf = dev
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Gillespie prng"),
contents: bytemuck::cast_slice(prng_seeds),
usage: wgpu::BufferUsages::STORAGE,
});
let times_buf = dev.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Gillespie times"),
size: (n_t * std::mem::size_of::<f64>()) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let prop_buf = dev.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Gillespie propensities"),
size: ((n_t * n_r) * std::mem::size_of::<f64>()).max(8) as u64,
usage: wgpu::BufferUsages::STORAGE,
mapped_at_creation: false,
});
let params = GillespieParamsGpu {
n_reactions: n_r as u32,
n_species: n_s as u32,
n_trajectories: n_t as u32,
max_steps: config.max_steps,
t_max: config.t_max,
_pad0: 0,
_pad1: 0,
};
let params_buf = dev
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Gillespie params"),
contents: bytemuck::bytes_of(¶ms),
usage: wgpu::BufferUsages::STORAGE,
});
let wg = (n_t as u32).div_ceil(WORKGROUP_SIZE_1D);
ComputeDispatch::new(dev, "gillespie_ssa")
.shader(
include_str!("../../shaders/bio/gillespie_ssa_f64.wgsl"),
"main",
)
.f64()
.storage_read(0, ¶ms_buf)
.storage_read(1, &rate_buf)
.storage_read(2, &sreact_buf)
.storage_read(3, &snet_buf)
.storage_rw(4, &states_buf)
.storage_rw(5, &prng_buf)
.storage_rw(6, ×_buf)
.storage_rw(7, &prop_buf)
.dispatch(wg, 1, 1)
.submit()?;
let states = dev.read_buffer_f64(&states_buf, n_t * n_s)?;
let times = dev.read_buffer_f64(×_buf, n_t)?;
Ok(GillespieResult {
states,
times,
n_trajectories: n_t,
n_species: n_s,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::device::test_pool;
#[tokio::test]
async fn test_irreversible_decay_mean() {
let Some(device) = test_pool::get_test_device_if_f64_gpu_available().await else {
return;
};
let ssa = GillespieGpu::new(&device);
let n_traj = 256usize;
let rate_k = vec![1.0_f64]; let stoich_react = vec![1u32]; let stoich_net = vec![-1i32];
let initial: Vec<f64> = vec![100.0; n_traj];
let mut seeds = Vec::with_capacity(n_traj * 4);
for i in 0..n_traj {
seeds.push(i as u32 + 1);
seeds.push(0x9e3779b9u32);
seeds.push(0x6c62272eu32);
seeds.push(0x85ebca77u32);
}
let model = GillespieModel {
rate_k: &rate_k,
stoich_react: &stoich_react,
stoich_net: &stoich_net,
};
let result = ssa
.simulate(
&model,
&initial,
&seeds,
n_traj,
&GillespieConfig {
t_max: 1.0,
max_steps: 100_000,
},
)
.unwrap();
let mean: f64 = result.states.iter().sum::<f64>() / n_traj as f64;
let expected = 100.0 * (-1.0_f64).exp();
assert!(
(mean - expected).abs() / expected < 0.15,
"mean={mean:.2}, expected≈{expected:.2}"
);
}
#[tokio::test]
async fn test_absorbing_state() {
let Some(device) = test_pool::get_test_device_if_f64_gpu_available().await else {
return;
};
let ssa = GillespieGpu::new(&device);
let rate_k = vec![0.0_f64];
let stoich_react = vec![1u32];
let stoich_net = vec![-1i32];
let initial = vec![50.0_f64, 50.0];
let seeds = vec![1u32, 2, 3, 4, 5, 6, 7, 8];
let model = GillespieModel {
rate_k: &rate_k,
stoich_react: &stoich_react,
stoich_net: &stoich_net,
};
let result = ssa
.simulate(&model, &initial, &seeds, 2, &GillespieConfig::default())
.unwrap();
assert_eq!(result.states[0], 50.0);
assert_eq!(result.states[1], 50.0);
}
}