cumo 0.1.0

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

@@ -0,0 +1,79 @@
+/*
+  Element-wise <%=name%> of two arrays.
+
+<% if is_float %>
+  @overload <%=name%>(a1, a2, nan:false)
+  @param [Cumo::NArray,Numeric] a1  The array to be compared.
+  @param [Cumo::NArray,Numeric] a2  The array to be compared.
+  @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN if exist).
+<% else %>
+  @overload <%=name%>(a1, a2)
+  @param [Cumo::NArray,Numeric] a1,a2  The arrays holding the elements to be compared.
+<% end %>
+  @return [Cumo::<%=class_name%>]
+*/
+
+<% (is_float ? ["","_nan"] : [""]).each do |nan| %>
+
+<% unless type_name == 'robject' %>
+void cumo_<%=type_name%>_<%=name%><%=nan%>_kernel_launch(char *p1, char* p2, char* p3, ssize_t s1, ssize_t s2, ssize_t s3, size_t n);
+<% end %>
+
+static void
+<%=c_iter%><%=nan%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+
+    <% if type_name == 'robject' %>
+    {
+        size_t i;
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=nan%>", "<%=type_name%>");
+        for (i=0; i<n; i++) {
+            dtype x, y, z;
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            GET_DATA_STRIDE(p2,s2,dtype,y);
+            GET_DATA(p3,dtype,z);
+            z = f_<%=name%><%=nan%>(x,y);
+            SET_DATA_STRIDE(p3,s3,dtype,z);
+        }
+    }
+    <% else %>
+    {
+        cumo_<%=type_name%>_<%=name%><%=nan%>_kernel_launch(p1,p2,p3,s1,s2,s3,n);
+    }
+    <% end %>
+}
+<% end %>
+
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE mod)
+{
+    VALUE a1 = Qnil;
+    VALUE a2 = Qnil;
+    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP, 2, 1, ain, aout };
+
+    <% if is_float %>
+    VALUE kw_hash = Qnil;
+    ID kw_table[1] = {id_nan};
+    VALUE opts[1] = {Qundef};
+
+    rb_scan_args(argc, argv, "20:", &a1, &a2, &kw_hash);
+    rb_get_kwargs(kw_hash, kw_table, 0, 1, opts);
+    if (opts[0] != Qundef) {
+        ndf.func = <%=c_iter%>_nan;
+    }
+    <% else %>
+    rb_scan_args(argc, argv, "20", &a1, &a2);
+    <% end %>
+
+    return na_ndloop(&ndf, 2, a1, a2);
+}

data/ext/cumo/narray/gen/tmpl/ewcomp_kernel.cu

