carray-jit 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4d8ccd59d268ba31816c5339867d7231b7051f7879d67faecdc4eb4d924b375
-  data.tar.gz: d73b3600e59633ac69986019597626b42a27e5e18b0143e00d39406d3f1c562f
+  metadata.gz: e052fd85b01164a6147a30ca655b8997ba7c87ac9c7ec8354d73447d1208b5ca
+  data.tar.gz: 2a6ebb524fb6afee5c871c0a45ed13ecf2f120f9ef0194e36f486ac3b015b378
 SHA512:
-  metadata.gz: 96e9c9585b2e93ed1a2f655ee92e3ef446a11d35f95895acf08dda59ed841c7570e5bc0361995c303eda8aa81b3461068fb93f0495814b6a973309d8f0f18bb0
-  data.tar.gz: 4b6fd2250447527deca38a65b19555833cd5702e2f27a253aa9bcba7359e3862e3f3b95f921004911de2ff502422c522a37d3507efb5b69449d94a3b40f4ecad
+  metadata.gz: bd5017f5251ad7b9f4263bfc25091a938d3bccd7f18ef5d83a5a68b63f57e0df6c1ee4278ccd1b903a68cb77a5a156a47c98cbc4832edabbf144593778fed1b5
+  data.tar.gz: d8d2733f8a98376561ccb183895e1e963eff8a1caea636d066e88ce4852f167fb8755c6f1225beaf0c89aea51bf18dab4482bde0a079983ff507e9cd66769b2f

data/CHANGELOG.md

@@ -37,6 +37,35 @@ version you have and a newer one.
      a release needs is said in the gemspec, and an entry says so only
      when the answer changes. -->
 
+## 0.1.6
+
+- Change: needs CArray 3.0.5 or later in the 3.0 series; install it
+  alongside this release. A Float stored into an integer array in a block
+  is refused as CArray 3.0.5's own store refuses it, and under 3.0.4 the
+  block would raise where CArray's store does not.
+
+- Change: a Float stored into an integer array in a block, captured or
+  local, that the type has no integer for raises `RangeError`, or
+  `FloatDomainError` for a NaN or an infinity, as CArray 3.0.5's own
+  store does. Before, it stored whatever the machine's C conversion gave,
+  which differed between x86 and ARM. Round and clamp first where the
+  value may leave the range. A masked cell, and a `jit_function`'s return
+  value or pointer parameter, are not checked.
+
+- Fix: an int64 array handed to a C function declared to take
+  `long long *` compiles with gcc, as it did with clang; gcc 14 raised
+  CompilationError. An array of the wrong element type raises Unsupported,
+  naming the type the function takes, under gcc as under clang.
+
+- Fix: `finite?` on an integer cell in a block compiles with gcc; it
+  raised CompilationError there, while clang accepted it. It is true for
+  every integer, as in Ruby.
+
+- Fix: a lazy expression or `CArray.fuse` computed here now gives the
+  same bits as CArray's own walk where gcc is the compiler. On x86 with
+  `-march=native`, a multiply followed by an add could come out one
+  rounding off in the last bit. Builds with clang were not affected.
+
 ## 0.1.5
 
 - Change: needs CArray 3.0.4 or later in the 3.0 series; install it

data/README.md

@@ -8,7 +8,7 @@ The block is read with Prism, translated to C if it falls inside that subset, co
 
 ## Status
 
-0.1.5 is the current release, and it still moves: behaviour can change between releases.
+0.1.6 is the current release, and it still moves: behaviour can change between releases.
 
 ## Features
 
@@ -35,7 +35,7 @@ gem "carray-jit"
 Requires:
 
 - Ruby >= 3.2
-- CArray >= 3.0.4, < 3.1
+- CArray >= 3.0.5, < 3.1
 - A C compiler
 - Prism and Fiddle (both ship with Ruby; Fiddle is a bundled gem)
 

data/carray-jit.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   spec.executables   = ["carray-jit"]
 
   # A kernel reaches CArray's C by address, so the ceiling is the next minor.
