carray 3.0.6 → 3.0.7

data/ext/ca_obj_meld.c

@@ -883,8 +883,8 @@ ca_meld_func_allocate (void *ap)
 {
   CAMeld *ca = (CAMeld *) ap;
   ca_meld_mask_refresh(ca);
-  ca_attach_all(ca->parents, ca->n_parents);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, ca->n_parents,
+                                       ca->parents);
 }
 
 static VALUE
@@ -1129,7 +1129,7 @@ rb_ca_meld_new (VALUE parents_ary, int8_t meld_axis)
   }
   parents = ALLOCV_N(CArray *, holder, n);
   for ( i = 0; i < n; i++ ) {
-    VALUE p = rb_ary_entry(parents_ary, i);
+    volatile VALUE p = rb_ary_entry(parents_ary, i);
     rb_check_carray_object(p);
     TypedData_Get_Struct(p, CArray, &carray_data_type, parents[i]);
     ca_multi_parent_check_part(parents[i], "meld");
@@ -1185,7 +1185,7 @@ rb_ca_meld_initialize (int argc, VALUE *argv, VALUE self)
   }
   if ( ! NIL_P(axis_val) ) {
     CArray *ref;
-    VALUE first = rb_ary_entry(list, 0);
+    volatile VALUE first = rb_ary_entry(list, 0);
     rb_check_carray_object(first);
     TypedData_Get_Struct(first, CArray, &carray_data_type, ref);
     meld_axis = (int8_t) ca_normalize_axis_arg(
@@ -1195,7 +1195,7 @@ rb_ca_meld_initialize (int argc, VALUE *argv, VALUE self)
   ca_check_uninitialized(ca);
   parents = ALLOCV_N(CArray *, holder, n);
   for ( i = 0; i < n; i++ ) {
-    VALUE p = rb_ary_entry(list, i);
+    volatile VALUE p = rb_ary_entry(list, i);
     rb_check_carray_object(p);
     TypedData_Get_Struct(p, CArray, &carray_data_type, parents[i]);
     ca_multi_parent_check_part(parents[i], "meld");

data/ext/ca_obj_monop.c

@@ -64,6 +64,7 @@ extern int8_t CA_OBJ_LAZY_MARKER;
 extern int8_t CA_OBJ_BINOP;
 extern int8_t CA_OBJ_BINCMP;
 extern int8_t CA_OBJ_MONCMP;
+extern int8_t CA_OBJ_TRIOP;
 
 typedef struct CAMonOp {
   int16_t   obj_type;
@@ -169,6 +170,7 @@ ca_monop_view_is_single_cast (CArray *view)
      (so `1/zero` zero-check works).  */
   return ( p->obj_type != CA_OBJ_MONOP
         && p->obj_type != CA_OBJ_BINOP
+        && p->obj_type != CA_OBJ_TRIOP
         && p->obj_type != CA_OBJ_BINCMP
         && p->obj_type != CA_OBJ_MONCMP
         && p->obj_type != CA_OBJ_LAZY_MARKER );
@@ -338,14 +340,17 @@ ca_size_t ca_monop_materialise_call_count = 0;
 #define CA_MAX_LAZY_DEPTH 256
 #endif
 
-/* Whether a cast from `from` to `to` raises on a NaN cell: a float or
-   complex value has no integer for NaN. */
+/* Whether a cast from `from` to `to` can raise on a cell, so that it has to
+   skip the masked ones, whose values are not defined: a float or complex
+   value has no integer for NaN, a boolean takes only 0 and 1, and an object
+   cell may hold anything. */
 static int
-ca_monop_cast_refuses_nan (int8_t from, int8_t to)
+ca_monop_cast_can_raise (int8_t from, int8_t to)
 {
   int from_float = ( from == CA_FLOAT32 || from == CA_FLOAT64 ||
                      from == CA_CMPLX64 || from == CA_CMPLX128 );
-  return from_float && to >= CA_INT8 && to <= CA_UINT64;
+  return from == CA_OBJECT || to == CA_BOOLEAN
+         || ( from_float && to >= CA_INT8 && to <= CA_UINT64 );
 }
 
 /* Apply a single op in-place on `data` (src == dst, unit element stride).
@@ -384,7 +389,8 @@ ca_data_type_stub (int8_t data_type)
   return stub;
 }
 
-/* Pull leaf into the output buffer.  Three paths:
+/* Pull leaf into the output buffer.  `mask` marks the cells a cast must
+   skip, or is NULL.  Three paths:
 
    1. No size change (leaf.bytes == out.bytes): pull directly into
       `data` using the caller's `strides` (= output byte layout).
@@ -411,7 +417,8 @@ ca_data_type_stub (int8_t data_type)
 static int8_t
 pull_leaf_with_optional_cast (CArray *leaf, uint16_t innermost_op,
                               int has_cast_at_leaf, int8_t out_bytes,
-                              const ca_lazy_req_t *req, void *data)
+                              const ca_lazy_req_t *req, void *data,
+                              boolean8_t *mask)
 {
   ca_size_t leaf_bytes = leaf->bytes;
   ca_size_t slab_n = req->n;
@@ -437,7 +444,9 @@ pull_leaf_with_optional_cast (CArray *leaf, uint16_t innermost_op,
     int8_t target_dt = (int8_t)(innermost_op - CA_MONOP_CAST_BASE);
     CArray src_stub = ca_data_type_stub(leaf->data_type);
     CArray dst_stub = ca_data_type_stub(target_dt);
-    ca_cast_block(slab_n, &src_stub, scratch, &dst_stub, data);
+    ca_cast_block_skip_masked(slab_n, &src_stub, scratch, &dst_stub, data,
+                              ca_monop_cast_can_raise(leaf->data_type, target_dt)
+                                ? mask : NULL);
     result_dt = target_dt;
   } else {
     /* Path 3: memcpy scratch → start of data.  Mid-chain cast will
@@ -465,7 +474,7 @@ ca_monop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
   int       has_cast_at_leaf = 0;
   int       chain_apply_count;
   boolean8_t *slab_mask = NULL;
-  int       mask_taken = 0;
+  int       may_raise = 0;
 
   /* Writable-view op_ids (cast / byte_swap) use CAFake-style xfer_stride
      for both GET and PUT.  This avoids the chain-materialise inline path
@@ -483,11 +492,10 @@ ca_monop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
     v = ALLOCV_N(char, holder, n * parent_bytes);
     if ( dir == CA_XFER_GET ) {
       ca_lazy_req_pull(mo->parent, req, v, CA_XFER_GET);
-      if ( is_cast && ca_monop_cast_refuses_nan(mo->parent->data_type,
+      if ( is_cast && ca_monop_cast_can_raise(mo->parent->data_type,
                                                 mo->data_type) ) {
-        /* The cast raises on a NaN cell it is asked to convert; a masked
-           cell (mask_invalid keeps the NaN under the mask) is skipped.
-           The mask is copied off the arena first so a raise leaves no
+        /* The cast raises on a cell it cannot convert; a masked cell
+           (mask_invalid keeps a NaN under the mask) is skipped.  The mask is copied off the arena first so a raise leaves no
            arena slot held. */
         CArray *parent = mo->parent;
         boolean8_t *arena_mask = ca_lazy_req_mask(req, 1, &parent);
@@ -498,7 +506,7 @@ ca_monop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
           memcpy(m, arena_mask, n);
           ca_lazy_arena_release(arena_mask);
         }
-        ca_cast_block_with_mask(n, mo->parent, v, (CArray *) mo, data, m);
+        ca_cast_block_skip_masked(n, mo->parent, v, (CArray *) mo, data, m);
         if ( m ) {
           ALLOCV_END(mholder);
         }
@@ -567,25 +575,39 @@ ca_monop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
      widest type along it: the leaf, or a step that widens before a later
      one narrows (cmplx128.lazy.abs pulls 16-byte cells and answers 8-byte
      ones).  When that is wider than the output, run in a scratch and copy
-     the answer into `data` at the end. */
+     the answer into `data` at the end.  The same walk finds whether a step
+     can raise on a cell, so that it has to skip the masked ones. */
   void   *out  = data;
   void   *work = NULL;
   {
     ca_size_t max_bytes = leaf->bytes;
     int8_t    dt        = leaf->data_type;
     for ( i = chain_len - 1; i >= 0; i-- ) {
-      dt = ca_monop_is_cast(op_chain[i])
-             ? (int8_t)(op_chain[i] - CA_MONOP_CAST_BASE)
-             : ca_lazy_promote_monop(op_chain[i], dt);
+      int8_t next = ca_monop_is_cast(op_chain[i])
+                      ? (int8_t)(op_chain[i] - CA_MONOP_CAST_BASE)
+                      : ca_lazy_promote_monop(op_chain[i], dt);
+      if ( ca_monop_is_cast(op_chain[i])
+             ? ca_monop_cast_can_raise(dt, next)
+             : ca_op_raises_on_cell(CA_OP_KIND_MONOP, op_chain[i], dt) ) {
+        may_raise = 1;
+      }
+      dt = next;
       if ( ca_sizeof[dt] > max_bytes ) max_bytes = ca_sizeof[dt];
     }
     if ( max_bytes > mo->bytes ) {
-      work = ( leaf->data_type == CA_OBJECT )
+      /* Object cells stay in the buffer until a cast takes them to numbers;
+         a cast at the leaf takes them before they reach it. */
+      work = ( leaf->data_type == CA_OBJECT && ! has_cast_at_leaf )
                ? ca_lazy_arena_acquire_object((slab_n * max_bytes + sizeof(VALUE) - 1) / sizeof(VALUE))
                : ca_lazy_arena_acquire(slab_n * max_bytes);
       data = work;
     }
   }
+  /* raises: the walk above asks ca_op_raises_on_cell of each operation; a
+     cast, which is not one, has ca_monop_cast_can_raise */
+  if ( may_raise ) {
+    slab_mask = ca_lazy_req_mask(req, 1, &leaf);
+  }
 
   /* === 2. pull leaf into output buffer (with optional cast) === */
   cur_dt = pull_leaf_with_optional_cast(
@@ -593,7 +615,7 @@ ca_monop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
     has_cast_at_leaf ? op_chain[chain_len - 1] : 0,
     has_cast_at_leaf,
     (int8_t) mo->bytes,
-    req, data
+    req, data, slab_mask
   );
 
   /* === 3. apply remaining chain in reverse (leaf side → outermost) ===
@@ -620,14 +642,15 @@ ca_monop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
                   : ca_lazy_arena_acquire(total_bytes);
       ca_monop_scratch_acquire_count++;
       memcpy(scratch, data, total_bytes);
-      ca_cast_block(slab_n, &src_stub, scratch, &dst_stub, data);
+      if ( work ) {
+        ca_lazy_arena_untag_objects(work);
+      }
+      ca_cast_block_skip_masked(slab_n, &src_stub, scratch, &dst_stub, data,
+                                ca_monop_cast_can_raise(cur_dt, target_dt)
+                                  ? slab_mask : NULL);
       ca_lazy_arena_release(scratch);
       cur_dt = target_dt;
     } else {
-      if ( ! mask_taken && ca_op_raises_on_cell(CA_OP_KIND_MONOP, op_id, cur_dt) ) {
-        slab_mask  = ca_lazy_req_mask(req, 1, &leaf);
-        mask_taken = 1;
-      }
       apply_monop_in_place(op_id, cur_dt, slab_n, data,
                            ca_op_raises_on_cell(CA_OP_KIND_MONOP, op_id, cur_dt) ? slab_mask : NULL);
       cur_dt = ca_lazy_promote_monop(op_id, cur_dt);
@@ -645,16 +668,18 @@ ca_monop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
 /* A chain is evaluated from its leaf without evaluating the nodes under
    the top one, so those nodes are recorded with it: a cell that holds an
    expression over one of them is caught when it comes back, before a
-   longer chain over the same cells is built. */
+   longer chain over the same cells is built.  The walk stops where the
+   evaluation leaves the chain: a writable view evaluates its parent through
+   the transfer, as a leaf does, and that node records itself. */
 static void
 ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
 {
   CArray *chain[CA_MAX_LAZY_DEPTH];
   CArray *leaf = mo->parent;
   int     nchain = 0;
-  while ( nchain < CA_MAX_LAZY_DEPTH &&
-          ( leaf->obj_type == CA_OBJ_MONOP ||
-            leaf->obj_type == CA_OBJ_LAZY_MARKER ) ) {
+  while ( ! ca_monop_is_writable_view(mo->op_id) &&
+          nchain < CA_MAX_LAZY_DEPTH &&
+          leaf->obj_type == CA_OBJ_MONOP ) {
     chain[nchain++] = leaf;
     leaf = ((CAView *) leaf)->parent;
   }
@@ -711,9 +736,11 @@ ca_monop_func_allocate (void *ap)
      count.  Total ca_attach(parent) calls per view lifecycle = 1.  CAFake
      uses this same pattern.  */
   if ( ca_monop_is_writable_view(ca->op_id) ) {
-    ca_attach(ca->parent);
+    ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
+  }
+  else {
+    ca->ptr = ca_alloc_cells((CArray *) ca);
   }
-  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -741,20 +768,19 @@ ca_monop_func_attach (void *ap)
 
      Mirrors CAFake.attach.  */
   if ( ca_monop_is_writable_view(ca->op_id) ) {
-    ca_attach(ca->parent);
-    ca->ptr = ca_alloc_cells((CArray *) ca);
+    ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
     if ( ca_monop_is_cast(ca->op_id) ) {
       /* Cast parent.ptr (parent data_type) → ca.ptr (cast target data_type).
-         A cast that raises on NaN skips the masked cells; the parent's
+         A cast that can raise skips the masked cells; the parent's
          mask is attached with the parent.  A raise here is undone by
          ca_attach, which calls the detach slot once ca->ptr is set. */
       boolean8_t *m = NULL;
-      if ( ca_monop_cast_refuses_nan(ca->parent->data_type, ca->data_type)
+      if ( ca_monop_cast_can_raise(ca->parent->data_type, ca->data_type)
            && ca_has_mask(ca->parent) ) {
         m = (boolean8_t *) ca->parent->mask->ptr;
       }
-      ca_cast_block_with_mask(ca->elements, ca->parent, ca->parent->ptr,
-                              (CArray *) ca, ca->ptr, m);
+      ca_cast_block_skip_masked(ca->elements, ca->parent, ca->parent->ptr,
+                                (CArray *) ca, ca->ptr, m);
     }
     else {
       /* byte_swap: memcpy parent.ptr → ca.ptr (same data_type same bytes),
@@ -795,9 +821,9 @@ ca_monop_func_sync (void *ap)
     /* Cast view → parent: reverse-cast bulk.  */
     ca_update_mask(ca);
     if ( ca->mask ) {
-      ca_cast_block_with_mask(ca->elements, ca, ca->ptr,
-                              ca->parent, ca->parent->ptr,
-                              (boolean8_t *) ca->mask->ptr);
+      ca_cast_block_skip_masked(ca->elements, ca, ca->ptr,
+                                ca->parent, ca->parent->ptr,
+                                (boolean8_t *) ca->mask->ptr);
     }
     else {
       ca_cast_block(ca->elements, ca, ca->ptr, ca->parent, ca->parent->ptr);

data/ext/ca_obj_object.c

@@ -311,13 +311,13 @@ ca_object_hook_release (VALUE varg)
 }
 
 static void
-ca_object_call_transient (VALUE recv, const char *mid,
+ca_object_call_transient (VALUE recv, ID mid,
                           int argc, const VALUE *argv,
                           int ntrans, const VALUE *trans)
 {
   ca_object_hook_t h;
   h.recv   = recv;
-  h.mid    = rb_intern(mid);
+  h.mid    = mid;
   h.argc   = argc;
   h.argv   = argv;
   h.ntrans = ntrans;
@@ -472,7 +472,7 @@ ca_objmask_get_cells (CAObjectMask *ca, ca_size_t n, ca_size_t *addrs,
       VALUE args[2];
       args[0] = raddrs;
       args[1] = rdata;
-      ca_object_call_transient(ca->array, "mask_copy_addrs", 2, args, 2, args);
+      ca_object_call_transient(ca->array, rb_intern("mask_copy_addrs"), 2, args, 2, args);
     }
     return;
   }
@@ -520,7 +520,7 @@ ca_objmask_put_cells (CAObjectMask *ca, ca_size_t n, ca_size_t *addrs,
       VALUE args[2];
       args[0] = raddrs;
       args[1] = rdata;
-      ca_object_call_transient(ca->array, "mask_sync_addrs", 2, args, 2, args);
+      ca_object_call_transient(ca->array, rb_intern("mask_sync_addrs"), 2, args, 2, args);
     }
     return;
   }
@@ -707,7 +707,7 @@ ca_objmask_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
         args[1] = rcounts;
         args[2] = rsteps;
         args[3] = rdata;
-        ca_object_call_transient(ca->array, rb_id2name(mid_block),
+        ca_object_call_transient(ca->array, mid_block,
                                  4, args, 1, args + 3);
       }
       return;
@@ -1320,7 +1320,7 @@ ca_object_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
       VALUE args[2];
       args[0] = raddrs;
       args[1] = rdata;
-      ca_object_call_transient(ca->self, rb_id2name(mid), 2, args, 2, args);
+      ca_object_call_transient(ca->self, mid, 2, args, 2, args);
     }
     return;
   }
@@ -1417,7 +1417,7 @@ ca_object_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
         args[1] = rcounts;
         args[2] = rsteps;
         args[3] = rdata;
-        ca_object_call_transient(ca->self, rb_id2name(mid_block),
+        ca_object_call_transient(ca->self, mid_block,
                                  4, args, 1, args + 3);
       }
       return;
@@ -1494,7 +1494,7 @@ ca_object_func_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *ptr)
       VALUE args[2];
       args[0] = raddrs;
       args[1] = rval;
-      ca_object_call_transient(ca->self, rb_id2name(mid), 2, args, 1, args);
+      ca_object_call_transient(ca->self, mid, 2, args, 1, args);
     }
     return;
   }
@@ -1763,7 +1763,7 @@ rb_ca_object_initialize (int argc, VALUE *argv, VALUE self)
 
   ndim = RARRAY_LEN(rdim);
   for (i=0; i<ndim; i++) {
-    dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
+    dim[i] = ca_integer_arg(rb_ary_entry(rdim, i), "a dimension", NULL);
   }
 
   TypedData_Get_Struct(self, CAObject, &caobject_data_type, ca);

data/ext/ca_obj_reduce.c

@@ -216,8 +216,7 @@ static void
 ca_reduce_func_allocate (void *ap)
 {
   CAReduce *ca = (CAReduce *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
 }
 
 static void
@@ -226,8 +225,7 @@ ca_reduce_func_attach (void *ap)
   CAReduce *ca = (CAReduce *) ap;
   char *p;
   ca_size_t i;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
   p = ca->ptr;
   for (i=0; i<ca->elements; i++) {
     ca_reduce_func_xfer_addrs(ca, 1, &i, p, CA_XFER_GET);

data/ext/ca_obj_refer.c

@@ -339,16 +339,75 @@ ca_keep_chain_flags (CArray *view, CArray *src)
 }
 
 /* The sources of folded views (CA_FLAG_FOLDED), keyed by the view.  Views are
-   made and freed in any Ractor, so the table is taken under a lock. */
+   made and freed in any Ractor, so the table is taken under a lock.
+
+   st_insert can grow the table through ruby_xmalloc, which can run a GC, and
+   the GC frees folded views through ca_fold_forget.  ca_fold_forget therefore
+   never waits for the lock: when it is held (by the inserting thread itself,
+   or by a Ractor stopped for this GC) the view is put on a list instead, and
+   whoever takes the lock next removes the listed views first.  A freed view's
+   address can be reused by a new view only once that view is recorded, which
+   takes the lock and so empties the list first. */
 static st_table *ca_fold_sources;
 static rb_nativethread_lock_t ca_fold_lock;
 
+typedef struct ca_fold_gone {
+  struct ca_fold_gone *next;
+  st_data_t            key;
+} ca_fold_gone_t;
+
+static ca_fold_gone_t *ca_fold_gone_list = NULL;
+
+/* With the lock held: remove the views freed while it was held elsewhere.
+   The list is allocated with malloc, not xmalloc: it is grown inside a GC. */
+static void
+ca_fold_forget_gone (void)
+{
+  ca_fold_gone_t *g = __atomic_exchange_n(&ca_fold_gone_list, NULL, __ATOMIC_ACQ_REL);
+  while ( g ) {
+    ca_fold_gone_t *next = g->next;
+    st_data_t key = g->key;
+    st_delete(ca_fold_sources, &key, NULL);
+    free(g);
+    g = next;
+  }
+}
+
+static void
+ca_fold_lock_table (void)
+{
+  ca_native_lock_without_gvl(&ca_fold_lock);
+  ca_fold_forget_gone();
+}
+
+typedef struct {
+  CArray *view;
+  CArray *src;
+} ca_fold_note_arg_t;
+
+static VALUE
+ca_fold_insert (VALUE varg)
+{
+  ca_fold_note_arg_t *a = (ca_fold_note_arg_t *) varg;
+  st_insert(ca_fold_sources, (st_data_t) a->view, (st_data_t) a->src);
+  return Qnil;
+}
+
+/* The growth of the table can raise NoMemoryError; the lock is released
+   before that raise goes on. */
 void
 ca_fold_note_source (CArray *view, CArray *src)
 {
-  rb_native_mutex_lock(&ca_fold_lock);
-  st_insert(ca_fold_sources, (st_data_t) view, (st_data_t) src);
+  ca_fold_note_arg_t arg = { view, src };
+  int state = 0;
+  /* lock: st_insert can run a GC; a view it frees is listed, not waited for */
+  ca_fold_lock_table();
+  /* protect: releases a native lock; no array is held */
+  rb_protect(ca_fold_insert, (VALUE) &arg, &state);
   rb_native_mutex_unlock(&ca_fold_lock);
+  if ( state ) {
+    rb_jump_tag(state);
+  }
   ca_set_flag(view, CA_FLAG_FOLDED);
 }
 
@@ -356,7 +415,7 @@ CArray *
 ca_fold_source (CArray *view)
 {
   st_data_t src = 0;
-  rb_native_mutex_lock(&ca_fold_lock);
+  ca_fold_lock_table();
   st_lookup(ca_fold_sources, (st_data_t) view, &src);
   rb_native_mutex_unlock(&ca_fold_lock);
   return (CArray *) src;
@@ -366,9 +425,30 @@ void
 ca_fold_forget (CArray *view)
 {
   st_data_t key = (st_data_t) view;
-  rb_native_mutex_lock(&ca_fold_lock);
-  st_delete(ca_fold_sources, &key, NULL);
-  rb_native_mutex_unlock(&ca_fold_lock);
+  ca_fold_gone_t *g;
+  if ( rb_native_mutex_trylock(&ca_fold_lock) == 0 ) {
+    ca_fold_forget_gone();
+    st_delete(ca_fold_sources, &key, NULL);
+    rb_native_mutex_unlock(&ca_fold_lock);
+    return;
+  }
+  g = (ca_fold_gone_t *) malloc(sizeof(*g));
+  if ( g == NULL ) {
+    /* No memory for the list: wait for the lock, as there is no other way
+       to drop the record. */
+    /* lock: only with no memory for the list; the wait may block the GC */
+    rb_native_mutex_lock(&ca_fold_lock);
+    ca_fold_forget_gone();
+    st_delete(ca_fold_sources, &key, NULL);
+    rb_native_mutex_unlock(&ca_fold_lock);
+    return;
+  }
+  g->key  = key;
+  g->next = __atomic_load_n(&ca_fold_gone_list, __ATOMIC_ACQUIRE);
+  while ( ! __atomic_compare_exchange_n(&ca_fold_gone_list, &g->next, g, 0,
+                                        __ATOMIC_RELEASE, __ATOMIC_ACQUIRE) ) {
+    /* g->next now holds the head that won; try again on top of it */
+  }
 }
 
 /* Builds the folded view of `ca` for reshape / flatten: a CAStride over
@@ -557,11 +637,25 @@ rb_ca_refer_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
         rdim = rb_ca_dim(self);
       }
     }
+    if ( ca_is_face(ca) && ! rb_obj_is_data_class(rtype)
+         && ( data_type == CA_OBJECT || ca->data_type == CA_FIXLEN ) ) {
+      /* A Face's cells do not mean their storage bytes, and the view below
+         would be lifted back to a Face reading cells of the wrong width. */
+      CArray *storage = ca_strip_face(ca);
+      if ( ! ( data_type == ca->data_type && bytes == ca->bytes )
+           && ! ( data_type == storage->data_type
+                  && bytes == storage->bytes ) ) {
+        rb_raise(rb_eTypeError,
+                 "%"PRIsVALUE" has no view of its values in another data_type: "
+                 "#to_type gives the values, #parent.refer the raw storage",
+                 rb_obj_class(self));
+      }
+    }
     Check_Type(rdim, T_ARRAY);
     CA_CHECK_RANK_GIVEN(RARRAY_LEN(rdim));   /* before dim[] is filled */
     ndim = RARRAY_LEN(rdim);
-    for (i = 0; i < ndim; i++) dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
-    if (! NIL_P(roffset)) offset = NUM2SIZE(roffset);
+    for (i = 0; i < ndim; i++) dim[i] = ca_integer_arg(rb_ary_entry(rdim, i), "a dimension", NULL);
+    if (! NIL_P(roffset)) offset = ca_integer_arg(roffset, "the offset", NULL);
     /* When rtype is a data_class the result is a record array.  It is
        built on the storage, never on a Face, so that a Face stays on top
        of the chain: re-reading a record array as its own data_class lifts
@@ -723,7 +817,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
       new_dim[i] = ca->dim[src];
     }
     else {
-      new_dim[i] = NUM2SIZE(argv[i]);
+      new_dim[i] = ca_integer_arg(argv[i], "a dimension", "reshape");
     }
     /* A product too large to count cannot equal the element count; an
        extent of zero anywhere makes it zero whatever it overflowed to. */

data/ext/ca_obj_repeat.c

@@ -233,7 +233,7 @@ rb_ca_repeat (int argc, VALUE *argv, VALUE self)
       }
     }
     else {
-      count[i] = NUM2SIZE(argv[i]);
+      count[i] = ca_integer_arg(argv[i], "a repeat count", "repeat");
       if ( count[i] == 0 ) {
         rb_raise(rb_eArgError,
                  "zero repeat count specified in creating CARepeat object");

data/ext/ca_obj_roll.c

@@ -525,16 +525,14 @@ static void
 ca_roll_func_allocate (void *ap)
 {
   CARoll *ca = (CARoll *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
 }
 
 static void
 ca_roll_func_attach (void *ap)
 {
   CARoll *ca = (CARoll *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
   ca_roll_iterate_regions(ca, ca->ptr, 0);
 }
 

data/ext/ca_obj_select.c

@@ -465,9 +465,11 @@ ca_select_func_allocate (void *ap)
 {
   CASelect *ca = (CASelect *) ap;
   if ( ! ca_parent_lends_no_memory(ca->parent) ) {
-    ca_attach(ca->parent);
+    ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
+  }
+  else {
+    ca->ptr = ca_alloc_cells((CArray *) ca);
   }
-  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -482,10 +484,10 @@ ca_select_func_attach (void *ap)
     return;
   }
 
-  ca_attach(ca->parent);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
   ca_select_describe_axes(ca, desc, pdims);
-  ca->ptr = ca_axis_dispatch_attach(ca->parent, pdims, desc, ca->ndim,
-                                    ca->bytes, ca->elements, NULL);
+  ca_axis_dispatch_gather(ca->parent, pdims, desc, ca->ndim,
+                          ca->bytes, ca->elements, NULL, ca->ptr);
 }
 
 static void
@@ -600,7 +602,7 @@ ca_operation_function_t ca_select_func = {
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_select_new (VALUE cary, VALUE select)
+rb_ca_select_new (VALUE cary, volatile VALUE select)
 {
   volatile VALUE obj;
   CArray *parent, *cselect;

data/ext/ca_obj_select_axis.c

@@ -726,9 +726,11 @@ ca_select_axis_func_allocate (void *ap)
 {
   CASelectAxis *ca = (CASelectAxis *) ap;
   if ( ! ca_parent_lends_no_memory(ca->parent) ) {
-    ca_attach(ca->parent);
+    ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
+  }
+  else {
+    ca->ptr = ca_alloc_cells((CArray *) ca);
   }
-  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -743,10 +745,10 @@ ca_select_axis_func_attach (void *ap)
     return;
   }
 
-  ca_attach(ca->parent);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
   ca_select_axis_describe_axes(ca, desc, pdims);
-  ca->ptr = ca_axis_dispatch_attach(ca->parent, pdims, desc, ca->ndim,
-                                    ca->bytes, ca->elements, NULL);
+  ca_axis_dispatch_gather(ca->parent, pdims, desc, ca->ndim,
+                          ca->bytes, ca->elements, NULL, ca->ptr);
 }
 
 static void
@@ -1008,7 +1010,7 @@ rb_ca_select_axis (int argc, VALUE *argv, VALUE self)
   }
 
   for ( i = 0; i < argc; i++ ) {
-    VALUE arg = argv[i];
+    volatile VALUE arg = argv[i];
 
     if ( ! rb_obj_is_carray(arg) ) {
       ca_index_axis_key(arg, parent->dim[i], i,