rubyduino 0.1.1

data/vendor/spinel/benchmark/bm_linked_list.rb

@@ -0,0 +1,75 @@
+class LNode
+  attr_accessor :val, :nxt
+  def initialize(val)
+    @val = val
+    @nxt = nil
+    @tag = "ln"
+  end
+end
+
+def list_push(head, val)
+  node = LNode.new(val)
+  node.nxt = head
+  node
+end
+
+def list_length(head)
+  n = 0
+  cur = head
+  while cur != nil
+    n = n + 1
+    cur = cur.nxt
+  end
+  n
+end
+
+def list_reverse(head)
+  prev = nil
+  cur = head
+  while cur != nil
+    nxt = cur.nxt
+    cur.nxt = prev
+    prev = cur
+    cur = nxt
+  end
+  prev
+end
+
+def list_sum(head)
+  s = 0
+  cur = head
+  while cur != nil
+    s = s + cur.val
+    cur = cur.nxt
+  end
+  s
+end
+
+# Build list of 100000 elements
+head = nil
+i = 0
+while i < 100000
+  head = list_push(head, i)
+  i = i + 1
+end
+puts list_length(head)
+puts list_sum(head)
+
+# Reverse and sum
+head = list_reverse(head)
+puts list_sum(head)
+
+# Rebuild + reverse 10 times
+j = 0
+while j < 10
+  head = nil
+  i = 0
+  while i < 100000
+    head = list_push(head, i)
+    i = i + 1
+  end
+  head = list_reverse(head)
+  j = j + 1
+end
+puts list_length(head)
+puts "done"

data/vendor/spinel/benchmark/bm_loops_times.rb

@@ -0,0 +1,16 @@
+# yjit-bench: loops-times - Integer#times performance
+# Ported from https://github.com/Shopify/yjit-bench
+
+u = 5
+r = 7
+a = Array.new(10000, 0)
+
+4000.times do |i|
+  4000.times do |j|
+    a[i] = a[i] + j % u
+  end
+  a[i] = a[i] + r
+end
+
+result = a[r]
+puts result

data/vendor/spinel/benchmark/bm_mandel_term.rb

@@ -0,0 +1,34 @@
+def mandelbrot(c_r, c_i)
+  limit=95
+  iterations=0
+  cr = (c_r * 100).to_i
+  ci = (c_i * 100).to_i
+  zr = zi = 0
+  # Avoid sqrt by squaring the threshold: sqrt(x) < 1000 => x < 1000000
+  while iterations<limit
+    zr2 = zr*zr
+    zi2 = zi*zi
+    break if zr2+zi2 >= 1000000
+    zr, zi = (zr2-zi2)/100+cr, (zr*zi*2)/100+ci
+    iterations+=1
+  end
+  return iterations
+end
+
+def mandel_calc(min_r, min_i, max_r, max_i, res)
+  cur_i = min_i
+  while cur_i > max_i
+    putc "|"
+    cur_r = min_r
+    while cur_r < max_r
+      ch = 127 - mandelbrot(cur_r, cur_i)
+      putc ch  # Use putc with integer - no string allocation!
+      cur_r += res
+    end
+    putc "|"
+    putc "\n"
+    cur_i -= res
+  end
+end
+
+mandel_calc(-2, 1, 1, -1, 0.04)

data/vendor/spinel/benchmark/bm_matmul.rb

@@ -0,0 +1,42 @@
+def matgen(n)
+  a = Array.new(n * n, 0.0)
+  i = 0
+  while i < n
+    j = 0
+    while j < n
+      a[i * n + j] = (1.0 / n / n) * (i - j) * (i + j)
+      j = j + 1
+    end
+    i = i + 1
+  end
+  a
+end
+
+def matmul(a, b, n)
+  c = Array.new(n * n, 0.0)
+  i = 0
+  while i < n
+    k = 0
+    while k < n
+      aik = a[i * n + k]
+      j = 0
+      while j < n
+        c[i * n + j] = c[i * n + j] + aik * b[k * n + j]
+        j = j + 1
+      end
+      k = k + 1
+    end
+    i = i + 1
+  end
+  c
+end
+
+n = 150
+a = matgen(n)
+b = matgen(n)
+c = matmul(a, b, n)
+
+# Print checksum (integer part of first and last elements)
+puts (c[0] * 1000000).to_i
+puts (c[n * n - 1] * 1000000).to_i
+puts "done"

