cumo 0.1.0

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

@@ -0,0 +1,12 @@
+<% unless defined?($cumo_narray_gen_tmpl_accum_kernel_included) %>
+<% $cumo_narray_gen_tmpl_accum_kernel_included = 1 %>
+
+<% if type_name.include?('int') %>
+<% f = File.join(File.dirname(__FILE__), 'real_accum_kernel.cu'); ERB.new(File.read(f)).tap {|erb| erb.filename = f }.result(binding) %>
+<% elsif type_name.include?('float') %>
+<%= f = File.join(File.dirname(__FILE__), 'float_accum_kernel.cu'); ERB.new(File.read(f)).tap {|erb| erb.filename = f }.result(binding) %>
+<% elsif type_name.include?('complex') %>
+<%= f = File.join(File.dirname(__FILE__), 'complex_accum_kernel.cu'); ERB.new(File.read(f)).tap {|erb| erb.filename = f }.result(binding) %>
+<% end %>
+
+<% end %>

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

@@ -0,0 +1,107 @@
+static size_t
+<%=type_name%>_memsize(const void* ptr)
+{
+    size_t size = sizeof(narray_data_t);
+    const narray_data_t *na = (const narray_data_t*)ptr;
+
+    assert(na->base.type == NARRAY_DATA_T);
+
+    if (na->ptr != NULL) {
+  <% if is_bit %>
+        size += ((na->base.size-1)/8/sizeof(BIT_DIGIT)+1)*sizeof(BIT_DIGIT);
+  <% else %>
+        size += na->base.size * sizeof(dtype);
+  <% end %>
+    }
+    if (na->base.size > 0) {
+        if (na->base.shape != NULL && na->base.shape != &(na->base.size)) {
+            size += sizeof(size_t) * na->base.ndim;
+        }
+    }
+    return size;
+}
+
+static void
+<%=type_name%>_free(void* ptr)
+{
+    narray_data_t *na = (narray_data_t*)ptr;
+
+    assert(na->base.type == NARRAY_DATA_T);
+
+    if (na->ptr != NULL) {
+        cumo_cuda_runtime_free(na->ptr);
+        na->ptr = NULL;
+    }
+    if (na->base.size > 0) {
+        if (na->base.shape != NULL && na->base.shape != &(na->base.size)) {
+            xfree(na->base.shape);
+            na->base.shape = NULL;
+        }
+    }
+    xfree(na);
+}
+
+static narray_type_info_t <%=type_name%>_info = {
+  <% if is_bit %>
+    1,             // element_bits
+    0,             // element_bytes
+    1,             // element_stride (in bits)
+  <% else %>
+    0,             // element_bits
+    sizeof(dtype), // element_bytes
+    sizeof(dtype), // element_stride (in bytes)
+  <% end %>
+};
+
+<% if is_object %>
+static void
+<%=type_name%>_gc_mark(void *ptr)
+{
+    size_t n, i;
+    VALUE *a;
+    narray_data_t *na = ptr;
+
+    if (na->ptr) {
+        a = (VALUE*)(na->ptr);
+        n = na->base.size;
+        for (i=0; i<n; i++) {
+            rb_gc_mark(a[i]);
+        }
+    }
+}
+
+static const rb_data_type_t <%=type_name%>_data_type = {
+    "<%=full_class_name%>",
+    {<%=type_name%>_gc_mark, <%=type_name%>_free, <%=type_name%>_memsize,},
+    &na_data_type,
+    &<%=type_name%>_info,
+    0, // flags
+};
+
+<% else %>
+
+static const rb_data_type_t <%=type_name%>_data_type = {
+    "<%=full_class_name%>",
+    {0, <%=type_name%>_free, <%=type_name%>_memsize,},
+    &na_data_type,
+    &<%=type_name%>_info,
+    0, // flags
+};
+
+<% end %>
+
+static VALUE
+<%=c_func(0)%>(VALUE klass)
+{
+    narray_data_t *na = ALLOC(narray_data_t);
+
+    na->base.ndim = 0;
+    na->base.type = NARRAY_DATA_T;
+    na->base.flag[0] = NA_FL0_INIT;
+    na->base.flag[1] = NA_FL1_INIT;
+    na->base.size = 0;
+    na->base.shape = NULL;
+    na->base.reduce = INT2FIX(0);
+    na->ptr = NULL;
+    return TypedData_Wrap_Struct(klass, &<%=type_name%>_data_type, (void*)na);
+}

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

