pbk-15:~/devl/yarv-0.2.0 $ make benchmark
/usr/local/bin/ruby -I. -I. ./rb/aotcompile.rb -I. -I/usr/local/lib/ruby/1.9/powerpc-darwin7.7.0 -I/usr/local/lib/ruby/1.9/powerpc-darwin7.7.0 -I. -DDISPATCH_THREADED_CODE -DDISPATCH_DIRECT_THREADED_CODE -DOPT_BASIC_OPERATIONS -DOPT_REGEXP_MATCH -DOPT_INSNS_UNIFICATION -DOPT_STACK_CACHING -DINLINE_METHOD_CACHE  --srcdir=.
<Insn:getlocal_OP_2_SC_xx_ax (2)>
<Insn:putobject_SC_ax_ab (2)>
<Insn:opt_lt_SC_ab_ax (2)>
<Insn:unless_SC_ax_xx (2)>
<Insn:putobject_OP_INT2FIX_O_1_C__SC_xx_ax (3)>
<Insn:jump_SC_ax_ax (2)>
<Insn:putself_SC_xx_ax (5)>
<Insn:getlocal_OP_2_SC_ax_ab (5)>
<Insn:putobject_OP_INT2FIX_O_1_C__SC_ab_ba (5)>
<Insn:opt_minus_SC_ba_ax (5)>
<Insn:send_OP__WC___WC__Qfalse_0__WC__SC_ax_ax (5)>
<Insn:putself_SC_ax_ab (5)>
<Insn:getlocal_OP_2_SC_ab_ba (5)>
<Insn:putobject_SC_ba_ab (5)>
<Insn:opt_minus_SC_ab_ax (5)>
<Insn:send_OP__WC___WC__Qfalse_0__WC__SC_ax_ax (5)>
<Insn:opt_plus_SC_ax_ax (5)>
<Insn:end_SC_ax_ax (0)>
gcc -fno-common -g -O2 -pipe -fno-common  -I. -I/usr/local/lib/ruby/1.9/powerpc-darwin7.7.0 -I/usr/local/lib/ruby/1.9/powerpc-darwin7.7.0 -I. -DDISPATCH_THREADED_CODE -DDISPATCH_DIRECT_THREADED_CODE -DOPT_BASIC_OPERATIONS -DOPT_REGEXP_MATCH -DOPT_INSNS_UNIFICATION -DOPT_STACK_CACHING -DINLINE_METHOD_CACHE  -c compiled.c
cc -dynamic -bundle -undefined suppress -flat_namespace  -L"/usr/local/lib" -o yarvcore.bundle compile.o compiled.o debug.o disasm.o jitcompile.o vm.o yarvcore.o yarvsubst.o  -ldl -lobjc  
/usr/local/bin/ruby -I. ./benchmark/run.rb
ruby 1.9.0 powerpc-darwin7.7.0(2005-01-12)
YARVCore 0.2.0 rev: 154 (2005-03-04)
[direct threaded code] [optimize basic operation] [optimize regexp match] [stack caching] [inline method cache] 

-----------------------------------------------------------
array: 
i=0
while i<10000000
  i+=1
  a = [1,2,3,4,5,6,7,8,9,10]
end
--
      user     system      total        real
ruby 42.390000   0.100000  42.490000 ( 44.780388)
yarv 13.190000   0.110000  13.300000 ( 13.973322)
-----------------------------------------------------------
block: 
def m
  yield
end

i=0
while i<1000000
  i+=1
  m{
  }
end
--
      user     system      total        real
ruby  3.050000   0.000000   3.050000 (  3.092854)
yarv  0.390000   0.000000   0.390000 (  0.395801)
-----------------------------------------------------------
const: 
Const = 1

i = 0
while i < 10000000
  i+= 1
  j = Const
  k = Const
end
--
      user     system      total        real
ruby 21.900000   0.010000  21.910000 ( 22.295421)
yarv  1.680000   0.000000   1.680000 (  1.707209)
-----------------------------------------------------------
ensure: 
i=0
while i<1000000
  i+=1
  begin
    begin
    ensure
    end
  ensure
  end
