use crate::device::WgpuDevice;
use crate::error::Result;
use crate::pipeline::ReduceScalarPipeline;
use std::sync::Arc;
use super::dirac::StaggeredDirac;
const CG_WG: u32 = 64;
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct DotParams {
n_pairs: u32,
pad0: u32,
pad1: u32,
pad2: u32,
}
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct AxpyParams {
n: u32,
pad0: u32,
alpha: f64,
}
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct XpayParams {
n: u32,
pad0: u32,
beta: f64,
}
pub struct CgLatticeBuffers<'a> {
pub links: &'a wgpu::Buffer,
pub nbr: &'a wgpu::Buffer,
pub phases: &'a wgpu::Buffer,
}
#[derive(Clone, Debug)]
pub struct CgSolverConfig {
pub mass: f64,
pub tol: f64,
pub max_iter: usize,
}
#[derive(Clone, Debug)]
pub struct GpuCgResult {
pub converged: bool,
pub iterations: usize,
pub residual_sq: f64,
}
pub struct GpuCgBuffers {
pub x: wgpu::Buffer,
pub r: wgpu::Buffer,
pub p: wgpu::Buffer,
pub ap: wgpu::Buffer,
pub tmp: wgpu::Buffer,
pub dot_out: wgpu::Buffer,
}
impl GpuCgBuffers {
#[must_use]
pub fn new(device: &WgpuDevice, volume: usize) -> Self {
let field_bytes = (volume * 6 * std::mem::size_of::<f64>()) as u64;
let dot_bytes = (volume * 3 * std::mem::size_of::<f64>()) as u64;
let make_field = |label: &str| {
device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label),
size: field_bytes,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_DST
| wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
})
};
Self {
x: make_field("cg:x"),
r: make_field("cg:r"),
p: make_field("cg:p"),
ap: make_field("cg:ap"),
tmp: make_field("cg:tmp"),
dot_out: device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("cg:dot_out"),
size: dot_bytes,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_DST
| wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
}),
}
}
}
pub struct GpuCgSolver {
device: Arc<WgpuDevice>,
volume: u32,
n_f64: u32,
n_pairs: u32,
dirac: StaggeredDirac,
dot_pipeline: wgpu::ComputePipeline,
dot_bgl: wgpu::BindGroupLayout,
axpy_pipeline: wgpu::ComputePipeline,
axpy_bgl: wgpu::BindGroupLayout,
xpay_pipeline: wgpu::ComputePipeline,
xpay_bgl: wgpu::BindGroupLayout,
reducer: ReduceScalarPipeline,
}
impl GpuCgSolver {
pub fn new(device: Arc<WgpuDevice>, volume: u32) -> Result<Self> {
let dirac = StaggeredDirac::new(device.clone(), volume)?;
let n_f64 = volume * 6; let n_pairs = volume * 3;
let dot_module =
device.compile_shader_f64(super::cg::WGSL_COMPLEX_DOT_RE_F64, Some("cg_dot"));
let axpy_module = device.compile_shader_f64(super::cg::WGSL_AXPY_F64, Some("cg_axpy"));
let xpay_module = device.compile_shader_f64(super::cg::WGSL_XPAY_F64, Some("cg_xpay"));
let dot_bgl = device
.device
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("cg_dot:bgl"),
entries: &[
uniform_bgl(0),
storage_bgl(1, true),
storage_bgl(2, true),
storage_bgl(3, false),
],
});
let axpy_bgl = device
.device
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("cg_axpy:bgl"),
entries: &[uniform_bgl(0), storage_bgl(1, true), storage_bgl(2, false)],
});
let xpay_bgl = device
.device
.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("cg_xpay:bgl"),
entries: &[uniform_bgl(0), storage_bgl(1, true), storage_bgl(2, false)],
});
let make_pipeline = |bgl: &wgpu::BindGroupLayout,
module: &wgpu::ShaderModule,
label: &str| {
let layout = device
.device
.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some(&format!("{label}:layout")),
bind_group_layouts: &[bgl],
immediate_size: 0,
});
device
.device
.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some(label),
layout: Some(&layout),
module,
entry_point: Some("main"),
compilation_options: Default::default(),
cache: None,
})
};
let dot_pipeline = make_pipeline(&dot_bgl, &dot_module, "cg_dot");
let axpy_pipeline = make_pipeline(&axpy_bgl, &axpy_module, "cg_axpy");
let xpay_pipeline = make_pipeline(&xpay_bgl, &xpay_module, "cg_xpay");
let reducer = ReduceScalarPipeline::new(device.clone(), n_pairs as usize)?;
Ok(Self {
device,
volume,
n_f64,
n_pairs,
dirac,
dot_pipeline,
dot_bgl,
axpy_pipeline,
axpy_bgl,
xpay_pipeline,
xpay_bgl,
reducer,
})
}
pub fn solve(
&self,
b_buf: &wgpu::Buffer,
bufs: &GpuCgBuffers,
lattice: &CgLatticeBuffers<'_>,
config: &CgSolverConfig,
) -> Result<GpuCgResult> {
let n = self.n_f64 as usize;
let n_bytes = (n * std::mem::size_of::<f64>()) as u64;
self.device
.queue
.write_buffer(&bufs.x, 0, &vec![0u8; n_bytes as usize]);
self.copy_buffer(b_buf, &bufs.r, n_bytes);
self.copy_buffer(&bufs.r, &bufs.p, n_bytes);
let b_norm_sq = self.complex_dot_re(b_buf, b_buf, &bufs.dot_out)?;
if b_norm_sq < 1e-30 {
return Ok(GpuCgResult {
converged: true,
iterations: 0,
residual_sq: 0.0,
});
}
let tol_sq = config.tol * config.tol * b_norm_sq;
let mut rr = b_norm_sq;
for iter in 0..config.max_iter {
self.dirac.dispatch(
config.mass,
1.0,
lattice.links,
&bufs.p,
&bufs.tmp,
lattice.nbr,
lattice.phases,
)?;
self.dirac.dispatch(
config.mass,
-1.0,
lattice.links,
&bufs.tmp,
&bufs.ap,
lattice.nbr,
lattice.phases,
)?;
let p_ap = self.complex_dot_re(&bufs.p, &bufs.ap, &bufs.dot_out)?;
if p_ap.abs() < 1e-30 {
return Ok(GpuCgResult {
converged: false,
iterations: iter,
residual_sq: rr,
});
}
let alpha = rr / p_ap;
self.axpy(alpha, &bufs.p, &bufs.x)?;
self.axpy(-alpha, &bufs.ap, &bufs.r)?;
let new_rr = self.complex_dot_re(&bufs.r, &bufs.r, &bufs.dot_out)?;
if new_rr < tol_sq {
return Ok(GpuCgResult {
converged: true,
iterations: iter + 1,
residual_sq: new_rr,
});
}
let beta = new_rr / rr;
rr = new_rr;
self.xpay(&bufs.r, beta, &bufs.p)?;
}
Ok(GpuCgResult {
converged: false,
iterations: config.max_iter,
residual_sq: rr,
})
}
fn copy_buffer(&self, src: &wgpu::Buffer, dst: &wgpu::Buffer, size: u64) {
let mut enc = self.device.create_encoder_guarded(&Default::default());
enc.copy_buffer_to_buffer(src, 0, dst, 0, size);
self.device.submit_commands(Some(enc.finish()));
}
fn complex_dot_re(
&self,
a: &wgpu::Buffer,
b: &wgpu::Buffer,
out: &wgpu::Buffer,
) -> Result<f64> {
let params_data = DotParams {
n_pairs: self.n_pairs,
pad0: 0,
pad1: 0,
pad2: 0,
};
let params = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("cg_dot:params"),
size: std::mem::size_of::<DotParams>() 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("cg_dot:bg"),
layout: &self.dot_bgl,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: params.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: a.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 2,
resource: b.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 3,
resource: out.as_entire_binding(),
},
],
});
let mut enc = self
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("cg_dot:enc"),
});
{
let mut pass = enc.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("cg_dot:pass"),
timestamp_writes: None,
});
pass.set_pipeline(&self.dot_pipeline);
pass.set_bind_group(0, Some(&bg), &[]);
pass.dispatch_workgroups(self.n_pairs.div_ceil(CG_WG), 1, 1);
}
self.device.submit_commands(Some(enc.finish()));
self.reducer.sum_f64(out)
}
fn axpy(&self, alpha: f64, x: &wgpu::Buffer, y: &wgpu::Buffer) -> Result<()> {
let params_data = AxpyParams {
n: self.n_f64,
pad0: 0,
alpha,
};
let params = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("cg_axpy:params"),
size: std::mem::size_of::<AxpyParams>() 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("cg_axpy:bg"),
layout: &self.axpy_bgl,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: params.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: x.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 2,
resource: y.as_entire_binding(),
},
],
});
let mut enc = self
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("cg_axpy:enc"),
});
{
let mut pass = enc.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("cg_axpy:pass"),
timestamp_writes: None,
});
pass.set_pipeline(&self.axpy_pipeline);
pass.set_bind_group(0, Some(&bg), &[]);
pass.dispatch_workgroups(self.n_f64.div_ceil(CG_WG), 1, 1);
}
self.device.submit_commands(Some(enc.finish()));
Ok(())
}
fn xpay(&self, x: &wgpu::Buffer, beta: f64, p: &wgpu::Buffer) -> Result<()> {
let params_data = XpayParams {
n: self.n_f64,
pad0: 0,
beta,
};
let params = self.device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("cg_xpay:params"),
size: std::mem::size_of::<XpayParams>() 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("cg_xpay:bg"),
layout: &self.xpay_bgl,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: params.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: x.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 2,
resource: p.as_entire_binding(),
},
],
});
let mut enc = self
.device
.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("cg_xpay:enc"),
});
{
let mut pass = enc.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("cg_xpay:pass"),
timestamp_writes: None,
});
pass.set_pipeline(&self.xpay_pipeline);
pass.set_bind_group(0, Some(&bg), &[]);
pass.dispatch_workgroups(self.n_f64.div_ceil(CG_WG), 1, 1);
}
self.device.submit_commands(Some(enc.finish()));
Ok(())
}
#[must_use]
pub fn volume(&self) -> u32 {
self.volume
}
}
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 test_cg_solver_pipeline_creation() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available_sync()
else {
return;
};
let solver = GpuCgSolver::new(device, 16).unwrap();
assert_eq!(solver.volume(), 16);
}
}