cumo 0.1.0

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

@@ -0,0 +1,14 @@
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v;
+
+    v = <%=find_tmpl("any?").c_func%>(argc,argv,self);
+
+    if (v==Qtrue) {
+        return Qfalse;
+    } else if (v==Qfalse) {
+        return Qtrue;
+    }
+    return <%=find_tmpl("not").c_func%>(v);
+}

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

@@ -0,0 +1,108 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, n;
+    size_t i1, n1;
+    VALUE  v1, *ptr;
+    BIT_DIGIT *a1;
+    size_t p1;
+    size_t s1, *idx1;
+    VALUE  x;
+    double y;
+    BIT_DIGIT z;
+    size_t len, c;
+    double beg, step;
+
+    // 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);
+    v1 = lp->args[1].value;
+    i = 0;
+
+    if (lp->args[1].ptr) {
+        if (v1 == Qtrue) {
+            iter_<%=type_name%>_store_<%=type_name%>(lp);
+            i = lp->args[1].shape[0];
+            if (idx1) {
+                idx1 += i;
+            } else {
+                p1 += s1 * i;
+            }
+        }
+        goto loop_end;
+    }
+
+    ptr = &v1;
+
+    switch(TYPE(v1)) {
+    case T_ARRAY:
+        n1 = RARRAY_LEN(v1);
+        ptr = RARRAY_PTR(v1);
+        break;
+    case T_NIL:
+        n1 = 0;
+        break;
+    default:
+        n1 = 1;
+    }
+
+    if (idx1) {
+        for (i=i1=0; i1<n1 && i<n; i++,i1++) {
+            x = ptr[i1];
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, na_cStep)) {
+                nary_step_sequence(x,&len,&beg,&step);
+                for (c=0; c<len && i<n; c++,i++) {
+                    y = beg + step * c;
+                    z = m_from_double(y);
+                    STORE_BIT(a1, p1+*idx1, z); idx1++;
+                }
+            }
+            if (TYPE(x) != T_ARRAY) {
+                if (x == Qnil) x = INT2FIX(0);
+                z = m_num_to_data(x);
+                STORE_BIT(a1, p1+*idx1, z); idx1++;
+            }
+        }
+    } else {
+        for (i=i1=0; i1<n1 && i<n; i++,i1++) {
+            x = ptr[i1];
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, na_cStep)) {
+                nary_step_sequence(x,&len,&beg,&step);
+                for (c=0; c<len && i<n; c++,i++) {
+                    y = beg + step * c;
+                    z = m_from_double(y);
+                    STORE_BIT(a1, p1, z); p1+=s1;
+                }
+            }
+            if (TYPE(x) != T_ARRAY) {
+                z = m_num_to_data(x);
+                STORE_BIT(a1, p1, z); p1+=s1;
+            }
+        }
+    }
+
+ loop_end:
+    z = m_zero;
+    if (idx1) {
+        for (; i<n; i++) {
+            STORE_BIT(a1, p1+*idx1, z); idx1++;
+        }
+    } else {
+        for (; i<n; i++) {
+            STORE_BIT(a1, p1, z); p1+=s1;
+        }
+    }
+}
+
+static VALUE
+<%=c_func(:nodef)%>(VALUE self, VALUE rary)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0}, {rb_cArray,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2, 0, ain, 0};
+
+    na_ndloop_store_rarray(&ndf, self, rary);
+    return self;
+}

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

@@ -0,0 +1,70 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  n;
+    size_t  p1, p3;
+    ssize_t s1, s3;
+    size_t *idx1, *idx3;
+    int     o1, l1, r1, len;
+    BIT_DIGIT *a1, *a3;
+    BIT_DIGIT  x;
+
+    // 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, a3, p3, s3, idx3);
+    INIT_PTR_BIT_IDX(lp, 1, a1, p1, s1, idx1);
+    if (s1!=1 || s3!=1 || idx1 || idx3) {
+        for (; n--;) {
+            LOAD_BIT_STEP(a1, p1, s1, idx1, x);
+            STORE_BIT_STEP(a3, p3, s3, idx3, x);
+        }
+    } else {
+        o1 =  p1 % NB;
+        o1 -= p3;
+        l1 =  NB+o1;
+        r1 =  NB-o1;
+        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++;
+            *a3 = (x & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            a3++;
+            n -= len;
+        }
+        if (o1==0) {
+            for (; n>=NB; n-=NB) {
+                x = *(a1++);
+                *(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++;
+                *(a3++) = x;
+            }
+        }
+        if (n>0) {
+            x = *a1>>o1;
+            if (o1<0)  x |= *(a1-1)>>l1;
+            *a3 = (x & SLB(n)) | (*a3 & BALL<<n);
+        }
+    }
+}
+
+static VALUE
+<%=c_func(:nodef)%>(VALUE self, VALUE obj)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2,0, ain,0};
+
+    na_ndloop(&ndf, 2, self, obj);
+    return self;
+}

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

