carray 3.0.2 → 3.0.4

data/ext/ca_obj_stride.c

@@ -20,6 +20,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_normalize_axis_arg */
 #include "ca_iter_substrate.h"
 #include "ca_obj_face.h"  /* ca_is_face, used by the compose-fold walk */
 
@@ -93,24 +94,27 @@ int8_t CA_OBJ_STRIDE;       /* assigned at Init time via ca_install_obj_type */
    override pattern and makes the C-level dispatch wire up correctly
    on the first try. */
 int
-ca_stride_setup (CAStride *ca, int8_t obj_type, CArray *parent,
-                 int8_t data_type, ca_size_t bytes,
-                 int8_t ndim, ca_size_t *dim,
-                 ca_size_t *strides, ca_size_t base_offset)
+ca_stride_setup_view (CAStride *ca, int8_t obj_type, CArray *parent,
+                      int8_t data_type, ca_size_t bytes,
+                      int8_t ndim, ca_size_t *dim,
+                      ca_size_t *strides, ca_size_t base_offset)
 {
   ca_size_t elements;
   int  i;
 
-  if (ndim < 0 || ndim > CA_RANK_MAX) {
-    rb_raise(rb_eArgError, "invalid ndim %d", (int) ndim);
-  }
-  elements = 1;
+  ca_check_rank_fits(ndim, NULL);
   for (i = 0; i < ndim; i++) {
     if (dim[i] < 0) {
       rb_raise(rb_eIndexError,
                "invalid size for %i-th dimension (negative)", i);
     }
-    elements *= dim[i];
+  }
+  elements = ca_shape_elements(ndim, dim, bytes);
+
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
   }
 
   ca->obj_type     = obj_type;
@@ -138,10 +142,23 @@ ca_stride_setup (CAStride *ca, int8_t obj_type, CArray *parent,
     ca->strides[i] = strides[i];
   }
 
-  if (parent && ca_has_mask(parent)) {
-    ca_create_mask(ca);
-  }
+  return 0;
+}
 
+/* The public form also takes the parent's mask.  A struct that no Ruby
+   object owns yet is lost if the parent's answer raises; the in-tree
+   constructors use ca_stride_setup_view and ca_view_inherit_mask. */
+int
+ca_stride_setup (CAStride *ca, int8_t obj_type, CArray *parent,
+                 int8_t data_type, ca_size_t bytes,
+                 int8_t ndim, ca_size_t *dim,
+                 ca_size_t *strides, ca_size_t base_offset)
+{
+  ca_stride_setup_view(ca, obj_type, parent, data_type, bytes,
+                       ndim, dim, strides, base_offset);
+  if ( ca != NULL ) {
+    ca_view_inherit_mask((VALUE) ca);
+  }
   return 0;
 }
 
@@ -151,9 +168,13 @@ ca_stride_new (int8_t obj_type, CArray *parent,
                int8_t ndim, ca_size_t *dim,
                ca_size_t *strides, ca_size_t base_offset)
 {
-  CAStride *ca = (CAStride *) ca_array_alloc(obj_type, ndim);
-  ca_stride_setup(ca, obj_type, parent,
-                  data_type, bytes, ndim, dim, strides, base_offset);
+  CAStride *ca;
+  ca_stride_setup_view(NULL, obj_type, parent,
+                       data_type, bytes, ndim, dim, strides, base_offset);
+  ca = (CAStride *) ca_array_alloc(obj_type, ndim);
+  ca_stride_setup_view(ca, obj_type, parent,
+                       data_type, bytes, ndim, dim, strides, base_offset);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -292,6 +313,38 @@ ca_stride_compose_through (CAStride *leaf, CAStride *parent,
     out_strides[k] = composed;
   }
 
+  /* A leaf cell wider than the remainder of its first parent element
+     (CARefer reinterpreting two float64 as one complex128) covers several
+     consecutive parent elements, and the folded access reads the cell as
+     one run of bytes from out_base.  That is only true when those parent
+     elements are adjacent in parent->parent's memory as well: every cell
+     must fit inside the parent's trailing row-major contiguous block.
+     Cell starts are flat0 + sum idx[k]*advance[k], so their residues
+     modulo the block size C step by g = gcd(C, advance...); every cell
+     fits when (flat0 mod g) + span <= g. */
+  if ( sub_byte + leaf->bytes > parent->bytes ) {
+    ca_size_t span = (sub_byte + leaf->bytes + parent->bytes - 1)
+                     / parent->bytes;
+    ca_size_t block = 1;
+    ca_size_t g, flat0 = leaf->base_offset / parent->bytes;
+    if ( parent->ndim > 0
+         && parent->strides[parent->ndim - 1] == parent->bytes ) {
+      block = parent->dim[parent->ndim - 1];
+      for (m = parent->ndim - 2; m >= 0; m--) {
+        if ( parent->strides[m] != parent->strides[m + 1] * parent->dim[m + 1] )
+          break;
+        block *= parent->dim[m];
+      }
+    }
+    g = block;
+    for (k = 0; k < leaf->ndim; k++) {
+      ca_size_t a = leaf->strides[k] / parent->bytes;
+      if ( a < 0 ) a = -a;
+      while ( a != 0 ) { ca_size_t r = g % a; g = a; a = r; }
+    }
+    if ( g == 0 || (flat0 % g) + span > g ) return 0;
+  }
+
   return 1;
 }
 
