carray 3.0.2 → 3.0.4

data/ext/ca_obj_repeat.c

@@ -39,20 +39,21 @@ ca_repeat_setup (CAStride *ca, CArray *parent, int8_t ndim, ca_size_t *count)
   int8_t data_ndim = 0;
   int8_t i, j;
 
+  ca_check_rank_fits(ndim, NULL);
   for (i = 0; i < ndim; i++) {
     if (count[i] < 0) {
-      rb_raise(rb_eRuntimeError,
+      rb_raise(rb_eArgError,
                "negative size for %i-th dimension specified", i);
     }
     if (count[i]) nrpt *= count[i];
     else          data_ndim += 1;
   }
   if (data_ndim != parent->ndim) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "mismatch in ndim between original array and determined by # of dummies");
   }
   if (((double) parent->elements) * nrpt > CA_LENGTH_MAX) {
-    rb_raise(rb_eRuntimeError, "too large byte length");
+    rb_raise(rb_eArgError, "too large byte length");
   }
   (void) total_elements_d;
 
@@ -77,9 +78,15 @@ ca_repeat_setup (CAStride *ca, CArray *parent, int8_t ndim, ca_size_t *count)
     }
   }
 
-  ca_stride_setup(ca, CA_OBJ_REPEAT, parent,
-                  parent->data_type, parent->bytes,
-                  ndim, newdim, strides, 0);
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
+  ca_stride_setup_view(ca, CA_OBJ_REPEAT, parent,
+                       parent->data_type, parent->bytes,
+                       ndim, newdim, strides, 0);
 
   ca_set_flag(ca, CA_FLAG_READ_ONLY);
   if (ca->mask) {
@@ -91,8 +98,11 @@ ca_repeat_setup (CAStride *ca, CArray *parent, int8_t ndim, ca_size_t *count)
 CAStride *
 ca_repeat_new (CArray *parent, int8_t ndim, ca_size_t *count)
 {
-  CAStride *ca = (CAStride *) ca_array_alloc(CA_OBJ_REPEAT, ndim);
+  CAStride *ca;
+  ca_repeat_setup(NULL, parent, ndim, count);
+  ca = (CAStride *) ca_array_alloc(CA_OBJ_REPEAT, ndim);
   ca_repeat_setup(ca, parent, ndim, count);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -155,7 +165,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
       TypedData_Get_Struct(argv[0], CArray, &carray_data_type, ct);
     }
     if ( ct->ndim < ca->ndim ) {
-      rb_raise(rb_eRuntimeError, "invalid ndim to template");
+      rb_raise(rb_eArgError, "invalid ndim to template");
     }
     args = rb_ary_new();
     ndim = 0;
@@ -205,9 +215,13 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
         self = rb_ca_refer_new(self, ca->data_type, ndim, dim, ca->bytes, 0);
       }
     }
-    return rb_ca_repeat((int)RARRAY_LEN(args), (VALUE *)RARRAY_CONST_PTR(args), self);
+    self = rb_ca_repeat((int)RARRAY_LEN(args), (VALUE *)RARRAY_CONST_PTR(args), self);
+    RB_GC_GUARD(args);   /* the repeat reads its arguments out of args */
+    return self;
   }
 
