rubyduino 0.1.1

data/vendor/spinel/benchmark/bm_gcbench.rb

@@ -0,0 +1,73 @@
+# GCBench (from yjit-bench) - binary tree construction benchmark
+
+class Node
+  attr_accessor :left, :right, :i, :j
+  def initialize
+    @left = nil
+    @right = nil
+    @i = 0
+    @j = 0
+    @tag = "n"
+  end
+end
+
+STRETCH_DEPTH = 18
+LONG_LIVED_DEPTH = 16
+MIN_DEPTH = 4
+MAX_DEPTH = 16
+
+def tree_size(depth)
+  (1 << (depth + 1)) - 1
+end
+
+def num_iters(depth)
+  2 * tree_size(STRETCH_DEPTH) / tree_size(depth)
+end
+
+def populate(depth, node)
+  if depth > 0
+    node.left = Node.new
+    node.right = Node.new
+    populate(depth - 1, node.left)
+    populate(depth - 1, node.right)
+  end
+end
+
+def make_tree(depth)
+  if depth <= 0
+    Node.new
+  else
+    n = Node.new
+    n.left = make_tree(depth - 1)
+    n.right = make_tree(depth - 1)
+    n
+  end
+end
+
+def time_construction(depth)
+  n = num_iters(depth)
+  i = 0
+  while i < n
+    node = Node.new
+    populate(depth, node)
+    i = i + 1
+  end
+  i = 0
+  while i < n
+    make_tree(depth)
+    i = i + 1
+  end
+end
+
+make_tree(STRETCH_DEPTH)
+
+long_lived = Node.new
+populate(LONG_LIVED_DEPTH, long_lived)
+
+depth = MIN_DEPTH
+while depth <= MAX_DEPTH
+  time_construction(depth)
+  depth = depth + 2
+end
+
+puts "done"

data/vendor/spinel/benchmark/bm_getivar.rb

@@ -0,0 +1,34 @@
+# yjit-bench: getivar - instance variable read performance
+# Ported from https://github.com/Shopify/yjit-bench
+
+class TheClass
+  def initialize
+    @v0 = 1
+    @v1 = 2
+    @v2 = 3
+    @levar = 1
+  end
+
+  def get_value_loop
+    sum = 0
+    i = 0
+    while i < 1000000
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      i = i + 1
+    end
+    sum
+  end
+end
+
+obj = TheClass.new
+result = obj.get_value_loop
+puts result

data/vendor/spinel/benchmark/bm_getivar_module.rb

@@ -0,0 +1,34 @@
+# getivar-module benchmark (from yjit-bench)
+# Uses module-level ivar access via class method
+
+module TheModule
+  @levar = 1
+
+  def self.get_value_loop
+    sum = 0
+    i = 0
+    while i < 1000000
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      sum = sum + @levar
+      i = i + 1
+    end
+    sum
+  end
+end
+
+total = 0
+idx = 0
+while idx < 10
+  total = total + TheModule.get_value_loop
+  idx = idx + 1
+end
+puts total
+puts "done"

data/vendor/spinel/benchmark/bm_huffman.rb

