rubyduino 0.1.1

data/vendor/spinel/benchmark/bm_setivar.rb

@@ -0,0 +1,33 @@
+# yjit-bench: setivar - instance variable write performance
+# Ported from https://github.com/Shopify/yjit-bench
+
+class TheClass
+  def initialize
+    @v0 = 1
+    @v1 = 2
+    @v3 = 3
+    @levar = 1
+  end
+
+  def set_value_loop
+    i = 0
+    while i < 1000000
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      i = i + 1
+    end
+    @levar
+  end
+end
+
+obj = TheClass.new
+result = obj.set_value_loop
+puts result

data/vendor/spinel/benchmark/bm_setivar_object.rb

@@ -0,0 +1,33 @@
+# setivar_object benchmark (from yjit-bench)
+
+class TheClass
+  def initialize
+    @v0 = 1
+    @v1 = 2
+    @v3 = 3
+    @levar = 1
+    @tag = "obj"
+  end
+
+  def set_value_loop(val)
+    i = 0
+    while i < 1000000
+      @levar = val
+      @levar = val
+      @levar = val
+      @levar = val
+      @levar = val
+      @levar = val
+      @levar = val
+      @levar = val
+      @levar = val
+      @levar = val
+      i = i + 1
+    end
+    @levar
+  end
+end
+
+tc = TheClass.new
+puts tc.set_value_loop(999)
+puts "done"

data/vendor/spinel/benchmark/bm_setivar_young.rb

@@ -0,0 +1,37 @@
+# setivar_young benchmark (from yjit-bench)
+
+class TheClass
+  def initialize
+    @v0 = 1
+    @v1 = 2
+    @v3 = 3
+    @levar = TheClass.new_inner
+    @tag = "young"
+  end
+
+  def self.new_inner
+    0
+  end
+
+  def set_value_loop
+    i = 0
+    while i < 1000000
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      @levar = i
+      i = i + 1
+    end
+    @levar
+  end
+end
+
+tc = TheClass.new
+puts tc.set_value_loop
+puts "done"

data/vendor/spinel/benchmark/bm_sieve.rb

@@ -0,0 +1,23 @@
+num = 500
+count = 0
+flags0 = Array.new(8192, 1)
+k = 0
+while k < num
+  k = k + 1
+  count = 0
+  flags = Array.new(8192, 1)
+  i = 2
+  while i < 8192
+    i = i + 1
+    if flags[i] == 1
+      j = i * i
+      while j < 8192
+        j = j + i
+        flags[j] = 0
+      end
+      count = count + 1
+    end
+  end
+end
+puts count
+puts "done"

data/vendor/spinel/benchmark/bm_so_lists.rb

@@ -0,0 +1,47 @@
+#from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
+
+NUM = 300
+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

data/vendor/spinel/benchmark/bm_so_mandelbrot.rb

@@ -0,0 +1,65 @@
+#  The Computer Language Benchmarks Game
+#  http://shootout.alioth.debian.org/
+#
+#  contributed by Karl von Laudermann
+#  modified by Jeremy Echols
+#  optimized: while loops instead of for..in to avoid closure overhead
+
+size = 600 # ARGV[0].to_i
+
+puts "P4\n#{size} #{size}"
+
+# Cache constants in local variables to avoid repeated constant lookup
+iter = 49
+limit_squared = 4.0
+
+byte_acc = 0
+bit_num = 0
+
+count_size = size - 1
+
+# Use while loops instead of for..in to avoid closure/upvalue overhead
+y = 0
+while y <= count_size
+  x = 0
+  while x <= count_size
+    zr = 0.0
+    zi = 0.0
+    cr = (2.0*x/size)-1.5
+    ci = (2.0*y/size)-1.0
+    escape = false
+
+    # Use while instead of for..in to avoid closure overhead
+    i = 0
+    while i <= iter
+      tr = zr*zr - zi*zi + cr
+      ti = 2*zr*zi + ci
+      zr = tr
+      zi = ti
+
+      if (zr*zr+zi*zi) > limit_squared
+        escape = true
+        break
+      end
+      i += 1
+    end
+
+    byte_acc = (byte_acc << 1) | (escape ? 0b0 : 0b1)
+    bit_num += 1
+
+    # Code is very similar for these cases, but using separate blocks
+    # ensures we skip the shifting when it's unnecessary, which is most cases.
+    if (bit_num == 8)
+      print byte_acc.chr
+      byte_acc = 0
+      bit_num = 0
+    elsif (x == count_size)
+      byte_acc <<= (8 - bit_num)
+      print byte_acc.chr
+      byte_acc = 0
+      bit_num = 0
+    end
+    x += 1
+  end
+  y += 1
+end

