carray 3.0.5 → 3.0.6

data/ext/ca_kernel_iterator.c

@@ -31,7 +31,8 @@
 
   A route added for speed is a shortcut, tagged next to its code with
   "Shortcut NAME" and a fixed set of fields; each one is switched off by
-  ca_fast_paths_enabled().
+  ca_fast_path(CA_SC_name): by its name in CARRAY_SHORTCUTS_OFF, or with
+  the others by CARRAY_GENERAL_PATH=1 (carray_internal.h).
 
 ---------------------------------------------------------------------------- */
 
@@ -43,7 +44,6 @@
 
 #include <assert.h>
 #include <string.h>
-#include <ruby/ractor.h>
 
 /* Private flags bit, kept in ca_iter_state.flags like
    CA_ITER_FLAG_WALK_MAY_RAISE below: src is a copy the walk owns (see
@@ -52,69 +52,7 @@
 
 /* Data scratch.  A scratch of object cells holds VALUEs no Ruby object
    owns while the kernel calls Ruby for each cell, so it is filled with
-   Qnil and held for the GC until finish releases it.
-
-   One large scratch is kept when a walk frees it and handed to the next
-   walk that fits in it: a fresh allocation of that size costs the page
-   faults of touching it, which for a reduction is several times the
-   reduction itself.  The kept buffer is owned by nobody, and a walk that
-   takes it owns it alone until it frees it again.  Each Ractor keeps its
-   own (ractor-local storage), since walks in different Ractors run at
-   the same time.
-
-   Shortcut KEEP_SCRATCH (name tag; docs/internal/KernelIteratorEngine.md
-   section 3.4 has the table of all shortcuts).
-     Layer       data: where a scratch comes from.  The walk is unchanged.
-     Speeds up   walks with a scratch of 1 MiB or more, run one after
-                 another.
-     Why         no difference measured on macOS (a per-axis sum of a
-                 2000x2000 fake view); the page faults it
-                 avoids are expected to cost more on Linux (unmeasured).
-     Enters      ki_data_alloc: bytes >= KI_KEEP_MIN and a kept buffer
-                 that fits; ki_data_free: KI_KEEP_MIN <= bytes <=
-                 KI_KEEP_MAX.
-     Promises    4 (a kept buffer has no owner, so no exit can leave it
-                 held); 7 (object cells are cleared and held either way).
-     Switch      ca_fast_paths_enabled(): off, every scratch is fresh.
-     Checked by  test_iter_ractor_scratch.rb; the buffer count in
-                 test_iter_delivery_detectors.rb. */
-
-#define KI_KEEP_MIN ((ca_size_t) 1 << 20)
-#define KI_KEEP_MAX ((ca_size_t) 64 << 20)
-
-typedef struct {
-  void      *p;
-  ca_size_t  bytes;
-} ki_kept_t;
-
-static rb_ractor_local_key_t ki_kept_key;
-
-static void
-ki_kept_free (void *ptr)
-{
-  ki_kept_t *k = (ki_kept_t *) ptr;
-  if ( k ) {
-    if ( k->p ) ruby_xfree(k->p);
-    ruby_xfree(k);
-  }
-}
-
-static const struct rb_ractor_local_storage_type ki_kept_type = {
-  NULL, ki_kept_free
-};
-
-static ki_kept_t *
-ki_kept_slot (void)
-{
-  ki_kept_t *k = (ki_kept_t *) rb_ractor_local_storage_ptr(ki_kept_key);
-  if ( k == NULL ) {
-    k = ALLOC(ki_kept_t);
-    k->p     = NULL;
-    k->bytes = 0;
-    rb_ractor_local_storage_ptr_set(ki_kept_key, k);
-  }
-  return k;
-}
+   Qnil and held for the GC until finish releases it. */
 
 /* Development build: the number of buffers ki_data_alloc has handed out
    that ki_data_free has not taken back (CArray.__iter_buffers__).  A walk
@@ -131,19 +69,9 @@ static long ki_buffers_out = 0;
 static void *
 ki_data_alloc (int8_t data_type, ca_size_t bytes)
 {
-  void *p = NULL;
+  void *p;
   KI_BUFFERS_OUT(1);
-  if ( bytes >= KI_KEEP_MIN && ca_fast_paths_enabled() ) {
-    ki_kept_t *k = ki_kept_slot();
-    if ( k->p && bytes <= k->bytes ) {
-      p = k->p;
-      k->p = NULL;
-      k->bytes = 0;
-    }
-  }
-  if ( p == NULL ) {
-    p = xmalloc(bytes > 0 ? bytes : 1);
-  }
+  p = xmalloc(bytes > 0 ? bytes : 1);
   if ( data_type == CA_OBJECT ) {
     ca_size_t n = bytes / (ca_size_t) sizeof(VALUE);
     ca_object_cells_clear(p, n);
@@ -152,24 +80,11 @@ ki_data_alloc (int8_t data_type, ca_size_t bytes)
   return p;
 }
 
-/* `bytes` is the size p was allocated with (0 when unknown: never kept). */
 static void