@@ -0,0 +1,19 @@
+<% unless type_name == 'robject' %>
+<% (is_float ? ["","_nan"] : [""]).each do |nan| %>
+
+__global__ void <%="cumo_#{type_name}_#{name}#{nan}_kernel"%>(char* p1, char* p2, char* p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
+{
+    for (size_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        *((dtype*)(p3+(i*s3))) = f_<%=name%><%=nan%>(*((dtype*)(p1+(i*s1))), *((dtype*)(p2+(i*s2))));
+    }
+}
+
+void cumo_<%=type_name%>_<%=name%><%=nan%>_kernel_launch(char *p1, char *p2, char* p3, ssize_t s1, ssize_t s2, ssize_t s3, size_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{type_name}_#{name}#{nan}_kernel"%><<<gridDim, blockDim>>>(p1,p2,p3,s1,s2,s3,n);
+}
+
+<% end %>
+<% end %>

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

@@ -0,0 +1,22 @@
+static VALUE
+<%=c_func(0)%>_cpu(VALUE self);
+
+/*
+  Returns self.
+  @overload extract
+  @return [Cumo::NArray]
+  --- Note that Cumo::NArray always returns NArray and does not
+  return a Ruby numeric object as Numo::NArray does to avoid
+  synchronization between CPU and GPU for performance.
+
+  Call `Cumo.enable_compatible_mode` to make this method behave
+  compatible with Numo, or you can use `extract_cpu` method instead.
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    if (cumo_compatible_mode_enabled_p()) {
+        return <%=c_func(0)%>_cpu(self);
+    }
+    return self;
+}

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

@@ -0,0 +1,26 @@
+/*
+  Extract an element only if self is a dimensionless NArray.
+  @overload extract_cpu
+  @return [Numeric,Cumo::NArray]
+  --- Extract element value as Ruby Object if self is a dimensionless NArray,
+  otherwise returns self.
+  This method is compatible with Numo NArray's `extract` method.
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    volatile VALUE v;
+    char *ptr;
+    narray_t *na;
+    GetNArray(self,na);
+
+    if (na->ndim==0) {
+        ptr = na_get_pointer_for_read(self) + na_get_offset(self);
+        SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+        v = m_extract(ptr);
+        na_release_lock(self);
+        return v;
+    }
+    return self;
+}

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

@@ -0,0 +1,53 @@
+/*
+  Convert a data value of obj (with a single element) to dtype.
+*/
+/*
+static dtype
+<%=c_func(:nodef)%>(VALUE obj)
+{
+    narray_t *na;
+    dtype  x;
+    char  *ptr;
+    size_t pos;
+    VALUE  r, klass;
+
+    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+
+    if (IsNArray(obj)) {
+        GetNArray(obj,na);
+        if (na->size != 1) {
+            rb_raise(nary_eShapeError,"narray size should be 1");
+       }
+        klass = CLASS_OF(obj);
+        ptr = na_get_pointer_for_read(obj);
+        pos = na_get_offset(obj);
+        <% find_tmpl("store").definitions.select{|x| x.class==Store}.each do |x| %>
+        if (<%=x.condition("klass")%>) {
+            <%=x.extract_data("ptr","pos","x")%>;
+            return x;
+        }
+        <% end %>
+
+        // coerce
+        r = rb_funcall(obj, rb_intern("coerce_cast"), 1, cT);
+        if (CLASS_OF(r)==cT) {
+            return <%=c_func%>(r);
+        }
+        <% if is_object %>
+        return obj;
+        <% else %>
+        rb_raise(nary_eCastError, "unknown conversion from %s to %s",
+                 rb_class2name(CLASS_OF(obj)),
+                 rb_class2name(cT));
+        <% end %>
+    }
+    if (TYPE(obj)==T_ARRAY) {
+        if (RARRAY_LEN(obj) != 1) {
+            rb_raise(nary_eShapeError,"array size should be 1");
+        }
+        return m_num_to_data(RARRAY_AREF(obj,0));
+    }
+    return m_num_to_data(obj);
+}
+*/

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

@@ -0,0 +1,105 @@
+<% unless type_name == 'robject' %>
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *ptr, ssize_t s0, ssize_t s1, ssize_t kofs, dtype data, uint64_t n0, uint64_t n1);
+<% end %>
+
+#include <cuda_runtime.h>
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   n0, n1;
+    ssize_t  s0, s1;
+    char    *p0;
+    char    *g;
+    ssize_t kofs;
+    dtype   data;
+
+    g = (char*)(lp->opt_ptr);
+    kofs = *(ssize_t*)g;
+    data = *(dtype*)(g+sizeof(ssize_t));
+
+    n0 = lp->args[0].shape[0];
+    n1 = lp->args[0].shape[1];
+    s0 = lp->args[0].iter[0].step;
+    s1 = lp->args[0].iter[1].step;
+    p0 = NDL_PTR(lp,0);
+
+    <% if type_name == 'robject' %>
+    {
+        size_t i0, i1;
+        char *p1;
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        for (i0=0; i0 < n0; i0++) {
+            p1 = p0;
+            for (i1=0; i1 < n1; i1++) {
+                *(dtype*)p1 = (i0+kofs==i1) ? data : m_zero;
+                p1 += s1;
+            }
+            p0 += s0;
+        }
+    }
+    <% else %>
+    <%="cumo_#{c_iter}_stride_kernel_launch"%>(p0,s0,s1,kofs,data,n0,n1);
+    <% end %>
+}
+
+/*
+  Eye: Set a value to diagonal components, set 0 to non-diagonal components.
+  @overload <%=name%>([element,offset])
+  @param [Numeric] element  Diagonal element to be stored. Default is 1.
+  @param [Integer] offset Diagonal offset from the main diagonal.  The
+      default is 0. k>0 for diagonals above the main diagonal, and k<0
+      for diagonals below the main diagonal.
+  @return [Cumo::<%=class_name%>] <%=name%> of self.
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,2}};
+    ndfunc_t ndf = {<%=c_iter%>, NO_LOOP, 1,0, ain,0};
+    ssize_t kofs;
+    dtype data;
+    char *g;
+    int nd;
+    narray_t *na;
+
+    // check arguments
+    if (argc > 2) {
+        rb_raise(rb_eArgError,"too many arguments (%d for 0..2)",argc);
+    } else if (argc == 2) {
+        data = m_num_to_data(argv[0]);
+        kofs = NUM2SSIZET(argv[1]);
+    } else if (argc == 1) {
+        data = m_num_to_data(argv[0]);
+        kofs = 0;
+    } else {
+        data = m_one;
+        kofs = 0;
+    }
+
+    GetNArray(self,na);
+    nd = na->ndim;
+    if (nd < 2) {
+        rb_raise(nary_eDimensionError,"less than 2-d array");
+    }
+
+    // Diagonal offset from the main diagonal.
+    if (kofs >= 0) {
+        if ((size_t)(kofs) >= na->shape[nd-1]) {
+            rb_raise(rb_eArgError,"invalid diagonal offset(%"SZF"d) for "
+                     "last dimension size(%"SZF"d)",kofs,na->shape[nd-1]);
+        }
+    } else {
+        if ((size_t)(-kofs) >= na->shape[nd-2]) {
+            rb_raise(rb_eArgError,"invalid diagonal offset(%"SZF"d) for "
+                     "last-1 dimension size(%"SZF"d)",kofs,na->shape[nd-2]);
+        }
+    }
+
+    g = ALLOCA_N(char,sizeof(ssize_t)+sizeof(dtype));
+    *(ssize_t*)g = kofs;
+    *(dtype*)(g+sizeof(ssize_t)) = data;
+
+    na_ndloop3(&ndf, g, 1, self);
+    return self;
+}

data/ext/cumo/narray/gen/tmpl/eye_kernel.cu

@@ -0,0 +1,19 @@
+<% unless type_name == 'robject' %>
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char*ptr, ssize_t s0, ssize_t s1, ssize_t kofs, dtype data, uint64_t n0, uint64_t n1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        uint64_t i0 = i / n1;
+        uint64_t i1 = i - (i0 * n1);
+        *(dtype*)(ptr + (i0*s0) + (i1*s1)) = (i0+kofs==i1) ? data : m_zero;
+    }
+}
+
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *ptr, ssize_t s0, ssize_t s1, ssize_t kofs, dtype data, uint64_t n0, uint64_t n1)
+{
+    uint64_t n = n0 * n1;
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_kernel"%><<<gridDim, blockDim>>>(ptr,s0,s1,kofs,data,n0,n1,n);
+}
+<% end %>
+

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

@@ -0,0 +1,52 @@
+<% unless type_name == 'robject' %>
+void <%="cumo_#{c_iter}_index_kernel_launch"%>(char *ptr, size_t *idx, dtype val, uint64_t n);
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *ptr, ssize_t step, dtype val, uint64_t n);
+<% end %>
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1;
+    ssize_t  s1;
+    size_t  *idx1;
+    VALUE    x = lp->option;
+    dtype    y;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    y = m_num_to_data(x);
+    <% if type_name == 'robject' %>
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    if (idx1) {
+        for (; i--;) {
+            SET_DATA_INDEX(p1,idx1,dtype,y);
+        }
+    } else {
+        for (; i--;) {
+            SET_DATA_STRIDE(p1,s1,dtype,y);
+        }
+    }
+    <% else %>
+    if (idx1) {
+        <%="cumo_#{c_iter}_index_kernel_launch"%>(p1,idx1,y,i);
+    } else {
+        <%="cumo_#{c_iter}_stride_kernel_launch"%>(p1,s1,y,i);
+    }
+    <% end %>
+}
+
+/*
+  Fill elements with other.
+  @overload <%=name%> other
+  @param [Numeric] other
+  @return [Cumo::<%=class_name%>] self.
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE val)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_option}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 0, ain, 0 };
+
+    na_ndloop(&ndf, 2, self, val);
+    return self;
+}

data/ext/cumo/narray/gen/tmpl/fill_kernel.cu

@@ -0,0 +1,29 @@
+<% unless type_name == 'robject' %>
+__global__ void <%="cumo_#{c_iter}_index_kernel"%>(char *ptr, size_t *idx, dtype val, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        *(dtype*)(ptr + idx[i]) = val;
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(char*ptr, ssize_t step, dtype val, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        *(dtype*)(ptr + (i*step)) = val;
+    }
+}
+
+void <%="cumo_#{c_iter}_index_kernel_launch"%>(char *ptr, size_t *idx, dtype val, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_index_kernel"%><<<gridDim, blockDim>>>(ptr,idx,val,n);
+}
+
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(char *ptr, ssize_t step, dtype val, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_kernel"%><<<gridDim, blockDim>>>(ptr,step,val,n);
+}
+<% end %>

data/ext/cumo/narray/gen/tmpl/float_accum_kernel.cu

@@ -0,0 +1,106 @@
+<% f = File.join(File.dirname(__FILE__), 'real_accum_kernel.cu'); ERB.new(File.read(f)).tap {|erb| erb.filename = f }.result(binding) %>
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+template<typename Iterator1>
+__global__ void cumo_<%=type_name%>_mean_kernel(Iterator1 p1_begin, Iterator1 p1_end, <%=dtype%>* p2, uint64_t n)
+{
+    dtype init = m_zero;
+    *p2 = thrust::reduce(thrust::cuda::par, p1_begin, p1_end, init, thrust::plus<dtype>());
+    *p2 /= (dtype)n;
+}
+
+template<typename Iterator1>
+__global__ void cumo_<%=type_name%>_var_kernel(Iterator1 p1_begin, Iterator1 p1_end, <%=dtype%>* p2)
+{
+    cumo_thrust_variance_unary_op<dtype>  unary_op;
+    cumo_thrust_variance_binary_op<dtype> binary_op;
+    cumo_thrust_variance_data<dtype> init = {};
+    cumo_thrust_variance_data<dtype> result;
+    result = thrust::transform_reduce(thrust::cuda::par, p1_begin, p1_end, unary_op, init, binary_op);
+    *p2 = result.variance();
+}
+
+template<typename Iterator1>
+__global__ void cumo_<%=type_name%>_stddev_kernel(Iterator1 p1_begin, Iterator1 p1_end, <%=dtype%>* p2)
+{
+    cumo_thrust_variance_unary_op<dtype>  unary_op;
+    cumo_thrust_variance_binary_op<dtype> binary_op;
+    cumo_thrust_variance_data<dtype> init = {};
+    cumo_thrust_variance_data<dtype> result;
+    result = thrust::transform_reduce(thrust::cuda::par, p1_begin, p1_end, unary_op, init, binary_op);
+    *p2 = m_sqrt(result.variance());
+}
+
+template<typename Iterator1>
+__global__ void cumo_<%=type_name%>_rms_kernel(Iterator1 p1_begin, Iterator1 p1_end, <%=dtype%>* p2, uint64_t n)
+{
+    dtype init = m_zero;
+    dtype result;
+    result = thrust::transform_reduce(thrust::cuda::par, p1_begin, p1_end, cumo_thrust_square(), init, thrust::plus<dtype>());
+    *p2 = m_sqrt(m_div(result,n));
+}
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+void cumo_<%=type_name%>_mean_kernel_launch(uint64_t n, char *p1, ssize_t s1, char *p2)
+{
+    ssize_t s1_idx = s1 / sizeof(dtype);
+    thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
+    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
+    if (s1_idx == 1) {
+        cumo_<%=type_name%>_mean_kernel<<<1,1>>>(data_begin, data_end, (<%=dtype%>*)p2, n);
+    } else {
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
+        cumo_<%=type_name%>_mean_kernel<<<1,1>>>(range.begin(), range.end(), (<%=dtype%>*)p2, n);
+    }
+}
+
+void cumo_<%=type_name%>_var_kernel_launch(uint64_t n, char *p1, ssize_t s1, char *p2)
+{
+    ssize_t s1_idx = s1 / sizeof(dtype);
+    thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
+    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
+    if (s1_idx == 1) {
+        cumo_<%=type_name%>_var_kernel<<<1,1>>>(data_begin, data_end, (<%=dtype%>*)p2);
+    } else {
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
+        cumo_<%=type_name%>_var_kernel<<<1,1>>>(range.begin(), range.end(), (<%=dtype%>*)p2);
+    }
+}
+
+void cumo_<%=type_name%>_stddev_kernel_launch(uint64_t n, char *p1, ssize_t s1, char *p2)
+{
+    ssize_t s1_idx = s1 / sizeof(dtype);
+    thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
+    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
+    if (s1_idx == 1) {
+        cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(data_begin, data_end, (<%=dtype%>*)p2);
+    } else {
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
+        cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(range.begin(), range.end(), (<%=dtype%>*)p2);
+    }
+}
+
+void cumo_<%=type_name%>_rms_kernel_launch(uint64_t n, char *p1, ssize_t s1, char *p2)
+{
+    ssize_t s1_idx = s1 / sizeof(dtype);
+    thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
+    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
+    if (s1_idx == 1) {
+        cumo_<%=type_name%>_rms_kernel<<<1,1>>>(data_begin, data_end, (<%=dtype%>*)p2, n);
+    } else {
+        cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
+        cumo_<%=type_name%>_rms_kernel<<<1,1>>>(range.begin(), range.end(), (<%=dtype%>*)p2, n);
+    }
+}