carray 3.0.1 → 3.0.3

data/ext/ca_obj_repeat.c

@@ -39,20 +39,23 @@ ca_repeat_setup (CAStride *ca, CArray *parent, int8_t ndim, ca_size_t *count)
   int8_t data_ndim = 0;
   int8_t i, j;
 
+  if ( ndim < 0 || ndim > CA_RANK_MAX ) {
+    rb_raise(rb_eArgError, "invalid ndim %d", (int) ndim);
+  }
   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,6 +80,12 @@ ca_repeat_setup (CAStride *ca, CArray *parent, int8_t ndim, ca_size_t *count)
     }
   }
 
+  /* 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(ca, CA_OBJ_REPEAT, parent,
                   parent->data_type, parent->bytes,
                   ndim, newdim, strides, 0);
@@ -91,7 +100,9 @@ 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);
   return ca;
 }
@@ -155,7 +166,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;
@@ -208,6 +219,10 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
     return rb_ca_repeat((int)RARRAY_LEN(args), (VALUE *)RARRAY_CONST_PTR(args), self);
   }
 
+  if ( argc > CA_RANK_MAX ) {         /* count[] and dim[] hold CA_RANK_MAX */
+    rb_raise(rb_eArgError, "invalid ndim %d", argc);
+  }
+
   repeat = 1;
   for (i=0; i<argc; i++) {
     if ( rb_obj_is_kind_of(argv[i], rb_cSymbol) ) {
@@ -255,6 +270,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,8 +118,11 @@ 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;
   }
 
@@ -129,7 +136,9 @@ 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);
   return ca;
 }
@@ -214,6 +223,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;
@@ -264,6 +274,95 @@ 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;
   while (1) {
     ca_size_t pbase = 0, doff = 0, i;
@@ -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,13 @@ 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);
   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 +684,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 +720,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

@@ -83,22 +83,60 @@ VALUE rb_cCASelectMask;
 
 /* ------------------------------------------------------------------- */
 
-/* Snapshot the selector into ca->select (always a copy) and pre-compute
-   ca->indices (TRUE positions in flat parent order).  Masked selector
-   cells become false in the snapshot.  After construction, mutating
-   the caller's live selector does not affect the view. */
-static int
-ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
+/* Owned snapshot of the selector: masked selector cells become false.
+   After construction, mutating the caller's live selector does not affect
+   the view.  Reading the selector can raise (a lazy boolean view), so the
+   snapshot is taken before the view struct is allocated, and a snapshot
+   whose fill raises is freed on the way out. */
+static VALUE
+ca_select_snapshot_masked (VALUE arg)
 {
-  int8_t data_type;
-  ca_size_t bytes;
+  CArray **pair = (CArray **) arg;
+  CArray *select = pair[0], *snap = pair[1];
+  boolean8_t *q, *m;
   ca_size_t i;
+  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;
+  for (i = 0; i < select->elements; i++) {
+    if ( m[i] ) {
+      q[i] = 0;
+    }
+  }
+  ALLOCV_END(holder);
+  return Qnil;
+}
 
+CArray *
+ca_select_snapshot (CArray *select)
+{
   if ( ! ca_is_boolean_type(select) ) {
     rb_raise(rb_eRuntimeError,
              "selection array for CASelect should be have "
              "the data_type of CA_BOOLEAN");
   }
+  if ( ca_has_mask(select) ) {
+    CArray *pair[2];
+    pair[0] = select;
+    pair[1] = ca_template(select);
+    ca_fill_or_free(pair[1], ca_select_snapshot_masked, (VALUE) pair);
+    return pair[1];
+  }
+  return ca_copy(select);
+}
+
+/* Set up the view over `parent` from an owned selector snapshot (see
+   ca_select_snapshot) and pre-compute ca->indices (TRUE positions in flat
+   parent order).  Does not raise. */
+static int
+ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
+{
+  int8_t data_type;
+  ca_size_t bytes;
+  ca_size_t i;
 
   data_type = parent->data_type;
   bytes     = parent->bytes;
@@ -114,26 +152,7 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
   ca->attach    = 0;
   ca->nosync    = 0;
   ca->indices   = NULL;
-
-  /* The `share` argument is preserved for source compatibility but
-     no longer toggles a live-reference path; both paths copy.
-     Masked selector cells become false in the snapshot. */
-  (void) share;
-  if ( ca_has_mask(select) ) {
-    boolean8_t *p, *q, *m;
-    ca->select = ca_template(select);
-    ca_attach(select);
-    q = (boolean8_t *) ca->select->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++;
-    }
-    ca_detach(select);
-  } else {
-    ca->select = ca_copy(select);
-  }
+  ca->select    = snapshot;
 
   /* Count TRUE positions and snapshot them into ca->indices. */
   {
@@ -181,7 +200,7 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
   ca->dim       = &(ca->_dim);
   ca->dim[0]    = ca->elements;
 
-  if ( ca_is_scalar(select) ) {
+  if ( ca_is_scalar(snapshot) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
 
@@ -191,8 +210,9 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
 CArray *
 ca_select_new (CArray *parent, CArray *select)
 {
+  CArray *snapshot = ca_select_snapshot(select);
   CASelect *ca = ALLOC(CASelect);
-  ca_select_setup(ca, parent, select, 0);
+  ca_select_setup(ca, parent, snapshot);
   return (CArray*) ca;
 }
 
@@ -202,9 +222,7 @@ ca_select_new (CArray *parent, CArray *select)
 CArray *
 ca_select_new_share (CArray *parent, CArray *select)
 {
-  CASelect *ca = ALLOC(CASelect);
-  ca_select_setup(ca, parent, select, 1);
-  return (CArray*) ca;
+  return ca_select_new(parent, select);
 }
 
 static void
@@ -337,6 +355,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];
@@ -399,24 +418,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);
+  if ( ! ca_parent_lends_no_memory(ca->parent) ) {
+    ca_attach(ca->parent);
+  }
   ca->ptr = xmalloc(ca_length(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,
@@ -429,6 +458,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);
@@ -439,16 +474,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);
@@ -461,33 +500,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
@@ -516,18 +532,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);
 }
 
@@ -609,11 +621,12 @@ 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
      end up with independent indices buffers. */
-  ca_select_setup(ca, cs->parent, cs->select, 1);
+  ca_select_setup(ca, cs->parent, ca_select_snapshot(cs->select));
 
   return self;
 }