carray 3.0.5 → 3.0.6

data/ext/carray_address_basis.c

@@ -965,6 +965,139 @@ address_basis_tier (VALUE module, VALUE object)
   return INT2NUM(tier_for(ca));
 }
 
+/* ------------------------------------------------------------------- */
+
+/*
+ * call-seq:
+ *   CArray::AddressBasis.sweep(function, fsync, arrays, *parts) -> nil
+ *
+ * Runs ca_call_cslab_N_r over `arrays` with the slab function at the address
+ * `function`, and hands it as `userdata` a table of pointers to the bytes of
+ * each of `parts`, in order.
+ *
+ * This is what a consumer did through Fiddle: copy the parts into memory
+ * from malloc, write the table in front of them, and call the family member
+ * for the arity.  The copy was there because a String's bytes may be moved
+ * by GC compaction, and the sweep allocates -- so a collection can run
+ * between taking an address and the slab reading it.  It is not needed
+ * here: every part is also held in an array on the machine stack for the
+ * length of this call, and an object referenced from there is pinned.  The
+ * VM stack is not enough by itself -- a splat of 128 or more arguments
+ * reaches a C method as a heap array, whose elements compaction moves.
+ * The machine stack is why the parts are limited to 1024.
+ *
+ * A part that is not frozen is the slab's to write (an error slot), and is
+ * made unshared first so the write lands in that String alone.  A frozen
+ * part is read only.  Each part has to start on an 8-byte boundary, since a
+ * slab reads doubles and int64s out of them.
+ */
+static VALUE
+address_basis_sweep (int argc, VALUE *argv, VALUE module)
+{
+  volatile VALUE rfunction, rfsync, rarrays;
+  ca_cslab_r_t function;
+  const char *fsync;
+  VALUE vholder = 0;
+  void **table;
+  VALUE *arrays;
+  volatile VALUE *parts;
+  int i, n, nparts;
+
+  rb_check_arity(argc, 3, UNLIMITED_ARGUMENTS);
+  rfunction = argv[0];
+  rfsync    = argv[1];
+  rarrays   = argv[2];
+  nparts    = argc - 3;
+
+  if ( nparts > 1024 ) {
+    rb_raise(rb_eArgError, "%s: a sweep takes at most 1024 parts, got %d",
+             ca_calling_method_name(), nparts);
+  }
+  /* Held on the machine stack, which the GC scans conservatively and so
+     pins.  argv is not written: it may be the storage of a heap array. */
+  parts = ALLOCA_N(VALUE, nparts > 0 ? nparts : 1);
+  for ( i = 0; i < nparts; i++ ) {
+    parts[i] = argv[3 + i];
+  }
+
+  Check_Type(rarrays, T_ARRAY);
+  n = (int) RARRAY_LEN(rarrays);
+  if ( n < 1 || n > 7 ) {
+    rb_raise(rb_eArgError, "%s: a sweep takes 1 to 7 arrays, got %d",
+             ca_calling_method_name(), n);
+  }
+  fsync = StringValueCStr(rfsync);
+  if ( (int) strlen(fsync) != n ) {
+    rb_raise(rb_eArgError, "%s: fsync has %d characters for %d arrays",
+             ca_calling_method_name(), (int) strlen(fsync), n);
+  }
+  for ( i = 0; i < n; i++ ) {
+    if ( fsync[i] != '0' && fsync[i] != '1' ) {
+      rb_raise(rb_eArgError,
+               "%s: fsync character %d is '%c', not '0' (read) or '1' (written)",
+               ca_calling_method_name(), i, fsync[i]);
+    }
+  }
+  function = (ca_cslab_r_t) (uintptr_t) NUM2ULL(rfunction);
+  if ( ! function ) {
+    rb_raise(rb_eArgError, "%s: the slab function's address is zero",
+             ca_calling_method_name());
+  }
+
+  arrays = RARRAY_PTR(rarrays);
+  for ( i = 0; i < n; i++ ) {
+    if ( ! rb_obj_is_kind_of(arrays[i], rb_cCArray) ) {
+      rb_raise(rb_eTypeError, "%s: array %d is not a CArray",
+               ca_calling_method_name(), i);
+    }
+  }
+
+  for ( i = 0; i < nparts; i++ ) {
+    VALUE part = parts[i];
+    StringValue(part);
+    parts[i] = part;
+    if ( ! OBJ_FROZEN(part) ) {
+      rb_str_modify(part);
+    }
+    if ( (uintptr_t) RSTRING_PTR(part) & 7 ) {
+      rb_raise(rb_eArgError, "%s: part %d does not start on an 8-byte boundary",
+               ca_calling_method_name(), i);
+    }
+  }
+
+  /* Taken after every check, so a refusal has nothing to free.  The sweep
+     itself can raise (a shape that will not broadcast); then the table is
+     left to ALLOCV's own holder, which the GC reclaims. */
+  table = ALLOCV_N(void *, vholder, nparts > 0 ? nparts : 1);
+  for ( i = 0; i < nparts; i++ ) {
+    table[i] = RSTRING_PTR(parts[i]);
+  }
+
+  switch ( n ) {
+  case 1: ca_call_cslab_1_r(function, fsync, arrays[0], table); break;
+  case 2: ca_call_cslab_2_r(function, fsync, arrays[0], arrays[1], table); break;
+  case 3: ca_call_cslab_3_r(function, fsync, arrays[0], arrays[1], arrays[2],
+                            table); break;
+  case 4: ca_call_cslab_4_r(function, fsync, arrays[0], arrays[1], arrays[2],
+                            arrays[3], table); break;
+  case 5: ca_call_cslab_5_r(function, fsync, arrays[0], arrays[1], arrays[2],
+                            arrays[3], arrays[4], table); break;
+  case 6: ca_call_cslab_6_r(function, fsync, arrays[0], arrays[1], arrays[2],
+                            arrays[3], arrays[4], arrays[5], table); break;
+  case 7: ca_call_cslab_7_r(function, fsync, arrays[0], arrays[1], arrays[2],
+                            arrays[3], arrays[4], arrays[5], arrays[6],
+                            table); break;
+  }
+
+  ALLOCV_END(vholder);
+  for ( i = 0; i < nparts; i++ ) {
+    RB_GC_GUARD(parts[i]);
+  }
+  RB_GC_GUARD(rarrays);
+  RB_GC_GUARD(rfsync);
+  return Qnil;
+}
+
 /* ------------------------------------------------------------------- */
 /* Init_carray_address_basis                                            */
 /* ------------------------------------------------------------------- */