data/vendor/spinel/benchmark/bm_nbody.rb

@@ -0,0 +1,115 @@
+# N-Body with object array
+SOLAR_MASS = 39.47841760435743
+DAYS_PER_YEAR = 365.24
+
+class Planet
+  attr_accessor :x, :y, :z, :vx, :vy, :vz, :mass
+  def initialize(x, y, z, vx, vy, vz, mass)
+    @x = x
+    @y = y
+    @z = z
+    @vx = vx
+    @vy = vy
+    @vz = vz
+    @mass = mass
+  end
+end
+
+bodies = []
+bodies.push(Planet.new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, SOLAR_MASS))
+bodies.push(Planet.new(
+  4.84143144246472090e+00, -1.16032004402742839e+00, -1.03622044471123109e-01,
+  1.66007664274403694e-03 * DAYS_PER_YEAR, 7.69901118419740425e-03 * DAYS_PER_YEAR,
+  -6.90460016972063023e-05 * DAYS_PER_YEAR, 9.54791938424326609e-04 * SOLAR_MASS))
+bodies.push(Planet.new(
+  8.34336671824457987e+00, 4.12479856412430479e+00, -4.03523417114321381e-01,
+  -2.76742510726862411e-03 * DAYS_PER_YEAR, 4.99852801234917238e-03 * DAYS_PER_YEAR,
+  2.30417297573763929e-05 * DAYS_PER_YEAR, 2.85885980666130812e-04 * SOLAR_MASS))
+bodies.push(Planet.new(
+  1.28943695621391310e+01, -1.51111514016986312e+01, -2.23307578892655734e-01,
+  2.96460137564761618e-03 * DAYS_PER_YEAR, 2.37847173959480950e-03 * DAYS_PER_YEAR,
+  -2.96589568540237556e-05 * DAYS_PER_YEAR, 4.36624404335156298e-05 * SOLAR_MASS))
+bodies.push(Planet.new(
+  1.53796971148509165e+01, -2.59193146099879641e+01, 1.79258772950371181e-01,
+  2.68067772490389322e-03 * DAYS_PER_YEAR, 1.62824170038242295e-03 * DAYS_PER_YEAR,
+  -9.51592254519715870e-05 * DAYS_PER_YEAR, 5.15138902046611451e-05 * SOLAR_MASS))
+
+nbodies = bodies.length
+
+# offset momentum
+px = 0.0
+py = 0.0
+pz = 0.0
+i = 0
+while i < nbodies
+  b = bodies[i]
+  px = px + b.vx * b.mass
+  py = py + b.vy * b.mass
+  pz = pz + b.vz * b.mass
+  i = i + 1
+end
+b0 = bodies[0]
+b0.vx = 0.0 - px / SOLAR_MASS
+b0.vy = 0.0 - py / SOLAR_MASS
+b0.vz = 0.0 - pz / SOLAR_MASS
+
+def energy(bodies, nbodies)
+  e = 0.0
+  i = 0
+  while i < nbodies
+    b = bodies[i]
+    e = e + 0.5 * b.mass * (b.vx * b.vx + b.vy * b.vy + b.vz * b.vz)
+    j = i + 1
+    while j < nbodies
+      b2 = bodies[j]
+      dx = b.x - b2.x
+      dy = b.y - b2.y
+      dz = b.z - b2.z
+      dist = Math.sqrt(dx * dx + dy * dy + dz * dz)
+      e = e - (b.mass * b2.mass) / dist
+      j = j + 1
+    end
+    i = i + 1
+  end
+  e
+end
+
+def advance(bodies, nbodies, dt)
+  i = 0
+  while i < nbodies
+    b = bodies[i]
+    j = i + 1
+    while j < nbodies
+      b2 = bodies[j]
+      dx = b.x - b2.x
+      dy = b.y - b2.y
+      dz = b.z - b2.z
+      dsq = dx * dx + dy * dy + dz * dz
+      dist = Math.sqrt(dsq)
+      mag = dt / (dsq * dist)
+      b.vx = b.vx - dx * b2.mass * mag
+      b.vy = b.vy - dy * b2.mass * mag
+      b.vz = b.vz - dz * b2.mass * mag
+      b2.vx = b2.vx + dx * b.mass * mag
+      b2.vy = b2.vy + dy * b.mass * mag
+      b2.vz = b2.vz + dz * b.mass * mag
+      j = j + 1
+    end
+    b.x = b.x + dt * b.vx
+    b.y = b.y + dt * b.vy
+    b.z = b.z + dt * b.vz
+    i = i + 1
+  end
+end
+
+n = Integer(ARGV[0] || 1000)
+
+puts (energy(bodies, nbodies) * 1000000000).to_i
+
+i = 0
+while i < n
+  advance(bodies, nbodies, 0.01)
+  i = i + 1
+end
+
+puts (energy(bodies, nbodies) * 1000000000).to_i

