rusby 0.1.0

data/lib/rusby.rb

@@ -0,0 +1,15 @@
+require 'parser/ruby22'
+require 'yaml'
+require 'hashie'
+require 'method_source'
+require 'colorize'
+require 'benchmark'
+require 'ffi'
+
+require "rusby/version"
+
+rusby_dir = File.expand_path('../rusby', __FILE__)
+Dir["#{rusby_dir}/**/*.rb"].each { |file| require file }
+
+module Rusby
+end

data/lib/rusby/builder.rb

@@ -0,0 +1,149 @@
+module Rusby
+  module Builder
+    extend self
+
+    def root_path
+      @root ||= File.expand_path('../../..', __FILE__)
+    end
+
+    def lib_path
+      return @lib_path if @lib_path
+      path = './tmp/rusby'
+      Dir.mkdir('./tmp') unless Dir.exists?('./tmp')
+      Dir.mkdir(path) unless Dir.exists?(path)
+      @lib_path = path
+    end
+
+    def rust
+      @rust ||= Hashie::Mash.new YAML.load_file("#{root_path}/rust.yaml")
+    end
+
+    def convert_to_rust(meta, method_name, orig_method, owner)
+      code = rust.file_header
+      code += construct_method(
+        Preprocessor.apply(orig_method.source),
+        meta[method_name]
+      )
+      code = expand_internal_methods(meta, code, owner)
+      code = Postrocessor.apply(code, meta[method_name])
+
+      File.open("#{lib_path}/#{method_name}.rs", 'w') do |file|
+        file.write(code)
+      end
+      `rustfmt #{lib_path}/#{method_name}.rs`
+
+      puts 'Done generating source code'.colorize(:yellow)
+      File.open("#{lib_path}/#{method_name}.rs") do |file|
+        code = file.read
+        code.split("\n").each_with_index do |line, i|
+          puts "#{(i + 1).to_s.rjust(3).colorize(:light_black)}.  #{line}"
+        end
+      end
+
+      compile_and_load_rust(method_name, meta)
+    end
+
+    def compile_and_load_rust(method_name, meta)
+      signature = construct_signature(
+        meta[method_name][:args],
+        meta[method_name][:result]
+      )
+      puts "Compiling #{signature.last} #{method_name}(#{signature.first.join(', ')})".colorize(:yellow)
+      puts `rustc -A unused_imports --crate-type=dylib -O -o #{lib_path}/#{method_name}.dylib #{lib_path}/#{method_name}.rs`
+
+      Proxy.rusby_load "#{lib_path}/#{method_name}"
+      Proxy.attach_function "ffi_#{method_name}", *signature
+
+      Proxy.method("ffi_#{method_name}")
+    end
+
+    def rust_method_body(meta, ast)
+      name = ast.children.first
+      rust = Rust.new(@rust.rust_types[meta[:result]])
+      rust.remember_method(name)
+
+      result = ''
+      ast.children[2..-1].each do |node|
+        result += rust.generate(node)
+      end
+      result
+    end
+
+    def expand_internal_methods(meta, code, owner)
+      method_names = code.scan(/internal_method_(\w+)\([^\)]+\)/)[0]
+      return code unless method_names
+
+      result = code
+      method_names.each do |method_name|
+        source = owner.method(method_name).source
+        result += construct_method(
+          source,
+          meta[method_name.to_sym],
+          false
+        )
+      end
+      result
+    end
+
+    def ffi_wrapper(method_name, arg_names, arg_types, return_type)
+      args = arg_names.each_with_index.map do |arg_name, i|
+        if rust.ffi_to_rust_types[arg_types[i]]
+          rust.ffi_to_rust_types[arg_types[i]].gsub('<name>', arg_name)
+        else
+          "#{arg_name}: #{rust.rust_types[arg_types[i]]}"
+        end
+      end
+      result = [
+        '',
+        '// this function folds ffi arguments and unfolds result to ffi types'
+      ]
+      result << "#{rust.exposed_method_prefix} fn ffi_#{method_name}(#{args.join(', ')}) -> #{rust.rust_to_ffi_types[return_type] || rust.rust_types[return_type]} {"
+      arg_names.each_with_index.map do |arg_name, i|
+        next unless rust.ffi_to_rust[arg_types[i]] # for simple args we don't need any convertion
+        result << rust.ffi_to_rust[arg_types[i]].gsub('<name>', arg_name).to_s
+      end
+      result << "let result = #{method_name}(#{arg_names.join(', ')});" # calls the real method with ffi args folded
+      result << "return #{rust.rust_to_ffi[return_type] || 'result'};"
+      result << '}'
+
+      result
+    end
+
+    def construct_method(source, meta, exposed = true)
+      arg_types = meta[:args]
+      return_type = meta[:result]
+
+      ast = Parser::Ruby22.parse(source)
+      method_name = ast.children[0]
+      arg_names = ast.children[1].children.map { |ch| ch.children[0].to_s }
+      meta[:names] = arg_names
+
+      result = exposed ? ffi_wrapper(method_name, arg_names, arg_types, return_type) : []
+      result << rust.method_prefix
+
+      args = arg_names.each_with_index.map { |arg_name, i| "#{arg_name}: #{rust.rust_types[arg_types[i]]}" }
+
+      result << "fn #{exposed ? '' : 'internal_method_'}#{method_name}(#{args.join(', ')}) -> #{rust.rust_types[return_type]} {"
+      result << rust_method_body(meta, ast)
+      result << '}'
+
+      result.join("\n")
+    end
+
+    def construct_signature(arg_types, return_type)
+      args = arg_types.map do |arg|
+        rust_type = rust.ffi_types[arg]
+        unless rust_type
+          puts "Please define mapping from '#{arg}' " \
+            'to rust equivalent in rust.yaml'.colorize(:red)
+          raise 'Missing mapping'
+        end
+        rust_type.to_sym
+      end
+      [
+        args.map { |arg| arg == :pointer ? [arg, :int] : arg }.flatten,
+        rust.ffi_types[return_type].to_sym
+      ]
+    end
+  end
+end

