cumo 0.2.5 → 0.3.0.pre1

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

@@ -0,0 +1,191 @@
+#ifdef CUDNN_FOUND
+
+<%
+  cudnn_dtype =
+    case type_name
+    when 'sfloat'
+      'CUDNN_DATA_FLOAT'
+    when 'dfloat'
+      'CUDNN_DATA_DOUBLE'
+    else
+      # CUDNN_DATA_HALF
+      raise 'not supported'
+    end
+%>
+
+// gx, ggamma, gbeta = x.batch_normalizatoin_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;
+
+    VALUE x=self, gamma, gy, mean, inv_std, eps, axis, gx, ggamma, gbeta;
+    VALUE kw_hash = Qnil;
+    ID kw_table[] = {
+        rb_intern("mean"),
+        rb_intern("inv_std"),
+        rb_intern("eps"),
+        rb_intern("axis"),
+        rb_intern("gx"),
+        rb_intern("ggamma"),
+        rb_intern("gbeta")
+    };
+    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;
+
+    VALUE x_cont, gamma_cont, gy_cont;
+    cudnnTensorDescriptor_t x_desc = 0;
+    cudnnTensorDescriptor_t bn_desc = 0;
+    char *x_cont_ptr, *gamma_cont_ptr, *gy_cont_ptr, *gx_ptr, *ggamma_ptr, *gbeta_ptr;
+
+    cudnnBatchNormMode_t mode;
+
+    // default values
+    char *mean_ptr=NULL;
+    char *inv_std_ptr=NULL;
+    double double_eps = 2e-5;
+    int int_axis[CUMO_NA_MAX_DIMENSION] = {0};
+    size_t axis_ndim = 1;
+
+    rb_scan_args(argc, argv, "2:", &gamma, &gy, &kw_hash);
+    rb_get_kwargs(kw_hash, kw_table, 0, 8, opts);
+    mean = cumo_cuda_cudnn_option_value(opts[0], Qnil);
+    inv_std = cumo_cuda_cudnn_option_value(opts[1], Qnil);
+    eps = cumo_cuda_cudnn_option_value(opts[2], Qnil);
+    axis = cumo_cuda_cudnn_option_value(opts[3], Qnil);
+    gx = cumo_cuda_cudnn_option_value(opts[4], Qnil);
+    ggamma = cumo_cuda_cudnn_option_value(opts[5], Qnil);
+    gbeta = cumo_cuda_cudnn_option_value(opts[6], Qnil);
+
+    if (mean != Qnil) {
+        mean_ptr = cumo_na_get_offset_pointer_for_read(mean);
+    }
+    if (inv_std != Qnil) {
+        inv_std_ptr = cumo_na_get_offset_pointer_for_read(inv_std);
+    }
+    if (eps != Qnil) {
+        double_eps = NUM2DBL(eps);
+    }
+    if (axis != Qnil) {
+        Check_Type(axis, T_ARRAY);
+        axis_ndim = (size_t)(RARRAY_LEN(axis));
+        for (size_t idim = 0; idim < axis_ndim; ++idim) {
+            int_axis[idim] = NUM2INT(rb_ary_entry(axis, (long)idim));
+        }
+        // TODO: check axis is sorted
+    }
+
+    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_CUDA_CUDNN_CHECK_NARRAY_TYPE(x, cT);
+    CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(gamma, cT);
+    CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(gy, cT);
+    if (mean != Qnil) CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(mean, cT);
+    if (inv_std != Qnil) CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(inv_std, cT);
+
+    x_cont = cumo_na_as_contiguous_array(x);
+    gamma_cont = cumo_na_as_contiguous_array(gamma);
+    gy_cont = cumo_na_as_contiguous_array(gy);
+    if (mean != Qnil && cumo_na_check_contiguous(mean) != Qtrue) {
+        rb_raise(rb_eRuntimeError, "mean must be contiguous");
+    }
+    if (inv_std != Qnil && cumo_na_check_contiguous(inv_std) != Qtrue) {
+        rb_raise(rb_eRuntimeError, "inv_std must be contiguous");
+    }
+
+    x_cont_ptr = cumo_na_get_offset_pointer_for_read(x_cont);
+    gamma_cont_ptr = cumo_na_get_offset_pointer_for_read(gamma_cont);
+    gy_cont_ptr = cumo_na_get_offset_pointer_for_read(gy_cont);
+
+    // TODO: type and shape check
+    if (gx == Qnil) gx = cumo_na_new(cT, x_ndim, x_shape);
+    gx_ptr = cumo_na_get_offset_pointer_for_write(gx);
+    if (ggamma == Qnil) ggamma = cumo_na_new(cT, gamma_ndim, gamma_shape);
+    ggamma_ptr = cumo_na_get_offset_pointer_for_write(ggamma);
+    if (gbeta == Qnil) gbeta = cumo_na_new(cT, gamma_ndim, gamma_shape);
+    gbeta_ptr = cumo_na_get_offset_pointer_for_write(gbeta);
+
+    status = cumo_cuda_cudnn_CreateTensorDescriptor(&x_desc, x_cont, cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto BATCH_NORM_ERROR;
+
+    mode = cumo_cuda_cudnn_GetBatchNormMode(axis_ndim, int_axis);
+    status = cumo_cuda_cudnn_CreateBNTensorDescriptor(&bn_desc, x_desc, mode);
+    if (status != CUDNN_STATUS_SUCCESS) goto BATCH_NORM_ERROR;
+    // TODO: bn_desc may return another type, and may need to cast gamma, gy, mean, var
+
+    handle = cumo_cuda_cudnn_handle();
+
+    status = cudnnBatchNormalizationBackward(
+            handle,
+            mode,
+            (void*)&coef_alpha,
+            (void*)&coef_beta,
+            (void*)&coef_alpha,
+            (void*)&coef_beta,
+            x_desc,
+            x_cont_ptr,
+            x_desc,
+            gy_cont_ptr,
+            x_desc,
+            gx_ptr,
+            bn_desc,
+            gamma_cont_ptr,
+            ggamma_ptr,
+            gbeta_ptr,
+            double_eps,
+            mean_ptr,
+            inv_std_ptr);
+    if (status != CUDNN_STATUS_SUCCESS) goto BATCH_NORM_ERROR;
+
+BATCH_NORM_ERROR:
+    if (x_desc) cudnnDestroyTensorDescriptor(x_desc);
+    if (bn_desc) cudnnDestroyTensorDescriptor(bn_desc);
+    cumo_cuda_cudnn_check_status(status);
+
+    {
+        VALUE ret = rb_ary_new2(3);
+        rb_ary_push(ret, gx);
+        rb_ary_push(ret, ggamma);
+        rb_ary_push(ret, gbeta);
+        return ret;
+    }
+}
+
+#else // CUDNN_FOUND
+VALUE cumo_cuda_eCudnnError;
+
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE argv[], VALUE self)
+{
+    rb_raise(cumo_cuda_eCudnnError, "cuDNN is not available");
+}
+#endif // CUDNN_FOUND

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