data/vendor/spinel/benchmark/bm_nested_loop.rb

@@ -0,0 +1,29 @@
+n = 16
+x = 0
+a = 0
+while a < n
+  b = 0
+  while b < n
+    c = 0
+    while c < n
+      d = 0
+      while d < n
+        e = 0
+        while e < n
+          f = 0
+          while f < n
+            x = x + 1
+            f = f + 1
+          end
+          e = e + 1
+        end
+        d = d + 1
+      end
+      c = c + 1
+    end
+    b = b + 1
+  end
+  a = a + 1
+end
+puts x
+puts "done"

data/vendor/spinel/benchmark/bm_nqueens.rb

@@ -0,0 +1,46 @@
+# N-Queens solver benchmark (from yjit-bench)
+
+def nq_solve(n)
+  a = Array.new(n, -1)
+  l = Array.new(n, 0)
+  c = Array.new(n, 0)
+  r = Array.new(n, 0)
+  y0 = (1 << n) - 1
+  m = 0
+  k = 0
+
+  while k >= 0
+    y = (l[k] | c[k] | r[k]) & y0
+    if (y ^ y0) >> (a[k] + 1) != 0
+      i = a[k] + 1
+      while i < n && (y & 1 << i) != 0
+        i = i + 1
+      end
+      if k < n - 1
+        z = 1 << i
+        a[k] = i
+        k = k + 1
+        l[k] = (l[k - 1] | z) << 1
+        c[k] = c[k - 1] | z
+        r[k] = (r[k - 1] | z) >> 1
+      else
+        m = m + 1
+        k = k - 1
+      end
+    else
+      a[k] = -1
+      k = k - 1
+    end
+  end
+
+  m
+end
+
+total = 0
+n = 0
+while n < 10
+  total = total + nq_solve(10)
+  n = n + 1
+end
+puts total
+puts "done"

data/vendor/spinel/benchmark/bm_object_new.rb

@@ -0,0 +1,21 @@
+# yjit-bench: object-new - object allocation performance
+# Ported from https://github.com/Shopify/yjit-bench
+
+class SimpleObj
+  def initialize
+    @x = 0
+  end
+
+  def x
+    @x
+  end
+end
+
+sum = 0
+i = 0
+while i < 1000000
+  obj = SimpleObj.new
+  sum = sum + obj.x
+  i = i + 1
+end
+puts sum

data/vendor/spinel/benchmark/bm_object_new_init.rb

@@ -0,0 +1,21 @@
+# object-new-initialize benchmark (from yjit-bench)
+class C
+  def initialize(a, b, c, d)
+    @a = a
+    @b = b
+    @c = c
+    @d = d
+    @e = "c"
+  end
+end
+
+def test
+  C.new(1, 2, 3, 4)
+end
+
+i = 0
+while i < 1000000
+  test
+  i = i + 1
+end
+puts "done"

