tensor_stream-opencl 0.1.0

data/lib/tensor_stream/opencl/kernels/apply_gradient.cl

@@ -0,0 +1,9 @@
+% c_dtype = dtype_to_c_type(dtype)
+ // same dimension add floating point op
+ __kernel void apply_gradient_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] -= A[globalRow * N + globalCol] * B[0];
+}

data/lib/tensor_stream/opencl/kernels/apply_momentum.cl

@@ -0,0 +1,16 @@
+% c_dtype = dtype_to_c_type(dtype)
+ // same dimension add floating point op
+ __kernel void apply_momentum_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *grad, __global const <%= c_dtype %> *learning_rate,
+                                          __global const <%= c_dtype %> *momentum, __global <%= c_dtype %> *output, __global <%= c_dtype %> *acc) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+    const int index = globalRow * N + globalCol;
+    <%= c_dtype %> acc_m = acc[index];
+    acc[index] = acc_m * momentum[0] + grad[index];
+<% if nesterov %>
+    output[index] -= grad[index] * learning_rate[0] + acc_m * momentum[0] * learning_rate[0];
+<% else %>
+    output[index] -= acc_m * learning_rate[0];
+<% end %>
+}

data/lib/tensor_stream/opencl/kernels/argmax.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+ __kernel void argmax_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+    
+    C[globalRow * N + globalCol] = A[globalRow * N + globalCol] + B[globalRow * N + globalCol];
+}

data/lib/tensor_stream/opencl/kernels/argmin.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+ __kernel void argmin_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+    
+    C[globalRow * N + globalCol] = A[globalRow * N + globalCol] + B[globalRow * N + globalCol];
+}

data/lib/tensor_stream/opencl/kernels/asin.cl