@@ -0,0 +1,141 @@
+# Huffman encoding benchmark
+# Counts byte frequencies in a generated text, builds a Huffman tree,
+# generates per-byte codes, and outputs the total encoded bit length.
+# Exercises: nullable self-referential objects (tree), int-indexed arrays,
+# recursive tree walk, and hash-of-codes via fixed-size lookup table.
+
+class Node
+  attr_accessor :ch, :freq, :left, :right
+  def initialize(ch, freq)
+    @ch = ch
+    @freq = freq
+    @left = nil
+    @right = nil
+  end
+end
+
+# Generate a deterministic ~N-byte text from a small alphabet.
+def gen_text(n)
+  letters = "abcdefghijklmnopqrstuvwxyz ,.?!"
+  out = ""
+  seed = 12345
+  i = 0
+  while i < n
+    seed = (seed * 1103515245 + 12345) % 2147483648
+    idx = seed % letters.length
+    out << letters[idx]
+    i = i + 1
+  end
+  out
+end
+
+# Recursive walk: assign code paths to leaves into `codes` (byte -> string).
+def walk(node, path, codes)
+  if node.left == nil && node.right == nil
+    codes[node.ch] = path
+    return
+  end
+  if node.left != nil
+    walk(node.left, path + "0", codes)
+  end
+  if node.right != nil
+    walk(node.right, path + "1", codes)
+  end
+end
+
+n = Integer(ARGV[0] || 200000)
+text = gen_text(n)
+bytes = text.bytes
+
+# Byte frequencies via 256-entry table (alphabet fits in ASCII).
+freq = []
+i = 0
+while i < 256
+  freq.push(0)
+  i = i + 1
+end
+i = 0
+while i < bytes.length
+  bv = bytes[i]
+  freq[bv] = freq[bv] + 1
+  i = i + 1
+end
+
+# Seed the priority queue with one leaf per byte seen.
+queue = []
+i = 0
+while i < 256
+  if freq[i] > 0
+    queue.push(Node.new(i, freq[i]))
+  end
+  i = i + 1
+end
+
+# Build the tree by repeatedly merging the two smallest-freq nodes.
+# Linear-search for the two minima — small alphabet keeps this cheap.
+while queue.length > 1
+  min1 = 0
+  i = 1
+  while i < queue.length
+    if queue[i].freq < queue[min1].freq
+      min1 = i
+    end
+    i = i + 1
+  end
+  min2 = -1
+  i = 0
+  while i < queue.length
+    if i != min1
+      if min2 < 0 || queue[i].freq < queue[min2].freq
+        min2 = i
+      end
+    end
+    i = i + 1
+  end
+  a = queue[min1]
+  b = queue[min2]
+  new_queue = []
+  i = 0
+  while i < queue.length
+    if i != min1 && i != min2
+      new_queue.push(queue[i])
+    end
+    i = i + 1
+  end
+  parent = Node.new(0, a.freq + b.freq)
+  parent.left = a
+  parent.right = b
+  new_queue.push(parent)
+  queue = new_queue
+end
+root = queue[0]
+
+# Code table: 256 slots, one string each.
+codes = []
+i = 0
+while i < 256
+  codes.push("")
+  i = i + 1
+end
+walk(root, "", codes)
+
+# Sum the encoded bit length over the whole text.
+total_bits = 0
+i = 0
+while i < bytes.length
+  total_bits = total_bits + codes[bytes[i]].length
+  i = i + 1
+end
+
+puts total_bits
+
+# Count alphabet size (chars actually used).
+alphabet = 0
+i = 0
+while i < 256
+  if freq[i] > 0
+    alphabet = alphabet + 1
+  end
+  i = i + 1
+end
+puts alphabet

data/vendor/spinel/benchmark/bm_inline.rb

@@ -0,0 +1,68 @@
+# Benchmark: method inlining effect
+# Small methods called in tight loops
+
+class Vec2
+  attr_reader :x, :y
+  def initialize(x, y)
+    @x = x
+    @y = y
+  end
+  def length_sq
+    @x * @x + @y * @y
+  end
+  def dot(other)
+    @x * other.x + @y * other.y
+  end
+end
+
+# Use enough ivars to force pointer type (avoid value type pass-by-copy issue)
+class Counter
+  attr_reader :value, :step, :name, :flag
+  def initialize
+    @value = 0
+    @step = 1
+    @name = "counter"
+    @flag = 0
+  end
+  def increment
+    @value = @value + @step
+  end
+  def double_value
+    @value * 2
+  end
+end
+
+n = 10000000
+
+# Benchmark 1: length_sq in loop (single-expression method, no args)
+sum = 0
+v = Vec2.new(3, 4)
+i = 0
+while i < n
+  sum = sum + v.length_sq
+  i = i + 1
+end
+puts sum  # 25 * 10000000 = 250000000
+
+# Benchmark 2: dot product (single-expression, one arg)
+sum2 = 0
+v1 = Vec2.new(1, 2)
+v2 = Vec2.new(3, 4)
+i = 0
+while i < n
+  sum2 = sum2 + v1.dot(v2)
+  i = i + 1
+end
+puts sum2  # 11 * 10000000 = 110000000
+
+# Benchmark 3: counter increment + getter
+c = Counter.new
+i = 0
+while i < n
+  c.increment
+  i = i + 1
+end
+puts c.value        # 10000000
+puts c.double_value # 20000000
+
+puts "done"

