carray 3.0.1 → 3.0.3

data/ext/carray_copy.c

@@ -11,6 +11,7 @@
 #include "carray.h"
 #include "ca_obj_face.h"   /* CA_FACE_LIFT_IF_FACE */
 #include "carray_internal.h"   /* ca_gc_hold_push / ca_gc_hold_pop_to */
+#include "ca_sweep_engine.h"   /* ca_sweep_same_shape / ca_sweep_refuse_shapes */
 #include <stdarg.h>
 
 /* ------------------------------------------------------------------- */
@@ -19,15 +20,48 @@
  * and bytes as `ca`, copies the element payload, and reproduces the
  * mask state.  Always copies even when `ca` is an entity; for view
  * sources the data path goes through `ca_copy_data`, otherwise a flat
- * memcpy of `ca_length(ca)` bytes.
+ * memcpy of `ca_length(ca)` bytes.  If reading the source raises, the
+ * copy is freed before the raise propagates.
  *
  * Backs `CArray#copy` and is also reachable as a C-level utility from
  * other ext files that need an owned snapshot. */
+void
+ca_fill_or_free (CArray *co, VALUE (*fill)(VALUE), VALUE arg)
+{
+  int tag = 0;
+  rb_protect(fill, arg, &tag);
+  if ( tag ) {
+    ca_free(co);
+    rb_jump_tag(tag);
+  }
+}
+
+static VALUE
+ca_copy_fill (VALUE arg)
+{
+  CArray **pair = (CArray **) arg;
+  CArray *ca = pair[0], *co = pair[1];
+
+  if ( ca_is_attached(ca) ) {
+    memcpy(co->ptr, ca->ptr, ca_length(ca));
+  }
+  else {
+    ca_copy_data(ca, co->ptr);
+  }
+
+  ca_update_mask(ca);
+  if ( ca->mask ) {
+    ca_copy_mask(co, ca);
+  }
+  return Qnil;
+}
+
 CArray *
 ca_copy (void *ap)
 {
   CArray *ca = (CArray *) ap;
   CArray *co;
+  CArray *pair[2];
 
   if ( ca_is_scalar(ca) ) {
     co = (CArray *) cscalar_new(ca->data_type, ca->bytes, 0);
@@ -36,16 +70,26 @@ ca_copy (void *ap)
     co = carray_new(ca->data_type, ca->ndim, ca->dim, ca->bytes, 0);
   }
 
-  if ( ca_is_attached(ca) ) {
-    memcpy(co->ptr, ca->ptr, ca_length(ca));
+  pair[0] = ca;
+  pair[1] = co;
+
+  /* Object cells read from a view that computes them exist only in
+     co->ptr, and copying the mask afterwards can build it -- a lazy
+     expression's mask is computed from its operands -- which allocates.
+     Hold them until the copy is complete.  carray_new has filled the
+     cells with valid VALUEs. */
+  if ( ca_is_object_type(co) ) {
+    int tag = 0;
+    int guard = ca_gc_hold_push(co->ptr, co->elements);
+    rb_protect(ca_copy_fill, (VALUE) pair, &tag);
+    ca_gc_hold_pop_to(guard);
+    if ( tag ) {
+      ca_free(co);
+      rb_jump_tag(tag);
+    }
   }
   else {
-    ca_copy_data(ca, co->ptr);
-  }
-
-  ca_update_mask(ca);
-  if ( ca->mask ) {
-    ca_copy_mask(co, ca);
+    ca_fill_or_free(co, ca_copy_fill, (VALUE) pair);
   }
 
   return co;
@@ -53,7 +97,7 @@ ca_copy (void *ap)
 
 /* Ruby entry for `CArray#copy`.  Wraps `ca_copy` and, when `self` is a
  * Face (e.g. CARecord), lifts the wrapped result so the derived class
- * identity is preserved on the copy. */
+ * identity is preserved on the copy.  The copy keeps self's attributes. */
 VALUE
 rb_ca_copy (VALUE self)
 {
@@ -71,6 +115,7 @@ rb_ca_copy (VALUE self)
   obj = ca_wrap_struct(co);
   ca_gc_hold_pop_to(guard);
   CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  rb_ca_inherit_attr(obj, self);
   return obj;
 }
 
@@ -128,7 +173,7 @@ rb_ca_to_ca (int argc, VALUE *argv, VALUE self)
     CArray *ca;
     TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
     if ( ca_is_readonly(ca) ) {
-      rb_raise(rb_eRuntimeError, "can't modify read-only carray");
+      rb_raise(rb_eRuntimeError, "can not modify read-only array");
     }
   }
   return self;
@@ -194,9 +239,8 @@ ca_template_safe2 (void *ap, int8_t data_type, ca_size_t bytes)
  * The arity dispatch matches `CArray.new` (ca_obj_array.c) so the two
  * factories behave the same for block-driven initialisation. */
 static VALUE
-rb_ca_template_method (int argc, VALUE *argv, VALUE self)
+rb_ca_template_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
 {
-  volatile VALUE ropt = rb_pop_options(&argc, &argv);
   volatile VALUE obj, rtype, rbytes = Qnil;
   CArray *ca, *co;
   int8_t data_type;
@@ -230,10 +274,7 @@ rb_ca_template_method (int argc, VALUE *argv, VALUE self)
       if ( co->ndim > 0 ) {
         ca_size_t idx[CA_RANK_MAX];
         volatile VALUE ridx = rb_ary_new2(co->ndim);
-        ca_attach(co);
         rb_ca_index_walk(obj, co, 0, idx, ridx, CA_LOOP_STORE);
-        ca_sync(co);
-        ca_detach(co);
       }
       else {
         volatile VALUE rval = rb_yield_values2(0, NULL);
@@ -257,6 +298,13 @@ rb_ca_template_method (int argc, VALUE *argv, VALUE self)
   return obj;
 }
 
+static VALUE
+rb_ca_template_method (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  return rb_ca_template_kw(argc, argv, ropt, self);
+}
+
 VALUE
 rb_ca_template (VALUE self)
 {
@@ -266,22 +314,21 @@ rb_ca_template (VALUE self)
 VALUE
 rb_ca_template_with_type (VALUE self, VALUE rtype, VALUE rbytes)
 {
-  VALUE ropt = rb_hash_new();
-  VALUE args[2] = { rtype, ropt };
+  volatile VALUE ropt = rb_hash_new();
   rb_set_options(ropt, "bytes", rbytes);
-  return rb_ca_template_method(2, args, self);
+  return rb_ca_template_kw(1, &rtype, ropt, self);
 }
 
-/* Picks the largest-shape CArray among `n` variadic CArray arguments
- * and returns `template(largest)`.  Used by `carray_call_cfunc.c` to
- * size the output of vectorised scalar C-function calls, where the
- * inputs may be a mix of scalars and arrays. */
+/* Returns `template` of the first non-scalar among `n` variadic CArray
+ * arguments (of the first argument when all are scalars).  Used by
+ * `carray_call_cfunc.c` to size the output of vectorised scalar
+ * C-function calls: a scalar pairs with any array, two arrays only when
+ * their shapes agree. */
 VALUE
 rb_ca_template_n (int n, ...)
 {
-  volatile VALUE varg, obj;
-  CArray *ca;
-  ca_size_t elements = -1;
+  volatile VALUE varg, obj = Qnil;
+  CArray *ca, *donor = NULL;
   va_list vargs;
   int i;
 
@@ -289,24 +336,23 @@ rb_ca_template_n (int n, ...)
   for (i=0; i<n; i++) {
     varg = va_arg(vargs, VALUE);
     if ( ! rb_obj_is_carray(varg) ) {
+      va_end(vargs);
       rb_raise(rb_eRuntimeError, "[BUG] not-carray object given to rb_ca_template_n");
     }
     TypedData_Get_Struct(varg, CArray, &carray_data_type, ca);
     if ( i == 0 ) {
       obj = varg;
-      elements = ca->elements;
     }
-    else {
-      if ( rb_obj_is_cscalar(varg) ) {
-        continue;
-      }
-      if ( rb_obj_is_cscalar(obj) ) {
-        obj = varg;
-        elements = ca->elements;
-      }
-      else if ( ca->elements != elements ) {
-        rb_raise(rb_eRuntimeError, "size mismatch");
-      }
+    if ( ca_is_scalar(ca) ) {
+      continue;
+    }
+    if ( ! donor ) {
+      donor = ca;
+      obj   = varg;
+    }
+    else if ( ! ca_sweep_same_shape(donor, ca) ) {
+      va_end(vargs);
+      ca_sweep_refuse_shapes(donor, ca);
     }
   }
   va_end(vargs);