cumo 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 784e23c2ba8be26ed4a9834766f4a410b6a73fe2b828a696b3f8107bdd187861
-  data.tar.gz: 9ff0de0b005907b070868cf40548b3b6c883459898e83b252784a7e30dc77058
+  metadata.gz: 4886418f8fc62df52cc7b235e755e2d7733221b39d46f2f68e25a1ee49923487
+  data.tar.gz: 7476161b95f04d560397d6d2d6abf64bfbf9987a10559ea90e66fa12275075bb
 SHA512:
-  metadata.gz: 6cb2f338da7f52501e0d3d6716990a9ddc4165b2aa564b5e22afe98526a151a25474f27081850719fc00e49c0407859af8470070666de0653e4cd74bf0155866
-  data.tar.gz: 3a4362323eb239376644bfb49857afce658d79f8e7ec786e993502592387caa281c9a626fae01b374f28ab6ae8dcb4bc435c7fe73f97728b3200b9f39409b357
+  metadata.gz: 543fc92511dc863926f970ff23d811fc7975d182b74f11053ace504e68a6fd70b607c132a46bdf6f9396131560885d92a91a8c91544e0524d6a3cad12b3cdb64
+  data.tar.gz: 610458caead3fef458aba25384ad817ff27e727f01d3452d165332163b93c64b14934b7d9546c942fc60920d63e6fb5e745180c1c69ad6ee0d2f96f3d8a9887b

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.4.2 (2019-01-11)
+
+Fixes:
+
+* cond_unary.c: add cudaDeviceSynchronize to avoid bus error
+* index.c: add cudaDeviceSynchronize to avoid bus error
+* cum.c: add cudaDeviceSynchronize to avoid bus error
+
 # 0.4.1 (2019-05-06)
 
 Fixes:

data/ext/cumo/cuda/cudnn_impl.cpp

@@ -540,29 +540,40 @@ cumo_cuda_cudnn_CreateBNTensorDescriptor(
 }
 
 size_t
+cumo_cuda_cudnn_GetTotalSize(cumo_cuda_cudnn_shape_t *shape)
+{
+    size_t i = 0;
+    size_t total_size = 1;
+    for (i = 0; i < shape->ndim; ++i) {
+        total_size *= shape->data[i];
+    }
+    return total_size;
+}
+
+cumo_cuda_cudnn_shape_t
 cumo_cuda_cudnn_ReduceShape(
-        size_t *reduced_shape,
         size_t shape_ndim,
         size_t *shape,
         size_t axes_ndim,
         int *axes,
-        char keepdims) {
-    assert(shape_ndim >= axes_ndim);
+        char keepdims)
+{
+    cumo_cuda_cudnn_shape_t reduced_shape{};
     size_t i_axis = 0;
-    size_t i_shape = 0;
+    assert(shape_ndim >= axes_ndim);
     for (size_t i = 0; i < shape_ndim; ++i) {
         if (i_axis < axes_ndim && i == (size_t)axes[i_axis]) {
             ++i_axis;
             if (keepdims) {
-                reduced_shape[i_shape++] = 1;
+                reduced_shape.data[reduced_shape.ndim++] = 1;
             }
         } else {
-            reduced_shape[i_shape++] = shape[i];
+            reduced_shape.data[reduced_shape.ndim++] = shape[i];
         }
     }
     assert(i_axis == axes_ndim);
-    assert(i_shape == shape_ndim - static_cast<int8_t>(!keepdims) * axes_ndim);
-    return i_shape;
+    assert(reduced_shape.ndim == shape_ndim - static_cast<int8_t>(!keepdims) * axes_ndim);
+    return reduced_shape;
 }
 
 #if defined(__cplusplus)

data/ext/cumo/include/cumo.h

