carray 3.0.0 → 3.0.2

data/ext/carray_conversion.c

@@ -7,7 +7,7 @@
   Siblings:
     carray_copy.c        — CArray-to-CArray copy / template family
     carray_element.c     — element-level fetch/store (rb_ca_ptr2obj / obj2ptr)
-    carray_cast_func.c   — dtype cast table used by rb_ca_ptr2obj
+    carray_cast_func.c   — data type cast table used by rb_ca_ptr2obj
 
 ---------------------------------------------------------------------------- */
 
@@ -16,15 +16,15 @@
 #include "ruby/io.h"
 
 /* to_a dispatch:
-     numeric / boolean dtype + entity or attach-able view -> fast path
-       (dtype-direct leaf loop over the attached contig buffer)
+     numeric / boolean data type + entity or attach-able view -> fast path
+       (data type-direct leaf loop over the attached contig buffer)
      CA_OBJECT / CA_FIXLEN                                -> universal
        (rb_ca_fetch_index per cell; ptr is VALUE or byte string, not
         directly castable through the leaf switch)
 
    Masked cells materialise as CA_UNDEF on both paths. */
 
-/* Leaf macro: dtype-specialized inner loop.  Produces `n` VALUE objects
+/* Leaf macro: data type-specialized inner loop.  Produces `n` VALUE objects
    from a contig ptr base + element width, storing into `dst` (Ruby Array). */
 #define TO_A_LEAF_LOOP(T, TO_VALUE) do { \
   const T *src = (const T *) base; \
@@ -42,7 +42,7 @@
 
 #define TO_A_DISPATCH_LEAF(LOOP) do { \
   ca_size_t li; \
-  switch ( dtype ) { \
+  switch ( data_type ) { \
   case CA_FLOAT64: LOOP(double,   rb_float_new); break; \
   case CA_FLOAT32: LOOP(float,    rb_float_new); break; \
   case CA_INT64:   LOOP(int64_t,  LL2NUM);       break; \
@@ -67,13 +67,13 @@
     } \
     break; \
   default: \
-    rb_bug("to_a fast path: unexpected dtype %d", dtype); \
+    rb_bug("to_a fast path: unexpected data type %d", data_type); \
   } \
 } while (0)
 
 #define TO_A_DISPATCH_LEAF_MASKED(LOOP) do { \
   ca_size_t li; \
-  switch ( dtype ) { \
+  switch ( data_type ) { \
   case CA_FLOAT64: LOOP(double,   rb_float_new); break; \
   case CA_FLOAT32: LOOP(float,    rb_float_new); break; \
   case CA_INT64:   LOOP(int64_t,  LL2NUM);       break; \
@@ -95,7 +95,7 @@
     } \
     break; \
   default: \
-    rb_bug("to_a fast path masked: unexpected dtype %d", dtype); \
+    rb_bug("to_a fast path masked: unexpected data type %d", data_type); \
   } \
 } while (0)
 
@@ -105,7 +105,7 @@
 static void
 to_a_fast_recurse (CArray *ca, int32_t level, const char *base,
                    const boolean8_t *mask_base, VALUE dst,
-                   int dtype, ca_size_t bytes, int has_mask)
+                   int data_type, ca_size_t bytes, int has_mask)
 {
   ca_size_t i, n, slab_elements, slab_bytes;
 
@@ -135,7 +135,7 @@ to_a_fast_recurse (CArray *ca, int32_t level, const char *base,
     to_a_fast_recurse(ca, level + 1,
                       base + i * slab_bytes,
                       has_mask ? mask_base + i * slab_elements : NULL,
-                      child, dtype, bytes, has_mask);
+                      child, data_type, bytes, has_mask);
   }
 }
 
@@ -172,8 +172,8 @@ rb_ca_to_a_loop_universal (VALUE self, int32_t level, ca_size_t *idx, VALUE ary)
  * ndim-1 nesting: shape [2, 3] -> 2-element Array of 3-element Arrays.
  * Masked cells become CA_UNDEF; the mask itself is not preserved on the
  * result.  ca_attach(self) supplies a contig row-major buffer for the
- * fast path, so all view kinds land in the dtype-direct leaf loop when
- * the dtype is numeric or boolean; CA_OBJECT / CA_FIXLEN fall through
+ * fast path, so all view kinds land in the data type-direct leaf loop when
+ * the data type is numeric or boolean; CA_OBJECT / CA_FIXLEN fall through
  * to the universal fetch_index walk. */
 VALUE
 rb_ca_to_a (VALUE self)
