carray 3.0.2 → 3.0.4

data/ext/ca_obj_select_axis.c

@@ -12,12 +12,13 @@
     - single INDIRECT axis (boolean), other axes AP (nil/Integer/Range)
     - parent must be an entity CArray (no CAStride parent)
     - selector copied at construction (fully static, fragility-free)
-    - selector must not have a mask (hard reject)
+    - a masked selector cell selects nothing (same rule as CASelect)
     - slab copy uses straightforward nested-loop memcpy (no SIMD fast paths)
 
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_select_snapshot */
 
 typedef struct {
   /* CAView prefix (mirrors carray.h ca_virtual layout) */
@@ -112,9 +113,11 @@ static int8_t CA_OBJ_SELECT_AXIS;
 
 /* Benchmark-only bypass flag: when non-zero, rb_ca_grid skips the
    CASelectAxis dispatch hook and falls through to the pre-CSA CAGrid path.
-   Exposed to Ruby as CArray._csa_bypass=.  Production code never touches it. */
+   Exposed to Ruby as CArray._csa_bypass= in development builds.
+   Production code never touches it. */
 int ca_csa_dispatch_bypass = 0;
 
+#ifdef CARRAY_DEV_BUILD
 static VALUE
 rb_ca_s_csa_bypass_eq (VALUE klass, VALUE val)
 {
@@ -129,6 +132,7 @@ rb_ca_s_csa_bypass_p (VALUE klass)
   (void) klass;
   return ca_csa_dispatch_bypass ? Qtrue : Qfalse;
 }
+#endif
 
 static VALUE rb_cCASelectAxis;
 static VALUE rb_cCASelectAxisMask;
@@ -175,22 +179,18 @@ ca_select_axis_setup (CASelectAxis *ca, CArray *parent, int8_t indirect_axis,
              (int) indirect_axis,
              (long long) parent->dim[indirect_axis]);
   }
