cumo 0.6.0 → 0.7.0

data/ext/cumo/include/cumo/types/half_macro_kernel.h

@@ -0,0 +1,198 @@
+#ifndef CUMO_HALF_MACRO_KERNEL_H
+#define CUMO_HALF_MACRO_KERNEL_H
+
+#include "float_def_kernel.h"
+#include "half_def_kernel.h"
+#include <string.h>
+
+#define CUMO_HALF_EPSILON 9.765625e-04f
+
+#define m_zero cumo_float2half(0.0f)
+#define m_one  cumo_float2half(1.0f)
+
+#define m_from_double(x) cumo_double2half((double)(x))
+#define m_from_real(x)   cumo_double2half((double)(x))
+#define m_from_sint(x)   cumo_double2half((double)(x))
+#define m_from_int32(x)  cumo_double2half((double)(x))
+#define m_from_int64(x)  cumo_double2half((double)(x))
+#define m_from_uint32(x) cumo_double2half((double)(x))
+#define m_from_uint64(x) cumo_double2half((double)(x))
+#define m_from_half(x)   (x)
+
+// Overloaded rather than substituted, so that a scan or a reduction can apply
+// the same rule to its own wider accumulator.
+__host__ __device__ static inline float cumo_half_add(float x, float y) { return x + y; }
+__host__ __device__ static inline float cumo_half_sub(float x, float y) { return x - y; }
+__host__ __device__ static inline float cumo_half_mul(float x, float y) { return x * y; }
+__host__ __device__ static inline float cumo_half_div(float x, float y) { return x / y; }
+__host__ __device__ static inline bool cumo_half_not_nan(float x) { return x == x; }
+__host__ __device__ static inline cumo_half cumo_half_add(cumo_half x, cumo_half y) { return cumo_float2half(cumo_half2float(x) + cumo_half2float(y)); }
+__host__ __device__ static inline cumo_half cumo_half_sub(cumo_half x, cumo_half y) { return cumo_float2half(cumo_half2float(x) - cumo_half2float(y)); }
+__host__ __device__ static inline cumo_half cumo_half_mul(cumo_half x, cumo_half y) { return cumo_float2half(cumo_half2float(x) * cumo_half2float(y)); }
+__host__ __device__ static inline cumo_half cumo_half_div(cumo_half x, cumo_half y) { return cumo_float2half(cumo_half2float(x) / cumo_half2float(y)); }
+__host__ __device__ static inline bool cumo_half_not_nan(cumo_half x) { return cumo_half2float(x) == cumo_half2float(x); }
+
+#define m_add(x,y) cumo_half_add(x,y)
+#define m_sub(x,y) cumo_half_sub(x,y)
+#define m_mul(x,y) cumo_half_mul(x,y)
+#define m_div(x,y) cumo_half_div(x,y)
+#define m_div_check(x,y) (cumo_half2float(y)==0)
+
+__host__ __device__ static inline float cumo_half_floored_mod(float x, float y)
+{
+    float r = fmodf(x,y);
+    if (r != 0 && ((r < 0) != (y < 0))) {
+        r += y;
+    }
+    return r;
+}
+
+#define m_mod(x,y) cumo_float2half(cumo_half_floored_mod(cumo_half2float(x),cumo_half2float(y)))
+#define m_divmod(x,y,a,b)                                               \
+    {float cumo_h_x = cumo_half2float(x), cumo_h_y = cumo_half2float(y); \
+     float cumo_h_b = fmodf(cumo_h_x,cumo_h_y);                         \
+     float cumo_h_a = roundf((cumo_h_x-cumo_h_b)/cumo_h_y);             \
+     if (cumo_h_b != 0 && ((cumo_h_b < 0) != (cumo_h_y < 0))) {         \
+         cumo_h_b += cumo_h_y; cumo_h_a -= 1;                           \
+     }                                                                  \
+     a = cumo_float2half(cumo_h_a); b = cumo_float2half(cumo_h_b);}
+#define m_pow(x,y) cumo_float2half(powf(cumo_half2float(x),cumo_half2float(y)))
+#define m_pow_int(x,y) cumo_float2half(cumo_half_pow_int(cumo_half2float(x),(int)(y)))
+
+#define m_abs(x)     cumo_float2half(fabsf(cumo_half2float(x)))
+#define m_minus(x)   cumo_float2half(-cumo_half2float(x))
+#define m_reciprocal(x) cumo_float2half(1.0f/cumo_half2float(x))
+#define m_square(x)  cumo_float2half(cumo_half2float(x)*cumo_half2float(x))
+#define m_floor(x)   cumo_float2half(floorf(cumo_half2float(x)))
+#define m_round(x)   cumo_float2half(roundf(cumo_half2float(x)))
+#define m_ceil(x)    cumo_float2half(ceilf(cumo_half2float(x)))
+#define m_trunc(x)   cumo_float2half(truncf(cumo_half2float(x)))
+#define m_rint(x)    cumo_float2half(rintf(cumo_half2float(x)))
+#define m_sign(x)    cumo_float2half(cumo_half_sign(cumo_half2float(x)))
+#define m_copysign(x,y) cumo_float2half(copysignf(cumo_half2float(x),cumo_half2float(y)))
+#define m_signbit(x) signbit(cumo_half2float(x))
+#define m_modf(x,y,z) {float cumo_h_i; float cumo_h_f = modff(cumo_half2float(x),&cumo_h_i); y = cumo_float2half(cumo_h_f); z = cumo_float2half(cumo_h_i);}
+
+#define m_eq(x,y) (cumo_half2float(x)==cumo_half2float(y))
+#define m_ne(x,y) (cumo_half2float(x)!=cumo_half2float(y))
+#define m_gt(x,y) (cumo_half2float(x)>cumo_half2float(y))
+#define m_ge(x,y) (cumo_half2float(x)>=cumo_half2float(y))
+#define m_lt(x,y) (cumo_half2float(x)<cumo_half2float(y))
+#define m_le(x,y) (cumo_half2float(x)<=cumo_half2float(y))
+
+#define m_isnan(x) isnan(cumo_half2float(x))
+#define m_isinf(x) isinf(cumo_half2float(x))
+#define m_isposinf(x) (isinf(cumo_half2float(x)) && signbit(cumo_half2float(x))==0)
+#define m_isneginf(x) (isinf(cumo_half2float(x)) && signbit(cumo_half2float(x)))
+#define m_isfinite(x) isfinite(cumo_half2float(x))
+
+#define not_nan(x) cumo_half_not_nan(x)
+
+#define m_mulsum_init m_zero
+
+#define m_sprintf(s,x) sprintf(s,"%g",cumo_half2float(x))
+
+#define m_sqrt(x)    cumo_float2half(sqrtf(cumo_half2float(x)))
+#define m_cbrt(x)    cumo_float2half(cbrtf(cumo_half2float(x)))
+#define m_log(x)     cumo_float2half(logf(cumo_half2float(x)))
+#define m_log2(x)    cumo_float2half(log2f(cumo_half2float(x)))
+#define m_log10(x)   cumo_float2half(log10f(cumo_half2float(x)))
+#define m_exp(x)     cumo_float2half(expf(cumo_half2float(x)))
+#define m_exp2(x)    cumo_float2half(exp2f(cumo_half2float(x)))
+#ifdef HAVE_EXP10
+#define m_exp10(x)   cumo_float2half(exp10f(cumo_half2float(x)))
+#else
+#define m_exp10(x)   cumo_float2half(powf(10.0f,cumo_half2float(x)))
+#endif
+#define m_expm1(x)   cumo_float2half(expm1f(cumo_half2float(x)))
+#define m_log1p(x)   cumo_float2half(log1pf(cumo_half2float(x)))
+
+#define m_sin(x)     cumo_float2half(sinf(cumo_half2float(x)))
+#define m_cos(x)     cumo_float2half(cosf(cumo_half2float(x)))
+#define m_tan(x)     cumo_float2half(tanf(cumo_half2float(x)))
+#define m_asin(x)    cumo_float2half(asinf(cumo_half2float(x)))
+#define m_acos(x)    cumo_float2half(acosf(cumo_half2float(x)))
+#define m_atan(x)    cumo_float2half(atanf(cumo_half2float(x)))
+#define m_sinh(x)    cumo_float2half(sinhf(cumo_half2float(x)))
+#define m_cosh(x)    cumo_float2half(coshf(cumo_half2float(x)))
+#define m_tanh(x)    cumo_float2half(tanhf(cumo_half2float(x)))
+#define m_asinh(x)   cumo_float2half(asinhf(cumo_half2float(x)))
+#define m_acosh(x)   cumo_float2half(acoshf(cumo_half2float(x)))
+#define m_atanh(x)   cumo_float2half(atanhf(cumo_half2float(x)))
+#define m_atan2(x,y) cumo_float2half(atan2f(cumo_half2float(x),cumo_half2float(y)))
+#define m_hypot(x,y) cumo_float2half(hypotf(cumo_half2float(x),cumo_half2float(y)))
+#define m_sinc(x)    cumo_float2half(cumo_half_sinc(cumo_half2float(x)))
+
+#define m_erf(x)     cumo_float2half(erff(cumo_half2float(x)))
+#define m_erfc(x)    cumo_float2half(erfcf(cumo_half2float(x)))
+#define m_ldexp(x,y) cumo_float2half(cumo_half_ldexp(cumo_half2float(x),cumo_half2float(y)))
+#define m_frexp(x,exp) cumo_float2half(frexpf(cumo_half2float(x),exp))
+
+
+__host__ __device__ static inline float cumo_half_pow_positive_int(float x, unsigned int p)
+{
+    float r = 1.0f;
+    switch (p) {
+    case 0: return 1.0f;
+    case 1: return x;
+    case 2: return x*x;
+    case 3: return x*x*x;
+    case 4: x = x*x; return x*x;
+    }
+    if (p > 64) return powf(x, (float)p);
+    while (p) {
+        if (p & 1) r *= x;
+        x *= x;
+        p >>= 1;
+    }
+    return r;
+}
+
+__host__ __device__ static inline float cumo_half_pow_int(float x, int p)
+{
+    if (p < 0) return 1.0f / cumo_half_pow_positive_int(x, -(unsigned int)p);
+    return cumo_half_pow_positive_int(x, (unsigned int)p);
+}
+
+// The bit-pattern intrinsics are device-only before CUDA 12, so the bits are
+// taken the way a host caller can take them too.
+__host__ __device__ static inline cumo_half cumo_half_step_down(cumo_half h)
+{
+    unsigned short b;
+    cumo_half r;
+    memcpy(&b, &h, sizeof(b));
+    if (b == 0x0000u) {
+        b = 0x8001u;
+    } else {
+        b = (unsigned short)((b & 0x8000u) ? (b + 1) : (b - 1));
+    }
+    memcpy(&r, &b, sizeof(b));
+    return r;
+}
+
+__host__ __device__ static inline float cumo_half_ldexp(float x, float y)
+{
+    if (!(y == y)) return y;
+    if (y > 64.0f) y = 64.0f;
+    if (y < -64.0f) y = -64.0f;
+    return ldexpf(x, (int)y);
+}
+
+__host__ __device__ static inline float cumo_half_sinc(float x)
+{
+    return (x==0) ? 1.0f : (sinf(x)/x);
+}
+
+__host__ __device__ static inline float cumo_half_sign(float x)
+{
+    return (x==0) ? 0.0f : ((x>0) ? 1.0f : ((x<0) ? -1.0f : x));
+}
+
+__host__ __device__ static inline cumo_half f_seq(cumo_half x, cumo_half y, double c)
+{
+    return cumo_float2half(cumo_half2float(x) + cumo_half2float(y) * (float)c);
+}
+
+#include "real_accum_kernel.h"
+
+#endif // CUMO_HALF_MACRO_KERNEL_H

