cumo 0.1.0

data/ext/cumo/narray/gen/tmpl/coerce_cast.c

@@ -0,0 +1,10 @@
+/*
+  return NArray with cast to the type of self.
+  @overload coerce_cast(type)
+  @return [nil]
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE type)
+{
+    return Qnil;
+}

data/ext/cumo/narray/gen/tmpl/complex_accum_kernel.cu

@@ -0,0 +1,129 @@
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+struct cumo_<%=type_name%>_sum_impl {
+    __device__ <%=dtype%> Identity() { return m_zero; }
+    __device__ dtype MapIn(dtype in, int64_t /*index*/) { return in; }
+    __device__ void Reduce(dtype next, <%=dtype%>& accum) { accum = m_add(next, accum); }
+    __device__ <%=dtype%> MapOut(<%=dtype%> accum) { return accum; }
+};
+
+struct cumo_<%=type_name%>_prod_impl {
+    __device__ <%=dtype%> Identity() { return m_one; }
+    __device__ dtype MapIn(dtype in, int64_t /*index*/) { return in; }
+    __device__ void Reduce(dtype next, <%=dtype%>& accum) { accum = m_mul(next, accum); }
+    __device__ <%=dtype%> MapOut(<%=dtype%> accum) { return accum; }
+};
+
+template<typename Iterator1>
+__global__ void cumo_<%=type_name%>_mean_kernel(Iterator1 p1_begin, Iterator1 p1_end, <%=dtype%>* p2, uint64_t n)
+{
+    dtype init = m_zero;
+    dtype sum = thrust::reduce(thrust::cuda::par, p1_begin, p1_end, init, cumo_thrust_plus());
+    *p2 = c_div_r(sum, n);
+}
+
+template<typename Iterator1>
+__global__ void cumo_<%=type_name%>_var_kernel(Iterator1 p1_begin, Iterator1 p1_end, rtype* p2)
+{
+    cumo_thrust_complex_variance_unary_op<dtype, rtype>  unary_op;
+    cumo_thrust_complex_variance_binary_op<dtype, rtype> binary_op;
+    cumo_thrust_complex_variance_data<dtype, rtype> init = {};
+    cumo_thrust_complex_variance_data<dtype, rtype> result;
+    result = thrust::transform_reduce(thrust::cuda::par, p1_begin, p1_end, unary_op, init, binary_op);
+    *p2 = result.variance();
+}
+
+template<typename Iterator1>
+__global__ void cumo_<%=type_name%>_stddev_kernel(Iterator1 p1_begin, Iterator1 p1_end, rtype* p2)
+{
+    cumo_thrust_complex_variance_unary_op<dtype, rtype>  unary_op;
+    cumo_thrust_complex_variance_binary_op<dtype, rtype> binary_op;
+    cumo_thrust_complex_variance_data<dtype, rtype> init = {};
+    cumo_thrust_complex_variance_data<dtype, rtype> result;
+    result = thrust::transform_reduce(thrust::cuda::par, p1_begin, p1_end, unary_op, init, binary_op);
+    *p2 = r_sqrt(result.variance());
+}
+
+template<typename Iterator1>
+__global__ void cumo_<%=type_name%>_rms_kernel(Iterator1 p1_begin, Iterator1 p1_end, rtype* p2, uint64_t n)
+{
+    rtype init = 0;
+    rtype result;
+    result = thrust::transform_reduce(thrust::cuda::par, p1_begin, p1_end, cumo_thrust_square(), init, thrust::plus<rtype>());
+    *p2 = r_sqrt(result/n);
+}
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+void cumo_<%=type_name%>_sum_kernel_launch(na_reduction_arg_t* arg)
+{
+    cumo_reduce<dtype, <%=dtype%>, cumo_<%=type_name%>_sum_impl>(*arg, cumo_<%=type_name%>_sum_impl{});
+}
+
+void cumo_<%=type_name%>_prod_kernel_launch(na_reduction_arg_t* arg)
+{
+    cumo_reduce<dtype, <%=dtype%>, cumo_<%=type_name%>_prod_impl>(*arg, cumo_<%=type_name%>_prod_impl{});
+}
+
+void cumo_<%=type_name%>_mean_kernel_launch(uint64_t n, char *p1, ssize_t s1, char *p2)
+{
+    ssize_t s1_idx = s1 / sizeof(dtype);
+    thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
+    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
+    if (s1_idx == 1) {
+        cumo_<%=type_name%>_mean_kernel<<<1,1>>>(data_begin, data_end, (dtype*)p2, n);
+    } else {
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
+        cumo_<%=type_name%>_mean_kernel<<<1,1>>>(range.begin(), range.end(), (dtype*)p2, n);
+    }
+}
+
+void cumo_<%=type_name%>_var_kernel_launch(uint64_t n, char *p1, ssize_t s1, char *p2)
+{
+    ssize_t s1_idx = s1 / sizeof(dtype);
+    thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
+    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
+    if (s1_idx == 1) {
+        cumo_<%=type_name%>_var_kernel<<<1,1>>>(data_begin, data_end, (rtype*)p2);
+    } else {
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
+        cumo_<%=type_name%>_var_kernel<<<1,1>>>(range.begin(), range.end(), (rtype*)p2);
+    }
+}
+
+void cumo_<%=type_name%>_stddev_kernel_launch(uint64_t n, char *p1, ssize_t s1, char *p2)
+{
+    ssize_t s1_idx = s1 / sizeof(dtype);
+    thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
+    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
+    if (s1_idx == 1) {
+        cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(data_begin, data_end, (rtype*)p2);
+    } else {
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
+        cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(range.begin(), range.end(), (rtype*)p2);
+    }
+}
+
+void cumo_<%=type_name%>_rms_kernel_launch(uint64_t n, char *p1, ssize_t s1, char *p2)
+{
+    ssize_t s1_idx = s1 / sizeof(dtype);
+    thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
+    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
+    if (s1_idx == 1) {
+        cumo_<%=type_name%>_rms_kernel<<<1,1>>>(data_begin, data_end, (rtype*)p2, n);
+    } else {
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
+        cumo_<%=type_name%>_rms_kernel<<<1,1>>>(range.begin(), range.end(), (rtype*)p2, n);
+    }
+}
+

