cumo 0.1.0 → 0.1.1

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

@@ -52,9 +52,9 @@ void <%="cumo_#{type_name}_mulsum#{nan}_reduce_kernel_launch"%>(char *p1, char *
 
 void <%="cumo_#{type_name}_mulsum#{nan}_kernel_launch"%>(char *p1, char *p2, char *p3, ssize_t s1, ssize_t s2, ssize_t s3, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{type_name}_mulsum#{nan}_kernel"%><<<gridDim, blockDim>>>(p1,p2,p3,s1,s2,s3,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{type_name}_mulsum#{nan}_kernel"%><<<grid_dim, block_dim>>>(p1,p2,p3,s1,s2,s3,n);
 }
 //<% end %>
 <% end %>

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

@@ -2,12 +2,12 @@
 
 <%   [64,32].each do |i| %>
 <% unless type_name == 'robject' %>
-void cumo_<%=type_name%>_<%=name%><%=nan%>_int<%=i%>_kernel_launch(na_reduction_arg_t* arg);
+void cumo_<%=type_name%>_<%=name%><%=nan%>_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg);
 <% end %>
 
 #define idx_t int<%=i%>_t
 static void
-<%=c_iter%>_index<%=i%><%=nan%>(na_loop_t *const lp)
+<%=c_iter%>_index<%=i%><%=nan%>(cumo_na_loop_t *const lp)
 {
     // TODO(sonots): Support nan in CUDA
     <% if type_name == 'robject' || nan == '_nan' %>
@@ -16,18 +16,18 @@ static void
         char    *d_ptr, *i_ptr, *o_ptr;
         ssize_t  d_step, i_step;
 
-        INIT_COUNTER(lp, n);
-        INIT_PTR(lp, 0, d_ptr, d_step);
-        INIT_PTR(lp, 1, i_ptr, i_step);
-        o_ptr = NDL_PTR(lp,2);
+        CUMO_INIT_COUNTER(lp, n);
+        CUMO_INIT_PTR(lp, 0, d_ptr, d_step);
+        CUMO_INIT_PTR(lp, 1, i_ptr, i_step);
+        o_ptr = CUMO_NDL_PTR(lp,2);
 
-        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=nan%>", "<%=type_name%>");
+        CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%><%=nan%>", "<%=type_name%>");
         idx = f_<%=name%><%=nan%>(n,d_ptr,d_step);
         *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
     }
     <% else %>
     {
-        na_reduction_arg_t arg = na_make_reduction_arg(lp);
+        cumo_na_reduction_arg_t arg = cumo_na_make_reduction_arg(lp);
         cumo_<%=type_name%>_<%=name%><%=nan%>_int<%=i%>_kernel_launch(&arg);
     }
     <% end %>
@@ -53,67 +53,67 @@ static VALUE
 {
     //<% if type_name == 'robject' %>
     {
-        narray_t *na;
+        cumo_narray_t *na;
         VALUE idx, reduce;
-        ndfunc_arg_in_t ain[3] = {{Qnil,0},{Qnil,0},{sym_reduce,0}};
-        ndfunc_arg_out_t aout[1] = {{0,0,0}};
-        ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 3,1, ain,aout};
+        cumo_ndfunc_arg_in_t ain[3] = {{Qnil,0},{Qnil,0},{cumo_sym_reduce,0}};
+        cumo_ndfunc_arg_out_t aout[1] = {{0,0,0}};
+        cumo_ndfunc_t ndf = {0, CUMO_STRIDE_LOOP_NIP|CUMO_NDF_FLAT_REDUCE|CUMO_NDF_EXTRACT, 3,1, ain,aout};
 
-        GetNArray(self,na);
+        CumoGetNArray(self,na);
         if (na->ndim==0) {
             return INT2FIX(0);
         }
         if (na->size > (~(u_int32_t)0)) {
             aout[0].type = cumo_cInt64;
-            idx = nary_new(cumo_cInt64, na->ndim, na->shape);
+            idx = cumo_na_new(cumo_cInt64, na->ndim, na->shape);
             ndf.func = <%=c_iter%>_index64;
             <% if is_float %>
-            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index64_nan);
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index64_nan);
             <% else %>
