hodu_cpu_kernels 0.2.4

hodu cpu kernels
Documentation 
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275

/**
 * @file ops_conv.h
 * @brief Convolution operations header
 *
 * Provides convolution operations for neural networks including:
 * - Standard convolutions (1D, 2D, 3D)
 * - Transposed convolutions (deconvolutions)
 * - Gradient weight computations for backpropagation
 *
 * All operations support:
 * - Padding: Zero-padding around input borders
 * - Stride: Step size for kernel movement
 * - Dilation: Spacing between kernel elements
 */

#ifndef OPS_CONV_H
#define OPS_CONV_H

#include <stddef.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

// ============================================================================
// CONVOLUTION OPERATIONS
// ============================================================================
//
// All convolution operations follow consistent signatures:
//   void convND_type(const void *input, const void *weight, void *output, const size_t *metadata)
//
// Parameters:
//   input    - Pointer to input tensor data
//   weight   - Pointer to convolution kernel/weight tensor
//   output   - Pointer to output buffer (pre-allocated)
//   metadata - Array describing convolution parameters (see layouts below)
//
// Metadata layout for conv1d / conv_transpose1d:
// - metadata[0]: num_els (total number of output elements)
// - metadata[1]: in_channels
// - metadata[2]: out_channels
// - metadata[3]: in_width
// - metadata[4]: kernel_width
// - metadata[5]: out_width
// - metadata[6]: stride
// - metadata[7]: padding
// - metadata[8]: dilation
// - metadata[9]: input_offset
// - metadata[10]: weight_offset
//
// Metadata layout for conv2d / conv_transpose2d:
// - metadata[0]: num_els (total number of output elements)
// - metadata[1]: in_channels
// - metadata[2]: out_channels
// - metadata[3]: in_height
// - metadata[4]: in_width
// - metadata[5]: kernel_height
// - metadata[6]: kernel_width
// - metadata[7]: out_height
// - metadata[8]: out_width
// - metadata[9]: stride_h
// - metadata[10]: stride_w
// - metadata[11]: padding_h
// - metadata[12]: padding_w
// - metadata[13]: dilation_h
// - metadata[14]: dilation_w
// - metadata[15]: input_offset
// - metadata[16]: weight_offset
//
// Metadata layout for conv3d / conv_transpose3d:
// - metadata[0]: num_els (total number of output elements)
// - metadata[1]: in_channels
// - metadata[2]: out_channels
// - metadata[3]: in_depth
// - metadata[4]: in_height
// - metadata[5]: in_width
// - metadata[6]: kernel_depth
// - metadata[7]: kernel_height
// - metadata[8]: kernel_width
// - metadata[9]: out_depth
// - metadata[10]: out_height
// - metadata[11]: out_width
// - metadata[12]: stride_d
// - metadata[13]: stride_h
// - metadata[14]: stride_w
// - metadata[15]: padding_d
// - metadata[16]: padding_h
// - metadata[17]: padding_w
// - metadata[18]: dilation_d
// - metadata[19]: dilation_h
// - metadata[20]: dilation_w
// - metadata[21]: input_offset
// - metadata[22]: weight_offset

// 1D Convolution operations

void conv1d_f8e4m3(const void *input, const void *weight, void *output, const size_t *metadata);
void conv1d_f8e5m2(const void *input, const void *weight, void *output, const size_t *metadata);
void conv1d_bf16(const void *input, const void *weight, void *output, const size_t *metadata);
void conv1d_f16(const void *input, const void *weight, void *output, const size_t *metadata);
void conv1d_f32(const void *input, const void *weight, void *output, const size_t *metadata);
void conv1d_f64(const void *input, const void *weight, void *output, const size_t *metadata);

// 2D Convolution operations
void conv2d_f8e4m3(const void *input, const void *weight, void *output, const size_t *metadata);
void conv2d_f8e5m2(const void *input, const void *weight, void *output, const size_t *metadata);
void conv2d_bf16(const void *input, const void *weight, void *output, const size_t *metadata);
void conv2d_f16(const void *input, const void *weight, void *output, const size_t *metadata);
void conv2d_f32(const void *input, const void *weight, void *output, const size_t *metadata);
void conv2d_f64(const void *input, const void *weight, void *output, const size_t *metadata);

