carray 3.0.4 → 3.0.6

data/ext/ca_obj_remap.c

@@ -304,8 +304,9 @@ ca_remap_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
 
   paddrs = ALLOCV_N(ca_size_t, holder, n);
   ca_xfer_addrs(ca->idx, n, addrs, paddrs, CA_XFER_GET);
-  /* idx is read live, so its values are checked here, not at
-     construction: negative counts from the end, out of range raises
+  /* idx is read-only once the view holds it, but its values are still
+     checked on every transfer (the private without_read_only_flag can
+     lift the flag): negative counts from the end, out of range raises
      before the parent is touched. */
   for ( i = 0; i < n; i++ ) {
     CA_CHECK_INDEX(paddrs[i], ca->parent->elements);
@@ -366,9 +367,19 @@ ca_remap_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   ALLOCV_END(holder);
 }
 
-/* xfer_all: whole-view delivery.  Sequential view-flat addresses
-   [0..elements) routed through xfer_addrs -- one ALLOCV for the addr
-   list, then two batched ca_xfer_addrs calls inside xfer_addrs.
+/* xfer_all: whole-view delivery.  The whole view reads every cell of idx
+   in order, so when idx holds its cells in memory those cells are the
+   parent addresses: they are checked in one pass, a negative one counting
+   from the end of the parent.
+
+   idx itself is handed to the parent only when the parent holds its cells
+   in memory and shares no root with idx: that transfer is a plain copy, so
+   no Ruby runs while the parent reads the list and a scatter cannot
+   rewrite it.  Any other parent (a view, a CAObject whose hooks run Ruby)
+   gets a copy of the addresses taken in the checking pass, so nothing it
+   does can change an address after it was checked, or change idx.
+   Without idx in memory, the sequential view-flat addresses [0..elements)
+   go through xfer_addrs.
 
    No ca_attach(parent) / ca_attach(idx). */
 static void
@@ -382,6 +393,46 @@ ca_remap_func_xfer_all (void *ap, void *data, int dir)
 
   if ( n == 0 ) return;
 
+  if ( ca->idx->ptr ) {
+    ca_size_t *iaddrs = (ca_size_t *) ca->idx->ptr;
+    ca_size_t  pn = ca->parent->elements;
+    ca_size_t *paddrs;
+
+    if ( ca->parent->ptr && ! ca_shares_root(ca->parent, ca->idx) ) {
+      int lendable = 1;
+      for ( i = 0; i < n; i++ ) {
+        ca_size_t a = iaddrs[i];
+        if ( a < 0 ) {
+          lendable = 0;
+          a += pn;
+        }
+        if ( a < 0 || a >= pn ) {
+          ca_index_out_of_range(iaddrs[i], pn, "index");
+        }
+      }
+      if ( lendable ) {
+        ca_xfer_addrs(ca->parent, n, iaddrs, data, dir);
+        return;
+      }
+    }
+
+    paddrs = ALLOCV_N(ca_size_t, holder, n);
+    for ( i = 0; i < n; i++ ) {
+      ca_size_t a = iaddrs[i];
+      if ( a < 0 ) {
+        a += pn;
+      }
+      if ( a < 0 || a >= pn ) {
+        ALLOCV_END(holder);
+        ca_index_out_of_range(iaddrs[i], pn, "index");
+      }
+      paddrs[i] = a;
+    }
+    ca_xfer_addrs(ca->parent, n, paddrs, data, dir);
+    ALLOCV_END(holder);
+    return;
+  }
+
   vaddrs = ALLOCV_N(ca_size_t, holder, n);
   for ( i = 0; i < n; i++ ) vaddrs[i] = i;
   ca_remap_func_xfer_addrs(ca, n, vaddrs, data, dir);
@@ -417,7 +468,13 @@ ca_operation_function_t ca_remap_func = {
    carray_partition.c).  Callers are expected to have already checked the
    routing preconditions (same shape, idx data_type == CA_SIZE);
    ca_remap_setup raises ArgumentError on mismatch as a defensive
-   fallback. */
+   fallback.
+
+   The view takes rmapper over: every caller hands a fresh array no one
+   else holds, and it is marked read-only here, so the mapping a view was
+   made with cannot be rewritten through #mapper.  CAGrid and CASelect
+   keep their indices where Ruby cannot reach them; this is the same
+   promise for an index array that stays visible. */
 VALUE
 rb_ca_remap_new (VALUE cary, VALUE rmapper)
 {
@@ -437,13 +494,14 @@ rb_ca_remap_new (VALUE cary, VALUE rmapper)
      covers the view's.  ca->idx is a raw pointer into idx's struct;
      keeping rmapper reachable through the view keeps it alive. */
   rb_ivar_set(obj, rb_intern("remap_idx"), rmapper);
+  rb_ca_set_read_only_flag(rmapper);
   return obj;
 }
 