-  if ( ca_has_mask(selector) ) {
-    rb_raise(rb_eArgError,
-             "CASelectAxis: selector boolean array must not have a mask. "
-             "Use `selector.strip_mask(false)` etc. to flatten first.");
-  }
-
   /* Validate AP axes */
   for ( k = 0; k < ndim; k++ ) {
     if ( k == indirect_axis ) continue;
     if ( ap_step[k] == 0 ) {
       rb_raise(rb_eArgError, "CASelectAxis: ap_step[%d] is 0", (int) k);
     }
-    if ( ap_count[k] <= 0 ) {
-      rb_raise(rb_eArgError, "CASelectAxis: ap_count[%d] must be positive", (int) k);
+    if ( ap_count[k] < 0 ) {
+      rb_raise(rb_eArgError, "CASelectAxis: ap_count[%d] is negative", (int) k);
     }
-    {
+    /* A zero count (an axis of length zero) selects no cells: the view is
+       empty and there is no first or last index to check. */
+    if ( ap_count[k] > 0 ) {
       ca_size_t start_v = ap_start[k];
       ca_size_t last_v  = ap_start[k] + (ap_count[k] - 1) * ap_step[k];
       if ( start_v < 0 || start_v >= parent->dim[k] ) {
@@ -222,8 +222,9 @@ ca_select_axis_setup (CASelectAxis *ca, CArray *parent, int8_t indirect_axis,
 
   /* Copy selector (view owns its own copy; immune to external mutation).
      The selector is small (1 axis length), so the copy cost is acceptable,
-     and it avoids the fragility CASelect has from live references. */
-  ca->selector = ca_copy(selector);
+     and it avoids the fragility CASelect has from live references.  A
+     masked selector cell selects nothing, as it does for CASelect. */
+  ca->selector = ca_select_snapshot(selector);
 
   /* Allocate dim and AP arrays (pool path: already wired by pool_init). */
   if ( ! ca->_pool ) {
@@ -310,6 +311,7 @@ ca_select_axis_new (CArray *parent, int8_t indirect_axis,
                     CArray *selector,
                     ca_size_t *ap_start, ca_size_t *ap_count, ca_size_t *ap_step)
 {
+  /* check: the callers (clone, create_mask) pass an existing view's checked selector */
   CASelectAxis *ca = (CASelectAxis *) ca_array_alloc(CA_OBJ_SELECT_AXIS, parent->ndim);
   ca_select_axis_setup(ca, parent, indirect_axis, selector,
                        ap_start, ap_count, ap_step);
@@ -548,6 +550,7 @@ static void
 ca_select_axis_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;
   CASelectAxis *ca = (CASelectAxis *) ap;
   CArray   *parent = ca->parent;
   int8_t    ndim = ca->ndim;
@@ -588,6 +591,7 @@ ca_select_axis_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     ca_size_t idx[CA_RANK_MAX], doff = 0, base = 0;
     for (k = 0; k < ndim; k++) base += starts[k] * cnative[k];
     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 coff = base, cidx[CA_RANK_MAX];
       for (k = 0; k < ndim; k++) coff += idx[k] * strides[k];
@@ -671,6 +675,7 @@ ca_select_axis_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
      ca_xfer_stride/ca_xfer_addrs. */
   for (k = 0; k < ndim; k++) o[k] = 0;
 
+  /* empty: the slot returns on an empty region at its entry */
   while (1) {
     ca_size_t pbase = 0, doff = 0;
     for (k = 0; k < inner; k++) {
@@ -710,25 +715,34 @@ ca_select_axis_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   }
 }
 
+/* A parent with no memory to lend (ca_parent_lends_no_memory) is never
+   attached: the view owns its buffer, filled and drained through xfer_all,
+   which asks the parent for the selected cells only.  The predicate asks
+   what the parent is, not whether it is attached now, so attach, sync and
+   detach all take the same branch. */
+
 static void
 ca_select_axis_func_allocate (void *ap)
 {
   CASelectAxis *ca = (CASelectAxis *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  if ( ! ca_parent_lends_no_memory(ca->parent) ) {
+    ca_attach(ca->parent);
+  }
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
-/* attach / sync / copy_data / sync_data / fill_data all go through the
-   common descriptor engine.  This file holds only describe_axes for
-   translating CSA state into the shared descriptor; the engine in
-   ext/ca_axis_dispatch.c does the rest. */
-
 static void
 ca_select_axis_func_attach (void *ap)
 {
   CASelectAxis *ca = (CASelectAxis *) ap;
   ca_axis_desc_t desc[CA_RANK_MAX];
   ca_size_t      pdims[CA_RANK_MAX];
+
+  if ( ca_parent_lends_no_memory(ca->parent) ) {
+    ca_axis_view_attach_owned(ca);
+    return;
+  }
+
   ca_attach(ca->parent);
   ca_select_axis_describe_axes(ca, desc, pdims);
   ca->ptr = ca_axis_dispatch_attach(ca->parent, pdims, desc, ca->ndim,
@@ -741,6 +755,12 @@ ca_select_axis_func_sync (void *ap)
   CASelectAxis *ca = (CASelectAxis *) ap;
   ca_axis_desc_t desc[CA_RANK_MAX];
   ca_size_t      pdims[CA_RANK_MAX];
+
+  if ( ca_parent_lends_no_memory(ca->parent) ) {
+    ca_axis_view_sync_owned(ca);
+    return;
+  }
+
   ca_select_axis_describe_axes(ca, desc, pdims);
   ca_axis_dispatch_scatter(ca->parent, pdims, desc, ca->ndim, ca->bytes,
                            ca->elements, ca->ptr);
@@ -756,16 +776,16 @@ ca_select_axis_func_detach (void *ap)
     ca->ptr = NULL;
   }
   /* indices[] lives for the view's lifetime; freed in free_ca_select_axis. */
-  ca_detach(ca->parent);
+  if ( ! ca_parent_lends_no_memory(ca->parent) ) {
+    ca_detach(ca->parent);
+  }
 }
 
-/* xfer_all: fast path on parent->ptr, with no silent transitive attach
-   of the parent.  A cold parent uses a proper 2-pass (materialise the
-   parent into scratch, expose it as parent->ptr, run the fast path, then
-   write scratch back for PUT). */
+/* The transfer against parent->ptr, for ca_axis_view_xfer_all. */
 static void
-ca_select_axis_func_run_fast_path (CASelectAxis *ca, char *data, int dir)
+ca_select_axis_func_run_fast_path (void *ap, char *data, int dir)
 {
+  CASelectAxis *ca = (CASelectAxis *) ap;
   ca_axis_desc_t desc[CA_RANK_MAX];
   ca_size_t      pdims[CA_RANK_MAX];
   ca_select_axis_describe_axes(ca, desc, pdims);
@@ -781,27 +801,7 @@ ca_select_axis_func_run_fast_path (CASelectAxis *ca, char *data, int dir)
 static void
 ca_select_axis_func_xfer_all (void *ap, void *data, int dir)
 {
-  CASelectAxis *ca = (CASelectAxis *) ap;
-  if ( ca->parent->ptr ) {
-    ca_select_axis_func_run_fast_path(ca, (char *) data, dir);
-    return;
-  }
-  /* Proper 2-pass cold fallback. */
-  {
-    volatile VALUE holder;
-    CArray   *parent = ca->parent;
-    ca_size_t plen   = parent->elements * parent->bytes;
-    char     *parent_scratch = ALLOCV_N(char, holder, plen);
-    char     *parent_ptr_saved = parent->ptr;
-    ca_xfer_all(parent, parent_scratch, CA_XFER_GET);
-    parent->ptr = parent_scratch;
-    ca_select_axis_func_run_fast_path(ca, (char *) data, dir);
-    if ( dir == CA_XFER_PUT ) {
-      ca_xfer_all(parent, parent_scratch, CA_XFER_PUT);
-    }
-    parent->ptr = parent_ptr_saved;
-    ALLOCV_END(holder);
-  }
+  ca_axis_view_xfer_all(ap, ca_select_axis_func_run_fast_path, 1, data, dir);
 }
 
 static void
@@ -824,21 +824,17 @@ ca_select_axis_func_fill_data (void *ap, void *val)
     return;
   }
 
-  ca_attach(ca->parent);
+  ca_attach(ca->parent);   /* window: nothing raises inside */
   ca_axis_dispatch_fill_value(ca->parent, pdims, desc, ca->ndim, ca->bytes,
                               ca->elements, val);
-  ca_sync(ca->parent);
-  ca_detach(ca->parent);
+  ca_sync_detach(ca->parent);
 }
 
 static void
 ca_select_axis_func_create_mask (void *ap)
 {
   CASelectAxis *ca = (CASelectAxis *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
+  ca_create_mask(ca->parent);
   ca->mask = ca_select_axis_new(ca->parent->mask, ca->indirect_axis,
                                 ca->selector,
                                 ca->ap_start, ca->ap_count, ca->ap_step);
@@ -878,6 +874,7 @@ rb_ca_select_axis_initialize_copy (VALUE self, VALUE other)
 {
   CASelectAxis *ca, *cs;
   TypedData_Get_Struct(self,  CASelectAxis, &caselectaxis_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CASelectAxis, &caselectaxis_data_type, cs);
   if ( ca_func[CA_OBJ_SELECT_AXIS].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_SELECT_AXIS, cs->parent->ndim);
@@ -887,6 +884,7 @@ rb_ca_select_axis_initialize_copy (VALUE self, VALUE other)
   return self;
 }
 
+#ifdef CARRAY_DEV_BUILD
 /* Debug-only Ruby ctor:
    CASelectAxis._new_debug(parent, indirect_axis, selector,
                             ap_start_arr, ap_count_arr, ap_step_arr)
@@ -900,6 +898,7 @@ rb_ca_select_axis_s_new_debug (VALUE klass, VALUE rparent, VALUE rindirect,
                                 VALUE rap_count, VALUE rap_step)
 {
   CArray *parent, *selector;
+  /* fits: an axis number from the view that made it */
   int8_t indirect_axis = (int8_t) NUM2INT(rindirect);
   int8_t ndim;
   int8_t k;
@@ -937,6 +936,7 @@ rb_ca_select_axis_s_new_debug (VALUE klass, VALUE rparent, VALUE rindirect,
   rb_ivar_set(obj, rb_intern("_selector"), rselector);
   return obj;
 }
+#endif
 
 /* ------------------------------------------------------------------- */
 /* Indexer dispatch hook: called from rb_ca_grid                       */
@@ -970,15 +970,15 @@ rb_ca_select_axis_eligible_p (int argc, VALUE *argv, VALUE self)
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
   if ( argc != ca->ndim ) return 0;
 
-  /* axis 0 is the boolean (indirect).  Walk rest; require nil/Integer/Range. */
+  /* axis 0 is the boolean (indirect).  The rest are read as the indexer
+     reads them; a run of more than one step, or of no cells, goes to
+     CAGrid. */
   for ( i = 1; i < argc; i++ ) {
     VALUE arg = argv[i];
-    if ( NIL_P(arg) ) continue;
-    if ( FIXNUM_P(arg) ) continue;
-    if ( TYPE(arg) == T_DATA ) return 0;   /* CArray at axis > 0 → bail */
-    if ( rb_obj_is_kind_of(arg, rb_cRange) ) continue;
-    if ( rb_obj_is_kind_of(arg, rb_cInteger) ) continue;
-    return 0;
+    ca_size_t start, count, step;
+    if ( rb_obj_is_carray(arg) ) return 0;   /* CArray at axis > 0 → bail */
+    ca_index_axis_key(arg, ca->dim[i], i, &start, &count, &step);
+    if ( step != 1 || count < 1 ) return 0;
   }
 
   return 1;
@@ -1010,45 +1010,9 @@ rb_ca_select_axis (int argc, VALUE *argv, VALUE self)
   for ( i = 0; i < argc; i++ ) {
     VALUE arg = argv[i];
 
-    if ( NIL_P(arg) ) {
-      ap_start[i] = 0;
-      ap_count[i] = parent->dim[i];
-      ap_step[i]  = 1;
-    }
-    else if ( FIXNUM_P(arg) || rb_obj_is_kind_of(arg, rb_cInteger) ) {
-      ca_size_t n = NUM2LL(arg);
-      if ( n < 0 ) n += parent->dim[i];
-      if ( n < 0 || n >= parent->dim[i] ) {
-        rb_raise(rb_eIndexError,
-                 "CASelectAxis: index %lld out of range at axis %d",
-                 (long long) n, i);
-      }
-      ap_start[i] = n;
-      ap_count[i] = 1;
-      ap_step[i]  = 1;
-    }
-    else if ( rb_obj_is_kind_of(arg, rb_cRange) ) {
-      VALUE rfirst = rb_funcall(arg, rb_intern("first"), 0);
-      VALUE rlast  = rb_funcall(arg, rb_intern("last"),  0);
-      int exclusive = RTEST(rb_funcall(arg, rb_intern("exclude_end?"), 0));
-      ca_size_t a = NUM2LL(rfirst);
-      ca_size_t b = NUM2LL(rlast);
-      if ( a < 0 ) a += parent->dim[i];
-      if ( b < 0 ) b += parent->dim[i];
-      ca_size_t cnt = exclusive ? (b - a) : (b - a + 1);
-      if ( cnt <= 0 ) {
-        rb_raise(rb_eIndexError,
-                 "CASelectAxis: empty range at axis %d", i);
-      }
-      if ( a < 0 || a >= parent->dim[i] ||
-           (a + cnt - 1) < 0 || (a + cnt - 1) >= parent->dim[i] ) {
-        rb_raise(rb_eIndexError,
-                 "CASelectAxis: range [%lld..%lld] out of bounds at axis %d",
-                 (long long) a, (long long) (a + cnt - 1), i);
-      }
-      ap_start[i] = a;
-      ap_count[i] = cnt;
-      ap_step[i]  = 1;
+    if ( ! rb_obj_is_carray(arg) ) {
+      ca_index_axis_key(arg, parent->dim[i], i,
+                        &ap_start[i], &ap_count[i], &ap_step[i]);
     }
     else if ( rb_obj_is_carray(arg) && rb_ca_is_boolean_type(arg) ) {
       TypedData_Get_Struct(arg, CArray, &carray_data_type, selector);
@@ -1188,7 +1152,7 @@ rb_ca_select_axis_dispatch_attach_debug (VALUE self)
   TypedData_Get_Struct(self, CASelectAxis, &caselectaxis_data_type, ca);
   ca_select_axis_describe_axes(ca, desc, pdims);
 
-  ca_attach(ca->parent);
+  ca_attach(ca->parent);   /* window: nothing raises inside */
   buf = ca_axis_dispatch_attach(ca->parent, pdims, desc, ca->ndim, ca->bytes,
                                 ca->elements, NULL);
   ca_detach(ca->parent);
@@ -1222,11 +1186,10 @@ rb_ca_select_axis_dispatch_scatter_debug (VALUE self, VALUE in_str)
   ca_size_t pdims[CA_RANK_MAX];
   ca_select_axis_describe_axes(ca, desc, pdims);
 
-  ca_attach(ca->parent);
+  ca_attach(ca->parent);   /* window: nothing raises inside */
   ca_axis_dispatch_scatter(ca->parent, pdims, desc, ca->ndim, ca->bytes,
                            ca->elements, RSTRING_PTR(in_str));
-  ca_sync(ca->parent);
-  ca_detach(ca->parent);
+  ca_sync_detach(ca->parent);
   return Qnil;
 }
 
@@ -1250,11 +1213,10 @@ rb_ca_select_axis_dispatch_fill_value_debug (VALUE self, VALUE val_str)
   ca_size_t pdims[CA_RANK_MAX];
   ca_select_axis_describe_axes(ca, desc, pdims);
 
-  ca_attach(ca->parent);
+  ca_attach(ca->parent);   /* window: nothing raises inside */
   ca_axis_dispatch_fill_value(ca->parent, pdims, desc, ca->ndim, ca->bytes,
                               ca->elements, RSTRING_PTR(val_str));
-  ca_sync(ca->parent);
-  ca_detach(ca->parent);
+  ca_sync_detach(ca->parent);
   return Qnil;
 }
 #endif /* CARRAY_DEV_BUILD */
@@ -1281,9 +1243,11 @@ Init_ca_obj_select_axis (void)
   rb_define_alloc_func(rb_cCASelectAxis, rb_ca_select_axis_s_allocate);
   rb_define_method(rb_cCASelectAxis, "initialize_copy",
                                      rb_ca_select_axis_initialize_copy, 1);
+#ifdef CARRAY_DEV_BUILD
   /* Debug-only ctor for testing; not part of the public API. */
   rb_define_singleton_method(rb_cCASelectAxis, "_new_debug",
                              rb_ca_select_axis_s_new_debug, 6);
+#endif
 
 #ifdef CARRAY_DEV_BUILD
   /* debug accessors (dev-only, stripped in release).
@@ -1300,7 +1264,9 @@ Init_ca_obj_select_axis (void)
                    rb_ca_select_axis_dispatch_fill_value_debug, 1);
 #endif
 
+#ifdef CARRAY_DEV_BUILD
   /* Benchmark-only bypass setter on CArray class. */
   rb_define_singleton_method(rb_cCArray, "_csa_bypass=", rb_ca_s_csa_bypass_eq, 1);
   rb_define_singleton_method(rb_cCArray, "_csa_bypass?", rb_ca_s_csa_bypass_p, 0);
+#endif
 }

data/ext/ca_obj_shift.c

@@ -8,14 +8,15 @@
   sync_data / fill_data / ptr_at_* / fetch_index / store_index) are
   shared with CAWindow's per-axis bounds engine via the `ca_shift_func`
   table, which is built by copying `ca_window_func` and only overriding
-  free / clone / create_mask so that CAShift-typed instances are produced
-  on cloning and mask-projection.
+  clone, so that cloning produces a CAShift.  create_mask is shared: it
+  gives the mask the view's own obj_type.
 
   User surface (CArray#shift) is documented in yard-stubs/ca_obj_shift.rb.
 
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_window_create_bounds_mask */
 #include "ca_obj_face.h"  /* CA_FACE_LIFT_IF_FACE */
 
 /* External: CAWindow's operation table + setup are the basis for CAShift. */
@@ -31,11 +32,13 @@ extern int ca_window_setup (CAWindow *ca, CArray *parent,
    (rb_data_type_t *) cast would write into .rodata and SIGBUS on macOS. */
 static size_t ca_shift_dsize (const void *ap);
 
+extern void ca_window_mark (void *ap);   /* ca_obj_window.c: marks the fill value */
+
 const rb_data_type_t cashift_data_type = {
-    .parent = &caview_data_type,
+    .parent = &cawindow_data_type,
     .wrap_struct_name = "CAShift",
     .function = {
-        .dmark = ca_mark,
+        .dmark = ca_window_mark,
         .dfree = ca_free,
         .dsize = ca_shift_dsize,
         .dcompact = NULL
@@ -44,7 +47,7 @@ const rb_data_type_t cashift_data_type = {
 };
 
 /* CAREFUL: mask TypedData uses ca_free_nop.  The mask CArray is owned
-   by the parent CAShift's `ca->mask` field and freed by free_ca_shift's
+   by the parent CAShift's `ca->mask` field and freed by the shared window free's
    ca_free(ca->mask).  If the wrapped Ruby VALUE (from the `ca.mask`
    accessor / rb_ca_mask_array) also freed it, the result is a
    double-free that explodes under GC stress. */
@@ -105,10 +108,13 @@ ca_shift_setup (CAShift *ca, CArray *parent,
   /* Delegate to CAWindow setup. */
   ca_window_setup((CAWindow *) ca, parent, start, count, bounds, fill);
 
+  if ( ca == NULL ) {                /* checks only, see ca_window_setup */
+    return 0;
+  }
+
   /* Override obj_type so dispatch (ca_func[obj_type]) lands on the
      CAShift-specific table (which differs from CAWindow only in
-     free / clone / create_mask, all forwarding to a CAShift-typed
-     result). */
+     clone). */
   ca->obj_type = CA_OBJ_SHIFT;
 
   return 0;
@@ -118,37 +124,14 @@ CAShift *
 ca_shift_new (CArray *parent, ca_size_t *shift, char *fill, int8_t *roll,
               int fill_mask)
 {
-  CAShift *ca = (CAShift *) ca_array_alloc(CA_OBJ_SHIFT, parent->ndim);
+  CAShift *ca;
+  ca_shift_setup(NULL, parent, shift, fill, roll, fill_mask);
+  ca = (CAShift *) ca_array_alloc(CA_OBJ_SHIFT, parent->ndim);
   ca_shift_setup(ca, parent, shift, fill, roll, fill_mask);
+  ca_fill_or_free((CArray *) ca, ca_window_create_bounds_mask, (VALUE) ca);
   return ca;
 }
 
-/* Free: same fields as CAWindow (same struct).  CAShift goes through
-   ca_window_setup, so the same seven ndim-sized fields live in ca->_pool
-   (fill stays separate). */
-static void
-free_ca_shift (void *ap)
-{
-  CAShift *ca = (CAShift *) ap;
-  if ( ca != NULL ) {
-    ca_free(ca->mask);
-    xfree(ca->fill);              /* always separate (bytes-sized) */
-    if ( ca->_pool ) {
-      ca_array_free(ca);
-    }
-    else {
-      xfree(ca->bounds);
-      xfree(ca->start);
-      xfree(ca->count);
-      xfree(ca->size0);
-      xfree(ca->embed_parent_start);
-      xfree(ca->embed_count);
-      xfree(ca->embed_output_offset);
-      xfree(ca);
-    }
-  }
-}
-
 /* Clone: produce a CAShift (not CAWindow) by rebuilding via setup.
    Recover (shift[], roll[], fill_mask) from current (start[], bounds[]). */
 static void *
@@ -171,73 +154,14 @@ ca_shift_func_clone (void *ap)
     }
   }
 
-  return ca_shift_new(ca->parent, shift, ca->fill, roll, fill_mask);
-}
-
-/* create_mask: produce a CAShift-typed mask (not CAWindow-typed).
-   Following the original ca_shift_func_create_mask semantics:
-   - Ensure parent has mask
-   - Build mask sub-view using same shift/roll, fill = 1 if fill_mask
-     else 0 (i.e. range-outside cells get masked when fill_mask was on,
-     unmasked otherwise) */
-static void
-ca_shift_func_create_mask (void *ap)
-{
-  CAShift *ca = (CAShift *) ap;
-  ca_size_t shift[CA_RANK_MAX];
-  int8_t   roll[CA_RANK_MAX];
-  boolean8_t fill_val;
-  int fill_mask_was_on = 0;
-  int8_t k;
-
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
-
-  for (k = 0; k < ca->ndim; k++) {
-    shift[k] = -ca->start[k];
-    if ( ca->bounds[k] == CA_BOUNDS_PERIODIC ) {
-      roll[k] = 1;
-    } else {
-      roll[k] = 0;
-      if ( ca->bounds[k] == CA_BOUNDS_MASK ) fill_mask_was_on = 1;
-    }
-  }
-
-  /* If MASK policy was set, the mask sub-view should mark out-of-range
-     cells as "masked" (fill value = 1).  Otherwise out-of-range cells
-     get the fill value (fill = 0) and aren't masked. */
-  fill_val = fill_mask_was_on ? 1 : 0;
-
-  /* Build the mask as CAShift with same shift/roll but using fill_mask=0
-     (the mask itself shouldn't recursively create a mask) and fill = 0/1
-     boolean.  Bounds for mask: replace MASK→FILL so the mask values are
-     written, not the mask's mask. */
   {
-    /* Construct mask via direct ca_window_new with adjusted bounds. */
-    uint8_t mbounds[CA_RANK_MAX];
-    ca_size_t mstart[CA_RANK_MAX];
-    ca_size_t mcount[CA_RANK_MAX];
-    CAShift *m;
-    CA_ASSUME(ca->ndim >= 0 && ca->ndim <= CA_RANK_MAX);   /* bound loop over [CA_RANK_MAX] arrays */
-    for (k = 0; k < ca->ndim; k++) {
-      mstart[k] = ca->start[k];
-      mcount[k] = ca->count[k];
-      mbounds[k] = ( ca->bounds[k] == CA_BOUNDS_MASK )
-                       ? CA_BOUNDS_FILL : ca->bounds[k];
-    }
-    /* CAShift-typed mask: allocate, setup as CAWindow with adjusted
-       bounds, bump obj_type. */
-    m = (CAShift *) ca_array_alloc(CA_OBJ_SHIFT, ca->ndim);
-    ca_window_setup((CAWindow *) m, ca->parent->mask,
-                    mstart, mcount, mbounds, (char *) &fill_val);
-    m->obj_type = CA_OBJ_SHIFT;
-    ca->mask = (CArray *) m;
+    CAShift *cp = ca_shift_new(ca->parent, shift, ca->fill, roll, fill_mask);
+    cp->mask_owner = ca->mask_owner;
+    return cp;
   }
-  (void) shift; (void) roll;   /* recovered above but unused in this block */
 }
 
+
 /* ------------------------------------------------------------------- */
 
 VALUE
@@ -319,9 +243,12 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
     fill_mask = 1;
   }
   else {
-    rcs = rb_cscalar_new_with_value(ca->data_type, ca->bytes, rfval);
+    /* The fill is a value of the array (a struct, an instant for a Face):
+       rb_ca_obj2ptr writes it as one cell of the storage. */
+    rcs = rb_cscalar_new(ca_strip_face(ca)->data_type, ca->bytes, NULL);
     TypedData_Get_Struct(rcs, CScalar, &cscalar_data_type, cs);
     fill = cs->ptr;
+    rb_ca_obj2ptr(self, rfval, fill);
   }
 
   if ( NIL_P(rroll) ) {
@@ -366,6 +293,7 @@ rb_ca_shift_initialize_copy (VALUE self, VALUE other)
   int8_t k;
 
   TypedData_Get_Struct(self,  CAShift, &cashift_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CAShift, &cashift_data_type, cs);
 
   /* Recover shift/roll/fill_mask from cs (same scheme as clone). */
@@ -384,6 +312,10 @@ rb_ca_shift_initialize_copy (VALUE self, VALUE other)
     ca_array_pool_alloc(ca, CA_OBJ_SHIFT, cs->ndim);
   }
   ca_shift_setup(ca, cs->parent, shift, cs->fill, roll, fill_mask);
+  ca_window_create_bounds_mask((VALUE) ca);
+  /* a copy of a mask over a stand-in gives way to the parent's mask as
+     the original does */
+  ca->mask_owner = cs->mask_owner;
 
   return self;
 }
@@ -395,12 +327,10 @@ rb_ca_shift_initialize_copy (VALUE self, VALUE other)
 void
 Init_ca_obj_shift (void)
 {
-  /* Build the CAShift op table by copying CAWindow's and overriding
-     just the slots that need to produce CAShift-typed results. */
+  /* Build the CAShift op table by copying CAWindow's; only clone has to
+     rebuild a CAShift. */
   ca_shift_func = ca_window_func;
-  ca_shift_func.free_object = free_ca_shift;
   ca_shift_func.clone       = ca_shift_func_clone;
-  ca_shift_func.create_mask = ca_shift_func_create_mask;
 
   rb_cCAShift = rb_define_class("CAShift", rb_cCAWindow);
   rb_cCAShiftMask = rb_define_class("CAShiftMask", rb_cCAShift);