end

--
      user     system      total        real
ruby  1.580000   0.000000   1.580000 (  1.627552)
yarv  0.110000   0.000000   0.110000 (  0.109697)
-----------------------------------------------------------
factorial: 
def fact(n)
  if(n > 1)
    n * fact(n-1)
  else
    1
  end
end

fact(7300)
--
      user     system      total        real
ruby	stack level too deep
yarv  0.250000   0.020000   0.270000 (  0.266155)
-----------------------------------------------------------
fib: 
def fib n
  if n < 3
    1
  else
    fib(n-1) + fib(n-2)
  end
end

fib(32)

--
      user     system      total        real
ruby 10.640000   0.020000  10.660000 ( 10.867425)
yarv  1.150000   0.000000   1.150000 (  1.165137)
-----------------------------------------------------------
lists: 
#from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby

NUM = 10
SIZE = 10000

def test_lists()
  # create a list of integers (Li1) from 1 to SIZE
  li1 = (1..SIZE).to_a
  # copy the list to li2 (not by individual items)
  li2 = li1.dup
  # remove each individual item from left side of li2 and
  # append to right side of li3 (preserving order)
  li3 = Array.new
  while (not li2.empty?)
    li3.push(li2.shift)
  end
  # li2 must now be empty
  # remove each individual item from right side of li3 and
  # append to right side of li2 (reversing list)
  while (not li3.empty?)
    li2.push(li3.pop)
  end
  # li3 must now be empty
  # reverse li1 in place
  li1.reverse!
  # check that first item is now SIZE
  if li1[0] != SIZE then
    p "not SIZE"
    0
  else
    # compare li1 and li2 for equality
    if li1 != li2 then
      return(0)
    else
      # return the length of the list
      li1.length
    end
  end
end

i = 0
while i<NUM
  i+=1
  result = test_lists()
end

result
--
      user     system      total        real
ruby  0.470000   0.010000   0.480000 (  0.477611)
yarv  0.210000   0.010000   0.220000 (  0.217372)
-----------------------------------------------------------
method: 
def m
end

i=0
while i<1000000
  i+=1
  m; m; m; m; m; m; m; m; m; m
end
--
      user     system      total        real
ruby  8.820000   0.020000   8.840000 (  9.083102)
yarv  1.750000   0.000000   1.750000 (  1.780617)
-----------------------------------------------------------
poly_method: 
class C1
  def m
    1
  end
end
class C2
  def m
    2
  end
end

o1 = C1.new
o2 = C2.new

i=0
while i< 1000000
  o = (i % 2 == 0) ? o1 : o2
  o.m; o.m; o.m; o.m; o.m; o.m; o.m; o.m; o.m; o.m
  i+=1
end
--
      user     system      total        real
ruby 11.530000   0.000000  11.530000 ( 11.787577)
yarv  2.410000   0.000000   2.410000 (  2.473931)
-----------------------------------------------------------
proc: 
def m &b
  b
end

pr = m{
  a = 1
}

i=0
while i<1000000
  i+=1
  pr.call
end

--
      user     system      total        real
ruby  4.440000   0.020000   4.460000 (  4.626118)
yarv  0.820000   0.010000   0.830000 (  0.835645)
-----------------------------------------------------------
reccount: 
def reccount n
  if n > 1
    1 + reccount(n-1)
  else
    1
  end
end

reccount 7000

--
      user     system      total        real
ruby	stack level too deep
yarv  0.010000   0.000000   0.010000 (  0.004736)
-----------------------------------------------------------
regexp: 
i=0
while i<1000000
  /hoge/ =~ 'xxxhogexxx'
  i+=1
end
--
      user     system      total        real
ruby  2.800000   0.000000   2.800000 (  2.929835)
yarv  1.180000   0.000000   1.180000 (  1.233916)
-----------------------------------------------------------
rescue: 
i=0
while i<10000000
  i+=1
  begin
  rescue
  end
end
--
      user     system      total        real