data/lib/rusby/core.rb

@@ -0,0 +1,113 @@
+module Rusby
+  module Core
+    BOOST_THRESHOLD = -1e6 # TODO: turn on
+
+    # next method should be added to the rusby table
+    def rusby!
+      @rusby_awaits_method = true
+    end
+
+    def rusby_replace_method(method_name, method_reference)
+      @rusby_skips_method = true
+      define_method(method_name, method_reference)
+    end
+
+    def rusby_type(object)
+      object.class == Array ? "Array[#{object[0].class}]" : object.class.to_s
+    end
+
+    # proxy method that records arg and result types
+    def rusby_method_proxy(object, method_name, method_reference, args)
+      bound_method = method_reference.bind(object)
+      result = bound_method.call(*args)
+
+      @rusby_method_table[method_name][:args] = args.map { |arg| rusby_type(arg) }
+      @rusby_method_table[method_name][:result] = rusby_type(result)
+
+      if @rusby_method_table[method_name][:exposed]
+        # try to convert to rust or return back the original method
+        rusby_convert_or_bust(method_name, method_reference, object, args)
+      else
+        # if we don't need to convert method to rust return back the original method
+        rusby_replace_method(method_name, method_reference)
+      end
+
+      result
+    end
+
+    def rusby_ffi_wrapper(method_name, method_reference, args)
+      bridge = ::Rusby::FFI::Bridge.new
+      arg_types = @rusby_method_table[method_name][:args]
+      ffi_args = arg_types.each_with_index.map do |arg_type, i|
+        bridge.to_ffi(arg_type, args[i])
+      end.flatten
+      ffi_result = method_reference.call(*ffi_args)
+      result_type = @rusby_method_table[method_name][:result]
+      bridge.from_ffi(result_type, ffi_result)
+    end
+
+    def rusby_convert_or_bust(method_name, method_reference, object, args)
+      # if we are converting recursive function
+      # we need to wait for it to exit all recursive calls
+      return if caller.any? { |entry| entry.include?("`#{method_name}'") }
+
+      rust_method = Builder.convert_to_rust(
+        @rusby_method_table,
+        method_name,
+        method_reference,
+        object
+      )
+
+      wrapped_rust_method = lambda do |*wrapped_args|
+        object.class.rusby_ffi_wrapper(method_name, rust_method, wrapped_args)
+      end
+
+      # check if rust method is running faster than the original one
+      puts 'Benchmarking native and rust methods (intertwined pattern)'.colorize(:yellow)
+      boost = Profiler.benchit(object, method_reference, wrapped_rust_method, args)
+
+      # coose between rust and ruby methods
+      resulting_method = method_reference
+      if boost > BOOST_THRESHOLD
+        resulting_method = wrapped_rust_method
+        puts 'Choose Rust. Choose speed.'.colorize(:green)
+      end
+
+      # set chosen method permanently
+      rusby_replace_method(method_name, resulting_method)
+    end
+
+    # module callbacks
+    def method_added(method_name)
+      super
+
+      if @rusby_skips_method
+        @rusby_skips_method = false
+        return
+      end
+
+      @rusby_method_table ||= {}
+      @rusby_method_table[method_name] = {}
+
+      if @rusby_awaits_method
+        @rusby_awaits_method = false
+        @rusby_method_table[method_name][:exposed] = true
+      end
+
+      original_method = instance_method(method_name)
+      new_method = lambda do |*args|
+        self.class.rusby_method_proxy(
+          self,
+          method_name,
+          original_method,
+          args
+        )
+      end
+      rusby_replace_method(method_name, new_method)
+    end
+
+    def singleton_method_added(method_name)
+      # TODO
+    end
+  end
+end

data/lib/rusby/ffi/bridge.rb

