Created
November 14, 2017 11:39
-
-
Save anonymous/64b7e73e5972befc33a9acde09612f90 to your computer and use it in GitHub Desktop.
We can make this file beautiful and searchable if this error is corrected: Illegal quoting in line 2.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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