@@ -10,8 +10,8 @@ extern "C" {
 #endif
 #endif
 
-#define CUMO_VERSION "0.4.1"
-#define CUMO_VERSION_CODE 41
+#define CUMO_VERSION "0.4.2"
+#define CUMO_VERSION_CODE 42
 
 bool cumo_compatible_mode_enabled_p();
 bool cumo_show_warning_enabled_p();

data/ext/cumo/include/cumo/cuda/cudnn.h

@@ -203,9 +203,17 @@ cumo_cuda_cudnn_CreateBNTensorDescriptor(
         cudnnTensorDescriptor_t x_desc,
         cudnnBatchNormMode_t mode);
 
+
+typedef struct {
+    size_t ndim;
+    size_t data[CUMO_NA_MAX_DIMENSION];
+} cumo_cuda_cudnn_shape_t;
+
 size_t
+cumo_cuda_cudnn_GetTotalSize(cumo_cuda_cudnn_shape_t *shape);
+
+cumo_cuda_cudnn_shape_t
 cumo_cuda_cudnn_ReduceShape(
-        size_t *reduced_shape,
         size_t shape_ndim,
         size_t *shape,
         size_t axes_ndim,

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

@@ -20,8 +20,8 @@ static VALUE
     cudnnDataType_t cudnn_dtype = <%= cudnn_dtype %>;
     cudnnStatus_t status = 0;
     cudnnHandle_t handle = 0;
-    dtype coef_alpha = 1;
-    dtype coef_beta = 0;
+    dtype coef_one = 1;
+    dtype coef_zero = 0;
 
     VALUE x=self, gamma, beta, running_mean, running_var, eps, decay, axis, mean, inv_std, y;
     VALUE kw_hash = Qnil;
@@ -37,8 +37,8 @@ static VALUE
     };
     VALUE opts[] = {Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef};
 
-    cumo_narray_t *nx; // , *ngamma, *nbeta;
-    size_t *x_shape; // *gamma_shape, *beta_shape, reduced_shape[CUMO_NA_MAX_DIMENSION];
+    cumo_narray_t *nx;
+    size_t *x_shape;
     size_t x_ndim;
 
     VALUE x_cont, gamma_cont, beta_cont;
@@ -92,24 +92,35 @@ static VALUE
     }
 
     CumoGetNArray(x, nx);
-    // CumoGetNArray(gamma, ngamma);
-    // CumoGetNArray(beta, nbeta);
     x_ndim = nx->ndim;
     x_shape = nx->shape;
-    // gamma_ndim = ngamma->ndim;
-    // gamma_shape = ngamma->shape;
-    // beta_ndim = nbeta->ndim;
-    // beta_shape = nbeta->shape;
-
-    // TODO: Size check of gammma, beta, running_mean, running_var, mean, inv_std
-    // are equivalent with either of reduced_shape(keepdims: false) or reduced_shape(keepdims: true)
-    // reduced_ndim = cumo_cuda_cudnn_ReduceShape(reduced_shape, x_ndim, x_shape, axis_ndim, int_axis, 1);
-    // CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_ndim, gamma_ndim);
-    // CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_ndim, beta_ndim);
-    // for (size_t idim = 0; idim < reduced_ndim; ++idim) {
-    //     CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_shape[idim], gamma_shape[idim]);
-    //     CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_shape[idim], beta_shape[idim]);
-    // }
+
+    {
+        cumo_narray_t *ngamma, *nbeta, *nrunning_mean, *nrunning_var, *nmean, *ninv_std;
+        cumo_cuda_cudnn_shape_t reduced_shape = cumo_cuda_cudnn_ReduceShape(x_ndim, x_shape, axis_ndim, int_axis, 1);
+        size_t reduced_total_size = cumo_cuda_cudnn_GetTotalSize(&reduced_shape);
+
+        CumoGetNArray(gamma, ngamma);
+        CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(ngamma->size, reduced_total_size);
+        CumoGetNArray(beta, nbeta);
+        CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(nbeta->size, reduced_total_size);
+        if (running_mean != Qnil) {
+            CumoGetNArray(running_mean, nrunning_mean);
+            CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(nrunning_mean->size, reduced_total_size);
+        }
+        if (running_var != Qnil) {
+            CumoGetNArray(running_var, nrunning_var);
+            CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(nrunning_var->size, reduced_total_size);
+        }
+        if (mean != Qnil) {
+            CumoGetNArray(mean, nmean);
+            CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(nmean->size, reduced_total_size);
+        }
+        if (inv_std != Qnil) {
+            CumoGetNArray(inv_std, ninv_std);
+            CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(ninv_std->size, reduced_total_size);
+        }
+    }
 
     CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(x, cT);
     CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(gamma, cT);
