carray 3.0.5 → 3.0.6

data/ext/ca_obj_bincmp.c

@@ -291,9 +291,11 @@ ca_bincmp_try_leaf_inplace (CArray *op, int8_t common_dt,
 
 /* Evaluate the cells a request names into `data` (packed, n cells). */
 static void
-ca_bincmp_eval (CABinCmp *bc, const ca_lazy_req_t *req, void *data)
+ca_bincmp_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
 {
+  CABinCmp *bc = (CABinCmp *) node;
   ca_size_t slab_n = req->n;
+  (void) dir;
   int8_t    k;
   void     *left_scratch, *right_scratch;
   ca_size_t left_bytes, right_bytes;
@@ -437,6 +439,12 @@ ca_bincmp_eval (CABinCmp *bc, const ca_lazy_req_t *req, void *data)
   if ( ! left_is_inplace  ) ca_lazy_arena_release(left_scratch);
 }
 
+static void
+ca_bincmp_eval (CABinCmp *bc, const ca_lazy_req_t *req, void *data)
+{
+  ca_lazy_eval_recorded(bc, 2, bc->operands, 0, NULL, ca_bincmp_eval_cells, req, data, CA_XFER_GET);
+}
+
 static void
 ca_bincmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                             ca_size_t *strides, void *data, int dir)

data/ext/ca_obj_binop.c

@@ -249,9 +249,11 @@ ca_size_t ca_binop_materialise_call_count = 0;
 
 /* Evaluate the cells a request names into `data` (packed, n cells). */
 static void
-ca_binop_eval (CABinOp *bo, const ca_lazy_req_t *req, void *data)
+ca_binop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
 {
+  CABinOp  *bo = (CABinOp *) node;
   ca_size_t slab_n = req->n;
+  (void) dir;
   int8_t    k;
   void     *scratch;
   volatile VALUE holder;
@@ -350,6 +352,13 @@ ca_binop_eval (CABinOp *bo, const ca_lazy_req_t *req, void *data)
   ca_lazy_arena_release(scratch);
 }
 
+static void
+ca_binop_eval (CABinOp *bo, const ca_lazy_req_t *req, void *data)
+{
+  ca_lazy_eval_recorded(bo, 2, bo->operands, 0, NULL, ca_binop_eval_cells,
+                        req, data, CA_XFER_GET);
+}
+
 static void
 ca_binop_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                            ca_size_t *strides, void *data, int dir)

data/ext/ca_obj_bitfield.c

@@ -480,7 +480,9 @@ ca_bitfield_func_sync (void *ap)
 {
   CABitfield *ca = (CABitfield *) ap;
   ca_bitfield_sync(ca);
+  ca_view_pass_mask_to_parent(ca);
   ca_sync(ca->parent);
+  ca_view_sync_mask_after_parent(ca);
 }
 
 static void

data/ext/ca_obj_byte_swap.c

@@ -491,7 +491,9 @@ ca_byte_swap_func_sync (void *ap)
   ca_byte_swap_apply(ca, tmp);
   memcpy(ca->parent->ptr, tmp, ca_length(ca));
   ALLOCV_END(holder);
+  ca_view_pass_mask_to_parent(ca);
   ca_sync(ca->parent);
+  ca_view_sync_mask_after_parent(ca);
 }
 
 static void

data/ext/ca_obj_face.c

@@ -49,7 +49,9 @@ ca_face_sync (void *ap)
 {
   CAView *cav = (CAView *) ap;
   /* alias means no copy-back is needed; parent sync propagates */
+  ca_view_pass_mask_to_parent(cav);
   ca_sync(cav->parent);
+  ca_view_sync_mask_after_parent(cav);
 }
 
 void

data/ext/ca_obj_fake.c

@@ -310,12 +310,14 @@ ca_fake_func_sync (void *ap)
   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->parent->mask->ptr);
+                            (boolean8_t *)ca->mask->ptr);
   }
   else {
     ca_cast_block(ca->elements, ca, ca->ptr, ca->parent, ca->parent->ptr);
   }
+  ca_view_pass_mask_to_parent(ca);
   ca_sync(ca->parent);
+  ca_view_sync_mask_after_parent(ca);
 }
 
 static void

