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())
# 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())
(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))