rpiet 0.1 → 0.2

data/lib/rpiet/ir/ir_native_interpreter.rb

@@ -0,0 +1,77 @@
+require_relative 'ir_interpreter'
+
+module RPiet
+  module IR
+    class IRNativeInterpreter < IRInterpreter
+      def process_image(image)
+        graph = RPiet::ASG::Parser.new(image).run
+        builder = RPiet::Builder.new
+        builder.run graph
+        @instructions = builder.instructions
+        @cfg = CFG.new(@instructions)
+        @instructions = @cfg.instructions(Passes::Peephole)
+        @cfg.write_to_dot_file
+        # Note: left over from experiment but pop or push with n will construct an array and this outweighs the benefit
+        # combine_pushes_and_pops
+        generate_ruby_bb_methods
+      end
+
+      def run
+        method_name = :entry
+        while method_name do
+          method_name = send(method_name)
+        end
+      end
+
+      private
+
+      def generate_ruby_bb_methods
+        # Generate constants and things generated methods may rely on.
+        @instructions.each { |instr| eval instr.to_ruby_pre if instr.respond_to?(:to_ruby_pre) }
+
+        @cfg.basic_blocks.each do |bb|
+          s = ["def #{bb.label}()\n"]
+          bb.instrs.each do |instr|
+            lines = instr.to_ruby(@cfg, bb)
+            s << lines if lines
+          end
+          unless bb.instrs&.last&.jump?
+            ret = @cfg.outgoing_target(bb, :fall_through)&.label || 'nil'
+            s << "  #{ret}\n"
+          end
+          s << "end\n"
+          code = s.join('')
+          puts "#{code}\n"
+          self.instance_eval code
+          if bb.instrs&.first.kind_of?(Instructions::LabelInstr)
+            bb.instrs.pop(bb.instrs.length - 1)
+          else
+            bb.instrs.clear
+          end
+        end
+      end
+
+      def combine_pushes_and_pops
+        @cfg.basic_blocks.each { |bb| multi_opt(Instructions::MultiplePushInstr, bb, :push, :operand) }
+        @cfg.basic_blocks.each { |bb| multi_opt(Instructions::MultiplePopInstr, bb, :pop, :result) }
+      end
+
+      def multi_opt(instr_type, bb, operation, field)
+        list = []
+        bb.instrs.each_with_index do |instr, i|
+          if instr.operation == operation
+            list << instr
+          else
+            if list.length > 1
+              bb.instrs[(i - list.length)...i] = instr_type.new(*list.map { |instr| instr.send(field) }.reverse)
+            end
+            list = []
+          end
+        end
+        if list.length > 1
+          bb.instrs[(bb.instrs.length - list.length)..-1] = instr_type.new(*list.map { |instr| instr.send(field) }.reverse)
+        end
+      end
+    end
+  end
+end

data/lib/rpiet/ir/jruby_backend.rb