@@ -402,6 +455,8 @@ ca_stride_compose_to_root (CAStride *leaf,
 
    "Identity compose-fold" semantics:
      - cand->bytes == root->bytes      (no byte reinterpret)
+     - cand->data_type == root->data_type (no type reinterpret: a caller
+       may read the root's cells as typed values)
      - composed_base == 0
      - composed_strides[k] match row-major over cand->dim with cand->bytes
 
@@ -430,6 +485,7 @@ ca_resolve_attached_root_via_identity (CArray *cand)
   ca_stride_compose_to_root(cs, &root, composed_strides, &composed_base);
   if ( !root->ptr ) return cand;
   if ( cs->bytes != root->bytes ) return cand;
+  if ( cs->data_type != root->data_type ) return cand;
   if ( composed_base != 0 ) return cand;
 
   s = root->bytes;
@@ -512,19 +568,32 @@ ca_stride_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
       ca_xfer_index(ca->parent, pidx, data, dir);
     }
     else {
-      char buf[64];  /* parent cell width <= 16 in practice */
-      char *scratch = (pbytes <= (ca_size_t) sizeof(buf)) ? buf : xmalloc(pbytes);
+      /* Byte-mismatched reinterpret.  The cell covers the parent elements
+         from off / pbytes through the one holding its last byte: one for a
+         narrower cell (CAField .real / .imag), several for a wider one
+         (CARefer reading two float64 as one complex128).  Read all of
+         them; a store writes back all of them.
+         ALLOCV: the parent's fetch/store can raise (a CAObject parent runs
+         Ruby), and a raise must not leak the scratch. */
+      volatile VALUE holder;
+      ca_size_t addr = off / pbytes;
+      ca_size_t sub  = off % pbytes;
+      ca_size_t span = (sub + ca->bytes + pbytes - 1) / pbytes;
+      ca_size_t i;
+      char *scratch = ALLOCV_N(char, holder, span * pbytes);
+      for (i = 0; i < span; i++) {
+        ca_fetch_addr(ca->parent, addr + i, scratch + i * pbytes);
+      }
       if (dir == CA_XFER_GET) {
-        ca_fetch_addr(ca->parent, off / pbytes, scratch);
-        memcpy(data, scratch + (off % pbytes), ca->bytes);
+        memcpy(data, scratch + sub, ca->bytes);
       }
       else {
-        /* read-modify-write the parent cell for sub-byte reinterpret */
-        ca_fetch_addr(ca->parent, off / pbytes, scratch);
-        memcpy(scratch + (off % pbytes), data, ca->bytes);
-        ca_store_addr(ca->parent, off / pbytes, scratch);
+        memcpy(scratch + sub, data, ca->bytes);
+        for (i = 0; i < span; i++) {
+          ca_store_addr(ca->parent, addr + i, scratch + i * pbytes);
+        }
       }
-      if (scratch != buf) xfree(scratch);
+      ALLOCV_END(holder);
     }
   }
 }
@@ -556,7 +625,7 @@ ca_stride_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
   ca_size_t composed_base;
   ca_size_t rbytes;
   ca_size_t *paddrs;
-  ca_size_t  i, base;
+  ca_size_t  i;
   int8_t     k;
   int        all_aligned = 1;
   volatile VALUE holder;
@@ -565,18 +634,12 @@ ca_stride_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
   ca_stride_compose_to_root(ca, &root, composed_strides, &composed_base);
   rbytes = root->bytes;
 
-  /* Fast path: identity transform detection -- when the addr remap composed_base +
-     Σ idx[k]*composed_strides[k] reduces to an identity mapping over the
-     root's flat byte space (= simple reshape, same bytes, row-major
-     composed_strides), forward addrs as-is to root without the ALLOCV +
-     per-cell remap loop.  Cascades through chain a[idx_2d] (= outer
-     reshape -> CAGrid -> inner reshape -> entity): outer CARefer is a
-     simple reshape so addrs pass through, then CAGrid Y.1.b fast path
-     triggers on the recursive call, then inner CARefer simple reshape
-     pass-through to entity.  Detection is O(ndim) + O(n).  */
-  if ( n == ca->elements
-       && ca->bytes == rbytes && composed_base == 0
-       && ca_xfer_addrs_is_sequential_run(n, addrs, &base) && base == 0 ) {
+  /* Identity: same cell size, no offset, row-major composed strides (a
+     simple reshape / flatten of the root).  A view address is then the
+     root address, whatever the addresses are, so the list goes through
+     as-is.  Cascades through chains such as a[idx_2d] (outer reshape ->
+     CAGrid -> inner reshape -> entity). */
+  if ( ca->bytes == rbytes && composed_base == 0 ) {
     ca_size_t s = rbytes;
     int is_identity = 1;
     for ( k = ca->ndim - 1; k >= 0; k-- ) {
@@ -589,36 +652,51 @@ ca_stride_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
     }
   }
 
-  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);
+  /* Whole-cell strides: translate in cell units, with no per-cell division. */
+  if ( ca->bytes == rbytes && composed_base % rbytes == 0 ) {
     for ( k = 0; k < ca->ndim; k++ ) {
-      off += idx[k] * composed_strides[k];
-    }
-    if ( ca->bytes == rbytes && off % rbytes == 0 ) {
-      paddrs[i] = off / rbytes;
-    }
-    else {
-      all_aligned = 0;
-      break;
+      if ( composed_strides[k] % rbytes != 0 ) { all_aligned = 0; break; }
     }
   }