data/vendor/spinel/benchmark/bm_spectral_norm.rb

@@ -0,0 +1,71 @@
+# The Computer Language Benchmarks Game
+# https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
+# Contributed by Sokolov Yura
+# Modified by Chris Houhoulis
+# Adapted for Spinel benchmark
+
+n = Integer(ARGV[0] || 100)
+
+u = Array.new(n, 1.0)
+v = Array.new(n, 0.0)
+
+def eval_a(i, j)
+  1.0 / ((i + j) * (i + j + 1) / 2 + i + 1)
+end
+
+def vector_times_array(n, vector)
+  arr = Array.new(n, 0.0)
+  i = 0
+  while i < n
+    sum = 0.0
+    j = 0
+    while j < n
+      sum = sum + eval_a(i, j) * vector[j]
+      j = j + 1
+    end
+    arr[i] = sum
+    i = i + 1
+  end
+  arr
+end
+
+def vector_times_array_transposed(n, vector)
+  arr = Array.new(n, 0.0)
+  i = 0
+  while i < n
+    sum = 0.0
+    j = 0
+    while j < n
+      sum = sum + eval_a(j, i) * vector[j]
+      j = j + 1
+    end
+    arr[i] = sum
+    i = i + 1
+  end
+  arr
+end
+
+def multiply(n, u)
+  v = vector_times_array(n, u)
+  vector_times_array_transposed(n, v)
+end
+
+k = 0
+while k < 10
+  v = multiply(n, u)
+  u = multiply(n, v)
+  k = k + 1
+end
+
+vbv = 0.0
+vv = 0.0
+i = 0
+while i < n
+  vbv = vbv + u[i] * v[i]
+  vv = vv + v[i] * v[i]
+  i = i + 1
+end
+
+result = Math.sqrt(vbv / vv)
+# Print as integer to avoid float formatting differences
+puts (result * 1000000000).to_i

data/vendor/spinel/benchmark/bm_splay.rb

@@ -0,0 +1,128 @@
+# Splay tree benchmark (from yjit-bench / V8 Octane)
+
+class SplayNode
+  attr_accessor :key, :value, :left, :right
+  def initialize(key, value)
+    @key = key
+    @value = value
+    @left = nil
+    @right = nil
+    @tag = "splay"
+  end
+end
+
+class SplayTree
+  def initialize
+    @root = nil
+    @size = 0
+    @tag = "tree"
+  end
+
+  def empty_p
+    @root.nil?
+  end
+
+  def insert(key, value)
+    if empty_p
+      @root = SplayNode.new(key, value)
+    else
+      splay(key)
+      if @root.key != key
+        node = SplayNode.new(key, value)
+        if key > @root.key
+          node.left = @root
+          node.right = @root.right
+          @root.right = nil
+        else
+          node.right = @root
+          node.left = @root.left
+          @root.left = nil
+        end
+        @root = node
+      end
+    end
+    @size = @size + 1
+  end
+
+  def find(key)
+    if empty_p
+      -1
+    else
+      splay(key)
+      @root.key
+    end
+  end
+
+  def splay(key)
+    dummy = SplayNode.new(0, 0)
+    sl = dummy
+    sr = dummy
+    t = @root
+    while true
+      if key < t.key
+        if t.left.nil?
+          break
+        end
+        if key < t.left.key
+          y = t.left
+          t.left = y.right
+          y.right = t
+          t = y
+          if t.left.nil?
+            break
+          end
+        end
+        sr.left = t
+        sr = t
+        t = t.left
+      elsif key > t.key
+        if t.right.nil?
+          break
+        end
+        if key > t.right.key
+          y = t.right
+          t.right = y.left
+          y.left = t
+          t = y
+          if t.right.nil?
+            break
+          end
+        end
+        sl.right = t
+        sl = t
+        t = t.right
+      else
+        break
+      end
+    end
+    sl.right = t.left
+    sr.left = t.right
+    t.left = dummy.right
+    t.right = dummy.left
+    @root = t
+  end
+end
+
+# Deterministic: insert keys 0..24999 in scrambled order
+tree = SplayTree.new
+idx = 0
+while idx < 25000
+  key = (idx * 7919) % 100000
+  tree.insert(key, idx)
+  idx = idx + 1
+end
+
+# Find known keys
+found = 0
+idx = 0
+while idx < 25000
+  key = (idx * 7919) % 100000
+  result = tree.find(key)
+  if result == key
+    found = found + 1
+  end
+  idx = idx + 1
+end
+
+puts found
+puts "done"

