carray-jit 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 255cd246bcdd06c49b0afd2aeaaa4c3086eb8b9c84f4ad04319129f7415c182f
-  data.tar.gz: 80fedb1eb6cfcfece4009d69d26251a58a2caa9d5975d1895bb34b9a7fa18ac7
+  metadata.gz: 89d3c3c1c950f938ca30658e4d6586bd305b60e6d83083a33e645ea69168d3e3
+  data.tar.gz: 6101247a5b517a6f28ce051016ced3674ce26e4400952a3a69eaf2ab8ea7eb40
 SHA512:
-  metadata.gz: fa33123ca9012275607181b6808e2497da5e8d1908764bff23200299e9c972dd61e9b9e4d3ab58345b2fbcd5badba39ddd03b214ad9ccadde6413b37a32f3215
-  data.tar.gz: 45050b058cba426afc373e50f47797e4720968c1e4a26862322364d44a81a4610a991622b0e35d3d20519fb583e654558728a85393064978c9adfc23db5d9f06
+  metadata.gz: 6789499fd3fa7bbb2e2342bb48b35cb2eb6c5dbe05a2ef281cc4c9c734c6ef18c37ece9a929623103e5f1c388b656184bcc76e4b457b9c03241ae226c132e49c
+  data.tar.gz: 16b2611b901be3ab35fd088309ba4976ac45f3cefd360a472971c95e7f0edcf17e3ebb19abb0bded712012b9b8e3c85cc26aea6787b9caf71741bc7b06b861f5

data/CHANGELOG.md

@@ -1,6 +1,8 @@
 # Changelog
 
-Releases are recorded here from 0.1.0, which is the first.
+Releases are recorded here from 0.1.0, which is the first. There is no
+separate NEWS file: this is where to look for what changed between the
+version you have and a newer one.
 
 <!-- Newest first, at both levels: a new release section goes above the
      ones below it, and a new entry goes directly under its own release
@@ -8,6 +10,12 @@ Releases are recorded here from 0.1.0, which is the first.
      carried by the `- Fix:` / `- Change:` / `- New:` that opens the
      entry; there are no per-kind subheadings.
 
+     A section is written newest-first while the release is open, and
+     sorted into New, Change, Fix when it closes -- in the same commit
+     that drops `(unreleased)`. Within Change, the ones that ask the
+     reader to change code come first. It is a reading order rather than
+     a classification: where it is not obvious, either place will do.
+
      An entry says three things and stops: what changed, what to do about
      it (the migration, the replacement, the condition under which nothing
      changes), and what is excluded. It does not say how the code was
@@ -15,10 +23,37 @@ Releases are recorded here from 0.1.0, which is the first.
      speed came from, or argue the design -- those belong in the commit
      message. Two to six lines.
 
+     It is written for someone using the library, not someone working on
+     it: with no NEWS file, this is what a reader consults before
+     upgrading. An entry naming something only a C extension touches says
+     so in its opening words.
+
+     Every entry has to read on its own. Entries are looked at one at a
+     time and move about within a section, so none may lean on a
+     neighbour ("as well", "the kernel above") or leave unnamed the
+     method, class or keyword it is about.
+
      The version here is this gem's own and is not CArray's. Which CArray
      a release needs is said in the gemspec, and an entry says so only
      when the answer changes. -->
 
+## 0.1.1
+
+- Fix: a zero divisor in a `CArray.fuse` expression no longer turns
+  compilation off for the rest of the process. `ZeroDivisionError` is raised
+  as before; what has gone is the warning that followed it on stderr, and the
+  expressions walked rather than compiled from then on. Nothing to do.
+  `jit_for`, `jit_each` and `jit_map` were never affected.
+
+- Fix: on macOS, a `CArray.fuse` expression holding an integer `/` or `%` is
+  compiled rather than walked. The answers were right before and are
+  unchanged; this is speed alone. Linux was never affected.
+
+- Fix: on Linux, a program that compiles more than one kernel no longer
+  crashes -- any two of `jit_for`, `jit_each`, `jit_map`, `jit_stencil`,
+  `jit_contract` and `jit_function` reached in the same run. Nothing to do:
+  cached kernels are rebuilt on first use. macOS was never affected.
+
 ## 0.1.0
 
 - New: `CArray.jit_for`, `CArray.jit_each` and `CArray.jit_map` compile their
@@ -73,9 +108,10 @@ Releases are recorded here from 0.1.0, which is the first.
   `CARRAY_JIT_NO_CACHE` keeps the cache in a temporary directory that goes
   away with the process, and `CARRAY_JIT_CC` names a different compiler.
 
-- New: the `carray-jit` command reports and looks after that cache --
-  `status`, `list`, `show`, `clear`. It loads the compiler and nothing else,
-  so a cache can be inspected or cleared when CArray itself will not load.
+- New: the `carray-jit` command reports and looks after the on-disk kernel
+  cache -- `status`, `list`, `show`, `clear`. It loads the compiler and
+  nothing else, so a cache can be inspected or cleared when CArray itself
+  will not load.
 
 - New: needs CArray 3.0.1 or later in the 3.0 series, and Ruby 3.2 or later.
   The floor is where `ca_call_cslab_N`, the expression evaluator hook,

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.0 is the first release, and it still moves: behaviour can change between releases — see [CHANGELOG.md](CHANGELOG.md). A companion gem to CArray, it follows CArray's surface, which is not settled until CArray 3.1.
+0.1.1 is the current release, and it still moves: behaviour can change between releases — see [CHANGELOG.md](CHANGELOG.md). A companion gem to CArray, it follows CArray's surface, which is not settled until CArray 3.1.
 
 ## Features
 

