carray-jit 0.1.5 → 0.1.7

data/lib/carray/jit/kernel.rb

@@ -1,4 +1,4 @@
-require "fiddle"
+require "carray/jit/native"
 require "carray/jit/sweep"
 
 class CArray
@@ -7,8 +7,9 @@ class CArray
     # A compiled kernel, bound to one set of array data types and one set of
     # scalar types.
     #
-    # Every kernel has the same C signature, so the Fiddle::Function shape is
-    # fixed and the per-kernel detail travels in the six buffers.
+    # Every kernel has the same C signature, so the shape of the function
+    # Native makes is fixed and the per-kernel detail travels in the six
+    # buffers.
     class CompiledKernel
 
       # @!attribute [r] source
@@ -54,6 +55,12 @@ class CArray
         @rank = analyzer.rank
         @index_names = analyzer.index_names
         @written_arrays = analyzer.written_arrays
+        # Which operands the sweep writes, in CArray's spelling: one character
+        # per operand.  Decided by the body, so spelled once rather than on
+        # every call.
+        @fsync = @arrays.map { |name|
+          @written_arrays.include?(name) ? "1" : "0"
+        }.join.freeze
         @array_ranks = analyzer.array_ranks
         @inner_ranges = analyzer.inner_ranges
         @unbounded_indices = analyzer.unbounded_indices
@@ -126,9 +133,8 @@ class CArray
         @handle, @compiled = Compiler.build(generator.generate_slab(SLAB_NAME),
                                             CGenerator::FUNCTION_NAME,
                                             header: generator.provenance)
-        @function = Fiddle::Function.new(@handle[CGenerator::FUNCTION_NAME],
-                                         [Fiddle::TYPE_VOIDP] * 10,
-                                         Fiddle::TYPE_VOID)
+        @function = Native.function(Native.address(@handle, CGenerator::FUNCTION_NAME),
+                                    [:pointer] * 10, :void, release_gvl: true)
       end
 
       # `bounds` is one [start, limit, step] per axis.
@@ -209,9 +215,6 @@ class CArray
       # arguments the kernel's own loop takes are the ones a chunk arrives as.
       def sweep (array_values, scalar_values, c_function_values = {})
         arrays = @arrays.map { |name| array_values.fetch(name) }
-        fsync = @arrays.map { |name|
-          @written_arrays.include?(name) ? "1" : "0"
-        }.join
 
         error = [0].pack("l")
         reals = packed_reals(scalar_values)
@@ -233,12 +236,10 @@ class CArray
         # signature has the slots.
         masks = ("\0" * 8)
 
-        held = [buffer(reals), buffer(integers), buffer(functions),
-                buffer(data), masks, masks, error]
-        error = in_one_block(held) { |context, slots|
-          Sweep.call(slab_pointer, fsync, arrays, context)
-          slots.last[0, error.bytesize]
-        }
+        # The slab writes the error slot in `error` itself.
+        Sweep.run(slab_pointer, @fsync, arrays,
+                  buffer(reals), buffer(integers), buffer(functions),
+                  buffer(data), masks, masks, error)
 
         packed.each_with_index do |(array, item), index|
           next if array.equal?(item)
@@ -332,7 +333,7 @@ class CArray
          @shape_scalar_names.map { |name| scalars[name] }]
       end
 
-      # A kernel is shared, and Fiddle lets go of the GVL for the call, so two
+      # A kernel is shared, and its call lets go of the GVL, so two
       # threads can be reading one plan while a third prepares another.  That
       # is sound only while nothing in a plan is written after it is published
       # -- and a box is arrays inside an array, so freezing the top of it
@@ -456,7 +457,7 @@ class CArray
       end
 
       def slab_pointer
-        @slab_pointer ||= @handle[SLAB_NAME]
+        @slab_pointer ||= Native.address(@handle, SLAB_NAME)
       end
 
       # Resolved when the frame is first walked rather than at build time: a
@@ -464,8 +465,8 @@ class CArray
       # runs its interior first.
       def border_function
         @border_function ||=
-          Fiddle::Function.new(@handle[CGenerator::BORDER_NAME],
-                               [Fiddle::TYPE_VOIDP] * 10, Fiddle::TYPE_VOID)
+          Native.function(Native.address(@handle, CGenerator::BORDER_NAME),
+                          [:pointer] * 10, :void, release_gvl: true)
       end
 
       # What a C function may be handed as a pointer, and what has to be true
@@ -523,7 +524,7 @@ class CArray
 
       def address_buffer (name, array)
         @address_parameters.fetch(name).each do |parameter|
