cumo 0.1.0 → 0.1.1

data/ext/cumo/narray/gen/tmpl_bit/bit_count.c

@@ -1,24 +1,24 @@
 #undef int_t
 #define int_t uint64_t
 
-void <%="cumo_#{c_iter}_index_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, size_t *idx1, uint64_t n);
-void <%="cumo_#{c_iter}_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, ssize_t s1, uint64_t n);
-void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, size_t *idx1, ssize_t s2, uint64_t n);
-void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, ssize_t s1, ssize_t s2, uint64_t n);
+void <%="cumo_#{c_iter}_index_kernel_launch"%>(size_t p1, char *p2, CUMO_BIT_DIGIT *a1, size_t *idx1, uint64_t n);
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(size_t p1, char *p2, CUMO_BIT_DIGIT *a1, ssize_t s1, uint64_t n);
+void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(size_t p1, char *p2, CUMO_BIT_DIGIT *a1, size_t *idx1, ssize_t s2, uint64_t n);
+void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(size_t p1, char *p2, CUMO_BIT_DIGIT *a1, ssize_t s1, ssize_t s2, uint64_t n);
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
-    BIT_DIGIT *a1;
+    CUMO_BIT_DIGIT *a1;
     size_t  p1;
     char   *p2;
     ssize_t s1, s2;
     size_t *idx1;
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-    INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
 
     if (s2==0) {
         if (idx1) {
@@ -53,12 +53,12 @@ static VALUE
         return <%=c_func(-1)%>_cpu(argc, argv, self);
     } else {
         VALUE v, reduce;
-        ndfunc_arg_in_t ain[3] = {{cT,0},{sym_reduce,0},{sym_init,0}};
-        ndfunc_arg_out_t aout[1] = {{cumo_cUInt64,0}};
-        ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 3, 1, ain, aout };
+        cumo_ndfunc_arg_in_t ain[3] = {{cT,0},{cumo_sym_reduce,0},{cumo_sym_init,0}};
+        cumo_ndfunc_arg_out_t aout[1] = {{cumo_cUInt64,0}};
+        cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_FULL_LOOP_NIP, 3, 1, ain, aout };
 
-        reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
-        v = na_ndloop(&ndf, 3, self, reduce, INT2FIX(0));
+        reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+        v = cumo_na_ndloop(&ndf, 3, self, reduce, INT2FIX(0));
         return v;
     }
 }

data/ext/cumo/narray/gen/tmpl_bit/bit_count_cpu.c

@@ -2,28 +2,28 @@
 #define int_t int64_t
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t  i;
-    BIT_DIGIT *a1;
+    CUMO_BIT_DIGIT *a1;
     size_t  p1;
     char   *p2;
     ssize_t s1, s2;
     size_t *idx1;
