carray 3.0.3 → 3.0.5

data/ext/ca_monop_dispatch.c

@@ -45,67 +45,67 @@
 /* op_id -> kernel table lookup                                         */
 /* ------------------------------------------------------------------- */
 
-/* Returns the kernel for the given input data_type.  Returns NULL for
-   cast ops (op_id >= CA_MONOP_CAST_BASE) and unknown op_ids; cast is
-   handled specially in xfer_stride via ca_cast_block. */
-ca_monop_func_t
-ca_monop_kernel_lookup (uint16_t op_id, int8_t in_data_type)
+/* The kernel table of an op, or NULL for cast ops (op_id >=
+   CA_MONOP_CAST_BASE) and unknown op_ids; cast is handled specially in
+   xfer_stride via ca_cast_block. */
+static ca_monop_func_t *
+ca_monop_table_of (uint16_t op_id)
 {
   switch (op_id) {
-    case CA_MONOP_ZERO:    return ca_monop_zero[in_data_type];
-    case CA_MONOP_ONE:     return ca_monop_one[in_data_type];
-    case CA_MONOP_FRAC:    return ca_monop_frac[in_data_type];
-    case CA_MONOP_NEG:     return ca_monop_neg[in_data_type];
-    case CA_MONOP_BIT_NEG: return ca_monop_bit_neg[in_data_type];
-    case CA_MONOP_ABS_I:   return ca_monop_abs_i[in_data_type];
-    case CA_MONOP_CONJ:    return ca_monop_conj[in_data_type];
-    case CA_MONOP_NOT:     return ca_monop_not[in_data_type];
-
-    case CA_MONOP_CEIL:    return ca_monop_ceil[in_data_type];
-    case CA_MONOP_FLOOR:   return ca_monop_floor[in_data_type];
-    case CA_MONOP_ROUND:   return ca_monop_round[in_data_type];
-    case CA_MONOP_RCP:     return ca_monop_rcp[in_data_type];
-
-    case CA_MONOP_RAD:     return ca_monop_rad[in_data_type];
-    case CA_MONOP_DEG:     return ca_monop_deg[in_data_type];
-    case CA_MONOP_SQRT:    return ca_monop_sqrt[in_data_type];
-    case CA_MONOP_EXP:     return ca_monop_exp[in_data_type];
-    case CA_MONOP_EXP2:    return ca_monop_exp2[in_data_type];
-    case CA_MONOP_EXP10:   return ca_monop_exp10[in_data_type];
-    case CA_MONOP_LOG:     return ca_monop_log[in_data_type];
-    case CA_MONOP_LOG10:   return ca_monop_log10[in_data_type];
-    case CA_MONOP_LOG2:    return ca_monop_log2[in_data_type];
-    case CA_MONOP_LOGB:    return ca_monop_logb[in_data_type];
-    case CA_MONOP_SIN:     return ca_monop_sin[in_data_type];
-    case CA_MONOP_COS:     return ca_monop_cos[in_data_type];
-    case CA_MONOP_TAN:     return ca_monop_tan[in_data_type];
-    case CA_MONOP_ASIN:    return ca_monop_asin[in_data_type];
-    case CA_MONOP_ACOS:    return ca_monop_acos[in_data_type];
-    case CA_MONOP_ATAN:    return ca_monop_atan[in_data_type];
-    case CA_MONOP_SINH:    return ca_monop_sinh[in_data_type];
-    case CA_MONOP_COSH:    return ca_monop_cosh[in_data_type];
-    case CA_MONOP_TANH:    return ca_monop_tanh[in_data_type];
-    case CA_MONOP_ASINH:   return ca_monop_asinh[in_data_type];
-    case CA_MONOP_ACOSH:   return ca_monop_acosh[in_data_type];
-    case CA_MONOP_ATANH:   return ca_monop_atanh[in_data_type];
-
-    case CA_MONOP_BYTE_SWAP: return ca_monop_byte_swap[in_data_type];
-
-    case CA_MONOP_IMAG_I:  return ca_monop_imag_i[in_data_type];
-
-    case CA_MONOP_EXPM1:   return ca_monop_expm1 [in_data_type];
-    case CA_MONOP_LOG1P:   return ca_monop_log1p [in_data_type];
-    case CA_MONOP_RSQRT:   return ca_monop_rsqrt [in_data_type];
-    case CA_MONOP_TRUNC:   return ca_monop_trunc [in_data_type];
-    case CA_MONOP_SQUARE:  return ca_monop_square[in_data_type];
-
-    case CA_MONOP_DEG_360: return ca_monop_deg_360[in_data_type];
-    case CA_MONOP_DEG_180: return ca_monop_deg_180[in_data_type];
-    case CA_MONOP_RAD_2PI: return ca_monop_rad_2pi[in_data_type];
-    case CA_MONOP_RAD_PI:  return ca_monop_rad_pi [in_data_type];
-
-    case CA_MONOP_SIGN:    return ca_monop_sign   [in_data_type];
-    case CA_MONOP_ARG_I:   return ca_monop_arg_i  [in_data_type];
+    case CA_MONOP_ZERO:    return ca_monop_zero;
+    case CA_MONOP_ONE:     return ca_monop_one;
+    case CA_MONOP_FRAC:    return ca_monop_frac;
+    case CA_MONOP_NEG:     return ca_monop_neg;
+    case CA_MONOP_BIT_NEG: return ca_monop_bit_neg;
+    case CA_MONOP_ABS_I:   return ca_monop_abs_i;
+    case CA_MONOP_CONJ:    return ca_monop_conj;
+    case CA_MONOP_NOT:     return ca_monop_not;
+
+    case CA_MONOP_CEIL:    return ca_monop_ceil;
+    case CA_MONOP_FLOOR:   return ca_monop_floor;
+    case CA_MONOP_ROUND:   return ca_monop_round;
+    case CA_MONOP_RCP:     return ca_monop_rcp;
+
+    case CA_MONOP_RAD:     return ca_monop_rad;
+    case CA_MONOP_DEG:     return ca_monop_deg;
+    case CA_MONOP_SQRT:    return ca_monop_sqrt;
+    case CA_MONOP_EXP:     return ca_monop_exp;
+    case CA_MONOP_EXP2:    return ca_monop_exp2;
+    case CA_MONOP_EXP10:   return ca_monop_exp10;
+    case CA_MONOP_LOG:     return ca_monop_log;
+    case CA_MONOP_LOG10:   return ca_monop_log10;
+    case CA_MONOP_LOG2:    return ca_monop_log2;
+    case CA_MONOP_LOGB:    return ca_monop_logb;
+    case CA_MONOP_SIN:     return ca_monop_sin;
+    case CA_MONOP_COS:     return ca_monop_cos;
+    case CA_MONOP_TAN:     return ca_monop_tan;
+    case CA_MONOP_ASIN:    return ca_monop_asin;
+    case CA_MONOP_ACOS:    return ca_monop_acos;
+    case CA_MONOP_ATAN:    return ca_monop_atan;
+    case CA_MONOP_SINH:    return ca_monop_sinh;
+    case CA_MONOP_COSH:    return ca_monop_cosh;
+    case CA_MONOP_TANH:    return ca_monop_tanh;
+    case CA_MONOP_ASINH:   return ca_monop_asinh;
+    case CA_MONOP_ACOSH:   return ca_monop_acosh;
+    case CA_MONOP_ATANH:   return ca_monop_atanh;
+
+    case CA_MONOP_BYTE_SWAP: return ca_monop_byte_swap;
+
+    case CA_MONOP_IMAG_I:  return ca_monop_imag_i;
+
+    case CA_MONOP_EXPM1:   return ca_monop_expm1;
+    case CA_MONOP_LOG1P:   return ca_monop_log1p;
+    case CA_MONOP_RSQRT:   return ca_monop_rsqrt;
+    case CA_MONOP_TRUNC:   return ca_monop_trunc;
+    case CA_MONOP_SQUARE:  return ca_monop_square;
+
+    case CA_MONOP_DEG_360: return ca_monop_deg_360;
+    case CA_MONOP_DEG_180: return ca_monop_deg_180;
+    case CA_MONOP_RAD_2PI: return ca_monop_rad_2pi;
+    case CA_MONOP_RAD_PI:  return ca_monop_rad_pi;
+
+    case CA_MONOP_SIGN:    return ca_monop_sign;
+    case CA_MONOP_ARG_I:   return ca_monop_arg_i;
 
     default:
       /* Cast ops or unknown — caller handles cast specially.  */
@@ -113,6 +113,29 @@ ca_monop_kernel_lookup (uint16_t op_id, int8_t in_data_type)
   }
 }
 