-  spec.add_dependency "carray", ">= 3.0.4", "< 3.1"
+  spec.add_dependency "carray", ">= 3.0.5", "< 3.1"
   # fiddle ships as a bundled gem; depend on it explicitly so Ruby 3.5+ resolves it.
   spec.add_dependency "fiddle"
 end

data/docs/03_SupportedFeatures.md

@@ -1223,6 +1223,6 @@ Everything else: `for` and `until`, `begin ... end while`, strings, hashes, symb
 - **A local array's subscript counts from the start.** CArray's `w[-1]` is the last cell; a kernel has no such reading, so a literal negative subscript is refused by name and one the kernel works out raises `IndexError`. This is the difference the captured arrays already have. Write `w[n - 1]`.
 - **`CArray.empty` leaves its cells as the stack left them.** Reading one before writing it is out of contract, the way reading under a mask is: the value is whatever was there. What it saves is the clearing, which for a 256-cell array inside a per-cell loop is 2 KiB a cell.
 - **The stack limits are per function, and a chain of them is not counted.** One local array up to 4 KiB stands in a frame, and the arrays of one kernel body or one function body up to 16 KiB together; past either, a kernel allocates the array at its entry, while a function body -- which is called once per cell -- refuses it and asks the calling kernel for a pointer instead. A pasted function called from a kernel is a second frame, and a chain of three such functions can therefore stand 48 KiB deep while each of them is inside its own limit -- counting along the chain was considered and dropped, since the depth is not knowable where recursion is in the subset at all. What that costs is the bargain a deep recursion already takes: too deep is a SIGSEGV rather than a `SystemStackError`, and a body carrying arrays reaches it sooner. Both numbers are provisional, and neither counts a future thread pool's stacks.
-- **Storing a real number into an integer array is C's conversion.** A value past the type's range, or a NaN, is undefined behaviour rather than a number -- and the same is true of a captured integer array, so a kernel brings no new hazard here. Round and clamp before storing where the value may leave the range. The rounding methods are not this case: `floor`, `ceil`, `round`, `truncate` and `to_i` on a Float raise `FloatDomainError` for a NaN or an infinity, as Ruby does, and `RangeError` where the Integer is past int64 -- except written straight into a float cell, which holds it whole (`1e20.floor` is `1e20`). The check costs a comparison per call, and in a loop that does little else it shows.
+- **Storing a real number into an integer array is checked.** It keeps the integer part, as CArray's own store does, and a value past the type's range raises `RangeError` -- `FloatDomainError` for a NaN or an infinity -- where CArray's store raises the same; C leaves that conversion undefined, and x86 and ARM answer it differently. Like any error at a cell it is raised when the pass ends, and the cell holds 0 in the meantime. A masked cell is not checked. The check is a comparison per store; round and clamp before storing where the value may leave the range and the cost shows. A compiled function's return value and a write through its pointer parameter are not this case: they are C's conversion, as the declaration says. Nor are the rounding methods: `floor`, `ceil`, `round`, `truncate` and `to_i` on a Float raise `FloatDomainError` for a NaN or an infinity, as Ruby does, and `RangeError` where the Integer is past int64 -- except written straight into a float cell, which holds it whole (`1e20.floor` is `1e20`). The check costs a comparison per call, and in a loop that does little else it shows.
 - **A block's source must be recoverable.** Blocks defined in `eval` or in a console have no file to read back; set `RubyVM.keep_script_lines = true` before defining them, or hand the text to `CArray::JIT.compile`, which takes a kernel as a string rather than as a block. This also ties the gem to CRuby, which CArray requires anyway.
 - **Nothing existing is replaced.** `jit_for` is a new method, not a faster `each_index`: the two differ in what they reject, and a caller should be able to choose.

data/docs/04_Compiling.md

