carray 3.0.3 → 3.0.4

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 = {
@@ -142,10 +148,10 @@ carray_setup_i (CArray *ca,
   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 +196,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 +219,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 +248,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,19 +266,44 @@ 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;
+}
+
 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);
+  carray_setup(NULL, data_type, ndim, dim, bytes, NULL);
   ca = (CArray *) ca_array_alloc(CA_OBJ_ARRAY, ndim);
-  carray_setup(ca, data_type, ndim, dim, bytes, mask);
-  return ca;
+  carray_setup(ca, data_type, ndim, dim, bytes, NULL);
+  return carray_new_with_mask(ca, mask);
 }
 
 CArray *
@@ -278,10 +311,10 @@ 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);
+  carray_safe_setup(NULL, data_type, ndim, dim, bytes, NULL);
   ca = (CArray *) ca_array_alloc(CA_OBJ_ARRAY, ndim);
-  carray_safe_setup(ca, data_type, ndim, dim, bytes, mask);
-  return ca;
+  carray_safe_setup(ca, data_type, ndim, dim, bytes, NULL);
+  return carray_new_with_mask(ca, mask);
 }
 
 /* Create an entity that adopts a caller-provided data buffer instead of
@@ -297,6 +330,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 +340,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 +398,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 +414,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 +427,7 @@ cscalar_setup (CScalar *ca,
   }
 
   if ( mask ) {
+    /* mask: the constructors pass none (carray_new_with_mask copies it) */
     ca_setup_mask((CArray *)ca, mask);
   }
 
@@ -398,9 +443,11 @@ cscalar_setup (CScalar *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_setup(NULL, data_type, bytes, NULL);
+  ca = ALLOC(CScalar);
+  cscalar_setup(ca, data_type, bytes, NULL);
+  return (CScalar *) carray_new_with_mask((CArray *) ca, mask);
 }
 
 /*
@@ -410,7 +457,9 @@ 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 *ca;
+  cscalar_setup(NULL, data_type, bytes, NULL);
+  ca = ALLOC(CScalar);
   cscalar_setup(ca, data_type, bytes, NULL);
   memcpy(ca->ptr, val, ca->bytes);
   return ca;
@@ -591,6 +640,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 +874,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 +905,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 +957,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 +1215,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 +1233,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 +1303,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 +1609,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 +1653,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);

data/ext/ca_obj_bincmp.c

@@ -74,10 +74,7 @@ typedef struct CABinCmp {
                                 target of both left & right, also the
                                 kernel lookup key) */
   double    eps;             /* Runtime tolerance slot for IS_CLOSE /
-                                IS_EQUIV; ignored for other ops.  The
-                                `eps` name is retained to keep the
-                                `__eps__` Ruby accessor stable across
-                                the dual purpose. */
+                                IS_EQUIV; ignored for other ops. */
   int8_t    sign_fix;        /* 0, or the side (1 left, 2 right) of an
                                 int64 operand compared with a uint64 one:
                                 the kernel compares both as uint64 and
@@ -179,6 +176,7 @@ ca_bincmp_setup (CABinCmp *ca, CArray *left, CArray *right, uint16_t op_id,
 CABinCmp *
 ca_bincmp_new (CArray *left, CArray *right, uint16_t op_id, double eps)
 {
+  /* check: the setup checks nothing */
   CABinCmp *ca = (CABinCmp *) ca_array_alloc(CA_OBJ_BINCMP, left->ndim);
   ca_bincmp_setup(ca, left, right, op_id, eps);
   return ca;
@@ -226,7 +224,7 @@ ca_bincmp_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
   int8_t    k;
 
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CABinCmp is read-only (xfer_index PUT)");
+    ca_refuse_read_only();
   }
 
   for ( k = ca->ndim - 1; k >= 0; k-- ) {
@@ -412,7 +410,7 @@ ca_bincmp_eval (CABinCmp *bc, const ca_lazy_req_t *req, void *data)
                "CABinCmp: kernel not implemented (op_id=%u data_type=%d)",
                (unsigned) bc->op_id, (int) bc->common_dt);
     }
