carray-jit 0.1.3 → 0.1.4

data/lib/carray/jit/analyzer.rb

@@ -263,7 +263,7 @@ class CArray
       COMPARISON_OPERATORS = [:<, :<=, :>, :>=, :==, :!=].freeze
 
       attr_reader :parameter_names, :pointer_names, :address_arrays,
-                  :address_parameters, :random_names
+                  :address_parameters, :random_names, :assigned_parameters
       # An offset that is an integer here rather than when the kernel runs.
       # A literal is one; so is arithmetic over literals, which is the same
       # number written a way that says where it came from -- `w[-RADIUS-1]`
@@ -310,7 +310,7 @@ class CArray
       attr_reader :windows
       attr_reader :index_names, :array_names, :scalar_names, :c_function_names, :body,
                   :written_arrays, :array_ranks, :subscripts, :inner_ranges,
-                  :index_sources,
+                  :index_sources, :unbounded_indices,
                   :contracted_names
       # The C arrays the body declares, as [scope, name, storage, shape].
       # Nothing in the operand tables says a body has any, so this is how the
@@ -503,6 +503,7 @@ class CArray
         @inner_names_seen = []
         @array_ranks = {}
         @inner_ranges = {}
+        @unbounded_indices = []
         @subscripts = Hash.new { |hash, key| hash[key] = [] }
         @write_subscripts = Hash.new { |hash, key| hash[key] = [] }
         @given_rank = rank
@@ -535,6 +536,7 @@ class CArray
         @scalar_names = []
         @c_function_names = []
         @parameter_names = []
+        @assigned_parameters = []
         @pointer_names = []
         @address_arrays = []
         @address_parameters = {}
@@ -808,6 +810,15 @@ class CArray
           raise Unsupported.new("kernel body is empty")
         end
         @assigned_names = collect_assigned_names(block.body)
+        read_parameter_assignments(block.body) if @function
+        # A parameter the body assigns is a local from the top of the body
+        # on, starting at the value the call passed.  Bound here, before any
+        # statement is built, so every read of it -- the first included --
+        # is a read of that local.
+        entry = @assigned_parameters.map { |name|
+          @scalar_names << name unless @scalar_names.include?(name)
+          assign_local(name, CaptureRead.new(name), nil)
+        }
 
         # A contraction may end in a bare expression rather than an
         # assignment; that is the form that allocates its result and returns.
@@ -839,7 +850,7 @@ class CArray
           built << (returns_value ? build(last) : build_statement(last))
           @map_value = built.last if @map
         end
-        @body = KernelBody.new(built)
+        @body = KernelBody.new(entry + built)
 
         return if @contract == :probe || @map == :probe
         return if @function
@@ -1239,6 +1250,50 @@ class CArray
         names.uniq
       end
 
+      # A parameter the body assigns.  Left alone, the assignment was taken
+      # for a new local of the same name -- declared a second time in the C,
+      # which the C compiler refused, or read before it was assigned, which
+      # is not what it is.
+      #
+      # In a `jit_function` body it is what C makes of it: the parameter is
+      # the function's own copy of what it was called with, and a body may
+      # count it down or replace it.  So a number is kept, and bound as a
+      # local at the top of the body (see #analyze).  A pointer is not: the
+      # name is the array the body indexes, and a second array under it is
+      # nothing the body's arrays can be.
+      #
+      # For `jit_call` it is the leak in the block reading as a closure: the
+      # name is a local of the method around the call, and assigning it
+      # looks like writing that local, which a value passed by value cannot
+      # do.  An array parameter does come back, through its cells, so the
+      # two look alike and only one of them works.
+      def read_parameter_assignments (node)
+        return unless node
+        if ASSIGNMENT_NODES.any? { |kind| node.is_a?(kind) } &&
+           @parameter_names.include?(node.name)
+          name = node.name
+          if @declared_parameters
+            raise Unsupported.new(
+              "`#{name}` is a parameter of this `jit_call`, so assigning it " \
+              "looks like writing the local of that name -- and a parameter " \
+              "is passed by value, so nothing written here would reach it. " \
+              "An array's cells do come back, as in `#{name}[0] = ...`; for " \
+              "a number, give the body a local of its own name, or pass a " \
+              "one-cell array and write its cell",
+              node.location)
+          end
+          if @pointers.key?(name)
+            raise Unsupported.new(
+              "`#{name}` is a pointer parameter, and the body's arrays are " \
+              "the ones it was called with; write its cells, as in " \
+              "`#{name}[0] = ...`, rather than the name",
+              node.location)
+          end
+          @assigned_parameters << name unless @assigned_parameters.include?(name)
+        end
+        node.compact_child_nodes.each { |child| read_parameter_assignments(child) }
+      end
+
       # Accepts `->(i) { ... }`, `proc { |i| ... }` and `lambda { |i| ... }`.
       def extract_block (program)
         statements = program.statements.body
@@ -1570,7 +1625,7 @@ class CArray
             "Ruby; write the test at the top",
             node.location)
         end
