Skip to content

Instantly share code, notes, and snippets.

/bmlog-20171114-160025.24853.tsv

Created November 14, 2017 11:39
Show Gist options
  • Save anonymous/64b7e73e5972befc33a9acde09612f90 to your computer and use it in GitHub Desktop.
Save anonymous/64b7e73e5972befc33a9acde09612f90 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
bmlog-20171114-160025.24853.tsv
We can make this file beautiful and searchable if this error is corrected: Illegal quoting in line 2.
2017-11-14 16:00:25 +0900
target 0: ruby_2_4 (ruby 2.4.3p202 (2017-11-03 revision 60626) [x86_64-linux]) at "~/ruby/install/ruby_2_4/bin/ruby"
target 1: trunk_oct (ruby 2.5.0dev (2017-09-30 trunk 60079) [x86_64-linux]) at "~/ruby/install/trunk_r60079/bin/ruby"
target 2: trunk (ruby 2.5.0dev (2017-11-14 trunk 60762) [x86_64-linux]) at "~/ruby/install/trunk/bin/ruby"
target 3: modified (ruby 2.5.0dev (2017-11-14 remove_trace 60762) [x86_64-linux]
last_commit=fix trace-on process) at "~/ruby/install/gitruby/bin/ruby"
measure target: real
-----------------------------------------------------------
app_answer
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
def the_answer_to_life_the_universe_and_everything
(ack(3,7).to_s.split(//).inject(0){|s,x| s+x.to_i}.to_s + "2" ).to_i
end
answer = the_answer_to_life_the_universe_and_everything
ruby_2_4 0.04487689025700092
ruby_2_4 0.044887082651257515
ruby_2_4 0.04478233680129051
ruby_2_4 0.044680457562208176
ruby_2_4 0.044472331181168556
trunk_oct 0.05369561351835728
trunk_oct 0.05327794328331947
trunk_oct 0.053324973210692406
trunk_oct 0.0533294128254056
trunk_oct 0.05318734794855118
trunk 0.05527955200523138
trunk 0.05591896828263998
trunk 0.055002798326313496
trunk 0.055259526707232
trunk 0.05526765063405037
modified 0.05576000455766916
modified 0.056411576457321644
modified 0.05564382392913103
modified 0.05569745972752571
modified 0.055554790422320366
-----------------------------------------------------------
app_aobench
# AO render benchmark
# Original program (C) Syoyo Fujita in Javascript (and other languages)
# https://code.google.com/p/aobench/
# Ruby(yarv2llvm) version by Hideki Miura
#
IMAGE_WIDTH = 256
IMAGE_HEIGHT = 256
NSUBSAMPLES = 2
NAO_SAMPLES = 8
class Vec
def initialize(x, y, z)
@x = x
@y = y
@z = z
end
attr_accessor :x, :y, :z
def vadd(b)
Vec.new(@x + b.x, @y + b.y, @z + b.z)
end
def vsub(b)
Vec.new(@x - b.x, @y - b.y, @z - b.z)
end
def vcross(b)
Vec.new(@y * b.z - @z * b.y,
@z * b.x - @x * b.z,
@x * b.y - @y * b.x)
end
def vdot(b)
@x * b.x + @y * b.y + @z * b.z
end
def vlength
Math.sqrt(@x * @x + @y * @y + @z * @z)
end
def vnormalize
len = vlength
v = Vec.new(@x, @y, @z)
if len > 1.0e-17 then
v.x = v.x / len
v.y = v.y / len
v.z = v.z / len
end
v
end
end
class Sphere
def initialize(center, radius)
@center = center
@radius = radius
end
attr_reader :center, :radius
def intersect(ray, isect)
rs = ray.org.vsub(@center)
b = rs.vdot(ray.dir)
c = rs.vdot(rs) - (@radius * @radius)
d = b * b - c
if d > 0.0 then
t = - b - Math.sqrt(d)
if t > 0.0 and t < isect.t then
isect.t = t
isect.hit = true
isect.pl = Vec.new(ray.org.x + ray.dir.x * t,
ray.org.y + ray.dir.y * t,
ray.org.z + ray.dir.z * t)
n = isect.pl.vsub(@center)
isect.n = n.vnormalize
else
0.0
end
end
nil
end
end
class Plane
def initialize(p, n)
@p = p
@n = n
end
def intersect(ray, isect)
d = -@p.vdot(@n)
v = ray.dir.vdot(@n)
v0 = v
if v < 0.0 then
v0 = -v
end
if v0 < 1.0e-17 then
return
end
t = -(ray.org.vdot(@n) + d) / v
if t > 0.0 and t < isect.t then
isect.hit = true
isect.t = t
isect.n = @n
isect.pl = Vec.new(ray.org.x + t * ray.dir.x,
ray.org.y + t * ray.dir.y,
ray.org.z + t * ray.dir.z)
end
nil
end
end
class Ray
def initialize(org, dir)
@org = org
@dir = dir
end
attr_accessor :org, :dir
end
class Isect
def initialize
@t = 10000000.0
@hit = false
@pl = Vec.new(0.0, 0.0, 0.0)
@n = Vec.new(0.0, 0.0, 0.0)
end
attr_accessor :t, :hit, :pl, :n
end
def clamp(f)
i = f * 255.5
if i > 255.0 then
i = 255.0
end
if i < 0.0 then
i = 0.0
end
i.to_i
end
def otherBasis(basis, n)
basis[2] = Vec.new(n.x, n.y, n.z)
basis[1] = Vec.new(0.0, 0.0, 0.0)
if n.x < 0.6 and n.x > -0.6 then
basis[1].x = 1.0
elsif n.y < 0.6 and n.y > -0.6 then
basis[1].y = 1.0
elsif n.z < 0.6 and n.z > -0.6 then
basis[1].z = 1.0
else
basis[1].x = 1.0
end
basis[0] = basis[1].vcross(basis[2])
basis[0] = basis[0].vnormalize
basis[1] = basis[2].vcross(basis[0])
basis[1] = basis[1].vnormalize
end
class Scene
def initialize
@spheres = Array.new
@spheres[0] = Sphere.new(Vec.new(-2.0, 0.0, -3.5), 0.5)
@spheres[1] = Sphere.new(Vec.new(-0.5, 0.0, -3.0), 0.5)
@spheres[2] = Sphere.new(Vec.new(1.0, 0.0, -2.2), 0.5)
@plane = Plane.new(Vec.new(0.0, -0.5, 0.0), Vec.new(0.0, 1.0, 0.0))
end
def ambient_occlusion(isect)
basis = Array.new
otherBasis(basis, isect.n)
ntheta = NAO_SAMPLES
nphi = NAO_SAMPLES
eps = 0.0001
occlusion = 0.0
p0 = Vec.new(isect.pl.x + eps * isect.n.x,
isect.pl.y + eps * isect.n.y,
isect.pl.z + eps * isect.n.z)
nphi.times do |j|
ntheta.times do |i|
r = rand
phi = 2.0 * 3.14159265 * rand
x = Math.cos(phi) * Math.sqrt(1.0 - r)
y = Math.sin(phi) * Math.sqrt(1.0 - r)
z = Math.sqrt(r)
rx = x * basis[0].x + y * basis[1].x + z * basis[2].x
ry = x * basis[0].y + y * basis[1].y + z * basis[2].y
rz = x * basis[0].z + y * basis[1].z + z * basis[2].z
raydir = Vec.new(rx, ry, rz)
ray = Ray.new(p0, raydir)
occisect = Isect.new
@spheres[0].intersect(ray, occisect)
@spheres[1].intersect(ray, occisect)
@spheres[2].intersect(ray, occisect)
@plane.intersect(ray, occisect)
if occisect.hit then
occlusion = occlusion + 1.0
else
0.0
end
end
end
occlusion = (ntheta.to_f * nphi.to_f - occlusion) / (ntheta.to_f * nphi.to_f)
Vec.new(occlusion, occlusion, occlusion)
end
def render(w, h, nsubsamples)
cnt = 0
nsf = nsubsamples.to_f
h.times do |y|
w.times do |x|
rad = Vec.new(0.0, 0.0, 0.0)
# Subsampling
nsubsamples.times do |v|
nsubsamples.times do |u|
cnt = cnt + 1
wf = w.to_f
hf = h.to_f
xf = x.to_f
yf = y.to_f
uf = u.to_f
vf = v.to_f
px = (xf + (uf / nsf) - (wf / 2.0)) / (wf / 2.0)
py = -(yf + (vf / nsf) - (hf / 2.0)) / (hf / 2.0)
eye = Vec.new(px, py, -1.0).vnormalize
ray = Ray.new(Vec.new(0.0, 0.0, 0.0), eye)
isect = Isect.new
@spheres[0].intersect(ray, isect)
@spheres[1].intersect(ray, isect)
@spheres[2].intersect(ray, isect)
@plane.intersect(ray, isect)
if isect.hit then
col = ambient_occlusion(isect)
rad.x = rad.x + col.x
rad.y = rad.y + col.y
rad.z = rad.z + col.z
end
end
end
r = rad.x / (nsf * nsf)
g = rad.y / (nsf * nsf)
b = rad.z / (nsf * nsf)
printf("%c", clamp(r))
printf("%c", clamp(g))
printf("%c", clamp(b))
end
nil
end
nil
end
end
alias printf_orig printf
def printf *args
end
# File.open("ao.ppm", "w") do |fp|
printf("P6\n")
printf("%d %d\n", IMAGE_WIDTH, IMAGE_HEIGHT)
printf("255\n", IMAGE_WIDTH, IMAGE_HEIGHT)
Scene.new.render(IMAGE_WIDTH, IMAGE_HEIGHT, NSUBSAMPLES)
# end
undef printf
alias printf printf_orig
ruby_2_4 36.20966003648937
ruby_2_4 36.276483993045986
ruby_2_4 36.06006149761379
ruby_2_4 36.40027827769518
ruby_2_4 36.59175945352763
trunk_oct 43.17953597661108
trunk_oct 39.5161963775754
trunk_oct 40.67096074577421
trunk_oct 38.93619007524103
trunk_oct 38.87406879570335
trunk 38.30207220930606
trunk 38.3029449256137
trunk 39.2404085919261
trunk 39.17272327654064
trunk 38.36024654470384
modified 37.33606534730643
modified 37.78875325806439
modified 37.444791925139725
modified 37.156153441406786
modified 38.43332130461931
-----------------------------------------------------------
app_erb
#
# Create many HTML strings with ERB.
#
require 'erb'
data = DATA.read
max = 15_000
title = "hello world!"
content = "hello world!\n" * 10
max.times{
ERB.new(data).result(binding)
}
__END__
<html>
<head> <%= title %> </head>
<body>
<h1> <%= title %> </h1>
<p>
<%= content %>
</p>
</body>
</html>
ruby_2_4 1.0910273203626275
ruby_2_4 1.1160900527611375
ruby_2_4 1.1138797011226416
ruby_2_4 1.1137238182127476
ruby_2_4 1.0859335204586387
trunk_oct 0.8029095465317369
trunk_oct 0.8081927429884672
trunk_oct 0.8069239566102624
trunk_oct 0.8096117489039898
trunk_oct 0.8034359868615866
trunk 0.8403531908988953
trunk 0.8421134259551764
trunk 0.8327486971393228
trunk 0.8372374074533582
trunk 0.8351303180679679
modified 0.8252536691725254
modified 0.831566384062171
modified 0.8288772627711296
modified 0.8264654008671641
modified 0.8336413651704788
-----------------------------------------------------------
app_factorial
def fact(n)
if(n > 1)
n * fact(n-1)
else
1
end
end
100.times {
fact(5000)
}
ruby_2_4 0.603745648637414
ruby_2_4 0.6038031615316868
ruby_2_4 0.6046772794798017
ruby_2_4 0.6043389672413468
ruby_2_4 0.6039576455950737
trunk_oct 0.669595368206501
trunk_oct 0.6659398227930069
trunk_oct 0.6744274199008942
trunk_oct 0.6669504605233669
trunk_oct 0.6685555214062333
trunk 0.6079981550574303
trunk 0.6069057630375028
trunk 0.6096790451556444
trunk 0.6078688716515899
trunk 0.6082294499501586
modified 0.6126801799982786
modified 0.6108460640534759
modified 0.6114145591855049
modified 0.6117470702156425
modified 0.6101243132725358
-----------------------------------------------------------
app_fib
def fib n
if n < 3
1
else
fib(n-1) + fib(n-2)
end
end
fib(34)
ruby_2_4 0.36114765889942646
ruby_2_4 0.33853843063116074
ruby_2_4 0.3421305660158396
ruby_2_4 0.34071844164282084
ruby_2_4 0.34828669764101505
trunk_oct 0.4085798738524318
trunk_oct 0.38410656433552504
trunk_oct 0.39509366918355227
trunk_oct 0.4005908276885748
trunk_oct 0.38477741554379463
trunk 0.4005790390074253
trunk 0.39988459181040525
trunk 0.4004660816863179
trunk 0.3989400062710047
trunk 0.4002835098654032
modified 0.3631491204723716
modified 0.35965136997401714
modified 0.361650213599205
modified 0.35752243362367153
modified 0.36000645998865366
-----------------------------------------------------------
app_lc_fizzbuzz
#
# FizzBuzz program using only lambda calculus
#
# This program is quoted from
# "Understanding Computation" by Tom Stuart
# http://computationbook.com/
#
# You can understand why this program works fine by reading this book.
#
solution = -> k { -> f { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } }] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][y] }] } } } }][k][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> l { -> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[l][f[x]] } }] } }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[m][n]][-> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[f[-> n { -> p { -> x { p[n[p][x]] } } }[m]][n]][m][x] }][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]] } } }][-> p { -> x { p[x] } }][-> p { -> x { p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[x]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] } }]][-> n { -> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[x]]]]]]]]]]]]]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[x]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> n { -> l { -> x { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } }] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][y] }] } } } }][l][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][x]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }] } }[-> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> x { f[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { -> n { -> p { -> x { p[n[p][x]] } } }[f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n]][x] }][-> p { -> x { x } }] } } }][n][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][x] }]][-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]] } }][n]]]] }]
FIRST = -> l { LEFT[RIGHT[l]] }
IF = -> b { b }
LEFT = -> p { p[-> x { -> y { x } } ] }
RIGHT = -> p { p[-> x { -> y { y } } ] }
IS_EMPTY = LEFT
REST = -> l { RIGHT[RIGHT[l]] }
def to_integer(proc)
proc[-> n { n + 1 }][0]
end
def to_boolean(proc)
IF[proc][true][false]
end
def to_array(proc)
array = []
until to_boolean(IS_EMPTY[proc])
array.push(FIRST[proc])
proc = REST[proc]
end
array
end
def to_char(c)
'0123456789BFiuz'.slice(to_integer(c))
end
def to_string(s)
to_array(s).map { |c| to_char(c) }.join
end
answer = to_array(solution).map do |p|
to_string(p)
end
answer_ary = answer.to_a
# puts answer_ary
ruby_2_4 36.53207976743579
ruby_2_4 37.89537764713168
ruby_2_4 36.723573193885386
ruby_2_4 38.48227261565626
ruby_2_4 36.90794064849615
trunk_oct 36.873438694514334
trunk_oct 36.245762643404305
trunk_oct 35.49768565688282
trunk_oct 35.30468615423888
trunk_oct 34.43972430471331
trunk 33.43890817370266
trunk 32.89311058353633
trunk 34.13755172677338
trunk 36.41347415372729
trunk 34.11650806944817
modified 33.69486961700022
modified 33.82463005371392
modified 33.184486526064575
modified 32.46442792471498
modified 31.319396573118865
-----------------------------------------------------------
app_mandelbrot
require 'complex'
def mandelbrot? z
i = 0
while i<100
i += 1
z = z * z
return false if z.abs > 2
end
true
end
ary = []
(0..1000).each{|dx|
(0..1000).each{|dy|
x = dx / 50.0
y = dy / 50.0
c = Complex(x, y)
ary << c if mandelbrot?(c)
}
}
ruby_2_4 0.925727934576571
ruby_2_4 0.9439300484955311
ruby_2_4 0.9091543704271317
ruby_2_4 0.9452749313786626
ruby_2_4 0.9127898877486587
trunk_oct 0.9456870397552848
trunk_oct 0.9509583497419953
trunk_oct 0.9463692363351583
trunk_oct 0.9440803667530417
trunk_oct 0.9558739792555571
trunk 0.952283376827836
trunk 0.9713358459994197
trunk 0.9485433483496308
trunk 0.9530115472152829
trunk 0.9520656513050199
modified 0.9396216114982963
modified 0.9364266060292721
modified 0.9358242331072688
modified 0.9580141827464104
modified 0.9555799597874284
-----------------------------------------------------------
app_pentomino
#!/usr/local/bin/ruby
# This program is contributed by Shin Nishiyama
# modified by K.Sasada
NP = 5
ROW = 8 + NP
COL = 8
$p = []
$b = []
$no = 0
def piece(n, a, nb)
nb.each{|x|
a[n] = x
if n == NP-1
$p << [a.sort]
else
nbc=nb.dup
[-ROW, -1, 1, ROW].each{|d|
if x+d > 0 and not a.include?(x+d) and not nbc.include?(x+d)
nbc << x+d
end
}
nbc.delete x
piece(n+1,a[0..n],nbc)
end
}
end
def kikaku(a)
a.collect {|x| x - a[0]}
end
def ud(a)
kikaku(a.collect {|x| ((x+NP)%ROW)-ROW*((x+NP)/ROW) }.sort)
end
def rl(a)
kikaku(a.collect {|x| ROW*((x+NP)/ROW)+ROW-((x+NP)%ROW)}.sort)
end
def xy(a)
kikaku(a.collect {|x| ROW*((x+NP)%ROW) + (x+NP)/ROW }.sort)
end
def mkpieces
piece(0,[],[0])
$p.each do |a|
a0 = a[0]
a[1] = ud(a0)
a[2] = rl(a0)
a[3] = ud(rl(a0))
a[4] = xy(a0)
a[5] = ud(xy(a0))
a[6] = rl(xy(a0))
a[7] = ud(rl(xy(a0)))
a.sort!
a.uniq!
end
$p.uniq!.sort! {|x,y| x[0] <=> y[0] }
end
def mkboard
(0...ROW*COL).each{|i|
if i % ROW >= ROW-NP
$b[i] = -2
else
$b[i] = -1
end
$b[3*ROW+3]=$b[3*ROW+4]=$b[4*ROW+3]=$b[4*ROW+4]=-2
}
end
def pboard
return # skip print
print "No. #$no\n"
(0...COL).each{|i|
print "|"
(0...ROW-NP).each{|j|
x = $b[i*ROW+j]
if x < 0
print "..|"
else
printf "%2d|",x+1
end
}
print "\n"
}
print "\n"
end
$pnum=[]
def setpiece(a,pos)
if a.length == $p.length then
$no += 1
pboard
return
end
while $b[pos] != -1
pos += 1
end
($pnum - a).each do |i|
$p[i].each do |x|
f = 0
x.each{|s|
if $b[pos+s] != -1
f=1
break
end
}
if f == 0 then
x.each{|s|
$b[pos+s] = i
}
a << i
setpiece(a.dup, pos)
a.pop
x.each{|s|
$b[pos+s] = -1
}
end
end
end
end
mkpieces
mkboard
$p[4] = [$p[4][0]]
$pnum = (0...$p.length).to_a
setpiece([],0)
__END__
# original
NP = 5
ROW = 8 + NP
COL = 8
$p = []
$b = []
$no = 0
def piece(n,a,nb)
for x in nb
a[n] = x
if n == NP-1
$p << [a.sort]
else
nbc=nb.dup
for d in [-ROW, -1, 1, ROW]
if x+d > 0 and not a.include?(x+d) and not nbc.include?(x+d)
nbc << x+d
end
end
nbc.delete x
piece(n+1,a[0..n],nbc)
end
end
end
def kikaku(a)
a.collect {|x| x - a[0]}
end
def ud(a)
kikaku(a.collect {|x| ((x+NP)%ROW)-ROW*((x+NP)/ROW) }.sort)
end
def rl(a)
kikaku(a.collect {|x| ROW*((x+NP)/ROW)+ROW-((x+NP)%ROW)}.sort)
end
def xy(a)
kikaku(a.collect {|x| ROW*((x+NP)%ROW) + (x+NP)/ROW }.sort)
end
def mkpieces
piece(0,[],[0])
$p.each do |a|
a0 = a[0]
a[1] = ud(a0)
a[2] = rl(a0)
a[3] = ud(rl(a0))
a[4] = xy(a0)
a[5] = ud(xy(a0))
a[6] = rl(xy(a0))
a[7] = ud(rl(xy(a0)))
a.sort!
a.uniq!
end
$p.uniq!.sort! {|x,y| x[0] <=> y[0] }
end
def mkboard
for i in 0...ROW*COL
if i % ROW >= ROW-NP
$b[i] = -2
else
$b[i] = -1
end
$b[3*ROW+3]=$b[3*ROW+4]=$b[4*ROW+3]=$b[4*ROW+4]=-2
end
end
def pboard
print "No. #$no\n"
for i in 0...COL
print "|"
for j in 0...ROW-NP
x = $b[i*ROW+j]
if x < 0
print "..|"
else
printf "%2d|",x+1
end
end
print "\n"
end
print "\n"
end
$pnum=[]
def setpiece(a,pos)
if a.length == $p.length then
$no += 1
pboard
return
end
while $b[pos] != -1
pos += 1
end
($pnum - a).each do |i|
$p[i].each do |x|
f = 0
for s in x do
if $b[pos+s] != -1
f=1
break
end
end
if f == 0 then
for s in x do
$b[pos+s] = i
end
a << i
setpiece(a.dup, pos)
a.pop
for s in x do
$b[pos+s] = -1
end
end
end
end
end
mkpieces
mkboard
$p[4] = [$p[4][0]]
$pnum = (0...$p.length).to_a
setpiece([],0)
ruby_2_4 10.340436936356127
ruby_2_4 10.26072520390153
ruby_2_4 10.40820305235684
ruby_2_4 10.290426510386169
ruby_2_4 10.318881308659911
trunk_oct 10.564207458868623
trunk_oct 10.45787581242621
trunk_oct 10.485318578779697
trunk_oct 10.420554504729807
trunk_oct 10.618309519253671
trunk 10.273468842729926
trunk 10.102290431037545
trunk 10.127600049600005
trunk 10.193915856070817
trunk 10.167326777242124
modified 9.924994584172964
modified 9.929463713429868
modified 9.918480903841555
modified 9.88340763002634
modified 9.879915663972497
-----------------------------------------------------------
app_raise
i = 0
while i<300000
i += 1
begin
raise
rescue
end
end
ruby_2_4 0.17838600184768438
ruby_2_4 0.17501006741076708
ruby_2_4 0.17996628675609827
ruby_2_4 0.18227750342339277
ruby_2_4 0.17908358480781317
trunk_oct 0.1874496778473258
trunk_oct 0.19084734097123146
trunk_oct 0.18677002470940351
trunk_oct 0.18702173512429
trunk_oct 0.1870880899950862
trunk 0.18548655975610018
trunk 0.18686705827713013
trunk 0.18463914841413498
trunk 0.18457612302154303
trunk 0.1846449924632907
modified 0.18765069358050823
modified 0.18769632186740637
modified 0.18800458870828152
modified 0.1883128797635436
modified 0.1892009163275361
-----------------------------------------------------------
app_strconcat
i = 0
while i<2_000_000
"#{1+1} #{1+1} #{1+1}"
i += 1
end
ruby_2_4 0.7654742449522018
ruby_2_4 0.7948119519278407
ruby_2_4 0.7673031808808446
ruby_2_4 0.7640487998723984
ruby_2_4 0.7711082641035318
trunk_oct 0.7626644130796194
trunk_oct 0.7309178821742535
trunk_oct 0.7315988969057798
trunk_oct 0.7351448154076934
trunk_oct 0.7301147468388081
trunk 0.7378271007910371
trunk 0.7387549160048366
trunk 0.7378970254212618
trunk 0.7387903444468975
trunk 0.7387805189937353
modified 0.7293761782348156
modified 0.7338413437828422
modified 0.7358414940536022
modified 0.7298681391403079
modified 0.7283730050548911
-----------------------------------------------------------
app_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)
ruby_2_4 0.5038435598835349
ruby_2_4 0.5028090076521039
ruby_2_4 0.5219125980511308
ruby_2_4 0.5068032648414373
ruby_2_4 0.5048781149089336
trunk_oct 0.5110951131209731
trunk_oct 0.5248937616124749
trunk_oct 0.5222185803577304
trunk_oct 0.5302830990403891
trunk_oct 0.5173734966665506
trunk 0.5375435454770923
trunk 0.5497156092897058
trunk 0.5430646222084761
trunk 0.5374544756487012
trunk 0.5364547353237867
modified 0.49949335400015116
modified 0.5008256258442998
modified 0.5009597418829799
modified 0.5101037258282304
modified 0.501644229516387
-----------------------------------------------------------
app_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)
ruby_2_4 0.4232830246910453
ruby_2_4 0.4196279076859355
ruby_2_4 0.4227399108931422
ruby_2_4 0.4237120309844613
ruby_2_4 0.42692682426422834
trunk_oct 0.44046545308083296
trunk_oct 0.45594013575464487
trunk_oct 0.4436839232221246
trunk_oct 0.46460551489144564
trunk_oct 0.43735334277153015
trunk 0.46855807211250067
trunk 0.4719211347401142
trunk 0.47725564520806074
trunk 0.47434646636247635
trunk 0.4816421000286937
modified 0.4196786815300584
modified 0.4139177994802594
modified 0.4215358402580023
modified 0.41485053300857544
modified 0.41740911919623613
-----------------------------------------------------------
app_uri
require 'uri'
100_000.times{
uri = URI.parse('http://www.ruby-lang.org')
uri.scheme
uri.host
uri.port
}
ruby_2_4 0.46180492267012596
ruby_2_4 0.4573489334434271
ruby_2_4 0.4546288913115859
ruby_2_4 0.4528842447325587
ruby_2_4 0.4509422993287444
trunk_oct 0.4815033273771405
trunk_oct 0.47097593266516924
trunk_oct 0.4757920615375042
trunk_oct 0.466670636087656
trunk_oct 0.470277750864625
trunk 0.45849289186298847
trunk 0.4616105295717716
trunk 0.45852625742554665
trunk 0.4658892685547471
trunk 0.4568141447380185
modified 0.46998004242777824
modified 0.46345530450344086
modified 0.4554989682510495
modified 0.45493804942816496
modified 0.45752451941370964
-----------------------------------------------------------
array_sample_100k_10
arr = [*0...100000]
10_000.times {arr.sample 10}
ruby_2_4 0.02950125839561224
ruby_2_4 0.0292540080845356
ruby_2_4 0.029195214621722698
ruby_2_4 0.029124343767762184
ruby_2_4 0.029260456562042236
trunk_oct 0.03751176968216896
trunk_oct 0.03737057093530893
trunk_oct 0.03721648082137108
trunk_oct 0.03718503285199404
trunk_oct 0.03719606250524521
trunk 0.03838095162063837
trunk 0.03798821475356817
trunk 0.038725041784346104
trunk 0.03827290236949921
trunk 0.03830507304519415
modified 0.04066624119877815
modified 0.040673685260117054
modified 0.04057355597615242
modified 0.040464249439537525
modified 0.04056987911462784
-----------------------------------------------------------
array_sample_100k_11
arr = [*0...100000]
10_000.times {arr.sample 11}
ruby_2_4 0.6606828169897199
ruby_2_4 0.6488657798618078
ruby_2_4 0.6510301260277629
ruby_2_4 0.6499084252864122
ruby_2_4 0.6423075329512358
trunk_oct 0.041237770579755306
trunk_oct 0.04111320525407791
trunk_oct 0.041138594038784504
trunk_oct 0.041162275709211826
trunk_oct 0.040904912166297436
trunk 0.04134767409414053
trunk 0.04158247448503971
trunk 0.04145221598446369
trunk 0.04133627377450466
trunk 0.04167115967720747
modified 0.043928662315011024
modified 0.04390209075063467
modified 0.04394834581762552
modified 0.04403913952410221
modified 0.043743777088820934
-----------------------------------------------------------
array_sample_100k__100
arr = [*0...100000]
10_000.times {arr.sample 100}
ruby_2_4 0.6623934572562575
ruby_2_4 0.6640799958258867
ruby_2_4 0.6602982878684998
ruby_2_4 0.6600730195641518
ruby_2_4 0.6696218233555555
trunk_oct 0.08090994041413069
trunk_oct 0.08101366087794304
trunk_oct 0.08157859649509192
trunk_oct 0.08113863784819841
trunk_oct 0.08121221698820591
trunk 0.08170587196946144
trunk 0.08162978943437338
trunk 0.0808451259508729
trunk 0.08087221439927816
trunk 0.08096039108932018
modified 0.083500437438488
modified 0.08393660746514797
modified 0.08398211933672428
modified 0.08396678324788809
modified 0.0843675248324871
-----------------------------------------------------------
array_sample_100k__1k
arr = [*0...100000]
10_000.times {arr.sample 1000}
ruby_2_4 0.8079767534509301
ruby_2_4 0.8053814945742488
ruby_2_4 0.8116927854716778
ruby_2_4 0.8043063106015325
ruby_2_4 0.8095842115581036
trunk_oct 0.49835555255413055
trunk_oct 0.5142400227487087
trunk_oct 0.498779209330678
trunk_oct 0.4986087568104267
trunk_oct 0.4983958415687084
trunk 0.49240061920136213
trunk 0.4967837706208229
trunk 0.4985520299524069
trunk 0.49130321107804775
trunk 0.49092247523367405
modified 0.5003009000793099
modified 0.49788558296859264
modified 0.4979515112936497
modified 0.503381634131074
modified 0.49630678445100784
-----------------------------------------------------------
array_sample_100k__6k
arr = [*0...100000]
10_000.times {arr.sample 6000}
ruby_2_4 1.5716388328000903
ruby_2_4 1.5782960345968604
ruby_2_4 1.578008184209466
ruby_2_4 1.5681307911872864
ruby_2_4 1.5721359457820654
trunk_oct 1.5956734726205468
trunk_oct 1.5903776213526726
trunk_oct 1.5994160855188966
trunk_oct 1.5982768889516592
trunk_oct 1.6031629657372832
trunk 1.5789744956418872
trunk 1.5713908076286316
trunk 1.5625593094155192
trunk 1.5745469778776169
trunk 1.5728356903418899
modified 1.5852369805797935
modified 1.575236569158733
modified 1.577095023356378
modified 1.5689958641305566
modified 1.5718932738527656
-----------------------------------------------------------
array_sample_100k___10k
arr = [*0...100000]
10_000.times {arr.sample 10_000}
ruby_2_4 2.205017488449812
ruby_2_4 2.171666132286191
ruby_2_4 2.1659449748694897
ruby_2_4 2.165872278623283
ruby_2_4 2.1669661132618785
trunk_oct 2.204504747875035
trunk_oct 2.194258383475244
trunk_oct 2.1962699303403497
trunk_oct 2.195070507004857
trunk_oct 2.249415007419884
trunk 2.1587591804564
trunk 2.1593775739893317
trunk 2.160155759193003
trunk 2.1610017055645585
trunk 2.15755879227072
modified 2.1717774234712124
modified 2.3299802094697952
modified 2.163971151225269
modified 2.158941427245736
modified 2.1660576751455665
-----------------------------------------------------------
array_sample_100k___50k
arr = [*0...100000]
10_000.times {arr.sample 50_000}
ruby_2_4 7.809174820780754
ruby_2_4 7.806549916043878
ruby_2_4 7.715758080594242
ruby_2_4 7.755669089965522
ruby_2_4 7.783610421232879
trunk_oct 7.958461046218872
trunk_oct 7.94976463355124
trunk_oct 7.8647908344864845
trunk_oct 7.912963852286339
trunk_oct 7.913691173307598
trunk 7.787658085115254
trunk 7.74038855265826
trunk 7.752917944453657
trunk 7.768044015392661
trunk 7.820888922549784
modified 7.844436853192747
modified 7.786277565173805
modified 7.81502278149128
modified 7.845739766955376
modified 7.853899677284062
-----------------------------------------------------------
array_shift
require 'benchmark'
Benchmark.bm do |x|
[10_000,1_000_000,100_000_000].each do |n|
ary = Array.new(n,0)
GC.start
x.report("#{n}:shift"){ ary.shift }
(0..4).each do |i|
ary = Array.new(n,0)
GC.start
x.report("#{n}:shift(#{i})"){ ary.shift(i) }
end
end
end
ruby_2_4 3.5863759266212583
ruby_2_4 3.6033725421875715
ruby_2_4 3.594981645233929
ruby_2_4 3.617394160479307
ruby_2_4 3.602064718492329
trunk_oct 3.792987175285816
trunk_oct 3.6687114080414176
trunk_oct 3.6558352252468467
trunk_oct 3.6526988577097654
trunk_oct 3.6570083051919937
trunk 1.961324568837881
trunk 1.9620508551597595
trunk 1.9623122792690992
trunk 1.960218240506947
trunk 2.0169059075415134
modified 1.9611085494980216
modified 1.9610675629228354
modified 1.9606889793649316
modified 1.9566379748284817
modified 1.9610895654186606
-----------------------------------------------------------
array_small_and
MIN_SIZE = ENV.fetch('SMALL_ARRAY_MIN', 0).to_i
MAX_SIZE = ENV.fetch('SMALL_ARRAY_MAX', 16).to_i
ITERATIONS = ENV.fetch('SMALL_ARRAY_ITERATIONS', 100).to_i
ARRAYS = (MIN_SIZE..MAX_SIZE).map do |size1|
(MIN_SIZE..MAX_SIZE).map do |size2|
[Array.new(size1) { rand(MAX_SIZE) }, Array.new(size2) { rand(MAX_SIZE) }]
end
end
ITERATIONS.times do
ARRAYS.each do |group|
group.each do |arr1, arr2|
arr1 & arr2
end
end
end
ruby_2_4 0.04314385913312435
ruby_2_4 0.042992763221263885
ruby_2_4 0.04247965291142464
ruby_2_4 0.04251945484429598
ruby_2_4 0.04269628319889307
trunk_oct 0.04317949339747429
trunk_oct 0.04326737951487303
trunk_oct 0.043151671066880226
trunk_oct 0.04343361593782902
trunk_oct 0.04334050323814154
trunk 0.04446489177644253
trunk 0.04405117221176624
trunk 0.044496748596429825
trunk 0.0441123666241765
trunk 0.04398850444704294
modified 0.04639121983200312
modified 0.04621213115751743
modified 0.04610369727015495
modified 0.046426533721387386
modified 0.046094074845314026
-----------------------------------------------------------
array_small_diff
MIN_SIZE = ENV.fetch('SMALL_ARRAY_MIN', 0).to_i
MAX_SIZE = ENV.fetch('SMALL_ARRAY_MAX', 16).to_i
ITERATIONS = ENV.fetch('SMALL_ARRAY_ITERATIONS', 100).to_i
ARRAYS = (MIN_SIZE..MAX_SIZE).map do |size1|
(MIN_SIZE..MAX_SIZE).map do |size2|
[Array.new(size1) { rand(MAX_SIZE) }, Array.new(size2) { rand(MAX_SIZE) }]
end
end
ITERATIONS.times do
ARRAYS.each do |group|
group.each do |arr1, arr2|
arr1 - arr2
end
end
end
ruby_2_4 0.04579384531825781
ruby_2_4 0.04583666939288378
ruby_2_4 0.04647925868630409
ruby_2_4 0.04598063975572586
ruby_2_4 0.045941867865622044
trunk_oct 0.04417698085308075
trunk_oct 0.04424693714827299
trunk_oct 0.044360662810504436
trunk_oct 0.04433419741690159
trunk_oct 0.044364359229803085
trunk 0.04526221193373203
trunk 0.04504249710589647
trunk 0.0447850376367569
trunk 0.04534667916595936
trunk 0.04528128355741501
modified 0.04730869736522436
modified 0.0474362438544631
modified 0.04752052389085293
modified 0.04742819629609585
modified 0.047524972818791866
-----------------------------------------------------------
array_small_or
MIN_SIZE = ENV.fetch('SMALL_ARRAY_MIN', 0).to_i
MAX_SIZE = ENV.fetch('SMALL_ARRAY_MAX', 16).to_i
ITERATIONS = ENV.fetch('SMALL_ARRAY_ITERATIONS', 100).to_i
ARRAYS = (MIN_SIZE..MAX_SIZE).map do |size1|
(MIN_SIZE..MAX_SIZE).map do |size2|
[Array.new(size1) { rand(MAX_SIZE) }, Array.new(size2) { rand(MAX_SIZE) }]
end
end
ITERATIONS.times do
ARRAYS.each do |group|
group.each do |arr1, arr2|
arr1 | arr2
end
end
end
ruby_2_4 0.04941077437251806
ruby_2_4 0.0490758428350091
ruby_2_4 0.0483282245695591
ruby_2_4 0.048524326644837856
ruby_2_4 0.04835126083344221
trunk_oct 0.05159367062151432
trunk_oct 0.050720677711069584
trunk_oct 0.050714993849396706
trunk_oct 0.050847786478698254
trunk_oct 0.05077840015292168
trunk 0.052041953429579735
trunk 0.052027663215994835
trunk 0.05208864528685808
trunk 0.05207608733326197
trunk 0.05212043598294258
modified 0.054272521287202835
modified 0.054302056320011616
modified 0.05433242954313755
modified 0.05439317785203457
modified 0.05421718955039978
-----------------------------------------------------------
array_sort_block
ary = Array.new(1000) { rand(1000) }
10000.times { ary.sort { |a, b| a <=> b } }
ruby_2_4 4.990935520268977
ruby_2_4 5.008760734461248
ruby_2_4 5.002211184240878
ruby_2_4 5.031768757849932
ruby_2_4 5.010361919179559
trunk_oct 4.620776174589992
trunk_oct 4.6228157775476575
trunk_oct 4.628693396225572
trunk_oct 4.634254821576178
trunk_oct 4.6398517601192
trunk 4.6604104693979025
trunk 4.6803290052339435
trunk 4.695919220335782
trunk 4.698329074308276
trunk 4.676961782388389
modified 4.465667547658086
modified 4.4563381634652615
modified 4.457205110229552
modified 4.442073345184326
modified 4.43261747341603
-----------------------------------------------------------
array_sort_float
arr = Array.new(1000) { rand }
10000.times { arr.sort }
ruby_2_4 2.9691732367500663
ruby_2_4 2.9651240250095725
ruby_2_4 2.9431838244199753
ruby_2_4 2.973076667636633
ruby_2_4 2.967228399589658
trunk_oct 1.5360774910077453
trunk_oct 1.5372640900313854
trunk_oct 1.5914093377068639
trunk_oct 1.530824408866465
trunk_oct 1.540001641958952
trunk 1.6600666958838701
trunk 1.558536239899695
trunk 1.5544176446273923
trunk 1.564120912924409
trunk 1.5635378854349256
modified 1.5336211854591966
modified 1.5208673346787691
modified 1.5700370520353317
modified 1.531577586196363
modified 1.5355555731803179
-----------------------------------------------------------
bighash
h = {}; 5000000.times {|n| h[n] = n }
ruby_2_4 1.1658156188204885
ruby_2_4 1.1619386924430728
ruby_2_4 1.1778438221663237
ruby_2_4 1.177191092632711
ruby_2_4 1.1696994761005044
trunk_oct 1.1916822316125035
trunk_oct 1.1992708332836628
trunk_oct 1.1910538002848625
trunk_oct 1.2156227435916662
trunk_oct 1.1998401647433639
trunk 1.2078109737485647
trunk 1.2166875256225467
trunk 1.2052306067198515
trunk 1.206314828246832
trunk 1.2102624317631125
modified 1.211957766674459
modified 1.2027070298790932
modified 1.2055514501407743
modified 1.2117169462144375
modified 1.2023955518379807
-----------------------------------------------------------
dir_empty_p
require 'tmpdir'
max = 100_000
Dir.mktmpdir('bm_dir_empty_p') do |dir|
max.times { Dir.empty?(dir) }
end
ruby_2_4 0.22107713297009468
ruby_2_4 0.20824912749230862
ruby_2_4 0.21443202625960112
ruby_2_4 0.2158330800011754
ruby_2_4 0.2104991702362895
trunk_oct 0.22432265151292086
trunk_oct 0.2660670196637511
trunk_oct 0.21744792722165585
trunk_oct 0.21820032969117165
trunk_oct 0.21739510353654623
trunk 0.22934256959706545
trunk 0.2406091457232833
trunk 0.22949449252337217
trunk 0.22903573978692293
trunk 0.23602640721946955
modified 0.2354406053200364
modified 0.23155706655234098
modified 0.2339407168328762
modified 0.23286220338195562
modified 0.23001439403742552
-----------------------------------------------------------
erb_render
require 'erb'
data = DATA.read
max = 1_500_000
title = "hello world!"
content = "hello world!\n" * 10
src = "def self.render(title, content); #{ERB.new(data).src}; end"
mod = Module.new
mod.instance_eval(src, "(ERB)")
max.times do
mod.render(title, content)
end
__END__
<html>
<head> <%= title %> </head>
<body>
<h1> <%= title %> </h1>
<p>
<%= content %>
</p>
</body>
</html>
ruby_2_4 2.648871618323028
ruby_2_4 2.601091149263084
ruby_2_4 2.6083217319101095
ruby_2_4 2.6274924371391535
ruby_2_4 2.6040284829214215
trunk_oct 1.0657949335873127
trunk_oct 1.075893527828157
trunk_oct 1.0614414513111115
trunk_oct 1.099606178700924
trunk_oct 1.064248469658196
trunk 1.084544393233955
trunk 1.0845027780160308
trunk 1.0832743281498551
trunk 1.1745046861469746
trunk 1.0948968958109617
modified 1.2614368768408895
modified 1.0565239069983363
modified 1.0615467857569456
modified 1.065241951495409
modified 1.1145551661029458
-----------------------------------------------------------
file_chmod
# chmod file
require 'tempfile'
max = 200_000
tmp = Tempfile.new('chmod')
path = tmp.path
max.times do
File.chmod(0777, path)
end
tmp.close!
ruby_2_4 0.19015854876488447
ruby_2_4 0.19285294879227877
ruby_2_4 0.1905073681846261
ruby_2_4 0.19568252936005592
ruby_2_4 0.19243267178535461
trunk_oct 0.2016332894563675
trunk_oct 0.19890588708221912
trunk_oct 0.20081097353249788
trunk_oct 0.2001079497858882
trunk_oct 0.20737564004957676
trunk 0.22116354294121265
trunk 0.21869436744600534
trunk 0.22755639161914587
trunk 0.21909922547638416
trunk 0.2188980421051383
modified 0.21806801576167345
modified 0.23552309162914753
modified 0.2178712347522378
modified 0.22257215715944767
modified 0.21878324821591377
-----------------------------------------------------------
file_rename
# rename file
require 'tempfile'
max = 100_000
tmp = [ Tempfile.new('rename-a'), Tempfile.new('rename-b') ]
a, b = tmp.map { |x| x.path }
max.times do
File.rename(a, b)
File.rename(b, a)
end
tmp.each { |t| t.close! }
ruby_2_4 0.6642924919724464
ruby_2_4 0.6502274638041854
ruby_2_4 0.6562406495213509
ruby_2_4 0.6850288612768054
ruby_2_4 0.6594824707135558
trunk_oct 0.6670955242589116
trunk_oct 0.6725148819386959
trunk_oct 0.664207162335515
trunk_oct 0.6652930174022913
trunk_oct 0.6675800252705812
trunk 0.6808162312954664
trunk 0.68763168156147
trunk 0.6752430256456137
trunk 0.6801165351644158
trunk 0.6752310367301106
modified 0.6756181111559272
modified 0.6772550158202648
modified 0.6776238521561027
modified 0.6753160459920764
modified 0.6779537666589022
-----------------------------------------------------------
hash_aref_dsym
h = {}
syms = ('a'..'z').map { |s| s.to_sym }
syms.each { |s| h[s] = 1 }
200_000.times { syms.each { |s| h[s] } }
ruby_2_4 0.263726475648582
ruby_2_4 0.2761738272383809
ruby_2_4 0.2723959432914853
ruby_2_4 0.26847472228109837
ruby_2_4 0.2680125245824456
trunk_oct 0.2943550646305084
trunk_oct 0.2937017111107707
trunk_oct 0.29192993324249983
trunk_oct 0.2919363062828779
trunk_oct 0.30135550256818533
trunk 0.3101480947807431
trunk 0.314423693343997
trunk 0.31170643866062164
trunk 0.3108241092413664
trunk 0.30914205592125654
modified 0.30534568428993225
modified 0.30895554553717375
modified 0.31122990790754557
modified 0.3072431115433574
modified 0.33601050078868866
-----------------------------------------------------------
hash_aref_dsym_long
# [ruby-core:70129] [Bug #11396]
collection_size = 200000
sample_size = 10000
values = (1..collection_size).to_a.map do |x|
"THIS IS A LONGER STRING THAT IS ALSO UNIQUE #{x}"
end
symbol_hash = {}
values.each do |x|
symbol_hash[x.to_sym] = 1
end
# use the same samples each time to minimize deviations
rng = Random.new(0)
symbol_sample_array = values.sample(sample_size, random: rng).map(&:to_sym)
3000.times do
symbol_sample_array.each { |x| symbol_hash[x] }
end
ruby_2_4 3.175567743368447
ruby_2_4 3.206102818250656
ruby_2_4 3.2415223885327578
ruby_2_4 3.299550731666386
ruby_2_4 3.311943086795509
trunk_oct 3.237652954645455
trunk_oct 3.0586729859933257
trunk_oct 3.3109343741089106
trunk_oct 3.3957728538662195
trunk_oct 3.459920813329518
trunk 3.164889508858323
trunk 3.1942493384703994
trunk 3.189624813385308
trunk 3.1740572210401297
trunk 3.2820500675588846
modified 3.1559967659413815
modified 3.197402344085276
modified 3.2052777437493205
modified 3.282293534837663
modified 3.3287694938480854
-----------------------------------------------------------
hash_aref_fix
h = {}
nums = (1..26).to_a
nums.each { |i| h[i] = i }
200_000.times { nums.each { |s| h[s] } }
ruby_2_4 0.2609948040917516
ruby_2_4 0.2578913839533925
ruby_2_4 0.25224294513463974
ruby_2_4 0.271748811006546
ruby_2_4 0.27248279098421335
trunk_oct 0.29355032555758953
trunk_oct 0.28349983040243387
trunk_oct 0.2936028419062495
trunk_oct 0.3452490037307143
trunk_oct 0.41720787063241005
trunk 0.3100457526743412
trunk 0.2910926891490817
trunk 0.29295599088072777
trunk 0.41942670848220587
trunk 0.2960450313985348
modified 0.2895897263661027
modified 0.27915025781840086
modified 0.2791378078982234
modified 0.2965983608737588
modified 0.28458560444414616
-----------------------------------------------------------
hash_aref_flo
h = {}
strs = [*1..10000].map! {|i| i.fdiv(10)}
strs.each { |s| h[s] = s }
50.times { strs.each { |s| h[s] } }
ruby_2_4 0.0499512767419219
ruby_2_4 0.051750097423791885
ruby_2_4 0.05015122704207897
ruby_2_4 0.04933540336787701
ruby_2_4 0.04952178802341223
trunk_oct 0.05952627211809158
trunk_oct 0.059625888243317604
trunk_oct 0.059829698875546455
trunk_oct 0.060849291272461414
trunk_oct 0.05933453608304262
trunk 0.06063990853726864
trunk 0.060607340186834335
trunk 0.060403233394026756
trunk 0.0609989445656538
trunk 0.06045036483556032
modified 0.062234902754426
modified 0.06396108586341143
modified 0.0621397802606225
modified 0.0630847280845046
modified 0.062187787145376205
-----------------------------------------------------------
hash_aref_miss
h = {}
strs = ('a'..'z').to_a.map!(&:freeze)
strs.each { |s| h[s] = s }
strs = ('A'..'Z').to_a
200_000.times { strs.each { |s| h[s] } }
ruby_2_4 0.3686364060267806
ruby_2_4 0.37831310741603374
ruby_2_4 0.3779862029477954
ruby_2_4 0.3743992382660508
ruby_2_4 0.361598146148026
trunk_oct 0.38061713334172964
trunk_oct 0.3909873841330409
trunk_oct 0.395187652669847
trunk_oct 0.3763585928827524
trunk_oct 0.3905332116410136
trunk 0.39660962857306004
trunk 0.3936945628374815
trunk 0.4377703182399273
trunk 0.40676034800708294
trunk 0.36866373661905527
modified 0.39652410615235567
modified 0.3937609801068902
modified 0.40038585383445024
modified 0.3890699865296483
modified 0.400178880430758
-----------------------------------------------------------
hash_aref_str
h = {}
strs = ('a'..'z').to_a.map!(&:freeze)
strs.each { |s| h[s] = s }
200_000.times { strs.each { |s| h[s] } }
ruby_2_4 0.3430917225778103
ruby_2_4 0.32951133884489536
ruby_2_4 0.33487503230571747
ruby_2_4 0.3384719081223011
ruby_2_4 0.33576900139451027
trunk_oct 0.34187883976846933
trunk_oct 0.34241723641753197
trunk_oct 0.34056114312261343
trunk_oct 0.35416494961827993
trunk_oct 0.35687818843871355
trunk 0.3454119525849819
trunk 0.34791990276426077
trunk 0.35336306039243937
trunk 0.35420312639325857
trunk 0.34874989464879036
modified 0.3405866641551256
modified 0.34616814460605383
modified 0.32941246312111616
modified 0.3446532553061843
modified 0.3441737936809659
-----------------------------------------------------------
hash_aref_sym
h = {}
syms = ('a'..'z').to_a
begin
syms = eval("%i[#{syms.join(' ')}]")
rescue SyntaxError # <= 1.9.3
syms.map!(&:to_sym)
end
syms.each { |s| h[s] = s }
200_000.times { syms.each { |s| h[s] } }
ruby_2_4 0.2723753023892641
ruby_2_4 0.26579560339450836
ruby_2_4 0.2653283290565014
ruby_2_4 0.27019786927849054
ruby_2_4 0.285128521732986
trunk_oct 0.3119408180937171
trunk_oct 0.29992883652448654
trunk_oct 0.29907585494220257
trunk_oct 0.3094273768365383
trunk_oct 0.30554392095655203
trunk 0.3042509751394391
trunk 0.30037481151521206
trunk 0.3012241991236806
trunk 0.29844539798796177
trunk 0.30931904818862677
modified 0.3019282864406705
modified 0.32146325148642063
modified 0.2996023017913103
modified 0.3141472479328513
modified 0.2989084841683507
-----------------------------------------------------------
hash_aref_sym_long
h = {}
syms = %w[puts warn syswrite write stat bacon lettuce tomato
some symbols in this array may already be interned others should not be
hash browns make good breakfast but not cooked using prime numbers
shift for division entries delete_if keys exist?
]
begin
syms = eval("%i[#{syms.join(' ')}]")
rescue SyntaxError # <= 1.9.3
syms.map!(&:to_sym)
end
syms.each { |s| h[s] = s }
200_000.times { syms.each { |s| h[s] } }
ruby_2_4 0.3622218491509557
ruby_2_4 0.4381094928830862
ruby_2_4 0.3674069354310632
ruby_2_4 0.3799957800656557
ruby_2_4 0.3875621594488621
trunk_oct 0.44223527424037457
trunk_oct 0.42702542897313833
trunk_oct 0.4132824158295989
trunk_oct 0.41335222963243723
trunk_oct 0.42288501653820276
trunk 0.4240665137767792
trunk 0.4099509548395872
trunk 0.41233318485319614
trunk 0.4047677731141448
trunk 0.41507475171238184
modified 0.40376974642276764
modified 0.407093895599246
modified 0.40305578522384167
modified 0.42089630104601383
modified 0.4092823453247547
-----------------------------------------------------------
hash_flatten
h = {}
10000.times do |i|
h[i] = nil
end
1000.times do
h.flatten
end
ruby_2_4 0.23931661248207092
ruby_2_4 0.23898044601082802
ruby_2_4 0.2388934502378106
ruby_2_4 0.2389828274026513
ruby_2_4 0.23898828402161598
trunk_oct 0.18286235444247723
trunk_oct 0.18168202694505453
trunk_oct 0.18208450730890036
trunk_oct 0.18146330770105124
trunk_oct 0.18216758500784636
trunk 0.20638114120811224
trunk 0.20617200154811144
trunk 0.20668425224721432
trunk 0.20664830226451159
trunk 0.20640033297240734
modified 0.18963987659662962
modified 0.18995442241430283
modified 0.1893994454294443
modified 0.1897573471069336
modified 0.1897696079686284
-----------------------------------------------------------
hash_ident_flo
h = {}.compare_by_identity
strs = (1..10000).to_a.map!(&:to_f)
strs.each { |s| h[s] = s }
50.times { strs.each { |s| h[s] } }
ruby_2_4 0.04909050464630127
ruby_2_4 0.04922498110681772
ruby_2_4 0.04883077833801508
ruby_2_4 0.0491654546931386
ruby_2_4 0.04862384870648384
trunk_oct 0.05925955902785063
trunk_oct 0.05936989467591047
trunk_oct 0.059128270484507084
trunk_oct 0.05897417291998863
trunk_oct 0.059846263378858566
trunk 0.06017099879682064
trunk 0.0599897475913167
trunk 0.060129120014607906
trunk 0.059829612262547016
trunk 0.059953819029033184
modified 0.06197364069521427
modified 0.06301239226013422
modified 0.06195529829710722
modified 0.06145096942782402
modified 0.06151615083217621
-----------------------------------------------------------
hash_ident_num
h = {}.compare_by_identity
nums = (1..26).to_a
nums.each { |n| h[n] = n }
200_000.times { nums.each { |n| h[n] } }
ruby_2_4 0.2550027072429657
ruby_2_4 0.25709130242466927
ruby_2_4 0.2795975673943758
ruby_2_4 0.28014630638062954
ruby_2_4 0.2746730362996459
trunk_oct 0.30431725084781647
trunk_oct 0.27907548658549786
trunk_oct 0.3097229143604636
trunk_oct 0.28085173200815916
trunk_oct 0.2814785363152623
trunk 0.30336756259202957
trunk 0.2823643572628498
trunk 0.3062245165929198
trunk 0.3192725069820881
trunk 0.28318785782903433
modified 0.34642425179481506
modified 0.29638210218399763
modified 0.2898220447823405
modified 0.29221873730421066
modified 0.3005418302491307
-----------------------------------------------------------
hash_ident_obj
h = {}.compare_by_identity
objs = 26.times.map { Object.new }
objs.each { |o| h[o] = o }
200_000.times { objs.each { |o| h[o] } }
ruby_2_4 0.2589333523064852
ruby_2_4 0.2724173329770565
ruby_2_4 0.2794358851388097
ruby_2_4 0.26604977436363697
ruby_2_4 0.25615649949759245
trunk_oct 0.28422093857079744
trunk_oct 0.29160023387521505
trunk_oct 0.2841336829587817
trunk_oct 0.29316555336117744
trunk_oct 0.29831799305975437
trunk 0.2968236692249775
trunk 0.3070484884083271
trunk 0.29577150382101536
trunk 0.2952602840960026
trunk 0.2905656127259135
modified 0.2833299096673727
modified 0.3000877173617482
modified 0.30436465982347727
modified 0.29478229861706495
modified 0.296668728813529
-----------------------------------------------------------
hash_ident_str
h = {}.compare_by_identity
strs = ('a'..'z').to_a
strs.each { |s| h[s] = s }
200_000.times { strs.each { |s| h[s] } }
ruby_2_4 0.28064961079508066
ruby_2_4 0.2699139639735222
ruby_2_4 0.2610522909089923
ruby_2_4 0.259786419570446
ruby_2_4 0.2636388372629881
trunk_oct 0.289898619055748
trunk_oct 0.27941754274070263
trunk_oct 0.2989111291244626
trunk_oct 0.30557968094944954
trunk_oct 0.3044827217236161
trunk 0.2841451307758689
trunk 0.29513147193938494
trunk 0.29825274739414454
trunk 0.3008001418784261
trunk 0.29079663939774036
modified 0.2829178422689438
modified 0.2951761847361922
modified 0.29073284193873405
modified 0.2812343193218112
modified 0.2890197755768895
-----------------------------------------------------------
hash_ident_sym
h = {}.compare_by_identity
syms = ('a'..'z').to_a.map(&:to_sym)
syms.each { |s| h[s] = s }
200_000.times { syms.each { |s| h[s] } }
ruby_2_4 0.26749170385301113
ruby_2_4 0.25853430200368166
ruby_2_4 0.26072264928370714
ruby_2_4 0.25702809914946556
ruby_2_4 0.27116471622139215
trunk_oct 0.3072659121826291
trunk_oct 0.30654087476432323
trunk_oct 0.3076043529435992
trunk_oct 0.2920140326023102
trunk_oct 0.31216693948954344
trunk 0.30231455527246
trunk 0.3066350994631648
trunk 0.29409283585846424
trunk 0.3120587505400181
trunk 0.30041169468313456
modified 0.2973363669589162
modified 0.3094587540253997
modified 0.3012598352506757
modified 0.3460267363116145
modified 0.2915645893663168
-----------------------------------------------------------
hash_keys
h = {}
10000.times do |i|
h[i] = nil
end
5000.times do
h.keys
end
ruby_2_4 0.09465214144438505
ruby_2_4 0.09494761656969786
ruby_2_4 0.09517013281583786
ruby_2_4 0.09517311304807663
ruby_2_4 0.09566901158541441
trunk_oct 0.10243359114974737
trunk_oct 0.10314598213881254
trunk_oct 0.1023942157626152
trunk_oct 0.10257727932184935
trunk_oct 0.10197165608406067
trunk 0.1065923161804676
trunk 0.1063461247831583
trunk 0.10021214559674263
trunk 0.10675222054123878
trunk 0.1004721550270915
modified 0.10937212035059929
modified 0.10857798904180527
modified 0.10883629694581032
modified 0.10871011950075626
modified 0.10857814364135265
-----------------------------------------------------------
hash_long
k1 = "Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong";
k2 = "Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping";
h = {k1 => 0, k2 => 0};
3000000.times{|i| k = i % 2 ? k2 : k1; h [k] = h[k] + 1}
ruby_2_4 0.6776566496118903
ruby_2_4 0.6738138990476727
ruby_2_4 0.6687519643455744
ruby_2_4 0.6694637639448047
ruby_2_4 0.6692806025967002
trunk_oct 0.576607920229435
trunk_oct 0.583100532181561
trunk_oct 0.5810478115454316
trunk_oct 0.5759585332125425
trunk_oct 0.5758388945832849
trunk 0.5886679319664836
trunk 0.578824719414115
trunk 0.5794282341375947
trunk 0.5891964696347713
trunk 0.5801844587549567
modified 0.5787801658734679
modified 0.5786007614806294
modified 0.5786173976957798
modified 0.5787396812811494
modified 0.5783470449969172
-----------------------------------------------------------
hash_shift
h = {}
10000.times do |i|
h[i] = nil
end
50000.times do
k, v = h.shift
h[k] = v
end
ruby_2_4 0.029302826151251793
ruby_2_4 0.02946515940129757
ruby_2_4 0.02928383182734251
ruby_2_4 0.029138588346540928
ruby_2_4 0.02953410241752863
trunk_oct 0.03826920222491026
trunk_oct 0.038040789775550365
trunk_oct 0.03791420720517635
trunk_oct 0.03813316021114588
trunk_oct 0.03833345044404268
trunk 0.0393370445817709
trunk 0.0394512414932251
trunk 0.03941994905471802
trunk 0.039190332405269146
trunk 0.03947609290480614
modified 0.04173279367387295
modified 0.04142030142247677
modified 0.0414245929569006
modified 0.041482603177428246
modified 0.04123121686279774
-----------------------------------------------------------
hash_shift_u16
h = {}
(16384..65536).each do |i|
h[i] = nil
end
300000.times do
k, v = h.shift
h[k] = v
end
ruby_2_4 0.06899990793317556
ruby_2_4 0.06721921171993017
ruby_2_4 0.0671424102038145
ruby_2_4 0.06842063087970018
ruby_2_4 0.06798364501446486
trunk_oct 0.0758235789835453
trunk_oct 0.07667972147464752
trunk_oct 0.07573583722114563
trunk_oct 0.07633332069963217
trunk_oct 0.0763377146795392
trunk 0.07831694092601538
trunk 0.07861876394599676
trunk 0.07803748268634081
trunk 0.07770607620477676
trunk 0.07872064877301455
modified 0.07910268101841211
modified 0.08106855396181345
modified 0.07938780821859837
modified 0.07960688043385744
modified 0.07941157557070255
-----------------------------------------------------------
hash_shift_u24
h = {}
(0xff4000..0xffffff).each do |i|
h[i] = nil
end
300000.times do
k, v = h.shift
h[k] = v
end
ruby_2_4 0.06821257993578911
ruby_2_4 0.06714130844920874
ruby_2_4 0.06836456805467606
ruby_2_4 0.06916996371001005
ruby_2_4 0.06688732840120792
trunk_oct 0.07595515623688698
trunk_oct 0.07614211458712816
trunk_oct 0.0766504593193531
trunk_oct 0.07583861239254475
trunk_oct 0.07618055399507284
trunk 0.07757530827075243
trunk 0.07761591114103794
trunk 0.07828425709158182
trunk 0.07989687751978636
trunk 0.07830884121358395
modified 0.07936799339950085
modified 0.08005461096763611
modified 0.08000997081398964
modified 0.07990794256329536
modified 0.07945192977786064
-----------------------------------------------------------
hash_shift_u32
h = {}
(0xffff4000..0xffffffff).each do |i|
h[i] = nil
end
300000.times do
k, v = h.shift
h[k] = v
end
ruby_2_4 0.0692470520734787
ruby_2_4 0.06743897125124931
ruby_2_4 0.06738287396728992
ruby_2_4 0.06708309706300497
ruby_2_4 0.06774392630904913
trunk_oct 0.07641611527651548
trunk_oct 0.07598584052175283
trunk_oct 0.07606874126940966
trunk_oct 0.07611617632210255
trunk_oct 0.07661638222634792
trunk 0.0782409030944109
trunk 0.07836768310517073
trunk 0.07830094452947378
trunk 0.07797120045870543
trunk 0.0782504640519619
modified 0.07922205608338118
modified 0.07980144582688808
modified 0.07950060721486807
modified 0.08021101914346218
modified 0.07971761748194695
-----------------------------------------------------------
hash_small2
1000000.times.map{|i| a={}; 2.times{|j| a[j]=j}; a}
ruby_2_4 0.4494409402832389
ruby_2_4 0.4508389215916395
ruby_2_4 0.451890891417861
ruby_2_4 0.45400820206850767
ruby_2_4 0.45705028530210257
trunk_oct 0.4623531950637698
trunk_oct 0.4621663298457861
trunk_oct 0.46354869566857815
trunk_oct 0.46262427791953087
trunk_oct 0.46277075447142124
trunk 0.48058672808110714
trunk 0.47581950295716524
trunk 0.4770717294886708
trunk 0.4768876023590565
trunk 0.47570366598665714
modified 0.4747159481048584
modified 0.47542138025164604
modified 0.48115441482514143
modified 0.47522070351988077
modified 0.47443811874836683
-----------------------------------------------------------
hash_small4
1000000.times.map{|i| a={}; 4.times{|j| a[j]=j}; a}
ruby_2_4 0.5742486761882901
ruby_2_4 0.5974699202924967
ruby_2_4 0.5767933959141374
ruby_2_4 0.5782211907207966
ruby_2_4 0.5712182810530066
trunk_oct 0.5861901910975575
trunk_oct 0.5861655008047819
trunk_oct 0.5861290348693728
trunk_oct 0.6346785500645638
trunk_oct 0.5867755152285099
trunk 0.6085033426061273
trunk 0.6072090184316039
trunk 0.6069953348487616
trunk 0.6076025785878301
trunk 0.6087436396628618
modified 0.6034981710836291
modified 0.604193969629705
modified 0.6024577636271715
modified 0.604750245809555
modified 0.6031058877706528
-----------------------------------------------------------
hash_small8
1000000.times.map{|i| a={}; 8.times{|j| a[j]=j}; a}
ruby_2_4 1.0295241875573993
ruby_2_4 1.1690709693357348
ruby_2_4 1.0750119490548968
ruby_2_4 1.0536391269415617
ruby_2_4 1.0349234230816364
trunk_oct 1.058202332817018
trunk_oct 1.0488654309883714
trunk_oct 1.0568763576447964
trunk_oct 1.0487769413739443
trunk_oct 1.047456793487072
trunk 1.235707575455308
trunk 1.1773730088025331
trunk 1.181349717080593
trunk 1.239696185104549
trunk 1.1787792230024934
modified 1.0944882482290268
modified 1.091933854855597
modified 1.0930390488356352
modified 1.0945343114435673
modified 1.0924241999164224
-----------------------------------------------------------
hash_to_proc
h = {}
10000.times do |i|
h[i] = nil
end
5000.times do |i|
[i].map(&h)
end
ruby_2_4 0.024416503496468067
ruby_2_4 0.024257753044366837
ruby_2_4 0.024156589061021805
ruby_2_4 0.0242291409522295
ruby_2_4 0.024087593890726566
trunk_oct 0.03295538853853941
trunk_oct 0.033053671941161156
trunk_oct 0.03301873616874218
trunk_oct 0.03271505702286959
trunk_oct 0.03284402284771204
trunk 0.033997722901403904
trunk 0.03410301823168993
trunk 0.033932266756892204
trunk 0.03396750520914793
trunk 0.03401686251163483
modified 0.03639744780957699
modified 0.03635264374315739
modified 0.036440882831811905
modified 0.03617205750197172
modified 0.03621793072670698
-----------------------------------------------------------
hash_values
h = {}
10000.times do |i|
h[i] = nil
end
5000.times do
h.values
end
ruby_2_4 0.09482246823608875
ruby_2_4 0.0951392687857151
ruby_2_4 0.09502425231039524
ruby_2_4 0.095138237811625
ruby_2_4 0.09573106747120619
trunk_oct 0.10253547970205545
trunk_oct 0.10209653619676828
trunk_oct 0.10230094008147717
trunk_oct 0.10225026402622461
trunk_oct 0.10090127028524876
trunk 0.1004562433809042
trunk 0.1064581610262394
trunk 0.10636940412223339
trunk 0.10040752310305834
trunk 0.1064596688374877
modified 0.1088621262460947
modified 0.10968368221074343
modified 0.10879790503531694
modified 0.10862477961927652
modified 0.1090538464486599
-----------------------------------------------------------
int_quo
5000000.times { 42.quo(3) }
ruby_2_4 1.7910891138017178
ruby_2_4 1.7285595210269094
ruby_2_4 1.7591103501617908
ruby_2_4 1.7299061687663198
ruby_2_4 1.775772562250495
trunk_oct 0.9134138859808445
trunk_oct 0.9059665594249964
trunk_oct 0.9056594418361783
trunk_oct 0.9054229985922575
trunk_oct 0.928419372998178
trunk 0.9065565336495638
trunk 0.905972296372056
trunk 0.8987451354041696
trunk 0.919618234038353
trunk 0.8996790926903486
modified 0.9016909934580326
modified 0.9023942472413182
modified 0.9089935682713985
modified 0.90226483438164
modified 0.9030623137950897
-----------------------------------------------------------
io_copy_stream_write
# The goal of this is to use a synthetic (non-IO) reader
# to trigger the read/write loop of IO.copy_stream,
# bypassing in-kernel mechanisms like sendfile for zero copy,
# so we wrap the /dev/zero IO object:
class Zero
def initialize
@n = 100000
@in = File.open('/dev/zero', 'rb')
end
def read(len, buf)
return if (@n -= 1) == 0
@in.read(len, buf)
end
end
begin
src = Zero.new
dst = File.open(IO::NULL, 'wb')
n = IO.copy_stream(src, dst)
rescue Errno::ENOENT
# not *nix
end if IO.respond_to?(:copy_stream) && IO.const_defined?(:NULL)
ruby_2_4 0.16210402268916368
ruby_2_4 0.16486232168972492
ruby_2_4 0.16260320134460926
ruby_2_4 0.1673704106360674
ruby_2_4 0.16285186167806387
trunk_oct 0.16517131309956312
trunk_oct 0.16473023127764463
trunk_oct 0.16761245392262936
trunk_oct 0.16392066795378923
trunk_oct 0.1653193812817335
trunk 0.16689542774111032
trunk 0.1713306289166212
trunk 0.16785669792443514
trunk 0.1687092548236251
trunk 0.17021904978901148
modified 0.1704663671553135
modified 0.17199433408677578
modified 0.16818094532936811
modified 0.1791617888957262
modified 0.17123859841376543
-----------------------------------------------------------
io_copy_stream_write_socket
# The goal of this is to use a synthetic (non-IO) reader
# to trigger the read/write loop of IO.copy_stream,
# bypassing in-kernel mechanisms like sendfile for zero copy,
# so we wrap the /dev/zero IO object:
class Zero
def initialize
@n = 100000
@in = File.open('/dev/zero', 'rb')
end
def read(len, buf)
return if (@n -= 1) == 0
@in.read(len, buf)
end
end
begin
require 'socket'
src = Zero.new
rd, wr = UNIXSocket.pair
pid = fork do
wr.close
buf = String.new
while rd.read(16384, buf)
end
end
rd.close
IO.copy_stream(src, wr)
rescue Errno::ENOENT, NotImplementedError, NameError
# not *nix: missing /dev/zero, fork, or UNIXSocket
rescue LoadError # no socket?
ensure
wr.close if wr
Process.waitpid(pid) if pid
end if IO.respond_to?(:copy_stream)
ruby_2_4 0.3203147491440177
ruby_2_4 0.3256166009232402
ruby_2_4 0.31645045056939125
ruby_2_4 0.3181094489991665
ruby_2_4 0.3224779777228832
trunk_oct 0.32048323657363653
trunk_oct 0.333693141117692
trunk_oct 0.32401488348841667
trunk_oct 0.336939106695354
trunk_oct 0.4383966764435172
trunk 0.3204655172303319
trunk 0.3223985591903329
trunk 0.3596854144707322
trunk 0.3231933154165745
trunk 0.32139942422509193
modified 0.3314205938950181
modified 0.33042685873806477
modified 0.32387255039066076
modified 0.32587605249136686
modified 0.33207847736775875
-----------------------------------------------------------
io_file_create
#
# Create files
#
max = 200_000
file = './tmpfile_of_bm_io_file_create'
max.times{
f = open(file, 'w')
f.close#(true)
}
File.unlink(file)
ruby_2_4 0.7999052871018648
ruby_2_4 0.7802762482315302
ruby_2_4 0.7981305615976453
ruby_2_4 0.8176641836762428
ruby_2_4 0.7996335029602051
trunk_oct 0.8188932035118341
trunk_oct 0.8183162622153759
trunk_oct 0.8078320994973183
trunk_oct 0.8258823677897453
trunk_oct 0.8580632116645575
trunk 0.7810021582990885
trunk 0.8000286109745502
trunk 0.8005015533417463
trunk 0.7879576412960887
trunk 0.7909177830442786
modified 0.8119170628488064
modified 0.7866885531693697
modified 0.7928201509639621
modified 0.8005136391147971
modified 0.8375968812033534
-----------------------------------------------------------
io_file_read
#
# Seek and Read file.
#
require 'tempfile'
max = 200_000
str = "Hello world! " * 1000
f = Tempfile.new('yarv-benchmark')
f.write str
max.times{
f.seek 0
f.read
}
ruby_2_4 0.8217237209901214
ruby_2_4 0.8444003714248538
ruby_2_4 0.8303785212337971
ruby_2_4 0.8469831356778741
ruby_2_4 0.8294633002951741
trunk_oct 0.7688569575548172
trunk_oct 0.7721415897831321
trunk_oct 0.8051110897213221
trunk_oct 0.7887211926281452
trunk_oct 0.8064563442021608
trunk 0.7544424263760448
trunk 0.7700773729011416
trunk 0.7584051731973886
trunk 0.7609825311228633
trunk 0.7656487720087171
modified 0.7598473494872451
modified 0.7565656080842018
modified 0.8026420054957271
modified 0.755095761269331
modified 0.7528132116422057
-----------------------------------------------------------
io_file_write
#
# Seek and Write file.
#
require 'tempfile'
max = 200_000
str = "Hello world! " * 1000
f = Tempfile.new('yarv-benchmark')
max.times{
f.seek 0
f.write str
}
ruby_2_4 0.5772966332733631
ruby_2_4 0.5744149908423424
ruby_2_4 0.5781210800632834
ruby_2_4 0.577535237185657
ruby_2_4 0.595387808047235
trunk_oct 0.585019969381392
trunk_oct 0.5834510438144207
trunk_oct 0.5755818607285619
trunk_oct 0.5747231030836701
trunk_oct 0.5832370640709996
trunk 0.5774798141792417
trunk 0.5735156740993261
trunk 0.5775971859693527
trunk 0.5818069921806455
trunk 0.5767041118815541
modified 0.5714107882231474
modified 0.5819572256878018
modified 0.5726626105606556
modified 0.5816189525648952
modified 0.5776834171265364
-----------------------------------------------------------
io_nonblock_noex
nr = 1_000_000
i = 0
msg = '.'
buf = '.'
noex = { exception: false }
begin
r, w = IO.pipe
while i < nr
i += 1
w.write_nonblock(msg, noex)
r.read_nonblock(1, buf, noex)
end
rescue ArgumentError # old Rubies
while i < nr
i += 1
w.write_nonblock(msg)
r.read_nonblock(1, buf)
end
ensure
r.close
w.close
end
ruby_2_4 1.351217346265912
ruby_2_4 1.3710231287404895
ruby_2_4 1.4210442770272493
ruby_2_4 1.339781346730888
ruby_2_4 1.373001316562295
trunk_oct 1.282431822270155
trunk_oct 1.2943201018497348
trunk_oct 1.2761540720239282
trunk_oct 1.2877383586019278
trunk_oct 1.300718992948532
trunk 1.2950346199795604
trunk 1.2903010724112391
trunk 1.3431848688051105
trunk 1.2978426683694124
trunk 1.2955013345927
modified 1.3379434710368514
modified 1.3073850935325027
modified 1.43139236420393
modified 1.3297874238342047
modified 1.3217193624004722
-----------------------------------------------------------
io_nonblock_noex2
nr = 1_000_000
i = 0
msg = '.'
buf = '.'
begin
r, w = IO.pipe
while i < nr
i += 1
w.write_nonblock(msg, exception: false)
r.read_nonblock(1, buf, exception: false)
end
rescue ArgumentError # old Rubies
while i < nr
i += 1
w.write_nonblock(msg)
r.read_nonblock(1, buf)
end
ensure
r.close
w.close
end
ruby_2_4 0.8324068998917937
ruby_2_4 0.8314814483746886
ruby_2_4 0.8269680328667164
ruby_2_4 0.8316371915861964
ruby_2_4 0.8199124159291387
trunk_oct 0.8225545426830649
trunk_oct 0.8366458108648658
trunk_oct 0.8511283118277788
trunk_oct 0.8294539796188474
trunk_oct 0.8529512928798795
trunk 0.8512865994125605
trunk 0.8464699042961001
trunk 0.8392754150554538
trunk 0.8420780496671796
trunk 0.8508471073582768
modified 0.8645479064434767
modified 0.8406872861087322
modified 0.8594023119658232
modified 0.8463565856218338
modified 0.8332216292619705
-----------------------------------------------------------
io_pipe_rw
# Measure uncontended GVL performance via read/write with 1:1 threading
# If we switch to M:N threading, this will benchmark something else...
r, w = IO.pipe
src = '0'.freeze
dst = String.new
i = 0
while i < 1_000_000
i += 1
w.write(src)
r.read(1, dst)
end
w.close
r.close
ruby_2_4 0.7143390085548162
ruby_2_4 0.7022978942841291
ruby_2_4 0.7022813595831394
ruby_2_4 0.7124151447787881
ruby_2_4 0.7000056002289057
trunk_oct 0.7139607220888138
trunk_oct 0.710090241394937
trunk_oct 0.7141006896272302
trunk_oct 0.7125008162111044
trunk_oct 0.7146924622356892
trunk 0.7243178458884358
trunk 0.7200548071414232
trunk 0.7394839841872454
trunk 0.7268596375361085
trunk 0.7209014231339097
modified 0.7262718323618174
modified 0.7193344123661518
modified 0.7222678856924176
modified 0.7509619044139981
modified 0.7261429792270064
-----------------------------------------------------------
io_select
# IO.select performance
w = [ IO.pipe[1] ];
nr = 1000000
nr.times {
IO.select nil, w
}
ruby_2_4 0.9978612475097179
ruby_2_4 0.9951350139454007
ruby_2_4 0.9974106270819902
ruby_2_4 0.9967657895758748
ruby_2_4 1.0035944301635027
trunk_oct 1.0107591282576323
trunk_oct 1.0033363224938512
trunk_oct 1.009982293471694
trunk_oct 1.005640427581966
trunk_oct 1.0018855407834053
trunk 0.9936086991801858
trunk 1.0324719995260239
trunk 1.00522892922163
trunk 1.020094777457416
trunk 0.9990698415786028
modified 1.0174420643597841
modified 1.015567747876048
modified 0.9971954477950931
modified 1.00277444627136
modified 1.026356372050941
-----------------------------------------------------------
io_select2
# IO.select performance. worst case of single fd.
ios = []
nr = 1000000
if defined?(Process::RLIMIT_NOFILE)
max = Process.getrlimit(Process::RLIMIT_NOFILE)[0]
else
max = 64
end
puts "max fd: #{max} (results not apparent with <= 1024 max fd)"
((max / 2) - 10).times do
ios.concat IO.pipe
end
last = [ ios[-1] ]
puts "last IO: #{last[0].inspect}"
nr.times do
IO.select nil, last
end
ruby_2_4 1.2514165174216032
ruby_2_4 1.2058365903794765
ruby_2_4 1.2566699665039778
ruby_2_4 1.2180656678974628
ruby_2_4 1.2143642427399755
trunk_oct 1.2226426051929593
trunk_oct 1.2405806230381131
trunk_oct 1.2254924103617668
trunk_oct 1.2207012921571732
trunk_oct 1.2302411468699574
trunk 1.23319860547781
trunk 1.2176413107663393
trunk 1.2214890699833632
trunk 1.242837361060083
trunk 1.2556630987673998
modified 1.2407134361565113
modified 1.223868195898831
modified 1.2421179804950953
modified 1.2392476228997111
modified 1.2411613631993532
-----------------------------------------------------------
io_select3
# IO.select performance. a lot of fd
ios = []
nr = 100
if defined?(Process::RLIMIT_NOFILE)
max = Process.getrlimit(Process::RLIMIT_NOFILE)[0]
else
max = 64
end
puts "max fd: #{max} (results not apparent with <= 1024 max fd)"
(max - 10).times do
r, w = IO.pipe
r.close
ios.push w
end
nr.times do
IO.select nil, ios
end
ruby_2_4 0.12176590226590633
ruby_2_4 0.10139702539891005
ruby_2_4 0.1210133982822299
ruby_2_4 0.09872106462717056
ruby_2_4 0.12972754146903753
trunk_oct 0.12838854361325502
trunk_oct 0.12410090956836939
trunk_oct 0.11200020927935839
trunk_oct 0.10974986292421818
trunk_oct 0.11278579756617546
trunk 0.1150733856484294
trunk 0.10835539177060127
trunk 0.1078281830996275
trunk 0.09894286841154099
trunk 0.0969577869400382
modified 0.11497108265757561
modified 0.10831099934875965
modified 0.11509297415614128
modified 0.10960207972675562
modified 0.1161925457417965
-----------------------------------------------------------
loop_for
for i in 1..30_000_000
#
end
ruby_2_4 0.9044722365215421
ruby_2_4 0.8913315301761031
ruby_2_4 0.8917335430160165
ruby_2_4 0.9003735594451427
ruby_2_4 0.891508269123733
trunk_oct 0.9779127929359674
trunk_oct 0.9779272573068738
trunk_oct 0.9824546426534653
trunk_oct 1.226051683537662
trunk_oct 1.049929440021515
trunk 1.0119363153353333
trunk 1.0605404255911708
trunk 1.0116948680952191
trunk 1.0291864844039083
trunk 1.017377712763846
modified 0.9972810121253133
modified 0.9777810694649816
modified 0.9819500455632806
modified 0.9814369948580861
modified 0.9772939933463931
-----------------------------------------------------------
loop_generator
max = 600000
if defined? Fiber
gen = (1..max).each
loop do
gen.next
end
else
require 'generator'
gen = Generator.new((0..max))
while gen.next?
gen.next
end
end
ruby_2_4 0.28958967607468367
ruby_2_4 0.2817333731800318
ruby_2_4 0.30630672723054886
ruby_2_4 0.2807753887027502
ruby_2_4 0.27863746136426926
trunk_oct 0.3039307380095124
trunk_oct 0.3060454139485955
trunk_oct 0.30376856960356236
trunk_oct 0.3065807707607746
trunk_oct 0.30464411806315184
trunk 0.28339630272239447
trunk 0.2835812931880355
trunk 0.28066639322787523
trunk 0.28298798855394125
trunk 0.28092439845204353
modified 0.2857633577659726
modified 0.2886517709121108
modified 0.28970182966440916
modified 0.28230337891727686
modified 0.285346164368093
-----------------------------------------------------------
loop_times
30_000_000.times{|e|}
ruby_2_4 0.800098036415875
ruby_2_4 0.7994052208960056
ruby_2_4 0.81767104472965
ruby_2_4 0.8039096966385841
ruby_2_4 0.9809081982821226
trunk_oct 0.8972129980102181
trunk_oct 0.8951454674825072
trunk_oct 0.895119103603065
trunk_oct 0.8975104046985507
trunk_oct 0.897660561837256
trunk 0.9161784658208489
trunk 0.9009289182722569
trunk 0.9006341714411974
trunk 0.9242716180160642
trunk 0.9066849211230874
modified 0.8799077365547419
modified 0.8780862903222442
modified 0.8784855492413044
modified 0.8822809010744095
modified 0.9416052401065826
-----------------------------------------------------------
loop_whileloop
i = 0
while i<30_000_000 # benchmark loop 1
i += 1
end
ruby_2_4 0.38871809281408787
ruby_2_4 0.38852716889232397
ruby_2_4 0.3900247998535633
ruby_2_4 0.38787161000072956
ruby_2_4 0.4692509137094021
trunk_oct 0.4302550461143255
trunk_oct 0.4261731216683984
trunk_oct 0.4263553023338318
trunk_oct 0.4262999976053834
trunk_oct 0.4261710103601217
trunk 0.44495165906846523
trunk 0.44308482576161623
trunk 0.4439132548868656
trunk 0.5232562273740768
trunk 0.4427309790626168
modified 0.4297006605193019
modified 0.4296526713296771
modified 0.43171786796301603
modified 0.4310999112203717
modified 0.4299190267920494
-----------------------------------------------------------
loop_whileloop2
i = 0
while i< 6_000_000 # benchmark loop 2
i += 1
end
ruby_2_4 0.09508057497441769
ruby_2_4 0.09816205408424139
ruby_2_4 0.09490170422941446
ruby_2_4 0.09514188952744007
ruby_2_4 0.09823123272508383
trunk_oct 0.10931369755417109
trunk_oct 0.10927016381174326
trunk_oct 0.10950556118041277
trunk_oct 0.10906031168997288
trunk_oct 0.10930100549012423
trunk 0.1131787234917283
trunk 0.11350607126951218
trunk 0.11356672924011946
trunk 0.11348916590213776
trunk 0.11342305224388838
modified 0.11254169326275587
modified 0.11256999894976616
modified 0.11183645389974117
modified 0.11254487559199333
modified 0.11250667553395033
-----------------------------------------------------------
marshal_dump_flo
bug10761 = 10000.times.map { |x| x.to_f }
100.times { Marshal.dump(bug10761) }
ruby_2_4 0.2474653758108616
ruby_2_4 0.2463385034352541
ruby_2_4 0.24670730996876955
ruby_2_4 0.2659081034362316
ruby_2_4 0.246890252456069
trunk_oct 0.25504343677312136
trunk_oct 0.25651744566857815
trunk_oct 0.25390689726918936
trunk_oct 0.2542014615610242
trunk_oct 0.25434407591819763
trunk 0.2572882482782006
trunk 0.25845279823988676
trunk 0.2580233821645379
trunk 0.2570078521966934
trunk 0.2581360889598727
modified 0.2605440830811858
modified 0.26057865656912327
modified 0.2618860388174653
modified 0.26100150868296623
modified 0.2605224484577775
-----------------------------------------------------------
marshal_dump_load_geniv
a = ''
a.instance_eval do
@a = :a
@b = :b
@c = :c
end
100000.times do
a = Marshal.load(Marshal.dump(a))
end
#p(a.instance_eval { @a == :a && @b == :b && @c == :c })
ruby_2_4 0.38658848591148853
ruby_2_4 0.38398884423077106
ruby_2_4 0.3930904380977154
ruby_2_4 0.3915357328951359
ruby_2_4 0.3868562411516905
trunk_oct 0.39498877339065075
trunk_oct 0.3954792330041528
trunk_oct 0.3979486972093582
trunk_oct 0.3920952929183841
trunk_oct 0.3908311817795038
trunk 0.3994530038908124
trunk 0.3945854725316167
trunk 0.4059576028957963
trunk 0.3963400172069669
trunk 0.3893438410013914
modified 0.40164520870894194
modified 0.3948695659637451
modified 0.3964743921533227
modified 0.39503393042832613
modified 0.3978611407801509
-----------------------------------------------------------
marshal_dump_load_time
100000.times { Marshal.load(Marshal.dump(Time.now)) }
ruby_2_4 1.1609864998608828
ruby_2_4 1.1564325913786888
ruby_2_4 1.1912339758127928
ruby_2_4 1.166799645870924
ruby_2_4 1.152001416310668
trunk_oct 1.175420201383531
trunk_oct 1.1364163476973772
trunk_oct 1.1284445095807314
trunk_oct 1.162480417639017
trunk_oct 1.1347096469253302
trunk 1.1818950893357396
trunk 1.1549881594255567
trunk 1.2190832709893584
trunk 1.163321797735989
trunk 1.1695076981559396
modified 1.1573536796495318
modified 1.1767047625035048
modified 1.1633068844676018
modified 1.1642479738220572
modified 1.1985326698049903
-----------------------------------------------------------
require
$:.push File.join(File.dirname(__FILE__), "bm_require.data")
1.upto(10000) do |i|
require "c#{i}"
end
$:.pop
ruby_2_4 0.7003255039453506
ruby_2_4 0.6770226173102856
ruby_2_4 0.6845751907676458
ruby_2_4 0.6869270578026772
ruby_2_4 0.6865763831883669
trunk_oct 0.7193482229486108
trunk_oct 0.7275565005838871
trunk_oct 0.7269294839352369
trunk_oct 0.7329859836027026
trunk_oct 0.7227034391835332
trunk 0.7305544791743159
trunk 0.7094148565083742
trunk 0.7062418721616268
trunk 0.7997284382581711
trunk 0.707997677847743
modified 0.7551164655014873
modified 0.7279995884746313
modified 0.7400414794683456
modified 0.7204265147447586
modified 0.7185903489589691
-----------------------------------------------------------
require_thread
$:.push File.join(File.dirname(__FILE__), "bm_require.data")
i=0
t = Thread.new do
while true
i = i+1 # dummy loop
end
end
1.upto(100) do |i|
require "c#{i}"
end
$:.pop
t.kill
ruby_2_4 0.12859986256808043
ruby_2_4 0.1278662383556366
ruby_2_4 17.139101547189057
ruby_2_4 0.12799783889204264
ruby_2_4 14.341372024267912
trunk_oct 0.13724040985107422
trunk_oct 0.13700702134519815
trunk_oct 0.1374838687479496
trunk_oct 0.1369559159502387
trunk_oct 0.236913344822824
trunk 101.16569390054792
trunk 103.43558030668646
trunk 32.263321708887815
trunk 103.76521679852158
trunk 72.00294751580805
modified 62.51455730292946
modified 99.16671017743647
modified 97.66403281129897
modified 82.54443915374577
modified 103.37254293449223
-----------------------------------------------------------
securerandom
require "securerandom"
20_0000.times do
SecureRandom.random_number(100)
end
ruby_2_4 0.1747917402535677
ruby_2_4 0.17374191246926785
ruby_2_4 0.18010317254811525
ruby_2_4 0.17790788505226374
ruby_2_4 0.17303849011659622
trunk_oct 0.22200851701200008
trunk_oct 0.22202838957309723
trunk_oct 0.23062498588114977
trunk_oct 0.22145147435367107
trunk_oct 0.22212802711874247
trunk 0.22578141558915377
trunk 0.22446201462298632
trunk 0.2248234525322914
trunk 0.224688989110291
trunk 0.22262599598616362
modified 0.22193302772939205
modified 0.22469153068959713
modified 0.22500979620963335
modified 0.22283765766769648
modified 0.22584333829581738
-----------------------------------------------------------
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 = 9
ack(3, NUM)
ruby_2_4 0.394165282137692
ruby_2_4 0.3939297618344426
ruby_2_4 0.39566834177821875
ruby_2_4 0.39374957140535116
ruby_2_4 0.3940361188724637
trunk_oct 0.39930439833551645
trunk_oct 0.39863829407840967
trunk_oct 0.39800180681049824
trunk_oct 0.4183602165430784
trunk_oct 0.40153941605240107
trunk 0.4259690511971712
trunk 0.41846096329391
trunk 0.41895114351063967
trunk 0.4184820372611284
trunk 0.4509238637983799
modified 0.3930969974026084
modified 0.39542569871991873
modified 0.39219037629663944
modified 0.3924806835129857
modified 0.3939360249787569
-----------------------------------------------------------
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}"
ruby_2_4 0.8295369409024715
ruby_2_4 0.611743145622313
ruby_2_4 0.6117981057614088
ruby_2_4 0.6140669099986553
ruby_2_4 0.6131450338289142
trunk_oct 0.6552423983812332
trunk_oct 0.6528829522430897
trunk_oct 0.6759208580479026
trunk_oct 0.6562178805470467
trunk_oct 0.6593029722571373
trunk 0.6725892294198275
trunk 0.6728537809103727
trunk 0.6702935108914971
trunk 0.7063782475888729
trunk 0.6745461979880929
modified 0.6619908884167671
modified 0.6562794949859381
modified 0.6586566250771284
modified 0.6556976130232215
modified 0.6578402174636722
-----------------------------------------------------------
so_binary_trees
# The Computer Language Shootout Benchmarks
# http://shootout.alioth.debian.org
#
# contributed by Jesse Millikan
# disable output
alias puts_orig puts
def puts str
# disable puts
end
def item_check(tree)
if tree[0] == nil
tree[1]
else
tree[1] + item_check(tree[0]) - item_check(tree[2])
end
end
def bottom_up_tree(item, depth)
if depth > 0
item_item = 2 * item
depth -= 1
[bottom_up_tree(item_item - 1, depth), item, bottom_up_tree(item_item, depth)]
else
[nil, item, nil]
end
end
max_depth = 16 # ARGV[0].to_i
min_depth = 4
max_depth = min_depth + 2 if min_depth + 2 > max_depth
stretch_depth = max_depth + 1
stretch_tree = bottom_up_tree(0, stretch_depth)
puts "stretch tree of depth #{stretch_depth}\t check: #{item_check(stretch_tree)}"
stretch_tree = nil
long_lived_tree = bottom_up_tree(0, max_depth)
min_depth.step(max_depth + 1, 2) do |depth|
iterations = 2**(max_depth - depth + min_depth)
check = 0
for i in 1..iterations
temp_tree = bottom_up_tree(i, depth)
check += item_check(temp_tree)
temp_tree = bottom_up_tree(-i, depth)
check += item_check(temp_tree)
end
puts "#{iterations * 2}\t trees of depth #{depth}\t check: #{check}"
end
puts "long lived tree of depth #{max_depth}\t check: #{item_check(long_lived_tree)}"
undef puts
alias puts puts_orig
ruby_2_4 4.359847350046039
ruby_2_4 4.23919237870723
ruby_2_4 4.257350823841989
ruby_2_4 4.25885096937418
ruby_2_4 4.238811162300408
trunk_oct 4.23889244440943
trunk_oct 4.312817181460559
trunk_oct 4.341334853321314
trunk_oct 4.346625108271837
trunk_oct 4.328528879210353
trunk 4.5401236694306135
trunk 4.593720803968608
trunk 4.559484443627298
trunk 4.56108489818871
trunk 4.6567939799278975
modified 4.43616914562881
modified 4.569371286779642
modified 4.532888426445425
modified 4.684375158511102
modified 4.4301601611077785
-----------------------------------------------------------
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"
i = 0
while i<10
i += 1
hello = ''
4_000_000.times do |e|
hello << STUFF
end
end
# puts hello.length
ruby_2_4 2.8542529735714197
ruby_2_4 2.855884239077568
ruby_2_4 2.8499110639095306
ruby_2_4 2.8512823432683945
ruby_2_4 2.8487400403246284
trunk_oct 2.9521667193621397
trunk_oct 2.961184752173722
trunk_oct 2.952890577726066
trunk_oct 2.9514555744826794
trunk_oct 2.9549610558897257
trunk 3.0745205199345946
trunk 3.0743666645139456
trunk 3.0733328694477677
trunk 3.0728870863094926
trunk 3.0723974891006947
modified 2.9682219615206122
modified 3.0021516056731343
modified 2.9623350258916616
modified 2.9560116790235043
modified 3.065779614262283
-----------------------------------------------------------
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
input = open(File.join(File.dirname($0), 'wc.input'), 'rb')
nl = nw = nc = 0
while true
tmp = input.read(4096) or break
data = tmp << (input.gets || "")
nc += data.length
nl += data.count("\n")
((data.strip! || data).tr!("\n", " ") || data).squeeze!
nw += data.count(" ") + 1
end
# STDERR.puts "#{nl} #{nw} #{nc}"
ruby_2_4 0.13292209431529045
ruby_2_4 0.1329799061641097
ruby_2_4 0.1326249921694398
ruby_2_4 0.13304319884628057
ruby_2_4 0.1329117063432932
trunk_oct 0.1404149578884244
trunk_oct 0.14065165352076292
trunk_oct 0.14067816268652678
trunk_oct 0.14016995206475258
trunk_oct 0.1405358389019966
trunk 0.15460665617138147
trunk 0.1538712540641427
trunk 0.15462887845933437
trunk 0.1546104196459055
trunk 0.15447503607720137
modified 0.1565698916092515
modified 0.1570461504161358
modified 0.15607906877994537
modified 0.15718519035726786
modified 0.15635679382830858
-----------------------------------------------------------
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
ruby_2_4 0.22726632561534643
ruby_2_4 0.22583076171576977
ruby_2_4 0.221515741199255
ruby_2_4 0.2221260704100132
ruby_2_4 0.22224968764930964
trunk_oct 0.2294118320569396
trunk_oct 0.23374507948756218
trunk_oct 0.2299413150176406
trunk_oct 0.2269281353801489
trunk_oct 0.2265768302604556
trunk 0.23472302127629519
trunk 0.24264333676546812
trunk 0.23562572244554758
trunk 0.23501654528081417
trunk 0.23726077657192945
modified 0.22585246060043573
modified 0.22526070196181536
modified 0.22486719395965338
modified 0.22173711005598307
modified 0.22404176089912653
-----------------------------------------------------------
so_fannkuch
# The Computer Language Shootout
# http://shootout.alioth.debian.org/
# Contributed by Sokolov Yura
# Modified by Ryan Williams
def fannkuch(n)
maxFlips, m, r, check = 0, n-1, n, 0
count = (1..n).to_a
perm = (1..n).to_a
while true
if check < 30
puts "#{perm}"
check += 1
end
while r != 1
count[r-1] = r
r -= 1
end
if perm[0] != 1 and perm[m] != n
perml = perm.clone #.dup
flips = 0
while (k = perml.first ) != 1
perml = perml.slice!(0, k).reverse + perml
flips += 1
end
maxFlips = flips if flips > maxFlips
end
while true
if r==n then return maxFlips end
perm.insert r,perm.shift
break if (count[r] -= 1) > 0
r += 1
end
end
end
def puts *args
end
N = 9 # (ARGV[0] || 1).to_i
puts "Pfannkuchen(#{N}) = #{fannkuch(N)}"
ruby_2_4 0.8191407145932317
ruby_2_4 0.8211729293689132
ruby_2_4 0.830899054184556
ruby_2_4 0.8211070392280817
ruby_2_4 0.8184840846806765
trunk_oct 0.8506222302094102
trunk_oct 0.8441071258857846
trunk_oct 0.8481834745034575
trunk_oct 0.8506027571856976
trunk_oct 0.8767997119575739
trunk 0.9008601326495409
trunk 0.8503843881189823
trunk 0.8476368524134159
trunk 0.8478699373081326
trunk 0.850719390437007
modified 0.8486929861828685
modified 0.8574986793100834
modified 0.8445206778123975
modified 0.8621928729116917
modified 0.844983285292983
-----------------------------------------------------------
so_fasta
# The Computer Language Shootout
# http://shootout.alioth.debian.org/
# Contributed by Sokolov Yura
$last = 42.0
def gen_random(max, im=139968, ia=3877, ic=29573)
(max * ($last = ($last * ia + ic) % im)) / im
end
alu =
"GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"+
"GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"+
"CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"+
"ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"+
"GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"+
"AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"+
"AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
iub = [
["a", 0.27],
["c", 0.12],
["g", 0.12],
["t", 0.27],
["B", 0.02],
["D", 0.02],
["H", 0.02],
["K", 0.02],
["M", 0.02],
["N", 0.02],
["R", 0.02],
["S", 0.02],
["V", 0.02],
["W", 0.02],
["Y", 0.02],
]
homosapiens = [
["a", 0.3029549426680],
["c", 0.1979883004921],
["g", 0.1975473066391],
["t", 0.3015094502008],
]
def make_repeat_fasta(id, desc, src, n)
puts ">#{id} #{desc}"
v = nil
width = 60
l = src.length
s = src * ((n / l) + 1)
s.slice!(n, l)
puts(s.scan(/.{1,#{width}}/).join("\n"))
end
def make_random_fasta(id, desc, table, n)
puts ">#{id} #{desc}"
rand, v = nil,nil
width = 60
chunk = 1 * width
prob = 0.0
table.each{|v| v[1]= (prob += v[1])}
for i in 1..(n/width)
puts((1..width).collect{
rand = gen_random(1.0)
table.find{|v| v[1]>rand}[0]
}.join)
end
if n%width != 0
puts((1..(n%width)).collect{
rand = gen_random(1.0)
table.find{|v| v[1]>rand}[0]
}.join)
end
end
n = (ARGV[0] or 250_000).to_i
make_repeat_fasta('ONE', 'Homo sapiens alu', alu, n*2)
make_random_fasta('TWO', 'IUB ambiguity codes', iub, n*3)
make_random_fasta('THREE', 'Homo sapiens frequency', homosapiens, n*5)
ruby_2_4 1.2201206097379327
ruby_2_4 1.2196027785539627
ruby_2_4 1.2136210883036256
ruby_2_4 1.2173871397972107
ruby_2_4 1.2251200070604682
trunk_oct 1.2831258932128549
trunk_oct 1.2861877465620637
trunk_oct 1.417847934179008
trunk_oct 1.2906327303498983
trunk_oct 1.2838180316612124
trunk 1.4332627980038524
trunk 1.285471641458571
trunk 1.2890075398609042
trunk 1.4308448862284422
trunk 1.2803919203579426
modified 1.27948949765414
modified 1.2860844573006034
modified 1.2776277409866452
modified 1.272096480242908
modified 1.275735855102539
-----------------------------------------------------------
so_k_nucleotide
# The Computer Language Shootout
# http://shootout.alioth.debian.org
#
# contributed by jose fco. gonzalez
# modified by Sokolov Yura
seq = String.new
def frecuency( seq,length )
n, table = seq.length - length + 1, Hash.new(0)
f, i = nil, nil
(0 ... length).each do |f|
(f ... n).step(length) do |i|
table[seq[i,length]] += 1
end
end
[n,table]
end
def sort_by_freq( seq,length )
n,table = frecuency( seq,length )
a, b, v = nil, nil, nil
table.sort{|a,b| b[1] <=> a[1]}.each do |v|
puts "%s %.3f" % [v[0].upcase,((v[1]*100).to_f/n)]
end
puts
end
def find_seq( seq,s )
n,table = frecuency( seq,s.length )
puts "#{table[s].to_s}\t#{s.upcase}"
end
input = open(File.join(File.dirname($0), 'fasta.output.100000'), 'rb')
line = input.gets while line !~ /^>THREE/
line = input.gets
while (line !~ /^>/) & line do
seq << line.chomp
line = input.gets
end
[1,2].each {|i| sort_by_freq( seq,i ) }
%w(ggt ggta ggtatt ggtattttaatt ggtattttaatttatagt).each{|s| find_seq( seq,s) }
ruby_2_4 0.8590771807357669
ruby_2_4 0.9881570478901267
ruby_2_4 0.8596108229830861
ruby_2_4 0.8602258870378137
ruby_2_4 0.8604057375341654
trunk_oct 0.8651048690080643
trunk_oct 0.8705999897792935
trunk_oct 0.8715275283902884
trunk_oct 0.8688820581883192
trunk_oct 0.8709613448008895
trunk 0.8811677116900682
trunk 0.8799803759902716
trunk 0.872853054665029
trunk 0.885897783562541
trunk 0.871613634750247
modified 0.8717275261878967
modified 0.8751911167055368
modified 0.8688216423615813
modified 0.869478796608746
modified 0.8729496160522103
-----------------------------------------------------------
so_lists
#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
ruby_2_4 0.38326943945139647
ruby_2_4 0.38286024145781994
ruby_2_4 0.3828663360327482
ruby_2_4 0.38287252373993397
ruby_2_4 0.3826301610097289
trunk_oct 0.3575837118551135
trunk_oct 0.3591359658166766
trunk_oct 0.3577789831906557
trunk_oct 0.35794258397072554
trunk_oct 0.3581985319033265
trunk 0.3630874715745449
trunk 0.36417560186237097
trunk 0.36346066650003195
trunk 0.362745676189661
trunk 0.363191737793386
modified 0.36357950046658516
modified 0.3623280618339777
modified 0.36237639654427767
modified 0.36283602099865675
modified 0.3634634595364332
-----------------------------------------------------------
so_mandelbrot
# The Computer Language Benchmarks Game
# http://shootout.alioth.debian.org/
#
# contributed by Karl von Laudermann
# modified by Jeremy Echols
size = 600 # ARGV[0].to_i
puts "P4\n#{size} #{size}"
ITER = 49 # Iterations - 1 for easy for..in looping
LIMIT_SQUARED = 4.0 # Presquared limit
byte_acc = 0
bit_num = 0
count_size = size - 1 # Precomputed size for easy for..in looping
# For..in loops are faster than .upto, .downto, .times, etc.
for y in 0..count_size
for x in 0..count_size
zr = 0.0
zi = 0.0
cr = (2.0*x/size)-1.5
ci = (2.0*y/size)-1.0
escape = false
# To make use of the for..in code, we use a dummy variable,
# like one would in C
for dummy in 0..ITER
tr = zr*zr - zi*zi + cr
ti = 2*zr*zi + ci
zr, zi = tr, ti
if (zr*zr+zi*zi) > LIMIT_SQUARED
escape = true
break
end
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
end
end
ruby_2_4 1.835338570177555
ruby_2_4 1.8241520142182708
ruby_2_4 1.8862576205283403
ruby_2_4 1.8379918662831187
ruby_2_4 1.858496100641787
trunk_oct 2.0549077382311225
trunk_oct 2.054156359285116
trunk_oct 1.9315293775871396
trunk_oct 1.9456397034227848
trunk_oct 2.0528963673859835
trunk 2.0258221365511417
trunk 2.0213693976402283
trunk 2.061582013964653
trunk 2.019574492238462
trunk 2.1127477902919054
modified 1.900754738599062
modified 1.893930503167212
modified 1.896593670360744
modified 1.943287892267108
modified 1.8937652809545398
-----------------------------------------------------------
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 = 40
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]}"
ruby_2_4 0.37967456970363855
ruby_2_4 0.3832985498011112
ruby_2_4 0.3805954623967409
ruby_2_4 0.3799684848636389
ruby_2_4 0.38001074083149433
trunk_oct 0.4101771442219615
trunk_oct 0.4140275437384844
trunk_oct 0.4414729680866003
trunk_oct 0.5091881621629
trunk_oct 0.4070788072422147
trunk 0.41902750823646784
trunk 0.4235832719132304
trunk 0.41803340427577496
trunk 0.4264401011168957
trunk 0.4261182574555278
modified 0.40770130790770054
modified 0.40887937042862177
modified 0.4070527870208025
modified 0.5036796145141125
modified 0.41164416167885065
-----------------------------------------------------------
so_meteor_contest
#!/usr/bin/env ruby
#
# The Computer Language Shootout
# http://shootout.alioth.debian.org
# contributed by Kevin Barnes (Ruby novice)
# PROGRAM: the main body is at the bottom.
# 1) read about the problem here: http://www-128.ibm.com/developerworks/java/library/j-javaopt/
# 2) see how I represent a board as a bitmask by reading the blank_board comments
# 3) read as your mental paths take you
def print *args
end
# class to represent all information about a particular rotation of a particular piece
class Rotation
# an array (by location) containing a bit mask for how the piece maps at the given location.
# if the rotation is invalid at that location the mask will contain false
attr_reader :start_masks
# maps a direction to a relative location. these differ depending on whether it is an even or
# odd row being mapped from
@@rotation_even_adder = { :west => -1, :east => 1, :nw => -7, :ne => -6, :sw => 5, :se => 6 }
@@rotation_odd_adder = { :west => -1, :east => 1, :nw => -6, :ne => -5, :sw => 6, :se => 7 }
def initialize( directions )
@even_offsets, @odd_offsets = normalize_offsets( get_values( directions ))
@even_mask = mask_for_offsets( @even_offsets)
@odd_mask = mask_for_offsets( @odd_offsets)
@start_masks = Array.new(60)
# create the rotational masks by placing the base mask at the location and seeing if
# 1) it overlaps the boundaries and 2) it produces a prunable board. if either of these
# is true the piece cannot be placed
0.upto(59) do | offset |
mask = is_even(offset) ? (@even_mask << offset) : (@odd_mask << offset)
if (blank_board & mask == 0 && !prunable(blank_board | mask, 0, true)) then
imask = compute_required( mask, offset)
@start_masks[offset] = [ mask, imask, imask | mask ]
else
@start_masks[offset] = false
end
end
end
def compute_required( mask, offset )
board = blank_board
0.upto(offset) { | i | board |= 1 << i }
board |= mask
return 0 if (!prunable(board | mask, offset))
board = flood_fill(board,58)
count = 0
imask = 0
0.upto(59) do | i |
if (board[i] == 0) then
imask |= (1 << i)
count += 1
end
end
(count > 0 && count < 5) ? imask : 0
end
def flood_fill( board, location)
return board if (board[location] == 1)
board |= 1 << location
row, col = location.divmod(6)
board = flood_fill( board, location - 1) if (col > 0)
board = flood_fill( board, location + 1) if (col < 4)
if (row % 2 == 0) then
board = flood_fill( board, location - 7) if (col > 0 && row > 0)
board = flood_fill( board, location - 6) if (row > 0)
board = flood_fill( board, location + 6) if (row < 9)
board = flood_fill( board, location + 5) if (col > 0 && row < 9)
else
board = flood_fill( board, location - 5) if (col < 4 && row > 0)
board = flood_fill( board, location - 6) if (row > 0)
board = flood_fill( board, location + 6) if (row < 9)
board = flood_fill( board, location + 7) if (col < 4 && row < 9)
end
board
end
# given a location, produces a list of relative locations covered by the piece at this rotation
def offsets( location)
if is_even( location) then
@even_offsets.collect { | value | value + location }
else
@odd_offsets.collect { | value | value + location }
end
end
# returns a set of offsets relative to the top-left most piece of the rotation (by even or odd rows)
# this is hard to explain. imagine we have this partial board:
# 0 0 0 0 0 x [positions 0-5]
# 0 0 1 1 0 x [positions 6-11]
# 0 0 1 0 0 x [positions 12-17]
# 0 1 0 0 0 x [positions 18-23]
# 0 1 0 0 0 x [positions 24-29]
# 0 0 0 0 0 x [positions 30-35]
# ...
# The top-left of the piece is at position 8, the
# board would be passed as a set of positions (values array) containing [8,9,14,19,25] not necessarily in that
# sorted order. Since that array starts on an odd row, the offsets for an odd row are: [0,1,6,11,17] obtained
# by subtracting 8 from everything. Now imagine the piece shifted up and to the right so it's on an even row:
# 0 0 0 1 1 x [positions 0-5]
# 0 0 1 0 0 x [positions 6-11]
# 0 0 1 0 0 x [positions 12-17]
# 0 1 0 0 0 x [positions 18-23]
# 0 0 0 0 0 x [positions 24-29]
# 0 0 0 0 0 x [positions 30-35]
# ...
# Now the positions are [3,4,8,14,19] which after subtracting the lowest value (3) gives [0,1,5,11,16] thus, the
# offsets for this particular piece are (in even, odd order) [0,1,5,11,16],[0,1,6,11,17] which is what
# this function would return
def normalize_offsets( values)
min = values.min
even_min = is_even(min)
other_min = even_min ? min + 6 : min + 7
other_values = values.collect do | value |
if is_even(value) then
value + 6 - other_min
else
value + 7 - other_min
end
end
values.collect! { | value | value - min }
if even_min then
[values, other_values]
else
[other_values, values]
end
end
# produce a bitmask representation of an array of offset locations
def mask_for_offsets( offsets )
mask = 0
offsets.each { | value | mask = mask + ( 1 << value ) }
mask
end
# finds a "safe" position that a position as described by a list of directions can be placed
# without falling off any edge of the board. the values returned a location to place the first piece
# at so it will fit after making the described moves
def start_adjust( directions )
south = east = 0;
directions.each do | direction |
east += 1 if ( direction == :sw || direction == :nw || direction == :west )
south += 1 if ( direction == :nw || direction == :ne )
end
south * 6 + east
end
# given a set of directions places the piece (as defined by a set of directions) on the board at
# a location that will not take it off the edge
def get_values( directions )
start = start_adjust(directions)
values = [ start ]
directions.each do | direction |
if (start % 12 >= 6) then
start += @@rotation_odd_adder[direction]
else
start += @@rotation_even_adder[direction]
end
values += [ start ]
end
# some moves take you back to an existing location, we'll strip duplicates
values.uniq
end
end
# describes a piece and caches information about its rotations to as to be efficient for iteration
# ATTRIBUTES:
# rotations -- all the rotations of the piece
# type -- a numeic "name" of the piece
# masks -- an array by location of all legal rotational masks (a n inner array) for that location
# placed -- the mask that this piece was last placed at (not a location, but the actual mask used)
class Piece
attr_reader :rotations, :type, :masks
attr_accessor :placed
# transform hashes that change one direction into another when you either flip or rotate a set of directions
@@flip_converter = { :west => :west, :east => :east, :nw => :sw, :ne => :se, :sw => :nw, :se => :ne }
@@rotate_converter = { :west => :nw, :east => :se, :nw => :ne, :ne => :east, :sw => :west, :se => :sw }
def initialize( directions, type )
@type = type
@rotations = Array.new();
@map = {}
generate_rotations( directions )
directions.collect! { | value | @@flip_converter[value] }
generate_rotations( directions )
# creates the masks AND a map that returns [location, rotation] for any given mask
# this is used when a board is found and we want to draw it, otherwise the map is unused
@masks = Array.new();
0.upto(59) do | i |
even = true
@masks[i] = @rotations.collect do | rotation |
mask = rotation.start_masks[i]
@map[mask[0]] = [ i, rotation ] if (mask)
mask || nil
end
@masks[i].compact!
end
end
# rotates a set of directions through all six angles and adds a Rotation to the list for each one
def generate_rotations( directions )
6.times do
rotations.push( Rotation.new(directions))
directions.collect! { | value | @@rotate_converter[value] }
end
end
# given a board string, adds this piece to the board at whatever location/rotation
# important: the outbound board string is 5 wide, the normal location notation is six wide (padded)
def fill_string( board_string)
location, rotation = @map[@placed]
rotation.offsets(location).each do | offset |
row, col = offset.divmod(6)
board_string[ row*5 + col, 1 ] = @type.to_s
end
end
end
# a blank bit board having this form:
#
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 0 0 0 0 0 1
# 1 1 1 1 1 1
#
# where left lest significant bit is the top left and the most significant is the lower right
# the actual board only consists of the 0 places, the 1 places are blockers to keep things from running
# off the edges or bottom
def blank_board
0b111111100000100000100000100000100000100000100000100000100000100000
end
def full_board
0b111111111111111111111111111111111111111111111111111111111111111111
end
# determines if a location (bit position) is in an even row
def is_even( location)
(location % 12) < 6
end
# support function that create three utility maps:
# $converter -- for each row an array that maps a five bit row (via array mapping)
# to the a five bit representation of the bits below it
# $bit_count -- maps a five bit row (via array mapping) to the number of 1s in the row
# @@new_regions -- maps a five bit row (via array mapping) to an array of "region" arrays
# a region array has three values the first is a mask of bits in the region,
# the second is the count of those bits and the third is identical to the first
# examples:
# 0b10010 => [ 0b01100, 2, 0b01100 ], [ 0b00001, 1, 0b00001]
# 0b01010 => [ 0b10000, 1, 0b10000 ], [ 0b00100, 1, 0b00100 ], [ 0b00001, 1, 0b00001]
# 0b10001 => [ 0b01110, 3, 0b01110 ]
def create_collector_support
odd_map = [0b11, 0b110, 0b1100, 0b11000, 0b10000]
even_map = [0b1, 0b11, 0b110, 0b1100, 0b11000]
all_odds = Array.new(0b100000)
all_evens = Array.new(0b100000)
bit_counts = Array.new(0b100000)
new_regions = Array.new(0b100000)
0.upto(0b11111) do | i |
bit_count = odd = even = 0
0.upto(4) do | bit |
if (i[bit] == 1) then
bit_count += 1
odd |= odd_map[bit]
even |= even_map[bit]
end
end
all_odds[i] = odd
all_evens[i] = even
bit_counts[i] = bit_count
new_regions[i] = create_regions( i)
end
$converter = []
10.times { | row | $converter.push((row % 2 == 0) ? all_evens : all_odds) }
$bit_counts = bit_counts
$regions = new_regions.collect { | set | set.collect { | value | [ value, bit_counts[value], value] } }
end
# determines if a board is punable, meaning that there is no possibility that it
# can be filled up with pieces. A board is prunable if there is a grouping of unfilled spaces
# that are not a multiple of five. The following board is an example of a prunable board:
# 0 0 1 0 0
# 0 1 0 0 0
# 1 1 0 0 0
# 0 1 0 0 0
# 0 0 0 0 0
# ...
#
# This board is prunable because the top left corner is only 3 bits in area, no piece will ever fit it
# parameters:
# board -- an initial bit board (6 bit padded rows, see blank_board for format)
# location -- starting location, everything above and to the left is already full
# slotting -- set to true only when testing initial pieces, when filling normally
# additional assumptions are possible
#
# Algorithm:
# The algorithm starts at the top row (as determined by location) and iterates a row at a time
# maintainng counts of active open areas (kept in the collector array) each collector contains
# three values at the start of an iteration:
# 0: mask of bits that would be adjacent to the collector in this row
# 1: the number of bits collected so far
# 2: a scratch space starting as zero, but used during the computation to represent
# the empty bits in the new row that are adjacent (position 0)
# The exact procedure is described in-code
def prunable( board, location, slotting = false)
collectors = []
# loop across the rows
(location / 6).to_i.upto(9) do | row_on |
# obtain a set of regions representing the bits of the current row.
regions = $regions[(board >> (row_on * 6)) & 0b11111]
converter = $converter[row_on]
# track the number of collectors at the start of the cycle so that
# we don't compute against newly created collectors, only existing collectors
initial_collector_count = collectors.length
# loop against the regions. For each region of the row
# we will see if it connects to one or more existing collectors.
# if it connects to 1 collector, the bits from the region are added to the
# bits of the collector and the mask is placed in collector[2]
# If the region overlaps more than one collector then all the collectors
# it overlaps with are merged into the first one (the others are set to nil in the array)
# if NO collectors are found then the region is copied as a new collector
regions.each do | region |
collector_found = nil
region_mask = region[2]
initial_collector_count.times do | collector_num |
collector = collectors[collector_num]
if (collector) then
collector_mask = collector[0]
if (collector_mask & region_mask != 0) then
if (collector_found) then
collector_found[0] |= collector_mask
collector_found[1] += collector[1]
collector_found[2] |= collector[2]
collectors[collector_num] = nil
else
collector_found = collector
collector[1] += region[1]
collector[2] |= region_mask
end
end
end
end
if (collector_found == nil) then
collectors.push(Array.new(region))
end
end
# check the existing collectors, if any collector overlapped no bits in the region its [2] value will
# be zero. The size of any such reaason is tested if it is not a multiple of five true is returned since
# the board is prunable. if it is a multiple of five it is removed.
# Collector that are still active have a new adjacent value [0] set based n the matched bits
# and have [2] cleared out for the next cycle.
collectors.length.times do | collector_num |
collector = collectors[collector_num]
if (collector) then
if (collector[2] == 0) then
return true if (collector[1] % 5 != 0)
collectors[collector_num] = nil
else
# if a collector matches all bits in the row then we can return unprunable early for the
# following reasons:
# 1) there can be no more unavailable bits bince we fill from the top left downward
# 2) all previous regions have been closed or joined so only this region can fail
# 3) this region must be good since there can never be only 1 region that is nuot
# a multiple of five
# this rule only applies when filling normally, so we ignore the rule if we are "slotting"
# in pieces to see what configurations work for them (the only other time this algorithm is used).
return false if (collector[2] == 0b11111 && !slotting)
collector[0] = converter[collector[2]]
collector[2] = 0
end
end
end
# get rid of all the empty converters for the next round
collectors.compact!
end
return false if (collectors.length <= 1) # 1 collector or less and the region is fine
collectors.any? { | collector | (collector[1] % 5) != 0 } # more than 1 and we test them all for bad size
end
# creates a region given a row mask. see prunable for what a "region" is
def create_regions( value )
regions = []
cur_region = 0
5.times do | bit |
if (value[bit] == 0) then
cur_region |= 1 << bit
else
if (cur_region != 0 ) then
regions.push( cur_region)
cur_region = 0;
end
end
end
regions.push(cur_region) if (cur_region != 0)
regions
end
# find up to the counted number of solutions (or all solutions) and prints the final result
def find_all
find_top( 1)
find_top( 0)
print_results
end
# show the board
def print_results
print "#{@boards_found} solutions found\n\n"
print_full_board( @min_board)
print "\n"
print_full_board( @max_board)
print "\n"
end
# finds solutions. This special version of the main function is only used for the top level
# the reason for it is basically to force a particular ordering on how the rotations are tested for
# the first piece. It is called twice, first looking for placements of the odd rotations and then
# looking for placements of the even locations.
#
# WHY?
# Since any found solution has an inverse we want to maximize finding solutions that are not already found
# as an inverse. The inverse will ALWAYS be 3 one of the piece configurations that is exactly 3 rotations away
# (an odd number). Checking even vs odd then produces a higher probability of finding more pieces earlier
# in the cycle. We still need to keep checking all the permutations, but our probability of finding one will
# diminsh over time. Since we are TOLD how many to search for this lets us exit before checking all pieces
# this bennifit is very great when seeking small numbers of solutions and is 0 when looking for more than the
# maximum number
def find_top( rotation_skip)
board = blank_board
(@pieces.length-1).times do
piece = @pieces.shift
piece.masks[0].each do | mask, imask, cmask |
if ((rotation_skip += 1) % 2 == 0) then
piece.placed = mask
find( 1, 1, board | mask)
end
end
@pieces.push(piece)
end
piece = @pieces.shift
@pieces.push(piece)
end
# the normail find routine, iterates through the available pieces, checks all rotations at the current location
# and adds any boards found. depth is achieved via recursion. the overall approach is described
# here: http://www-128.ibm.com/developerworks/java/library/j-javaopt/
# parameters:
# start_location -- where to start looking for place for the next piece at
# placed -- number of pieces placed
# board -- current state of the board
#
# see in-code comments
def find( start_location, placed, board)
# find the next location to place a piece by looking for an empty bit
while board[start_location] == 1
start_location += 1
end
@pieces.length.times do
piece = @pieces.shift
piece.masks[start_location].each do | mask, imask, cmask |
if ( board & cmask == imask) then
piece.placed = mask
if (placed == 9) then
add_board
else
find( start_location + 1, placed + 1, board | mask)
end
end
end
@pieces.push(piece)
end
end
# print the board
def print_full_board( board_string)
10.times do | row |
print " " if (row % 2 == 1)
5.times do | col |
print "#{board_string[row*5 + col,1]} "
end
print "\n"
end
end
# when a board is found we "draw it" into a string and then flip that string, adding both to
# the list (hash) of solutions if they are unique.
def add_board
board_string = "99999999999999999999999999999999999999999999999999"
@all_pieces.each { | piece | piece.fill_string( board_string ) }
save( board_string)
save( board_string.reverse)
end
# adds a board string to the list (if new) and updates the current best/worst board
def save( board_string)
if (@all_boards[board_string] == nil) then
@min_board = board_string if (board_string < @min_board)
@max_board = board_string if (board_string > @max_board)
@all_boards.store(board_string,true)
@boards_found += 1
# the exit motif is a time saver. Ideally the function should return, but those tests
# take noticeable time (performance).
if (@boards_found == @stop_count) then
print_results
exit(0)
end
end
end
##
## MAIN BODY :)
##
create_collector_support
@pieces = [
Piece.new( [ :nw, :ne, :east, :east ], 2),
Piece.new( [ :ne, :se, :east, :ne ], 7),
Piece.new( [ :ne, :east, :ne, :nw ], 1),
Piece.new( [ :east, :sw, :sw, :se ], 6),
Piece.new( [ :east, :ne, :se, :ne ], 5),
Piece.new( [ :east, :east, :east, :se ], 0),
Piece.new( [ :ne, :nw, :se, :east, :se ], 4),
Piece.new( [ :se, :se, :se, :west ], 9),
Piece.new( [ :se, :se, :east, :se ], 8),
Piece.new( [ :east, :east, :sw, :se ], 3)
];
@all_pieces = Array.new( @pieces)
@min_board = "99999999999999999999999999999999999999999999999999"
@max_board = "00000000000000000000000000000000000000000000000000"
@stop_count = ARGV[0].to_i || 2089
@all_boards = {}
@boards_found = 0
find_all ######## DO IT!!!
ruby_2_4 2.047541420906782
ruby_2_4 2.0507780108600855
ruby_2_4 2.05195056181401
ruby_2_4 2.0517996503040195
ruby_2_4 2.0484675746411085
trunk_oct 2.176755669526756
trunk_oct 2.191023667342961
trunk_oct 2.198599934577942
trunk_oct 2.194957667030394
trunk_oct 2.1815862972289324
trunk 2.0796195631846786
trunk 2.0852093128487468
trunk 2.087739490903914
trunk 2.0775687471032143
trunk 2.0768789490684867
modified 2.011031011119485
modified 2.0147771118208766
modified 2.012514960952103
modified 2.029349511489272
modified 2.0183694269508123
-----------------------------------------------------------
so_nbody
# The Computer Language Shootout
# http://shootout.alioth.debian.org
#
# Optimized for Ruby by Jesse Millikan
# From version ported by Michael Neumann from the C gcc version,
# which was written by Christoph Bauer.
SOLAR_MASS = 4 * Math::PI**2
DAYS_PER_YEAR = 365.24
def _puts *args
end
class Planet
attr_accessor :x, :y, :z, :vx, :vy, :vz, :mass
def initialize(x, y, z, vx, vy, vz, mass)
@x, @y, @z = x, y, z
@vx, @vy, @vz = vx * DAYS_PER_YEAR, vy * DAYS_PER_YEAR, vz * DAYS_PER_YEAR
@mass = mass * SOLAR_MASS
end
def move_from_i(bodies, nbodies, dt, i)
while i < nbodies
b2 = bodies[i]
dx = @x - b2.x
dy = @y - b2.y
dz = @z - b2.z
distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
mag = dt / (distance * distance * distance)
b_mass_mag, b2_mass_mag = @mass * mag, b2.mass * mag
@vx -= dx * b2_mass_mag
@vy -= dy * b2_mass_mag
@vz -= dz * b2_mass_mag
b2.vx += dx * b_mass_mag
b2.vy += dy * b_mass_mag
b2.vz += dz * b_mass_mag
i += 1
end
@x += dt * @vx
@y += dt * @vy
@z += dt * @vz
end
end
def energy(bodies)
e = 0.0
nbodies = bodies.size
for i in 0 ... nbodies
b = bodies[i]
e += 0.5 * b.mass * (b.vx * b.vx + b.vy * b.vy + b.vz * b.vz)
for j in (i + 1) ... nbodies
b2 = bodies[j]
dx = b.x - b2.x
dy = b.y - b2.y
dz = b.z - b2.z
distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
e -= (b.mass * b2.mass) / distance
end
end
e
end
def offset_momentum(bodies)
px, py, pz = 0.0, 0.0, 0.0
for b in bodies
m = b.mass
px += b.vx * m
py += b.vy * m
pz += b.vz * m
end
b = bodies[0]
b.vx = - px / SOLAR_MASS
b.vy = - py / SOLAR_MASS
b.vz = - pz / SOLAR_MASS
end
BODIES = [
# sun
Planet.new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
# jupiter
Planet.new(
4.84143144246472090e+00,
-1.16032004402742839e+00,
-1.03622044471123109e-01,
1.66007664274403694e-03,
7.69901118419740425e-03,
-6.90460016972063023e-05,
9.54791938424326609e-04),
# saturn
Planet.new(
8.34336671824457987e+00,
4.12479856412430479e+00,
-4.03523417114321381e-01,
-2.76742510726862411e-03,
4.99852801234917238e-03,
2.30417297573763929e-05,
2.85885980666130812e-04),
# uranus
Planet.new(
1.28943695621391310e+01,
-1.51111514016986312e+01,
-2.23307578892655734e-01,
2.96460137564761618e-03,
2.37847173959480950e-03,
-2.96589568540237556e-05,
4.36624404335156298e-05),
# neptune
Planet.new(
1.53796971148509165e+01,
-2.59193146099879641e+01,
1.79258772950371181e-01,
2.68067772490389322e-03,
1.62824170038242295e-03,
-9.51592254519715870e-05,
5.15138902046611451e-05)
]
init = 200_000 # ARGV[0]
n = Integer(init)
offset_momentum(BODIES)
puts "%.9f" % energy(BODIES)
nbodies = BODIES.size
dt = 0.01
n.times do
i = 0
while i < nbodies
b = BODIES[i]
b.move_from_i(BODIES, nbodies, dt, i + 1)
i += 1
end
end
puts "%.9f" % energy(BODIES)
ruby_2_4 1.0692435251548886
ruby_2_4 1.0717863403260708
ruby_2_4 1.0436121616512537
ruby_2_4 1.0453649098053575
ruby_2_4 1.0412232968956232
trunk_oct 1.1395627679303288
trunk_oct 1.1401907354593277
trunk_oct 1.1666238401085138
trunk_oct 1.1473090779036283
trunk_oct 1.1414265492931008
trunk 1.1804447825998068
trunk 1.1805660296231508
trunk 1.222014680504799
trunk 1.1922595519572496
trunk 1.1758363842964172
modified 1.3207525359466672
modified 1.1673106420785189
modified 1.170576335862279
modified 1.172426039353013
modified 1.1707572042942047
-----------------------------------------------------------
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
ruby_2_4 0.719905311241746
ruby_2_4 0.7226330349221826
ruby_2_4 0.7150830924510956
ruby_2_4 0.7161043388769031
ruby_2_4 0.7214943859726191
trunk_oct 0.7867694590240717
trunk_oct 0.7801391212269664
trunk_oct 0.7814135625958443
trunk_oct 0.8079315591603518
trunk_oct 0.7893188074231148
trunk 0.807498668320477
trunk 0.8206066936254501
trunk 0.8260151613503695
trunk 1.0406140089035034
trunk 0.8309459164738655
modified 0.7884627869352698
modified 0.7770965658128262
modified 0.8238503271713853
modified 0.8142206044867635
modified 0.7768465811386704
-----------------------------------------------------------
so_nsieve
# The Computer Language Shootout
# http://shootout.alioth.debian.org/
#
# contributed by Glenn Parker, March 2005
# modified by Evan Phoenix, Sept 2006
def sieve(m)
flags = Flags.dup[0,m]
count = 0
pmax = m - 1
p = 2
while p <= pmax
unless flags[p].zero?
count += 1
mult = p
while mult <= pmax
flags[mult] = 0
mult += p
end
end
p += 1
end
count
end
n = 9 # (ARGV[0] || 2).to_i
Flags = ("\x1" * ( 2 ** n * 10_000)).unpack("c*")
n.downto(n-2) do |exponent|
break if exponent < 0
m = (1 << exponent) * 10_000
# m = (2 ** exponent) * 10_000
count = sieve(m)
printf "Primes up to %8d %8d\n", m, count
end
ruby_2_4 1.2883011968806386
ruby_2_4 1.2495624162256718
ruby_2_4 1.3429833510890603
ruby_2_4 1.2486428748816252
ruby_2_4 1.270385880023241
trunk_oct 1.3484207838773727
trunk_oct 1.3498019529506564
trunk_oct 1.357909532263875
trunk_oct 1.3465847838670015
trunk_oct 1.3558229487389326
trunk 1.4014641251415014
trunk 1.398685104213655
trunk 1.365258234553039
trunk 1.3697841074317694
trunk 1.3643926996737719
modified 1.355614822357893
modified 1.335494264960289
modified 1.335546520538628
modified 1.3485909719020128
modified 1.3401325568556786
-----------------------------------------------------------
so_nsieve_bits
#!/usr/bin/ruby
#coding: us-ascii
#
# The Great Computer Language Shootout
# http://shootout.alioth.debian.org/
#
# nsieve-bits in Ruby
# Contributed by Glenn Parker, March 2005
CharExponent = 3
BitsPerChar = 1 << CharExponent
LowMask = BitsPerChar - 1
def sieve(m)
items = "\xFF" * ((m / BitsPerChar) + 1)
masks = ""
BitsPerChar.times do |b|
masks << (1 << b).chr
end
count = 0
pmax = m - 1
2.step(pmax, 1) do |p|
if items[p >> CharExponent][p & LowMask] == 1
count += 1
p.step(pmax, p) do |mult|
a = mult >> CharExponent
b = mult & LowMask
items[a] -= masks[b] if items[a][b] != 0
end
end
end
count
end
n = 9 # (ARGV[0] || 2).to_i
n.step(n - 2, -1) do |exponent|
break if exponent < 0
m = 2 ** exponent * 10_000
count = sieve(m)
printf "Primes up to %8d %8d\n", m, count
end
ruby_2_4 1.7433604942634702
ruby_2_4 1.6451375242322683
ruby_2_4 1.8064179215580225
ruby_2_4 1.6669695330783725
ruby_2_4 1.817519586533308
trunk_oct 1.7189516900107265
trunk_oct 1.6876679062843323
trunk_oct 1.6629183059558272
trunk_oct 1.677707408554852
trunk_oct 1.6976082976907492
trunk 1.6943465480580926
trunk 1.68894808832556
trunk 1.772359005175531
trunk 1.6955888979136944
trunk 1.6908907163888216
modified 1.6575268870219588
modified 1.6546079777181149
modified 1.65987831633538
modified 1.652183742262423
modified 1.6511950315907598
-----------------------------------------------------------
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
ruby_2_4 0.5006946781650186
ruby_2_4 0.5013703247532248
ruby_2_4 0.5333143370226026
ruby_2_4 0.4999330872669816
ruby_2_4 0.5011045085266232
trunk_oct 0.5258233770728111
trunk_oct 0.5260475818067789
trunk_oct 0.5254053836688399
trunk_oct 0.5386674739420414
trunk_oct 0.5567600913345814
trunk 0.531104538589716
trunk 0.5377200711518526
trunk 0.5316079715266824
trunk 0.5300312936306
trunk 0.5309334900230169
modified 0.5151661336421967
modified 0.5127241043373942
modified 0.5183673622086644
modified 0.6371085261926055
modified 0.5109165627509356
-----------------------------------------------------------
so_partial_sums
n = 2_500_000 # (ARGV.shift || 1).to_i
alt = 1.0 ; s0 = s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = 0.0
1.upto(n) do |d|
d = d.to_f ; d2 = d * d ; d3 = d2 * d ; ds = Math.sin(d) ; dc = Math.cos(d)
s0 += (2.0 / 3.0) ** (d - 1.0)
s1 += 1.0 / Math.sqrt(d)
s2 += 1.0 / (d * (d + 1.0))
s3 += 1.0 / (d3 * ds * ds)
s4 += 1.0 / (d3 * dc * dc)
s5 += 1.0 / d
s6 += 1.0 / d2
s7 += alt / d
s8 += alt / (2.0 * d - 1.0)
alt = -alt
end
if false
printf("%.9f\t(2/3)^k\n", s0)
printf("%.9f\tk^-0.5\n", s1)
printf("%.9f\t1/k(k+1)\n", s2)
printf("%.9f\tFlint Hills\n", s3)
printf("%.9f\tCookson Hills\n", s4)
printf("%.9f\tHarmonic\n", s5)
printf("%.9f\tRiemann Zeta\n", s6)
printf("%.9f\tAlternating Harmonic\n", s7)
printf("%.9f\tGregory\n", s8)
end
ruby_2_4 1.7108501149341464
ruby_2_4 1.7190658850595355
ruby_2_4 1.7087708888575435
ruby_2_4 1.7101066131144762
ruby_2_4 1.7149731190875173
trunk_oct 1.8198573319241405
trunk_oct 1.804289385676384
trunk_oct 1.8132188878953457
trunk_oct 1.8248246368020773
trunk_oct 1.8023860855028033
trunk 1.8597428305074573
trunk 1.8496416294947267
trunk 1.8608955265954137
trunk 1.8451305078342557
trunk 1.8431661315262318
modified 1.7992861410602927
modified 1.817713798955083
modified 1.8040225887671113
modified 1.8161977380514145
modified 1.8060487266629934
-----------------------------------------------------------
so_pidigits
# The Great Computer Language Shootout
# http://shootout.alioth.debian.org/
#
# contributed by Gabriele Renzi
class PiDigitSpigot
def initialize()
@z = Transformation.new 1,0,0,1
@x = Transformation.new 0,0,0,0
@inverse = Transformation.new 0,0,0,0
end
def next!
@y = @z.extract(3)
if safe? @y
@z = produce(@y)
@y
else
@z = consume @x.next!()
next!()
end
end
def safe?(digit)
digit == @z.extract(4)
end
def produce(i)
@inverse.qrst(10,-10*i,0,1).compose(@z)
end
def consume(a)
@z.compose(a)
end
end
class Transformation
attr_reader :q, :r, :s, :t
def initialize(q, r, s, t)
@q,@r,@s,@t,@k = q,r,s,t,0
end
def next!()
@q = @k = @k + 1
@r = 4 * @k + 2
@s = 0
@t = 2 * @k + 1
self
end
def extract(j)
(@q * j + @r) / (@s * j + @t)
end
def compose(a)
self.class.new( @q * a.q,
@q * a.r + r * a.t,
@s * a.q + t * a.s,
@s * a.r + t * a.t
)
end
def qrst *args
initialize *args
self
end
end
WIDTH = 10
n = 2_500 # Integer(ARGV[0])
j = 0
digits = PiDigitSpigot.new
while n > 0
if n >= WIDTH
WIDTH.times {print digits.next!}
j += WIDTH
else
n.times {print digits.next!}
(WIDTH-n).times {print " "}
j += n
end
puts "\t:"+j.to_s
n -= WIDTH
end
ruby_2_4 0.7657669549807906
ruby_2_4 0.7676611617207527
ruby_2_4 0.7652134895324707
ruby_2_4 0.7640891466289759
ruby_2_4 0.771140843629837
trunk_oct 0.7813822636380792
trunk_oct 0.7845096662640572
trunk_oct 0.7827473403885961
trunk_oct 0.7808729205280542
trunk_oct 0.7816900461912155
trunk 0.7626273678615689
trunk 0.7643931647762656
trunk 0.7597324587404728
trunk 0.762136853300035
trunk 0.8565071411430836
modified 0.7601227127015591
modified 0.7629268858581781
modified 0.7609134977683425
modified 0.7620244491845369
modified 0.7608208199962974
-----------------------------------------------------------
so_random
# from http://www.bagley.org/~doug/shootout/bench/random/random.ruby
IM = 139968.0
IA = 3877.0
IC = 29573.0
$last = 42.0
def gen_random(max)
(max * ($last = ($last * IA + IC) % IM)) / IM
end
N = 3_000_000
i = 0
while i<N
i +=1
gen_random(100.0)
end
# "%.9f" % gen_random(100.0)
ruby_2_4 0.45207184832543135
ruby_2_4 0.45267290249466896
ruby_2_4 0.4520146772265434
ruby_2_4 0.4526656912639737
ruby_2_4 0.4517761915922165
trunk_oct 0.476027300581336
trunk_oct 0.4781214529648423
trunk_oct 0.4769682455807924
trunk_oct 0.476099475286901
trunk_oct 0.47742537315934896
trunk 0.48719506058841944
trunk 0.48832261376082897
trunk 0.4905919851735234
trunk 0.4924090560525656
trunk 0.49773690197616816
modified 0.47766343876719475
modified 0.4811979625374079
modified 0.4770943196490407
modified 0.47776682302355766
modified 0.4771637115627527
-----------------------------------------------------------
so_reverse_complement
#!/usr/bin/ruby
# The Great Computer Language Shootout
# http://shootout.alioth.debian.org/
#
# Contributed by Peter Bjarke Olsen
# Modified by Doug King
seq=Array.new
def revcomp(seq)
seq.reverse!.tr!('wsatugcyrkmbdhvnATUGCYRKMBDHVN','WSTAACGRYMKVHDBNTAACGRYMKVHDBN')
stringlen=seq.length
0.step(stringlen-1,60) {|x| print seq.slice(x,60) , "\n"}
end
input = open(File.join(File.dirname($0), 'fasta.output.2500000'), 'rb')
while input.gets
if $_ =~ />/
if seq.length != 0
revcomp(seq.join)
seq=Array.new
end
puts $_
else
$_.sub(/\n/,'')
seq.push $_
end
end
revcomp(seq.join)
ruby_2_4 1.1043842136859894
ruby_2_4 1.1062881238758564
ruby_2_4 1.1025847280398011
ruby_2_4 1.1173962410539389
ruby_2_4 1.1210448741912842
trunk_oct 1.0926780076697469
trunk_oct 1.0990766854956746
trunk_oct 1.0757757173851132
trunk_oct 1.0826186323538423
trunk_oct 1.0918241180479527
trunk 1.0918039036914706
trunk 1.087092406116426
trunk 1.0832933206111193
trunk 1.123605807311833
trunk 1.085325269959867
modified 1.0883789081126451
modified 1.1149368034675717
modified 1.0898411199450493
modified 1.0963871804997325
modified 1.1007649526000023
-----------------------------------------------------------
so_sieve
# from http://www.bagley.org/~doug/shootout/bench/sieve/sieve.ruby
num = 500
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
ruby_2_4 0.39210155978798866
ruby_2_4 0.3844521101564169
ruby_2_4 0.39479630906134844
ruby_2_4 0.38371561374515295
ruby_2_4 0.3836186872795224
trunk_oct 0.4252029238268733
trunk_oct 0.423957129009068
trunk_oct 0.42327942699193954
trunk_oct 0.4233335228636861
trunk_oct 0.42442364525049925
trunk 0.43371201679110527
trunk 0.4334556171670556
trunk 0.5236137611791492
trunk 0.43084512185305357
trunk 0.4340560557320714
modified 0.4266826771199703
modified 0.4256686447188258
modified 0.4256442617624998
modified 0.42422182857990265
modified 0.4327029436826706
-----------------------------------------------------------
so_spectralnorm
# The Computer Language Shootout
# http://shootout.alioth.debian.org/
# Contributed by Sokolov Yura
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
n = 500 # ARGV[0].to_i
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
str = "%0.9f" % (Math.sqrt(vBv/vv)), "\n"
# print str
ruby_2_4 1.3757685888558626
ruby_2_4 1.293019762262702
ruby_2_4 1.2942099003121257
ruby_2_4 1.2926682839170098
ruby_2_4 1.2930507035925984
trunk_oct 1.4632894545793533
trunk_oct 1.4482001941651106
trunk_oct 1.4469446633011103
trunk_oct 1.458707643672824
trunk_oct 1.4525392772629857
trunk 1.5475740302354097
trunk 1.5351202609017491
trunk 1.5258412286639214
trunk 1.5362128242850304
trunk 1.5235477508977056
modified 1.4421532591804862
modified 1.4420481324195862
modified 1.4596601566299796
modified 1.4404089860618114
modified 1.4472940741106868
-----------------------------------------------------------
string_index
str1 = "あ" * 1024 + "い" # not single byte optimizable
str2 = "い"
100_000.times { str1.index(str2) }
ruby_2_4 0.27286301366984844
ruby_2_4 0.27240108139812946
ruby_2_4 0.2725079823285341
ruby_2_4 0.27242896892130375
ruby_2_4 0.27263053227216005
trunk_oct 0.2807594258338213
trunk_oct 0.2804857147857547
trunk_oct 0.28107733000069857
trunk_oct 0.2806160720065236
trunk_oct 0.2805692683905363
trunk 0.2263137251138687
trunk 0.22610899806022644
trunk 0.22630213107913733
trunk 0.2259977152571082
trunk 0.22610794752836227
modified 0.2284553786739707
modified 0.2283129310235381
modified 0.22833734564483166
modified 0.22823673952370882
modified 0.22853991109877825
-----------------------------------------------------------
string_scan_re
str = Array.new(1_000, 'abc').join(',')
1_000.times { str.scan(/abc/) }
ruby_2_4 0.2079500174149871
ruby_2_4 0.20777677465230227
ruby_2_4 0.2071150355041027
ruby_2_4 0.20754011813551188
ruby_2_4 0.20757359825074673
trunk_oct 0.19626768119633198
trunk_oct 0.19575737044215202
trunk_oct 0.19580966886132956
trunk_oct 0.19548674300312996
trunk_oct 0.22124707140028477
trunk 0.19376169424504042
trunk 0.193414693698287
trunk 0.19344198238104582
trunk 0.19316123612225056
trunk 0.19337948318570852
modified 0.19555887393653393
modified 0.19561755191534758
modified 0.1958187110722065
modified 0.19513331446796656
modified 0.19503659568727016
-----------------------------------------------------------
string_scan_str
str = Array.new(1_000, 'abc').join(',')
1_000.times { str.scan('abc') }
ruby_2_4 0.1889276085421443
ruby_2_4 0.1893777847290039
ruby_2_4 0.18872145470231771
ruby_2_4 0.18897287361323833
ruby_2_4 0.1889195665717125
trunk_oct 0.1451359996572137
trunk_oct 0.14526538085192442
trunk_oct 0.14515735115855932
trunk_oct 0.14494518749415874
trunk_oct 0.14472305122762918
trunk 0.1411191774532199
trunk 0.14889925811439753
trunk 0.1415062490850687
trunk 0.141255890019238
trunk 0.14129992108792067
modified 0.14348130952566862
modified 0.14335066825151443
modified 0.14341404847800732
modified 0.14370747469365597
modified 0.1432449808344245
-----------------------------------------------------------
time_subsec
t = Time.now
4000000.times { t.subsec }
ruby_2_4 2.2449037358164787
ruby_2_4 2.195107350125909
ruby_2_4 2.115496297366917
ruby_2_4 2.432168315164745
ruby_2_4 2.3408427219837904
trunk_oct 1.0012786891311407
trunk_oct 0.9420177778229117
trunk_oct 0.9833070561289787
trunk_oct 0.9848502418026328
trunk_oct 0.9548217430710793
trunk 0.9978848304599524
trunk 1.000202065333724
trunk 0.9817005889490247
trunk 0.9403291270136833
trunk 0.9501170124858618
modified 0.9807577449828386
modified 0.9679672662168741
modified 0.9535470809787512
modified 1.00922045763582
modified 0.9556684540584683
-----------------------------------------------------------
vm1_attr_ivar
class C
attr_reader :a, :b
def initialize
@a = nil
@b = nil
end
end
obj = C.new
i = 0
while i<30_000_000 # while loop 1
i += 1
j = obj.a
k = obj.b
end
ruby_2_4 0.8940521581098437
ruby_2_4 0.9361831760033965
ruby_2_4 0.8942011147737503
ruby_2_4 0.9767392706125975
ruby_2_4 0.900523342192173
trunk_oct 0.9546184968203306
trunk_oct 0.9538245983421803
trunk_oct 0.9520324617624283
trunk_oct 0.951689587906003
trunk_oct 0.9518179660663009
trunk 1.0092729656025767
trunk 1.0128224259242415
trunk 1.0359004186466336
trunk 1.0598388509824872
trunk 1.0102015174925327
modified 0.9663311904296279
modified 0.9783340683206916
modified 0.9616457959637046
modified 0.9615122061222792
modified 0.9743748931214213
-----------------------------------------------------------
vm1_attr_ivar_set
class C
attr_accessor :a, :b
def initialize
@a = nil
@b = nil
end
end
obj = C.new
i = 0
while i<30_000_000 # while loop 1
i += 1
obj.a = 1
obj.b = 2
end
ruby_2_4 0.9847579943016171
ruby_2_4 0.9909547213464975
ruby_2_4 0.9974583191797137
ruby_2_4 1.0135707128793001
ruby_2_4 1.0312126465141773
trunk_oct 1.0171027863398194
trunk_oct 1.0436245640739799
trunk_oct 1.0157041968777776
trunk_oct 1.026420851238072
trunk_oct 1.017745622433722
trunk 1.0477080699056387
trunk 1.0416485210880637
trunk 1.0389733193442225
trunk 1.0370306130498648
trunk 1.0810612300410867
modified 1.0110517730936408
modified 1.014640998095274
modified 1.1719854287803173
modified 1.012173649854958
modified 1.0200687507167459
-----------------------------------------------------------
vm1_block
def m
yield
end
i = 0
while i<30_000_000 # while loop 1
i += 1
m{
}
end
ruby_2_4 1.3672876674681902
ruby_2_4 1.4321664990857244
ruby_2_4 1.4452351871877909
ruby_2_4 1.3687137924134731
ruby_2_4 1.3667716113850474
trunk_oct 1.4375105993822217
trunk_oct 1.493250316940248
trunk_oct 1.437195461243391
trunk_oct 1.4383736765012145
trunk_oct 1.4400127483531833
trunk 1.5101739540696144
trunk 1.5133912693709135
trunk 1.5127917844802141
trunk 1.576439829543233
trunk 1.5135236196219921
modified 1.4131324226036668
modified 1.4112477330490947
modified 1.3813772331923246
modified 1.3814136171713471
modified 1.3800622476264834
-----------------------------------------------------------
vm1_blockparam
def m &b
end
i = 0
while i<30_000_000 # while loop 1
i += 1
m{}
end
ruby_2_4 4.323410007171333
ruby_2_4 4.066246813163161
ruby_2_4 4.06549418810755
ruby_2_4 4.084111415781081
ruby_2_4 4.078505569137633
trunk_oct 4.226216555573046
trunk_oct 4.0945022366940975
trunk_oct 4.1370830507948995
trunk_oct 4.141661386936903
trunk_oct 4.093774465844035
trunk 1.3360264608636498
trunk 1.3317627720534801
trunk 1.3306941576302052
trunk 1.3671083925291896
trunk 1.3328566495329142
modified 1.3931286670267582
modified 1.303077507764101
modified 1.280121510848403
modified 1.3926655855029821
modified 1.259799218736589
-----------------------------------------------------------
vm1_blockparam_call
def m &b
b.call
end
i = 0
while i<30_000_000 # while loop 1
i += 1
m{}
end
ruby_2_4 5.530843419954181
ruby_2_4 5.754100318998098
ruby_2_4 5.4999083718284965
ruby_2_4 5.909824676811695
ruby_2_4 5.453678068704903
trunk_oct 5.718877580016851
trunk_oct 5.781533771194518
trunk_oct 5.642458607442677
trunk_oct 5.682599168270826
trunk_oct 5.789289116859436
trunk 5.694487787783146
trunk 5.730516019277275
trunk 5.847027279436588
trunk 5.7758748000487685
trunk 5.723953898064792
modified 5.916680314578116
modified 5.821031738072634
modified 5.678850069642067
modified 5.626730810850859
modified 5.703656557947397
-----------------------------------------------------------
vm1_blockparam_pass
def bp_yield
yield
end
def bp_pass &b
bp_yield &b
end
i = 0
while i<30_000_000 # while loop 1
i += 1
bp_pass{}
end
ruby_2_4 5.333951806649566
ruby_2_4 5.547041137702763
ruby_2_4 5.390959706157446
ruby_2_4 5.385894214734435
ruby_2_4 5.6055715680122375
trunk_oct 5.652499822899699
trunk_oct 5.614506131969392
trunk_oct 5.441324954852462
trunk_oct 5.449716918170452
trunk_oct 5.473958337679505
trunk 2.4497437700629234
trunk 2.4653187207877636
trunk 2.4396206717938185
trunk 2.4672860093414783
trunk 2.4357821606099606
modified 2.422079913318157
modified 2.254868390969932
modified 2.297367029823363
modified 2.2752416767179966
modified 2.2651320500299335
-----------------------------------------------------------
vm1_blockparam_yield
def bp_yield &b
yield
end
i = 0
while i<30_000_000 # while loop 1
i += 1
bp_yield{}
end
ruby_2_4 4.681193007156253
ruby_2_4 4.585045827552676
ruby_2_4 4.663360565900803
ruby_2_4 4.565610415302217
ruby_2_4 4.560332400724292
trunk_oct 4.770014110952616
trunk_oct 4.693701208569109
trunk_oct 4.669947342947125
trunk_oct 4.6642184145748615
trunk_oct 4.702302381396294
trunk 1.8568331524729729
trunk 2.0619641495868564
trunk 1.8837449587881565
trunk 1.8565067378804088
trunk 1.944807281717658
modified 1.7709983959794044
modified 1.7460943888872862
modified 1.7420761128887534
modified 1.7479670252650976
modified 1.8392816875129938
-----------------------------------------------------------
vm1_const
Const = 1
i = 0
while i<30_000_000 # while loop 1
i += 1
j = Const
k = Const
end
ruby_2_4 0.673799236305058
ruby_2_4 0.6289646802470088
ruby_2_4 0.6426139371469617
ruby_2_4 0.6316197961568832
ruby_2_4 0.637986452318728
trunk_oct 0.6692809769883752
trunk_oct 0.6680225059390068
trunk_oct 0.6677848817780614
trunk_oct 0.6684680609032512
trunk_oct 0.6681160153821111
trunk 0.6811496438458562
trunk 0.6804074477404356
trunk 0.6871226681396365
trunk 0.6811571577563882
trunk 0.6806154483929276
modified 0.6359898326918483
modified 0.6364925857633352
modified 0.6365431845188141
modified 0.6646013855934143
modified 0.635978096164763
-----------------------------------------------------------
vm1_ensure
i = 0
while i<30_000_000 # benchmark loop 1
i += 1
begin
begin
ensure
end
ensure
end
end
ruby_2_4 0.4179206723347306
ruby_2_4 0.4178086072206497
ruby_2_4 0.4177434192970395
ruby_2_4 0.43235581647604704
ruby_2_4 0.41820990294218063
trunk_oct 0.46299421694129705
trunk_oct 0.4627833301201463
trunk_oct 0.4628591099753976
trunk_oct 0.4623630363494158
trunk_oct 0.46261554304510355
trunk 0.4739560689777136
trunk 0.47334925923496485
trunk 0.47417939454317093
trunk 0.47491976618766785
trunk 0.474414368160069
modified 0.4484301460906863
modified 0.44759572576731443
modified 0.4524977933615446
modified 0.4473575744777918
modified 0.44721302296966314
-----------------------------------------------------------
vm1_float_simple
i = 0.0; f = 0.0
while i<30_000_000
i += 1
f += 0.1; f -= 0.1
f += 0.1; f -= 0.1
f += 0.1; f -= 0.1
end
ruby_2_4 3.4377737771719694
ruby_2_4 3.4296320350840688
ruby_2_4 3.4306024936959147
ruby_2_4 3.4263686295598745
ruby_2_4 3.424309113062918
trunk_oct 3.8312151320278645
trunk_oct 3.6576587120071054
trunk_oct 3.659487722441554
trunk_oct 3.6614441787824035
trunk_oct 3.65794943831861
trunk 4.492796437814832
trunk 3.929424907080829
trunk 3.9185613989830017
trunk 3.9249936919659376
trunk 3.916889543645084
modified 3.9276854023337364
modified 4.571953944861889
modified 3.9244422130286694
modified 3.9372902931645513
modified 3.932452884502709
-----------------------------------------------------------
vm1_gc_short_lived
i = 0
while i<30_000_000 # while loop 1
a = '' # short-lived String
b = ''
c = ''
d = ''
e = ''
f = ''
i+=1
end
ruby_2_4 3.970261429436505
ruby_2_4 4.021901831030846
ruby_2_4 3.9680663608014584
ruby_2_4 3.9821827886626124
ruby_2_4 3.966042624786496
trunk_oct 4.3000673381611705
trunk_oct 4.294544079340994
trunk_oct 4.333468989469111
trunk_oct 4.274460714310408
trunk_oct 4.297868913039565
trunk 3.979233019053936
trunk 3.992850139737129
trunk 4.003715254366398
trunk 3.9962109168991446
trunk 3.9884786857292056
modified 3.996678475290537
modified 3.9989688880741596
modified 4.023256856016815
modified 4.071604412049055
modified 3.9946960965171456
-----------------------------------------------------------
vm1_gc_short_with_complex_long
def nested_hash h, n
if n == 0
''
else
10.times{
h[Object.new] = nested_hash(h, n-1)
}
end
end
long_lived = Hash.new
nested_hash long_lived, 6
GC.start
GC.start
i = 0
while i<30_000_000 # while loop 1
a = '' # short-lived String
b = ''
c = ''
d = ''
e = ''
f = ''
i+=1
end
ruby_2_4 4.3283177418634295
ruby_2_4 4.223051902838051
ruby_2_4 4.3000400476157665
ruby_2_4 4.319697103463113
ruby_2_4 4.292609076015651
trunk_oct 4.342072139494121
trunk_oct 4.312078240327537
trunk_oct 4.302175440825522
trunk_oct 4.321224361658096
trunk_oct 4.3238424733281136
trunk 4.518936256878078
trunk 4.378754242323339
trunk 4.368203934282064
trunk 4.377462053671479
trunk 4.401532907038927
modified 4.3588674534112215
modified 4.4546590112149715
modified 4.3608705485239625
modified 4.379730576649308
modified 4.360716417431831
-----------------------------------------------------------
vm1_gc_short_with_long
long_lived = Array.new(1_000_000){|i| "#{i}"}
GC.start
GC.start
i = 0
while i<30_000_000 # while loop 1
a = '' # short-lived String
b = ''
c = ''
d = ''
e = ''
f = ''
i+=1
end
ruby_2_4 4.982936262153089
ruby_2_4 4.7541441433131695
ruby_2_4 4.378576665185392
ruby_2_4 4.787012606859207
ruby_2_4 4.397237667813897
trunk_oct 4.254866898059845
trunk_oct 4.623631022870541
trunk_oct 4.657522251829505
trunk_oct 4.622929994948208
trunk_oct 4.278917017392814
trunk 4.2391941249370575
trunk 4.27221708279103
trunk 4.234884295612574
trunk 4.238052228465676
trunk 4.3883656254038215
modified 4.640468697994947
modified 4.70163459982723
modified 4.644291591830552
modified 4.82427439186722
modified 4.640353991650045
-----------------------------------------------------------
vm1_gc_short_with_symbol
# make many symbols
50_000.times{|i| sym = "sym#{i}".to_sym}
GC.start
GC.start
i = 0
while i<30_000_000 # while loop 1
a = '' # short-lived String
b = ''
c = ''
d = ''
e = ''
f = ''
i+=1
end
ruby_2_4 4.128805799409747
ruby_2_4 4.02243591658771
ruby_2_4 4.0051007606089115
ruby_2_4 4.0175188658759
ruby_2_4 3.99500167183578
trunk_oct 4.341198854148388
trunk_oct 4.330056168138981
trunk_oct 4.374754324555397
trunk_oct 4.303981394506991
trunk_oct 4.302381478250027
trunk 3.9529457790777087
trunk 3.945811789482832
trunk 3.9649920649826527
trunk 3.941321828402579
trunk 3.941511433571577
modified 3.936058273538947
modified 3.938582860864699
modified 3.9256192333996296
modified 3.929445036686957
modified 3.9312875606119633
-----------------------------------------------------------
vm1_gc_wb_ary
short_lived_ary = []
if RUBY_VERSION >= "2.2.0"
GC.start(full_mark: false, immediate_mark: true, immediate_sweep: true)
end
i = 0
short_lived = ''
while i<30_000_000 # while loop 1
short_lived_ary[0] = short_lived # write barrier
i+=1
end
ruby_2_4 0.8134366236627102
ruby_2_4 0.9425155743956566
ruby_2_4 0.810227507725358
ruby_2_4 0.808975649997592
ruby_2_4 0.8090758994221687
trunk_oct 0.9108235044404864
trunk_oct 0.9097813703119755
trunk_oct 0.911210804246366
trunk_oct 0.9071115972474217
trunk_oct 0.9085765732452273
trunk 0.9252893812954426
trunk 0.9267751956358552
trunk 0.9420013297349215
trunk 0.9229717152193189
trunk 0.9266486158594489
modified 0.9228408224880695
modified 0.9194059213623405
modified 0.9216093067079782
modified 0.9501404780894518
modified 0.9196680337190628
-----------------------------------------------------------
vm1_gc_wb_ary_promoted
long_lived = []
if RUBY_VERSION > "2.2.0"
3.times{ GC.start(full_mark: false, immediate_mark: true, immediate_sweep: true) }
elsif
GC.start
end
i = 0
short_lived = ''
while i<30_000_000 # while loop 1
long_lived[0] = short_lived # write barrier
i+=1
end
ruby_2_4 0.8575779218226671
ruby_2_4 0.8530022520571947
ruby_2_4 0.8543383879587054
ruby_2_4 0.8542105630040169
ruby_2_4 0.8523113569244742
trunk_oct 0.9110242640599608
trunk_oct 0.9099698988720775
trunk_oct 0.9093383010476828
trunk_oct 0.9549500085413456
trunk_oct 0.9102202672511339
trunk 0.9235727675259113
trunk 0.9261145163327456
trunk 0.924994352273643
trunk 0.9253526357933879
trunk 0.9257693402469158
modified 0.9208290288224816
modified 0.9178777849301696
modified 0.9308790015056729
modified 0.9178461730480194
modified 0.9206209182739258
-----------------------------------------------------------
vm1_gc_wb_obj
class C
attr_accessor :foo
end
short_lived_obj = C.new
if RUBY_VERSION >= "2.2.0"
GC.start(full_mark: false, immediate_mark: true, immediate_sweep: true)
end
i = 0
short_lived = ''
while i<30_000_000 # while loop 1
short_lived_obj.foo = short_lived # write barrier
i+=1
end
ruby_2_4 0.7344502899795771
ruby_2_4 0.8931145127862692
ruby_2_4 0.7330877706408501
ruby_2_4 0.749016659334302
ruby_2_4 0.7323824623599648
trunk_oct 0.8043870376423001
trunk_oct 0.8180004293099046
trunk_oct 0.8088260889053345
trunk_oct 0.81008714530617
trunk_oct 0.8151710452511907
trunk 0.8501133359968662
trunk 0.8687211591750383
trunk 0.8440206628292799
trunk 0.838344793766737
trunk 0.8429984226822853
modified 0.8177876016125083
modified 0.8066678522154689
modified 0.8085187096148729
modified 0.81284408736974
modified 0.8054432664066553
-----------------------------------------------------------
vm1_gc_wb_obj_promoted
class C
attr_accessor :foo
end
long_lived = C.new
if RUBY_VERSION >= "2.2.0"
3.times{ GC.start(full_mark: false, immediate_mark: true, immediate_sweep: true) }
elsif
GC.start
end
i = 0
short_lived = ''
while i<30_000_000 # while loop 1
long_lived.foo = short_lived # write barrier
i+=1
end
ruby_2_4 0.7713038772344589
ruby_2_4 0.7690691528841853
ruby_2_4 0.7693197317421436
ruby_2_4 0.8243326721712947
ruby_2_4 0.7669011671096087
trunk_oct 0.8541847532615066
trunk_oct 0.8068015901371837
trunk_oct 0.8132928013801575
trunk_oct 0.8073939876630902
trunk_oct 0.8090243171900511
trunk 0.8394197328016162
trunk 0.838859467767179
trunk 0.8391662063077092
trunk 0.8403420718386769
trunk 0.840756275691092
modified 0.8079216973856091
modified 0.8091209465637803
modified 0.8049498107284307
modified 0.8058611880987883
modified 0.8096832763403654
-----------------------------------------------------------
vm1_ivar
@a = 1
i = 0
while i<30_000_000 # while loop 1
i += 1
j = @a
k = @a
end
ruby_2_4 0.6113632088527083
ruby_2_4 0.6074917959049344
ruby_2_4 0.6265815570950508
ruby_2_4 0.6111576156690717
ruby_2_4 0.6082240492105484
trunk_oct 0.6535889031365514
trunk_oct 0.6527379862964153
trunk_oct 0.6531391711905599
trunk_oct 0.6518992781639099
trunk_oct 0.6537933917716146
trunk 0.6642929576337337
trunk 0.6638645865023136
trunk 0.6647167690098286
trunk 0.6630283091217279
trunk 0.662922590970993
modified 0.6466583451256156
modified 0.6454455209895968
modified 0.6463614758104086
modified 0.6491927178576589
modified 0.7741084573790431
-----------------------------------------------------------
vm1_ivar_set
i = 0
while i<30_000_000 # while loop 1
i += 1
@a = 1
@b = 2
end
ruby_2_4 0.7301303874701262
ruby_2_4 0.7190538691356778
ruby_2_4 0.7192482575774193
ruby_2_4 0.7230735840275884
ruby_2_4 0.7273735636845231
trunk_oct 0.7801290303468704
trunk_oct 0.7830705661326647
trunk_oct 0.7808935474604368
trunk_oct 0.7907607415691018
trunk_oct 0.7794415941461921
trunk 0.7882513646036386
trunk 0.7926838779821992
trunk 0.7969612805172801
trunk 0.7911466974765062
trunk 0.7919378839433193
modified 0.7553661717101932
modified 0.7559350840747356
modified 0.7542028333991766
modified 0.9644231786951423
modified 0.7661874806508422
-----------------------------------------------------------
vm1_length
a = 'abc'
b = [1, 2, 3]
i = 0
while i<30_000_000 # while loop 1
i += 1
a.length
b.length
end
ruby_2_4 0.9499629233032465
ruby_2_4 0.7471891790628433
ruby_2_4 0.7477815914899111
ruby_2_4 0.7496443660929799
ruby_2_4 0.7429783688858151
trunk_oct 0.8455419484525919
trunk_oct 0.8420565668493509
trunk_oct 0.8418171619996428
trunk_oct 0.8795920321717858
trunk_oct 0.843876582570374
trunk 0.8602595468983054
trunk 0.8578748377040029
trunk 0.859683527611196
trunk 0.8565905764698982
trunk 0.8621567469090223
modified 0.8514421181753278
modified 0.8480733605101705
modified 0.8490802487358451
modified 0.8487747944891453
modified 0.8645786456763744
-----------------------------------------------------------
vm1_lvar_init
def m v
unless v
# unreachable code
v1 = v2 = v3 = v4 = v5 = v6 = v7 = v8 = v9 = v10 =
v11 = v12 = v13 = v14 = v15 = v16 = v17 = v18 = v19 = v20 =
v21 = v22 = v23 = v24 = v25 = v26 = v27 = v28 = v29 = v30 =
v31 = v32 = v33 = v34 = v35 = v36 = v37 = v38 = v39 = v40 =
v41 = v42 = v43 = v44 = v45 = v46 = v47 = v48 = v49 = v50 = 1
end
end
i = 0
while i<30_000_000 # while loop 1
i += 1
m i
end
ruby_2_4 1.6399649120867252
ruby_2_4 1.6460850648581982
ruby_2_4 1.6384170046076179
ruby_2_4 1.6309055285528302
ruby_2_4 1.6429072571918368
trunk_oct 1.486971840262413
trunk_oct 1.5846282355487347
trunk_oct 1.4553700210526586
trunk_oct 1.4105997858569026
trunk_oct 1.4274101741611958
trunk 1.517898553982377
trunk 1.4890678999945521
trunk 1.4885039739310741
trunk 1.6129294000566006
trunk 1.4784392891451716
modified 1.4039916452020407
modified 1.4010341931134462
modified 1.4139288775622845
modified 1.4136650385335088
modified 1.4194312822073698
-----------------------------------------------------------
vm1_lvar_set
i = 0
while i<30_000_000 # while loop 1
i += 1
a = b = c = d = e = f = g = h = j = k = l = m = n = o = p = q = r = 1
end
ruby_2_4 2.2264384273439646
ruby_2_4 1.966598459519446
ruby_2_4 1.9951813546940684
ruby_2_4 1.96509906090796
ruby_2_4 1.9778020633384585
trunk_oct 2.0322912577539682
trunk_oct 2.033676532097161
trunk_oct 2.0355348279699683
trunk_oct 2.032198586501181
trunk_oct 2.034584636799991
trunk 2.053531794808805
trunk 2.0637367153540254
trunk 2.0529544418677688
trunk 2.0645198402926326
trunk 2.0527466582134366
modified 2.0392724676057696
modified 2.018345307558775
modified 2.0251504778862
modified 2.018694478087127
modified 2.6607636380940676
-----------------------------------------------------------
vm1_neq
i = 0
obj1 = Object.new
obj2 = Object.new
while i<30_000_000 # while loop 1
i += 1
obj1 != obj2
end
ruby_2_4 0.7816581362858415
ruby_2_4 0.7844801908358932
ruby_2_4 0.7806287445127964
ruby_2_4 0.7793467259034514
ruby_2_4 0.7869414901360869
trunk_oct 0.8547707917168736
trunk_oct 0.8404115587472916
trunk_oct 0.8402957199141383
trunk_oct 0.8406060999259353
trunk_oct 0.8465976165607572
trunk 0.8613753188401461
trunk 0.8600517520681024
trunk 0.8556281076744199
trunk 0.8878092262893915
trunk 0.8581048091873527
modified 0.8370948377996683
modified 0.8388927280902863
modified 0.8340346394106746
modified 0.8389740074053407
modified 0.8366635851562023
-----------------------------------------------------------
vm1_not
i = 0
obj = Object.new
while i<30_000_000 # while loop 1
i += 1
!obj
end
ruby_2_4 0.6226228456944227
ruby_2_4 0.6195132406428456
ruby_2_4 0.6300992984324694
ruby_2_4 0.6380940685048699
ruby_2_4 0.6227479642257094
trunk_oct 0.6650179261341691
trunk_oct 0.666659664362669
trunk_oct 0.6778871174901724
trunk_oct 0.6775785461068153
trunk_oct 0.6637949701398611
trunk 0.704634309746325
trunk 0.7034803256392479
trunk 0.7048636814579368
trunk 0.7091738991439342
trunk 0.7086890041828156
modified 0.6704635191708803
modified 0.6725514447316527
modified 0.669091553427279
modified 0.6743245739489794
modified 0.6765706483274698
-----------------------------------------------------------
vm1_rescue
i = 0
while i<30_000_000 # while loop 1
i += 1
begin
rescue
end
end
ruby_2_4 0.48362155817449093
ruby_2_4 0.5607535289600492
ruby_2_4 0.45292704924941063
ruby_2_4 0.45301714166998863
ruby_2_4 0.4538842123001814
trunk_oct 0.5143291726708412
trunk_oct 0.5118257757276297
trunk_oct 0.5105192670598626
trunk_oct 0.6226660376414657
trunk_oct 0.5104353167116642
trunk 0.6674901051446795
trunk 0.5255304118618369
trunk 0.5901393871754408
trunk 0.5251290267333388
trunk 0.5248917480930686
modified 0.512166753411293
modified 0.5233354698866606
modified 0.5263411998748779
modified 0.6144088674336672
modified 0.5253454837948084
-----------------------------------------------------------
vm1_simplereturn
def m
return 1
end
i = 0
while i<30_000_000 # while loop 1
i += 1
m
end
ruby_2_4 0.8855573497712612
ruby_2_4 0.9209818625822663
ruby_2_4 0.8767516976222396
ruby_2_4 0.8701710682362318
ruby_2_4 0.8700376432389021
trunk_oct 0.9268939765170217
trunk_oct 1.1342718796804547
trunk_oct 0.9253498045727611
trunk_oct 1.0367419961839914
trunk_oct 0.9223425947129726
trunk 1.1293946728110313
trunk 0.9584309011697769
trunk 0.9345335988327861
trunk 0.9403315912932158
trunk 0.9330351399257779
modified 0.8541979864239693
modified 0.8389158621430397
modified 0.8456347994506359
modified 0.8340142024680972
modified 0.8410083567723632
-----------------------------------------------------------
vm1_swap
a = 1
b = 2
i = 0
while i<30_000_000 # while loop 1
i += 1
a, b = b, a
end
ruby_2_4 0.5515313819050789
ruby_2_4 0.5509366225451231
ruby_2_4 0.5512991594150662
ruby_2_4 0.5509388176724315
ruby_2_4 0.5789878824725747
trunk_oct 0.5984950447455049
trunk_oct 0.6074849534779787
trunk_oct 0.6047585289925337
trunk_oct 0.6045454321429133
trunk_oct 0.6044688150286674
trunk 0.6128213750198483
trunk 0.6129792667925358
trunk 0.6129238242283463
trunk 0.6129599316045642
trunk 0.6197584327310324
modified 0.596332311630249
modified 0.5994708593934774
modified 0.5955106290057302
modified 0.5936657302081585
modified 0.5934464791789651
-----------------------------------------------------------
vm1_yield
def m
i = 0
while i<30_000_000 # while loop 1
i += 1
yield
end
end
m{}
ruby_2_4 0.9466953705996275
ruby_2_4 0.9468949288129807
ruby_2_4 0.9466270487755537
ruby_2_4 0.9882068214938045
ruby_2_4 1.0067393593490124
trunk_oct 0.988257396966219
trunk_oct 0.988337779417634
trunk_oct 0.9892059173434973
trunk_oct 0.9879414644092321
trunk_oct 0.9914456540718675
trunk 1.0160547094419599
trunk 1.0292068710550666
trunk 1.0243378710001707
trunk 1.007736699655652
trunk 1.0086251655593514
modified 0.9446033472195268
modified 0.9431708427146077
modified 0.9632953153923154
modified 0.9406146509572864
modified 0.9670986672863364
-----------------------------------------------------------
vm2_array
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
a = [1,2,3,4,5,6,7,8,9,10]
end
ruby_2_4 0.6879033893346786
ruby_2_4 0.6807534145191312
ruby_2_4 0.6880061561241746
ruby_2_4 0.6877457061782479
ruby_2_4 0.6876855241134763
trunk_oct 0.6683848490938544
trunk_oct 0.6750662988051772
trunk_oct 0.6738111479207873
trunk_oct 0.6695768916979432
trunk_oct 0.668460575863719
trunk 0.7024285700172186
trunk 0.7039032345637679
trunk 0.7031668955460191
trunk 0.7013489454984665
trunk 0.7017070166766644
modified 0.6952498964965343
modified 0.6990041481330991
modified 0.7041021836921573
modified 0.7116325199604034
modified 0.6965233478695154
-----------------------------------------------------------
vm2_bigarray
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
a = [
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
1,2,3,4,5,6,7,8,9,10,
]
end
ruby_2_4 2.931380044668913
ruby_2_4 2.966919862665236
ruby_2_4 3.022059055045247
ruby_2_4 2.9457194609567523
ruby_2_4 2.9613160230219364
trunk_oct 3.0213973065838218
trunk_oct 3.0098908515647054
trunk_oct 3.004955650307238
trunk_oct 3.006437400355935
trunk_oct 3.0052676936611533
trunk 3.022303474135697
trunk 3.015151779167354
trunk 3.0898205656558275
trunk 3.023872960358858
trunk 3.095117513090372
modified 3.011964120902121
modified 3.005124825052917
modified 2.9446652783080935
modified 3.0019884072244167
modified 2.9988143481314182
-----------------------------------------------------------
vm2_bighash
i = 0
while i<60_000 # benchmark loop 2
i += 1
a = {0=>0, 1=>1, 2=>2, 3=>3, 4=>4, 5=>5, 6=>6, 7=>7, 8=>8, 9=>9, 10=>10, 11=>11, 12=>12, 13=>13, 14=>14, 15=>15, 16=>16, 17=>17, 18=>18, 19=>19, 20=>20, 21=>21, 22=>22, 23=>23, 24=>24, 25=>25, 26=>26, 27=>27, 28=>28, 29=>29, 30=>30, 31=>31, 32=>32, 33=>33, 34=>34, 35=>35, 36=>36, 37=>37, 38=>38, 39=>39, 40=>40, 41=>41, 42=>42, 43=>43, 44=>44, 45=>45, 46=>46, 47=>47, 48=>48, 49=>49, 50=>50, 51=>51, 52=>52, 53=>53, 54=>54, 55=>55, 56=>56, 57=>57, 58=>58, 59=>59, 60=>60, 61=>61, 62=>62, 63=>63, 64=>64, 65=>65, 66=>66, 67=>67, 68=>68, 69=>69, 70=>70, 71=>71, 72=>72, 73=>73, 74=>74, 75=>75, 76=>76, 77=>77, 78=>78, 79=>79, 80=>80, 81=>81, 82=>82, 83=>83, 84=>84, 85=>85, 86=>86, 87=>87, 88=>88, 89=>89, 90=>90, 91=>91, 92=>92, 93=>93, 94=>94, 95=>95, 96=>96, 97=>97, 98=>98, 99=>99, 100=>100, 101=>101, 102=>102, 103=>103, 104=>104, 105=>105, 106=>106, 107=>107, 108=>108, 109=>109, 110=>110, 111=>111, 112=>112, 113=>113, 114=>114, 115=>115, 116=>116, 117=>117, 118=>118, 119=>119, 120=>120, 121=>121, 122=>122, 123=>123, 124=>124, 125=>125, 126=>126, 127=>127, 128=>128, 129=>129, 130=>130, 131=>131, 132=>132, 133=>133, 134=>134, 135=>135, 136=>136, 137=>137, 138=>138, 139=>139, 140=>140, 141=>141, 142=>142, 143=>143, 144=>144, 145=>145, 146=>146, 147=>147, 148=>148, 149=>149, 150=>150, 151=>151, 152=>152, 153=>153, 154=>154, 155=>155, 156=>156, 157=>157, 158=>158, 159=>159, 160=>160, 161=>161, 162=>162, 163=>163, 164=>164, 165=>165, 166=>166, 167=>167, 168=>168, 169=>169, 170=>170, 171=>171, 172=>172, 173=>173, 174=>174, 175=>175, 176=>176, 177=>177, 178=>178, 179=>179, 180=>180, 181=>181, 182=>182, 183=>183, 184=>184, 185=>185, 186=>186, 187=>187, 188=>188, 189=>189, 190=>190, 191=>191, 192=>192, 193=>193, 194=>194, 195=>195, 196=>196, 197=>197, 198=>198, 199=>199, 200=>200, 201=>201, 202=>202, 203=>203, 204=>204, 205=>205, 206=>206, 207=>207, 208=>208, 209=>209, 210=>210, 211=>211, 212=>212, 213=>213, 214=>214, 215=>215, 216=>216, 217=>217, 218=>218, 219=>219, 220=>220, 221=>221, 222=>222, 223=>223, 224=>224, 225=>225, 226=>226, 227=>227, 228=>228, 229=>229, 230=>230, 231=>231, 232=>232, 233=>233, 234=>234, 235=>235, 236=>236, 237=>237, 238=>238, 239=>239, 240=>240, 241=>241, 242=>242, 243=>243, 244=>244, 245=>245, 246=>246, 247=>247, 248=>248, 249=>249, 250=>250, 251=>251, 252=>252, 253=>253, 254=>254, 255=>255, 256=>256, 257=>257, 258=>258, 259=>259, 260=>260, 261=>261, 262=>262, 263=>263, 264=>264, 265=>265, 266=>266, 267=>267, 268=>268, 269=>269, 270=>270, 271=>271, 272=>272, 273=>273, 274=>274, 275=>275, 276=>276, 277=>277, 278=>278, 279=>279, 280=>280, 281=>281, 282=>282, 283=>283, 284=>284, 285=>285, 286=>286, 287=>287, 288=>288, 289=>289, 290=>290, 291=>291, 292=>292, 293=>293, 294=>294, 295=>295, 296=>296, 297=>297, 298=>298, 299=>299, 300=>300, 301=>301, 302=>302, 303=>303, 304=>304, 305=>305, 306=>306, 307=>307, 308=>308, 309=>309, 310=>310, 311=>311, 312=>312, 313=>313, 314=>314, 315=>315, 316=>316, 317=>317, 318=>318, 319=>319, 320=>320, 321=>321, 322=>322, 323=>323, 324=>324, 325=>325, 326=>326, 327=>327, 328=>328, 329=>329, 330=>330, 331=>331, 332=>332, 333=>333, 334=>334, 335=>335, 336=>336, 337=>337, 338=>338, 339=>339, 340=>340, 341=>341, 342=>342, 343=>343, 344=>344, 345=>345, 346=>346, 347=>347, 348=>348, 349=>349, 350=>350, 351=>351, 352=>352, 353=>353, 354=>354, 355=>355, 356=>356, 357=>357, 358=>358, 359=>359, 360=>360, 361=>361, 362=>362, 363=>363, 364=>364, 365=>365, 366=>366, 367=>367, 368=>368, 369=>369, 370=>370, 371=>371, 372=>372, 373=>373, 374=>374, 375=>375, 376=>376, 377=>377, 378=>378, 379=>379, 380=>380, 381=>381, 382=>382, 383=>383, 384=>384, 385=>385, 386=>386, 387=>387, 388=>388, 389=>389, 390=>390, 391=>391, 392=>392, 393=>393, 394=>394, 395=>395, 396=>396, 397=>397, 398=>398, 399=>399, 400=>400, 401=>401, 402=>402, 403=>403, 404=>404, 405=>405, 406=>406, 407=>407, 408=>408, 409=>409, 410=>410, 411=>411, 412=>412, 413=>413, 414=>414, 415=>415, 416=>416, 417=>417, 418=>418, 419=>419, 420=>420, 421=>421, 422=>422, 423=>423, 424=>424, 425=>425, 426=>426, 427=>427, 428=>428, 429=>429, 430=>430, 431=>431, 432=>432, 433=>433, 434=>434, 435=>435, 436=>436, 437=>437, 438=>438, 439=>439, 440=>440, 441=>441, 442=>442, 443=>443, 444=>444, 445=>445, 446=>446, 447=>447, 448=>448, 449=>449, 450=>450, 451=>451, 452=>452, 453=>453, 454=>454, 455=>455, 456=>456, 457=>457, 458=>458, 459=>459, 460=>460, 461=>461, 462=>462, 463=>463, 464=>464, 465=>465, 466=>466, 467=>467, 468=>468, 469=>469, 470=>470, 471=>471, 472=>472, 473=>473, 474=>474, 475=>475, 476=>476, 477=>477, 478=>478, 479=>479, 480=>480, 481=>481, 482=>482, 483=>483, 484=>484, 485=>485, 486=>486, 487=>487, 488=>488, 489=>489, 490=>490, 491=>491, 492=>492, 493=>493, 494=>494, 495=>495, 496=>496, 497=>497, 498=>498, 499=>499, 500=>500,}
end
ruby_2_4 1.0641428176313639
ruby_2_4 1.1071511320769787
ruby_2_4 1.1037046872079372
ruby_2_4 1.0879178764298558
ruby_2_4 1.0978290429338813
trunk_oct 0.4551398176699877
trunk_oct 0.45289504528045654
trunk_oct 0.4548823880031705
trunk_oct 0.4595910431817174
trunk_oct 0.4582721395418048
trunk 0.4610483767464757
trunk 0.46069761365652084
trunk 0.46141425613313913
trunk 0.4581455076113343
trunk 0.45628385432064533
modified 0.4660323280841112
modified 0.466643787920475
modified 0.4625652004033327
modified 0.46597661357373
modified 0.4720247620716691
-----------------------------------------------------------
vm2_case
i = 0
while i<6_000_000 # while loop 2
case :foo
when :bar
raise
when :baz
raise
when :boo
raise
when :foo
i += 1
end
end
ruby_2_4 0.22057433519512415
ruby_2_4 0.16993278078734875
ruby_2_4 0.16992263682186604
ruby_2_4 0.16994296573102474
ruby_2_4 0.1699926108121872
trunk_oct 0.1846805289387703
trunk_oct 0.1841173367574811
trunk_oct 0.18422345630824566
trunk_oct 0.18521067313849926
trunk_oct 0.1874868143349886
trunk 0.19681511167436838
trunk 0.19629650376737118
trunk 0.19628396816551685
trunk 0.19629060570150614
trunk 0.19704224169254303
modified 0.18860022816807032
modified 0.18725387658923864
modified 0.1926647750660777
modified 0.1910641547292471
modified 0.1873056935146451
-----------------------------------------------------------
vm2_case_lit
i = 0
@ret = [ "foo", true, false, :sym, 6, nil, 0.1, 0xffffffffffffffff ]
def foo(i)
@ret[i % @ret.size]
end
while i<6_000_000 # while loop 2
case foo(i)
when "foo" then :foo
when true then true
when false then false
when :sym then :sym
when 6 then :fix
when nil then nil
when 0.1 then :float
when 0xffffffffffffffff then :big
end
i += 1
end
ruby_2_4 0.6838153330609202
ruby_2_4 0.6634501442313194
ruby_2_4 0.6670353524386883
ruby_2_4 0.6622022213414311
ruby_2_4 0.6791366972029209
trunk_oct 0.6602653544396162
trunk_oct 0.6596519201993942
trunk_oct 0.6507228203117847
trunk_oct 0.8084848746657372
trunk_oct 0.6658746609464288
trunk 0.9160970142111182
trunk 0.7322486881166697
trunk 0.7381801595911384
trunk 0.734194764867425
trunk 0.7113137794658542
modified 0.6742148213088512
modified 0.6790109248831868
modified 0.6758620152249932
modified 0.6780694173648953
modified 0.6758277770131826
-----------------------------------------------------------
vm2_defined_method
class Object
define_method(:m){}
end
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
m; m; m; m; m; m; m; m;
end
ruby_2_4 2.2170686880126595
ruby_2_4 2.312459481880069
ruby_2_4 2.222548226825893
ruby_2_4 2.235144617035985
ruby_2_4 2.223838474601507
trunk_oct 2.391143531538546
trunk_oct 2.4075656654313207
trunk_oct 2.436562003567815
trunk_oct 2.389460636302829
trunk_oct 2.464390557259321
trunk 3.0968091571703553
trunk 2.574973779730499
trunk 2.4956702906638384
trunk 2.542401692830026
trunk 2.4175443071871996
modified 2.1891724187880754
modified 2.171085959300399
modified 2.2664444353431463
modified 2.1681242268532515
modified 2.160668938420713
-----------------------------------------------------------
vm2_dstr
i = 0
x = y = 'z'
while i<6_000_000 # benchmark loop 2
i += 1
str = "foo#{x}bar#{y}baz"
end
ruby_2_4 0.9101701565086842
ruby_2_4 0.8535049753263593
ruby_2_4 0.8597821574658155
ruby_2_4 0.8533114967867732
ruby_2_4 0.8564699748530984
trunk_oct 0.9540958851575851
trunk_oct 0.9302140483632684
trunk_oct 0.9056037301197648
trunk_oct 0.908707152120769
trunk_oct 0.9066498735919595
trunk 0.9310823855921626
trunk 0.9244440058246255
trunk 0.9601276246830821
trunk 0.9271508250385523
trunk 0.924890068359673
modified 0.9092350276187062
modified 0.906065777875483
modified 0.9057641513645649
modified 0.9113192986696959
modified 0.9056867714971304
-----------------------------------------------------------
vm2_eval
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
eval("1")
end
ruby_2_4 16.718625208362937
ruby_2_4 17.28424076270312
ruby_2_4 16.972146140411496
ruby_2_4 16.52821529377252
ruby_2_4 16.834049965254962
trunk_oct 17.116188400425017
trunk_oct 17.3485023137182
trunk_oct 17.362054970115423
trunk_oct 17.29709404334426
trunk_oct 17.095396992750466
trunk 18.248213010840118
trunk 18.421063139103353
trunk 18.388740411028266
trunk 18.342810074798763
trunk 18.258126033470035
modified 18.992245567962527
modified 18.69465200509876
modified 18.67924950271845
modified 18.83897701371461
modified 18.925650051794946
-----------------------------------------------------------
vm2_fiber_switch
# based on benchmark for [ruby-core:65518] [Feature #10341] by Knut Franke
fib = Fiber.new do
loop { Fiber.yield }
end
i = 0
while i< 6_000_000 # benchmark loop 2
i += 1
fib.resume
end
ruby_2_4 2.422097958624363
ruby_2_4 2.454029757529497
ruby_2_4 2.4321685172617435
ruby_2_4 2.4711640495806932
ruby_2_4 2.4509651735424995
trunk_oct 2.661185353063047
trunk_oct 2.7320316340774298
trunk_oct 2.673636855557561
trunk_oct 2.6604054234921932
trunk_oct 2.7170183500275016
trunk 2.402249406091869
trunk 2.4175773868337274
trunk 2.4082290772348642
trunk 2.4632625384256244
trunk 2.4030340472236276
modified 2.4314284306019545
modified 2.4604553170502186
modified 2.4275944530963898
modified 2.397690915502608
modified 2.4740118058398366
-----------------------------------------------------------
vm2_method
def m
nil
end
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
m; m; m; m; m; m; m; m;
end
ruby_2_4 0.8423004625365138
ruby_2_4 0.8438723860308528
ruby_2_4 0.8423204245045781
ruby_2_4 0.8452958464622498
ruby_2_4 0.8551852088421583
trunk_oct 0.8381646098569036
trunk_oct 0.960912274196744
trunk_oct 0.9089878024533391
trunk_oct 0.8222297308966517
trunk_oct 0.850903925485909
trunk 0.8685315754264593
trunk 0.8886378156021237
trunk 0.864399241283536
trunk 0.8978807544335723
trunk 0.8778506051748991
modified 0.8053509183228016
modified 0.8025825889781117
modified 0.8039987264201045
modified 0.8023779317736626
modified 0.8136614905670285
-----------------------------------------------------------
vm2_method_missing
class C
def method_missing mid
end
end
obj = C.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
obj.m; obj.m; obj.m; obj.m; obj.m; obj.m; obj.m; obj.m;
end
ruby_2_4 2.039170482195914
ruby_2_4 1.8635820969939232
ruby_2_4 1.8277103146538138
ruby_2_4 1.8445083135738969
ruby_2_4 2.0094737373292446
trunk_oct 1.8583634123206139
trunk_oct 1.8589506382122636
trunk_oct 1.857690591365099
trunk_oct 1.8582142479717731
trunk_oct 1.8586676865816116
trunk 1.878373198211193
trunk 1.8901610262691975
trunk 1.876028592698276
trunk 1.9090906856581569
trunk 1.8919458910822868
modified 1.9104250110685825
modified 1.8112911330536008
modified 1.820550206117332
modified 1.8132611121982336
modified 1.812999022193253
-----------------------------------------------------------
vm2_method_with_block
def m
nil
end
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
m{}; m{}; m{}; m{}; m{}; m{}; m{}; m{};
end
ruby_2_4 0.867371597327292
ruby_2_4 0.8557482482865453
ruby_2_4 1.0366066675633192
ruby_2_4 0.8531498992815614
ruby_2_4 0.8604749869555235
trunk_oct 0.8727079927921295
trunk_oct 0.8797455644235015
trunk_oct 0.8746652277186513
trunk_oct 0.9148074556142092
trunk_oct 0.8730647470802069
trunk 0.9724524775519967
trunk 0.9823746792972088
trunk 0.9800840029492974
trunk 0.9760151570662856
trunk 0.9619612768292427
modified 0.9057921674102545
modified 0.9025661591440439
modified 0.911524998024106
modified 0.9151780940592289
modified 0.9026452135294676
-----------------------------------------------------------
vm2_module_ann_const_set
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
Module.new.const_set(:X, Module.new)
end
ruby_2_4 4.619345954619348
ruby_2_4 4.659718052484095
ruby_2_4 4.575888819992542
ruby_2_4 4.608316856436431
ruby_2_4 4.574162160046399
trunk_oct 4.5983307380229235
trunk_oct 4.654339836910367
trunk_oct 4.713745977729559
trunk_oct 4.619368797168136
trunk_oct 4.699738371185958
trunk 4.761367827653885
trunk 4.655590275302529
trunk 4.645173650234938
trunk 4.664962224662304
trunk 4.756889489479363
modified 4.609621262177825
modified 4.663952679373324
modified 4.634255982935429
modified 4.665562521666288
modified 4.626598101109266
-----------------------------------------------------------
vm2_module_const_set
i = 0
module M
end
$VERBOSE = nil
while i<6_000_000 # benchmark loop 2
i += 1
M.const_set(:X, Module.new)
end
ruby_2_4 4.060350379906595
ruby_2_4 4.092231187969446
ruby_2_4 4.088175083510578
ruby_2_4 4.083009165711701
ruby_2_4 4.062972409650683
trunk_oct 4.027109404094517
trunk_oct 4.024824561551213
trunk_oct 4.121719679795206
trunk_oct 4.024495902471244
trunk_oct 4.056667405180633
trunk 4.137245091609657
trunk 4.14350088685751
trunk 4.163888447917998
trunk 4.181744988076389
trunk 4.1926790764555335
modified 4.447292258031666
modified 4.395610785111785
modified 4.41122838575393
modified 4.446610104292631
modified 4.394822235219181
-----------------------------------------------------------
vm2_mutex
require 'thread'
m = Thread::Mutex.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
m.synchronize{}
end
ruby_2_4 0.6595231629908085
ruby_2_4 0.6693255919963121
ruby_2_4 0.6750112604349852
ruby_2_4 0.6602621739730239
ruby_2_4 0.6614552205428481
trunk_oct 0.5654449770227075
trunk_oct 0.5687443995848298
trunk_oct 0.5646612271666527
trunk_oct 0.5758685832843184
trunk_oct 0.5662791971117258
trunk 0.6083284821361303
trunk 0.5917344084009528
trunk 0.6205710461363196
trunk 0.5969145288690925
trunk 0.6222432870417833
modified 0.5808472177013755
modified 0.5794729962944984
modified 0.579837559722364
modified 0.5805721031501889
modified 0.581592595204711
-----------------------------------------------------------
vm2_newlambda
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
lambda {}
end
ruby_2_4 0.747922221198678
ruby_2_4 0.7412349013611674
ruby_2_4 0.748213168233633
ruby_2_4 0.7613251926377416
ruby_2_4 0.7504190392792225
trunk_oct 0.7616980224847794
trunk_oct 0.7521673496812582
trunk_oct 0.767953003756702
trunk_oct 0.8932927567511797
trunk_oct 0.7512757377699018
trunk 0.9265603190287948
trunk 0.774400619789958
trunk 0.7770624551922083
trunk 0.7769672786816955
trunk 0.7758155073970556
modified 0.7906234571710229
modified 0.7944205170497298
modified 0.8005718803033233
modified 0.7746407268568873
modified 0.7872080132365227
-----------------------------------------------------------
vm2_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<6_000_000 # benchmark loop 2
o = (i % 2 == 0) ? o1 : o2
o.m; o.m; o.m; o.m; o.m; o.m; o.m; o.m
i += 1
end
ruby_2_4 1.963839778676629
ruby_2_4 1.934094225987792
ruby_2_4 2.080768303014338
ruby_2_4 1.921637136489153
ruby_2_4 2.089455271139741
trunk_oct 2.037475165911019
trunk_oct 2.0290770530700684
trunk_oct 1.9655153034254909
trunk_oct 1.966142357327044
trunk_oct 1.9636014988645911
trunk 1.95117795933038
trunk 1.9968231581151485
trunk 1.9227830050513148
trunk 1.933584694750607
trunk 1.9243655977770686
modified 1.8495569434016943
modified 1.8690578322857618
modified 1.8511461419984698
modified 1.875864140689373
modified 1.8929387042298913
-----------------------------------------------------------
vm2_poly_method_ov
class C1
def m
1
end
end
class C2
def m
2
end
end
o1 = C1.new
o2 = C2.new
i = 0
while i<6_000_000 # benchmark loop 2
o = (i % 2 == 0) ? o1 : o2
# o.m; o.m; o.m; o.m; o.m; o.m; o.m; o.m
i += 1
end
ruby_2_4 0.2304581431671977
ruby_2_4 0.23086052108556032
ruby_2_4 0.23029428720474243
ruby_2_4 0.23026043456047773
ruby_2_4 0.23226655181497335
trunk_oct 0.25307000894099474
trunk_oct 0.25292895175516605
trunk_oct 0.25291548762470484
trunk_oct 0.2530162697657943
trunk_oct 0.2528738584369421
trunk 0.25989875197410583
trunk 0.26223669946193695
trunk 0.25995477475225925
trunk 0.25971176009625196
trunk 0.2598541658371687
modified 0.2617475325241685
modified 0.2571541629731655
modified 0.25922003854066133
modified 0.2570143258199096
modified 0.2569133145734668
-----------------------------------------------------------
vm2_poly_singleton
class C1
def m; 1; end
end
o1 = C1.new
o2 = C1.new
o2.singleton_class
i = 0
while i<6_000_000 # benchmark loop 2
o = (i % 2 == 0) ? o1 : o2
o.m; o.m; o.m; o.m; o.m; o.m; o.m; o.m
i += 1
end
ruby_2_4 1.056302455253899
ruby_2_4 1.0928648402914405
ruby_2_4 1.0625794995576143
ruby_2_4 1.0606936272233725
ruby_2_4 1.078374756500125
trunk_oct 1.0855855774134398
trunk_oct 1.0882130227982998
trunk_oct 1.0854570558294654
trunk_oct 1.0824537770822644
trunk_oct 1.089549308642745
trunk 1.2017863914370537
trunk 1.0819554515182972
trunk 1.1675442950800061
trunk 1.0966295739635825
trunk 1.0976999336853623
modified 0.9881633212789893
modified 0.9855323806405067
modified 0.9781452398747206
modified 0.9813648303970695
modified 1.0134037910029292
-----------------------------------------------------------
vm2_proc
def m &b
b
end
pr = m{
a = 1
}
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
pr.call
end
ruby_2_4 0.4128565099090338
ruby_2_4 0.41388774290680885
ruby_2_4 0.4151155147701502
ruby_2_4 0.4231558032333851
ruby_2_4 0.4157105116173625
trunk_oct 0.47645074035972357
trunk_oct 0.4549435758963227
trunk_oct 0.47815077006816864
trunk_oct 0.4594630775973201
trunk_oct 0.47499845642596483
trunk 0.45905072148889303
trunk 0.4490852802991867
trunk 0.46935277059674263
trunk 0.46591903641819954
trunk 0.4639596687629819
modified 0.4550198698416352
modified 0.4550231425091624
modified 0.45700353663414717
modified 0.4505202239379287
modified 0.45555445924401283
-----------------------------------------------------------
vm2_raise1
def rec n
if n > 0
rec n-1
else
raise
end
end
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
begin
rec 1
rescue
# ignore
end
end
ruby_2_4 3.5394127229228616
ruby_2_4 3.5354533502832055
ruby_2_4 3.547255058772862
ruby_2_4 3.5763096641749144
ruby_2_4 3.6347243525087833
trunk_oct 3.6334931487217546
trunk_oct 3.631053696386516
trunk_oct 3.6370621928945184
trunk_oct 3.6772939953953028
trunk_oct 3.680373840034008
trunk 3.5401264261454344
trunk 3.551492450758815
trunk 3.510443389415741
trunk 3.55013904068619
trunk 3.6103051379323006
modified 3.5075750229880214
modified 3.5183465108275414
modified 3.487779026851058
modified 3.483348281122744
modified 3.500735874287784
-----------------------------------------------------------
vm2_raise2
def rec n
if n > 0
rec n-1
else
raise
end
end
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
begin
rec 10
rescue
# ignore
end
end
ruby_2_4 5.640480271540582
ruby_2_4 5.448301689699292
ruby_2_4 5.515504111535847
ruby_2_4 5.5870074620470405
ruby_2_4 5.456209228374064
trunk_oct 5.7030363930389285
trunk_oct 5.694540305994451
trunk_oct 5.649818086065352
trunk_oct 5.63062578253448
trunk_oct 5.656540053896606
trunk 5.551559401676059
trunk 5.569777560420334
trunk 5.563222817145288
trunk 5.5571034997701645
trunk 5.5534384567290545
modified 5.494964850135148
modified 5.474818249233067
modified 5.554188945330679
modified 5.478121626190841
modified 5.453758143819869
-----------------------------------------------------------
vm2_regexp
i = 0
str = 'xxxhogexxx'
while i<6_000_000 # benchmark loop 2
/hoge/ =~ str
i += 1
end
ruby_2_4 0.9345816690474749
ruby_2_4 0.9242771873250604
ruby_2_4 0.9239272149279714
ruby_2_4 0.9228821704164147
ruby_2_4 0.9258621726185083
trunk_oct 0.9708305420354009
trunk_oct 0.9710144801065326
trunk_oct 0.971285181120038
trunk_oct 0.9722117567434907
trunk_oct 0.9702650289982557
trunk 0.9594777878373861
trunk 0.9555474184453487
trunk 0.9562963331118226
trunk 0.955180088058114
trunk 1.1078183818608522
modified 0.9562140889465809
modified 0.9535345397889614
modified 0.9598455727100372
modified 1.1437578722834587
modified 0.9557588761672378
-----------------------------------------------------------
vm2_send
class C
def m
end
end
o = C.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
o.__send__ :m
end
ruby_2_4 0.44093822315335274
ruby_2_4 0.3511182367801666
ruby_2_4 0.32640426233410835
ruby_2_4 0.3316727699711919
ruby_2_4 0.3345595756545663
trunk_oct 0.352178480476141
trunk_oct 0.3620084775611758
trunk_oct 0.3764608381316066
trunk_oct 0.35480916034430265
trunk_oct 0.35190825164318085
trunk 0.36500020045787096
trunk 0.3908478068187833
trunk 0.3618582831695676
trunk 0.35354460310190916
trunk 0.35361377988010645
modified 0.3533921232447028
modified 0.34500707034021616
modified 0.3424664195626974
modified 0.3424155507236719
modified 0.34233205299824476
-----------------------------------------------------------
vm2_string_literal
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
end
ruby_2_4 0.2242958089336753
ruby_2_4 0.22422402538359165
ruby_2_4 0.22474661841988564
ruby_2_4 0.22396460641175508
ruby_2_4 0.223758845590055
trunk_oct 0.24675879627466202
trunk_oct 0.24907668121159077
trunk_oct 0.24585421476513147
trunk_oct 0.24530491791665554
trunk_oct 0.24638168700039387
trunk 0.24748359341174364
trunk 0.24655564408749342
trunk 0.24706194549798965
trunk 0.24715876579284668
trunk 0.24696534126996994
modified 0.25024435948580503
modified 0.24613196030259132
modified 0.24659795686602592
modified 0.24666296411305666
modified 0.24683881178498268
-----------------------------------------------------------
vm2_struct_big_aref_hi
s = Struct.new(*('a'..'z').map { |x| x.to_sym })
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x.z # x[25]
end
ruby_2_4 0.21344923973083496
ruby_2_4 0.21397610567510128
ruby_2_4 0.217591498978436
ruby_2_4 0.21379563584923744
ruby_2_4 0.21339174825698137
trunk_oct 0.23171468172222376
trunk_oct 0.22946237958967686
trunk_oct 0.23697416111826897
trunk_oct 0.22974949423223734
trunk_oct 0.23122762143611908
trunk 0.24169778916984797
trunk 0.23883204255253077
trunk 0.23862307518720627
trunk 0.2353495853021741
trunk 0.23420832119882107
modified 0.22997669409960508
modified 0.23249073885381222
modified 0.23029572889208794
modified 0.2300000386312604
modified 0.23080481868237257
-----------------------------------------------------------
vm2_struct_big_aref_lo
s = Struct.new(*('a'..'z').map { |x| x.to_sym })
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x.k # x[10]
end
ruby_2_4 0.21380270086228848
ruby_2_4 0.21652668341994286
ruby_2_4 0.21335487347096205
ruby_2_4 0.21319017373025417
ruby_2_4 0.21349182538688183
trunk_oct 0.23108083102852106
trunk_oct 0.2292939554899931
trunk_oct 0.23041626904159784
trunk_oct 0.2300979197025299
trunk_oct 0.2305571949109435
trunk 0.2375079859048128
trunk 0.23326641041785479
trunk 0.23563627060502768
trunk 0.23800937086343765
trunk 0.24457866325974464
modified 0.2302206726744771
modified 0.2318198699504137
modified 0.23002019617706537
modified 0.23473106231540442
modified 0.2328773932531476
-----------------------------------------------------------
vm2_struct_big_aset
s = Struct.new(*('a'..'z').map { |x| x.to_sym })
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x.k = i # x[10] = i
end
ruby_2_4 0.237123042345047
ruby_2_4 0.23770717903971672
ruby_2_4 0.23782570008188486
ruby_2_4 0.2375199142843485
ruby_2_4 0.23752303794026375
trunk_oct 0.25586198177188635
trunk_oct 0.2607412366196513
trunk_oct 0.25639444775879383
trunk_oct 0.25619821809232235
trunk_oct 0.26105878222733736
trunk 0.276278723962605
trunk 0.2640425283461809
trunk 0.2640023520216346
trunk 0.26203485764563084
trunk 0.2613731427118182
modified 0.2565210144966841
modified 0.2554275533184409
modified 0.261544949375093
modified 0.2584812864661217
modified 0.25929547008126974
-----------------------------------------------------------
vm2_struct_big_href_hi
s = Struct.new(*('a'..'z').map { |x| x.to_sym })
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x[:z]
end
ruby_2_4 0.2956023393198848
ruby_2_4 0.29406770318746567
ruby_2_4 0.2973213540390134
ruby_2_4 0.29400819819420576
ruby_2_4 0.32877590134739876
trunk_oct 0.3160199113190174
trunk_oct 0.3162379711866379
trunk_oct 0.3199714124202728
trunk_oct 0.3159192204475403
trunk_oct 0.3194360602647066
trunk 0.3197044301778078
trunk 0.3190050721168518
trunk 0.31957393046468496
trunk 0.31953003723174334
trunk 0.32402434945106506
modified 0.3220282318070531
modified 0.3208946082741022
modified 0.3235566969960928
modified 0.32100933603942394
modified 0.32172038685530424
-----------------------------------------------------------
vm2_struct_big_href_lo
s = Struct.new(*('a'..'z').map { |x| x.to_sym })
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x[:k]
end
ruby_2_4 0.2955749547109008
ruby_2_4 0.2968687806278467
ruby_2_4 0.29402787424623966
ruby_2_4 0.29421871062368155
ruby_2_4 0.29441249556839466
trunk_oct 0.3169121276587248
trunk_oct 0.31676657870411873
trunk_oct 0.316965913400054
trunk_oct 0.31633466575294733
trunk_oct 0.31708176899701357
trunk 0.3155637374147773
trunk 0.31557241454720497
trunk 0.3170522041618824
trunk 0.31569164246320724
trunk 0.32466521114110947
modified 0.3197305202484131
modified 0.31763041485100985
modified 0.32271901704370975
modified 0.319657277315855
modified 0.3573391120880842
-----------------------------------------------------------
vm2_struct_big_hset
s = Struct.new(*('a'..'z').map { |x| x.to_sym })
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x[:k] = i
end
ruby_2_4 0.32773155719041824
ruby_2_4 0.3178493306040764
ruby_2_4 0.38019675668329
ruby_2_4 0.31493213027715683
ruby_2_4 0.3149310601875186
trunk_oct 0.4199048327282071
trunk_oct 0.3492139717563987
trunk_oct 0.33906652592122555
trunk_oct 0.3397403694689274
trunk_oct 0.3427045922726393
trunk 0.35118310432881117
trunk 0.34319135546684265
trunk 0.33946997858583927
trunk 0.34831795562058687
trunk 0.341691636480391
modified 0.33613864053040743
modified 0.3377050971612334
modified 0.33593417797237635
modified 0.33531004190444946
modified 0.33575355913490057
-----------------------------------------------------------
vm2_struct_small_aref
s = Struct.new(:a, :b, :c)
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x.a
end
ruby_2_4 0.17449604999274015
ruby_2_4 0.17508253175765276
ruby_2_4 0.19363085366785526
ruby_2_4 0.17165197525173426
ruby_2_4 0.1728421477600932
trunk_oct 0.1850651791319251
trunk_oct 0.18484944198280573
trunk_oct 0.20156569592654705
trunk_oct 0.18485073372721672
trunk_oct 0.18680202402174473
trunk 0.19028134737163782
trunk 0.19372699316591024
trunk 0.20207310747355223
trunk 0.19292897451668978
trunk 0.1917476151138544
modified 0.19039233773946762
modified 0.19071171060204506
modified 0.1903015300631523
modified 0.19258555117994547
modified 0.19024861883372068
-----------------------------------------------------------
vm2_struct_small_aset
s = Struct.new(:a, :b, :c)
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x.a = i
end
ruby_2_4 0.25045622419565916
ruby_2_4 0.23791306093335152
ruby_2_4 0.23771726433187723
ruby_2_4 0.23955964390188456
ruby_2_4 0.23769354820251465
trunk_oct 0.25829240400344133
trunk_oct 0.2582491235807538
trunk_oct 0.2548843575641513
trunk_oct 0.2609655661508441
trunk_oct 0.2565011428669095
trunk 0.26237039268016815
trunk 0.26467520371079445
trunk 0.25748176779598
trunk 0.2627118919044733
trunk 0.2809766186401248
modified 0.2552326526492834
modified 0.2547570103779435
modified 0.25718350149691105
modified 0.2533710990101099
modified 0.2571981279179454
-----------------------------------------------------------
vm2_struct_small_href
s = Struct.new(:a, :b, :c)
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x[:a]
end
ruby_2_4 0.3107422664761543
ruby_2_4 0.26587213203310966
ruby_2_4 0.26511883549392223
ruby_2_4 0.2645557839423418
ruby_2_4 0.2656591599807143
trunk_oct 0.2861583763733506
trunk_oct 0.28642769157886505
trunk_oct 0.2848404301330447
trunk_oct 0.28455453272908926
trunk_oct 0.2833607839420438
trunk 0.29093282483518124
trunk 0.28454430401325226
trunk 0.29215049371123314
trunk 0.286106014624238
trunk 0.33175021782517433
modified 0.30096718948334455
modified 0.2913954993709922
modified 0.29156415816396475
modified 0.293227132409811
modified 0.2894948963075876
-----------------------------------------------------------
vm2_struct_small_hset
s = Struct.new(:a, :b, :c)
x = s.new
i = 0
while i<6_000_000 # benchmark loop 2
i += 1
x[:a] = 1
end
ruby_2_4 0.2780542057007551
ruby_2_4 0.27570487186312675
ruby_2_4 0.2762524439021945
ruby_2_4 0.2763327965512872
ruby_2_4 0.27646281104534864
trunk_oct 0.302474114112556
trunk_oct 0.2997535187751055
trunk_oct 0.29909030161798
trunk_oct 0.30033108964562416
trunk_oct 0.3027640711516142
trunk 0.30328572914004326
trunk 0.3048247080296278
trunk 0.30345460679382086
trunk 0.3149544820189476
trunk 0.3065588315948844
modified 0.2999376291409135
modified 0.2998925680294633
modified 0.2997020659968257
modified 0.2996747409924865
modified 0.29957148246467113
-----------------------------------------------------------
vm2_super
class C
def m
1
end
end
class CC < C
def m
super()
end
end
obj = CC.new
i = 0
while i<6_000_000 # benchmark loop 2
obj.m
i += 1
end
ruby_2_4 0.3951922683045268
ruby_2_4 0.4017675332725048
ruby_2_4 0.4021150805056095
ruby_2_4 0.3992750383913517
ruby_2_4 0.3936321884393692
trunk_oct 0.42028992623090744
trunk_oct 0.4107969691976905
trunk_oct 0.41471547819674015
trunk_oct 0.4108435697853565
trunk_oct 0.4127252772450447
trunk 0.4508631359785795
trunk 0.42626385670155287
trunk 0.43682218529284
trunk 0.47110701259225607
trunk 0.43810966424643993
modified 0.4058084189891815
modified 0.41138959024101496
modified 0.4901592433452606
modified 0.5379780912771821
modified 0.40996528416872025
-----------------------------------------------------------
vm2_unif1
i = 0
def m a, b
end
while i<6_000_000 # benchmark loop 2
i += 1
m 100, 200
end
ruby_2_4 0.20211779046803713
ruby_2_4 0.20484201051294804
ruby_2_4 0.20152448397129774
ruby_2_4 0.2014916529878974
ruby_2_4 0.23751750402152538
trunk_oct 0.21408810932189226
trunk_oct 0.21340340841561556
trunk_oct 0.2134730014950037
trunk_oct 0.2151914518326521
trunk_oct 0.21884607058018446
trunk 0.22066356614232063
trunk 0.22461617179214954
trunk 0.2248547663912177
trunk 0.2174307955428958
trunk 0.21866703312844038
modified 0.2219256730750203
modified 0.20623823441565037
modified 0.20549296401441097
modified 0.20561531465500593
modified 0.20531604439020157
-----------------------------------------------------------
vm2_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<6_000_000 # benchmark loop 2
obj.m 10
i += 1
end
ruby_2_4 0.4094451926648617
ruby_2_4 0.41061127558350563
ruby_2_4 0.428572547622025
ruby_2_4 0.4093203730881214
ruby_2_4 0.40922017209231853
trunk_oct 0.4286733577027917
trunk_oct 0.4332756930962205
trunk_oct 0.42789354640990496
trunk_oct 0.4314629463478923
trunk_oct 0.42741391342133284
trunk 0.4509992506355047
trunk 0.4631134122610092
trunk 0.4614688018336892
trunk 0.4455903647467494
trunk 0.4530133754014969
modified 0.4233180331066251
modified 0.4302905136719346
modified 0.4214795436710119
modified 0.42994418181478977
modified 0.4232106199488044
-----------------------------------------------------------
vm3_backtrace
# get last backtrace
begin
caller(0, 0)
rescue ArgumentError
alias caller_orig caller
def caller lev, n
caller_orig(lev)[0..n]
end
end
def rec n
if n < 0
100_000.times{
caller(0, 1)
}
else
rec(n-1)
end
end
rec 50
ruby_2_4 0.13976429589092731
ruby_2_4 0.14181318506598473
ruby_2_4 0.14070920087397099
ruby_2_4 0.13924666307866573
ruby_2_4 0.13842553365975618
trunk_oct 0.14890534058213234
trunk_oct 0.1486876830458641
trunk_oct 0.148668278940022
trunk_oct 0.14734627772122622
trunk_oct 0.1475882139056921
trunk 0.14486138895154
trunk 0.14541300386190414
trunk 0.14550993219017982
trunk 0.14565506856888533
trunk 0.1454340536147356
modified 0.1477775750681758
modified 0.1478390097618103
modified 0.14856997039169073
modified 0.14936698973178864
modified 0.14932245388627052
-----------------------------------------------------------
vm3_clearmethodcache
i = 0
while i<200_000
i += 1
Class.new{
def m; end
}
end
ruby_2_4 0.24222776386886835
ruby_2_4 0.24177947640419006
ruby_2_4 0.24186649173498154
ruby_2_4 0.24268512707203627
ruby_2_4 0.24360188283026218
trunk_oct 0.25108938571065664
trunk_oct 0.25082196667790413
trunk_oct 0.2502557262778282
trunk_oct 0.2515487913042307
trunk_oct 0.2527437163516879
trunk 0.2563631907105446
trunk 0.25704192370176315
trunk 0.2594701098278165
trunk 0.2549857506528497
trunk 0.25579832773655653
modified 0.255524723790586
modified 0.25609891675412655
modified 0.2549712099134922
modified 0.25689463410526514
modified 0.2579151727259159
-----------------------------------------------------------
vm3_gc
5000.times do
100.times do
{"xxxx"=>"yyyy"}
end
GC.start
end
ruby_2_4 2.1808535512536764
ruby_2_4 2.1949819196015596
ruby_2_4 2.202510980889201
ruby_2_4 2.1810358176007867
ruby_2_4 2.169563232921064
trunk_oct 2.761144170537591
trunk_oct 2.733060118742287
trunk_oct 2.756712385453284
trunk_oct 2.72822342813015
trunk_oct 2.7328729294240475
trunk 2.6345444936305285
trunk 2.606421608477831
trunk 2.6109197372570634
trunk 2.613246292807162
trunk 2.614854392595589
modified 2.678764186799526
modified 2.704426043666899
modified 2.6760713532567024
modified 2.677072836086154
modified 2.6793594984337687
-----------------------------------------------------------
vm3_gc_old_full
old_object = Array.new(1_000_000){''}
100.times do
GC.start
end
ruby_2_4 2.141999989748001
ruby_2_4 2.1419968958944082
ruby_2_4 2.1426977291703224
ruby_2_4 2.136960718780756
ruby_2_4 2.1392890214920044
trunk_oct 2.1865233182907104
trunk_oct 2.274385235272348
trunk_oct 2.179888876155019
trunk_oct 2.1775283878669143
trunk_oct 2.245344441384077
trunk 2.1516162725165486
trunk 2.1461330223828554
trunk 2.149570361711085
trunk 2.1482705660164356
trunk 2.1446994999423623
modified 2.138347951695323
modified 2.1400753119960427
modified 2.140069996006787
modified 2.137915234081447
modified 2.144130096770823
-----------------------------------------------------------
vm3_gc_old_immediate
old_object = Array.new(1_000_000){''}
30_000.times do
GC.start(full_mark: false, immediate_sweep: true)
end
ruby_2_4 2.023003295995295
ruby_2_4 3.3983790362253785
ruby_2_4 2.040706943720579
ruby_2_4 2.027483052574098
ruby_2_4 2.0229092855006456
trunk_oct 2.1300259893760085
trunk_oct 2.1187731930986047
trunk_oct 2.130536242388189
trunk_oct 2.1557531729340553
trunk_oct 2.12240943685174
trunk 2.0149036338552833
trunk 2.0086050499230623
trunk 2.026668718084693
trunk 2.03363323956728
trunk 2.015575715340674
modified 2.029278125613928
modified 2.087109581567347
modified 2.0583449248224497
modified 2.060246811248362
modified 2.0606304025277495
-----------------------------------------------------------
vm3_gc_old_lazy
old_object = Array.new(1_000_000){''}
30_000.times do
GC.start(full_mark: false, immediate_sweep: false)
end
ruby_2_4 2.627276225015521
ruby_2_4 2.5897014904767275
ruby_2_4 2.6325794626027346
ruby_2_4 2.640420876443386
ruby_2_4 2.6140017388388515
trunk_oct 2.690549506805837
trunk_oct 2.7807156117632985
trunk_oct 2.7773546064272523
trunk_oct 2.828917007893324
trunk_oct 2.7557871378958225
trunk 2.615165615454316
trunk 2.5989129208028316
trunk 2.5958776073530316
trunk 2.6180637245997787
trunk 2.6339213913306594
modified 2.6669311355799437
modified 2.5608460353687406
modified 2.652139972895384
modified 2.640227389521897
modified 2.644776060245931
-----------------------------------------------------------
vm_symbol_block_pass
class C
1000.times {|i|
eval("def i#{i};end")
}
end
c = C.new
m = C.instance_methods(false)
5_000.times do
m.each do |n|
c.tap(&n)
end
end
ruby_2_4 0.6890878435224295
ruby_2_4 0.6789304381236434
ruby_2_4 0.6896575298160315
ruby_2_4 0.6858800454065204
ruby_2_4 0.6808324698358774
trunk_oct 0.7159304311499
trunk_oct 0.7185308868065476
trunk_oct 0.7166847521439195
trunk_oct 0.7173843132331967
trunk_oct 0.7146834107115865
trunk 0.6871357448399067
trunk 0.8641062695533037
trunk 0.6929481225088239
trunk 0.6984733147546649
trunk 0.7233011610805988
modified 0.6684396453201771
modified 0.6734270388260484
modified 0.677773923613131
modified 0.674062218517065
modified 0.6768492441624403
-----------------------------------------------------------
vm_thread_alive_check1
5_000.times{
t = Thread.new{}
while t.alive?
Thread.pass
end
}
ruby_2_4 0.08003556728363037
ruby_2_4 0.08068436197936535
ruby_2_4 0.08161660190671682
ruby_2_4 0.08106287848204374
ruby_2_4 0.0810283413156867
trunk_oct 0.08925117831677198
trunk_oct 0.08755378797650337
trunk_oct 0.09206554852426052
trunk_oct 0.09126275312155485
trunk_oct 0.09024572279304266
trunk 0.09116620477288961
trunk 0.09324696101248264
trunk 0.09281659591943026
trunk 0.0924611184746027
trunk 0.09237904474139214
modified 0.09318399615585804
modified 0.09221791848540306
modified 0.09026079624891281
modified 0.09599153976887465
modified 0.09209492430090904
-----------------------------------------------------------
vm_thread_close
1000.times { Thread.new { sleep } }
i = 0
while i<100_000 # benchmark loop 3
i += 1
IO.pipe.each(&:close)
end
ruby_2_4 0.42705254163593054
ruby_2_4 0.427050594240427
ruby_2_4 0.4206481482833624
ruby_2_4 0.43131527677178383
ruby_2_4 0.42766829673200846
trunk_oct 0.4692115820944309
trunk_oct 0.46141284238547087
trunk_oct 0.4690132746472955
trunk_oct 0.46218116115778685
trunk_oct 0.45972640346735716
trunk 0.42320986092090607
trunk 0.45503614749759436
trunk 0.4337203064933419
trunk 0.43977702502161264
trunk 0.4371778555214405
modified 0.44170696195214987
modified 0.43477920815348625
modified 0.4264431083574891
modified 0.4559372551739216
modified 0.4402331728488207
-----------------------------------------------------------
vm_thread_condvar1
# two threads, two mutex, two condvar ping-pong
require 'thread'
m1 = Mutex.new
m2 = Mutex.new
cv1 = ConditionVariable.new
cv2 = ConditionVariable.new
max = 100000
i = 0
wait = nil
m2.synchronize do
wait = Thread.new do
m1.synchronize do
m2.synchronize { cv2.signal }
while (i += 1) < max
cv1.wait(m1)
cv2.signal
end
end
end
cv2.wait(m2)
end
m1.synchronize do
while i < max
cv1.signal
cv2.wait(m1)
end
end
wait.join
ruby_2_4 0.5068395948037505
ruby_2_4 0.49922027718275785
ruby_2_4 0.4905734695494175
ruby_2_4 0.4925146587193012
ruby_2_4 0.4913450004532933
trunk_oct 0.4958278760313988
trunk_oct 0.5044522285461426
trunk_oct 0.4982830863445997
trunk_oct 0.5141279632225633
trunk_oct 0.4914207458496094
trunk 0.5172950820997357
trunk 0.4956356957554817
trunk 0.5055789640173316
trunk 0.5096529806032777
trunk 0.5066920025274158
modified 0.5183016061782837
modified 0.505222762003541
modified 0.5065654776990414
modified 0.5229422217234969
modified 0.5088327694684267
-----------------------------------------------------------
vm_thread_condvar2
# many threads, one mutex, many condvars
require 'thread'
m = Mutex.new
cv1 = ConditionVariable.new
cv2 = ConditionVariable.new
max = 1000
n = 100
waiting = 0
scvs = []
waiters = n.times.map do |i|
start_cv = ConditionVariable.new
scvs << start_cv
start_mtx = Mutex.new
start_mtx.synchronize do
th = Thread.new(start_mtx, start_cv) do |sm, scv|
m.synchronize do
sm.synchronize { scv.signal }
max.times do
cv2.signal if (waiting += 1) == n
cv1.wait(m)
end
end
end
start_cv.wait(start_mtx)
th
end
end
m.synchronize do
max.times do
cv2.wait(m) until waiting == n
waiting = 0
cv1.broadcast
end
end
waiters.each(&:join)
ruby_2_4 0.5233125993981957
ruby_2_4 0.5059186508879066
ruby_2_4 0.507368789985776
ruby_2_4 0.5143058598041534
ruby_2_4 0.5199752040207386
trunk_oct 0.3867679750546813
trunk_oct 0.39505081437528133
trunk_oct 0.39263651613146067
trunk_oct 0.3886463074013591
trunk_oct 0.3922042930498719
trunk 0.3818937102332711
trunk 0.3922112910076976
trunk 0.37229993753135204
trunk 0.38149037305265665
trunk 0.3780381288379431
modified 0.39039106015115976
modified 0.3820401728153229
modified 0.37418060563504696
modified 0.4052897710353136
modified 0.3839657995849848
-----------------------------------------------------------
vm_thread_create_join
i = 0
while i<100_000 # benchmark loop 3
i += 1
Thread.new{
}.join
end
ruby_2_4 0.998861400410533
ruby_2_4 0.9487500442191958
ruby_2_4 1.0203588297590613
ruby_2_4 1.012604946270585
ruby_2_4 0.9807319212704897
trunk_oct 0.983495332300663
trunk_oct 0.9638786651194096
trunk_oct 0.9679070468991995
trunk_oct 0.9961703261360526
trunk_oct 0.9701418615877628
trunk 1.020853460766375
trunk 0.993821419775486
trunk 1.0322873266413808
trunk 1.0600321358069777
trunk 1.0560854859650135
modified 1.0198526559397578
modified 1.074254672974348
modified 0.9961341228336096
modified 1.0161309856921434
modified 1.0036895759403706
-----------------------------------------------------------
vm_thread_mutex1
# one thread, one mutex (no contention)
require 'thread'
m = Thread::Mutex.new
r = 0
max = 2000
lmax = max * max
(1..1).map{
Thread.new{
i = 0
while i<lmax
i += 1
m.synchronize{
r += 1
}
end
}
}.each{|e|
e.join
}
raise r.to_s if r != max * max
ruby_2_4 0.4960473794490099
ruby_2_4 0.6460710074752569
ruby_2_4 0.496061940677464
ruby_2_4 0.503277369774878
ruby_2_4 0.497000097297132
trunk_oct 0.5820590993389487
trunk_oct 0.43677283078432083
trunk_oct 0.43682778533548117
trunk_oct 0.47659938130527735
trunk_oct 0.4396412316709757
trunk 0.4602205902338028
trunk 0.4565476346760988
trunk 0.4605985153466463
trunk 0.4600034775212407
trunk 0.4622178338468075
modified 0.44742385298013687
modified 0.44924879632890224
modified 0.4479735055938363
modified 0.4526807554066181
modified 0.47652481868863106
-----------------------------------------------------------
vm_thread_mutex2
# two threads, one mutex
require 'thread'
m = Thread::Mutex.new
r = 0
max = 2000
lmax = (max * max)/2
(1..2).map{
Thread.new{
i = 0
while i<lmax
i += 1
m.synchronize{
r += 1
}
end
}
}.each{|e|
e.join
}
raise r.to_s if r != max * max
ruby_2_4 2.322713453322649
ruby_2_4 1.846596010029316
ruby_2_4 1.6483780713751912
ruby_2_4 2.0987603552639484
ruby_2_4 1.7402854058891535
trunk_oct 0.4340166384354234
trunk_oct 0.43856405559927225
trunk_oct 0.4442194104194641
trunk_oct 0.4382934523746371
trunk_oct 0.4406911004334688
trunk 0.4569590147584677
trunk 0.4601500341668725
trunk 0.4615392005071044
trunk 0.4574607899412513
trunk 0.4569877600297332
modified 0.44866136740893126
modified 0.4477036530151963
modified 0.44927958492189646
modified 0.4748839922249317
modified 0.4480593539774418
-----------------------------------------------------------
vm_thread_mutex3
# 1000 threads, one mutex
require 'thread'
m = Thread::Mutex.new
r = 0
max = 2000
(1..max).map{
Thread.new{
i = 0
while i<max
i += 1
m.synchronize{
r += 1
}
end
}
}.each{|e|
e.join
}
raise r.to_s if r != max * max
ruby_2_4 13.229081232100725
ruby_2_4 10.361821477301419
ruby_2_4 13.21454683598131
ruby_2_4 13.127974891103804
ruby_2_4 13.101391088217497
trunk_oct 0.5335255851969123
trunk_oct 0.6239631148055196
trunk_oct 0.595430564135313
trunk_oct 0.5881124306470156
trunk_oct 0.649148665368557
trunk 0.6481779562309384
trunk 0.7439629575237632
trunk 0.6616273690015078
trunk 0.6847296943888068
trunk 0.6425670552998781
modified 0.6182468663901091
modified 0.6477580312639475
modified 0.7076717717573047
modified 0.6307074092328548
modified 0.6462077107280493
-----------------------------------------------------------
vm_thread_pass
# Plenty Thtread.pass
# A performance may depend on GVL implementation.
tmax = (ARGV.shift || 2).to_i
lmax = 200_000 / tmax
(1..tmax).map{
Thread.new{
lmax.times{
Thread.pass
}
}
}.each{|t| t.join}
ruby_2_4 0.20077786222100258
ruby_2_4 0.1840678071603179
ruby_2_4 0.2092479821294546
ruby_2_4 0.20319670345634222
ruby_2_4 0.17695394903421402
trunk_oct 0.2662556003779173
trunk_oct 0.20653991773724556
trunk_oct 0.2505806218832731
trunk_oct 0.3006536699831486
trunk_oct 0.31350578274577856
trunk 0.2777848755940795
trunk 0.219541578553617
trunk 0.24411905650049448
trunk 0.19811622612178326
trunk 0.19413186144083738
modified 0.1954143075272441
modified 0.2819817801937461
modified 0.2202981784939766
modified 0.21726321894675493
modified 0.21226701233536005
-----------------------------------------------------------
vm_thread_pass_flood
# n.b. this is a good test for GVL when pinned to a single CPU
1000.times{
Thread.new{loop{Thread.pass}}
}
i = 0
while i<10000
i += 1
end
ruby_2_4 0.06185524072498083
ruby_2_4 0.06377452705055475
ruby_2_4 0.06320396903902292
ruby_2_4 0.06295364908874035
ruby_2_4 0.06256257276982069
trunk_oct 0.0724976547062397
trunk_oct 0.0727549958974123
trunk_oct 0.07420433312654495
trunk_oct 0.0732979103922844
trunk_oct 0.07281546294689178
trunk 0.0760016506537795
trunk 0.07527142576873302
trunk 0.07552359625697136
trunk 0.07348260283470154
trunk 0.0750909373164177
modified 0.07608831021934748
modified 0.07728622108697891
modified 0.07751876767724752
modified 0.07697273045778275
modified 0.0772504536435008
-----------------------------------------------------------
vm_thread_pipe
# Measure small and plenty pipe read/write.
# A performance may depend on GVL implementation.
lmax = 100_000
r, w = IO.pipe
[Thread.new{
lmax.times{
w.write('a')
}
p "w:exit"
}, Thread.new{
lmax.times{
r.read(1)
}
p "r:exit"
}].each{|t| t.join}
ruby_2_4 0.28154731914401054
ruby_2_4 0.2708658976480365
ruby_2_4 0.28065589629113674
ruby_2_4 0.27115851640701294
ruby_2_4 0.2817091280594468
trunk_oct 0.30450946278870106
trunk_oct 0.2787585724145174
trunk_oct 0.29437954537570477
trunk_oct 0.2891360120847821
trunk_oct 0.306916993111372
trunk 0.3100350499153137
trunk 0.2925932416692376
trunk 0.2896188236773014
trunk 0.2987119536846876
trunk 0.3008888456970453
modified 0.30315235350281
modified 0.3017531055957079
modified 0.3073718249797821
modified 0.30004817247390747
modified 0.30826299358159304
-----------------------------------------------------------
vm_thread_queue
require 'thread'
n = 1_000_000
q = Thread::Queue.new
consumer = Thread.new{
while q.pop
# consuming
end
}
producer = Thread.new{
n.times{
q.push true
}
q.push nil
}
consumer.join
ruby_2_4 0.09707112424075603
ruby_2_4 0.09783682134002447
ruby_2_4 0.09907612483948469
ruby_2_4 0.09743348602205515
ruby_2_4 0.10052135959267616
trunk_oct 0.10897290054708719
trunk_oct 0.10889455210417509
trunk_oct 0.10858452413231134
trunk_oct 0.10851394012570381
trunk_oct 0.10863521881401539
trunk 0.11006676591932774
trunk 0.10962370783090591
trunk 0.11245737224817276
trunk 0.11022763606160879
trunk 0.11000106390565634
modified 0.11161650065332651
modified 0.11197167541831732
modified 0.11070610396564007
modified 0.11094601359218359
modified 0.1106795622035861
-----------------------------------------------------------
vm_thread_sized_queue
require 'thread'
# on producer, one consumer
n = 1_000_000
q = Thread::SizedQueue.new(100)
consumer = Thread.new{
while q.pop
# consuming
end
}
producer = Thread.new{
while n > 0
q.push true
n -= 1
end
q.push nil
}
consumer.join
ruby_2_4 0.16495272517204285
ruby_2_4 0.18097694870084524
ruby_2_4 0.16396748647093773
ruby_2_4 0.16168665327131748
ruby_2_4 0.16181478556245565
trunk_oct 0.1687923837453127
trunk_oct 0.16870401706546545
trunk_oct 0.16344268433749676
trunk_oct 0.16586524341255426
trunk_oct 0.16192950773984194
trunk 0.1805695602670312
trunk 0.18242293410003185
trunk 0.16569650918245316
trunk 0.17067490704357624
trunk 0.16444664355367422
modified 0.16913603339344263
modified 0.16566202603280544
modified 0.1681229518726468
modified 0.1662365486845374
modified 0.16631945595145226
-----------------------------------------------------------
vm_thread_sized_queue2
require 'thread'
# one producer, many consumers
n = 1_000_000
m = 10
q = Thread::SizedQueue.new(100)
consumers = m.times.map do
Thread.new do
while q.pop
# consuming
end
end
end
producer = Thread.new do
while n > 0
q.push true
n -= 1
end
m.times { q.push nil }
end
producer.join
consumers.each(&:join)
ruby_2_4 0.4533231146633625
ruby_2_4 0.4604426044970751
ruby_2_4 0.46321689151227474
ruby_2_4 0.46123337745666504
ruby_2_4 0.4566977312788367
trunk_oct 0.42793169990181923
trunk_oct 0.4358728742226958
trunk_oct 0.4282519221305847
trunk_oct 0.42990866489708424
trunk_oct 0.43017060682177544
trunk 0.43597924150526524
trunk 0.4221631111577153
trunk 0.4346413044258952
trunk 0.4337912444025278
trunk 0.43028371687978506
modified 0.43665296770632267
modified 0.4352031257003546
modified 0.4343093065544963
modified 0.4384396728128195
modified 0.4413782674819231
-----------------------------------------------------------
vm_thread_sized_queue3
require 'thread'
# many producers, one consumer
n = 1_000_000
m = 10
q = Thread::SizedQueue.new(100)
consumer = Thread.new do
while q.pop
# consuming
end
end
producers = m.times.map do
Thread.new do
while n > 0
q.push true
n -= 1
end
end
end
producers.each(&:join)
q.push nil
consumer.join
ruby_2_4 0.45086408499628305
ruby_2_4 0.45005742367357016
ruby_2_4 0.4500123728066683
ruby_2_4 0.4580862410366535
ruby_2_4 0.44981281366199255
trunk_oct 0.4211096437647939
trunk_oct 0.41846535075455904
trunk_oct 0.4247137811034918
trunk_oct 0.4227958545088768
trunk_oct 0.4229021156206727
trunk 0.4330023005604744
trunk 0.43574557825922966
trunk 0.4312185253947973
trunk 0.43063072487711906
trunk 0.43380977399647236
modified 0.42779526486992836
modified 0.4342837119475007
modified 0.42964852042496204
modified 0.4375357609242201
modified 0.4390948824584484
-----------------------------------------------------------
vm_thread_sized_queue4
require 'thread'
# many producers, many consumers
nr = 1_000_000
n = 10
m = 10
q = Thread::SizedQueue.new(100)
consumers = n.times.map do
Thread.new do
while q.pop
# consuming
end
end
end
producers = m.times.map do
Thread.new do
while nr > 0
q.push true
nr -= 1
end
end
end
producers.each(&:join)
n.times { q.push nil }
consumers.each(&:join)
ruby_2_4 0.28202506247907877
ruby_2_4 0.31670866906642914
ruby_2_4 0.27734627667814493
ruby_2_4 0.40430656634271145
ruby_2_4 0.31685886811465025
trunk_oct 0.26414157450199127
trunk_oct 0.32285674661397934
trunk_oct 0.2371793333441019
trunk_oct 0.30815719719976187
trunk_oct 0.24667307268828154
trunk 0.2452874593436718
trunk 0.24910050723701715
trunk 0.27432305831462145
trunk 0.3108911532908678
trunk 0.3159103225916624
modified 0.41180176846683025
modified 0.3184793358668685
modified 0.29488882049918175
modified 0.2217257833108306
modified 0.2535018865019083
-----------------------------------------------------------
raw data:
[["app_answer",
[[0.04487689025700092,
0.044887082651257515,
0.04478233680129051,
0.044680457562208176,
0.044472331181168556],
[0.05369561351835728,
0.05327794328331947,
0.053324973210692406,
0.0533294128254056,
0.05318734794855118],
[0.05527955200523138,
0.05591896828263998,
0.055002798326313496,
0.055259526707232,
0.05526765063405037],
[0.05576000455766916,
0.056411576457321644,
0.05564382392913103,
0.05569745972752571,
0.055554790422320366]]],
["app_aobench",
[[36.20966003648937,
36.276483993045986,
36.06006149761379,
36.40027827769518,
36.59175945352763],
[43.17953597661108,
39.5161963775754,
40.67096074577421,
38.93619007524103,
38.87406879570335],
[38.30207220930606,
38.3029449256137,
39.2404085919261,
39.17272327654064,
38.36024654470384],
[37.33606534730643,
37.78875325806439,
37.444791925139725,
37.156153441406786,
38.43332130461931]]],
["app_erb",
[[1.0910273203626275,
1.1160900527611375,
1.1138797011226416,
1.1137238182127476,
1.0859335204586387],
[0.8029095465317369,
0.8081927429884672,
0.8069239566102624,
0.8096117489039898,
0.8034359868615866],
[0.8403531908988953,
0.8421134259551764,
0.8327486971393228,
0.8372374074533582,
0.8351303180679679],
[0.8252536691725254,
0.831566384062171,
0.8288772627711296,
0.8264654008671641,
0.8336413651704788]]],
["app_factorial",
[[0.603745648637414,
0.6038031615316868,
0.6046772794798017,
0.6043389672413468,
0.6039576455950737],
[0.669595368206501,
0.6659398227930069,
0.6744274199008942,
0.6669504605233669,
0.6685555214062333],
[0.6079981550574303,
0.6069057630375028,
0.6096790451556444,
0.6078688716515899,
0.6082294499501586],
[0.6126801799982786,
0.6108460640534759,
0.6114145591855049,
0.6117470702156425,
0.6101243132725358]]],
["app_fib",
[[0.36114765889942646,
0.33853843063116074,
0.3421305660158396,
0.34071844164282084,
0.34828669764101505],
[0.4085798738524318,
0.38410656433552504,
0.39509366918355227,
0.4005908276885748,
0.38477741554379463],
[0.4005790390074253,
0.39988459181040525,
0.4004660816863179,
0.3989400062710047,
0.4002835098654032],
[0.3631491204723716,
0.35965136997401714,
0.361650213599205,
0.35752243362367153,
0.36000645998865366]]],
["app_lc_fizzbuzz",
[[36.53207976743579,
37.89537764713168,
36.723573193885386,
38.48227261565626,
36.90794064849615],
[36.873438694514334,
36.245762643404305,
35.49768565688282,
35.30468615423888,
34.43972430471331],
[33.43890817370266,
32.89311058353633,
34.13755172677338,
36.41347415372729,
34.11650806944817],
[33.69486961700022,
33.82463005371392,
33.184486526064575,
32.46442792471498,
31.319396573118865]]],
["app_mandelbrot",
[[0.925727934576571,
0.9439300484955311,
0.9091543704271317,
0.9452749313786626,
0.9127898877486587],
[0.9456870397552848,
0.9509583497419953,
0.9463692363351583,
0.9440803667530417,
0.9558739792555571],
[0.952283376827836,
0.9713358459994197,
0.9485433483496308,
0.9530115472152829,
0.9520656513050199],
[0.9396216114982963,
0.9364266060292721,
0.9358242331072688,
0.9580141827464104,
0.9555799597874284]]],
["app_pentomino",
[[10.340436936356127,
10.26072520390153,
10.40820305235684,
10.290426510386169,
10.318881308659911],
[10.564207458868623,
10.45787581242621,
10.485318578779697,
10.420554504729807,
10.618309519253671],
[10.273468842729926,
10.102290431037545,
10.127600049600005,
10.193915856070817,
10.167326777242124],
[9.924994584172964,
9.929463713429868,
9.918480903841555,
9.88340763002634,
9.879915663972497]]],
["app_raise",
[[0.17838600184768438,
0.17501006741076708,
0.17996628675609827,
0.18227750342339277,
0.17908358480781317],
[0.1874496778473258,
0.19084734097123146,
0.18677002470940351,
0.18702173512429,
0.1870880899950862],
[0.18548655975610018,
0.18686705827713013,
0.18463914841413498,
0.18457612302154303,
0.1846449924632907],
[0.18765069358050823,
0.18769632186740637,
0.18800458870828152,
0.1883128797635436,
0.1892009163275361]]],
["app_strconcat",
[[0.7654742449522018,
0.7948119519278407,
0.7673031808808446,
0.7640487998723984,
0.7711082641035318],
[0.7626644130796194,
0.7309178821742535,
0.7315988969057798,
0.7351448154076934,
0.7301147468388081],
[0.7378271007910371,
0.7387549160048366,
0.7378970254212618,
0.7387903444468975,
0.7387805189937353],
[0.7293761782348156,
0.7338413437828422,
0.7358414940536022,
0.7298681391403079,
0.7283730050548911]]],
["app_tak",
[[0.5038435598835349,
0.5028090076521039,
0.5219125980511308,
0.5068032648414373,
0.5048781149089336],
[0.5110951131209731,
0.5248937616124749,
0.5222185803577304,
0.5302830990403891,
0.5173734966665506],
[0.5375435454770923,
0.5497156092897058,
0.5430646222084761,
0.5374544756487012,
0.5364547353237867],
[0.49949335400015116,
0.5008256258442998,
0.5009597418829799,
0.5101037258282304,
0.501644229516387]]],
["app_tarai",
[[0.4232830246910453,
0.4196279076859355,
0.4227399108931422,
0.4237120309844613,
0.42692682426422834],
[0.44046545308083296,
0.45594013575464487,
0.4436839232221246,
0.46460551489144564,
0.43735334277153015],
[0.46855807211250067,
0.4719211347401142,
0.47725564520806074,
0.47434646636247635,
0.4816421000286937],
[0.4196786815300584,
0.4139177994802594,
0.4215358402580023,
0.41485053300857544,
0.41740911919623613]]],
["app_uri",
[[0.46180492267012596,
0.4573489334434271,
0.4546288913115859,
0.4528842447325587,
0.4509422993287444],
[0.4815033273771405,
0.47097593266516924,
0.4757920615375042,
0.466670636087656,
0.470277750864625],
[0.45849289186298847,
0.4616105295717716,
0.45852625742554665,
0.4658892685547471,
0.4568141447380185],
[0.46998004242777824,
0.46345530450344086,
0.4554989682510495,
0.45493804942816496,
0.45752451941370964]]],
["array_sample_100k_10",
[[0.02950125839561224,
0.0292540080845356,
0.029195214621722698,
0.029124343767762184,
0.029260456562042236],
[0.03751176968216896,
0.03737057093530893,
0.03721648082137108,
0.03718503285199404,
0.03719606250524521],
[0.03838095162063837,
0.03798821475356817,
0.038725041784346104,
0.03827290236949921,
0.03830507304519415],
[0.04066624119877815,
0.040673685260117054,
0.04057355597615242,
0.040464249439537525,
0.04056987911462784]]],
["array_sample_100k_11",
[[0.6606828169897199,
0.6488657798618078,
0.6510301260277629,
0.6499084252864122,
0.6423075329512358],
[0.041237770579755306,
0.04111320525407791,
0.041138594038784504,
0.041162275709211826,
0.040904912166297436],
[0.04134767409414053,
0.04158247448503971,
0.04145221598446369,
0.04133627377450466,
0.04167115967720747],
[0.043928662315011024,
0.04390209075063467,
0.04394834581762552,
0.04403913952410221,
0.043743777088820934]]],
["array_sample_100k__100",
[[0.6623934572562575,
0.6640799958258867,
0.6602982878684998,
0.6600730195641518,
0.6696218233555555],
[0.08090994041413069,
0.08101366087794304,
0.08157859649509192,
0.08113863784819841,
0.08121221698820591],
[0.08170587196946144,
0.08162978943437338,
0.0808451259508729,
0.08087221439927816,
0.08096039108932018],
[0.083500437438488,
0.08393660746514797,
0.08398211933672428,
0.08396678324788809,
0.0843675248324871]]],
["array_sample_100k__1k",
[[0.8079767534509301,
0.8053814945742488,
0.8116927854716778,
0.8043063106015325,
0.8095842115581036],
[0.49835555255413055,
0.5142400227487087,
0.498779209330678,
0.4986087568104267,
0.4983958415687084],
[0.49240061920136213,
0.4967837706208229,
0.4985520299524069,
0.49130321107804775,
0.49092247523367405],
[0.5003009000793099,
0.49788558296859264,
0.4979515112936497,
0.503381634131074,
0.49630678445100784]]],
["array_sample_100k__6k",
[[1.5716388328000903,
1.5782960345968604,
1.578008184209466,
1.5681307911872864,
1.5721359457820654],
[1.5956734726205468,
1.5903776213526726,
1.5994160855188966,
1.5982768889516592,
1.6031629657372832],
[1.5789744956418872,
1.5713908076286316,
1.5625593094155192,
1.5745469778776169,
1.5728356903418899],
[1.5852369805797935,
1.575236569158733,
1.577095023356378,
1.5689958641305566,
1.5718932738527656]]],
["array_sample_100k___10k",
[[2.205017488449812,
2.171666132286191,
2.1659449748694897,
2.165872278623283,
2.1669661132618785],
[2.204504747875035,
2.194258383475244,
2.1962699303403497,
2.195070507004857,
2.249415007419884],
[2.1587591804564,
2.1593775739893317,
2.160155759193003,
2.1610017055645585,
2.15755879227072],
[2.1717774234712124,
2.3299802094697952,
2.163971151225269,
2.158941427245736,
2.1660576751455665]]],
["array_sample_100k___50k",
[[7.809174820780754,
7.806549916043878,
7.715758080594242,
7.755669089965522,
7.783610421232879],
[7.958461046218872,
7.94976463355124,
7.8647908344864845,
7.912963852286339,
7.913691173307598],
[7.787658085115254,
7.74038855265826,
7.752917944453657,
7.768044015392661,
7.820888922549784],
[7.844436853192747,
7.786277565173805,
7.81502278149128,
7.845739766955376,
7.853899677284062]]],
["array_shift",
[[3.5863759266212583,
3.6033725421875715,
3.594981645233929,
3.617394160479307,
3.602064718492329],
[3.792987175285816,
3.6687114080414176,
3.6558352252468467,
3.6526988577097654,
3.6570083051919937],
[1.961324568837881,
1.9620508551597595,
1.9623122792690992,
1.960218240506947,
2.0169059075415134],
[1.9611085494980216,
1.9610675629228354,
1.9606889793649316,
1.9566379748284817,
1.9610895654186606]]],
["array_small_and",
[[0.04314385913312435,
0.042992763221263885,
0.04247965291142464,
0.04251945484429598,
0.04269628319889307],
[0.04317949339747429,
0.04326737951487303,
0.043151671066880226,
0.04343361593782902,
0.04334050323814154],
[0.04446489177644253,
0.04405117221176624,
0.044496748596429825,
0.0441123666241765,
0.04398850444704294],
[0.04639121983200312,
0.04621213115751743,
0.04610369727015495,
0.046426533721387386,
0.046094074845314026]]],
["array_small_diff",
[[0.04579384531825781,
0.04583666939288378,
0.04647925868630409,
0.04598063975572586,
0.045941867865622044],
[0.04417698085308075,
0.04424693714827299,
0.044360662810504436,
0.04433419741690159,
0.044364359229803085],
[0.04526221193373203,
0.04504249710589647,
0.0447850376367569,
0.04534667916595936,
0.04528128355741501],
[0.04730869736522436,
0.0474362438544631,
0.04752052389085293,
0.04742819629609585,
0.047524972818791866]]],
["array_small_or",
[[0.04941077437251806,
0.0490758428350091,
0.0483282245695591,
0.048524326644837856,
0.04835126083344221],
[0.05159367062151432,
0.050720677711069584,
0.050714993849396706,
0.050847786478698254,
0.05077840015292168],
[0.052041953429579735,
0.052027663215994835,
0.05208864528685808,
0.05207608733326197,
0.05212043598294258],
[0.054272521287202835,
0.054302056320011616,
0.05433242954313755,
0.05439317785203457,
0.05421718955039978]]],
["array_sort_block",
[[4.990935520268977,
5.008760734461248,
5.002211184240878,
5.031768757849932,
5.010361919179559],
[4.620776174589992,
4.6228157775476575,
4.628693396225572,
4.634254821576178,
4.6398517601192],
[4.6604104693979025,
4.6803290052339435,
4.695919220335782,
4.698329074308276,
4.676961782388389],
[4.465667547658086,
4.4563381634652615,
4.457205110229552,
4.442073345184326,
4.43261747341603]]],
["array_sort_float",
[[2.9691732367500663,
2.9651240250095725,
2.9431838244199753,
2.973076667636633,
2.967228399589658],
[1.5360774910077453,
1.5372640900313854,
1.5914093377068639,
1.530824408866465,
1.540001641958952],
[1.6600666958838701,
1.558536239899695,
1.5544176446273923,
1.564120912924409,
1.5635378854349256],
[1.5336211854591966,
1.5208673346787691,
1.5700370520353317,
1.531577586196363,
1.5355555731803179]]],
["bighash",
[[1.1658156188204885,
1.1619386924430728,
1.1778438221663237,
1.177191092632711,
1.1696994761005044],
[1.1916822316125035,
1.1992708332836628,
1.1910538002848625,
1.2156227435916662,
1.1998401647433639],
[1.2078109737485647,
1.2166875256225467,
1.2052306067198515,
1.206314828246832,
1.2102624317631125],
[1.211957766674459,
1.2027070298790932,
1.2055514501407743,
1.2117169462144375,
1.2023955518379807]]],
["dir_empty_p",
[[0.22107713297009468,
0.20824912749230862,
0.21443202625960112,
0.2158330800011754,
0.2104991702362895],
[0.22432265151292086,
0.2660670196637511,
0.21744792722165585,
0.21820032969117165,
0.21739510353654623],
[0.22934256959706545,
0.2406091457232833,
0.22949449252337217,
0.22903573978692293,
0.23602640721946955],
[0.2354406053200364,
0.23155706655234098,
0.2339407168328762,
0.23286220338195562,
0.23001439403742552]]],
["erb_render",
[[2.648871618323028,
2.601091149263084,
2.6083217319101095,
2.6274924371391535,
2.6040284829214215],
[1.0657949335873127,
1.075893527828157,
1.0614414513111115,
1.099606178700924,
1.064248469658196],
[1.084544393233955,
1.0845027780160308,
1.0832743281498551,
1.1745046861469746,
1.0948968958109617],
[1.2614368768408895,
1.0565239069983363,
1.0615467857569456,
1.065241951495409,
1.1145551661029458]]],
["file_chmod",
[[0.19015854876488447,
0.19285294879227877,
0.1905073681846261,
0.19568252936005592,
0.19243267178535461],
[0.2016332894563675,
0.19890588708221912,
0.20081097353249788,
0.2001079497858882,
0.20737564004957676],
[0.22116354294121265,
0.21869436744600534,
0.22755639161914587,
0.21909922547638416,
0.2188980421051383],
[0.21806801576167345,
0.23552309162914753,
0.2178712347522378,
0.22257215715944767,
0.21878324821591377]]],
["file_rename",
[[0.6642924919724464,
0.6502274638041854,
0.6562406495213509,
0.6850288612768054,
0.6594824707135558],
[0.6670955242589116,
0.6725148819386959,
0.664207162335515,
0.6652930174022913,
0.6675800252705812],
[0.6808162312954664,
0.68763168156147,
0.6752430256456137,
0.6801165351644158,
0.6752310367301106],
[0.6756181111559272,
0.6772550158202648,
0.6776238521561027,
0.6753160459920764,
0.6779537666589022]]],
["hash_aref_dsym",
[[0.263726475648582,
0.2761738272383809,
0.2723959432914853,
0.26847472228109837,
0.2680125245824456],
[0.2943550646305084,
0.2937017111107707,
0.29192993324249983,
0.2919363062828779,
0.30135550256818533],
[0.3101480947807431,
0.314423693343997,
0.31170643866062164,
0.3108241092413664,
0.30914205592125654],
[0.30534568428993225,
0.30895554553717375,
0.31122990790754557,
0.3072431115433574,
0.33601050078868866]]],
["hash_aref_dsym_long",
[[3.175567743368447,
3.206102818250656,
3.2415223885327578,
3.299550731666386,
3.311943086795509],
[3.237652954645455,
3.0586729859933257,
3.3109343741089106,
3.3957728538662195,
3.459920813329518],
[3.164889508858323,
3.1942493384703994,
3.189624813385308,
3.1740572210401297,
3.2820500675588846],
[3.1559967659413815,
3.197402344085276,
3.2052777437493205,
3.282293534837663,
3.3287694938480854]]],
["hash_aref_fix",
[[0.2609948040917516,
0.2578913839533925,
0.25224294513463974,
0.271748811006546,
0.27248279098421335],
[0.29355032555758953,
0.28349983040243387,
0.2936028419062495,
0.3452490037307143,
0.41720787063241005],
[0.3100457526743412,
0.2910926891490817,
0.29295599088072777,
0.41942670848220587,
0.2960450313985348],
[0.2895897263661027,
0.27915025781840086,
0.2791378078982234,
0.2965983608737588,
0.28458560444414616]]],
["hash_aref_flo",
[[0.0499512767419219,
0.051750097423791885,
0.05015122704207897,
0.04933540336787701,
0.04952178802341223],
[0.05952627211809158,
0.059625888243317604,
0.059829698875546455,
0.060849291272461414,
0.05933453608304262],
[0.06063990853726864,
0.060607340186834335,
0.060403233394026756,
0.0609989445656538,
0.06045036483556032],
[0.062234902754426,
0.06396108586341143,
0.0621397802606225,
0.0630847280845046,
0.062187787145376205]]],
["hash_aref_miss",
[[0.3686364060267806,
0.37831310741603374,
0.3779862029477954,
0.3743992382660508,
0.361598146148026],
[0.38061713334172964,
0.3909873841330409,
0.395187652669847,
0.3763585928827524,
0.3905332116410136],
[0.39660962857306004,
0.3936945628374815,
0.4377703182399273,
0.40676034800708294,
0.36866373661905527],
[0.39652410615235567,
0.3937609801068902,
0.40038585383445024,
0.3890699865296483,
0.400178880430758]]],
["hash_aref_str",
[[0.3430917225778103,
0.32951133884489536,
0.33487503230571747,
0.3384719081223011,
0.33576900139451027],
[0.34187883976846933,
0.34241723641753197,
0.34056114312261343,
0.35416494961827993,
0.35687818843871355],
[0.3454119525849819,
0.34791990276426077,
0.35336306039243937,
0.35420312639325857,
0.34874989464879036],
[0.3405866641551256,
0.34616814460605383,
0.32941246312111616,
0.3446532553061843,
0.3441737936809659]]],
["hash_aref_sym",
[[0.2723753023892641,
0.26579560339450836,
0.2653283290565014,
0.27019786927849054,
0.285128521732986],
[0.3119408180937171,
0.29992883652448654,
0.29907585494220257,
0.3094273768365383,
0.30554392095655203],
[0.3042509751394391,
0.30037481151521206,
0.3012241991236806,
0.29844539798796177,
0.30931904818862677],
[0.3019282864406705,
0.32146325148642063,
0.2996023017913103,
0.3141472479328513,
0.2989084841683507]]],
["hash_aref_sym_long",
[[0.3622218491509557,
0.4381094928830862,
0.3674069354310632,
0.3799957800656557,
0.3875621594488621],
[0.44223527424037457,
0.42702542897313833,
0.4132824158295989,
0.41335222963243723,
0.42288501653820276],
[0.4240665137767792,
0.4099509548395872,
0.41233318485319614,
0.4047677731141448,
0.41507475171238184],
[0.40376974642276764,
0.407093895599246,
0.40305578522384167,
0.42089630104601383,
0.4092823453247547]]],
["hash_flatten",
[[0.23931661248207092,
0.23898044601082802,
0.2388934502378106,
0.2389828274026513,
0.23898828402161598],
[0.18286235444247723,
0.18168202694505453,
0.18208450730890036,
0.18146330770105124,
0.18216758500784636],
[0.20638114120811224,
0.20617200154811144,
0.20668425224721432,
0.20664830226451159,
0.20640033297240734],
[0.18963987659662962,
0.18995442241430283,
0.1893994454294443,
0.1897573471069336,
0.1897696079686284]]],
["hash_ident_flo",
[[0.04909050464630127,
0.04922498110681772,
0.04883077833801508,
0.0491654546931386,
0.04862384870648384],
[0.05925955902785063,
0.05936989467591047,
0.059128270484507084,
0.05897417291998863,
0.059846263378858566],
[0.06017099879682064,
0.0599897475913167,
0.060129120014607906,
0.059829612262547016,
0.059953819029033184],
[0.06197364069521427,
0.06301239226013422,
0.06195529829710722,
0.06145096942782402,
0.06151615083217621]]],
["hash_ident_num",
[[0.2550027072429657,
0.25709130242466927,
0.2795975673943758,
0.28014630638062954,
0.2746730362996459],
[0.30431725084781647,
0.27907548658549786,
0.3097229143604636,
0.28085173200815916,
0.2814785363152623],
[0.30336756259202957,
0.2823643572628498,
0.3062245165929198,
0.3192725069820881,
0.28318785782903433],
[0.34642425179481506,
0.29638210218399763,
0.2898220447823405,
0.29221873730421066,
0.3005418302491307]]],
["hash_ident_obj",
[[0.2589333523064852,
0.2724173329770565,
0.2794358851388097,
0.26604977436363697,
0.25615649949759245],
[0.28422093857079744,
0.29160023387521505,
0.2841336829587817,
0.29316555336117744,
0.29831799305975437],
[0.2968236692249775,
0.3070484884083271,
0.29577150382101536,
0.2952602840960026,
0.2905656127259135],
[0.2833299096673727,
0.3000877173617482,
0.30436465982347727,
0.29478229861706495,
0.296668728813529]]],
["hash_ident_str",
[[0.28064961079508066,
0.2699139639735222,
0.2610522909089923,
0.259786419570446,
0.2636388372629881],
[0.289898619055748,
0.27941754274070263,
0.2989111291244626,
0.30557968094944954,
0.3044827217236161],
[0.2841451307758689,
0.29513147193938494,
0.29825274739414454,
0.3008001418784261,
0.29079663939774036],
[0.2829178422689438,
0.2951761847361922,
0.29073284193873405,
0.2812343193218112,
0.2890197755768895]]],
["hash_ident_sym",
[[0.26749170385301113,
0.25853430200368166,
0.26072264928370714,
0.25702809914946556,
0.27116471622139215],
[0.3072659121826291,
0.30654087476432323,
0.3076043529435992,
0.2920140326023102,
0.31216693948954344],
[0.30231455527246,
0.3066350994631648,
0.29409283585846424,
0.3120587505400181,
0.30041169468313456],
[0.2973363669589162,
0.3094587540253997,
0.3012598352506757,
0.3460267363116145,
0.2915645893663168]]],
["hash_keys",
[[0.09465214144438505,
0.09494761656969786,
0.09517013281583786,
0.09517311304807663,
0.09566901158541441],
[0.10243359114974737,
0.10314598213881254,
0.1023942157626152,
0.10257727932184935,
0.10197165608406067],
[0.1065923161804676,
0.1063461247831583,
0.10021214559674263,
0.10675222054123878,
0.1004721550270915],
[0.10937212035059929,
0.10857798904180527,
0.10883629694581032,
0.10871011950075626,
0.10857814364135265]]],
["hash_long",
[[0.6776566496118903,
0.6738138990476727,
0.6687519643455744,
0.6694637639448047,
0.6692806025967002],
[0.576607920229435,
0.583100532181561,
0.5810478115454316,
0.5759585332125425,
0.5758388945832849],
[0.5886679319664836,
0.578824719414115,
0.5794282341375947,
0.5891964696347713,
0.5801844587549567],
[0.5787801658734679,
0.5786007614806294,
0.5786173976957798,
0.5787396812811494,
0.5783470449969172]]],
["hash_shift",
[[0.029302826151251793,
0.02946515940129757,
0.02928383182734251,
0.029138588346540928,
0.02953410241752863],
[0.03826920222491026,
0.038040789775550365,
0.03791420720517635,
0.03813316021114588,
0.03833345044404268],
[0.0393370445817709,
0.0394512414932251,
0.03941994905471802,
0.039190332405269146,
0.03947609290480614],
[0.04173279367387295,
0.04142030142247677,
0.0414245929569006,
0.041482603177428246,
0.04123121686279774]]],
["hash_shift_u16",
[[0.06899990793317556,
0.06721921171993017,
0.0671424102038145,
0.06842063087970018,
0.06798364501446486],
[0.0758235789835453,
0.07667972147464752,
0.07573583722114563,
0.07633332069963217,
0.0763377146795392],
[0.07831694092601538,
0.07861876394599676,
0.07803748268634081,
0.07770607620477676,
0.07872064877301455],
[0.07910268101841211,
0.08106855396181345,
0.07938780821859837,
0.07960688043385744,
0.07941157557070255]]],
["hash_shift_u24",
[[0.06821257993578911,
0.06714130844920874,
0.06836456805467606,
0.06916996371001005,
0.06688732840120792],
[0.07595515623688698,
0.07614211458712816,
0.0766504593193531,
0.07583861239254475,
0.07618055399507284],
[0.07757530827075243,
0.07761591114103794,
0.07828425709158182,
0.07989687751978636,
0.07830884121358395],
[0.07936799339950085,
0.08005461096763611,
0.08000997081398964,
0.07990794256329536,
0.07945192977786064]]],
["hash_shift_u32",
[[0.0692470520734787,
0.06743897125124931,
0.06738287396728992,
0.06708309706300497,
0.06774392630904913],
[0.07641611527651548,
0.07598584052175283,
0.07606874126940966,
0.07611617632210255,
0.07661638222634792],
[0.0782409030944109,
0.07836768310517073,
0.07830094452947378,
0.07797120045870543,
0.0782504640519619],
[0.07922205608338118,
0.07980144582688808,
0.07950060721486807,
0.08021101914346218,
0.07971761748194695]]],
["hash_small2",
[[0.4494409402832389,
0.4508389215916395,
0.451890891417861,
0.45400820206850767,
0.45705028530210257],
[0.4623531950637698,
0.4621663298457861,
0.46354869566857815,
0.46262427791953087,
0.46277075447142124],
[0.48058672808110714,
0.47581950295716524,
0.4770717294886708,
0.4768876023590565,
0.47570366598665714],
[0.4747159481048584,
0.47542138025164604,
0.48115441482514143,
0.47522070351988077,
0.47443811874836683]]],
["hash_small4",
[[0.5742486761882901,
0.5974699202924967,
0.5767933959141374,
0.5782211907207966,
0.5712182810530066],
[0.5861901910975575,
0.5861655008047819,
0.5861290348693728,
0.6346785500645638,
0.5867755152285099],
[0.6085033426061273,
0.6072090184316039,
0.6069953348487616,
0.6076025785878301,
0.6087436396628618],
[0.6034981710836291,
0.604193969629705,
0.6024577636271715,
0.604750245809555,
0.6031058877706528]]],
["hash_small8",
[[1.0295241875573993,
1.1690709693357348,
1.0750119490548968,
1.0536391269415617,
1.0349234230816364],
[1.058202332817018,
1.0488654309883714,
1.0568763576447964,
1.0487769413739443,
1.047456793487072],
[1.235707575455308,
1.1773730088025331,
1.181349717080593,
1.239696185104549,
1.1787792230024934],
[1.0944882482290268,
1.091933854855597,
1.0930390488356352,
1.0945343114435673,
1.0924241999164224]]],
["hash_to_proc",
[[0.024416503496468067,
0.024257753044366837,
0.024156589061021805,
0.0242291409522295,
0.024087593890726566],
[0.03295538853853941,
0.033053671941161156,
0.03301873616874218,
0.03271505702286959,
0.03284402284771204],
[0.033997722901403904,
0.03410301823168993,
0.033932266756892204,
0.03396750520914793,
0.03401686251163483],
[0.03639744780957699,
0.03635264374315739,
0.036440882831811905,
0.03617205750197172,
0.03621793072670698]]],
["hash_values",
[[0.09482246823608875,
0.0951392687857151,
0.09502425231039524,
0.095138237811625,
0.09573106747120619],
[0.10253547970205545,
0.10209653619676828,
0.10230094008147717,
0.10225026402622461,
0.10090127028524876],
[0.1004562433809042,
0.1064581610262394,
0.10636940412223339,
0.10040752310305834,
0.1064596688374877],
[0.1088621262460947,
0.10968368221074343,
0.10879790503531694,
0.10862477961927652,
0.1090538464486599]]],
["int_quo",
[[1.7910891138017178,
1.7285595210269094,
1.7591103501617908,
1.7299061687663198,
1.775772562250495],
[0.9134138859808445,
0.9059665594249964,
0.9056594418361783,
0.9054229985922575,
0.928419372998178],
[0.9065565336495638,
0.905972296372056,
0.8987451354041696,
0.919618234038353,
0.8996790926903486],
[0.9016909934580326,
0.9023942472413182,
0.9089935682713985,
0.90226483438164,
0.9030623137950897]]],
["io_copy_stream_write",
[[0.16210402268916368,
0.16486232168972492,
0.16260320134460926,
0.1673704106360674,
0.16285186167806387],
[0.16517131309956312,
0.16473023127764463,
0.16761245392262936,
0.16392066795378923,
0.1653193812817335],
[0.16689542774111032,
0.1713306289166212,
0.16785669792443514,
0.1687092548236251,
0.17021904978901148],
[0.1704663671553135,
0.17199433408677578,
0.16818094532936811,
0.1791617888957262,
0.17123859841376543]]],
["io_copy_stream_write_socket",
[[0.3203147491440177,
0.3256166009232402,
0.31645045056939125,
0.3181094489991665,
0.3224779777228832],
[0.32048323657363653,
0.333693141117692,
0.32401488348841667,
0.336939106695354,
0.4383966764435172],
[0.3204655172303319,
0.3223985591903329,
0.3596854144707322,
0.3231933154165745,
0.32139942422509193],
[0.3314205938950181,
0.33042685873806477,
0.32387255039066076,
0.32587605249136686,
0.33207847736775875]]],
["io_file_create",
[[0.7999052871018648,
0.7802762482315302,
0.7981305615976453,
0.8176641836762428,
0.7996335029602051],
[0.8188932035118341,
0.8183162622153759,
0.8078320994973183,
0.8258823677897453,
0.8580632116645575],
[0.7810021582990885,
0.8000286109745502,
0.8005015533417463,
0.7879576412960887,
0.7909177830442786],
[0.8119170628488064,
0.7866885531693697,
0.7928201509639621,
0.8005136391147971,
0.8375968812033534]]],
["io_file_read",
[[0.8217237209901214,
0.8444003714248538,
0.8303785212337971,
0.8469831356778741,
0.8294633002951741],
[0.7688569575548172,
0.7721415897831321,
0.8051110897213221,
0.7887211926281452,
0.8064563442021608],
[0.7544424263760448,
0.7700773729011416,
0.7584051731973886,
0.7609825311228633,
0.7656487720087171],
[0.7598473494872451,
0.7565656080842018,
0.8026420054957271,
0.755095761269331,
0.7528132116422057]]],
["io_file_write",
[[0.5772966332733631,
0.5744149908423424,
0.5781210800632834,
0.577535237185657,
0.595387808047235],
[0.585019969381392,
0.5834510438144207,
0.5755818607285619,
0.5747231030836701,
0.5832370640709996],
[0.5774798141792417,
0.5735156740993261,
0.5775971859693527,
0.5818069921806455,
0.5767041118815541],
[0.5714107882231474,
0.5819572256878018,
0.5726626105606556,
0.5816189525648952,
0.5776834171265364]]],
["io_nonblock_noex",
[[1.351217346265912,
1.3710231287404895,
1.4210442770272493,
1.339781346730888,
1.373001316562295],
[1.282431822270155,
1.2943201018497348,
1.2761540720239282,
1.2877383586019278,
1.300718992948532],
[1.2950346199795604,
1.2903010724112391,
1.3431848688051105,
1.2978426683694124,
1.2955013345927],
[1.3379434710368514,
1.3073850935325027,
1.43139236420393,
1.3297874238342047,
1.3217193624004722]]],
["io_nonblock_noex2",
[[0.8324068998917937,
0.8314814483746886,
0.8269680328667164,
0.8316371915861964,
0.8199124159291387],
[0.8225545426830649,
0.8366458108648658,
0.8511283118277788,
0.8294539796188474,
0.8529512928798795],
[0.8512865994125605,
0.8464699042961001,
0.8392754150554538,
0.8420780496671796,
0.8508471073582768],
[0.8645479064434767,
0.8406872861087322,
0.8594023119658232,
0.8463565856218338,
0.8332216292619705]]],
["io_pipe_rw",
[[0.7143390085548162,
0.7022978942841291,
0.7022813595831394,
0.7124151447787881,
0.7000056002289057],
[0.7139607220888138,
0.710090241394937,
0.7141006896272302,
0.7125008162111044,
0.7146924622356892],
[0.7243178458884358,
0.7200548071414232,
0.7394839841872454,
0.7268596375361085,
0.7209014231339097],
[0.7262718323618174,
0.7193344123661518,
0.7222678856924176,
0.7509619044139981,
0.7261429792270064]]],
["io_select",
[[0.9978612475097179,
0.9951350139454007,
0.9974106270819902,
0.9967657895758748,
1.0035944301635027],
[1.0107591282576323,
1.0033363224938512,
1.009982293471694,
1.005640427581966,
1.0018855407834053],
[0.9936086991801858,
1.0324719995260239,
1.00522892922163,
1.020094777457416,
0.9990698415786028],
[1.0174420643597841,
1.015567747876048,
0.9971954477950931,
1.00277444627136,
1.026356372050941]]],
["io_select2",
[[1.2514165174216032,
1.2058365903794765,
1.2566699665039778,
1.2180656678974628,
1.2143642427399755],
[1.2226426051929593,
1.2405806230381131,
1.2254924103617668,
1.2207012921571732,
1.2302411468699574],
[1.23319860547781,
1.2176413107663393,
1.2214890699833632,
1.242837361060083,
1.2556630987673998],
[1.2407134361565113,
1.223868195898831,
1.2421179804950953,
1.2392476228997111,
1.2411613631993532]]],
["io_select3",
[[0.12176590226590633,
0.10139702539891005,
0.1210133982822299,
0.09872106462717056,
0.12972754146903753],
[0.12838854361325502,
0.12410090956836939,
0.11200020927935839,
0.10974986292421818,
0.11278579756617546],
[0.1150733856484294,
0.10835539177060127,
0.1078281830996275,
0.09894286841154099,
0.0969577869400382],
[0.11497108265757561,
0.10831099934875965,
0.11509297415614128,
0.10960207972675562,
0.1161925457417965]]],
["loop_for",
[[0.9044722365215421,
0.8913315301761031,
0.8917335430160165,
0.9003735594451427,
0.891508269123733],
[0.9779127929359674,
0.9779272573068738,
0.9824546426534653,
1.226051683537662,
1.049929440021515],
[1.0119363153353333,
1.0605404255911708,
1.0116948680952191,
1.0291864844039083,
1.017377712763846],
[0.9972810121253133,
0.9777810694649816,
0.9819500455632806,
0.9814369948580861,
0.9772939933463931]]],
["loop_generator",
[[0.28958967607468367,
0.2817333731800318,
0.30630672723054886,
0.2807753887027502,
0.27863746136426926],
[0.3039307380095124,
0.3060454139485955,
0.30376856960356236,
0.3065807707607746,
0.30464411806315184],
[0.28339630272239447,
0.2835812931880355,
0.28066639322787523,
0.28298798855394125,
0.28092439845204353],
[0.2857633577659726,
0.2886517709121108,
0.28970182966440916,
0.28230337891727686,
0.285346164368093]]],
["loop_times",
[[0.800098036415875,
0.7994052208960056,
0.81767104472965,
0.8039096966385841,
0.9809081982821226],
[0.8972129980102181,
0.8951454674825072,
0.895119103603065,
0.8975104046985507,
0.897660561837256],
[0.9161784658208489,
0.9009289182722569,
0.9006341714411974,
0.9242716180160642,
0.9066849211230874],
[0.8799077365547419,
0.8780862903222442,
0.8784855492413044,
0.8822809010744095,
0.9416052401065826]]],
["loop_whileloop",
[[0.38871809281408787,
0.38852716889232397,
0.3900247998535633,
0.38787161000072956,
0.4692509137094021],
[0.4302550461143255,
0.4261731216683984,
0.4263553023338318,
0.4262999976053834,
0.4261710103601217],
[0.44495165906846523,
0.44308482576161623,
0.4439132548868656,
0.5232562273740768,
0.4427309790626168],
[0.4297006605193019,
0.4296526713296771,
0.43171786796301603,
0.4310999112203717,
0.4299190267920494]]],
["loop_whileloop2",
[[0.09508057497441769,
0.09816205408424139,
0.09490170422941446,
0.09514188952744007,
0.09823123272508383],
[0.10931369755417109,
0.10927016381174326,
0.10950556118041277,
0.10906031168997288,
0.10930100549012423],
[0.1131787234917283,
0.11350607126951218,
0.11356672924011946,
0.11348916590213776,
0.11342305224388838],
[0.11254169326275587,
0.11256999894976616,
0.11183645389974117,
0.11254487559199333,
0.11250667553395033]]],
["marshal_dump_flo",
[[0.2474653758108616,
0.2463385034352541,
0.24670730996876955,
0.2659081034362316,
0.246890252456069],
[0.25504343677312136,
0.25651744566857815,
0.25390689726918936,
0.2542014615610242,
0.25434407591819763],
[0.2572882482782006,
0.25845279823988676,
0.2580233821645379,
0.2570078521966934,
0.2581360889598727],
[0.2605440830811858,
0.26057865656912327,
0.2618860388174653,
0.26100150868296623,
0.2605224484577775]]],
["marshal_dump_load_geniv",
[[0.38658848591148853,
0.38398884423077106,
0.3930904380977154,
0.3915357328951359,
0.3868562411516905],
[0.39498877339065075,
0.3954792330041528,
0.3979486972093582,
0.3920952929183841,
0.3908311817795038],
[0.3994530038908124,
0.3945854725316167,
0.4059576028957963,
0.3963400172069669,
0.3893438410013914],
[0.40164520870894194,
0.3948695659637451,
0.3964743921533227,
0.39503393042832613,
0.3978611407801509]]],
["marshal_dump_load_time",
[[1.1609864998608828,
1.1564325913786888,
1.1912339758127928,
1.166799645870924,
1.152001416310668],
[1.175420201383531,
1.1364163476973772,
1.1284445095807314,
1.162480417639017,
1.1347096469253302],
[1.1818950893357396,
1.1549881594255567,
1.2190832709893584,
1.163321797735989,
1.1695076981559396],
[1.1573536796495318,
1.1767047625035048,
1.1633068844676018,
1.1642479738220572,
1.1985326698049903]]],
["require",
[[0.7003255039453506,
0.6770226173102856,
0.6845751907676458,
0.6869270578026772,
0.6865763831883669],
[0.7193482229486108,
0.7275565005838871,
0.7269294839352369,
0.7329859836027026,
0.7227034391835332],
[0.7305544791743159,
0.7094148565083742,
0.7062418721616268,
0.7997284382581711,
0.707997677847743],
[0.7551164655014873,
0.7279995884746313,
0.7400414794683456,
0.7204265147447586,
0.7185903489589691]]],
["require_thread",
[[0.12859986256808043,
0.1278662383556366,
17.139101547189057,
0.12799783889204264,
14.341372024267912],
[0.13724040985107422,
0.13700702134519815,
0.1374838687479496,
0.1369559159502387,
0.236913344822824],
[101.16569390054792,
103.43558030668646,
32.263321708887815,
103.76521679852158,
72.00294751580805],
[62.51455730292946,
99.16671017743647,
97.66403281129897,
82.54443915374577,
103.37254293449223]]],
["securerandom",
[[0.1747917402535677,
0.17374191246926785,
0.18010317254811525,
0.17790788505226374,
0.17303849011659622],
[0.22200851701200008,
0.22202838957309723,
0.23062498588114977,
0.22145147435367107,
0.22212802711874247],
[0.22578141558915377,
0.22446201462298632,
0.2248234525322914,
0.224688989110291,
0.22262599598616362],
[0.22193302772939205,
0.22469153068959713,
0.22500979620963335,
0.22283765766769648,
0.22584333829581738]]],
["so_ackermann",
[[0.394165282137692,
0.3939297618344426,
0.39566834177821875,
0.39374957140535116,
0.3940361188724637],
[0.39930439833551645,
0.39863829407840967,
0.39800180681049824,
0.4183602165430784,
0.40153941605240107],
[0.4259690511971712,
0.41846096329391,
0.41895114351063967,
0.4184820372611284,
0.4509238637983799],
[0.3930969974026084,
0.39542569871991873,
0.39219037629663944,
0.3924806835129857,
0.3939360249787569]]],
["so_array",
[[0.8295369409024715,
0.611743145622313,
0.6117981057614088,
0.6140669099986553,
0.6131450338289142],
[0.6552423983812332,
0.6528829522430897,
0.6759208580479026,
0.6562178805470467,
0.6593029722571373],
[0.6725892294198275,
0.6728537809103727,
0.6702935108914971,
0.7063782475888729,
0.6745461979880929],
[0.6619908884167671,
0.6562794949859381,
0.6586566250771284,
0.6556976130232215,
0.6578402174636722]]],
["so_binary_trees",
[[4.359847350046039,
4.23919237870723,
4.257350823841989,
4.25885096937418,
4.238811162300408],
[4.23889244440943,
4.312817181460559,
4.341334853321314,
4.346625108271837,
4.328528879210353],
[4.5401236694306135,
4.593720803968608,
4.559484443627298,
4.56108489818871,
4.6567939799278975],
[4.43616914562881,
4.569371286779642,
4.532888426445425,
4.684375158511102,
4.4301601611077785]]],
["so_concatenate",
[[2.8542529735714197,
2.855884239077568,
2.8499110639095306,
2.8512823432683945,
2.8487400403246284],
[2.9521667193621397,
2.961184752173722,
2.952890577726066,
2.9514555744826794,
2.9549610558897257],
[3.0745205199345946,
3.0743666645139456,
3.0733328694477677,
3.0728870863094926,
3.0723974891006947],
[2.9682219615206122,
3.0021516056731343,
2.9623350258916616,
2.9560116790235043,
3.065779614262283]]],
["so_count_words",
[[0.13292209431529045,
0.1329799061641097,
0.1326249921694398,
0.13304319884628057,
0.1329117063432932],
[0.1404149578884244,
0.14065165352076292,
0.14067816268652678,
0.14016995206475258,
0.1405358389019966],
[0.15460665617138147,
0.1538712540641427,
0.15462887845933437,
0.1546104196459055,
0.15447503607720137],
[0.1565698916092515,
0.1570461504161358,
0.15607906877994537,
0.15718519035726786,
0.15635679382830858]]],
["so_exception",
[[0.22726632561534643,
0.22583076171576977,
0.221515741199255,
0.2221260704100132,
0.22224968764930964],
[0.2294118320569396,
0.23374507948756218,
0.2299413150176406,
0.2269281353801489,
0.2265768302604556],
[0.23472302127629519,
0.24264333676546812,
0.23562572244554758,
0.23501654528081417,
0.23726077657192945],
[0.22585246060043573,
0.22526070196181536,
0.22486719395965338,
0.22173711005598307,
0.22404176089912653]]],
["so_fannkuch",
[[0.8191407145932317,
0.8211729293689132,
0.830899054184556,
0.8211070392280817,
0.8184840846806765],
[0.8506222302094102,
0.8441071258857846,
0.8481834745034575,
0.8506027571856976,
0.8767997119575739],
[0.9008601326495409,
0.8503843881189823,
0.8476368524134159,
0.8478699373081326,
0.850719390437007],
[0.8486929861828685,
0.8574986793100834,
0.8445206778123975,
0.8621928729116917,
0.844983285292983]]],
["so_fasta",
[[1.2201206097379327,
1.2196027785539627,
1.2136210883036256,
1.2173871397972107,
1.2251200070604682],
[1.2831258932128549,
1.2861877465620637,
1.417847934179008,
1.2906327303498983,
1.2838180316612124],
[1.4332627980038524,
1.285471641458571,
1.2890075398609042,
1.4308448862284422,
1.2803919203579426],
[1.27948949765414,
1.2860844573006034,
1.2776277409866452,
1.272096480242908,
1.275735855102539]]],
["so_k_nucleotide",
[[0.8590771807357669,
0.9881570478901267,
0.8596108229830861,
0.8602258870378137,
0.8604057375341654],
[0.8651048690080643,
0.8705999897792935,
0.8715275283902884,
0.8688820581883192,
0.8709613448008895],
[0.8811677116900682,
0.8799803759902716,
0.872853054665029,
0.885897783562541,
0.871613634750247],
[0.8717275261878967,
0.8751911167055368,
0.8688216423615813,
0.869478796608746,
0.8729496160522103]]],
["so_lists",
[[0.38326943945139647,
0.38286024145781994,
0.3828663360327482,
0.38287252373993397,
0.3826301610097289],
[0.3575837118551135,
0.3591359658166766,
0.3577789831906557,
0.35794258397072554,
0.3581985319033265],
[0.3630874715745449,
0.36417560186237097,
0.36346066650003195,
0.362745676189661,
0.363191737793386],
[0.36357950046658516,
0.3623280618339777,
0.36237639654427767,
0.36283602099865675,
0.3634634595364332]]],
["so_mandelbrot",
[[1.835338570177555,
1.8241520142182708,
1.8862576205283403,
1.8379918662831187,
1.858496100641787],
[2.0549077382311225,
2.054156359285116,
1.9315293775871396,
1.9456397034227848,
2.0528963673859835],
[2.0258221365511417,
2.0213693976402283,
2.061582013964653,
2.019574492238462,
2.1127477902919054],
[1.900754738599062,
1.893930503167212,
1.896593670360744,
1.943287892267108,
1.8937652809545398]]],
["so_matrix",
[[0.37967456970363855,
0.3832985498011112,
0.3805954623967409,
0.3799684848636389,
0.38001074083149433],
[0.4101771442219615,
0.4140275437384844,
0.4414729680866003,
0.5091881621629,
0.4070788072422147],
[0.41902750823646784,
0.4235832719132304,
0.41803340427577496,
0.4264401011168957,
0.4261182574555278],
[0.40770130790770054,
0.40887937042862177,
0.4070527870208025,
0.5036796145141125,
0.41164416167885065]]],
["so_meteor_contest",
[[2.047541420906782,
2.0507780108600855,
2.05195056181401,
2.0517996503040195,
2.0484675746411085],
[2.176755669526756,
2.191023667342961,
2.198599934577942,
2.194957667030394,
2.1815862972289324],
[2.0796195631846786,
2.0852093128487468,
2.087739490903914,
2.0775687471032143,
2.0768789490684867],
[2.011031011119485,
2.0147771118208766,
2.012514960952103,
2.029349511489272,
2.0183694269508123]]],
["so_nbody",
[[1.0692435251548886,
1.0717863403260708,
1.0436121616512537,
1.0453649098053575,
1.0412232968956232],
[1.1395627679303288,
1.1401907354593277,
1.1666238401085138,
1.1473090779036283,
1.1414265492931008],
[1.1804447825998068,
1.1805660296231508,
1.222014680504799,
1.1922595519572496,
1.1758363842964172],
[1.3207525359466672,
1.1673106420785189,
1.170576335862279,
1.172426039353013,
1.1707572042942047]]],
["so_nested_loop",
[[0.719905311241746,
0.7226330349221826,
0.7150830924510956,
0.7161043388769031,
0.7214943859726191],
[0.7867694590240717,
0.7801391212269664,
0.7814135625958443,
0.8079315591603518,
0.7893188074231148],
[0.807498668320477,
0.8206066936254501,
0.8260151613503695,
1.0406140089035034,
0.8309459164738655],
[0.7884627869352698,
0.7770965658128262,
0.8238503271713853,
0.8142206044867635,
0.7768465811386704]]],
["so_nsieve",
[[1.2883011968806386,
1.2495624162256718,
1.3429833510890603,
1.2486428748816252,
1.270385880023241],
[1.3484207838773727,
1.3498019529506564,
1.357909532263875,
1.3465847838670015,
1.3558229487389326],
[1.4014641251415014,
1.398685104213655,
1.365258234553039,
1.3697841074317694,
1.3643926996737719],
[1.355614822357893,
1.335494264960289,
1.335546520538628,
1.3485909719020128,
1.3401325568556786]]],
["so_nsieve_bits",
[[1.7433604942634702,
1.6451375242322683,
1.8064179215580225,
1.6669695330783725,
1.817519586533308],
[1.7189516900107265,
1.6876679062843323,
1.6629183059558272,
1.677707408554852,
1.6976082976907492],
[1.6943465480580926,
1.68894808832556,
1.772359005175531,
1.6955888979136944,
1.6908907163888216],
[1.6575268870219588,
1.6546079777181149,
1.65987831633538,
1.652183742262423,
1.6511950315907598]]],
["so_object",
[[0.5006946781650186,
0.5013703247532248,
0.5333143370226026,
0.4999330872669816,
0.5011045085266232],
[0.5258233770728111,
0.5260475818067789,
0.5254053836688399,
0.5386674739420414,
0.5567600913345814],
[0.531104538589716,
0.5377200711518526,
0.5316079715266824,
0.5300312936306,
0.5309334900230169],
[0.5151661336421967,
0.5127241043373942,
0.5183673622086644,
0.6371085261926055,
0.5109165627509356]]],
["so_partial_sums",
[[1.7108501149341464,
1.7190658850595355,
1.7087708888575435,
1.7101066131144762,
1.7149731190875173],
[1.8198573319241405,
1.804289385676384,
1.8132188878953457,
1.8248246368020773,
1.8023860855028033],
[1.8597428305074573,
1.8496416294947267,
1.8608955265954137,
1.8451305078342557,
1.8431661315262318],
[1.7992861410602927,
1.817713798955083,
1.8040225887671113,
1.8161977380514145,
1.8060487266629934]]],
["so_pidigits",
[[0.7657669549807906,
0.7676611617207527,
0.7652134895324707,
0.7640891466289759,
0.771140843629837],
[0.7813822636380792,
0.7845096662640572,
0.7827473403885961,
0.7808729205280542,
0.7816900461912155],
[0.7626273678615689,
0.7643931647762656,
0.7597324587404728,
0.762136853300035,
0.8565071411430836],
[0.7601227127015591,
0.7629268858581781,
0.7609134977683425,
0.7620244491845369,
0.7608208199962974]]],
["so_random",
[[0.45207184832543135,
0.45267290249466896,
0.4520146772265434,
0.4526656912639737,
0.4517761915922165],
[0.476027300581336,
0.4781214529648423,
0.4769682455807924,
0.476099475286901,
0.47742537315934896],
[0.48719506058841944,
0.48832261376082897,
0.4905919851735234,
0.4924090560525656,
0.49773690197616816],
[0.47766343876719475,
0.4811979625374079,
0.4770943196490407,
0.47776682302355766,
0.4771637115627527]]],
["so_reverse_complement",
[[1.1043842136859894,
1.1062881238758564,
1.1025847280398011,
1.1173962410539389,
1.1210448741912842],
[1.0926780076697469,
1.0990766854956746,
1.0757757173851132,
1.0826186323538423,
1.0918241180479527],
[1.0918039036914706,
1.087092406116426,
1.0832933206111193,
1.123605807311833,
1.085325269959867],
[1.0883789081126451,
1.1149368034675717,
1.0898411199450493,
1.0963871804997325,
1.1007649526000023]]],
["so_sieve",
[[0.39210155978798866,
0.3844521101564169,
0.39479630906134844,
0.38371561374515295,
0.3836186872795224],
[0.4252029238268733,
0.423957129009068,
0.42327942699193954,
0.4233335228636861,
0.42442364525049925],
[0.43371201679110527,
0.4334556171670556,
0.5236137611791492,
0.43084512185305357,
0.4340560557320714],
[0.4266826771199703,
0.4256686447188258,
0.4256442617624998,
0.42422182857990265,
0.4327029436826706]]],
["so_spectralnorm",
[[1.3757685888558626,
1.293019762262702,
1.2942099003121257,
1.2926682839170098,
1.2930507035925984],
[1.4632894545793533,
1.4482001941651106,
1.4469446633011103,
1.458707643672824,
1.4525392772629857],
[1.5475740302354097,
1.5351202609017491,
1.5258412286639214,
1.5362128242850304,
1.5235477508977056],
[1.4421532591804862,
1.4420481324195862,
1.4596601566299796,
1.4404089860618114,
1.4472940741106868]]],
["string_index",
[[0.27286301366984844,
0.27240108139812946,
0.2725079823285341,
0.27242896892130375,
0.27263053227216005],
[0.2807594258338213,
0.2804857147857547,
0.28107733000069857,
0.2806160720065236,
0.2805692683905363],
[0.2263137251138687,
0.22610899806022644,
0.22630213107913733,
0.2259977152571082,
0.22610794752836227],
[0.2284553786739707,
0.2283129310235381,
0.22833734564483166,
0.22823673952370882,
0.22853991109877825]]],
["string_scan_re",
[[0.2079500174149871,
0.20777677465230227,
0.2071150355041027,
0.20754011813551188,
0.20757359825074673],
[0.19626768119633198,
0.19575737044215202,
0.19580966886132956,
0.19548674300312996,
0.22124707140028477],
[0.19376169424504042,
0.193414693698287,
0.19344198238104582,
0.19316123612225056,
0.19337948318570852],
[0.19555887393653393,
0.19561755191534758,
0.1958187110722065,
0.19513331446796656,
0.19503659568727016]]],
["string_scan_str",
[[0.1889276085421443,
0.1893777847290039,
0.18872145470231771,
0.18897287361323833,
0.1889195665717125],
[0.1451359996572137,
0.14526538085192442,
0.14515735115855932,
0.14494518749415874,
0.14472305122762918],
[0.1411191774532199,
0.14889925811439753,
0.1415062490850687,
0.141255890019238,
0.14129992108792067],
[0.14348130952566862,
0.14335066825151443,
0.14341404847800732,
0.14370747469365597,
0.1432449808344245]]],
["time_subsec",
[[2.2449037358164787,
2.195107350125909,
2.115496297366917,
2.432168315164745,
2.3408427219837904],
[1.0012786891311407,
0.9420177778229117,
0.9833070561289787,
0.9848502418026328,
0.9548217430710793],
[0.9978848304599524,
1.000202065333724,
0.9817005889490247,
0.9403291270136833,
0.9501170124858618],
[0.9807577449828386,
0.9679672662168741,
0.9535470809787512,
1.00922045763582,
0.9556684540584683]]],
["vm1_attr_ivar",
[[0.8940521581098437,
0.9361831760033965,
0.8942011147737503,
0.9767392706125975,
0.900523342192173],
[0.9546184968203306,
0.9538245983421803,
0.9520324617624283,
0.951689587906003,
0.9518179660663009],
[1.0092729656025767,
1.0128224259242415,
1.0359004186466336,
1.0598388509824872,
1.0102015174925327],
[0.9663311904296279,
0.9783340683206916,
0.9616457959637046,
0.9615122061222792,
0.9743748931214213]]],
["vm1_attr_ivar_set",
[[0.9847579943016171,
0.9909547213464975,
0.9974583191797137,
1.0135707128793001,
1.0312126465141773],
[1.0171027863398194,
1.0436245640739799,
1.0157041968777776,
1.026420851238072,
1.017745622433722],
[1.0477080699056387,
1.0416485210880637,
1.0389733193442225,
1.0370306130498648,
1.0810612300410867],
[1.0110517730936408,
1.014640998095274,
1.1719854287803173,
1.012173649854958,
1.0200687507167459]]],
["vm1_block",
[[1.3672876674681902,
1.4321664990857244,
1.4452351871877909,
1.3687137924134731,
1.3667716113850474],
[1.4375105993822217,
1.493250316940248,
1.437195461243391,
1.4383736765012145,
1.4400127483531833],
[1.5101739540696144,
1.5133912693709135,
1.5127917844802141,
1.576439829543233,
1.5135236196219921],
[1.4131324226036668,
1.4112477330490947,
1.3813772331923246,
1.3814136171713471,
1.3800622476264834]]],
["vm1_blockparam",
[[4.323410007171333,
4.066246813163161,
4.06549418810755,
4.084111415781081,
4.078505569137633],
[4.226216555573046,
4.0945022366940975,
4.1370830507948995,
4.141661386936903,
4.093774465844035],
[1.3360264608636498,
1.3317627720534801,
1.3306941576302052,
1.3671083925291896,
1.3328566495329142],
[1.3931286670267582,
1.303077507764101,
1.280121510848403,
1.3926655855029821,
1.259799218736589]]],
["vm1_blockparam_call",
[[5.530843419954181,
5.754100318998098,
5.4999083718284965,
5.909824676811695,
5.453678068704903],
[5.718877580016851,
5.781533771194518,
5.642458607442677,
5.682599168270826,
5.789289116859436],
[5.694487787783146,
5.730516019277275,
5.847027279436588,
5.7758748000487685,
5.723953898064792],
[5.916680314578116,
5.821031738072634,
5.678850069642067,
5.626730810850859,
5.703656557947397]]],
["vm1_blockparam_pass",
[[5.333951806649566,
5.547041137702763,
5.390959706157446,
5.385894214734435,
5.6055715680122375],
[5.652499822899699,
5.614506131969392,
5.441324954852462,
5.449716918170452,
5.473958337679505],
[2.4497437700629234,
2.4653187207877636,
2.4396206717938185,
2.4672860093414783,
2.4357821606099606],
[2.422079913318157,
2.254868390969932,
2.297367029823363,
2.2752416767179966,
2.2651320500299335]]],
["vm1_blockparam_yield",
[[4.681193007156253,
4.585045827552676,
4.663360565900803,
4.565610415302217,
4.560332400724292],
[4.770014110952616,
4.693701208569109,
4.669947342947125,
4.6642184145748615,
4.702302381396294],
[1.8568331524729729,
2.0619641495868564,
1.8837449587881565,
1.8565067378804088,
1.944807281717658],
[1.7709983959794044,
1.7460943888872862,
1.7420761128887534,
1.7479670252650976,
1.8392816875129938]]],
["vm1_const",
[[0.673799236305058,
0.6289646802470088,
0.6426139371469617,
0.6316197961568832,
0.637986452318728],
[0.6692809769883752,
0.6680225059390068,
0.6677848817780614,
0.6684680609032512,
0.6681160153821111],
[0.6811496438458562,
0.6804074477404356,
0.6871226681396365,
0.6811571577563882,
0.6806154483929276],
[0.6359898326918483,
0.6364925857633352,
0.6365431845188141,
0.6646013855934143,
0.635978096164763]]],
["vm1_ensure",
[[0.4179206723347306,
0.4178086072206497,
0.4177434192970395,
0.43235581647604704,
0.41820990294218063],
[0.46299421694129705,
0.4627833301201463,
0.4628591099753976,
0.4623630363494158,
0.46261554304510355],
[0.4739560689777136,
0.47334925923496485,
0.47417939454317093,
0.47491976618766785,
0.474414368160069],
[0.4484301460906863,
0.44759572576731443,
0.4524977933615446,
0.4473575744777918,
0.44721302296966314]]],
["vm1_float_simple",
[[3.4377737771719694,
3.4296320350840688,
3.4306024936959147,
3.4263686295598745,
3.424309113062918],
[3.8312151320278645,
3.6576587120071054,
3.659487722441554,
3.6614441787824035,
3.65794943831861],
[4.492796437814832,
3.929424907080829,
3.9185613989830017,
3.9249936919659376,
3.916889543645084],
[3.9276854023337364,
4.571953944861889,
3.9244422130286694,
3.9372902931645513,
3.932452884502709]]],
["vm1_gc_short_lived",
[[3.970261429436505,
4.021901831030846,
3.9680663608014584,
3.9821827886626124,
3.966042624786496],
[4.3000673381611705,
4.294544079340994,
4.333468989469111,
4.274460714310408,
4.297868913039565],
[3.979233019053936,
3.992850139737129,
4.003715254366398,
3.9962109168991446,
3.9884786857292056],
[3.996678475290537,
3.9989688880741596,
4.023256856016815,
4.071604412049055,
3.9946960965171456]]],
["vm1_gc_short_with_complex_long",
[[4.3283177418634295,
4.223051902838051,
4.3000400476157665,
4.319697103463113,
4.292609076015651],
[4.342072139494121,
4.312078240327537,
4.302175440825522,
4.321224361658096,
4.3238424733281136],
[4.518936256878078,
4.378754242323339,
4.368203934282064,
4.377462053671479,
4.401532907038927],
[4.3588674534112215,
4.4546590112149715,
4.3608705485239625,
4.379730576649308,
4.360716417431831]]],
["vm1_gc_short_with_long",
[[4.982936262153089,
4.7541441433131695,
4.378576665185392,
4.787012606859207,
4.397237667813897],
[4.254866898059845,
4.623631022870541,
4.657522251829505,
4.622929994948208,
4.278917017392814],
[4.2391941249370575,
4.27221708279103,
4.234884295612574,
4.238052228465676,
4.3883656254038215],
[4.640468697994947,
4.70163459982723,
4.644291591830552,
4.82427439186722,
4.640353991650045]]],
["vm1_gc_short_with_symbol",
[[4.128805799409747,
4.02243591658771,
4.0051007606089115,
4.0175188658759,
3.99500167183578],
[4.341198854148388,
4.330056168138981,
4.374754324555397,
4.303981394506991,
4.302381478250027],
[3.9529457790777087,
3.945811789482832,
3.9649920649826527,
3.941321828402579,
3.941511433571577],
[3.936058273538947,
3.938582860864699,
3.9256192333996296,
3.929445036686957,
3.9312875606119633]]],
["vm1_gc_wb_ary",
[[0.8134366236627102,
0.9425155743956566,
0.810227507725358,
0.808975649997592,
0.8090758994221687],
[0.9108235044404864,
0.9097813703119755,
0.911210804246366,
0.9071115972474217,
0.9085765732452273],
[0.9252893812954426,
0.9267751956358552,
0.9420013297349215,
0.9229717152193189,
0.9266486158594489],
[0.9228408224880695,
0.9194059213623405,
0.9216093067079782,
0.9501404780894518,
0.9196680337190628]]],
["vm1_gc_wb_ary_promoted",
[[0.8575779218226671,
0.8530022520571947,
0.8543383879587054,
0.8542105630040169,
0.8523113569244742],
[0.9110242640599608,
0.9099698988720775,
0.9093383010476828,
0.9549500085413456,
0.9102202672511339],
[0.9235727675259113,
0.9261145163327456,
0.924994352273643,
0.9253526357933879,
0.9257693402469158],
[0.9208290288224816,
0.9178777849301696,
0.9308790015056729,
0.9178461730480194,
0.9206209182739258]]],
["vm1_gc_wb_obj",
[[0.7344502899795771,
0.8931145127862692,
0.7330877706408501,
0.749016659334302,
0.7323824623599648],
[0.8043870376423001,
0.8180004293099046,
0.8088260889053345,
0.81008714530617,
0.8151710452511907],
[0.8501133359968662,
0.8687211591750383,
0.8440206628292799,
0.838344793766737,
0.8429984226822853],
[0.8177876016125083,
0.8066678522154689,
0.8085187096148729,
0.81284408736974,
0.8054432664066553]]],
["vm1_gc_wb_obj_promoted",
[[0.7713038772344589,
0.7690691528841853,
0.7693197317421436,
0.8243326721712947,
0.7669011671096087],
[0.8541847532615066,
0.8068015901371837,
0.8132928013801575,
0.8073939876630902,
0.8090243171900511],
[0.8394197328016162,
0.838859467767179,
0.8391662063077092,
0.8403420718386769,
0.840756275691092],
[0.8079216973856091,
0.8091209465637803,
0.8049498107284307,
0.8058611880987883,
0.8096832763403654]]],
["vm1_ivar",
[[0.6113632088527083,
0.6074917959049344,
0.6265815570950508,
0.6111576156690717,
0.6082240492105484],
[0.6535889031365514,
0.6527379862964153,
0.6531391711905599,
0.6518992781639099,
0.6537933917716146],
[0.6642929576337337,
0.6638645865023136,
0.6647167690098286,
0.6630283091217279,
0.662922590970993],
[0.6466583451256156,
0.6454455209895968,
0.6463614758104086,
0.6491927178576589,
0.7741084573790431]]],
["vm1_ivar_set",
[[0.7301303874701262,
0.7190538691356778,
0.7192482575774193,
0.7230735840275884,
0.7273735636845231],
[0.7801290303468704,
0.7830705661326647,
0.7808935474604368,
0.7907607415691018,
0.7794415941461921],
[0.7882513646036386,
0.7926838779821992,
0.7969612805172801,
0.7911466974765062,
0.7919378839433193],
[0.7553661717101932,
0.7559350840747356,
0.7542028333991766,
0.9644231786951423,
0.7661874806508422]]],
["vm1_length",
[[0.9499629233032465,
0.7471891790628433,
0.7477815914899111,
0.7496443660929799,
0.7429783688858151],
[0.8455419484525919,
0.8420565668493509,
0.8418171619996428,
0.8795920321717858,
0.843876582570374],
[0.8602595468983054,
0.8578748377040029,
0.859683527611196,
0.8565905764698982,
0.8621567469090223],
[0.8514421181753278,
0.8480733605101705,
0.8490802487358451,
0.8487747944891453,
0.8645786456763744]]],
["vm1_lvar_init",
[[1.6399649120867252,
1.6460850648581982,
1.6384170046076179,
1.6309055285528302,
1.6429072571918368],
[1.486971840262413,
1.5846282355487347,
1.4553700210526586,
1.4105997858569026,
1.4274101741611958],
[1.517898553982377,
1.4890678999945521,
1.4885039739310741,
1.6129294000566006,
1.4784392891451716],
[1.4039916452020407,
1.4010341931134462,
1.4139288775622845,
1.4136650385335088,
1.4194312822073698]]],
["vm1_lvar_set",
[[2.2264384273439646,
1.966598459519446,
1.9951813546940684,
1.96509906090796,
1.9778020633384585],
[2.0322912577539682,
2.033676532097161,
2.0355348279699683,
2.032198586501181,
2.034584636799991],
[2.053531794808805,
2.0637367153540254,
2.0529544418677688,
2.0645198402926326,
2.0527466582134366],
[2.0392724676057696,
2.018345307558775,
2.0251504778862,
2.018694478087127,
2.6607636380940676]]],
["vm1_neq",
[[0.7816581362858415,
0.7844801908358932,
0.7806287445127964,
0.7793467259034514,
0.7869414901360869],
[0.8547707917168736,
0.8404115587472916,
0.8402957199141383,
0.8406060999259353,
0.8465976165607572],
[0.8613753188401461,
0.8600517520681024,
0.8556281076744199,
0.8878092262893915,
0.8581048091873527],
[0.8370948377996683,
0.8388927280902863,
0.8340346394106746,
0.8389740074053407,
0.8366635851562023]]],
["vm1_not",
[[0.6226228456944227,
0.6195132406428456,
0.6300992984324694,
0.6380940685048699,
0.6227479642257094],
[0.6650179261341691,
0.666659664362669,
0.6778871174901724,
0.6775785461068153,
0.6637949701398611],
[0.704634309746325,
0.7034803256392479,
0.7048636814579368,
0.7091738991439342,
0.7086890041828156],
[0.6704635191708803,
0.6725514447316527,
0.669091553427279,
0.6743245739489794,
0.6765706483274698]]],
["vm1_rescue",
[[0.48362155817449093,
0.5607535289600492,
0.45292704924941063,
0.45301714166998863,
0.4538842123001814],
[0.5143291726708412,
0.5118257757276297,
0.5105192670598626,
0.6226660376414657,
0.5104353167116642],
[0.6674901051446795,
0.5255304118618369,
0.5901393871754408,
0.5251290267333388,
0.5248917480930686],
[0.512166753411293,
0.5233354698866606,
0.5263411998748779,
0.6144088674336672,
0.5253454837948084]]],
["vm1_simplereturn",
[[0.8855573497712612,
0.9209818625822663,
0.8767516976222396,
0.8701710682362318,
0.8700376432389021],
[0.9268939765170217,
1.1342718796804547,
0.9253498045727611,
1.0367419961839914,
0.9223425947129726],
[1.1293946728110313,
0.9584309011697769,
0.9345335988327861,
0.9403315912932158,
0.9330351399257779],
[0.8541979864239693,
0.8389158621430397,
0.8456347994506359,
0.8340142024680972,
0.8410083567723632]]],
["vm1_swap",
[[0.5515313819050789,
0.5509366225451231,
0.5512991594150662,
0.5509388176724315,
0.5789878824725747],
[0.5984950447455049,
0.6074849534779787,
0.6047585289925337,
0.6045454321429133,
0.6044688150286674],
[0.6128213750198483,
0.6129792667925358,
0.6129238242283463,
0.6129599316045642,
0.6197584327310324],
[0.596332311630249,
0.5994708593934774,
0.5955106290057302,
0.5936657302081585,
0.5934464791789651]]],
["vm1_yield",
[[0.9466953705996275,
0.9468949288129807,
0.9466270487755537,
0.9882068214938045,
1.0067393593490124],
[0.988257396966219,
0.988337779417634,
0.9892059173434973,
0.9879414644092321,
0.9914456540718675],
[1.0160547094419599,
1.0292068710550666,
1.0243378710001707,
1.007736699655652,
1.0086251655593514],
[0.9446033472195268,
0.9431708427146077,
0.9632953153923154,
0.9406146509572864,
0.9670986672863364]]],
["vm2_array",
[[0.6879033893346786,
0.6807534145191312,
0.6880061561241746,
0.6877457061782479,
0.6876855241134763],
[0.6683848490938544,
0.6750662988051772,
0.6738111479207873,
0.6695768916979432,
0.668460575863719],
[0.7024285700172186,
0.7039032345637679,
0.7031668955460191,
0.7013489454984665,
0.7017070166766644],
[0.6952498964965343,
0.6990041481330991,
0.7041021836921573,
0.7116325199604034,
0.6965233478695154]]],
["vm2_bigarray",
[[2.931380044668913,
2.966919862665236,
3.022059055045247,
2.9457194609567523,
2.9613160230219364],
[3.0213973065838218,
3.0098908515647054,
3.004955650307238,
3.006437400355935,
3.0052676936611533],
[3.022303474135697,
3.015151779167354,
3.0898205656558275,
3.023872960358858,
3.095117513090372],
[3.011964120902121,
3.005124825052917,
2.9446652783080935,
3.0019884072244167,
2.9988143481314182]]],
["vm2_bighash",
[[1.0641428176313639,
1.1071511320769787,
1.1037046872079372,
1.0879178764298558,
1.0978290429338813],
[0.4551398176699877,
0.45289504528045654,
0.4548823880031705,
0.4595910431817174,
0.4582721395418048],
[0.4610483767464757,
0.46069761365652084,
0.46141425613313913,
0.4581455076113343,
0.45628385432064533],
[0.4660323280841112,
0.466643787920475,
0.4625652004033327,
0.46597661357373,
0.4720247620716691]]],
["vm2_case",
[[0.22057433519512415,
0.16993278078734875,
0.16992263682186604,
0.16994296573102474,
0.1699926108121872],
[0.1846805289387703,
0.1841173367574811,
0.18422345630824566,
0.18521067313849926,
0.1874868143349886],
[0.19681511167436838,
0.19629650376737118,
0.19628396816551685,
0.19629060570150614,
0.19704224169254303],
[0.18860022816807032,
0.18725387658923864,
0.1926647750660777,
0.1910641547292471,
0.1873056935146451]]],
["vm2_case_lit",
[[0.6838153330609202,
0.6634501442313194,
0.6670353524386883,
0.6622022213414311,
0.6791366972029209],
[0.6602653544396162,
0.6596519201993942,
0.6507228203117847,
0.8084848746657372,
0.6658746609464288],
[0.9160970142111182,
0.7322486881166697,
0.7381801595911384,
0.734194764867425,
0.7113137794658542],
[0.6742148213088512,
0.6790109248831868,
0.6758620152249932,
0.6780694173648953,
0.6758277770131826]]],
["vm2_defined_method",
[[2.2170686880126595,
2.312459481880069,
2.222548226825893,
2.235144617035985,
2.223838474601507],
[2.391143531538546,
2.4075656654313207,
2.436562003567815,
2.389460636302829,
2.464390557259321],
[3.0968091571703553,
2.574973779730499,
2.4956702906638384,
2.542401692830026,
2.4175443071871996],
[2.1891724187880754,
2.171085959300399,
2.2664444353431463,
2.1681242268532515,
2.160668938420713]]],
["vm2_dstr",
[[0.9101701565086842,
0.8535049753263593,
0.8597821574658155,
0.8533114967867732,
0.8564699748530984],
[0.9540958851575851,
0.9302140483632684,
0.9056037301197648,
0.908707152120769,
0.9066498735919595],
[0.9310823855921626,
0.9244440058246255,
0.9601276246830821,
0.9271508250385523,
0.924890068359673],
[0.9092350276187062,
0.906065777875483,
0.9057641513645649,
0.9113192986696959,
0.9056867714971304]]],
["vm2_eval",
[[16.718625208362937,
17.28424076270312,
16.972146140411496,
16.52821529377252,
16.834049965254962],
[17.116188400425017,
17.3485023137182,
17.362054970115423,
17.29709404334426,
17.095396992750466],
[18.248213010840118,
18.421063139103353,
18.388740411028266,
18.342810074798763,
18.258126033470035],
[18.992245567962527,
18.69465200509876,
18.67924950271845,
18.83897701371461,
18.925650051794946]]],
["vm2_fiber_switch",
[[2.422097958624363,
2.454029757529497,
2.4321685172617435,
2.4711640495806932,
2.4509651735424995],
[2.661185353063047,
2.7320316340774298,
2.673636855557561,
2.6604054234921932,
2.7170183500275016],
[2.402249406091869,
2.4175773868337274,
2.4082290772348642,
2.4632625384256244,
2.4030340472236276],
[2.4314284306019545,
2.4604553170502186,
2.4275944530963898,
2.397690915502608,
2.4740118058398366]]],
["vm2_method",
[[0.8423004625365138,
0.8438723860308528,
0.8423204245045781,
0.8452958464622498,
0.8551852088421583],
[0.8381646098569036,
0.960912274196744,
0.9089878024533391,
0.8222297308966517,
0.850903925485909],
[0.8685315754264593,
0.8886378156021237,
0.864399241283536,
0.8978807544335723,
0.8778506051748991],
[0.8053509183228016,
0.8025825889781117,
0.8039987264201045,
0.8023779317736626,
0.8136614905670285]]],
["vm2_method_missing",
[[2.039170482195914,
1.8635820969939232,
1.8277103146538138,
1.8445083135738969,
2.0094737373292446],
[1.8583634123206139,
1.8589506382122636,
1.857690591365099,
1.8582142479717731,
1.8586676865816116],
[1.878373198211193,
1.8901610262691975,
1.876028592698276,
1.9090906856581569,
1.8919458910822868],
[1.9104250110685825,
1.8112911330536008,
1.820550206117332,
1.8132611121982336,
1.812999022193253]]],
["vm2_method_with_block",
[[0.867371597327292,
0.8557482482865453,
1.0366066675633192,
0.8531498992815614,
0.8604749869555235],
[0.8727079927921295,
0.8797455644235015,
0.8746652277186513,
0.9148074556142092,
0.8730647470802069],
[0.9724524775519967,
0.9823746792972088,
0.9800840029492974,
0.9760151570662856,
0.9619612768292427],
[0.9057921674102545,
0.9025661591440439,
0.911524998024106,
0.9151780940592289,
0.9026452135294676]]],
["vm2_module_ann_const_set",
[[4.619345954619348,
4.659718052484095,
4.575888819992542,
4.608316856436431,
4.574162160046399],
[4.5983307380229235,
4.654339836910367,
4.713745977729559,
4.619368797168136,
4.699738371185958],
[4.761367827653885,
4.655590275302529,
4.645173650234938,
4.664962224662304,
4.756889489479363],
[4.609621262177825,
4.663952679373324,
4.634255982935429,
4.665562521666288,
4.626598101109266]]],
["vm2_module_const_set",
[[4.060350379906595,
4.092231187969446,
4.088175083510578,
4.083009165711701,
4.062972409650683],
[4.027109404094517,
4.024824561551213,
4.121719679795206,
4.024495902471244,
4.056667405180633],
[4.137245091609657,
4.14350088685751,
4.163888447917998,
4.181744988076389,
4.1926790764555335],
[4.447292258031666,
4.395610785111785,
4.41122838575393,
4.446610104292631,
4.394822235219181]]],
["vm2_mutex",
[[0.6595231629908085,
0.6693255919963121,
0.6750112604349852,
0.6602621739730239,
0.6614552205428481],
[0.5654449770227075,
0.5687443995848298,
0.5646612271666527,
0.5758685832843184,
0.5662791971117258],
[0.6083284821361303,
0.5917344084009528,
0.6205710461363196,
0.5969145288690925,
0.6222432870417833],
[0.5808472177013755,
0.5794729962944984,
0.579837559722364,
0.5805721031501889,
0.581592595204711]]],
["vm2_newlambda",
[[0.747922221198678,
0.7412349013611674,
0.748213168233633,
0.7613251926377416,
0.7504190392792225],
[0.7616980224847794,
0.7521673496812582,
0.767953003756702,
0.8932927567511797,
0.7512757377699018],
[0.9265603190287948,
0.774400619789958,
0.7770624551922083,
0.7769672786816955,
0.7758155073970556],
[0.7906234571710229,
0.7944205170497298,
0.8005718803033233,
0.7746407268568873,
0.7872080132365227]]],
["vm2_poly_method",
[[1.963839778676629,
1.934094225987792,
2.080768303014338,
1.921637136489153,
2.089455271139741],
[2.037475165911019,
2.0290770530700684,
1.9655153034254909,
1.966142357327044,
1.9636014988645911],
[1.95117795933038,
1.9968231581151485,
1.9227830050513148,
1.933584694750607,
1.9243655977770686],
[1.8495569434016943,
1.8690578322857618,
1.8511461419984698,
1.875864140689373,
1.8929387042298913]]],
["vm2_poly_method_ov",
[[0.2304581431671977,
0.23086052108556032,
0.23029428720474243,
0.23026043456047773,
0.23226655181497335],
[0.25307000894099474,
0.25292895175516605,
0.25291548762470484,
0.2530162697657943,
0.2528738584369421],
[0.25989875197410583,
0.26223669946193695,
0.25995477475225925,
0.25971176009625196,
0.2598541658371687],
[0.2617475325241685,
0.2571541629731655,
0.25922003854066133,
0.2570143258199096,
0.2569133145734668]]],
["vm2_poly_singleton",
[[1.056302455253899,
1.0928648402914405,
1.0625794995576143,
1.0606936272233725,
1.078374756500125],
[1.0855855774134398,
1.0882130227982998,
1.0854570558294654,
1.0824537770822644,
1.089549308642745],
[1.2017863914370537,
1.0819554515182972,
1.1675442950800061,
1.0966295739635825,
1.0976999336853623],
[0.9881633212789893,
0.9855323806405067,
0.9781452398747206,
0.9813648303970695,
1.0134037910029292]]],
["vm2_proc",
[[0.4128565099090338,
0.41388774290680885,
0.4151155147701502,
0.4231558032333851,
0.4157105116173625],
[0.47645074035972357,
0.4549435758963227,
0.47815077006816864,
0.4594630775973201,
0.47499845642596483],
[0.45905072148889303,
0.4490852802991867,
0.46935277059674263,
0.46591903641819954,
0.4639596687629819],
[0.4550198698416352,
0.4550231425091624,
0.45700353663414717,
0.4505202239379287,
0.45555445924401283]]],
["vm2_raise1",
[[3.5394127229228616,
3.5354533502832055,
3.547255058772862,
3.5763096641749144,
3.6347243525087833],
[3.6334931487217546,
3.631053696386516,
3.6370621928945184,
3.6772939953953028,
3.680373840034008],
[3.5401264261454344,
3.551492450758815,
3.510443389415741,
3.55013904068619,
3.6103051379323006],
[3.5075750229880214,
3.5183465108275414,
3.487779026851058,
3.483348281122744,
3.500735874287784]]],
["vm2_raise2",
[[5.640480271540582,
5.448301689699292,
5.515504111535847,
5.5870074620470405,
5.456209228374064],
[5.7030363930389285,
5.694540305994451,
5.649818086065352,
5.63062578253448,
5.656540053896606],
[5.551559401676059,
5.569777560420334,
5.563222817145288,
5.5571034997701645,
5.5534384567290545],
[5.494964850135148,
5.474818249233067,
5.554188945330679,
5.478121626190841,
5.453758143819869]]],
["vm2_regexp",
[[0.9345816690474749,
0.9242771873250604,
0.9239272149279714,
0.9228821704164147,
0.9258621726185083],
[0.9708305420354009,
0.9710144801065326,
0.971285181120038,
0.9722117567434907,
0.9702650289982557],
[0.9594777878373861,
0.9555474184453487,
0.9562963331118226,
0.955180088058114,
1.1078183818608522],
[0.9562140889465809,
0.9535345397889614,
0.9598455727100372,
1.1437578722834587,
0.9557588761672378]]],
["vm2_send",
[[0.44093822315335274,
0.3511182367801666,
0.32640426233410835,
0.3316727699711919,
0.3345595756545663],
[0.352178480476141,
0.3620084775611758,
0.3764608381316066,
0.35480916034430265,
0.35190825164318085],
[0.36500020045787096,
0.3908478068187833,
0.3618582831695676,
0.35354460310190916,
0.35361377988010645],
[0.3533921232447028,
0.34500707034021616,
0.3424664195626974,
0.3424155507236719,
0.34233205299824476]]],
["vm2_string_literal",
[[0.2242958089336753,
0.22422402538359165,
0.22474661841988564,
0.22396460641175508,
0.223758845590055],
[0.24675879627466202,
0.24907668121159077,
0.24585421476513147,
0.24530491791665554,
0.24638168700039387],
[0.24748359341174364,
0.24655564408749342,
0.24706194549798965,
0.24715876579284668,
0.24696534126996994],
[0.25024435948580503,
0.24613196030259132,
0.24659795686602592,
0.24666296411305666,
0.24683881178498268]]],
["vm2_struct_big_aref_hi",
[[0.21344923973083496,
0.21397610567510128,
0.217591498978436,
0.21379563584923744,
0.21339174825698137],
[0.23171468172222376,
0.22946237958967686,
0.23697416111826897,
0.22974949423223734,
0.23122762143611908],
[0.24169778916984797,
0.23883204255253077,
0.23862307518720627,
0.2353495853021741,
0.23420832119882107],
[0.22997669409960508,
0.23249073885381222,
0.23029572889208794,
0.2300000386312604,
0.23080481868237257]]],
["vm2_struct_big_aref_lo",
[[0.21380270086228848,
0.21652668341994286,
0.21335487347096205,
0.21319017373025417,
0.21349182538688183],
[0.23108083102852106,
0.2292939554899931,
0.23041626904159784,
0.2300979197025299,
0.2305571949109435],
[0.2375079859048128,
0.23326641041785479,
0.23563627060502768,
0.23800937086343765,
0.24457866325974464],
[0.2302206726744771,
0.2318198699504137,
0.23002019617706537,
0.23473106231540442,
0.2328773932531476]]],
["vm2_struct_big_aset",
[[0.237123042345047,
0.23770717903971672,
0.23782570008188486,
0.2375199142843485,
0.23752303794026375],
[0.25586198177188635,
0.2607412366196513,
0.25639444775879383,
0.25619821809232235,
0.26105878222733736],
[0.276278723962605,
0.2640425283461809,
0.2640023520216346,
0.26203485764563084,
0.2613731427118182],
[0.2565210144966841,
0.2554275533184409,
0.261544949375093,
0.2584812864661217,
0.25929547008126974]]],
["vm2_struct_big_href_hi",
[[0.2956023393198848,
0.29406770318746567,
0.2973213540390134,
0.29400819819420576,
0.32877590134739876],
[0.3160199113190174,
0.3162379711866379,
0.3199714124202728,
0.3159192204475403,
0.3194360602647066],
[0.3197044301778078,
0.3190050721168518,
0.31957393046468496,
0.31953003723174334,
0.32402434945106506],
[0.3220282318070531,
0.3208946082741022,
0.3235566969960928,
0.32100933603942394,
0.32172038685530424]]],
["vm2_struct_big_href_lo",
[[0.2955749547109008,
0.2968687806278467,
0.29402787424623966,
0.29421871062368155,
0.29441249556839466],
[0.3169121276587248,
0.31676657870411873,
0.316965913400054,
0.31633466575294733,
0.31708176899701357],
[0.3155637374147773,
0.31557241454720497,
0.3170522041618824,
0.31569164246320724,
0.32466521114110947],
[0.3197305202484131,
0.31763041485100985,
0.32271901704370975,
0.319657277315855,
0.3573391120880842]]],
["vm2_struct_big_hset",
[[0.32773155719041824,
0.3178493306040764,
0.38019675668329,
0.31493213027715683,
0.3149310601875186],
[0.4199048327282071,
0.3492139717563987,
0.33906652592122555,
0.3397403694689274,
0.3427045922726393],
[0.35118310432881117,
0.34319135546684265,
0.33946997858583927,
0.34831795562058687,
0.341691636480391],
[0.33613864053040743,
0.3377050971612334,
0.33593417797237635,
0.33531004190444946,
0.33575355913490057]]],
["vm2_struct_small_aref",
[[0.17449604999274015,
0.17508253175765276,
0.19363085366785526,
0.17165197525173426,
0.1728421477600932],
[0.1850651791319251,
0.18484944198280573,
0.20156569592654705,
0.18485073372721672,
0.18680202402174473],
[0.19028134737163782,
0.19372699316591024,
0.20207310747355223,
0.19292897451668978,
0.1917476151138544],
[0.19039233773946762,
0.19071171060204506,
0.1903015300631523,
0.19258555117994547,
0.19024861883372068]]],
["vm2_struct_small_aset",
[[0.25045622419565916,
0.23791306093335152,
0.23771726433187723,
0.23955964390188456,
0.23769354820251465],
[0.25829240400344133,
0.2582491235807538,
0.2548843575641513,
0.2609655661508441,
0.2565011428669095],
[0.26237039268016815,
0.26467520371079445,
0.25748176779598,
0.2627118919044733,
0.2809766186401248],
[0.2552326526492834,
0.2547570103779435,
0.25718350149691105,
0.2533710990101099,
0.2571981279179454]]],
["vm2_struct_small_href",
[[0.3107422664761543,
0.26587213203310966,
0.26511883549392223,
0.2645557839423418,
0.2656591599807143],
[0.2861583763733506,
0.28642769157886505,
0.2848404301330447,
0.28455453272908926,
0.2833607839420438],
[0.29093282483518124,
0.28454430401325226,
0.29215049371123314,
0.286106014624238,
0.33175021782517433],
[0.30096718948334455,
0.2913954993709922,
0.29156415816396475,
0.293227132409811,
0.2894948963075876]]],
["vm2_struct_small_hset",
[[0.2780542057007551,
0.27570487186312675,
0.2762524439021945,
0.2763327965512872,
0.27646281104534864],
[0.302474114112556,
0.2997535187751055,
0.29909030161798,
0.30033108964562416,
0.3027640711516142],
[0.30328572914004326,
0.3048247080296278,
0.30345460679382086,
0.3149544820189476,
0.3065588315948844],
[0.2999376291409135,
0.2998925680294633,
0.2997020659968257,
0.2996747409924865,
0.29957148246467113]]],
["vm2_super",
[[0.3951922683045268,
0.4017675332725048,
0.4021150805056095,
0.3992750383913517,
0.3936321884393692],
[0.42028992623090744,
0.4107969691976905,
0.41471547819674015,
0.4108435697853565,
0.4127252772450447],
[0.4508631359785795,
0.42626385670155287,
0.43682218529284,
0.47110701259225607,
0.43810966424643993],
[0.4058084189891815,
0.41138959024101496,
0.4901592433452606,
0.5379780912771821,
0.40996528416872025]]],
["vm2_unif1",
[[0.20211779046803713,
0.20484201051294804,
0.20152448397129774,
0.2014916529878974,
0.23751750402152538],
[0.21408810932189226,
0.21340340841561556,
0.2134730014950037,
0.2151914518326521,
0.21884607058018446],
[0.22066356614232063,
0.22461617179214954,
0.2248547663912177,
0.2174307955428958,
0.21866703312844038],
[0.2219256730750203,
0.20623823441565037,
0.20549296401441097,
0.20561531465500593,
0.20531604439020157]]],
["vm2_zsuper",
[[0.4094451926648617,
0.41061127558350563,
0.428572547622025,
0.4093203730881214,
0.40922017209231853],
[0.4286733577027917,
0.4332756930962205,
0.42789354640990496,
0.4314629463478923,
0.42741391342133284],
[0.4509992506355047,
0.4631134122610092,
0.4614688018336892,
0.4455903647467494,
0.4530133754014969],
[0.4233180331066251,
0.4302905136719346,
0.4214795436710119,
0.42994418181478977,
0.4232106199488044]]],
["vm3_backtrace",
[[0.13976429589092731,
0.14181318506598473,
0.14070920087397099,
0.13924666307866573,
0.13842553365975618],
[0.14890534058213234,
0.1486876830458641,
0.148668278940022,
0.14734627772122622,
0.1475882139056921],
[0.14486138895154,
0.14541300386190414,
0.14550993219017982,
0.14565506856888533,
0.1454340536147356],
[0.1477775750681758,
0.1478390097618103,
0.14856997039169073,
0.14936698973178864,
0.14932245388627052]]],
["vm3_clearmethodcache",
[[0.24222776386886835,
0.24177947640419006,
0.24186649173498154,
0.24268512707203627,
0.24360188283026218],
[0.25108938571065664,
0.25082196667790413,
0.2502557262778282,
0.2515487913042307,
0.2527437163516879],
[0.2563631907105446,
0.25704192370176315,
0.2594701098278165,
0.2549857506528497,
0.25579832773655653],
[0.255524723790586,
0.25609891675412655,
0.2549712099134922,
0.25689463410526514,
0.2579151727259159]]],
["vm3_gc",
[[2.1808535512536764,
2.1949819196015596,
2.202510980889201,
2.1810358176007867,
2.169563232921064],
[2.761144170537591,
2.733060118742287,
2.756712385453284,
2.72822342813015,
2.7328729294240475],
[2.6345444936305285,
2.606421608477831,
2.6109197372570634,
2.613246292807162,
2.614854392595589],
[2.678764186799526,
2.704426043666899,
2.6760713532567024,
2.677072836086154,
2.6793594984337687]]],
["vm3_gc_old_full",
[[2.141999989748001,
2.1419968958944082,
2.1426977291703224,
2.136960718780756,
2.1392890214920044],
[2.1865233182907104,
2.274385235272348,
2.179888876155019,
2.1775283878669143,
2.245344441384077],
[2.1516162725165486,
2.1461330223828554,
2.149570361711085,
2.1482705660164356,
2.1446994999423623],
[2.138347951695323,
2.1400753119960427,
2.140069996006787,
2.137915234081447,
2.144130096770823]]],
["vm3_gc_old_immediate",
[[2.023003295995295,
3.3983790362253785,
2.040706943720579,
2.027483052574098,
2.0229092855006456],
[2.1300259893760085,
2.1187731930986047,
2.130536242388189,
2.1557531729340553,
2.12240943685174],
[2.0149036338552833,
2.0086050499230623,
2.026668718084693,
2.03363323956728,
2.015575715340674],
[2.029278125613928,
2.087109581567347,
2.0583449248224497,
2.060246811248362,
2.0606304025277495]]],
["vm3_gc_old_lazy",
[[2.627276225015521,
2.5897014904767275,
2.6325794626027346,
2.640420876443386,
2.6140017388388515],
[2.690549506805837,
2.7807156117632985,
2.7773546064272523,
2.828917007893324,
2.7557871378958225],
[2.615165615454316,
2.5989129208028316,
2.5958776073530316,
2.6180637245997787,
2.6339213913306594],
[2.6669311355799437,
2.5608460353687406,
2.652139972895384,
2.640227389521897,
2.644776060245931]]],
["vm_symbol_block_pass",
[[0.6890878435224295,
0.6789304381236434,
0.6896575298160315,
0.6858800454065204,
0.6808324698358774],
[0.7159304311499,
0.7185308868065476,
0.7166847521439195,
0.7173843132331967,
0.7146834107115865],
[0.6871357448399067,
0.8641062695533037,
0.6929481225088239,
0.6984733147546649,
0.7233011610805988],
[0.6684396453201771,
0.6734270388260484,
0.677773923613131,
0.674062218517065,
0.6768492441624403]]],
["vm_thread_alive_check1",
[[0.08003556728363037,
0.08068436197936535,
0.08161660190671682,
0.08106287848204374,
0.0810283413156867],
[0.08925117831677198,
0.08755378797650337,
0.09206554852426052,
0.09126275312155485,
0.09024572279304266],
[0.09116620477288961,
0.09324696101248264,
0.09281659591943026,
0.0924611184746027,
0.09237904474139214],
[0.09318399615585804,
0.09221791848540306,
0.09026079624891281,
0.09599153976887465,
0.09209492430090904]]],
["vm_thread_close",
[[0.42705254163593054,
0.427050594240427,
0.4206481482833624,
0.43131527677178383,
0.42766829673200846],
[0.4692115820944309,
0.46141284238547087,
0.4690132746472955,
0.46218116115778685,
0.45972640346735716],
[0.42320986092090607,
0.45503614749759436,
0.4337203064933419,
0.43977702502161264,
0.4371778555214405],
[0.44170696195214987,
0.43477920815348625,
0.4264431083574891,
0.4559372551739216,
0.4402331728488207]]],
["vm_thread_condvar1",
[[0.5068395948037505,
0.49922027718275785,
0.4905734695494175,
0.4925146587193012,
0.4913450004532933],
[0.4958278760313988,
0.5044522285461426,
0.4982830863445997,
0.5141279632225633,
0.4914207458496094],
[0.5172950820997357,
0.4956356957554817,
0.5055789640173316,
0.5096529806032777,
0.5066920025274158],
[0.5183016061782837,
0.505222762003541,
0.5065654776990414,
0.5229422217234969,
0.5088327694684267]]],
["vm_thread_condvar2",
[[0.5233125993981957,
0.5059186508879066,
0.507368789985776,
0.5143058598041534,
0.5199752040207386],
[0.3867679750546813,
0.39505081437528133,
0.39263651613146067,
0.3886463074013591,
0.3922042930498719],
[0.3818937102332711,
0.3922112910076976,
0.37229993753135204,
0.38149037305265665,
0.3780381288379431],
[0.39039106015115976,
0.3820401728153229,
0.37418060563504696,
0.4052897710353136,
0.3839657995849848]]],
["vm_thread_create_join",
[[0.998861400410533,
0.9487500442191958,
1.0203588297590613,
1.012604946270585,
0.9807319212704897],
[0.983495332300663,
0.9638786651194096,
0.9679070468991995,
0.9961703261360526,
0.9701418615877628],
[1.020853460766375,
0.993821419775486,
1.0322873266413808,
1.0600321358069777,
1.0560854859650135],
[1.0198526559397578,
1.074254672974348,
0.9961341228336096,
1.0161309856921434,
1.0036895759403706]]],
["vm_thread_mutex1",
[[0.4960473794490099,
0.6460710074752569,
0.496061940677464,
0.503277369774878,
0.497000097297132],
[0.5820590993389487,
0.43677283078432083,
0.43682778533548117,
0.47659938130527735,
0.4396412316709757],
[0.4602205902338028,
0.4565476346760988,
0.4605985153466463,
0.4600034775212407,
0.4622178338468075],
[0.44742385298013687,
0.44924879632890224,
0.4479735055938363,
0.4526807554066181,
0.47652481868863106]]],
["vm_thread_mutex2",
[[2.322713453322649,
1.846596010029316,
1.6483780713751912,
2.0987603552639484,
1.7402854058891535],
[0.4340166384354234,
0.43856405559927225,
0.4442194104194641,
0.4382934523746371,
0.4406911004334688],
[0.4569590147584677,
0.4601500341668725,
0.4615392005071044,
0.4574607899412513,
0.4569877600297332],
[0.44866136740893126,
0.4477036530151963,
0.44927958492189646,
0.4748839922249317,
0.4480593539774418]]],
["vm_thread_mutex3",
[[13.229081232100725,
10.361821477301419,
13.21454683598131,
13.127974891103804,
13.101391088217497],
[0.5335255851969123,
0.6239631148055196,
0.595430564135313,
0.5881124306470156,
0.649148665368557],
[0.6481779562309384,
0.7439629575237632,
0.6616273690015078,
0.6847296943888068,
0.6425670552998781],
[0.6182468663901091,
0.6477580312639475,
0.7076717717573047,
0.6307074092328548,
0.6462077107280493]]],
["vm_thread_pass",
[[0.20077786222100258,
0.1840678071603179,
0.2092479821294546,
0.20319670345634222,
0.17695394903421402],
[0.2662556003779173,
0.20653991773724556,
0.2505806218832731,
0.3006536699831486,
0.31350578274577856],
[0.2777848755940795,
0.219541578553617,
0.24411905650049448,
0.19811622612178326,
0.19413186144083738],
[0.1954143075272441,
0.2819817801937461,
0.2202981784939766,
0.21726321894675493,
0.21226701233536005]]],
["vm_thread_pass_flood",
[[0.06185524072498083,
0.06377452705055475,
0.06320396903902292,
0.06295364908874035,
0.06256257276982069],
[0.0724976547062397,
0.0727549958974123,
0.07420433312654495,
0.0732979103922844,
0.07281546294689178],
[0.0760016506537795,
0.07527142576873302,
0.07552359625697136,
0.07348260283470154,
0.0750909373164177],
[0.07608831021934748,
0.07728622108697891,
0.07751876767724752,
0.07697273045778275,
0.0772504536435008]]],
["vm_thread_pipe",
[[0.28154731914401054,
0.2708658976480365,
0.28065589629113674,
0.27115851640701294,
0.2817091280594468],
[0.30450946278870106,
0.2787585724145174,
0.29437954537570477,
0.2891360120847821,
0.306916993111372],
[0.3100350499153137,
0.2925932416692376,
0.2896188236773014,
0.2987119536846876,
0.3008888456970453],
[0.30315235350281,
0.3017531055957079,
0.3073718249797821,
0.30004817247390747,
0.30826299358159304]]],
["vm_thread_queue",
[[0.09707112424075603,
0.09783682134002447,
0.09907612483948469,
0.09743348602205515,
0.10052135959267616],
[0.10897290054708719,
0.10889455210417509,
0.10858452413231134,
0.10851394012570381,
0.10863521881401539],
[0.11006676591932774,
0.10962370783090591,
0.11245737224817276,
0.11022763606160879,
0.11000106390565634],
[0.11161650065332651,
0.11197167541831732,
0.11070610396564007,
0.11094601359218359,
0.1106795622035861]]],
["vm_thread_sized_queue",
[[0.16495272517204285,
0.18097694870084524,
0.16396748647093773,
0.16168665327131748,
0.16181478556245565],
[0.1687923837453127,
0.16870401706546545,
0.16344268433749676,
0.16586524341255426,
0.16192950773984194],
[0.1805695602670312,
0.18242293410003185,
0.16569650918245316,
0.17067490704357624,
0.16444664355367422],
[0.16913603339344263,
0.16566202603280544,
0.1681229518726468,
0.1662365486845374,
0.16631945595145226]]],
["vm_thread_sized_queue2",
[[0.4533231146633625,
0.4604426044970751,
0.46321689151227474,
0.46123337745666504,
0.4566977312788367],
[0.42793169990181923,
0.4358728742226958,
0.4282519221305847,
0.42990866489708424,
0.43017060682177544],
[0.43597924150526524,
0.4221631111577153,
0.4346413044258952,
0.4337912444025278,
0.43028371687978506],
[0.43665296770632267,
0.4352031257003546,
0.4343093065544963,
0.4384396728128195,
0.4413782674819231]]],
["vm_thread_sized_queue3",
[[0.45086408499628305,
0.45005742367357016,
0.4500123728066683,
0.4580862410366535,
0.44981281366199255],
[0.4211096437647939,
0.41846535075455904,
0.4247137811034918,
0.4227958545088768,
0.4229021156206727],
[0.4330023005604744,
0.43574557825922966,
0.4312185253947973,
0.43063072487711906,
0.43380977399647236],
[0.42779526486992836,
0.4342837119475007,
0.42964852042496204,
0.4375357609242201,
0.4390948824584484]]],
["vm_thread_sized_queue4",
[[0.28202506247907877,
0.31670866906642914,
0.27734627667814493,
0.40430656634271145,
0.31685886811465025],
[0.26414157450199127,
0.32285674661397934,
0.2371793333441019,
0.30815719719976187,
0.24667307268828154],
[0.2452874593436718,
0.24910050723701715,
0.27432305831462145,
0.3108911532908678,
0.3159103225916624],
[0.41180176846683025,
0.3184793358668685,
0.29488882049918175,
0.2217257833108306,
0.2535018865019083]]]]
Elapsed time: 6988.928281464 (sec)
-----------------------------------------------------------
benchmark results:
minimum results in each 5 measurements.
Execution time (sec)
name ruby_2_4 trunk_oct trunk modified
app_answer 0.044 0.053 0.055 0.056
app_aobench 36.060 38.874 38.302 37.156
app_erb 1.086 0.803 0.833 0.825
app_factorial 0.604 0.666 0.607 0.610
app_fib 0.339 0.384 0.399 0.358
app_lc_fizzbuzz 36.532 34.440 32.893 31.319
app_mandelbrot 0.909 0.944 0.949 0.936
app_pentomino 10.261 10.421 10.102 9.880
app_raise 0.175 0.187 0.185 0.188
app_strconcat 0.764 0.730 0.738 0.728
app_tak 0.503 0.511 0.536 0.499
app_tarai 0.420 0.437 0.469 0.414
app_uri 0.451 0.467 0.457 0.455
array_sample_100k_10 0.029 0.037 0.038 0.040
array_sample_100k_11 0.642 0.041 0.041 0.044
array_sample_100k__100 0.660 0.081 0.081 0.084
array_sample_100k__1k 0.804 0.498 0.491 0.496
array_sample_100k__6k 1.568 1.590 1.563 1.569
array_sample_100k___10k 2.166 2.194 2.158 2.159
array_sample_100k___50k 7.716 7.865 7.740 7.786
array_shift 3.586 3.653 1.960 1.957
array_small_and 0.042 0.043 0.044 0.046
array_small_diff 0.046 0.044 0.045 0.047
array_small_or 0.048 0.051 0.052 0.054
array_sort_block 4.991 4.621 4.660 4.433
array_sort_float 2.943 1.531 1.554 1.521
bighash 1.162 1.191 1.205 1.202
dir_empty_p 0.208 0.217 0.229 0.230
erb_render 2.601 1.061 1.083 1.057
file_chmod 0.190 0.199 0.219 0.218
file_rename 0.650 0.664 0.675 0.675
hash_aref_dsym 0.264 0.292 0.309 0.305
hash_aref_dsym_long 3.176 3.059 3.165 3.156
hash_aref_fix 0.252 0.283 0.291 0.279
hash_aref_flo 0.049 0.059 0.060 0.062
hash_aref_miss 0.362 0.376 0.369 0.389
hash_aref_str 0.330 0.341 0.345 0.329
hash_aref_sym 0.265 0.299 0.298 0.299
hash_aref_sym_long 0.362 0.413 0.405 0.403
hash_flatten 0.239 0.181 0.206 0.189
hash_ident_flo 0.049 0.059 0.060 0.061
hash_ident_num 0.255 0.279 0.282 0.290
hash_ident_obj 0.256 0.284 0.291 0.283
hash_ident_str 0.260 0.279 0.284 0.281
hash_ident_sym 0.257 0.292 0.294 0.292
hash_keys 0.095 0.102 0.100 0.109
hash_long 0.669 0.576 0.579 0.578
hash_shift 0.029 0.038 0.039 0.041
hash_shift_u16 0.067 0.076 0.078 0.079
hash_shift_u24 0.067 0.076 0.078 0.079
hash_shift_u32 0.067 0.076 0.078 0.079
hash_small2 0.449 0.462 0.476 0.474
hash_small4 0.571 0.586 0.607 0.602
hash_small8 1.030 1.047 1.177 1.092
hash_to_proc 0.024 0.033 0.034 0.036
hash_values 0.095 0.101 0.100 0.109
int_quo 1.729 0.905 0.899 0.902
io_copy_stream_write 0.162 0.164 0.167 0.168
io_copy_stream_write_socket 0.316 0.320 0.320 0.324
io_file_create 0.780 0.808 0.781 0.787
io_file_read 0.822 0.769 0.754 0.753
io_file_write 0.574 0.575 0.574 0.571
io_nonblock_noex 1.340 1.276 1.290 1.307
io_nonblock_noex2 0.820 0.823 0.839 0.833
io_pipe_rw 0.700 0.710 0.720 0.719
io_select 0.995 1.002 0.994 0.997
io_select2 1.206 1.221 1.218 1.224
io_select3 0.099 0.110 0.097 0.108
loop_for 0.891 0.978 1.012 0.977
loop_generator 0.279 0.304 0.281 0.282
loop_times 0.799 0.895 0.901 0.878
loop_whileloop 0.388 0.426 0.443 0.430
loop_whileloop2 0.095 0.109 0.113 0.112
marshal_dump_flo 0.246 0.254 0.257 0.261
marshal_dump_load_geniv 0.384 0.391 0.389 0.395
marshal_dump_load_time 1.152 1.128 1.155 1.157
require 0.677 0.719 0.706 0.719
require_thread 0.128 0.137 32.263 62.515
securerandom 0.173 0.221 0.223 0.222
so_ackermann 0.394 0.398 0.418 0.392
so_array 0.612 0.653 0.670 0.656
so_binary_trees 4.239 4.239 4.540 4.430
so_concatenate 2.849 2.951 3.072 2.956
so_count_words 0.133 0.140 0.154 0.156
so_exception 0.222 0.227 0.235 0.222
so_fannkuch 0.818 0.844 0.848 0.845
so_fasta 1.214 1.283 1.280 1.272
so_k_nucleotide 0.859 0.865 0.872 0.869
so_lists 0.383 0.358 0.363 0.362
so_mandelbrot 1.824 1.932 2.020 1.894
so_matrix 0.380 0.407 0.418 0.407
so_meteor_contest 2.048 2.177 2.077 2.011
so_nbody 1.041 1.140 1.176 1.167
so_nested_loop 0.715 0.780 0.807 0.777
so_nsieve 1.249 1.347 1.364 1.335
so_nsieve_bits 1.645 1.663 1.689 1.651
so_object 0.500 0.525 0.530 0.511
so_partial_sums 1.709 1.802 1.843 1.799
so_pidigits 0.764 0.781 0.760 0.760
so_random 0.452 0.476 0.487 0.477
so_reverse_complement 1.103 1.076 1.083 1.088
so_sieve 0.384 0.423 0.431 0.424
so_spectralnorm 1.293 1.447 1.524 1.440
string_index 0.272 0.280 0.226 0.228
string_scan_re 0.207 0.195 0.193 0.195
string_scan_str 0.189 0.145 0.141 0.143
time_subsec 2.115 0.942 0.940 0.954
vm1_attr_ivar* 0.506 0.526 0.567 0.532
vm1_attr_ivar_set* 0.597 0.590 0.594 0.581
vm1_block* 0.979 1.011 1.067 0.950
vm1_blockparam* 3.678 3.668 0.888 0.830
vm1_blockparam_call* 5.066 5.216 5.252 5.197
vm1_blockparam_pass* 4.946 5.015 1.993 1.825
vm1_blockparam_yield* 4.172 4.238 1.414 1.312
vm1_const* 0.241 0.242 0.238 0.206
vm1_ensure* 0.030 0.036 0.031 0.018
vm1_float_simple* 3.036 3.231 3.474 3.495
vm1_gc_short_lived* 3.578 3.848 3.537 3.565
vm1_gc_short_with_complex_long* 3.835 3.876 3.925 3.929
vm1_gc_short_with_long* 3.991 3.829 3.792 4.211
vm1_gc_short_with_symbol* 3.607 3.876 3.499 3.496
vm1_gc_wb_ary* 0.421 0.481 0.480 0.490
vm1_gc_wb_ary_promoted* 0.464 0.483 0.481 0.488
vm1_gc_wb_obj* 0.345 0.378 0.396 0.376
vm1_gc_wb_obj_promoted* 0.379 0.381 0.396 0.375
vm1_ivar* 0.220 0.226 0.220 0.216
vm1_ivar_set* 0.331 0.353 0.346 0.325
vm1_length* 0.355 0.416 0.414 0.418
vm1_lvar_init* 1.243 0.984 1.036 0.971
vm1_lvar_set* 1.577 1.606 1.610 1.589
vm1_neq* 0.391 0.414 0.413 0.404
vm1_not* 0.232 0.238 0.261 0.239
vm1_rescue* 0.065 0.084 0.082 0.083
vm1_simplereturn* 0.482 0.496 0.490 0.404
vm1_swap* 0.163 0.172 0.170 0.164
vm1_yield* 0.559 0.562 0.565 0.511
vm2_array* 0.586 0.559 0.588 0.583
vm2_bigarray* 2.836 2.896 2.902 2.833
vm2_bighash* 0.969 0.344 0.343 0.351
vm2_case* 0.075 0.075 0.083 0.075
vm2_case_lit* 0.567 0.542 0.598 0.562
vm2_defined_method* 2.122 2.280 2.304 2.049
vm2_dstr* 0.758 0.797 0.811 0.794
vm2_eval* 16.433 16.986 18.135 18.567
vm2_fiber_switch* 2.327 2.551 2.289 2.286
vm2_method* 0.747 0.713 0.751 0.691
vm2_method_missing* 1.733 1.749 1.763 1.699
vm2_method_with_block* 0.758 0.764 0.849 0.791
vm2_module_ann_const_set* 4.479 4.489 4.532 4.498
vm2_module_const_set* 3.965 3.915 4.024 4.283
vm2_mutex* 0.565 0.456 0.479 0.468
vm2_newlambda* 0.646 0.642 0.661 0.663
vm2_poly_method* 1.827 1.855 1.810 1.738
vm2_poly_method_ov* 0.135 0.144 0.147 0.145
vm2_poly_singleton* 0.961 0.973 0.969 0.866
vm2_proc* 0.318 0.346 0.336 0.339
vm2_raise1* 3.441 3.522 3.397 3.372
vm2_raise2* 5.353 5.522 5.438 5.342
vm2_regexp* 0.828 0.861 0.842 0.842
vm2_send* 0.232 0.243 0.240 0.230
vm2_string_literal* 0.129 0.136 0.133 0.134
vm2_struct_big_aref_hi* 0.118 0.120 0.121 0.118
vm2_struct_big_aref_lo* 0.118 0.120 0.120 0.118
vm2_struct_big_aset* 0.142 0.147 0.148 0.144
vm2_struct_big_href_hi* 0.199 0.207 0.206 0.209
vm2_struct_big_href_lo* 0.199 0.207 0.202 0.206
vm2_struct_big_hset* 0.220 0.230 0.226 0.223
vm2_struct_small_aref* 0.077 0.076 0.077 0.078
vm2_struct_small_aset* 0.143 0.146 0.144 0.142
vm2_struct_small_href* 0.170 0.174 0.171 0.178
vm2_struct_small_hset* 0.181 0.190 0.190 0.188
vm2_super* 0.299 0.302 0.313 0.294
vm2_unif1* 0.107 0.104 0.104 0.093
vm2_zsuper* 0.314 0.318 0.332 0.310
vm3_backtrace 0.138 0.147 0.145 0.148
vm3_clearmethodcache 0.242 0.250 0.255 0.255
vm3_gc 2.170 2.728 2.606 2.676
vm3_gc_old_full 2.137 2.178 2.145 2.138
vm3_gc_old_immediate 2.023 2.119 2.009 2.029
vm3_gc_old_lazy 2.590 2.691 2.596 2.561
vm_symbol_block_pass 0.679 0.715 0.687 0.668
vm_thread_alive_check1 0.080 0.088 0.091 0.090
vm_thread_close 0.421 0.460 0.423 0.426
vm_thread_condvar1 0.491 0.491 0.496 0.505
vm_thread_condvar2 0.506 0.387 0.372 0.374
vm_thread_create_join 0.949 0.964 0.994 0.996
vm_thread_mutex1 0.496 0.437 0.457 0.447
vm_thread_mutex2 1.648 0.434 0.457 0.448
vm_thread_mutex3 10.362 0.534 0.643 0.618
vm_thread_pass 0.177 0.207 0.194 0.195
vm_thread_pass_flood 0.062 0.072 0.073 0.076
vm_thread_pipe 0.271 0.279 0.290 0.300
vm_thread_queue 0.097 0.109 0.110 0.111
vm_thread_sized_queue 0.162 0.162 0.164 0.166
vm_thread_sized_queue2 0.453 0.428 0.422 0.434
vm_thread_sized_queue3 0.450 0.418 0.431 0.428
vm_thread_sized_queue4 0.277 0.237 0.245 0.222
Speedup ratio: compare with the result of `ruby_2_4' (greater is better)
name trunk_oct trunk modified
app_answer 0.836 0.809 0.801
app_aobench 0.928 0.941 0.971
app_erb 1.352 1.304 1.316
app_factorial 0.907 0.995 0.990
app_fib 0.881 0.849 0.947
app_lc_fizzbuzz 1.061 1.111 1.166
app_mandelbrot 0.963 0.958 0.972
app_pentomino 0.985 1.016 1.039
app_raise 0.937 0.948 0.933
app_strconcat 1.046 1.036 1.049
app_tak 0.984 0.937 1.007
app_tarai 0.959 0.896 1.014
app_uri 0.966 0.987 0.991
array_sample_100k_10 0.783 0.767 0.720
array_sample_100k_11 15.702 15.539 14.683
array_sample_100k__100 8.158 8.165 7.905
array_sample_100k__1k 1.614 1.638 1.621
array_sample_100k__6k 0.986 1.004 0.999
array_sample_100k___10k 0.987 1.004 1.003
array_sample_100k___50k 0.981 0.997 0.991
array_shift 0.982 1.830 1.833
array_small_and 0.984 0.966 0.922
array_small_diff 1.037 1.023 0.968
array_small_or 0.953 0.929 0.891
array_sort_block 1.080 1.071 1.126
array_sort_float 1.923 1.893 1.935
bighash 0.976 0.964 0.966
dir_empty_p 0.958 0.909 0.905
erb_render 2.451 2.401 2.462
file_chmod 0.956 0.870 0.873
file_rename 0.979 0.963 0.963
hash_aref_dsym 0.903 0.853 0.864
hash_aref_dsym_long 1.038 1.003 1.006
hash_aref_fix 0.890 0.867 0.904
hash_aref_flo 0.831 0.817 0.794
hash_aref_miss 0.961 0.981 0.929
hash_aref_str 0.968 0.954 1.000
hash_aref_sym 0.887 0.889 0.888
hash_aref_sym_long 0.876 0.895 0.899
hash_flatten 1.316 1.159 1.261
hash_ident_flo 0.824 0.813 0.791
hash_ident_num 0.914 0.903 0.880
hash_ident_obj 0.902 0.882 0.904
hash_ident_str 0.930 0.914 0.924
hash_ident_sym 0.880 0.874 0.882
hash_keys 0.928 0.945 0.872
hash_long 1.161 1.155 1.156
hash_shift 0.769 0.744 0.707
hash_shift_u16 0.887 0.864 0.849
hash_shift_u24 0.882 0.862 0.843
hash_shift_u32 0.883 0.860 0.847
hash_small2 0.972 0.945 0.947
hash_small4 0.975 0.941 0.948
hash_small8 0.983 0.874 0.943
hash_to_proc 0.736 0.710 0.666
hash_values 0.940 0.944 0.873
int_quo 1.909 1.923 1.917
io_copy_stream_write 0.989 0.971 0.964
io_copy_stream_write_socket 0.987 0.987 0.977
io_file_create 0.966 0.999 0.992
io_file_read 1.069 1.089 1.092
io_file_write 0.999 1.002 1.005
io_nonblock_noex 1.050 1.038 1.025
io_nonblock_noex2 0.997 0.977 0.984
io_pipe_rw 0.986 0.972 0.973
io_select 0.993 1.002 0.998
io_select2 0.988 0.990 0.985
io_select3 0.900 1.018 0.911
loop_for 0.911 0.881 0.912
loop_generator 0.917 0.993 0.987
loop_times 0.893 0.888 0.910
loop_whileloop 0.910 0.876 0.903
loop_whileloop2 0.870 0.839 0.849
marshal_dump_flo 0.970 0.958 0.946
marshal_dump_load_geniv 0.982 0.986 0.972
marshal_dump_load_time 1.021 0.997 0.995
require 0.941 0.959 0.942
require_thread 0.934 0.004 0.002
securerandom 0.781 0.777 0.780
so_ackermann 0.989 0.941 1.004
so_array 0.937 0.913 0.933
so_binary_trees 1.000 0.934 0.957
so_concatenate 0.965 0.927 0.964
so_count_words 0.946 0.862 0.850
so_exception 0.978 0.944 0.999
so_fannkuch 0.970 0.966 0.969
so_fasta 0.946 0.948 0.954
so_k_nucleotide 0.993 0.986 0.989
so_lists 1.070 1.055 1.056
so_mandelbrot 0.944 0.903 0.963
so_matrix 0.933 0.908 0.933
so_meteor_contest 0.941 0.986 1.018
so_nbody 0.914 0.886 0.892
so_nested_loop 0.917 0.886 0.920
so_nsieve 0.927 0.915 0.935
so_nsieve_bits 0.989 0.974 0.996
so_object 0.952 0.943 0.979
so_partial_sums 0.948 0.927 0.950
so_pidigits 0.979 1.006 1.005
so_random 0.949 0.927 0.947
so_reverse_complement 1.025 1.018 1.013
so_sieve 0.906 0.890 0.904
so_spectralnorm 0.893 0.848 0.897
string_index 0.971 1.205 1.194
string_scan_re 1.059 1.072 1.062
string_scan_str 1.304 1.337 1.317
time_subsec 2.246 2.250 2.219
vm1_attr_ivar* 0.963 0.893 0.952
vm1_attr_ivar_set* 1.012 1.004 1.027
vm1_block* 0.968 0.917 1.030
vm1_blockparam* 1.003 4.142 4.430
vm1_blockparam_call* 0.971 0.965 0.975
vm1_blockparam_pass* 0.986 2.482 2.710
vm1_blockparam_yield* 0.985 2.951 3.179
vm1_const* 0.998 1.014 1.169
vm1_ensure* 0.825 0.976 1.701
vm1_float_simple* 0.940 0.874 0.869
vm1_gc_short_lived* 0.930 1.012 1.004
vm1_gc_short_with_complex_long* 0.989 0.977 0.976
vm1_gc_short_with_long* 1.042 1.052 0.948
vm1_gc_short_with_symbol* 0.931 1.031 1.032
vm1_gc_wb_ary* 0.876 0.877 0.860
vm1_gc_wb_ary_promoted* 0.961 0.966 0.951
vm1_gc_wb_obj* 0.911 0.871 0.917
vm1_gc_wb_obj_promoted* 0.996 0.957 1.010
vm1_ivar* 0.973 0.997 1.018
vm1_ivar_set* 0.937 0.959 1.020
vm1_length* 0.854 0.858 0.849
vm1_lvar_init* 1.263 1.200 1.280
vm1_lvar_set* 0.982 0.980 0.993
vm1_neq* 0.945 0.948 0.968
vm1_not* 0.975 0.888 0.967
vm1_rescue* 0.772 0.792 0.788
vm1_simplereturn* 0.972 0.983 1.192
vm1_swap* 0.946 0.959 0.996
vm1_yield* 0.995 0.989 1.094
vm2_array* 1.047 0.996 1.004
vm2_bigarray* 0.979 0.977 1.001
vm2_bighash* 2.819 2.825 2.764
vm2_case* 1.000 0.903 0.995
vm2_case_lit* 1.047 0.948 1.009
vm2_defined_method* 0.931 0.921 1.036
vm2_dstr* 0.952 0.935 0.955
vm2_eval* 0.967 0.906 0.885
vm2_fiber_switch* 0.912 1.017 1.018
vm2_method* 1.048 0.995 1.082
vm2_method_missing* 0.991 0.983 1.020
vm2_method_with_block* 0.993 0.893 0.959
vm2_module_ann_const_set* 0.998 0.988 0.996
vm2_module_const_set* 1.013 0.985 0.926
vm2_mutex* 1.239 1.180 1.207
vm2_newlambda* 1.006 0.977 0.975
vm2_poly_method* 0.985 1.009 1.051
vm2_poly_method_ov* 0.941 0.924 0.933
vm2_poly_singleton* 0.988 0.992 1.110
vm2_proc* 0.919 0.947 0.939
vm2_raise1* 0.977 1.013 1.020
vm2_raise2* 0.970 0.984 1.002
vm2_regexp* 0.961 0.983 0.984
vm2_send* 0.953 0.963 1.004
vm2_string_literal* 0.946 0.966 0.960
vm2_struct_big_aref_hi* 0.984 0.979 1.003
vm2_struct_big_aref_lo* 0.984 0.985 1.001
vm2_struct_big_aset* 0.969 0.960 0.990
vm2_struct_big_href_hi* 0.963 0.967 0.952
vm2_struct_big_href_lo* 0.961 0.984 0.968
vm2_struct_big_hset* 0.957 0.972 0.985
vm2_struct_small_aref* 1.013 0.995 0.979
vm2_struct_small_aset* 0.979 0.990 1.009
vm2_struct_small_href* 0.973 0.990 0.955
vm2_struct_small_hset* 0.951 0.951 0.963
vm2_super* 0.990 0.954 1.016
vm2_unif1* 1.022 1.022 1.140
vm2_zsuper* 0.987 0.946 1.015
vm3_backtrace 0.939 0.956 0.937
vm3_clearmethodcache 0.966 0.948 0.948
vm3_gc 0.795 0.832 0.811
vm3_gc_old_full 0.981 0.996 1.000
vm3_gc_old_immediate 0.955 1.007 0.997
vm3_gc_old_lazy 0.963 0.998 1.011
vm_symbol_block_pass 0.950 0.988 1.016
vm_thread_alive_check1 0.914 0.878 0.887
vm_thread_close 0.915 0.994 0.986
vm_thread_condvar1 0.998 0.990 0.971
vm_thread_condvar2 1.308 1.359 1.352
vm_thread_create_join 0.984 0.955 0.952
vm_thread_mutex1 1.136 1.087 1.109
vm_thread_mutex2 3.798 3.607 3.682
vm_thread_mutex3 19.421 16.126 16.760
vm_thread_pass 0.857 0.912 0.906
vm_thread_pass_flood 0.853 0.842 0.813
vm_thread_pipe 0.972 0.935 0.903
vm_thread_queue 0.895 0.885 0.877
vm_thread_sized_queue 0.999 0.983 0.976
vm_thread_sized_queue2 1.059 1.074 1.044
vm_thread_sized_queue3 1.075 1.045 1.051
vm_thread_sized_queue4 1.169 1.131 1.251
Log file: bmlog-20171114-160025.24853.tsv
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment