tensor_stream 0.2.0 → 0.3.0

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

@@ -0,0 +1,7 @@
+__kernel void cos_fp(const int M, const int N, __global const float *A, __global float *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/kernels/div.cl.erb

@@ -0,0 +1,5 @@
+% %w[fp int].product(%w[div]).each do |dtype, fname|
+% c_dtype = dtype_to_c_type(dtype)
+% op = operator_to_c(fname)
+<%= render 'operand.cl', c_dtype: c_dtype, op: op, fname: fname, dtype: dtype, result_t: c_dtype %>
+% end

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

@@ -0,0 +1,7 @@
+__kernel void exp_fp(const int M, const int N, __global const float *A, __global float *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/kernels/gemm.cl

@@ -0,0 +1,63 @@
+// First naive implementation
+__kernel void gemm_fp(const int M, const int N, const int K,
+                      const int A_transpose,
+                      const int B_transpose,
+                      const __global float* A,
+                      const __global float* B,
+                      __global float* 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)
+    float 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;
+}
+
+// First naive implementation
+__kernel void gemm_int(const int M, const int N, const int K,
+                      const int A_transpose,
+                      const int B_transpose,
+                      const __global int* A,
+                      const __global int* B,
+                      __global int* 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)
+    int acc = 0;
+    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/kernels/log.cl

@@ -0,0 +1,7 @@
+__kernel void log_fp(const int M, const int N, __global const float *A, __global float *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/kernels/log1p.cl

@@ -0,0 +1,7 @@
+__kernel void log1p_fp(const int M, const int N, __global const float *A, __global float *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/kernels/max.cl

@@ -0,0 +1,91 @@
+ // same dimension add floating point op
+ __kernel void max_fp(const int M, const int N, const int switch_op, __global const float *A, __global const float *B, __global float *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_fp(const int M, const int N, const int switch_op, __global const float *A, __global const float *B, __global float *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_fp(const int M, const int N, const int M2, const int N2, const int switch_op, __global const float *A, __global const float *B, __global float *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];
+    }
+}
+
+ // same dimension add floating point op
+ __kernel void max_int(const int M, const int N, const int switch_op, __global const int *A, __global const int *B, __global int *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_int(const int M, const int N, const int switch_op, __global const int *A, __global const int *B, __global int *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_int(const int M, const int N, const int M2, const int N2, const int switch_op, __global const int *A, __global const int *B, __global int *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/evaluator/kernels/mul.cl

@@ -0,0 +1,5 @@
+% %w[fp int].product(%w[mul]).each do |dtype, fname|
+% c_dtype = dtype_to_c_type(dtype)
+% op = operator_to_c(fname)
+<%= render 'operand.cl', c_dtype: c_dtype, op: op, fname: fname, dtype: dtype, result_t: c_dtype %>
+% end

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

@@ -0,0 +1,15 @@
+__kernel void negate_fp(const int M, const int N, __global const float *A, __global float *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];
+}
+
+__kernel void negate_int(const int M, const int N, __global const int *A, __global int *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/kernels/pow.cl

@@ -0,0 +1,130 @@
+ // same dimension add floating point op
+ __kernel void pow_fp(const int M, const int N, const int switch_op, __global const float *A, __global const float *B, __global float *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_fp(const int M, const int N, const int switch_op, __global const float *A, __global const float *B, __global float *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_fp(const int M, const int N, const int M2, const int N2, const int switch_op, __global const float *A, __global const float *B, __global float *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]);
+    }
+}
+
+ // same dimension add floating point op
+ __kernel void pow_int(const int M, const int N, const int switch_op, __global const int *A, __global const int *B, __global int *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 acc = A[globalRow * N + globalCol];
+    const int count = B[globalRow * N + globalCol];
+    const int c = A[globalRow * N + globalCol];
+
+    if (count < 4) {
+      for(int i = 0; i < count - 1; i++) {
+        acc *= c;
+      }
+      C[globalRow * N + globalCol] = acc;
+    } else {
+      C[globalRow * N + globalCol] = pow((float)c, (float)count);
+    }
+}
+
+ // 1D + Scalar floating point add op
+ __kernel void pow_c_int(const int M, const int N, const int switch_op, __global const int *A, __global const int *B, __global int *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 acc, count, c;
+    if (switch_op == 0) {
+      acc = A[globalRow * N + globalCol];
+      count = B[0];
+      c = A[globalRow * N + globalCol];
+    } else {
+      acc = B[0];
+      count = A[globalRow * N + globalCol];
+      c = B[0];
+    }
+    if (count < 4) {
+      for(int i =0; i < count - 1; i++) {
+        acc *= c;
+      }
+      C[globalRow * N + globalCol] = acc;
+    } else {
+      C[globalRow * N + globalCol] = pow((float)c, (float)count);
+    }
+}
+
+ // 1D + Scalar floating point add op broadcast
+ __kernel void pow_b_int(const int M, const int N, const int M2, const int N2, const int switch_op, __global const int *A, __global const int *B, __global int *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;
+    }
+
+    int acc, count, c;
+
+    if (switch_op == 0) {
+      acc = A[globalRow * N + globalCol];
+      count = B[b_m_index * N2 + b_n_index];
+      c = A[globalRow * N + globalCol];
+    } else {
+      acc = B[b_m_index * N2 + b_n_index];
+      count = A[globalRow * N + globalCol];
+      c = B[b_m_index * N2 + b_n_index];
+    }
+
+    if (count < 4) {
+      for (int i = 0; i < count - 1; i++) {
+        acc *= c;
+      }
+      C[globalRow * N + globalCol] = acc;
+    } else {
+      C[globalRow * N + globalCol] = pow((float)c, (float)count);
+    }
+}

data/lib/tensor_stream/evaluator/kernels/reciprocal.cl

@@ -0,0 +1,15 @@
+__kernel void reciprocal_fp(const int M, const int N, __global const float *A, __global float *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] = 1.0f / A[globalRow * N + globalCol];
+}
+
+__kernel void reciprocal_int(const int M, const int N, __global const int *A, __global int *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] = 1 / A[globalRow * N + globalCol];
+}

data/lib/tensor_stream/evaluator/kernels/round.cl

@@ -0,0 +1,7 @@
+__kernel void round_fp(const int M, const int N, __global const float *A, __global float *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] = round(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/evaluator/kernels/sigmoid.cl

@@ -0,0 +1,8 @@
+
+__kernel void sigmoid_fp(const int M, const int N, __global const float *A, __global float *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] = 1.0f/(1.0f + exp(-A[globalRow * N + globalCol]));
+}

data/lib/tensor_stream/evaluator/kernels/sigmoid_grad.cl

@@ -0,0 +1,54 @@
+
+float sigmoid(float x) {
+  return 1.0f/(1.0f + exp(-x));
+}
+
+float sigmoid_grad(float x, float g) {
+  return g * sigmoid(x) * ( 1.0f - sigmoid(x));
+}
+
+ // same dimension add floating point op
+ __kernel void sigmoid_grad_fp(const int M, const int N, const int switch_op, __global const float *A, __global const float *B, __global float *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] = sigmoid_grad(A[globalRow * N + globalCol], B[globalRow * N + globalCol]);
+}
+
+ // 1D + Scalar floating point add op
+ __kernel void sigmoid_grad_c_fp(const int M, const int N, const int switch_op, __global const float *A, __global const float *B, __global float *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] = sigmoid_grad(A[globalRow * N + globalCol], B[0]);
+    } else {
+      C[globalRow * N + globalCol] = sigmoid_grad(B[0], A[globalRow * N + globalCol]);
+    }
+}
+
+ // 1D + Scalar floating point add op broadcast
+ __kernel void sigmoid_grad_b_fp(const int M, const int N, const int M2, const int N2, const int switch_op, __global const float *A, __global const float *B, __global float *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] = sigmoid_grad(A[globalRow * N + globalCol], B[b_m_index * N2 + b_n_index]);
+    } else {
+      C[globalRow * N + globalCol] = sigmoid_grad(B[b_m_index * N2 + b_n_index], A[globalRow * N + globalCol]);
+    }
+}