@@ -0,0 +1,37 @@
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    narray_t *na;
+    void *ptr;
+
+    GetNArray(self,na);
+
+    switch(NA_TYPE(na)) {
+    case NARRAY_DATA_T:
+        ptr = NA_DATA_PTR(na);
+        if (na->size > 0 && ptr == NULL) {
+            <% if is_object %>
+            ptr = xmalloc(sizeof(dtype) * na->size);
+            {   size_t i;
+                VALUE *a = (VALUE*)ptr;
+                for (i=na->size; i--;) {
+                    *a++ = Qnil;
+                }
+            }
+            <% else %>
+            ptr = cumo_cuda_runtime_malloc(sizeof(dtype) * na->size);
+            <% end %>
+            NA_DATA_PTR(na) = ptr;
+        }
+        break;
+    case NARRAY_VIEW_T:
+        rb_funcall(NA_VIEW_DATA(na), rb_intern("allocate"), 0);
+        break;
+    case NARRAY_FILEMAP_T:
+        //ptr = ((narray_filemap_t*)na)->ptr;
+        // to be implemented
+    default:
+        rb_bug("invalid narray type : %d",NA_TYPE(na));
+    }
+    return self;
+}

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

@@ -0,0 +1,66 @@
+static VALUE
+<%=c_func(-1)%>_cpu(int argc, VALUE *argv, VALUE self);
+
+/*
+  Array element referenece or slice view.
+  @overload [](dim0,...,dimL)
+  @param [Numeric,Range,etc] dim0,...,dimL  Multi-dimensional Index.
+  @return [NArray::<%=class_name%>] NArray view.
+
+  --- Returns the element at +dim0+, +dim1+, ... are Numeric indices
+  for each dimension, or returns a NArray View as a sliced subarray if
+  +dim0+, +dim1+, ... includes other than Numeric index, e.g., Range
+  or Array or true.
+
+  Note that Cumo::NArray always returns NArray and does not return a
+  Ruby numeric object as Numo::NArray does to avoid synchronization
+  between GPU and CPU for performance.
+
+  Call Cumo.enable_compatible_mode to make ths method behave compatibly
+  with Numo, or you can use `aref_cpu(*idx)` method instead.
+
+  @example
+      a = Cumo::DFloat.new(4,5).seq
+      => Cumo::DFloat#shape=[4,5]
+      [[0, 1, 2, 3, 4],
+       [5, 6, 7, 8, 9],
+       [10, 11, 12, 13, 14],
+       [15, 16, 17, 18, 19]]
+
+      a[7]
+      => Cumo::DFloat#shape=[]
+      6.0
+
+      a[1,1]
+      => Cumo::DFloat#shape=[]
+      6.0
+
+      a[1..3,1]
+      => Cumo::DFloat#shape=[3]
+      [6, 11, 16]
+
+      a[1,[1,3,4]]
+      => Cumo::DFloat#shape=[3]
+      [6, 8, 9]
+
+      a[true,2].fill(99)
+      a
+      => Cumo::DFloat#shape=[4,5]
+      [[0, 1, 99, 3, 4],
+       [5, 6, 99, 8, 9],
+       [10, 11, 99, 13, 14],
+       [15, 16, 99, 18, 19]]
+ */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    if (cumo_compatible_mode_enabled_p()) {
+        return <%=c_func(-1)%>_cpu(argc, argv, self);
+    } else {
+        int result_nd;
+        size_t pos;
+
+        result_nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
+        return na_aref_main(argc, argv, self, 0, result_nd, pos);
+    }
+}

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

