use crate::device::WgpuDevice;
use crate::error::Result;
use bytemuck::{Pod, Zeroable};
use std::sync::Arc;
const DIRAC_WG: u32 = 64;
const DIRAC_SHADER: &str = include_str!("../../shaders/lattice/dirac_staggered_f64.wgsl");
#[repr(C)]
#[derive(Copy, Clone, Pod, Zeroable)]
struct DiracParams {
volume: u32,
pad0: u32,
mass_re: f64,
hop_sign: f64,
}
pub struct StaggeredDirac {
device: Arc<WgpuDevice>,
volume: u32,
pipeline: wgpu::ComputePipeline,
bgl: wgpu::BindGroupLayout,
}
impl StaggeredDirac {
pub fn new(device: Arc<WgpuDevice>, volume: u32) -> Result<Self> {
let module = device.compile_shader_f64(DIRAC_SHADER, Some("dirac_staggered"));
let bgl = device
.device
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("StaggeredDirac:bgl"),
entries: &[
uniform_bgl(0),
storage_bgl(1, true), storage_bgl(2, true), storage_bgl(3, false), storage_bgl(4, true), storage_bgl(5, true), ],
});
let layout = device
.device
.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("StaggeredDirac:layout"),
bind_group_layouts: &[&bgl],
immediate_size: 0,
});
let pipeline = device
.device
.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("StaggeredDirac:pipeline"),
layout: Some(&layout),
module: &module,
entry_point: Some("dirac"),
compilation_options: Default::default(),
cache: None,
});
Ok(Self {
device,
volume,
pipeline,
bgl,
})
}
pub fn dispatch(
&self,
mass: f64,
hop_sign: f64,
links_buf: &wgpu::Buffer,
psi_in: &wgpu::Buffer,
psi_out: &wgpu::Buffer,
nbr_buf: &wgpu::Buffer,
phases_buf: &wgpu::Buffer,
) -> Result<()> {
let params_data = DiracParams {
volume: self.volume,
pad0: 0,
mass_re: mass,
hop_sign,
};
let params = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("StaggeredDirac:params"),
size: std::mem::size_of::<DiracParams>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
self.device
.queue
.write_buffer(¶ms, 0, bytemuck::bytes_of(¶ms_data));
let bg = self
.device
.device
.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("StaggeredDirac:bg"),
layout: &self.bgl,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: params.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: links_buf.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 2,
resource: psi_in.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 3,
resource: psi_out.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 4,
resource: nbr_buf.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 5,
resource: phases_buf.as_entire_binding(),
},
],
});
let mut enc = self
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("StaggeredDirac:enc"),
});
{
let mut pass = enc.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("StaggeredDirac:pass"),
timestamp_writes: None,
});
pass.set_pipeline(&self.pipeline);
pass.set_bind_group(0, Some(&bg), &[]);
pass.dispatch_workgroups(self.volume.div_ceil(DIRAC_WG), 1, 1);
}
self.device.submit_commands(Some(enc.finish()));
Ok(())
}
}
pub struct DiracGpuLayout {
pub volume: usize,
pub links_flat: Vec<f64>,
pub neighbors: Vec<u32>,
pub phases: Vec<f64>,
}
impl DiracGpuLayout {
#[must_use]
pub fn new(dims: [usize; 4], links_data: Vec<f64>) -> Self {
let volume = dims.iter().product::<usize>();
let mut neighbors = vec![0u32; volume * 8];
let mut phases = vec![0.0f64; volume * 4];
for idx in 0..volume {
let coords = index_to_coords(idx, &dims);
for mu in 0..4 {
let fwd = site_neighbor(&coords, &dims, mu, true);
let bwd = site_neighbor(&coords, &dims, mu, false);
neighbors[idx * 8 + mu * 2] = fwd as u32;
neighbors[idx * 8 + mu * 2 + 1] = bwd as u32;
phases[idx * 4 + mu] = staggered_phase(&coords, mu);
}
}
Self {
volume,
links_flat: links_data,
neighbors,
phases,
}
}
}
fn index_to_coords(idx: usize, dims: &[usize; 4]) -> [usize; 4] {
let mut coords = [0usize; 4];
let mut rem = idx;
for d in (0..4).rev() {
coords[d] = rem % dims[d];
rem /= dims[d];
}
coords
}
fn coords_to_index(coords: &[usize; 4], dims: &[usize; 4]) -> usize {
coords[0] * dims[1] * dims[2] * dims[3]
+ coords[1] * dims[2] * dims[3]
+ coords[2] * dims[3]
+ coords[3]
}
fn site_neighbor(coords: &[usize; 4], dims: &[usize; 4], mu: usize, forward: bool) -> usize {
let mut c = *coords;
if forward {
c[mu] = (c[mu] + 1) % dims[mu];
} else {
c[mu] = (c[mu] + dims[mu] - 1) % dims[mu];
}
coords_to_index(&c, dims)
}
fn staggered_phase(coords: &[usize; 4], mu: usize) -> f64 {
let sum: usize = coords.iter().take(mu).sum();
if sum.is_multiple_of(2) { 1.0 } else { -1.0 }
}
fn storage_bgl(binding: u32, read_only: bool) -> wgpu::BindGroupLayoutEntry {
wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}
}
fn uniform_bgl(binding: u32) -> wgpu::BindGroupLayoutEntry {
wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn staggered_phases_correct() {
assert_eq!(staggered_phase(&[0, 0, 0, 0], 0), 1.0);
assert_eq!(staggered_phase(&[1, 0, 0, 0], 1), -1.0);
assert_eq!(staggered_phase(&[1, 1, 0, 0], 2), 1.0);
assert_eq!(staggered_phase(&[1, 1, 1, 0], 3), -1.0);
}
#[test]
fn index_roundtrip() {
let dims = [4, 4, 4, 4];
for idx in 0..256 {
let c = index_to_coords(idx, &dims);
assert_eq!(coords_to_index(&c, &dims), idx);
}
}
#[test]
fn neighbor_periodic() {
let dims = [4, 4, 4, 4];
let c = [3, 0, 0, 0];
let fwd = site_neighbor(&c, &dims, 0, true);
let fwd_c = index_to_coords(fwd, &dims);
assert_eq!(fwd_c[0], 0, "forward wraps: 3→0");
}
#[test]
fn gpu_layout_dimensions() {
let dims = [2, 2, 2, 2];
let vol = 16;
let links = vec![0.0f64; vol * 4 * 18];
let layout = DiracGpuLayout::new(dims, links);
assert_eq!(layout.volume, 16);
assert_eq!(layout.links_flat.len(), 16 * 4 * 18);
assert_eq!(layout.neighbors.len(), 16 * 8);
assert_eq!(layout.phases.len(), 16 * 4);
}
#[test]
fn test_dirac_shader_compiles() {
assert!(DIRAC_SHADER.contains("fn dirac"));
assert!(DIRAC_SHADER.contains("mass_re"));
}
}