carray 3.0.0 → 3.0.2

data/ext/ca_kernel_iterator.h

@@ -198,15 +198,9 @@ typedef enum {
 #define CA_ITER_ERR_READONLY    4    /* WRITE on readonly view (CARepeat etc.) */
 #define CA_ITER_ERR_MASK        5    /* masked source — step 4-5 only, lifted in step 6 */
 #define CA_ITER_ERR_MASK_NOT_ALLOWED 6  /* NO_MASK flag set on a masked source (step 7) */
-#define CA_ITER_ERR_UNBOUND_SHAPE 7  /* CAUnboundRepeat passed before bind() — reserved for
-                                        sub-step 9.3 (= used iff unbound CAUbrep smoke shows
-                                        unsafe behavior on the existing SRC_CASTRIDE path) */
-
 /* ---- source kind (step 5+, internal routing) ------------------------- */
 #define CA_ITER_SRC_NONE       0
-#define CA_ITER_SRC_CASTRIDE   1     /* entity / CAStride family (step 1-4).
-                                        CAUnboundRepeat is also classified
-                                        here via ca_ubrep_func = ca_stride_func. */
+#define CA_ITER_SRC_CASTRIDE   1     /* entity / CAStride family (step 1-4) */
 #define CA_ITER_SRC_DESCRIPTOR 2     /* CSA / CAGrid / CASelect / CAMapping / CAWindow / CAShift (step 5+) */
 #define CA_ITER_SRC_ATTACH     3     /* CAFake / CAByteSwap / CABitfield /
                                         CABitarray / CAReduce — view's own
@@ -534,7 +528,24 @@ int  ca_iter_state_init_l2 (ca_iter_state    *st,
    source carries a mask (= ca_has_mask(src)), or NULL otherwise.
    The mask layout matches the value layout (= same iteration order
    and same n).  Step 6+: kernels use the CA_FOR_EACH_UNMASKED macro
-   family (carray.h) to skip masked cells. */
+   family (carray.h) to skip masked cells.
+
+   The mask is an input.  What it points at is a copy taken when the
+   walk began, so writing through it changes nothing -- not even under
+   CA_KERNEL_WRITE, where the value half of the same yield is often a
+   live alias.  It also cannot express the thing an author would most
+   want it for: an unmasked source yields NULL, so there is nowhere to
+   record that a cell has become undefined.  A kernel authors its
+   output mask on its own output array instead:
+
+       if ( op_mask == NULL ) {
+         ca_create_mask(co);
+         op_mask = (boolean8_t *) co->mask->ptr;
+       }
+       op_mask[out_i] = 1;
+
+   which is what every kernel in carray does (carray_hold.c, and the
+   reduction kernels mkkernel emits). */
 int  ca_iter_state_next_slab (ca_iter_state *st,
                               char         **out_ptr,
                               boolean8_t   **out_mask,
@@ -609,6 +620,13 @@ void ca_iter_state_sync_slab (ca_iter_state *st);
    exactly once after a successful init (either level). */
 void ca_iter_state_finish (ca_iter_state *st);
 
+/* Raise unless rc is CA_ITER_OK.  The block macros call this on the value
+   ca_iter_state_init_l1 / _l2 returned, so an author who never looks at a
+   return code still hears about a request the iterator would not serve.
+   Returns rc when there is nothing to report, so it composes inside the
+   macros' comma expressions. */
+int ca_iter_check_init (int rc);
+
 /* ---- Phase C C.3: kernel author block macros ------------------------
    (PROPOSAL_CAPSTONE_PHASE_C.md D3.1 (A) do/while/for + D3.2 (C) 2 kinds)
 
@@ -623,17 +641,24 @@ void ca_iter_state_finish (ca_iter_state *st);
      surrounding scope.
    - `flags` arg propagates to init_l2 (= CA_KERNEL_WRITE supported).
      `sync_slab` is called automatically after each iteration; it's a
-     no-op when WRITE flag is absent.
-   - Init failure (ca_iter_state_init_l2 returns CA_ITER_ERR_*) is
-     silently discarded: the body runs zero times and finish is still
-     called.  Production kernels that need explicit error messages
-     (e.g., sum_ki's rc=%d raise) should drop down to the raw API
-     instead of using this macro.
+     no-op when WRITE flag is absent.  The mask cursor is an input even
+     under WRITE -- see ca_iter_state_next_slab above for why, and for
+     where an output mask is written instead.
+   - Init failure (ca_iter_state_init_l2 returns CA_ITER_ERR_*) raises:
+     the macro passes the code to ca_iter_check_init, which reports what
+     the iterator declined to do.  The body does not run and finish is
+     not reached, which is safe because a failed init allocates nothing.
+     Kernels that want to handle a refusal rather than propagate it
+     should drop down to the raw API and read the code themselves.
    - `break;` from inside the body exits the loop AND triggers finish
      correctly (= outer for's "increment" clause runs once on natural
      exit; `break` from the inner while breaks both).  `return` inside
      the body LEAKS resources (scratch_ptr, parent attach) — drop to
-     raw API if early return is needed.
+     raw API if early return is needed.  A body that raises leaks the
+     same way: the engine releases what it holds when the walk itself
+     raises (a gather or a write-back through the source's slots), but
+     the body runs in the caller's frame, where it has no hold on it.
+     An object-lane body calling back into Ruby is the case to watch.
    - Macros are not statement-equivalent (= they expand to nested for
      constructs).  Don't follow them with `else` etc. */
 
@@ -766,8 +791,9 @@ void ca_iter_state_finish (ca_iter_state *st);
    always-constant argument).  CA_SLAB_AXES is still FROZEN, because
    raw-API kernels pass it to ca_iter_state_init_l2 directly. */
 #define CA_FOR_EACH_SLAB(st, ca, axes, naxes, flags, p, m)                    \
-  for ( int __caf_init = (ca_iter_state_init_l2(&(st), (ca), CA_SLAB_AXES,    \
-                                                (axes), (naxes), (flags)),    \
+  for ( int __caf_init = (ca_iter_check_init(                                 \
+                            ca_iter_state_init_l2(&(st), (ca), CA_SLAB_AXES,  \
+                                                  (axes), (naxes), (flags))), \
                           1);                                                 \
         __caf_init;                                                           \
         __caf_init = 0, ca_iter_state_finish(&(st)) )                         \
@@ -783,16 +809,18 @@ void ca_iter_state_finish (ca_iter_state *st);
    Shape mismatch between ca_in / ca_out is NOT validated by the macro
    — caller responsibility (= typically output is `rb_ca_template_with_type`
    of input, guaranteeing same shape).  Init failure on either iter
-   silently skips the body. */
+   raises — see CA_FOR_EACH_SLAB above. */
 /* Policy fixed to CA_SLAB_AXES internally — see CA_FOR_EACH_SLAB above. */
 #define CA_FOR_EACH_SLAB_INOUT(st_in, st_out, ca_in, ca_out,                  \
                                axes, naxes,                                   \
                                p_in, p_out, m_in, m_out)                      \
   for ( int __cafi_init = (                                                   \
-            ca_iter_state_init_l2(&(st_in),  (ca_in),  CA_SLAB_AXES,          \
-                                  (axes), (naxes), 0),                        \
-            ca_iter_state_init_l2(&(st_out), (ca_out), CA_SLAB_AXES,          \
-                                  (axes), (naxes), CA_KERNEL_WRITE),          \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_in),  (ca_in),  CA_SLAB_AXES,        \
+                                    (axes), (naxes), 0)),                     \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_out), (ca_out), CA_SLAB_AXES,        \
+                                    (axes), (naxes), CA_KERNEL_WRITE)),       \
             1);                                                               \
         __cafi_init;                                                          \
         __cafi_init = 0,                                                      \