data/vendor/spinel/benchmark/bm_io_wordcount.rb

@@ -0,0 +1,57 @@
+# Line-by-line file processing with File.open block
+# Tests: File.open, each_line, string split, Hash
+
+# Write test data: word frequency file
+words = ["the", "quick", "brown", "fox", "jumps", "over", "lazy", "dog"]
+File.open("/tmp/spinel_io_wf.txt", "w") do |f|
+  i = 0
+  while i < 5000
+    w = words[i % 8]
+    f.puts(w + " " + (i % 100).to_s)
+    i = i + 1
+  end
+end
+
+# Process: count word frequencies
+counts = {}
+File.open("/tmp/spinel_io_wf.txt", "r") do |f|
+  f.each_line do |line|
+    parts = line.strip.split(" ")
+    if parts.length >= 1
+      word = parts[0]
+      if counts.has_key?(word)
+        counts[word] = counts[word] + 1
+      else
+        counts[word] = 1
+      end
+    end
+  end
+end
+
+# Print sorted results
+counts.each do |k, v|
+  puts k + ": " + v.to_s
+end
+
+# Process 20 times for benchmark
+i = 0
+while i < 20
+  c = {}
+  File.open("/tmp/spinel_io_wf.txt", "r") do |f|
+    f.each_line do |line|
+      parts = line.strip.split(" ")
+      if parts.length >= 1
+        w = parts[0]
+        if c.has_key?(w)
+          c[w] = c[w] + 1
+        else
+          c[w] = 1
+        end
+      end
+    end
+  end
+  i = i + 1
+end
+
+File.delete("/tmp/spinel_io_wf.txt")
+puts "done"

data/vendor/spinel/benchmark/bm_json_parse.rb

@@ -0,0 +1,157 @@
+# Minimal JSON parser (numbers, strings, arrays, objects)
+class JSONParser
+  def initialize(input)
+    @input = input
+    @pos = 0
+  end
+
+  def parse
+    skip_ws
+    parse_value
+  end
+
+  def skip_ws
+    while @pos < @input.length
+      c = @input[@pos]
+      if c == " " || c == "\n" || c == "\t" || c == "\r"
+        @pos = @pos + 1
+      else
+        break
+      end
+    end
+  end
+
+  def peek
+    if @pos < @input.length
+      @input[@pos]
+    else
+      ""
+    end
+  end
+
+  def advance
+    c = @input[@pos]
+    @pos = @pos + 1
+    c
+  end
+
+  def parse_value
+    skip_ws
+    c = peek
+    if c == "\""
+      return parse_string
+    end
+    if c == "["
+      return parse_array
+    end
+    if c == "{"
+      return parse_object
+    end
+    if c == "t"
+      @pos = @pos + 4
+      return "true"
+    end
+    if c == "f"
+      @pos = @pos + 5
+      return "false"
+    end
+    if c == "n"
+      @pos = @pos + 4
+      return "null"
+    end
+    parse_number
+  end
+
+  def parse_string
+    advance  # skip "
+    result = ""
+    while peek != "\""
+      result = result + advance
+    end
+    advance  # skip "
+    result
+  end
+
+  def parse_number
+    start = @pos
+    if peek == "-"
+      @pos = @pos + 1
+    end
+    while @pos < @input.length
+      c = @input[@pos]
+      if c >= "0" && c <= "9"
+        @pos = @pos + 1
+      elsif c == "."
+        @pos = @pos + 1
+      else
+        break
+      end
+    end
+    @input[start, @pos - start]
+  end
+
+  def parse_array
+    advance  # skip [
+    items = 0
+    skip_ws
+    if peek != "]"
+      parse_value
+      items = items + 1
+      skip_ws
+      while peek == ","
+        advance
+        parse_value
+        items = items + 1
+        skip_ws
+      end
+    end
+    advance  # skip ]
+    items.to_s
+  end
+
+  def parse_object
+    advance  # skip {
+    keys = 0
+    skip_ws
+    if peek != "}"
+      parse_string
+      skip_ws
+      advance  # skip :
+      parse_value
+      keys = keys + 1
+      skip_ws
+      while peek == ","
+        advance
+        skip_ws
+        parse_string
+        skip_ws
+        advance  # skip :
+        parse_value
+        keys = keys + 1
+        skip_ws
+      end
+    end
+    advance  # skip }
+    keys.to_s
+  end
+end
+
+# Test
+json = '{"name": "spinel", "version": 1, "features": ["aot", "gc", "fiber"], "fast": true}'
+parser = JSONParser.new(json)
+result = parser.parse
+puts result
+
+json2 = '[1, 2, [3, 4, [5]], "hello", null, true, false]'
+parser2 = JSONParser.new(json2)
+result2 = parser2.parse
+puts result2
+
+# Benchmark: parse 10000 times
+i = 0
+while i < 10000
+  p = JSONParser.new(json)
+  p.parse
+  i = i + 1
+end
+puts "done"