-/* Read-only accessor for the per-cell index CArray that defines this
-   CARemap's mapping: the array the view reads.  For ca[mapper] it is a
-   copy of mapper taken at the call, so a later change to mapper does
-   not reach the view.  Companion to
+/* Accessor for the per-cell index CArray that defines this CARemap's
+   mapping: the array the view reads, itself read-only.  For ca[mapper]
+   it is a copy of mapper taken at the call, so a later change to mapper
+   does not reach the view.  Companion to
    CABlock#start / CAStride#strides / CAWindow#count etc. — the view
    hierarchy is preserved so each named view class exposes its own
    defining semantic state. */
@@ -526,6 +584,7 @@ Init_ca_obj_remap (void)
                                      rb_cCARemapMask,
                                      &caremap_mask_data_type,
                                      &ca_remap_func, sizeof(ca_remap_func));
+  ca_register_cell_moving_view(CA_OBJ_REMAP);
 
   /* Defining semantic state accessor — companion to CABlock#start /
      CAStride#strides / CAWindow#count.  The hierarchy-preserving

data/ext/ca_obj_roll.c

@@ -112,6 +112,8 @@ ca_roll_setup (CARoll *ca, CArray *parent, ca_size_t *shift)
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
+  ca->reps      = NULL;               /* set before either allocation can raise */
+  ca->dim       = NULL;
   ca->reps      = ALLOC_N(ca_size_t, ndim);  /* repurposed as shift[] */
   ca->dim       = ALLOC_N(ca_size_t, ndim);
 
@@ -130,15 +132,33 @@ ca_roll_setup (CARoll *ca, CArray *parent, ca_size_t *shift)
   return 0;
 }
 
+typedef struct {
+  CARoll    *ca;
+  CArray    *parent;
+  ca_size_t *shift;
+} ca_roll_new_arg;
+
+static VALUE
+ca_roll_new_setup (VALUE varg)
+{
+  ca_roll_new_arg *a = (ca_roll_new_arg *) varg;
+  ca_roll_setup(a->ca, a->parent, a->shift);
+  return Qnil;
+}
+
+/* The setup allocates reps and dim after the struct: when either fails,
+   the struct goes too. */
 CARoll *
 ca_roll_new (CArray *parent, ca_size_t *shift)
 {
-  CARoll *ca;
+  ca_roll_new_arg a;
   ca_roll_setup(NULL, parent, shift);
-  ca = ALLOC(CARoll);
-  ca_roll_setup(ca, parent, shift);
-  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
-  return ca;
+  a.ca     = ALLOC(CARoll);
+  a.parent = parent;
+  a.shift = shift;
+  ca_fill_or_free((CArray *) a.ca, ca_roll_new_setup, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_view_inherit_mask, (VALUE) a.ca);
+  return a.ca;
 }
 
 static void
@@ -629,7 +649,7 @@ rb_ca_roll (int argc, VALUE *argv, VALUE self)
   }
   for ( i = 0; i < ca->ndim; i++ ) {
     if ( i < argc ) {
-      shift[i] = NUM2SIZE(argv[i]);
+      shift[i] = ca_integer_arg(argv[i], "a shift", NULL);
     } else {
       shift[i] = 0;
     }
@@ -713,6 +733,7 @@ Init_ca_obj_roll (void)
                                     &caroll_data_type,
                                     rb_cCARollMask,
                                     &caroll_mask_data_type, &ca_roll_func, sizeof(ca_roll_func));
+  ca_register_cell_moving_view(CA_OBJ_ROLL);
   rb_define_const(rb_cObject, "CA_OBJ_ROLL", INT2NUM(CA_OBJ_ROLL));
 
   rb_define_method(rb_cCArray, "roll", rb_ca_roll, -1);

data/ext/ca_obj_select.c

