carray 3.0.4 → 3.0.6

data/ext/ca_obj_monop.c

@@ -370,12 +370,19 @@ apply_monop_in_place (uint16_t op_id, int8_t cur_dt,
   fn(slab_n, mask, (char *) data, 1, (char *) data, 1);
 }
 
-/* Minimal CArray-shaped stub used as ca_cast_block's data_type-only carrier.
-   ca_cast_block only reads data_type to index into ca_cast_func_table.  */
-typedef struct {
-  int16_t obj_type;
-  int8_t  data_type;
-} ca_data_type_stub_t;
+/* A zeroed CArray carrying only data_type and bytes, handed to
+   ca_cast_block in place of a real array.  It is a whole CArray, not a
+   shorter struct cast to one: ca_cast_block reads data_type through a
+   CArray pointer, and a fixlen cast reads bytes as well.  */
+static CArray
+ca_data_type_stub (int8_t data_type)
+{
+  CArray stub;
+  memset(&stub, 0, sizeof(stub));
+  stub.data_type = data_type;
+  stub.bytes     = ca_sizeof[data_type];
+  return stub;
+}
 
 /* Pull leaf into the output buffer.  Three paths:
 
@@ -428,8 +435,8 @@ pull_leaf_with_optional_cast (CArray *leaf, uint16_t innermost_op,
   if ( has_cast_at_leaf ) {
     /* Path 2: cast scratch → data with output layout in target data_type.  */
     int8_t target_dt = (int8_t)(innermost_op - CA_MONOP_CAST_BASE);
-    ca_data_type_stub_t src_stub = { 0, leaf->data_type };
-    ca_data_type_stub_t dst_stub = { 0, target_dt };
+    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);
     result_dt = target_dt;
   } else {
@@ -446,8 +453,9 @@ pull_leaf_with_optional_cast (CArray *leaf, uint16_t innermost_op,
 /* Evaluate (GET) or write (PUT, writable views only) the cells a request
    names; `data` holds them packed. */
 static void
-ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
+ca_monop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
 {
+  CAMonOp *mo = (CAMonOp *) node;
   uint16_t op_chain[CA_MAX_LAZY_DEPTH];
   int chain_len = 0;
   CArray  *leaf;
@@ -555,6 +563,30 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
     chain_apply_count = chain_len - 1;
   }
 
+  /* The chain runs in place, so the buffer must hold slab_n cells of the
+     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. */
+  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);
+      if ( ca_sizeof[dt] > max_bytes ) max_bytes = ca_sizeof[dt];
+    }
+    if ( max_bytes > mo->bytes ) {
+      work = ( leaf->data_type == CA_OBJECT )
+               ? ca_lazy_arena_acquire_object((slab_n * max_bytes + sizeof(VALUE) - 1) / sizeof(VALUE))
+               : ca_lazy_arena_acquire(slab_n * max_bytes);
+      data = work;
+    }
+  }
+
   /* === 2. pull leaf into output buffer (with optional cast) === */
   cur_dt = pull_leaf_with_optional_cast(
     leaf,
@@ -576,8 +608,8 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
       ca_size_t src_bytes = ca_sizeof[cur_dt];
       ca_size_t total_bytes = slab_n * src_bytes;
       void *scratch;
-      ca_data_type_stub_t src_stub = { 0, cur_dt };
-      ca_data_type_stub_t dst_stub = { 0, target_dt };
+      CArray src_stub = ca_data_type_stub(cur_dt);
+      CArray dst_stub = ca_data_type_stub(target_dt);
 
       /* Copy current data → scratch (in src data_type), then cast scratch
          → data (in target data_type).  Required because in-place cast
@@ -604,6 +636,30 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
   if ( slab_mask ) {
     ca_lazy_arena_release(slab_mask);
   }
+  if ( work ) {
+    memcpy(out, work, slab_n * mo->bytes);
+    ca_lazy_arena_release(work);
+  }
+}
+
+/* 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. */
+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 ) ) {
+    chain[nchain++] = leaf;
+    leaf = ((CAView *) leaf)->parent;
+  }
+  ca_lazy_eval_recorded(mo, 1, &leaf, nchain, chain, ca_monop_eval_cells,
+                        req, data, dir);
 }
 
 static void