+/* Returns the kernel for the given input data_type.  Returns NULL for
+   cast ops and unknown op_ids. */
+ca_monop_func_t
+ca_monop_kernel_lookup (uint16_t op_id, int8_t in_data_type)
+{
+  ca_monop_func_t *table = ca_monop_table_of(op_id);
+  return table ? table[in_data_type] : NULL;
+}
+
+/* The op id whose kernel table is `table`, or -1 for a table no op id
+   names. */
+int
+ca_monop_op_id_of_table (ca_monop_func_t table[])
+{
+  int op_id;
+  for ( op_id = 0; op_id < CA_MONOP_CAST_BASE; op_id++ ) {
+    if ( ca_monop_table_of((uint16_t) op_id) == table ) return op_id;
+  }
+  return -1;
+}
+
+
+
 /* ------------------------------------------------------------------- */
 /* op category predicates                                               */
 /* ------------------------------------------------------------------- */

data/ext/ca_monop_dispatch.h

@@ -190,6 +190,7 @@ extern ca_monop_func_t ca_monop_arg_i  [CA_NTYPE];
 /* Look up the per-data_type kernel for a normal monop op_id.  Returns NULL
    for cast op_ids (caller handles cast via ca_cast_block).  */
 ca_monop_func_t ca_monop_kernel_lookup (uint16_t op_id, int8_t in_data_type);
