use crate::device::DeviceCapabilities;
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::{BarracudaError, Result};
use crate::tensor::Tensor;
const SHADER_F64: &str = include_str!("../shaders/math/slice_assign_f64.wgsl");
static SHADER_F32: std::sync::LazyLock<String> =
std::sync::LazyLock::new(|| SHADER_F64.to_string());
#[derive(Debug, Clone)]
pub struct SliceRange {
pub start: usize,
pub end: usize,
pub stride: usize,
}
pub struct SliceAssign {
input: Tensor,
slice_range: SliceRange,
values: Tensor,
}
impl SliceAssign {
pub fn new(input: Tensor, slice_range: SliceRange, values: Tensor) -> Result<Self> {
let input_shape = input.shape();
let input_size = input_shape.iter().product::<usize>();
let values_size = values.shape().iter().product::<usize>();
if slice_range.start >= slice_range.end {
return Err(BarracudaError::invalid_op(
"SliceAssign",
format!(
"Start {} must be less than end {}",
slice_range.start, slice_range.end
),
));
}
if slice_range.end > input_size {
return Err(BarracudaError::invalid_op(
"SliceAssign",
format!("End {} exceeds input size {}", slice_range.end, input_size),
));
}
if slice_range.stride == 0 {
return Err(BarracudaError::invalid_op(
"SliceAssign",
"Stride must be greater than zero",
));
}
let slice_size = (slice_range.end - slice_range.start).div_ceil(slice_range.stride);
if values_size != slice_size {
return Err(BarracudaError::invalid_op(
"SliceAssign",
format!("Values size {values_size} doesn't match slice size {slice_size}"),
));
}
Ok(Self {
input,
slice_range,
values,
})
}
fn wgsl_shader() -> &'static str {
&SHADER_F32
}
pub fn execute(self) -> Result<Tensor> {
let device = self.input.device();
let input_size: usize = self.input.shape().iter().product();
let values_size = self.values.shape().iter().product::<usize>();
let input_buffer = self.input.buffer();
let values_buffer = self.values.buffer();
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct Params {
input_size: u32,
start: u32,
end: u32,
stride: u32,
values_size: u32,
}
let params = Params {
input_size: input_size as u32,
start: self.slice_range.start as u32,
end: self.slice_range.end as u32,
stride: self.slice_range.stride as u32,
values_size: values_size as u32,
};
let params_buffer = device
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("SliceAssign Params"),
contents: bytemuck::cast_slice(&[params]),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let caps = DeviceCapabilities::from_device(device.as_ref());
let workgroups = caps.dispatch_1d(values_size as u32);
ComputeDispatch::new(device.as_ref(), "SliceAssign")
.shader(Self::wgsl_shader(), "main")
.uniform(0, ¶ms_buffer)
.storage_read(1, values_buffer)
.storage_rw(2, input_buffer)
.dispatch(workgroups, 1, 1)
.submit()?;
let output_data = crate::utils::read_buffer(device, input_buffer, input_size)?;
Ok(Tensor::new(
output_data,
self.input.shape().to_vec(),
device.clone(),
))
}
}
impl Tensor {
pub fn slice_assign(self, slice_range: SliceRange, values: Self) -> Result<Self> {
SliceAssign::new(self, slice_range, values)?.execute()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_slice_assign_basic() {
let device = crate::device::test_pool::get_test_device().await;
let input = Tensor::new(vec![1.0, 2.0, 3.0, 4.0, 5.0], vec![5], device.clone());
let values = Tensor::new(vec![10.0, 20.0], vec![2], device);
let slice_range = SliceRange {
start: 1,
end: 3,
stride: 1,
};
let result = input.slice_assign(slice_range, values).unwrap();
let output_data = result.to_vec().unwrap();
assert_eq!(output_data[0], 1.0);
assert_eq!(output_data[1], 10.0);
assert_eq!(output_data[2], 20.0);
assert_eq!(output_data[3], 4.0);
assert_eq!(output_data[4], 5.0);
}
#[tokio::test]
async fn test_slice_assign_strided() {
let device = crate::device::test_pool::get_test_device().await;
let input = Tensor::new(vec![1.0, 2.0, 3.0, 4.0, 5.0], vec![5], device.clone());
let values = Tensor::new(vec![10.0, 20.0, 30.0], vec![3], device);
let slice_range = SliceRange {
start: 0,
end: 5,
stride: 2,
};
let result = input.slice_assign(slice_range, values).unwrap();
let output_data = result.to_vec().unwrap();
assert_eq!(output_data[0], 10.0);
assert_eq!(output_data[1], 2.0);
assert_eq!(output_data[2], 20.0);
assert_eq!(output_data[3], 4.0);
assert_eq!(output_data[4], 30.0);
}
}