+  ca_check_rank_fits(argc, NULL);     /* count[] and dim[] hold CA_RANK_MAX */
+
   repeat = 1;
   for (i=0; i<argc; i++) {
     if ( rb_obj_is_kind_of(argv[i], rb_cSymbol) ) {
@@ -255,6 +269,7 @@ rb_ca_repeat_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);
   if ( ca_func[CA_OBJ_REPEAT].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_REPEAT, cs->ndim);

data/ext/ca_obj_roll.c

@@ -17,6 +17,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 #include "ca_composite_dispatch.h"
 #include "ca_obj_face.h"
 
@@ -90,12 +91,15 @@ ca_roll_setup (CARoll *ca, CArray *parent, ca_size_t *shift)
 
   elements = 1;
   for (i = 0; i < ndim; i++) {
-    if ( parent->dim[i] <= 0 ) {
-      rb_raise(rb_eIndexError, "invalid parent dim for %d-th dimension", i);
-    }
     elements *= parent->dim[i];
   }
 
+  /* 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_ROLL;
   ca->data_type = parent->data_type;
   ca->flags     = 0;
@@ -114,14 +118,14 @@ ca_roll_setup (CARoll *ca, CArray *parent, ca_size_t *shift)
   for (i = 0; i < ndim; i++) {
     ca->dim[i] = parent->dim[i];
     /* Normalise: ((shift[i] % dim[i]) + dim[i]) % dim[i] ∈ [0, dim[i]). */
-    ca_size_t s = shift[i] % parent->dim[i];
-    if ( s < 0 ) s += parent->dim[i];
+    ca_size_t s = 0;                 /* an empty axis has nothing to roll */
+    if ( parent->dim[i] > 0 ) {
+      s = shift[i] % parent->dim[i];
+      if ( s < 0 ) s += parent->dim[i];
+    }
     ca->reps[i] = s;
   }
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
 
   return 0;
 }
@@ -129,8 +133,11 @@ ca_roll_setup (CARoll *ca, CArray *parent, ca_size_t *shift)
 CARoll *
 ca_roll_new (CArray *parent, ca_size_t *shift)
 {
-  CARoll *ca = ALLOC(CARoll);
+  CARoll *ca;
+  ca_roll_setup(NULL, parent, shift);
+  ca = ALLOC(CARoll);
   ca_roll_setup(ca, parent, shift);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -214,6 +221,7 @@ static void
 ca_roll_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;
   CARoll   *ca = (CARoll *) ap;
   CArray   *parent = ca->parent;
   int8_t    ndim = ca->ndim;
@@ -251,6 +259,7 @@ ca_roll_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] * rnative[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 roff = base, ridx[CA_RANK_MAX];
       for (k = 0; k < ndim; k++) roff += idx[k] * strides[k];
@@ -264,7 +273,97 @@ ca_roll_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     return;
   }
 