ruby 18.650000   0.020000  18.670000 ( 19.129190)
yarv  1.330000   0.000000   1.330000 (  1.359620)
-----------------------------------------------------------
rescue2: 
i=0
while i<100000
  i+=1
  begin
    raise
  rescue
  end
end
--
      user     system      total        real
ruby  2.260000   0.210000   2.470000 (  2.587030)
yarv  1.670000   0.210000   1.880000 (  1.970383)
-----------------------------------------------------------
simpleiter: 
1000000.times{|simpleiter|
  simpleiter
}
--
      user     system      total        real
ruby  0.900000   0.000000   0.900000 (  0.942726)
yarv  0.400000   0.000000   0.400000 (  0.429443)
-----------------------------------------------------------
simplereturn: 
def m
  return 1
end
i=0
while i<1000000
  i+=1
  m
end

--
      user     system      total        real
ruby  2.280000   0.000000   2.280000 (  2.306492)
yarv  0.280000   0.000000   0.280000 (  0.277903)
-----------------------------------------------------------
so_ackermann: 
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: ackermann-ruby.code,v 1.4 2004/11/13 07:40:41 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/

def ack(m, n)
    if m == 0 then
        n + 1
    elsif n == 0 then
        ack(m - 1, 1)
    else
        ack(m - 1, ack(m, n - 1))
    end
end

NUM = 7
ack(3, NUM)


--
      user     system      total        real
ruby	stack level too deep
yarv  0.310000   0.000000   0.310000 (  0.310373)
-----------------------------------------------------------
so_array: 
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: ary-ruby.code,v 1.4 2004/11/13 07:41:27 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# with help from Paul Brannan and Mark Hubbart

n = 9000 # Integer(ARGV.shift || 1)

x = Array.new(n)
y = Array.new(n, 0)

n.times{|bi|
  x[bi] = bi + 1
}

(0 .. 999).each do |e|
  (n-1).step(0,-1) do |bi|
    y[bi] += x.at(bi)
  end
end
# puts "#{y.first} #{y.last}"


--
      user     system      total        real
ruby 26.630000   0.050000  26.680000 ( 27.155358)
yarv 10.760000   0.000000  10.760000 ( 10.933831)
-----------------------------------------------------------
so_concatenate: 
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: strcat-ruby.code,v 1.4 2004/11/13 07:43:28 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# based on code from Aristarkh A Zagorodnikov and Dat Nguyen

STUFF = "hello\n"
hello = ''
400000.times do |e|
    hello << STUFF
end
# puts hello.length


--
      user     system      total        real
ruby  0.710000   0.010000   0.720000 (  0.738011)
yarv  0.270000   0.000000   0.270000 (  0.294169)
-----------------------------------------------------------
so_count_words: 
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: wc-ruby.code,v 1.4 2004/11/13 07:43:32 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# with help from Paul Brannan

require 'stringio'

input = StringIO.new
data = File.read($DRIVER_PATH + '/wc.input')

5000.times{|i|
  input.write data
}
input.seek 0

nl = nw = nc = 0
while true
  data = (input.read(4096) or break) << (input.gets || "")

  nc += data.length
  nl += data.count("\n")
  ((data.strip! || data).tr!("\n", " ") || data).squeeze!
  nw += data.count(" ") + 1
end
# puts "#{nl} #{nw} #{nc}"

--
      user     system      total        real
ruby  0.600000   0.190000   0.790000 (  0.919376)
yarv  0.640000   0.150000   0.790000 (  0.810519)
-----------------------------------------------------------
so_exception: 
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: except-ruby.code,v 1.4 2004/11/13 07:41:33 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/

$HI = 0
$LO = 0
NUM = 250000 # Integer(ARGV[0] || 1)


class Lo_Exception < Exception
  def initialize(num)
    @value = num
  end
end

class Hi_Exception < Exception
  def initialize(num)
    @value = num
  end
end

def some_function(num)
  begin
    hi_function(num)
  rescue
    print "We shouldn't get here, exception is: #{$!.type}\n"
  end
end

def hi_function(num)
  begin
    lo_function(num)
  rescue Hi_Exception
    $HI = $HI + 1
  end
end