@@ -0,0 +1,50 @@
+/*
+  Array element referenece or slice view.
+  @overload [](dim0,...,dimL)
+  @param [Numeric,Range,etc] dim0,...,dimL  Multi-dimensional Index.
+  @return [Numeric,NArray::<%=class_name%>] Element object or NArray view.
+  --- Returns the element at +dim0+, +dim1+, ... are Numeric indices
+  for each dimension, or returns a NArray View as a sliced subarray if
+  +dim0+, +dim1+, ... includes other than Numeric index, e.g., Range
+  or Array or true.
+  This method is compatible with Numo NArray's [] method.
+  @example
+      a = Cumo::DFloat.new(4,5).seq
+      => Cumo::DFloat#shape=[4,5]
+      [[0, 1, 2, 3, 4],
+       [5, 6, 7, 8, 9],
+       [10, 11, 12, 13, 14],
+       [15, 16, 17, 18, 19]]
+      a[1,1]
+      => 6.0
+      a[1..3,1]
+      => Cumo::DFloat#shape=[3]
+      [6, 11, 16]
+      a[1,[1,3,4]]
+      => Cumo::DFloat#shape=[3]
+      [6, 8, 9]
+      a[true,2].fill(99)
+      a
+      => Cumo::DFloat#shape=[4,5]
+      [[0, 1, 99, 3, 4],
+       [5, 6, 99, 8, 9],
+       [10, 11, 99, 13, 14],
+       [15, 16, 99, 18, 19]]
+ */
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    int result_nd;
+    size_t pos;
+    char *ptr;
+
+    result_nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
+    if (result_nd) {
+        return na_aref_main(argc, argv, self, 0, result_nd, pos);
+    } else {
+        ptr = na_get_pointer_for_read(self) + pos;
+        SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+        return m_extract(ptr);
+    }
+}

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

