1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
// SPDX-License-Identifier: AGPL-3.0-or-later
//! Dequantize operation - Convert quantized integers to floating point
//!
//! Dequantization: Convert low-precision integers back to FP32
//! Used for inference with quantized models
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::{BarracudaError, Result};
use crate::tensor::Tensor;
use bytemuck::{Pod, Zeroable};
#[repr(C)]
#[derive(Copy, Clone, Debug, Pod, Zeroable)]
struct DequantizeParams {
size: u32,
scale: f32,
zero_point: f32,
_padding: u32,
}
/// Dequantize operation
pub struct Dequantize {
input: Tensor,
scale: f32,
zero_point: f32,
}
impl Dequantize {
/// Create dequantize operation
/// Note: input tensor should contain i32 values (quantized integers)
/// This will be converted to f32 output
/// # Errors
/// Returns [`Err`] if scale is not positive.
pub fn new(input: Tensor, scale: f32, zero_point: f32) -> Result<Self> {
if scale <= 0.0 {
return Err(BarracudaError::invalid_op(
"dequantize",
format!("scale must be positive, got {scale}"),
));
}
Ok(Self {
input,
scale,
zero_point,
})
}
/// WGSL shader source (embedded at compile time)
fn wgsl_shader() -> &'static str {
static SHADER: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
include_str!("../shaders/misc/dequantize_f64.wgsl").to_string()
});
&SHADER
}
/// Execute dequantize on tensor
/// # Errors
/// Returns [`Err`] if buffer allocation, GPU dispatch, or buffer
/// readback fails (e.g. device lost or out of memory).
pub fn execute(self) -> Result<Tensor> {
let device = self.input.device();
let size = self.input.len();
// Create output buffer (f32)
let output_buffer = device.create_buffer_f32(size)?;
// Use tensor buffer directly (zero-copy)
// The shader will handle f32->i32 conversion
let input_buffer = self.input.buffer();
// Create params
let params = DequantizeParams {
size: size as u32,
scale: self.scale,
zero_point: self.zero_point,
_padding: 0,
};
let params_buffer = device.create_uniform_buffer("Dequantize Params", ¶ms);
ComputeDispatch::new(device, "Dequantize")
.shader(Self::wgsl_shader(), "main")
.storage_read(0, input_buffer)
.storage_rw(1, &output_buffer)
.uniform(2, ¶ms_buffer)
.dispatch_1d(size as u32)
.submit()?;
// Create output tensor
Ok(Tensor::from_buffer(
output_buffer,
self.input.shape().to_vec(),
device.clone(),
))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_dequantize_basic() {
let device = crate::device::test_pool::get_test_device().await;
// Simulate quantized values (as f32, will be cast to i32)
let input = Tensor::from_vec_on(vec![100.0, 150.0, 200.0, 250.0], vec![4], device)
.await
.unwrap();
let output = Dequantize::new(input, 0.1, 128.0)
.unwrap()
.execute()
.unwrap();
let result = output.to_vec().unwrap();
assert_eq!(result.len(), 4);
// Dequantized: (quantized - zero_point) * scale
// (100 - 128) * 0.1 = -2.8
assert!((result[0] - (-2.8)).abs() < 0.1);
}
}