import helper
helper.load_backends()
code = """
(begin
(define (grow)
(set! s (string-append "123" s "456" s "789"))
(set! s (string-append
(substring s (quotient (string-length s) 2) (string-length s))
(substring s 0 (+ 1 (quotient (string-length s) 2)))))
s)
(define (trial n)
(do ((i 0 (+ i 1)))
((> (string-length s) n) (string-length s))
(grow))))
"""
def call_trial(vm):
vm.eval(vm.compile('(define s "abcdef")'))
scm = vm.eval(vm.compile('(trial 1000000)'))
assert vm.fromscheme(scm) == 1048566
bm = Benchmark(title="string-append and substring performance", repeat=10)
for backend in helper.BACKENDS:
vm = helper.VM(backend=backend)
vm.eval(vm.compile(code))
bm.measure(backend, call_trial, vm)
helper.report(bm.report())
helper.load_backends()
code = """
(begin
(define (grow)
(set! s (string-append "123" s "456" s "789"))
(set! s (string-append
(substring s (quotient (string-length s) 2) (string-length s))
(substring s 0 (+ 1 (quotient (string-length s) 2)))))
s)
(define (trial n)
(do ((i 0 (+ i 1)))
((> (string-length s) n) (string-length s))
(grow))))
"""
def call_trial(vm):
vm.eval(vm.compile('(define s "abcdef")'))
scm = vm.eval(vm.compile('(trial 1000000)'))
assert vm.fromscheme(scm) == 1048566
bm = Benchmark(title="string-append and substring performance", repeat=10)
for backend in helper.BACKENDS:
vm = helper.VM(backend=backend)
vm.eval(vm.compile(code))
bm.measure(backend, call_trial, vm)
helper.report(bm.report())
from benchmark import Benchmark
import helper
helper.load_backends()
code = """
(define (tak x y z)
(if (not (< y x))
z
(tak (tak (- x 1) y z)
(tak (- y 1) z x)
(tak (- z 1) x y))))
"""
def call_tak(vm):
for case in [(7, (18, 12, 6)), (15, (30, 15, 9)), (10, (33, 15, 9)),
(15, (40, 15, 9))]:
scm = vm.apply(vm.get("tak"), [vm.toscheme(x) for x in case[1]])
assert vm.fromscheme(scm) == case[0]
bm = Benchmark(title="tak benchmark", repeat=1)
for backend in helper.BACKENDS:
vm = helper.VM(backend=backend)
vm.eval(vm.compile(code))
bm.measure(backend, call_tak, vm)
helper.report(bm.report())
from benchmark import Benchmark
import helper
helper.load_backends()
code = """
(lambda (n)
(define (iter sum i)
(if (= i 0)
sum
(iter (+ sum i)
(- i 1))))
(iter 0 n))
"""
def call_sum(proc, vm):
scm = vm.apply(proc, [vm.toscheme(10000)])
assert vm.fromscheme(scm) == 50005000
bm = Benchmark(title="Tail call performance", repeat=10)
for backend in helper.BACKENDS:
vm = helper.VM(backend=backend)
proc = vm.eval(vm.compile(code))
bm.measure(backend, call_sum, proc, vm)
helper.report(bm.report())
"""\
This benchmark test the loading time of each backend.
But it seems to be hard to make this benchmark accurate. Because
it is only slow for the first time when a VM is to be loaded. Later
it will be very fast since all related stuffs are already in memory.
So repeating here just makes no help.
"""
from benchmark import Benchmark
import helper
def load_backend(backend):
vm = helper.VM(backend=backend)
bm = Benchmark(title="Time to load the VM", repeat=1)
for backend in helper.BACKENDS:
bm.measure(backend, load_backend, backend)
helper.report(bm.report())
from benchmark import Benchmark
import helper
helper.load_backends()
code = """
(define (tak x y z)
(if (not (< y x))
z
(tak (tak (- x 1) y z)
(tak (- y 1) z x)
(tak (- z 1) x y))))
"""
def call_tak(vm):
for case in [(7, (18, 12, 6)),
(15, (30, 15, 9)),
(10, (33, 15, 9)),
(15, (40, 15, 9))]:
scm = vm.apply(vm.get("tak"), [vm.toscheme(x) for x in case[1]])
assert vm.fromscheme(scm) == case[0]
bm = Benchmark(title="tak benchmark", repeat=1)
for backend in helper.BACKENDS:
vm = helper.VM(backend=backend)
vm.eval(vm.compile(code))
bm.measure(backend, call_tak, vm)
helper.report(bm.report())
# we don't asser the euqality because sometimes the time to
# test the equality may be longer than the conversion (e.g.
# when testing two big chunk of string).
vm.fromscheme(scm)
class Foo(object):
pass
BIG_TEXT = open(__file__).read()
cases = [("integers", [1, 10, -5]),
("float numbers", [0.5, -3.2, 0.0]),
("big numbers", [2**33, -2**34, 10**10]),
("bool values", [True, False, False]),
("strings", ["foo", "", "baz"]),
("big string", [BIG_TEXT, BIG_TEXT, BIG_TEXT]),
("symbols", [helper.Symbol("foo"), helper.Symbol(""), helper.Symbol("bar")]),
("cons pairs", [helper.Cons(1, 2), helper.Cons([], []), helper.Cons(1, helper.Cons(2, []))]),
("lists", [[1, 2, 3], [1, 2, 3, 4], []]),
("dicts", [{1:1, 2:2}, {}, {1:10, 10:1}]),
("callables", [__import__, do_convert, list.sort]),
("objects", [Foo(), Foo(), object()])
]
for case in cases:
bm = Benchmark(title="performance of converting " + case[0], repeat=1000)
for backend in helper.BACKENDS:
vm = helper.VM(backend=backend)
bm.measure(backend, do_convert, vm, case[1])
helper.report(bm.report())
"""\
This benchmark test the loading time of each backend.
But it seems to be hard to make this benchmark accurate. Because
it is only slow for the first time when a VM is to be loaded. Later
it will be very fast since all related stuffs are already in memory.
So repeating here just makes no help.
"""
from benchmark import Benchmark
import helper
def load_backend(backend):
vm = helper.VM(backend=backend)
bm = Benchmark(title="Time to load the VM", repeat=1)
for backend in helper.BACKENDS:
bm.measure(backend, load_backend, backend)
helper.report(bm.report())
from benchmark import Benchmark
import helper
helper.load_backends()
code = """
(lambda (n)
(define (iter sum i)
(if (= i 0)
sum
(iter (+ sum i)
(- i 1))))
(iter 0 n))
"""
def call_sum(proc, vm):
scm = vm.apply(proc, [vm.toscheme(10000)])
assert vm.fromscheme(scm) == 50005000
bm = Benchmark(title="Tail call performance", repeat=10)
for backend in helper.BACKENDS:
vm = helper.VM(backend=backend)
proc = vm.eval(vm.compile(code))
bm.measure(backend, call_sum, proc, vm)
helper.report(bm.report())
(define lst '(5 9 2 4 7 6 3 1 8 10 -5 83))
(define sorted (insertion-sort lst))
(sorted? sorted))
"""
def call_sort(vm, compiled):
scm = vm.eval(compiled)
assert vm.type(scm) is bool, "Type should be bool"
assert vm.fromscheme(scm) == True, "The array should be sorted"
bm = Benchmark(title="performance improvements by compiling (sort)", repeat=100)
for backend in helper.BACKENDS:
vm = helper.VM(backend=backend)
compiled = vm.compile(code_sort)
bm.measure(backend, call_sort, vm, compiled)
helper.report(bm.report())
code_calc = """
(begin
(define a 5)
(define b 10)
(define c (- a b))
(+ a
(* b 10 11)
(apply + (list (* b c) 1 2 (- 3 a) b 5))
9
b))