@@ -67,7 +67,7 @@ In `~/.cache/carray-jit` (honouring `XDG_CACHE_HOME`), one directory per version
 
 A kernel is only good for the version that generated it and the architecture it was built for, so those get their own directories. CArray's version is there for the same reason and one of its own: a kernel is handed CArray's memory, on layouts CArray decides, so one compiled against one version and run against the next would answer wrongly rather than fail to load.
 
-The two numbers say different things and move on their own clocks: the first is the version that generated the kernel, the second the version it was generated against. This gem is not versioned with CArray, and one release of it meets more than one -- the dependency is `>= 3.0.4, < 3.1`, so 3.0.4 and 3.0.5 both satisfy it -- and a layout the kernel reaches into can move between them. A new release does not spend its cache budget on entries nothing can reach any more, and a home directory shared between machines -- over NFS, or between Rosetta and native -- does not have one architecture evicting the other's kernels. A directory whose newest entry has not been touched in 30 days (`CARRAY_JIT_CACHE_MAX_AGE_DAYS`) is removed.
+The two numbers say different things and move on their own clocks: the first is the version that generated the kernel, the second the version it was generated against. This gem is not versioned with CArray, and one release of it meets more than one -- the dependency is `>= 3.0.5, < 3.1`, so 3.0.5 and 3.0.6 both satisfy it -- and a layout the kernel reaches into can move between them. A new release does not spend its cache budget on entries nothing can reach any more, and a home directory shared between machines -- over NFS, or between Rosetta and native -- does not have one architecture evicting the other's kernels. A directory whose newest entry has not been touched in 30 days (`CARRAY_JIT_CACHE_MAX_AGE_DAYS`) is removed.
 
 ```ruby
 CArray::JIT.cache_root                 #=> "/home/you/.cache/carray-jit"

data/docs/08_LanguageReference.md

@@ -395,7 +395,7 @@ These are deliberate. Everything not listed here gives Ruby's answer, to the las
 - **A complex raised to a power** uses C's `cpow`, which can differ from Ruby in the last bit.
 - **A sine beside a cosine of the same argument** may be computed together by the C compiler, which can change the last bit.
 - **A reduction is reassociated** into partial sums unless `reassociate: false` is given, so its last bits can differ from adding in order.
-- **A real stored into an integer array** is C's conversion: past the type's range, or for a NaN, the result depends on the machine. Ruby would raise or grow.
+- **A real stored into an integer array** keeps its integer part, as CArray's store does, and one past the type's range raises `RangeError` where Ruby's `to_i` would grow. A NaN or an infinity raises `FloatDomainError`, as `to_i` does.
 
 **The language**
 
@@ -425,4 +425,4 @@ A block reads like Ruby run over one cell at a time, and it answers as that Ruby
 | `\|` and `&` of a masked boolean (`UNDEF \| true`) | Kleene: `true` | `\|\|` and `&&`: masked whenever an operand is |
 | a `uint64` compared with a negative `int64` | compares by value: `7 < -7` is false | compared as two `uint64`: `7 < -7` is true |
 
-Where they agree, the block keeps CArray's answer: integer `/` and `%` floor, a shift means what it means to `Integer`, `INT64_MIN / -1` is `INT64_MIN`, overflow wraps, an Integer meets a Float as two doubles, narrow types compute narrow, `Math` outside its domain is NaN, a real out of range stored into an integer cell is C's conversion, and a masked operand gives a masked result.
+Where they agree, the block keeps CArray's answer: integer `/` and `%` floor, a shift means what it means to `Integer`, `INT64_MIN / -1` is `INT64_MIN`, overflow wraps, an Integer meets a Float as two doubles, narrow types compute narrow, `Math` outside its domain is NaN, a real stored into an integer cell keeps its integer part and raises `RangeError` past the type's range (`FloatDomainError` for a NaN or an infinity), and a masked operand gives a masked result.

data/lib/carray/jit/c_function.rb

@@ -55,6 +55,13 @@ class CArray
         "#{text.sub(/\s*\[.*\]\z/, "")} #{name}[#{array if sized?}]"
       end
 
+      # The pointer an array argument decays to, as C spells it:
+      # `const double coef[3]` takes a `const double *`.
+      def decayed
+        return text unless array
+        "#{text.sub(/\s*\[.*\]\z/, "")} *"
+      end
+
       # @return [String] the type, as C spells it.
       def to_s
         text

data/lib/carray/jit/c_generator.rb

@@ -421,6 +421,7 @@ class CArray
         @uses_real_arg = false
         @uses_real_power_complex = false
         @clamp_types = []
+        @store_types = []
         @gamma_types = []
         @complex_helpers = []
         @uses_floor_divide = false
@@ -727,6 +728,7 @@ class CArray
           :real_arg => @uses_real_arg,
           :real_power_complex => @uses_real_power_complex,
           :clamp => @clamp_types.dup,
+          :store => @store_types.dup,
           :gamma => @gamma_types.dup,
           :complex => @complex_helpers.dup,
           :index_check => @uses_index_check,
@@ -839,6 +841,7 @@ class CArray
           @uses_real_arg ||= needs[:real_arg]
           @uses_real_power_complex ||= needs[:real_power_complex]
           @clamp_types |= needs[:clamp] || []
+          @store_types |= needs[:store] || []
           @gamma_types |= needs[:gamma] || []
           @complex_helpers |= needs[:complex] || []
           @uses_index_check ||= needs[:index_check]
@@ -1095,6 +1098,31 @@ class CArray
           C
         end
         text << intrinsic_helpers
+        @store_types.each do |storage|
+          low, high = STORE_BOUNDS.fetch(storage)
+          c_type = storage_c_type(storage)
+          text << <<~C
+            /* A real number stored into an #{storage} cell keeps its integer
+               part, as CArray's store does.  One with no #{storage} to keep --
+               a NaN, an infinity, a number past the range -- is refused as
+               CArray refuses it: C leaves that conversion undefined, and the
+               machines answer it differently. */
+            static inline #{c_type}
+            carray_jit_store_#{storage} (double value, int32_t *error)
+            {
+              if ( value > #{low} && value < #{high} ) {
+                return (#{c_type}) value;
+              }
+              if ( error ) {
+                *error = isnan(value) ? #{FLOAT_NAN_CODE} :
+                         isinf(value) ? ( value > 0 ? #{FLOAT_INFINITY_CODE} : #{FLOAT_NEGATIVE_INFINITY_CODE} ) :
+                         #{STORE_RANGE_CODES.fetch(storage)};
+              }
+              return 0;
+            }
+
+          C
+        end
         @clamp_types.each do |type|
           suffix, c_type, has_nan = CLAMP_C_TYPES.fetch(type)
           refusal = lambda { |test, code|
@@ -1834,6 +1862,14 @@ class CArray
       FLOAT_NEGATIVE_INFINITY_CODE = -5
       INTEGER_RANGE_CODE = -6
 
+      # And what a real number stored into an integer cell reports where the
+      # cell's type has no integer for it, one code for each type, so the
+      # message can name the type as CArray's own store does.
+      STORE_RANGE_CODES = {
+        "int8"  => -7,  "int16"  => -8,  "int32"  => -9,  "int64"  => -10,
+        "uint8" => -11, "uint16" => -12, "uint32" => -13, "uint64" => -14,
+      }.freeze
+
       # The fixed failures a body reports, as the exception each one raises.
       # A kernel and a compiled function both look here, so the two say the
       # same thing for the same cell.
@@ -1842,6 +1878,24 @@ class CArray
         FLOAT_INFINITY_CODE => [FloatDomainError, "Infinity"],
         FLOAT_NEGATIVE_INFINITY_CODE => [FloatDomainError, "-Infinity"],
         INTEGER_RANGE_CODE => [RangeError, "a rounded Float is past the range of int64"],
+        **STORE_RANGE_CODES.to_h { |storage, code|
+          [code, [RangeError, "a Float is out of range for #{storage}"]]
+        },
+      }.freeze
+
+      # The bounds a real number has to fall strictly between for its integer
+      # part to be a value of the type, written as doubles, which hold every
+      # one of them exactly.  CArray's store keeps the integer part, so -0.5
+      # goes into a uint8 cell as 0, and 255.9 as 255.
+      STORE_BOUNDS = {
+        "int8"   => ["-129.0", "128.0"],
+        "int16"  => ["-32769.0", "32768.0"],
+        "int32"  => ["-2147483649.0", "2147483648.0"],
+        "int64"  => ["-9223372036854777856.0", "9223372036854775808.0"],
+        "uint8"  => ["-1.0", "256.0"],
+        "uint16" => ["-1.0", "65536.0"],
+        "uint32" => ["-1.0", "4294967296.0"],
+        "uint64" => ["-1.0", "18446744073709551616.0"],
       }.freeze
 
       RAISE_CODE_FLOOR = 3
@@ -2588,9 +2642,9 @@ class CArray
         # expression written into it carried, and the branches the write
         # stands in.  A write reached because a missing cell said so was
         # reached for no reason, whichever of the three it writes.
+        masked = @masked ? combine_masks(@carried_masks + [emit_mask(write.expression)]) : nil
         mask = if @masked
-                 "#{indent}#{local_array_reference(write, :mask)} = " \
-                 "#{combine_masks(@carried_masks + [emit_mask(write.expression)])};\n"
+                 "#{indent}#{local_array_reference(write, :mask)} = #{masked};\n"
                else
                  ""
                end
@@ -2600,10 +2654,10 @@ class CArray
           "#{indent}#{COMPUTATION_C_TYPES.fetch(type)} #{temporary};\n" +
             emit_conditional_statement(expression, temporary, type, indent) +
             "#{indent}#{target} = " \
-            "#{cast_to_storage(temporary, type, write.storage)};\n" + mask
+            "#{cast_to_storage(temporary, type, write.storage, masked: masked)};\n" + mask
         else
           type = complex_storage_of_power(expression, write.storage) || expression.type
-          value = cast_to_storage(emit(expression, type), type, write.storage)
+          value = cast_to_storage(emit(expression, type), type, write.storage, masked: masked)
           "#{indent}#{target} = #{value};\n" + mask
         end
       end
@@ -2999,13 +3053,41 @@ class CArray
         @storage_types.fetch(array)
       end
 
-      def cast_to_storage (text, type, storage)
+      # A captured array's element type is matched at the call
+      # (`address_buffer`), after the build, and raises before the kernel
+      # runs.  Where the declaration spells the pointer differently from the
+      # array's own, the address is cast to it, so that check is the one that
+      # answers: gcc refuses an incompatible pointer at compile time where
+      # clang only warns.  `long long *` is such a spelling for an int64
+      # array, which the check accepts and gcc does not.  A body's own
+      # pointer parameter is no captured array and is handed on as it is:
+      # its type was declared in C.
+      def emit_array_argument (argument, parameter)
+        address = emit(argument, :address)
+        return address unless @storage_types.key?(argument.array)
+        own = "#{storage_c_type(array_storage(argument.array))} *"
+        declared = parameter.decayed.sub(/\Aconst\s+/, "")
+        declared == own ? address : "(#{parameter.decayed})#{address}"
+      end
+
+      # `masked` is the C of the written cell's mask, for a write whose mask
+      # the error slot does not already know about: a missing cell holds
+      # whatever was under its mask, which is no value to refuse.
+      def cast_to_storage (text, type, storage, masked: nil)
         # Storing into a boolean array normalises: CArray's boolean is a byte
         # holding 0 or 1, and a kernel is not the place that invariant stops
         # being true.
         return "(uint8_t)((#{text}) ? 1 : 0)" if boolean_storage?(storage)
         target = storage_c_type(storage)
         return text if COMPUTATION_C_TYPES.fetch(type) == target
+        if [:double, :float].include?(type) and STORE_BOUNDS.key?(storage)
+          @store_types |= [storage]
+          error = error_argument
+          if masked and masked != "0"
+            error = "(#{masked} ? (int32_t *) 0 : #{error})"
+          end
+          return "carray_jit_store_#{storage}(#{text}, #{error})"
+        end
         "(#{target})(#{text})"
       end
 
@@ -3563,8 +3645,9 @@ class CArray
           c_function = @c_functions.fetch(node.name)
           arguments = node.arguments.zip(c_function.parameters)
                           .map { |argument, parameter|
-                            if argument.is_a?(ArrayAddress) ||
-                               argument.is_a?(LocalArrayAddress)
+                            if argument.is_a?(ArrayAddress)
+                              emit_array_argument(argument, parameter)
+                            elsif argument.is_a?(LocalArrayAddress)
                               emit(argument, :address)
                             else
                               emit(argument, parameter.computation)
@@ -3623,12 +3706,15 @@ class CArray
          "#{emit(node.high, type)}, #{error_argument})", LEAF_PRECEDENCE]
       end
 
-      # `isnan` and `isfinite` are C's own, and take a number of any width.
-      # A Complex answers `finite?` the way Ruby answers it -- both parts
-      # finite -- through a helper, so that the number is computed once.
-      # An Integer is finite whatever it holds, and goes through `isfinite`
-      # all the same rather than being answered here: the read it stands for
-      # is a read, and dropping it would drop what the read reports.
+      # `isnan` and `isfinite` are C's own, and take a real floating number
+      # of either width.  A Complex answers `finite?` the way Ruby answers
+      # it -- both parts finite -- through a helper, so that the number is
+      # computed once.  An Integer is finite whatever it holds, and goes
+      # through `isfinite` all the same rather than being answered here: the
+      # read it stands for is a read, and dropping it would drop what the
+      # read reports.  It goes in as a double, because C asks for a floating
+      # argument and gcc refuses an integer one where clang lets it pass;
+      # every integer converts to a finite double.
       def emit_numeric_predicate (node)
         type = node.operand.type
         function = node.name == :nan? ? "isnan" : "isfinite"
@@ -3636,7 +3722,11 @@ class CArray
           return emit_helper_call("complex_finite", [emit(node.operand, type)],
                                   type == :float_complex)
         end
-        ["#{function}(#{emit(node.operand, type)})", LEAF_PRECEDENCE]
+        operand = emit(node.operand, type)
+        if TypeAssignment::INTEGER_TYPES.include?(type)
+          operand = "(double)(#{operand})"
+        end
+        ["#{function}(#{operand})", LEAF_PRECEDENCE]
       end
 
       def emit_mask_test (node)

data/lib/carray/jit/expression.rb

@@ -40,7 +40,17 @@ class CArray
       # multiply and an add into one rounding, so it compiles with
       # -ffp-contract=off.  Here the reference is the eager kernel, which was
       # built with whatever CArray settled on.
-      FLAGS = ["-fPIC", "-shared", *CArray::BUILD_FLAGS.split, *DYNAMIC_LOOKUP].freeze
+      #
+      # Except between nodes.  CArray computes each node in a kernel of its
+      # own, so no node's multiply meets the next node's add; this object
+      # writes the expression as one statement per node in a single loop.
+      # clang contracts within a statement by default, which leaves that
+      # alone, but gcc defaults to -ffp-contract=fast and contracts across
+      # statements: on x86 with -march=native, `a * b + c` lost a rounding in
+      # 3296 of 30000 cells.  -ffp-contract=on keeps a contraction inside a
+      # node's own body, as CArray's kernel has it, and none between nodes.
+      FLAGS = ["-fPIC", "-shared", *CArray::BUILD_FLAGS.split,
+               "-ffp-contract=on", *DYNAMIC_LOOKUP].freeze
 
       C_TYPES = {
         float64: "double",  float32: "float",

data/lib/carray/jit/version.rb

@@ -1,5 +1,5 @@
 class CArray
   module JIT
-    VERSION = "0.1.5"
+    VERSION = "0.1.6"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carray-jit
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - himotoyoshi
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: 3.0.5
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.1'
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: 3.0.5
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.1'