def lo_function(num)
  begin
    blowup(num)
  rescue Lo_Exception
    $LO = $LO + 1
  end
end

def blowup(num)
  if num % 2 == 0
    raise Lo_Exception.new(num)
  else
    raise Hi_Exception.new(num)
  end
end


i = 1
max = NUM+1
while i < max
  i+=1
  some_function(i+1)
end
--
      user     system      total        real
ruby 10.800000   0.710000  11.510000 ( 12.101493)
yarv  7.520000   0.510000   8.030000 (  9.606575)
-----------------------------------------------------------
so_matrix: 
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: matrix-ruby.code,v 1.4 2004/11/13 07:42:14 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/

n = 60 #Integer(ARGV.shift || 1)

size = 30

def mkmatrix(rows, cols)
    count = 1
    mx = Array.new(rows)
    (0 .. (rows - 1)).each do |bi|
        row = Array.new(cols, 0)
        (0 .. (cols - 1)).each do |j|
            row[j] = count
            count += 1
        end
        mx[bi] = row
    end
    mx
end

def mmult(rows, cols, m1, m2)
    m3 = Array.new(rows)
    (0 .. (rows - 1)).each do |bi|
        row = Array.new(cols, 0)
        (0 .. (cols - 1)).each do |j|
            val = 0
            (0 .. (cols - 1)).each do |k|
                val += m1.at(bi).at(k) * m2.at(k).at(j)
            end
            row[j] = val
        end
        m3[bi] = row
    end
    m3
end

m1 = mkmatrix(size, size)
m2 = mkmatrix(size, size)
mm = Array.new
n.times do
    mm = mmult(size, size, m1, m2)
end
# puts "#{mm[0][0]} #{mm[2][3]} #{mm[3][2]} #{mm[4][4]}"


--
      user     system      total        real
ruby  7.930000   0.060000   7.990000 (  9.536280)
yarv  2.470000   0.030000   2.500000 (  2.811987)
-----------------------------------------------------------
so_nested_loop: 
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: nestedloop-ruby.code,v 1.4 2004/11/13 07:42:22 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# from Avi Bryant

n = 16 # Integer(ARGV.shift || 1)
x = 0
n.times do
    n.times do
        n.times do
            n.times do
                n.times do
                    n.times do
                        x += 1
                    end
                end
            end
        end
    end
end
# puts x


--
      user     system      total        real
ruby 23.880000   0.040000  23.920000 ( 26.016732)
yarv  8.530000   0.080000   8.610000 ( 10.677813)
-----------------------------------------------------------
so_object: 
#!/usr/bin/ruby
# -*- mode: ruby -*-
# $Id: objinst-ruby.code,v 1.4 2004/11/13 07:42:25 bfulgham Exp $
# http://www.bagley.org/~doug/shootout/
# with help from Aristarkh Zagorodnikov

class Toggle
    def initialize(start_state)
        @bool = start_state
    end

    def value
        @bool
    end

    def activate
        @bool = !@bool
        self
    end
end

class NthToggle < Toggle
    def initialize(start_state, max_counter)
        super start_state
        @count_max = max_counter
        @counter = 0
    end

    def activate
        @counter += 1
        if @counter >= @count_max
            @bool = !@bool
            @counter = 0
        end
        self
    end
end

n = 1500000 # (ARGV.shift || 1).to_i

toggle = Toggle.new 1
5.times do
    toggle.activate.value ? 'true' : 'false'
end
n.times do
    toggle = Toggle.new 1
end

ntoggle = NthToggle.new 1, 3
8.times do
    ntoggle.activate.value ? 'true' : 'false'
end
n.times do
    ntoggle = NthToggle.new 1, 3
end

--
      user     system      total        real
ruby 20.150000   0.110000  20.260000 ( 26.968556)
yarv 16.990000   0.050000  17.040000 ( 19.287725)
-----------------------------------------------------------
so_random: 
# from http://www.bagley.org/~doug/shootout/bench/random/random.ruby

IM = 139968
IA = 3877
IC = 29573

$last = 42.0

