cumo 0.1.0

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

@@ -0,0 +1,66 @@
+<% unless c_iter.include? 'robject' %>
+__global__ void <%="cumo_#{c_iter}_index_index_kernel"%>(char *p1, size_t p2, BIT_DIGIT *a2, size_t *idx1, size_t *idx2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        BIT_DIGIT x;
+        LOAD_BIT(a2, p2 + idx2[i], x);
+        *(dtype*)(p1 + idx1[i]) = m_from_real(x);
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_stride_index_kernel"%>(char *p1, size_t p2, BIT_DIGIT *a2, ssize_t s1, size_t *idx2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        BIT_DIGIT x;
+        LOAD_BIT(a2, p2 + idx2[i], x);
+        *(dtype*)(p1 + (i * s1)) = m_from_real(x);
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_index_stride_kernel"%>(char *p1, size_t p2, BIT_DIGIT *a2, size_t *idx1, ssize_t s2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        BIT_DIGIT x;
+        LOAD_BIT(a2, p2 + (i * s2), x);
+        *(dtype*)(p1 + idx1[i]) = m_from_real(x);
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_stride_stride_kernel"%>(char *p1, size_t p2, BIT_DIGIT *a2, ssize_t s1, ssize_t s2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        BIT_DIGIT x;
+        LOAD_BIT(a2, p2 + (i * s2), x);
+        *(dtype*)(p1 + (i * s1)) = m_from_real(x);
+    }
+}
+
+void <%="cumo_#{c_iter}_index_index_kernel_launch"%>(char *p1, size_t p2, BIT_DIGIT *a2, size_t *idx1, size_t *idx2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_index_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,a2,idx1,idx2,n);
+}
+
+void <%="cumo_#{c_iter}_stride_index_kernel_launch"%>(char *p1, size_t p2, BIT_DIGIT *a2, ssize_t s1, size_t *idx2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,a2,s1,idx2,n);
+}
+
+void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(char *p1, size_t p2, BIT_DIGIT *a2, size_t *idx1, ssize_t s2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_index_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,a2,idx1,s2,n);
+}
+
+void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(char *p1, size_t p2, BIT_DIGIT *a2, ssize_t s1, ssize_t s2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,a2,s1,s2,n);
+}
+
+<% end %>

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

@@ -0,0 +1,81 @@
+//<% unless c_iter.include? 'robject' %>
+void <%="cumo_#{c_iter}_index_index_kernel_launch"%>(char *p1, char *p2, size_t *idx1, size_t *idx2, uint64_t n);
+void <%="cumo_#{c_iter}_stride_index_kernel_launch"%>(char *p1, char *p2, ssize_t s1, size_t *idx2, uint64_t n);
+void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(char *p1, char *p2, size_t *idx1, ssize_t s2, uint64_t n);
+void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(char *p1, char *p2, ssize_t s1, ssize_t s2, uint64_t n);
+//<% end %>
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i, s1, s2;
+    char   *p1, *p2;
+    size_t *idx1, *idx2;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+    //<% if c_iter.include? 'robject' %>
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    {
+        <%=dtype%> x;
+        dtype y;
+        if (idx2) {
+            if (idx1) {
+                for (; i--;) {
+                    GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                    y = <%=macro%>(x);
+                    SET_DATA_INDEX(p1,idx1,dtype,y);
+                }
+            } else {
+                for (; i--;) {
+                    GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                    y = <%=macro%>(x);
+                    SET_DATA_STRIDE(p1,s1,dtype,y);
+                }
+            }
+        } else {
+            if (idx1) {
+                for (; i--;) {
+                    GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                    y = <%=macro%>(x);
+                    SET_DATA_INDEX(p1,idx1,dtype,y);
+                }
+            } else {
+                for (; i--;) {
+                    GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                    y = <%=macro%>(x);
+                    SET_DATA_STRIDE(p1,s1,dtype,y);
+                }
+            }
+        }
+    }
+    //<% else %>
+    {
+        if (idx2) {
+            if (idx1) {
+                <%="cumo_#{c_iter}_index_index_kernel_launch"%>(p1,p2,idx1,idx2,i);
+            } else {
+                <%="cumo_#{c_iter}_stride_index_kernel_launch"%>(p1,p2,s1,idx2,i);
+            }
+        } else {
+            if (idx1) {
+                <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(p1,p2,idx1,s2,i);
+            } else {
+                <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(p1,p2,s1,s2,i);
+            }
+        }
+    }
+    //<% end %>
+}
+
+
+static VALUE
+<%=c_func(:nodef)%>(VALUE self, VALUE obj)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{Qnil,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 0, ain, 0 };
+
+    na_ndloop(&ndf, 2, self, obj);
+    return self;
+}

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