-    BIT_DIGIT x=0;
+    CUMO_BIT_DIGIT x=0;
     int_t   y;
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-    INIT_PTR(lp, 1, p2, s2);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    CUMO_INIT_PTR(lp, 1, p2, s2);
     if (s2==0) {
-        GET_DATA(p2, int_t, y);
+        CUMO_GET_DATA(p2, int_t, y);
         if (idx1) {
             for (; i--;) {
-                LOAD_BIT(a1, p1+*idx1, x);
+                CUMO_LOAD_BIT(a1, p1+*idx1, x);
                 idx1++;
                 if (m_<%=name%>(x)) {
                     y++;
@@ -31,7 +31,7 @@ static void
             }
         } else {
             for (; i--;) {
-                LOAD_BIT(a1, p1, x);
+                CUMO_LOAD_BIT(a1, p1, x);
                 p1 += s1;
                 if (m_<%=name%>(x)) {
                     y++;
@@ -42,23 +42,23 @@ static void
     } else {
         if (idx1) {
             for (; i--;) {
-                LOAD_BIT(a1, p1+*idx1, x);
+                CUMO_LOAD_BIT(a1, p1+*idx1, x);
                 idx1++;
                 if (m_<%=name%>(x)) {
-                    GET_DATA(p2, int_t, y);
+                    CUMO_GET_DATA(p2, int_t, y);
                     y++;
-                    SET_DATA(p2, int_t, y);
+                    CUMO_SET_DATA(p2, int_t, y);
                 }
                 p2+=s2;
             }
         } else {
             for (; i--;) {
-                LOAD_BIT(a1, p1, x);
+                CUMO_LOAD_BIT(a1, p1, x);
                 p1+=s1;
                 if (m_<%=name%>(x)) {
-                    GET_DATA(p2, int_t, y);
+                    CUMO_GET_DATA(p2, int_t, y);
                     y++;
-                    SET_DATA(p2, int_t, y);
+                    CUMO_SET_DATA(p2, int_t, y);
                 }
                 p2+=s2;
             }
@@ -78,11 +78,11 @@ static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     VALUE v, reduce;
-    ndfunc_arg_in_t ain[3] = {{cT,0},{sym_reduce,0},{sym_init,0}};
-    ndfunc_arg_out_t aout[1] = {{cumo_cInt64,0}};
-    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 3, 1, ain, aout };
+    cumo_ndfunc_arg_in_t ain[3] = {{cT,0},{cumo_sym_reduce,0},{cumo_sym_init,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cumo_cInt64,0}};
+    cumo_ndfunc_t ndf = { <%=c_iter%>, CUMO_FULL_LOOP_NIP, 3, 1, ain, aout };
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
-    v = na_ndloop(&ndf, 3, self, reduce, INT2FIX(0));
+    reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+    v = cumo_na_ndloop(&ndf, 3, self, reduce, INT2FIX(0));
     return rb_funcall(v,rb_intern("extract_cpu"),0);
 }

data/ext/cumo/narray/gen/tmpl_bit/bit_count_kernel.cu

@@ -1,76 +1,76 @@
 #undef int_t
 #define int_t unsigned long long int
 
-__global__ void <%="cumo_#{c_iter}_index_kernel"%>(size_t p1, char* p2, BIT_DIGIT *a1, size_t *idx1, uint64_t n)
+__global__ void <%="cumo_#{c_iter}_index_kernel"%>(size_t p1, char* p2, CUMO_BIT_DIGIT *a1, size_t *idx1, uint64_t n)
 {
     for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
-        BIT_DIGIT x=0;
-        LOAD_BIT(a1, p1 + idx1[i], x);
+        CUMO_BIT_DIGIT x=0;
+        CUMO_LOAD_BIT(a1, p1 + idx1[i], x);
         if (m_<%=name%>(x)) {
             atomicAdd((int_t*)p2, (int_t)1);
         }
     }
 }
 
-__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(size_t p1, char* p2, BIT_DIGIT *a1, ssize_t s1, uint64_t n)
+__global__ void <%="cumo_#{c_iter}_stride_kernel"%>(size_t p1, char* p2, CUMO_BIT_DIGIT *a1, ssize_t s1, uint64_t n)
 {
     for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
-        BIT_DIGIT x=0;
-        LOAD_BIT(a1, p1 + i * s1, x);
+        CUMO_BIT_DIGIT x=0;
+        CUMO_LOAD_BIT(a1, p1 + i * s1, x);
         if (m_<%=name%>(x)) {
             atomicAdd((int_t*)p2, (int_t)1);
         }
     }
 }
 
-__global__ void <%="cumo_#{c_iter}_index_stride_kernel"%>(size_t p1, char* p2, BIT_DIGIT *a1, size_t *idx1, ssize_t s2, uint64_t n)
+__global__ void <%="cumo_#{c_iter}_index_stride_kernel"%>(size_t p1, char* p2, CUMO_BIT_DIGIT *a1, 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=0;
-        LOAD_BIT(a1, p1 + idx1[i], x);
+        CUMO_BIT_DIGIT x=0;
+        CUMO_LOAD_BIT(a1, p1 + idx1[i], x);
         if (m_<%=name%>(x)) {
             atomicAdd((int_t*)(p2 + i * s2), (int_t)1);
         }
     }
 }
 
-__global__ void <%="cumo_#{c_iter}_stride_stride_kernel"%>(size_t p1, char* p2, BIT_DIGIT *a1, ssize_t s1, ssize_t s2, uint64_t n)
+__global__ void <%="cumo_#{c_iter}_stride_stride_kernel"%>(size_t p1, char* p2, CUMO_BIT_DIGIT *a1, 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=0;
-        LOAD_BIT(a1, p1 + i * s1, x);
+        CUMO_BIT_DIGIT x=0;
+        CUMO_LOAD_BIT(a1, p1 + i * s1, x);
         if (m_<%=name%>(x)) {
             atomicAdd((int_t*)(p2 + i * s2), (int_t)1);
         }
     }
 }
 
-void <%="cumo_#{c_iter}_index_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, size_t *idx1, uint64_t n)
+void <%="cumo_#{c_iter}_index_kernel_launch"%>(size_t p1, char *p2, CUMO_BIT_DIGIT *a1, size_t *idx1, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_index_kernel"%><<<gridDim, blockDim>>>(p1,p2,a1,idx1,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_index_kernel"%><<<grid_dim, block_dim>>>(p1,p2,a1,idx1,n);
 }
 