-          wanted = CDeclaration::DATA_TYPES.fetch(parameter.element.fiddle)
+          wanted = CDeclaration::DATA_TYPES.fetch(parameter.element.abi)
           unless array.data_type_name == wanted.to_s
             raise Unsupported,
                   "`#{name}` is handed to a C function as `#{parameter.text}`, " \
@@ -553,37 +554,12 @@ class CArray
         Access.classify(array)[:entity] ? array : array.copy
       end
 
-      # A pointer into an empty string is not something Fiddle can hand over,
-      # and a kernel with no scalars has an empty buffer.
+      # A pointer into an empty string is not something Native is asked to
+      # hand over, and a kernel with no scalars has an empty buffer.
       def buffer (packed)
         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

data/lib/carray/jit/native.rb

@@ -0,0 +1,149 @@
+require "fiddle"
+require "fiddle/import"
+require "carray/jit/errors"
+
+class CArray
+  module JIT
+
+    # Everything this library asks of the layer that reaches C from Ruby, and
+    # the one place that layer is named.  The rest of the library says what
+    # it wants -- open this object, find this symbol, make a function of
+    # these types, read these bytes -- in the words below, and only this
+    # file knows that Fiddle is what answers.
+    #
+    # That is so the layer can be replaced by changing one file.  Fiddle does
+    # not let a call be made from a Ractor other than the main one, and a
+    # layer that does would be a second version of this module rather than a
+    # second version of the library (devel/PROPOSAL_FFI_SEAM.md).
+    #
+    # What is asked:
+    #
+    # - a shared object opened, and the libraries already loaded searched
+    # - a symbol's address found in one
+    # - a function made from an address and its types, and called
+    # - bytes read and written at an address
+    # - a Ruby object handed to C as the VALUE it is
+    #
+    # A function is called by calling what #function returns: its #call is
+    # the layer's own, so nothing stands between a kernel and the C beyond
+    # what the layer itself costs.  The arguments it takes for a `:pointer`
+    # are an Integer address, a String -- whose bytes are what C is handed --
+    # or nil.
+    # @private
+    module Native
+
+      # The C types a function is made with, by this library's names for
+      # them.  `:pointer` is any pointer; a function's arguments say what it
+      # points at only to the C, which is all that needs to know.
+      TYPES = {
+        void:       Fiddle::TYPE_VOID,
+        pointer:    Fiddle::TYPE_VOIDP,
+        char:       Fiddle::TYPE_CHAR,
+        uchar:      Fiddle::TYPE_UCHAR,
+        short:      Fiddle::TYPE_SHORT,
+        ushort:     Fiddle::TYPE_USHORT,
+        int:        Fiddle::TYPE_INT,
+        uint:       Fiddle::TYPE_UINT,
+        long:       Fiddle::TYPE_LONG,
+        ulong:      Fiddle::TYPE_ULONG,
+        long_long:  Fiddle::TYPE_LONG_LONG,
+        ulong_long: Fiddle::TYPE_ULONG_LONG,
+        float:      Fiddle::TYPE_FLOAT,
+        double:     Fiddle::TYPE_DOUBLE,
+      }.freeze
+
+      # The other way round, for what Fiddle's parser answers.  Every code it
+      # gives for a spelling CDeclaration hands it is one of the fourteen
+      # above: `size_t` and the other platform words arrive as the code of
+      # whichever of these they are on this machine.
+      NAMES = TYPES.invert.freeze
+      private_constant :NAMES
+
+      POINTER_SIZE = Fiddle::SIZEOF_VOIDP
+
+      # What a library is, for a caller that was handed one.  `jit_extern`'s
+      # `from:` takes one of these as it stands.
+      Library = Fiddle::Handle
+
+      # Raised when a library will not open or a symbol is not in it.
+      LinkError = Fiddle::DLError
+
+      PARSER = ::Object.new.extend(Fiddle::CParser)
+      private_constant :PARSER
+
+      # Opens a shared object.  `global:` is whether its symbols join the
+      # process-wide namespace -- RTLD_GLOBAL -- and it is a required word
+      # because layers differ on what they do unasked: Fiddle opens globally,
+      # and a layer that opened locally would change which definition a name
+      # in one generated object resolves to (see Compiler's link flags).
+      # Fiddle has no word for the other way, and nothing here asks for it.
+      def self.open_library (path, global:)
+        raise ArgumentError, "Fiddle opens a library only globally" unless global
+        Fiddle::Handle.new(path, Fiddle::RTLD_LAZY | Fiddle::RTLD_GLOBAL)
+      end
+
+      # What the process has already loaded, searched as one library.
+      def self.loaded_libraries
+        Fiddle::Handle::DEFAULT
+      end
+
+      # The address of `name` in `library`, as an Integer.
+      def self.address (library, name)
+        library[name]
+      end
+
+      # A function at `address` taking `arguments` and returning `result`,
+      # each one of the names in TYPES.
+      #
+      # `release_gvl:` is whether the GVL is let go for the length of a call,
+      # and it is a required word because layers differ on what they do
+      # unasked -- Fiddle lets it go, FFI keeps it.  Letting it go is right
+      # for C that touches no Ruby value, which is every generated kernel; it
+      # is wrong for C that does, which is CArray's own sweep.
+      def self.function (address, arguments, result, release_gvl:, name: nil)
+        types = arguments.map { |type| TYPES.fetch(type) }
+        options = name ? { name: name } : {}
+        return Fiddle::Function.new(address, types, TYPES.fetch(result), **options) if release_gvl
+        begin
+          Fiddle::Function.new(address, types, TYPES.fetch(result),
+                               need_gvl: true, **options)
+        rescue ArgumentError
+          # A Fiddle too old to be told.  It is also too old to have let go
+          # of the GVL in the first place -- the keyword and the releasing
+          # arrived together -- so what is left here is what that Fiddle
+          # would have done anyway.
+          Fiddle::Function.new(address, types, TYPES.fetch(result), **options)
+        end
+      end
+
+      # The type a C spelling is on this machine, as a name in TYPES, or nil
+      # where it is not one.  The spelling is one CDeclaration has already
+      # put in order: `unsigned long` rather than `long unsigned`, `void *`
+      # for any pointer.
+      def self.c_type (spelling)
+        NAMES.fetch(PARSER.parse_ctype(spelling))
+      rescue StandardError
+        nil
+      end
+
+      # `size` bytes at `address`, as a String.  Fiddle::Pointer.read and
+      # .write are not in the fiddle Ruby 3.2 ships (1.1.1).
+      def self.read (address, size)
+        Fiddle::Pointer.new(address)[0, size]
+      end
+
+      # `bytes` written at `address`.
+      def self.write (address, bytes)
+        Fiddle::Pointer.new(address)[0, bytes.bytesize] = bytes
+      end
+
+      # `object` as the VALUE C sees -- for CArray's own C, which takes the
+      # array itself rather than its memory.
+      def self.value (object)
+        Fiddle.dlwrap(object)
+      end
+
+    end
+
+  end
+end