+  else {
+    all_aligned = 0;
+  }
 
   if ( all_aligned ) {
+    ca_size_t esteps[CA_RANK_MAX];
+    ca_size_t ebase = composed_base / rbytes;
+    for ( k = 0; k < ca->ndim; k++ ) {
+      esteps[k] = composed_strides[k] / rbytes;
+    }
+    paddrs = ALLOCV_N(ca_size_t, holder, n);
+    if ( ca->ndim == 1 ) {
+      for ( i = 0; i < n; i++ ) {
+        paddrs[i] = ebase + addrs[i] * esteps[0];
+      }
+    }
+    else {
+      for ( i = 0; i < n; i++ ) {
+        ca_size_t idx[CA_RANK_MAX];
+        ca_size_t off = ebase;
+        ca_addr2index((CArray *) ca, addrs[i], idx);
+        for ( k = 0; k < ca->ndim; k++ ) {
+          off += idx[k] * esteps[k];
+        }
+        paddrs[i] = off;
+      }
+    }
     ca_xfer_addrs(root, n, paddrs, data, dir);
+    ALLOCV_END(holder);
+    return;
   }
-  else {
-    /* byte-mismatched reinterpret: deliver cell by cell via xfer_index
-       (still no whole-view attach -- delegates one cell at a time). */
-    for ( i = 0; i < n; i++ ) {
-      ca_size_t idx[CA_RANK_MAX];
-      ca_addr2index((CArray *) ca, addrs[i], idx);
-      ca_stride_func_xfer_index(ca, idx, d + i * ca->bytes, dir);
-    }
+
+  /* Byte-mismatched reinterpret: deliver cell by cell via xfer_index
+     (still no whole-view attach -- delegates one cell at a time). */
+  for ( i = 0; i < n; i++ ) {
+    ca_size_t idx[CA_RANK_MAX];
+    ca_addr2index((CArray *) ca, addrs[i], idx);
+    ca_stride_func_xfer_index(ca, idx, d + i * ca->bytes, dir);
   }
-  ALLOCV_END(holder);
 }
 
 /* Optimised region delivery.  Reached when ca->ptr == NULL (the central dispatcher handles the alias / attached case).
@@ -656,6 +734,7 @@ 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)
 {
+  if ( ca_region_is_empty(((CArray *) ap)->ndim, counts) ) return;
   CAStride *ca = (CAStride *) ap;
   CArray   *root;
   ca_size_t composed_strides[CA_RANK_MAX];
@@ -736,16 +815,49 @@ ca_stride_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     }
   }
 
+  /* A reshape over a 1-D cold root (ndim != root->ndim): the request has no
+     box in the root's single axis, but the root cells it touches lie in one
+     flat span.  Ask the root for that span once and walk the request over
+     it, as xfer_all does for the whole view.  A PUT reads the span first so
+     the cells between the requested ones go back unchanged. */
+  if (aligned && !root->ptr && ca_func[root->obj_type].xfer_stride
+       && ca->bytes == root->bytes && root->ndim == 1
+       && root_base % root->bytes == 0) {
+    ca_size_t span_lo = root_base;
+    ca_size_t span_hi = root_base + ca->bytes;
+    for (k = 0; k < ndim; k++) {
+      ca_size_t ext = (counts[k] - 1) * root_stride[k];
+      if ( root_stride[k] >= 0 ) span_hi += ext;
+      else                       span_lo += ext;
+    }
+    if ( span_lo >= 0 && span_hi <= root->elements * root->bytes ) {
+      volatile VALUE holder;
+      ca_size_t rlo    = span_lo / root->bytes;
+      ca_size_t rcount = (span_hi - span_lo) / root->bytes;
+      ca_size_t rstep  = root->bytes;
+      char     *scratch = ALLOCV_N(char, holder, rcount * root->bytes);
+      ca_xfer_stride(root, &rlo, &rcount, &rstep, scratch, CA_XFER_GET);
+      ca_xfer_strided_walk(scratch + (root_base - span_lo), ca->bytes, ndim,
+                           counts, root_stride, d, dir);
+      if ( dir == CA_XFER_PUT ) {
+        ca_xfer_stride(root, &rlo, &rcount, &rstep, scratch, CA_XFER_PUT);
+      }
+      ALLOCV_END(holder);
+      return;
+    }
+  }
+
   /* Per-cell fallback (correct, no whole-view attach): byte-mismatch
      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. */
