carray 3.0.0 → 3.0.2

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.c

@@ -83,22 +83,57 @@ VALUE rb_cCASelectMask;
 
 /* ------------------------------------------------------------------- */
 
-/* Snapshot the selector into ca->select (always a copy) and pre-compute
-   ca->indices (TRUE positions in flat parent order).  Masked selector
-   cells become false in the snapshot.  After construction, mutating
-   the caller's live selector does not affect the view. */
-static int
-ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
+/* Owned snapshot of the selector: masked selector cells become false.
+   After construction, mutating the caller's live selector does not affect
+   the view.  Reading the selector can raise (a lazy boolean view), so the
+   snapshot is taken before the view struct is allocated, and a snapshot
+   whose fill raises is freed on the way out. */
+static VALUE
+ca_select_snapshot_masked (VALUE arg)
 {
-  int8_t data_type;
-  ca_size_t bytes;
+  CArray **pair = (CArray **) arg;
+  CArray *select = pair[0], *snap = pair[1];
+  boolean8_t *p, *q, *m;
   ca_size_t i;
+  ca_attach(select);
+  q = (boolean8_t *) snap->ptr;
+  p = (boolean8_t *) select->ptr;
+  m = (boolean8_t *) select->mask->ptr;
+  for (i = 0; i < select->elements; i++) {
+    *q = ( *m ) ? 0 : *p;
+    q++; p++; m++;
+  }
+  ca_detach(select);
+  return Qnil;
+}
 
+static CArray *
+ca_select_snapshot (CArray *select)
+{
   if ( ! ca_is_boolean_type(select) ) {
     rb_raise(rb_eRuntimeError,
              "selection array for CASelect should be have "
              "the data_type of CA_BOOLEAN");
   }
+  if ( ca_has_mask(select) ) {
+    CArray *pair[2];
+    pair[0] = select;
+    pair[1] = ca_template(select);
+    ca_fill_or_free(pair[1], ca_select_snapshot_masked, (VALUE) pair);
+    return pair[1];
+  }
+  return ca_copy(select);
+}
+
+/* Set up the view over `parent` from an owned selector snapshot (see
+   ca_select_snapshot) and pre-compute ca->indices (TRUE positions in flat
+   parent order).  Does not raise. */
+static int
+ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
+{
+  int8_t data_type;
+  ca_size_t bytes;
+  ca_size_t i;
 
   data_type = parent->data_type;
   bytes     = parent->bytes;
@@ -114,26 +149,7 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
   ca->attach    = 0;
   ca->nosync    = 0;
   ca->indices   = NULL;
-
-  /* The `share` argument is preserved for source compatibility but
-     no longer toggles a live-reference path; both paths copy.
-     Masked selector cells become false in the snapshot. */
-  (void) share;
-  if ( ca_has_mask(select) ) {
-    boolean8_t *p, *q, *m;
-    ca->select = ca_template(select);
-    ca_attach(select);
-    q = (boolean8_t *) ca->select->ptr;
-    p = (boolean8_t *) select->ptr;
-    m = (boolean8_t *) select->mask->ptr;
-    for (i = 0; i < select->elements; i++) {
-      *q = ( *m ) ? 0 : *p;
-      q++; p++; m++;
-    }
-    ca_detach(select);
-  } else {
-    ca->select = ca_copy(select);
-  }
+  ca->select    = snapshot;
 
   /* Count TRUE positions and snapshot them into ca->indices. */
   {
@@ -181,7 +197,7 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
   ca->dim       = &(ca->_dim);
   ca->dim[0]    = ca->elements;
 
-  if ( ca_is_scalar(select) ) {
+  if ( ca_is_scalar(snapshot) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
 
@@ -191,8 +207,9 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
 CArray *
 ca_select_new (CArray *parent, CArray *select)
 {
+  CArray *snapshot = ca_select_snapshot(select);
   CASelect *ca = ALLOC(CASelect);
-  ca_select_setup(ca, parent, select, 0);
+  ca_select_setup(ca, parent, snapshot);
   return (CArray*) ca;
 }
 
@@ -202,9 +219,7 @@ ca_select_new (CArray *parent, CArray *select)
 CArray *
 ca_select_new_share (CArray *parent, CArray *select)
 {
-  CASelect *ca = ALLOC(CASelect);
-  ca_select_setup(ca, parent, select, 1);
-  return (CArray*) ca;
+  return ca_select_new(parent, select);
 }
 
 static void
@@ -613,7 +628,7 @@ rb_cm_initialize_copy (VALUE self, VALUE other)
 
   /* Re-snapshot from the source's selector copy so the two views
      end up with independent indices buffers. */
-  ca_select_setup(ca, cs->parent, cs->select, 1);
+  ca_select_setup(ca, cs->parent, ca_select_snapshot(cs->select));
 
   return self;
 }

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_stack.c

@@ -18,6 +18,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_attach_all */
 #include "ca_composite_dispatch.h"
 #include "ca_obj_face.h"
 
@@ -740,10 +741,7 @@ static void
 ca_stack_func_allocate (void *ap)
 {
   CAStack *ca = (CAStack *) ap;
-  int32_t k;
-  for ( k = 0; k < ca->n_parents; k++ ) {
-    ca_attach(ca->parents[k]);
-  }
+  ca_attach_all(ca->parents, ca->n_parents);
   ca->ptr = xmalloc(ca_length(ca));
 }
 
@@ -751,10 +749,7 @@ static void
 ca_stack_func_attach (void *ap)
 {
   CAStack *ca = (CAStack *) ap;
-  int32_t k;
-  for ( k = 0; k < ca->n_parents; k++ ) {
-    ca_attach(ca->parents[k]);
-  }
+  ca_attach_all(ca->parents, ca->n_parents);
   ca->ptr = xmalloc(ca_length(ca));
   ca_stack_func_xfer_all(ca, ca->ptr, CA_XFER_GET);
 }

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);
@@ -753,6 +836,59 @@ ca_stride_region_axes (CAStride *ca, ca_size_t base, int8_t ndim,
    root in units root does not share, so there is no address to hand over
    and the per-cell descent stands in. */
 
+static void
+ca_stride_func_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *ptr)
+{
+  CAStride *ca = (CAStride *) ap;
+  CArray   *root;
+  ca_size_t composed_strides[CA_RANK_MAX];
+  ca_size_t composed_base;
+  ca_size_t rbytes;
+  ca_size_t *paddrs;
+  ca_size_t  i;
+  int8_t     k;
+  int        all_aligned = 1;
+  volatile VALUE holder;
+
+  /* Addresses name cells one by one, so unlike fill_stride there is nothing
+     here that only the whole extent can express: translate each view address
+     into the root's and hand the list down in one call.  Without this the
+     region is still the only thing touched -- ca_fill_addrs_default sees to
+     that -- but it costs the parent one call per cell, which is the whole
+     difference on a backing where a call is a request. */
+  if ( n == 0 ) {
+    return;
+  }
+
+  ca_stride_compose_to_root(ca, &root, composed_strides, &composed_base);
+  rbytes = root->bytes;
+
+  if ( ca->bytes != rbytes ) {
+    ca_fill_addrs_default(ca, n, addrs, ptr);
+    return;
+  }
+
+  paddrs = ALLOCV_N(ca_size_t, holder, n);
+  for ( i = 0; i < n; i++ ) {
+    ca_size_t idx[CA_RANK_MAX];
+    ca_size_t off = composed_base;
+    ca_addr2index((CArray *) ca, addrs[i], idx);
+    for ( k = 0; k < ca->ndim; k++ ) {
+      off += idx[k] * composed_strides[k];
+    }
+    if ( off % rbytes != 0 ) { all_aligned = 0; break; }
+    paddrs[i] = off / rbytes;
+  }
+
+  if ( all_aligned ) {
+    ca_fill_addrs(root, n, paddrs, ptr);
+  }
+  else {
+    ca_fill_addrs_default(ca, n, addrs, ptr);
+  }
+  ALLOCV_END(holder);
+}
+
 static void
 ca_stride_func_fill_stride (void *ap, ca_size_t base, int8_t ndim,
                             ca_size_t *counts, ca_size_t *steps, void *ptr)
@@ -920,6 +1056,15 @@ ca_stride_func_allocate (void *ap)
   }
 }
 