data/lib/carray/jit/sweep.rb

@@ -1,4 +1,4 @@
-require "fiddle"
+require "carray"
 
 class CArray
   module JIT
@@ -19,64 +19,6 @@ class CArray
     # as saying it is the form a sweep can drive.
     module Sweep
 
-      # The sweep is reached by address, the way this library reaches every
-      # other C function: CArray's extension is already loaded, so the symbol
-      # is there to be found rather than linked against.
-      def self.handle
-        return @handle if defined?(@handle)
-        path = $LOADED_FEATURES.find { |feature|
-          File.basename(feature) =~ /\Acarray_ext\.(so|bundle|dylib)\z/
-        }
-        @handle = path && begin
-          Fiddle::Handle.new(path)
-        rescue Fiddle::DLError
-          nil
-        end
-      end
-
-      # True when this CArray is new enough to have the chunked slab family.
-      def self.available?
-        return @available if defined?(@available)
-        @available = !handle.nil? && begin
-          handle["ca_call_cslab_1_r"]
-          true
-        rescue Fiddle::DLError
-          false
-        end
-      end
-
-      # ca_call_cslab_N_r(func, fsync, rcx0..rcxN-1, userdata)
-      #
-      # `need_gvl: true` is not a detail.  Fiddle releases the GVL for a call
-      # unless it is told otherwise, which is right for every other function
-      # this library reaches -- a generated kernel is pure C, touches no Ruby
-      # value and is the better for running while other threads do.  This one
-      # is not that: it is CArray's own C, and acquiring the operands attaches
-      # them, allocates with `xmalloc`, creates a mask where an output needs
-      # one and raises on a shape that will not broadcast.  All of that is the
-      # Ruby runtime's, and none of it may be done without the GVL.  The
-      # kernel it calls back into is still pure C, but the GVL is held for the
-      # whole call rather than the callback, because Fiddle's choice is made
-      # once at the boundary and there is nowhere inside to make it again.
-      def self.function (arity)
-        @functions ||= {}
-        @functions[arity] ||=
-          begin
-            types = [Fiddle::TYPE_VOIDP] * (arity + 3)
-            begin
-              Fiddle::Function.new(handle["ca_call_cslab_#{arity}_r"], types,
-                                   Fiddle::TYPE_VOIDP, need_gvl: true)
-            rescue ArgumentError
-              # A Fiddle too old to be told.  It is also too old to have let
-              # go of the GVL in the first place -- the keyword and the
-              # releasing arrived together -- so what is left here is what
-              # that Fiddle would have done anyway.
-              Fiddle::Function.new(handle["ca_call_cslab_#{arity}_r"], types,
-                                   Fiddle::TYPE_VOIDP)
-            end
-          end
-      end
-
       # The largest arity the family was generated for.  Whether a pass can
       # go this way at all is decided in CArray::JIT.sweepable_pass?, before
       # there is a kernel -- because the answer changes what is compiled.