+     axes), or a cold non-entity root the branches above could not hand a
+     region to (a reshape over a root of two or more axes, or one with 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;
     for (k = 0; k < ndim; k++) idx[k] = 0;
+    /* empty: the slot returns on an empty region at its entry */
     while (1) {
       ca_size_t off = base_addr, vmidx[CA_RANK_MAX];
       for (k = 0; k < ndim; k++) off += idx[k] * strides[k];
@@ -942,6 +1054,8 @@ ca_stride_func_fill_stride (void *ap, ca_size_t base, int8_t ndim,
 }
 
 extern int ca_stride_is_contiguous (CAStride *ca);   /* defined below; non-static for Tier A */
+static int ca_layout_is_contiguous (int8_t ndim, const ca_size_t *dim,
+                                   const ca_size_t *strides, ca_size_t bytes);
 
 /* Alias fast path:
    When the view's strides describe a contiguous row-major run, the
@@ -996,8 +1110,9 @@ extern int ca_stride_is_contiguous (CAStride *ca);   /* defined below; non-stati
    composes a source down to its root.
 
    Entities hold their own buffer.  A CAStride-family root is one the fold
-   declined to walk through (a byte reinterpret, say); its own attach folds
-   onward as it always has, so leave that chain alone.  What is left is the
+   declined to walk through (a reshape over a transpose); its own attach
+   folds onward from itself, so the answer is the one for the root it folds
+   to.  What is left is the
    boundary views that compute or fetch their contents -- CAObject, the lazy
    per-element transforms, whatever a companion gem installed -- and of those,
    only the ones with an xfer_stride slot can answer a region request at all.
@@ -1009,10 +1124,41 @@ ca_root_lends_no_memory (void *ap)
   CArray *root = (CArray *) ap;
 
   if ( ca_is_entity(root) ) return 0;
-  if ( ca_func[root->obj_type].attach == ca_stride_func.attach ) return 0;
+  if ( ca_func[root->obj_type].attach == ca_stride_func.attach ) {
+    /* The fold stopped at a CAStride (a reshape over a transpose).  Its
+       own attach folds onward from itself, so it lends memory exactly when
+       the root it folds to does: over a computed root, attaching it
+       produces all of it. */
+    CArray   *below;
+    ca_size_t cs[CA_RANK_MAX];
+    ca_size_t base;
+    ca_stride_compose_to_root((CAStride *) root, &below, cs, &base);
+    return ca_root_lends_no_memory(below);
+  }
   return ca_func[root->obj_type].xfer_stride != NULL;
 }
 
+/* The same question for the parent of a view that is not itself in the
+   CAStride family (CAGrid, ...): whether the array its cells come from --
+   the parent, or the root a CAStride parent folds to -- has no memory to
+   lend.  Like ca_root_lends_no_memory it asks only what those arrays are,
+   so the lifecycle slots can rely on getting the same answer from attach
+   to detach. */
+int
+ca_parent_lends_no_memory (void *ap)
+{
+  CArray *parent = (CArray *) ap;
+
+  if ( ca_is_stride_family(parent) ) {
+    CArray   *root;
+    ca_size_t cs[CA_RANK_MAX];
+    ca_size_t base;
+    ca_stride_compose_to_root((CAStride *) parent, &root, cs, &base);
+    return ca_root_lends_no_memory(root);
+  }
+  return ca_root_lends_no_memory(parent);
+}
+
 /* ca_attach_is_alias asks the same question from carray_core.c: a view whose
    attach owns its buffer does not alias its parent, so writes through
    ca->ptr need a ca_sync and callers must not assume otherwise. */
@@ -1032,7 +1178,16 @@ ca_stride_attach_aliases_root (CAStride *ca)
     return 1;
   }
   ca_stride_compose_to_root(ca, &root, composed_strides, &composed_base);
-  return !ca_root_lends_no_memory(root);
+  /* The same test ca_stride_func_attach makes, and then the same question of
+     the fold boundary.  The leaf's own strides are in its parent's address
+     space -- a block over a flip is contiguous there and not in the root --
+     and a boundary that is itself a CAStride (a reshape over a transpose
+     stops the fold) is one whose attach may build a buffer of its own, which
+     this view would then alias without reaching the memory below it. */
+  return !ca_root_lends_no_memory(root)
+         && ca_layout_is_contiguous(ca->ndim, ca->dim, composed_strides,
+                                    ca->bytes)
+         && ca_attach_is_alias(root);
 }
 
 static void