@@ -0,0 +1,58 @@
+<% unless c_iter.include? 'robject' %>
+__global__ void <%="cumo_#{c_iter}_index_index_kernel"%>(char *p1, char *p2, size_t *idx1, size_t *idx2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        *(dtype*)(p1 + idx1[i]) = <%=macro%>(*(<%=dtype%>*)(p2 + idx2[i]));
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_stride_index_kernel"%>(char *p1, char *p2, ssize_t s1, size_t *idx2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        *(dtype*)(p1 + (i * s1)) = <%=macro%>(*(<%=dtype%>*)(p2 + idx2[i]));
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_index_stride_kernel"%>(char *p1, char *p2, size_t *idx1, ssize_t s2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        *(dtype*)(p1 + idx1[i]) = <%=macro%>(*(<%=dtype%>*)(p2 + (i * s2)));
+    }
+}
+
+__global__ void <%="cumo_#{c_iter}_stride_stride_kernel"%>(char *p1, char *p2, ssize_t s1, ssize_t s2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        *(dtype*)(p1 + (i * s1)) = <%=macro%>(*(<%=dtype%>*)(p2 + (i * s2)));
+    }
+}
+
+void <%="cumo_#{c_iter}_index_index_kernel_launch"%>(char *p1, char *p2, size_t *idx1, size_t *idx2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_index_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,idx1,idx2,n);
+}
+
+void <%="cumo_#{c_iter}_stride_index_kernel_launch"%>(char *p1, char *p2, ssize_t s1, size_t *idx2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,s1,idx2,n);
+}
+
+void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(char *p1, char *p2, size_t *idx1, ssize_t s2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_index_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,idx1,s2,n);
+}
+
+void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(char *p1, char *p2, ssize_t s1, ssize_t s2, uint64_t n)
+{
+    size_t gridDim = get_gridDim(n);
+    size_t blockDim = get_blockDim(n);
+    <%="cumo_#{c_iter}_stride_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,s1,s2,n);
+}
+
+<% end %>

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

@@ -0,0 +1,3 @@
+<% children.each do |c|%>
+<%= c.result %>
+<% end %>

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

@@ -0,0 +1,9 @@
+static VALUE
+<%=c_func(:nodef)%>(VALUE self, VALUE obj)
+{
+    dtype x;
+    x = m_num_to_data(obj);
+    obj = <%=type_name%>_new_dim0(x);
+    <%=parent.c_func%>(self,obj);
+    return self;
+}

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