-    if ( bc->common_dt == CA_OBJECT ) {
+    if ( ca_op_raises_on_cell(CA_OP_KIND_BINCMP, bc->op_id, bc->common_dt) ) {
       slab_mask = ca_lazy_req_mask(req, 2, bc->operands);
     }
     fn(slab_n, slab_mask,
@@ -446,7 +444,7 @@ ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   if ( ca_region_is_empty(((CArray *) ap)->ndim, counts) ) return;
   ca_lazy_req_t req;
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CABinCmp is read-only (xfer_stride PUT)");
+    ca_refuse_read_only();
   }
   ca_lazy_req_region(&req, ap, starts, counts, strides);
   ca_bincmp_eval((CABinCmp *) ap, &req, data);
@@ -459,7 +457,7 @@ ca_bincmp_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
 {
   ca_lazy_req_t req;
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CABinCmp is read-only (xfer_addrs PUT)");
+    ca_refuse_read_only();
   }
   ca_lazy_req_addrs(&req, n, addrs);
   ca_bincmp_eval((CABinCmp *) ap, &req, data);
@@ -482,7 +480,7 @@ static void
 ca_bincmp_func_allocate (void *ap)
 {
   CABinCmp *ca = (CABinCmp *) ap;
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -499,7 +497,7 @@ ca_bincmp_func_attach (void *ap)
   int8_t    k;
   ca_size_t s;
 
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 
   s = ca->bytes;
   for ( k = ca->ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
@@ -525,7 +523,7 @@ NORETURN(static void ca_bincmp_func_fill_data (void *ap, void *ptr));
 static void
 ca_bincmp_func_fill_data (void *ap, void *ptr)
 {
-  rb_raise(rb_eRuntimeError, "CABinCmp is read-only (fill_data)");
+  ca_refuse_read_only();
 }
 
 /* mask = left.mask | right.mask, computed on each read (CAMaskOfOperands). */
@@ -580,6 +578,14 @@ rb_ca_bincmp_new (VALUE l_cary, VALUE r_cary, uint16_t op_id, double eps)
   rb_check_carray_object(r_cary);
   TypedData_Get_Struct(l_cary, CArray, &carray_data_type, l);
   TypedData_Get_Struct(r_cary, CArray, &carray_data_type, r);
+  /* No kernel for the type the builder cast to: refuse as the eager
+     comparison does, before anything is allocated. */
+  {
+    ca_bincmp_func_t fn = ca_bincmp_kernel_lookup(op_id, l->data_type);
+    if ( fn == NULL || fn == ca_bincmp_not_implement ) {
+      ca_op_refuse_unimplemented(l_cary, l->data_type, rb_eTypeError);
+    }
+  }
   ca  = ca_bincmp_new(l, r, op_id, eps);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, l_cary);
@@ -711,6 +717,7 @@ rb_ca_bincmp_s_build (int argc, VALUE *argv, VALUE klass)
   double eps = 0.0;
   (void) klass;
   rb_scan_args(argc, argv, "31", &l_cary, &r_cary, &op_id_val, &eps_val);
+  /* fits: an operation number from the library's own table */
   op_id = (uint16_t) NUM2UINT(op_id_val);
   if ( argc >= 4 ) eps = NUM2DBL(eps_val);
   return rb_ca_bincmp_build(l_cary, r_cary, op_id, eps);
@@ -724,7 +731,8 @@ rb_ca_bincmp_trapping (VALUE self)
 {
   CABinCmp *bc;
   TypedData_Get_Struct(self, CABinCmp, &cabincmp_data_type, bc);
-  return ( bc->common_dt == CA_OBJECT ) ? Qtrue : Qfalse;
+  return ca_op_raises_on_cell(CA_OP_KIND_BINCMP, bc->op_id, bc->common_dt)
+         ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -741,14 +749,7 @@ rb_ca_bincmp_right (VALUE self)
   return rb_ivar_get(self, rb_intern("__bincmp_right__"));
 }
 
-static VALUE
-rb_ca_bincmp_eps (VALUE self)
-{
-  CABinCmp *bc;
-  TypedData_Get_Struct(self, CABinCmp, &cabincmp_data_type, bc);
-  return rb_float_new(bc->eps);
-}
-
+#ifdef CARRAY_DEV_BUILD
 static VALUE
 rb_ca_bincmp_s_reset_scratch_counter (VALUE klass)
 {
@@ -793,6 +794,7 @@ rb_ca_bincmp_s_leaf_inplace_count (VALUE klass)
   (void) klass;
   return SIZE2NUM(ca_bincmp_leaf_inplace_count);
 }
+#endif /* CARRAY_DEV_BUILD */
 
 static VALUE
 rb_ca_bincmp_s_allocate (VALUE klass)
@@ -853,8 +855,8 @@ Init_ca_obj_bincmp (void)
   rb_define_method(rb_cCABinCmp, "__trapping__", rb_ca_bincmp_trapping, 0);
   rb_define_method(rb_cCABinCmp, "__bincmp_right__",
                                   rb_ca_bincmp_right, 0);
-  rb_define_method(rb_cCABinCmp, "__eps__",       rb_ca_bincmp_eps, 0);
 
+#ifdef CARRAY_DEV_BUILD
   rb_define_singleton_method(rb_cCABinCmp, "__reset_scratch_counter__",
                              rb_ca_bincmp_s_reset_scratch_counter, 0);
   rb_define_singleton_method(rb_cCABinCmp, "__scratch_count__",
@@ -867,4 +869,5 @@ Init_ca_obj_bincmp (void)
                              rb_ca_bincmp_s_reset_leaf_inplace_counter, 0);
   rb_define_singleton_method(rb_cCABinCmp, "__leaf_inplace_count__",
                              rb_ca_bincmp_s_leaf_inplace_count, 0);
+#endif
 }