+  /* The inner range is one run of a parent row, or two when it wraps, and
+     the rows along the next axis out are consecutive parent rows except
+     across that axis's wrap.  So each pass over the axes further out moves
+     at most two strided boxes per inner run, instead of one transfer per
+     row.  A box over an unwrapped inner range is already the request's own
+     layout; a box over one of two inner runs goes through a scratch whose
+     rows are spliced into the request's.  Object cells keep the per-row
+     path: a scratch would hold the VALUEs a parent produces where the GC
+     cannot see them. */
+  if ( inner >= 1 ) {
+    int8_t    m  = inner - 1;
+    ca_size_t dim_in = parent->dim[inner];
+    ca_size_t p0 = starts[inner] - ca->reps[inner];
+    ca_size_t seg_p[2], seg_n[2], seg_i[2];
+    int       nseg, sg;
+    if (p0 < 0) p0 += dim_in;
+    if ( p0 + counts[inner] <= dim_in ) {
+      nseg = 1;
+      seg_p[0] = p0; seg_n[0] = counts[inner]; seg_i[0] = 0;
+    }
+    else {
+      nseg = 2;
+      seg_p[0] = p0; seg_n[0] = dim_in - p0;            seg_i[0] = 0;
+      seg_p[1] = 0;  seg_n[1] = counts[inner] - seg_n[0]; seg_i[1] = seg_n[0];
+    }
+    if ( nseg == 1 || ca->data_type != CA_OBJECT ) {
+      volatile VALUE holder = 0;
+      char *tmp = NULL;
+      if ( nseg == 2 ) {
+        ca_size_t wide = seg_n[0] > seg_n[1] ? seg_n[0] : seg_n[1];
+        tmp = (char *) ALLOCV(holder, counts[m] * wide * ca->bytes);
+      }
+      for (k = 0; k < m; k++) o[k] = 0;
+      while (1) {
+        ca_size_t pbase = 0, doff = 0;
+        for (k = 0; k < m; k++) {
+          ca_size_t j = (starts[k] + o[k]) - ca->reps[k];
+          if (j < 0) j += parent->dim[k];
+          pbase += j * pnative[k];
+          doff  += o[k] * dstride[k];
+        }
+        for (sg = 0; sg < nseg; sg++) {
+          ca_size_t r = 0;
+          while (r < counts[m]) {
+            ca_size_t pm = (starts[m] + r) - ca->reps[m];
+            ca_size_t run, q;
+            ca_size_t pstarts[CA_RANK_MAX], pcounts[CA_RANK_MAX], pstrides[CA_RANK_MAX];
+            char     *rows = d + doff + r * dstride[m] + seg_i[sg] * ca->bytes;
+            ca_size_t rowb = seg_n[sg] * ca->bytes;
+            if (pm < 0) pm += parent->dim[m];
+            run = parent->dim[m] - pm;
+            if (run > counts[m] - r) run = counts[m] - r;
+            ca_addr2index((CArray *) parent,
+                          (pbase + pm * pnative[m] + seg_p[sg] * pnative[inner])
+                          / parent->bytes, pstarts);
+            for (k = 0; k < ndim; k++) { pcounts[k] = 1; pstrides[k] = 0; }
+            pcounts[m]      = run;
+            pstrides[m]     = pnative[m];
+            pcounts[inner]  = seg_n[sg];
+            pstrides[inner] = pnative[inner];
+            if ( nseg == 1 ) {
+              ca_xfer_stride(parent, pstarts, pcounts, pstrides, rows, dir);
+            }
+            else if ( dir == CA_XFER_GET ) {
+              ca_xfer_stride(parent, pstarts, pcounts, pstrides, tmp, dir);
+              for (q = 0; q < run; q++) {
+                memcpy(rows + q * dstride[m], tmp + q * rowb, rowb);
+              }
+            }
+            else {
+              for (q = 0; q < run; q++) {
+                memcpy(tmp + q * rowb, rows + q * dstride[m], rowb);
+              }
+              ca_xfer_stride(parent, pstarts, pcounts, pstrides, tmp, dir);
+            }
+            r += run;
+          }
+        }
+        k = m - 1;
+        while (k >= 0) { if (++o[k] < counts[k]) break; o[k] = 0; k--; }
+        if (k < 0) break;
+      }
+      if ( tmp ) {
+        ALLOCV_END(holder);
+      }
+      return;
+    }
+  }
+
   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, i;
     for (k = 0; k < inner; k++) {
@@ -407,7 +506,7 @@ ca_roll_func_allocate (void *ap)
 {
   CARoll *ca = (CARoll *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -415,7 +514,7 @@ ca_roll_func_attach (void *ap)
 {
   CARoll *ca = (CARoll *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
   ca_roll_iterate_regions(ca, ca->ptr, 0);
 }
 
@@ -459,10 +558,13 @@ ca_roll_func_xfer_all (void *ap, void *data, int dir)
     ca_xfer_all(parent, parent_scratch, CA_XFER_GET);
     parent->ptr = parent_scratch;
     ca_roll_iterate_regions(ca, (char *) data, dir == CA_XFER_PUT);
+    /* 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 ) {
       ca_xfer_all(parent, parent_scratch, CA_XFER_PUT);
     }
-    parent->ptr = parent_ptr_saved;
     ALLOCV_END(holder);
   }
 }
@@ -480,10 +582,7 @@ static void
 ca_roll_func_create_mask (void *ap)
 {
   CARoll *ca = (CARoll *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
+  ca_create_mask(ca->parent);
   ca->mask = (CArray *) ca_roll_new(ca->parent->mask, ca->reps);
 }
 
@@ -557,11 +656,14 @@ rb_ca_roll_initialize_copy (VALUE self, VALUE other)
 {
   CARoll *ca, *cs;
   TypedData_Get_Struct(self,  CARoll, &caroll_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CARoll, &caroll_data_type, cs);
   ca_roll_setup(ca, cs->parent, cs->reps);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 
+#ifdef CARRAY_DEV_BUILD
 /* Debug-only accessor returning the roll descriptor as a Hash
    (`shifts`, `n_regions`, `ndim`).  Not part of the public surface. */
 static VALUE
@@ -583,6 +685,7 @@ rb_ca_roll_descriptor (VALUE self)
   rb_hash_aset(hash, ID2SYM(rb_intern("ndim")), INT2NUM(ca->ndim));
   return hash;
 }
+#endif
 
 void
 Init_ca_obj_roll (void)
@@ -618,7 +721,9 @@ Init_ca_obj_roll (void)
   rb_define_method(rb_cCARoll, "initialize_copy",
                                       rb_ca_roll_initialize_copy, 1);
 
+#ifdef CARRAY_DEV_BUILD
   /* Debug accessor, not part of the public surface. */
   rb_define_method(rb_cCARoll, "_roll_descriptor",
                                       rb_ca_roll_descriptor, 0);
+#endif
 }

data/ext/ca_obj_select.c

@@ -93,21 +93,24 @@ ca_select_snapshot_masked (VALUE arg)
 {
   CArray **pair = (CArray **) arg;
   CArray *select = pair[0], *snap = pair[1];
-  boolean8_t *p, *q, *m;
+  boolean8_t *q, *m;
   ca_size_t i;
-  ca_attach(select);
+  volatile VALUE holder = 0;
+  ca_copy_data(select, snap->ptr);
+  ca_update_mask(select);
+  m = ALLOCV_N(boolean8_t, holder, select->elements);
+  ca_copy_data(select->mask, (char *) m);
   q = (boolean8_t *) snap->ptr;
-  p = (boolean8_t *) select->ptr;
-  m = (boolean8_t *) select->mask->ptr;
   for (i = 0; i < select->elements; i++) {
-    *q = ( *m ) ? 0 : *p;
-    q++; p++; m++;
+    if ( m[i] ) {
+      q[i] = 0;
+    }
   }
-  ca_detach(select);
+  ALLOCV_END(holder);
   return Qnil;
 }
 
-static CArray *
+CArray *
 ca_select_snapshot (CArray *select)
 {
   if ( ! ca_is_boolean_type(select) ) {
@@ -159,15 +162,19 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
       if ( s[i] ) count++;
     }
     ca->elements = count;
-    /* Placeholder 1-element allocation when count == 0 to avoid
-       malloc(0) implementation variance; the engine treats
-       elements==0 as a no-op so the contents are irrelevant. */
-    ca->indices  = (ca_size_t *) xmalloc(
-                     sizeof(ca_size_t) * (count > 0 ? count : 1));
+    /* One slot more than count: the loop below writes every position
+       and advances only on TRUE, so a run of FALSE after the last TRUE
+       writes slot `count`.  Writing without a branch keeps a selector
+       with TRUE and FALSE mixed at random from mispredicting on most
+       cells.  The extra slot also keeps count == 0 from malloc(0). */
+    ca->indices  = (ca_size_t *) xmalloc(sizeof(ca_size_t) * (count + 1));
     {
-      ca_size_t j = 0;
-      for (i = 0; i < ca->select->elements; i++) {
-        if ( s[i] ) ca->indices[j++] = i;
+      ca_size_t *ix = ca->indices;
+      ca_size_t n   = ca->select->elements;
+      ca_size_t j   = 0;
+      for (i = 0; i < n; i++) {
+        ix[j] = i;
+        j += ( s[i] != 0 );
       }
     }
     /* Constant-step detection: promotes to STRIDE descriptor kind
@@ -208,6 +215,7 @@ CArray *
 ca_select_new (CArray *parent, CArray *select)
 {
   CArray *snapshot = ca_select_snapshot(select);
+  /* check: the setup checks nothing */
   CASelect *ca = ALLOC(CASelect);
   ca_select_setup(ca, parent, snapshot);
   return (CArray*) ca;
@@ -352,6 +360,7 @@ static void
 ca_select_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;
   CASelect  *ca = (CASelect *) ap;
   CArray    *parent = ca->parent;
   ca_size_t  n = counts[0];
@@ -414,24 +423,34 @@ ca_select_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_func_allocate (void *ap)
 {
   CASelect *ca = (CASelect *) 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);
 }
 
-/* Every attach / sync / xfer_all / xfer_stride / fill_data path
-   dispatches through the descriptor engine with the same shape
-   CASelectAxis uses: one axis over a flattened parent. */
-
 static void
 ca_select_func_attach (void *ap)
 {
   CASelect *ca = (CASelect *) 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_describe_axes(ca, desc, pdims);
   ca->ptr = ca_axis_dispatch_attach(ca->parent, pdims, desc, ca->ndim,
@@ -444,6 +463,12 @@ ca_select_func_sync (void *ap)
   CASelect *ca = (CASelect *) 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_describe_axes(ca, desc, pdims);
   ca_axis_dispatch_scatter(ca->parent, pdims, desc, ca->ndim, ca->bytes,
                            ca->elements, ca->ptr);
@@ -454,16 +479,20 @@ static void
 ca_select_func_detach (void *ap)
 {
   CASelect *ca = (CASelect *) ap;
-  xfree(ca->ptr);
-  ca->ptr = NULL;
-  ca_detach(ca->parent);
+  if ( ca->ptr ) {
+    xfree(ca->ptr);
+    ca->ptr = NULL;
+  }
+  if ( ! ca_parent_lends_no_memory(ca->parent) ) {
+    ca_detach(ca->parent);
+  }
 }
 
-/* Fast-path core used by xfer_all's attached-parent branch and the
-   cold-parent 2-pass scratch branch below. */
+/* The transfer against parent->ptr, for ca_axis_view_xfer_all. */
 static void
-ca_select_func_run_fast_path (CASelect *ca, char *data, int dir)
+ca_select_func_run_fast_path (void *ap, char *data, int dir)
 {
+  CASelect *ca = (CASelect *) ap;
   ca_axis_desc_t desc[CA_RANK_MAX];
   ca_size_t      pdims[CA_RANK_MAX];
   ca_select_describe_axes(ca, desc, pdims);
@@ -476,33 +505,10 @@ ca_select_func_run_fast_path (CASelect *ca, char *data, int dir)
   }
 }
 
-/* Cold parent is served by a 2-pass scratch (gather parent into a
-   local buffer, dispatch through the fast path against the buffer,
-   scatter back on PUT).  Deliberately avoids ca_attach(parent) so
-   that a silent transitive attach cannot re-enter through here. */
 static void
 ca_select_func_xfer_all (void *ap, void *data, int dir)
 {
-  CASelect *ca = (CASelect *) ap;
-  if ( ca->parent->ptr ) {
-    ca_select_func_run_fast_path(ca, (char *) data, dir);
-    return;
-  }
-  {
-    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_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_func_run_fast_path, 1, data, dir);
 }
 
 static void
@@ -531,18 +537,14 @@ ca_select_func_fill_data (void *ap, void *ptr)
   ca_select_describe_axes(ca, desc, pdims);
   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_select_func_create_mask (void *ap)
 {
   CASelect *ca = (CASelect *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
+  ca_create_mask(ca->parent);
   ca->mask = (CArray *) ca_select_new_share(ca->parent->mask, ca->select);
 }
 
@@ -624,6 +626,7 @@ rb_cm_initialize_copy (VALUE self, VALUE other)
   CASelect *ca, *cs;
 
   TypedData_Get_Struct(self,  CASelect, &caselect_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CASelect, &caselect_data_type, cs);
 
   /* Re-snapshot from the source's selector copy so the two views