carray 3.0.4 → 3.0.6

data/ext/carray_struct.c

@@ -194,20 +194,40 @@ ca_struct_write_primitive_fast (char *p, int type_code, VALUE val)
    to keep neighbouring bits untouched.
    --------------------------------------------------------------------- */
 
+/* The word's bytes are read and written least significant first on
+   every host: the layout numbers the bits byte by byte from the record's
+   start, so a field read through a wider word than its neighbour still
+   sees the same bits. */
+static uint64_t
+ca_struct_load_le (const char *p, int n)
+{
+  uint64_t word = 0;
+  int i;
+  for (i = 0; i < n; i++) {
+    word |= (uint64_t) (uint8_t) p[i] << (8 * i);
+  }
+  return word;
+}
+
+static void
+ca_struct_store_le (char *p, int n, uint64_t word)
+{
+  int i;
+  for (i = 0; i < n; i++) {
+    p[i] = (char) (word >> (8 * i));
+  }
+}
+
 static VALUE
 ca_struct_read_bitfield_fast (const char *p, int view_bytes,
                               int bit_in_word, int bits)
 {
-  uint64_t word = 0;
-  switch (view_bytes) {
-  case 1: { uint8_t  v; memcpy(&v, p, 1); word = v; break; }
-  case 2: { uint16_t v; memcpy(&v, p, 2); word = v; break; }
-  case 4: { uint32_t v; memcpy(&v, p, 4); word = v; break; }
-  case 8: { uint64_t v; memcpy(&v, p, 8); word = v; break; }
-  default:
+  uint64_t word;
+  if ( view_bytes != 1 && view_bytes != 2 && view_bytes != 4 && view_bytes != 8 ) {
     rb_raise(rb_eRuntimeError,
              "[BUG] bitfield view_bytes %d not in {1,2,4,8}", view_bytes);
   }
+  word = ca_struct_load_le(p, view_bytes);
   uint64_t mask = (bits >= 64) ? ~(uint64_t)0
                                : ((uint64_t)1 << bits) - 1;
   uint64_t val  = (word >> bit_in_word) & mask;
@@ -224,7 +244,11 @@ static void
 ca_struct_write_bitfield_fast (char *p, int view_bytes,
                                int bit_in_word, int bits, VALUE val)
 {
-  uint64_t v;
+  uint64_t v, word;
+  if ( view_bytes != 1 && view_bytes != 2 && view_bytes != 4 && view_bytes != 8 ) {
+    rb_raise(rb_eRuntimeError,
+             "[BUG] bitfield view_bytes %d not in {1,2,4,8}", view_bytes);
+  }
   if ( bits == 1 ) {
     if      ( val == Qtrue  || val == INT2FIX(1) ) v = 1;
     else if ( val == Qfalse || val == INT2FIX(0) ) v = 0;
@@ -240,41 +264,9 @@ ca_struct_write_bitfield_fast (char *p, int view_bytes,
   uint64_t mask = (bits >= 64) ? ~(uint64_t)0
                                : ((uint64_t)1 << bits) - 1;
   v &= mask;
-  uint64_t shifted_mask = mask << bit_in_word;
-  uint64_t shifted_val  = v    << bit_in_word;
-  switch (view_bytes) {
-  case 1: {
-    uint8_t word;
-    memcpy(&word, p, 1);
-    word = (uint8_t)((word & ~(uint8_t)shifted_mask) | (uint8_t)shifted_val);
-    memcpy(p, &word, 1);
-    return;
-  }
-  case 2: {
-    uint16_t word;
-    memcpy(&word, p, 2);
-    word = (uint16_t)((word & ~(uint16_t)shifted_mask) | (uint16_t)shifted_val);
-    memcpy(p, &word, 2);
-    return;
-  }
-  case 4: {
-    uint32_t word;
-    memcpy(&word, p, 4);
-    word = (uint32_t)((word & ~(uint32_t)shifted_mask) | (uint32_t)shifted_val);
-    memcpy(p, &word, 4);
-    return;
-  }
-  case 8: {
-    uint64_t word;
-    memcpy(&word, p, 8);
-    word = (word & ~shifted_mask) | shifted_val;
-    memcpy(p, &word, 8);
-    return;
-  }
-  default:
-    rb_raise(rb_eRuntimeError,
-             "[BUG] bitfield view_bytes %d not in {1,2,4,8}", view_bytes);
-  }
+  word = ca_struct_load_le(p, view_bytes);
+  word = (word & ~(mask << bit_in_word)) | (v << bit_in_word);
+  ca_struct_store_le(p, view_bytes, word);
 }
 
 /* ---------------------------------------------------------------------

data/ext/carray_test.c

@@ -274,10 +274,23 @@ eql_## type (const char *a, const char *b, ca_size_t bytes) \
   return ( *(const type*)a == *(const type*)b ); \
 }
 
+/* == compares contents: a NaN equals a NaN (whatever its payload), as the
+   same array read back or copied holds the same NaN; -0.0 equals 0.0 as
+   values do.  eql? stays bitwise. */
+static int
+ca_object_cells_equal (VALUE x, VALUE y)
+{
+  if ( RB_FLOAT_TYPE_P(x) && RB_FLOAT_TYPE_P(y) &&
+       isnan(RFLOAT_VALUE(x)) && isnan(RFLOAT_VALUE(y)) ) {
+    return 1;
+  }
+  return RTEST(rb_funcall(x, id_equal, 1, y)) ? 1 : 0;
+}
+
 static int
 eql_VALUE (const char *a, const char *b, ca_size_t bytes)
 {
-  return RTEST(rb_funcall(*(const VALUE*)a, id_equal, 1, *(const VALUE*)b)) ? 1 : 0;
+  return ca_object_cells_equal(*(const VALUE*)a, *(const VALUE*)b);
 }
 
 static int
@@ -295,10 +308,28 @@ eql_type(int32_t)
 eql_type(uint32_t)
 eql_type(int64_t)
 eql_type(uint64_t)
-eql_type(float32_t)
-eql_type(float64_t)
-eql_type(cmplx64_t)
-eql_type(cmplx128_t)
+#define eql_float(type)        \
+static int                      \
+eql_## type (const char *a, const char *b, ca_size_t bytes) \
+{                               \
+  type x = *(const type*)a, y = *(const type*)b; \
+  return ( x == y ) || ( isnan(x) && isnan(y) ); \
+}
+
+#define eql_cmplx(type, part)   \
+static int                      \
+eql_## type (const char *a, const char *b, ca_size_t bytes) \
+{                               \
+  type x = *(const type*)a, y = *(const type*)b; \
+  part xr = creal(x), xi = cimag(x), yr = creal(y), yi = cimag(y); \
+  return ( ( xr == yr ) || ( isnan(xr) && isnan(yr) ) ) && \
+         ( ( xi == yi ) || ( isnan(xi) && isnan(yi) ) ); \
+}
+
+eql_float(float32_t)
+eql_float(float64_t)
+eql_cmplx(cmplx64_t, float)
+eql_cmplx(cmplx128_t, double)
 
 /* Placeholder for CA_FLOAT128 / CA_CMPLX256 slots (ca_valid[12] =
    ca_valid[15] = 0, so never invoked). */
@@ -371,8 +402,8 @@ ca_compare_body (VALUE arg)
      comparison is bitwise (= NaN.eql?(NaN) yields true since their bit
      patterns match), so memcmp gives the right semantics. For non-strict
      (==) of numeric data_types, type-equality is byte-equality EXCEPT for
-     floats where -0.0 == +0.0 (different bit pattern, same value) and
-     NaN != NaN (same bit pattern, unequal value) -- so we must keep the
+     floats where -0.0 == +0.0 (different bit pattern, same value) and any
+     NaN equals any NaN (payloads may differ) -- so we must keep the
      per-element comparator there.
 
      Integer / bool / fixlen data_types are byte-exact, so memcmp matches both
@@ -380,13 +411,14 @@ ca_compare_body (VALUE arg)
      the comparator. */
   if ( ! masked_a && ! masked_b ) {
     if ( is_object ) {
-      ID id = strict ? id_eql : id_equal;
       VALUE *va = (VALUE *) pa;
       VALUE *vb = (VALUE *) pb;
       for (i=0; i<ca->elements; i++) {
         volatile VALUE x = va[i];
         volatile VALUE y = vb[i];
-        if ( ! RTEST(rb_funcall(x, id, 1, y)) ) {
+        int eq = strict ? RTEST(rb_funcall(x, id_eql, 1, y))
+                        : ca_object_cells_equal(x, y);
+        if ( ! eq ) {
           flag = 0;
           break;
         }
@@ -427,8 +459,8 @@ ca_compare_body (VALUE arg)
         if ( is_object ) {
           volatile VALUE x = *(VALUE *) pa;
           volatile VALUE y = *(VALUE *) pb;
-          ID id = strict ? id_eql : id_equal;
-          eq = RTEST(rb_funcall(x, id, 1, y));
+          eq = strict ? RTEST(rb_funcall(x, id_eql, 1, y))
+                      : ca_object_cells_equal(x, y);
         }
         else if ( strict
                   || ca->data_type <= CA_UINT64
@@ -451,6 +483,19 @@ ca_compare_body (VALUE arg)
   return Qnil;
 }
 
+typedef struct {
+  CArray           **list;
+  ca_compare_ctx_t  *c;
+} ca_compare_run_t;
+
+static VALUE
+ca_compare_run (VALUE arg)
+{
+  ca_compare_run_t *r = (ca_compare_run_t *) arg;
+  ca_attach_window(2, r->list, "rr", ca_compare_body, (VALUE) r->c);
+  return Qnil;
+}
+
 /* ca_compare_common(a, b, strict) — shared body of ca_equal (==) and
  * ca_eql_strict (eql?).  Returns 1 if arrays match under the selected
  * semantics, else 0.
@@ -461,7 +506,7 @@ ca_compare_body (VALUE arg)
  * four masked/unmasked combinations.
  *
  * The only difference is the per-element comparator:
- *   == : ca_eql[data_type] (type-specific, so float NaN != NaN)
+ *   == : ca_eql[data_type] (by value: NaN equals NaN, -0.0 equals 0.0)
  *   eql?: memcmp for numeric, rb_funcall(:eql?) for CA_OBJECT
  *
  * The unmasked-unmasked branch takes a bulk memcmp or per-cell
@@ -503,8 +548,14 @@ ca_compare_common (void *ap, void *bp, int strict)
     c.flag   = 1;
     list[0]  = ca;
     list[1]  = cb;
-    /* The object lane calls #== / #eql? with both arrays attached. */
-    ca_attach_window(2, list, "rr", ca_compare_body, (VALUE) &c);
+    /* The object lane calls #== / #eql? with both arrays attached, and
+       recorded as compared over (ca_computing_run), so a cell holding one
+       of them is refused as cyclic rather than compared again without
+       end. */
+    ca_compare_run_t r;
+    r.list = list;
+    r.c    = &c;
+    ca_computing_run(2, list, ca_compare_run, (VALUE) &r);
     return c.flag;
   }
 }
@@ -522,9 +573,10 @@ ca_eql_storage (void *ap, void *bp)
 }
 
 /* CArray#==(other) — elementwise equality returning true / false.
- * data_class, data_type, shape, and mask state must all match; NaN
- * compares unequal per IEEE semantics.  Non-CArray other returns
- * false. */
+ * data_class, data_type, shape, and mask state must all match.  It asks
+ * whether the contents are the same, so a NaN equals a NaN and -0.0
+ * equals 0.0; the IEEE comparison of each element is #eq.  Non-CArray
+ * other returns false. */
 static VALUE
 rb_ca_equal (VALUE self, VALUE other)
 {
@@ -795,7 +847,8 @@ without_read_only_ensure (VALUE arg)
  * the bridge owns.
  *
  * Mechanics: clears CA_FLAG_READ_ONLY on self and on its mask for the
- * duration of the block; rb_ensure restores both on normal return AND on
+ * duration of the block, except on a mask that is a wrap: that mask borrows
+ * its bits from a producer (wrap_memory_view's mask:), which set the flag; rb_ensure restores both on normal return AND on
  * raise, setting the flag on whatever mask self has by then.  (A read-only
  * array's mask carries the flag once CArray#mask has handed it out.)  Frozen
  * objects still raise FrozenError.  Does not walk parent chains.
@@ -822,7 +875,9 @@ rb_ca_without_read_only_flag (VALUE self)
   s.was_readonly = ca_test_flag(ca, CA_FLAG_READ_ONLY);
   if (s.was_readonly) {
     ca_unset_flag(ca, CA_FLAG_READ_ONLY);
-    if (ca->mask) {
+    /* A mask that is a wrap borrows its bits (the mask: of
+       wrap_memory_view); its flag is the lender's and stays. */
+    if (ca->mask && ca->mask->obj_type != CA_OBJ_ARRAY_WRAP) {
       ca_unset_flag(ca->mask, CA_FLAG_READ_ONLY);
     }
   }

data/ext/carray_time_text.c

@@ -234,7 +234,9 @@ ca_time_text_read (VALUE str, ca_time_text_t *t, int wide)
         }
       }
     }
-    if ( hour > 24 || min > 59 || sec > 59 ) {
+    /* Second 60 is the leap second; it carries into the next minute below,
+       as CArray.time reads it. */
+    if ( hour > 24 || min > 59 || sec > 60 ) {
       return CA_TIME_TEXT_UNREADABLE;
     }
     /* Hour 24 is the end of the day, 24:00:00, and nothing past it, as in
@@ -359,7 +361,7 @@ rb_ca_parse_time_text (int argc, VALUE *argv, VALUE self)
   boolean8_t *m_in, *m_out;
   int64_t *days, *nsod, *months, *ticks;
   int64_t per_day = 1, ns_per_tick = 1;
-  ID unit;
+  ID unit = 0;
   int clock = 0, fraction = 0, coarse = 2, any = 0, wide;
   int calendar = 0;              /* 1 ticks of months, 2 of years */
   ca_size_t i;
@@ -381,7 +383,7 @@ rb_ca_parse_time_text (int argc, VALUE *argv, VALUE self)
   if ( ca->data_type != CA_OBJECT ) {
     rb_raise(rb_eArgError, "time text 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);
   }
@@ -1075,7 +1077,7 @@ rb_ca_strptime_fields (VALUE self, VALUE rformat, VALUE rstrict)
   if ( ca->data_type != CA_OBJECT ) {
     rb_raise(rb_eArgError, "strptime 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);
   }

data/ext/carray_utils.c

@@ -371,6 +371,10 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
     last  = NUM2SIZE(x.end);
     excl  = RTEST(x.exclude_end);
     step  = NUM2SIZE(x.step);
+    if ( step == 0 ) {
+      rb_raise(rb_eArgError, "%s: step should not be 0",
+               ca_calling_method_name());
+    }
     if ( excl ) {
       last += ( (last>=start) ? -1 : 1 );
     }
@@ -391,6 +395,10 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
       if ( NIL_P(arg0) ) {              /* [nil,k] */
         start = 0;
         step  = NUM2SIZE(arg1);
+        if ( step == 0 ) {
+          rb_raise(rb_eArgError, "%s: step should not be 0",
+                   ca_calling_method_name());
+        }
         count = (size-1)/llabs(step) + 1;
         *poffset = start;
         *pcount  = count;
@@ -401,6 +409,10 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
         last  = NUM2SIZE(RANGE_END(arg0));
         excl  = RTEST(RANGE_EXCL(arg0));
         step  = NUM2SIZE(arg1);
+        if ( step == 0 ) {
+          rb_raise(rb_eArgError, "%s: step should not be 0",
+                   ca_calling_method_name());
+        }
         if ( excl ) {
           last += ( (last>=start) ? -1 : 1 );
         }
@@ -418,6 +430,10 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
         last  = NUM2SIZE(x.end);
         excl  = RTEST(x.exclude_end);
         step  = NUM2SIZE(x.step);
+        if ( step == 0 ) {
+          rb_raise(rb_eArgError, "%s: step should not be 0",
+                   ca_calling_method_name());
+        }
         if ( excl ) {
           last += ( (last>=start) ? -1 : 1 );
         }
@@ -922,6 +938,15 @@ ca_reduce_fill (VALUE result, VALUE fill, int whole)
     if ( ca_has_mask(cr) ) {
       result = rb_ca_mask_fill_copy(result, fill);
     }
+    else if ( cr->elements > 0 ) {
+      /* No cell needed the fill, but a fill the result cannot hold is
+         refused all the same, not only when some cell happens to be
+         undefined: it goes into a one-cell array of the result's kind. */
+      volatile VALUE one = rb_funcall(rb_funcall(result, rb_intern("flatten"), 0),
+                                      rb_intern("[]"), 1,
+                                      rb_range_new(INT2FIX(0), INT2FIX(0), 0));
+      rb_ca_store_addr(rb_ca_template(one), 0, fill);
+    }
     return whole ? rb_ca_fetch_addr(result, 0) : result;
   }
   return ( result == CA_UNDEF ) ? fill : result;
@@ -1253,11 +1278,36 @@ rb_hash_has_key(VALUE hash, VALUE key)
   return Qfalse;
 }
 
+/* The next comma-separated key of a spec, its length in *len, or NULL
+   past the last key.  The spec is read in place: a copy to cut up would
+   be a C allocation, and its failure has nowhere to go but to drop every
+   keyword. */
+static const char *
+option_key (const char **sp, long *len)
+{
+  const char *p = *sp, *end;
+
+  if ( p == NULL ) {
+    return NULL;
+  }
+  end = strchr(p, ',');
+  if ( end ) {
+    *len = end - p;
+    *sp  = end + 1;
+  }
+  else {
+    *len = (long) strlen(p);
+    *sp  = NULL;
+  }
+  return p;
+}
+
 void
 rb_scan_options (VALUE ropt, const char *spec_in, ...)
 {
   VALUE *vp;
-  char *sp, *tok, *spec;
+  const char *sp, *tok;
+  long len;
   int has_option = 0;
   va_list vals;
 
@@ -1272,22 +1322,19 @@ rb_scan_options (VALUE ropt, const char *spec_in, ...)
   }
 
   va_start(vals, spec_in);
-  sp = spec = strdup(spec_in);
-  tok = strsep1(&sp, ',');
-  while ( tok != NULL ) {
+  sp = spec_in;
+  while ( ( tok = option_key(&sp, &len) ) != NULL ) {
     vp = va_arg(vals, VALUE*);
     if ( has_option ) {
-      VALUE key = ID2SYM(rb_intern(tok));
+      VALUE key = ID2SYM(rb_intern2(tok, len));
       if ( rb_hash_has_key(ropt, key) ) {
         *vp = rb_hash_aref(ropt, key);
       }
       /* key absent: leave *vp unchanged (caller's pre-initialized default) */
     }
     /* opts == Qnil: leave all *vp unchanged */
-    tok = strsep1(&sp, ',');
   }
   va_end(vals);
-  free(spec);
 
   /* Strict: reject any key not named in spec, matching Ruby's native
      keyword-argument behaviour ("unknown keyword: :foo").  Every call
@@ -1300,15 +1347,12 @@ rb_scan_options (VALUE ropt, const char *spec_in, ...)
       VALUE key = rb_ary_entry(keys, i);
       VALUE kname = SYMBOL_P(key) ? rb_sym2str(key) : rb_obj_as_string(key);
       const char *kn = StringValueCStr(kname);
-      char *sp2, *tok2, *spec2;
+      long kn_len = RSTRING_LEN(kname);
       int found = 0;
-      sp2 = spec2 = strdup(spec_in);
-      tok2 = strsep1(&sp2, ',');
-      while ( tok2 != NULL ) {
-        if ( strcmp(tok2, kn) == 0 ) { found = 1; break; }
-        tok2 = strsep1(&sp2, ',');
+      sp = spec_in;
+      while ( ( tok = option_key(&sp, &len) ) != NULL ) {
+        if ( len == kn_len && memcmp(tok, kn, len) == 0 ) { found = 1; break; }
       }
-      free(spec2);
       if ( ! found ) {
         rb_raise(rb_eArgError, "unknown keyword: %"PRIsVALUE, rb_inspect(key));
       }
@@ -1341,7 +1385,8 @@ void
 rb_set_options (VALUE ropt, const char *spec_in, ...)
 {
   VALUE rval;
-  char *sp, *tok, *spec;
+  const char *sp, *tok;
+  long len;
   int has_option = 0;
   va_list vals;
 
@@ -1356,17 +1401,14 @@ rb_set_options (VALUE ropt, const char *spec_in, ...)
   }
 
   va_start(vals, spec_in);
-  sp = spec = strdup(spec_in);
-  tok = strsep1(&sp, ',');
-  while ( tok != NULL ) {
+  sp = spec_in;
+  while ( ( tok = option_key(&sp, &len) ) != NULL ) {
     rval = va_arg(vals, VALUE);
     if ( has_option ) {
-      rb_hash_aset(ropt, ID2SYM(rb_intern(tok)), rval);
+      rb_hash_aset(ropt, ID2SYM(rb_intern2(tok, len)), rval);
     }
-    tok = strsep1(&sp, ',');
   }
   va_end(vals);
-  free(spec);
 
   return;
 }

data/ext/extconf.rb

@@ -118,6 +118,17 @@ if try_compile("int main(void) { return 0; }", "-fwrapv")
   $carray_build_flags << "-fwrapv"
 end
 
+# --- math functions do not set errno (`-fno-math-errno`)
+#
+# Nothing in carray reads errno after a math call.  With errno kept, GCC
+# must call sqrt() for every cell instead of using the vector square root,
+# so `sqrt` ran 2-4x slower than it could.  The values do not change.
+# Apple clang already defaults to this.
+if try_compile("int main(void) { return 0; }", "-fno-math-errno")
+  $CFLAGS += " -fno-math-errno"
+  $carray_build_flags << "-fno-math-errno"
+end
+
 # --- probe for `-fopenmp-simd` (SL.1.0, PROPOSAL_REDUCTION_SIMD_LICENSE)
 #
 # `-fopenmp-simd` enables `#pragma omp simd` (and its `reduction(+:acc)`