@@ -0,0 +1,216 @@
+#ifdef CUDNN_FOUND
+
+<%
+  cudnn_dtype =
+    case type_name
+    when 'sfloat'
+      'CUDNN_DATA_FLOAT'
+    when 'dfloat'
+      'CUDNN_DATA_DOUBLE'
+    else
+      # CUDNN_DATA_HALF
+      raise 'not supported'
+    end
+%>
+
+// cover_all=true is not supported with CUDNN
+// dilation > 1 is not supported yet
+// x.conv(w, b: nil, stride: 1, pad: 0, y: nil)
+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 alpha = 1;
+    dtype beta = 0;
+
+    VALUE x=self, w, b, stride, pad, y;
+    VALUE kw_hash = Qnil;
+    ID kw_table[4] = {rb_intern("stride"), rb_intern("pad"), rb_intern("b"), rb_intern("y")};
+    VALUE opts[4] = {Qundef, Qundef, Qundef, Qundef};
+
+    size_t ndim;
+    cumo_narray_t *nx, *nw;
+    size_t *x_shape, *w_shape;
+    size_t out_channels, batch_size;
+
+    VALUE x_cont, w_cont;
+    cudnnTensorDescriptor_t x_desc = 0;
+    cudnnTensorDescriptor_t y_desc = 0;
+    cudnnTensorDescriptor_t b_desc = 0;
+    cudnnFilterDescriptor_t w_desc = 0;
+    cudnnConvolutionDescriptor_t conv_desc = 0;
+    char *x_cont_ptr, *w_cont_ptr, *y_ptr;
+
+    cudnnConvolutionFwdAlgoPerf_t perf_result;
+    cudnnConvolutionFwdAlgo_t algo;
+    size_t max_workspace_size = CUMO_CUDA_CUDNN_DEFAULT_MAX_WORKSPACE_SIZE;
+    size_t workspace_size;
+    char* workspace = 0;
+
+    int int_stride[CUMO_NA_MAX_DIMENSION];
+    int int_pad[CUMO_NA_MAX_DIMENSION];
+
+    rb_scan_args(argc, argv, "1:", &w, &kw_hash);
+    rb_get_kwargs(kw_hash, kw_table, 0, 4, opts);
+    stride = cumo_cuda_cudnn_option_value(opts[0], Qnil);
+    pad = cumo_cuda_cudnn_option_value(opts[1], Qnil);
+    b = cumo_cuda_cudnn_option_value(opts[2], Qnil);
+    y = cumo_cuda_cudnn_option_value(opts[3], Qnil);
+
+    CumoGetNArray(x, nx);
+    CumoGetNArray(w, nw);
+
+    CUMO_CUDA_CUDNN_CHECK_DIM_EQ(nx->ndim, nw->ndim);
+    CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(x, cT);
+    CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(w, cT);
+    if (nx->ndim - 2 < 2) {
+        rb_raise(cumo_na_eShapeError, "CUDNN convolution requires number of spatial "
+                "dimensions to be greater than or equal to 2, but %d", nx->ndim - 2);
+    }
+    ndim = nx->ndim - 2;  // Number of spatial dimensions
+
+    cumo_cuda_cudnn_get_int_ary(int_stride, stride, ndim, 1);
+    cumo_cuda_cudnn_get_int_ary(int_pad, pad, ndim, 0);
+
+    x_shape = nx->shape;
+    w_shape = nw->shape;
+    batch_size = x_shape[0]; // x_shape = (batch_size, in_channels, d_1, d_2, ..., d_N)
+    out_channels = w_shape[0]; // w.shape = (out_channels, in_channels, k_1, k_2, ..., k_N)
+    if (x_shape[1] != w_shape[1]) {
+        rb_raise(cumo_na_eShapeError, "x_shape[1]:%d does not match with w_shape[1]:%d",
+                (int)x_shape[1], (int)w_shape[1]);
+    }
+
+    if (y != Qnil) {
+        CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(y, cT);
+    }
+    else {
+        size_t *y_shape = ALLOCA_N(size_t, ndim + 2);
+        // out_shape = (batch_size, out_channels, out_1, out_2, ..., out_N)
+        y_shape[0] = batch_size;
+        y_shape[1] = out_channels;
+        for (size_t i = 0; i < ndim; ++i) {
+            y_shape[i + 2] = cumo_cuda_cudnn_GetConvOutDim(
+                    x_shape[i + 2], w_shape[i + 2], int_stride[i], int_pad[i]);
+        }
+        y = cumo_na_new(cT, ndim + 2, y_shape);
+    }
+
+    x_cont = cumo_na_as_contiguous_array(x);
+    w_cont = cumo_na_as_contiguous_array(w);
+
+    x_cont_ptr = cumo_na_get_offset_pointer_for_read(x_cont);
+    w_cont_ptr = cumo_na_get_offset_pointer_for_read(w_cont);
+    y_ptr = cumo_na_get_offset_pointer_for_write(y);
+
+    status = cumo_cuda_cudnn_CreateTensorDescriptor(&x_desc, x_cont, cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_ERROR;
+    status = cumo_cuda_cudnn_CreateTensorDescriptor(&y_desc, y, cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_ERROR;
+    status = cumo_cuda_cudnn_CreateFilterDescriptor(&w_desc, w_cont, cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_ERROR;
+    status = cumo_cuda_cudnn_CreateConvolutionDescriptor(&conv_desc, ndim, int_stride, int_pad, cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_ERROR;
+
+    handle = cumo_cuda_cudnn_handle();
+
+    // auto tune
+    status = cumo_cuda_cudnn_FindConvolutionForwardAlgorithm(
+            &perf_result,
+            handle,
+            x_desc,
+            x_cont,
+            w_desc,
+            w_cont,
+            conv_desc,
+            y_desc,
+            y,
+            max_workspace_size,
+            int_stride,
+            int_pad,
+            ndim,
+            cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_ERROR;
+    algo = perf_result.algo;
+    workspace_size = perf_result.memory;
+
+    workspace = cumo_cuda_runtime_malloc(max_workspace_size);
+    status = cudnnConvolutionForward(
+            handle,
+            (void*)&alpha,
+            x_desc,
+            (void*)x_cont_ptr,
+            w_desc,
+            (void*)w_cont_ptr,
+            conv_desc,
+            algo,
+            (void*)workspace,
+            workspace_size,
+            (void*)&beta,
+            y_desc,
+            (void*)y_ptr);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_ERROR;
+
+    if (b != Qnil) {
+        size_t new_shape[CUMO_NA_MAX_DIMENSION];
+        VALUE b_cont;
+        char* b_cont_ptr;
+        cumo_narray_t *nb, *nb_cont;
+        size_t *b_shape;
+        int b_ndim;
+
+        CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(b, cT);
+        CumoGetNArray(b, nb);
+        new_shape[0] = 1;
+        new_shape[1] = nb->size;
+        for (size_t i = 0; i < ndim; ++i) {
+            new_shape[i + 2] = 1;
+        }
+        b_cont =  cumo_na_as_contiguous_array(b);
+        b_cont_ptr = cumo_na_get_offset_pointer_for_read(b_cont);
+        CumoGetNArray(b_cont, nb_cont);
+        b_shape = nb_cont->shape;
+        b_ndim = nb_cont->ndim;
+        // reshape b
+        nb_cont->ndim = ndim + 2;
+        nb_cont->shape = new_shape;
+        status = cumo_cuda_cudnn_CreateTensorDescriptor(&b_desc, b_cont, cudnn_dtype);
+        // restore b.shape
+        nb_cont->ndim = b_ndim;
+        nb_cont->shape = b_shape;
+        if (status != CUDNN_STATUS_SUCCESS) goto CONV_ERROR;
+
+        status = cudnnAddTensor(
+                    handle,
+                    (void*)&alpha,
+                    b_desc,
+                    (void*)b_cont_ptr,
+                    (void*)&alpha,
+                    y_desc,
+                    (void*)y_ptr);
+        if (status != CUDNN_STATUS_SUCCESS) goto CONV_ERROR;
+    }
+
+CONV_ERROR:
+    if (x_desc) cudnnDestroyTensorDescriptor(x_desc);
+    if (y_desc) cudnnDestroyTensorDescriptor(y_desc);
+    if (b_desc) cudnnDestroyTensorDescriptor(b_desc);
+    if (w_desc) cudnnDestroyFilterDescriptor(w_desc);
+    if (conv_desc) cudnnDestroyConvolutionDescriptor(conv_desc);
+    if (workspace) cumo_cuda_runtime_free(workspace);
+    cumo_cuda_cudnn_check_status(status);
+
+    return y;
+}
+
+#else // CUDNN_FOUND
+VALUE cumo_cuda_eCUDNNError;
+
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE argv[], VALUE self)
+{
+    rb_raise(cumo_cuda_eCUDNNError, "cuDNN is not available");
+}
+#endif // CUDNN_FOUND

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

@@ -0,0 +1,183 @@
+#ifdef CUDNN_FOUND
+
+<%
+  cudnn_dtype =
+    case type_name
+    when 'sfloat'
+      'CUDNN_DATA_FLOAT'
+    when 'dfloat'
+      'CUDNN_DATA_DOUBLE'
+    else
+      # CUDNN_DATA_HALF
+      raise 'not supported'
+    end
+%>
+
+static void
+cumo_cuda_cudnn_get_sizet_ary(size_t *sizet_ary, VALUE ary, size_t ndim)
+{
+    Check_Type(ary, T_ARRAY);
+    CUMO_CUDA_CUDNN_CHECK_DIM_EQ((size_t)(RARRAY_LEN(ary)), ndim);
+    for (size_t idim = 0; idim < ndim; ++idim) {
+        sizet_ary[idim] = NUM2SIZET(rb_ary_entry(ary, (long)idim));
+    }
+}
+
+// cover_all=true is not supported with CUDNN
+// gw = x.conv_grad_w(gy, w_shape, stride: 1, pad: 0, gw: nil)
+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 one = 1;
+    dtype zero = 0;
+
+    VALUE x=self, gy, w_shape, stride, pad, gw;
+    VALUE kw_hash = Qnil;
+    ID kw_table[] = {rb_intern("stride"), rb_intern("pad"), rb_intern("gw")};
+    VALUE opts[] = {Qundef, Qundef, Qundef};
+
+    size_t ndim;
+    cumo_narray_t *nx, *ngy;
+
+    VALUE x_cont, gy_cont;
+    cudnnTensorDescriptor_t x_desc = 0;
+    cudnnTensorDescriptor_t gy_desc = 0;
+    cudnnConvolutionDescriptor_t conv_desc = 0;
+    cudnnFilterDescriptor_t gw_desc = 0;
+    char *x_cont_ptr, *gy_cont_ptr, *gw_ptr;
+
+    cudnnConvolutionBwdFilterAlgoPerf_t perf_result;
+    cudnnConvolutionBwdFilterAlgo_t algo;
+    size_t max_workspace_size = CUMO_CUDA_CUDNN_DEFAULT_MAX_WORKSPACE_SIZE;
+    size_t workspace_size;
+    char* workspace = 0;
+
+    size_t sizet_w_shape[CUMO_NA_MAX_DIMENSION];
+    int int_stride[CUMO_NA_MAX_DIMENSION];
+    int int_pad[CUMO_NA_MAX_DIMENSION];
+
+    rb_scan_args(argc, argv, "2:", &gy, &w_shape, &kw_hash);
+    rb_get_kwargs(kw_hash, kw_table, 0, 3, opts);
+    stride = cumo_cuda_cudnn_option_value(opts[0], Qnil);
+    pad = cumo_cuda_cudnn_option_value(opts[1], Qnil);
+    gw = cumo_cuda_cudnn_option_value(opts[2], Qnil);
+
+    CumoGetNArray(x, nx);
+    CumoGetNArray(gy, ngy);
+
+    CUMO_CUDA_CUDNN_CHECK_DIM_EQ(nx->ndim, ngy->ndim);
+    CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(x, cT);
+    CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(gy, cT);
+    if (nx->ndim - 2 < 2) {
+        rb_raise(cumo_na_eShapeError, "CUDNN convolution requires number of spatial "
+                "dimensions to be greater than or equal to 2, but %d", nx->ndim - 2);
+    }
+    ndim = nx->ndim - 2;  // Number of spatial dimensions
+
+    cumo_cuda_cudnn_get_sizet_ary(sizet_w_shape, w_shape, ndim + 2);
+    cumo_cuda_cudnn_get_int_ary(int_stride, stride, ndim, 1);
+    cumo_cuda_cudnn_get_int_ary(int_pad, pad, ndim, 0);
+
+    if (gw != Qnil) {
+        CUMO_CUDA_CUDNN_CHECK_NARRAY_TYPE(gw, cT);
+        assert(cumo_na_check_contiguous(gw) == Qtrue);
+    }
+    else {
+        gw = cumo_na_new(cT, ndim + 2, sizet_w_shape);
+    }
+    // w_shape = (out_channels, in_channels, k_1, k_2, ..., k_N)
+    // x_shape = (batch_size, in_channels, d_1, d_2, ..., d_N)
+    // y_shape = (batch_size, out_channels, out_1, out_2, ..., out_N)
+    CUMO_CUDA_CUDNN_CHECK_DIM_EQ(nx->shape[0], ngy->shape[0]);
+    CUMO_CUDA_CUDNN_CHECK_DIM_EQ(sizet_w_shape[0], ngy->shape[1]);
+    CUMO_CUDA_CUDNN_CHECK_DIM_EQ(sizet_w_shape[1], nx->shape[1]);
+
+    {
+        // shape check of gy
+        size_t *y_shape = ngy->shape;
+        size_t *x_shape = nx->shape;
+        for (size_t i = 0; i < ndim; ++i) {
+            // TODO: raise
+            assert(y_shape[i + 2] == cumo_cuda_cudnn_GetConvOutDim(
+                    x_shape[i + 2], sizet_w_shape[i + 2], int_stride[i], int_pad[i]));
+        }
+    }
+
+    x_cont = cumo_na_as_contiguous_array(x);
+    gy_cont = cumo_na_as_contiguous_array(gy);
+
+    x_cont_ptr = cumo_na_get_offset_pointer_for_read(x_cont);
+    gy_cont_ptr = cumo_na_get_offset_pointer_for_read(gy_cont);
+    gw_ptr = cumo_na_get_offset_pointer_for_write(gw);
+
+    status = cumo_cuda_cudnn_CreateTensorDescriptor(&x_desc, x_cont, cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_GRAD_W_ERROR;
+    status = cumo_cuda_cudnn_CreateTensorDescriptor(&gy_desc, gy_cont, cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_GRAD_W_ERROR;
+    status = cumo_cuda_cudnn_CreateFilterDescriptor(&gw_desc, gw, cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_GRAD_W_ERROR;
+    status = cumo_cuda_cudnn_CreateConvolutionDescriptor(&conv_desc, ndim, int_stride, int_pad, cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_GRAD_W_ERROR;
+
+    handle = cumo_cuda_cudnn_handle();
+
+    // auto tune
+    status = cumo_cuda_cudnn_FindConvolutionBackwardFilterAlgorithm(
+            &perf_result,
+            handle,
+            x_desc,
+            x_cont,
+            gy_desc,
+            gy_cont,
+            conv_desc,
+            gw_desc,
+            gw,
+            max_workspace_size,
+            int_stride,
+            int_pad,
+            ndim,
+            cudnn_dtype);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_GRAD_W_ERROR;
+    algo = perf_result.algo;
+    workspace_size = perf_result.memory;
+
+    workspace = cumo_cuda_runtime_malloc(max_workspace_size);
+    status = cudnnConvolutionBackwardFilter(
+            handle,
+            (void*)&one,
+            x_desc,
+            (void*)x_cont_ptr,
+            gy_desc,
+            (void*)gy_cont_ptr,
+            conv_desc,
+            algo,
+            (void*)workspace,
+            workspace_size,
+            (void*)&zero,
+            gw_desc,
+            (void*)gw_ptr);
+    if (status != CUDNN_STATUS_SUCCESS) goto CONV_GRAD_W_ERROR;
+
+CONV_GRAD_W_ERROR:
+    if (x_desc) cudnnDestroyTensorDescriptor(x_desc);
+    if (gy_desc) cudnnDestroyTensorDescriptor(gy_desc);
+    if (gw_desc) cudnnDestroyFilterDescriptor(gw_desc);
+    if (conv_desc) cudnnDestroyConvolutionDescriptor(conv_desc);
+    if (workspace) cumo_cuda_runtime_free(workspace);
+    cumo_cuda_cudnn_check_status(status);
+
+    return gw;
+}
+
+#else // CUDNN_FOUND
+VALUE cumo_cuda_eCUDNNError;
+
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE argv[], VALUE self)
+{
+    rb_raise(cumo_cuda_eCUDNNError, "cuDNN is not available");
+}
+#endif // CUDNN_FOUND