-            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
             <% end %>
         } else {
             aout[0].type = cumo_cInt32;
-            idx = nary_new(cumo_cInt32, na->ndim, na->shape);
+            idx = cumo_na_new(cumo_cInt32, na->ndim, na->shape);
             ndf.func = <%=c_iter%>_index32;
             <% if is_float %>
-            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index32_nan);
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index32_nan);
             <% else %>
-            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
             <% end %>
         }
         rb_funcall(idx, rb_intern("seq"), 0);
 
-        return na_ndloop(&ndf, 3, self, idx, reduce);
+        return cumo_na_ndloop(&ndf, 3, self, idx, reduce);
     }
     <% else %>
     {
-        narray_t *na;
+        cumo_narray_t *na;
         VALUE reduce;
-        ndfunc_arg_in_t ain[2] = {{Qnil,0},{sym_reduce,0}};
-        ndfunc_arg_out_t aout[1] = {{0,0,0}};
-        ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT|NDF_INDEXER_LOOP, 2,1, ain,aout};
+        cumo_ndfunc_arg_in_t ain[2] = {{Qnil,0},{cumo_sym_reduce,0}};
+        cumo_ndfunc_arg_out_t aout[1] = {{0,0,0}};
+        cumo_ndfunc_t ndf = {0, CUMO_STRIDE_LOOP_NIP|CUMO_NDF_FLAT_REDUCE|CUMO_NDF_EXTRACT|CUMO_NDF_INDEXER_LOOP, 2,1, ain,aout};
 
-        GetNArray(self,na);
+        CumoGetNArray(self,na);
         if (na->size > (~(u_int32_t)0)) {
             aout[0].type = cumo_cInt64;
             ndf.func = <%=c_iter%>_index64;
             <% if is_float %>
-            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index64_nan);
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index64_nan);
             <% else %>
-            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
             <% end %>
         } else {
             aout[0].type = cumo_cInt32;
             ndf.func = <%=c_iter%>_index32;
             <% if is_float %>
-            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index32_nan);
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, <%=c_iter%>_index32_nan);
             <% else %>
-            reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+            reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
             <% end %>
         }
 
-        return na_ndloop(&ndf, 2, self, reduce);
+        return cumo_na_ndloop(&ndf, 2, self, reduce);
     }
     <% end %>
 }

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

@@ -49,12 +49,12 @@ extern "C" {
 #endif
 #endif
 
-void cumo_<%=type_name%>_min_index_int<%=i%>_kernel_launch(na_reduction_arg_t* arg)
+void cumo_<%=type_name%>_min_index_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce<dtype, idx_t, cumo_<%=type_name%>_min_index_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_min_index_int<%=i%>_impl{});
 }
 
-void cumo_<%=type_name%>_max_index_int<%=i%>_kernel_launch(na_reduction_arg_t* arg)
+void cumo_<%=type_name%>_max_index_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce<dtype, idx_t, cumo_<%=type_name%>_max_index_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_max_index_int<%=i%>_impl{});
 }

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

@@ -2,11 +2,11 @@
 <% $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) %>
+<%= load_erb("real_accum").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) %>
+<%= load_erb("float_accum").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) %>
+<%= load_erb("complex_accum").result(binding) %>
 <% end %>
 
 <% end %>

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

@@ -1,14 +1,14 @@
 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;
+    size_t size = sizeof(cumo_narray_data_t);
+    const cumo_narray_data_t *na = (const cumo_narray_data_t*)ptr;
 