// 3D Convolution operations
void conv3d_f8e4m3(const void *input, const void *weight, void *output, const size_t *metadata);
void conv3d_f8e5m2(const void *input, const void *weight, void *output, const size_t *metadata);
void conv3d_bf16(const void *input, const void *weight, void *output, const size_t *metadata);
void conv3d_f16(const void *input, const void *weight, void *output, const size_t *metadata);
void conv3d_f32(const void *input, const void *weight, void *output, const size_t *metadata);
void conv3d_f64(const void *input, const void *weight, void *output, const size_t *metadata);

// ============================================================================
// TRANSPOSED CONVOLUTION OPERATIONS
// ============================================================================
//
// Transposed convolutions (deconvolutions) follow same metadata layouts
// as their forward counterparts.

// 1D Transposed Convolution operations
void conv_transpose1d_f8e4m3(const void *input, const void *weight, void *output,
                             const size_t *metadata);
void conv_transpose1d_f8e5m2(const void *input, const void *weight, void *output,
                             const size_t *metadata);
void conv_transpose1d_bf16(const void *input, const void *weight, void *output,
                           const size_t *metadata);
void conv_transpose1d_f16(const void *input, const void *weight, void *output,
                          const size_t *metadata);
void conv_transpose1d_f32(const void *input, const void *weight, void *output,
                          const size_t *metadata);
void conv_transpose1d_f64(const void *input, const void *weight, void *output,
                          const size_t *metadata);

// 2D Transposed Convolution operations
void conv_transpose2d_f8e4m3(const void *input, const void *weight, void *output,
                             const size_t *metadata);
void conv_transpose2d_f8e5m2(const void *input, const void *weight, void *output,
                             const size_t *metadata);
void conv_transpose2d_bf16(const void *input, const void *weight, void *output,
                           const size_t *metadata);
void conv_transpose2d_f16(const void *input, const void *weight, void *output,
                          const size_t *metadata);
void conv_transpose2d_f32(const void *input, const void *weight, void *output,
                          const size_t *metadata);
void conv_transpose2d_f64(const void *input, const void *weight, void *output,
                          const size_t *metadata);

// 3D Transposed Convolution operations
void conv_transpose3d_f8e4m3(const void *input, const void *weight, void *output,
                             const size_t *metadata);
void conv_transpose3d_f8e5m2(const void *input, const void *weight, void *output,
                             const size_t *metadata);
void conv_transpose3d_bf16(const void *input, const void *weight, void *output,
                           const size_t *metadata);
void conv_transpose3d_f16(const void *input, const void *weight, void *output,
                          const size_t *metadata);
void conv_transpose3d_f32(const void *input, const void *weight, void *output,
                          const size_t *metadata);
void conv_transpose3d_f64(const void *input, const void *weight, void *output,
                          const size_t *metadata);

// ============================================================================
// CONVOLUTION GRADIENT WEIGHT OPERATIONS
// ============================================================================
//
// Compute gradients with respect to convolution weights for backpropagation.
// Follow same metadata layouts as their forward counterparts.
//
// All gradient operations follow consistent signatures:
//   void convND_grad_weight_type(const void *input, const void *grad_output,
//                                void *grad_weight, const size_t *metadata)
//
// Parameters:
//   input       - Pointer to input tensor from forward pass
//   grad_output - Pointer to gradient tensor from next layer
//   grad_weight - Pointer to output gradient weight buffer
//   metadata    - Array describing convolution parameters (same as forward)

// 1D Convolution gradient weight operations
void conv1d_grad_weight_f8e4m3(const void *input, const void *grad_output, void *grad_weight,
                               const size_t *metadata);
void conv1d_grad_weight_f8e5m2(const void *input, const void *grad_output, void *grad_weight,
                               const size_t *metadata);
void conv1d_grad_weight_bf16(const void *input, const void *grad_output, void *grad_weight,
                             const size_t *metadata);
void conv1d_grad_weight_f16(const void *input, const void *grad_output, void *grad_weight,
                            const size_t *metadata);
void conv1d_grad_weight_f32(const void *input, const void *grad_output, void *grad_weight,
                            const size_t *metadata);
void conv1d_grad_weight_f64(const void *input, const void *grad_output, void *grad_weight,
                            const size_t *metadata);