@@ -978,6 +1111,7 @@ Init_carray_address_basis (void)
   rb_define_singleton_method(mAddressBasis, "classify",
                              address_basis_classify, 1);
   rb_define_singleton_method(mAddressBasis, "tier", address_basis_tier, 1);
+  rb_define_singleton_method(mAddressBasis, "sweep", address_basis_sweep, -1);
 
   rb_define_const(mAddressBasis, "TIER_ENTITY", INT2NUM(TIER_ENTITY));
   rb_define_const(mAddressBasis, "TIER_STRIDE", INT2NUM(TIER_STRIDE));

data/ext/carray_attribute.c

@@ -223,6 +223,14 @@ ca_is_readonly (void *ap)
         return 1;
       }
     }
+    if ( ca_test_flag(ca, CA_FLAG_FOLDED) ) {
+      /* a folded reshape: its source is not on the parent chain */
+      CArray *src = ca_fold_source(ca);
+      if ( src && ca_is_readonly(src) ) {
+        ca_set_flag(ca, CA_FLAG_READ_ONLY);
+        return 1;
+      }
+    }
     return 0;                                            /* all test -> false */
   }
 }

data/ext/carray_broadcast.c

@@ -85,13 +85,12 @@ ca_broadcast_to_destination (VALUE dst, volatile VALUE *src)
     for ( i = 0; agree && i < dst_ndim; i++ ) {
       if ( dst_dim[i] != src_dim[i] ) agree = 0;
     }