@@ -84,11 +26,19 @@ class CArray
 
       # `arrays` are the operands in the order the kernel addresses them, and
       # `fsync` says which of them it writes -- CArray's own spelling, one
-      # character per operand.
-      def self.call (slab, fsync, arrays, context)
-        function(arrays.size).call(slab, fsync,
-                                   *arrays.map { |array| Fiddle.dlwrap(array) },
-                                   context)
+      # character per operand.  `parts` become the table the slab is handed
+      # as `userdata`, in order; one that is not frozen is the slab's to
+      # write.
+      #
+      # CArray makes the call, and points the slab at the Strings' own bytes:
+      # they arrive as arguments, and an argument is pinned against
+      # compaction for the length of the call.  It holds the GVL throughout,
+      # unlike every other call this library makes into C.  Acquiring the
+      # operands attaches them, allocates and raises on a shape that will not
+      # broadcast, none of which may be done without it, and the kernel is
+      # called back from inside, where there is nowhere to let go of it.
+      def self.run (slab, fsync, arrays, *parts)
+        CArray::AddressBasis.sweep(slab, fsync, arrays, *parts)
       end
 
     end

data/lib/carray/jit/version.rb

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

data/lib/carray/jit.rb

@@ -315,9 +315,9 @@ class CArray
   #   CArray.jit_each { out = j0.call(x) }
   #
   # Nothing is compiled here: `extern` is C's word for a body that lives
-  # elsewhere, and finding it is Fiddle's job.  What this gem adds is that the
-  # kernel calls the address directly instead of reaching it per cell through
-  # Fiddle.
+  # elsewhere, and finding it is the dynamic loader's job.  What this gem adds
+  # is that the kernel calls the address directly instead of reaching it per
+  # cell through a foreign-function call from Ruby.
   #
   # @param prototype [String] the function's C declaration, as C writes it.
   # @param from [String, nil] the library to open; `nil` searches the process.
@@ -905,7 +905,6 @@ class CArray
       # that every operand already has the shape the pass covers, which is
       # stricter than agreeing on the count of cells.
       def sweepable_pass? (arrays, shape, masked)