// 2D Convolution gradient weight operations
void conv2d_grad_weight_f8e4m3(const void *input, const void *grad_output, void *grad_weight,
                               const size_t *metadata);
void conv2d_grad_weight_f8e5m2(const void *input, const void *grad_output, void *grad_weight,
                               const size_t *metadata);
void conv2d_grad_weight_bf16(const void *input, const void *grad_output, void *grad_weight,
                             const size_t *metadata);
void conv2d_grad_weight_f16(const void *input, const void *grad_output, void *grad_weight,
                            const size_t *metadata);
void conv2d_grad_weight_f32(const void *input, const void *grad_output, void *grad_weight,
                            const size_t *metadata);
void conv2d_grad_weight_f64(const void *input, const void *grad_output, void *grad_weight,
                            const size_t *metadata);

// 3D Convolution gradient weight operations
void conv3d_grad_weight_f8e4m3(const void *input, const void *grad_output, void *grad_weight,
                               const size_t *metadata);
void conv3d_grad_weight_f8e5m2(const void *input, const void *grad_output, void *grad_weight,
                               const size_t *metadata);
void conv3d_grad_weight_bf16(const void *input, const void *grad_output, void *grad_weight,
                             const size_t *metadata);
void conv3d_grad_weight_f16(const void *input, const void *grad_output, void *grad_weight,
                            const size_t *metadata);
void conv3d_grad_weight_f32(const void *input, const void *grad_output, void *grad_weight,
                            const size_t *metadata);
void conv3d_grad_weight_f64(const void *input, const void *grad_output, void *grad_weight,
                            const size_t *metadata);

// 1D Transposed Convolution gradient weight operations
void conv_transpose1d_grad_weight_f8e4m3(const void *input, const void *grad_output,
                                         void *grad_weight, const size_t *metadata);
void conv_transpose1d_grad_weight_f8e5m2(const void *input, const void *grad_output,
                                         void *grad_weight, const size_t *metadata);
void conv_transpose1d_grad_weight_bf16(const void *input, const void *grad_output,
                                       void *grad_weight, const size_t *metadata);
void conv_transpose1d_grad_weight_f16(const void *input, const void *grad_output, void *grad_weight,
                                      const size_t *metadata);
void conv_transpose1d_grad_weight_f32(const void *input, const void *grad_output, void *grad_weight,
                                      const size_t *metadata);
void conv_transpose1d_grad_weight_f64(const void *input, const void *grad_output, void *grad_weight,
                                      const size_t *metadata);

// 2D Transposed Convolution gradient weight operations
void conv_transpose2d_grad_weight_f8e4m3(const void *input, const void *grad_output,
                                         void *grad_weight, const size_t *metadata);
void conv_transpose2d_grad_weight_f8e5m2(const void *input, const void *grad_output,
                                         void *grad_weight, const size_t *metadata);
void conv_transpose2d_grad_weight_bf16(const void *input, const void *grad_output,
                                       void *grad_weight, const size_t *metadata);
void conv_transpose2d_grad_weight_f16(const void *input, const void *grad_output, void *grad_weight,
                                      const size_t *metadata);
void conv_transpose2d_grad_weight_f32(const void *input, const void *grad_output, void *grad_weight,
                                      const size_t *metadata);
void conv_transpose2d_grad_weight_f64(const void *input, const void *grad_output, void *grad_weight,
                                      const size_t *metadata);

// 3D Transposed Convolution gradient weight operations
void conv_transpose3d_grad_weight_f8e4m3(const void *input, const void *grad_output,
                                         void *grad_weight, const size_t *metadata);
void conv_transpose3d_grad_weight_f8e5m2(const void *input, const void *grad_output,
                                         void *grad_weight, const size_t *metadata);
void conv_transpose3d_grad_weight_bf16(const void *input, const void *grad_output,
                                       void *grad_weight, const size_t *metadata);
void conv_transpose3d_grad_weight_f16(const void *input, const void *grad_output, void *grad_weight,
                                      const size_t *metadata);
void conv_transpose3d_grad_weight_f32(const void *input, const void *grad_output, void *grad_weight,
                                      const size_t *metadata);
void conv_transpose3d_grad_weight_f64(const void *input, const void *grad_output, void *grad_weight,
                                      const size_t *metadata);

#ifdef __cplusplus
}
#endif

#endif // OPS_CONV_H