data/ext/cumo/include/cumo/types/hfloat.h

@@ -0,0 +1,22 @@
+#include "half_def.h"
+
+typedef cumo_half dtype;
+typedef cumo_half rtype;
+#define cT  cumo_cHFloat
+#define cRT cumo_cHFloat
+#define mTM cumo_mHFloatMath
+
+#include "half_macro.h"
+#include "cublas_v2.h"
+#include "cumo/cuda/cublas.h"
+#include "cumo/cuda/cudnn.h"
+
+#define m_extract(x) rb_float_new(cumo_half2float(*(cumo_half*)x))
+#define m_nearly_eq(x,y) (fabsf(cumo_half2float(x)-cumo_half2float(y))<=(fabsf(cumo_half2float(x))+fabsf(cumo_half2float(y)))*CUMO_HALF_EPSILON*2)
+
+#define M_EPSILON rb_float_new(9.765625e-04)
+#define M_MIN     rb_float_new(6.103515625e-05)
+#define M_MAX     rb_float_new(65504.0)
+
+#define DATA_MIN cumo_float2half(-65504.0f)
+#define DATA_MAX cumo_float2half(65504.0f)

data/ext/cumo/include/cumo/types/hfloat_kernel.h

@@ -0,0 +1,16 @@
+#ifndef CUMO_HFLOAT_KERNEL_H
+#define CUMO_HFLOAT_KERNEL_H
+
+#include "half_def_kernel.h"
+
+typedef cumo_half dtype;
+typedef cumo_half rtype;
+
+#include "half_macro_kernel.h"
+
+#define m_nearly_eq(x,y) (fabsf(cumo_half2float(x)-cumo_half2float(y))<=(fabsf(cumo_half2float(x))+fabsf(cumo_half2float(y)))*CUMO_HALF_EPSILON*2)
+
+#define DATA_MIN cumo_float2half(-65504.0f)
+#define DATA_MAX cumo_float2half(65504.0f)
+
+#endif // CUMO_HFLOAT_KERNEL_H