-        return false unless Sweep.available?
         return false if masked
         return false if arrays.empty? || arrays.size > Sweep::MAX_ARITY
         return false unless arrays.each_value.all? { |array|
@@ -1526,6 +1525,16 @@ class CArray
         written = written_names.filter_map { |name| aligned[name] }
         return aligned if written.empty?
         roots = written.map { |array| root_of(array) }
+        # Asked first without building anything, because the answer is nearly
+        # always that nothing is shared, and this runs on every call.  The
+        # root is compared first since it is what nearly always says no.
+        shared = aligned.any? { |name, array|
+          next false if written_names.include?(name)
+          root = root_of(array)
+          roots.any? { |one| one.equal?(root) } &&
+            written.none? { |one| one.equal?(array) }
+        }
+        return aligned unless shared
         aligned.to_h do |name, array|
           next [name, array] if written_names.include?(name)
           next [name, array] if written.any? { |other| other.equal?(array) }
@@ -1645,21 +1654,23 @@ class CArray
         end
         pairs = bounds(extents, extents.size)
         steps = pairs.map { |triple, _| triple[2] }
+        reassociate = JIT.reassociate if reassociate.nil?
+
+        # Which kernel runs, and whether any operand would be transferred,
+        # answer the same for two calls whose operands agree on name, type,
+        # mask and tier -- so they are worked out once per such agreement,
+        # as an element-wise pass does (#run_over_whole_arrays).
+        key = indexed_run_key(arrays, scalars, c_functions, randoms, steps,
+                              into, reassociate)
+        plan = key && found_run_plan(source, key)
+        unless plan
+          plan = plan_indexed_run(source, node, origin, arrays, scalars,
+                                  c_functions, randoms, steps, into,
+                                  reassociate)
+          keep_run_plan(source, key, plan) if key
+        end
 
-        kernel = compile(source,
-                         node: node,
-                         origin: origin,
-                         array_names: arrays.keys,
-                         storage_types: arrays.transform_values(&:data_type_name),
-                         scalar_values: scalars,
-                         c_functions: c_functions,
-                         randoms: randoms,
-                         masked: arrays.each_value.any? { |array| array.has_mask? },
-                         steps: steps,
-                         cell_names: cell_names(arrays),
-                         map: into ? true : false,
-                         result: into ? INIT_TARGET : nil,
-                         reassociate: reassociate.nil? ? JIT.reassociate : reassociate)
+        kernel = plan.kernel
         # The kernel decides, not the caller: mentioning UNDEF makes it a
         # masked kernel even when no array carries a mask yet.
         if kernel.masked
@@ -1675,11 +1686,77 @@ class CArray
                 "#{pairs.size} #{pairs.size == 1 ? 'extent was' : 'extents were'} " \
                 "given"
         end
-        refuse_a_transferred_alias(kernel, arrays)
+        # Only an operand opened at the xfer tier can be refused, and the tier
+        # is in the key; which arrays share a root is not, and is asked here.
+        refuse_a_transferred_alias(kernel, arrays) if plan.transferred
         kernel.call(arrays, scalars, pairs.map(&:first), c_functions)
         into || kernel
       end
 
+      # What an indexed pass works out from its operands without their data
+      # or their shapes: the kernel, and whether any operand is opened at the
+      # xfer tier.  The shapes are the kernel's own plan to keep, since they
+      # are what its bounds are checked against (CompiledKernel#call).
+      #
+      # @private
+      IndexedRunPlan = Data.define(:kernel, :transferred)
+
+      # What two calls of one indexed block have to agree on for one to run
+      # the other's kernel: what #compile is keyed on, read off the operands
+      # rather than built.  Each operand's name and type, whether it is a
+      # CScalar (read at its one cell rather than walked) and whether it has
+      # a mask; and its tier, because whether a transferred operand has to be
+      # refused depends on it.  Not its shape: the kernel is the same over
+      # any shape, and a caller that grows its arrays would miss on every
+      # call.  Not a scalar's value, for the reason #run_key gives.
+      #
+      # The leading symbol keeps these apart from an element-wise pass's
+      # keys, which share the store.
+      #
+      # 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 indexed_run_key (arrays, scalars, c_functions, randoms, steps, into,
+                           reassociate)
+        key = [:indexed, into ? true : false, reassociate, steps, arrays.size]
+        arrays.each do |name, array|
+          key << name << array.data_type << array.is_a?(CScalar) <<
+                 array.has_mask? << Access.tier(array)
+        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 plan_indexed_run (source, node, origin, arrays, scalars, c_functions,
+                            randoms, steps, into, reassociate)
+        kernel = compile(source,
+                         node: node,
+                         origin: origin,
+                         array_names: arrays.keys,
+                         storage_types: arrays.transform_values(&:data_type_name),
+                         scalar_values: scalars,
+                         c_functions: c_functions,
+                         randoms: randoms,
+                         masked: arrays.each_value.any? { |array| array.has_mask? },
+                         steps: steps,
+                         cell_names: cell_names(arrays),
+                         map: into ? true : false,
+                         result: into ? INIT_TARGET : nil,
+                         reassociate: reassociate)
+        transferred = arrays.each_value.any? { |array|
+          Access.tier(array) == Access::TIER_XFER
+        }
+        IndexedRunPlan.new(kernel: kernel, transferred: transferred)
+      end
+
       # Compiles for one set of array data types and one set of scalar types,
       # and returns the same CompiledKernel for every later call with the
       # same ones.  Nothing on this path is cheap relative to running the

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carray-jit
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - himotoyoshi
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: 3.0.6
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.1'
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: 3.0.6
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.1'
@@ -35,14 +35,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.1
 description: |
   Write the loop in Ruby, and it runs at the speed of C -- one to two orders
   of magnitude faster than interpreted. It is for what a CArray expression
@@ -125,6 +125,7 @@ files:
 - lib/carray/jit/errors.rb
 - lib/carray/jit/expression.rb
 - lib/carray/jit/kernel.rb
+- lib/carray/jit/native.rb
 - lib/carray/jit/node.rb
 - lib/carray/jit/sorting_networks.rb
 - lib/carray/jit/sweep.rb
@@ -148,7 +149,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: []