data/vendor/spinel/benchmark/bm_str_concat.rb

@@ -0,0 +1,15 @@
+# yjit-bench: str_concat - string concatenation performance
+# Ported from https://github.com/Shopify/yjit-bench
+
+def concat_test(n, str_to_add)
+  s = ""
+  i = 0
+  while i < n
+    s << str_to_add
+    i = i + 1
+  end
+  s
+end
+
+result = concat_test(10240, "ssssssee")
+puts result.length

data/vendor/spinel/benchmark/bm_structaref.rb

@@ -0,0 +1,25 @@
+# structaref benchmark (from yjit-bench)
+TheClass = Struct.new(:v0, :v1, :v2, :levar)
+
+def get_value_loop(obj)
+  sum = 0
+  i = 0
+  while i < 1000000
+    sum = sum + obj.levar
+    sum = sum + obj.levar
+    sum = sum + obj.levar
+    sum = sum + obj.levar
+    sum = sum + obj.levar
+    sum = sum + obj.levar
+    sum = sum + obj.levar
+    sum = sum + obj.levar
+    sum = sum + obj.levar
+    sum = sum + obj.levar
+    i = i + 1
+  end
+  sum
+end
+
+obj = TheClass.new(1, 2, 3, 1)
+puts get_value_loop(obj)
+puts "done"

data/vendor/spinel/benchmark/bm_structaset.rb

@@ -0,0 +1,24 @@
+# structaset benchmark (from yjit-bench)
+TheClass = Struct.new(:v0, :v1, :v2, :levar)
+
+def set_value_loop(obj)
+  i = 0
+  while i < 1000000
+    obj.levar = i
+    obj.levar = i
+    obj.levar = i
+    obj.levar = i
+    obj.levar = i
+    obj.levar = i
+    obj.levar = i
+    obj.levar = i
+    obj.levar = i
+    obj.levar = i
+    i = i + 1
+  end
+  obj.levar
+end
+
+obj = TheClass.new(1, 2, 3, 1)
+puts set_value_loop(obj)
+puts "done"

data/vendor/spinel/benchmark/bm_sudoku.rb