data/ext/cumo/include/cumo/types/real_accum.h

@@ -1,4 +1,6 @@
+#ifndef not_nan
 #define not_nan(x) ((x)==(x))
+#endif
 
 #define m_mulsum(x,y,z) {z = m_add(m_mul(x,y),z);}
 #define m_mulsum_nan(x,y,z) {          \

data/ext/cumo/include/cumo/types/real_accum_kernel.h

@@ -1,7 +1,9 @@
 #ifndef CUMO_REAL_ACCUM_KERNEL_H
 #define CUMO_REAL_ACCUM_KERNEL_H
 
+#ifndef not_nan
 #define not_nan(x) ((x)==(x))
+#endif
 
 #define m_mulsum(x,y,z) {z = m_add(m_mul(x,y),z);}
 #define m_mulsum_nan(x,y,z) {          \

data/ext/cumo/include/cumo/types/robj_macro.h

@@ -1,3 +1,5 @@
+#include "half_def.h"
+
 #define m_zero INT2FIX(0)
 #define m_one  INT2FIX(1)
 
@@ -6,6 +8,7 @@
 
 #define m_from_double(x) rb_float_new(x)
 #define m_from_real(x)   rb_float_new(x)
+#define m_from_half(x) m_from_real(cumo_half2float(x))
 #define m_from_sint(x)   INT2FIX(x)
 #define m_from_int32(x)  INT322NUM(x)
 #define m_from_int64(x)  INT642NUM(x)