@@ -1045,14 +1200,14 @@ ca_stride_func_allocate (void *ap)
 
   ca_stride_compose_to_root(ca, &root, composed_strides, &composed_base);
   if (ca_root_lends_no_memory(root)) {
-    ca->ptr = xmalloc(ca_length(ca));
+    ca->ptr = ca_alloc_cells((CArray *) ca);
     return;
   }
   ca_attach(root);
   if (ca_layout_is_contiguous(ca->ndim, ca->dim, composed_strides, ca->bytes)) {
     ca->ptr = root->ptr + composed_base;
   } else {
-    ca->ptr = xmalloc(ca_length(ca));
+    ca->ptr = ca_alloc_cells((CArray *) ca);
   }
 }
 
@@ -1081,14 +1236,9 @@ ca_stride_func_attach (void *ap)
        transfer slots. */
     char *buf = xmalloc(ca_length(ca));
     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_fill_or_xfree(buf, ca_stride_cold_fill, (VALUE) args);   /* root stays cold */
     ca->ptr = buf;
     return;
   }
@@ -1096,7 +1246,7 @@ ca_stride_func_attach (void *ap)
   if (ca_layout_is_contiguous(ca->ndim, ca->dim, composed_strides, ca->bytes)) {
     ca->ptr = root->ptr + composed_base;
   } else {
-    ca->ptr = xmalloc(ca_length(ca));
+    ca->ptr = ca_alloc_cells((CArray *) ca);
     ca_stride_xfer_with_layout(ca, 0, root->ptr + composed_base, composed_strides);
   }
 }
@@ -1223,6 +1373,8 @@ ca_stride_func_xfer_all (void *ap, void *data, int dir)
   char *ptr0 = ca->ptr;
   char *ptr = (char *) data;
 
+  if ( ca->elements == 0 ) return;
+
   ca_stride_compose_to_root(ca, &root, composed_strides, &composed_base);
 
   /* Partial materialise: when the fold stops at a cold boundary view that knows how to deliver a region (has an
@@ -1324,6 +1476,81 @@ ca_stride_func_xfer_all (void *ap, void *data, int dir)
     return;
   }
 
+  /* A request the bridges above could not express as a region goes to the
+     root as the list of its cells.  A write never makes a round trip of
+     the whole root: a root that repeats its cells (CATile) would have the
+     stale copies the caller never wrote land after the written ones, and a
+     root that converts on the way would bring the unwritten cells back
+     changed.  A read does not make the root produce cells it was not asked
+     for, unless it is asked for as many as it has.  The root's addresses
+     are whole elements here, as in the region hand-off above. */
+  if ( ( dir == CA_XFER_PUT || ca->elements < root->elements )
+       && ca->bytes == root->bytes && composed_base % root->bytes == 0 ) {
+    volatile VALUE holder;
+    ca_size_t *addrs = ALLOCV_N(ca_size_t, holder, ca->elements);
+    ca_size_t  idx[CA_RANK_MAX], n = 0;
+    int8_t     k;
+    for (k = 0; k < ca->ndim; k++) idx[k] = 0;
+    /* empty: the slot returns on an empty view at its entry */
+    while (1) {
+      ca_size_t off = composed_base;
+      for (k = 0; k < ca->ndim; k++) off += idx[k] * composed_strides[k];
+      addrs[n++] = off / root->bytes;
+      k = ca->ndim - 1;
+      while (k >= 0) { if (++idx[k] < ca->dim[k]) break; idx[k] = 0; k--; }
+      if (k < 0) break;
+    }
+    ca_xfer_addrs(root, n, addrs, ptr, dir);
+    ALLOCV_END(holder);
+    return;
+  }
+
+  /* A read through a byte reinterpret (CAField, a refer to another width)
+     over a cold root: the root's addresses are not this view's cells, but
+     each cell lies in a run of whole root elements.  Ask the root for those
+     elements and cut the cell's bytes out of them.  A write keeps the
+     whole-root round trip below: two cells can share a root element, and
+     writing back each one's copy of it would drop the other's bytes. */
+  if ( dir == CA_XFER_GET && ca->elements > 0 && ca->bytes != root->bytes
+       && ca_func[root->obj_type].xfer_stride ) {
+    volatile VALUE ah = 0, sh = 0;
+    ca_size_t  rb = root->bytes, cb = ca->bytes;
+    ca_size_t  per = (cb + rb - 1) / rb + 1;
+    ca_size_t *addrs = ALLOCV_N(ca_size_t, ah, ca->elements * per);
+    char      *scratch;
+    ca_size_t  idx[CA_RANK_MAX], n = 0, i;
+    ca_size_t *first = ALLOCV_N(ca_size_t, sh, ca->elements);
+    int8_t     k;
+    int        ok = 1;
+    for (k = 0; k < ca->ndim; k++) idx[k] = 0;
+    for (i = 0; ok; i++) {
+      ca_size_t off = composed_base, e, e_end;
+      for (k = 0; k < ca->ndim; k++) off += idx[k] * composed_strides[k];
+      if ( off < 0 || off + cb > root->elements * rb ) { ok = 0; break; }
+      first[i] = n * rb + off % rb;
+      for (e = off / rb, e_end = (off + cb - 1) / rb; e <= e_end; e++) {
+        addrs[n++] = e;
+      }
+      k = ca->ndim - 1;
+      while (k >= 0) { if (++idx[k] < ca->dim[k]) break; idx[k] = 0; k--; }
+      if (k < 0) break;
+    }
+    if ( ok && n < root->elements ) {
+      volatile VALUE dh = 0;
+      scratch = ALLOCV_N(char, dh, n * rb);
+      ca_xfer_addrs(root, n, addrs, scratch, CA_XFER_GET);
+      for (i = 0; i < ca->elements; i++) {
+        memcpy(ptr + i * cb, scratch + first[i], cb);
+      }
+      ALLOCV_END(dh);
+      ALLOCV_END(sh);
+      ALLOCV_END(ah);
+      return;
+    }
+    ALLOCV_END(sh);
+    ALLOCV_END(ah);
+  }
+
   /* Cold root without an xfer_stride slot, or an ndim mismatch the bridges
      above could not express: materialise the root into scratch via
      ca_xfer_all and run the direct strided gather/scatter against that.
@@ -1342,11 +1569,14 @@ ca_stride_func_xfer_all (void *ap, void *data, int dir)
     ca_stride_xfer_with_layout(ca, (dir == CA_XFER_PUT) ? 1 : 0,
                                root->ptr + composed_base, composed_strides);
     ca->ptr = ptr0;
+    /* Put root->ptr back before the PUT: the PUT can raise (a lazy
+       backing's sync failing), and the scratch is gone once this frame
+       is. */
+    root->ptr = root_ptr_saved;
     if ( dir == CA_XFER_PUT ) {
       /* Push back scratch (modified by scatter) to root. */
       ca_xfer_all(root, root_scratch, CA_XFER_PUT);
     }