@@ -156,8 +167,8 @@ static VALUE
     status = cudnnBatchNormalizationForwardTraining(
             handle,
             mode,
-            (void*)&coef_alpha,
-            (void*)&coef_beta,
+            (void*)&coef_one,
+            (void*)&coef_zero,
             x_desc,
             x_cont_ptr,
             x_desc,

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

@@ -13,15 +13,15 @@
     end
 %>
 
-// gx, ggamma, gbeta = x.batch_normalizatoin_backward(gamma, gy, mean:, inv_std:, eps:, axis:)
+// gx, ggamma, gbeta = x.batch_norm_backward(gamma, gy, mean:, inv_std:, eps:, axis:)
 static VALUE
 <%=c_func(-1)%>(int argc, VALUE argv[], VALUE self)
 {
     cudnnDataType_t cudnn_dtype = <%= cudnn_dtype %>;
     cudnnStatus_t status = 0;
     cudnnHandle_t handle = 0;
-    dtype coef_alpha = 1;
-    dtype coef_beta = 0;
+    dtype coef_one = 1;
+    dtype coef_zero = 0;
 
     VALUE x=self, gamma, gy, mean, inv_std, eps, axis, gx, ggamma, gbeta;
     VALUE kw_hash = Qnil;
@@ -36,9 +36,9 @@ static VALUE
     };
     VALUE opts[] = {Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef};
 
-    cumo_narray_t *nx, *ngamma; // , *ngy;
-    size_t *x_shape, *gamma_shape; // , *gy_shape, reduced_shape[CUMO_NA_MAX_DIMENSION];
-    size_t x_ndim, gamma_ndim; // , gy_ndim, reduced_ndim;
+    cumo_narray_t *nx, *ngamma;
+    size_t *x_shape, *gamma_shape;
+    size_t x_ndim, gamma_ndim;
 
     VALUE x_cont, gamma_cont, gy_cont;
     cudnnTensorDescriptor_t x_desc = 0;
@@ -79,27 +79,29 @@ static VALUE
 
     CumoGetNArray(x, nx);
     CumoGetNArray(gamma, ngamma);
-    // CumoGetNArray(gy, ngy);
     x_ndim = nx->ndim;
     x_shape = nx->shape;
     gamma_ndim = ngamma->ndim;
     gamma_shape = ngamma->shape;
-    // gy_ndim = ngy->ndim;
-    // gy_shape = ngy->shape;
-
-    // TODO: Size check of gammma, beta, running_mean, running_var, mean, inv_std
-    // are equivalent with either of reduced_shape(keepdims: false) or reduced_shape(keepdims: true)
-    // reduced_ndim = cumo_cuda_cudnn_ReduceShape(reduced_shape, x_ndim, x_shape, axis_ndim, int_axis, 1);
-    // CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_ndim, gamma_ndim);
-    // for (size_t idim = 0; idim < reduced_ndim; ++idim) {
-    //     CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_shape[idim], gamma_shape[idim]);
-    // }
-    // CUMO_CUDA_CUDNN_CHECK_DIM_EQ(x_ndim, gy_ndim);
-    // for (size_t idim = 0; idim < x_ndim; ++idim) {
-    //     CUMO_CUDA_CUDNN_CHECK_DIM_EQ(x_shape[idim], gy_shape[idim]);
-    // }
-
-    // TODO: Add ndim and shape (same with reduced) for mean and inv_std if given
+
+    {
+        cumo_narray_t *ngy, *nmean, *ninv_std;
+        cumo_cuda_cudnn_shape_t reduced_shape = cumo_cuda_cudnn_ReduceShape(x_ndim, x_shape, axis_ndim, int_axis, 1);
+        size_t reduced_total_size = cumo_cuda_cudnn_GetTotalSize(&reduced_shape);
+
+        CumoGetNArray(gy, ngy);
+        CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(nx->size, ngy->size);
+
+        CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(ngamma->size, reduced_total_size);
+        if (mean != Qnil) {
+            CumoGetNArray(mean, nmean);
+            CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(nmean->size, reduced_total_size);
+        }
+        if (inv_std != Qnil) {
+            CumoGetNArray(inv_std, ninv_std);
+            CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(ninv_std->size, reduced_total_size);
+        }
+    }
 
     CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(x, cT);
     CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(gamma, cT);
@@ -142,10 +144,10 @@ static VALUE
     status = cudnnBatchNormalizationBackward(
             handle,
             mode,
-            (void*)&coef_alpha,
-            (void*)&coef_beta,
-            (void*)&coef_alpha,
-            (void*)&coef_beta,
+            (void*)&coef_one,
+            (void*)&coef_zero,
+            (void*)&coef_one,
+            (void*)&coef_zero,
             x_desc,
             x_cont_ptr,
             x_desc,

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

@@ -13,6 +13,7 @@ static void
     CUMO_INIT_PTR_IDX(lp, 0, p1, s1, idx1);
     CUMO_INIT_PTR_BIT(lp, 1, a2, p2, s2);
     CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
     if (idx1) {
         for (; i--;) {
             CUMO_GET_DATA_INDEX(p1,idx1,dtype,x);

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

@@ -12,10 +12,12 @@ static void
     CUMO_INIT_PTR(lp, 1, p2, s2);
     //printf("i=%lu p1=%lx s1=%lu p2=%lx s2=%lu\n",i,(size_t)p1,s1,(size_t)p2,s2);
 
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=j%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
     CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
     CUMO_SET_DATA_STRIDE(p2,s2,dtype,x);
     //printf("i=%lu x=%f\n",i,x);
-    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=j%>", "<%=type_name%>");
     for (i--; i--;) {
         CUMO_GET_DATA_STRIDE(p1,s1,dtype,y);
         m_<%=name%><%=j%>(x,y);

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

@@ -32,8 +32,8 @@ static VALUE
     };
     VALUE opts[] = {Qundef, Qundef, Qundef};
 
-    cumo_narray_t *nx; // , *ngamma, *nbeta;
-    size_t *x_shape; // *gamma_shape, *beta_shape, reduced_shape[CUMO_NA_MAX_DIMENSION];
+    cumo_narray_t *nx;
+    size_t *x_shape;
     size_t x_ndim;
 
     VALUE x_cont, gamma_cont, beta_cont, mean_cont, var_cont;
@@ -62,24 +62,24 @@ static VALUE
     }
 
     CumoGetNArray(x, nx);
-    // CumoGetNArray(gamma, ngamma);
-    // CumoGetNArray(beta, nbeta);
     x_ndim = nx->ndim;
     x_shape = nx->shape;
-    // gamma_ndim = ngamma->ndim;
-    // gamma_shape = ngamma->shape;
-    // beta_ndim = nbeta->ndim;
-    // beta_shape = nbeta->shape;
-
-    // TODO: Size check of gammma, beta, running_mean, running_var, mean, inv_std
-    // are equivalent with either of reduced_shape(keepdims: false) or reduced_shape(keepdims: true)
-    // reduced_ndim = cumo_cuda_cudnn_ReduceShape(reduced_shape, x_ndim, x_shape, axis_ndim, int_axis, 1);
-    // CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_ndim, gamma_ndim);
-    // CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_ndim, beta_ndim);
-    // for (size_t idim = 0; idim < reduced_ndim; ++idim) {
-    //     CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_shape[idim], gamma_shape[idim]);
-    //     CUMO_CUDA_CUDNN_CHECK_DIM_EQ(reduced_shape[idim], beta_shape[idim]);
-    // }
+
+    {
+        cumo_narray_t *ngamma, *nbeta, *nmean, *nvar;
+        cumo_cuda_cudnn_shape_t reduced_shape = cumo_cuda_cudnn_ReduceShape(x_ndim, x_shape, axis_ndim, int_axis, 1);
+        size_t reduced_total_size = cumo_cuda_cudnn_GetTotalSize(&reduced_shape);
+
+        CumoGetNArray(gamma, ngamma);
+        CumoGetNArray(beta, nbeta);
+        CumoGetNArray(mean, nmean);
+        CumoGetNArray(var, nvar);
+
+        CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(ngamma->size, reduced_total_size);
+        CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(nbeta->size, reduced_total_size);
+        CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(nmean->size, reduced_total_size);
+        CUMO_CUDA_CUDNN_CHECK_SIZE_EQ(nvar->size, reduced_total_size);
+    }
 
     CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(x, cT);
     CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(gamma, cT);

data/ext/cumo/narray/index.c

@@ -857,6 +857,8 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
                 x = cumo_na_range_check(idx[i], na->shape[i], i);
                 sdx = nv->stridx[i];
                 if (CUMO_SDX_IS_INDEX(sdx)) {
+                    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("index", "cumo_na_get_result_dimension");
+                    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
                     pos += CUMO_SDX_GET_INDEX(sdx)[x];
                 } else {
                     pos += CUMO_SDX_GET_STRIDE(sdx)*x;
@@ -872,6 +874,8 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
                 x = x / s;
                 sdx = nv->stridx[i];
                 if (CUMO_SDX_IS_INDEX(sdx)) {
+                    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("index", "cumo_na_get_result_dimension");
+                    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
                     pos += CUMO_SDX_GET_INDEX(sdx)[m];
                 } else {
                     pos += CUMO_SDX_GET_STRIDE(sdx)*m;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cumo
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Naotoshi Seo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-06 00:00:00.000000000 Z
+date: 2019-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray