cumo 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a909afef2849be43637539db86170d49f2063e53df43d90e4237b1b7857bb1b0
-  data.tar.gz: 831c2071af2e8ac4f5da2506d488d164f90358268dcd8b6b891dc549d387c38b
+  metadata.gz: ac2b9873bc48d45afcac57ff6e45ba84cc69ed1c61430cb13236a5c1ce018d0c
+  data.tar.gz: c001063b6a66de3055f98789420d5574b5b2d53357624dc6ffbe750ce2f727f1
 SHA512:
-  metadata.gz: fbc6727d8f2fe31292b36c1a962aae090c2ac9d00037b4b04f674ace1e99db49203141966d93cb1689830a66196dc6432ea90501cd70c57a4dff9f47374f1170
-  data.tar.gz: '096263752329c9dee63ddd22aaa1658b127c251b08997e728aa3b0304b3243937ba58ef7a2f3096eda5e2cd2afdbb40908bfdbb1169d8f0eec43ad1a76cb0511'
+  metadata.gz: f18aa1652ddd921ae91da6f75e28a5b9338091111a07b1cc97b586b19e0a755fcb195b2307626a27f95def01845629ed710786f12932888a14e7dcfc55b0d034
+  data.tar.gz: ed082b7188a9b517074eb78216fd0a15333ae84e7eeb271c6f7675d8c4bfecd0ef8ccf575017dfe450c75b85e5f275b801c11295e985be447cd9c08703601c86

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 0.2.2 (2018-11-13)
+
+Enhancements:
+
+* CUDA kernelize na\_index\_aref\_naview
+* CUDA kernelize na\_index\_aref\_nadata
+* CUDA kernelize diagonal
+* CUDA kernelize copy
+
 # 0.2.1 (2018-11-12)
 
 Enhancements:

data/ext/cumo/extconf.rb

@@ -66,8 +66,10 @@ narray/narray
 narray/array
 narray/step
 narray/index
+narray/index_kernel
 narray/ndloop
 narray/data
+narray/data_kernel
 narray/types/bit
 narray/types/int8
 narray/types/int16

data/ext/cumo/include/cumo.h

@@ -10,8 +10,8 @@ extern "C" {
 #endif
 #endif
 
-#define CUMO_VERSION "0.2.1"
-#define CUMO_VERSION_CODE 21
+#define CUMO_VERSION "0.2.2"
+#define CUMO_VERSION_CODE 22
 
 bool cumo_compatible_mode_enabled_p();
 bool cumo_show_warning_enabled_p();

data/ext/cumo/narray/data.c

@@ -53,15 +53,23 @@ static ID cumo_id_swap_byte;
     }                                              \
 }
 
-#define m_memcpy(src,dst) memcpy(dst,src,e)
+void cumo_iter_copy_bytes_kernel_launch(char *p1, char *p2, ssize_t s1, ssize_t s2, size_t *idx1, size_t *idx2, size_t n, int elmsz);
+// #define m_memcpy(src,dst) memcpy(dst,src,e)
+
 static void
 iter_copy_bytes(cumo_na_loop_t *const lp)
 {
-    size_t e;
-    e = lp->args[0].elmsz;
-    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("iter_copy_bytes", "any");
-    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-    LOOP_UNARY_PTR(lp,m_memcpy);
+    size_t  n;
+    ssize_t s1, s2;
+    char   *p1, *p2;
+    size_t *idx1, *idx2;
+    CUMO_INIT_COUNTER(lp, n);
+    CUMO_INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    CUMO_INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+    cumo_iter_copy_bytes_kernel_launch(p1, p2, s1, s2, idx1, idx2, n, lp->args[0].elmsz);
+    // size_t e;
+    // e = lp->args[0].elmsz;
+    // LOOP_UNARY_PTR(lp,m_memcpy);
 }
 
 VALUE
@@ -562,6 +570,10 @@ cumo_na_flatten(VALUE self)
 
 #define MIN(a,b) (((a)<(b))?(a):(b))
 
