ruby-libjit 0.1.0

data/lib/jit/value.rb

@@ -0,0 +1,199 @@
+require 'jit'
+
+module JIT
+  class Value
+    module UNINITIALIZED; end
+
+    # Create a new JIT::Value.  If value is specified, the value will be
+    # variable, otherwise it will be a constant with the given value.
+    #
+    # +function+:: The function to which this value will belong.
+    # +type+::     The type of the new value.
+    # +value+:     The value to use, if this is a constant.
+    #
+    def self.new(function, type, value=UNINITIALIZED)
+      # TODO: Not sure if I like this...
+      if value == UNINITIALIZED then
+        return function.value(type)
+      else
+        return function.const(type, value)
+      end
+    end
+
+    # Assign +value+ to this JIT::Value.
+    #
+    # +value+:: The value to assign.
+    #
+    def store(value)
+      lhs, rhs = coerce(value)
+      self.function.insn_store(lhs, rhs)
+    end
+
+    # Return the address of this value.
+    def address
+      return self.function.insn_address_of(self)
+    end
+
+    # Add this value to another and return the result.
+    #
+    # +rhs+:: The right hand side of the addition operator.
+    #
+    def +(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_add(lhs, rhs)
+    end
+
+    # Subtract another value from this one and return the result.
+    #
+    # +rhs+:: The right hand side of the subtraction operator.
+    #
+    def -(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_sub(lhs, rhs)
+    end
+
+    # Multiply this value by another and return the result.
+    #
+    # +rhs+:: The right hand side of the multiplication operator.
+    #
+    def *(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_mul(lhs, rhs)
+    end
+
+    # Divide this value by another and return the quotient.
+    #
+    # +rhs+:: The right hand side of the division operator.
+    #
+    def /(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_div(lhs, rhs)
+    end
+
+    # Return the additive inverse (negation) of this value.
+    def -@()
+      rhs, lhs = coerce(0) # inverted, since we are subtracting from 0
+      return lhs - rhs
+    end
+
+    # Divide this value by another and return the remainder.
+    #
+    # +rhs+:: The right hand side of the modulus operator.
+    #
+    def %(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_rem(lhs, rhs)
+    end
+
+    # Perform a bitwise and between this value and another.
+    #
+    # +rhs+:: The right hand side of the operator.
+    #
+    def &(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_and(lhs, rhs)
+    end
+
+    # Perform a bitwise or between this value and another.
+    #
+    # +rhs+:: The right hand side of the operator.
+    #
+    def |(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_or(lhs, rhs)
+    end
+
+    # Perform a bitwise xor between this value and another.
+    #
+    # +rhs+:: The right hand side of the operator.
+    #
+    def ^(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_xor(lhs, rhs)
+    end
+
+    # Compare this value to another, returning 1 if the left hand is
+    # less than the right hand side or 0 otherwise.
+    #
+    # +rhs+:: The right hand side of the comparison.
+    #
+    def <(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_lt(lhs, rhs)
+    end
+
+    # Compare this value to another, returning 1 if the left hand is
+    # greater than the right hand side or 0 otherwise.
+    #
+    # +rhs+:: The right hand side of the comparison.
+    #
+    def >(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_gt(lhs, rhs)
+    end
+
+    # Compare this value to another, returning 1 if the left hand is
+    # equal to the right hand side or 0 otherwise.
+    #
+    # +rhs+:: The right hand side of the comparison.
+    #
+    def ==(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_eq(lhs, rhs)
+    end
+
+    # Compare this value to another, returning 1 if the left hand is
+    # not equal to the right hand side or 0 otherwise.
+    #
+    # +rhs+:: The right hand side of the comparison.
+    #
+    def neq(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_ne(lhs, rhs)
+    end
+
+    # Compare this value to another, returning 1 if the left hand is
+    # less than or equal to the right hand side or 0 otherwise.
+    #
+    # +rhs+:: The right hand side of the comparison.
+    #
+    def <=(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_le(lhs, rhs)
+    end
+
+    # Compare this value to another, returning 1 if the left hand is
+    # greater than or equal to the right hand side or 0 otherwise.
+    #
+    # +rhs+:: The right hand side of the comparison.
+    #
+    def >=(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_ge(lhs, rhs)
+    end
+
+    # Shift this value left by the given number of bits.
+    #
+    # +rhs+:: The number of bits to shift by.
+    #
+    def <<(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_shl(lhs, rhs)
+    end
+
+    # Shift this value right by the given number of bits.
+    #
+    # +rhs+:: The number of bits to shift by.
+    #
+    def >>(rhs)
+      lhs, rhs = coerce(rhs)
+      return self.function.insn_shr(lhs, rhs)
+    end
+
+    # Return the logical inverse of this value.
+    def ~()
+      return self.function.insn_not(self)
+    end
+  end
+end
+

data/lib/jit.rb

@@ -0,0 +1,5 @@
+require 'jit.so'
+require 'jit/array'
+require 'jit/function'
+require 'jit/struct'
+require 'jit/value'

data/sample/fib.rb

@@ -0,0 +1,29 @@
+require 'jit'
+
+fib = nil
+signature = JIT::Type.create_signature(
+    JIT::ABI::CDECL,
+    JIT::Type::INT,
+    [ JIT::Type::INT ])
+fib = JIT::Function.build(signature) do |f|
+  n = f.param(0)
+
+  a = f.value(JIT::Type::INT, 0)
+  b = f.value(JIT::Type::INT, 1)
+  c = f.value(JIT::Type::INT, 1)
+
+  i = f.value(JIT::Type::INT, 0)
+
+  f.while(proc { i < n }) {
+    c.store(a + b)
+    a.store(b)
+    b.store(c)
+    i.store(i + 1)
+  }.end
+
+  f.return(c)
+end
+
+values = (0...10).collect { |x| fib.apply(x) }
+p values #=> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+

data/sample/gcd_benchmark.rb

@@ -0,0 +1,117 @@
+require 'jit'
+require 'benchmark'
+
+# GCD, JIT-compiled
+
+jit_gcd = nil
+
+JIT::Context.build do |context|
+  signature = JIT::Type.create_signature(
+      JIT::ABI::CDECL,
+      JIT::Type::INT,
+      [ JIT::Type::INT, JIT::Type::INT ])
+  jit_gcd = JIT::Function.compile(context, signature) do |f|
+    x = f.get_param(0)
+    y = f.get_param(1)
+    temp1 = f.insn_eq(x, y)
+    label1 = JIT::Label.new
+    f.insn_branch_if_not(temp1, label1)
+    f.insn_return(x)
+    f.insn_label(label1)
+    temp2 = f.insn_lt(x, y)
+    label2 = JIT::Label.new
+    f.insn_branch_if_not(temp2, label2)
+    s1 = f.insn_sub(y, x)
+    temp3 = f.insn_call("gcd", f, 0, x, s1)
+    f.insn_return(temp3)
+    f.insn_label(label2)
+    s2 = f.insn_sub(x, y)
+    temp4 = f.insn_call("gcd", f, 0, s2, y)
+    f.insn_return(temp4)
+
+    f.optimization_level = 3
+  end
+end
+
+if jit_gcd.apply(28, 21) != 7 then
+  puts "jit_gcd is broken"
+  exit 1
+end
+
+
+# GCD with tail recursion optimization
+
+jit_gcd_tail = nil
+
+JIT::Context.build do |context|
+  signature = JIT::Type.create_signature(
+      JIT::ABI::CDECL,
+      JIT::Type::INT,
+      [ JIT::Type::INT, JIT::Type::INT ])
+  jit_gcd_tail = JIT::Function.compile(context, signature) do |f|
+    x = f.get_param(0)
+    y = f.get_param(1)
+    temp1 = f.insn_eq(x, y)
+    label1 = JIT::Label.new
+    f.insn_branch_if_not(temp1, label1)
+    f.insn_return(x)
+    f.insn_label(label1)
+    temp2 = f.insn_lt(x, y)
+    label2 = JIT::Label.new
+    f.insn_branch_if_not(temp2, label2)
+    s1 = f.insn_sub(y, x)
+    temp3 = f.insn_call("gcd", f, JIT::Call::TAIL, x, s1)
+    # f.insn_return(temp3)
+    f.insn_label(label2)
+    s2 = f.insn_sub(x, y)
+    temp4 = f.insn_call("gcd", f, JIT::Call::TAIL, s2, x)
+    # f.insn_return(temp4)
+
+    f.optimization_level = 3
+  end
+end
+
+if jit_gcd_tail.apply(28, 21) != 7 then
+  puts "jit_gcd_tail is broken"
+  exit 1
+end
+
+
+# GCD in ruby with recursion
+
+def gcd(x, y)
+  if x == y
+    return x
+  elsif x < y
+    return gcd(x, y - x)
+  else
+    return gcd(x - y, y)
+  end
+end
+
+
+# GCD in ruby without recursion
+
+def gcd2(x, y)
+  while x != y do
+    if x < y
+      y -= x
+    else
+      x -= y
+    end
+  end
+  return x
+end
+
+N = 1000
+
+X = 1000
+Y = 1005
+
+Benchmark.bm(16) do |x|
+  x.report("jit")            { N.times { jit_gcd.apply(X, Y) } }
+  x.report("jit tail:")      { N.times { jit_gcd_tail.apply(X, Y) } }
+  x.report("ruby recur:")    { N.times { gcd(X, Y) } }
+  x.report("ruby iter:")     { N.times { gcd2(X, Y) } }
+end
+

data/sample/simple.rb

@@ -0,0 +1,15 @@
+require 'jit'
+
+function = nil
+JIT::Context.build do |context|
+  signature = JIT::Type.create_signature(
+      JIT::ABI::CDECL,
+      JIT::Type::INT,       # returns an integer
+      [ JIT::Type::INT ])   # and tages an integer as a parameter
+  function = JIT::Function.compile(context, signature) do |f|
+    value = f.get_param(0)
+    f.insn_return(value)
+  end
+end
+
+p function.apply(42) #=> 42

data/test/test_jit_array.rb

@@ -0,0 +1,70 @@
+require 'jit/array'
+require 'jit/function'
+require 'test/unit'
+require 'assertions'
+
+class TestJitArray < Test::Unit::TestCase
+  include JitAssertions
+
+  def test_new_array
+    a_type = JIT::Array.new(JIT::Type::INT, 12)
+    assert_equal JIT::Type::INT, a_type.type
+    assert_equal 12, a_type.length
+  end
+
+  # TODO: wrap
+
+  def test_create
+    p = proc { |f|
+      a_type = JIT::Array.new(JIT::Type::INT, 4)
+      a = a_type.create(f)
+      f.return f.const(JIT::Type::INT, 0)
+    }
+    assert_function_result(
+        :result => [ JIT::Type::INT, 0 ],
+        &p)
+  end
+
+  def test_offset_of
+    a_type = JIT::Array.new(JIT::Type::INT, 4)
+    assert_equal 0, a_type.offset_of(0)
+    assert_equal 4, a_type.offset_of(1)
+    assert_equal 8, a_type.offset_of(2)
+    assert_equal 12, a_type.offset_of(3)
+    # TODO: check out of bounds
+  end
+
+  def test_type_of
+    a_type = JIT::Array.new(JIT::Type::INT, 4)
+    assert_equal JIT::Type::INT, a_type.type_of(0)
+    assert_equal JIT::Type::INT, a_type.type_of(1)
+    assert_equal JIT::Type::INT, a_type.type_of(2)
+    assert_equal JIT::Type::INT, a_type.type_of(3)
+    # TODO: check out of bounds
+  end
+
+  def test_instance_bracket
+    p = proc { |f|
+      a_type = JIT::Array.new(JIT::Type::INT, 4)
+      a = a_type.create(f)
+      f.insn_store_relative(a.ptr, 4, f.const(JIT::Type::INT, 42))
+      f.return a[1]
+    }
+    assert_function_result(
+        :result => [ JIT::Type::INT, 42 ],
+        &p)
+  end
+
+  def test_instance_bracket_eq
+    p = proc { |f|
+      a_type = JIT::Array.new(JIT::Type::INT, 4)
+      a = a_type.create(f)
+      a[1] = f.const(JIT::Type::INT, 42)
+      f.return a[1]
+    }
+    assert_function_result(
+        :result => [ JIT::Type::INT, 42 ],
+        &p)
+  end
+end
+