carray-jit 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85e10fcc54b5ddc4ef74d6a2ddf169b56891eef480471ac91b8b834055677da1
-  data.tar.gz: 2c6a3c4a390c4c3cffd3b1621656e06ea627a44789db2450721ec6c97bfbfc3f
+  metadata.gz: a4d8ccd59d268ba31816c5339867d7231b7051f7879d67faecdc4eb4d924b375
+  data.tar.gz: d73b3600e59633ac69986019597626b42a27e5e18b0143e00d39406d3f1c562f
 SHA512:
-  metadata.gz: 9d20ccad82918edc5df3038d35204a419fa9e4d92645c5d3a2691c97d251d31624acee7b9bf28b1bef35958b255ef62ed10006ac15983786ffaf3bfcbd3df2b3
-  data.tar.gz: d67ec3082b6e76bd10175c593cbfabfe13c1eec9efdd9c91edb344cad5b3ea6e1b7fecbd4b1f1b7a16b8413e4c180f8449dcc8e03f386ca798a2c2149476db79
+  metadata.gz: 96e9c9585b2e93ed1a2f655ee92e3ef446a11d35f95895acf08dda59ed841c7570e5bc0361995c303eda8aa81b3461068fb93f0495814b6a973309d8f0f18bb0
+  data.tar.gz: 4b6fd2250447527deca38a65b19555833cd5702e2f27a253aa9bcba7359e3862e3f3b95f921004911de2ff502422c522a37d3507efb5b69449d94a3b40f4ecad

data/CHANGELOG.md