data/vendor/spinel/benchmark/bm_object_new_no_escape.rb

@@ -0,0 +1,28 @@
+# object-new-no-escape benchmark (from yjit-bench)
+
+class Point
+  attr_reader :x, :y
+  def initialize(x, y)
+    @x = x
+    @y = y
+  end
+end
+
+def test
+  a = Point.new(1, 2)
+  b = Point.new(1, 2)
+  if a.x == b.x && a.y == b.y
+    1
+  else
+    0
+  end
+end
+
+total = 0
+i = 0
+while i < 1000000
+  total = total + test
+  i = i + 1
+end
+puts total
+puts "done"

data/vendor/spinel/benchmark/bm_partial_sums.rb

@@ -0,0 +1,38 @@
+n = 2500000
+
+alt = 1.0
+s0 = 0.0
+s1 = 0.0
+s2 = 0.0
+s3 = 0.0
+s4 = 0.0
+s5 = 0.0
+s6 = 0.0
+s7 = 0.0
+s8 = 0.0
+
+d_int = 1
+while d_int <= n
+  d = d_int.to_f
+  d2 = d * d
+  d3 = d2 * d
+  ds = Math.sin(d)
+  dc = Math.cos(d)
+
+  s0 = s0 + (2.0 / 3.0) ** (d - 1.0)
+  s1 = s1 + 1.0 / Math.sqrt(d)
+  s2 = s2 + 1.0 / (d * (d + 1.0))
+  s3 = s3 + 1.0 / (d3 * ds * ds)
+  s4 = s4 + 1.0 / (d3 * dc * dc)
+  s5 = s5 + 1.0 / d
+  s6 = s6 + 1.0 / d2
+  s7 = s7 + alt / d
+  s8 = s8 + alt / (2.0 * d - 1.0)
+
+  alt = 0.0 - alt
+  d_int = d_int + 1
+end
+
+puts (s0 * 1000000000).to_i
+puts (s8 * 1000000000).to_i
+puts "done"

data/vendor/spinel/benchmark/bm_pidigits.rb

@@ -0,0 +1,31 @@
+# Pidigits - extract digits of pi using Gosper's series
+# Tests bigint arithmetic (auto-promoted from loop multiplication)
+
+n = Integer(ARGV[0] || 27)
+q = 1
+r = 0
+t = 1
+k = 0
+i = 0
+result = ""
+while i < n
+  k = k + 1
+  b = 2 * k + 1
+  nq = q * k
+  nr = (2 * q + r) * b
+  nt = t * b
+  q = nq
+  r = nr
+  t = nt
+  while (q * 3 + r) / t == (q * 4 + r) / t
+    d = (q * 3 + r) / t
+    result = result + d.to_s
+    r = 10 * (r - d * t)
+    q = q * 10
+    i = i + 1
+    if i >= n
+      break
+    end
+  end
+end
+puts result

data/vendor/spinel/benchmark/bm_rbtree.rb