@@ -0,0 +1,42 @@
+module Rusby
+  module FFI
+    class Bridge
+      def self.parameterize(string)
+        string.gsub(/\W/, '_').gsub(/_{2,}/, '_').downcase
+      end
+
+      def to_ffi(name, value)
+        method_name = self.class.parameterize(name + '_to_ffi')
+        send(method_name, value)
+      end
+
+      def from_ffi(name, value)
+        method_name = self.class.parameterize(name + '_from_ffi')
+        send(method_name, value)
+      end
+
+      def array_fixnum_to_ffi(arg)
+        pointer = ::FFI::MemoryPointer.new :int, arg.size
+        pointer.put_array_of_int 0, arg
+        @size = arg.size
+        [pointer, arg.size]
+      end
+
+      def array_float_to_ffi(arg)
+        pointer = ::FFI::MemoryPointer.new :double, arg.size
+        pointer.put_array_of_double 0, arg
+        @size = arg.size
+        [pointer, arg.size]
+      end
+
+      def array_float_from_ffi(result)
+        result.read_array_of_double(@size)
+      end
+
+      # for arguments which don't need convertion
+      def method_missing(_method_name, *args)
+        args.first
+      end
+    end
+  end
+end

data/lib/rusby/generators/assignments.rb

@@ -0,0 +1,40 @@
+module Rusby
+  module Generators
+    module Assignments
+      def generate_lvasgn(ast)
+        variable = ast.children[0]
+        return variable if ast.children.size == 1
+
+        result = "#{variable} = #{generate(ast.children[1])};"
+        result = "let mut #{result}" unless known_variable?(variable)
+        remember_variable(variable)
+
+        result
+      end
+
+      def generate_lvar(ast)
+        variable = ast.children[0]
+        variable
+      end
+
+      def generate_masgn(ast)
+        left = ast.children[0].children
+        right = ast.children[1].children
+
+        result = []
+        result += right.each_with_index.map do |_statement, i|
+          "let lv#{i} = #{generate(right[i])};"
+        end
+        result += left.each_with_index.map do |statement, i|
+          statement = generate(statement)
+          "#{statement =~ /=$/ ? statement : "#{statement} = "}lv#{i};"
+        end
+        result.join("\n")
+      end
+
+      def generate_op_asgn(ast)
+        "#{generate(ast.children[0])} #{ast.children[1]}= #{generate(ast.children[2])}"
+      end
+    end
+  end
+end

data/lib/rusby/generators/base.rb

@@ -0,0 +1,66 @@
+module Rusby
+  module Generators
+    module Base
+      def generate(ast)
+        unless ast.respond_to?(:type)
+          # ok, it's not ast node, but it could be a method
+          # redefine internal ruby methods as needed
+          return case ast
+                 when :<< || :>>
+                   ast
+                 when :length
+                   '.len()'
+                 when :min
+                   '.iter().min()'
+                 else
+                   ast.to_s
+                end
+        end
+        send("generate_#{ast.type.to_s.tr('-', '_')}", ast)
+      end
+
+      def generate_send(ast)
+        if ast.children[0]
+          fold_arrays(ast.children).join
+        else
+          verb = ast.children[1]
+          case verb
+          when :puts
+            "\nprintln!(\"{}\", #{generate(ast.children[2])});io::stdout().flush().unwrap();\n"
+          # argument of this ruby method is rust code "as is"
+          when :rust
+            ast.children[2].children[0] + ' // generated by Rusby::Preprocessor'
+          # mark variabale as already defined
+          when :rust_variable
+            remember_variable(ast.children[2].children[0])
+            nil
+          else
+            return verb if known_variable?(verb)
+
+            arguments = fold_arrays(ast.children[2..-1])
+            result = "#{verb}(#{arguments.join(', ')});"
+            result = 'internal_method_' + result unless known_method?(ast.children[1])
+            result
+          end
+        end
+      end
+
+      def generate_block(ast)
+        block_operator = ast.children[0].children[1]
+        case block_operator
+        when :loop
+          generate_loop(ast)
+        when :each
+          generate_each_loop(ast)
+        when :each_with_index
+          generate_each_with_index_loop(ast)
+        when :rust
+          ast.children[1..-1].to_s
+        else
+          statements = ast.children[1..-1].map { |node| generate(node) }.compact
+          "#{ast.children[0].children[1]} {\n#{statements.join("\n")}\n}"
+        end
+      end
+    end
+  end
+end

data/lib/rusby/generators/conditionals.rb

@@ -0,0 +1,38 @@
+module Rusby
+  module Generators
+    module Conditionals
+      def generate_if(ast)
+        result = if ast.children[1]
+                   generate_regular_if(ast)
+                 else
+                   generate_unless(ast)
+        end
+        result.gsub(/^\s+/, '')
+      end
+
+      def generate_unless(ast)
+        result = <<-EOF
+          if !(#{generate(ast.children[0])}) {
+            #{generate(ast.children[2])}
+          }
+        EOF
+      end
+
+      def generate_regular_if(ast)
+        result = <<-EOF
+          if #{generate(ast.children[0])} {
+            #{generate(ast.children[1])}
+          }
+        EOF
+        if ast.children[2]
+          result += <<-EOF
+            else {
+              #{generate(ast.children[2])}
+            }
+          EOF
+        end
+        result
+      end
+    end
+  end
+end