-    root->ptr = root_ptr_saved;
     ALLOCV_END(holder);
   }
 }
@@ -1849,6 +2079,7 @@ rb_cs_initialize_copy (VALUE self, VALUE other)
 {
   CAStride *ca, *cs;
   TypedData_Get_Struct(self,  CAStride, &castride_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CAStride, &castride_data_type, cs);
   /* Pool framework: self was created by rb_cs_s_allocate (= TypedData_Make_Struct),
      so ca->_pool is NULL.  Wire up the pool before ca_stride_setup so the
@@ -1927,9 +2158,10 @@ rb_ca_as_strided (int argc, VALUE *argv, VALUE self)
              "shape (%ld) and strides (%ld) length mismatch",
              len, RARRAY_LEN(rstrides));
   }
-  if (len <= 0 || len > CA_RANK_MAX) {
+  if (len <= 0) {
     rb_raise(rb_eArgError, "invalid ndim %ld", len);
   }
+  ca_check_rank_fits(len, NULL);
   ndim = (int8_t) len;
   for (i = 0; i < len; i++) {
     shape[i]   = NUM2SIZE(RARRAY_AREF(rshape,   i));
@@ -1939,8 +2171,10 @@ rb_ca_as_strided (int argc, VALUE *argv, VALUE self)
     base_offset = NUM2SIZE(roffset);
   }
 
-  return rb_ca_stride_new(self, parent->data_type, parent->bytes,
-                          ndim, shape, strides, base_offset);
+  VALUE obj = rb_ca_stride_new(self, parent->data_type, parent->bytes,
+                               ndim, shape, strides, base_offset);
+  CA_WRAPPER_LIFT(obj, self, parent);
+  return obj;
 }
 
 /* sliding_windows(*window, step: nil) -- overlapping-window view over every
@@ -1965,11 +2199,7 @@ rb_ca_sliding_windows (int argc, VALUE *argv, VALUE self)
   TypedData_Get_Struct(self, CArray, &carray_data_type, parent);
 
   ndim = parent->ndim;
-  if (2 * (int) ndim > CA_RANK_MAX) {
-    rb_raise(rb_eArgError,
-             "sliding_windows: result rank %d exceeds CA_RANK_MAX (%d)",
-             2 * (int) ndim, CA_RANK_MAX);
-  }
+  ca_check_rank_fits(2 * (long) ndim, "sliding_windows");
 
   rb_scan_args(argc, argv, "*:", (VALUE *) &rposary, (VALUE *) &ropt);
   if (! NIL_P(ropt)) {
@@ -2051,8 +2281,10 @@ rb_ca_sliding_windows (int argc, VALUE *argv, VALUE self)
     outstrides[ndim + i] = parent_byte_stride[i];
   }
 
-  return rb_ca_stride_new(self, parent->data_type, parent->bytes,
-                          (int8_t)(2 * ndim), outdim, outstrides, 0);
+  VALUE obj = rb_ca_stride_new(self, parent->data_type, parent->bytes,
+                               (int8_t)(2 * ndim), outdim, outstrides, 0);
+  CA_WRAPPER_LIFT(obj, self, parent);
+  return obj;
 }
 
 /* unfold(*window, step: nil) -- sliding_windows over the leading `S` axes
@@ -2111,11 +2343,7 @@ rb_ca_unfold (int argc, VALUE *argv, VALUE self)
 
   ntrail = ndim - nspatial;
   outrank = (int) ndim + (int) nspatial;
-  if (outrank > CA_RANK_MAX) {
-    rb_raise(rb_eArgError,
-             "unfold: result rank %d exceeds CA_RANK_MAX (%d)",
-             outrank, CA_RANK_MAX);
-  }
+  ca_check_rank_fits(outrank, "unfold");
 
   if (NIL_P(rstep)) {
     for (i = 0; i < nspatial; i++) step[i] = 1;
@@ -2173,8 +2401,10 @@ rb_ca_unfold (int argc, VALUE *argv, VALUE self)
     outstrides[2 * nspatial + i] = parent_byte_stride[nspatial + i];
   }
 
-  return rb_ca_stride_new(self, parent->data_type, parent->bytes,
-                          (int8_t) outrank, outdim, outstrides, 0);
+  VALUE obj = rb_ca_stride_new(self, parent->data_type, parent->bytes,
+                               (int8_t) outrank, outdim, outstrides, 0);
+  CA_WRAPPER_LIFT(obj, self, parent);
+  return obj;
 }
 
 /* block_view(*block) -- non-overlapping tile view.  Parent [d0..dN-1]
@@ -2197,11 +2427,7 @@ rb_ca_block_view (int argc, VALUE *argv, VALUE self)
   TypedData_Get_Struct(self, CArray, &carray_data_type, parent);
 
   ndim = parent->ndim;
-  if (2 * (int) ndim > CA_RANK_MAX) {
-    rb_raise(rb_eArgError,
-             "block_view: result rank %d exceeds CA_RANK_MAX (%d)",
-             2 * (int) ndim, CA_RANK_MAX);
-  }
+  ca_check_rank_fits(2 * (long) ndim, "block_view");
 
   rb_scan_args(argc, argv, "*:", (VALUE *) &rposary, (VALUE *) &ropt);
   rb_reject_options(ropt);
@@ -2258,8 +2484,12 @@ rb_ca_block_view (int argc, VALUE *argv, VALUE self)
     outstrides[ndim + i] = parent_byte_stride[i];
   }
 
-  return rb_ca_stride_new(self, parent->data_type, parent->bytes,
-                          (int8_t)(2 * ndim), outdim, outstrides, 0);
+  VALUE obj = rb_ca_stride_new(self, parent->data_type, parent->bytes,
+                               (int8_t)(2 * ndim), outdim, outstrides, 0);
+  /* The Face stays on top, as for every view: a tile reduction over a
+     bare block_view compared the Face's surface bytes. */
+  CA_WRAPPER_LIFT(obj, self, parent);
+  return obj;
 }
 
 /* defined in ca_obj_transpose.c */