@@ -0,0 +1,60 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    ssize_t  i, s1, s2;
+    size_t   p1;
+    char    *p2;
+    size_t  *idx1, *idx2;
+    <%=dtype%> x;
+    BIT_DIGIT *a1;
+    BIT_DIGIT  y;
+
+    // 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_IDX(lp, 1, p2, s2, idx2);
+
+    if (idx2) {
+        if (idx1) {
+            for (; i--;) {
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                STORE_BIT(a1, p1+*idx1, y); idx1++;
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                STORE_BIT(a1, p1, y); p1+=s1;
+            }
+        }
+    } else {
+        if (idx1) {
+            for (; i--;) {
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                STORE_BIT(a1, p1+*idx1, y); idx1++;
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                STORE_BIT(a1, p1, y); p1+=s1;
+            }
+        }
+    }
+}
+
+
+static VALUE
+<%=c_func(:nodef)%>(VALUE self, VALUE obj)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2,0, ain,0};
+
+    na_ndloop(&ndf, 2, self, obj);
+    return self;
+}

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

@@ -0,0 +1,47 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t     i;
+    BIT_DIGIT *a1;
+    size_t     p1;
+    ssize_t    s1;
+    size_t    *idx1;
+    BIT_DIGIT  x=0;
+    VALUE      a, 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);
+    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 = m_data_to_num(x);
+            rb_ary_push(a,y);
+        }
+    } else {
+        for (; i--;) {
+            LOAD_BIT(a1,p1,x); p1+=s1;
+            y = m_data_to_num(x);
+            rb_ary_push(a,y);
+        }
+    }
+}
+
+/*
+  Convert self to Array.
+  @overload <%=name%>
+  @return [Array]
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    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};
+
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
+}

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

@@ -0,0 +1,81 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  n;
+    size_t  p1, p3;
+    ssize_t s1, s3;
+    size_t *idx1, *idx3;
+    int     o1, l1, r1, len;
+    BIT_DIGIT *a1, *a3;
+    BIT_DIGIT  x;
+    BIT_DIGIT  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, a3, p3, s3, idx3);
+    if (s1!=1 || s3!=1 || idx1 || idx3) {
+        for (; n--;) {
+            LOAD_BIT_STEP(a1, p1, s1, idx1, x);
+            y = m_<%=name%>(x);
+            STORE_BIT_STEP(a3, p3, s3, idx3, y);
+        }
+    } else {
+        o1 =  p1 % NB;
+        o1 -= p3;
+        l1 =  NB+o1;
+        r1 =  NB-o1;
+        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++;
+            y = m_<%=name%>(x);
+            *a3 = (y & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            a3++;
+            n -= len;
+        }
+        if (o1==0) {
+            for (; n>=NB; n-=NB) {
+                x = *(a1++);
+                y = m_<%=name%>(x);
+                *(a3++) = y;
+            }
+        } 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 = m_<%=name%>(x);
+                *(a3++) = y;
+            }
+        }
+        if (n>0) {
+            x = *a1>>o1;
+            if (o1<0)  x |= *(a1-1)>>l1;
+            y = m_<%=name%>(x);
+            *a3 = (y & SLB(n)) | (*a3 & BALL<<n);
+        }
+    }
+}
+
+/*
+  Unary <%=name%>.
+  @overload <%=name%>
+  @return [Cumo::<%=class_name%>] <%=name%> of self.
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,1, ain,aout};
+
+    return na_ndloop(&ndf, 1, self);
+}

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

@@ -0,0 +1,90 @@
+typedef struct {
+    size_t count;
+    char  *idx0;
+    char  *idx1;
+    size_t elmsz;
+} where_opt_t;
+
+#define STORE_INT(ptr, esz, x) memcpy(ptr,&(x),esz)
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    BIT_DIGIT *a;
+    size_t  p;
+    ssize_t s;
+    size_t *idx;
+    BIT_DIGIT x=0;
+    char   *idx1;
+    size_t  count;
+    size_t  e;
+    where_opt_t *g;
+
+    // TODO(sonots): CUDA kernelize
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    g = (where_opt_t*)(lp->opt_ptr);
+    count = g->count;
+    idx1  = g->idx1;
+    e     = g->elmsz;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a, p, s, idx);
+    if (idx) {
+        for (; i--;) {
+            LOAD_BIT(a, p+*idx, x);
+            idx++;
+            if (x!=0) {
+                STORE_INT(idx1,e,count);
+                idx1 += e;
+            }
+            count++;
+        }
+    } else {
+        for (; i--;) {
+            LOAD_BIT(a, p, x);
+            p+=s;
+            if (x!=0) {
+                STORE_INT(idx1,e,count);
+                idx1 += e;
+            }
+            count++;
+        }
+    }
+    g->count = count;
+    g->idx1  = idx1;
+}
+
+/*
+  Returns the array of index where the bit is one (true).
+  @overload <%=op_map%>
+  @return [Cumo::Int32,Cumo::Int64]
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    volatile VALUE idx_1;
+    size_t size, n_1;
+    where_opt_t *g;
+
+    ndfunc_arg_in_t ain[1] = {{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 0, ain, 0 };
+
+    size = RNARRAY_SIZE(self);
+    n_1 = NUM2SIZET(<%=find_tmpl("count_true_cpu").c_func%>(0, NULL, self));
+    g = ALLOCA_N(where_opt_t,1);
+    g->count = 0;
+    if (size>4294967295ul) {
+        idx_1 = nary_new(cumo_cInt64, 1, &n_1);
+        g->elmsz = 8;
+    } else {
+        idx_1 = nary_new(cumo_cInt32, 1, &n_1);
+        g->elmsz = 4;
+    }
+    g->idx1 = na_get_pointer_for_write(idx_1);
+    g->idx0 = NULL;
+    na_ndloop3(&ndf, g, 1, self);
+    na_release_lock(idx_1);
+    return idx_1;
+}