@@ -37,6 +37,25 @@ 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.5
+
+- Change: needs CArray 3.0.4 or later in the 3.0 series; install it
+  alongside this release. 0.1.4 accepts CArray 3.0.4 but does not run
+  under it, so the two are upgraded together. A store in a block into a
+  cell that cannot hold the value still wraps as C does, where CArray
+  3.0.4's own `int8[0] = 300` raises RangeError.
+
+- Change: `jit_each` and `jit_map` called again with operands of the same
+  shapes, types and masking cost less per call -- about 9 us rather than 11
+  for a small two-array block -- which a time-stepping loop calling one
+  block thousands of times will notice. Nothing changes in what they
+  compute; a scalar's value may differ from call to call as before.
+
+- Fix: an element-wise `jit_each` or `jit_map` run through CArray's sweep
+  could read its scalars and C functions from where they had been before
+  GC compaction moved them, and answer wrongly or crash. Only a process
+  that compacts (`GC.compact`, `GC.auto_compact = true`) was exposed.
+
 ## 0.1.4
 
 - New: a lazy `then_else` (a lazy condition or branch) is compiled with

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.4 is the current release, and it still moves: behaviour can change between releases.
+0.1.5 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.3, < 3.1
+- CArray >= 3.0.4, < 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.3", "< 3.1"
+  spec.add_dependency "carray", ">= 3.0.4", "< 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/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.3, < 3.1`, so 3.0.3 and 3.0.4 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.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.
 
 ```ruby
 CArray::JIT.cache_root                 #=> "/home/you/.cache/carray-jit"

data/docs/05_DesignNotes.md

@@ -4,7 +4,7 @@ Decisions that were not obvious, and why.
 
 ## The type is C's, and so is the arithmetic where the width is real
 
-The storage type is CArray's, mapped to C exactly -- `int64_t`, `uint8_t`, `float` -- and everything the type itself decides follows from that: the width, the wrap on store, the bit patterns. There a kernel agrees with CArray, because both are the same C. A shift agrees too, though the two get there differently: a kernel shifts in the width it computes in, `int64_t`, and narrows on store, where CArray shifts in the cell's own width -- and since both take a shift to mean what Ruby's Integer means by it, the low bits that survive the narrowing are the same.
+The storage type is CArray's, mapped to C exactly -- `int64_t`, `uint8_t`, `float` -- and everything the type itself decides follows from that: the width, the wrap on store, the bit patterns. There a kernel agrees with CArray's conversion between arrays (`to_type`), because both are the same C; CArray's store of a single Ruby Integer refuses one the cell cannot hold, where a kernel narrows it. A shift agrees too, though the two get there differently: a kernel shifts in the width it computes in, `int64_t`, and narrows on store, where CArray shifts in the cell's own width -- and since both take a shift to mean what Ruby's Integer means by it, the low bits that survive the narrowing are the same.
 
 The arithmetic follows the same rule where the width makes a difference to the answer, and Ruby's where it does not. That splits the types in two.
 

data/docs/08_LanguageReference.md

@@ -417,6 +417,7 @@ A block reads like Ruby run over one cell at a time, and it answers as that Ruby
 | `int8` cells: `a * 2 / 4` with `a = 100` | `-14`: each operation wraps at 8 bits | `50`: computed in `int64`, wrapped only when stored |
 | `int8` + `uint8` | computed and returned in `uint8` | computed in `int64` |
 | a uint8 cell `+ 300` | `RangeError`: 300 does not fit uint8 | `301`, computed in `int64` |
+| `int8` cell `= 300` | `RangeError`: 300 does not fit int8 (`to_type` gives `44`) | `44`: narrowed as C converts |
 | `x.round`, `floor`, `ceil`, `truncate` | a float array | an Integer, as Ruby |
 | boolean arithmetic, `b + b` | `2`: a boolean is 0/1 | refused, as Ruby refuses `true + true` |
 | a boolean compared with a number, `b == 1` | compares as 0/1 | refused: in Ruby `true == 1` is false |

data/lib/carray/jit/kernel.rb

@@ -235,9 +235,10 @@ class CArray
 
         held = [buffer(reals), buffer(integers), buffer(functions),
                 buffer(data), masks, masks, error]
-        context = held.map { |item| Fiddle::Pointer[item].to_i }.pack("Q*")
-
-        Sweep.call(slab_pointer, fsync, arrays, Fiddle::Pointer[context])
+        error = in_one_block(held) { |context, slots|
+          Sweep.call(slab_pointer, fsync, arrays, context)
+          slots.last[0, error.bytesize]
+        }
 
         packed.each_with_index do |(array, item), index|
           next if array.equal?(item)
@@ -558,6 +559,31 @@ class CArray
         packed.empty? ? "\0" * 8 : packed
       end
 
+      # Copies `parts` into one block of C memory, each part 8-byte aligned,
+      # after a table of their addresses, and yields a pointer to the table
+      # and a pointer to each part; the block is freed when this returns.
+      #
+      # For a call that is handed addresses inside other memory rather than
+      # arguments: a Ruby String's bytes may be moved by GC compaction, and
+      # an address taken from one and packed elsewhere is not one Ruby knows
+      # to keep in place.  Memory from malloc is never moved.
+      def in_one_block (parts)
+        table = parts.size * Fiddle::SIZEOF_VOIDP
+        offsets = parts.each_with_object([]) { |part, list|
+          last = list.empty? ? table : list.last + parts[list.size - 1].bytesize
+          list << ((last + 7) & ~7)
+        }
+        size = offsets.last + parts.last.bytesize
+        Fiddle::Pointer.malloc(size, Fiddle::RUBY_FREE) do |block|
+          slots = parts.zip(offsets).map { |part, offset|
+            block[offset, part.bytesize] = part
+            block + offset
+          }
+          block[0, table] = slots.map(&:to_i).pack("Q*")
+          yield block, slots
+        end
+      end
+
       # The xfer tier transfers a box rather than the whole view.  The box
       # is the loop range grown by how far the kernel reaches from the cell it
       # is on -- per array, because two arrays in one kernel need not be read
@@ -778,9 +804,9 @@ class CArray
           unless array.is_a?(CArray)
             raise Unsupported, "`#{name}` is not a CArray"
           end
-          unless array.rank == array_rank(name)
+          unless array.ndim == array_rank(name)
             raise Unsupported,
