bench9000 0.1

data/benchmarks/classic/spectral-norm.rb

@@ -0,0 +1,95 @@
+# Copyright © 2004-2013 Brent Fulgham
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#
+#   * Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#
+#   * Neither the name of "The Computer Language Benchmarks Game" nor the name
+#     of "The Computer Language Shootout Benchmarks" nor the names of its
+#     contributors may be used to endorse or promote products derived from this
+#     software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The Computer Language Benchmarks Game
+# http://benchmarksgame.alioth.debian.org
+# Contributed by Sokolov Yura
+
+# http://benchmarksgame.alioth.debian.org/u64q/program.php?test=spectralnorm&lang=yarv&id=1
+
+def eval_A(i,j)
+  return 1.0/((i+j)*(i+j+1)/2+i+1)
+end
+
+def eval_A_times_u(u)
+        v, i = nil, nil
+  (0..u.length-1).collect { |i|
+                v = 0
+    for j in 0..u.length-1
+      v += eval_A(i,j)*u[j]
+                end
+                v
+        }
+end
+
+def eval_At_times_u(u)
+  v, i = nil, nil
+  (0..u.length-1).collect{|i|
+                v = 0
+    for j in 0..u.length-1
+      v += eval_A(j,i)*u[j]
+                end
+                v
+        }
+end
+
+def eval_AtA_times_u(u)
+  return eval_At_times_u(eval_A_times_u(u))
+end
+
+def spectral_norm(n)
+  u=[1]*n
+  for i in 1..10
+          v=eval_AtA_times_u(u)
+          u=eval_AtA_times_u(v)
+  end
+  vBv=0
+  vv=0
+  for i in 0..n-1
+          vBv += u[i]*v[i]
+          vv += v[i]*v[i]
+  end
+
+  Math.sqrt(vBv/vv)
+end
+
+def harness_input
+  400
+end
+
+def harness_sample(input)
+  spectral_norm(input)
+end
+
+def harness_verify(output)
+  (output - 1.2742240813922308).abs < 0.000001
+end
+
+require 'bench9000/harness'

data/benchmarks/default.config.rb

