cumo 0.2.4 → 0.2.5

data/ext/cumo/narray/array.c

@@ -117,10 +117,12 @@ static int cumo_na_mdai_object_type(int type, VALUE v)
     if (rb_obj_is_kind_of(v, rb_cRange)) {
         MDAI_ATTR_TYPE(type,v,begin);
         MDAI_ATTR_TYPE(type,v,end);
-    } else if (rb_obj_is_kind_of(v, cumo_na_cStep)) {
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+    } else if (rb_obj_is_kind_of(v, rb_cArithSeq)) {
         MDAI_ATTR_TYPE(type,v,begin);
         MDAI_ATTR_TYPE(type,v,end);
         MDAI_ATTR_TYPE(type,v,step);
+#endif
     } else {
         type = cumo_na_object_type(type,v);
     }
@@ -205,7 +207,11 @@ cumo_na_mdai_investigate(cumo_na_mdai_t *mdai, int ndim)
             }
         }
         else
-        if (rb_obj_is_kind_of(v, rb_cRange) || rb_obj_is_kind_of(v, cumo_na_cStep)) {
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+        if (rb_obj_is_kind_of(v, rb_cRange) || rb_obj_is_kind_of(v, rb_cArithSeq)) {
+#else
+        if (rb_obj_is_kind_of(v, rb_cRange) || rb_obj_is_kind_of(v, rb_cEnumerator)) {
+#endif
             cumo_na_step_sequence(v,&length,&dbeg,&dstep);
             len += length-1;
             mdai->type = cumo_na_mdai_object_type(mdai->type, v);

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

@@ -65,7 +65,11 @@ static void
         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, cumo_na_cStep)) {
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+                if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cArithSeq)) {
+#else
+                if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cEnumerator)) {
+#endif
                     cumo_na_step_sequence(x,&len,&beg,&step);
                     for (c=0; c<len && i<n; c++,i++) {
                         y = beg + step * c;
@@ -81,7 +85,11 @@ static void
         } 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, cumo_na_cStep)) {
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+                if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cArithSeq)) {
+#else
+                if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cEnumerator)) {
+#endif
                     cumo_na_step_sequence(x,&len,&beg,&step);
                     for (c=0; c<len && i<n; c++,i++) {
                         y = beg + step * c;
@@ -110,7 +118,11 @@ static void
         dtype* host_z = ALLOC_N(dtype, n);
         for (i=i1=0; i1<n1 && i<n; i1++) {
             x = ptr[i1];
-            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, cumo_na_cStep)) {
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cArithSeq)) {
+#else
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cEnumerator)) {
+#endif
                 cumo_na_step_sequence(x,&len,&beg,&step);
                 for (c=0; c<len && i<n; c++,i++) {
                     y = beg + step * c;

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

@@ -52,7 +52,11 @@ static void
     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, cumo_na_cStep)) {
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cArithSeq)) {
+#else
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cEnumerator)) {
+#endif
                 cumo_na_step_sequence(x,&len,&beg,&step);
                 for (c=0; c<len && i<n; c++,i++) {
                     y = beg + step * c;
@@ -69,7 +73,11 @@ static void
     } 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, cumo_na_cStep)) {
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cArithSeq)) {
+#else
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, rb_cEnumerator)) {
+#endif
                 cumo_na_step_sequence(x,&len,&beg,&step);
                 for (c=0; c<len && i<n; c++,i++) {
                     y = beg + step * c;

data/ext/cumo/narray/index.c

@@ -12,23 +12,6 @@
 #define cIndex cumo_cInt32
 #endif
 
-// from ruby/enumerator.c
-struct enumerator {
-    VALUE obj;
-    ID    meth;
-    VALUE args;
-    // use only above in this source
-    VALUE fib;
-    VALUE dst;
-    VALUE lookahead;
-    VALUE feedvalue;
-    VALUE stop_exc;
-    VALUE size;
-    // incompatible below depending on ruby version
-    //VALUE procs;                      // ruby 2.4
-    //rb_enumerator_size_func *size_fn; // ruby 2.1-2.4
-    //VALUE (*size_fn)(ANYARGS);        // ruby 2.0
-};
 
 // note: the memory refed by this pointer is not freed and causes memroy leak.
 //
@@ -204,6 +187,42 @@ cumo_na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, cumo_
     ssize_t beg, end, beg_orig, end_orig;
     const char *dot = "..", *edot = "...";
 
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+    rb_arithmetic_sequence_components_t x;
+    rb_arithmetic_sequence_extract(range, &x);
+    step = NUM2SSIZET(x.step);
+
+    beg = beg_orig = NUM2SSIZET(x.begin);
+    if (beg < 0) {
+        beg += size;
+    }
+    if (T_NIL == TYPE(x.end)) { // endless range
+        end = size -1;
+        if (RTEST(x.exclude_end)) {
+            dot = edot;
+        }
+    } else {
+        end = end_orig = NUM2SSIZET(x.end);
+        if (end < 0) {
+            end += size;
+        }
+        if (RTEST(x.exclude_end)) {
+            end--;
+            dot = edot;
+        }
+    }
+    if (beg < 0 || beg >= size || end < 0 || end >= size) {
+        if (T_NIL == TYPE(x.end)) { // endless range
+            rb_raise(rb_eRangeError,
+                     "%"SZF"d%s is out of range for size=%"SZF"d",
+                     beg_orig, dot, size);
+        } else {
+            rb_raise(rb_eRangeError,
+                     "%"SZF"d%s%"SZF"d is out of range for size=%"SZF"d",
+                     beg_orig, dot, end_orig, size);
+        }
+    }
+#else
     beg = beg_orig = NUM2SSIZET(rb_funcall(range,cumo_id_beg,0));
     if (beg < 0) {
         beg += size;
@@ -222,44 +241,59 @@ cumo_na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, cumo_
                  "%"SZF"d%s%"SZF"d is out of range for size=%"SZF"d",
                  beg_orig, dot, end_orig, size);
     }
+#endif
     n = (end-beg)/step+1;
     if (n<0) n=0;
     cumo_na_index_set_step(q,orig_dim,n,beg,step);
 
 }
 