@@ -0,0 +1,279 @@
+require 'jruby'
+require_relative '../parser/ser'
+require_relative 'builder'
+
+module Kernel
+  # returns a lambda containing the piet program loaded
+  def piet_require(filename, codel_size=1)
+    if filename =~ /.txt/
+      require_relative '../image/ascii_image'
+      image = RPiet::Image::AsciiImage.new(File.read(filename), codel_size)
+    else
+      filename = 'file:' + filename if File.exist? filename
+      require_relative '../image/url_image'
+      image = RPiet::Image::URLImage.new(filename, codel_size)
+    end
+
+    graph = RPiet::Parser.new(image).run
+    builder = RPiet::Builder.new
+    builder.run graph
+    puts builder.instructions.join("\n")
+    puts "Done"
+    runtime = JRuby.runtime
+    tc = runtime.current_context
+    scope = RPiet::JRubyBackend.new(runtime.getIRManager, tc.current_static_scope).build(builder.instructions, builder.cc, builder.dp)
+    
+    body = scope.block_body
+    runtime.getJITCompiler.get_task_for(tc, body).run
+    block = org.jruby.runtime.Block.new(body, tc.currentBinding(runtime.object, tc.current_scope))
+
+    #set_trace_func proc { |event, *e| p e if event.to_s == "call" }
+
+    org.jruby.RubyProc.newProc(runtime, block, org.jruby.runtime.Block::Type::LAMBDA, filename, 0)
+  end
+
+  #public :p
+end
+
+class Array
+  def roll(depth, num)
+    num %= depth
+    return if depth <= 0 || num == 0
+    if num > 0
+      self[-depth..-1] = self[-num..-1] + self[-depth...-num]
+    elsif num < 0
+      self[-depth..-1] = self[-depth...-num] + self[-num..-1]
+    end
+  end
+end
+
+module RPiet
+  class JRubyBackend
+    DEBUG = false
+
+    java_import org.jruby.parser.StaticScope
+    java_import org.jruby.parser.StaticScopeFactory
+    java_import org.jruby.runtime.ArgumentDescriptor
+    java_import org.jruby.runtime.ArgumentType
+    java_import org.jruby.runtime.CallType
+    java_import org.jruby.runtime.RubyEvent
+    java_import org.jruby.runtime.Signature
+    java_import org.jruby.ir.Operation
+    java_import org.jruby.ir.IRClosure
+    java_import org.jruby.ir.instructions.BEQInstr
+    java_import org.jruby.ir.instructions.BNEInstr
+    java_import org.jruby.ir.instructions.CallInstr
+    java_import org.jruby.ir.instructions.CheckArityInstr
+    java_import org.jruby.ir.instructions.JumpInstr
+    java_import org.jruby.ir.instructions.LabelInstr
+    java_import org.jruby.ir.instructions.NopInstr
+    java_import org.jruby.ir.instructions.NoResultCallInstr
+    java_import org.jruby.ir.instructions.ReceivePreReqdArgInstr
+    java_import org.jruby.ir.instructions.ReturnInstr
+    java_import org.jruby.ir.instructions.TraceInstr
+    java_import org.jruby.ir.operands.CurrentScope
+    java_import org.jruby.ir.operands.Operand
+    java_import org.jruby.ir.operands.ScopeModule
+    java_import org.jruby.ir.operands.StringLiteral
+    java_import org.jruby.ir.operands.TemporaryLocalVariable
+    java_import org.jruby.ir.operands.UnexecutableNil
+
+    class NamedTemporaryVariable < TemporaryLocalVariable
+      def initialize(index, name)
+        super(index)
+        @name = name
+      end
+
+      def getPrefix
+        @name
+      end
+    end
+
+    def initialize(manager, containing_scope)
+      @manager = manager
+      "_in".to_java(:String).intern
+      "_out".to_java(:String).intern
+      param_names = ["_in", "_out"].to_java java.lang.String
+      static_scope = StaticScopeFactory.new_static_scope(containing_scope, StaticScope::Type::BLOCK, param_names, -1)
+      @scope = IRClosure.new(@manager, containing_scope.getIRScope, 0,
+                             static_scope, Signature::TWO_ARGUMENTS)
+      @instructions = java.util.ArrayList.new
+      @variables = {} # piet -> jruby
+      @labels = {} # piet -> jruby
+    end
+
+    def add(instr)
+      @instructions.add instr
+    end
+
+    # Note: originally considered fully boxing by default but VM
+    # should be responsible so this is a call (plus this is way simpler)
+    def alu_op(instr)
+      add call(instr.result, instr.operand1, instr.oper, instr.operand2)
+    end
+
+    def call(result, receiver, name, *args)
+      if result
+        CallInstr.create(@scope, CallType::NORMAL, build_operand(result), name.to_s,
+                         build_operand(receiver), build_operands(*args).to_java(Operand), nil)
+      else
+        recv = build_operand(receiver)
+        operands = build_operands(*args)
+        NoResultCallInstr.create(CallType::NORMAL, name.to_s, recv, operands.to_java(Operand),
+                                 nil, false)
+      end
+    end
+    
+    def copy(a,b)
+      org.jruby.ir.instructions.CopyInstr.new build_operand(a), build_operand(b)
+    end
+
+    def build_operands(*operands)
+      operands.inject([]) do |array, operand|
+        array << build_operand(operand)
+        array
+      end
+    end
+
+    def build_operand(operand)
+      return operand if operand.kind_of? Operand
+
+      case operand.type
+      when :var then
+        temp_var_for(operand)
+      when :string then
+        StringLiteral.new operand.value
+      when :num then num(operand.value)
+      end
+    end
+
+    def label(piet_label)
+      @labels[piet_label] = @scope.get_new_label(piet_label.value)  unless @labels[piet_label]
+      @labels[piet_label]
+    end
+
+    def num(value)
+      org.jruby.ir.operands.Fixnum.new value
+    end
+
+    def temp_var_for(variable)
+      @variables[variable] = temp_var unless @variables[variable]
+      @variables[variable]
+    end
+    
+    def temp_var
+      @scope.create_temporary_variable
+    end
+
+    def build(piet_instructions, cc, dp)
+      build_prologue
+      build_args
+      build_pointers(cc, dp)
+      return_value = build_body(piet_instructions)
+      build_return return_value
+      @scope.allocateInterpreterContext @instructions
+      @scope      
+    end
+
+    # 2 args (in, out)
+    def build_args
+      @scope.argument_descriptors = build_arg_descriptor
+      add CheckArityInstr.new(2, 0, false, false, -1)
+      _in = @scope.get_new_local_variable("_in", 0)
+      add ReceivePreReqdArgInstr.new(_in, 0)
+      _out = @scope.get_new_local_variable("_out", 0)
+      add ReceivePreReqdArgInstr.new(_out, 1)
+    end
+
+    def build_body(piet_instrs)
+      temp_var = temp_var() # we generally only need one and can reuse it.
+      input = @scope.lookupExistingLVar("_in")
+      output = @scope.lookupExistingLVar("_out")
+      stack_var = build_stack
+      piet_instrs.each do |instr|
+        next unless instr
+        case instr.type
+        when :noop
+          add NopInstr.NOP
+        when :add, :sub, :mult, :div, :mod, :pow then alu_op(instr)
+        when :push
+          add call(nil, stack_var, :push, instr.operand)
+        when :pop
+          add call(instr.result, stack_var, :pop)
+        when :roll
+          add call(nil, stack_var, :roll, instr.operand1, instr.operand2)
+        when :cin
+          add call(instr.result, input, :read, num(1))
+        when :nin
+          add call(temp_var, input, :gets)
+          add call(nil, output, :puts, temp_var)
+          add call(instr.result, temp_var, :to_i)
+        when :cout
+          add call(temp_var, instr.operand, :chr)
+          add call(nil, output, :print, temp_var)
+        when :nout
+          add call(nil, output, :print, instr.operand)
+        when :jump
+          add JumpInstr.new label(instr.label)
+        when :beq
+          add BEQInstr.create(*build_operands(instr.operand1, instr.operand2),
+                              label(instr.label))
+        when :bne
+          add BNEInstr.create(label(instr.label),
+                              *build_operands(instr.operand1, instr.operand2))
+        when :gt
+          add call(temp_var, instr.operand2, :>, instr.operand1)
+          add BNEInstr.create(label(instr.label), temp_var, @manager.true)
+        when :label
+          add LabelInstr.new(label(instr))
+        when :copy
+          add copy(instr.result, instr.operand)
+        when :node
+          add TraceInstr.new(RubyEvent::CALL, instr.to_s, "", -1) if DEBUG
+        end
+      end
+      add call(temp_var, stack_var, :pop)
+      temp_var
+    end
+
+    # Made custom-named type so we get better output in JRuby IR
+    # so we can more easily recognize special locals
+    def build_pointers(cc, dp)
+      cc_operand = build_operand(cc)
+      @variables[cc] = NamedTemporaryVariable.new cc_operand.offset, '%cc'
+      dp_operand = build_operand(dp)
+      @variables[dp] = NamedTemporaryVariable.new dp_operand.offset, '%dp'
+    end
+
+    # will be our live stack during execution.
+    # Note: JRuby IR has no primitives for manipulating arrays
+    # directly so we will be leveraging Ruby internally for
+    # stack manipulation
+    def build_stack
+      t = temp_var # alloc temp but the take it over with named one
+      NamedTemporaryVariable.new(t.offset, '%stack').tap do |stack_var|
+        add copy(stack_var, org.jruby.ir.operands.Array.new)
+      end
+    end
+
+    def build_arg_descriptor
+      [ArgumentDescriptor.new(ArgumentType.req, "_in"),
+       ArgumentDescriptor.new(ArgumentType.req, "_out")].to_java(ArgumentDescriptor)
+    end
+
+    def build_prologue
+      add @manager.receive_self_instr
+      add copy(@scope.current_scope_variable, CurrentScope::CURRENT_SCOPE[0])
+      add copy(@scope.current_module_variable, ScopeModule::SCOPE_MODULE[0])
+    end
+
+    def build_return(return_value)
+      if return_value && return_value != UnexecutableNil::U_NIL
+        add ReturnInstr.new(return_value)
+      end
+      # Note: I am ignoring all special handling logic for lambda here
+      # because I know I have no need for it but I wonder if JRuby IR
+      # will choke on this lack of support regardless?
+    end
+  end
+end