@@ -833,9 +861,10 @@ void ca_iter_state_finish (ca_iter_state *st);
 
 #define CA_FOR_EACH_FIBER(st, ca, axis, flags, p, n)                          \
   for ( int __cff_init = (                                                    \
-            ca_iter_state_init_l2(&(st), (ca), CA_SLAB_AXES,                  \
-                                  (int8_t[]){(int8_t)(axis)}, 1,              \
-                                  (flags) | CA_KERNEL_FIBER_CONTIG),          \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st), (ca), CA_SLAB_AXES,                \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    (flags) | CA_KERNEL_FIBER_CONTIG)),       \
             (n) = (st).slab_dims[0],                                          \
             1);                                                               \
         __cff_init;                                                           \
@@ -845,9 +874,10 @@ void ca_iter_state_finish (ca_iter_state *st);
 
 #define CA_FOR_EACH_FIBER_MASKED(st, ca, axis, flags, p, n, m)                \
   for ( int __cffm_init = (                                                   \
-            ca_iter_state_init_l2(&(st), (ca), CA_SLAB_AXES,                  \
-                                  (int8_t[]){(int8_t)(axis)}, 1,              \
-                                  (flags) | CA_KERNEL_FIBER_CONTIG),          \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st), (ca), CA_SLAB_AXES,                \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    (flags) | CA_KERNEL_FIBER_CONTIG)),       \
             (n) = (st).slab_dims[0],                                          \
             1);                                                               \
         __cffm_init;                                                          \