-                  "`#{name}` has rank #{array.rank}, but is indexed with " \
+                  "`#{name}` has rank #{array.ndim}, but is indexed with " \
                   "#{array_rank(name)} #{array_rank(name) == 1 ? 'index' : 'indices'}"
           end
           unless array.data_type_name == @storage_types.fetch(name)

data/lib/carray/jit/version.rb

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

data/lib/carray/jit.rb

@@ -638,10 +638,10 @@ class CArray
                   "the indices of a term are symbols naming its axes, as in " \
                   "`[a, [:i, :k]]`; got #{subscripts.inspect}"
           end
-          unless subscripts.size == array.rank
+          unless subscripts.size == array.ndim
             raise Unsupported,
                   "a term names one index per axis: this array has rank " \
-                  "#{array.rank} and #{subscripts.size} " \
+                  "#{array.ndim} and #{subscripts.size} " \
                   "#{subscripts.size == 1 ? 'index' : 'indices'} were given"
           end
         end
@@ -680,9 +680,9 @@ class CArray
           raise Unsupported, "`into:` is an array to write into"
         end
         expected = free.empty? ? 1 : free.size
-        unless into.rank == expected
+        unless into.ndim == expected
           raise Unsupported,
-                "`into:` has rank #{into.rank}, and the result's axes are " \
+                "`into:` has rank #{into.ndim}, and the result's axes are " \
                 "#{free.empty? ? 'none, which is one cell' : free.map { |name| "`#{name}`" }.join(', ')}"
         end
       end
@@ -909,7 +909,7 @@ class CArray
         return false if masked
         return false if arrays.empty? || arrays.size > Sweep::MAX_ARITY
         return false unless arrays.each_value.all? { |array|
-          array.rank.zero? || array.dim == shape
+          array.ndim.zero? || array.dim == shape
         }
         walkable_in_place?(arrays.each_value)
       end
@@ -933,7 +933,7 @@ class CArray
       # 0.9 ns/cell with the driver here against 6.1 ns/cell swept, and no
       # scratch either way -- there was nothing the re-gather was buying.
       def walkable_in_place? (arrays)
-        tiers = arrays.map { |array| Access.classify(array)[:tier] }
+        tiers = arrays.map { |array| Access.tier(array) }
         return true if tiers.include?(Access::TIER_XFER)
         tiers.none? { |tier| tier == Access::TIER_STRIDE }
       end
@@ -1214,6 +1214,23 @@ class CArray
       # common case allocates nothing.
       EMPTY_ARRAYS = {}.freeze
 
+      # What an element-wise pass works out from its operands' shapes and
+      # types, and not from their data: which of them are walked and which
+      # are handed to a C function whole, the shape the pass covers, whether
+      # lining the walked ones up to it changes any of them, which loop runs
+      # it, the kernel, and what type a map's result is made as.
+      #
+      # @private
+      RunPlan = Data.define(:walked, :addressed, :stretched, :shape,
+                            :sweeping, :kernel, :result_type)
+
+      # How many plans one block keeps.  Not one: a caller alternating
+      # between two model states would miss on every call, and pay for the
+      # asking on top of what every call paid before.  Eight, as a kernel
+      # keeps of its own calls (CompiledKernel::PLAN_LIMIT), and for no
+      # better-measured reason.
+      RUN_PLAN_LIMIT = 8
+
       # @private
       def run_over_whole_arrays (block, map: false)
         node, source, origin = read_block(block)
@@ -1238,11 +1255,185 @@ class CArray
         # is before the broadcast.
         made = local_array_names(source, node)
         refuse_a_shadowed_array(made, outside)
-        arrays = arrays.merge(assigned_arrays(assigned - made, outside))
+        written = assigned_arrays(made.empty? ? assigned : assigned - made,
+                                  outside)
+        arrays = arrays.merge(written) unless written.empty?
         if arrays.empty?
           raise Unsupported, "the block reaches no array"
         end
 