@@ -0,0 +1,9 @@
+
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void asin_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = asin(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/opencl/kernels/cast.cl

@@ -0,0 +1,10 @@
+% source_ctype = dtype_to_c_type(source_dt)
+% target_ctype = dtype_to_c_type(target_dt)
+
+__kernel void cast(const int M, const int N, __global const <%= source_ctype %> *A, __global <%= target_ctype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = A[globalRow * N + globalCol];
+}

data/lib/tensor_stream/opencl/kernels/ceil.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void ceil_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = ceil(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/opencl/kernels/cond.cl.erb

@@ -0,0 +1,6 @@
+% ["#{dtype}"].product(%w[less less_equal equal not_equal greater greater_equal logical_and]).each do |dtype, fname|
+% a_dtype = dtype_to_c_type(a)
+% b_dtype = dtype_to_c_type(b)
+% op = operator_to_c(fname)
+<%= render 'bool_operand.cl', a_dtype: a_dtype, b_dtype: b_dtype, op: op, fname: fname, dtype: "#{a}_#{b}", result_t: 'short' %>
+% end

data/lib/tensor_stream/opencl/kernels/cos.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void cos_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = cos(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/opencl/kernels/div.cl.erb

@@ -0,0 +1,3 @@
+% c_dtype = dtype_to_c_type(dtype)
+% op = operator_to_c('div')
+<%= render 'operand.cl', c_dtype: c_dtype, op: op, fname: 'div', dtype: "#{a}_#{b}", result_t: c_dtype %>

data/lib/tensor_stream/opencl/kernels/exp.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void exp_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = exp(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/opencl/kernels/floor.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void floor_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = floor(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/opencl/kernels/floor_div.cl

@@ -0,0 +1,48 @@
+% c_dtype = dtype_to_c_type(dtype)
+% fname = 'floor_div'
+% result_t = c_dtype
+ // same dimension add floating point op
+ __kernel void <%= fname%>_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *B, __global <%= result_t %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = (int)(A[globalRow * N + globalCol] / B[globalRow * N + globalCol]);
+}
+
+ // 1D + Scalar floating point add op
+ __kernel void <%=fname%>_c_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *B, __global <%= result_t %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    if (switch_op == 0) {
+      C[globalRow * N + globalCol] = (int)(A[globalRow * N + globalCol] / B[0]);
+    } else {
+      C[globalRow * N + globalCol] = (int)(B[0] / A[globalRow * N + globalCol]);
+    }
+}
+
+ // 1D + Scalar floating point add op broadcast
+ __kernel void <%= fname%>_b_<%= dtype %>_<%= dtype %>(const int M, const int N, const int M2, const int N2, const int switch_op,__global const <%= c_dtype %> *A, __global <%= c_dtype %> *B, __global <%= result_t %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    int b_m_index = globalRow;
+    int b_n_index = globalCol;
+
+    if ( b_m_index >= M2) {
+      b_m_index = b_m_index % M2;
+    };
+
+    if (b_n_index >= N2) {
+      b_n_index = b_n_index % N2;
+    }
+
+    if (switch_op == 0) {
+      C[globalRow * N + globalCol] = (int)(A[globalRow * N + globalCol] / B[b_m_index * N2 + b_n_index]);
+    } else {
+      C[globalRow * N + globalCol] = (int)(B[b_m_index * N2 + b_n_index] / A[globalRow * N + globalCol]);
+    }
+}

data/lib/tensor_stream/opencl/kernels/floor_mod.cl

@@ -0,0 +1,3 @@
+% c_dtype = dtype_to_c_type(dtype)
+% op = operator_to_c('mod')
+<%= render 'operand.cl', c_dtype: c_dtype, op: op, fname: 'floor_mod', dtype: "#{a}_#{b}", result_t: c_dtype %>

data/lib/tensor_stream/opencl/kernels/gemm.cl

@@ -0,0 +1,32 @@
+// First naive implementation
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void gemm_<%= dtype %>(const int M, const int N, const int K,
+                      const int A_transpose,
+                      const int B_transpose,
+                      const __global <%= c_dtype %>* A,
+                      const __global <%= c_dtype %>* B,
+                      __global <%= c_dtype %>* C) {
+
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    // Compute a single element (loop over K)
+    <%= c_dtype %> acc = 0.0f;
+    for (int k=0; k<K; k++) {
+        int a_index = globalRow*K + k;
+        int b_index = k*N + globalCol;
+
+        if (A_transpose) {
+            a_index = M*k + globalRow;
+        }
+
+        if (B_transpose) {
+            b_index = globalCol*K + k;
+        }
+        acc += A[a_index] * B[b_index];
+    }
+
+    // Store the result
+    C[globalRow*N + globalCol] = acc;
+}

data/lib/tensor_stream/opencl/kernels/log.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void log_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = log(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/opencl/kernels/log1p.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void log1p_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = log1p(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/opencl/kernels/log_softmax.cl

@@ -0,0 +1,26 @@
+// First naive implementation
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void log_softmax_<%= dtype %>(const int N,
+                      const __global <%= c_dtype %>* A,
+                      __global <%= c_dtype %>* C) {
+
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+
+    // Compute a single element (loop over K)
+    <%= c_dtype %> acc = 0.0f;
+    <%= c_dtype %> max = <%= min_value_for(dtype) %>;
+
+    for (int k=0; k<N; k++) {
+      max = A[globalRow*N + k] > max ? A[globalRow*N + k] : max;
+    }
+
+    for (int k=0; k<N; k++) {
+      acc += exp(A[globalRow*N + k] - max);
+    }
+
+    // Store the result
+    for (int k=0; k < N; k++) {
+      C[globalRow*N + k] = (A[globalRow*N + k] - max) - log(acc);
+    }
+}

data/lib/tensor_stream/opencl/kernels/max.cl

@@ -0,0 +1,46 @@
+ // same dimension add floating point op
+% c_dtype = dtype_to_c_type(dtype)
+ __kernel void max_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = A[globalRow * N + globalCol] >= B[globalRow * N + globalCol] ? A[globalRow * N + globalCol] : B[globalRow * N + globalCol];
+}
+
+ // 1D + Scalar floating point add op
+ __kernel void max_c_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+    
+    if (switch_op == 0) {
+      C[globalRow * N + globalCol] = A[globalRow * N + globalCol] >= B[0] ? A[globalRow * N + globalCol] : B[0];
+    } else {
+      C[globalRow * N + globalCol] = B[0] >= A[globalRow * N + globalCol] ? B[0] : A[globalRow * N + globalCol];
+    }
+}
+
+ // 1D + Scalar floating point add op broadcast
+ __kernel void max_b_<%= dtype %>_<%= dtype %>(const int M, const int N, const int M2, const int N2, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+    
+    int b_m_index = globalRow;
+    int b_n_index = globalCol;
+
+    if ( b_m_index >= M2) {
+      b_m_index = b_m_index % M2;
+    };
+
+    if (b_n_index >= N2) {
+      b_n_index = b_n_index % N2;
+    }
+
+    if (switch_op == 0) {
+      C[globalRow * N + globalCol] = A[globalRow * N + globalCol] >= B[b_m_index * N2 + b_n_index] ? A[globalRow * N + globalCol] : B[b_m_index * N2 + b_n_index];
+    } else {
+      C[globalRow * N + globalCol] = B[b_m_index * N2 + b_n_index] >= A[globalRow * N + globalCol] ? B[b_m_index * N2 + b_n_index] :  A[globalRow * N + globalCol];
+    }
+}

data/lib/tensor_stream/opencl/kernels/min.cl

@@ -0,0 +1,46 @@
+ // same dimension add floating point op
+% c_dtype = dtype_to_c_type(dtype)
+ __kernel void min_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = A[globalRow * N + globalCol] <= B[globalRow * N + globalCol] ? A[globalRow * N + globalCol] : B[globalRow * N + globalCol];
+}
+
+ // 1D + Scalar floating point add op
+ __kernel void min_c_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    if (switch_op == 0) {
+      C[globalRow * N + globalCol] = A[globalRow * N + globalCol] <= B[0] ? A[globalRow * N + globalCol] : B[0];
+    } else {
+      C[globalRow * N + globalCol] = B[0] <= A[globalRow * N + globalCol] ? B[0] : A[globalRow * N + globalCol];
+    }
+}
+
+ // 1D + Scalar floating point add op broadcast
+ __kernel void min_b_<%= dtype %>_<%= dtype %>(const int M, const int N, const int M2, const int N2, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    int b_m_index = globalRow;
+    int b_n_index = globalCol;
+
+    if ( b_m_index >= M2) {
+      b_m_index = b_m_index % M2;
+    };
+
+    if (b_n_index >= N2) {
+      b_n_index = b_n_index % N2;
+    }
+
+    if (switch_op == 0) {
+      C[globalRow * N + globalCol] = A[globalRow * N + globalCol] <= B[b_m_index * N2 + b_n_index] ? A[globalRow * N + globalCol] : B[b_m_index * N2 + b_n_index];
+    } else {
+      C[globalRow * N + globalCol] = B[b_m_index * N2 + b_n_index] <= A[globalRow * N + globalCol] ? B[b_m_index * N2 + b_n_index] :  A[globalRow * N + globalCol];
+    }
+}

data/lib/tensor_stream/opencl/kernels/mod.cl

@@ -0,0 +1,3 @@
+% c_dtype = dtype_to_c_type(dtype)
+% op = operator_to_c('mod')
+<%= render 'operand.cl', c_dtype: c_dtype, op: op, fname: 'mod', dtype: "#{a}_#{b}", result_t: c_dtype %>

data/lib/tensor_stream/opencl/kernels/mul.cl

@@ -0,0 +1,3 @@
+% c_dtype = dtype_to_c_type(dtype)
+% op = operator_to_c('mul')
+<%= render 'operand.cl', c_dtype: c_dtype, op: op, fname: 'mul', dtype: "#{a}_#{b}", result_t: c_dtype %>

data/lib/tensor_stream/opencl/kernels/negate.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void negate_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = -A[globalRow * N + globalCol];
+}