data/ext/ca_obj_grid.c

@@ -490,11 +490,86 @@ cag_parent_addr (const CAGrid *ca, const ca_size_t *idx, ca_size_t *paddr)
   return hole;
 }
 
+/* The parent addresses (paddrs, may be NULL) and the hole marks of every
+   view cell in address order: a walk over the outer axes with the
+   innermost axis a run, its indices and holes read off the axis.  A 1-D
+   index axis is its own index and hole arrays. */
+static void
+cag_parent_addrs_whole (const CAGrid *ca, ca_size_t *paddrs, uint8_t *hole)
+{
+  int8_t            ndim  = ca->ndim;
+  int8_t            inner = ndim - 1;
+  const cag_axis_t *last  = &ca->axes[inner];
+  ca_size_t         count = last->count;
+  ca_size_t         pdim  = ca->parent->dim[inner];
+  ca_size_t         idx[CA_RANK_MAX];
+  ca_size_t         i = 0, j;
+  int8_t            k;
+
+  if ( ndim == 1 && last->kind == CAG_AXIS_INDEX ) {
+    if ( paddrs ) {
+      memcpy(paddrs, last->indices, (size_t) count * sizeof(ca_size_t));
+    }
+    if ( last->holes ) {
+      memcpy(hole, last->holes, (size_t) count);
+    }
+    else {
+      memset(hole, 0, (size_t) count);
+    }
+    return;
+  }
+  if ( count == 0 || ca->elements == 0 ) {
+    return;
+  }
+  for (k = 0; k < ndim; k++) {
+    idx[k] = 0;
+  }
+  /* empty: returned above when the view has no cell */
+  while ( 1 ) {
+    ca_size_t base = 0;
+    uint8_t   outer_hole = 0;
+    for (k = 0; k < inner; k++) {
+      const cag_axis_t *ax = &ca->axes[k];
+      if ( ax->kind == CAG_AXIS_INDEX && ax->holes && ax->holes[idx[k]] ) {
+        outer_hole = 1;
+      }
+      base = base * ca->parent->dim[k] + cag_parent_index_for(ax, idx[k]);
+    }
+    base *= pdim;
+    if ( last->kind == CAG_AXIS_INDEX ) {
+      const ca_size_t *ix = last->indices;
+      const uint8_t   *hx = last->holes;
+      for (j = 0; j < count; j++) {
+        if ( paddrs ) {
+          paddrs[i + j] = base + ix[j];
+        }
+        hole[i + j] = (uint8_t) (outer_hole | (hx ? hx[j] : 0));
+      }
+    }
+    else {
+      for (j = 0; j < count; j++) {
+        if ( paddrs ) {
+          paddrs[i + j] = base + last->start + j * last->step;
+        }
+        hole[i + j] = outer_hole;
+      }
+    }
+    i += count;
+    for (k = inner - 1; k >= 0; k--) {
+      if ( ++idx[k] < ca->dim[k] ) break;
+      idx[k] = 0;
+    }
+    if ( k < 0 ) break;
+  }
+}
+
 /* The transfer of a grid with holes, for the view cells at addrs (NULL:
-   the whole view in order).  The parent is asked for one batch of
-   addresses.  A GET reads every cell, a hole reading the cell at index 0
-   of its holed axes (in a mask grid it is then set true); a PUT leaves
-   the holes out. */
+   the whole view in order, walked axis by axis).  The parent is asked
+   for one batch of addresses.  A GET reads every cell, a hole reading the
+   cell at index 0 of its holed axes (in a mask grid it is then set true); a
+   PUT leaves the holes out.  A mask grid reading its owner's stand-in reads
+   nothing: the stand-in is all false at rest (a write to it is settled
+   into the parent's mask at once), so the holes are the whole answer. */
 static void
 ca_grid_holed_xfer (CAGrid *ca, ca_size_t n, const ca_size_t *addrs,
                     char *data, int dir)
@@ -511,11 +586,43 @@ ca_grid_holed_xfer (CAGrid *ca, ca_size_t n, const ca_size_t *addrs,
   }
   cag_mask_current(ca);
   parent = ca->parent;
-  paddrs = ALLOCV_N(ca_size_t, h_addr, n);
-  hole   = ALLOCV_N(uint8_t, h_hole, n);
-  for (i = 0; i < n; i++) {
-    ca_addr2index((CArray *) ca, addrs ? addrs[i] : i, idx);
-    hole[i] = (uint8_t) cag_parent_addr(ca, idx, &paddrs[i]);
+
+  if ( dir == CA_XFER_GET && ca->holes_read_masked && ca->mask_owner != NULL
+       && parent == ca->mask_owner->mask_standin ) {
+    if ( ! addrs ) {
+      cag_parent_addrs_whole(ca, NULL, (uint8_t *) data);
+    }
+    else {
+      for (i = 0; i < n; i++) {
+        ca_addr2index((CArray *) ca, addrs[i], idx);
+        ((boolean8_t *) data)[i] = (boolean8_t) cag_parent_addr(ca, idx, &m);
+      }
+    }
+    return;
+  }
+
+  if ( dir == CA_XFER_GET && ! addrs && ca->ndim == 1
+       && ( parent->obj_type == CA_OBJ_ARRAY || parent->obj_type == CA_OBJ_ARRAY_WRAP
+            || parent->obj_type == CA_OBJ_SCALAR ) ) {
+    /* A 1-D grid read whole from an array of its own: its index axis's
+       index and hole arrays are the batch as they are.  Another parent's
+       transfer (a view, a CAObject's hook) takes a copy it may write on,
+       as a PUT does, which compacts the batch. */
+    paddrs = ca->axes[0].indices;
+    hole   = ca->axes[0].holes;
+  }
+  else {
+    paddrs = ALLOCV_N(ca_size_t, h_addr, n);
+    hole   = ALLOCV_N(uint8_t, h_hole, n);
+    if ( ! addrs ) {
+      cag_parent_addrs_whole(ca, paddrs, hole);
+    }
+    else {
+      for (i = 0; i < n; i++) {
+        ca_addr2index((CArray *) ca, addrs[i], idx);
+        hole[i] = (uint8_t) cag_parent_addr(ca, idx, &paddrs[i]);
+      }
+    }
   }
 
   if ( dir == CA_XFER_GET ) {
@@ -712,6 +819,50 @@ ca_grid_func_fold_stride (void *ap, ca_fold_t *f, void **next_parent)
   return 1;
 }
 
+/* A region of a grid with holes: its view addresses as one batch to the
+   holed transfer, or none when the region is the whole view in order. */
+static void
+cag_holed_xfer_stride (CAGrid *g, const ca_size_t *starts, const ca_size_t *counts,
+                       const ca_size_t *strides, char *data, int dir)
+{
+  int8_t         ndim = g->ndim;
+  ca_size_t      gnative[CA_RANK_MAX], idx[CA_RANK_MAX];
+  ca_size_t      n = 1, i, s, base = 0;
+  ca_size_t     *addrs;
+  volatile VALUE holder = 0;
+  int            whole = 1;
+  int8_t         k;
+
+  s = g->bytes;
+  for (k = ndim - 1; k >= 0; k--) { gnative[k] = s; s *= g->dim[k]; }
+  for (k = 0; k < ndim; k++) {
+    n    *= counts[k];
+    base += starts[k] * gnative[k];
+    if ( starts[k] != 0 || counts[k] != g->dim[k] || strides[k] != gnative[k] ) {
+      whole = 0;
+    }
+    idx[k] = 0;
+  }
+  if ( whole ) {
+    ca_grid_holed_xfer(g, n, NULL, data, dir);
+    return;
+  }
+  addrs = ALLOCV_N(ca_size_t, holder, n);
+  for (i = 0; i < n; i++) {
+    ca_size_t goff = base;
+    for (k = 0; k < ndim; k++) {
+      goff += idx[k] * strides[k];
+    }
+    addrs[i] = goff / g->bytes;
+    for (k = ndim - 1; k >= 0; k--) {
+      if ( ++idx[k] < counts[k] ) break;
+      idx[k] = 0;
+    }
+  }
+  ca_grid_holed_xfer(g, n, addrs, data, dir);
+  ALLOCV_END(holder);
+}
+
 /* xfer_stride: structural region delivery when CAGrid is the (declining)
    fold boundary -- a multi-element INDEX axis.  Instead of materialising
    the whole grid, deliver only the requested region using the per-axis
@@ -763,9 +914,12 @@ ca_grid_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   /* The request is over the view's addresses, so a transposed / flat request
      is legal and must not be composed axis-by-axis; see
      ca_xfer_stride_request_is_axis_box (carray.h). */
-  if ( cag_has_holes(g)
-       || ! ca_xfer_stride_request_is_axis_box(g, starts, counts, strides) ) {
-    aligned = 0;   /* a grid with holes goes cell by cell (xfer_index) */
+  if ( cag_has_holes(g) ) {
+    cag_holed_xfer_stride(g, starts, counts, strides, d, dir);
+    return;
+  }
+  if ( ! ca_xfer_stride_request_is_axis_box(g, starts, counts, strides) ) {
+    aligned = 0;
   }
   else {
     for (k = 0; k < ndim; k++) {
@@ -1548,6 +1702,7 @@ Init_ca_obj_grid (void)
                                     &cagrid_data_type, 
 				    rb_cCAGridMask,
 				    &cagrid_mask_data_type, &ca_grid_func, sizeof(ca_grid_func));
+  ca_register_cell_moving_view(CA_OBJ_GRID);
   rb_define_const(rb_cObject, "CA_OBJ_GRID", INT2NUM(CA_OBJ_GRID));
 
   rb_define_method(rb_cCArray, "grid", rb_ca_grid, -1);

data/ext/ca_obj_meld.c

@@ -686,7 +686,7 @@ ca_meld_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     structural = 0;
   }
 
-  if ( ! structural || ! ca_fast_paths_enabled() ) {
+  if ( ! structural || ! ca_fast_path(CA_SC_MELD_STRIDE_BOX) ) {
     ca_meld_xfer_stride_per_cell(ca, starts, counts, strides, data, dir);
     return;
   }
@@ -702,16 +702,23 @@ ca_meld_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
 /* xfer_all                                                             */
 /* ------------------------------------------------------------------- */
 
-/* A parent's cells, delivered (PUT).  into_buffers writes them into the
-   buffer the parent's attach handed out, rather than through the parent to
-   what is behind it: the sync of an attached meld, which then syncs each
-   parent.  Writing past the buffer would leave it stale, and the parent's
-   own sync would push the stale buffer back over the cells just written. */
+/* A parent's cells, delivered (PUT).  A non-NULL sync_error writes them
+   into the buffer the parent's attach handed out, rather than through the
+   parent to what is behind it, and syncs the parent: the sync of an
+   attached meld.  Writing past the buffer would leave it stale, and the parent's
+   own sync would push the stale buffer back over the cells just written.
+   A parent with no buffer out (a stand-in the trial of a write puts in
+   place, which is never attached) has nothing to go stale: the cells go
+   through it. */
 static void
-ca_meld_put_parent (CArray *p, char *src, int into_buffers)
+ca_meld_put_parent (CArray *p, char *src, volatile VALUE *sync_error)
 {
-  if ( into_buffers ) {
+  if ( sync_error != NULL && p->ptr != NULL ) {
+    /* Synced at once, before the next part is written: parts that share
+       cells then take the write of the last of them, as a write through
+       the parts does. */
     memcpy(p->ptr, src, (size_t) (p->elements * p->bytes));
+    ca_sync_carry_on(p, sync_error);
   }
   else {
     ca_xfer_all(p, src, CA_XFER_PUT);
@@ -720,7 +727,7 @@ ca_meld_put_parent (CArray *p, char *src, int into_buffers)
 
 /* meld_axis == 0 best path: K contig xfer_all at prefix-sum offsets. */
 static void
-ca_meld_xfer_all_ma0 (CAMeld *ca, void *data, int dir, int into_buffers)
+ca_meld_xfer_all_ma0 (CAMeld *ca, void *data, int dir, volatile VALUE *sync_error)
 {
   ca_size_t tail_bytes = ca_meld_tail_elements(ca) * ca->bytes;
   char *d = (char *) data;
@@ -728,7 +735,7 @@ ca_meld_xfer_all_ma0 (CAMeld *ca, void *data, int dir, int into_buffers)
   for ( k = 0; k < ca->n_parents; k++ ) {
     char *seg = d + ca->seg_offset[k] * tail_bytes;
     if ( dir == CA_XFER_PUT ) {
-      ca_meld_put_parent(ca->parents[k], seg, into_buffers);
+      ca_meld_put_parent(ca->parents[k], seg, sync_error);
     }
     else {
       ca_xfer_all(ca->parents[k], seg, dir);
@@ -750,7 +757,7 @@ ca_meld_xfer_all_ma0 (CAMeld *ca, void *data, int dir, int into_buffers)
    chunked memcpy approaches memcpy bandwidth (eager parity target). */
 static void
 ca_meld_xfer_all_ma_internal (CAMeld *ca, void *data, int dir,
-                              int into_buffers)
+                              volatile VALUE *sync_error)
 {
   int8_t   ma = ca->meld_axis;
   int8_t   ndim = ca->ndim;
@@ -780,6 +787,12 @@ ca_meld_xfer_all_ma_internal (CAMeld *ca, void *data, int dir,
     ca_size_t voff;
     int8_t i;
 
+    /* A parent with no cells moves nothing.  The walks below copy one
+       chunk before they look at the outer extents, so a parent empty along
+       an outer axis would copy a chunk out of a 0-byte buffer.  sync comes
+       here without the slot's own check on the view. */
+    if ( p->elements == 0 ) continue;
+
     buf = ALLOCV_N(char, holder, slab_bytes);
 
     if ( dir == CA_XFER_GET ) {
@@ -837,19 +850,19 @@ ca_meld_xfer_all_ma_internal (CAMeld *ca, void *data, int dir,
     }
 
     if ( dir == CA_XFER_PUT ) {
-      ca_meld_put_parent(p, buf, into_buffers);
+      ca_meld_put_parent(p, buf, sync_error);
     }
     ALLOCV_END(holder);
   }
 }
 
 static void
-ca_meld_xfer_parents (CAMeld *ca, void *data, int dir, int into_buffers)
+ca_meld_xfer_parents (CAMeld *ca, void *data, int dir, volatile VALUE *sync_error)
 {
-  if ( ca->meld_axis == 0 && ca_fast_paths_enabled() ) {
-    ca_meld_xfer_all_ma0(ca, data, dir, into_buffers);
+  if ( ca->meld_axis == 0 && ca_fast_path(CA_SC_MELD_PARENTS_AXIS0) ) {
+    ca_meld_xfer_all_ma0(ca, data, dir, sync_error);
   } else {
-    ca_meld_xfer_all_ma_internal(ca, data, dir, into_buffers);
+    ca_meld_xfer_all_ma_internal(ca, data, dir, sync_error);
   }
 }
 
@@ -858,7 +871,7 @@ ca_meld_func_xfer_all (void *ap, void *data, int dir)
 {
   if ( ((CArray *) ap)->elements == 0 ) return;
   ca_meld_mask_refresh((CAMeld *) ap);
-  ca_meld_xfer_parents((CAMeld *) ap, data, dir, 0);
+  ca_meld_xfer_parents((CAMeld *) ap, data, dir, NULL);
 }
 
 /* ------------------------------------------------------------------- */
@@ -890,15 +903,19 @@ ca_meld_func_attach (void *ap)
   ca_fill_or_detach(ca->n_parents, ca->parents, ca_meld_attach_owned, (VALUE) ca);
 }
 
-static void ca_meld_mask_refuse_sync (CAMeld *ca);
-
 static void
 ca_meld_func_sync (void *ap)
 {
   CAMeld *ca = (CAMeld *) ap;
-  ca_meld_mask_refuse_sync(ca);
-  ca_meld_xfer_parents(ca, ca->ptr, CA_XFER_PUT, 1);
-  ca_sync_all(ca->parents, ca->n_parents);
+  CA_MULTI_PARENT_VALUE_TRIAL(ca, t,
+    ca_meld_xfer_parents((CAMeld *) t, ca->ptr, CA_XFER_PUT, NULL));
+  {
+    volatile VALUE error = Qnil;
+    ca_meld_xfer_parents(ca, ca->ptr, CA_XFER_PUT, &error);
+    if ( ! NIL_P(error) ) {
+      rb_exc_raise(error);
+    }
+  }
   ca_meld_mask_settle(ca);
 }
 
@@ -971,79 +988,21 @@ ca_meld_func_fold_stride (void *ap, ca_fold_t *f, void **next_parent)
 /* ------------------------------------------------------------------- */
 
 /* The table's write slots: after a write that may have put a true into a
-   stand-in, the true goes on to the parent's mask, or is refused for a
-   value array or a mask array (ca_mask_standin_settle).  Only the mask of
-   a CAMeld has stand-ins. */
-/* A write to the mask of a CAMeld, run once against blank masks first
-   (ca_multi_parent_mask_refuse_first), so that a write refused for a value
-   array or mask array part changes no other part. */
-enum { CA_MELD_PUT_INDEX, CA_MELD_PUT_ADDRS, CA_MELD_PUT_STRIDE, CA_MELD_PUT_ALL,
-       CA_MELD_PUT_FILL, CA_MELD_PUT_SYNC, CA_MELD_PUT_FILL_ADDRS,
-       CA_MELD_PUT_FILL_STRIDE };
-
-typedef struct {
-  int        slot;
-  void      *ap;
-  ca_size_t *idx;
-  ca_size_t  n;
-  ca_size_t *addrs;
-  ca_size_t *starts;
-  ca_size_t *counts;
-  ca_size_t *strides;
-  void      *data;
-  ca_size_t  base;
-  int8_t     ndim;
-  ca_size_t *steps;
-} ca_meld_put_t;
-
-static VALUE
-ca_meld_put_body (VALUE arg)
-{
-  ca_meld_put_t *a = (ca_meld_put_t *) arg;
-  switch ( a->slot ) {
-  case CA_MELD_PUT_INDEX:
-    ca_meld_func_xfer_index(a->ap, a->idx, a->data, CA_XFER_PUT); break;
-  case CA_MELD_PUT_ADDRS:
-    ca_meld_func_xfer_addrs(a->ap, a->n, a->addrs, a->data, CA_XFER_PUT); break;
-  case CA_MELD_PUT_STRIDE:
-    ca_meld_func_xfer_stride(a->ap, a->starts, a->counts, a->strides, a->data,
-                             CA_XFER_PUT); break;
-  case CA_MELD_PUT_ALL:
-    ca_meld_func_xfer_all(a->ap, a->data, CA_XFER_PUT); break;
-  case CA_MELD_PUT_FILL:
-    ca_meld_func_fill_data(a->ap, a->data); break;
-  case CA_MELD_PUT_FILL_ADDRS:
-    ca_fill_addrs_default(a->ap, a->n, a->addrs, a->data); break;
-  case CA_MELD_PUT_FILL_STRIDE:
-    ca_fill_stride_default(a->ap, a->base, a->ndim, a->counts, a->steps,
-                           a->data); break;
-  case CA_MELD_PUT_SYNC:
-    ca_meld_xfer_parents((CAMeld *) a->ap, ((CArray *) a->ap)->ptr, CA_XFER_PUT, 1);
-    break;
-  }
-  return Qnil;
-}
-
+   stand-in, the true goes on to the parent's mask (ca_mask_standin_settle).
+   Only the mask of a CAMeld has stand-ins. */
+/* After a write of n cells of `data` to the mask of a CAMeld: a true
+   that went into a stand-in goes on to its parent's mask. */
 static void
-ca_meld_mask_refuse_first (ca_meld_put_t *a)
+ca_meld_mask_adopt_before (void *ap, const void *data, ca_size_t n)
 {
-  CAMeld *o = (CAMeld *) ((CAMeld *) a->ap)->mask_owner;
-  if ( o != NULL ) {
-    ca_multi_parent_mask_refuse_first((CArray *) a->ap, o->parents,
-                                      o->mask_standins, o->n_parents,
-                                      ca_meld_put_body, (VALUE) a);
+  CAMeld *ca = (CAMeld *) ap;
+  CAMeld *o  = (CAMeld *) ca->mask_owner;
+  if ( o != NULL && ca_mask_any_true(data, n) ) {
+    ca_multi_parent_mask_adopt((CArray *) ca, o->parents, o->mask_standins,
+                               o->n_parents);
   }
 }
 
-static void
-ca_meld_mask_refuse_sync (CAMeld *ca)
-{
-  ca_meld_put_t a = { CA_MELD_PUT_SYNC, ca, NULL, 0, NULL, NULL, NULL, NULL, NULL };
-  ca_meld_mask_refuse_first(&a);
-}
-
-/* After a write of n cells of `data` to the mask of a CAMeld: a true
-   that went into a stand-in goes on to its parent's mask. */
 static void
 ca_meld_mask_settle_after (CAMeld *ca, const void *data, ca_size_t n)
 {
@@ -1055,10 +1014,7 @@ ca_meld_mask_settle_after (CAMeld *ca, const void *data, ca_size_t n)
 static void
 ca_meld_put_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
 {
-  if ( dir == CA_XFER_PUT ) {
-    ca_meld_put_t a = { CA_MELD_PUT_INDEX, ap, idx, 0, NULL, NULL, NULL, NULL, data };
-    ca_meld_mask_refuse_first(&a);
-  }
+  if ( dir == CA_XFER_PUT ) ca_meld_mask_adopt_before(ap, data, 1);
   ca_meld_func_xfer_index(ap, idx, data, dir);
   if ( dir == CA_XFER_PUT ) ca_meld_mask_settle_after((CAMeld *) ap, data, 1);
 }
@@ -1068,8 +1024,9 @@ ca_meld_put_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *data,
                          int dir)
 {
   if ( dir == CA_XFER_PUT ) {
-    ca_meld_put_t a = { CA_MELD_PUT_ADDRS, ap, NULL, n, addrs, NULL, NULL, NULL, data };
-    ca_meld_mask_refuse_first(&a);
+    CA_MULTI_PARENT_VALUE_TRIAL(ap, t,
+      ca_meld_func_xfer_addrs(t, n, addrs, data, dir));
+    ca_meld_mask_adopt_before(ap, data, n);
   }
   ca_meld_func_xfer_addrs(ap, n, addrs, data, dir);
   if ( dir == CA_XFER_PUT ) ca_meld_mask_settle_after((CAMeld *) ap, data, n);
@@ -1080,8 +1037,10 @@ ca_meld_put_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                           ca_size_t *strides, void *data, int dir)
 {
   if ( dir == CA_XFER_PUT ) {
-    ca_meld_put_t a = { CA_MELD_PUT_STRIDE, ap, NULL, 0, NULL, starts, counts, strides, data };
-    ca_meld_mask_refuse_first(&a);
+    CA_MULTI_PARENT_VALUE_TRIAL(ap, t,
+      ca_meld_func_xfer_stride(t, starts, counts, strides, data, dir));
+    ca_meld_mask_adopt_before(ap, data,
+                               ca_shape_elements(((CArray *) ap)->ndim, counts, 1));
   }
   ca_meld_func_xfer_stride(ap, starts, counts, strides, data, dir);
   if ( dir == CA_XFER_PUT ) {
@@ -1094,8 +1053,8 @@ static void
 ca_meld_put_xfer_all (void *ap, void *data, int dir)
 {
   if ( dir == CA_XFER_PUT ) {
-    ca_meld_put_t a = { CA_MELD_PUT_ALL, ap, NULL, 0, NULL, NULL, NULL, NULL, data };
-    ca_meld_mask_refuse_first(&a);
+    CA_MULTI_PARENT_VALUE_TRIAL(ap, t, ca_meld_func_xfer_all(t, data, dir));
+    ca_meld_mask_adopt_before(ap, data, ((CArray *) ap)->elements);
   }
   ca_meld_func_xfer_all(ap, data, dir);
   if ( dir == CA_XFER_PUT ) {
@@ -1106,23 +1065,17 @@ ca_meld_put_xfer_all (void *ap, void *data, int dir)
 static void
 ca_meld_put_fill_data (void *ap, void *ptr)
 {
-  {
-    ca_meld_put_t a = { CA_MELD_PUT_FILL, ap, NULL, 0, NULL, NULL, NULL, NULL, ptr };
-    ca_meld_mask_refuse_first(&a);
-  }
+  CA_MULTI_PARENT_VALUE_TRIAL(ap, t, ca_meld_func_fill_data(t, ptr));
+  ca_meld_mask_adopt_before(ap, ptr, 1);
   ca_meld_func_fill_data(ap, ptr);
   ca_meld_mask_settle_after((CAMeld *) ap, ptr, 1);
 }
 
-/* A fill of part of the mask goes cell by cell through xfer_index; run
-   the whole of it against blank masks first, so that a cell refused late
-   does not leave the cells before it written. */
 static void
 ca_meld_put_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *ptr)
 {
-  ca_meld_put_t a = { CA_MELD_PUT_FILL_ADDRS, ap, NULL, n, addrs, NULL, NULL,
-                     NULL, ptr };
-  ca_meld_mask_refuse_first(&a);
+  CA_MULTI_PARENT_VALUE_TRIAL(ap, t, ca_fill_addrs_default(t, n, addrs, ptr));
+  ca_meld_mask_adopt_before(ap, ptr, 1);
   ca_fill_addrs_default(ap, n, addrs, ptr);
   ca_meld_mask_settle_after((CAMeld *) ap, ptr, 1);
 }
@@ -1131,9 +1084,9 @@ static void
 ca_meld_put_fill_stride (void *ap, ca_size_t base, int8_t ndim,
                          ca_size_t *counts, ca_size_t *steps, void *ptr)
 {
-  ca_meld_put_t a = { CA_MELD_PUT_FILL_STRIDE, ap, NULL, 0, NULL, NULL, counts,
-                     NULL, ptr, base, ndim, steps };
-  ca_meld_mask_refuse_first(&a);
+  CA_MULTI_PARENT_VALUE_TRIAL(ap, t,
+    ca_fill_stride_default(t, base, ndim, counts, steps, ptr));
+  ca_meld_mask_adopt_before(ap, ptr, 1);
   ca_fill_stride_default(ap, base, ndim, counts, steps, ptr);
   ca_meld_mask_settle_after((CAMeld *) ap, ptr, 1);
 }
@@ -1179,6 +1132,7 @@ rb_ca_meld_new (VALUE parents_ary, int8_t meld_axis)
     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");
   }
   ca  = ca_meld_new((int32_t) n, parents, meld_axis);
   obj = ca_wrap_struct(ca);
@@ -1244,6 +1198,7 @@ rb_ca_meld_initialize (int argc, VALUE *argv, VALUE self)
     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");
   }
   ca_meld_setup(ca, (int32_t) n, parents, meld_axis);
   rb_ivar_set(self, id_parents, rb_ary_dup(list));
@@ -1339,6 +1294,7 @@ Init_ca_obj_meld (void)
                                     &cameld_data_type,
                                     rb_cCAMeldMask,
                                     &cameld_mask_data_type, &ca_meld_func, sizeof(ca_meld_func));
+  ca_register_cell_moving_view(CA_OBJ_MELD);
   rb_define_const(rb_cObject, "CA_OBJ_MELD", INT2NUM(CA_OBJ_MELD));
 
   id_parents = rb_intern("parents");

data/ext/ca_obj_moncmp.c

@@ -227,9 +227,11 @@ ca_moncmp_try_leaf_inplace (CArray *p,
 
 /* Evaluate the cells a request names into `data` (packed, n cells). */
 static void
-ca_moncmp_eval (CAMonCmp *mc, const ca_lazy_req_t *req, void *data)
+ca_moncmp_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
 {
+  CAMonCmp *mc = (CAMonCmp *) node;
   ca_size_t slab_n = req->n;
+  (void) dir;
   void     *scratch;
   ca_size_t operand_bytes;
   int       is_contig;
@@ -295,6 +297,12 @@ ca_moncmp_eval (CAMonCmp *mc, const ca_lazy_req_t *req, void *data)
   if ( ! scratch_is_inplace ) ca_lazy_arena_release(scratch);
 }
 
+static void
+ca_moncmp_eval (CAMonCmp *mc, const ca_lazy_req_t *req, void *data)
+{
+  ca_lazy_eval_recorded(mc, 1, &mc->parent, 0, NULL, ca_moncmp_eval_cells, req, data, CA_XFER_GET);
+}
+
 static void
 ca_moncmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                             ca_size_t *strides, void *data, int dir)