+        # Everything from here to the kernel answers the same for two calls
+        # whose operands agree on shape and type, so it is worked out once
+        # per such agreement rather than once per call (#plan_run).  What the
+        # plan leaves to the call is what it has to: the operands themselves,
+        # the views the broadcast makes of them, a generator's state, the
+        # map's result, and the masks.
+        key = run_key(arrays, scalars, c_functions, randoms, map)
+        plan = key && found_run_plan(source, key)
+        unless plan
+          plan = plan_run(source, node, origin, arrays, scalars, c_functions,
+                          randoms, map)
+          keep_run_plan(source, key, plan) if key
+        end
+
+        walked = plan.addressed.empty? ? arrays : arrays.slice(*plan.walked)
+        # Where no operand is stretched the broadcast hands back the operands
+        # it was given, so it is not asked.  Where one is, the views it makes
+        # are views of these arrays and are made again: a view is exactly
+        # what a plan must not keep.
+        #
+        # Unstretched, `aligned` can be `arrays` itself.  That is sound only
+        # because every write into it below puts back the array already
+        # there.
+        aligned = plan.stretched ? broadcast(walked).first : walked
+        plan.addressed.each { |name| aligned[name] = arrays.fetch(name) }
+        # A generator's state joins after the broadcast, never before it.
+        # It is passed whole rather than walked, so the expression's shape
+        # has nothing to say about it -- and it has a shape of its own that
+        # would not line up anyway: four cells, against however many the
+        # expression covers.  Lining it up first is what `jit_each` did to a
+        # one-cell state before 314d6cb, and a four-cell one does not even
+        # stretch.
+        unless randoms.empty?
+          states = random_states(randoms)
+          arrays = arrays.merge(states)
+          aligned = aligned.merge(states)
+        end
+        shape = plan.shape
+        if map
+          result = CArray.send(plan.result_type, *(shape.empty? ? [1] : shape))
+          arrays = arrays.merge(MAP_RESULT => result)
+          aligned = aligned.merge(MAP_RESULT => result)
+        end
+
+        kernel = plan.kernel
+        # The shape of each of these was checked against the pass's when the
+        # plan was made, and the key holds the shapes.
+        kernel.written_arrays.each do |name|
+          next if name == MAP_RESULT
+          aligned[name] = arrays.fetch(name)
+        end
+
+        aligned = read_once_where_the_pass_writes(aligned, kernel.written_arrays)
+
+        # An array handed to a C function by address is passed whole rather
+        # than walked, so the expression's shape has nothing to say about it.
+        # Broadcasting it would stretch a one-cell state array into a
+        # read-only `CARepeat`, which the copy-back after the call cannot
+        # write through -- and a state array is exactly the shape a caller
+        # reaches for.
+        kernel.address_arrays.each do |name|
+          aligned[name] = arrays.fetch(name)
+        end
+
+        if kernel.masked
+          kernel.written_arrays.each do |name|
+            array = arrays.fetch(name)
+            array.mask = 0 unless array.has_mask?
+          end
+        end
+
+        result.mask = 0 if map && kernel.masked && !result.has_mask?
+        drive(kernel, aligned, scalars, c_functions, shape, plan.sweeping)
+        map ? result : kernel
+      end
+
+      # What two calls of one block have to agree on for one to be run as
+      # the other was.
+      #
+      # Each operand's name, type and shape, because that is what the kernel
+      # is compiled for and the broadcast lines up; whether it is a CScalar,
+      # because the broadcast stretches one where it leaves a one-cell array
+      # standing.  Whether it has a mask, because a mask is runtime state that
+      # leaves the shape and the type alone -- one appearing makes a masked
+      # kernel, and nothing else here would notice it.  And the tier it would
+      # be opened at, because that decides whether CArray's sweep or the
+      # tiers here run the pass (#walkable_in_place?).  All of it read off
+      # the operand on this call; none of it kept from the last.
+      #
+      # Then the type of each scalar, each C function's signature and each
+      # generator's kind, which is what the kernel is compiled for of those.
+      # Not a scalar's value: a clock or a coefficient changes every step,
+      # and keying on it would miss on every call of the loop this is for.
+      #
+      # Values only, never an operand: a block's plans live as long as the
+      # process, and holding an array would hold its memory as long.  Shapes
+      # from `ndim`, `elements` and `dim0`.. rather than `dim`, which builds
+      # an Array on every call.
+      #
+      # nil where a scalar is not one a kernel takes, so that the call is
+      # refused where and as it always was rather than here.
+      def run_key (arrays, scalars, c_functions, randoms, map)
+        key = [map, arrays.size]
+        arrays.each do |name, array|
+          rank = array.ndim
+          key << name << array.data_type << rank << array.is_a?(CScalar) <<
+                 array.has_mask? << Access.tier(array)
+          case rank
+          when 1 then key << array.elements
+          when 2 then key << array.dim0 << array.dim1
+          when 3 then key << array.dim0 << array.dim1 << array.dim2
+          else        key.concat(array.dim)
+          end
+        end
+        key << scalars.size
+        scalars.each do |name, value|
+          key << name << TypeAssignment.scalar_type(value)
+        end
+        key << c_functions.size
+        c_functions.each { |name, function| key << name << function.kernel_key }
+        randoms.each { |name, generator| key << name << generator.generator }
+        key
+      rescue Unsupported
+        nil
+      end
+
+      # @private
+      def run_plans
+        @run_plans ||= {}
+      end
+
+      # The block's plan for this key, if it has one.  The list a plan sits
+      # in is never changed once it is published -- a kernel's call lets go
+      # of the GVL, so another thread may be reading it -- and bringing a
+      # plan to the front replaces the list rather than editing it.
+      def found_run_plan (source, key)
+        plans = run_plans[source]
+        return nil unless plans
+        found = plans.assoc(key)
+        return nil unless found
+        unless plans.first.equal?(found)
+          run_plans[source] =
+            [found, *plans.reject { |entry| entry.equal?(found) }].freeze
+        end
+        found[1]
+      end
+
+      # @private
+      def keep_run_plan (source, key, plan)
+        entry = [frozen_throughout(key), plan].freeze
+        run_plans[source] =
+          [entry, *run_plans[source]].first(RUN_PLAN_LIMIT).freeze
+      end
+
+      # A copy that nothing outside can change under it, and that changes
+      # nothing outside by being frozen: a C function's signature is its own
+      # strings, and freezing those in place would freeze them in the
+      # function.
+      def frozen_throughout (value)
+        case value
+        when Array  then value.map { |item| frozen_throughout(item) }.freeze
+        when String then value.frozen? ? value : value.dup.freeze
+        else value
+        end
+      end
+
+      # Works out what #run_over_whole_arrays keeps between calls, the way it
+      # always worked it out on every call.  Every refusal a pass can meet is
+      # met here, before a plan exists, so a plan is only ever of a call that
+      # ran.
+      def plan_run (source, node, origin, arrays, scalars, c_functions,
+                    randoms, map)
         # An array the block only hands to a C function whole is not walked,
         # so the expression's shape has nothing to say about it -- and it has
         # a shape of its own that need not line up with anything.  Left in,
