carray 3.0.0 → 3.0.2

data/ext/carray_scatter.c

@@ -9,7 +9,7 @@
     duplicates unbuffered (sequential) — collisions accumulate
     mask       pair skipped when any of addrs[i] / vals[i] / self[addrs[i]] is masked
     cast       vals silently cast to self.data_type
-    dtype      arithmetic (add / sub / mul / min / max): numeric only
+    data type      arithmetic (add / sub / mul / min / max): numeric only
                (boolean / object / fixlen → CADataTypeError; the bang
                cannot widen self, same rationale as fma! / fms!)
                replace: numeric or boolean (assignment, no widening)

data/ext/carray_slab.c

@@ -460,6 +460,19 @@ ca_slab_setup_input_slab_view (ca_slab_iter_state_t *st, CArray *src,
     }
   }
 
+  /* The slab is a window onto the source when the fiber is contiguous and
+     a copy in the iterator's scratch when it is not, so writing through it
+     landed on one axis and vanished on the next.  Nothing in the surface
+     said which you would get.  Refuse the write on both instead: the block
+     forms that produce values (map_slab, reduce_slab) hand their result
+     back rather than writing into the slab, and an in-place walk belongs
+     to `ca[] = ...` or a C kernel with CA_KERNEL_WRITE. */
+  {
+    CArray *slab;
+    TypedData_Get_Struct(st->slab_view, CArray, &carray_data_type, slab);
+    ca_set_flag(slab, CA_FLAG_READ_ONLY);
+  }
+
   return in_alias;
 }
 

data/ext/carray_sort.c