def gen_random(max)
  (max * ($last = ($last * IA + IC) % IM)) / IM
end

N = 1000000

i=0
while i<N
  i+=1
  gen_random(100.0)
end
# "%.9f" % gen_random(100.0)
--
      user     system      total        real
ruby  8.050000   0.020000   8.070000 (  8.327131)
yarv  3.480000   0.020000   3.500000 (  3.667081)
-----------------------------------------------------------
so_sieve: 
# from http://www.bagley.org/~doug/shootout/bench/sieve/sieve.ruby
num = 100
count = i = j = 0
flags0 = Array.new(8192,1)
k = 0
while k < num
  k+=1
  count = 0
  flags = flags0.dup
  i = 2
  while i<8192
    i+=1
    if flags[i]
      # remove all multiples of prime: i
      j = i*i
      while j < 8192
        j += i
        flags[j] = nil
      end
      count += 1
    end
  end
end
count
--
      user     system      total        real
ruby  6.710000   0.020000   6.730000 (  6.930304)
yarv  0.920000   0.000000   0.920000 (  0.938068)
-----------------------------------------------------------
strconcat: 
i=0
while i<1000000
  "#{1+1} #{1+1} #{1+1}"
  i+=1
end
--
      user     system      total        real
ruby 11.150000   0.040000  11.190000 ( 12.245546)
yarv  8.250000   0.050000   8.300000 (  8.615117)
-----------------------------------------------------------
super: 

class C
  def m
    1
  end
end

class CC < C
  def m
    super()
  end
end

obj = CC.new

i = 0
while i<10000000
  obj.m
  i+=1
end
--
      user     system      total        real
ruby 30.870000   0.020000  30.890000 ( 31.510835)
yarv  6.110000   0.010000   6.120000 (  6.214421)
-----------------------------------------------------------
swap: 
a = 1
b = 2
i=0
while i<10000000
  i+=1
  a, b = b, a
end

--
      user     system      total        real
ruby 30.910000   0.050000  30.960000 ( 32.036917)
yarv  1.510000   0.000000   1.510000 (  1.540928)
-----------------------------------------------------------
tak: 

def tak x, y, z
  unless y < x
    z
  else
    tak( tak(x-1, y, z),
         tak(y-1, z, x),
         tak(z-1, x, y))
  end
end

tak(18, 9, 0)

--
      user     system      total        real
ruby 36.790000   0.120000  36.910000 ( 37.705966)
yarv  4.250000   0.000000   4.250000 (  4.315381)
-----------------------------------------------------------
tarai: 
def tarai( x, y, z )
  if x <= y
  then y
  else tarai(tarai(x-1, y, z),
             tarai(y-1, z, x),
             tarai(z-1, x, y))
  end
end

tarai(12, 6, 0)
--
      user     system      total        real
ruby 29.230000   0.070000  29.300000 ( 34.560779)
yarv  4.550000   0.010000   4.560000 (  5.032957)
-----------------------------------------------------------
times: 
10000000.times{|i|
}
--
      user     system      total        real
ruby  6.010000   0.010000   6.020000 (  6.624082)
yarv  4.240000   0.000000   4.240000 (  4.369249)
-----------------------------------------------------------
unif1: 
i = 0
def m a, b
end

while i<10000000
  i+=1
  m 100, 200
end
--
      user     system      total        real
ruby 26.410000   0.020000  26.430000 ( 27.851872)
yarv  2.920000   0.010000   2.930000 (  3.268114)
-----------------------------------------------------------
whileloop: 
i = 0
while i<10000000
  i+=1
end
--
      user     system      total        real
ruby 15.030000   0.010000  15.040000 ( 15.584783)
yarv  1.100000   0.000000   1.100000 (  1.212492)
-----------------------------------------------------------
zsuper: 
i = 0

class C
  def m a
    1
  end
end

class CC < C
  def m a
    super
  end
end

obj = CC.new

while i<10000000
  obj.m 10
  i+=1
end
--
      user     system      total        real
ruby 33.500000   0.040000  33.540000 ( 41.648908)
yarv  6.170000   0.010000   6.180000 (  7.153734)