@@ -0,0 +1,206 @@
+# Copyright (c) 2014, 2015 Oracle and/or its affiliates. All rights reserved. This
+# code is released under a tri EPL/GPL/LGPL license. You can use it,
+# redistribute it and/or modify it under the terms of the:
+#
+# Eclipse Public License version 1.0
+# GNU General Public License version 2
+# GNU Lesser General Public License version 2.1
+
+rbenv "1.8.7-p375"
+rbenv "1.9.3-p551"
+rbenv "2.0.0-p647"
+rbenv "2.1.7"
+rbenv "2.2.3"
+rbenv "2.3.0-dev"
+
+rbenv "jruby-9.0.4.0-int", "jruby-9.0.4.0", "-J-Xmx2G -X-C"
+rbenv "jruby-9.0.4.0-noindy", "jruby-9.0.4.0", "-J-Xmx2G -Xcompile.invokedynamic=false"
+rbenv "jruby-9.0.4.0-indy", "jruby-9.0.4.0", "-J-Xmx2G -Xcompile.invokedynamic=true"
+
+rbenv "rbx-2.5.8-int", "rbx-2.5.8", "-Xint"
+rbenv "rbx-2.5.8"
+
+rbenv "topaz-dev"
+
+if ENV.has_key? "JRUBY_DEV_DIR"
+  binary "jruby-dev-int", "#{ENV['JRUBY_DEV_DIR']}/bin/jruby", "-J-Xmx2G -X-C"
+  binary "jruby-dev-noindy", "#{ENV['JRUBY_DEV_DIR']}/bin/jruby", "-J-Xmx2G -Xcompile.invokedynamic=false"
+  binary "jruby-dev-indy", "#{ENV['JRUBY_DEV_DIR']}/bin/jruby", "-J-Xmx2G -Xcompile.invokedynamic=true"
+  binary "jruby-dev-truffle-nograal", "#{ENV['JRUBY_DEV_DIR']}/bin/jruby", "-J-Xmx2G -X+T"
+
+  if ENV.has_key? "GRAAL_BIN"
+    binary "jruby-dev-truffle-graal", "JAVACMD=#{ENV['GRAAL_BIN']} #{ENV['JRUBY_DEV_DIR']}/bin/jruby", "-J-Xmx2G -J-d64 -J-server -J-G:+TruffleCompilationExceptionsAreFatal -X+T"
+  end
+end
+
+if ENV.has_key? "RUBY_BIN" and ENV.has_key? "RUBY_ARGS"
+  binary "custom", ENV['RUBY_BIN'], ENV['RUBY_ARGS']
+end
+
+benchmark "classic-binary-trees", "#{default_benchmarks_dir}/classic/binary-trees.rb"
+benchmark "classic-fannkuch-redux", "#{default_benchmarks_dir}/classic/fannkuch-redux.rb"
+benchmark "classic-mandelbrot", "#{default_benchmarks_dir}/classic/mandelbrot.rb"
+benchmark "classic-n-body", "#{default_benchmarks_dir}/classic/n-body.rb"
+benchmark "classic-pidigits", "#{default_benchmarks_dir}/classic/pidigits.rb"
+benchmark "classic-spectral-norm", "#{default_benchmarks_dir}/classic/spectral-norm.rb"
+benchmark "classic-richards", "#{default_benchmarks_dir}/classic/richards.rb"
+benchmark "classic-deltablue", "#{default_benchmarks_dir}/classic/deltablue.rb"
+benchmark "classic-red-black", "#{default_benchmarks_dir}/classic/red-black.rb"
+benchmark "classic-matrix-multiply", "#{default_benchmarks_dir}/classic/matrix-multiply.rb"
+benchmark "classic-fasta-string", "#{default_benchmarks_dir}/classic/fasta-string.rb"
+
+benchmark_group "classic",
+  "classic-binary-trees",
+  "classic-fannkuch-redux",
+  "classic-mandelbrot",
+  "classic-n-body",
+  "classic-pidigits",
+  "classic-spectral-norm",
+  "classic-richards",
+  "classic-deltablue",
+  "classic-red-black",
+  "classic-matrix-multiply",
+  "classic-fasta-string"
+
+benchmark "topaz-neural-net", "#{default_benchmarks_dir}/topaz/neural-net.rb"
+
+benchmark "octane-deltablue", "#{default_benchmarks_dir}/octane/deltablue.rb"
+
+benchmark_group "octane",
+  "octane-deltablue"
+
+chunky_benchmarks = [
+  "chunky-canvas-resampling-steps-residues",
+  "chunky-canvas-resampling-steps",
+  "chunky-canvas-resampling-nearest-neighbor",
+  "chunky-canvas-resampling-bilinear",
+  "chunky-decode-png-image-pass",
+  "chunky-encode-png-image-pass-to-stream",
+  "chunky-color-compose-quick",
+  "chunky-color-r",
+  "chunky-color-g",
+  "chunky-color-b",
+  "chunky-color-a",
+  "chunky-operations-compose",
+  "chunky-operations-replace"
+]
+
+chunky_benchmarks.each do |b|
+  benchmark b, "#{default_benchmarks_dir}/chunky_png/#{b}.rb", "-I#{default_benchmarks_dir}/../vendor/chunky_png/lib"
+end
+
+benchmark_group "chunky", *chunky_benchmarks
+
+psd_benchmarks = [
+  "psd-imagemode-rgb-combine-rgb-channel",
+  "psd-imagemode-cmyk-combine-cmyk-channel",
+  "psd-imagemode-greyscale-combine-greyscale-channel",
+  "psd-imageformat-rle-decode-rle-channel",
+  "psd-imageformat-layerraw-parse-raw",
+  "psd-color-cmyk-to-rgb",
+  "psd-compose-normal",
+  "psd-compose-darken",
+  "psd-compose-multiply",
+  "psd-compose-color-burn",
+  "psd-compose-linear-burn",
+  "psd-compose-lighten",
+  "psd-compose-screen",
+  "psd-compose-color-dodge",
+  "psd-compose-linear-dodge",
+  "psd-compose-overlay",
+  "psd-compose-soft-light",
+  "psd-compose-hard-light",
+  "psd-compose-vivid-light",
+  "psd-compose-linear-light",
+  "psd-compose-pin-light",
+  "psd-compose-hard-mix",
+  "psd-compose-difference",
+  "psd-compose-exclusion",
+  "psd-renderer-clippingmask-apply",
+  "psd-renderer-mask-apply",
+  "psd-renderer-blender-compose",
+  "psd-util-clamp",
+  "psd-util-pad2",
+  "psd-util-pad4"
+]
+
+psd_benchmarks.each do |b|
+  benchmark b,
+            "#{default_benchmarks_dir}/psd.rb/#{b}.rb",
+            "-I#{default_benchmarks_dir}/psd.rb -I#{default_benchmarks_dir}/../vendor/chunky_png/lib -I#{default_benchmarks_dir}/../vendor/psd.rb/lib"
+end
+
+benchmark_group "psd", *psd_benchmarks
+
+benchmark "graph-connected", "#{default_benchmarks_dir}/graph/connected.rb"
+
+micro_benchmarks = %w[
+  string-equal
+  pack-big-xLX-repeat
+  pack-big-U-loop
+  pack-small-mixture
+]
+
+micro_benchmarks.each do |b|
+  benchmark "micro-#{b}", "#{default_benchmarks_dir}/micro/#{b}.rb"
+end
+
+benchmark_group "micro", *micro_benchmarks.map { |b| "micro-#{b}" }
+
+benchmark "vm-codeload", "#{default_benchmarks_dir}/vm/codeload.rb"
+
+benchmark_group "vm",
+  "vm-codeload"
+
+benchmark "literature-acid", "#{default_benchmarks_dir}/literature/acid.rb"
+
+benchmark_group "literature",
+  "literature-acid"
+
+# Other groups
+
+benchmark_group "3",
+  "classic-mandelbrot",
+  "chunky-color-g",
+  "psd-compose-overlay"
+
+benchmark_group "5",
+  "classic-mandelbrot",
+  "classic-richards",
+  "chunky-color-g",
+  "chunky-operations-compose",
+  "psd-compose-overlay"
+
+benchmark_group "10",
+  "classic-fannkuch-redux",
+  "classic-mandelbrot",
+  "classic-richards",
+  "chunky-canvas-resampling-steps-residues",
+  "chunky-color-g",
+  "chunky-operations-compose",
+  "psd-imageformat-rle-decode-rle-channel",
+  "psd-color-cmyk-to-rgb",
+  "psd-compose-overlay",
+  "psd-util-pad2"
+
+benchmark_group "15",
+  "classic-fannkuch-redux",
+  "classic-mandelbrot",
+  "classic-n-body",
+  "classic-spectral-norm",
+  "classic-richards",
+  "classic-deltablue",
+  "chunky-canvas-resampling-steps-residues",
+  "chunky-color-g",
+  "chunky-operations-compose",
+  "psd-imagemode-rgb-combine-rgb-channel",
+  "psd-imageformat-rle-decode-rle-channel",
+  "psd-color-cmyk-to-rgb",
+  "psd-compose-overlay",
+  "psd-renderer-clippingmask-apply",
+  "psd-util-pad2"
+
+# Exclusions - benchmarks that break so badly that we can't run them at all
+
+fails_hard "rbx-2.5.8", "classic-fasta-string"
+fails_hard "rbx-2.5.8-int", "classic-fasta-string"

