mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
benchmark/gc: prevent GC bench from depending on normal benchmark
scripts. This is needed to finish converting Ruby scripts to YAMLs. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@63899 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
k0kubun
parent
2079fe863c
commit
d933fe9b85
3 changed files with 612 additions and 3 deletions
|
|
@ -1 +1,291 @@
|
|||
require_relative '../bm_app_aobench.rb'
|
||||
# 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
|
||||
|
|
|
|||
|
|
@ -1 +1,62 @@
|
|||
require_relative '../bm_so_binary_trees.rb'
|
||||
# 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
|
||||
|
|
|
|||
|
|
@ -1 +1,259 @@
|
|||
require_relative '../bm_app_pentomino.rb'
|
||||
#!/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)
|
||||
|
|
|
|||
Loading…
Reference in a new issue