data/lib/rpiet/ir/operands.rb

@@ -0,0 +1,28 @@
+module RPiet
+  module IR
+    ##
+    # Using pure Ruby types for all operands but variable:
+    #   1. label => Symbol
+    #   2. char => String
+    #   3. numeric => Integer
+    module Operands
+      class Poperand
+        def to_s = "<pop>"
+      end
+
+      class VariableOperand
+        attr_reader :name
+        attr_accessor :value
+        def initialize(name)
+          @value, @name = nil, name
+        end
+
+        def eql?(other) = @name == other.name
+
+        def hash = [self.class, @name].hash
+
+        def to_s = "#@name#{@value ? %Q{:(#@value)} : ''}"
+      end
+    end
+  end
+end

data/lib/rpiet/ir/passes/data_flow_problem.rb

@@ -0,0 +1,32 @@
+module RPiet
+  module IR
+    module Passes
+      class DataFlowProblem
+        attr_reader :computed, :worklist, :cfg
+        attr_accessor :debug
+
+        def initialize(cfg, flow_node_class)
+          @cfg, @flow_node_class, @debug = cfg, flow_node_class, false
+        end
+
+        def run
+          # we will walk forward but want to pop to remove entries so it will appear backwards!
+          @worklist = @cfg.postorder_bbs.map {|bb| @flow_node_class.new(self, bb) }
+          @node_map = {}
+          @computed = @worklist.each_with_object({}) do |node, h|
+            h[node] = true
+            @node_map[node.bb] = node
+          end
+
+          while !@worklist.empty?
+            @worklist.pop.compute_data_flow_info
+          end
+        end
+
+        def node_for(bb)
+          @node_map[bb]
+        end
+      end
+    end
+  end
+end