-void <%="cumo_#{c_iter}_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, ssize_t s1, uint64_t n)
+void <%="cumo_#{c_iter}_stride_kernel_launch"%>(size_t p1, char *p2, CUMO_BIT_DIGIT *a1, ssize_t s1, uint64_t n)
 {
-    size_t gridDim = get_gridDim(n);
-    size_t blockDim = get_blockDim(n);
-    <%="cumo_#{c_iter}_stride_kernel"%><<<gridDim, blockDim>>>(p1,p2,a1,s1,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_stride_kernel"%><<<grid_dim, block_dim>>>(p1,p2,a1,s1,n);
 }
 
-void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, size_t *idx1, ssize_t s2, uint64_t n)
+void <%="cumo_#{c_iter}_index_stride_kernel_launch"%>(size_t p1, char *p2, CUMO_BIT_DIGIT *a1, 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,a1,idx1,s2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_index_stride_kernel"%><<<grid_dim, block_dim>>>(p1,p2,a1,idx1,s2,n);
 }
 
-void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(size_t p1, char *p2, BIT_DIGIT *a1, ssize_t s1, ssize_t s2, uint64_t n)
+void <%="cumo_#{c_iter}_stride_stride_kernel_launch"%>(size_t p1, char *p2, CUMO_BIT_DIGIT *a1, 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,a1,s1,s2,n);
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    <%="cumo_#{c_iter}_stride_stride_kernel"%><<<grid_dim, block_dim>>>(p1,p2,a1,s1,s2,n);
 }
 
 #undef int_t

data/ext/cumo/narray/gen/tmpl_bit/bit_reduce.c

@@ -1,28 +1,28 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t     i;
-    BIT_DIGIT *a1, *a2;
+    CUMO_BIT_DIGIT *a1, *a2;
     size_t     p1,  p2;
     ssize_t    s1,  s2;
     size_t    *idx1, *idx2;
-    BIT_DIGIT  x=0, y=0;
+    CUMO_BIT_DIGIT  x=0, y=0;
 
     // TODO(sonots): CUDA kernelize