@@ -0,0 +1,56 @@
+/*
+  Array element(s) set.
+  @overload []=(dim0,..,dimL,val)
+  @param [Numeric,Range,etc] dim0,..,dimL  Multi-dimensional Index.
+  @param [Numeric,Cumo::NArray,etc] val  Value(s) to be set to self.
+  @return [Numeric] returns val (last argument).
+
+  --- Replace element(s) at +dim0+, +dim1+, ... (index/range/array/true
+  for each dimention). Broadcasting mechanism is applied.
+
+  @example
+      a = Cumo::DFloat.new(3,4).seq
+      => Cumo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [4, 5, 6, 7],
+       [8, 9, 10, 11]]
+
+      a[1,2]=99
+      a
+      => Cumo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [4, 5, 99, 7],
+       [8, 9, 10, 11]]
+
+      a[1,[0,2]] = [101,102]
+      a
+      => Cumo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [101, 5, 102, 7],
+       [8, 9, 10, 11]]
+
+      a[1,true]=99
+      a
+      => Cumo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [99, 99, 99, 99],
+       [8, 9, 10, 11]]
+
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    int nd;
+    size_t pos;
+    VALUE a;
+
+    argc--;
+    if (argc==0) {
+        <%=c_func.sub(/_aset/,"_store")%>(self, argv[argc]);
+    } else {
+        nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
+        a = na_aref_main(argc, argv, self, 0, nd, pos);
+        <%=c_func.sub(/_aset/,"_store")%>(a, argv[argc]);
+    }
+    return argv[argc];
+}

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

@@ -0,0 +1,162 @@
+// TODO(sonots): handle zero division error in CUDA kernel?
+// ref. https://devtalk.nvidia.com/default/topic/415951/divide-by-zero-handling/
+
+//<% if is_int and %w[div mod divmod].include? name %>
+#define check_intdivzero(y)              \
+    if ((y)==0) {                        \
+        lp->err_type = rb_eZeroDivError; \
+        return;                          \
+    }
+//<% else %>
+#define check_intdivzero(y) {}
+//<% end %>
+
+<% unless type_name == 'robject' %>
+void <%="cumo_#{c_iter}_kernel_launch"%>(na_iarray_t* a1, na_iarray_t* a2, na_iarray_t* a3, na_indexer_t* indexer);
+<% end %>
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    <% if type_name == 'robject' %>
+    {
+        size_t   i, 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);
+
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        //<% if need_align %>
+        if (is_aligned(p1,sizeof(dtype)) &&
+            is_aligned(p2,sizeof(dtype)) &&
+            is_aligned(p3,sizeof(dtype)) ) {
+
+            if (s1 == sizeof(dtype) &&
+                s2 == sizeof(dtype) &&
+                s3 == sizeof(dtype) ) {
+
+                if (p1 == p3) { // inplace case
+                    for (i=0; i<n; i++) {
+                        check_intdivzero(*(dtype*)p2);
+                        ((dtype*)p1)[i] = m_<%=name%>(((dtype*)p1)[i],((dtype*)p2)[i]);
+                    }
+                } else {
+                    for (i=0; i<n; i++) {
+                        check_intdivzero(*(dtype*)p2);
+                        ((dtype*)p3)[i] = m_<%=name%>(((dtype*)p1)[i],((dtype*)p2)[i]);
+                    }
+                }
+                return;
+            }
+            if (is_aligned_step(s1,sizeof(dtype)) &&
+                is_aligned_step(s2,sizeof(dtype)) &&
+                is_aligned_step(s3,sizeof(dtype)) ) {
+                //<% end %>
+
+                if (s2 == 0){ // Broadcasting from scalar value.
+                    check_intdivzero(*(dtype*)p2);
+                    if (s1 == sizeof(dtype) &&
+                        s3 == sizeof(dtype) ) {
+                        if (p1 == p3) { // inplace case
+                            for (i=0; i<n; i++) {
+                                ((dtype*)p1)[i] = m_<%=name%>(((dtype*)p1)[i],*(dtype*)p2);
+                            }
+                        } else {
+                            for (i=0; i<n; i++) {
+                                ((dtype*)p3)[i] = m_<%=name%>(((dtype*)p1)[i],*(dtype*)p2);
+                            }
+                        }
+                    } else {
+                        for (i=0; i<n; i++) {
+                            *(dtype*)p3 = m_<%=name%>(*(dtype*)p1,*(dtype*)p2);
+                            p1 += s1;
+                            p3 += s3;
+                        }
+                    }
+                } else { // Broadcasting from Numo::NArray
+                    if (p1 == p3) { // inplace case
+                        for (i=0; i<n; i++) {
+                            check_intdivzero(*(dtype*)p2);
+                            *(dtype*)p1 = m_<%=name%>(*(dtype*)p1,*(dtype*)p2);
+                            p1 += s1;
+                            p2 += s2;
+                        }
+                    } else {
+                        for (i=0; i<n; i++) {
+                            check_intdivzero(*(dtype*)p2);
+                            *(dtype*)p3 = m_<%=name%>(*(dtype*)p1,*(dtype*)p2);
+                            p1 += s1;
+                            p2 += s2;
+                            p3 += s3;
+                        }
+                    }
+                }
+
+                return;
+                //<% if need_align %>
+            }
+        }
+        for (i=0; i<n; i++) {
+            dtype x, y, z;
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            GET_DATA_STRIDE(p2,s2,dtype,y);
+            check_intdivzero(y);
+            z = m_<%=name%>(x,y);
+            SET_DATA_STRIDE(p3,s3,dtype,z);
+        }
+        //<% end %>
+    }
+    <% else %>
+    {
+        na_iarray_t a1 = na_make_iarray(&lp->args[0]);
+        na_iarray_t a2 = na_make_iarray(&lp->args[1]);
+        na_iarray_t a3 = na_make_iarray(&lp->args[2]);
+        na_indexer_t indexer = na_make_indexer(&lp->args[0]);
+
+        <%="cumo_#{c_iter}_kernel_launch"%>(&a1,&a2,&a3,&indexer);
+    }
+    <% end %>
+}
+#undef check_intdivzero
+
+static VALUE
+<%=c_func%>_self(VALUE self, VALUE other)
+{
+    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    <% if type_name == 'robject' %>
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 1, ain, aout };
+    <% else %>
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP|NDF_INDEXER_LOOP, 2, 1, ain, aout };
+    <% end %>
+
+    return na_ndloop(&ndf, 2, self, other);
+}
+
+/*
+  Binary <%=name%>.
+  @overload <%=op_map%> other
+  @param [Cumo::NArray,Numeric] other
+  @return [Cumo::NArray] self <%=op_map%> other
+*/
+static VALUE
+<%=c_func(1)%>(VALUE self, VALUE other)
+{
+    <% if is_object %>
+    return <%=c_func%>_self(self, other);
+    <% else %>
+    VALUE klass, v;
+
+    klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
+    if (klass==cT) {
+        return <%=c_func%>_self(self, other);
+    } else {
+        v = rb_funcall(klass, id_cast, 1, self);
+        return rb_funcall(v, <%=id_op%>, 1, other);
+    }
+    <% end %>
+}