@@ -870,13 +900,15 @@ void ca_iter_state_finish (ca_iter_state *st);
 #define CA_FOR_EACH_FIBER_INOUT(st_in, st_out, ca_in, ca_out, axis,           \
                                 flags, p_in, p_out, n)                        \
   for ( int __cffi_init = (                                                   \
-            ca_iter_state_init_l2(&(st_in),  (ca_in),  CA_SLAB_AXES,          \
-                                  (int8_t[]){(int8_t)(axis)}, 1,              \
-                                  (flags) | CA_KERNEL_FIBER_CONTIG),          \
-            ca_iter_state_init_l2(&(st_out), (ca_out), CA_SLAB_AXES,          \
-                                  (int8_t[]){(int8_t)(axis)}, 1,              \
-                                  ((flags) | CA_KERNEL_FIBER_CONTIG           \
-                                           | CA_KERNEL_WRITE)),               \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_in),  (ca_in),  CA_SLAB_AXES,        \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    (flags) | CA_KERNEL_FIBER_CONTIG)),       \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_out), (ca_out), CA_SLAB_AXES,        \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    ((flags) | CA_KERNEL_FIBER_CONTIG         \
+                                             | CA_KERNEL_WRITE))),            \
             (n) = (st_in).slab_dims[0],                                       \
             1);                                                               \
         __cffi_init;                                                          \
@@ -894,13 +926,15 @@ void ca_iter_state_finish (ca_iter_state *st);
 #define CA_FOR_EACH_FIBER_INOUT_MASKED(st_in, st_out, ca_in, ca_out, axis,    \
                                        flags, p_in, p_out, n, m)              \
   for ( int __cffim_init = (                                                  \
-            ca_iter_state_init_l2(&(st_in),  (ca_in),  CA_SLAB_AXES,          \
-                                  (int8_t[]){(int8_t)(axis)}, 1,              \
-                                  (flags) | CA_KERNEL_FIBER_CONTIG),          \
-            ca_iter_state_init_l2(&(st_out), (ca_out), CA_SLAB_AXES,          \
-                                  (int8_t[]){(int8_t)(axis)}, 1,              \
-                                  ((flags) | CA_KERNEL_FIBER_CONTIG           \
-                                           | CA_KERNEL_WRITE)),               \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_in),  (ca_in),  CA_SLAB_AXES,        \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    (flags) | CA_KERNEL_FIBER_CONTIG)),       \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_out), (ca_out), CA_SLAB_AXES,        \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    ((flags) | CA_KERNEL_FIBER_CONTIG         \
+                                             | CA_KERNEL_WRITE))),            \
             (n) = (st_in).slab_dims[0],                                       \
             1);                                                               \
         __cffim_init;                                                         \