-    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-    INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    CUMO_INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
     if (idx2) {
         if (idx1) {
             for (; i--;) {
-                LOAD_BIT(a2, p2+*idx2, y);
+                CUMO_LOAD_BIT(a2, p2+*idx2, y);
                 if (y == <%=init_bit%>) {
-                    LOAD_BIT(a1, p1+*idx1, x);
+                    CUMO_LOAD_BIT(a1, p1+*idx1, x);
                     if (x != <%=init_bit%>) {
-                        STORE_BIT(a2, p2+*idx2, x);
+                        CUMO_STORE_BIT(a2, p2+*idx2, x);
                     }
                 }
                 idx1++;
@@ -30,11 +30,11 @@ static void
             }
         } else {
             for (; i--;) {
-                LOAD_BIT(a2, p2+*idx2, y);
+                CUMO_LOAD_BIT(a2, p2+*idx2, y);
                 if (y == <%=init_bit%>) {
-                    LOAD_BIT(a1, p1, x);
+                    CUMO_LOAD_BIT(a1, p1, x);
                     if (x != <%=init_bit%>) {
-                        STORE_BIT(a2, p2+*idx2, x);
+                        CUMO_STORE_BIT(a2, p2+*idx2, x);
                     }
                 }
                 p1 += s1;
@@ -44,11 +44,11 @@ static void
     } else if (s2) {
         if (idx1) {
             for (; i--;) {
-                LOAD_BIT(a2, p2, y);
+                CUMO_LOAD_BIT(a2, p2, y);
                 if (y == <%=init_bit%>) {
-                    LOAD_BIT(a1, p1+*idx1, x);
+                    CUMO_LOAD_BIT(a1, p1+*idx1, x);
                     if (x != <%=init_bit%>) {
-                        STORE_BIT(a2, p2, x);
+                        CUMO_STORE_BIT(a2, p2, x);
                     }
                 }
                 idx1++;
@@ -56,11 +56,11 @@ static void
             }
         } else {
             for (; i--;) {
-                LOAD_BIT(a2, p2, y);
+                CUMO_LOAD_BIT(a2, p2, y);
                 if (y == <%=init_bit%>) {
-                    LOAD_BIT(a1, p1, x);
+                    CUMO_LOAD_BIT(a1, p1, x);
                     if (x != <%=init_bit%>) {
-                        STORE_BIT(a2, p2, x);
+                        CUMO_STORE_BIT(a2, p2, x);
                     }
                 }
                 p1 += s1;
@@ -68,24 +68,24 @@ static void
             }
         }
     } else {
-        LOAD_BIT(a2, p2, x);
+        CUMO_LOAD_BIT(a2, p2, x);
         if (x != <%=init_bit%>) {
             return;
         }
         if (idx1) {
             for (; i--;) {
-                LOAD_BIT(a1, p1+*idx1, y);
+                CUMO_LOAD_BIT(a1, p1+*idx1, y);
                 if (y != <%=init_bit%>) {
-                    STORE_BIT(a2, p2, y);
+                    CUMO_STORE_BIT(a2, p2, y);
                     return;
                 }
                 idx1++;
             }
         } else {
             for (; i--;) {
-                LOAD_BIT(a1, p1, y);
+                CUMO_LOAD_BIT(a1, p1, y);
                 if (y != <%=init_bit%>) {
-                    STORE_BIT(a2, p2, y);
+                    CUMO_STORE_BIT(a2, p2, y);
                     return;
                 }
                 p1 += s1;
@@ -111,12 +111,12 @@ static VALUE
 <%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     VALUE v, reduce;
-    ndfunc_arg_in_t ain[3] = {{cT,0},{sym_reduce,0},{sym_init,0}};
-    ndfunc_arg_out_t aout[1] = {{cumo_cBit,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 3,1, ain,aout};
+    cumo_ndfunc_arg_in_t ain[3] = {{cT,0},{cumo_sym_reduce,0},{cumo_sym_init,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{cumo_cBit,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP_NIP, 3,1, ain,aout};
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
-    v = na_ndloop(&ndf, 3, self, reduce, INT2FIX(<%=init_bit%>));
+    reduce = cumo_na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
+    v = cumo_na_ndloop(&ndf, 3, self, reduce, INT2FIX(<%=init_bit%>));
     if (argc > 0) {
         return v;
     }

data/ext/cumo/narray/gen/tmpl_bit/each.c

@@ -1,28 +1,28 @@
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t   i;
-    BIT_DIGIT *a1, x=0;
+    CUMO_BIT_DIGIT *a1, x=0;
     size_t   p1;
     ssize_t  s1;
     size_t  *idx1;
     VALUE  y;
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
     if (idx1) {
         for (; i--;) {
-            LOAD_BIT(a1, p1+*idx1, x); idx1++;
+            CUMO_LOAD_BIT(a1, p1+*idx1, x); idx1++;
             y = m_data_to_num(x);
             rb_yield(y);
         }
     } else {
         for (; i--;) {
-            LOAD_BIT(a1, p1, x); p1+=s1;
+            CUMO_LOAD_BIT(a1, p1, x); p1+=s1;
             y = m_data_to_num(x);
             rb_yield(y);
         }
@@ -40,9 +40,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};
+    cumo_ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP_NIP, 1,0, ain,0};
 
-    na_ndloop(&ndf, 1, self);
+    cumo_na_ndloop(&ndf, 1, self);
     return self;
 }

data/ext/cumo/narray/gen/tmpl_bit/each_with_index.c

@@ -12,10 +12,10 @@ yield_each_with_index(dtype x, size_t *c, VALUE *a, int nd, int md)
 
 
 static void
-<%=c_iter%>(na_loop_t *const lp)
+<%=c_iter%>(cumo_na_loop_t *const lp)
 {
     size_t   i;
-    BIT_DIGIT *a1, x=0;
+    CUMO_BIT_DIGIT *a1, x=0;
     size_t   p1;
     ssize_t  s1;
     size_t  *idx1;
@@ -29,22 +29,22 @@ static void
     md = lp->ndim + 1;
     a = ALLOCA_N(VALUE,md);
 
-    INIT_COUNTER(lp, i);
-    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    CUMO_INIT_COUNTER(lp, i);
+    CUMO_INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
     c[nd] = 0;
 
-    SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("<%=name%>", "<%=type_name%>");
     cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
 
     if (idx1) {
         for (; i--;) {
-            LOAD_BIT(a1, p1+*idx1, x); idx1++;
+            CUMO_LOAD_BIT(a1, p1+*idx1, x); idx1++;
             yield_each_with_index(x,c,a,nd,md);
             c[nd]++;
         }
     } else {
         for (; i--;) {
-            LOAD_BIT(a1, p1, x); p1+=s1;
+            CUMO_LOAD_BIT(a1, p1, x); p1+=s1;
             yield_each_with_index(x,c,a,nd,md);
             c[nd]++;
         }
@@ -62,9 +62,9 @@ static void
 static VALUE
 <%=c_func(0)%>(VALUE self)
 {
-    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
-    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};
+    cumo_ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    cumo_ndfunc_t ndf = {<%=c_iter%>, CUMO_FULL_LOOP_NIP, 1,0, ain,0};
 
-    na_ndloop_with_index(&ndf, 1, self);
+    cumo_na_ndloop_with_index(&ndf, 1, self);
     return self;
 }