@@ -130,7 +130,8 @@ ca_select_snapshot (CArray *select)
 
 /* Set up the view over `parent` from an owned selector snapshot (see
    ca_select_snapshot) and pre-compute ca->indices (TRUE positions in flat
-   parent order).  Does not raise. */
+   parent order).  Raises only when the indices cannot be allocated, after
+   every field free_ca_select reads is set. */
 static int
 ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
 {
@@ -204,21 +205,51 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
   ca->dim       = &(ca->_dim);
   ca->dim[0]    = ca->elements;
 
-  if ( ca_is_scalar(snapshot) ) {
+  /* A selection of a scalar is one only while it picks the cell: a scalar
+     is one cell along one axis. */
+  if ( ca_is_scalar(snapshot) && ca->elements == 1 ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
 
   return 0;
 }
 
+typedef struct {
+  CASelect *ca;
+  CArray   *parent;
+  CArray   *snapshot;
+} ca_select_new_arg;
+
+static VALUE
+ca_select_new_alloc (VALUE varg)
+{
+  ca_select_new_arg *a = (ca_select_new_arg *) varg;
+  a->ca = ALLOC(CASelect);
+  return Qnil;
+}
+
+static VALUE
+ca_select_new_setup (VALUE varg)
+{
+  ca_select_new_arg *a = (ca_select_new_arg *) varg;
+  ca_select_setup(a->ca, a->parent, a->snapshot);
+  return Qnil;
+}
+
+/* The struct and the indices are allocated after the snapshot.  When the
+   struct cannot be allocated the snapshot goes; when the indices cannot,
+   the struct goes and takes the snapshot with it (the setup stores the
+   snapshot before it allocates the indices). */
 CArray *
 ca_select_new (CArray *parent, CArray *select)
 {
-  CArray *snapshot = ca_select_snapshot(select);
+  ca_select_new_arg a;
+  a.parent   = parent;
+  a.snapshot = ca_select_snapshot(select);
   /* check: the setup checks nothing */
-  CASelect *ca = ALLOC(CASelect);
-  ca_select_setup(ca, parent, snapshot);
-  return (CArray*) ca;
+  ca_fill_or_free(a.snapshot, ca_select_new_alloc, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_select_new_setup, (VALUE) &a);
+  return (CArray*) a.ca;
 }
 
 /* Alias for source compatibility.  Both constructors produce a
@@ -639,6 +670,7 @@ rb_cm_initialize_copy (VALUE self, VALUE other)
 void
 Init_ca_obj_select (void)
 {
+  ca_register_cell_moving_view(CA_OBJ_SELECT);
   /* 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));

data/ext/ca_obj_select_axis.c

@@ -1238,6 +1238,7 @@ Init_ca_obj_select_axis (void)
                                            rb_cCASelectAxisMask,
                                            &caselectaxis_mask_data_type,
                                            &ca_select_axis_func, sizeof(ca_select_axis_func));
+  ca_register_cell_moving_view(CA_OBJ_SELECT_AXIS);
   rb_define_const(rb_cObject, "CA_OBJ_SELECT_AXIS", INT2NUM(CA_OBJ_SELECT_AXIS));
 
   rb_define_alloc_func(rb_cCASelectAxis, rb_ca_select_axis_s_allocate);

data/ext/ca_obj_shift.c

@@ -120,16 +120,40 @@ ca_shift_setup (CAShift *ca, CArray *parent,
   return 0;
 }
 
+typedef struct {
+  CAShift   *ca;
+  CArray    *parent;
+  ca_size_t *shift;
+  char      *fill;
+  int8_t    *roll;
+  int        fill_mask;
+} ca_shift_new_arg;
+
+static VALUE
+ca_shift_new_setup (VALUE varg)
+{
+  ca_shift_new_arg *a = (ca_shift_new_arg *) varg;
+  ca_shift_setup(a->ca, a->parent, a->shift, a->fill, a->roll, a->fill_mask);
+  return Qnil;
+}
+
+/* The setup allocates the fill value after the struct and its pool: when
+   that fails, the struct goes too. */
 CAShift *
 ca_shift_new (CArray *parent, ca_size_t *shift, char *fill, int8_t *roll,
               int fill_mask)
 {
-  CAShift *ca;
+  ca_shift_new_arg a;
   ca_shift_setup(NULL, parent, shift, fill, roll, fill_mask);
-  ca = (CAShift *) ca_array_alloc(CA_OBJ_SHIFT, parent->ndim);
-  ca_shift_setup(ca, parent, shift, fill, roll, fill_mask);
-  ca_fill_or_free((CArray *) ca, ca_window_create_bounds_mask, (VALUE) ca);
-  return ca;
+  a.ca        = (CAShift *) ca_array_alloc(CA_OBJ_SHIFT, parent->ndim);
+  a.parent    = parent;
+  a.shift     = shift;
+  a.fill      = fill;
+  a.roll      = roll;
+  a.fill_mask = fill_mask;
+  ca_fill_or_free((CArray *) a.ca, ca_shift_new_setup, (VALUE) &a);
+  ca_fill_or_free((CArray *) a.ca, ca_window_create_bounds_mask, (VALUE) a.ca);
+  return a.ca;
 }
 
 /* Clone: produce a CAShift (not CAWindow) by rebuilding via setup.
@@ -216,7 +240,7 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
   }
 
   for (i=0; i<ca->ndim; i++) {
-    shift[i] = NUM2SIZE(argv[i]);
+    shift[i] = ca_integer_arg(argv[i], "a shift", NULL);
   }
 
   if ( rb_block_given_p() ) {
@@ -264,7 +288,7 @@ rb_ca_shift (int argc, VALUE *argv, VALUE self)
     }
 
     for (i=0; i<ca->ndim; i++) {
-      roll[i] = NUM2INT(rb_ary_entry(rroll, i));
+      roll[i] = ca_integer_arg(rb_ary_entry(rroll, i), "a shift", NULL);
     }
   }
 
@@ -339,6 +363,7 @@ Init_ca_obj_shift (void)
                                      &cashift_data_type,
                                      rb_cCAShiftMask,
                                      &cashift_mask_data_type, &ca_shift_func, sizeof(ca_shift_func));
+  ca_register_cell_moving_view(CA_OBJ_SHIFT);
   rb_define_const(rb_cObject, "CA_OBJ_SHIFT", INT2NUM(CA_OBJ_SHIFT));
 
   rb_define_method(rb_cCArray, "shift", rb_ca_shift, -1);