data/lib/rpiet/ir/passes/flow_graph_node.rb

@@ -0,0 +1,76 @@
+module RPiet
+  module IR
+    module Passes
+      class FlowGraphNode
+        attr_reader :bb, :problem
+
+        def initialize(problem, bb)
+          @problem, @bb = problem, bb
+        end
+
+        def cfg = problem.cfg
+        def computed = problem.computed
+        def debug = problem.debug
+        def worklist = problem.worklist
+
+        def compute_data_flow_info
+          computed[self] = false
+
+          apply_pre_meet_handler
+          compute_flow_info
+        end
+
+        def compute_flow_info
+          puts "compute_flow_info for #{bb.label}" if debug
+          cfg.incoming_sources(bb).each do |source|
+            puts "  <--- #{source.label}" if debug
+            compute_meet(problem.node_for(source))
+          end
+
+          solution do
+            bb.instrs.each { |instr| apply_transfer_function(instr) }
+            requeue_target_bbs(cfg.outgoing_targets(bb)) if solution_changed?
+          end
+        end
+
+        def solution
+          solution_init
+          yield
+          assign_outs
+        end
+
+        # Something changed and so we need to reprocess these flow nodes.
+        def requeue_target_bbs(bbs)
+          bbs.filter { |bb| !computed[bb] }.each do |bb|
+            computed[bb] = true
+            worklist << problem.node_for(bb)
+          end
+        end
+
+        def apply_pre_meet_handler
+        end
+
+        def apply_transfer_function(instr)
+        end
+
+        # See define_ins
+        def assign_outs
+        end
+
+        # Function which merges out values from the incoming flow nodes.
+        # Define appropriate logic to apply MOP (to merge results into a
+        # new in set for this node).
+        def compute_meet(node)
+        end
+
+        # Construct the data structure to represent the values of this node
+        # in terms to resolve with in and to become out.
+        def solution_init
+        end
+
+        def solution_changed?
+        end
+      end
+    end
+  end
+end