+int ca_monop_op_id_of_table (ca_monop_func_t table[]);
 
 /* Returns true iff op_id encodes a cast operation.  */
 int ca_monop_is_cast (uint16_t op_id);

data/ext/ca_obj_array.c

@@ -61,7 +61,10 @@ const rb_data_type_t carray_data_type = {
         .dsize = ca_dsize,
         .dcompact = NULL
     },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    /* A frozen entity is shared between Ractors: reading it writes nothing
+       to its struct (an entity takes no attach count), so each Ractor makes
+       its own views of it. */
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 const rb_data_type_t cawrap_data_type = {
@@ -85,7 +88,10 @@ const rb_data_type_t cscalar_data_type = {
         .dsize = ca_dsize,
         .dcompact = NULL
     },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+    /* A frozen entity is shared between Ractors: reading it writes nothing
+       to its struct (an entity takes no attach count), so each Ractor makes
+       its own views of it. */
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE
 };
 
 const rb_data_type_t caview_data_type = {
@@ -138,14 +144,13 @@ carray_setup_i (CArray *ca,
                 CArray *mask, int allocate, int use_calloc, char *adopt_ptr)
 {
   ca_size_t elements;
-  int8_t i;
   ca_size_t k;
 
   /* check arguments */
-  CA_CHECK_DATA_TYPE(data_type);
-  CA_CHECK_RANK(ndim);
-  CA_CHECK_DIM(ndim, dim);
-  CA_CHECK_BYTES(data_type, bytes);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
+  CA_CHECK_RANK_GIVEN(ndim);
+  CA_CHECK_DIM_GIVEN(ndim, dim);
+  CA_CHECK_BYTES_GIVEN(data_type, bytes);
 
   elements = ca_shape_elements(ndim, dim, bytes);
 
@@ -190,16 +195,14 @@ carray_setup_i (CArray *ca,
 
     /* allocate memory for entity */
     if ( use_calloc ) {
-      /* ca->ptr = ALLOC_N(char, elements * bytes); */
-      ca->ptr = xmalloc(elements * bytes);
+      ca->ptr = xmalloc(elements * bytes);  /* cells: set to 0 below */
       MEMZERO(ca->ptr, char, elements * bytes);
     }
     else {
-      /* ca->ptr = ALLOC_N(char, elements * bytes); */
-      ca->ptr = xmalloc(elements * bytes);
+      ca->ptr = xmalloc(elements * bytes);  /* cells: set to 0 below */
     }
 
-    /* initialize elements with Qnil for CA_OBJECT data_type */
+    /* an object array starts with every cell 0 */
     if ( allocate && data_type == CA_OBJECT ) {
       volatile VALUE zero = SIZE2NUM(0);
       VALUE *p = (VALUE *) ca->ptr;
@@ -215,6 +218,7 @@ carray_setup_i (CArray *ca,
 
   ca->mask = NULL;
   if ( mask ) {
+    /* mask: only initialize_copy passes one, on a struct Ruby owns */
     ca_setup_mask(ca, mask);
   }
 
@@ -243,9 +247,12 @@ ca_wrap_setup (CArray *ca,
   int ret;
 
   ret = carray_setup_i(ca, data_type, ndim, dim, bytes, mask, 0, 0, NULL);
-  if ( (!ptr) && (ca->elements != 0) ) {
+  if ( (!ptr) && ca_shape_elements(ndim, dim, bytes) != 0 ) {
     rb_raise(rb_eRuntimeError, "wrapping NULL pointer with an non-empty array");
   }
+  if ( ca == NULL ) {                            /* checks only */
+    return ret;
+  }
   ca->ptr = ptr;
   return ret;
 }
@@ -258,30 +265,83 @@ ca_wrap_setup_null (CArray *ca,
   int ret;
 
   ret = carray_setup_i(ca, data_type, ndim, dim, bytes, mask, 0, 0, NULL);
-  ca->ptr = NULL;
+  if ( ca != NULL ) {
+    ca->ptr = NULL;
+  }
   return ret;
 }
 
+static VALUE
+carray_new_copy_mask (VALUE arg)
+{
+  void **a = (void **) arg;
+  ca_setup_mask((CArray *) a[0], (CArray *) a[1]);
+  return Qnil;
+}
+
+/* Reading the mask to copy can call Ruby (a CAObject's mask hooks) and
+   raise, while the new array belongs to no Ruby object yet.  The array is
+   built without it, and the mask is copied in under ca_fill_or_free. */
+static CArray *
+carray_new_with_mask (CArray *ca, CArray *mask)
+{
+  if ( mask ) {
+    void *a[2];
+    a[0] = ca;
+    a[1] = mask;
+    ca_fill_or_free(ca, carray_new_copy_mask, (VALUE) a);
+  }
+  return ca;
+}
+
+typedef struct {
+  CArray    *ca;
+  int8_t     data_type;
+  int8_t     ndim;
+  ca_size_t *dim;
+  ca_size_t  bytes;
+  int        use_calloc;
+} carray_new_arg;
+
+static VALUE
+carray_new_setup (VALUE varg)
+{
+  carray_new_arg *a = (carray_new_arg *) varg;
+  carray_setup_i(a->ca, a->data_type, a->ndim, a->dim, a->bytes, NULL,
+                 1, a->use_calloc, NULL);
+  return Qnil;
+}
+
+/* The setup allocates the cells, after the struct: when that fails, the
+   struct goes too. */
+static CArray *
+carray_new_i (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
+              CArray *mask, int use_calloc)
+{
+  carray_new_arg a;
+  carray_setup_i(NULL, data_type, ndim, dim, bytes, NULL, 1, use_calloc, NULL);
+  a.ca = (CArray *) ca_array_alloc(CA_OBJ_ARRAY, ndim);
+  a.data_type = data_type;
+  a.ndim = ndim;
+  a.dim = dim;
+  a.bytes = bytes;
+  a.use_calloc = use_calloc;
+  ca_fill_or_free(a.ca, carray_new_setup, (VALUE) &a);
+  return carray_new_with_mask(a.ca, mask);
+}
+
 CArray *
 carray_new (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
             CArray *mask)
 {
-  CArray *ca;
-  carray_setup(NULL, data_type, ndim, dim, bytes, mask);
-  ca = (CArray *) ca_array_alloc(CA_OBJ_ARRAY, ndim);
-  carray_setup(ca, data_type, ndim, dim, bytes, mask);
-  return ca;
+  return carray_new_i(data_type, ndim, dim, bytes, mask, 0);
 }
 
 CArray *
 carray_new_safe (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
             CArray *mask)
 {
-  CArray *ca;
-  carray_safe_setup(NULL, data_type, ndim, dim, bytes, mask);
-  ca = (CArray *) ca_array_alloc(CA_OBJ_ARRAY, ndim);
-  carray_safe_setup(ca, data_type, ndim, dim, bytes, mask);
-  return ca;
+  return carray_new_i(data_type, ndim, dim, bytes, mask, 1);
 }
 
 /* Create an entity that adopts a caller-provided data buffer instead of
@@ -297,6 +357,7 @@ carray_new_adopt (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes
   if ( ! ptr ) {
     rb_raise(rb_eRuntimeError, "carray_new_adopt: NULL data pointer");
   }
+  carray_setup_i(NULL, data_type, ndim, dim, bytes, NULL, 0, 0, ptr);
   ca = (CArray *) ca_array_alloc(CA_OBJ_ARRAY, ndim);
   carray_setup_i(ca, data_type, ndim, dim, bytes, NULL, 0, 0, ptr);
   return ca;
@@ -306,18 +367,22 @@ CAWrap *
 ca_wrap_new (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
             CArray *mask, char *ptr)
 {
-  CAWrap *ca  = (CAWrap *) ca_array_alloc(CA_OBJ_ARRAY_WRAP, ndim);
-  ca_wrap_setup(ca, data_type, ndim, dim, bytes, mask, ptr);
-  return ca;
+  CAWrap *ca;
+  ca_wrap_setup(NULL, data_type, ndim, dim, bytes, NULL, ptr);
+  ca = (CAWrap *) ca_array_alloc(CA_OBJ_ARRAY_WRAP, ndim);
+  ca_wrap_setup(ca, data_type, ndim, dim, bytes, NULL, ptr);
+  return (CAWrap *) carray_new_with_mask((CArray *) ca, mask);
 }
 
 CAWrap *
 ca_wrap_new_null (int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
                   CArray *mask)
 {
-  CAWrap *ca  = (CAWrap *) ca_array_alloc(CA_OBJ_ARRAY_WRAP, ndim);
-  ca_wrap_setup_null(ca, data_type, ndim, dim, bytes, mask);
-  return ca;
+  CAWrap *ca;
+  ca_wrap_setup_null(NULL, data_type, ndim, dim, bytes, NULL);
+  ca = (CAWrap *) ca_array_alloc(CA_OBJ_ARRAY_WRAP, ndim);
+  ca_wrap_setup_null(ca, data_type, ndim, dim, bytes, NULL);
+  return (CAWrap *) carray_new_with_mask((CArray *) ca, mask);
 }
 
 void
@@ -360,8 +425,14 @@ static int
 cscalar_setup (CScalar *ca,
                int8_t data_type, ca_size_t bytes, CArray *mask)
 {
-  CA_CHECK_DATA_TYPE(data_type);
-  CA_CHECK_BYTES(data_type, bytes);
+  CA_CHECK_DATA_TYPE_GIVEN(data_type);
+  CA_CHECK_BYTES_GIVEN(data_type, bytes);
+
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
 
   ca->obj_type  = CA_OBJ_SCALAR;
   ca->data_type = data_type;
@@ -370,7 +441,7 @@ cscalar_setup (CScalar *ca,
   ca->bytes     = bytes;
   ca->elements  = 1;
   ca->dim       = &(ca->_dim);
-  ca->ptr       = xmalloc(bytes);
+  ca->ptr       = xmalloc(bytes);  /* cells: the one cell is set to 0 below */
   ca->mask      = NULL;
 
   ca->dim[0] = 1;
@@ -383,6 +454,7 @@ cscalar_setup (CScalar *ca,
   }
 
   if ( mask ) {
+    /* mask: the constructors pass none (carray_new_with_mask copies it) */
     ca_setup_mask((CArray *)ca, mask);
   }
 
@@ -395,12 +467,40 @@ cscalar_setup (CScalar *ca,
  * constructs a CScalar struct without initialization
  */
 
+typedef struct {
+  CScalar  *ca;
+  int8_t    data_type;
+  ca_size_t bytes;
+} cscalar_new_arg;
+
+static VALUE
+cscalar_new_setup (VALUE varg)
+{
+  cscalar_new_arg *a = (cscalar_new_arg *) varg;
+  cscalar_setup(a->ca, a->data_type, a->bytes, NULL);
+  return Qnil;
+}
+
+/* The setup allocates the cell after the struct: when that fails, the
+   struct goes too.  It goes by xfree, not ca_free, because its ptr was
+   never set. */
+static CScalar *
+cscalar_new_i (int8_t data_type, ca_size_t bytes)
+{
+  cscalar_new_arg a;
+  cscalar_setup(NULL, data_type, bytes, NULL);
+  a.ca        = ALLOC(CScalar);
+  a.data_type = data_type;
+  a.bytes     = bytes;
+  ca_fill_or_xfree(a.ca, cscalar_new_setup, (VALUE) &a);
+  return a.ca;
+}
+
 CScalar *
 cscalar_new (int8_t data_type, ca_size_t bytes, CArray *mask)
 {
-  CScalar *ca = ALLOC(CScalar);
-  cscalar_setup(ca, data_type, bytes, mask);
-  return ca;
+  CScalar *ca = cscalar_new_i(data_type, bytes);
+  return (CScalar *) carray_new_with_mask((CArray *) ca, mask);
 }
 
 /*
@@ -410,8 +510,7 @@ cscalar_new (int8_t data_type, ca_size_t bytes, CArray *mask)
 CScalar *
 cscalar_new2 (int8_t data_type, ca_size_t bytes, char *val)
 {
-  CScalar *ca = ALLOC(CScalar);
-  cscalar_setup(ca, data_type, bytes, NULL);
+  CScalar *ca = cscalar_new_i(data_type, bytes);
   memcpy(ca->ptr, val, ca->bytes);
   return ca;
 }
@@ -591,6 +690,7 @@ ca_fill_stride_buffer (char *dst, ca_size_t bytes, ca_size_t base, int8_t ndim,
   outer_ndim  = ndim - 1;
 
   for ( k = 0; k < outer_ndim; k++ ) idx[k] = 0;
+  /* empty: the function returns on an empty region at its entry */
   while ( 1 ) {
     ca_size_t addr = base;
     char     *p;
@@ -824,7 +924,7 @@ rb_ca_s_allocate (VALUE klass)
 }
 
 /* Reads the (data_type, dim, bytes: nil) argument list that CArray.new
-   and CArray.__empty__ share.  The two differ only in whether the buffer
+   and CArray.empty_of_data_type share.  The two differ only in whether the buffer
    is filled, so the rule for reading their arguments -- the optional
    bytes for a fixlen, the refusal of a Class, the guess of the data type,
    the demand that dim be an Array -- is written once here. */
@@ -855,7 +955,7 @@ ca_scan_construct_args (int argc, VALUE *argv, int8_t *data_type,
   rb_ca_guess_type_and_bytes(rtype, rbytes, data_type, bytes);
 
   Check_Type(rdim, T_ARRAY);
-  CA_CHECK_RANK(RARRAY_LEN(rdim));     /* before dim[] is filled */
+  CA_CHECK_RANK_GIVEN(RARRAY_LEN(rdim));     /* before dim[] is filled */
   *ndim = RARRAY_LEN(rdim);
   for (i=0; i<*ndim; i++) {
     dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
@@ -907,8 +1007,13 @@ rb_ca_initialize (int argc, VALUE *argv, VALUE self)
          with the multi-dimensional subscript yielded as individual
          integer arguments, so |i|, |i,j|, |i,j,k| all work uniformly
          across ranks.  Block forms that want the whole subscript as
-         an Array should write |*idx|. */
-    if ( rb_proc_arity(rb_block_proc()) == 0 ) {
+         an Array should write |*idx|.
+       An array of no cells calls neither, as Array.new(0) { ... } does
+       not. */
+    if ( ca->elements == 0 ) {
+      ;
+    }
+    else if ( rb_proc_arity(rb_block_proc()) == 0 ) {
       volatile VALUE rval = rb_yield_values2(0, NULL);
       rb_ca_store_all(self, rval);
     }
@@ -1160,6 +1265,7 @@ rb_ca_initialize_dup (VALUE self, VALUE other)
 {
   rb_call_super(1, &other);
   ca_dup_keep_state(self, other);
+  rb_ca_own_attr(self);
   return self;
 }
 
@@ -1177,6 +1283,7 @@ rb_ca_initialize_clone (int argc, VALUE *argv, VALUE self)
   rb_call_super_kw(argc, argv, RB_PASS_CALLED_KEYWORDS);
   rb_scan_args(argc, argv, "1:", &orig, &opts);
   ca_dup_keep_state(self, orig);
+  rb_ca_own_attr(self);
 
   if ( ! NIL_P(opts) ) {
     vfreeze = rb_hash_lookup2(opts, ID2SYM(rb_intern("freeze")), Qnil);
@@ -1246,7 +1353,7 @@ rb_ca_s_wrap (int argc, VALUE *argv, VALUE self)
   rb_ca_guess_type_and_bytes(rtype, rbytes, &data_type, &bytes);
 
   Check_Type(rdim, T_ARRAY);
-  CA_CHECK_RANK(RARRAY_LEN(rdim));     /* before dim[] is filled */
+  CA_CHECK_RANK_GIVEN(RARRAY_LEN(rdim));     /* before dim[] is filled */
   ndim = RARRAY_LEN(rdim);
   for (i=0; i<ndim; i++) {
     dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
@@ -1552,7 +1659,7 @@ rb_ca_s_alloc_uninit (VALUE klass, VALUE rtype, VALUE rshape)
   int8_t i;
   rb_ca_guess_type_and_bytes(rtype, Qnil, &data_type, &bytes);
   Check_Type(rshape, T_ARRAY);
-  CA_CHECK_RANK(RARRAY_LEN(rshape));   /* before dim[] is filled */
+  CA_CHECK_RANK_GIVEN(RARRAY_LEN(rshape));   /* before dim[] is filled */
   ndim = (int8_t) RARRAY_LEN(rshape);
   for (i = 0; i < ndim; i++) dim[i] = NUM2SIZE(rb_ary_entry(rshape, i));
   return rb_carray_new(data_type, ndim, dim, bytes, NULL);
@@ -1596,7 +1703,7 @@ Init_ca_obj_array (void)
   rb_define_method(rb_cCArray, "initialize", rb_ca_initialize, -1);
   rb_define_singleton_method(rb_cCArray, "__alloc_uninit__",
                              rb_ca_s_alloc_uninit, 2);
-  rb_define_singleton_method(rb_cCArray, "__empty__", rb_ca_s_empty, -1);
+  rb_define_private_method(rb_singleton_class(rb_cCArray), "empty_of_data_type", rb_ca_s_empty, -1);
 
   rb_define_singleton_method(rb_cCArray, "fixlen", rb_ca_s_fixlen, -1);
   rb_define_singleton_method(rb_cCArray, "boolean", rb_ca_s_boolean, -1);