data/lib/carray/jit/compiler.rb

@@ -40,7 +40,26 @@ class CArray
       # being lower was not a decision -- the flag list is the one the first
       # milestone was scaffolded with, and only the contraction flag beside
       # it was ever argued for.
-      FLAGS = ["-O3", "-fPIC", "-shared", "-ffp-contract=off"].freeze
+
+      # Every generated object exports the same fixed names -- carray_jit_kernel,
+      # carray_jit_slab, the border and error helpers -- because each one is a
+      # module of its own.  Fiddle.dlopen passes RTLD_GLOBAL, so on ELF those
+      # names all land in one flat namespace and an intra-module call resolves
+      # to the first definition loaded: a later kernel's carray_jit_slab calls
+      # an earlier kernel's carray_jit_kernel, which takes a different number
+      # of operands, reads past the pointers it was given, and the process
+      # segfaults.  -Wl,-Bsymbolic binds each object's own definitions before
+      # the global scope, which is what one object per kernel assumed all
+      # along.  Nothing else needs saying so: Mach-O binds within each dylib's
+      # own two-level namespace and PE within each DLL, so the flag is named
+      # only where it means something -- and Apple's linker rejects it
+      # outright, which would trade a Linux crash for a macOS build that never
+      # compiles at all.
+      SYMBOLIC =
+        (RbConfig::CONFIG["host_os"] =~ /darwin|mswin|mingw|cygwin/ ?
+           [] : ["-Wl,-Bsymbolic"]).freeze
+
+      FLAGS = ["-O3", "-fPIC", "-shared", "-ffp-contract=off", *SYMBOLIC].freeze
 
       # Kernels retained on disk.  Each costs about 17 KB, so the default is
       # roughly 9 MB -- far more than any real program compiles, but a bound

data/lib/carray/jit/expression.rb

@@ -16,13 +16,24 @@ class CArray
     # goes back to CArray, which walks it and arrives at the same answer.
     class Expression
 
+      # A kernel that can divide by zero calls ca_zerodiv, which the CArray
+      # extension defines and this object does not.  ELF is content to leave
+      # the name undefined and resolve it when the object is loaded, which is
+      # what the declaration in #source_for assumes; Mach-O refuses to link at
+      # all, so on macOS every expression holding an integer `/` or `%` failed
+      # to compile and was silently handed back to CArray to walk.  The flag
+      # says to look the name up at load time, which is what Ruby builds its
+      # own extensions with and the only thing this object leaves undefined.
+      DYNAMIC_LOOKUP =
+        (RbConfig::CONFIG["host_os"] =~ /darwin/ ? ["-Wl,-undefined,dynamic_lookup"] : []).freeze
+
       # Built the way CArray's own kernels were, since that is what the answer
       # is being compared against.  The Prism front end wants the opposite of
       # this on one point -- it answers to a Ruby loop, which does not fuse a
       # 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].freeze
+      FLAGS = ["-fPIC", "-shared", *CArray::BUILD_FLAGS.split, *DYNAMIC_LOOKUP].freeze
 
       C_TYPES = {
         float64: "double",  float32: "float",
@@ -37,7 +48,9 @@ class CArray
         @kernels = {}
       end
 
-      # Fills `out` and returns true, or writes nothing and returns false.
+      # Fills `out` and returns true, or returns false and leaves it to
+      # CArray.  A decline may have written part of `out` first, which is
+      # what walking it over again then settles.
       def call (plan, out)
         return false unless C_TYPES.key?(plan.data_type)
         aliased = plan.leaves.any? { |array| array.equal?(out) }
@@ -51,6 +64,25 @@ class CArray
           kernel.call(out.elements, *pointers(plan, bases))
         end
         true
+      rescue ZeroDivisionError
+        # A zero divisor is an answer, not a fault: it is what ca_zerodiv --
+        # the only thing a kernel here calls out to -- reports, and the same
+        # expression walked reaches the same place and raises the same error.
+        #
+        # CArray cannot tell the two apart, though.  It catches whatever an
+        # evaluator raises, retires it for the rest of the process and says so
+        # on stderr, which is right for an evaluator that is broken and wrong
+        # for one that has just met a zero.  So this declines instead, and
+        # CArray walks the expression and raises it there.  Anything else
+        # still reaches CArray and still retires this, which is what that net
+        # is for.
+        #
+        # What it costs: a kernel that raised where the walk does not -- over
+        # a masked zero, say -- now reads as slow rather than as wrong, since
+        # the walk answers and nobody sees the difference.  The answer is
+        # right either way, and the masked-divisor test asks the evaluator
+        # directly for that reason.
+        false
       end
 
       private

data/lib/carray/jit/version.rb

@@ -1,5 +1,5 @@
 class CArray
   module JIT
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carray-jit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - himotoyoshi
@@ -133,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.17
+rubygems_version: 4.0.8
 specification_version: 4
 summary: JIT compilation of CArray kernels written in Ruby
 test_files: []