@@ -2300,7 +2530,7 @@ rb_ca_dim_view (int argc, VALUE *argv, VALUE self)
                (int) n_iter, (int) ndim);
     }
     for (i = 0; i < n_iter; i++) {
-      iter_axes[i] = NUM2SIZE(RARRAY_AREF(aary, i));
+      iter_axes[i] = ca_normalize_axis_arg(RARRAY_AREF(aary, i), ndim, NULL);
     }
   }
   else if (nargs >= 1) {
@@ -2311,7 +2541,7 @@ rb_ca_dim_view (int argc, VALUE *argv, VALUE self)
     }
     n_iter = (int8_t) nargs;
     for (i = 0; i < n_iter; i++) {
-      iter_axes[i] = NUM2SIZE(RARRAY_AREF(rposary, i));
+      iter_axes[i] = ca_normalize_axis_arg(RARRAY_AREF(rposary, i), ndim, NULL);
     }
   }
   else {
@@ -2319,23 +2549,16 @@ rb_ca_dim_view (int argc, VALUE *argv, VALUE self)
              "dim_view: at least one iteration axis required");
   }
 
-  /* Normalize negative indices and validate range / distinctness. */
+  /* The axes are normalized as they are read; check distinctness. */
   for (i = 0; i < ndim; i++) seen[i] = 0;
   for (i = 0; i < n_iter; i++) {
     ca_size_t a = iter_axes[i];
-    if (a < 0) a += ndim;
-    if (a < 0 || a >= ndim) {
-      rb_raise(rb_eArgError,
-               "dim_view: axis %lld out of range for ndim %d",
-               (long long) iter_axes[i], (int) ndim);
-    }
     if (seen[a]) {
       rb_raise(rb_eArgError,
                "dim_view: duplicate iteration axis %lld",
                (long long) a);
     }
     seen[a] = 1;
-    iter_axes[i] = a;
   }
 
   /* imap: iter axes first (in given order), then remaining axes
@@ -2407,12 +2630,8 @@ rb_ca_flip_axis (VALUE self, long axis)
   rb_check_carray_object(self);
   TypedData_Get_Struct(self, CArray, &carray_data_type, parent);
   int8_t ndim = parent->ndim;
-  long a = (axis < 0) ? (axis + ndim) : axis;
-  if (a < 0 || a >= ndim) {
-    rb_raise(rb_eArgError,
-             "flip_axis: axis %ld out of range for ndim %d",
-             axis, (int) ndim);
-  }
+  long a = rb_ca_normalize_axis_for_ndim(axis, ndim,   /* axis-check: a long from a C caller */
+                                         "flip_axis");
   int8_t flip[CA_RANK_MAX] = {0};
   flip[a] = 1;
   return rb_ca_flip_build_view(self, parent, flip);