@@ -915,6 +949,73 @@ void ca_iter_state_finish (ca_iter_state *st);
             ca_iter_state_sync_slab(&(st_in)),                                \
             ca_iter_state_sync_slab(&(st_out)) )
 
+/* PAIR forms: two sources read together along the same axis.
+
+   The INOUT forms cover input + output.  These cover input + input, which
+   is what a routine taking two vectors of the same length wants -- a
+   correlation, a dot product, a distance.  Neither state gets
+   CA_KERNEL_WRITE, and `flags` must not carry it: use the INOUT forms to
+   write.
+
+   Both fibers are contig-delivered, so the pair may be handed straight to
+   a C routine that walks it itself.  The MASKED form yields BOTH mask
+   cursors: which cells a pair of fibers may be used at is a question about
+   both of them, and the INOUT forms answer only about the input.
+
+   Shape agreement is guarded the way the INOUT forms guard it (ndim,
+   elements, fiber length), and the body is skipped on mismatch.  The two
+   sources may be the same array. */
+
+#define CA_FOR_EACH_FIBER_PAIR(st_a, st_b, ca_a, ca_b, axis,                  \
+                               flags, p_a, p_b, n)                            \
+  for ( int __cffp_init = (                                                   \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_a), (ca_a), CA_SLAB_AXES,            \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    (flags) | CA_KERNEL_FIBER_CONTIG)),       \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_b), (ca_b), CA_SLAB_AXES,            \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    (flags) | CA_KERNEL_FIBER_CONTIG)),       \
+            (n) = (st_a).slab_dims[0],                                        \
+            1);                                                               \
+        __cffp_init;                                                          \
+        __cffp_init = 0,                                                      \
+          ca_iter_state_finish(&(st_a)),                                      \
+          ca_iter_state_finish(&(st_b)) )                                     \
+    for ( ; (st_a).src->ndim     == (st_b).src->ndim                          \
+         && (st_a).src->elements == (st_b).src->elements                      \
+         && (st_a).slab_dims[0]  == (st_b).slab_dims[0]                       \
+         && ca_iter_state_next_slab_axes(&(st_a), &(p_a), NULL)               \
+         && ca_iter_state_next_slab_axes(&(st_b), &(p_b), NULL);              \
+            ca_iter_state_sync_slab(&(st_a)),                                 \
+            ca_iter_state_sync_slab(&(st_b)) )
+
+#define CA_FOR_EACH_FIBER_PAIR_MASKED(st_a, st_b, ca_a, ca_b, axis,           \
+                                      flags, p_a, p_b, n, m_a, m_b)           \
+  for ( int __cffpm_init = (                                                  \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_a), (ca_a), CA_SLAB_AXES,            \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    (flags) | CA_KERNEL_FIBER_CONTIG)),       \
+            ca_iter_check_init(                                               \
+              ca_iter_state_init_l2(&(st_b), (ca_b), CA_SLAB_AXES,            \
+                                    (int8_t[]){(int8_t)(axis)}, 1,            \
+                                    (flags) | CA_KERNEL_FIBER_CONTIG)),       \
+            (n) = (st_a).slab_dims[0],                                        \
+            1);                                                               \
+        __cffpm_init;                                                         \
+        __cffpm_init = 0,                                                     \
+          ca_iter_state_finish(&(st_a)),                                      \
+          ca_iter_state_finish(&(st_b)) )                                     \
+    for ( ; (st_a).src->ndim     == (st_b).src->ndim                          \
+         && (st_a).src->elements == (st_b).src->elements                      \
+         && (st_a).slab_dims[0]  == (st_b).slab_dims[0]                       \
+         && ca_iter_state_next_slab_axes(&(st_a), &(p_a), &(m_a))             \
+         && ca_iter_state_next_slab_axes(&(st_b), &(p_b), &(m_b));            \
+            ca_iter_state_sync_slab(&(st_a)),                                 \
+            ca_iter_state_sync_slab(&(st_b)) )
+
 /* ---- Phase D: per-data_type reduction macro suite ----------------------- */
 
 /* CA_SLAB_REDUCE_T(T, ...): generic per-data_type slab reduction.  T is the
@@ -1100,8 +1201,7 @@ void ca_iter_state_finish (ca_iter_state *st);
  *
  *   PoC (2026-06-12): N=1M f64 sum 906 us -> 116 us (= 7.8x, 68.8 GB/s).
  *   Parity: ε-close (relative error < 2e-16 for f64 sum), bit-exact
- *   not guaranteed (= reassoc license, documented in CLAUDE.md
- *   ε-close policy section, SL.1.5).
+ *   not guaranteed (= the SIMD license; see guides/devel/11_kernel_iterator.md).
  *
  *   Other state vars referenced inside REDUCE (induction counters
  *   like `cnt`, position counters like `idx`) are auto-vectorised
@@ -1217,7 +1317,7 @@ void ca_iter_state_finish (ca_iter_state *st);
  *   EXPR(x) is a function-like macro producing the per-element contribution
  *   (Pass 1: (double)(x); Pass 2: ((double)(x)-mean)*((double)(x)-mean)).
  *   Reassoc across the 8 lanes is the same ε-close license as _PLUS_EX
- *   (bit-exact not guaranteed; CLAUDE.md ε-close policy, SL.1.5).
+ *   (bit-exact not guaranteed; see guides/devel/11_kernel_iterator.md).
  *
  *   Only the no-mask + contig branch is 8-way; masked / non-contig
  *   branches stay single-accumulator (not the hot path).  Position

data/ext/ca_obj_array.c

@@ -825,26 +825,17 @@ rb_ca_s_allocate (VALUE klass)
   return TypedData_Make_Struct(klass, CArray, &carray_data_type, ca);
 }
 
-/* @overload  initialize(data_type, dim, bytes=0) { ... }
+/* Reads the (data_type, dim, bytes: nil) argument list that CArray.new
+   and CArray.__empty__ 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. */
 
