carray 3.0.0 → 3.0.1

data/ext/ca_obj_moncmp.c

@@ -2,7 +2,7 @@
 
   CAMonCmp — lazy monadic element-wise comparison view: is_nan /
   is_inf / is_finite / is_invalid / signbit.  Output data_type =
-  CA_BOOLEAN (1 byte); operand keeps its native data_type (per-dtype
+  CA_BOOLEAN (1 byte); operand keeps its native data_type (per-type
   kernels cover integer as well, so is_nan / is_inf on integer parents
   return const-false and is_finite const-true without a cast layer).
 
@@ -20,7 +20,7 @@
   Peak scratch: 1 operand-data_type slab.
 
   Mask propagation:
-    Per-dtype moncmp kernels write only at non-masked positions, so
+    Per-type moncmp kernels write only at non-masked positions, so
     the standard create_mask = parent.mask machinery carries mask bits
     to the caller-visible result.  No in-flight mask handling in
     xfer_stride.
@@ -121,9 +121,8 @@ ca_moncmp_setup (CAMonCmp *ca, CArray *parent, uint16_t op_id)
 
   memcpy(ca->dim, parent->dim, parent->ndim * sizeof(ca_size_t));
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
+  /* The mask is NOT built here: ca_has_mask creates a view's mask on
+     demand from its parent's. */
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
@@ -252,6 +251,8 @@ ca_moncmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   int8_t    k;
   void     *scratch;
   ca_size_t operand_bytes;
+  ca_size_t operand_strides[CA_RANK_MAX];
+  int       is_contig;
 
   if ( dir != CA_XFER_GET ) {
     rb_raise(rb_eRuntimeError, "CAMonCmp is read-only (xfer_stride PUT)");
@@ -263,26 +264,44 @@ ca_moncmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
 
   operand_bytes = mc->parent->bytes;
 
+  /* The operand's cell is operand_bytes wide where this view's is one byte
+     (CA_BOOLEAN), so the caller's strides have to be restated at the
+     operand's cell size before the pull; 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 the parent'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 = mc->bytes;
+    is_contig = 1;
+    for ( k = mc->ndim - 1; k >= 0; k-- ) {
+      operand_strides[k] = strides[k] / mc->bytes * operand_bytes;
+      if ( strides[k] != native ) {
+        is_contig = 0;
+      }
+      native *= mc->dim[k];
+    }
+  }
+
   /* === 1. pull parent (leaf-opt or scratch) === */
   int scratch_is_inplace = 0;
   {
     char *inplace = NULL;
-    if ( ca_moncmp_try_leaf_inplace(mc->parent, starts, counts,
+    if ( is_contig &&
+         ca_moncmp_try_leaf_inplace(mc->parent, starts, counts,
                                      operand_bytes, &inplace) ) {
       scratch = inplace;
       scratch_is_inplace = 1;
       ca_moncmp_leaf_inplace_count++;
     }
     else {
-      ca_size_t scratch_strides[CA_RANK_MAX];
-      ca_size_t s = operand_bytes;
-      for ( k = mc->ndim - 1; k >= 0; k-- ) {
-        scratch_strides[k] = s;
-        s *= counts[k];
-      }
-      scratch = ca_lazy_arena_acquire(slab_n * operand_bytes);
+      scratch = ( mc->parent->data_type == CA_OBJECT )
+                  ? ca_lazy_arena_acquire_object(slab_n)
+                  : ca_lazy_arena_acquire(slab_n * operand_bytes);
       ca_moncmp_scratch_acquire_count++;
-      ca_xfer_stride(mc->parent, starts, counts, scratch_strides, scratch,
+      ca_xfer_stride(mc->parent, starts, counts, operand_strides, scratch,
                      CA_XFER_GET);
     }
   }

data/ext/ca_obj_monop.c

@@ -207,9 +207,9 @@ ca_monop_setup (CAMonOp *ca, CArray *parent, uint16_t op_id)
 
   memcpy(ca->dim, parent->dim, parent->ndim * sizeof(ca_size_t));
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
+  /* The mask is NOT built here: ca_has_mask creates a view's mask on
+     demand from its parent's, so an expression whose mask nobody reads
+     never allocates one. */
 
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -380,8 +380,8 @@ ca_size_t ca_monop_materialise_call_count = 0;
    but they are unobservable: the output mask is built separately via
    the attach lifecycle (ca_monop_func_create_mask + parent.mask
    CARefer), so reads of masked cells return UNDEF regardless of byte
-   contents.  This is the design license stated in CLAUDE.md
-   §"design premises" ("mask is not a protection mechanism").
+   contents.  The mask marks cells as undefined; it does not guard their
+   bytes, so writing garbage into a masked cell is licensed.
 
    A "partial mask slow path" (= a cell-wise branch to skip masked-cell
    compute) is a possible future micro-optimisation; it is not done
@@ -461,7 +461,9 @@ pull_leaf_with_optional_cast (CArray *leaf, uint16_t innermost_op,
     }
   }
   (void) holder;
-  scratch = ca_lazy_arena_acquire(total_bytes);
+  scratch = ( leaf->data_type == CA_OBJECT )
+              ? ca_lazy_arena_acquire_object(slab_n)
+              : ca_lazy_arena_acquire(total_bytes);
   ca_monop_scratch_acquire_count++;
   ca_xfer_stride(leaf, starts, counts, parent_strides, scratch, CA_XFER_GET);
 
@@ -615,7 +617,9 @@ ca_monop_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
          → data (in target data_type).  Required because in-place cast
          would overlap source/dest reads when target_bytes > src_bytes
          (forward-walk reads cells past their own write boundary). */
-      scratch = ca_lazy_arena_acquire(total_bytes);
+      scratch = ( cur_dt == CA_OBJECT )
+                  ? ca_lazy_arena_acquire_object(slab_n)
+                  : ca_lazy_arena_acquire(total_bytes);
       ca_monop_scratch_acquire_count++;
       memcpy(scratch, data, total_bytes);
       ca_cast_block(slab_n, &src_stub, scratch, &dst_stub, data);
@@ -728,6 +732,14 @@ ca_monop_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_monop_func_xfer_stride(ca, starts, ca->dim, native, ca->ptr, CA_XFER_GET);
 }
 

data/ext/ca_obj_object.c

@@ -352,8 +352,11 @@ ca_objmask_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   if ( n == 0 ) return;
 
   if ( rb_obj_respond_to(ca->array, mid_block, Qtrue) ) {
-    int aligned = 1;
-    for ( k = 0; k < ndim; k++ ) {
+    /* The request is over the view's addresses, so a transposed / flat
+       request is legal; the per-axis copy_block dispatch below would
+       misread it.  See ca_xfer_stride_request_is_axis_box (carray.h). */
+    int aligned = ca_xfer_stride_request_is_axis_box(ca, starts, counts, strides);
+    for ( k = 0; aligned && k < ndim; k++ ) {
       if ( strides[k] <= 0 || strides[k] % native[k] != 0 ) { aligned = 0; break; }
       steps[k] = strides[k] / native[k];
     }
@@ -937,8 +940,11 @@ ca_object_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
        before the % check
      - given %==0 + >0, strides/native >= 1 holds automatically */
   if ( rb_obj_respond_to(ca->self, mid_block, Qtrue) ) {
-    int aligned = 1;
-    for ( k = 0; k < ndim; k++ ) {
+    /* The request is over the view's addresses, so a transposed / flat
+       request is legal; the per-axis copy_block dispatch below would
+       misread it.  See ca_xfer_stride_request_is_axis_box (carray.h). */
+    int aligned = ca_xfer_stride_request_is_axis_box(ca, starts, counts, strides);
+    for ( k = 0; aligned && k < ndim; k++ ) {
       if ( strides[k] <= 0 || strides[k] % native[k] != 0 ) { aligned = 0; break; }
       steps[k] = strides[k] / native[k];   /* >= 1 by construction */
     }
@@ -1001,6 +1007,93 @@ ca_object_func_fill_data (void *ap, void *ptr)
   ca_object_dispatch_fill((CAObject *) ap, ptr);
 }
 
+/* Partial fill.  fill_data carries no region and can only say "fill
+   everything I cover", so before these two slots existed the only way to
+   fill part of a CAObject was the per-cell default -- one store_addr per
+   cell.  The region arrives in the view's own address space.  With
+   `fill_block` defined (and the region an axis-aligned forward sub-box of
+   self) it becomes one call; with `fill_addrs` defined it becomes one call
+   per address window.  With neither defined the behaviour is exactly the
+   old default, so an existing subclass sees no change. */
+static void
+ca_object_func_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *ptr)
+{
+  CAObject *ca = (CAObject *) ap;
+  ID        mid = rb_intern("fill_addrs");
+
+  if ( ca_is_face(ca) ) {
+    ca_face_fill_addrs(ap, n, addrs, ptr);
+    return;
+  }
+
+  if ( n > 0 && rb_obj_respond_to(ca->self, mid, Qtrue) ) {
+    volatile VALUE raddrs, rval;
+    ca_size_t dim1[1] = { n };
+    raddrs = ca_object_wrap_transient(CA_SIZE, sizeof(ca_size_t),
+                                      1, dim1, addrs, CA_XFER_PUT);
+    rval = rb_ca_ptr2obj(ca->self, ptr);
+    rb_funcall(ca->self, mid, 2, raddrs, rval);
+    return;
+  }
+
+  ca_fill_addrs_default(ap, n, addrs, ptr);
+}
+
+/* Gate: one region axis per view axis, forward, and a whole number of
+   elements per step.  native is strictly decreasing, so steps[k] =
+   m_k * native[k] with m_k >= 1 admits only the identity permutation --
+   transpose, negative and zero (broadcast) steps, sub-element steps and
+   dimension-dropping regions all fail it and take the addrs route.  The
+   bound check then confirms the decomposed box lies inside self. */
+static void
+ca_object_func_fill_stride (void *ap, ca_size_t base, int8_t ndim,
+                            ca_size_t *counts, ca_size_t *steps, void *ptr)
+{
+  CAObject  *ca = (CAObject *) ap;
+  ca_size_t  native[CA_RANK_MAX], istep[CA_RANK_MAX], start[CA_RANK_MAX];
+  ca_size_t  s;
+  int8_t     k;
+  ID         mid = rb_intern("fill_block");
+
+  if ( ca_is_face(ca) ) {
+    ca_face_fill_stride(ap, base, ndim, counts, steps, ptr);
+    return;
+  }
+
+  if ( ndim == ca->ndim && rb_obj_respond_to(ca->self, mid, Qtrue) ) {
+    int aligned = 1;
+    s = 1;
+    for ( k = ca->ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
+    for ( k = 0; k < ndim; k++ ) {
+      if ( steps[k] <= 0 || steps[k] % native[k] != 0 ) { aligned = 0; break; }
+      istep[k] = steps[k] / native[k];
+      start[k] = ( base / native[k] ) % ca->dim[k];
+      if ( start[k] + ( counts[k] - 1 ) * istep[k] >= ca->dim[k] ) {
+        aligned = 0;
+        break;
+      }
+    }
+    if ( aligned ) {
+      volatile VALUE rstarts, rcounts, rsteps, rval;
+      rstarts = rb_ary_new_capa(ndim);
+      rcounts = rb_ary_new_capa(ndim);
+      rsteps  = rb_ary_new_capa(ndim);
+      for ( k = 0; k < ndim; k++ ) {
+        rb_ary_push(rstarts, SIZE2NUM(start[k]));
+        rb_ary_push(rcounts, SIZE2NUM(counts[k]));
+        rb_ary_push(rsteps,  SIZE2NUM(istep[k]));
+      }
+      rval = rb_ca_ptr2obj(ca->self, ptr);
+      rb_funcall(ca->self, mid, 4, rstarts, rcounts, rsteps, rval);
+      return;
+    }
+  }
+
+  /* addrs route: address windows -> ca_fill_addrs -> `fill_addrs` when the
+     author defined it, else the per-cell default. */
+  ca_fill_stride_via_addrs(ap, base, ndim, counts, steps, ptr);
+}
+
 static void
 ca_object_func_create_mask (void *ap)
 {
@@ -1050,6 +1143,8 @@ ca_operation_function_t ca_object_func = {
   NULL,                       /* fold_stride: never-fold (callback boundary) */
   ca_object_func_xfer_stride,
   ca_object_func_xfer_all,
+  .fill_addrs  = ca_object_func_fill_addrs,
+  .fill_stride = ca_object_func_fill_stride,
 };
 
 /* ------------------------------------------------------------------- */

data/ext/ca_obj_record.c

@@ -202,7 +202,9 @@ ca_operation_function_t ca_record_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_refer.c

@@ -454,7 +454,7 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
       return obj;
     }
   }
-  CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  CA_WRAPPER_LIFT(obj, self, ca);
   return obj;
 }
 
@@ -482,7 +482,31 @@ rb_ca_refer_new (VALUE self,
   rb_set_options(ropt, "bytes,offset", SIZE2NUM(bytes), SIZE2NUM(offset));
   rb_ary_store(list, 2, ropt);
 
-  return rb_ca_refer(3, (VALUE *) RARRAY_CONST_PTR(list), self);
+  {
+    volatile VALUE obj = rb_ca_refer(3, (VALUE *) RARRAY_CONST_PTR(list), self);
+    CArray *co;
+
+    /* CAREFUL: this is the internal builder -- some fifteen call sites want
+       the refer itself, not a wrapper on top of it.  The public `refer` it
+       delegates to lifts a CALazyMarker, so strip that here.
+
+       Two things go wrong otherwise.  rb_ca_value_array strips the mask off
+       what it gets back and marks the level it is handed; with a marker in
+       the way the refer underneath keeps its mask and never gets
+       CA_FLAG_VALUE_ARRAY, so the values read back as UNDEF.  And builders
+       that stack further views on the result -- fancy indexing goes refer,
+       grid, refer -- end up with a marker buried in the middle of the
+       chain, which is the redundant-middle-wrapper that CAFace.md section
+       8.3 exists to prevent.
+
+       Faces stay lifted: rb_ca_value_array depends on that and says so
+       where it marks the storage level. */
+    TypedData_Get_Struct(obj, CArray, &carray_data_type, co);
+    if ( ca_is_lazy_marker(co) ) {
+      obj = rb_ca_parent(obj);
+    }
+    return obj;
+  }
 }
 
 /* CArray#reshape(*newdim) — returns a view of self with the new
@@ -605,7 +629,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
                                    out_strides, out_base);
       obj = ca_wrap_struct(cs);
       rb_ca_set_parent(obj, self);
-      CA_FACE_LIFT_IF_FACE(obj, self, ca);
+      CA_WRAPPER_LIFT(obj, self, ca);
       return obj;
     }
   }
@@ -614,7 +638,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
                     new_dim, ca->bytes, 0);
   obj = ca_wrap_struct(cr);
   rb_ca_set_parent(obj, self);
-  CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  CA_WRAPPER_LIFT(obj, self, ca);
   return obj;
 }
 
@@ -642,7 +666,7 @@ rb_ca_flatten (VALUE self)
                                    1, dim, out_strides, out_base);
       obj = ca_wrap_struct(cs);
       rb_ca_set_parent(obj, self);
-      CA_FACE_LIFT_IF_FACE(obj, self, ca);
+      CA_WRAPPER_LIFT(obj, self, ca);
       return obj;
     }
   }
@@ -650,7 +674,7 @@ rb_ca_flatten (VALUE self)
   cr = ca_refer_new(ca, ca->data_type, 1, dim, ca->bytes, 0);
   obj = ca_wrap_struct(cr);
   rb_ca_set_parent(obj, self);
-  CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  CA_WRAPPER_LIFT(obj, self, ca);
   return obj;
 }
 

data/ext/ca_obj_roll.c

@@ -232,10 +232,18 @@ ca_roll_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   s = ca->bytes;
   for (k = ndim - 1; k >= 0; k--) { dstride[k] = s; s *= counts[k]; }
 
-  for (k = 0; k < ndim; k++) {
-    if (strides[k] % rnative[k] != 0 || strides[k] / rnative[k] != 1) {
-      structural = 0;
-      break;
+  /* 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(ca, starts, counts, strides) ) {
+    structural = 0;
+  }
+  else {
+    for (k = 0; k < ndim; k++) {
+      if (strides[k] % rnative[k] != 0 || strides[k] / rnative[k] != 1) {
+        structural = 0;
+        break;
+      }
     }
   }
 
@@ -529,7 +537,7 @@ rb_ca_roll (int argc, VALUE *argv, VALUE self)
   }
   {
     VALUE obj = rb_ca_roll_new(self, shift);
-    CA_FACE_LIFT_IF_FACE(obj, self, ca);
+    CA_WRAPPER_LIFT(obj, self, ca);
     return obj;
   }
 }

data/ext/ca_obj_select_axis.c

@@ -571,9 +571,17 @@ ca_select_axis_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   s = ca->bytes;
   for (k = ndim - 1; k >= 0; k--) { dstride[k] = s; s *= counts[k]; }
 
-  for (k = 0; k < ndim; k++) {
-    if (strides[k] % cnative[k] != 0) { aligned = 0; break; }
-    src_step[k] = strides[k] / cnative[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(ca, starts, counts, strides) ) {
+    aligned = 0;
+  }
+  else {
+    for (k = 0; k < ndim; k++) {
+      if (strides[k] % cnative[k] != 0) { aligned = 0; break; }
+      src_step[k] = strides[k] / cnative[k];
+    }
   }
 
   if (!aligned) {
@@ -925,7 +933,7 @@ rb_ca_select_axis_s_new_debug (VALUE klass, VALUE rparent, VALUE rindirect,
   obj = TypedData_Make_Struct(klass, CASelectAxis, &caselectaxis_data_type, ca);
   ca_select_axis_setup(ca, parent, indirect_axis, selector,
                        ap_start_buf, ap_count_buf, ap_step_buf);
-  rb_ivar_set(obj, rb_intern("_parent"),   rparent);
+  rb_ca_set_parent(obj, rparent);
   rb_ivar_set(obj, rb_intern("_selector"), rselector);
   return obj;
 }
@@ -1066,8 +1074,10 @@ rb_ca_select_axis (int argc, VALUE *argv, VALUE self)
   ca_select_axis_setup(ca, parent, indirect_axis, selector,
                        ap_start, ap_count, ap_step);
 
-  /* Keep Ruby objects alive (parent and selector references). */
-  rb_ivar_set(obj, rb_intern("_parent"),   self);
+  /* Keep Ruby objects alive (parent and selector references).  The parent
+     goes through rb_ca_set_parent so #parent, #root_array and #ancestors
+     read the same link here as they do through every other view. */
+  rb_ca_set_parent(obj, self);
   rb_ivar_set(obj, rb_intern("_selector"), rselector_keep);
   return obj;
 }

data/ext/ca_obj_shift.c

@@ -264,7 +264,7 @@ rb_ca_shift_new (VALUE cary, ca_size_t *shift, char *fill, int8_t *roll,
 VALUE
 rb_ca_shift (int argc, VALUE *argv, VALUE self)
 {
-  volatile VALUE obj, ropt, rfval = CA_NIL, rroll = Qnil, rcs;
+  volatile VALUE obj, ropt, rfval = CA_UNSPECIFIED, rroll = Qnil, rcs;
   CArray *ca;
   CScalar *cs;
   ca_size_t shift[CA_RANK_MAX];
@@ -301,7 +301,7 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
              "use fill_value: kwarg (e.g. shift(1, fill_value: -2))");
   }
 
-  if ( rfval == CA_NIL ) {
+  if ( rfval == CA_UNSPECIFIED ) {
     /* Default fill value = 0 (or INT2NUM(0) for OBJECT type) */
     rcs = rb_cscalar_new(ca->data_type, ca->bytes, NULL);
     TypedData_Get_Struct(rcs, CScalar, &cscalar_data_type, cs);
@@ -343,7 +343,7 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
 
   obj = rb_ca_shift_new(self, shift, fill, roll, fill_mask);
 
-  CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  CA_WRAPPER_LIFT(obj, self, ca);
   return obj;
 }
 

data/ext/ca_obj_stride.c

@@ -192,6 +192,19 @@ void ca_xfer_stride_tiled_transpose_2d (char *src_base, ca_size_t bytes,
                                          ca_size_t *counts, ca_size_t *strides,
                                          char *data, int dir);
 
+/* Public form of the family test the fold walk below uses inline.  The
+   family is defined by the operation table, not by a class or an
+   obj_type list: every member was installed with a copy of
+   ca_stride_func, so an externally installed view that shares the
+   table answers true as well.  See carray.h for what membership does
+   and does not promise. */
+int
+ca_is_stride_family (const void *ap)
+{
+  const CArray *ca = (const CArray *) ap;
+  return ( ca_func[ca->obj_type].attach == ca_stride_func.attach );
+}
+
 /* Compose `leaf->strides` and `leaf->base_offset` (which live in `parent`'s
    own logical row-major contig byte space) into `out_strides` and
    `out_base` expressed in `parent->parent`'s byte space.
@@ -616,9 +629,29 @@ ca_stride_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
    hand the whole region to the root in a SINGLE ca_xfer_stride (entity -> ptr
    memcpy; boundary view -> one recursion).
 
-   Axis-aligned, byte-matching requests only; the byte-mismatch reinterpret
-   (CAField .real/.imag) and non-aligned access fall back to per-cell
-   xfer_index (which handles the sub-byte case). */
+   CAREFUL: the request is given over this view's linear ADDRESSES (carray.h
+   xfer_stride contract), so request axis k does NOT have to be view axis k.
+   A caller is free to hand over a transposed region -- counts/strides in one
+   order, the packed destination in another -- which is exactly what a
+   column-major backend (carray-linalg's Fortran-LAPACK gather) does.  Matching
+   request axis k to view axis k by dividing strides[k] by the axis-k native
+   step looks right and is wrong: an (n, 1) view has the same native step on
+   both axes, so a transposed request divides cleanly and then composes the
+   n-cell walk onto the length-1 axis, whose parent stride is 0 -- delivering
+   the first cell n times, with no error anywhere.  Ask ca_stride_region_axes
+   which view axis each request axis really moves (the same question
+   fill_stride asks), and fall back to the per-cell walk when the region is
+   not a box over our axes.
+
+   Byte-matching requests only; the byte-mismatch reinterpret (CAField
+   .real/.imag) and non-box access fall back to per-cell xfer_index (which
+   handles the sub-byte case). */
+
+static int ca_stride_region_axes (CAStride *ca, ca_size_t base, int8_t ndim,
+                                  ca_size_t *counts, ca_size_t *steps,
+                                  ca_size_t *base_idx, int8_t *axis_of,
+                                  ca_size_t *mult);
+
 static void
 ca_stride_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                             ca_size_t *strides, void *data, int dir)
@@ -629,7 +662,12 @@ ca_stride_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   ca_size_t composed_base;
   ca_size_t view_native[CA_RANK_MAX];
   ca_size_t root_stride[CA_RANK_MAX];
+  ca_size_t steps[CA_RANK_MAX];
+  ca_size_t base_idx[CA_RANK_MAX];
+  ca_size_t mult[CA_RANK_MAX];
+  int8_t    axis_of[CA_RANK_MAX];
   ca_size_t root_base;
+  ca_size_t base_addr = 0;
   ca_size_t s;
   int8_t    ndim = ca->ndim, k;
   int       aligned = 1;
@@ -639,26 +677,77 @@ ca_stride_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
 
   s = ca->bytes;
   for (k = ndim - 1; k >= 0; k--) { view_native[k] = s; s *= ca->dim[k]; }
+  for (k = 0; k < ndim; k++) base_addr += starts[k] * view_native[k];
 
   if (ca->bytes != root->bytes) {
     aligned = 0;
   }
   else {
     for (k = 0; k < ndim; k++) {
-      if (strides[k] % view_native[k] != 0) { aligned = 0; break; }
+      if ( strides[k] % ca->bytes != 0 ) { aligned = 0; break; }
+      steps[k] = strides[k] / ca->bytes;
+    }
+    if ( aligned ) {
+      aligned = ca_stride_region_axes(ca, base_addr / ca->bytes, ndim,
+                                      counts, steps, base_idx, axis_of, mult);
+    }
+  }
+
+  if ( aligned ) {
+    /* Each request axis now names the view axis it moves (axis_of) and by how
+       many of that axis' cells (mult); a count-1 axis moves nothing and gets
+       stride 0, which the walk never follows. */
+    root_base = composed_base;
+    for (k = 0; k < ca->ndim; k++) {
+      root_base += base_idx[k] * composed_strides[k];
+    }
+    for (k = 0; k < ndim; k++) {
+      root_stride[k] = ( axis_of[k] >= 0 )
+                     ? mult[k] * composed_strides[axis_of[k]]
+                     : 0;
+    }
+  }
+
+  /* Cold root that answers regions: compose the request into its addresses
+     and hand it over whole, exactly as xfer_all does for the whole view.  A
+     root with no memory to lend (a lazy transform, a CAObject over a file)
+     has no ptr to walk, but it can still produce a region on request -- and
+     asking it once beats asking it once per cell, which is what the per-cell
+     descent below would do.  Chunked consumers (the binop / sweep drivers'
+     per-chunk gather) arrive here, so the difference is the whole cost of
+     the transfer, not a constant factor.
+
+     The gate is xfer_all's: the root must have the slot, share this view's
+     cell width (else the composed offsets are not whole root elements), and
+     carry the same ndim (else its index space cannot hold this request's
+     axes).  Anything narrower keeps the per-cell descent, which is correct
+     for all of them.  Direction is not part of the gate: a root that refuses
+     writes refuses them per cell as well. */
+  if (aligned && !root->ptr && ca_func[root->obj_type].xfer_stride
+       && ca->bytes == root->bytes && ndim == root->ndim) {
+    ca_size_t rstarts[CA_RANK_MAX];
+    if ( root_base % root->bytes == 0 ) {
+      ca_size_t raddr = root_base / root->bytes;
+      if ( raddr >= 0 && raddr < root->elements ) {
+        ca_addr2index(root, raddr, rstarts);
+        ca_xfer_stride(root, rstarts, counts, root_stride, d, dir);
+        return;
+      }
     }
   }
 
   /* Per-cell fallback (correct, no whole-view attach): byte-mismatch
-     reinterpret (CAField), non-aligned access, or a cold non-entity root
-     (whose ndim may differ from the view's -- e.g. a reshape over a boundary).
-     ca_stride_func_xfer_index composes one hop and delegates to the parent. */
+     reinterpret (CAField), a region that is not a box over our axes (a
+     transposed request onto a degenerate axis, a flat index over several
+     axes), or a cold non-entity root the branch above could not hand a
+     region to (its ndim differs from the view's -- e.g. a reshape over a
+     boundary -- or it has no region slot).  ca_stride_func_xfer_index
+     composes one hop and delegates to the parent. */
   if (!aligned || !root->ptr) {
-    ca_size_t idx[CA_RANK_MAX], doff = 0, base = 0;
-    for (k = 0; k < ndim; k++) base += starts[k] * view_native[k];
+    ca_size_t idx[CA_RANK_MAX], doff = 0;
     for (k = 0; k < ndim; k++) idx[k] = 0;
     while (1) {
-      ca_size_t off = base, vmidx[CA_RANK_MAX];
+      ca_size_t off = base_addr, vmidx[CA_RANK_MAX];
       for (k = 0; k < ndim; k++) off += idx[k] * strides[k];
       ca_addr2index((CArray *) ca, off / ca->bytes, vmidx);
       ca_stride_func_xfer_index(ca, vmidx, d + doff, dir);
@@ -670,17 +759,11 @@ ca_stride_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     return;
   }
 
-  /* Structural: root has a live ptr (entity / attached).  Translate the
-     request into root's BYTE space and do a strided memcpy in the VIEW's ndim
-     (byte offsets into root->ptr -- independent of root's own ndim, so a
-     reshape view over a 1-D entity works).  compose happened once. */
-  root_base = composed_base;
-  for (k = 0; k < ndim; k++) {
-    ca_size_t req_step = strides[k] / view_native[k];
-    root_base       += starts[k] * composed_strides[k];
-    root_stride[k]   = req_step * composed_strides[k];
-  }
-  /* Slab-merge, tile-block and the general driver all live in the shared
+  /* Structural: root has a live ptr (entity / attached).  The request is
+     already in root's BYTE space (root_base / root_stride above), so the walk
+     runs in the VIEW's ndim -- independent of root's own ndim, which is what
+     lets a reshape view over a 1-D entity through.  compose happened once.
+     Slab-merge, tile-block and the general driver all live in the shared
      walker, which the central dispatcher's structural path also uses. */
   ca_xfer_strided_walk(root->ptr + root_base, ca->bytes, ndim,
                        counts, root_stride, d, dir);
@@ -2239,7 +2322,7 @@ rb_ca_flip_build_view (VALUE self, CArray *parent, const int8_t *flip)
 
   VALUE obj = rb_ca_stride_new(self, parent->data_type, parent->bytes,
                                ndim, outdim, outstrides, base_offset);
-  CA_FACE_LIFT_IF_FACE(obj, self, parent);
+  CA_WRAPPER_LIFT(obj, self, parent);
   return obj;
 }
 
@@ -2462,7 +2545,7 @@ rb_ca_diagonal (int argc, VALUE *argv, VALUE self)
   {
     VALUE obj = rb_ca_stride_new(self, parent->data_type, parent->bytes,
                                  out_k, outdim, outstrides, base_offset);
-    CA_FACE_LIFT_IF_FACE(obj, self, parent);
+    CA_WRAPPER_LIFT(obj, self, parent);
     return obj;
   }
 }