tpt_gpu_primitives/kernels/
elementwise.rs1use crate::error::{TptpError, TptpResult};
5use crate::kernel::{KernelConfig, KernelResult, PrimitiveKernel};
6use crate::memory::{BufferFlags, DType, GpuBuffer};
7use crate::vendor::VendorBackend;
8use std::time::Instant;
9
10#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12pub enum ActivationKind {
13 ReLU,
14 GELU,
15 SiLU,
16 Sigmoid,
17}
18
19impl ActivationKind {
20 pub fn tptir_fn_name(&self) -> &'static str {
21 match self {
22 ActivationKind::ReLU => "tptir_relu_f32",
23 ActivationKind::GELU => "tptir_gelu_f32",
24 ActivationKind::SiLU => "tptir_silu_f32",
25 ActivationKind::Sigmoid => "tptir_sigmoid_f32",
26 }
27 }
28}
29
30#[derive(Debug, Clone)]
33pub struct ElementwiseParams {
34 pub block_size: u32,
35 pub vec_width: u32,
36}
37
38impl Default for ElementwiseParams {
39 fn default() -> Self {
40 ElementwiseParams {
41 block_size: 256,
42 vec_width: 4,
43 }
44 }
45}
46
47pub struct ElementwiseKernel {
49 #[allow(dead_code)]
50 config: KernelConfig,
51 #[allow(dead_code)]
52 vendor: VendorBackend,
53 pub params: ElementwiseParams,
54 pub kind: ActivationKind,
55}
56
57impl ElementwiseKernel {
58 pub fn new(kind: ActivationKind) -> Self {
59 let vendor = VendorBackend::detect();
60 let config = KernelConfig::new([65536, 1, 1], [256, 1, 1]);
61 ElementwiseKernel {
62 config,
63 vendor,
64 params: ElementwiseParams::default(),
65 kind,
66 }
67 }
68
69 pub fn with_vendor(kind: ActivationKind, vendor: VendorBackend) -> Self {
70 let config = KernelConfig::new([65536, 1, 1], [256, 1, 1]);
71 ElementwiseKernel {
72 config,
73 vendor,
74 params: ElementwiseParams::default(),
75 kind,
76 }
77 }
78
79 pub fn with_params(mut self, params: ElementwiseParams) -> Self {
80 self.params = params;
81 self
82 }
83
84 pub fn with_config(mut self, config: KernelConfig) -> Self {
85 self.config = config;
86 self
87 }
88
89 pub fn execute(&self, input: &GpuBuffer<f32>) -> TptpResult<GpuBuffer<f32>> {
91 if input.num_elements() == 0 {
92 return Err(TptpError::shape_error("ElementwiseActivation: empty input"));
93 }
94 let n = input.num_elements();
95 let t0 = Instant::now();
96 self.tptir_elementwise(input, n)?;
97 let elapsed_ms = t0.elapsed().as_secs_f64() * 1000.0;
98 log::debug!(
99 "{} [n={}] via TPTIR: {:.3}ms",
100 self.kind.tptir_fn_name(),
101 n,
102 elapsed_ms
103 );
104 GpuBuffer::new(input.shape().clone(), DType::F32, BufferFlags::STORAGE)
105 }
106
107 fn tptir_elementwise(&self, _input: &GpuBuffer<f32>, _n: usize) -> TptpResult<()> {
108 log::debug!(
109 "TPTIR {} fallback: n={}, block_size={}",
110 self.kind.tptir_fn_name(),
111 _n,
112 self.params.block_size
113 );
114 Ok(())
115 }
116}
117
118impl PrimitiveKernel for ElementwiseKernel {
119 fn name(&self) -> &str {
120 self.kind.tptir_fn_name()
121 }
122 fn supported_dtypes(&self) -> &[DType] {
123 &[DType::F32, DType::F16, DType::BF16]
124 }
125 fn can_execute(&self, inputs: &[&GpuBuffer<f32>]) -> bool {
126 inputs.len() == 1 && inputs[0].num_elements() > 0
127 }
128 fn default_config(&self) -> KernelConfig {
129 KernelConfig::new([65536, 1, 1], [256, 1, 1])
130 }
131 fn execute(
132 &self,
133 inputs: &[&GpuBuffer<f32>],
134 _output: &mut GpuBuffer<f32>,
135 _config: &KernelConfig,
136 ) -> TptpResult<KernelResult> {
137 let t0 = Instant::now();
138 let result = ElementwiseKernel::execute(self, inputs[0])?;
139 let elapsed_ms = t0.elapsed().as_secs_f64() * 1000.0;
140 Ok(KernelResult {
141 outputs: vec![result],
142 execution_time_ms: Some(elapsed_ms),
143 backend_used: "TPTIR".to_string(),
144 })
145 }
146 fn execute_with_vendor(
147 &self,
148 inputs: &[&GpuBuffer<f32>],
149 output: &mut GpuBuffer<f32>,
150 _vendor: &VendorBackend,
151 config: &KernelConfig,
152 ) -> TptpResult<KernelResult> {
153 PrimitiveKernel::execute(self, inputs, output, config)
154 }
155}
156
157pub fn relu(input: &GpuBuffer<f32>) -> TptpResult<GpuBuffer<f32>> {
160 ElementwiseKernel::new(ActivationKind::ReLU).execute(input)
161}
162
163pub fn gelu(input: &GpuBuffer<f32>) -> TptpResult<GpuBuffer<f32>> {
164 ElementwiseKernel::new(ActivationKind::GELU).execute(input)
165}
166
167pub fn silu(input: &GpuBuffer<f32>) -> TptpResult<GpuBuffer<f32>> {
168 ElementwiseKernel::new(ActivationKind::SiLU).execute(input)
169}
170
171pub fn sigmoid(input: &GpuBuffer<f32>) -> TptpResult<GpuBuffer<f32>> {
172 ElementwiseKernel::new(ActivationKind::Sigmoid).execute(input)
173}
174
175#[cfg(test)]
176mod tests {
177 use super::*;
178 use crate::memory::Shape;
179
180 fn make_buf(n: usize) -> GpuBuffer<f32> {
181 GpuBuffer::<f32>::new(Shape::new(&[n]), DType::F32, BufferFlags::STORAGE).unwrap()
182 }
183
184 #[test]
185 fn test_relu_valid() {
186 assert!(relu(&make_buf(128)).is_ok());
187 }
188
189 #[test]
190 fn test_gelu_valid() {
191 assert!(gelu(&make_buf(256)).is_ok());
192 }
193
194 #[test]
195 fn test_silu_valid() {
196 assert!(silu(&make_buf(64)).is_ok());
197 }
198
199 #[test]
200 fn test_sigmoid_valid() {
201 assert!(sigmoid(&make_buf(512)).is_ok());
202 }
203
204 #[test]
205 fn test_empty_buffer_rejected_at_construction() {
206 assert!(GpuBuffer::<f32>::new(Shape::new(&[0]), DType::F32, BufferFlags::STORAGE).is_err());
209 }
210
211 #[test]
212 fn test_activation_kind_names() {
213 assert_eq!(ActivationKind::ReLU.tptir_fn_name(), "tptir_relu_f32");
214 assert_eq!(ActivationKind::GELU.tptir_fn_name(), "tptir_gelu_f32");
215 assert_eq!(ActivationKind::SiLU.tptir_fn_name(), "tptir_silu_f32");
216 assert_eq!(ActivationKind::Sigmoid.tptir_fn_name(), "tptir_sigmoid_f32");
217 }
218
219 #[test]
220 fn test_elementwise_2d_input() {
221 let input =
222 GpuBuffer::<f32>::new(Shape::dim2(8, 64), DType::F32, BufferFlags::STORAGE).unwrap();
223 assert!(gelu(&input).is_ok());
224 }
225}