-Constructs a new CArray object of <i>data_type</i>, which has the
-ndim and the dimensions specified by an <code>Array</code> of
-<code>Integer</code> or an argument list of <code>Integer</code>.
-The byte size of each element for the fixed length data type
-(<code>data_type == CA_FIXLEN</code>) is specified optional argument
-<i>bytes</i>. Otherwise, this optional argument has no
-effect. If the block is given, the new CArray
-object will be initialized by the value returned from the block.
-*/
-
-static VALUE
-rb_ca_initialize (int argc, VALUE *argv, VALUE self)
+static void
+ca_scan_construct_args (int argc, VALUE *argv, int8_t *data_type,
+                        ca_size_t *bytes, int8_t *ndim, ca_size_t *dim)
 {
   volatile VALUE rtype, rdim, ropt, rbytes = Qnil;
-  CArray *ca;
-  int8_t data_type, ndim;
-  ca_size_t dim[CA_RANK_MAX];
-  ca_size_t bytes;
   int8_t i;
 
   rb_scan_args(argc, argv, "21", (VALUE *)&rtype, (VALUE *) &rdim, (VALUE *) &ropt);
@@ -863,13 +854,36 @@ rb_ca_initialize (int argc, VALUE *argv, VALUE self)
              rtype, rtype, rtype);
   }
 
