use crate::device::WgpuDevice;
use crate::device::capabilities::{DeviceCapabilities, Fp64Strategy};
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::Result;
use std::sync::Arc;
use super::su3::{su3_df64_preamble, su3_preamble};
const FORCE_WG: u32 = 64;
const FORCE_SHADER_BODY: &str = include_str!("../../shaders/lattice/su3_hmc_force_f64.wgsl");
const FORCE_SHADER_DF64: &str = include_str!("../../shaders/lattice/su3_hmc_force_df64.wgsl");
pub struct Su3HmcForce {
device: Arc<WgpuDevice>,
volume: u32,
shader_src: String,
params: wgpu::Buffer,
}
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct ForceParams {
nt: u32,
nx: u32,
ny: u32,
nz: u32,
volume: u32,
_pad0: u32,
_pad1: u32,
_pad2: u32,
beta: f64,
_padf: f64,
_paf1: f64,
_paf2: f64,
}
impl Su3HmcForce {
pub fn new(
device: Arc<WgpuDevice>,
nt: u32,
nx: u32,
ny: u32,
nz: u32,
beta: f64,
) -> Result<Self> {
let volume = nt * nx * ny * nz;
let caps = DeviceCapabilities::from_device(&device);
let strategy = caps.fp64_strategy();
let shader_src = match strategy {
Fp64Strategy::Sovereign | Fp64Strategy::Native | Fp64Strategy::Concurrent => {
format!("{}{}", su3_preamble(), FORCE_SHADER_BODY)
}
Fp64Strategy::Hybrid => format!("{}{}", su3_df64_preamble(), FORCE_SHADER_DF64),
};
tracing::info!(
?strategy,
"Su3HmcForce: compiled with {:?} FP64 strategy",
strategy
);
let params_data = ForceParams {
nt,
nx,
ny,
nz,
volume,
_pad0: 0,
_pad1: 0,
_pad2: 0,
beta,
_padf: 0.0,
_paf1: 0.0,
_paf2: 0.0,
};
let params = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Su3HmcForce:params"),
size: std::mem::size_of::<ForceParams>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
device
.queue
.write_buffer(¶ms, 0, bytemuck::bytes_of(¶ms_data));
Ok(Self {
device,
volume,
shader_src,
params,
})
}
pub fn compute(&self, links_buf: &wgpu::Buffer, force_buf: &wgpu::Buffer) -> Result<()> {
ComputeDispatch::new(self.device.as_ref(), "Su3HmcForce")
.shader(&self.shader_src, "hmc_force")
.f64()
.uniform(0, &self.params)
.storage_read(1, links_buf)
.storage_rw(2, force_buf)
.dispatch(self.volume.div_ceil(FORCE_WG), 1, 1)
.submit()?;
Ok(())
}
#[must_use]
pub fn volume(&self) -> u32 {
self.volume
}
#[must_use]
pub fn link_buffer_len(&self) -> u64 {
self.volume as u64 * 4 * 18
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_shader_has_staple_sum() {
let src = format!("{}{}", su3_preamble(), FORCE_SHADER_BODY);
assert!(
src.contains("staple"),
"force shader must implement staple sum"
);
assert!(
src.contains("su3_project_algebra"),
"must project onto algebra"
);
}
#[test]
fn test_link_buffer_len() {
let vol: u64 = 4 * 4 * 4 * 4; assert_eq!(vol * 4 * 18, 18432);
}
#[test]
fn test_params_16byte_aligned() {
assert_eq!(std::mem::size_of::<ForceParams>() % 16, 0);
}
#[test]
fn test_su3_hmc_force_identity_links_gpu() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available_sync()
else {
return;
};
let (nt, nx, ny, nz) = (2u32, 2, 2, 2);
let volume = (nt * nx * ny * nz) as usize;
let identity_18: [f64; 18] = [
1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0,
0.0,
];
let links_f64: Vec<f64> = std::iter::repeat_n(identity_18.iter().copied(), volume * 4)
.flatten()
.collect();
let buf_f64_len = volume * 4 * 18;
let buf_bytes = buf_f64_len * std::mem::size_of::<f64>();
let links_buf = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("test:links"),
size: buf_bytes as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
device
.queue
.write_buffer(&links_buf, 0, bytemuck::cast_slice(&links_f64));
let zeros: Vec<u8> = vec![0u8; buf_bytes];
let force_buf = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("test:force"),
size: buf_bytes as u64,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_DST
| wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
device.queue.write_buffer(&force_buf, 0, &zeros);
let op = Su3HmcForce::new(device.clone(), nt, nx, ny, nz, 6.0).unwrap();
op.compute(&links_buf, &force_buf).unwrap();
let staging = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("test:force_staging"),
size: buf_bytes as u64,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut enc = device.create_encoder_guarded(&Default::default());
enc.copy_buffer_to_buffer(&force_buf, 0, &staging, 0, buf_bytes as u64);
device.submit_commands(Some(enc.finish()));
let force_out: Vec<f64> = device.map_staging_buffer(&staging, buf_f64_len).unwrap();
for (i, &v) in force_out.iter().enumerate() {
assert!(
v.abs() < 1e-10,
"force[{i}] = {v:.15e}, expected 0.0 for identity links"
);
}
}
}