@@ -1250,15 +1441,10 @@ class CArray
         # axis rather than the call it was written for.
         #
         # So it joins after the broadcast, which is what a generator's state
-        # already does and for the same reason.  The re-substitution further
-        # down stays: this is a static reading, and the analyzer's answer is
-        # the final one.
+        # already does and for the same reason.  The re-substitution in the
+        # caller stays: this is a static reading, and the analyzer's answer
+        # is the final one.
         handed_over = address_array_names(source, node, c_functions)
-        # The common case is that there are none, and it pays nothing: no
-        # hash is built and the broadcast is handed the operands it always
-        # was.  Every call comes through here -- `jit_each` is re-entered per
-        # call -- so the work that is only needed sometimes is done only
-        # then.
         addressed = handed_over.empty? ? EMPTY_ARRAYS
                                        : arrays.slice(*handed_over)
         walked = addressed.empty? ? arrays
@@ -1274,22 +1460,13 @@ class CArray
         end
 
         aligned, shape = broadcast(walked)
-        addressed.each { |name, array| aligned[name] = array }
-        # A generator's state joins after the broadcast, never before it.
-        # It is passed whole rather than walked, so the expression's shape
-        # has nothing to say about it -- and it has a shape of its own that
-        # would not line up anyway: four cells, against however many the
-        # expression covers.  Lining it up first is what `jit_each` did to a
-        # one-cell state before 314d6cb, and a four-cell one does not even
-        # stretch.
-        states = random_states(randoms)
-        arrays = arrays.merge(states)
-        aligned = aligned.merge(states)
+        stretched = aligned.any? { |name, array| !array.equal?(walked[name]) }
+        arrays = arrays.merge(random_states(randoms))
         if map