data/vendor/spinel/benchmark/bm_keyword_args.rb

@@ -0,0 +1,23 @@
+# Keyword arguments benchmark (from yjit-bench)
+
+def add(left:, right:)
+  left + right
+end
+
+total = 0
+n = 0
+while n < 500000
+  total = total + add(left: 1, right: 0)
+  total = total + add(left: 1, right: 1)
+  total = total + add(left: 1, right: 2)
+  total = total + add(left: 1, right: 3)
+  total = total + add(left: 1, right: 4)
+  total = total + add(left: 1, right: 5)
+  total = total + add(left: 1, right: 6)
+  total = total + add(left: 1, right: 7)
+  total = total + add(left: 1, right: 8)
+  total = total + add(left: 1, right: 9)
+  n = n + 1
+end
+puts total
+puts "done"

data/vendor/spinel/benchmark/bm_life.rb

@@ -0,0 +1,70 @@
+# Conway's Game of Life
+#
+# Rules:
+#   Birth:    dead cell with exactly 3 live neighbors → alive
+#   Survive:  live cell with 2 or 3 live neighbors → alive
+#   Death:    otherwise → dead
+#
+# Uses 1D array (H*W) to represent the grid.
+
+H = 40
+W = 80
+SIZE = H * W
+GENERATIONS = 200
+
+def cell_get(cells, x, y)
+  cells[(y % H) * W + (x % W)]
+end
+
+# Range-with-block idioms (`(-1..1).count { ... }`, `(-1..1).sum { ... }`,
+# `SIZE.times.map { ... }`) aren't implemented in spinel's codegen yet —
+# they emit a deduped warning and a literal 0 at codegen time. Use the
+# Array equivalents so the generation actually runs.
+OFFSETS = [-1, 0, 1]
+
+def neighbors(cells, x, y)
+  OFFSETS.sum { |iy|
+    OFFSETS.count { |ix| cell_get(cells, x + ix, y + iy) == 1 }
+  }
+end
+
+def next_gen(cells)
+  Array.new(SIZE) { |i|
+    y = i / W
+    x = i % W
+    n = neighbors(cells, x, y)
+    if n == 3
+      1
+    elsif n == 4 && cells[i] == 1
+      1
+    else
+      0
+    end
+  }
+end
+
+# Initialize with a deterministic pattern (glider + blinker)
+cells = Array.new(SIZE) { 0 }
+
+# Glider at (1,1)
+cells[1 * W + 2] = 1
+cells[2 * W + 3] = 1
+cells[3 * W + 1] = 1
+cells[3 * W + 2] = 1
+cells[3 * W + 3] = 1
+
+# Blinker at (10,10)
+cells[10 * W + 10] = 1
+cells[10 * W + 11] = 1
+cells[10 * W + 12] = 1
+
+# Run
+gen = 0
+while gen < GENERATIONS
+  cells = next_gen(cells)
+  gen = gen + 1
+end
+
+# Count final live cells
+puts cells.count { _1 == 1 }
+puts "done"