carray 2.0.0 → 3.0.0

data/ext/ca_obj_select.c

@@ -1,19 +1,22 @@
 /* ---------------------------------------------------------------------------
 
-  ca_obj_select.c
-
-  This file is part of Ruby/CArray extension library.
-
-  Copyright (C) 2005-2020 Hiroki Motoyoshi
+  CASelect view: 1-D gather of the parent through a boolean selector.
+  The view snapshots the selector at construction time and pre-computes
+  `indices[]` (the flat parent positions where the selector is TRUE).
+
+  Sibling of ca_axis_dispatch.c (the per-axis descriptor engine).
+  attach / sync / xfer_all / xfer_stride / fill_data all dispatch
+  through `ca_axis_dispatch_*` with a single 1-D INDEX descriptor over
+  a flattened parent (parent_axis_dims = {parent->elements}).  When
+  the TRUE positions form a constant-step run, the descriptor is
+  promoted to STRIDE kind so the engine's contig-memcpy fast path
+  becomes available.
 
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
-
-/* yard:
-  class CASelect < CAVirtual # :nodoc:
-  end
-*/
+#include "carray_internal.h"   /* per-obj_type view constructors */
+#include "ca_obj_face.h"
 
 typedef struct {
   int16_t   obj_type;
@@ -25,21 +28,38 @@ typedef struct {
   ca_size_t  *dim;  /* point to _dim */
   char     *ptr;
   CArray   *mask;
+  char     *_pool;         /* framework-managed pool buffer (NULL = legacy ALLOC_N path). */
   CArray   *parent;
   uint32_t  attach;
   uint8_t   nosync;
   /* ---------- */
-  CArray   *select;
+  CArray    *select;    /* snapshot of selector (boolean array, owned) */
+  ca_size_t *indices;   /* snapshot of TRUE positions in flat parent
+                           (length = ca->elements; engine consumes this) */
+  /* Constant-step detection on indices[].  When TRUE positions form
+     an arithmetic progression (consecutive TRUE block, all-TRUE,
+     equally spaced), the descriptor is emitted as STRIDE kind
+     instead of INDEX to unlock the engine's contig-memcpy path. */
+  uint8_t    stride_kind;
+  ca_size_t  stride_start;
+  ca_size_t  stride_step;
   ca_size_t  _dim;
 } CASelect;
 
+static size_t
+ca_select_dsize (const void *ap)
+{
+  /* CASelect: dim points to _dim inside struct, no separate allocation */
+  return sizeof(CASelect);
+}
+
 const rb_data_type_t caselect_data_type = {
-    .parent = &cavirtual_data_type,
+    .parent = &caview_data_type,
     .wrap_struct_name = "CASelect",
     .function = {
         .dmark = ca_mark,
         .dfree = ca_free,
-        .dsize = NULL,
+        .dsize = ca_select_dsize,
         .dcompact = NULL
     },
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
@@ -51,7 +71,7 @@ const rb_data_type_t caselect_mask_data_type = {
     .function = {
         .dmark = NULL,
         .dfree = ca_free_nop,
-        .dsize = NULL,
+        .dsize = ca_select_dsize,
         .dcompact = NULL
     },
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
@@ -63,12 +83,16 @@ 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)
 {
   int8_t data_type;
   ca_size_t bytes;
-  int i;
+  ca_size_t i;
 
   if ( ! ca_is_boolean_type(select) ) {
     rb_raise(rb_eRuntimeError,
@@ -84,51 +108,79 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
   ca->flags     = 0;
   ca->ndim      = 1;
   ca->bytes     = bytes;
-
-  if ( share && ca_is_entity(select) ) {
-    ca_set_flag(ca, CA_FLAG_SHARE_INDEX);
-    ca->select = select;
-  }
-  else {
-    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->ptr       = NULL;
+  ca->mask      = NULL;
+  ca->parent    = parent;
+  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);
   }
 
+  /* Count TRUE positions and snapshot them into ca->indices. */
   {
-    int count = 0;
     boolean8_t *s = (boolean8_t *) ca->select->ptr;
-    for (i=0; i<ca->select->elements; i++) {
-      if ( *s ) {
-        count++;
+    ca_size_t count = 0;
+    for (i = 0; i < ca->select->elements; i++) {
+      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));
+    {
+      ca_size_t j = 0;
+      for (i = 0; i < ca->select->elements; i++) {
+        if ( s[i] ) ca->indices[j++] = i;
       }
-      s++;
     }
-    ca->elements  = count;
+    /* Constant-step detection: promotes to STRIDE descriptor kind
+       when TRUE positions form an arithmetic progression. */
+    ca->stride_kind  = 0;
+    ca->stride_start = 0;
+    ca->stride_step  = 1;
+    if ( count >= 2 ) {
+      ca_size_t step = ca->indices[1] - ca->indices[0];
+      ca_size_t k;
+      int is_const = 1;
+      for ( k = 2; k < count; k++ ) {
+        if ( ca->indices[k] - ca->indices[k-1] != step ) { is_const = 0; break; }
+      }
+      if ( is_const ) {
+        ca->stride_kind  = 1;
+        ca->stride_start = ca->indices[0];
+        ca->stride_step  = step;
+      }
+    } else if ( count == 1 ) {
+      ca->stride_kind  = 1;
+      ca->stride_start = ca->indices[0];
+      ca->stride_step  = 1;
+    }
   }
 
-  ca->ptr       = NULL;
-  ca->mask      = NULL;
   ca->dim       = &(ca->_dim);
   ca->dim[0]    = ca->elements;
 
-  ca->parent    = parent;
-  ca->attach    = 0;
-  ca->nosync    = 0;
-
   if ( ca_is_scalar(select) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
@@ -144,6 +196,9 @@ ca_select_new (CArray *parent, CArray *select)
   return (CArray*) ca;
 }
 
+/* Alias for source compatibility.  Both constructors produce a
+   snapshot view; the `share` name is retained because a handful of
+   internal call sites still pass a `share` flag. */
 CArray *
 ca_select_new_share (CArray *parent, CArray *select)
 {
@@ -158,18 +213,40 @@ free_ca_select (void *ap)
   CASelect *ca = (CASelect *) ap;
   if ( ca != NULL ) {
     ca_free(ca->mask);
-    if ( ! (ca->flags & CA_FLAG_SHARE_INDEX) ) {
-      ca_free(ca->select);
-    }
+    ca_free(ca->select);   /* the snapshot is always owned */
+    if ( ca->indices ) xfree(ca->indices);
     xfree(ca);
   }
 }
 
-void ca_select_to_ptr (CArray *ca, CArray *select, char *ptr);
-void ca_select_from_ptr (CArray *ca, CArray *select, char *ptr);
-void ca_select_fill (CArray *ca, CArray *select, char *valp);
-void ca_select_to_carray (CArray *ca, CArray *select, CArray *cs);
-void ca_select_from_carray (CArray *ca, CArray *select, CArray *cs);
+/* ------------------------------------------------------------------- */
+/* Producer for the per-axis descriptor engine: emit a single 1-D axis.
+   Writes 1 entry into `out` and `out_parent_dims`.  parent_axis_dims[0]
+   is the flattened parent length, so the engine treats the parent as
+   1-D regardless of its original shape. */
+
+void
+ca_select_describe_axes (void *ap, ca_axis_desc_t *out,
+                         ca_size_t *out_parent_dims)
+{
+  CASelect *ca = (CASelect *) ap;
+  out_parent_dims[0] = ca->parent->elements;
+  if ( ca->stride_kind ) {
+    /* Constant-step run: emit STRIDE so the engine's contig-memcpy
+       fast path is available (all-TRUE, block-TRUE, equally-spaced). */
+    out[0].kind    = CA_AXIS_KIND_STRIDE;
+    out[0].count   = ca->elements;
+    out[0].start   = ca->stride_start;
+    out[0].step    = ca->stride_step;
+    out[0].indices = NULL;
+  } else {
+    out[0].kind    = CA_AXIS_KIND_INDEX;
+    out[0].count   = ca->elements;
+    out[0].start   = 0;
+    out[0].step    = 0;
+    out[0].indices = ca->indices;
+  }
+}
 
 /* ------------------------------------------------------------------- */
 
@@ -180,107 +257,146 @@ ca_select_func_clone (void *ap)
   return ca_select_new_share(ca->parent, ca->select);
 }
 
-static char *
-ca_select_func_ptr_at_addr (void *ap, ca_size_t addr)
-{
-  CASelect *ca = (CASelect *) ap;
-
-  if ( ca->ptr ) {
-    return ca->ptr + ca->bytes * addr;
-  }
-  else {
-    ca_size_t n, i, a;
-    ca_size_t elements = ca->select->elements;
-    boolean8_t  s;
-
-    n = 0;
-    a = 0;
-
-    for (i=0; i<elements; i++) {
-      ca_fetch_addr(ca->select, i, &s);
-      if ( s ) {
-        if ( addr == a++ ) {
-          n = i;
-          break;
-        }
-      }
-    }
-
-    if ( ca_is_attached(ca->parent) ) {
-      return ca->parent->ptr + ca->bytes * n;
-    }
-    else {
-      return ca_ptr_at_addr(ca->parent, n);
-    }
-  }
-}
+static void ca_select_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *data, int dir);
 
-static char *
-ca_select_func_ptr_at_index (void *ap, ca_size_t *idx)
+static void
+ca_select_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
 {
-  CASelect *ca = (CASelect *) ap;
-  ca_size_t addr = idx[0];
-
-  if ( ca->ptr ) {
-    return ca->ptr + ca->bytes * addr;
-  }
-  else {
-    return ca_select_func_ptr_at_addr(ca, idx[0]);
-  }
+  ca_select_func_xfer_addrs(ap, 1, &idx[0], data, dir);
 }
 
+/* Translate the incoming address list through ca->indices and deliver
+   to the parent in one call.
+
+   Fast path: when `addrs` covers the whole view sequentially and the
+   parent is attached, the pre-built ca->indices is handed straight to
+   the descriptor engine (zero copy, no ALLOCV).  This is the same
+   1-D-INDEX-over-flat-parent dispatch attach / sync use, so a chain
+   like `a[idx_2d]` (which reshape/CAGrid folds down to whole-view
+   sequential addrs on CASelect) also lands on the fast path. */
 static void
-ca_select_func_fetch_addr (void *ap, ca_size_t addr, void *ptr)
+ca_select_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
+                           void *data, int dir)
 {
-  CASelect *ca = (CASelect *) ap;
-  ca_size_t n, i, a;
-  ca_size_t elements = ca->select->elements;
-  boolean8_t  s;
-  n = 0;
-  a = 0;
-  for (i=0; i<elements; i++) {
-    ca_fetch_addr(ca->select, i, &s);
-    if ( s ) {
-      if ( addr == a++ ) {
-        n = i;
-        break;
+  CASelect  *ca = (CASelect *) ap;
+  CArray    *parent = ca->parent;
+  ca_size_t *paddrs;
+  ca_size_t  i, base;
+  volatile VALUE holder;
+
+  if ( n == ca->elements
+       && ca_xfer_addrs_is_sequential_run(n, addrs, &base) && base == 0 ) {
+    CArray *eff_parent = ca_resolve_attached_root_via_identity(parent);
+    if ( eff_parent->ptr ) {
+      ca_axis_desc_t sub_axes[1];
+      ca_size_t      parent_axis_dims[1];
+      parent_axis_dims[0] = parent->elements;
+      if ( ca->stride_kind ) {
+        sub_axes[0].kind    = CA_AXIS_KIND_STRIDE;
+        sub_axes[0].count   = ca->elements;
+        sub_axes[0].start   = ca->stride_start;
+        sub_axes[0].step    = ca->stride_step;
+        sub_axes[0].indices = NULL;
+      } else {
+        sub_axes[0].kind    = CA_AXIS_KIND_INDEX;
+        sub_axes[0].count   = ca->elements;
+        sub_axes[0].start   = 0;
+        sub_axes[0].step    = 0;
+        sub_axes[0].indices = ca->indices;
+      }
+      if ( dir == CA_XFER_GET ) {
+        ca_axis_dispatch_gather(eff_parent, parent_axis_dims, sub_axes, 1,
+                                ca->bytes, ca->elements, NULL, (char *) data);
+      } else {
+        ca_axis_dispatch_scatter(eff_parent, parent_axis_dims, sub_axes, 1,
+                                 ca->bytes, ca->elements, (char *) data);
       }
+      return;
     }
   }
-  ca_fetch_addr(ca->parent, n, ptr);
-}
 
-static void
-ca_select_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
-{
-  ca_select_func_fetch_addr(ap, idx[0], ptr);
+  /* Per-cell remap fallback (arbitrary addrs or unattached parent). */
+  paddrs = ALLOCV_N(ca_size_t, holder, n);
+  for ( i = 0; i < n; i++ ) {
+    paddrs[i] = ca->indices[addrs[i]];
+  }
+  ca_xfer_addrs(ca->parent, n, paddrs, data, dir);
+  ALLOCV_END(holder);
 }
 
+/* CASelect is the never-fold gather boundary: the incoming strided
+   region request describes a 1-D access into the selection, which
+   the view translates to a parent address list and delegates in one
+   call.  `data` is contiguous (row-major over counts).
+
+   Access into the selection is
+     position = starts[0] + i * (strides[0] / bytes)
+   and ca->indices[position] is the parent address.  ca->indices is a
+   construction-time snapshot, so no attach is required. */
 static void
-ca_select_func_store_addr (void *ap, ca_size_t addr, void *ptr)
+ca_select_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
+                            ca_size_t *strides, void *data, int dir)
 {
-  CASelect *ca = (CASelect *) ap;
-  ca_size_t n, i, a;
-  ca_size_t elements = ca->select->elements;
-  boolean8_t  s;
-  n = 0;
-  a = 0;
-  for (i=0; i<elements; i++) {
-    ca_fetch_addr(ca->select, i, &s);
-    if ( s ) {
-      if ( addr == a++ ) {
-        n = i;
-        break;
+  CASelect  *ca = (CASelect *) ap;
+  CArray    *parent = ca->parent;
+  ca_size_t  n = counts[0];
+  ca_size_t  step = strides[0] / ca->bytes;   /* element step (may be negative) */
+  ca_size_t  start = starts[0];
+
+  /* Attached-parent fast path: translate the sub-region request
+     (start / n / step over the 1-D INDEX view) into a transient
+     ca_axis_desc_t[1] and dispatch through the engine directly,
+     without calling ca_attach(parent).  Collapses the per-cell
+     ca_xfer_addrs loop into a single batched engine call. */
+  if ( parent->ptr ) {
+    ca_axis_desc_t sub_axes[1];
+    ca_size_t      parent_axis_dims[1];
+    ca_size_t     *index_buf = NULL;
+    volatile VALUE index_holder = Qnil;
+
+    parent_axis_dims[0] = parent->elements;  /* parent flattened */
+    sub_axes[0].kind  = CA_AXIS_KIND_INDEX;
+    sub_axes[0].count = n;
+    sub_axes[0].start = 0;
+    sub_axes[0].step  = 0;
+
+    if ( step == 1 ) {
+      /* zero-copy pointer offset into precomputed indices[] */
+      sub_axes[0].indices = ca->indices + start;
+    } else {
+      /* sub-sampled or reversed: materialise sub-indices */
+      ca_size_t i;
+      index_buf = ALLOCV_N(ca_size_t, index_holder, n);
+      for ( i = 0; i < n; i++ ) {
+        index_buf[i] = ca->indices[start + i * step];
       }
+      sub_axes[0].indices = index_buf;
+    }
+
+    if ( dir == CA_XFER_GET ) {
+      ca_axis_dispatch_gather(parent, parent_axis_dims, sub_axes, 1,
+                              ca->bytes, n, NULL, (char *)data);
+    } else {
+      ca_axis_dispatch_scatter(parent, parent_axis_dims, sub_axes, 1,
+                               ca->bytes, n, (char *)data);
     }
+
+    if ( index_buf != NULL ) ALLOCV_END(index_holder);
+    return;
   }
-  ca_store_addr(ca->parent, n, ptr);
-}
 
-static void
-ca_select_func_store_index (void *ap, ca_size_t *idx, void *ptr)
-{
-  ca_select_func_store_addr(ap, idx[0], ptr);
+  /* Fallback for unattached parent: per-cell ca_xfer_addrs. */
+  {
+    ca_size_t *paddrs;
+    ca_size_t  i;
+    volatile VALUE holder;
+    paddrs = ALLOCV_N(ca_size_t, holder, n);
+    for ( i = 0; i < n; i++ ) {
+      paddrs[i] = ca->indices[start + i * step];
+    }
+    ca_xfer_addrs(parent, n, paddrs, data, dir);
+    ALLOCV_END(holder);
+  }
 }
 
 static void
@@ -288,25 +404,34 @@ ca_select_func_allocate (void *ap)
 {
   CASelect *ca = (CASelect *) ap;
   ca_attach(ca->parent);
-  /* ca->ptr = ALLOC_N(char, ca_length(ca)); */
-  ca->ptr = malloc_with_check(ca_length(ca));  
+  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];
   ca_attach(ca->parent);
-  /* ca->ptr = ALLOC_N(char, ca_length(ca)); */
-  ca->ptr = malloc_with_check(ca_length(ca));  
-  ca_select_to_ptr(ca->parent, ca->select, ca->ptr);
+  ca_select_describe_axes(ca, desc, pdims);
+  ca->ptr = ca_axis_dispatch_attach(ca->parent, pdims, desc, ca->ndim,
+                                    ca->bytes, ca->elements, NULL);
 }
 
 static void
 ca_select_func_sync (void *ap)
 {
   CASelect *ca = (CASelect *) ap;
-  ca_select_from_ptr(ca->parent, ca->select, ca->ptr);
+  ca_axis_desc_t desc[CA_RANK_MAX];
+  ca_size_t      pdims[CA_RANK_MAX];
+  ca_select_describe_axes(ca, desc, pdims);
+  ca_axis_dispatch_scatter(ca->parent, pdims, desc, ca->ndim, ca->bytes,
+                           ca->elements, ca->ptr);
   ca_sync(ca->parent);
 }
 
@@ -314,37 +439,83 @@ static void
 ca_select_func_detach (void *ap)
 {
   CASelect *ca = (CASelect *) ap;
-  free(ca->ptr);
+  xfree(ca->ptr);
   ca->ptr = NULL;
   ca_detach(ca->parent);
 }
 
+/* Fast-path core used by xfer_all's attached-parent branch and the
+   cold-parent 2-pass scratch branch below. */
 static void
-ca_select_func_copy_data (void *ap, void *ptr)
+ca_select_func_run_fast_path (CASelect *ca, char *data, int dir)
 {
-  CASelect *ca = (CASelect *) ap;
-  ca_attach(ca->parent);
-  ca_select_to_ptr(ca->parent, ca->select, ptr);
-  ca_detach(ca->parent);
+  ca_axis_desc_t desc[CA_RANK_MAX];
+  ca_size_t      pdims[CA_RANK_MAX];
+  ca_select_describe_axes(ca, desc, pdims);
+  if ( dir == CA_XFER_GET ) {
+    ca_axis_dispatch_gather(ca->parent, pdims, desc, ca->ndim, ca->bytes,
+                            ca->elements, NULL, data);
+  } else {
+    ca_axis_dispatch_scatter(ca->parent, pdims, desc, ca->ndim, ca->bytes,
+                             ca->elements, data);
+  }
 }
 
+/* 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_sync_data (void *ap, void *ptr)
+ca_select_func_xfer_all (void *ap, void *data, int dir)
 {
   CASelect *ca = (CASelect *) ap;
-  ca_attach(ca->parent);
-  ca_select_from_ptr(ca->parent, ca->select, ptr);
-  ca_sync(ca->parent);
-  ca_detach(ca->parent);
+  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);
+  }
 }
 
-
 static void
 ca_select_func_fill_data (void *ap, void *ptr)
 {
   CASelect *ca = (CASelect *) ap;
+  ca_axis_desc_t desc[CA_RANK_MAX];
+  ca_size_t      pdims[CA_RANK_MAX];
+
+  /* Writing only the selected cells still went through a whole-parent
+     attach and sync.  Where that attach is a gather rather than an alias,
+     the unselected cells make the round trip for nothing -- and through a
+     lossy transform layer they do not come back the same.  Descend per cell
+     instead; the cost then follows the selection.  Kept in step with the
+     CAStride form, so both spellings of a partial fill behave alike.
+     (PROPOSAL_PARTIAL_FILL_WHOLE_ROOT_WRITEBACK.md sections 3.3 / 6.2) */
+  if ( !ca_is_attached(ca->parent) && !ca_attach_is_alias(ca->parent) ) {
+    /* indices[] are already the selected positions in the parent's flat
+       space, so the selection passes down as it stands -- one hop, no
+       attach, and the unselected cells are never named. */
+    ca_fill_addrs(ca->parent, ca->elements, ca->indices, ptr);
+    return;
+  }
+
   ca_attach(ca->parent);
-  ca_select_fill(ca->parent, ca->select, 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);
 }
@@ -362,23 +533,20 @@ ca_select_func_create_mask (void *ap)
 
 ca_operation_function_t ca_select_func = {
   CA_OBJ_SELECT,
-  CA_VIRTUAL_ARRAY,
+  CA_VIEW_ARRAY,
   free_ca_select,
   ca_select_func_clone,
-  ca_select_func_ptr_at_addr,
-  ca_select_func_ptr_at_index,
-  ca_select_func_fetch_addr,
-  ca_select_func_fetch_index,
-  ca_select_func_store_addr,
-  ca_select_func_store_index,
   ca_select_func_allocate,
   ca_select_func_attach,
   ca_select_func_sync,
   ca_select_func_detach,
-  ca_select_func_copy_data,
-  ca_select_func_sync_data,
   ca_select_func_fill_data,
   ca_select_func_create_mask,
+  ca_select_func_xfer_index,
+  ca_select_func_xfer_addrs,
+  NULL,                       /* fold_stride: never fold — gather boundary */
+  ca_select_func_xfer_stride,
+  ca_select_func_xfer_all,
 };
 
 /* ------------------------------------------------------------------- */
@@ -399,13 +567,16 @@ rb_ca_select_new (VALUE cary, VALUE select)
   }
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, cary);
-  rb_ca_data_type_inherit(obj, cary);
+  CA_FACE_LIFT_IF_FACE(obj, cary, parent);
   return obj;
 }
 
 VALUE
 rb_ca_select_new_share (VALUE cary, VALUE select)
 {
+  /* Alias of the snapshot constructor.  The `referred_index` ivar is
+     set so consumers that expect the original selector to be
+     reachable from the view object continue to find it. */
   volatile VALUE obj;
   CArray *parent, *cselect;
   CASelect *ca;
@@ -419,136 +590,12 @@ rb_ca_select_new_share (VALUE cary, VALUE select)
   }
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, cary);
-  rb_ca_data_type_inherit(obj, cary);
   rb_ivar_set(obj, rb_intern("referred_index"), select);
   return obj;
 }
 
 /* -------------------------------------------------------------------- */
 
