carray 3.0.2 → 3.0.4

data/ext/ca_obj_window.c

@@ -30,6 +30,7 @@
 #include "carray.h"
 #include "ca_composite_dispatch.h"
 #include "ca_obj_face.h"  /* CA_FACE_LIFT_IF_FACE, used by rb_ca_window */
+#include "carray_internal.h"   /* ca_axis_view_attach_owned */
 
 /* should not be static variable as used by CAIteratorWindow */
 
@@ -82,11 +83,23 @@ ca_window_pool_init (void *ap, int8_t ndim)
   ca->dim                 = ca->count;   /* alias; ca_window_setup re-sets */
 }
 
+/* A window over an object array keeps its fill value, a VALUE, in a
+   buffer of its own, so it marks it; ca_mark covers only ca->ptr. */
+void
+ca_window_mark (void *ap)
+{
+  CAWindow *ca = (CAWindow *) ap;
+  ca_mark(ca);
+  if ( ca->fill != NULL && ca_is_object_type(ca) ) {
+    rb_gc_mark(*(VALUE *) ca->fill);
+  }
+}
+
 const rb_data_type_t cawindow_data_type = {
     .parent = &caview_data_type,
     .wrap_struct_name = "CAWindow",
     .function = {
-        .dmark = ca_mark,
+        .dmark = ca_window_mark,
         .dfree = ca_free,
         .dsize = ca_window_dsize,
         .dcompact = NULL
@@ -255,10 +268,19 @@ ca_window_compose_fold (void *win_ap,
    for the window-over-parent mapping (ca_window_compose_fold) and composes
    f through it (ca_stride_compose_through).  Declines (returns 0) when the
    window is not interior-only, making the window the fold boundary. */
+static void ca_window_mask_current (CAWindow *ca);
+static int  ca_window_mask_reads_standin (CAWindow *ca);
+
 static int
 ca_window_func_fold_stride (void *ap, ca_fold_t *f, void **next_parent)
 {
   CAWindow *w = (CAWindow *) ap;
+  ca_window_mask_current(w);
+  /* A write folded through to a stand-in would bypass the settle in this
+     window's write slots. */
+  if ( ca_window_mask_reads_standin(w) ) {
+    return 0;
+  }
   ca_size_t synth_strides[CA_RANK_MAX];
   ca_size_t synth_base;
   ca_size_t *synth_dim;
@@ -314,7 +336,9 @@ static void
 ca_window_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;
   CAWindow *w = (CAWindow *) ap;
+  ca_window_mask_current(w);
   CArray   *parent = w->parent;
   int8_t    ndim = w->ndim;
   int8_t    inner = ndim - 1;
@@ -355,6 +379,7 @@ ca_window_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] * wnative[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 woff = base, widx[CA_RANK_MAX];
       for (k = 0; k < ndim; k++) woff += idx[k] * strides[k];
@@ -658,7 +683,6 @@ ca_window_setup (CAWindow *ca, CArray *parent,
   ca_size_t *dim;
   ca_size_t bytes, elements;
   int i;
-  int any_mask;
 
   data_type = parent->data_type;
   ndim      = parent->ndim;
@@ -667,11 +691,38 @@ ca_window_setup (CAWindow *ca, CArray *parent,
 
   elements = 1;
   for (i=0; i<ndim; i++) {
-    if ( count[i] <= 0 ) {
+    if ( count[i] < 0 ) {            /* zero is an empty window */
       rb_raise(rb_eIndexError,
-               "invalid size for %i-th dimension (negative or zero)", i);
+               "invalid size for %i-th dimension (negative)", i);
+    }
+  }
+  elements = ca_shape_elements(ndim, count, bytes);
+
+  /* Under "ruby" or "strict" an index outside the parent raises.  The
+     parent's shape is fixed, so a window that reaches outside it would raise
+     on every whole read or write, and a write would have changed the cells
+     before the one that raised.  It is refused here instead. */
+  for (i=0; i<ndim; i++) {
+    ca_size_t lo, hi, size = dim[i];
+    if ( count[i] == 0 ) {
+      continue;
+    }
+    lo = start[i];
+    hi = start[i] + count[i] - 1;
+    if ( bounds[i] == CA_BOUNDS_STRICT ) {
+      if ( lo < 0 ) ca_index_out_of_range(lo, size, "index");
+      if ( hi >= size ) ca_index_out_of_range(hi, size, "index");
     }
-    elements *= count[i];
+    else if ( bounds[i] == CA_BOUNDS_RUBY ) {
+      if ( lo < -size ) ca_index_out_of_range(lo, size, "index");
+      if ( hi >= size ) ca_index_out_of_range(hi, size, "index");
+    }
+  }
+
+  /* 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  = CA_OBJ_WINDOW;
@@ -687,6 +738,8 @@ ca_window_setup (CAWindow *ca, CArray *parent,
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
+  ca->mask_standin = NULL;
+  ca->mask_owner   = NULL;
   /* Pool path: bounds/start/count/size0/embed_* are already wired into
      ca->_pool by ca_window_pool_init.  Legacy path: ALLOC_N each.  `fill`
      is bytes-sized (not ndim) so it stays on its own ALLOC_N in both
@@ -727,27 +780,36 @@ ca_window_setup (CAWindow *ca, CArray *parent,
     }
   }
 
-  /* Mask is needed if ANY axis uses MASK policy (per-axis). */
-  any_mask = 0;
-  for (i=0; i<ndim; i++) {
+  return 0;
+}
+
+/* A window with an axis of MASK bounds has a mask of its own.  Making it
+   asks the parent for its mask, which can raise (a CAObject answers in
+   Ruby), so the constructor makes it after the setup under
+   ca_fill_or_free; see ca_view_inherit_mask. */
+VALUE
+ca_window_create_bounds_mask (VALUE view)
+{
+  CAWindow *ca = (CAWindow *) view;
+  int8_t i;
+  for (i = 0; i < ca->ndim; i++) {
     if ( ca->bounds[i] == CA_BOUNDS_MASK ) {
-      any_mask = 1;
+      ca_create_mask((CArray *) ca);
       break;
     }
   }
-  if ( any_mask ) {
-    ca_create_mask(ca);
-  }
-
-  return 0;
+  return Qnil;
 }
 
 CAWindow *
 ca_window_new (CArray *parent,
                ca_size_t *start, ca_size_t *count, uint8_t *bounds, char *fill)
 {
-  CAWindow *ca = (CAWindow *) ca_array_alloc(CA_OBJ_WINDOW, parent->ndim);
+  CAWindow *ca;
+  ca_window_setup(NULL, parent, start, count, bounds, fill);
+  ca = (CAWindow *) ca_array_alloc(CA_OBJ_WINDOW, parent->ndim);
   ca_window_setup(ca, parent, start, count, bounds, fill);
+  ca_fill_or_free((CArray *) ca, ca_window_create_bounds_mask, (VALUE) ca);
   return ca;
 }
 
@@ -757,6 +819,7 @@ free_ca_window (void *ap)
   CAWindow *ca = (CAWindow *) ap;
   if ( ca != NULL ) {
     ca_free(ca->mask);
+    ca_free(ca->mask_standin);
     xfree(ca->fill);              /* always separate (bytes-sized) */
     if ( ca->_pool ) {
       /* bounds/start/count/size0/embed_* all live in ca->_pool. */
@@ -796,7 +859,39 @@ static void *
 ca_window_func_clone (void *ap)
 {
   CAWindow *ca = (CAWindow *) ap;
-  return ca_window_new(ca->parent, ca->start, ca->count, ca->bounds, ca->fill);
+  CAWindow *cp = ca_window_new(ca->parent, ca->start, ca->count, ca->bounds,
+                               ca->fill);
+  cp->mask_owner = ca->mask_owner;
+  return cp;
+}
+
+/* A mask window over its owner's stand-in (ca_mask_standin_current): what
+   it reads from now on. */
+static void
+ca_window_mask_current (CAWindow *ca)
+{
+  CAWindow *o = (CAWindow *) ca->mask_owner;
+  if ( o != NULL ) {
+    ca->parent = ca_mask_standin_current((CArray *) ca, ca->parent, o->parent,
+                                         o->mask_standin);
+  }
+}
+
+static int
+ca_window_mask_reads_standin (CAWindow *ca)
+{
+  CAWindow *o = (CAWindow *) ca->mask_owner;
+  return o != NULL && o->mask_standin != NULL && ca->parent == o->mask_standin;
+}
+
+/* After a write that may have put a true into the stand-in: it goes on to
+   the parent's mask. */
+static void
+ca_window_mask_settle (CAWindow *ca)
+{
+  if ( ca_window_mask_reads_standin(ca) ) {
+    ca_mask_standin_settle(((CAWindow *) ca->mask_owner)->parent, ca->parent);
+  }
 }
 
 /* Per-cell access.  GET and PUT share the bound-normalised index walk; an OOB
@@ -806,6 +901,7 @@ static void
 ca_window_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
 {
   CAWindow *ca = (CAWindow *) ap;
+  ca_window_mask_current(ca);
   ca_size_t *start = ca->start;
   ca_size_t *size0 = ca->size0;
   ca_size_t idx0[CA_RANK_MAX];
@@ -834,6 +930,7 @@ ca_window_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
                            void *data, int dir)
 {
   CAWindow *ca = (CAWindow *) ap;
+  ca_window_mask_current(ca);
   ca_size_t *start = ca->start;
   ca_size_t *size0 = ca->size0;
   char      *d = (char *) data;
@@ -952,13 +1049,53 @@ ca_window_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
   ALLOCV_END(h1);
 }
 
+/* Whether this window over a parent with no memory to lend owns its buffer
+   rather than attaching the parent.  Only FILL / MASK bounds qualify: their
+   xfer_stride hands the parent one region per row, where the other bounds
+   go cell by cell -- for a Ruby-backed parent, a call per cell, which costs
+   more than producing the parent once.  Both inputs are fixed for the
+   life of the view, so attach, sync and detach take the same branch. */
+static int
+ca_window_owns_buffer (CAWindow *ca)
+{
+  int8_t k;
+  for ( k = 0; k < ca->ndim; k++ ) {
+    if ( ca->bounds[k] != CA_BOUNDS_FILL && ca->bounds[k] != CA_BOUNDS_MASK ) {
+      return 0;
+    }
+  }
+  return ca_parent_lends_no_memory(ca->parent);
+}
+
+/* The parent's storage the alias path points into: inner axes full and
+   interior, so the window is one contiguous run of the attached parent. */
+static char *
+ca_window_alias_ptr (CAWindow *ca)
+{
+  ca_size_t parent_row_stride = ca->bytes;
+  int8_t k;
+  for (k = ca->ndim - 1; k >= 1; k--) parent_row_stride *= ca->parent->dim[k];
+  return ca->parent->ptr + ca->start[0] * parent_row_stride;
+}
+
+/* Agrees with attach on the alias path: sync has nothing to write back
+   and detach frees nothing there, so a buffer of our own would take the
+   writes and be dropped. */
 static void
 ca_window_func_allocate (void *ap)
 {
   CAWindow *ca = (CAWindow *) ap;
+  ca_window_mask_current(ca);
+  if ( ca_window_owns_buffer(ca) ) {
+    ca->ptr = ca_alloc_cells((CArray *) ca);
+    return;
+  }
   ca_attach(ca->parent);
-  /* ca->ptr = ALLOC_N(char, ca_length(ca)); */
-  ca->ptr = xmalloc(ca_length(ca));  
+  if ( ca->embed_alias_eligible ) {
+    ca->ptr = ca_window_alias_ptr(ca);
+    return;
+  }
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 /* The engine paths below emit a per-axis descriptor (ca_window_describe_axes)
@@ -973,6 +1110,11 @@ static void
 ca_window_func_attach (void *ap)
 {
   CAWindow *ca = (CAWindow *) ap;
+  ca_window_mask_current(ca);
+  if ( ca_window_owns_buffer(ca) ) {
+    ca_axis_view_attach_owned(ca);
+    return;
+  }
   ca_attach(ca->parent);
   if ( ca->embed_alias_eligible ) {
     /* Alias path: inner axes full + interior, so the embedded region is a
@@ -981,14 +1123,10 @@ ca_window_func_attach (void *ap)
        CAREFUL: sync and detach must agree with this — sync has nothing to
        scatter back (the writes already landed in the parent) and detach must
        not xfree a pointer it does not own. */
-    ca_size_t parent_row_stride = ca->bytes;
-    int8_t k;
-    for (k = ca->ndim - 1; k >= 1; k--) parent_row_stride *= ca->parent->dim[k];
-    ca->ptr = ca->parent->ptr + ca->start[0] * parent_row_stride;
+    ca->ptr = ca_window_alias_ptr(ca);
   } else if ( ca->embed_eligible ) {
     /* Embed path: allocate, then 1 fill + 1 strided memcpy. */
-    ca_size_t out_len = ca->elements * ca->bytes;
-    ca->ptr = xmalloc(out_len > 0 ? out_len : 1);
+    ca->ptr = ca_alloc_cells((CArray *) ca);
     ca_window_attach_embed(ca, ca->ptr);
   } else {
     /* Fallback: PERIODIC / REFLECT / NEAREST / RUBY / STRICT go through
@@ -1005,6 +1143,10 @@ static void
 ca_window_func_sync (void *ap)
 {
   CAWindow *ca = (CAWindow *) ap;
+  if ( ca_window_owns_buffer(ca) ) {
+    ca_axis_view_sync_owned(ca);
+    return;
+  }
   if ( ca->embed_alias_eligible ) {
     /* Alias path: ca->ptr aliases the parent, so the writes already landed
        in parent storage.  Nothing to scatter back. */
@@ -1019,12 +1161,18 @@ ca_window_func_sync (void *ap)
                              ca->elements, ca->ptr);
   }
   ca_sync(ca->parent);
+  ca_window_mask_settle(ca);
 }
 
 static void
 ca_window_func_detach (void *ap)
 {
   CAWindow *ca = (CAWindow *) ap;
+  if ( ca_window_owns_buffer(ca) ) {
+    xfree(ca->ptr);
+    ca->ptr = NULL;
+    return;
+  }
   /* Alias path: ca->ptr aliases parent storage; it is not ours to xfree. */
   if ( ! ca->embed_alias_eligible ) {
     xfree(ca->ptr);
@@ -1078,6 +1226,7 @@ static void
 ca_window_func_xfer_all (void *ap, void *data, int dir)
 {
   CAWindow *ca = (CAWindow *) ap;
+  ca_window_mask_current(ca);
   if ( ca->parent->ptr ) {
     ca_window_func_run_fast_path(ca, (char *) data, dir);
     return;
@@ -1117,9 +1266,25 @@ ca_window_func_xfer_all (void *ap, void *data, int dir)
     }
   }
 
-  /* Cold parent with nothing to lend: materialise it into a scratch buffer
-     via ca_xfer_all, then run the normal fast path with the scratch standing
-     in for parent->ptr. */
+  /* A parent with no memory to lend is asked for the cells of the window
+     only, through xfer_stride over the whole view, when the bounds let that
+     go row by row (see ca_window_owns_buffer). */
+  if ( ca_window_owns_buffer(ca) ) {
+    ca_size_t starts[CA_RANK_MAX], strides[CA_RANK_MAX], s;
+    int8_t    k;
+    s = ca->bytes;
+    for ( k = ca->ndim - 1; k >= 0; k-- ) {
+      starts[k]  = 0;
+      strides[k] = s;
+      s *= ca->dim[k];
+    }
+    ca_window_func_xfer_stride(ca, starts, ca->dim, strides, data, dir);
+    return;
+  }
+
+  /* Any other cold parent: materialise it into a scratch buffer via
+     ca_xfer_all, then run the normal fast path with the scratch standing in
+     for parent->ptr. */
   {
     volatile VALUE holder;
     CArray   *parent = ca->parent;
@@ -1137,12 +1302,14 @@ ca_window_func_xfer_all (void *ap, void *data, int dir)
 
     ca_window_func_run_fast_path(ca, (char *) data, dir);
 
+    /* Put parent->ptr back before the PUT: the PUT can raise (a lazy
+       backing's sync failing), and the scratch is gone once this
+       frame is. */
+    parent->ptr = parent_ptr_saved;
     if ( dir == CA_XFER_PUT ) {
       /* Push back scratch (modified by scatter) to parent. */
       ca_xfer_all(parent, parent_scratch, CA_XFER_PUT);
     }
-
-    parent->ptr = parent_ptr_saved;
     ALLOCV_END(holder);
   }
 }
@@ -1161,6 +1328,7 @@ static void
 ca_window_func_fill_data (void *ap, void *ptr)
 {
   CAWindow *ca = (CAWindow *) ap;
+  ca_window_mask_current(ca);
 
   /* embed_eligible (= no PERIODIC/REFLECT) covers both interior-only
      windows (embed_covers_all == 1) and OOB-bearing ones such as a CAShift
@@ -1238,22 +1406,32 @@ ca_window_func_fill_data (void *ap, void *ptr)
   ca_attach(ca->parent);
   ca_axis_dispatch_fill_value(ca->parent, pdims, desc, ca->ndim, ca->bytes,
                               ca->elements, ptr);
-  ca_sync(ca->parent);
-  ca_detach(ca->parent);
+  ca_sync_detach(ca->parent);
 }
 
 static void
 ca_window_func_create_mask (void *ap)
 {
   CAWindow *ca = (CAWindow *) ap;
+  CArray *pmask;
   boolean8_t fill;
   uint8_t mbounds[CA_RANK_MAX];
   int8_t i;
   int any_mask;
 
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
+  /* The mask lies over the parent's mask, or, while the parent has none,
+     over an all-false stand-in this window holds: masking the
+     out-of-bounds cells gives the parent no mask
+     (ca_mask_standin_new). */
+  if ( ca_has_mask(ca->parent) ) {
     ca_create_mask(ca->parent);
+    pmask = ca->parent->mask;
+  }
+  else {
+    if ( ca->mask_standin == NULL ) {
+      ca->mask_standin = ca_mask_standin_new(ca->parent);
+    }
+    pmask = ca->mask_standin;
   }
 
   /* Any MASK axis of the view becomes FILL in the mask sub-view, with the
@@ -1270,8 +1448,77 @@ ca_window_func_create_mask (void *ap)
   }
   fill = any_mask ? 1 : 0;
 
-  ca->mask = (CArray *) ca_window_new(ca->parent->mask,
-                                    ca->start, ca->count, mbounds, (char*)&fill);
+  /* The mask has the view's own type, so CAShift (which shares this table)
+     gets a CAShiftMask. */
+  {
+    /* check: the mask window copies its own window's checked ranges */
+    CAWindow *m = (CAWindow *) ca_array_alloc(ca->obj_type, ca->ndim);
+    ca_window_setup(m, pmask, ca->start, ca->count, mbounds, (char*)&fill);
+    m->obj_type   = ca->obj_type;
+    m->mask_owner = (CArray *) ca;
+    if ( pmask == ca->mask_standin ) {
+      /* writes inside an attach window reach the stand-in through the
+         sync, where they can give way to the parent's mask */
+      m->embed_alias_eligible = 0;
+    }
+    ca->mask = (CArray *) m;
+  }
+}
+
+/* The table's write slots: on the mask of a window still reading a
+   stand-in, a write that may have put a true into it ends with the settle
+   (ca_mask_standin_settle). */
+static void
+ca_window_put_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
+{
+  ca_window_func_xfer_index(ap, idx, data, dir);
+  if ( dir == CA_XFER_PUT && ca_window_mask_reads_standin((CAWindow *) ap)
+       && ca_mask_any_true(data, 1) ) {
+    ca_window_mask_settle((CAWindow *) ap);
+  }
+}
+
+static void
+ca_window_put_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *data,
+                          int dir)
+{
+  ca_window_func_xfer_addrs(ap, n, addrs, data, dir);
+  if ( dir == CA_XFER_PUT && ca_window_mask_reads_standin((CAWindow *) ap)
+       && ca_mask_any_true(data, n) ) {
+    ca_window_mask_settle((CAWindow *) ap);
+  }
+}
+
+static void
+ca_window_put_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
+                           ca_size_t *strides, void *data, int dir)
+{
+  ca_window_func_xfer_stride(ap, starts, counts, strides, data, dir);
+  if ( dir == CA_XFER_PUT && ca_window_mask_reads_standin((CAWindow *) ap)
+       && ca_mask_any_true(data,
+                           ca_shape_elements(((CArray *) ap)->ndim, counts, 1)) ) {
+    ca_window_mask_settle((CAWindow *) ap);
+  }
+}
+
+static void
+ca_window_put_xfer_all (void *ap, void *data, int dir)
+{
+  ca_window_func_xfer_all(ap, data, dir);
+  if ( dir == CA_XFER_PUT && ca_window_mask_reads_standin((CAWindow *) ap)
+       && ca_mask_any_true(data, ((CArray *) ap)->elements) ) {
+    ca_window_mask_settle((CAWindow *) ap);
+  }
+}
+
+static void
+ca_window_put_fill_data (void *ap, void *ptr)
+{
+  ca_window_func_fill_data(ap, ptr);
+  if ( ca_window_mask_reads_standin((CAWindow *) ap)
+       && ca_mask_any_true(ptr, 1) ) {
+    ca_window_mask_settle((CAWindow *) ap);
+  }
 }
 
 ca_operation_function_t ca_window_func = {
@@ -1283,13 +1530,13 @@ ca_operation_function_t ca_window_func = {
   ca_window_func_attach,
   ca_window_func_sync,
   ca_window_func_detach,
-  ca_window_func_fill_data,
+  ca_window_put_fill_data,
   ca_window_func_create_mask,
-  ca_window_func_xfer_index,
-  ca_window_func_xfer_addrs,
+  ca_window_put_xfer_index,
+  ca_window_put_xfer_addrs,
   ca_window_func_fold_stride,
-  ca_window_func_xfer_stride,
-  ca_window_func_xfer_all,
+  ca_window_put_xfer_stride,
+  ca_window_put_xfer_all,
 };
 
 /* ------------------------------------------------------------------- */
@@ -1309,6 +1556,7 @@ ca_window_describe_axes (void *ap, ca_axis_desc_t *out,
                          ca_size_t *out_parent_dims)
 {
   CAWindow *ca = (CAWindow *) ap;
+  ca_window_mask_current(ca);
   int8_t k;
   for ( k = 0; k < ca->ndim; k++ ) {
     out_parent_dims[k] = ca->parent->dim[k];
@@ -1410,9 +1658,13 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
     bounds = CA_BOUNDS_MASK;
   }
   else {
-    rcs = rb_cscalar_new_with_value(ca->data_type, ca->bytes, rfval);
+    /* The fill is a value of the array (a String for a CAString, an
+       instant for a time array): rb_ca_obj2ptr writes it as one cell of
+       the storage, through the Face. */
+    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(rbounds) ) {
@@ -1427,7 +1679,7 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
       cbounds = StringValuePtr(rbounds);
       if ( rfval == CA_UNDEF && strncmp(cbounds, "fill", 4) 
                              && strncmp(cbounds, "mask", 4) ) {
-        rb_raise(rb_eRuntimeError, "conflicted bounds and fill_value");
+        rb_raise(rb_eArgError, "conflicted bounds and fill_value");
       }
       if ( ! strncmp(cbounds, "ruby", 4) ) {
         bounds = CA_BOUNDS_RUBY;
@@ -1458,7 +1710,7 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
         bounds = CA_BOUNDS_FILL;
       }
       else {
-        rb_raise(rb_eRuntimeError, 
+        rb_raise(rb_eArgError, 
                  "unknown option value '%s' for :bounds", cbounds);        
       }
       break;
@@ -1466,7 +1718,7 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
       bounds = NUM2INT(rbounds);
       break;
     default:
-      rb_raise(rb_eRuntimeError, "invalid option value for :bounds");
+      rb_raise(rb_eArgError, "invalid option value for :bounds");
     }
   }
 
@@ -1491,6 +1743,7 @@ rb_ca_window_initialize_copy (VALUE self, VALUE other)
   CAWindow *ca, *cs;
 
   TypedData_Get_Struct(self,  CAWindow, &cawindow_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CAWindow, &cawindow_data_type, cs);
 
   /* `self` came from rb_ca_window_s_allocate (TypedData_Make_Struct,
@@ -1500,6 +1753,10 @@ rb_ca_window_initialize_copy (VALUE self, VALUE other)
     ca_array_pool_alloc(ca, CA_OBJ_WINDOW, cs->ndim);
   }
   ca_window_setup(ca, cs->parent, cs->start, cs->count, cs->bounds, cs->fill);
+  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;
 }
@@ -1588,6 +1845,34 @@ rb_ca_window_get_bounds (VALUE self)
   return SIZE2NUM(cw->bounds[0]);
 }
 
+/* The boundary rule on each axis, one Symbol per axis.  `bounds` answers
+   for axis 0 only, which is all CArray#window sets; a shift with `roll:`
+   on some axes sets them one by one. */
+static VALUE
+rb_ca_window_axis_bounds (VALUE self)
+{
+  volatile VALUE ary;
+  CAWindow *cw;
+  const char *name;
+  int8_t i;
+  TypedData_Get_Struct(self, CAWindow, &cawindow_data_type, cw);
+  ary = rb_ary_new2(cw->ndim);
+  for (i=0; i<cw->ndim; i++) {
+    switch ( cw->bounds[i] ) {
+    case CA_BOUNDS_RUBY:     name = "ruby";     break;
+    case CA_BOUNDS_STRICT:   name = "strict";   break;
+    case CA_BOUNDS_NEAREST:  name = "nearest";  break;
+    case CA_BOUNDS_PERIODIC: name = "periodic"; break;
+    case CA_BOUNDS_REFLECT:  name = "reflect";  break;
+    case CA_BOUNDS_FILL:     name = "fill";     break;
+    case CA_BOUNDS_MASK:     name = "mask";     break;
+    default:                 name = "unknown";  break;
+    }
+    rb_ary_store(ary, i, ID2SYM(rb_intern(name)));
+  }
+  return ary;
+}
+
 #define rb_cw_get_attr_ary(name)    \
   rb_cw_## name (VALUE self)        \
   {                                 \
@@ -1688,6 +1973,7 @@ Init_ca_obj_window (void)
   /* No `count` accessor: the per-axis window widths are what `shape`
      already answers, and the name belongs to CArray#count. */
   rb_define_method(rb_cCAWindow, "start",  rb_cw_start, 0);
+  rb_define_method(rb_cCAWindow, "__boundary_rule_of_each_axis__", rb_ca_window_axis_bounds, 0);
   rb_define_method(rb_cCAWindow, "size0",  rb_cw_size0, 0);
 
 #ifdef CARRAY_DEV_BUILD