@@ -2439,8 +2658,8 @@ rb_ca_flip (int argc, VALUE *argv, VALUE self)
 
   for (i = 0; i < ndim; i++) flip[i] = 0;
 
-  if (nargs == 0) {
-    /* No args: flip every axis. */
+  if (nargs == 0 || (nargs == 1 && NIL_P(RARRAY_AREF(rposary, 0)))) {
+    /* No args, or a lone nil: flip every axis. */
     for (i = 0; i < ndim; i++) flip[i] = 1;
     n_axes = ndim;
   }
@@ -2454,7 +2673,7 @@ rb_ca_flip (int argc, VALUE *argv, VALUE self)
                  (int) n_axes, (int) ndim);
       }
       for (i = 0; i < n_axes; i++) {
-        axes[i] = NUM2SIZE(RARRAY_AREF(aary, i));
+        axes[i] = ca_normalize_axis_arg(RARRAY_AREF(aary, i), ndim, NULL);
       }
     }
     else {
@@ -2465,18 +2684,12 @@ rb_ca_flip (int argc, VALUE *argv, VALUE self)
       }
       n_axes = (int8_t) nargs;
       for (i = 0; i < n_axes; i++) {
-        axes[i] = NUM2SIZE(RARRAY_AREF(rposary, i));
+        axes[i] = ca_normalize_axis_arg(RARRAY_AREF(rposary, i), ndim, NULL);
       }
     }
 
     for (i = 0; i < n_axes; i++) {
       ca_size_t a = axes[i];
-      if (a < 0) a += ndim;
-      if (a < 0 || a >= ndim) {
-        rb_raise(rb_eArgError,
-                 "flip: axis %lld out of range for ndim %d",
-                 (long long) axes[i], (int) ndim);
-      }
       if (flip[a]) {
         rb_raise(rb_eArgError,
                  "flip: duplicate axis %lld",
@@ -2550,18 +2763,8 @@ rb_ca_diagonal (int argc, VALUE *argv, VALUE self)
       rb_raise(rb_eArgError,
                "diagonal: axis: must be an Array of 2 integers");
     }
-    ai = NUM2SIZE(RARRAY_AREF(raxis, 0));
-    aj = NUM2SIZE(RARRAY_AREF(raxis, 1));
-    if (ai < 0) ai += ndim;
-    if (aj < 0) aj += ndim;
-    if (ai < 0 || ai >= ndim) {
-      rb_raise(rb_eArgError, "diagonal: axis[0] out of range for ndim %d",
-               (int) ndim);
-    }
-    if (aj < 0 || aj >= ndim) {
-      rb_raise(rb_eArgError, "diagonal: axis[1] out of range for ndim %d",
-               (int) ndim);
-    }
+    ai = ca_normalize_axis_arg(RARRAY_AREF(raxis, 0), ndim, NULL);
+    aj = ca_normalize_axis_arg(RARRAY_AREF(raxis, 1), ndim, NULL);
     if (ai == aj) {
       rb_raise(rb_eArgError, "diagonal: axis[0] and axis[1] must be distinct");
     }
@@ -2589,7 +2792,9 @@ rb_ca_diagonal (int argc, VALUE *argv, VALUE self)
     base_offset = offset * parent_byte_stride[aj];
   }
   else {
-    ca_size_t neg = -offset;
+    /* compare before negating: -offset overflows for the most negative
+       offset */
+    ca_size_t neg = ( offset <= -parent->dim[ai] ) ? parent->dim[ai] : -offset;
     if (neg >= parent->dim[ai]) {
       diag_len = 0;
     }
@@ -2600,6 +2805,9 @@ rb_ca_diagonal (int argc, VALUE *argv, VALUE self)
     }
     base_offset = neg * parent_byte_stride[ai];
   }
+  if (diag_len == 0) {
+    base_offset = 0;   /* an offset past the edge can overflow the product */
+  }
 
   /* build output: kept axes (in original order), then diagonal axis */
   out_k = 0;