@@ -741,7 +797,7 @@ ca_monop_func_sync (void *ap)
     if ( ca->mask ) {
       ca_cast_block_with_mask(ca->elements, ca, ca->ptr,
                               ca->parent, ca->parent->ptr,
-                              (boolean8_t *) ca->parent->mask->ptr);
+                              (boolean8_t *) ca->mask->ptr);
     }
     else {
       ca_cast_block(ca->elements, ca, ca->ptr, ca->parent, ca->parent->ptr);
@@ -755,7 +811,9 @@ ca_monop_func_sync (void *ap)
     ca_byte_swap_buffer(ca->data_type, ca->bytes, ca->elements,
                         ca->parent->ptr);
   }
+  ca_view_pass_mask_to_parent(ca);
   ca_sync(ca->parent);
+  ca_view_sync_mask_after_parent(ca);
 }
 
 static void
@@ -812,6 +870,21 @@ ca_monop_func_create_mask (void *ap)
   }
 }
 
+/* For a writable cast: 1 and the data type it writes its parent in.  0 for
+   any other array. */
+int
+ca_monop_writable_cast_target (CArray *ca, int8_t *target)
+{
+  CAMonOp *mo = (CAMonOp *) ca;
+  if ( ca->obj_type != CA_OBJ_MONOP
+       || ! ca_monop_is_writable_view(mo->op_id)
+       || ! ca_monop_is_cast(mo->op_id) ) {
+    return 0;
+  }
+  *target = mo->parent->data_type;
+  return 1;
+}
+
 ca_operation_function_t ca_monop_func = {
   -1, /* CA_OBJ_MONOP, set at install time */
   CA_VIEW_ARRAY,
@@ -1116,6 +1189,7 @@ Init_ca_obj_monop (void)
   rb_define_const(rb_cCAMonOp, "OP_RAD_PI",  INT2NUM(CA_MONOP_RAD_PI));
   rb_define_const(rb_cCAMonOp, "OP_SIGN",    INT2NUM(CA_MONOP_SIGN));
   rb_define_const(rb_cCAMonOp, "OP_ARG_I",   INT2NUM(CA_MONOP_ARG_I));
+  rb_define_const(rb_cCAMonOp, "OP_BYTE_SWAP", INT2NUM(CA_MONOP_BYTE_SWAP));
   rb_define_const(rb_cCAMonOp, "CAST_BASE",  INT2NUM(CA_MONOP_CAST_BASE));
 
   rb_define_alloc_func(rb_cCAMonOp, rb_ca_monop_s_allocate);

data/ext/ca_obj_object.c

@@ -171,18 +171,66 @@ ca_object_empty_wrap (CArray *w)
   }
 }
 