data/benchmarks/graph/connected.rb

@@ -0,0 +1,62 @@
+# Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved. This
+# code is released under a tri EPL/GPL/LGPL license. You can use it,
+# redistribute it and/or modify it under the terms of the:
+#
+# Eclipse Public License version 1.0
+# GNU General Public License version 2
+# GNU Lesser General Public License version 2.1
+
+# Exercise Hash and Set (which is also Hash) insertion and lookup performance.
+# Creates a graph with an adjacency map. Finds the connected subgraph from a
+# root node, using an Array work list and a visited Set.
+
+require 'set'
+
+size = 100_000
+
+class Node
+end
+
+nodes = []
+
+size.times do
+  nodes << Node.new
+end
+
+adjacency = {}
+
+nodes.each do |node|
+  adjacency[node] = nodes.sample(3)
+end
+
+def connected(adjacency, root_node)
+  visited = Set.new
+  to_visit = [root_node]
+
+  while node = to_visit.pop
+    unless visited.member? node
+      visited.add node
+      to_visit.concat adjacency[node]
+    end
+  end
+
+  visited
+end
+
+ADJACENCY = adjacency
+ROOT_NODE = nodes.sample
+
+def harness_input
+  [ADJACENCY, ROOT_NODE]
+end
+
+def harness_sample(input)
+  adjacency, root_node = input
+  connected(adjacency, root_node)
+end
+
+def harness_verify(output)
+  output.size <= ADJACENCY.size
+end
+
+require 'bench9000/harness'

data/benchmarks/literature/acid.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved. This
+# code is released under a tri EPL/GPL/LGPL license. You can use it,
+# redistribute it and/or modify it under the terms of the:
+#
+# Eclipse Public License version 1.0
+# GNU General Public License version 2
+# GNU Lesser General Public License version 2.1
+
+module Foo
+  def self.foo(a, b, c)
+    hash = {a: a, b: b, c: c}
+    array = hash.map { |k, v| v }
+    x = array[0]
+    y = [a, b, c].sort[1]
+    x + y
+  end
+end
+
+class Bar
+  def method_missing(method, *args)
+    if Foo.respond_to?(method)
+      Foo.send(method, *args)
+    else
+      0
+    end
+  end
+end
+
+def harness_input
+  Bar.new
+end
+
+def harness_sample(input)
+  x = 0
+  1_000_000.times do
+    # This block should be compiled to the constant Fixnum value 22
+    x = input.foo(14, 8, 6)
+  end
+  x
+end
+
+def harness_verify(output)
+  output == 22
+end
+
+require 'bench9000/harness'

data/benchmarks/micro/pack-big-U-loop.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+SIZE = 1_000
+ITERATIONS = 10_000
+
+def harness_input
+  ['a'.ord, 'ü'.ord, '↔'.ord, '🐤'.ord] * (SIZE / 4)
+end
+
+def harness_sample(input)
+  sum = 0
+
+  ITERATIONS.times do
+    sum += input.pack("U#{SIZE}").sum
+  end
+
+  sum
+end
+
+def harness_verify(output)
+  output == 30534 * ITERATIONS
+end
+
+require 'bench9000/harness'

data/benchmarks/micro/pack-big-xLX-repeat.rb

@@ -0,0 +1,22 @@
+SIZE = 1_000
+ITERATIONS = 10_000
+
+def harness_input
+  [14] * SIZE
+end
+
+def harness_sample(input)
+  sum = 0
+
+  ITERATIONS.times do
+    sum += input.pack("x" + "LX" * SIZE).sum
+  end
+
+  sum
+end
+
+def harness_verify(output)
+  output == 14000 * ITERATIONS
+end
+
+require 'bench9000/harness'