data/lib/tensor_stream/opencl/kernels/pack.cl

@@ -0,0 +1,24 @@
+% ctype = dtype_to_c_type(data_type)
+
+__kernel void pack(const int N, const int index, __global const <%= ctype %> *A, __global <%= ctype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalCol = get_global_id(0); // Col ID of C (0..N)
+
+    int start = index * <%= divisors[0] %>;
+    int ptr = start + globalCol;
+    int index_map[<%= divisors.size %>] = { <%= Array.new(divisors.size) { 0 }.join(', ') %> };
+
+    // compute effective coordinates
+<% divisors.each_with_index do |div, index| %>
+    index_map[<%= index %>] = (int)floor(ptr / (float)<%= div %>);<% if index < divisors.size - 1%>ptr = ptr % <%= div %>;<% end %><% end %>
+
+    // Apply axis translation if needed
+<% if axis > 0 %>
+    int first = index_map[0];
+<% axis.times do |i| %>
+    index_map[<%= i %>] = index_map[<%= (i + 1) %>];<% end %>
+    index_map[<%= axis %>] = first;
+<% end%>
+
+    C[<%= multipliers.each_with_index.map { |m, idx| "#{m}*index_map[#{idx}]" }.join(' + ') %>] = A[globalCol];
+}

data/lib/tensor_stream/opencl/kernels/pow.cl

@@ -0,0 +1,46 @@
+ // same dimension add floating point op
+% c_dtype = dtype_to_c_type(dtype)
+ __kernel void pow_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = pow((float)A[globalRow * N + globalCol], (float)B[globalRow * N + globalCol]);
+}
+
+ // 1D + Scalar floating point add op
+ __kernel void pow_c_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+    
+    if (switch_op == 0) {
+      C[globalRow * N + globalCol] = pow((float)A[globalRow * N + globalCol], (float)B[0]);
+    } else {
+      C[globalRow * N + globalCol] = pow((float)B[0], (float)A[globalRow * N + globalCol]);
+    }
+}
+
+ // 1D + Scalar floating point add op broadcast
+ __kernel void pow_b_<%= dtype %>_<%= dtype %>(const int M, const int N, const int M2, const int N2, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+    
+    int b_m_index = globalRow;
+    int b_n_index = globalCol;
+
+    if ( b_m_index >= M2) {
+      b_m_index = b_m_index % M2;
+    };
+
+    if (b_n_index >= N2) {
+      b_n_index = b_n_index % N2;
+    }
+
+    if (switch_op == 0) {
+      C[globalRow * N + globalCol] = pow((float)A[globalRow * N + globalCol], (float)B[b_m_index * N2 + b_n_index]);
+    } else {
+      C[globalRow * N + globalCol] = pow((float)B[b_m_index * N2 + b_n_index], (float)A[globalRow * N + globalCol]);
+    }
+}