@@ -0,0 +1,43 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, s1;
+    char *p1;
+    size_t *idx1;
+    dtype x;
+    volatile VALUE a, y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    a = rb_ary_new2(i);
+    rb_ary_push(lp->args[1].value, a);
+    //SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    if (idx1) {
+        for (; i--;) {
+            GET_DATA_INDEX(p1,idx1,dtype,x);
+            y = m_data_to_num(x);
+            rb_ary_push(a,y);
+        }
+    } else {
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            y = m_data_to_num(x);
+            rb_ary_push(a,y);
+        }
+    }
+}
+
+/*
+  Convert self to Array.
+  @overload <%=name%>
+  @return [Array]
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
+    ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 3, 1, ain, aout };
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
+}

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

@@ -0,0 +1,132 @@
+<% if type_name == 'robject' || name == 'map' %>
+<% else %>
+void <%="cumo_#{c_iter}_index_index_kernel_launch"%>(char *p1, char *p2, size_t *idx1, size_t *idx2, uint64_t n);
+void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(char *p1, char *p2, size_t *idx1, ssize_t s2, uint64_t n);
+void <%="cumo_#{c_iter}_stride_index_kernel_launch"%>(char *p1, char *p2, ssize_t s1, size_t *idx2, uint64_t n);
+void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(char *p1, char *p2, ssize_t s1, ssize_t s2, uint64_t n);
+void <%="cumo_#{c_iter}_contiguous_kernel_launch"%>(char *p1, char *p2, uint64_t n);
+<% end %>
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  n;
+    char   *p1, *p2;
+    ssize_t s1, s2;
+    size_t *idx1, *idx2;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+
+    <% if type_name == 'robject' || name == 'map' %>
+    {
+        size_t i;
+        dtype x;
+        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        if (idx1) {
+            if (idx2) {
+                for (i=0; i<n; i++) {
+                    GET_DATA_INDEX(p1,idx1,dtype,x);
+                    x = m_<%=name%>(x);
+                    SET_DATA_INDEX(p2,idx2,dtype,x);
+                }
+            } else {
+                for (i=0; i<n; i++) {
+                    GET_DATA_INDEX(p1,idx1,dtype,x);
+                    x = m_<%=name%>(x);
+                    SET_DATA_STRIDE(p2,s2,dtype,x);
+                }
+            }
+        } else {
+            if (idx2) {
+                for (i=0; i<n; i++) {
+                    GET_DATA_STRIDE(p1,s1,dtype,x);
+                    x = m_<%=name%>(x);
+                    SET_DATA_INDEX(p2,idx2,dtype,x);
+                }
+            } else {
+                //<% if need_align %>
+                if (is_aligned(p1,sizeof(dtype)) &&
+                    is_aligned(p2,sizeof(dtype)) ) {
+                    if (s1 == sizeof(dtype) &&
+                        s2 == sizeof(dtype) ) {
+                        for (i=0; i<n; i++) {
+                            ((dtype*)p2)[i] = m_<%=name%>(((dtype*)p1)[i]);
+                        }
+                        return;
+                    }
+                    if (is_aligned_step(s1,sizeof(dtype)) &&
+                        is_aligned_step(s2,sizeof(dtype)) ) {
+                        //<% end %>
+                        for (i=0; i<n; i++) {
+                            *(dtype*)p2 = m_<%=name%>(*(dtype*)p1);
+                            p1 += s1;
+                            p2 += s2;
+                        }
+                        return;
+                        //<% if need_align %>
+                    }
+                }
+                for (i=0; i<n; i++) {
+                    GET_DATA_STRIDE(p1,s1,dtype,x);
+                    x = m_<%=name%>(x);
+                    SET_DATA_STRIDE(p2,s2,dtype,x);
+                }
+                //<% end %>
+            }
+        }
+    }
+    <% else %>
+    {
+        if (idx1) {
+            if (idx2) {
+                <%="cumo_#{c_iter}_index_index_kernel_launch"%>(p1,p2,idx1,idx2,n);
+            } else {
+                <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(p1,p2,idx1,s2,n);
+            }
+        } else {
+            if (idx2) {
+                <%="cumo_#{c_iter}_stride_index_kernel_launch"%>(p1,p2,s1,idx2,n);
+            } else {
+                //<% if need_align %>
+                if (is_aligned(p1,sizeof(dtype)) &&
+                    is_aligned(p2,sizeof(dtype)) ) {
+                    if (s1 == sizeof(dtype) &&
+                        s2 == sizeof(dtype) ) {
+                        <%="cumo_#{c_iter}_contiguous_kernel_launch"%>(p1,p2,n);
+                        return;
+                    }
+                    if (is_aligned_step(s1,sizeof(dtype)) &&
+                        is_aligned_step(s2,sizeof(dtype)) ) {
+                        //<% end %>
+                        <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(p1,p2,s1,s2,n);
+                        return;
+                        //<% if need_align %>
+                    }
+                }
+                <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(p1,p2,s1,s2,n);
+                //<% end %>
+            }
+        }
+    }
+    <% end %>
+}
+
+/*
+  Unary <%=name%>.
+  @overload <%=op_map%>
+  @return [Cumo::<%=class_name%>] <%=name%> of self.
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,1, ain,aout};
+
+    <% if name == 'map' %>
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+    <% end %>
+    return na_ndloop(&ndf, 1, self);
+}

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

@@ -0,0 +1,60 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2;
+    ssize_t s1, s2;
+    size_t *idx1, *idx2;
+    dtype   x;
+    <%=dtype%> y;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+    if (idx1) {
+        if (idx2) {
+            for (; i--;) {
+                GET_DATA_INDEX(p1,idx1,dtype,x);
+                y = m_<%=name%>(x);
+                SET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_INDEX(p1,idx1,dtype,x);
+                y = m_<%=name%>(x);
+                SET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
+            }
+        }
+    } else {
+        if (idx2) {
+            for (; i--;) {
+                GET_DATA_STRIDE(p1,s1,dtype,x);
+                y = m_<%=name%>(x);
+                SET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_STRIDE(p1,s1,dtype,x);
+                y = m_<%=name%>(x);
+                SET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
+            }
+        }
+    }
+}
+
+
+/*
+  <%=name%> of self.
+  @overload <%=name%>
+  @return [Cumo::<%=real_class_name%>] <%=name%> of self.
+*/
+static VALUE
+<%=c_func(0)%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{<%=result_class%>,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 1, ain, aout };
+
+    return na_ndloop(&ndf, 1, self);
+}