+/* Region request into the cold-root attach buffer; a lazy root can raise. */
+static VALUE
+ca_stride_cold_fill (VALUE arg)
+{
+  void **args = (void **) arg;
+  ca_copy_data((CArray *) args[0], (char *) args[1]);
+  return Qnil;
+}
+
 static void
 ca_stride_func_attach (void *ap)
 {
@@ -935,7 +1080,15 @@ ca_stride_func_attach (void *ap)
        view with a live ptr is what makes the per-cell dispatchers bypass the
        transfer slots. */
     char *buf = xmalloc(ca_length(ca));
-    ca_copy_data(ca, buf);       /* region request, root stays cold */
+    void *args[2];
+    int tag = 0;
+    args[0] = ca;
+    args[1] = buf;
+    rb_protect(ca_stride_cold_fill, (VALUE) args, &tag);   /* root stays cold */
+    if (tag) {
+      xfree(buf);
+      rb_jump_tag(tag);
+    }
     ca->ptr = buf;
     return;
   }
@@ -1400,6 +1553,7 @@ ca_operation_function_t ca_stride_func = {
   sizeof(CAStride),           /* struct_size: pool framework */
   ca_stride_pool_bytes,       /* pool_bytes  */
   ca_stride_pool_init,        /* pool_init   */
+  .fill_addrs   = ca_stride_func_fill_addrs,
   .fill_stride  = ca_stride_func_fill_stride,
 };
 
@@ -2239,7 +2393,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 +2616,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;
   }
 }

data/ext/ca_obj_string.c

@@ -90,10 +90,14 @@ ca_string_setup (CAString *ca, CArray *parent)
 
   ca->obj_type  = CA_OBJ_STRING;
   ca->data_type = CA_OBJECT;
-  /* ORDERABLE: object storage sorts by <=> (= String order on the surface),
-     so the sort family may descend to storage.  COMPARABLE is left off for
-     now; ordered search (bsearch) is a later phase. */
-  ca->flags     = CA_FLAG_IS_FACE | CA_FLAG_FACE_ORDERABLE_STORAGE;
+  /* ORDERABLE + COMPARABLE, and both hold by construction: a storage cell
+     IS the Ruby String the surface shows, so storage order is surface
+     order and an external String compares against storage directly, with
+     nothing to reconcile.  (A unit-bearing Face like CATime is the case
+     that has to stop at ORDERABLE; this one carries no unit.) */
+  ca->flags     = CA_FLAG_IS_FACE
+                | CA_FLAG_FACE_ORDERABLE_STORAGE
+                | CA_FLAG_FACE_COMPARABLE_STORAGE;
   ca->ndim      = parent->ndim;
   ca->bytes     = sizeof(VALUE);
   ca->elements  = parent->elements;
@@ -192,7 +196,9 @@ ca_operation_function_t ca_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,
 };
 
 /* ------------------------------------------------------------------- */