cumo 0.1.0

data/ext/cumo/narray/gen/tmpl_bit/binary.c

@@ -0,0 +1,98 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  n;
+    size_t  p1, p2, p3;
+    ssize_t s1, s2, s3;
+    size_t *idx1, *idx2, *idx3;
+    int     o1, o2, l1, l2, r1, r2, len;
+    BIT_DIGIT *a1, *a2, *a3;
+    BIT_DIGIT  x, y;
+
+    // TODO(sonots): CUDA kernelize
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
+    INIT_PTR_BIT_IDX(lp, 2, a3, p3, s3, idx3);
+    if (s1!=1 || s2!=1 || s3!=1 || idx1 || idx2 || idx3) {
+        for (; n--;) {
+            LOAD_BIT_STEP(a1, p1, s1, idx1, x);
+            LOAD_BIT_STEP(a2, p2, s2, idx2, y);
+            x = m_<%=name%>(x,y);
+            STORE_BIT_STEP(a3, p3, s3, idx3, x);
+        }
+    } else {
+        o1 =  p1 % NB;
+        o1 -= p3;
+        o2 =  p2 % NB;
+        o2 -= p3;
+        l1 =  NB+o1;
+        r1 =  NB-o1;
+        l2 =  NB+o2;
+        r2 =  NB-o2;
+        if (p3>0 || n<NB) {
+            len = NB - p3;
+            if ((int)n<len) len=n;
+            if (o1>=0) x = *a1>>o1;
+            else       x = *a1<<-o1;
+            if (p1+len>NB)  x |= *(a1+1)<<r1;
+            a1++;
+            if (o2>=0) y = *a2>>o2;
+            else       y = *a2<<-o2;
+            if (p2+len>NB)  y |= *(a2+1)<<r2;
+            a2++;
+            x = m_<%=name%>(x,y);
+            *a3 = (x & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            a3++;
+            n -= len;
+        }
+        if (o1==0 && o2==0) {
+            for (; n>=NB; n-=NB) {
+                x = *(a1++);
+                y = *(a2++);
+                x = m_<%=name%>(x,y);
+                *(a3++) = x;
+            }
+        } else {
+            for (; n>=NB; n-=NB) {
+                x = *a1>>o1;
+                if (o1<0)  x |= *(a1-1)>>l1;
+                if (o1>0)  x |= *(a1+1)<<r1;
+                a1++;
+                y = *a2>>o2;
+                if (o2<0)  y |= *(a2-1)>>l2;
+                if (o2>0)  y |= *(a2+1)<<r2;
+                a2++;
+                x = m_<%=name%>(x,y);
+                *(a3++) = x;
+            }
+        }
+        if (n>0) {
+            x = *a1>>o1;
+            if (o1<0)  x |= *(a1-1)>>l1;
+            y = *a2>>o2;
+            if (o2<0)  y |= *(a2-1)>>l2;
+            x = m_<%=name%>(x,y);
+            *a3 = (x & SLB(n)) | (*a3 & BALL<<n);
+        }
+    }
+}
+
+/*
+  Binary <%=name%>.
+  @overload <%=op_map%> other
+  @param [Cumo::NArray,Numeric] other
+  @return [Cumo::NArray] <%=name%> of self and other.
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE other)
+{
+    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 1, ain, aout };
+
+    return na_ndloop(&ndf, 2, self, other);
+}

data/ext/cumo/narray/gen/tmpl_bit/bit_count.c

@@ -0,0 +1,64 @@
+#undef int_t
+#define int_t uint64_t
+
+void <%="cumo_#{c_iter}_index_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, size_t *idx1, uint64_t n);
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, ssize_t s1, uint64_t n);
+void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, size_t *idx1, ssize_t s2, uint64_t n);
+void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, ssize_t s1, ssize_t s2, uint64_t n);
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    BIT_DIGIT *a1;
+    size_t  p1;
+    char   *p2;
+    ssize_t s1, s2;
+    size_t *idx1;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    INIT_PTR(lp, 1, p2, s2);
+
+    if (s2==0) {
+        if (idx1) {
+            <%="cumo_#{c_iter}_index_kernel_launch"%>(p1,p2,a1,idx1,i);
+        } else {
+            <%="cumo_#{c_iter}_stride_kernel_launch"%>(p1,p2,a1,s1,i);
+        }
+    } else {
+        if (idx1) {
+            <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(p1,p2,a1,idx1,s2,i);
+        } else {
+            <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(p1,p2,a1,s1,s2,i);
+        }
+    }
+}
+
+static VALUE
+<%=c_func(-1)%>_cpu(int argc, VALUE *argv, VALUE self);
+
+/*
+  Returns the number of bits.
+  If argument is supplied, return Int-array counted along the axes.
+  @overload <%=op_map%>(axis:nil, keepdims:false)
+  @param [Integer,Array,Range] axis (keyword) axes to be counted.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
+  @return [Cumo::UInt64]
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    if (cumo_compatible_mode_enabled_p()) {
+        return <%=c_func(-1)%>_cpu(argc, argv, self);
+    } else {
+        VALUE v, reduce;
+        ndfunc_arg_in_t ain[3] = {{cT,0},{sym_reduce,0},{sym_init,0}};
+        ndfunc_arg_out_t aout[1] = {{cumo_cUInt64,0}};
+        ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 3, 1, ain, aout };
+
+        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+        v = na_ndloop(&ndf, 3, self, reduce, INT2FIX(0));
+        return v;
+    }
+}

data/ext/cumo/narray/gen/tmpl_bit/bit_count_cpu.c

@@ -0,0 +1,88 @@
+#undef int_t
+#define int_t int64_t
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    BIT_DIGIT *a1;
+    size_t  p1;
+    char   *p2;
+    ssize_t s1, s2;
+    size_t *idx1;
+    BIT_DIGIT x=0;
+    int_t   y;
+
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    INIT_PTR(lp, 1, p2, s2);
+    if (s2==0) {
+        GET_DATA(p2, int_t, y);
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a1, p1+*idx1, x);
+                idx1++;
+                if (m_<%=name%>(x)) {
+                    y++;
+                }
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a1, p1, x);
+                p1 += s1;
+                if (m_<%=name%>(x)) {
+                    y++;
+                }
+            }
+        }
+        *(int_t*)p2 = y;
+    } else {
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a1, p1+*idx1, x);
+                idx1++;
+                if (m_<%=name%>(x)) {
+                    GET_DATA(p2, int_t, y);
+                    y++;
+                    SET_DATA(p2, int_t, y);
+                }
+                p2+=s2;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a1, p1, x);
+                p1+=s1;
+                if (m_<%=name%>(x)) {
+                    GET_DATA(p2, int_t, y);
+                    y++;
+                    SET_DATA(p2, int_t, y);
+                }
+                p2+=s2;
+            }
+        }
+    }
+}
+
+/*
+  Returns the number of bits.
+  If argument is supplied, return Int-array counted along the axes.
+  @overload <%=op_map%>(axis:nil, keepdims:false)
+  @param [Integer,Array,Range] axis (keyword) axes to be counted.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
+  @return [Cumo::Int64]
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v, reduce;
+    ndfunc_arg_in_t ain[3] = {{cT,0},{sym_reduce,0},{sym_init,0}};
+    ndfunc_arg_out_t aout[1] = {{cumo_cInt64,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 3, 1, ain, aout };
+
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+    v = na_ndloop(&ndf, 3, self, reduce, INT2FIX(0));
+    return rb_funcall(v,rb_intern("extract_cpu"),0);
+}

data/ext/cumo/narray/gen/tmpl_bit/bit_count_kernel.cu

@@ -0,0 +1,76 @@
+#undef int_t
+#define int_t unsigned long long int
+
+__global__ void <%="cumo_#{c_iter}_index_kernel"%>(size_t p1, char* p2, BIT_DIGIT *a1, size_t *idx1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        BIT_DIGIT x=0;
+        LOAD_BIT(a1, p1 + idx1[i], x);
+        if (m_<%=name%>(x)) {
+            atomicAdd((int_t*)p2, (int_t)1);
+        }
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(size_t p1, char* p2, BIT_DIGIT *a1, ssize_t s1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        BIT_DIGIT x=0;
+        LOAD_BIT(a1, p1 + i * s1, x);
+        if (m_<%=name%>(x)) {
+            atomicAdd((int_t*)p2, (int_t)1);
+        }
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_index_stride_kernel"%>(size_t p1, char* p2, BIT_DIGIT *a1, size_t *idx1, ssize_t s2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        BIT_DIGIT x=0;
+        LOAD_BIT(a1, p1 + idx1[i], x);
+        if (m_<%=name%>(x)) {
+            atomicAdd((int_t*)(p2 + i * s2), (int_t)1);
+        }
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_stride_stride_kernel"%>(size_t p1, char* p2, BIT_DIGIT *a1, ssize_t s1, ssize_t s2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        BIT_DIGIT x=0;
+        LOAD_BIT(a1, p1 + i * s1, x);
+        if (m_<%=name%>(x)) {
+            atomicAdd((int_t*)(p2 + i * s2), (int_t)1);
+        }
+    }
+}
+
+void <%="cumo_#{c_iter}_index_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, size_t *idx1, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,a1,idx1,n);
+}
+
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, ssize_t s1, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,a1,s1,n);
+}
+
+void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, size_t *idx1, ssize_t s2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_index_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,a1,idx1,s2,n);
+}
+
+void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, ssize_t s1, ssize_t s2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,a1,s1,s2,n);
+}
+
+#undef int_t

data/ext/cumo/narray/gen/tmpl_bit/bit_reduce.c

@@ -0,0 +1,133 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t     i;
+    BIT_DIGIT *a1, *a2;
+    size_t     p1,  p2;
+    ssize_t    s1,  s2;
+    size_t    *idx1, *idx2;
+    BIT_DIGIT  x=0, y=0;
+
+    // TODO(sonots): CUDA kernelize
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
+    if (idx2) {
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a2, p2+*idx2, y);
+                if (y == <%=init_bit%>) {
+                    LOAD_BIT(a1, p1+*idx1, x);
+                    if (x != <%=init_bit%>) {
+                        STORE_BIT(a2, p2+*idx2, x);
+                    }
+                }
+                idx1++;
+                idx2++;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a2, p2+*idx2, y);
+                if (y == <%=init_bit%>) {
+                    LOAD_BIT(a1, p1, x);
+                    if (x != <%=init_bit%>) {
+                        STORE_BIT(a2, p2+*idx2, x);
+                    }
+                }
+                p1 += s1;
+                idx2++;
+            }
+        }
+    } else if (s2) {
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a2, p2, y);
+                if (y == <%=init_bit%>) {
+                    LOAD_BIT(a1, p1+*idx1, x);
+                    if (x != <%=init_bit%>) {
+                        STORE_BIT(a2, p2, x);
+                    }
+                }
+                idx1++;
+                p2 += s2;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a2, p2, y);
+                if (y == <%=init_bit%>) {
+                    LOAD_BIT(a1, p1, x);
+                    if (x != <%=init_bit%>) {
+                        STORE_BIT(a2, p2, x);
+                    }
+                }
+                p1 += s1;
+                p2 += s2;
+            }
+        }
+    } else {
+        LOAD_BIT(a2, p2, x);
+        if (x != <%=init_bit%>) {
+            return;
+        }
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a1, p1+*idx1, y);
+                if (y != <%=init_bit%>) {
+                    STORE_BIT(a2, p2, y);
+                    return;
+                }
+                idx1++;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a1, p1, y);
+                if (y != <%=init_bit%>) {
+                    STORE_BIT(a2, p2, y);
+                    return;
+                }
+                p1 += s1;
+            }
+        }
+    }
+}
+
+/*
+<% case name
+   when /^any/ %>
+  Return true if any of bits is one (true).
+<% when /^all/ %>
+  Return true if all of bits are one (true).
+<% end %>
+  If argument is supplied, return Bit-array reduced along the axes.
+  @overload <%=op_map%>(axis:nil, keepdims:false)
+  @param [Integer,Array,Range] axis (keyword) axes to be reduced.
+  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
+  @return [Cumo::Bit] .
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v, reduce;
+    ndfunc_arg_in_t ain[3] = {{cT,0},{sym_reduce,0},{sym_init,0}};
+    ndfunc_arg_out_t aout[1] = {{cumo_cBit,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 3,1, ain,aout};
+
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+    v = na_ndloop(&ndf, 3, self, reduce, INT2FIX(<%=init_bit%>));
+    if (argc > 0) {
+        return v;
+    }
+    v = <%=find_tmpl("extract").c_func%>(v);
+    switch (v) {
+    case INT2FIX(0):
+        return Qfalse;
+    case INT2FIX(1):
+        return Qtrue;
+    default:
+        rb_bug("unexpected result");
+        return v;
+    }
+}