+void cumo_na_diagonal_index_index_kernel_launch(size_t *idx, size_t *idx0, size_t *idx1, size_t k0, size_t k1, uint64_t n);
+void cumo_na_diagonal_index_stride_kernel_launch(size_t *idx, size_t *idx0, ssize_t s1, size_t k0, size_t k1, uint64_t n);
+void cumo_na_diagonal_stride_index_kernel_launch(size_t *idx, ssize_t s0, size_t *idx1, size_t k0, size_t k1, uint64_t n);
+
 /*
   Returns a diagonal view of NArray
   @overload  diagonal([offset,axes])
@@ -601,7 +613,6 @@ static VALUE
 cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
 {
     int  i, k, nd;
-    size_t  j;
     size_t *idx0, *idx1, *diag_idx;
     size_t *shape;
     size_t  diag_size;
@@ -754,20 +765,12 @@ cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
             idx0 = CUMO_SDX_GET_INDEX(na1->stridx[ax[0]]);
             // diag_idx = ALLOC_N(size_t, diag_size);
             diag_idx = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*diag_size);
-
-            CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("na_diagonal", "any");
-            cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-
             if (CUMO_SDX_IS_INDEX(na1->stridx[ax[1]])) {
                 idx1 = CUMO_SDX_GET_INDEX(na1->stridx[ax[1]]);
-                for (j=0; j<diag_size; j++) {
-                    diag_idx[j] = idx0[j+k0] + idx1[j+k1];
-                }
+                cumo_na_diagonal_index_index_kernel_launch(diag_idx, idx0, idx1, k0, k1, diag_size);
             } else {
                 stride1 = CUMO_SDX_GET_STRIDE(na1->stridx[ax[1]]);
-                for (j=0; j<diag_size; j++) {
-                    diag_idx[j] = idx0[j+k0] + stride1*(j+k1);
-                }
+                cumo_na_diagonal_index_stride_kernel_launch(diag_idx, idx0, stride1, k0, k1, diag_size);
             }
             CUMO_SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
         } else {
@@ -776,13 +779,7 @@ cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
                 idx1 = CUMO_SDX_GET_INDEX(na1->stridx[ax[1]]);
                 // diag_idx = ALLOC_N(size_t, diag_size);
                 diag_idx = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*diag_size);
-
-                CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("na_diagonal", "any");
-                cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-
-                for (j=0; j<diag_size; j++) {
-                    diag_idx[j] = stride0*(j+k0) + idx1[j+k1];
-                }
+                cumo_na_diagonal_stride_index_kernel_launch(diag_idx, stride0, idx1, k0, k1, diag_size);
                 CUMO_SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
             } else {
                 stride1 = CUMO_SDX_GET_STRIDE(na1->stridx[ax[1]]);

data/ext/cumo/narray/data_kernel.cu

@@ -0,0 +1,75 @@
+#include "cumo/narray_kernel.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+__global__ void cumo_iter_copy_bytes_kernel(char *p1, char *p2, ssize_t s1, ssize_t s2, size_t *idx1, size_t *idx2, uint64_t n, ssize_t elmsz)
+{
+    char *p1_ = NULL;
+    char *p2_ = NULL;
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        p1_ = p1 + (idx1 ? idx1[i] : i * s1);
+        p2_ = p2 + (idx2 ? idx2[i] : i * s2);
+        memcpy(p2_, p1_, elmsz);
+    }
+}
+
+__global__ void cumo_na_diagonal_index_index_kernel(size_t *idx, size_t *idx0, size_t *idx1, size_t k0, size_t k1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] = idx0[i+k0] + idx1[i+k1];
+    }
+}
+
+__global__ void cumo_na_diagonal_index_stride_kernel(size_t *idx, size_t *idx0, ssize_t s1, size_t k0, size_t k1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] = idx0[i+k0] + s1*(i+k1);
+    }
+}
+
+__global__ void cumo_na_diagonal_stride_index_kernel(size_t *idx, ssize_t s0, size_t *idx1, size_t k0, size_t k1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] = s0*(i+k0) + idx1[i+k1];
+    }
+}
+
+void cumo_iter_copy_bytes_kernel_launch(char *p1, char *p2, ssize_t s1, ssize_t s2, size_t *idx1, size_t *idx2, uint64_t n, ssize_t elmsz)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_iter_copy_bytes_kernel<<<grid_dim, block_dim>>>(p1, p2, s1, s2, idx1, idx2, n, elmsz);
+}
+
+void cumo_na_diagonal_index_index_kernel_launch(size_t *idx, size_t *idx0, size_t *idx1, size_t k0, size_t k1, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_diagonal_index_index_kernel<<<grid_dim, block_dim>>>(idx, idx0, idx1, k0, k1, n);
+}
+
+void cumo_na_diagonal_index_stride_kernel_launch(size_t *idx, size_t *idx0, ssize_t s1, size_t k0, size_t k1, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_diagonal_index_stride_kernel<<<grid_dim, block_dim>>>(idx, idx0, s1, k0, k1, n);
+}
+
+void cumo_na_diagonal_stride_index_kernel_launch(size_t *idx, ssize_t s0, size_t *idx1, size_t k0, size_t k1, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_diagonal_stride_index_kernel<<<grid_dim, block_dim>>>(idx, s0, idx1, k0, k1, n);
+}
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif

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

@@ -130,6 +130,7 @@ static void
         r,
         swaptype,
         presorted;
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
  loop:SWAPINIT(a, es);
     if (n < 7)

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

@@ -9,6 +9,7 @@ static void
     CUMO_INIT_COUNTER(lp, n);
     CUMO_INIT_PTR(lp, 0, ptr, step);
     CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
     <%=type_name%>_qsort<%=j%>(ptr, n, step);
 }
 <% end %>

data/ext/cumo/narray/index.c

@@ -391,12 +391,14 @@ cumo_na_get_strides_nadata(const cumo_narray_data_t *na, ssize_t *strides, ssize
     }
 }
 
+void cumo_na_index_aref_nadata_index_stride_kernel_launch(size_t *idx, ssize_t s1, uint64_t n);
+
 static void
 cumo_na_index_aref_nadata(cumo_narray_data_t *na1, cumo_narray_view_t *na2,
                      cumo_na_index_arg_t *q, ssize_t elmsz, int ndim, int keep_dim)
 {
     int i, j;
-    ssize_t size, k, total=1;
+    ssize_t size, total=1;
     ssize_t stride1;
     ssize_t *strides_na1;
     size_t  *index;
@@ -425,15 +427,10 @@ cumo_na_index_aref_nadata(cumo_narray_data_t *na1, cumo_narray_view_t *na2,
 
         // array index
         if (q[i].idx != NULL) {
-            CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("na_index_aref_nadata", "any");
-            cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-
             index = q[i].idx;
             CUMO_SDX_SET_INDEX(na2->stridx[j],index);
             q[i].idx = NULL;
-            for (k=0; k<size; k++) {
-                index[k] = index[k] * stride1;
-            }
+            cumo_na_index_aref_nadata_index_stride_kernel_launch(index, stride1, size);
         } else {
             beg  = q[i].beg;
             step = q[i].step;
@@ -447,6 +444,11 @@ cumo_na_index_aref_nadata(cumo_narray_data_t *na1, cumo_narray_view_t *na2,
 }
 
 
+void cumo_na_index_aref_naview_index_index_kernel_launch(size_t *idx, size_t *idx1, uint64_t n);
+void cumo_na_index_aref_naview_index_stride_last_kernel_launch(size_t *idx, ssize_t s1, size_t last, uint64_t n);
+void cumo_na_index_aref_naview_index_stride_kernel_launch(size_t *idx, ssize_t s1, uint64_t n);
+void cumo_na_index_aref_naview_index_index_beg_step_kernel_launch(size_t *idx, size_t *idx1, size_t beg, ssize_t step, uint64_t n);
+
 static void
 cumo_na_index_aref_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
                      cumo_na_index_arg_t *q, ssize_t elmsz, int ndim, int keep_dim)
@@ -481,64 +483,41 @@ cumo_na_index_aref_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
         }
         else if (q[i].idx != NULL && CUMO_SDX_IS_INDEX(sdx1)) {
             // index <- index
-            int k;
             size_t *index = q[i].idx;
-
-            CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("na_index_aref_naview", "any");
-            cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-
+            size_t *index1 = CUMO_SDX_GET_INDEX(sdx1);
             CUMO_SDX_SET_INDEX(na2->stridx[j], index);
             q[i].idx = NULL;
-
-            for (k=0; k<size; k++) {
-                index[k] = CUMO_SDX_GET_INDEX(sdx1)[index[k]];
-            }
+            cumo_na_index_aref_naview_index_index_kernel_launch(index, index1, size);
         }
         else if (q[i].idx != NULL && CUMO_SDX_IS_STRIDE(sdx1)) {
             // index <- step
             ssize_t stride1 = CUMO_SDX_GET_STRIDE(sdx1);
             size_t *index = q[i].idx;
-
-            CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("na_index_aref_naview", "any");
-            cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-
             CUMO_SDX_SET_INDEX(na2->stridx[j],index);
             q[i].idx = NULL;
 
             if (stride1<0) {
                 size_t  last;
-                int k;
                 stride1 = -stride1;
                 last = na1->base.shape[q[i].orig_dim] - 1;
                 if (na2->offset < last * stride1) {
                     rb_raise(rb_eStandardError,"bug: negative offset");
                 }
                 na2->offset -= last * stride1;
-                for (k=0; k<size; k++) {
-                    index[k] = (last - index[k]) * stride1;
-                }
+                cumo_na_index_aref_naview_index_stride_last_kernel_launch(index, stride1, last, size);
             } else {
-                int k;
-                for (k=0; k<size; k++) {
-                    index[k] = index[k] * stride1;
-                }
+                cumo_na_index_aref_naview_index_stride_kernel_launch(index, stride1, size);
             }
         }
         else if (q[i].idx == NULL && CUMO_SDX_IS_INDEX(sdx1)) {
             // step <- index
-            int k;
             size_t beg  = q[i].beg;
             ssize_t step = q[i].step;
             // size_t *index = ALLOC_N(size_t, size);
             size_t *index = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*size);
+            size_t *index1 = CUMO_SDX_GET_INDEX(sdx1);
             CUMO_SDX_SET_INDEX(na2->stridx[j],index);
-
-            CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("na_index_aref_naview", "any");
-            cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
-
-            for (k=0; k<size; k++) {
-                index[k] = CUMO_SDX_GET_INDEX(sdx1)[beg+step*k];
-            }
+            cumo_na_index_aref_naview_index_index_beg_step_kernel_launch(index, index1, beg, step, size);
         }
         else if (q[i].idx == NULL && CUMO_SDX_IS_STRIDE(sdx1)) {
             // step <- step

data/ext/cumo/narray/index_kernel.cu

@@ -0,0 +1,86 @@
+#include "cumo/narray_kernel.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+__global__ void cumo_na_index_aref_nadata_index_stride_kernel(size_t *idx, ssize_t s1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] = idx[i] * s1;
+    }
+}
+
+__global__ void cumo_na_index_aref_naview_index_index_kernel(size_t *idx, size_t *idx1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] = idx1[idx[i]];
+    }
+}
+
+__global__ void cumo_na_index_aref_naview_index_stride_last_kernel(size_t *idx, ssize_t s1, size_t last, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] = (last - idx[i]) * s1;
+    }
+}
+
+__global__ void cumo_na_index_aref_naview_index_stride_kernel(size_t *idx, ssize_t s1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] = idx[i] * s1;
+    }
+}
+
+__global__ void cumo_na_index_aref_naview_index_index_beg_step_kernel(size_t *idx, size_t *idx1, size_t beg, ssize_t step, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] = idx1[beg + step * i];
+    }
+}
+
+void cumo_na_index_aref_nadata_index_stride_kernel_launch(size_t *idx, ssize_t s1, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_aref_nadata_index_stride_kernel<<<grid_dim, block_dim>>>(idx, s1, n);
+}
+
+void cumo_na_index_aref_naview_index_index_kernel_launch(size_t *idx, size_t *idx1, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_aref_naview_index_index_kernel<<<grid_dim, block_dim>>>(idx, idx1, n);
+}
+
+void cumo_na_index_aref_naview_index_stride_last_kernel_launch(size_t *idx, ssize_t s1, size_t last, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_aref_naview_index_stride_last_kernel<<<grid_dim, block_dim>>>(idx, s1, last, n);
+}
+
+void cumo_na_index_aref_naview_index_stride_kernel_launch(size_t *idx, ssize_t s1, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_aref_naview_index_stride_kernel<<<grid_dim, block_dim>>>(idx, s1, n);
+}
+
+void cumo_na_index_aref_naview_index_index_beg_step_kernel_launch(size_t *idx, size_t *idx1, size_t beg, ssize_t step, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_aref_naview_index_index_beg_step_kernel<<<grid_dim, block_dim>>>(idx, idx1, beg, step, n);
+}
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cumo
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Naotoshi Seo
@@ -170,6 +170,7 @@ files:
 - ext/cumo/narray/SFMT.h
 - ext/cumo/narray/array.c
 - ext/cumo/narray/data.c
+- ext/cumo/narray/data_kernel.cu
 - ext/cumo/narray/gen/cogen.rb
 - ext/cumo/narray/gen/cogen_kernel.rb
 - ext/cumo/narray/gen/def/bit.rb
@@ -305,6 +306,7 @@ files:
 - ext/cumo/narray/gen/tmpl_bit/where.c
 - ext/cumo/narray/gen/tmpl_bit/where2.c
 - ext/cumo/narray/index.c
+- ext/cumo/narray/index_kernel.cu
 - ext/cumo/narray/kwargs.c
 - ext/cumo/narray/math.c
 - ext/cumo/narray/narray.c