@@ -0,0 +1,100 @@
+class RBNode
+  attr_accessor :key, :left, :right, :red
+  def initialize(key)
+    @key = key
+    @left = nil
+    @right = nil
+    @red = 1
+    @tag = "rb"
+  end
+end
+
+def is_red(node)
+  if node.nil?
+    return 0
+  end
+  node.red
+end
+
+def rotate_left(h)
+  x = h.right
+  h.right = x.left
+  x.left = h
+  x.red = h.red
+  h.red = 1
+  x
+end
+
+def rotate_right(h)
+  x = h.left
+  h.left = x.right
+  x.right = h
+  x.red = h.red
+  h.red = 1
+  x
+end
+
+def flip_colors(h)
+  h.red = 1
+  h.left.red = 0
+  h.right.red = 0
+end
+
+def insert_node(h, key)
+  if h.nil?
+    return RBNode.new(key)
+  end
+  if key < h.key
+    h.left = insert_node(h.left, key)
+  elsif key > h.key
+    h.right = insert_node(h.right, key)
+  end
+  if is_red(h.right) == 1 && is_red(h.left) == 0
+    h = rotate_left(h)
+  end
+  if is_red(h.left) == 1
+    if h.left != nil && is_red(h.left.left) == 1
+      h = rotate_right(h)
+    end
+  end
+  if is_red(h.left) == 1 && is_red(h.right) == 1
+    flip_colors(h)
+  end
+  h
+end
+
+def count_nodes(h)
+  if h.nil?
+    return 0
+  end
+  1 + count_nodes(h.left) + count_nodes(h.right)
+end
+
+# Use typed initial assignment
+root = RBNode.new(0)
+root = nil
+i = 0
+while i < 10000
+  key = (i * 7919 + 1) % 100000
+  root = insert_node(root, key)
+  i = i + 1
+end
+root.red = 0
+
+puts count_nodes(root)
+
+# Rebuild 10 times
+j = 0
+while j < 10
+  root = nil
+  i = 0
+  while i < 10000
+    key = (i * 7919 + j) % 100000
+    root = insert_node(root, key)
+    i = i + 1
+  end
+  root.red = 0
+  j = j + 1
+end
+puts count_nodes(root)
+puts "done"

data/vendor/spinel/benchmark/bm_ruby_xor.rb

@@ -0,0 +1,28 @@
+# Adapted from yjit-bench ruby-xor
+# XOR two strings byte-by-byte
+
+def xor_strings(a, b)
+  len = a.bytesize
+  result = a.dup
+  i = 0
+  while i < len
+    result.setbyte(i, a.getbyte(i) ^ b.getbyte(i))
+    i = i.succ
+  end
+  result
+end
+
+a = "abcdefghijklmnop" * 100
+b = "qrstuvwxyz012345" * 100
+
+n = 10000
+i = 0
+while i < n
+  xor_strings(a, b)
+  i += 1
+end
+
+result = xor_strings(a, b)
+puts result.bytesize
+puts result.getbyte(0)
+puts result.getbyte(1)

data/vendor/spinel/benchmark/bm_send_bmethod.rb

@@ -0,0 +1,31 @@
+# send_bmethod benchmark (from yjit-bench)
+# define_method with static block → compiled as def
+
+define_method(:zero) { 0 }
+define_method(:one) { |arg| arg }
+
+total = 0
+n = 0
+while n < 500000
+  zero
+  total = total + one(123)
+  zero
+  total = total + one(123)
+  zero
+  total = total + one(123)
+  zero
+  total = total + one(123)
+  zero
+  total = total + one(123)
+  zero
+  total = total + one(123)
+  zero
+  total = total + one(123)
+  zero
+  total = total + one(123)
+  zero
+  total = total + one(123)
+  n = n + 1
+end
+puts total
+puts "done"

data/vendor/spinel/benchmark/bm_send_cfunc_block.rb

@@ -0,0 +1,18 @@
+# send_cfunc_block benchmark (from yjit-bench)
+arr = Array.new
+
+i = 0
+while i < 5000000
+  arr.each { 0 }
+  arr.each { 0 }
+  arr.each { 0 }
+  arr.each { 0 }
+  arr.each { 0 }
+  arr.each { 0 }
+  arr.each { 0 }
+  arr.each { 0 }
+  arr.each { 0 }
+  arr.each { 0 }
+  i = i + 1
+end
+puts "done"

data/vendor/spinel/benchmark/bm_send_rubyfunc_block.rb

@@ -0,0 +1,23 @@
+# send_rubyfunc_block benchmark (from yjit-bench)
+
+class C
+  def ruby_func
+    0
+  end
+end
+
+obj = C.new
+i = 0
+while i < 5000000
+  obj.ruby_func
+  obj.ruby_func
+  obj.ruby_func
+  obj.ruby_func
+  obj.ruby_func
+  obj.ruby_func
+  obj.ruby_func
+  obj.ruby_func
+  obj.ruby_func
+  i = i + 1
+end
+puts "done"