+/* Moves the cells of a wrap (or of its lent mask, `w`) into an array of
+   their own, held by `holder` under `name`, and points `w` at them.  The
+   cells are those the hook left in the caller's buffer. */
+static void
+ca_object_keep_cells (VALUE holder, const char *name, CArray *w)
+{
+  volatile VALUE cells;
+  CArray *c;
+  cells = rb_carray_new(w->data_type, w->ndim, w->dim, w->bytes, NULL);
+  c = (CArray *) DATA_PTR(cells);
+  memcpy(c->ptr, w->ptr, (size_t) w->elements * w->bytes);
+  rb_ivar_set(holder, rb_intern(name), cells);
+  w->ptr = c->ptr;
+}
+
+/* Takes the caller's buffer back from a wrap the hook was lent, together
+   with `lent_mask`, the wrap of the data's mask bits it was lent with (or
+   NULL).  When the hook took a view of either, the view outlives the call,
+   so both keep their cells; otherwise both are left with none.  A mask the
+   hook made on the wrap is the wrap's own, with cells of its own. */
+static void
+ca_object_take_back (VALUE wrap, CArray *lent_mask)
+{
+  CArray *w = (CArray *) DATA_PTR(wrap);
+  CArray *m = ( lent_mask != NULL && w->mask == lent_mask ) ? lent_mask : NULL;
+  int viewed = ca_test_flag(w, CA_FLAG_LENT_VIEWED) ||
+               ( m != NULL && ca_test_flag(m, CA_FLAG_LENT_VIEWED) );
+  ca_unset_flag(w, CA_FLAG_LENT | CA_FLAG_LENT_VIEWED);
+  if ( lent_mask != NULL ) {
+    ca_unset_flag(lent_mask, CA_FLAG_LENT | CA_FLAG_LENT_VIEWED);
+  }
+  if ( viewed ) {
+    ca_object_keep_cells(wrap, "kept_cells", w);
+    if ( m != NULL ) {
+      ca_object_keep_cells(wrap, "kept_mask_cells", m);
+    }
+  }
+  else {
+    if ( m != NULL ) {
+      ca_object_empty_wrap(m);
+    }
+    ca_object_empty_wrap(w);
+  }
+}
+
 /* Calls copy_data / sync_data with a wrap of a caller's buffer, shaped as
-   the object, and takes the buffer back however the call leaves.  The wrap
-   shares the object's mask (the data's), and whatever mask it holds after
-   the call becomes the data's: a hook that writes masked values masks the
-   object's cells.  The data points at the buffer for the duration too, for
-   a hook that reads the object back while it runs. */
+   the object, and takes the buffer back however the call leaves.  When the
+   data has a mask, the wrap's mask is a wrap of its bits: a hook that writes
+   masked values masks the object's cells, and the data keeps its mask
+   whatever the hook does with the wrap's.  A mask the hook makes on a wrap
+   that had none is the wrap's own and goes with it.  The data points at the
+   buffer for the duration too, for a hook that reads the object back while
+   it runs. */
 
 typedef struct {
   CAObject *ca;
   char     *saved;
   ID        mid;
   VALUE     wrap;
+  CArray   *mask;      /* the wrap of the data's mask bits, or NULL */
 } ca_object_lend_t;
 
 static VALUE
@@ -196,15 +244,12 @@ static VALUE
 ca_object_lend_restore (VALUE varg)
 {
   ca_object_lend_t *l = (ca_object_lend_t *) varg;
-  CArray *w = (CArray *) DATA_PTR(l->wrap);
-  l->ca->data->mask = w->mask;
-  w->mask = NULL;
-  ca_object_empty_wrap(w);
   l->ca->data->ptr = l->saved;
+  ca_object_take_back(l->wrap, l->mask);
   return Qnil;
 }
 
-static void
+static VALUE
 ca_object_call_lending (CAObject *ca, void *ptr, const char *mid)
 {
   ca_object_lend_t l;
@@ -213,14 +258,21 @@ ca_object_call_lending (CAObject *ca, void *ptr, const char *mid)
   w = ca_wrap_new(data->data_type, data->ndim, data->dim, data->bytes,
                   NULL, (char *) ptr);
   l.wrap  = ca_wrap_struct(w);
-  w->mask = data->mask;
+  l.mask  = NULL;
+  if ( data->mask != NULL ) {
+    l.mask = (CArray *) ca_wrap_new(CA_BOOLEAN, data->ndim, data->dim, 0,
+                                    NULL, data->mask->ptr);
+    ca_set_flag(l.mask, CA_FLAG_LENT);
+    w->mask = l.mask;
+  }
+  ca_set_flag(w, CA_FLAG_LENT);
   l.ca    = ca;
   l.saved = data->ptr;
   l.mid   = rb_intern(mid);
   data->ptr = (char *) ptr;
   rb_ensure(ca_object_lend_body, (VALUE) &l,
             ca_object_lend_restore, (VALUE) &l);
-  RB_GC_GUARD(l.wrap);
+  return l.wrap;
 }
 
 /* Calls recv.mid(*argv), where some of argv are transient wraps of a
@@ -253,7 +305,7 @@ ca_object_hook_release (VALUE varg)
   ca_object_hook_t *h = (ca_object_hook_t *) varg;
   int i;
   for ( i = 0; i < h->ntrans; i++ ) {
-    ca_object_empty_wrap((CArray *) DATA_PTR(h->trans[i]));
+    ca_object_take_back(h->trans[i], NULL);
   }
   return Qnil;
 }
@@ -742,7 +794,6 @@ ca_object_setup (CAObject *ca,
                int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes)
 {
   ca_size_t elements;
-  int8_t i;
 
   /* check arguments */
 