-    if ( ! agree ) ca_broadcast_refuse_write(dst, *src);
-    return;
+    if ( agree ) return;
   }
 
   /* A size-1 axis repeated onto an axis of length 0 leaves the source
-     larger than an empty destination; the axes say it is a repeat all
-     the same. */
+     larger than an empty destination, or as large when it is empty too
+     ((1,0) onto (2,0)); the axes say it is a repeat all the same. */
   if ( ( cs->elements < cd->elements || cd->elements == 0 )
        && cs->ndim == cd->ndim ) {
     int i;

data/ext/carray_build_flags.h

@@ -1,3 +1,3 @@
 /* GENERATED by extconf.rb: the flags this build's arithmetic
    was compiled with.  See CArray::BUILD_FLAGS. */
-#define CA_BUILD_FLAGS "-O3 -fno-fast-math -fwrapv -fopenmp-simd -march=native"
+#define CA_BUILD_FLAGS "-O3 -fno-fast-math -fwrapv -fno-math-errno -fopenmp-simd -march=native"

data/ext/carray_cast.c

@@ -1609,7 +1609,6 @@ static VALUE
 rb_ca_as_type_internal (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE obj, rtype = Qnil, ropt, rbytes = Qnil;
-  CArray *ca;
   int8_t data_type;
   ca_size_t bytes;
 
@@ -1618,14 +1617,12 @@ rb_ca_as_type_internal (int argc, VALUE *argv, VALUE self)
 
   rb_ca_guess_type_and_bytes(rtype, rbytes, &data_type, &bytes);
 
-  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
-  if ( ca->data_type == data_type ) {
-    if ( ! ca_is_fixlen_type(ca) ) {
-      return self;
-    }
-  }
+  rb_check_carray_object(self);
+
+  /* A view also when the data_type is the receiver's own: what is done to
+     it (an attribute, a freeze) stays with it.
 
-  /* Natural-width cast: dispatch via helper (CAMonOp for numeric,
+     Natural-width cast: dispatch via helper (CAMonOp for numeric,
      CAFake for CA_FIXLEN sizing / CA_OBJECT / class-rtype). */
   if ( bytes == (ca_size_t) ca_sizeof[data_type] ) {
     obj = ca_type_adapt_view(self, rtype, data_type, CA_ADAPT_VIEW);
@@ -3434,7 +3431,7 @@ rb_ca_read_text_as_number (int argc, VALUE *argv, VALUE self)
   if ( ca->data_type != CA_OBJECT ) {
     rb_raise(rb_eArgError, "decimal reading needs an object array");
   }
-  if ( ! ca_is_entity(ca) ) {
+  if ( ! ca_is_entity(ca) || ! ca->ptr ) {
     src = rb_ca_copy(src);
     TypedData_Get_Struct(src, CArray, &carray_data_type, ca);
   }
@@ -3571,7 +3568,7 @@ rb_ca_infer_number_type_of_text (VALUE self)
   if ( ca->data_type != CA_OBJECT ) {
     rb_raise(rb_eArgError, "type inference needs an object array");
   }
-  if ( ! ca_is_entity(ca) ) {
+  if ( ! ca_is_entity(ca) || ! ca->ptr ) {
     src = rb_ca_copy(src);
     TypedData_Get_Struct(src, CArray, &carray_data_type, ca);
   }
@@ -3634,7 +3631,7 @@ ca_const_string_buffer_and_ranges (VALUE cs, VALUE *buffer, CArray **ranges)
   *buffer = rb_funcall(cs, rb_intern("buffer"), 0);
   vranges = rb_ca_parent(cs);
   TypedData_Get_Struct(vranges, CArray, &carray_data_type, *ranges);
-  if ( ! ca_is_entity(*ranges) ) {
+  if ( ! ca_is_entity(*ranges) || ! (*ranges)->ptr ) {
     vranges = rb_ca_copy(vranges);
     TypedData_Get_Struct(vranges, CArray, &carray_data_type, *ranges);
   }

data/ext/carray_conversion.c

@@ -369,7 +369,8 @@ rb_ca_convert (int argc, VALUE *argv, VALUE self)
 
   list[0] = c.ca;
   list[1] = c.co;
-  ca_attach_window(2, list, "rw", ca_convert_body, (VALUE) &c);
+  ca_attach_window_yielding(rb_assoc_new(self, obj), 2, list, "rw",
+                            ca_convert_body, (VALUE) &c);
 
   return obj;
 }
@@ -417,9 +418,11 @@ rb_ca_dump_binary (int argc, VALUE *argv, VALUE self)
     ca_size_t total = ca_length(ca);
     GetOpenFile(io, iop);
     rb_io_check_writable(iop);
-    if ( ca_is_entity(ca) ) {
+    if ( ca_is_entity(ca) && ca->ptr ) {
       /* Owned ca->ptr: write through the IO buffer machinery so peak
-         stays at ca_length instead of doubling via a Ruby String. */
+         stays at ca_length instead of doubling via a Ruby String.  An
+         entity that leaves ptr NULL at rest (a CASource) takes the
+         gather below. */
       ssize_t n = rb_io_bufwrite(io, ca->ptr, (size_t) total);
       if ( n < 0 || (ca_size_t) n != total ) {
         rb_raise(rb_eRuntimeError,
@@ -428,7 +431,8 @@ rb_ca_dump_binary (int argc, VALUE *argv, VALUE self)
       }
     }
     else {
-      /* View: no chunked gather API, so materialise into one buffer. */
+      /* View, or entity without a ptr: no chunked gather API, so
+         materialise into one buffer. */
       volatile VALUE buf = rb_str_new(NULL, total);
       ca_copy_data(ca, RSTRING_PTR(buf));
       rb_io_write(io, buf);
@@ -545,7 +549,7 @@ rb_ca_load_binary (VALUE self, VALUE io)
 }
 
 /* The double nearest to the shortest decimal that reads back as x, the
-   float32 value, as from_csv reads text into float32: strtod, then the cast
+   float32 value, as read_csv reads text into float32: strtod, then the cast
    to float.  Its digits are those of the decimal (at most 9, which a double
    holds), so Float#to_s writes them. */
 static double