pulsatrix 1.1.0
Loading...
Searching...
No Matches
hip_backend.hpp
Go to the documentation of this file.
1
5#pragma once
6
7#include <memory>
8#include <hip/hip_runtime.h>
9#include <hipblas/hipblas.h>
10
13
14namespace pulsatrix {
15
36class HIPBackend : public DeviceBackend {
37public:
39 ~HIPBackend() override;
40
41 HIPBackend(const HIPBackend&) = delete;
42 HIPBackend& operator=(const HIPBackend&) = delete;
43
44 [[nodiscard]] DeviceType device() const noexcept override { return DeviceType::Hip; }
45
48 [[nodiscard]] void* allocate(size_t bytes) override;
50 void free(void* ptr) noexcept override;
51
54 [[nodiscard]] CachingAllocator::Stats memory_stats() const { return allocator_->stats(); }
56 void empty_cache() { allocator_->empty_cache(); }
62 void set_memory_budget(size_t bytes) { allocator_->set_budget(bytes); }
63
71 [[nodiscard]] bool sync_debug() const { return sync_debug_; }
72 void copy(void* dst, const void* src, size_t bytes, CopyDirection dir) override;
73 void fill(void* ptr, float value, size_t n) override;
74 void gemm(const float* a, const float* b, float* out, size_t m, size_t k, size_t n) override;
75 void elementwise(ElementwiseOp op, const float* in, float* out, size_t n) override;
76 void add(const float* a, const float* b, float* out, size_t n) override;
77 void mul(const float* a, const float* b, float* out, size_t n) override;
78 void gemm_ex(const float* a, bool transpose_a, const float* b, bool transpose_b, float* out, size_t m, size_t k,
79 size_t n, float beta) override;
80 void column_sums(const float* in, float* out, size_t rows, size_t cols, float beta) override;
81 void add_row_vector(const float* in, const float* row, float* out, size_t rows, size_t cols) override;
82 void add_row_vector_relu(const float* in, const float* row, float* z, float* out, size_t rows,
83 size_t cols) override;
84 void elementwise_backward(ElementwiseOp op, const float* x, const float* grad_out, float* grad_in,
85 size_t n) override;
86 void axpby(float alpha, const float* x, float beta, const float* y, float* out, size_t n) override;
87 [[nodiscard]] float dot(const float* a, const float* b, size_t n) override;
88 void gemm_strided_batched(const float* a, bool transpose_a, size_t stride_a, const float* b, bool transpose_b,
89 size_t stride_b, float* out, size_t stride_out, size_t m, size_t k, size_t n, size_t batch,
90 float beta = 0.0f) override;
91 void accumulate_parts(const float* parts, size_t count, size_t n, float* acc) override;
93 void dot_into(const float* a, const float* b, size_t n, float* out) override;
95 void adam_step_multi(const AdamTensorStep* tensors, size_t count, float beta1, float beta2, float eps) override;
96 void softmax_rows(const float* in, float* out, size_t rows, size_t cols) override;
97 void softmax_rows_backward(const float* y, const float* dy, float* dx, size_t rows, size_t cols) override;
98 void logsumexp_rows(const float* in, float* out, size_t rows, size_t cols) override;
99 void adam_step(float* param, const float* grad, float* m, float* v, size_t n, float lr, float beta1, float beta2,
100 float eps, float bias_correction1, float bias_correction2) override;
101 [[nodiscard]] float sum(const float* in, size_t n) override;
102 void dropout_forward(const float* in, float* out, float* mask, size_t n, float p, float scale, uint64_t seed,
103 uint64_t offset) override;
104 void bce_with_logits(const float* logits, const float* target, float* out, size_t n) override;
105 void bce_with_logits_grad(const float* logits, const float* target, float* grad, size_t n, float scale) override;
106 void layer_norm_forward(const float* in, const float* gamma, const float* beta, float* xhat, float* out,
107 float* row_std, size_t rows, size_t cols, float eps) override;
108 void layer_norm_backward(const float* grad_out, const float* gamma, const float* xhat, const float* row_std,
109 float* grad_in, size_t rows, size_t cols) override;
110 void rms_norm_forward(const float* in, const float* gamma, float* out, float* row_rms, size_t rows, size_t cols,
111 float eps) override;
112 void rms_norm_backward(const float* grad_out, const float* gamma, const float* in, const float* row_rms,
113 float* grad_in, float* gamma_terms, size_t rows, size_t cols) override;
114 void rope_rotate(const float* in, const float* cos_table, const float* sin_table, float* out, size_t num_slices,
115 size_t seq_len, size_t head_dim, bool inverse, bool rotate_half) override;
116 void permute_0213(const float* in, float* out, size_t d0, size_t d1, size_t d2, size_t d3) override;
117 void attention_mask_fill(float* scores, const float* key_keep, size_t batch, size_t heads, size_t q_len,
118 size_t k_len, bool causal, size_t q_offset, size_t window, float value) override;
119 void gather_rows(const float* table, const float* indices, float* out, size_t count, size_t dim) override;
120 void scatter_add_rows(const float* src, const float* indices, float* table, size_t count, size_t dim) override;
121 void tanh_gaussian_forward(const float* mean, const float* log_std, const float* eps, float* action,
122 float* std_cache, float* log_prob, size_t rows, size_t cols, float stabilizer,
123 double half_log_two_pi) override;
124 void tanh_gaussian_backward(const float* action, const float* std_cache, const float* eps,
125 const float* grad_action, const float* grad_log_prob, float* grad_mean,
126 float* grad_log_std, size_t n, float stabilizer) override;
127 void lrp_linear(const float* x, const float* w, const float* z, const float* r, float* r_in, size_t rows,
128 size_t in_features, size_t out_features, float eps) override;
129 void lrp_residual_split(const float* a, const float* b, const float* r, float* r_a, float* r_b, size_t n,
130 float eps) override;
131 void lrp_bilinear_elementwise(const float* a, const float* b, const float* r, float* r_out, size_t n,
132 float eps) override;
133 void lrp_bilinear_matmul(const float* a, const float* b, const float* o, const float* r_o, float* r_a, float* r_b,
134 size_t slices, size_t m, size_t p, size_t q, float eps, bool b_transposed) override;
135 void lrp_softmax_rows(const float* x, const float* y, const float* r, float* r_in, size_t rows,
136 size_t cols) override;
137 void lrp_rope(const float* x, const float* y, const float* r, const float* cos_table, const float* sin_table,
138 float* r_in, size_t slices, size_t seq_len, size_t head_dim, float eps, bool rotate_half) override;
139 void logic_pointwise(LogicOp op, int norm, const float* a, const float* b, const float* g_or_r, const float* y,
140 float* out_a, float* out_b, size_t n, float eps) override;
141 void aggregator_forward(const float* x, float* mean_pow, float* out, size_t n, size_t cols, float p) override;
142 void aggregator_backward(const float* x, const float* mean_pow, const float* grad_out, float* grad_in, size_t n,
143 size_t cols, float p) override;
144 void aggregator_lrp(const float* x, const float* mean_pow, const float* r_out, float* r_in, size_t n, size_t cols,
145 float p, float eps) override;
146 void im2col(const float* in, float* col, size_t n, size_t c, size_t h, size_t w,
147 const ConvGeometry& geometry) override;
148 void col2im_add(const float* col, float* out, size_t n, size_t c, size_t h, size_t w,
149 const ConvGeometry& geometry) override;
150 void add_channel_vector(const float* in, const float* vec, float* out, size_t n, size_t c, size_t inner) override;
151 void lrp_conv(const float* col, const float* kernel, const float* pre_bias, const float* r, float* r_col, size_t n,
152 size_t out_channels, size_t p, size_t q, float eps) override;
153 void lrp_stabilized_divide(const float* r, const float* denom, const float* gate, float* out, size_t n, float eps,
154 LrpGate gate_mode) override;
155 void max_pool_forward(const float* in, float* out, float* argmax, size_t planes, size_t h, size_t w, size_t kh,
156 size_t kw, size_t sh, size_t sw, size_t ph, size_t pw) override;
157 void max_unpool(const float* src, const float* argmax, float* dst, size_t planes, size_t h, size_t w, size_t kh,
158 size_t kw, size_t sh, size_t sw, size_t ph, size_t pw) override;
159 void avg_pool_forward(const float* in, float* out, size_t planes, size_t h, size_t w, size_t kh, size_t kw)
160 override;
161 void avg_pool_backward(const float* grad_out, float* grad_in, size_t planes, size_t h, size_t w, size_t kh, size_t
162 kw) override;
163 void lrp_avg_pool(const float* x, const float* r, float* r_in, size_t planes, size_t h, size_t w, size_t kh, size_t
164 kw, float eps) override;
165 void batch_norm_forward(const float* in, const float* gamma, const float* beta, float* xhat, float* out, float*
166 channel_std, size_t n, size_t c, size_t spatial, float eps) override;
167 void batch_norm_backward(const float* grad_out, const float* gamma, const float* xhat, const float* channel_std,
168 float* grad_in, float* gamma_grad, float* beta_grad, size_t n, size_t c, size_t spatial)
169 override;
170 void batch_norm_update_running(const float* in, float* running_mean, float* running_var, size_t n, size_t c,
171 size_t spatial, float momentum) override;
172 void batch_norm_eval_forward(const float* in, const float* gamma, const float* beta, const float* running_mean,
173 const float* running_var, float* xhat, float* out, float* channel_std, size_t n,
174 size_t c, size_t spatial, float eps) override;
175 void batch_norm_eval_backward(const float* grad_out, const float* gamma, const float* xhat,
176 const float* channel_std, float* grad_in, float* gamma_grad, float* beta_grad,
177 size_t n, size_t c, size_t spatial) override;
178 void group_norm_forward(const float* in, const float* gamma, const float* beta, float* xhat, float* out, float*
179 group_std, size_t n, size_t c, size_t spatial, size_t num_groups, float eps) override;
180 void group_norm_backward(const float* grad_out, const float* gamma, const float* xhat, const float* group_std,
181 float* grad_in, float* gamma_grad, float* beta_grad, size_t n, size_t c, size_t spatial,
182 size_t num_groups) override;
183 void copy_2d(float* dst, size_t dst_stride, const float* src, size_t src_stride, size_t rows,
184 size_t cols) override;
185 void accumulate_rows(const float* in, float* out, size_t rows, size_t cols) override;
186 void recurrent_cell(RecurrentCellOp op, const RecurrentCellArgs& args, size_t n) override;
187 void gru_lrp_hprev(const float* h_prev, const float* w_hn, const float* hn, const float* r_term_b,
188 const float* direct, float* r_hprev, size_t rows, size_t hidden, float eps) override;
189 void ssm_pass(SsmPassOp op, const SsmPassArgs& args) override;
190 void rl_rows(RlRowOp op, const RlRowArgs& args) override;
191 void top_k_rows(const float* in, float* values, float* indices, size_t rows, size_t cols, size_t k,
192 bool largest) override;
193
194private:
195 hipStream_t stream_;
196 std::unique_ptr<CachingAllocator> allocator_;
197 bool sync_debug_ = false;
198 void debug_sync();
199 hipblasHandle_t hipblas_handle_;
200 // One device float that dot() reduces into before copying it to the host; allocated once
201 // so dot() costs no per-call device allocation.
202 float* dot_result_ = nullptr; // dot/sum scratch: result at [0], per-block partials after it (HIP-5)
203 // Device scratch for per-channel reductions (HIP-2), grown on demand by reduce_scratch().
204 float* reduce_scratch_ = nullptr;
205 size_t reduce_scratch_floats_ = 0;
206 float* reduce_scratch(size_t floats);
207};
208
209} // namespace pulsatrix
A caching device-memory allocator (roadmap HIP-3): freed blocks are kept and reused for later request...
Vendor-agnostic compute/memory backend. CPUBackend, CUDABackend (Phase 1.5), and HIPBackend (Phase 1....
Definition device_backend.hpp:248
HIP-resident DeviceBackend implementation, targeting AMD GPUs via ROCm.
Definition hip_backend.hpp:36
void empty_cache()
Returns all cached (unused) blocks to the driver, after synchronizing.
Definition hip_backend.hpp:56
void aggregator_lrp(const float *x, const float *mean_pow, const float *r_out, float *r_in, size_t n, size_t cols, float p, float eps) override
AggregatorModule epsilon rule, per column.
void rope_rotate(const float *in, const float *cos_table, const float *sin_table, float *out, size_t num_slices, size_t seq_len, size_t head_dim, bool inverse, bool rotate_half) override
Rotary position embedding over (num_slices, seq_len, head_dim) data.
void batch_norm_eval_backward(const float *grad_out, const float *gamma, const float *xhat, const float *channel_std, float *grad_in, float *gamma_grad, float *beta_grad, size_t n, size_t c, size_t spatial) override
Eval-mode BatchNorm gradient: grad_out * gamma / std, plus gamma/beta gradients (overwritten,...
float sum(const float *in, size_t n) override
sum_i in[i], returned to the host. Same reduction order as dot(). Synchronizes.
void elementwise_backward(ElementwiseOp op, const float *x, const float *grad_out, float *grad_in, size_t n) override
Activation backward: grad_in[i] = grad_out[i] * f'(x[i]), f = op, x = the forward input.
void lrp_residual_split(const float *a, const float *b, const float *r, float *r_a, float *r_b, size_t n, float eps) override
Epsilon split of a residual sum y = a + b: r_a = (a / stab(y)) r, r_b = (b / stab(y)) r.
void batch_norm_forward(const float *in, const float *gamma, const float *beta, float *xhat, float *out, float *channel_std, size_t n, size_t c, size_t spatial, float eps) override
BatchNorm over (n, spatial) per channel of (n, c, spatial) data.
void add_row_vector_relu(const float *in, const float *row, float *z, float *out, size_t rows, size_t cols) override
add_row_vector() into z, then ReLU of z into out: a Linear layer's bias and the ReLU after it (HIP-6)...
void bce_with_logits_grad(const float *logits, const float *target, float *grad, size_t n, float scale) override
BCE-with-logits gradient: grad[i] = (sigmoid(x) - y) * scale, using the overflow-free sigmoid (exp(x)...
void rl_rows(RlRowOp op, const RlRowArgs &args) override
One fused RL loss / target / Polyak pass (see RlRowOp for lanes and slots).
void softmax_rows_backward(const float *y, const float *dy, float *dx, size_t rows, size_t cols) override
Softmax backward from its output y: dx[i][j] = y[i][j] * (dy[i][j] - sum_k y[i][k]*dy[i][k]).
void accumulate_rows(const float *in, float *out, size_t rows, size_t cols) override
out[j] += in[i][j] for i = 0..rows-1 in order, accumulating straight into out.
void batch_norm_update_running(const float *in, float *running_mean, float *running_var, size_t n, size_t c, size_t spatial, float momentum) override
Folds this batch's per-channel mean and unbiased variance into the running ones (PyTorch's momentum r...
void lrp_linear(const float *x, const float *w, const float *z, const float *r, float *r_in, size_t rows, size_t in_features, size_t out_features, float eps) override
LinearModule epsilon rule: r_in[n][i] = sum_j (x[n][i] w[i][j] / stab(z[n][j])) r[n][j].
void top_k_rows(const float *in, float *values, float *indices, size_t rows, size_t cols, size_t k, bool largest) override
Per row of a row-major (rows, cols) matrix: the k largest (or smallest) values in rank order into val...
void copy_2d(float *dst, size_t dst_stride, const float *src, size_t src_stride, size_t rows, size_t cols) override
Strided 2-D copy: rows of cols floats from src (row stride src_stride) to dst (row stride dst_stride)...
void add(const float *a, const float *b, float *out, size_t n) override
Elementwise binary addition: out[i] = a[i] + b[i] for i in [0, n).
HIPBackend(const HIPBackend &)=delete
void add_row_vector(const float *in, const float *row, float *out, size_t rows, size_t cols) override
Broadcast row add: out[i][j] = in[i][j] + row[j] for a (rows x cols) matrix.
void dropout_forward(const float *in, float *out, float *mask, size_t n, float p, float scale, uint64_t seed, uint64_t offset) override
Inverted dropout with a counter-based RNG: element i is dropped iff uniform(seed, offset + i) < p; ke...
void gather_rows(const float *table, const float *indices, float *out, size_t count, size_t dim) override
out[i][:] = table[indices[i]][:] for count rows of width dim.
void softmax_rows(const float *in, float *out, size_t rows, size_t cols) override
Row-wise softmax of a (rows x cols) matrix, max-subtracted. out may alias in.
void tanh_gaussian_forward(const float *mean, const float *log_std, const float *eps, float *action, float *std_cache, float *log_prob, size_t rows, size_t cols, float stabilizer, double half_log_two_pi) override
TanhGaussianPolicy sampling per (rows, cols) row: action = tanh(mean + exp(log_std)*eps),...
void copy(void *dst, const void *src, size_t bytes, CopyDirection dir) override
Copies bytes between buffers.
void max_unpool(const float *src, const float *argmax, float *dst, size_t planes, size_t h, size_t w, size_t kh, size_t kw, size_t sh, size_t sw, size_t ph, size_t pw) override
The inverse routing: each input position gets the sum of the pooled values whose argmax it is (window...
void fill(void *ptr, float value, size_t n) override
Fills every element of a float buffer with a constant value.
void add_channel_vector(const float *in, const float *vec, float *out, size_t n, size_t c, size_t inner) override
out[i][ch][k] = in[i][ch][k] + vec[ch] over (n, c, inner). out may alias in.
void free(void *ptr) noexcept override
Returns the block to the caching allocator; the memory stays with this backend.
void accumulate_parts(const float *parts, size_t count, size_t n, float *acc) override
acc += parts[0], then += parts[1], ... (count blocks of n floats, in order): the sums accumulating on...
void lrp_stabilized_divide(const float *r, const float *denom, const float *gate, float *out, size_t n, float eps, LrpGate gate_mode) override
Gated stabilized division, the one non-gemm step of the affine LRP rules: out[i] = passes(gate[i]) ?...
void gemm(const float *a, const float *b, float *out, size_t m, size_t k, size_t n) override
Row-major matrix multiply: out = a * b.
void im2col(const float *in, float *col, size_t n, size_t c, size_t h, size_t w, const ConvGeometry &geometry) override
Unfolds (n, c, h, w) into (n, c*kh*kw, out_h*out_w) patches, with out_h = (h + 2*pad_h - kh) / stride...
void column_sums(const float *in, float *out, size_t rows, size_t cols, float beta) override
Per-column sum of a (rows x cols) row-major matrix: out[j] = beta*out[j] + sum_i in[i][j].
void permute_0213(const float *in, float *out, size_t d0, size_t d1, size_t d2, size_t d3) override
Swaps the middle two axes: in (d0, d1, d2, d3) -> out (d0, d2, d1, d3).
void batch_norm_eval_forward(const float *in, const float *gamma, const float *beta, const float *running_mean, const float *running_var, float *xhat, float *out, float *channel_std, size_t n, size_t c, size_t spatial, float eps) override
Eval-mode BatchNorm from the running statistics: a per-channel affine map. FND-5.
void gru_lrp_hprev(const float *h_prev, const float *w_hn, const float *hn, const float *r_term_b, const float *direct, float *r_hprev, size_t rows, size_t hidden, float eps) override
GRU's R_hprev for (rows, hidden): the recurrent epsilon-rule sum through W_hn, with each element's di...
void lrp_bilinear_elementwise(const float *a, const float *b, const float *r, float *r_out, size_t n, float eps) override
Eq. 15 for an elementwise product c = a*b: r_out = (a b / (2c + eps sign c)) r (same for both).
void lrp_avg_pool(const float *x, const float *r, float *r_in, size_t planes, size_t h, size_t w, size_t kh, size_t kw, float eps) override
AvgPool2D epsilon rule; r_in must be zeroed by the caller.
void max_pool_forward(const float *in, float *out, float *argmax, size_t planes, size_t h, size_t w, size_t kh, size_t kw, size_t sh, size_t sw, size_t ph, size_t pw) override
Max pool over planes of (h, w) with a (kh, kw) window, stride (sh, sw) and padding (ph,...
void aggregator_backward(const float *x, const float *mean_pow, const float *grad_out, float *grad_in, size_t n, size_t cols, float p) override
AggregatorModule input gradient, per column.
void set_memory_budget(size_t bytes)
Caps the memory this backend holds, in use plus cached (0: no cap). Defaults to PULSATRIX_HIP_MEMORY_...
Definition hip_backend.hpp:62
void attention_mask_fill(float *scores, const float *key_keep, size_t batch, size_t heads, size_t q_len, size_t k_len, bool causal, size_t q_offset, size_t window, float value) override
Overwrites the masked entries of (batch, heads, q_len, k_len) attention scores with value,...
void mul(const float *a, const float *b, float *out, size_t n) override
Elementwise binary (Hadamard) multiplication: out[i] = a[i] * b[i] for i in [0, n).
void adam_step(float *param, const float *grad, float *m, float *v, size_t n, float lr, float beta1, float beta2, float eps, float bias_correction1, float bias_correction2) override
One fused Adam update over n parameters.
void dot_into(const float *a, const float *b, size_t n, float *out) override
No wait: the result stays on the device (HIP-6).
void bce_with_logits(const float *logits, const float *target, float *out, size_t n) override
Per-element binary cross-entropy with logits: out[i] = max(x, 0) - x*y + log1p(exp(-|x|)),...
void layer_norm_backward(const float *grad_out, const float *gamma, const float *xhat, const float *row_std, float *grad_in, size_t rows, size_t cols) override
LayerNorm input gradient per row, from the cached xhat and per-row std.
HIPBackend & operator=(const HIPBackend &)=delete
void logic_pointwise(LogicOp op, int norm, const float *a, const float *b, const float *g_or_r, const float *y, float *out_a, float *out_b, size_t n, float eps) override
One elementwise pass of Conjunction/Disjunction for operands a, b.
void group_norm_backward(const float *grad_out, const float *gamma, const float *xhat, const float *group_std, float *grad_in, float *gamma_grad, float *beta_grad, size_t n, size_t c, size_t spatial, size_t num_groups) override
GroupNorm input gradient plus this call's gamma/beta gradients (overwritten, per channel).
void lrp_rope(const float *x, const float *y, const float *r, const float *cos_table, const float *sin_table, float *r_in, size_t slices, size_t seq_len, size_t head_dim, float eps, bool rotate_half) override
RoPEModule epsilon rule over (slices, seq_len, head_dim), tables as for rope_rotate.
void ssm_pass(SsmPassOp op, const SsmPassArgs &args) override
One fused Mamba / RWKV / RetNet pass (see SsmPassOp for lanes and slots).
void batch_norm_backward(const float *grad_out, const float *gamma, const float *xhat, const float *channel_std, float *grad_in, float *gamma_grad, float *beta_grad, size_t n, size_t c, size_t spatial) override
BatchNorm input gradient plus this call's gamma/beta gradients (overwritten, per channel).
void tanh_gaussian_backward(const float *action, const float *std_cache, const float *eps, const float *grad_action, const float *grad_log_prob, float *grad_mean, float *grad_log_std, size_t n, float stabilizer) override
TanhGaussianPolicy gradients w.r.t. mean and log_std, per element.
void layer_norm_forward(const float *in, const float *gamma, const float *beta, float *xhat, float *out, float *row_std, size_t rows, size_t cols, float eps) override
LayerNorm forward per row: xhat = (x - mean)/sqrt(var + eps), out = gamma*xhat + beta.
DeviceType device() const noexcept override
Which device this backend's buffers reside on.
Definition hip_backend.hpp:44
void lrp_softmax_rows(const float *x, const float *y, const float *r, float *r_in, size_t rows, size_t cols) override
SoftmaxModule rule per row: r_in = x * (r - y * sum(r)).
float dot(const float *a, const float *b, size_t n) override
Dot product sum_i a[i]*b[i], returned to the host.
void rms_norm_forward(const float *in, const float *gamma, float *out, float *row_rms, size_t rows, size_t cols, float eps) override
RMSNorm forward per row: out = gamma * x / sqrt(mean(x^2) + eps).
void avg_pool_backward(const float *grad_out, float *grad_in, size_t planes, size_t h, size_t w, size_t kh, size_t kw) override
Spreads grad_out / (kh*kw) over each window; grad_in must be zeroed by the caller.
CachingAllocator::Stats memory_stats() const
The caching allocator's counters: bytes in use and cached, peak, raw hipMalloc/hipFree calls and cach...
Definition hip_backend.hpp:54
void gemm_strided_batched(const float *a, bool transpose_a, size_t stride_a, const float *b, bool transpose_b, size_t stride_b, float *out, size_t stride_out, size_t m, size_t k, size_t n, size_t batch, float beta=0.0f) override
batch independent gemm_ex() products, out_i = op(A_i) op(B_i) (+ beta out_i), with A_i = a + i * stri...
bool sync_debug() const
Whether every op waits for the GPU to finish (PULSATRIX_HIP_SYNC_DEBUG=1 when the backend was created...
Definition hip_backend.hpp:71
void recurrent_cell(RecurrentCellOp op, const RecurrentCellArgs &args, size_t n) override
One fused recurrent-cell pass over n elements (see RecurrentCellOp for slots).
void lrp_bilinear_matmul(const float *a, const float *b, const float *o, const float *r_o, float *r_a, float *r_b, size_t slices, size_t m, size_t p, size_t q, float eps, bool b_transposed) override
Eq. 15 for slices independent matmuls O = A @ B (A (M x P), B (P x Q), O and r_o (M x Q)).
void lrp_conv(const float *col, const float *kernel, const float *pre_bias, const float *r, float *r_col, size_t n, size_t out_channels, size_t p, size_t q, float eps) override
Conv2D epsilon rule in patch space: r_col (n, p, q) from the cached patches, the kernel (out_channels...
void rms_norm_backward(const float *grad_out, const float *gamma, const float *in, const float *row_rms, float *grad_in, float *gamma_terms, size_t rows, size_t cols) override
RMSNorm input gradient per row, plus gamma_terms[r][i] = grad_out * x / rms – the per-row contributio...
void adam_step_multi(const AdamTensorStep *tensors, size_t count, float beta1, float beta2, float eps) override
One launch per 32 tensors, the table passed as kernel arguments (HIP-6).
void aggregator_forward(const float *x, float *mean_pow, float *out, size_t n, size_t cols, float p) override
AggregatorModule power mean over the leading axis of an (n, cols) input, per column.
void group_norm_forward(const float *in, const float *gamma, const float *beta, float *xhat, float *out, float *group_std, size_t n, size_t c, size_t spatial, size_t num_groups, float eps) override
GroupNorm per (example, group) of (n, c, spatial) data; group_std is (n, num_groups).
void gemm_ex(const float *a, bool transpose_a, const float *b, bool transpose_b, float *out, size_t m, size_t k, size_t n, float beta) override
General row-major matrix multiply: out = op(A) * op(B) + beta * out.
void avg_pool_forward(const float *in, float *out, size_t planes, size_t h, size_t w, size_t kh, size_t kw) override
Non-overlapping average pool over planes of (h, w).
void scatter_add_rows(const float *src, const float *indices, float *table, size_t count, size_t dim) override
table[indices[i]][:] += src[i][:] for i = 0..count-1, in increasing i.
void axpby(float alpha, const float *x, float beta, const float *y, float *out, size_t n) override
out[i] = alpha * x[i] + beta * y[i]. out may alias x or y.
void col2im_add(const float *col, float *out, size_t n, size_t c, size_t h, size_t w, const ConvGeometry &geometry) override
Folds (n, c*kh*kw, out_h*out_w) patches back, adding into out (n, c, h, w).
void elementwise(ElementwiseOp op, const float *in, float *out, size_t n) override
Applies a unary elementwise operation to every element of a buffer.
void logsumexp_rows(const float *in, float *out, size_t rows, size_t cols) override
Per-row log-sum-exp, max-subtracted: out[i] = log sum_j exp(in[i][j]).
void * allocate(size_t bytes) override
From the caching allocator (HIP-3): a freed block of the same size class is reused instead of calling...
Abstract interface isolating vendor-specific memory/compute operations from Tensor/ComputationGraph.
Definition acquisition_functions.hpp:16
LogicOp
Elementwise passes of the fuzzy-logic modules, for DeviceBackend::logic_pointwise.
Definition device_backend.hpp:66
DeviceType
Which physical device a Tensor's buffer resides on.
Definition device_backend.hpp:17
CopyDirection
Direction of a DeviceBackend::copy() call.
Definition device_backend.hpp:24
SsmPassOp
Fused passes of the state-space / linear-recurrence modules (MambaModule, RWKVModule,...
Definition device_backend.hpp:135
RecurrentCellOp
Fused per-element recurrent-cell passes, for DeviceBackend::recurrent_cell. Slots (in[] / out[]),...
Definition device_backend.hpp:88
LrpGate
Elementwise boolean gate for DeviceBackend::lrp_stabilized_divide().
Definition device_backend.hpp:55
RlRowOp
Fused per-row reinforcement-learning passes, for DeviceBackend::rl_rows. One lane per batch row (per ...
Definition device_backend.hpp:205
ElementwiseOp
Unary elementwise operations supported by DeviceBackend::elementwise().
Definition device_backend.hpp:43
One parameter tensor's share of DeviceBackend::adam_step_multi (HIP-6): its buffers and its own step'...
Definition device_backend.hpp:225
Definition caching_allocator.hpp:27
Window geometry for DeviceBackend::im2col / col2im_add: kernel size, stride and zero padding per axis...
Definition device_backend.hpp:173
Operand pointers for DeviceBackend::recurrent_cell (passed to kernels by value).
Definition device_backend.hpp:91
Operand pointers and dims for DeviceBackend::rl_rows (passed to kernels by value).
Definition device_backend.hpp:208
Operand pointers and dims for DeviceBackend::ssm_pass (passed to kernels by value).
Definition device_backend.hpp:158