data/ext/cumo/narray/gen/tmpl/cond_binary.c

@@ -0,0 +1,68 @@
+<% unless type_name == 'robject' %>
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, BIT_DIGIT *a3, size_t p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n);
+<% end %>
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2;
+    BIT_DIGIT *a3;
+    size_t  p3;
+    ssize_t s1, s2, s3;
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR_BIT(lp, 2, a3, p3, s3);
+    <% if type_name == 'robject' %>
+    {
+        dtype x, y;
+        BIT_DIGIT b;
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            GET_DATA_STRIDE(p2,s2,dtype,y);
+            b = (m_<%=name%>(x,y)) ? 1:0;
+            STORE_BIT(a3,p3,b);
+            p3+=s3;
+        }
+    }
+    <% else %>
+    {
+        <%="cumo_#{c_iter}_stride_kernel_launch"%>(p1,p2,a3,p3,s1,s2,s3,i);
+    }
+    <% end %>
+}
+
+static VALUE
+<%=c_func%>_self(VALUE self, VALUE other)
+{
+    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{cumo_cBit,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 1, ain, aout };
+
+    return na_ndloop(&ndf, 2, self, other);
+}
+
+/*
+  Comparison <%=name%> other.
+  @overload <%=op_map%> other
+  @param [Cumo::NArray,Numeric] other
+  @return [Cumo::Bit] result of self <%=name%> other.
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE other)
+{
+    <% if is_object %>
+    return <%=c_func%>_self(self, other);
+    <% else %>
+    VALUE klass, v;
+    klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
+    if (klass==cT) {
+        return <%=c_func%>_self(self, other);
+    } else {
+        v = rb_funcall(klass, id_cast, 1, self);
+        return rb_funcall(v, <%=id_op%>, 1, other);
+    }
+    <% end %>
+}

data/ext/cumo/narray/gen/tmpl/cond_binary_kernel.cu

@@ -0,0 +1,18 @@
+<% unless type_name == 'robject' %>
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char *p1, char *p2, BIT_DIGIT *a3, size_t p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        dtype x = *(dtype*)(p1+(i*s1));
+        dtype y = *(dtype*)(p2+(i*s2));
+        BIT_DIGIT b = (m_<%=name%>(x,y)) ? 1:0;
+        STORE_BIT(a3,p3+(i*s3),b);
+    }
+}
+
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *p1, char *p2, BIT_DIGIT *a3, size_t p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,a3,p3,s1,s2,s3,n);
+}
+<% end %>

data/ext/cumo/narray/gen/tmpl/cond_unary.c

@@ -0,0 +1,46 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t    i;
+    char     *p1;
+    BIT_DIGIT *a2;
+    size_t    p2;
+    ssize_t   s1, s2;
+    size_t   *idx1;
+    dtype     x;
+    BIT_DIGIT b;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR_BIT(lp, 1, a2, p2, s2);
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    if (idx1) {
+        for (; i--;) {
+            GET_DATA_INDEX(p1,idx1,dtype,x);
+            b = (m_<%=name%>(x)) ? 1:0;
+            STORE_BIT(a2,p2,b);
+            p2+=s2;
+        }
+    } else {
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            b = (m_<%=name%>(x)) ? 1:0;
+            STORE_BIT(a2,p2,b);
+            p2+=s2;
+        }
+    }
+}
+
+/*
+  Condition of <%=name%>.
+  @overload <%=name%>
+  @return [Cumo::Bit] Condition of <%=name%>.
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{cumo_cBit,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 1, ain, aout };
+
+    return na_ndloop(&ndf, 1, self);
+}

data/ext/cumo/narray/gen/tmpl/cum.c

@@ -0,0 +1,50 @@
+<% (is_float ? ["","_nan"] : [""]).each do |j| %>
+static void
+<%=c_iter%><%=j%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1, *p2;
+    ssize_t  s1, s2;
+    dtype    x, y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    //printf("i=%lu p1=%lx s1=%lu p2=%lx s2=%lu\n",i,(size_t)p1,s1,(size_t)p2,s2);
+
+    GET_DATA_STRIDE(p1,s1,dtype,x);
+    SET_DATA_STRIDE(p2,s2,dtype,x);
+    //printf("i=%lu x=%f\n",i,x);
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=j%>", "<%=type_name%>");
+    for (i--; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,y);
+        m_<%=name%><%=j%>(x,y);
+        SET_DATA_STRIDE(p2,s2,dtype,x);
+        //printf("i=%lu x=%f\n",i,x);
+    }
+}
+<% end %>
+
+/*
+  <%=name%> of self.
+  @overload <%=name%>(axis:nil, nan:false)
+  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
+  @return [Cumo::<%=class_name%>] <%=name%> of self.
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE reduce;
+    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP|NDF_FLAT_REDUCE|NDF_CUM,
+                     2, 1, ain, aout };
+
+  <% if is_float %>
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_nan);
+  <% else %>
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+  <% end %>
+    return na_ndloop(&ndf, 2, self, reduce);
+}

data/ext/cumo/narray/gen/tmpl/each.c

@@ -0,0 +1,47 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, s1;
+    char *p1;
+    size_t *idx1;
+    dtype x;
+    VALUE y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    if (idx1) {
+        for (; i--;) {
+            GET_DATA_INDEX(p1,idx1,dtype,x);
+            y = m_data_to_num(x);
+            rb_yield(y);
+        }
+    } else {
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            y = m_data_to_num(x);
+            rb_yield(y);
+        }
+    }
+}
+
+/*
+  Calls the given block once for each element in self,
+  passing that element as a parameter.
+  @overload <%=name%>
+  @return [Cumo::NArray] self
+  For a block {|x| ... }
+  @yield [x]  x is element of NArray.
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};
+
+    na_ndloop(&ndf, 1, self);
+    return self;
+}

data/ext/cumo/narray/gen/tmpl/each_with_index.c

@@ -0,0 +1,70 @@
+static inline void
+yield_each_with_index(dtype x, size_t *c, VALUE *a, int nd, int md)
+{
+    int j;
+
+    a[0] = m_data_to_num(x);
+    for (j=0; j<=nd; j++) {
+        a[j+1] = SIZET2NUM(c[j]);
+    }
+    rb_yield(rb_ary_new4(md,a));
+}
+
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, s1;
+    char *p1;
+    size_t *idx1;
+    dtype x;
+    VALUE *a;
+    size_t *c;
+    int nd, md;
+
+    c = (size_t*)(lp->opt_ptr);
+    nd = lp->ndim;
+    if (nd > 0) {nd--;}
+    md = nd + 2;
+    a = ALLOCA_N(VALUE,md);
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    c[nd] = 0;
+
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    if (idx1) {
+        for (; i--;) {
+            GET_DATA_INDEX(p1,idx1,dtype,x);
+            yield_each_with_index(x,c,a,nd,md);
+            c[nd]++;
+        }
+    } else {
+        for (; i--;) {
+            cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            yield_each_with_index(x,c,a,nd,md);
+            c[nd]++;
+        }
+    }
+}
+
+/*
+  Invokes the given block once for each element of self,
+  passing that element and indices along each axis as parameters.
+  @overload <%=name%>
+  @return [Cumo::NArray] self
+  For a block {|x,i,j,...| ... }
+  @yield [x,i,j,...]  x is an element, i,j,... are multidimensional indices.
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};
+
+    na_ndloop_with_index(&ndf, 1, self);
+    return self;
+}