-#define proc_select_to_ptr(type) \
-  { \
-    type *p = (type *) ptr; \
-    type *q = (type *) ca->ptr; \
-    for (i=ca->elements; i; i--) { \
-      if ( *s ) { \
-        *p++ = *q; \
-      } \
-      q++; s++; \
-    } \
-  }
-
-void
-ca_select_to_ptr (CArray *ca, CArray *select, char *ptr)
-{
-  boolean8_t *s = (boolean8_t*) select->ptr;
-  ca_size_t i;
-
-  switch ( ca->bytes ) {
-  case 1: proc_select_to_ptr(int8_t); break;
-  case 2: proc_select_to_ptr(int16_t); break;
-  case 4: proc_select_to_ptr(int32_t); break;
-  case 8: proc_select_to_ptr(float64_t); break;
-  default: {
-    char *p = ptr, *q = ca->ptr;
-    ca_size_t bytes = ca->bytes;
-    for (i=ca->elements; i; i--) {
-      if ( *s ) {
-        memcpy(q, p, bytes);
-        p+=bytes;
-      }
-      q+=bytes; s++;
-    }
-    break;
-  }
-  }
-
-}
-
-/* ------------------------------------------------------------------- */
-
-#define proc_select_from_ptr(type) \
-  { \
-    type *p = (type *) ptr; \
-    type *q = (type *) ca->ptr; \
-    for (i=ca->elements; i; i--) { \
-      if ( *s ) { \
-        *q = *p++; \
-      } \
-      q++; s++; \
-    } \
-  }
-
-void
-ca_select_from_ptr (CArray *ca, CArray *select, char *ptr)
-{
-  boolean8_t *s = (boolean8_t *) select->ptr;
-  ca_size_t i;
-
-  switch ( ca->bytes ) {
-  case 1: proc_select_from_ptr(int8_t); break;
-  case 2: proc_select_from_ptr(int16_t); break;
-  case 4: proc_select_from_ptr(int32_t); break;
-  case 8: proc_select_from_ptr(float64_t); break;
-  default: {
-    char *p = ptr;
-    char *q = ca->ptr;
-    ca_size_t bytes = ca->bytes;
-    for (i=ca->elements; i; i--) {
-      if ( *s ) {
-        memcpy(q, p, bytes);
-        p+=bytes;
-      }
-      q+=bytes; s++;
-    }
-    break;
-  }
-  }
-
-}
-
-/* ------------------------------------------------------------------- */
-
-#define proc_select_fill(type) \
-  { \
-    type *q = (type *) ca->ptr; \
-    type v = *(type *) valp; \
-    for (i=ca->elements; i; i--) { \
-      if ( *s ) { \
-        *q = v; \
-      } \
-      q++; s++; \
-    } \
-  }
-
-void
-ca_select_fill (CArray *ca, CArray *select, char *valp)
-{
-  boolean8_t *s = (boolean8_t *) select->ptr;
-  ca_size_t i;
-
-  switch ( ca->bytes ) {
-  case 1: proc_select_fill(int8_t); break;
-  case 2: proc_select_fill(int16_t); break;
-  case 4: proc_select_fill(int32_t); break;
-  case 8: proc_select_fill(float64_t); break;
-  default: {
-    char *q = ca->ptr;
-    ca_size_t bytes = ca->bytes;
-    for (i=ca->elements; i; i--) {
-      if ( *s ) {
-        memcpy(q, valp, bytes);
-      }
-      q+=bytes; s++;
-    }
-    break;
-  }
-  }
-
-}
-
-/* ------------------------------------------------------------------- */
-
 static VALUE
 rb_cm_s_allocate (VALUE klass)
 {
@@ -564,19 +611,20 @@ rb_cm_initialize_copy (VALUE self, VALUE other)
   TypedData_Get_Struct(self,  CASelect, &caselect_data_type, ca);
   TypedData_Get_Struct(other, CASelect, &caselect_data_type, cs);
 
-  /* share select info */
+  /* 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);
 
   return self;
 }
 
 void
-Init_ca_obj_select ()
+Init_ca_obj_select (void)
 {
-  /* rb_cCASelect, CA_OBJ_SELECT are defined in rb_carray.c */
+  /* rb_cCASelect and CA_OBJ_SELECT are defined in ruby_carray.c;
+     this file only registers the constant + allocator. */
   rb_define_const(rb_cObject, "CA_OBJ_SELECT", INT2NUM(CA_OBJ_SELECT));
 
   rb_define_alloc_func(rb_cCASelect, rb_cm_s_allocate);
   rb_define_method(rb_cCASelect, "initialize_copy", rb_cm_initialize_copy, 1);
 }
-