tensor_stream 0.8.1 → 0.8.5

data/lib/tensor_stream/evaluator/opencl/kernels/_bool_operand.cl

@@ -1,45 +0,0 @@
- // same dimension add floating point op
- __kernel void <%= fname%>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= a_dtype %> *A, __global <%= b_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] = A[globalRow * N + globalCol] <%= op %> B[globalRow * N + globalCol] ? 1 : 0;
-}
-
- // 1D + Scalar floating point add op
- __kernel void <%=fname%>_c_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= a_dtype %> *A, __global <%= b_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] = A[globalRow * N + globalCol] <%= op %> B[0] ? 1 : 0;
-    } else {
-      C[globalRow * N + globalCol] = B[0] <%= op %> A[globalRow * N + globalCol] ? 1 : 0;
-    }
-}
-
- // 1D + Scalar floating point add op broadcast
- __kernel void <%= fname%>_b_<%= dtype %>(const int M, const int N, const int M2, const int N2, const int switch_op,__global const <%= a_dtype %> *A, __global <%= b_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] = A[globalRow * N + globalCol] <%= op %> B[b_m_index * N2 + b_n_index] ? 1 : 0;
-    } else {
-      C[globalRow * N + globalCol] = B[b_m_index * N2 + b_n_index] <%= op %> A[globalRow * N + globalCol] ? 1 : 0;
-    }
-}

data/lib/tensor_stream/evaluator/opencl/kernels/_operand.cl

@@ -1,45 +0,0 @@
- // same dimension add floating point op
- __kernel void <%= fname%>_<%= 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] = A[globalRow * N + globalCol] <%= op %> B[globalRow * N + globalCol];
-}
-
- // 1D + Scalar floating point add op
- __kernel void <%=fname%>_c_<%= 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] = A[globalRow * N + globalCol] <%= op %> B[0];
-    } else {
-      C[globalRow * N + globalCol] = B[0] <%= op %> A[globalRow * N + globalCol];
-    }
-}
-
- // 1D + Scalar floating point add op broadcast
- __kernel void <%= fname%>_b_<%= 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] = A[globalRow * N + globalCol] <%= op %> B[b_m_index * N2 + b_n_index];
-    } else {
-      C[globalRow * N + globalCol] = B[b_m_index * N2 + b_n_index] <%= op %> A[globalRow * N + globalCol];
-    }
-}

data/lib/tensor_stream/evaluator/opencl/kernels/abs.cl

@@ -1,20 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-% if TensorStream::Ops::FLOATING_POINT_TYPES.include?(dtype)
-__kernel void abs_<%= 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] = fabs(A[globalRow * N + globalCol]);
-}
-% else
-% %w[int int32].each do |dt|
-__kernel void abs_<%= dt %>(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] = fabs((float)A[globalRow * N + globalCol]);
-}
-% end
-%end

data/lib/tensor_stream/evaluator/opencl/kernels/acos.cl

@@ -1,8 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-__kernel void acos_<%= 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] = acos(A[globalRow * N + globalCol]);
-}

data/lib/tensor_stream/evaluator/opencl/kernels/add.cl

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

data/lib/tensor_stream/evaluator/opencl/kernels/apply_adam.cl

@@ -1,23 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
- // same dimension add floating point op
- __kernel void apply_adam_<%= dtype %>(const int M, const int N,
-                                       __global const <%= c_dtype %> *grad,
-                                       __global const <%= c_dtype %> *learning_rate,
-                                       __global const <%= c_dtype %> *beta1_power,
-                                       __global const <%= c_dtype %> *beta2_power,
-                                       __global const <%= c_dtype %> *beta1,
-                                       __global const <%= c_dtype %> *beta2,
-                                       __global const <%= c_dtype %> *epsilon,
-                                       __global <%= c_dtype %> *momentum,
-                                       __global <%= c_dtype %> *output, __global <%= c_dtype %> *v) {
-    // 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 %> alpha = learning_rate[0] * sqrt(1.0 - beta2_power[0]) / (1.0 - beta1_power[0]);
-
-    momentum[index] += (grad[index] - momentum[index]) * (1.0 - beta1[0]);
-    v[index] += (grad[index] * grad[index] - v[index]) * (1.0 - beta2[0]);
-    output[index] -= (momentum[index] * alpha) / ( sqrt(v[index]) + epsilon[0] );
-}

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

@@ -1,9 +0,0 @@
-% 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/evaluator/opencl/kernels/apply_momentum.cl

@@ -1,16 +0,0 @@
-% 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/evaluator/opencl/kernels/argmax.cl

@@ -1,8 +0,0 @@
-% 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/evaluator/opencl/kernels/argmin.cl

@@ -1,8 +0,0 @@
-% 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/evaluator/opencl/kernels/asin.cl

@@ -1,9 +0,0 @@
-
-% 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/evaluator/opencl/kernels/cast.cl

@@ -1,10 +0,0 @@
-% 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/evaluator/opencl/kernels/ceil.cl

@@ -1,8 +0,0 @@
-% 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/evaluator/opencl/kernels/cond.cl.erb

@@ -1,6 +0,0 @@
-% ["#{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/evaluator/opencl/kernels/cos.cl

@@ -1,8 +0,0 @@
-% 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/evaluator/opencl/kernels/div.cl.erb

@@ -1,3 +0,0 @@
-% 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/evaluator/opencl/kernels/exp.cl

@@ -1,8 +0,0 @@
-% 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/evaluator/opencl/kernels/floor.cl

@@ -1,8 +0,0 @@
-% 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/evaluator/opencl/kernels/floor_div.cl

@@ -1,48 +0,0 @@
-% 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/evaluator/opencl/kernels/floor_mod.cl

@@ -1,3 +0,0 @@
-% 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/evaluator/opencl/kernels/gemm.cl

@@ -1,32 +0,0 @@
-// 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/evaluator/opencl/kernels/log.cl

@@ -1,8 +0,0 @@
-% 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/evaluator/opencl/kernels/log1p.cl

@@ -1,8 +0,0 @@
-% 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/evaluator/opencl/kernels/log_softmax.cl

@@ -1,26 +0,0 @@
-// 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/evaluator/opencl/kernels/max.cl

@@ -1,46 +0,0 @@
- // 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];
-    }
-}