use crate::device::WgpuDevice;
use crate::device::capabilities::WORKGROUP_SIZE_1D;
use crate::device::capabilities::{DeviceCapabilities, Fp64Strategy};
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 ReduceParams {
size: u32,
_pad1: u32,
_pad2: u32,
_pad3: u32,
}
const SHADER_NATIVE: &str = include_str!("../shaders/reduce/prod_reduce_f64.wgsl");
const SHADER_DF64: &str = include_str!("../shaders/reduce/prod_reduce_df64.wgsl");
fn shader_config_for_device(device: &WgpuDevice) -> (&'static str, bool) {
let caps = DeviceCapabilities::from_device(device);
match caps.fp64_strategy() {
Fp64Strategy::Sovereign | Fp64Strategy::Native | Fp64Strategy::Concurrent => {
(SHADER_NATIVE, false)
}
Fp64Strategy::Hybrid => (SHADER_DF64, true),
}
}
pub struct ProdReduceF64;
impl ProdReduceF64 {
pub fn prod(device: Arc<WgpuDevice>, data: &[f64]) -> Result<f64> {
Self::reduce_op(device, data, "prod_reduce_f64")
}
pub fn log_prod(device: Arc<WgpuDevice>, data: &[f64]) -> Result<f64> {
let log_sum = Self::reduce_op(device, data, "log_prod_reduce_f64")?;
Ok(log_sum.exp())
}
fn reduce_op(device: Arc<WgpuDevice>, data: &[f64], entry_point: &str) -> Result<f64> {
if data.is_empty() {
return Ok(1.0);
}
if data.len() == 1 {
return Ok(data[0]);
}
let n = data.len();
let wg_size = WORKGROUP_SIZE_1D as usize;
let n_workgroups = n.div_ceil(wg_size);
let input_bytes: &[u8] = bytemuck::cast_slice(data);
let input_buffer = device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("ProdReduce input"),
contents: input_bytes,
usage: wgpu::BufferUsages::STORAGE,
});
let partial_buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("ProdReduce partials"),
size: (n_workgroups * 8) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let params = ReduceParams {
size: n as u32,
_pad1: 0,
_pad2: 0,
_pad3: 0,
};
let params_buffer = device.create_uniform_buffer("ProdReduce params", ¶ms);
let (shader_src, use_df64) = shader_config_for_device(&device);
let mut pass1 = ComputeDispatch::new(&device, "prod_reduce_pass1")
.shader(shader_src, entry_point)
.storage_read(0, &input_buffer)
.storage_rw(1, &partial_buffer)
.uniform(2, ¶ms_buffer)
.dispatch(n_workgroups as u32, 1, 1);
pass1 = if use_df64 { pass1.df64() } else { pass1.f64() };
pass1.submit()?;
if n_workgroups <= 1 {
return Self::read_f64_scalar(&device, &partial_buffer);
}
let final_buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("ProdReduce final"),
size: 8 * n_workgroups.div_ceil(wg_size) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let params2 = ReduceParams {
size: n_workgroups as u32,
_pad1: 0,
_pad2: 0,
_pad3: 0,
};
let params2_buffer = device.create_uniform_buffer("ProdReduce params 2", ¶ms2);
let n_workgroups2 = n_workgroups.div_ceil(wg_size);
let mut pass2 = ComputeDispatch::new(&device, "prod_reduce_pass2")
.shader(shader_src, entry_point)
.storage_read(0, &partial_buffer)
.storage_rw(1, &final_buffer)
.uniform(2, ¶ms2_buffer)
.dispatch(n_workgroups2 as u32, 1, 1);
pass2 = if use_df64 { pass2.df64() } else { pass2.f64() };
pass2.submit()?;
if n_workgroups2 > 1 {
let partials = device.read_f64_buffer(&final_buffer, n_workgroups2)?;
return Ok(partials.iter().product());
}
Self::read_f64_scalar(&device, &final_buffer)
}
fn read_f64_scalar(device: &WgpuDevice, buffer: &wgpu::Buffer) -> Result<f64> {
let values = device.read_f64_buffer(buffer, 1)?;
Ok(values[0])
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_prod_small() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available().await
else {
return;
};
let data: Vec<f64> = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let prod = ProdReduceF64::prod(device, &data).unwrap();
assert!(
(prod - 120.0).abs() < 1e-6,
"Product of 1..5 should be 120, got {prod}"
);
}
#[tokio::test]
async fn test_prod_identity() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available().await
else {
return;
};
let prod = ProdReduceF64::prod(device, &[]).unwrap();
assert!(
(prod - 1.0).abs() < 1e-10,
"Empty product should be 1, got {prod}"
);
}
#[tokio::test]
async fn test_prod_with_zeros() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available().await
else {
return;
};
let data: Vec<f64> = vec![1.0, 2.0, 0.0, 4.0, 5.0];
let prod = ProdReduceF64::prod(device, &data).unwrap();
assert!(
prod.abs() < 1e-10,
"Product with zero should be 0, got {prod}"
);
}
#[tokio::test]
async fn test_prod_large() {
let Some(device) = crate::device::test_pool::get_test_device_if_f64_gpu_available().await
else {
return;
};
let data: Vec<f64> = vec![1.1; 100];
let prod = ProdReduceF64::prod(device, &data).unwrap();
let expected = 1.1_f64.powi(100);
let rel_error = (prod - expected).abs() / expected;
assert!(
rel_error < 1e-6,
"Large product error too high: {rel_error} (expected {expected}, got {prod})"
);
}
}