-        condition = build(node.predicate)
+        condition = build_condition(node.predicate)
         @loop_depth += 1
         statements = statements_of(node.statements).map { |inner|
           build_statement(inner)
@@ -1715,6 +1770,10 @@ class CArray
         @inner_aliases[index] = internal
         @index_sources[internal] = index
         @inner_ranges[internal] = [from, to, step]
+        unless Analyzer.boundable_range?(from, @unbounded_indices) &&
+               Analyzer.boundable_range?(to, @unbounded_indices)
+          @unbounded_indices << internal
+        end
         @loop_depth += 1
         @scopes.push([])
         statements = statements_of(node.block.body).map { |inner|
@@ -1770,7 +1829,7 @@ class CArray
           else
             raise Unsupported.new("unsupported `if` continuation", node.location)
           end
-        Branch.new(build(node.predicate),
+        Branch.new(build_condition(node.predicate),
                    statements_of(node.statements).map { |inner|
                      build_statement(inner)
                    },
@@ -3021,6 +3080,42 @@ class CArray
         CaptureRead.new(name, location)
       end
 
+      # What `if`, `while` and `?:` read.  A pointer parameter named bare
+      # there is Ruby's truthiness -- nil is false and an array is true -- so
+      # `if grad` asks whether an address came, which is what NLopt's
+      # derivative-free methods leave out.  Only where a condition is read:
+      # anywhere else the bare name would be a value, and a pointer is not
+      # one.  `!`, `&&`, `||` and parentheses are looked through, since each
+      # of those reads its operands as conditions too.
+      def build_condition (node)
+        case node
+        when Prism::ParenthesesNode
+          inner = node.body ? node.body.body : []
+          return build_condition(inner.first) if inner.size == 1
+        when Prism::AndNode
+          return LogicalOperation.new(:"&&", build_condition(node.left),
+                                      build_condition(node.right), node.location)
+        when Prism::OrNode
+          return LogicalOperation.new(:"||", build_condition(node.left),
+                                      build_condition(node.right), node.location)
+        when Prism::CallNode
+          if node.name == :! && node.receiver && node.arguments.nil?
+            return LogicalNot.new(build_condition(node.receiver), node.location)
+          end
+        end
+        pointer_test(node, false, node.location) || build(node)
+      end
+
+      # A PointerTest when `receiver` names a pointer parameter, nil when it
+      # does not.  Asking is not reaching through, so a `void *` may be asked
+      # too: whether a slot was filled is a question about the slot.
+      def pointer_test (receiver, null, location)
+        name = captured_name(receiver)
+        return nil unless name && @pointers.key?(name)
+        return nil if @local_names.include?(name)
+        PointerTest.new(name, null, location)
+      end
+
       def build_conditional (node)
         unless node.subsequent
           raise Unsupported.new("`if` without `else` has no value for every cell",
@@ -3029,7 +3124,7 @@ class CArray
         unless node.subsequent.is_a?(Prism::ElseNode)
           raise Unsupported.new("`elsif` is not supported", node.location)
         end
-        Conditional.new(build(node.predicate),
+        Conditional.new(build_condition(node.predicate),
                         build_single(node.statements, node.location, "if"),
                         build_single(node.subsequent.statements, node.location, "else"),
                         node.location)
@@ -3125,6 +3220,20 @@ class CArray
           return Clamp.new(build(node.receiver), build(arguments.first),
                            build(arguments.last), node.location)
         end
+        if node.name == :nil? && arguments.empty? &&
+           (test = pointer_test(node.receiver, true, node.location))
+          return test
+        end
+        if [:==, :!=].include?(node.name) && arguments.size == 1
+          # `grad == nil` and `nil == grad`, which Ruby answers the way
+          # `grad.nil?` does and so may be written wherever that is.
+          receiver, other = node.receiver, arguments.first
+          receiver, other = other, receiver if receiver.is_a?(Prism::NilNode)
+          if other.is_a?(Prism::NilNode) &&
+             (test = pointer_test(receiver, node.name == :==, node.location))
+            return test
+          end
+        end
         if arguments.empty? && NUMERIC_PREDICATES.include?(node.name)
           return NumericPredicate.new(node.name, build(node.receiver),
                                       node.location)
@@ -3662,9 +3771,13 @@ class CArray
       # in scope, so that the offset is a compile-time constant.
       def read_subscript (node, location)
         name = index_name(node)
-        return [index_identifier(name), 0] if name && index_in_scope?(name)
+        if name && index_in_scope?(name)
+          return [nil, pinned_subscript(node)] if unbounded_index?(name)
+          return [index_identifier(name), 0]
+        end
         if node.is_a?(Prism::CallNode) && [:+, :-].include?(node.name) &&
            (receiver = index_name(node.receiver)) && index_in_scope?(receiver)
+          return [nil, pinned_subscript(node)] if unbounded_index?(receiver)
           return walked_subscript(node)
         end
         # Anything else pins the axis at a position the loop does not walk:
@@ -3678,6 +3791,30 @@ class CArray
         build(node)
       end
 
+      # An inner index whose range reads a local or a cell.  Its range is not
+      # known until the loop is reached, so a subscript it walks cannot be
+      # checked before the kernel runs; it is checked at each access instead,
+      # as `a[b[i]]` is.
+      def unbounded_index? (name)
+        @unbounded_indices.include?(index_identifier(name))
+      end
+
+      # Whether an inner loop's range can be worked out before the kernel
+      # runs: literals, captured integers, the extents, and indices whose own
+      # range can, under `+`, `-` and `*`.
+      def self.boundable_range? (node, unbounded)
+        case node
+        when IntegerLiteral, CaptureRead, BoundsValue then true
+        when IndexVariable then !unbounded.include?(node.name)
+        when UnaryMinus    then boundable_range?(node.operand, unbounded)
+        when BinaryOperation
+          [:+, :-, :*].include?(node.operator) &&
+            boundable_range?(node.left, unbounded) &&
+            boundable_range?(node.right, unbounded)
+        else false
+        end
+      end
+
       # The one cell a CScalar has: position zero on its one axis, which is a
       # pinned subscript like any other and is checked like one.
       def cell_subscripts (array, location)