@@ -0,0 +1,217 @@
+# Sudoku solver benchmark (from yjit-bench)
+# Adapted for Spinel AOT compilation
+# Multi-return encoded: forward returns min * 1000 + min_c
+
+def sd_genmat_mr
+  mr = Array.new(324 * 9, 0)
+  mr_len = Array.new(324, 0)
+  mc = Array.new(729 * 4, 0)
+  r = 0
+  i = 0
+  while i < 9
+    j = 0
+    while j < 9
+      k = 0
+      while k < 9
+        mc[r * 4] = 9 * i + j
+        mc[r * 4 + 1] = (i / 3 * 3 + j / 3) * 9 + k + 81
+        mc[r * 4 + 2] = 9 * i + k + 162
+        mc[r * 4 + 3] = 9 * j + k + 243
+        r = r + 1
+        k = k + 1
+      end
+      j = j + 1
+    end
+    i = i + 1
+  end
+  r2 = 0
+  while r2 < 729
+    c2 = 0
+    while c2 < 4
+      idx = mc[r2 * 4 + c2]
+      mr[idx * 9 + mr_len[idx]] = r2
+      mr_len[idx] = mr_len[idx] + 1
+      c2 = c2 + 1
+    end
+    r2 = r2 + 1
+  end
+  mr
+end
+
+def sd_genmat_mc
+  mc = Array.new(729 * 4, 0)
+  r = 0
+  i = 0
+  while i < 9
+    j = 0
+    while j < 9
+      k = 0
+      while k < 9
+        mc[r * 4] = 9 * i + j
+        mc[r * 4 + 1] = (i / 3 * 3 + j / 3) * 9 + k + 81
+        mc[r * 4 + 2] = 9 * i + k + 162
+        mc[r * 4 + 3] = 9 * j + k + 243
+        r = r + 1
+        k = k + 1
+      end
+      j = j + 1
+    end
+    i = i + 1
+  end
+  mc
+end
+
+# Returns min * 1000 + min_c (encoded pair)
+def sd_update_forward(mr, mc, sr, sc, r)
+  min = 10
+  min_c = 0
+  c2 = 0
+  while c2 < 4
+    idx = mc[r * 4 + c2]
+    sc[idx] = sc[idx] + 128
+    c2 = c2 + 1
+  end
+  c2 = 0
+  while c2 < 4
+    base = mc[r * 4 + c2] * 9
+    r2 = 0
+    while r2 < 9
+      rr = mr[base + r2]
+      sr[rr] = sr[rr] + 1
+      if sr[rr] == 1
+        cc2 = 0
+        while cc2 < 4
+          cc = mc[rr * 4 + cc2]
+          sc[cc] = sc[cc] - 1
+          if sc[cc] < min
+            min = sc[cc]
+            min_c = cc
+          end
+          cc2 = cc2 + 1
+        end
+      end
+      r2 = r2 + 1
+    end
+    c2 = c2 + 1
+  end
+  min * 1000 + min_c
+end
+
+def sd_update_reverse(mr, mc, sr, sc, r)
+  c2 = 0
+  while c2 < 4
+    idx = mc[r * 4 + c2]
+    sc[idx] = sc[idx] - 128
+    c2 = c2 + 1
+  end
+  c2 = 0
+  while c2 < 4
+    base = mc[r * 4 + c2] * 9
+    r2 = 0
+    while r2 < 9
+      rr = mr[base + r2]
+      sr[rr] = sr[rr] - 1
+      if sr[rr] == 0
+        sc[mc[rr * 4]] = sc[mc[rr * 4]] + 1
+        sc[mc[rr * 4 + 1]] = sc[mc[rr * 4 + 1]] + 1
+        sc[mc[rr * 4 + 2]] = sc[mc[rr * 4 + 2]] + 1
+        sc[mc[rr * 4 + 3]] = sc[mc[rr * 4 + 3]] + 1
+      end
+      r2 = r2 + 1
+    end
+    c2 = c2 + 1
+  end
+end
+
+def sd_solve(mr, mc, s)
+  sr = Array.new(729, 0)
+  sc = Array.new(324, 9)
+  hints = 0
+  i = 0
+  while i < 81
+    a = s[i] - 49
+    if a >= 0 && a < 9
+      sd_update_forward(mr, mc, sr, sc, i * 9 + a)
+      hints = hints + 1
+    end
+    i = i + 1
+  end
+
+  cr = Array.new(81, -1)
+  cc = Array.new(81, 0)
+  i = 0
+  min = 10
+  dir = 1
+  count = 0
+
+  while true
+    while i >= 0 && i < 81 - hints
+      if dir == 1
+        if min > 1
+          c = 0
+          while c < 324
+            if sc[c] < min
+              min = sc[c]
+              cc[i] = c
+              if min < 2
+                c = 324
+              end
+            end
+            c = c + 1
+          end
+        end
+        if min == 0 || min == 10
+          cr[i] = -1
+          dir = -1
+          i = i - 1
+          next
+        end
+      end
+
+      c = cc[i]
+      if dir == -1 && cr[i] >= 0
+        sd_update_reverse(mr, mc, sr, sc, mr[c * 9 + cr[i]])
+      end
+
+      r2 = cr[i] + 1
+      while r2 < 9 && sr[mr[c * 9 + r2]] != 0
+        r2 = r2 + 1
+      end
+
+      if r2 < 9
+        encoded = sd_update_forward(mr, mc, sr, sc, mr[c * 9 + r2])
+        min = encoded / 1000
+        cc[i + 1] = encoded - min * 1000
+        cr[i] = r2
+        dir = 1
+        i = i + 1
+      else
+        cr[i] = -1
+        dir = -1
+        i = i - 1
+      end
+    end
+
+    if i < 0
+      break
+    end
+    count = count + 1
+    i = i - 1
+    dir = -1
+  end
+  count
+end
+
+mr = sd_genmat_mr
+mc = sd_genmat_mc
+
+puzzle = [46,46,46,46,46,46,46,46,46,46,46,46,46,46,51,46,56,53,46,46,49,46,50,46,46,46,46,46,46,46,53,46,55,46,46,46,46,46,52,46,46,46,49,46,46,46,57,46,46,46,46,46,46,46,53,46,46,46,46,46,46,55,51,46,46,50,46,49,46,46,46,46,46,46,46,46,52,46,46,46,57]
+
+total = 0
+n = 0
+while n < 100
+  total = total + sd_solve(mr, mc, puzzle)
+  n = n + 1
+end
+puts total
+puts "done"