-static void
-cumo_na_parse_enumerator(VALUE enum_obj, int orig_dim, ssize_t size, cumo_na_index_arg_t *q)
+void
+cumo_na_parse_enumerator_step(VALUE enum_obj, VALUE *pstep)
 {
     int len;
-    ssize_t step;
-    struct enumerator *e;
+    VALUE step;
+    cumo_enumerator_t *e;
 
     if (!RB_TYPE_P(enum_obj, T_DATA)) {
         rb_raise(rb_eTypeError,"wrong argument type (not T_DATA)");
     }
-    e = (struct enumerator *)DATA_PTR(enum_obj);
+    e = (cumo_enumerator_t *)DATA_PTR(enum_obj);
+
+    if (!rb_obj_is_kind_of(e->obj, rb_cRange)) {
+        rb_raise(rb_eTypeError,"not Range object");
+    }
 
-    if (rb_obj_is_kind_of(e->obj, rb_cRange)) {
-        if (e->meth == cumo_id_each) {
-            cumo_na_parse_range(e->obj, 1, orig_dim, size, q);
+    if (e->meth == cumo_id_each) {
+        step = INT2NUM(1);
+    }
+    else if (e->meth == cumo_id_step) {
+        if (TYPE(e->args) != T_ARRAY) {
+            rb_raise(rb_eArgError,"no argument for step");
         }
-        else if (e->meth == cumo_id_step) {
-            if (TYPE(e->args) != T_ARRAY) {
-                rb_raise(rb_eArgError,"no argument for step");
-            }
-            len = RARRAY_LEN(e->args);
-            if (len != 1) {
-                rb_raise(rb_eArgError,"invalid number of step argument (1 for %d)",len);
-            }
-            step = NUM2SSIZET(RARRAY_AREF(e->args,0));
-            cumo_na_parse_range(e->obj, step, orig_dim, size, q);
-        } else {
-            rb_raise(rb_eTypeError,"unknown Range method: %s",rb_id2name(e->meth));
+        len = RARRAY_LEN(e->args);
+        if (len != 1) {
+            rb_raise(rb_eArgError,"invalid number of step argument (1 for %d)",len);
         }
+        step = RARRAY_AREF(e->args,0);
     } else {
-        rb_raise(rb_eTypeError,"not Range object");
+        rb_raise(rb_eTypeError,"unknown Range method: %s",rb_id2name(e->meth));
     }
+    if (pstep) *pstep = step;
+}
+
+static void
+cumo_na_parse_enumerator(VALUE enum_obj, int orig_dim, ssize_t size, cumo_na_index_arg_t *q)
+{
+    VALUE step;
+    cumo_enumerator_t *e;
+
+    if (!RB_TYPE_P(enum_obj, T_DATA)) {
+        rb_raise(rb_eTypeError,"wrong argument type (not T_DATA)");
+    }
+    cumo_na_parse_enumerator_step(enum_obj, &step);
+    e = (cumo_enumerator_t *)DATA_PTR(enum_obj);
+    cumo_na_parse_range(e->obj, NUM2SSIZET(step), orig_dim, size, q); // e->obj : Range Object
 }
 
 // Analyze *a* which is *i*-th index object and store the information to q
@@ -316,14 +350,14 @@ cumo_na_index_parse_each(volatile VALUE a, ssize_t size, int i, cumo_na_index_ar
         if (rb_obj_is_kind_of(a, rb_cRange)) {
             cumo_na_parse_range(a, 1, i, size, q);
         }
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+        else if (rb_obj_is_kind_of(a, rb_cArithSeq)) {
+            cumo_na_parse_range(a, 1, i, size, q);
+        }
+#endif
         else if (rb_obj_is_kind_of(a, rb_cEnumerator)) {
             cumo_na_parse_enumerator(a, i, size, q);
         }
-        else if (rb_obj_is_kind_of(a, cumo_na_cStep)) {
-            ssize_t beg, step, n;
-            cumo_na_step_array_index(a, size, (size_t*)(&n), &beg, &step);
-            cumo_na_index_set_step(q,i,n,beg,step);
-        }
         // NArray index
         else if (CUMO_NA_CumoIsNArray(a)) {
             cumo_na_parse_narray_index(a, i, size, q);

data/ext/cumo/narray/narray.c

@@ -40,10 +40,12 @@ VALUE cumo_sym_option;
 VALUE cumo_sym_loop_opt;
 VALUE cumo_sym_init;
 
-VALUE cumo_na_cStep;
 #ifndef HAVE_RB_CCOMPLEX
 VALUE rb_cComplex;
 #endif
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+VALUE rb_cArithSeq;
+#endif
 
 int cumo_na_inspect_rows_=20;
 int cumo_na_inspect_cols_=80;
@@ -1512,7 +1514,11 @@ cumo_na_get_reduce_flag_from_axes(VALUE cumo_na_obj, VALUE axes)
             step = 0;
             //printf("beg=%d step=%d len=%d\n",beg,step,len);
         } else if (rb_obj_is_kind_of(v,rb_cRange) ||
-                   rb_obj_is_kind_of(v,cumo_na_cStep)) {
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+                   rb_obj_is_kind_of(v,rb_cArithSeq)) {
+#else
+                   rb_obj_is_kind_of(v,rb_cEnumerator)) {
+#endif
             cumo_na_step_array_index( v, ndim, &len, &beg, &step );
         } else {
             rb_raise(cumo_na_eDimensionError, "invalid dimension argument %s",
@@ -1849,6 +1855,9 @@ Init_cumo_narray()
     rb_require("complex");
     rb_cComplex = rb_const_get(rb_cObject, rb_intern("Complex"));
 #endif
+#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
+    rb_cArithSeq = rb_path2class("Enumerator::ArithmeticSequence");
+#endif
 
     rb_define_const(cNArray, "VERSION", rb_str_new2(CUMO_VERSION));
 

data/ext/cumo/narray/ndloop.c

@@ -1,5 +1,6 @@
 #include <ruby.h>
 #include "cumo.h"
+#include "cumo/indexer.h"
 #include "cumo/narray.h"
 #include "cumo/cuda/memory_pool.h"
 #include "cumo/cuda/runtime.h"
@@ -1164,11 +1165,48 @@ cumo_ndfunc_set_bufcp(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp)
     }
 }
 
+static cumo_na_iarray_stridx_t
+cumo_na_make_iarray_buffer_copy(cumo_na_buffer_copy_t* lp)
+{
+    cumo_na_iarray_stridx_t iarray;
+    int i;
+    int ndim = lp->ndim;
+    iarray.ptr = lp->src_ptr + lp->src_iter[0].pos;
+    for (i = 0; i < ndim; ++i) {
+        if (LITER_SRC(lp,i).idx) {
+            CUMO_SDX_SET_INDEX(iarray.stridx[i], LITER_SRC(lp,i).idx);
+        } else {
+            CUMO_SDX_SET_STRIDE(iarray.stridx[i], LITER_SRC(lp,i).step);
+        }
+    }
+    return iarray;
+}
+
+static cumo_na_indexer_t
+cumo_na_make_indexer_buffer_copy(cumo_na_buffer_copy_t* lp)
+{
+    cumo_na_indexer_t indexer;
+    int i;
+    indexer.ndim = lp->ndim;
+    indexer.total_size = 1;
+    for (i = 0; i< lp->ndim; ++i) {
+        indexer.shape[i] = lp->n[i];
+        indexer.total_size *= lp->n[i];
+    }
+    return indexer;
+}
+
+void cumo_ndloop_copy_to_buffer_kernel_launch(cumo_na_iarray_stridx_t *a, cumo_na_indexer_t* indexer, char *buf, size_t elmsz);
 
 // Make contiguous memory for ops not supporting index or stride (step) loop
 static void
 ndloop_copy_to_buffer(cumo_na_buffer_copy_t *lp)
 {
+    cumo_na_iarray_stridx_t a = cumo_na_make_iarray_buffer_copy(lp);
+    cumo_na_indexer_t indexer = cumo_na_make_indexer_buffer_copy(lp);
+    cumo_ndloop_copy_to_buffer_kernel_launch(&a, &indexer, lp->buf_ptr, lp->elmsz);
+
+#if 0
     size_t *c;
     char *src, *buf;
     int  i;
@@ -1230,11 +1268,19 @@ ndloop_copy_to_buffer(cumo_na_buffer_copy_t *lp)
  loop_end:
     ;
     DBG(printf("]\n"));
+#endif
 }
 
+void cumo_ndloop_copy_from_buffer_kernel_launch(cumo_na_iarray_stridx_t *a, cumo_na_indexer_t* indexer, char *buf, size_t elmsz);
+
 static void
 ndloop_copy_from_buffer(cumo_na_buffer_copy_t *lp)
 {
+    cumo_na_iarray_stridx_t a = cumo_na_make_iarray_buffer_copy(lp);
+    cumo_na_indexer_t indexer = cumo_na_make_indexer_buffer_copy(lp);
+    cumo_ndloop_copy_from_buffer_kernel_launch(&a, &indexer, lp->buf_ptr, lp->elmsz);
+
+#if 0
     size_t *c;
     char *src, *buf;
     int  i;
@@ -1291,12 +1337,14 @@ ndloop_copy_from_buffer(cumo_na_buffer_copy_t *lp)
         for (;;) {
             if (i<=0) goto loop_end;
             i--;
-            if (++c[i] < lp->n[i]) break;
+            ++c[i];
+            if (c[i] < lp->n[i]) break;
             c[i] = 0;
         }
     }
  loop_end:
     DBG(printf("]\n"));
+#endif
 }
 
 

data/ext/cumo/narray/ndloop_kernel.cu

@@ -0,0 +1,97 @@
+#include "cumo/narray_kernel.h"
+#include "cumo/indexer.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#define CUMO_NDLOOP_COPY_FROM_BUFFER_KERNEL(NDIM) \
+__global__ void cumo_ndloop_copy_from_buffer_kernel_dim##NDIM( \
+        cumo_na_iarray_stridx_t a, cumo_na_indexer_t indexer, char *buf, size_t elmsz) { \
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < indexer.total_size; i += blockDim.x * gridDim.x) { \
+        cumo_na_indexer_set_dim##NDIM(&indexer, i); \
+        char* p = cumo_na_iarray_stridx_at_dim##NDIM(&a, &indexer); \
+        memcpy(p, buf + i * elmsz, elmsz); \
+    } \
+}
+
+#define CUMO_NDLOOP_COPY_TO_BUFFER_KERNEL(NDIM) \
+__global__ void cumo_ndloop_copy_to_buffer_kernel_dim##NDIM( \
+        cumo_na_iarray_stridx_t a, cumo_na_indexer_t indexer, char *buf, size_t elmsz) { \
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < indexer.total_size; i += blockDim.x * gridDim.x) { \
+        cumo_na_indexer_set_dim##NDIM(&indexer, i); \
+        char* p = cumo_na_iarray_stridx_at_dim##NDIM(&a, &indexer); \
+        memcpy(buf + i * elmsz, p, elmsz); \
+    } \
+}
+
+CUMO_NDLOOP_COPY_FROM_BUFFER_KERNEL(1)
+CUMO_NDLOOP_COPY_FROM_BUFFER_KERNEL(2)
+CUMO_NDLOOP_COPY_FROM_BUFFER_KERNEL(3)
+CUMO_NDLOOP_COPY_FROM_BUFFER_KERNEL(4)
+CUMO_NDLOOP_COPY_FROM_BUFFER_KERNEL()
+
+CUMO_NDLOOP_COPY_TO_BUFFER_KERNEL(1)
+CUMO_NDLOOP_COPY_TO_BUFFER_KERNEL(2)
+CUMO_NDLOOP_COPY_TO_BUFFER_KERNEL(3)
+CUMO_NDLOOP_COPY_TO_BUFFER_KERNEL(4)
+CUMO_NDLOOP_COPY_TO_BUFFER_KERNEL()
+
+#undef CUMO_NDLOOP_COPY_FROM_BUFFER_KERNEL
+#undef CUMO_NDLOOP_COPY_TO_BUFFER_KERNEL
+
+void cumo_ndloop_copy_from_buffer_kernel_launch(cumo_na_iarray_stridx_t *a, cumo_na_indexer_t* indexer, char *buf, size_t elmsz)
+{
+    size_t grid_dim = cumo_get_grid_dim(indexer->total_size);
+    size_t block_dim = cumo_get_block_dim(indexer->total_size);
+    switch (indexer->ndim) {
+        case 1:
+            cumo_ndloop_copy_from_buffer_kernel_dim1<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+        case 2:
+            cumo_ndloop_copy_from_buffer_kernel_dim2<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+        case 3:
+            cumo_ndloop_copy_from_buffer_kernel_dim3<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+        case 4:
+            cumo_ndloop_copy_from_buffer_kernel_dim4<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+        default:
+            cumo_ndloop_copy_from_buffer_kernel_dim<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+    }
+}
+
+void cumo_ndloop_copy_to_buffer_kernel_launch(cumo_na_iarray_stridx_t *a, cumo_na_indexer_t* indexer, char *buf, size_t elmsz)
+{
+    size_t grid_dim = cumo_get_grid_dim(indexer->total_size);
+    size_t block_dim = cumo_get_block_dim(indexer->total_size);
+    switch (indexer->ndim) {
+        case 1:
+            cumo_ndloop_copy_to_buffer_kernel_dim1<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+        case 2:
+            cumo_ndloop_copy_to_buffer_kernel_dim2<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+        case 3:
+            cumo_ndloop_copy_to_buffer_kernel_dim3<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+        case 4:
+            cumo_ndloop_copy_to_buffer_kernel_dim4<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+        default:
+            cumo_ndloop_copy_to_buffer_kernel_dim<<<grid_dim, block_dim>>>(*a,*indexer,buf,elmsz);
+            break;
+    }
+}
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif