carray 3.0.0 → 3.0.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);
     }
   }

data/ext/ca_obj_binop.c

@@ -70,11 +70,21 @@ typedef struct CABinOp {
                              collapse and attach lifecycle traversal) */
   uint32_t  attach;
   uint8_t   nosync;
+  /* ---- CAMultiParent conformance (CA_FLAG_MULTI_PARENTS): n_parents and
+         parents[] sit immediately after the CAView header, as the layout
+         convention in carray.h requires, so generic code that would walk a
+         single ->parent folds over both operands instead.  What this buys
+         here is ca_has_mask: it answers for a two-parent view by asking both
+         and creating the mask on demand, which lets the mask stay unbuilt
+         until something reads it. ---- */
+  int32_t   n_parents;        /* always 2 */
+  CArray  **parents;          /* = &operands[0]; no separate allocation */
   /* CABinOp-specific tail */
   CArray   *right;
   uint16_t  op_id;
   uint8_t   right_is_scalar;  /* 1 ⇒ right has elements == 1, walk
                                  with element-stride 0 (= broadcast) */
+  CArray   *operands[2];      /* {left, right}; what parents points at */
 } CABinOp;
 
 static size_t
@@ -125,7 +135,7 @@ ca_binop_setup (CABinOp *ca, CArray *left, CArray *right, uint16_t op_id)
 
   ca->obj_type  = CA_OBJ_BINOP;
   ca->data_type = out_dt;
-  ca->flags     = CA_FLAG_READ_ONLY;
+  ca->flags     = CA_FLAG_READ_ONLY | CA_FLAG_MULTI_PARENTS;
   ca->ndim      = left->ndim;
   ca->bytes     = out_bytes;
   ca->elements  = left->elements;
@@ -139,6 +149,10 @@ ca_binop_setup (CABinOp *ca, CArray *left, CArray *right, uint16_t op_id)
   ca->nosync    = 0;
   ca->right     = right;
   ca->op_id     = op_id;
+  ca->operands[0] = left;
+  ca->operands[1] = right;
+  ca->parents     = ca->operands;
+  ca->n_parents   = 2;
   /* right_is_scalar fast path: when right holds a single element,
      xfer_stride pulls only that cell into scratch and walks the
      kernel with element-stride 0 (broadcast).  The symmetric
@@ -148,9 +162,10 @@ ca_binop_setup (CABinOp *ca, CArray *left, CArray *right, uint16_t op_id)
 
   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 -- and a chain of masked nodes builds
+     one array at the end rather than one per node. */
 
   if ( ca_is_scalar(left) && ca_is_scalar(right) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -291,25 +306,25 @@ ca_binop_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
       one_counts[k]  = 1;
       one_strides[k] = right_bytes;
     }
-    scratch = ca_lazy_arena_acquire(right_bytes);
+    scratch = ( bo->data_type == CA_OBJECT )
+                ? ca_lazy_arena_acquire_object(1)
+                : ca_lazy_arena_acquire(right_bytes);
     ca_binop_scratch_acquire_count++;
     ca_xfer_stride(bo->right, one_starts, one_counts, one_strides,
                    scratch, CA_XFER_GET);
     right_step = 0;
   }
   else {
-    /* Same-shape right.  Pull with the same byte layout the caller
-       requested for the output; right.bytes matches output.bytes
-       because right.data_type == out.data_type by cast-before. */
-    ca_size_t right_strides[CA_RANK_MAX];
-    ca_size_t s = right_bytes;
-    for ( k = bo->ndim - 1; k >= 0; k-- ) {
-      right_strides[k] = s;
-      s *= counts[k];
-    }
-    scratch = ca_lazy_arena_acquire(slab_n * right_bytes);
+    /* Same-shape right.  `strides` is the step through the operand, the
+       same one the left was pulled with -- recomputing a packed one here
+       reads the right operand's cells 0, 1, 2 against the left's 0, 2, 4.
+       right.bytes matches output.bytes because right.data_type ==
+       out.data_type by cast-before, so the same steps serve both. */
+    scratch = ( bo->data_type == CA_OBJECT )
+                ? ca_lazy_arena_acquire_object(slab_n)
+                : ca_lazy_arena_acquire(slab_n * right_bytes);
     ca_binop_scratch_acquire_count++;
-    ca_xfer_stride(bo->right, starts, counts, right_strides, scratch,
+    ca_xfer_stride(bo->right, starts, counts, strides, scratch,
                    CA_XFER_GET);
     right_step = 1;
   }
@@ -438,6 +453,14 @@ ca_binop_func_allocate (void *ap)
 {
   CABinOp *ca = (CABinOp *) ap;
   ca->ptr = xmalloc(ca_length(ca));
+  /* CA_OBJECT cells are VALUEs and this buffer is about to be marked as
+     soon as the view is, so it must not be handed to the GC as raw
+     xmalloc garbage. */
+  if ( ca->data_type == CA_OBJECT ) {
+    VALUE *p = (VALUE *) ca->ptr;
+    ca_size_t i;
+    for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
+  }
 }
 
 static void
@@ -459,6 +482,14 @@ ca_binop_func_attach (void *ap)
   s = ca->bytes;
   for ( k = ca->ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
   for ( k = 0; k < ca->ndim; k++ ) starts[k] = 0;
+  /* CA_OBJECT cells are VALUEs and this buffer is about to be marked as
+     soon as the view is, so it must not be handed to the GC as raw
+     xmalloc garbage. */
+  if ( ca->data_type == CA_OBJECT ) {
+    VALUE *p = (VALUE *) ca->ptr;
+    ca_size_t i;
+    for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
+  }
   ca_binop_func_xfer_stride(ca, starts, ca->dim, native, ca->ptr, CA_XFER_GET);
 }
 
@@ -517,6 +548,19 @@ ca_binop_func_create_mask (void *ap)
              ( bo->op_id == CA_BINOP_BIT_AND || bo->op_id == CA_BINOP_BIT_OR ) );
   is_or  = ( bo->op_id == CA_BINOP_BIT_OR );
 
+  /* One masked operand and no Kleene resolution: the answer is that
+     operand's mask, cell for cell.  Share it the way CAMonOp shares its
+     parent's, rather than allocating a copy per node -- a chain of k
+     binops over one masked array then holds one boolean array, not k. */
+  if ( ! kleene && ( has_l != has_r ) ) {
+    CArray *src = has_l ? l : r;
+    if ( src->elements == bo->elements ) {
+      bo->mask = (CArray *) ca_refer_new(src->mask, CA_BOOLEAN,
+                                         bo->ndim, bo->dim, 0, 0);
+      return;
+    }
+  }
+
   bo->mask = (CArray *) carray_new(CA_BOOLEAN, bo->ndim, bo->dim, 0, NULL);
   dst = (boolean8_t *) bo->mask->ptr;
   n = bo->elements;
@@ -524,8 +568,18 @@ ca_binop_func_create_mask (void *ap)
   /* Kleene needs operand values even where an operand is unmasked. */
   need_l = has_l || kleene;
   need_r = has_r || kleene;
-  if ( need_l ) ca_attach(l);
-  if ( need_r ) ca_attach(r);
+  /* Only Kleene reads operand values.  Every other op reads the operand
+     masks alone, and attaching the operand to reach its mask materialises
+     the whole subexpression under it -- so a chain of k masked binops
+     evaluates its own subtree k times over.  Attach what is read. */
+  if ( kleene ) {
+    if ( need_l ) ca_attach(l);
+    if ( need_r ) ca_attach(r);
+  }
+  else {
+    if ( has_l ) ca_attach(l->mask);
+    if ( has_r ) ca_attach(r->mask);
+  }
 
   lm = has_l ? (boolean8_t *) l->mask->ptr : NULL;
   rm = has_r ? (boolean8_t *) r->mask->ptr : NULL;
@@ -550,8 +604,14 @@ ca_binop_func_create_mask (void *ap)
     dst[i] = m;
   }
 
-  if ( need_l ) ca_detach(l);
-  if ( need_r ) ca_detach(r);
+  if ( kleene ) {
+    if ( need_r ) ca_detach(r);
+    if ( need_l ) ca_detach(l);
+  }
+  else {
+    if ( has_r ) ca_detach(r->mask);
+    if ( has_l ) ca_detach(l->mask);
+  }
 }
 
 ca_operation_function_t ca_binop_func = {
@@ -682,8 +742,7 @@ rb_ca_binop_build (VALUE l_cary, VALUE r_cary, uint16_t op_id)
 
   /* === Step 2: broadcast via ca_broadcast_pair (same-ndim size-1
      expansion).  No-op when shapes already match or either operand
-     is scalar; also a no-op for incompatible shapes, which the
-     final elements-mismatch check below catches. */
+     is scalar; refuses a pair that cannot be brought to one shape. */
   ca_broadcast_pair(&l_resolved, &r_resolved);
   TypedData_Get_Struct(l_resolved, CArray, &carray_data_type, l);
   TypedData_Get_Struct(r_resolved, CArray, &carray_data_type, r);
@@ -735,14 +794,12 @@ rb_ca_binop_build (VALUE l_cary, VALUE r_cary, uint16_t op_id)
       }
     }
     else {
-      /* Cross-ndim or otherwise incompatible shapes; see the
-         builder header comment for why CArray rejects implicit
-         cross-ndim promotion. */
+      /* Unreachable from Ruby: ca_broadcast_pair above refuses a pair
+         it cannot bring to one shape, and states the rule there.  Kept
+         so a caller reaching this builder by another route still finds
+         the kernel guarded. */
       rb_raise(rb_eArgError,
-               "CABinOp: shape mismatch (%lld vs %lld) — only same-"
-               "ndim size-1 broadcast is supported; cross-ndim "
-               "promotion is not adopted in CArray "
-               "(reshape explicitly)",
+               "CABinOp: element count mismatch (%lld vs %lld)",
                (long long) l->elements, (long long) r->elements);
     }
   }
@@ -866,7 +923,6 @@ Init_ca_obj_binop (void)
   rb_define_const(rb_cCABinOp, "OP_AND",        INT2NUM(CA_BINOP_AND));
   rb_define_const(rb_cCABinOp, "OP_OR",         INT2NUM(CA_BINOP_OR));
   rb_define_const(rb_cCABinOp, "OP_XOR",        INT2NUM(CA_BINOP_XOR));
-  rb_define_const(rb_cCABinOp, "OP_REMINDER",   INT2NUM(CA_BINOP_REMINDER));
 
   rb_define_alloc_func(rb_cCABinOp, rb_ca_binop_s_allocate);
   rb_define_method(rb_cCABinOp, "initialize_copy",

data/ext/ca_obj_const_string.c

@@ -227,7 +227,9 @@ ca_operation_function_t ca_const_string_func = {
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride: identity Face is not foldable */
   ca_face_xfer_stride,
-  ca_face_xfer_all
+  ca_face_xfer_all,
+  .fill_addrs  = ca_face_fill_addrs,
+  .fill_stride = ca_face_fill_stride,
 };
 
 /* ------------------------------------------------------------------- */

data/ext/ca_obj_face.c

@@ -66,6 +66,21 @@ ca_face_fill_data (void *ap, void *ptr)
   ca_fill(cav->parent, ptr);
 }
 
+void
+ca_face_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *ptr)
+{
+  CAView *cav = (CAView *) ap;
+  ca_fill_addrs(cav->parent, n, addrs, ptr);
+}
+
+void
+ca_face_fill_stride (void *ap, ca_size_t base, int8_t ndim,
+                            ca_size_t *counts, ca_size_t *steps, void *ptr)
+{
+  CAView *cav = (CAView *) ap;
+  ca_fill_stride(cav->parent, base, ndim, counts, steps, ptr);
+}
+
 void
 ca_face_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
 {
@@ -270,6 +285,71 @@ ca_face_lift (VALUE view, VALUE face_parent)
   return lifted;
 }
 
+/* ca_lazy_marker_lift(view, marker) — the CALazyMarker half of
+ * ca_wrapper_lift.  Same invariant as the Face lift (wrapper on top, view
+ * built against what the wrapper wraps) reached by a shorter route: a
+ * marker carries no subclass state, so there is nothing for
+ * rb_ca_face_template's struct copy to preserve, and building a fresh
+ * marker over the view gets data_type, bytes, shape, mask and flags right
+ * by construction.  That last part is load-bearing for `refer(type)`,
+ * where the view's data_type differs from the one the old marker copied
+ * off the entity.
+ *
+ * The one piece it shares with the Face lift is the one-level swap: the
+ * builder handed us a view whose parent is the marker, and leaving it
+ * there would stack a redundant marker in the middle. */
+static VALUE
+ca_lazy_marker_lift (VALUE view, VALUE marker)
+{
+  CArray *view_ca, *mp;
+  extern VALUE rb_ca_lazy_marker_new (VALUE cary);
+
+  TypedData_Get_Struct(view, CArray, &carray_data_type, view_ca);
+
+  /* Idempotent: a builder that wrapped internally already returned a
+     marker (mirrors the same guard in ca_face_lift). */
+  if ( ca_is_lazy_marker(view_ca) ) {
+    return view;
+  }
+
+  TypedData_Get_Struct(marker, CArray, &carray_data_type, mp);
+
+  /* One-level swap (CAFace.md section 8.3, same reasoning): move the view
+     off the marker and onto what the marker wraps.  Guarded on pointer
+     equality so only a view built directly on this marker fires. */
+  if ( ca_is_view(view_ca)
+       && ((CAView *) view_ca)->parent == mp
+       && ! ca_test_flag(view_ca, CA_FLAG_MULTI_PARENTS) ) {
+    ((CAView *) view_ca)->parent = ((CAView *) mp)->parent;  /* C pointer */
+    rb_ca_set_parent(view, rb_ca_parent(marker));            /* @parent ivar */
+  }
+
+  return rb_ca_lazy_marker_new(view);
+}
+
+/* ca_wrapper_lift(view, wrapper, wrapper_ca) — dispatch for
+ * CA_WRAPPER_LIFT.  The macro has already established that wrapper_ca
+ * carries one of the two flags and that view is a CArray. */
+VALUE
+ca_wrapper_lift (VALUE view, VALUE wrapper, void *wrapper_ca)
+{
+  CArray *ca = (CArray *) wrapper_ca;
+
+  if ( ca_is_face(ca) ) {
+    CArray *view_ca;
+    TypedData_Get_Struct(view, CArray, &carray_data_type, view_ca);
+    /* Some builders (select / repeat / ...) lift their own result; a
+       second lift here would double-wrap.  Mirrors the guard the `[]`
+       call site used to carry inline. */
+    if ( ca_is_face(view_ca) ) {
+      return view;
+    }
+    return ca_face_lift(view, wrapper);
+  }
+
+  return ca_lazy_marker_lift(view, wrapper);
+}
+
 /* ca_strip_face(src) — walk down through Face parents to the storage
  * CArray.  Called at kernel_iterator entry and lazy chain endpoints
  * where downstream code needs to observe the storage layout, not the

data/ext/ca_obj_face.h

@@ -34,7 +34,8 @@
                via parent)
      - detach: release ptr alias, parent detach
      - xfer_*: delegate to parent's xfer_* (= identical shape / index space)
-     - fill_data: delegate to parent's ca_fill (= identical storage bytes)
+     - fill_data / fill_*: delegate to parent (= identical storage bytes,
+       and the identity layout makes the parent's addresses ours)
 
    Subclasses may override as needed (= default policy, not an invariant;
    does not preclude a future transform Face). */
@@ -43,6 +44,9 @@ void ca_face_attach     (void *ap);
 void ca_face_sync       (void *ap);
 void ca_face_detach     (void *ap);
 void ca_face_fill_data  (void *ap, void *ptr);
+void ca_face_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *ptr);
+void ca_face_fill_stride(void *ap, ca_size_t base, int8_t ndim,
+                                 ca_size_t *counts, ca_size_t *steps, void *ptr);
 void ca_face_xfer_index (void *ap, ca_size_t *idx,
                                  void *data, int dir);
 void ca_face_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
@@ -112,6 +116,34 @@ VALUE   rb_ca_record_get_data_class (CArray *ca);
   }                                                               \
 } while (0)
 
+/* -- wrapper lift (Face or CALazyMarker) --
+
+   A Face and a CALazyMarker are both storage-identical wrappers: they add
+   an interpretation over their parent's bytes without changing them.  Both
+   want the same invariant at a view-creating method -- the wrapper stays on
+   top, and the view is built against what the wrapper wraps.  For a Face
+   that keeps `dt.shift(1)` a CATime; for a marker it keeps a fuse block's
+   expression lazy instead of dropping out of the chain.
+
+   The flag test comes first and covers both bits in one mask, so an
+   ordinary array leaves through a single AND.  That matters: `[]` is the
+   hottest method this is deployed on (see devel/bench_index_percall.rb).
+
+   NOT interchangeable with CA_FACE_LIFT_IF_FACE.  Face is lifted at ~24
+   sites, including ones a marker must not follow it through -- `copy` owns
+   its data, `sort` reorders values, `value` and `strip_mask` change what
+   the mask means.  Deploy this only where the result is a view whose shape
+   was fixed at construction and which only moves positions
+   (PROPOSAL_LAZY_MARKER_LIFT section 4). */
+#define CA_WRAPPER_LIFT(obj, self, ca) do {                          \
+  if ( ca_test_flag((ca), CA_FLAG_IS_FACE | CA_FLAG_IS_LAZY_MARKER)  \
+       && rb_obj_is_kind_of((obj), rb_cCArray) ) {                   \
+    (obj) = ca_wrapper_lift((obj), (self), (ca));                    \
+  }                                                                  \
+} while (0)
+
+VALUE ca_wrapper_lift (VALUE view, VALUE wrapper, void *wrapper_ca);
+
 /* -- Scalar fetch decode hook (storage -> surface) --
    On the scalar-return path (= tail of rb_ca_fetch_index /
    rb_ca_fetch_addr), if a Face-derived subclass defines a

data/ext/ca_obj_fake.c

@@ -462,6 +462,17 @@ rb_ca_fake_new (VALUE cary, int8_t data_type, ca_size_t bytes)
   CAFake *ca;
   rb_check_carray_object(cary);
   TypedData_Get_Struct(cary, CArray, &carray_data_type, parent);
+  if ( ca_is_face(parent) && ( data_type == CA_OBJECT
+                               || parent->data_type == CA_FIXLEN ) ) {
+    /* A Face's cells do not mean their storage bytes, so reading them
+       under another data_type hands back what the surface exists to hide.
+       Both ways down stay open and say which one they are.  A Numeric Face
+       is not one of these: its surface is its storage. */
+    rb_raise(rb_eTypeError,
+             "%s has no view of its values in another data_type: "
+             "#to_type gives the values, #parent.fake the raw storage",
+             rb_obj_classname(cary));
+  }
   ca  = ca_fake_new(parent, data_type, bytes);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, cary);

data/ext/ca_obj_fixlen_string.c

@@ -202,7 +202,9 @@ ca_operation_function_t ca_fixlen_string_func = {
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride: identity Face is not foldable */
   ca_face_xfer_stride,
-  ca_face_xfer_all
+  ca_face_xfer_all,
+  .fill_addrs  = ca_face_fill_addrs,
+  .fill_stride = ca_face_fill_stride,
 };
 
 /* ------------------------------------------------------------------- */

data/ext/ca_obj_grid.c

@@ -478,9 +478,17 @@ ca_grid_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
      transposed leaf breaks this (cross-axis / non-multiple strides); fall back
      to per-cell delivery (correct, still no whole-view attach).  The wiring
      guards ndim == grid->ndim, so counts/strides have ndim entries here. */
-  for (k = 0; k < ndim; k++) {
-    if (strides[k] % gnative[k] != 0) { aligned = 0; break; }
-    src_step[k] = strides[k] / gnative[k];
+  /* The request is over the view's addresses, so a transposed / flat request
+     is legal and must not be composed axis-by-axis; see
+     ca_xfer_stride_request_is_axis_box (carray.h). */
+  if ( ! ca_xfer_stride_request_is_axis_box(g, starts, counts, strides) ) {
+    aligned = 0;
+  }
+  else {
+    for (k = 0; k < ndim; k++) {
+      if (strides[k] % gnative[k] != 0) { aligned = 0; break; }
+      src_step[k] = strides[k] / gnative[k];
+    }
   }
 
   if (!aligned) {

data/ext/ca_obj_meld.c

@@ -89,7 +89,7 @@ static ID id_parents;
 /* uniform check                                                        */
 /* ------------------------------------------------------------------- */
 
-/* Parents must share dtype, ndim, bytes, and all dims except meld_axis;
+/* Parents must share data type, ndim, bytes, and all dims except meld_axis;
    meld_axis lengths are the ragged dimension (may differ). */
 static void
 ca_meld_check_uniform (int32_t n_parents, CArray **parents, int8_t meld_axis)
@@ -598,19 +598,24 @@ ca_meld_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   int8_t   i;
   int      structural = 1;
 
-  /* Bound check on meld_axis */
+  s = ca->bytes;
+  for ( i = ca->ndim - 1; i >= 0; i-- ) { native[i] = s; s *= ca->dim[i]; }
+
+  /* Bound check on meld_axis.  The step along the axis is strides[ma] /
+     native[ma] and it can be negative -- a reversed read starts at the far
+     end and walks down -- so the region runs between the first and last
+     index, which is not the same as starts[ma] .. starts[ma] + counts[ma]. */
   {
-    ca_size_t req_lo = starts[ma];
-    ca_size_t req_hi = starts[ma] + counts[ma];
-    if ( req_lo < 0 || req_hi > ca->dim[ma] ) {
+    ca_size_t step = strides[ma] / native[ma];
+    ca_size_t last = starts[ma] + (counts[ma] - 1) * step;
+    ca_size_t req_lo = ( last < starts[ma] ) ? last : starts[ma];
+    ca_size_t req_hi = (( last < starts[ma] ) ? starts[ma] : last) + 1;
+    if ( counts[ma] > 0 && ( req_lo < 0 || req_hi > ca->dim[ma] ) ) {
       rb_raise(rb_eIndexError,
                "CAMeld xfer_stride meld_axis (axis %d) [%lld, %lld) out of range [0, %lld)",
                (int) ma, (long long) req_lo, (long long) req_hi, (long long) ca->dim[ma]);
     }
   }
-
-  s = ca->bytes;
-  for ( i = ca->ndim - 1; i >= 0; i-- ) { native[i] = s; s *= ca->dim[i]; }
   for ( i = 0; i < ca->ndim; i++ ) {
     if ( strides[i] != native[i] ) { structural = 0; break; }
   }