use super::Std;
use crate::device::compute_pipeline::ComputeDispatch;
use crate::device::{DeviceCapabilities, WorkloadType};
use crate::error::Result;
use crate::tensor::Tensor;
pub(super) fn execute(op: Std) -> Result<Tensor> {
let device = op.input.device();
let shape = op.input.shape();
let input_buffer = op.input.buffer();
match op.dim {
None => {
let size: usize = shape.iter().product();
let caps = DeviceCapabilities::from_device(device);
let optimal_wg_size = caps.optimal_workgroup_size(WorkloadType::Reduction);
let num_workgroups = (size as u32).div_ceil(optimal_wg_size);
let mean_output_buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Std Mean Output"),
size: (num_workgroups as usize * std::mem::size_of::<f32>()) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct Params {
size: u32,
}
let params = Params { size: size as u32 };
let params_buffer = device.create_uniform_buffer("Std Mean Params", ¶ms);
ComputeDispatch::new(device, "std_mean")
.shader(Std::wgsl_shader_reduce(), "main")
.storage_read(0, input_buffer)
.storage_rw(1, &mean_output_buffer)
.uniform(2, ¶ms_buffer)
.dispatch(num_workgroups, 1, 1)
.submit()?;
let partial_sums =
device.read_buffer_f32(&mean_output_buffer, num_workgroups as usize)?;
let global_sum: f32 = partial_sums.iter().sum();
let global_mean = global_sum / size as f32;
let diff_squared_buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Std Diff Squared"),
size: (size * std::mem::size_of::<f32>()) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let input_data = device.read_buffer_f32(input_buffer, size)?;
let diff_squared: Vec<f32> = input_data
.iter()
.map(|&x| {
let diff = x - global_mean;
diff * diff
})
.collect();
device
.queue
.write_buffer(&diff_squared_buffer, 0, bytemuck::cast_slice(&diff_squared));
let variance_output_buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Std Output"),
size: (num_workgroups as usize * std::mem::size_of::<f32>()) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
ComputeDispatch::new(device, "std_variance")
.shader(Std::wgsl_shader_reduce(), "main")
.storage_read(0, &diff_squared_buffer)
.storage_rw(1, &variance_output_buffer)
.uniform(2, ¶ms_buffer)
.dispatch(num_workgroups, 1, 1)
.submit()?;
let partial_variances =
device.read_buffer_f32(&variance_output_buffer, num_workgroups as usize)?;
let global_variance_sum: f32 = partial_variances.iter().sum();
let global_variance = global_variance_sum / size as f32;
let global_std = global_variance.sqrt();
Ok(Tensor::new(vec![global_std], vec![], device.clone()))
}
Some(dim) => {
if dim >= shape.len() {
return Err(crate::error::BarracudaError::InvalidInput {
message: format!("Dimension {dim} out of range for shape {shape:?}"),
});
}
let dim_size = shape[dim];
let outer_size: usize = shape[..dim].iter().product();
let inner_size: usize = shape[dim + 1..].iter().product();
let output_size = outer_size * inner_size;
let output_buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Std Dim Output"),
size: (output_size * std::mem::size_of::<f32>()) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct Params {
dim_size: u32,
outer_size: u32,
inner_size: u32,
}
let params = Params {
dim_size: dim_size as u32,
outer_size: outer_size as u32,
inner_size: inner_size as u32,
};
let params_buffer = device.create_uniform_buffer("Std Dim Params", ¶ms);
let caps = DeviceCapabilities::from_device(device);
let optimal_wg_size = caps.optimal_workgroup_size(WorkloadType::Reduction);
let workgroups = (output_size as u32).div_ceil(optimal_wg_size);
ComputeDispatch::new(device, "std_dim")
.shader(Std::wgsl_shader_dim(), "main")
.storage_read(0, input_buffer)
.storage_rw(1, &output_buffer)
.uniform(2, ¶ms_buffer)
.dispatch(workgroups.max(1), 1, 1)
.submit()?;
let output_data = device.read_buffer_f32(&output_buffer, output_size)?;
let mut output_shape = shape.to_vec();
if op.keepdim {
output_shape[dim] = 1;
} else {
output_shape.remove(dim);
}
Ok(Tensor::new(output_data, output_shape, device.clone()))
}
}
}