-ki_data_free (void *p, ca_size_t bytes)
+ki_data_free (void *p)
 {
   KI_BUFFERS_OUT(-1);
   ca_gc_release_buffer(p);
-  if ( bytes >= KI_KEEP_MIN && bytes <= KI_KEEP_MAX && ca_fast_paths_enabled() ) {
-    ki_kept_t *k = ki_kept_slot();
-    if ( bytes > k->bytes ) {
-      void *old = k->p;
-      k->p     = p;
-      k->bytes = bytes;
-      if ( old ) {
-        xfree(old);
-      }
-      return;
-    }
-  }
   xfree(p);
 }
 
@@ -197,7 +112,7 @@ extern ca_operation_function_t ca_window_func;
    engine gathers its cells into a scratch buffer of its own through the
    view's transfer (ki_gather_view = ca_xfer_all GET) and, on a WRITE
    walk, sends back the cells the kernel changed (ki_scratch_push_changed
-   = ca_xfer_addrs, or ca_xfer_all PUT when every cell changed).  The
+   = ca_xfer_addrs).  The
    view's attach / sync slots are not called.  Cast / byte swap / bit
    unpack / reduction views: */
 extern ca_operation_function_t ca_fake_func;
@@ -272,6 +187,14 @@ ca_iter_register_source_kind (int obj_type, uint8_t kind)
              "ca_iter_register_source_kind: obj_type %d out of range",
              obj_type);
   }