-    assert(na->base.type == NARRAY_DATA_T);
+    assert(na->base.type == CUMO_NARRAY_DATA_T);
 
     if (na->ptr != NULL) {
   <% if is_bit %>
-        size += ((na->base.size-1)/8/sizeof(BIT_DIGIT)+1)*sizeof(BIT_DIGIT);
+        size += ((na->base.size-1)/8/sizeof(CUMO_BIT_DIGIT)+1)*sizeof(CUMO_BIT_DIGIT);
   <% else %>
         size += na->base.size * sizeof(dtype);
   <% end %>
@@ -24,9 +24,9 @@ static size_t
 static void
 <%=type_name%>_free(void* ptr)
 {
-    narray_data_t *na = (narray_data_t*)ptr;
+    cumo_narray_data_t *na = (cumo_narray_data_t*)ptr;
 
-    assert(na->base.type == NARRAY_DATA_T);
+    assert(na->base.type == CUMO_NARRAY_DATA_T);
 
     if (na->ptr != NULL) {
         cumo_cuda_runtime_free(na->ptr);
@@ -41,7 +41,7 @@ static void
     xfree(na);
 }
 
-static narray_type_info_t <%=type_name%>_info = {
+static cumo_narray_type_info_t <%=type_name%>_info = {
   <% if is_bit %>
     1,             // element_bits
     0,             // element_bytes
@@ -59,7 +59,7 @@ static void
 {
     size_t n, i;
     VALUE *a;
-    narray_data_t *na = ptr;
+    cumo_narray_data_t *na = ptr;
 
     if (na->ptr) {
         a = (VALUE*)(na->ptr);
@@ -73,7 +73,7 @@ static void
 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,
+    &cumo_na_data_type,
     &<%=type_name%>_info,
     0, // flags
 };
@@ -83,7 +83,7 @@ static const rb_data_type_t <%=type_name%>_data_type = {
 static const rb_data_type_t <%=type_name%>_data_type = {
     "<%=full_class_name%>",
     {0, <%=type_name%>_free, <%=type_name%>_memsize,},
-    &na_data_type,
+    &cumo_na_data_type,
     &<%=type_name%>_info,
     0, // flags
 };
@@ -93,12 +93,12 @@ static const rb_data_type_t <%=type_name%>_data_type = {
 static VALUE
 <%=c_func(0)%>(VALUE klass)
 {
-    narray_data_t *na = ALLOC(narray_data_t);
+    cumo_narray_data_t *na = ALLOC(cumo_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.type = CUMO_NARRAY_DATA_T;
+    na->base.flag[0] = CUMO_NA_FL0_INIT;
+    na->base.flag[1] = CUMO_NA_FL1_INIT;
     na->base.size = 0;
     na->base.shape = NULL;
     na->base.reduce = INT2FIX(0);

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

@@ -1,14 +1,14 @@
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    narray_t *na;
+    cumo_narray_t *na;
     void *ptr;
 
-    GetNArray(self,na);
+    CumoGetNArray(self,na);
 
-    switch(NA_TYPE(na)) {
-    case NARRAY_DATA_T:
-        ptr = NA_DATA_PTR(na);
+    switch(CUMO_NA_TYPE(na)) {
+    case CUMO_NARRAY_DATA_T:
+        ptr = CUMO_NA_DATA_PTR(na);
         if (na->size > 0 && ptr == NULL) {
             <% if is_object %>
             ptr = xmalloc(sizeof(dtype) * na->size);
@@ -21,17 +21,17 @@ static VALUE
             <% else %>
             ptr = cumo_cuda_runtime_malloc(sizeof(dtype) * na->size);
             <% end %>
-            NA_DATA_PTR(na) = ptr;
+            CUMO_NA_DATA_PTR(na) = ptr;
         }
         break;
-    case NARRAY_VIEW_T:
-        rb_funcall(NA_VIEW_DATA(na), rb_intern("allocate"), 0);
+    case CUMO_NARRAY_VIEW_T:
+        rb_funcall(CUMO_NA_VIEW_DATA(na), rb_intern("allocate"), 0);
         break;
-    case NARRAY_FILEMAP_T:
-        //ptr = ((narray_filemap_t*)na)->ptr;
+    case CUMO_NARRAY_FILEMAP_T:
+        //ptr = ((cumo_narray_filemap_t*)na)->ptr;
         // to be implemented
     default:
-        rb_bug("invalid narray type : %d",NA_TYPE(na));
+        rb_bug("invalid narray type : %d",CUMO_NA_TYPE(na));
     }
     return self;
 }

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

@@ -60,7 +60,7 @@ static VALUE
         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);
+        result_nd = cumo_na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
+        return cumo_na_aref_main(argc, argv, self, 0, result_nd, pos);
     }
 }

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

@@ -38,12 +38,12 @@ static VALUE
     size_t pos;
     char *ptr;
 
-    result_nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
+    result_nd = cumo_na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
     if (result_nd) {
-        return na_aref_main(argc, argv, self, 0, result_nd, pos);
+        return cumo_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%>");
+        ptr = cumo_na_get_pointer_for_read(self) + pos;
+        CUMO_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

@@ -48,8 +48,8 @@ static VALUE
     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);
+        nd = cumo_na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
+        a = cumo_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

@@ -12,11 +12,11 @@
 //<% 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);
+void <%="cumo_#{c_iter}_kernel_launch"%>(cumo_na_iarray_t* a1, cumo_na_iarray_t* a2, cumo_na_iarray_t* a3, cumo_na_indexer_t* indexer);
 <% end %>
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     <% if type_name == 'robject' %>
     {
@@ -24,16 +24,16 @@ static void
         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);
+        CUMO_INIT_COUNTER(lp, n);
+        CUMO_INIT_PTR(lp, 0, p1, s1);
+        CUMO_INIT_PTR(lp, 1, p2, s2);
+        CUMO_INIT_PTR(lp, 2, p3, s3);
 
-        SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+        CUMO_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 (cumo_is_aligned(p1,sizeof(dtype)) &&
+            cumo_is_aligned(p2,sizeof(dtype)) &&
+            cumo_is_aligned(p3,sizeof(dtype)) ) {
 
             if (s1 == sizeof(dtype) &&
                 s2 == sizeof(dtype) &&
@@ -52,9 +52,9 @@ static void
                 }
                 return;
             }
-            if (is_aligned_step(s1,sizeof(dtype)) &&
-                is_aligned_step(s2,sizeof(dtype)) &&
-                is_aligned_step(s3,sizeof(dtype)) ) {
+            if (cumo_is_aligned_step(s1,sizeof(dtype)) &&
+                cumo_is_aligned_step(s2,sizeof(dtype)) &&
+                cumo_is_aligned_step(s3,sizeof(dtype)) ) {
                 //<% end %>
 
                 if (s2 == 0){ // Broadcasting from scalar value.
@@ -102,20 +102,20 @@ static void
         }
         for (i=0; i<n; i++) {
             dtype x, y, z;
-            GET_DATA_STRIDE(p1,s1,dtype,x);
-            GET_DATA_STRIDE(p2,s2,dtype,y);
+            CUMO_GET_DATA_STRIDE(p1,s1,dtype,x);
+            CUMO_GET_DATA_STRIDE(p2,s2,dtype,y);
             check_intdivzero(y);
             z = m_<%=name%>(x,y);
-            SET_DATA_STRIDE(p3,s3,dtype,z);
+            CUMO_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_na_iarray_t a1 = cumo_na_make_iarray(&lp->args[0]);
+        cumo_na_iarray_t a2 = cumo_na_make_iarray(&lp->args[1]);
+        cumo_na_iarray_t a3 = cumo_na_make_iarray(&lp->args[2]);
+        cumo_na_indexer_t indexer = cumo_na_make_indexer(&lp->args[0]);
 
         <%="cumo_#{c_iter}_kernel_launch"%>(&a1,&a2,&a3,&indexer);
     }
@@ -126,15 +126,15 @@ static void
 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}};
+    cumo_ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cT,0}};
     <% if type_name == 'robject' %>
-    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 1, ain, aout };
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_STRIDE_LOOP, 2, 1, ain, aout };
     <% else %>
-    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP|NDF_INDEXER_LOOP, 2, 1, ain, aout };
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_STRIDE_LOOP|CUMO_NDF_INDEXER_LOOP, 2, 1, ain, aout };
     <% end %>
 
-    return na_ndloop(&ndf, 2, self, other);
+    return cumo_na_ndloop(&ndf, 2, self, other);
 }
 
 /*
@@ -151,12 +151,12 @@ static VALUE
     <% else %>
     VALUE klass, v;
 
-    klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
+    klass = cumo_na_upcast(rb_obj_class(self),rb_obj_class(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);
+        v = rb_funcall(klass, cumo_id_cast, 1, self);
+        return rb_funcall(v, <%=cumo_id_op%>, 1, other);
     }
     <% end %>
 }