data/ext/cumo/include/cumo/types/xint_macro.h

@@ -1,3 +1,5 @@
+#include "half_def.h"
+
 #define m_zero 0
 #define m_one  1
 
@@ -6,6 +8,7 @@
 /* Handle negative values consistently across platforms for unsigned integer types */
 #define m_from_double(x) ((x) < 0 ? (dtype)((long long)(x)) : (dtype)(x))
 #define m_from_real(x) ((x) < 0 ? (dtype)((long long)(x)) : (dtype)(x))
+#define m_from_half(x) m_from_real(cumo_half2float(x))
 #define m_from_sint(x) (x)
 #define m_from_int32(x) (x)
 #define m_from_int64(x) (x)

data/ext/cumo/include/cumo/types/xint_macro_kernel.h

@@ -1,11 +1,13 @@
 #ifndef CUMO_XINT_MACRO_KERNEL_H
 #define CUMO_XINT_MACRO_KERNEL_H
+#include "half_def_kernel.h"
 
 #define m_zero 0
 #define m_one  1
 
 #define m_from_double(x) (x)
 #define m_from_real(x) (x)
+#define m_from_half(x) m_from_real(cumo_half2float(x))
 #define m_from_sint(x) (x)
 #define m_from_int32(x) (x)
 #define m_from_int64(x) (x)

data/ext/cumo/include/cumo.h