data/lib/rpiet/ir/passes/peephole.rb

@@ -0,0 +1,214 @@
+module RPiet
+  module IR
+    module Passes
+      class Peephole
+        def initialize(cfg)
+          @cfg = cfg
+          @pushes = {}
+          @processed = {}
+        end
+
+        def run
+          @cfg.linearize.each do |bb|
+            3.times do
+              push_pop_elimination(bb)
+              constant_bb(bb)
+              constant_fold_bb(bb)
+              roll_elimination(bb)
+            end
+
+            poperand_optimize(bb)
+            remove_extra_cc_dp(bb)
+          end
+          @cfg.cull
+        end
+
+        def remove_extra_cc_dp(bb)
+          instructions = bb.instrs
+          @dps, @ccs = [], []
+
+          instructions.each do |instr|
+            case instr
+            when Instructions::DPRotateInstr
+              @dps = []
+            when Instructions::DPInstr
+              @dps << instr
+            when Instructions::CCToggleInstr
+              @ccs = []
+            when Instructions::CCInstr
+              @ccs << instr
+            end
+          end
+
+          @ccs[0...-1].each { |instr| instructions.delete(instr) } if @ccs.length > 1
+          @dps[0...-1].each { |instr| instructions.delete(instr) } if @dps.length > 1
+        end
+
+        def roll_elimination(bb)
+          instructions = bb.instrs
+          @roll_vars ||= 0
+          i = 0
+          while i < instructions.length
+            instr = instructions[i]
+            if instr.kind_of?(Instructions::RollInstr) && instr.constant?
+              new_instructions = []
+              new_variables = []
+              depth = instr.depth
+              depth.times do
+                variable = Operands::VariableOperand.new("r#{@roll_vars}")
+                @roll_vars += 1
+                new_variables << variable
+                new_instructions << Instructions::PopInstr.new(variable)
+              end
+              num = instr.num
+              num = depth+num if num < 0
+              new_variables[0...num].reverse_each do |var|
+                new_instructions << Instructions::PushInstr.new(var)
+              end
+              new_variables[num..-1].reverse_each do |var|
+                new_instructions << Instructions::PushInstr.new(var)
+              end
+
+              instructions[i, 1] = new_instructions
+            end
+            i += 1
+          end
+        end
+
+        def poperand_optimize(bb)
+          instructions = bb.instrs
+          pops = []
+          dead_instrs = []
+
+          uses = instructions.each_with_object({}) do |instr, h|
+            instr.operands.each do |operand|
+              if operand.kind_of?(Operands::VariableOperand)
+                h[operand] ||= 0
+                h[operand] += 1
+              end
+            end
+          end
+
+          i = 0
+          while i < instructions.length
+            instr = instructions[i]
+
+            if instr.kind_of?(Instructions::PopInstr)
+              #puts "pushing another pop #{instr}"
+              pops << instr
+            elsif instr.kind_of?(Instructions::PushInstr)
+              pops = []
+            elsif contains_variables(instr)
+              roll = true if instr.kind_of?(Instructions::RollInstr)
+              if !pops.empty?
+                #puts "processing #{instr} with these pops #{pops.map {|p| p.disasm }.join(", ")}"
+                instr.operands.each_with_index do |operand, i|
+                  break if pops.empty?
+                  # This is at best conservative but it is wrong
+                  #puts "#{pops.last.result} <=> #{operand}"
+                  if pops.last.result == operand && uses[operand] == 1
+                    #puts "replacing #{operand} with a pop and removing #{pops.last.result}"
+                    instr.operands[i] = Operands::Poperand.new
+                    dead_instrs << pops.pop
+                  end
+                end
+              end
+
+              pops = [] if roll
+              roll = false
+            elsif instr.respond_to?(:two_pop)
+              roll = true if instr.kind_of?(Instructions::RollInstr)
+              if pops.length >= 2
+                dead_instrs.concat(pops.pop(2))
+                instructions[i] = instr.two_pop
+              end
+              pops = [] if roll
+              roll = false
+            end
+            i += 1
+          end
+
+          dead_instrs.each do |instr|
+            instructions.delete(instr)
+          end
+        end
+
+        def contains_variables(instr)
+          instr.operands.filter { |operand| operand.kind_of?(Operands::VariableOperand) }
+        end
+
+        def constant_bb(bb)
+          instructions = bb.instrs
+          i = 0
+          constants = {}
+          while i < instructions.length
+            instr = instructions[i]
+
+            instr.operands.each_with_index do |operand, i|
+              instr.operands[i] = constants[operand] if constants[operand]
+            end
+
+            if instr.kind_of?(Instructions::CopyInstr)
+              constants[instr.result] = instr.operand
+              instructions.delete(instr)
+            else
+              i += 1
+            end
+          end
+        end
+
+        def constant_fold_bb(bb)
+          instructions = bb.instrs
+          i = 0
+          while i < instructions.length
+            instr = instructions[i]
+            if (instr.kind_of?(Instructions::MathInstr) || instr.kind_of?(Instructions::GTInstr)) && instr.constant?
+              instr.execute(nil)
+              instructions[i] = Instructions::CopyInstr.new(instr.result, instr.result.value)
+            end
+            i += 1
+          end
+        end
+
+        def remove_dead_edges(bb)
+          last_instr = bb.instrs.last
+          if last_instr.kind_of?(Instructions::TwoOperandJumpInstr) && instr.constant? && instr.execute(nil).nil?
+            instr.label
+
+
+          end
+        end
+
+        def push_pop_elimination(bb)
+          @processed[bb] = true
+          #puts "RUN for #{bb.label}"
+          pushes = []  # lifo instr list
+          instructions = bb.instrs
+
+          i = 0
+          while i < instructions.length
+            instr = instructions[i]
+            if instr.kind_of?(Instructions::PushInstr)
+              pushes << instr
+            elsif instr.kind_of?(Instructions::NoopInstr) && !instr.kind_of?(Instructions::LabelInstr)
+              instructions.delete(instr)
+              next
+            elsif instr.kind_of?(Instructions::RollInstr)
+              # Without knowing roll values we have no way to reason about roll so we just throw out all pushes
+              pushes = []
+            elsif instr.kind_of?(Instructions::PopInstr) && !pushes.empty?
+              last_push = pushes.pop
+              #              count = count_map[last_push.operand]
+              #if !count || count == 1
+                instructions[i] = Instructions::CopyInstr.new(instr.result, last_push.operand)
+                instructions.delete(last_push)
+              #end
+              next
+            end
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end