+  /* carray's own types are classified from their operation tables; a
+     registration would only move one of them onto the transfer walk, for
+     every array in the process. */
+  if ( obj_type < ca_obj_num_builtin ) {
+    rb_raise(rb_eArgError,
+             "ca_iter_register_source_kind: obj_type %d is one of carray's "
+             "own", obj_type);
+  }
   if ( kind != CA_ITER_SRC_ATTACH ) {
     rb_raise(rb_eArgError,
              "ca_iter_register_source_kind: only CA_ITER_SRC_ATTACH (%d) "
@@ -497,10 +420,10 @@ ca_iter_build_rowmajor_strides (ca_size_t       *strides,
 /* ---- PER_FIBER_FUSED: which views take it ----------------------------- */
 
 /* A src_kind branch, then a check of the view's operation table, then of
-   the fiber axis's stride.  Returns nonzero for
+   the fiber axis's stride.  Returns nonzero for a read of
    CAFake / CAByteSwap / a single-cast CAMonOp under SRC_ATTACH when the
-   fiber is contiguous in the parent, and for CAWindow / CAShift under
-   SRC_DESCRIPTOR; zero otherwise.
+   fiber is contiguous in the parent (that is, the fiber runs along the
+   innermost axis); zero for a write walk and for every other view.
 
    The fiber_axis_stride argument is the effective byte stride of the
    fiber axis on the view (= what next_slab_axes would yield as
@@ -508,10 +431,10 @@ ca_iter_build_rowmajor_strides (ca_size_t       *strides,
    a contiguous run of the parent's memory, which is what lets the view's
    region transfer deliver it in one pass.
 
-   Called from two places in init_l2: the CA_SLAB_AXES descriptor branch
-   and the SRC_ATTACH branch, each before it would materialise.  When it
-   returns nonzero the caller skips the materialise and sets alias_mode =
-   CA_ITER_ALIAS_PER_FIBER_FUSED with the fiber dispatch state filled. */
+   Called from one place, the SRC_ATTACH branch of ki_choose_l2_route,
+   with src_kind = CA_ITER_SRC_ATTACH.  When it returns nonzero the route
+   is KI_L2_FIBER_FUSED: the whole view is not gathered and alias_mode is
+   CA_ITER_ALIAS_PER_FIBER_FUSED. */
 static int
 ca_iter_should_per_fiber_fused (CArray   *src,
                                 int       src_kind,
@@ -543,19 +466,6 @@ ca_iter_should_per_fiber_fused (CArray   *src,
     }
   }
 
-  /* CAShift / CAWindow: the view's region transfer fills out-of-bounds
-     cells itself, so a fiber can be fetched in one call instead of a
-     per-slab or whole-view gather (SRC_DESCRIPTOR).  A view that can
-     lend the parent's memory (SRC_DESCRIPTOR_L2_ALIASABLE, an interior
-     CAWindow) is already read in place; fetching it fiber by fiber was
-     measured slower (0.35-0.82x), so only SRC_DESCRIPTOR takes it. */
-  if ( src_kind == CA_ITER_SRC_DESCRIPTOR ) {
-    /* CAWindow and CAShift share ca_window_func.attach. */
-    if ( attach == ca_window_func.attach ) {
-      return 1;
-    }
-  }
-
   /* Not taken by the other views, each measured slower fiber by fiber:
      CASelectAxis / CAGrid / CASelect (1.25-4.7x), whose descriptor
      engine already gathers the whole view in one batched pass and has no
@@ -645,9 +555,9 @@ ca_iter_strip_storage_wrapper (CArray *src)
   return src;
 }
 
-/* Raise unless a and b have the same shape.  The INOUT and PAIR fiber
-   macros call it before opening either walk, so a refusal leaves nothing
-   to close. */
+/* Raise unless a and b have the same shape.  The INOUT, SLAB_INOUT and
+   PAIR macros call it before opening either walk, so a refusal leaves
+   nothing to close. */
 int
 ca_iter_check_same_shape (struct _CArray *a, struct _CArray *b)
 {
@@ -817,19 +727,7 @@ ki_scratch_push_changed (ca_iter_state *st)
     }
   }
 
-  /* Shortcut PUSH_ALL_CHANGED.
-       Layer       write-back.
-       Speeds up   a whole-view write walk that changed every cell: one
-                   ca_xfer_all PUT instead of a list of all the addresses.
-       Why         about 5% on a whole write of a fake view of 1M cells.
-       Enters      whole && n_changed == n.
-       Promises    3 (the same cells go back; the list would hold them all).
-       Switch      ca_fast_paths_enabled(): off, the address list.
-       Checked by  the write rows of the delivery matrix (L1 / L2 whole). */
-  if ( whole && n_changed == n && ca_fast_paths_enabled() ) {
-    ca_xfer_all(src, now, CA_XFER_PUT);
-  }
-  else if ( n_changed > 0 ) {
+  if ( n_changed > 0 ) {
     ca_xfer_addrs(src, n_changed, addrs, vals, CA_XFER_PUT);
   }
   ALLOCV_END(h_vals);
@@ -1027,8 +925,8 @@ ca_iter_state_init_l1_unprotected (ca_iter_state    *st,
    state is assembled in one place and init_l2 has one way out. */
 
 typedef enum {
-  KI_L2_FIBER_FUSED,   /* PER_FIBER_FUSED: a CAWindow / CAShift fiber, or a
-                          read of a conversion view's innermost fiber */
+  KI_L2_FIBER_FUSED,   /* PER_FIBER_FUSED: a read of a conversion view's
+                          innermost fiber */
   KI_L2_PER_SLAB,      /* descriptor view, read, a slab axis INDEX or SHIFT:
                           one slab gathered at a time (PER_SLAB / _HOIST) */
   KI_L2_DESC_WHOLE,    /* descriptor view, read: the whole view gathered by
@@ -1135,33 +1033,6 @@ ki_choose_l2_route (CArray *src, int8_t *axes, int8_t naxes, uint32_t flags,
 
   if ( plan->src_kind == CA_ITER_SRC_DESCRIPTOR
        || plan->src_kind == CA_ITER_SRC_DESCRIPTOR_L2_ALIASABLE ) {
-    /* Shortcut PER_FIBER_FUSED (CAWindow / CAShift).
-       Layer       all three, per fiber: each fiber is fetched with the
-                   view's ca_xfer_stride (which fills out-of-bounds
-                   cells itself) and put back the same way.
-       Speeds up   a fiber walk of a CAWindow / CAShift whose innermost
-                   axis is SHIFT.
-       Why         none measured: about 8% slower than the descriptor
-                   route on a sort of a 2000x2000 shift view.
-       Enters      CA_KERNEL_FIBER_CONTIG, one slab axis, the view's
-                   own rank, and ca_iter_should_per_fiber_fused.  An
-                   outer-only SHIFT arrives as L2_ALIASABLE and never
-                   reaches this hook.
-       Promises    1 (the fiber scratch is contiguous), 2 (the mask is
-                   fetched into the fiber mask scratch), 3 (ca_xfer_stride
-                   PUT of a fiber that neither converts nor repeats a
-                   cell), 4 (CA_ITER_FLAG_WALK_MAY_RAISE).
-       Switch      ca_fast_paths_enabled(): off, the descriptor route.
-       Checked by  the fiber rows of the "shift" view in the delivery
-                   matrix. */
-    if ( (flags & CA_KERNEL_FIBER_CONTIG) && naxes == 1
-         && plan->ndesc == src->ndim && ca_fast_paths_enabled()
-         && ca_iter_should_per_fiber_fused(src, plan->src_kind, axes[0],
-                                           row_bytes[axes[0]], flags) ) {
-      plan->route = KI_L2_FIBER_FUSED;
-      return CA_ITER_OK;
-    }
-
     /* The rank check guards a descriptor whose rank differs from the
        view's (it would not expose the axis partition slab_axes names).
        Every describe_axes in the engine reports the view's rank, so the
@@ -1190,19 +1061,21 @@ ki_choose_l2_route (CArray *src, int8_t *axes, int8_t naxes, uint32_t flags,
        Layer       data; the fiber layer (ki_fiber_contig_*) sits on top.
        Speeds up   read walks of a CAWindow / CAShift whose slab has a
                    SHIFT axis and not the innermost axis.
-       Why         about 1.5x on a median along axis 0 of a 2000x2000
-                   shift view.
+       Why         measured switched off alone (CARRAY_SHORTCUTS_OFF) on an
+                   M2 Max / a Xeon 6369P, 2026-10-26: 1.5x / 1.1x on a
+                   median along axis 0 of a 2000x2000 shift view, 3.1x /
+                   2.2x on a sum along axis 0 of a window.
        Enters      a non-stride slab axis, no INDEX slab axis, the
                    innermost axis outside the slab, a read walk.
        Promises    2 and 6 (the mask is copied by ki_take_mask_copy, and
                    only when the view has one).
-       Switch      ca_fast_paths_enabled(): off, the per-slab gather.
+       Switch      ca_fast_path(): off, the per-slab gather.
        Checked by  the slab-axis rows of the "shift" and "window" views
                    in the delivery matrix. */
     int whole_view = slab_has_non_stride && ! slab_has_index
                      && ! in_slab[src->ndim - 1]
                      && ! ( flags & CA_KERNEL_WRITE )
-                     && ca_fast_paths_enabled();
+                     && ca_fast_path(CA_SC_SHIFT_WHOLE_VIEW);
 
     /* The descriptor engine's gathers (per slab and whole view) read
        only.  A write takes the transfer walk instead: the view is
@@ -1234,19 +1107,20 @@ ki_choose_l2_route (CArray *src, int8_t *axes, int8_t naxes, uint32_t flags,
                    parents through a tile cache.
        Speeds up   read walks of an unmasked CAStack whose one slab axis
                    is the stack axis.
-       Why         about 2x on a mean along the stack axis of 4 parents
-                   of 500x2000.
+       Why         measured switched off alone (CARRAY_SHORTCUTS_OFF) on an
+                   M2 Max / a Xeon 6369P, 2026-10-26: 1.2x / 1.3x on a mean
+                   along the stack axis of 4 parents of 500x2000.
        Enters      a CAStack, no mask, a read walk, one slab axis that is
                    k_axis.
        Promises    1 (the slab is contiguous), 6 (no mask exists to touch).
-       Switch      ca_fast_paths_enabled(): off, the transfer walk.
+       Switch      ca_fast_path(): off, the transfer walk.
        Checked by  the slab-axis and fiber rows of the stack parent along
                    axis 0 in the delivery matrix. */
     if ( ca_func[src->obj_type].attach == ca_stack_func.attach
          && !ca_has_mask(src)
          && !(flags & CA_KERNEL_WRITE)
          && naxes == 1 && axes[0] == ((CAStack *) src)->k_axis
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK) ) {
       plan->route = KI_L2_STACK;
       return CA_ITER_OK;
     }
@@ -1255,19 +1129,22 @@ ki_choose_l2_route (CArray *src, int8_t *axes, int8_t naxes, uint32_t flags,
        Speeds up   read walks of a CAStack whose stack axis is an outer
                    axis: each slab is cut from the one parent the outer
                    index picks, without gathering the stack.
-       Why         about 11x on a mean along axis 1 of 4 parents of
-                   500x2000.
+       Why         measured switched off alone (CARRAY_SHORTCUTS_OFF) on an
+                   M2 Max / a Xeon 6369P, 2026-10-26: 1.0x / 1.0x on a mean
+                   along axis 1 of 4 parents of 500x2000, which the
+                   generated loop interchange answers first (3.5x / 3.8x
+                   with that off too); 1.1x / 1.2x on a median along axis 2.
        Enters      a CAStack, a read walk, the stack axis outside the slab.
        Promises    2 (the parents' masks are copied), 6 (masks are read
                    only when a parent has one), 8 (alias_ptr stays NULL,
                    so no slab is lent as a window).
-       Switch      ca_fast_paths_enabled(): off, the transfer walk.
+       Switch      ca_fast_path(): off, the transfer walk.
        Checked by  the slab-axis, fiber and two-slab-axes rows of the
                    stack parent along axes 1 and 2 in the delivery matrix. */
     if ( ca_func[src->obj_type].attach == ca_stack_func.attach
          && !(flags & CA_KERNEL_WRITE)
          && naxes >= 1 && !in_slab[((CAStack *) src)->k_axis]
-         && ca_fast_paths_enabled() ) {
+         && ca_fast_path(CA_SC_STACK_OUTER_K) ) {
       plan->route = KI_L2_STACK_OUTER_K;
       return CA_ITER_OK;
     }
@@ -1277,17 +1154,20 @@ ki_choose_l2_route (CArray *src, int8_t *axes, int8_t naxes, uint32_t flags,
                    gathering the whole view.
        Speeds up   a read of a fiber of a fake or byte-swap view, or of a
                    lazy monop that only casts, along its innermost axis.
-       Why         no difference measured on a sort along the last axis
-                   of a 2000x2000 fake view.
+       Why         measured switched off alone (CARRAY_SHORTCUTS_OFF) on an
+                   M2 Max / a Xeon 6369P, 2026-10-26: 1.0x / 1.1x on a sort
+                   and 1.05x / 1.2x on a median along the last axis of a
+                   2000x2000 fake view.
        Enters      CA_KERNEL_FIBER_CONTIG, one slab axis, a read walk, and
                    ca_iter_should_per_fiber_fused.
-       Promises    1, 2 and 4, as the CAWindow / CAShift hook above.  A
-                   write takes the transfer walk (promise 3).
-       Switch      ca_fast_paths_enabled(): off, the transfer walk.
+       Promises    1 (the fiber is fetched packed), 2 (its mask is fetched
+                   the same way into fiber_mask_scratch) and 4.  A write
+                   takes the transfer walk (promise 3).
+       Switch      ca_fast_path(): off, the transfer walk.
        Checked by  the fiber rows of the fake parent in the delivery
                    matrix. */
     if ( (flags & CA_KERNEL_FIBER_CONTIG) && naxes == 1
-         && ca_fast_paths_enabled()
+         && ca_fast_path(CA_SC_FIBER_FUSED_CONVERSION)
          && ca_iter_should_per_fiber_fused(src, CA_ITER_SRC_ATTACH, axes[0],
                                            row_bytes[axes[0]], flags) ) {
       plan->route = KI_L2_FIBER_FUSED;
@@ -1588,16 +1468,19 @@ ki_open_l2 (ca_iter_state *st, CArray *src, ca_slab_policy_t policy,
                    and with no SHIFT axis in the view: the outer and
                    non-innermost slab offsets are hoisted and the inner
                    run is copied with memcpy.
-       Why         no difference measured on a row-selected 2-D read.
+       Why         measured switched off alone (CARRAY_SHORTCUTS_OFF) on an
+                   M2 Max, 2026-10-26: 1.6x on a mean over two slab axes of
+                   a 400x200x200 array with rows selected.  Not taken with
+                   one slab axis.
        Enters      at least one slab axis, the innermost slab axis
                    STRIDE, no SHIFT axis.
        Promises    2 and 6 (the mask is copied by ki_take_mask_copy, and
                    only when the view has one).
-       Switch      ca_fast_paths_enabled(): off, the PER_SLAB gather.
+       Switch      ca_fast_path(): off, the PER_SLAB gather.
        Checked by  the two-slab-axes rows of the grid parent in the
                    delivery matrix. */
     ca_size_t slab_bytes = st->slab_elements * src->bytes;
-    int       hoist      = (st->slab_ndim > 0) && ca_fast_paths_enabled()
+    int       hoist      = (st->slab_ndim > 0) && ca_fast_path(CA_SC_PER_SLAB_HOIST)
                            && plan->descs[st->slab_axes_buf[st->slab_ndim - 1]].kind
                               == CA_AXIS_KIND_STRIDE;
     for ( k = 0; hoist && k < src->ndim; k++ ) {
@@ -1745,7 +1628,7 @@ ki_fiber_contig_data (ca_iter_state *st, char *data, ca_size_t step)
     return data;
   }
   if ( st->fiber_data_scratch_cap < need ) {
-    if ( st->fiber_data_scratch ) ki_data_free(st->fiber_data_scratch, st->fiber_data_scratch_cap);
+    if ( st->fiber_data_scratch ) ki_data_free(st->fiber_data_scratch);
     st->fiber_data_scratch     = (char *) ki_data_alloc(st->src->data_type, need);
     st->fiber_data_scratch_cap = need;
   }
@@ -2108,15 +1991,9 @@ ca_iter_state_next_slab_axes_unprotected (ca_iter_state *st,
   /* PER_FIBER_FUSED: there is no whole-view buffer to alias from.  Build
      the fiber region from outer_idx + fiber_axis and call
      ca_xfer_stride(src, ..., GET) directly into fiber_data_scratch; the
-     view's region transfer (out-of-bounds filling for CAWindow / CAShift,
-     the conversion for a fake or byte-swap view) delivers it in one
-     pass.
-
-     last_data_off carries the fiber region's outer footprint so
-     sync_slab can reconstruct the same region for WRITE PUT.  Encode
-     it as the linear outer_idx position scaled by fiber_axis stride
-     equivalence; for PER_FIBER_FUSED sync_slab reads outer_idx state
-     directly rather than data_off so the value is informational. */
+     view's region transfer (the conversion for a fake, byte-swap or
+     single-cast lazy view) delivers it in one pass.  The route is read
+     only, so nothing is put back; last_data_off is not used. */
   if ( st->alias_mode == CA_ITER_ALIAS_PER_FIBER_FUSED ) {
     ca_size_t  fiber_n     = st->slab_dims[0];
     ca_size_t  need        = fiber_n * st->bytes;
@@ -2126,16 +2003,13 @@ ca_iter_state_next_slab_axes_unprotected (ca_iter_state *st,
     ca_size_t  counts[CA_RANK_MAX];
 
     if ( st->fiber_data_scratch_cap < need ) {
-      if ( st->fiber_data_scratch ) ki_data_free(st->fiber_data_scratch, st->fiber_data_scratch_cap);
+      if ( st->fiber_data_scratch ) ki_data_free(st->fiber_data_scratch);
       st->fiber_data_scratch     = (char *) ki_data_alloc(st->src->data_type, need);
       st->fiber_data_scratch_cap = need;
     }
 
     /* Build fiber region: fiber_axis spans the full fiber, all other
-       axes pinned to outer_idx position (count=1).  Cache starts[] in
-       state so sync_slab can rebuild the same region for WRITE PUT
-       (= captured BEFORE the outer_idx advance below, the same hazard as
-       last_data_off; see sync_slab). */
+       axes pinned to outer_idx position (count=1). */
     {
       int8_t op = 0;
       for ( int8_t k = 0; k < nd; k++ ) {
@@ -2147,7 +2021,6 @@ ca_iter_state_next_slab_axes_unprotected (ca_iter_state *st,
           counts[k] = 1;
           op++;
         }
-        st->fiber_region_starts[k] = starts[k];
       }
     }
 
@@ -2276,27 +2149,6 @@ ca_iter_state_sync_slab_unprotected (ca_iter_state *st)
    * instead of reusing -- separate phase, separate design.
    * ====================================================================== */
 
-  /* PER_FIBER_FUSED write: the author
-     wrote into fiber_data_scratch and there is no whole-view buffer
-     to xfer_all PUT.  Rebuild the same fiber region from cached
-     fiber_region_starts[] (= captured pre-advance in next_slab_axes,
-     the same hazard as last_data_off) and call ca_xfer_stride(src, ...,
-     PUT), which puts the fiber back through the view's region transfer
-     in one pass. */
-  if ( st->alias_mode == CA_ITER_ALIAS_PER_FIBER_FUSED ) {
-    ca_size_t fiber_n = st->slab_dims[0];
-    int8_t    nd      = st->ndim;
-    ca_size_t counts[CA_RANK_MAX];
-    for ( int8_t k = 0; k < nd; k++ ) {
-      counts[k] = (k == st->fiber_axis) ? fiber_n : 1;
-    }
-    ca_xfer_stride(st->src, st->fiber_region_starts, counts,
-                   st->fiber_native_strides,
-                   st->fiber_data_scratch, CA_XFER_PUT);
-    st->write_dirty = 0;
-    return;
-  }
-
   /* Per-fiber gather path scatter.
      When next_slab_axes gathered the fiber into fiber_data_scratch
      (= naxes==1 + slab_strides[0] != bytes), scatter it back to the
@@ -2358,9 +2210,9 @@ ca_iter_state_sync_slab_unprotected (ca_iter_state *st)
 static VALUE ca_iter_finish_sync (VALUE arg);
 
 static VALUE
-ki_sync_detach_root (VALUE root)
+ki_sync_detach (VALUE ca)
 {
-  ca_sync_detach((CArray *) root);
+  ca_sync_detach((CArray *) ca);
   return Qnil;
 }
 
@@ -2389,7 +2241,7 @@ ca_iter_state_finish (ca_iter_state *st)
          at init.  ca_detach, or ca_sync_detach on a WRITE walk.
        - else (alias paths): src was attached at init, detach. */
   if ( st->scratch_ptr ) {
-    ki_data_free(st->scratch_ptr, st->scratch_cap);
+    ki_data_free(st->scratch_ptr);
     st->scratch_ptr = NULL;
     st->scratch_cap = 0;
   }
@@ -2399,7 +2251,7 @@ ca_iter_state_finish (ca_iter_state *st)
   }
   /* The per-fiber scratch. */
   if ( st->fiber_data_scratch ) {
-    ki_data_free(st->fiber_data_scratch, st->fiber_data_scratch_cap);
+    ki_data_free(st->fiber_data_scratch);
     st->fiber_data_scratch     = NULL;
     st->fiber_data_scratch_cap = 0;
   }
@@ -2422,7 +2274,7 @@ ca_iter_state_finish (ca_iter_state *st)
   }
   /* The STACK tile cache. */
   if ( st->stack_tile_cache ) {
-    ki_data_free(st->stack_tile_cache, 0);
+    ki_data_free(st->stack_tile_cache);
     st->stack_tile_cache = NULL;
     st->stack_tile_cap   = 0;
     st->stack_tile_pos   = 0;
@@ -2461,7 +2313,7 @@ ca_iter_state_finish (ca_iter_state *st)
          block, a view lending no memory) gave a buffer of its own. */
       if ( write ) {
         /* protect: frees the iterator's own copy before the raise passes on */
-        rb_protect(ki_sync_detach_root, (VALUE) root, &tag);
+        rb_protect(ki_sync_detach, (VALUE) root, &tag);
       }
       else {
         ca_detach(root);
@@ -2471,8 +2323,15 @@ ca_iter_state_finish (ca_iter_state *st)
       /* alias path (CONTIG/STRIDED for CAStride family): we attached
          src directly at init, so detach it here.  A SRC_ATTACH walk owns
          its own scratch (alias_mode = NONE, freed above) and attached
-         nothing to detach. */
-      ca_detach(src);
+         nothing to detach.  A write walk syncs first: an entity whose
+         attach hands out a copy (a cold one such as a CAObject mask)
+         keeps what was written only through its sync slot. */
+      if ( write ) {
+        rb_protect(ki_sync_detach, (VALUE) src, &tag);
+      }
+      else {
+        ca_detach(src);
+      }
     }
     if ( own ) {
       if ( ca_is_object_type(own) ) {
@@ -2554,18 +2413,20 @@ typedef struct {
      Layer       the exits (promise 4): which walks run next_slab /
                  sync_slab under rb_protect.
      Speeds up   walks that cannot raise there: they skip rb_protect.
-     Why         about 1.5x on a per-axis sum over 200k short fibers.
+     Why         measured switched off alone (CARRAY_SHORTCUTS_OFF) on an
+                 M2 Max / a Xeon 6369P, 2026-10-26: 1.55x / 1.4x on a
+                 per-axis sum over 200k short fibers.
      Enters      the route is not PER_FIBER_FUSED and the walk does not
                  write back out of scratch.
      Promises    4 (a walk left out cannot raise between init and finish).
-     Switch      ca_fast_paths_enabled(): off, every walk is protected.
+     Switch      ca_fast_path(): off, every walk is protected.
      Checked by  test_iter_raise_cleanup.rb; the raise rows of
                  test_iter_delivery_detectors.rb. */
 static void
 ca_iter_mark_walk_may_raise (ca_iter_state *st)
 {
   if ( st == NULL ) return;
-  if ( ! ca_fast_paths_enabled() ) {
+  if ( ! ca_fast_path(CA_SC_PROTECT_ONLY_MAY_RAISE) ) {
     /* the general path protects every walk */
     st->flags |= CA_ITER_FLAG_WALK_MAY_RAISE;
     return;
@@ -2578,8 +2439,8 @@ ca_iter_mark_walk_may_raise (ca_iter_state *st)
             && (st->scratch_ptr != NULL
                 || st->src_kind == CA_ITER_SRC_ATTACH) ) {
     /* writes back out of iterator-owned scratch, through the source's
-       transfer (ki_scratch_push_changed: ca_xfer_addrs / ca_xfer_all PUT)
-       or the descriptor scatter.  A write into aliased memory needs no
+       transfer (ki_scratch_push_changed: the changed cells by
+       ca_xfer_addrs PUT).  A write into aliased memory needs no
        push-back at all: sync_slab returns at once. */
     st->flags |= CA_ITER_FLAG_WALK_MAY_RAISE;
   }
@@ -2919,6 +2780,32 @@ ca_iter_ensure (int32_t n, ca_iter_state *states,
   return rb_ensure(body, arg, ca_iter_ensure_close, (VALUE) &e);
 }
 
+/* ca_iter_ensure over the object array ca, recorded as being computed
+   over (ca_computing_run) for the length of the body.  The record is taken
+   inside the ensure, so a refusal closes the states as a raise from the
+   body does. */
+typedef struct {
+  CArray *ca;
+  VALUE (*body)(VALUE);
+  VALUE arg;
+} ca_iter_computing_t;
+
+static VALUE
+ca_iter_computing_body (VALUE arg)
+{
+  ca_iter_computing_t *c = (ca_iter_computing_t *) arg;
+  return ca_computing_run(1, &c->ca, c->body, c->arg);
+}
+
+VALUE
+ca_iter_ensure_computing (CArray *ca, int32_t n, ca_iter_state *states,
+                          VALUE (*body)(VALUE), VALUE arg)
+{
+  ca_iter_computing_t c;
+  c.ca = ca; c.body = body; c.arg = arg;
+  return ca_iter_ensure(n, states, ca_iter_computing_body, (VALUE) &c);
+}
+
 #ifdef CARRAY_DEV_BUILD
 /* ============================================================
  * smoke surface (dev-only, stripped in release)
@@ -3729,7 +3616,7 @@ rb_t1_smoke_remap_read_strided (VALUE klass, VALUE vref, VALUE vidx)
 
 /* WRITE smoke: fill view's slab buffer with `val` (float64), let
    sync_slab send the changed cells back to ref through the view
-   (ki_scratch_push_changed: ca_xfer_addrs or ca_xfer_all PUT). */
+   (ki_scratch_push_changed: ca_xfer_addrs PUT). */
 static VALUE
 rb_t1_smoke_remap_write_fill_f64 (VALUE klass, VALUE vref, VALUE vidx,
                                   VALUE vval)
@@ -4223,8 +4110,6 @@ rb_ki_buffers_out (VALUE klass)
 void
 Init_ca_kernel_iterator (void)
 {
-  ki_kept_key = rb_ractor_local_storage_ptr_newkey(&ki_kept_type);
-
 #ifdef CARRAY_DEV_BUILD
   /* ==== smoke surface registrations (dev-only, stripped in release) ====
    * All `t1_smoke_*`, `caf_smoke_*`,