@@ -838,11 +889,10 @@ ca_object_mask_bytes (CAObject *ca)
   return (boolean8_t *) ca->mask->ptr;
 }
 
-/* Whether the mask of this object comes from its mask_* hooks.  Then a
-   fetched value says nothing about the mask: a cell the hooks mask stays
-   masked when its value is read, and only a fetcher answering UNDEF marks
-   one.  Without hooks the mask is what the fetches have answered, so a
-   value fetched clears the cell. */
+/* Whether the mask of this object comes from its mask_* hooks.  A fetched
+   value says nothing about the mask either way: a cell masked -- by the
+   hooks, or without hooks by a write of UNDEF or `mask =` -- stays masked
+   when its value is read, and only a fetcher answering UNDEF marks one. */
 static int
 ca_object_mask_from_hooks (CAObject *ca)
 {
@@ -871,9 +921,6 @@ ca_object_xfer_addr_one (CAObject *ca, ca_size_t addr, void *ptr, int dir)
         }
       }
       else {
-        if ( ! ca_object_mask_from_hooks(ca) && ca_has_mask(ca) ) {
-          ca_object_mask_bytes(ca)[addr] = 0;
-        }
         rb_ca_obj2ptr(ca->self, rval, ptr);
       }
     }
@@ -893,9 +940,6 @@ ca_object_xfer_addr_one (CAObject *ca, ca_size_t addr, void *ptr, int dir)
         }
       }
       else {
-        if ( ! ca_object_mask_from_hooks(ca) && ca_has_mask(ca) ) {
-          ca_object_mask_bytes(ca)[ca_index2addr(ca->mask, idx)] = 0;
-        }
         rb_ca_obj2ptr(ca->self, rval, ptr);
       }
     }
@@ -939,9 +983,6 @@ ca_object_xfer_index_one (CAObject *ca, ca_size_t *idx, void *ptr, int dir)
         }
       }
       else {
-        if ( ! ca_object_mask_from_hooks(ca) && ca_has_mask(ca) ) {
-          ca_object_mask_bytes(ca)[ca_index2addr(ca->mask, idx)] = 0;
-        }
         rb_ca_obj2ptr(ca->self, rval, ptr);
       }
     }
@@ -957,9 +998,6 @@ ca_object_xfer_index_one (CAObject *ca, ca_size_t *idx, void *ptr, int dir)
         }
       }
       else {
-        if ( ! ca_object_mask_from_hooks(ca) && ca_has_mask(ca) ) {
-          ca_object_mask_bytes(ca)[addr] = 0;
-        }
         rb_ca_obj2ptr(ca->self, rval, ptr);
       }
     }
@@ -1043,6 +1081,34 @@ ca_object_copy_bare_restore (VALUE arg)
   return Qnil;
 }
 
