cumo 0.1.0

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

@@ -0,0 +1,86 @@
+<% indexer_ops = %w[sum prod min max ptp] %>
+<% (is_float ? ["","_nan"] : [""]).each do |nan| %>
+
+<% unless type_name == 'robject' %>
+//<% unless indexer_ops.include?(name) %>
+void cumo_<%=type_name%>_<%=name%><%=nan%>_kernel_launch(size_t n, char *p1, ssize_t s1, char *p2);
+<% else %>
+void cumo_<%=type_name%>_<%=name%><%=nan%>_kernel_launch(na_reduction_arg_t* arg);
+<% end %>
+<% end %>
+
+static void
+<%=c_iter%><%=nan%>(na_loop_t *const lp)
+{
+    <% if type_name == 'robject' || name == 'kahan_sum' || nan == '_nan' %>
+    {
+        size_t   n;
+        char    *p1, *p2;
+        ssize_t  s1;
+
+        INIT_COUNTER(lp, n);
+        INIT_PTR(lp, 0, p1, s1);
+        p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
+
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=nan%>", "<%=type_name%>");
+        *(<%=dtype%>*)p2 = f_<%=name%><%=nan%>(n,p1,s1);
+    }
+    //<% elsif !indexer_ops.include?(name) %>
+    {
+        size_t   n;
+        char    *p1, *p2;
+        ssize_t  s1;
+
+        INIT_COUNTER(lp, n);
+        INIT_PTR(lp, 0, p1, s1);
+        p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
+
+        cumo_<%=type_name%>_<%=name%><%=nan%>_kernel_launch(n,p1,s1,p2);
+    }
+    <% else %>
+    {
+        // TODO(sonots): How to compute Kahan summation algorithm in parallel?
+        // TODO(sonots): Implement nan CUDA version
+        na_reduction_arg_t arg = na_make_reduction_arg(lp);
+        cumo_<%=type_name%>_<%=name%><%=nan%>_kernel_launch(&arg);
+    }
+    <% end %>
+}
+<% end %>
+
+/*
+  <%=name%> of self.
+<% if is_float %>
+  @overload <%=name%>(axis:nil, keepdims:false, nan:false)
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
+<% else %>
+  @overload <%=name%>(axis:nil, keepdims:false)
+<% end %>
+  @param [Numeric,Array,Range] axis (keyword) Affected dimensions.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
+  @return [Cumo::<%=class_name%>] returns result of <%=name%>.
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v, reduce;
+    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{<%=result_class%>,0}};
+    //<% if type_name == 'robject' || !indexer_ops.include?(name) %>
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };
+    <% else %>
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_INDEXER_LOOP, 2, 1, ain, aout };
+    <% end %>
+
+  <% 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 %>
+    v =  na_ndloop(&ndf, 2, self, reduce);
+  <% if result_class == "cT" %>
+    return <%=type_name%>_extract(v);
+  <% else %>
+    return rb_funcall(v,rb_intern("extract"),0);
+  <% end %>
+}

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

@@ -0,0 +1,121 @@
+//<% (is_float ? ["","_nan"] : [""]).each do |nan| %>
+
+<% unless type_name == 'robject' %>
+void <%="cumo_#{type_name}_#{name}#{nan}_reduce_kernel_launch"%>(char *p1, char *p2, char *p3, ssize_t s1, ssize_t s2, uint64_t n);
+void <%="cumo_#{type_name}_#{name}#{nan}_kernel_launch"%>(char *p1, char *p2, char *p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n);
+<% end %>
+
+static void
+<%=c_iter%><%=nan%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+
+    <% if type_name == 'robject' %>
+    {
+        size_t i;
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=nan%>", "<%=type_name%>");
+        if (s3==0) {
+            dtype z;
+            // Reduce loop
+            GET_DATA(p3,dtype,z);
+            for (i=0; i<n; i++) {
+                dtype x, y;
+                GET_DATA_STRIDE(p1,s1,dtype,x);
+                GET_DATA_STRIDE(p2,s2,dtype,y);
+                m_<%=name%><%=nan%>(x,y,z);
+            }
+            SET_DATA(p3,dtype,z);
+            return;
+        } else {
+            for (i=0; i<n; i++) {
+                dtype x, y, z;
+                GET_DATA_STRIDE(p1,s1,dtype,x);
+                GET_DATA_STRIDE(p2,s2,dtype,y);
+                GET_DATA(p3,dtype,z);
+                m_<%=name%><%=nan%>(x,y,z);
+                SET_DATA_STRIDE(p3,s3,dtype,z);
+            }
+        }
+    }
+    <% else %>
+    {
+        if (s3==0) {
+            <%="cumo_#{type_name}_#{name}#{nan}_reduce_kernel_launch"%>(p1,p2,p3,s1,s2,n);
+            return;
+        } else {
+            <%="cumo_#{type_name}_#{name}#{nan}_kernel_launch"%>(p1,p2,p3,s1,s2,s3,n);
+        }
+    }
+    <% end %>
+}
+//<% end %>
+
+static VALUE
+<%=c_func%>_self(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v, reduce;
+    VALUE naryv[2];
+    ndfunc_arg_in_t ain[4] = {{cT,0},{cT,0},{sym_reduce,0},{sym_init,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP, 4, 1, ain, aout };
+
+    if (argc < 1) {
+        rb_raise(rb_eArgError,"wrong number of arguments (%d for >=1)",argc);
+    }
+    // should fix below: [self.ndim,other.ndim].max or?
+    naryv[0] = self;
+    naryv[1] = argv[0];
+    //<% if is_float %>
+    reduce = na_reduce_dimension(argc-1, argv+1, 2, naryv, &ndf, <%=c_iter%>_nan);
+    //<% else %>
+    reduce = na_reduce_dimension(argc-1, argv+1, 2, naryv, &ndf, 0);
+    //<% end %>
+
+    v =  na_ndloop(&ndf, 4, self, argv[0], reduce, m_<%=name%>_init);
+    return <%=type_name%>_extract(v);
+}
+
+/*
+  Binary <%=name%>.
+
+<% if is_float %>
+  @overload <%=op_map%>(other, axis:nil, keepdims:false, nan:false)
+<% else %>
+  @overload <%=op_map%>(other, axis:nil, keepdims:false)
+<% end %>
+  @param [Cumo::NArray,Numeric] other
+  @param [Numeric,Array,Range] axis (keyword) Affected dimensions.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
+<% if is_float %>
+  @param [TrueClass] nan (keyword) If true, apply NaN-aware algorithm (avoid NaN if exists).
+<% end %>
+  @return [Cumo::NArray] <%=name%> of self and other.
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    //<% if !is_object %>
+    VALUE klass, v;
+    //<% end %>
+    if (argc < 1) {
+        rb_raise(rb_eArgError,"wrong number of arguments (%d for >=1)",argc);
+    }
+    //<% if is_object %>
+    return <%=c_func%>_self(argc, argv, self);
+    //<% else %>
+    klass = na_upcast(CLASS_OF(self),CLASS_OF(argv[0]));
+    if (klass==cT) {
+        return <%=c_func%>_self(argc, argv, self);
+    } else {
+        v = rb_funcall(klass, id_cast, 1, self);
+        return rb_funcall2(v, rb_intern("<%=name%>"), argc, argv);
+    }
+    //<% end %>
+}

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

@@ -0,0 +1,61 @@
+<% unless defined?($cumo_narray_gen_tmpl_accum_binary_kernel_included) %>
+<% $cumo_narray_gen_tmpl_accum_binary_kernel_included = 1 %>
+
+<% unless type_name == 'robject' %>
+//<% (is_float ? ["","_nan"] : [""]).each do |nan| %>
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+template<typename Iterator1, typename Iterator2>
+__global__ void <%="cumo_#{type_name}_mulsum#{nan}_reduce_kernel"%>(Iterator1 p1_begin, Iterator1 p1_end, Iterator2 p2_begin, dtype* p3)
+{
+    dtype init = m_zero;
+    *p3 = thrust::inner_product(thrust::cuda::par, p1_begin, p1_end, p2_begin, init, cumo_thrust_plus(), cumo_thrust_multiplies<%= "_mulsum#{nan}" unless nan.empty? %>());
+}
+
+__global__ void <%="cumo_#{type_name}_mulsum#{nan}_kernel"%>(char *p1, char *p2, char *p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
+{
+    for (size_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        m_<%=name%><%=nan%>(*(dtype*)(p1+(i*s1)), *(dtype*)(p2+(i*s2)), *(dtype*)(p3+(i*s3)));
+    }
+}
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+void <%="cumo_#{type_name}_mulsum#{nan}_reduce_kernel_launch"%>(char *p1, char *p2, char *p3, ssize_t s1, ssize_t s2, uint64_t n)
+{
+    ssize_t s1_idx = s1 / sizeof(dtype);
+    ssize_t s2_idx = s2 / sizeof(dtype);
+    thrust::device_ptr<dtype> p1_begin = thrust::device_pointer_cast((dtype*)p1);
+    thrust::device_ptr<dtype> p1_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
+    thrust::device_ptr<dtype> p2_begin = thrust::device_pointer_cast((dtype*)p2);
+    thrust::device_ptr<dtype> p2_end   = thrust::device_pointer_cast(((dtype*)p2) + n * s2_idx);
+    if (s1_idx > 1 || s2_idx > 1) {
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> r1(p1_begin, p1_end, s1_idx);
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> r2(p2_begin, p2_end, s2_idx);
+        <%="cumo_#{type_name}_mulsum#{nan}_reduce_kernel"%><<<1,1>>>(r1.begin(), r1.end(), r2.begin(), (dtype*)p3);
+    } else {
+        // ref. https://github.com/thrust/thrust/blob/master/examples/cuda/async_reduce.cu
+        <%="cumo_#{type_name}_mulsum#{nan}_reduce_kernel"%><<<1,1>>>(p1_begin, p1_end, p2_begin, (dtype*)p3);
+    }
+}
+
+void <%="cumo_#{type_name}_mulsum#{nan}_kernel_launch"%>(char *p1, char *p2, char *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_#{type_name}_mulsum#{nan}_kernel"%><<<gridDim, blockDim>>>(p1,p2,p3,s1,s2,s3,n);
+}
+//<% end %>
+<% end %>
+<% end %>

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

@@ -0,0 +1,119 @@
+<% (is_float ? ["","_nan"] : [""]).each do |nan| %>
+
+<%   [64,32].each do |i| %>
+<% unless type_name == 'robject' %>
+void cumo_<%=type_name%>_<%=name%><%=nan%>_int<%=i%>_kernel_launch(na_reduction_arg_t* arg);
+<% end %>
+
+#define idx_t int<%=i%>_t
+static void
+<%=c_iter%>_index<%=i%><%=nan%>(na_loop_t *const lp)
+{
+    // TODO(sonots): Support nan in CUDA
+    <% if type_name == 'robject' || nan == '_nan' %>
+    {
+        size_t   n, idx;
+        char    *d_ptr, *i_ptr, *o_ptr;
+        ssize_t  d_step, i_step;
+
+        INIT_COUNTER(lp, n);
+        INIT_PTR(lp, 0, d_ptr, d_step);
+        INIT_PTR(lp, 1, i_ptr, i_step);
+        o_ptr = NDL_PTR(lp,2);
+
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=nan%>", "<%=type_name%>");
+        idx = f_<%=name%><%=nan%>(n,d_ptr,d_step);
+        *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
+    }
+    <% else %>
+    {
+        na_reduction_arg_t arg = na_make_reduction_arg(lp);
+        cumo_<%=type_name%>_<%=name%><%=nan%>_int<%=i%>_kernel_launch(&arg);
+    }
+    <% end %>
+}
+#undef idx_t
+<% end;end %>
+
+/*
+  <%=name%>. Return an index of result.
+<% if is_float %>
+  @overload <%=name%>(axis:nil, nan:false)
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision if exist).
+<% else %>
+  @overload <%=name%>(axis:nil)
+<% end %>
+  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @return [Integer,Cumo::Int] returns result index of <%=name%>.
+  @example
+      Cumo::NArray[3,4,1,2].min_index => 3
+ */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    //<% if type_name == 'robject' %>
+    {
+        narray_t *na;
+        VALUE idx, reduce;
+        ndfunc_arg_in_t ain[3] = {{Qnil,0},{Qnil,0},{sym_reduce,0}};
+        ndfunc_arg_out_t aout[1] = {{0,0,0}};
+        ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 3,1, ain,aout};
+
+        GetNArray(self,na);
+        if (na->ndim==0) {
+            return INT2FIX(0);
+        }
+        if (na->size > (~(u_int32_t)0)) {
+            aout[0].type = cumo_cInt64;
+            idx = nary_new(cumo_cInt64, na->ndim, na->shape);
+            ndf.func = <%=c_iter%>_index64;
+            <% if is_float %>
+            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index64_nan);
+            <% else %>
+            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            <% end %>
+        } else {
+            aout[0].type = cumo_cInt32;
+            idx = nary_new(cumo_cInt32, na->ndim, na->shape);
+            ndf.func = <%=c_iter%>_index32;
+            <% if is_float %>
+            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index32_nan);
+            <% else %>
+            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            <% end %>
+        }
+        rb_funcall(idx, rb_intern("seq"), 0);
+
+        return na_ndloop(&ndf, 3, self, idx, reduce);
+    }
+    <% else %>
+    {
+        narray_t *na;
+        VALUE reduce;
+        ndfunc_arg_in_t ain[2] = {{Qnil,0},{sym_reduce,0}};
+        ndfunc_arg_out_t aout[1] = {{0,0,0}};
+        ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT|NDF_INDEXER_LOOP, 2,1, ain,aout};
+
+        GetNArray(self,na);
+        if (na->size > (~(u_int32_t)0)) {
+            aout[0].type = cumo_cInt64;
+            ndf.func = <%=c_iter%>_index64;
+            <% if is_float %>
+            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index64_nan);
+            <% else %>
+            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            <% end %>
+        } else {
+            aout[0].type = cumo_cInt32;
+            ndf.func = <%=c_iter%>_index32;
+            <% if is_float %>
+            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index32_nan);
+            <% else %>
+            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            <% end %>
+        }
+
+        return na_ndloop(&ndf, 2, self, reduce);
+    }
+    <% end %>
+}

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