@@ -10,8 +10,8 @@ extern "C" {
 #endif
 #endif
 
-#define CUMO_VERSION "0.6.0"
-#define CUMO_VERSION_CODE 600
+#define CUMO_VERSION "0.7.0"
+#define CUMO_VERSION_CODE 700
 
 bool cumo_compatible_mode_enabled_p();
 bool cumo_show_warning_enabled_p();

data/ext/cumo/narray/data.c

@@ -77,7 +77,7 @@ iter_copy_bytes(cumo_na_loop_t *const lp)
     // with nothing ordering that against the host reading it back.
     if (idx1 || idx2) {
         CUMO_SHOW_SYNCHRONIZE_WARNING_ONCE("copy", "any");
-        cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+        cumo_cuda_runtime_device_synchronize();
     }
     e = lp->args[0].elmsz;
     LOOP_UNARY_PTR(lp,m_memcpy);
@@ -256,6 +256,8 @@ cumo_na_swapaxes(VALUE self, VALUE a1, VALUE a2)
     cumo_narray_view_t *na;
     volatile VALUE view;
 
+    // cumo_na_make_view borrows, so index_owned is zero and the swap below
+    // has no ownership bits to carry with the strides.
     view = cumo_na_make_view(self);
     CumoGetNArrayView(view,na);
 
@@ -459,6 +461,8 @@ cumo_na_reshape_bang(int argc, VALUE *argv, VALUE self)
     if (OBJ_FROZEN(self)) {
         rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");
     }
+    // A contiguous view has every dimension on a stride, so overwriting them
+    // below drops no index array this view owns.
     if (cumo_na_check_contiguous(self)==Qfalse) {
         rb_raise(rb_eStandardError, "cannot change shape of non-contiguous NArray");
     }
@@ -469,15 +473,15 @@ cumo_na_reshape_bang(int argc, VALUE *argv, VALUE self)
     if (na->type == CUMO_NARRAY_VIEW_T) {
         CumoGetNArrayView(self, na2);
         if (na->ndim < argc) {
-            stridx = ALLOC_N(cumo_stridx_t,argc);
+            stridx = ZALLOC_N(cumo_stridx_t,argc);
         } else {
             stridx = na2->stridx;
         }
-        if (na->ndim == 0) {
-            stride = cumo_na_element_stride(self);
-        } else {
-            stride = CUMO_SDX_GET_STRIDE(na2->stridx[na->ndim-1]);
-        }
+        // A contiguous view holds its elements one after another from its
+        // offset, so the step between them is the element size whatever the
+        // strides say: a length-1 dimension may carry any stride, including a
+        // negative one.
+        stride = cumo_na_element_stride(self);
         for (i=argc; i--;) {
             CUMO_SDX_SET_STRIDE(stridx[i],stride);
             stride *= shape[i];
@@ -526,11 +530,11 @@ VALUE
 cumo_na_flatten_dim(VALUE self, int sd)
 {
     int i, nd, fd;
-    size_t *idx1, *idx2;
+    size_t *idx2;
     size_t stride;
     size_t  *shape, size;
     cumo_narray_t *na;
-    cumo_narray_view_t *na1, *na2;
+    cumo_narray_view_t *na1 = NULL, *na2;
     volatile VALUE view;
 
     CumoGetNArray(self,na);
@@ -561,7 +565,7 @@ cumo_na_flatten_dim(VALUE self, int sd)
 
     // new stride
     cumo_na_setup_shape((cumo_narray_t*)na2, sd+1, shape);
-    na2->stridx = ALLOC_N(cumo_stridx_t,sd+1);
+    na2->stridx = ZALLOC_N(cumo_stridx_t,sd+1);
 
     switch(na->type) {
     case CUMO_NARRAY_DATA_T:
@@ -578,25 +582,29 @@ cumo_na_flatten_dim(VALUE self, int sd)
         CumoGetNArrayView(self, na1);
         na2->data = na1->data;
         na2->offset = na1->offset;
+        // Every caller passes sd == 0 today, so this loop does not run.
         for (i=0; i<sd; i++) {
+            na2->stridx[i] = na1->stridx[i];
             if (CUMO_SDX_IS_INDEX(na1->stridx[i])) {
-                idx1 = CUMO_SDX_GET_INDEX(na1->stridx[i]);
-                idx2 = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*shape[i]);
-                cumo_cuda_runtime_check_status(cudaMemcpyAsync(idx2,idx1,sizeof(size_t)*shape[i],cudaMemcpyDeviceToDevice,0));
-                CUMO_SDX_SET_INDEX(na2->stridx[i],idx2);
-            } else {
-                na2->stridx[i] = na1->stridx[i];
+                cumo_na_index_borrow(na2, self);
             }
         }
-        // flat dimenion == last dimension
+        // flat dimension == last dimension that advances. A length-1 dimension
+        // is not part of the chain cumo_na_check_ladder() walks, so the stride
+        // at nd-1 may be any value.
         if (RTEST(cumo_na_check_ladder(self,sd))) {
-            na2->stridx[sd] = na1->stridx[nd-1];
+            i = cumo_na_last_dim_with_elements(na, sd);
+            if (i < 0) {
+                CUMO_SDX_SET_STRIDE(na2->stridx[sd], (ssize_t)cumo_na_element_stride(self));
+            } else {
+                na2->stridx[sd] = na1->stridx[i];
+            }
         } else {
             cumo_na_iarray_stridx_t iarray;
             cumo_na_indexer_t indexer;
 
             idx2 = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*((shape[sd]==0) ? 1 : shape[sd]));
-            CUMO_SDX_SET_INDEX(na2->stridx[sd],idx2);
+            cumo_na_index_own(na2,sd,idx2);
             fd = nd-sd;
             iarray.ptr = NULL;
             indexer.ndim = fd;
@@ -609,7 +617,11 @@ cumo_na_flatten_dim(VALUE self, int sd)
         }
         break;
     }
-    cumo_na_index_mark_filled(na2);
+    if (na1 != NULL) {
+        cumo_na_index_mark_derived(na2, na1);
+    } else {
+        cumo_na_index_mark_filled(na2);
+    }
     return view;
 }
 
@@ -667,13 +679,13 @@ void cumo_na_diagonal_stride_index_kernel_launch(size_t *idx, ssize_t s0, size_t
 static VALUE
 cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
 {
-    int  i, k, nd;
+    int  i, k, nd, borrow;
     size_t *idx0, *idx1, *diag_idx;
     size_t *shape;
     size_t  diag_size;
     ssize_t stride, stride0, stride1;
     cumo_narray_t *na;
-    cumo_narray_view_t *na1, *na2;
+    cumo_narray_view_t *na1 = NULL, *na2;
     VALUE view;
     VALUE vofs=0, vaxes=0;
     ssize_t kofs;
@@ -768,7 +780,7 @@ cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
 
     // new stride
     cumo_na_setup_shape((cumo_narray_t*)na2, nd-1, shape);
-    na2->stridx = ALLOC_N(cumo_stridx_t, nd-1);
+    na2->stridx = ZALLOC_N(cumo_stridx_t, nd-1);
 
     switch(na->type) {
     case CUMO_NARRAY_DATA_T:
@@ -799,19 +811,19 @@ cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
         CumoGetNArrayView(self, na1);
         na2->data = na1->data;
         na2->offset = na1->offset;
+        borrow = !CUMO_SDX_IS_INDEX(na1->stridx[ax[0]]) && !CUMO_SDX_IS_INDEX(na1->stridx[ax[1]]);
         for (i=k=0; i<nd; i++) {
             if (i != ax[0] && i != ax[1]) {
-                if (CUMO_SDX_IS_INDEX(na1->stridx[i])) {
+                if (borrow || !CUMO_SDX_IS_INDEX(na1->stridx[i])) {
+                    na2->stridx[k] = na1->stridx[i];
+                    if (CUMO_SDX_IS_INDEX(na1->stridx[i])) {
+                        cumo_na_index_borrow(na2, self);
+                    }
+                } else {
                     idx0 = CUMO_SDX_GET_INDEX(na1->stridx[i]);
-                    // idx1 = ALLOC_N(size_t, na->shape[i]);
-                    // for (j=0; j<na->shape[i]; j++) {
-                    //     idx1[j] = idx0[j];
-                    // }
                     idx1 = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*na->shape[i]);
+                    cumo_na_index_own(na2,k,idx1);
                     cumo_cuda_runtime_check_status(cudaMemcpyAsync(idx1,idx0,sizeof(size_t)*na->shape[i],cudaMemcpyDeviceToDevice,0));
-                    CUMO_SDX_SET_INDEX(na2->stridx[k],idx1);
-                } else {
-                    na2->stridx[k] = na1->stridx[i];
                 }
                 k++;
             }
@@ -820,6 +832,7 @@ cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
             idx0 = CUMO_SDX_GET_INDEX(na1->stridx[ax[0]]);
             // diag_idx = ALLOC_N(size_t, diag_size);
             diag_idx = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*diag_size);
+            cumo_na_index_own(na2,nd-2,diag_idx);
             if (CUMO_SDX_IS_INDEX(na1->stridx[ax[1]])) {
                 idx1 = CUMO_SDX_GET_INDEX(na1->stridx[ax[1]]);
                 cumo_na_diagonal_index_index_kernel_launch(diag_idx, idx0, idx1, k0, k1, diag_size);
@@ -827,15 +840,14 @@ cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
                 stride1 = CUMO_SDX_GET_STRIDE(na1->stridx[ax[1]]);
                 cumo_na_diagonal_index_stride_kernel_launch(diag_idx, idx0, stride1, k0, k1, diag_size);
             }
-            CUMO_SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
         } else {
             stride0 = CUMO_SDX_GET_STRIDE(na1->stridx[ax[0]]);
             if (CUMO_SDX_IS_INDEX(na1->stridx[ax[1]])) {
                 idx1 = CUMO_SDX_GET_INDEX(na1->stridx[ax[1]]);
                 // diag_idx = ALLOC_N(size_t, diag_size);
                 diag_idx = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*diag_size);
+                cumo_na_index_own(na2,nd-2,diag_idx);
                 cumo_na_diagonal_stride_index_kernel_launch(diag_idx, stride0, idx1, k0, k1, diag_size);
-                CUMO_SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
             } else {
                 stride1 = CUMO_SDX_GET_STRIDE(na1->stridx[ax[1]]);
                 na2->offset += stride0*k0 + stride1*k1;
@@ -844,153 +856,17 @@ cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
         }
         break;
     }
-    return view;
-}
-
-//----------------------------------------------------------------------
-
-
-#if 0
-#ifdef SWAP
-#undef SWAP
-#endif
-#define SWAP(a,b,t) {t=a;a=b;b=t;}
-
-static VALUE
-cumo_na_new_dimension_for_dot(VALUE self, int pos, int len, bool transpose)
-{
-    int i, k, l, nd;
-    size_t  j;
-    size_t *idx1, *idx2;
-    size_t *shape;
-    ssize_t stride;
-    cumo_narray_t *na;
-    cumo_narray_view_t *na1, *na2;
-    size_t shape_n;
-    cumo_stridx_t stridx_n;
-    volatile VALUE view;
-
-    CumoGetNArray(self,na);
-    nd = na->ndim;
-
-    view = cumo_na_s_allocate_view(rb_obj_class(self));
-
-    cumo_na_copy_flags(self, view);
-    CumoGetNArrayView(view, na2);
-
-    // new dimension
-    if (pos < 0) pos += nd;
-    if (pos > nd || pos < 0) {
-        rb_raise(rb_eRangeError,"new dimension is out of range");
-    }
-    nd += len;
-    shape = ALLOCA_N(size_t,nd);
-    na2->stridx = ALLOC_N(cumo_stridx_t,nd);
-
-    switch(na->type) {
-    case CUMO_NARRAY_DATA_T:
-    case CUMO_NARRAY_FILEMAP_T:
-        i = k = 0;
-        while (i < nd) {
-            if (i == pos && len > 0) {
-                for (l=0; l<len; l++) {
-                    shape[i++] = 1;
-                }
-            } else {
-                shape[i++] = na->shape[k++];
-            }
-        }
-        cumo_na_setup_shape((cumo_narray_t*)na2, nd, shape);
-        stride = cumo_na_element_stride(self);
-        for (i=nd; i--;) {
-            CUMO_SDX_SET_STRIDE(na2->stridx[i], stride);
-            stride *= shape[i];
-        }
-        na2->offset = 0;
-        na2->data = self;
-        break;
-    case CUMO_NARRAY_VIEW_T:
-        CumoGetNArrayView(self, na1);
-        i = k = 0;
-        while (i < nd) {
-            if (i == pos && len > 0) {
-                if (CUMO_SDX_IS_INDEX(na1->stridx[k])) {
-                    stride = CUMO_SDX_GET_INDEX(na1->stridx[k])[0];
-                } else {
-                    stride = CUMO_SDX_GET_STRIDE(na1->stridx[k]);
-                }
-                for (l=0; l<len; l++) {
-                    shape[i] = 1;
-                    CUMO_SDX_SET_STRIDE(na2->stridx[i], stride);
-                    i++;
-                }
-            } else {
-                shape[i] = na1->base.shape[k];
-                if (CUMO_SDX_IS_INDEX(na1->stridx[k])) {
-                    idx1 = CUMO_SDX_GET_INDEX(na1->stridx[k]);
-                    idx2 = ALLOC_N(size_t,na1->base.shape[k]);
-                    for (j=0; j<na1->base.shape[k]; j++) {
-                        idx2[j] = idx1[j];
-                    }
-                    CUMO_SDX_SET_INDEX(na2->stridx[i], idx2);
-                } else {
-                    na2->stridx[i] = na1->stridx[k];
-                }
-                i++; k++;
-            }
-        }
-        cumo_na_setup_shape((cumo_narray_t*)na2, nd, shape);
-        na2->offset = na1->offset;
-        na2->data = na1->data;
-        break;
-    }
-
-    if (transpose) {
-	SWAP(na2->base.shape[nd-1], na2->base.shape[nd-2], shape_n);
-	SWAP(na2->stridx[nd-1], na2->stridx[nd-2], stridx_n);
+    if (na1 != NULL) {
+        cumo_na_index_mark_derived(na2, na1);
+    } else {
+        cumo_na_index_mark_filled(na2);
     }
-
     return view;
 }
 
-
 //----------------------------------------------------------------------
 
-/*
- *  call-seq:
- *     narray.dot(other) => narray
- *
- *  Returns dot product.
- *
- */
-
-static VALUE
-cumo_na_dot(VALUE self, VALUE other)
-{
-    volatile VALUE a1=self, a2=other;
-    cumo_narray_t *na1, *na2;
 
-    if (!rb_respond_to(a1, cumo_id_mulsum)) {
-        rb_raise(rb_eNoMethodError,"requires mulsum method for dot method");
-    }
-    CumoGetNArray(a1,na1);
-    CumoGetNArray(a2,na2);
-    if (na1->ndim==0 || na2->ndim==0) {
-        rb_raise(cumo_na_eDimensionError,"zero dimensional narray");
-    }
-    if (na2->ndim > 1) {
-        if (na1->shape[na1->ndim-1] != na2->shape[na2->ndim-2]) {
-            rb_raise(cumo_na_eShapeError,"shape mismatch: self.shape[-1](=%"SZF"d) != other.shape[-2](=%"SZF"d)",
-                     na1->shape[na1->ndim-1], na2->shape[na2->ndim-2]);
-        }
-        // insert new axis [ ..., last-1-dim, newaxis*other.ndim, last-dim ]
-        a1 = cumo_na_new_dimension_for_dot(a1, na1->ndim-1, na2->ndim-1, 0);
-        // insert & transpose [ newaxis*self.ndim, ..., last-dim, last-1-dim ]
-        a2 = cumo_na_new_dimension_for_dot(a2, 0, na1->ndim-1, 1);
-    }
-    return rb_funcall(a1,cumo_id_mulsum,2,a2,INT2FIX(-1));
-}
-#endif
 
 void
 Init_cumo_na_data(void)
@@ -1024,7 +900,6 @@ Init_cumo_na_data(void)
     rb_define_method(cNArray, "to_host", cumo_na_to_host, 0);
     rb_define_method(cNArray, "to_swapped", cumo_na_to_swapped, 0);
 
-    //rb_define_method(cNArray, "dot", cumo_na_dot, 1);
 
     cumo_id_copy         = rb_intern("copy");
     cumo_id_mulsum       = rb_intern("mulsum");