carray-jit 0.1.6 → 0.1.7

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.6"
+    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.6
+  version: 0.1.7
 platform: ruby
 authors:
 - himotoyoshi
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.5
+        version: 3.0.6
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.1'
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.5
+        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: []