@@ -181,7 +181,7 @@ rb_ca_to_a (VALUE self)
   volatile VALUE ary;
   CArray *ca;
   ca_size_t idx[CA_RANK_MAX];
-  int dtype, fast_eligible;
+  int data_type, fast_eligible;
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
   ary = rb_ca_is_empty(self) ? rb_ary_new() : rb_ary_new2(ca->dim[0]);
@@ -199,22 +199,22 @@ rb_ca_to_a (VALUE self)
      numeric-storage Face -- CATimedelta serials instead of CATimedelta
      Elements -- while ca[i] / each / to_type(:object) all decode.  The
      universal loop goes through rb_ca_fetch_addr, which decodes. */
-  dtype = ca->data_type;
+  data_type = ca->data_type;
   fast_eligible = (ca->elements > 0)
                   && ( ! ca_is_face(ca) )
-                  && (dtype == CA_FLOAT64 || dtype == CA_FLOAT32
-                      || dtype == CA_INT64   || dtype == CA_INT32
-                      || dtype == CA_INT16   || dtype == CA_INT8
-                      || dtype == CA_UINT64  || dtype == CA_UINT32
-                      || dtype == CA_UINT16  || dtype == CA_UINT8
-                      || dtype == CA_BOOLEAN);
+                  && (data_type == CA_FLOAT64 || data_type == CA_FLOAT32
+                      || data_type == CA_INT64   || data_type == CA_INT32
+                      || data_type == CA_INT16   || data_type == CA_INT8
+                      || data_type == CA_UINT64  || data_type == CA_UINT32
+                      || data_type == CA_UINT16  || data_type == CA_UINT8
+                      || data_type == CA_BOOLEAN);
 
   if ( fast_eligible ) {
     int has_mask = (ca->mask != NULL);
     const boolean8_t *mask_base = has_mask
         ? (const boolean8_t *) ca->mask->ptr : NULL;
     to_a_fast_recurse(ca, 0, ca->ptr, mask_base, ary,
-                      dtype, ca->bytes, has_mask);
+                      data_type, ca->bytes, has_mask);
   }
   else if ( ca->elements > 0 ) {
     rb_ca_to_a_loop_universal(self, 0, idx, ary);
@@ -229,7 +229,7 @@ rb_ca_to_a (VALUE self)
 #undef TO_A_DISPATCH_LEAF_MASKED
 
 /* CArray#convert(data_type=nil, bytes: nil) { |elem| ... } — map every cell
- * through the block, into a new array whose dtype is chosen by argv via
+ * through the block, into a new array whose data type is chosen by argv via
  * CArray#template (shape is inherited from self).
  *
  * Masked cells skip the block; if the block returns CA_UNDEF, the

data/ext/carray_copy.c

@@ -10,6 +10,8 @@
 
 #include "carray.h"
 #include "ca_obj_face.h"   /* CA_FACE_LIFT_IF_FACE */
+#include "carray_internal.h"   /* ca_gc_hold_push / ca_gc_hold_pop_to */
+#include "ca_sweep_engine.h"   /* ca_sweep_same_shape / ca_sweep_refuse_shapes */
 #include <stdarg.h>
 
 /* ------------------------------------------------------------------- */
@@ -18,22 +20,27 @@
  * and bytes as `ca`, copies the element payload, and reproduces the
  * mask state.  Always copies even when `ca` is an entity; for view
  * sources the data path goes through `ca_copy_data`, otherwise a flat
- * memcpy of `ca_length(ca)` bytes.
+ * memcpy of `ca_length(ca)` bytes.  If reading the source raises, the
+ * copy is freed before the raise propagates.
  *
  * Backs `CArray#copy` and is also reachable as a C-level utility from
  * other ext files that need an owned snapshot. */
-CArray *
-ca_copy (void *ap)
+void
+ca_fill_or_free (CArray *co, VALUE (*fill)(VALUE), VALUE arg)
 {
-  CArray *ca = (CArray *) ap;
-  CArray *co;
-
-  if ( ca_is_scalar(ca) ) {
-    co = (CArray *) cscalar_new(ca->data_type, ca->bytes, 0);
-  }
-  else {
-    co = carray_new(ca->data_type, ca->ndim, ca->dim, ca->bytes, 0);
+  int tag = 0;
+  rb_protect(fill, arg, &tag);
+  if ( tag ) {
+    ca_free(co);
+    rb_jump_tag(tag);
   }
+}
+
+static VALUE
+ca_copy_fill (VALUE arg)
+{
+  CArray **pair = (CArray **) arg;
+  CArray *ca = pair[0], *co = pair[1];
 
   if ( ca_is_attached(ca) ) {
     memcpy(co->ptr, ca->ptr, ca_length(ca));
@@ -46,6 +53,26 @@ ca_copy (void *ap)
   if ( ca->mask ) {
     ca_copy_mask(co, ca);
   }
+  return Qnil;
+}
+
+CArray *
+ca_copy (void *ap)
+{
+  CArray *ca = (CArray *) ap;
+  CArray *co;
+  CArray *pair[2];
+
+  if ( ca_is_scalar(ca) ) {
+    co = (CArray *) cscalar_new(ca->data_type, ca->bytes, 0);
+  }
+  else {
+    co = carray_new(ca->data_type, ca->ndim, ca->dim, ca->bytes, 0);
+  }
+
+  pair[0] = ca;
+  pair[1] = co;
+  ca_fill_or_free(co, ca_copy_fill, (VALUE) pair);
 
   return co;
 }
@@ -57,9 +84,18 @@ VALUE
 rb_ca_copy (VALUE self)
 {
   volatile VALUE obj;
-  CArray *ca;
+  CArray *ca, *co;
+  int guard = -1;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
-  obj = ca_wrap_struct(ca_copy(ca));
+  co = ca_copy(ca);
+  /* The copy holds VALUEs that so far exist only in co->ptr, and
+     ca_wrap_struct allocates.  Keep them reachable until the wrapper
+     that owns them exists. */
+  if ( ca_is_object_type(co) ) {
+    guard = ca_gc_hold_push(co->ptr, co->elements);
+  }
+  obj = ca_wrap_struct(co);
+  ca_gc_hold_pop_to(guard);
   CA_FACE_LIFT_IF_FACE(obj, self, ca);
   return obj;
 }
@@ -262,16 +298,16 @@ rb_ca_template_with_type (VALUE self, VALUE rtype, VALUE rbytes)
   return rb_ca_template_method(2, args, self);
 }
 
-/* Picks the largest-shape CArray among `n` variadic CArray arguments
- * and returns `template(largest)`.  Used by `carray_call_cfunc.c` to
- * size the output of vectorised scalar C-function calls, where the
- * inputs may be a mix of scalars and arrays. */
+/* Returns `template` of the first non-scalar among `n` variadic CArray
+ * arguments (of the first argument when all are scalars).  Used by
+ * `carray_call_cfunc.c` to size the output of vectorised scalar
+ * C-function calls: a scalar pairs with any array, two arrays only when
+ * their shapes agree. */
 VALUE
 rb_ca_template_n (int n, ...)
 {
-  volatile VALUE varg, obj;
-  CArray *ca;
-  ca_size_t elements = -1;
+  volatile VALUE varg, obj = Qnil;
+  CArray *ca, *donor = NULL;
   va_list vargs;
   int i;
 
@@ -279,24 +315,23 @@ rb_ca_template_n (int n, ...)
   for (i=0; i<n; i++) {
     varg = va_arg(vargs, VALUE);
     if ( ! rb_obj_is_carray(varg) ) {
+      va_end(vargs);
       rb_raise(rb_eRuntimeError, "[BUG] not-carray object given to rb_ca_template_n");
     }
     TypedData_Get_Struct(varg, CArray, &carray_data_type, ca);
     if ( i == 0 ) {
       obj = varg;
-      elements = ca->elements;
     }
-    else {
-      if ( rb_obj_is_cscalar(varg) ) {
-        continue;
-      }
-      if ( rb_obj_is_cscalar(obj) ) {
-        obj = varg;
-        elements = ca->elements;
-      }
-      else if ( ca->elements != elements ) {
-        rb_raise(rb_eRuntimeError, "size mismatch");
-      }
+    if ( ca_is_scalar(ca) ) {
+      continue;
+    }
+    if ( ! donor ) {
+      donor = ca;
+      obj   = varg;
+    }
+    else if ( ! ca_sweep_same_shape(donor, ca) ) {
+      va_end(vargs);
+      ca_sweep_refuse_shapes(donor, ca);
     }
   }
   va_end(vargs);

data/ext/carray_core.c

@@ -231,7 +231,6 @@ ca_cast_table2[CA_NTYPE][CA_NTYPE] = {
     * CASelect
     * CAObject
     * CARepeat
-    * CAUnboundRepeat
 */
 
 void
@@ -243,7 +242,6 @@ ca_init_obj_type (void)
   extern ca_operation_function_t ca_select_func;
   extern ca_operation_function_t ca_object_func;
   extern ca_operation_function_t ca_stride_func;
-  extern ca_operation_function_t ca_ubrep_func;
 
   /* CArray */
   ca_func[CA_OBJ_ARRAY]       = ca_array_func;
@@ -309,12 +307,6 @@ ca_init_obj_type (void)
   ca_mask_class[CA_OBJ_REPEAT] = rb_cCARepeatMask;
   ca_mask_typeddata[CA_OBJ_REPEAT] = &castride_mask_data_type;
 
-  /* CAUnboundRepeat */
-  ca_func[CA_OBJ_UNBOUND_REPEAT]  = ca_ubrep_func;
-  ca_class[CA_OBJ_UNBOUND_REPEAT] = rb_cCAUnboundRepeat;
-  ca_typeddata[CA_OBJ_UNBOUND_REPEAT] = &caunboundrepeat_data_type;
-  ca_mask_class[CA_OBJ_UNBOUND_REPEAT] = rb_cCAUnboundRepeatMask;
-  ca_mask_typeddata[CA_OBJ_UNBOUND_REPEAT] = &caunboundrepeat_mask_data_type;
 
   ca_obj_num = 9;
 }
@@ -432,11 +424,22 @@ ca_attach_is_alias (void *ap)
 {
   CArray *ca = (CArray *) ap;
   extern ca_operation_function_t ca_stride_func;
+  extern ca_operation_function_t ca_lazy_marker_func;
   extern int ca_stride_is_contiguous (CAStride *ca);
   extern int ca_stride_attach_aliases_root (CAStride *ca);
 
   if ( ca == NULL ) return 0;
   if ( ca_is_entity(ca) )  return 1;
+
+  /* CALazyMarker's attach is literally `ca->ptr = ca->parent->ptr` after
+     attaching the parent — it adds no layout of its own — so it aliases
+     exactly when its parent does.  Without this a marker looks expensive
+     to every caller and views built on it fall onto materialising paths,
+     even though there is nothing between the marker and real memory. */
+  if ( ca_func[ca->obj_type].attach == ca_lazy_marker_func.attach ) {
+    return ca_attach_is_alias(((CAView *) ca)->parent);
+  }
+
   /* CAStride family share ca_stride_func.attach (= ca_stride_func_attach).
      The alias-attach fast path is taken iff composed strides are
      row-major contiguous.  ca_stride_is_contiguous checks the leaf
@@ -1399,6 +1402,30 @@ ca_xfer_strided_walk (char            *src_base,
   }
 }
 
+/* See the comment on the prototype in carray.h. */
+int
+ca_xfer_stride_request_is_axis_box (void *ap, ca_size_t *starts,
+                                    ca_size_t *counts, ca_size_t *strides)
+{
+  CArray   *ca = (CArray *) ap;
+  ca_size_t native[CA_RANK_MAX];
+  ca_size_t s = ca->bytes;
+  int8_t    ndim = ca->ndim, k;
+
+  for ( k = ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
+
+  for ( k = 0; k < ndim; k++ ) {
+    ca_size_t q;
+    if ( counts[k] <= 1 ) continue;          /* moves nothing */
+    if ( strides[k] <= 0 ) return 0;         /* zero / negative: not an axis walk */
+    if ( strides[k] % native[k] != 0 ) return 0;
+    q = strides[k] / native[k];
+    if ( q < 1 ) return 0;
+    if ( starts[k] + (counts[k] - 1) * q >= ca->dim[k] ) return 0;   /* runs off axis k */
+  }
+  return 1;
+}
+
 static void
 ca_xfer_stride_dispatch (CArray *ca, ca_size_t *starts, ca_size_t *counts,
                          ca_size_t *strides, void *data, int dir)
@@ -1532,10 +1559,12 @@ ca_xfer_all_body (VALUE arg)
   return Qnil;
 }
 
+/* `arg` carries the hold depth to unwind to, so nested ca_xfer_all calls
+   each drop their own hold rather than the whole stack. */
 static VALUE
 ca_xfer_all_ensure (VALUE arg)
 {
-  (void) arg;
+  ca_gc_hold_pop_to(NUM2INT(arg));
   ca_lazy_arena_exit();
   return Qnil;
 }
@@ -1545,6 +1574,7 @@ ca_xfer_all (void *ap, void *data, int dir)
 {
   CArray *ca = (CArray *) ap;
   ca_xfer_all_args_t args;
+  int guard = -1;
   if ( ! ca_func[ca->obj_type].xfer_all ) {
     rb_raise(rb_eRuntimeError,
              "[BUG] xfer_all not defined for object type <%i>",
@@ -1562,8 +1592,25 @@ ca_xfer_all (void *ap, void *data, int dir)
      next entry. */
   ca_lazy_arena_enter();
   args.ca = ca; args.data = data; args.dir = dir;
+
+  /* A CA_OBJECT cell is a VALUE, and this buffer belongs to no Ruby
+     object yet -- it is the destination `copy` will hand out, or a
+     view's own freshly allocated one.  The object lane calls rb_funcall
+     per cell, so a collection partway through would free what has been
+     written so far.  ca_xfer_all is the whole-view entry, so the window
+     is exactly ca->elements contiguous cells: the one place where the
+     extent is known without trusting a caller's strides.  Sub-windows
+     written by nested transfers land inside it. */
+  if ( ca->data_type == CA_OBJECT && dir == CA_XFER_GET ) {
+    if ( data != (void *) ca->ptr ) {
+      VALUE *p = (VALUE *) data;
+      ca_size_t i;
+      for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
+    }
+    guard = ca_gc_hold_push(data, ca->elements);
+  }
   rb_ensure(ca_xfer_all_body, (VALUE) &args,
-            ca_xfer_all_ensure, Qnil);
+            ca_xfer_all_ensure, INT2NUM(guard));
 }
 
 /* ------------------------------------------------------------------- */
@@ -1608,6 +1655,18 @@ ca_allocate (void *ap)
   ca_allocate(ca->mask);
 }
 
+/* The first attach of a view: materialise through the type's slot, then
+   its mask.  Run under rb_protect by ca_attach. */
+static VALUE
+ca_attach_view_first (VALUE arg)
+{
+  CArray *ca = (CArray *) arg;
+  ca_func[ca->obj_type].attach(ca);
+  ca_update_mask(ca);
+  ca_attach(ca->mask);
+  return Qnil;
+}
+
 /* attach parent's data to ca->ptr */
 
 void
@@ -1621,14 +1680,30 @@ ca_attach (void *ap)
 
   if ( ca_is_view(ca) ) {  /* view array */
 
-    CAVIEW(ca)->attach += 1; /* increments attach level */
-    if ( CAVIEW(ca)->attach > CA_ATTACH_MAX ) {
+    if ( CAVIEW(ca)->attach >= CA_ATTACH_MAX ) {
       rb_raise(rb_eRuntimeError,
                "too large attach count of view array");
     }
+    CAVIEW(ca)->attach += 1; /* increments attach level */
 
     if ( ! ca->ptr ) {
-      ca_func[ca->obj_type].attach(ap);
+      /* A slot can raise part way (a conversion meeting a value it cannot
+         hold).  Undo the attach then, or the next attach finds ca->ptr
+         set, skips the slot and reads a half-filled buffer.  A slot that
+         got as far as publishing ca->ptr has also attached what its
+         detach slot releases; one that raised earlier has published
+         nothing and released its own parent attach on the way out. */
+      int tag = 0;
+      rb_protect(ca_attach_view_first, (VALUE) ca, &tag);
+      if ( tag ) {
+        if ( ca->ptr ) {
+          ca_func[ca->obj_type].detach(ca);
+          ca->ptr = NULL;
+        }
+        CAVIEW(ca)->attach -= 1;
+        rb_jump_tag(tag);
+      }
+      return;
     }
   }
   else {                      /* entity array */
@@ -1639,6 +1714,43 @@ ca_attach (void *ap)
   ca_attach(ca->mask);
 }
 
+/* Attach every array in list[0..n-1], or, if one of those attaches
+   raises, none of them: the ones already attached are detached before the
+   raise propagates.  For views over several parents. */
+
+typedef struct {
+  CArray **list;
+  int32_t  n;
+  int32_t  done;
+} ca_attach_all_ctx_t;
+
+static VALUE
+ca_attach_all_body (VALUE arg)
+{
+  ca_attach_all_ctx_t *c = (ca_attach_all_ctx_t *) arg;
+  for ( ; c->done < c->n; c->done++ ) {
+    ca_attach(c->list[c->done]);
+  }
+  return Qnil;
+}
+
+void
+ca_attach_all (CArray **list, int32_t n)
+{
+  ca_attach_all_ctx_t c;
+  int tag = 0;
+  c.list = list;
+  c.n    = n;
+  c.done = 0;
+  rb_protect(ca_attach_all_body, (VALUE) &c, &tag);
+  if ( tag ) {
+    while ( c.done > 0 ) {
+      ca_detach(list[--c.done]);
+    }
+    rb_jump_tag(tag);
+  }
+}
+
 /* attach parent's data to ca->ptr */
 
 void
@@ -2040,6 +2152,17 @@ ca_fill (void *ap, void *aptr)
 
 /* ------------------------------------------------------------------- */
 
+#ifdef CARRAY_DEV_BUILD
+
+/* The Ruby attach surface is built into development builds only.  Ruby has no
+   raw pointer, so the only thing a block can do inside an attach window is call
+   back into the array API -- and which door that takes is invisible in the
+   syntax: v[0] reads the attached buffer while v[] and v[0..1] compose past it
+   to the root (R5, see the contract beside ca_attach in carray.h).  Per-cell and
+   whole-array writes reach the buffer and survive the sync; a write through a
+   derived view is discarded.  The in-tree tests drive the healthy spellings, so
+   the surface stays reachable here and out of released builds. */
+
 /* subroutines for CArray.attach, CArray.attach!
                    CArray#attach, CArray#attach! */
 
@@ -2260,6 +2383,8 @@ rb_ca__detach__ (VALUE self)
   return self;
 }
 
+#endif /* CARRAY_DEV_BUILD */
+
 /* ------------------------------------------------------------------- */
 
 static ID id_decode, id_encode;
@@ -2468,6 +2593,7 @@ Init_carray_core (void)
 
   ca_init_obj_type();
 
+#ifdef CARRAY_DEV_BUILD
   rb_define_singleton_method(rb_cCArray, "attach", rb_ca_s_attach, -1);
   rb_define_singleton_method(rb_cCArray, "attach!", rb_ca_s_attach_bang, -1);
 
@@ -2477,6 +2603,7 @@ Init_carray_core (void)
   rb_define_method(rb_cCArray, "__attach__", rb_ca__attach__, 0);
   rb_define_method(rb_cCArray, "__sync__", rb_ca__sync__, 0);
   rb_define_method(rb_cCArray, "__detach__", rb_ca__detach__, 0);
+#endif
 
   rb_define_method(rb_cCArray, "members", rb_ca_members, 0);
 

data/ext/carray_count.c

@@ -2,7 +2,7 @@
 
   CArray#count dispatcher (= value-comparison family entry point).
   Hand-routed because the dispatch decision depends on (self.data_type,
-  v's runtime class), which the per-dtype mkkernel kernels can't see;
+  v's runtime class), which the per-type mkkernel kernels can't see;
   the actual counting is delegated to the kernel-iterator helpers
   listed below.
 
@@ -39,11 +39,12 @@ VALUE rb_ca_count_not_masked (int argc, VALUE *argv, VALUE self);
      - v is a CArray             -> broadcast: count each v[k] and stack
                                     (rejected for boolean self; see below)
      - self is boolean, v scalar -> v must be true/false literal
-     - self is numeric, v scalar -> count_equal_ki (numeric equality)
+     - self is numeric or object, v scalar -> count_equal_ki (numeric ==
+                                    for a number, Ruby == for an object)
 
-   FIXLEN and OBJECT data_types raise CArray::DataTypeError (the
-   kernel-iterator helpers do not implement them).  Extend
-   count_equal_ki if demand returns. */
+     - self is fixlen, v scalar -> count_equal_ki (memcmp over the whole
+                                    cell; a short String query is padded
+                                    out to the cell width) */
 
 static VALUE
 rb_ca_count (int argc, VALUE *argv, VALUE self)
@@ -95,11 +96,7 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
     }
     if ( ca_test_flag(src, CA_FLAG_FACE_COMPARABLE_STORAGE) ) {
       if ( ! query_was_scalar ) {
-        CArray *cv;
-        GetCArray(rval, cv);
-        if ( ca_is_face(cv) ) {
-          rval = rb_ca_strip_face_value(rval);
-        }
+        rval = ca_face_operand_descend(rval, "count(v)");
       }
     }
     else if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -290,7 +287,9 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
                rb_obj_classname(rval));
     }
   } else {
-    if ( rval == Qtrue || rval == Qfalse ) {
+    /* true / false are the boolean array's own domain, not a number --
+       except in an object array, where they are ordinary stored values. */
+    if ( ( rval == Qtrue || rval == Qfalse ) && src->data_type != CA_OBJECT ) {
       rb_raise(rb_eTypeError,
                "count(v) on numeric array: v must be numeric, got %s",
                rb_obj_classname(rval));

data/ext/carray_element.c

@@ -254,10 +254,10 @@ rb_ca_elem_store (VALUE self, VALUE ridx, VALUE obj)
     from_array = 0;
   }
 
-  /* Super-hot path: entity + no mask + common numeric dtype + Numeric obj.
+  /* Super-hot path: entity + no mask + common numeric data type + Numeric obj.
      Bypasses rb_ca_store_index/addr -> ca_update_mask + rb_ca_obj2ptr ->
      cast_table dispatch.  Falls through to general path for: views,
-     existing mask, non-numeric dtype, UNDEF, or non-Numeric obj. */
+     existing mask, non-numeric data type, UNDEF, or non-Numeric obj. */
   if ( ca_is_entity(ca) && ! ca->mask && obj != CA_UNDEF ) {
     int8_t dt = ca->data_type;
     if ( dt == CA_FLOAT64 || dt == CA_FLOAT32 ||
@@ -269,7 +269,7 @@ rb_ca_elem_store (VALUE self, VALUE ridx, VALUE obj)
       /* Compute flat addr if T_ARRAY index path. */
       if ( from_array ) addr = elem_entity_addr(ca, idx);
       char *p = ca->ptr + ca->bytes * addr;
-      /* Convert obj to dtype + store.  Restrict to Fixnum / Float / true
+      /* Convert obj to data type + store.  Restrict to Fixnum / Float / true
          / false to avoid Bignum / Rational / Complex coercion that the
          cast_table handles in the general path. */
       switch ( dt ) {
@@ -311,7 +311,7 @@ rb_ca_elem_store (VALUE self, VALUE ridx, VALUE obj)
         if ( FIXNUM_P(obj) )             { *(uint8_t *)p = (FIX2LONG(obj) != 0); return obj; }
         break;
       }
-      /* Fall through: dtype matches but obj kind needs general coercion. */
+      /* Fall through: data type matches but obj kind needs general coercion. */
     }
   }
 
@@ -344,7 +344,7 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
     volatile VALUE out;
     elem_parse_idx_array(ca, ridx, idx);
 
-    /* Super-hot path: entity + common numeric dtype + no mask.
+    /* Super-hot path: entity + common numeric data type + no mask.
        Bypass ca_fetch_index dispatch AND rb_ca_ptr2obj cast-table dispatch.
        Covers the bench's float64 / int64 / int32 cases. */
     if ( ca_is_entity(ca) && ! ca->mask ) {
@@ -454,7 +454,7 @@ rb_ca_elem_incr (VALUE self, VALUE ridx1)
 
   has_mask = elem_probe_mask(ca);
 
-  /* Super-hot path: entity + no mask + integer dtype.
+  /* Super-hot path: entity + no mask + integer data type.
      Reads p directly, modifies in place — no separate fetch/store dispatch. */
   if ( ca_is_entity(ca) && ! has_mask ) {
     ca_size_t addr;
@@ -818,7 +818,7 @@ rb_ca_elem_min (VALUE self, VALUE ridx, VALUE rval)
              "elem_min requires a numeric array");
   }
 
-  /* Super-hot path: entity + numeric dtype + Fixnum/Float rval. */
+  /* Super-hot path: entity + numeric data type + Fixnum/Float rval. */
   ELEM_MINMAX_BODY(<);
 
   /* General path: view / Bignum-Rational-Complex rval / fall-through.