cumo 0.1.0

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

@@ -0,0 +1,48 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i;
+    BIT_DIGIT *a1, x=0;
+    size_t   p1;
+    ssize_t  s1;
+    size_t  *idx1;
+    VALUE  y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    if (idx1) {
+        for (; i--;) {
+            LOAD_BIT(a1, p1+*idx1, x); idx1++;
+            y = m_data_to_num(x);
+            rb_yield(y);
+        }
+    } else {
+        for (; i--;) {
+            LOAD_BIT(a1, p1, x); p1+=s1;
+            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_bit/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;
+    BIT_DIGIT *a1, x=0;
+    size_t   p1;
+    ssize_t  s1;
+    size_t  *idx1;
+
+    VALUE *a;
+    size_t *c;
+    int nd, md;
+
+    c = (size_t*)(lp->opt_ptr);
+    nd = lp->ndim - 1;
+    md = lp->ndim + 1;
+    a = ALLOCA_N(VALUE,md);
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    c[nd] = 0;
+
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    if (idx1) {
+        for (; i--;) {
+            LOAD_BIT(a1, p1+*idx1, x); idx1++;
+            yield_each_with_index(x,c,a,nd,md);
+            c[nd]++;
+        }
+    } else {
+        for (; i--;) {
+            LOAD_BIT(a1, p1, x); p1+=s1;
+            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;
+}

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

@@ -0,0 +1,30 @@
+/*
+  Extract an element only if self is a dimensionless NArray.
+  @overload extract
+  @return [Numeric,Cumo::NArray]
+  --- Extract element value as Ruby Object if self is a dimensionless NArray,
+  otherwise returns self.
+*/
+
+// TODO(sonots): Return Cumo::Bit instead of ruby built-in object to avoid synchronization
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    BIT_DIGIT *ptr, val;
+    size_t pos;
+    narray_t *na;
+    GetNArray(self,na);
+
+    if (na->ndim==0) {
+        pos = na_get_offset(self);
+        ptr = (BIT_DIGIT*)na_get_pointer_for_read(self);
+
+        SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+        val = ((*((ptr)+(pos)/NB)) >> ((pos)%NB)) & 1u;
+        na_release_lock(self);
+        return INT2FIX(val);
+    }
+    return self;
+}

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

@@ -0,0 +1,29 @@
+/*
+  Extract an element only if self is a dimensionless NArray.
+  @overload extract_cpu
+  @return [Numeric,Cumo::NArray]
+  --- Extract element value as Ruby Object if self is a dimensionless NArray,
+  otherwise returns self.
+*/
+
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    BIT_DIGIT *ptr, val;
+    size_t pos;
+    narray_t *na;
+    GetNArray(self,na);
+
+    if (na->ndim==0) {
+        pos = na_get_offset(self);
+        ptr = (BIT_DIGIT*)na_get_pointer_for_read(self);
+
+        SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+        val = ((*((ptr)+(pos)/NB)) >> ((pos)%NB)) & 1u;
+        na_release_lock(self);
+        return INT2FIX(val);
+    }
+    return self;
+}

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

@@ -0,0 +1,69 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  n;
+    size_t  p3;
+    ssize_t s3;
+    size_t *idx3;
+    int     len;
+    BIT_DIGIT *a3;
+    BIT_DIGIT  y;
+    VALUE x = lp->option;
+
+    // TODO(sonots): CUDA kernelize
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    if (x==INT2FIX(0) || x==Qfalse) {
+        y = 0;
+    } else
+    if (x==INT2FIX(1) || x==Qtrue) {
+        y = ~(BIT_DIGIT)0;
+    } else {
+        rb_raise(rb_eArgError, "invalid value for Bit");
+    }
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR_BIT_IDX(lp, 0, a3, p3, s3, idx3);
+    if (idx3) {
+        y = y&1;
+        for (; n--;) {
+            STORE_BIT(a3, p3+*idx3, y); idx3++;
+        }
+    } else if (s3!=1) {
+        y = y&1;
+        for (; n--;) {
+            STORE_BIT(a3, p3, y); p3+=s3;
+        }
+    } else {
+        if (p3>0 || n<NB) {
+            len = NB - p3;
+            if ((int)n<len) len=n;
+            *a3 = (y & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            a3++;
+            n -= len;
+        }
+        for (; n>=NB; n-=NB) {
+            *(a3++) = y;
+        }
+        if (n>0) {
+            *a3 = (y & SLB(n)) | (*a3 & BALL<<n);
+        }
+    }
+}
+
+/*
+  Fill elements with other.
+  @overload <%=name%> other
+  @param [Numeric] other
+  @return [Cumo::<%=class_name%>] self.
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE val)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_option}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2,0, ain,0};
+
+    na_ndloop(&ndf, 2, self, val);
+    return self;
+}

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

@@ -0,0 +1,64 @@
+static VALUE
+format_<%=type_name%>(VALUE fmt, dtype x)
+{
+    if (NIL_P(fmt)) {
+        char s[4];
+        int n;
+        n = m_sprintf(s,x);
+        return rb_str_new(s,n);
+    }
+    return rb_funcall(fmt, '%', 1, m_data_to_num(x));
+}
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    BIT_DIGIT *a1, x=0;
+    size_t     p1;
+    char      *p2;
+    ssize_t    s1, s2;
+    size_t    *idx1;
+    VALUE  y;
+    VALUE  fmt = lp->option;
+
+    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 (idx1) {
+        for (; i--;) {
+            LOAD_BIT(a1, p1+*idx1, x); idx1++;
+            y = format_<%=type_name%>(fmt, x);
+            SET_DATA_STRIDE(p2, s2, VALUE, y);
+        }
+    } else {
+        for (; i--;) {
+            LOAD_BIT(a1, p1, x); p1+=s1;
+            y = format_<%=type_name%>(fmt, x);
+            SET_DATA_STRIDE(p2, s2, VALUE, y);
+        }
+    }
+}
+
+/*
+  Format elements into strings.
+  @overload <%=name%> format
+  @param [String] format
+  @return [Cumo::RObject] array of formated strings.
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE fmt=Qnil;
+
+    ndfunc_arg_in_t ain[2] = {{Qnil,0},{sym_option}};
+    ndfunc_arg_out_t aout[1] = {{cumo_cRObject,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 2,1, ain,aout};
+
+    rb_scan_args(argc, argv, "01", &fmt);
+    return na_ndloop(&ndf, 2, self, fmt);
+}

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

@@ -0,0 +1,51 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    BIT_DIGIT *a1, x=0;
+    size_t     p1;
+    ssize_t    s1;
+    size_t   *idx1;
+    VALUE y;
+    VALUE fmt = lp->option;
+    volatile VALUE a;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    a = rb_ary_new2(i);
+    rb_ary_push(lp->args[1].value, a);
+    if (idx1) {
+        for (; i--;) {
+            LOAD_BIT(a1, p1+*idx1, x); idx1++;
+            y = format_bit(fmt, x);
+            rb_ary_push(a,y);
+        }
+    } else {
+        for (; i--;) {
+            LOAD_BIT(a1, p1, x); p1+=s1;
+            y = format_bit(fmt, x);
+            rb_ary_push(a,y);
+        }
+    }
+}
+
+/*
+  Format elements into strings.
+  @overload <%=name%> format
+  @param [String] format
+  @return [Array] array of formated strings.
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE fmt=Qnil;
+    ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
+    ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 3,1, ain,aout};
+
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    rb_scan_args(argc, argv, "01", &fmt);
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);
+}

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

@@ -0,0 +1,21 @@
+static VALUE
+<%=c_iter%>(char *ptr, size_t pos, VALUE fmt)
+{
+    dtype x;
+    LOAD_BIT(ptr,pos,x);
+    return format_<%=type_name%>(fmt, x);
+}
+
+/*
+  Returns a string containing a human-readable representation of NArray.
+  @overload inspect
+  @return [String]
+*/
+static VALUE
+<%=c_func(0)%>(VALUE ary)
+{
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    return na_ndloop_inspect(ary, <%=c_iter%>, Qnil);
+}

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

@@ -0,0 +1,136 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    BIT_DIGIT *a;
+    size_t  p1, p2;
+    ssize_t s1, s2;
+    size_t *idx1, *idx2, *pidx;
+    BIT_DIGIT x=0;
+    size_t  count;
+    where_opt_t *g;
+
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    g = (where_opt_t*)(lp->opt_ptr);
+    count = g->count;
+    pidx  = (size_t*)(g->idx1);
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a, p1, s1, idx1);
+    //INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+    p2 = lp->args[1].iter[0].pos;
+    s2 = lp->args[1].iter[0].step;
+    idx2 = lp->args[1].iter[0].idx;
+
+    if (idx1) {
+        if (idx2) {
+            for (; i--;) {
+                LOAD_BIT(a, p1+*idx1, x);
+                idx1++;
+                if (x) {
+                    *(pidx++) = p2+*idx2;
+                    count++;
+                }
+                idx2++;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a, p1+*idx1, x);
+                idx1++;
+                if (x) {
+                    *(pidx++) = p2;
+                    count++;
+                }
+                p2 += s2;
+            }
+        }
+    } else {
+        if (idx2) {
+            for (; i--;) {
+                LOAD_BIT(a, p1, x);
+                p1 += s1;
+                if (x) {
+                    *(pidx++) = p2+*idx2;
+                    count++;
+                }
+                idx2++;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a, p1, x);
+                p1 += s1;
+                if (x) {
+                    *(pidx++) = p2;
+                    count++;
+                }
+                p2 += s2;
+            }
+        }
+    }
+    g->count = count;
+    g->idx1  = (char*)pidx;
+}
+
+#if   SIZEOF_VOIDP == 8
+#define cIndex cumo_cInt64
+#elif SIZEOF_VOIDP == 4
+#define cIndex cumo_cInt32
+#endif
+
+/*
+  Return subarray of argument masked with self bit array.
+  @overload <%=op_map%>(array)
+  @param [Cumo::NArray] array  narray to be masked.
+  @return [Cumo::NArray]  view of masked array.
+*/
+static VALUE
+<%=c_func(1)%>(VALUE mask, VALUE val)
+{
+    volatile VALUE idx_1, view;
+    narray_data_t *nidx;
+    narray_view_t *nv;
+    narray_t      *na;
+    narray_view_t *na1;
+    stridx_t stridx0;
+    size_t n_1;
+    where_opt_t g;
+    ndfunc_arg_in_t ain[2] = {{cT,0},{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2, 0, ain, 0};
+
+    // TODO(sonots): bit_count_true synchronizes with CPU. Avoid.
+    n_1 = NUM2SIZET(<%=find_tmpl("count_true_cpu").c_func%>(0, NULL, mask));
+    idx_1 = nary_new(cIndex, 1, &n_1);
+    g.count = 0;
+    g.elmsz = SIZEOF_VOIDP;
+    g.idx1 = na_get_pointer_for_write(idx_1);
+    g.idx0 = NULL;
+    na_ndloop3(&ndf, &g, 2, mask, val);
+
+    view = na_s_allocate_view(CLASS_OF(val));
+    GetNArrayView(view, nv);
+    na_setup_shape((narray_t*)nv, 1, &n_1);
+
+    GetNArrayData(idx_1,nidx);
+    SDX_SET_INDEX(stridx0,(size_t*)nidx->ptr);
+    nidx->ptr = NULL;
+
+    nv->stridx = ALLOC_N(stridx_t,1);
+    nv->stridx[0] = stridx0;
+    nv->offset = 0;
+
+    GetNArray(val, na);
+    switch(NA_TYPE(na)) {
+    case NARRAY_DATA_T:
+        nv->data = val;
+        break;
+    case NARRAY_VIEW_T:
+        GetNArrayView(val, na1);
+        nv->data = na1->data;
+        break;
+    default:
+        rb_raise(rb_eRuntimeError,"invalid NA_TYPE: %d",NA_TYPE(na));
+    }
+
+    return view;
+}