@@ -0,0 +1,66 @@
+<% unless defined?($cumo_narray_gen_tmpl_accum_index_kernel_included) %>
+<% $cumo_narray_gen_tmpl_accum_index_kernel_included = 1 %>
+<% unless type_name == 'robject' %>
+
+<%   [64,32].each do |i| %>
+#define idx_t int<%=i%>_t
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+struct cumo_<%=type_name%>_min_index_int<%=i%>_impl {
+    struct MinAndArgMin {
+        dtype min;
+        idx_t argmin;
+    };
+    __device__ MinAndArgMin Identity() { return {DATA_MAX, 0}; }
+    __device__ MinAndArgMin MapIn(dtype in, idx_t index) { return {in, index}; }
+    __device__ void Reduce(MinAndArgMin next, MinAndArgMin& accum) {
+        if (accum.min > next.min) {
+            accum = next;
+        }
+    }
+    __device__ idx_t MapOut(MinAndArgMin accum) { return accum.argmin; }
+};
+
+struct cumo_<%=type_name%>_max_index_int<%=i%>_impl {
+    struct MaxAndArgMax {
+        dtype max;
+        idx_t argmax;
+    };
+    __device__ MaxAndArgMax Identity() { return {DATA_MIN, 0}; }
+    __device__ MaxAndArgMax MapIn(dtype in, idx_t index) { return {in, index}; }
+    __device__ void Reduce(MaxAndArgMax next, MaxAndArgMax& accum) {
+        if (accum.max < next.max) {
+            accum = next;
+        }
+    }
+    __device__ idx_t MapOut(MaxAndArgMax accum) { return accum.argmax; }
+};
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+void cumo_<%=type_name%>_min_index_int<%=i%>_kernel_launch(na_reduction_arg_t* arg)
+{
+    cumo_reduce<dtype, idx_t, cumo_<%=type_name%>_min_index_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_min_index_int<%=i%>_impl{});
+}
+
+void cumo_<%=type_name%>_max_index_int<%=i%>_kernel_launch(na_reduction_arg_t* arg)
+{
+    cumo_reduce<dtype, idx_t, cumo_<%=type_name%>_max_index_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_max_index_int<%=i%>_impl{});
+}
+
+#undef idx_t
+<% end %>
+
+<% end %>
+<% end %>