-  rb_ca_guess_type_and_bytes(rtype, rbytes, &data_type, &bytes);
+  rb_ca_guess_type_and_bytes(rtype, rbytes, data_type, bytes);
 
   Check_Type(rdim, T_ARRAY);
-  ndim = RARRAY_LEN(rdim);
-  for (i=0; i<ndim; i++) {
+  *ndim = RARRAY_LEN(rdim);
+  for (i=0; i<*ndim; i++) {
     dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
   }
+}
+
+/* @overload  initialize(data_type, dim, bytes=0) { ... }
+
+Constructs a new CArray object of <i>data_type</i>, which has the
+ndim and the dimensions specified by an <code>Array</code> of
+<code>Integer</code> or an argument list of <code>Integer</code>.
+The byte size of each element for the fixed length data type
+(<code>data_type == CA_FIXLEN</code>) is specified optional argument
+<i>bytes</i>. Otherwise, this optional argument has no
+effect. If the block is given, the new CArray
+object will be initialized by the value returned from the block.
+*/
+
+static VALUE
+rb_ca_initialize (int argc, VALUE *argv, VALUE self)
+{
+  CArray *ca;
+  int8_t data_type, ndim;
+  ca_size_t dim[CA_RANK_MAX];
+  ca_size_t bytes;
+
+  ca_scan_construct_args(argc, argv, &data_type, &bytes, &ndim, dim);
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
   if ( ca_func[CA_OBJ_ARRAY].pool_init ) {
@@ -1438,6 +1452,33 @@ rb_ca_s_alloc_uninit (VALUE klass, VALUE rtype, VALUE rshape)
   return rb_carray_new(data_type, ndim, dim, bytes, NULL);
 }
 
+/* Internal primitive behind CArray.empty(data_type, dim, bytes: nil) in
+   lib/carray/construct.rb, which also routes the compatibility spelling
+   CArray.empty(*shape).  It is CArray.new with the fill left out: the
+   arguments are read by the same function, and the buffer comes from
+   rb_carray_new (= no MEMZERO) rather than rb_carray_new_safe.  A block
+   is refused -- filling is what CArray.new is for.  CA_OBJECT still
+   falls through to the zero-VALUE init inside carray_setup_i (= required
+   for GC), so any data_type is safe to ask for. */
+
+static VALUE
+rb_ca_s_empty (int argc, VALUE *argv, VALUE klass)
+{
+  int8_t data_type, ndim;
+  ca_size_t dim[CA_RANK_MAX];
+  ca_size_t bytes;
+
+  if ( rb_block_given_p() ) {
+    rb_raise(rb_eArgError,
+             "CArray.empty does not take a block "
+             "(its contents are left undefined); use CArray.new to fill.");
+  }
+
+  ca_scan_construct_args(argc, argv, &data_type, &bytes, &ndim, dim);
+
+  return rb_carray_new(data_type, ndim, dim, bytes, NULL);
+}
+
 void
 Init_ca_obj_array (void)
 {
@@ -1449,6 +1490,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_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

@@ -9,7 +9,7 @@
   ca_bincmp_kernel_lookup from ca_bincmp_dispatch.h.
 
   Dispatch by data_type:
-    numeric (i8..f64, +complex) -> ca_bincmp_<op>_<dtype> kernel
+    numeric (i8..f64, +complex) -> ca_bincmp_<op>_<type> kernel
     boolean / fixlen / object   -> not implemented (raise)
 
   CAREFUL: the binop in-place trick (= pull left into the output
@@ -60,6 +60,12 @@ typedef struct CABinCmp {
   CArray   *parent;          /* = left */
   uint32_t  attach;
   uint8_t   nosync;
+  /* ---- CAMultiParent conformance (CA_FLAG_MULTI_PARENTS): n_parents and
+         parents[] sit immediately after the CAView header, as carray.h's
+         layout convention requires, so ca_has_mask can fold over both
+         operands and build the mask on demand instead of at setup. ---- */
+  int32_t   n_parents;        /* always 2 */
+  CArray  **parents;          /* = &operands[0]; no separate allocation */
   /* CABinCmp-specific tail */
   CArray   *right;
   uint16_t  op_id;
@@ -72,6 +78,7 @@ typedef struct CABinCmp {
                                 `eps` name is retained to keep the
                                 `__eps__` Ruby accessor stable across
                                 the dual purpose. */
+  CArray   *operands[2];      /* {left, right}; what parents points at */
 } CABinCmp;
 
 static size_t
@@ -119,7 +126,7 @@ ca_bincmp_setup (CABinCmp *ca, CArray *left, CArray *right, uint16_t op_id,
 {
   ca->obj_type  = CA_OBJ_BINCMP;
   ca->data_type = CA_BOOLEAN;          /* output is always boolean */
-  ca->flags     = CA_FLAG_READ_ONLY;
+  ca->flags     = CA_FLAG_READ_ONLY | CA_FLAG_MULTI_PARENTS;
   ca->ndim      = left->ndim;
   ca->bytes     = 1;                   /* boolean8_t */
   ca->elements  = left->elements;
@@ -137,12 +144,16 @@ ca_bincmp_setup (CABinCmp *ca, CArray *left, CArray *right, uint16_t op_id,
   /* Builder has already cast both operands to common data_type.  */
   ca->common_dt = left->data_type;
   ca->eps       = eps;
+  ca->operands[0] = left;
+  ca->operands[1] = right;
+  ca->parents     = ca->operands;
+  ca->n_parents   = 2;
 
   memcpy(ca->dim, left->dim, left->ndim * sizeof(ca_size_t));
 
-  if ( ca_has_mask(left) || ca_has_mask(right) ) {
-    ca_create_mask(ca);
-  }
+  /* The mask is NOT built here.  ca_has_mask folds over parents[] for a
+     multi-parent view and creates it on demand, so an expression whose mask
+     nobody reads never allocates one. */
 
   if ( ca_is_scalar(left) && ca_is_scalar(right) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -294,7 +305,9 @@ ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   int8_t    k;
   void     *left_scratch, *right_scratch;
   ca_size_t operand_bytes;
+  ca_size_t operand_strides[CA_RANK_MAX];
   ca_size_t right_step;
+  int       is_contig;
   int       left_is_inplace  = 0;   /* skip release for leaf-opt path */
   int       right_is_inplace = 0;
 
@@ -308,10 +321,33 @@ ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
 
   operand_bytes = ca_sizeof[bc->common_dt];
 
+  /* An operand cell is operand_bytes wide where this view's is one byte
+     (CA_BOOLEAN), so the caller's strides cannot be handed to the operand
+     pull the way a binop hands them on -- they have to be restated at the
+     operand's cell size.  strides[k] / bytes is the index step, which is
+     what the two spaces share.
+
+     is_contig says the caller asked for the row-major slab that xfer_all
+     and attach send.  Only then does an operand's own buffer hold the
+     wanted cells in the packed order the kernel reads them in, so it is
+     also the only case the leaf in-place path is good for. */
+  {
+    ca_size_t native = bc->bytes;
+    is_contig = 1;
+    for ( k = bc->ndim - 1; k >= 0; k-- ) {
+      operand_strides[k] = strides[k] / bc->bytes * operand_bytes;
+      if ( strides[k] != native ) {
+        is_contig = 0;
+      }
+      native *= bc->dim[k];
+    }
+  }
+
   /* === 1. pull LEFT (leaf in-place read or arena scratch) === */
   {
     char *left_inplace = NULL;
-    if ( ca_bincmp_try_leaf_inplace(bc->parent, bc->common_dt,
+    if ( is_contig &&
+         ca_bincmp_try_leaf_inplace(bc->parent, bc->common_dt,
                                      starts, counts, operand_bytes,
                                      &left_inplace) ) {
       /* Leaf-opt path: use parent->ptr + byte_offset directly. */
@@ -320,15 +356,11 @@ ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
       ca_bincmp_leaf_inplace_count++;
     }
     else {
-      ca_size_t left_strides[CA_RANK_MAX];
-      ca_size_t s = operand_bytes;
-      for ( k = bc->ndim - 1; k >= 0; k-- ) {
-        left_strides[k] = s;
-        s *= counts[k];
-      }
-      left_scratch = ca_lazy_arena_acquire(slab_n * operand_bytes);
+      left_scratch = ( bc->common_dt == CA_OBJECT )
+                       ? ca_lazy_arena_acquire_object(slab_n)
+                       : ca_lazy_arena_acquire(slab_n * operand_bytes);
       ca_bincmp_scratch_acquire_count++;
-      ca_xfer_stride(bc->parent, starts, counts, left_strides, left_scratch,
+      ca_xfer_stride(bc->parent, starts, counts, operand_strides, left_scratch,
                      CA_XFER_GET);
     }
   }
@@ -355,7 +387,9 @@ ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     else {
       ca_size_t one_strides[CA_RANK_MAX];
       for ( k = 0; k < bc->right->ndim; k++ ) one_strides[k] = operand_bytes;
-      right_scratch = ca_lazy_arena_acquire(operand_bytes);
+      right_scratch = ( bc->common_dt == CA_OBJECT )
+                        ? ca_lazy_arena_acquire_object(1)
+                        : ca_lazy_arena_acquire(operand_bytes);
       ca_bincmp_scratch_acquire_count++;
       ca_xfer_stride(bc->right, one_starts, one_counts, one_strides,
                      right_scratch, CA_XFER_GET);
@@ -365,7 +399,8 @@ ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   else {
     /* Same-shape right: full slab pull or leaf-opt. */
     char *right_inplace = NULL;
-    if ( ca_bincmp_try_leaf_inplace(bc->right, bc->common_dt,
+    if ( is_contig &&
+         ca_bincmp_try_leaf_inplace(bc->right, bc->common_dt,
                                      starts, counts, operand_bytes,
                                      &right_inplace) ) {
       right_scratch = right_inplace;
@@ -373,15 +408,11 @@ ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
       ca_bincmp_leaf_inplace_count++;
     }
     else {
-      ca_size_t right_strides[CA_RANK_MAX];
-      ca_size_t s = operand_bytes;
-      for ( k = bc->ndim - 1; k >= 0; k-- ) {
-        right_strides[k] = s;
-        s *= counts[k];
-      }
-      right_scratch = ca_lazy_arena_acquire(slab_n * operand_bytes);
+      right_scratch = ( bc->common_dt == CA_OBJECT )
+                        ? ca_lazy_arena_acquire_object(slab_n)
+                        : ca_lazy_arena_acquire(slab_n * operand_bytes);
       ca_bincmp_scratch_acquire_count++;
-      ca_xfer_stride(bc->right, starts, counts, right_strides, right_scratch,
+      ca_xfer_stride(bc->right, starts, counts, operand_strides, right_scratch,
                      CA_XFER_GET);
     }
     right_step = 1;
@@ -644,10 +675,9 @@ rb_ca_bincmp_build (VALUE l_cary, VALUE r_cary, uint16_t op_id, double eps)
       TypedData_Get_Struct(l_resolved, CArray, &carray_data_type, l);
     }
     else {
+      /* Unreachable from Ruby; see the note in ca_obj_binop.c. */
       rb_raise(rb_eArgError,
-               "CABinCmp: shape mismatch (%lld vs %lld) — only same-"
-               "ndim size-1 broadcast is supported; cross-ndim "
-               "promotion is not adopted in CArray",
+               "CABinCmp: element count mismatch (%lld vs %lld)",
                (long long) l->elements, (long long) r->elements);
     }
   }