+/* copy_data of an object with no mask yet: an UNDEF the call writes lands
+   on a mask of the wrap's own, which the wrap takes away with it.  The
+   cells it marks are masked on the object, as a fetcher answering UNDEF
+   masks its cell, so a bulk read and a cell read give the same answer. */
+static void
+ca_object_adopt_undef_cells (CAObject *ca, VALUE wrap)
+{
+  CArray *wm = ((CArray *) DATA_PTR(wrap))->mask;
+  boolean8_t *bits;
+  ca_size_t i, n;
+  if ( wm == NULL || wm->ptr == NULL ) {
+    return;
+  }
+  n = ( wm->elements < ca->elements ) ? wm->elements : ca->elements;
+  for ( i = 0; i < n && ! wm->ptr[i]; i++ ) {
+    ;
+  }
+  if ( i == n ) {
+    return;
+  }
+  ca_create_mask(ca);
+  bits = ca_object_mask_bytes(ca);
+  for ( ; i < n; i++ ) {
+    if ( wm->ptr[i] ) bits[i] = 1;
+  }
+  RB_GC_GUARD(wrap);
+}
+
 static void
 ca_object_dispatch_copy (CAObject *ca, void *ptr)
 {
@@ -1057,7 +1123,26 @@ ca_object_dispatch_copy (CAObject *ca, void *ptr)
                 ca_object_copy_bare_restore, (VALUE) &c);
       return;
     }
-    ca_object_call_lending(ca, ptr, "copy_data");
+    if ( ca->data->mask != NULL ) {
+      /* Without hooks the mask is the object's own: a store of the values
+         into the array copy_data is handed (d[] = src) would clear it, so
+         the cells it held masked are masked again after the call, beside
+         those the call marks. */
+      CArray *m = ca->data->mask;
+      volatile VALUE vkept = rb_str_new(m->ptr, (long) m->elements);
+      const char *kept;
+      ca_size_t i;
+      ca_object_call_lending(ca, ptr, "copy_data");
+      kept = RSTRING_PTR(vkept);
+      m = ca->data->mask;
+      for ( i = 0; m != NULL && i < m->elements; i++ ) {
+        if ( kept[i] ) m->ptr[i] = 1;
+      }
+      RB_GC_GUARD(vkept);
+      return;
+    }
+    ca_object_adopt_undef_cells(ca,
+                                ca_object_call_lending(ca, ptr, "copy_data"));
   }
   else {
     ca_size_t addr;
@@ -1194,6 +1279,7 @@ ca_object_wrap_transient (int8_t data_type, ca_size_t bytes,
   }
 
   wrap = ca_wrap_new(data_type, ndim, dim, bytes, NULL, (char *) data);
+  ca_set_flag(wrap, CA_FLAG_LENT);
   return ca_wrap_struct(wrap);
 }
 

data/ext/ca_obj_record.c

@@ -309,6 +309,9 @@ rb_ca_record_s_wrap (int argc, VALUE *argv, VALUE klass)
     rb_scan_args(argc, argv, "2", &entity_val, &data_class);
   }
   rb_check_carray_object(entity_val);
+  /* A record array (or another Face) is wrapped from its storage, so the
+     new record is not a Face over a Face. */
+  entity_val = rb_ca_strip_face_value(entity_val);
   return ca_record_build(klass, data_class, entity_val);
 }
 

data/ext/ca_obj_reduce.c

@@ -56,6 +56,10 @@ ca_reduce_setup (CAReduce *ca, CArray *parent, ca_size_t count, ca_size_t offset
              "[BUG] CAReduce can't inherit other than boolean array");
   }
 
+  if ( count <= 0 ) {
+    rb_raise(rb_eArgError, "CAReduce: count should be positive");
+  }
+
   /* ca == NULL asks for the checks above only, so that a constructor can
      run them before it allocates. */
   if ( ca == NULL ) {
@@ -123,7 +127,11 @@ ca_reduce_func_clone (void *ap)
 /* addr-list logic lives in xfer_addrs: GET = OR-reduce `count` adjacent parent
    bytes per addr; PUT = broadcast the value to all `count` parent cells.
    fetch_addr/store_addr forward (n==1), xfer_index = index2addr then xfer_addrs.
-   All forward to a single home; the legacy slots are removed at step 5. */
+
+   A true PUT onto a cell that already reads true leaves the parent cells
+   as they are.  Every sync of a view over a CAReduce sends back its cells,
+   changed or not; broadcasting an unchanged true would mask the parent
+   cells under it that were not masked. */
 static void
 ca_reduce_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
                            void *data, int dir)