@@ -46,7 +46,7 @@ struct sort_addr_key {
 /* Multi-key comparator for CArray.sort_addr: compares keys in priority
  * order, original index breaks ties (stable).  Masked cells are an
  * incomparable sentinel clustered at base->masked_last's end (same
- * role NaN plays for float dtypes, and the same masked_position:
+ * role NaN plays for float data types, and the same masked_position:
  * contract as the sort/partition family's :sentinel kernel mode --
  * see MASKED_POSITION rev1 in mkkernel.rb's MkKernel.sort doc).
  *
@@ -531,7 +531,7 @@ rb_ca_axis2addr (int argc, VALUE *argv, VALUE self)
  *                       worst case.
  *
  * Mask handling: masked cells are an incomparable sentinel, the same
- * role NaN plays for float dtypes.  They are excluded from the value
+ * role NaN plays for float data types.  They are excluded from the value
  * comparison and clustered at one end of each fiber; masked_position:
  * picks which end (:last, default, or :first).  Relative order within
  * the masked cluster is unspecified (same contract as the < / > regions
@@ -639,12 +639,20 @@ rb_ca_sorted_view (int argc, VALUE *argv, VALUE self)
  * fiber, no pair struct, no view layer.  This fast path is numeric-only
  * and mask-free (CA_KERNEL_NO_MASK below).
  *
- * CA_FIXLEN and masked input both delegate to {sort} + copy instead of
- * duplicating the fixlen dialect / mask-position split in this per-
- * fiber loop: masked_position: is forwarded unchanged.  Masked cells
- * keep their masked-ness (the view's remap gather carries the mask bit
- * through, and .copy materializes it), clustered at masked_position:
- * within each fiber -- same contract as {sort}.
+ * Everything the fast path does not cover -- any data_type outside
+ * CA_INT8..CA_FLOAT64 (fixlen, boolean, complex, object), and masked
+ * input of any type -- delegates to {sort} + copy rather than duplicate
+ * the fixlen dialect / the object comparator / the mask-position split
+ * in this per-fiber loop; masked_position: is forwarded unchanged.
+ * Masked cells keep their masked-ness (the view's remap gather carries
+ * the mask bit through, and .copy materializes it), clustered at
+ * masked_position: within each fiber -- same contract as {sort}.
+ *
+ * So sort_copy answers for exactly what sort answers for, which is what
+ * being its eager counterpart means.  It once refused everything the
+ * fast path could not take: object and boolean sorted through {sort}
+ * but not through this, and complex reported its refusal in two
+ * different ways depending on which of the pair was asked.
  */
 static VALUE
 rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
@@ -677,11 +685,12 @@ rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
   CArray *ca;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
-  /* CA_FIXLEN and masked input: the per-fiber path below covers
-     unmasked numeric dtypes only.  Delegate to {sort} (which handles
-     both the fixlen dialect and the masked_position split) + copy to
-     get the same shape/class contract as the fast path. */
-  if ( ca_is_fixlen_type(ca) || ca_has_mask(ca) ) {
+  /* The per-fiber path below covers unmasked CA_INT8..CA_FLOAT64 only.
+     Everything else goes to {sort} (which handles the fixlen dialect,
+     the object comparator and the masked_position split) + copy, for the
+     same shape/class contract as the fast path. */
+  if ( ca->data_type < CA_INT8 || ca->data_type > CA_FLOAT64
+       || ca_has_mask(ca) ) {
     VALUE sv_kw = rb_hash_new();
     if ( !NIL_P(vaxis) )            rb_hash_aset(sv_kw, ID2SYM(rb_intern("axis")), vaxis);
     if ( !NIL_P(vkind) )            rb_hash_aset(sv_kw, ID2SYM(rb_intern("kind")), vkind);
@@ -717,17 +726,6 @@ rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
              NUM2INT(vaxis_use), cat->ndim);
   }
 
-  /* data_type check: ALL_NUMERIC only (CA_INT8..CA_FLOAT64).
-     Complex / object are rejected here; CA_OBJECT goes through the
-     axis: lift in rb_ca_sorted_view, and complex sort semantics
-     differ enough that we do not pick a default. */
-  if ( cat->data_type < CA_INT8 || cat->data_type > CA_FLOAT64 ) {
-    rb_raise(rb_eCADataTypeError,
-             "sort_copy: data_type %d not supported "
-             "(expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64)",
-             cat->data_type);
-  }
-
   /* Allocate output: same shape and data_type as target
      (bytes=0 = preserve native bytes). */
   volatile VALUE vout = rb_ca_template_with_type(target,

data/ext/carray_sort_kernel.c

@@ -1,8 +1,8 @@
 /* ---------------------------------------------------------------------------
 
-   Portable textbook sort kernels: per-dtype quicksort + bottom-up
+   Portable textbook sort kernels: per-type quicksort + bottom-up
    mergesort with inline comparison (no function-pointer indirection
-   like libc qsort / mergesort).  All 10 numeric dtypes plus paired
+   like libc qsort / mergesort).  All 10 numeric data types plus paired
    forms for argsort.
 
    Internal C API only (no Ruby surface, no Init function).  Declared
@@ -12,13 +12,13 @@
 
    Algorithms:
 
-   * quicksort (ca_sort_quick_<dtype>)
+   * quicksort (ca_sort_quick_<type>)
        median-of-3 pivot, Hoare partition, strict `<`, insertion-sort
        base (threshold 16), smaller-side recursion / larger-side
        iterate (stack O(log n)).  Depth-limit escape to mergesort for
        worst-case O(n log n).
 
-   * mergesort (ca_sort_merge_<dtype>)
+   * mergesort (ca_sort_merge_<type>)
        Bottom-up, ping-pong (cur / next) per pass with no inter-pass
        memcpy.  Strict `<` (stable: equal -> take-left).  Insertion-
        sort pre-pass that converts the input into R=16-wide sorted
@@ -27,18 +27,18 @@
        skip the merge loop; no run-state machine, distinct from
        Timsort galloping).
 
-   * paired forms (ca_sort_quick_pair_<dtype> / ca_sort_merge_pair_<dtype>)
+   * paired forms (ca_sort_quick_pair_<type> / ca_sort_merge_pair_<type>)
        Same algorithms over (value, index) pairs for argsort
        (sort_index / sort_addr).  Stable tie-break by index is built
        into the comparison, so quicksort is effectively stable for
        argsort even though the algorithm itself is not.
 
-   * NaN partitioning (ca_partition_nan_<dtype> + _pair_<dtype>)
+   * NaN partitioning (ca_partition_nan_<type> + _pair_<type>)
        float32 / float64 only.  One-pass Hoare-style partition that
        separates `[finite | NaN]` regions so the downstream sort
        kernel can operate on the finite slice with plain `<`.
 
-   * value-level quickselect (ca_partition_quick_<dtype>)
+   * value-level quickselect (ca_partition_quick_<type>)
        median-of-3 + Hoare + insertion base + one-sided recursion
        into the side containing kth (quickselect property, expected
        O(n)).  Depth-limit escape to mergesort matches the sort
@@ -402,13 +402,13 @@ ca_sort_quick_pair_##SUFFIX (ca_pair_##SUFFIX *a, ca_size_t n)              \
 struct ca_sort_pair_##SUFFIX##_eat_semicolon
 
 
-/* ===== Per-dtype instantiations ===========================================
+/* ===== Per-type instantiations ===========================================
    `<` is well-defined and IEEE-stable for all numeric C types used
    here; NaN handling for f32 / f64 lives in the pre-partition pass
    below. */
 
 /* ---------------------------------------------------------------------------
-   NaN pre-partition (float dtypes only).
+   NaN pre-partition (float data types only).
 
    One-pass Hoare-style partition that separates `a[0..n)` into
    `[finite | NaN]` regions in place, returning the finite count k
@@ -447,7 +447,7 @@ struct ca_partition_nan_##SUFFIX##_eat_semicolon
 DEFINE_PARTITION_NAN(float32_t, f32);
 DEFINE_PARTITION_NAN(double,    f64);
 
-/* Pair variant for argsort: separates ca_pair_<dtype> by
+/* Pair variant for argsort: separates ca_pair_<type> by
    isnan(v.value).  Returns the finite count.
 
    Stable within both finite and NaN regions (original order

data/ext/carray_test.c

@@ -4,7 +4,7 @@
     - internal check_* / has_same_* helpers used across ext/ sources
     - Ruby surface: valid_index? / valid_addr? / same_shape? / == /
       eql? / hash / freeze (docs in yard-stubs/carray_test.rb)
-    - per-dtype element-equality table `ca_eql[CA_NTYPE]`
+    - per-type element-equality table `ca_eql[CA_NTYPE]`
     - `ca_compare_common` shared body for `==` and `eql?`
 
 ---------------------------------------------------------------------------- */

data/ext/extconf.rb

@@ -63,6 +63,17 @@ end
 
 $CFLAGS += " -Wall"
 
+# --- the flags that decide the numbers
+#
+# Two compilations of the same C do not have to agree on the last bit: what
+# the compiler is allowed to fuse or reorder is decided by the flags it was
+# given.  Anything computing what these kernels compute, somewhere other
+# than in them, has to be built the same way to arrive at the same answer,
+# so the flags that bear on it are recorded and handed out as
+# CArray::BUILD_FLAGS.  Optimisation and architecture only -- warnings,
+# defines and link options change nothing about the arithmetic.
+$carray_build_flags = [RbConfig::CONFIG["optflags"].to_s.strip]
+
 # --- in-build flag (CARRAY_BUILD)
 #
 # Marks a translation unit as part of carray itself, i.e. recompiled whenever
@@ -121,6 +132,7 @@ simd_probe = <<~C
 C
 if try_compile(simd_probe, "-fopenmp-simd")
   $CFLAGS += " -fopenmp-simd"
+  $carray_build_flags << "-fopenmp-simd"
   $stderr.puts "carray: -fopenmp-simd enabled (SIMD reduction license)"
 end
 
@@ -151,11 +163,17 @@ if enable_config("march-native", default_on)
   arch_probe = "int main(void) { return 0; }\n"
   if try_compile(arch_probe, "-march=native")
     $CFLAGS += " -march=native"
+    $carray_build_flags << "-march=native"
     $stderr.puts "carray: -march=native enabled (build-machine ISA extensions)"
   else
     $stderr.puts "carray: -march=native probe FAILED, keeping baseline SIMD"
   end
 end
+File.write("carray_build_flags.h",
+           "/* GENERATED by extconf.rb: the flags this build's arithmetic\n" \
+           "   was compiled with.  See CArray::BUILD_FLAGS. */\n" \
+           "#define CA_BUILD_FLAGS #{$carray_build_flags.join(" ").inspect}\n")
+
 # $CFLAGS += " -m128bit-long-double"  ### gcc only
 # $CFLAGS += " -Wno-absolute-value"
 # $LDFLAGS += " -L/usr/local/opt/llvm/lib -Wl,-rpath,/usr/local/opt/llvm/lib"