-          result = allocate_map_result(source, node, arrays, scalars, shape,
-                                       c_functions, randoms)
+          result_type = probe_map(source, node, arrays, scalars, c_functions,
+                                  randoms)
+          result = CArray.send(result_type, *(shape.empty? ? [1] : shape))
           arrays = arrays.merge(MAP_RESULT => result)
-          aligned = aligned.merge(MAP_RESULT => result)
         end
         # Both questions are about the arrays the loop walks.  An array
         # handed over whole is not one of them: its mask is not something the
@@ -1321,31 +1498,13 @@ class CArray
                   "expression covers #{shape.inspect}; a stretched array " \
                   "cannot be written to"
           end
-          aligned[name] = written
-        end
-
-        aligned = read_once_where_the_pass_writes(aligned, kernel.written_arrays)
-
-        # An array handed to a C function by address is passed whole rather
-        # than walked, so the expression's shape has nothing to say about it.
-        # Broadcasting it would stretch a one-cell state array into a
-        # read-only `CARepeat`, which the copy-back after the call cannot
-        # write through -- and a state array is exactly the shape a caller
-        # reaches for.
-        kernel.address_arrays.each do |name|
-          aligned[name] = arrays.fetch(name)
-        end
-
-        if kernel.masked
-          kernel.written_arrays.each do |name|
-            array = arrays.fetch(name)
-            array.mask = 0 unless array.has_mask?
-          end
         end
 
-        result.mask = 0 if map && kernel.masked && !result.has_mask?
-        drive(kernel, aligned, scalars, c_functions, shape, sweeping)
-        map ? result : kernel
+        RunPlan.new(walked: walked.keys.freeze,
+                    addressed: addressed.keys.freeze,
+                    stretched: stretched, shape: shape.freeze,
+                    sweeping: sweeping, kernel: kernel,
+                    result_type: result_type)
       end
 
       # `a = b * 2.0` reads the whole of the right-hand side and then assigns,
@@ -1394,7 +1553,7 @@ class CArray
         return if written.empty?
         roots = written.map { |array| root_of(array) }
         arrays.each do |name, array|
-          next unless Access.classify(array)[:tier] == Access::TIER_XFER
+          next unless Access.tier(array) == Access::TIER_XFER
           root = root_of(array)
           # Another operand on the same storage, and one of the two written:
           # a copy taken before the loop cannot answer for either of them.
@@ -1434,7 +1593,7 @@ class CArray
       def broadcast (arrays)
         values = arrays.values
         rank = values.reject { |value| value.is_a?(CScalar) }
-                     .map(&:rank).max || 1
+                     .map(&:ndim).max || 1
         values = values.map { |value|
           value.is_a?(CScalar) ? value.refer(value.data_type, [1] * rank) : value
         }
@@ -1695,6 +1854,9 @@ class CArray
         @undef_cache = {}
         @probe_cache = {}
         @local_array_name_cache = {}
+        # A plan holds the kernel it runs, so one left behind would hand the
+        # next call a kernel the registry no longer has.
+        @run_plans = {}
       end
 
       # @return [String] the directory this environment's kernels are kept in,

metadata

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