@@ -143,6 +151,16 @@ ca_reduce_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
       *(char*)cell = v;
     }
     else {
+      if ( *(char *) cell ) {
+        char q, v = 0;
+        for (i=0; i<ca->count; i++) {
+          ca_fetch_addr(ca->parent, addr*ca->count + i + ca->offset, &q);
+          if ( q ) { v = 1; break; }
+        }
+        if ( v ) {
+          continue;
+        }
+      }
       for (i=0; i<ca->count; i++) {
         ca_store_addr(ca->parent, addr*ca->count + i + ca->offset, cell);
       }

data/ext/ca_obj_refer.c

@@ -16,6 +16,7 @@
 #include "carray.h"
 #include "carray_internal.h"   /* per-obj_type view constructors */
 #include "ca_obj_face.h"  /* CA_FACE_LIFT_IF_FACE for CARecord parent */
+#include "ruby/thread_native.h"
 
 extern ca_operation_function_t ca_stride_func;
 
@@ -145,7 +146,10 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   ca_stride_setup_view((CAStride *) ca, CA_OBJ_REFER, parent,
                        data_type, bytes, ndim, dim, strides, base_offset);
 
-  if (ca_is_scalar(parent)) {
+  /* A refer of a scalar stays one only while it is one cell along one
+     axis, as a scalar is: read as narrower elements it is an array of
+     several, and read under another shape it is an array of that shape. */
+  if (ca_is_scalar(parent) && ca->elements == 1 && ca->ndim == 1) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
   return 0;
@@ -211,16 +215,20 @@ ca_refer_func_create_mask (void *ap)
   else if (ca->bytes < parent_bytes) {
     /* Divided reinterpret: one parent element splits into
        ratio = parent_bytes / bytes view elements.  Build a
-       CARepeat that broadcasts each parent mask bit across the
-       ratio sub-positions, then refer-reshape it to the view's
-       actual shape. */
+       repeat of two axes, (parent elements, ratio), that broadcasts
+       each parent mask bit across the ratio sub-positions, then
+       refer-reshape it to the view's actual shape.  Two axes whatever
+       the parent's rank, so a parent at CA_RANK_MAX needs no extra
+       one. */
     ca_size_t ratio = parent_bytes / ca->bytes;
-    ca_size_t count[CA_RANK_MAX];
-    int8_t i;
-    for (i = 0; i < ca->parent->ndim; i++) count[i] = 0;
-    count[ca->parent->ndim] = ratio;
+    ca_size_t mdim[2], mstrides[2];
+    mdim[0]     = ca->parent->elements;
+    mdim[1]     = ratio;
+    mstrides[0] = 1;
+    mstrides[1] = 0;
     ca->mask0 =
-      (CArray *) ca_repeat_new(ca->parent->mask, ca->parent->ndim + 1, count);
+      (CArray *) ca_stride_new(CA_OBJ_REPEAT, ca->parent->mask, CA_BOOLEAN, 1,
+                               2, mdim, mstrides, 0);
     ca_unset_flag(ca->mask0, CA_FLAG_READ_ONLY);
     /* mask0 has ratio cells per parent element, so the offset is counted
        in those. */
@@ -330,6 +338,59 @@ 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. */
+static st_table *ca_fold_sources;
+static rb_nativethread_lock_t ca_fold_lock;
+
+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);
+  rb_native_mutex_unlock(&ca_fold_lock);
+  ca_set_flag(view, CA_FLAG_FOLDED);
+}
+
+CArray *
+ca_fold_source (CArray *view)
+{
+  st_data_t src = 0;
+  rb_native_mutex_lock(&ca_fold_lock);
+  st_lookup(ca_fold_sources, (st_data_t) view, &src);
+  rb_native_mutex_unlock(&ca_fold_lock);
+  return (CArray *) src;
+}
+
+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);
+}
+
+/* Builds the folded view of `ca` for reshape / flatten: a CAStride over
+   `root`.  When `ca` is not `root` itself, it is recorded as the view's
+   source. */
+static VALUE
+ca_reshape_folded (VALUE self, CArray *ca, CArray *root, int8_t ndim,
+                   ca_size_t *dim, ca_size_t *strides, ca_size_t base)
+{
+  volatile VALUE obj;
+  CAStride *cs = ca_stride_new(CA_OBJ_STRIDE, root, ca->data_type, ca->bytes,
+                               ndim, dim, strides, base);
+  ca_keep_chain_flags((CArray *) cs, ca);
+  obj = ca_wrap_struct(cs);
+  rb_ca_set_parent(obj, self);
+  if ( root != ca ) {
+    ca_fold_note_source((CArray *) cs, ca);
+  }
+  CA_WRAPPER_LIFT(obj, self, ca);
+  return obj;
+}
+
 static int
 ca_reshape_try_strides (CArray *parent,
                         const ca_size_t *new_dim,
@@ -619,6 +680,9 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
+  if ( argc == 0 ) {
+    rb_raise(rb_eArgError, "reshape: give at least one axis");
+  }
   ca_check_rank_fits(argc, "reshape");
 
   /* Locate the (at most one) auto-infer placeholder.  `-1` is the
@@ -712,15 +776,8 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
     ca_size_t out_base;
     if (ca_reshape_try_strides(ca, new_dim, (int8_t) argc,
                                &out_root, out_strides, &out_base)) {
-      CAStride *cs = ca_stride_new(CA_OBJ_STRIDE, out_root,
-                                   ca->data_type, ca->bytes,
-                                   (int8_t) argc, new_dim,
-                                   out_strides, out_base);
-      ca_keep_chain_flags((CArray *) cs, ca);
-      obj = ca_wrap_struct(cs);
-      rb_ca_set_parent(obj, self);
-      CA_WRAPPER_LIFT(obj, self, ca);
-      return obj;
+      return ca_reshape_folded(self, ca, out_root, (int8_t) argc, new_dim,
+                               out_strides, out_base);
     }
   }
 
@@ -751,14 +808,8 @@ rb_ca_flatten (VALUE self)
     ca_size_t out_strides[1];
     ca_size_t out_base;
     if (ca_reshape_try_strides(ca, dim, 1, &out_root, out_strides, &out_base)) {
-      CAStride *cs = ca_stride_new(CA_OBJ_STRIDE, out_root,
-                                   ca->data_type, ca->bytes,
-                                   1, dim, out_strides, out_base);
-      ca_keep_chain_flags((CArray *) cs, ca);
-      obj = ca_wrap_struct(cs);
-      rb_ca_set_parent(obj, self);
-      CA_WRAPPER_LIFT(obj, self, ca);
-      return obj;
+      return ca_reshape_folded(self, ca, out_root, 1, dim,
+                               out_strides, out_base);
     }
   }
 
@@ -838,6 +889,9 @@ Init_ca_obj_refer (void)
   /* rb_cCARefer, CA_OBJ_REFER are defined in ruby_carray.c /
      carray_core.c.  Build the custom op table and override the
      baseline registration installed by Init_carray_core. */
+  ca_fold_sources = st_init_numtable();
+  rb_native_mutex_initialize(&ca_fold_lock);
+
   ca_refer_func = ca_stride_func;
   ca_refer_func.free_object = free_ca_refer;
   ca_refer_func.clone       = ca_refer_func_clone;