From d75abe3505126ecb579cc68cbe340abfb101c3bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 17 Feb 2021 23:10:18 +0100 Subject: add numbers benchmark --- progs/bench/add.sy | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 progs/bench/add.sy diff --git a/progs/bench/add.sy b/progs/bench/add.sy new file mode 100644 index 0000000..bf3a867 --- /dev/null +++ b/progs/bench/add.sy @@ -0,0 +1,6 @@ +// Adds the numbers 0 to 10000 +sum := 0 +for i := 0, i <= 1000000, i += 1 { + sum += i +} +sum <=> 500000500000 -- cgit v1.2.1 From 798c6feac22d94019e1247ec57c17fe3bc29fdb6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 17 Feb 2021 23:10:32 +0100 Subject: add fibonacci benchmark --- progs/bench/fib.sy | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 progs/bench/fib.sy diff --git a/progs/bench/fib.sy b/progs/bench/fib.sy new file mode 100644 index 0000000..a6504bf --- /dev/null +++ b/progs/bench/fib.sy @@ -0,0 +1,10 @@ +// The worst implementation of fibonacci calculations +// possible. FYI, it can be done in constant time. +fib :: fn a:int -> int { + if a < 2 { + ret a + } + ret fib(a - 1) + fib(a - 2) +} +// 23 is around where things start getting slow. +fib(28) <=> 317811 -- cgit v1.2.1 From 830c9cbe4bc944f57dcad6f9b78629ba7c402e36 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 17 Feb 2021 23:13:10 +0100 Subject: add iterative fibonacci benchmark --- progs/bench/fib-iter.sy | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 progs/bench/fib-iter.sy diff --git a/progs/bench/fib-iter.sy b/progs/bench/fib-iter.sy new file mode 100644 index 0000000..b6ff3d8 --- /dev/null +++ b/progs/bench/fib-iter.sy @@ -0,0 +1,14 @@ +// A fibonacci implementation that is a little +// less awefull. But we run it 10000 times instead. +j := 0 +for , j < 10000, j = j + 1 { + a := 0 + b := 1 + + for i := 0, i < 50, i = i + 1 { + c := a + a = b + b = c + b + } + a <=> 12586269025 +} -- cgit v1.2.1 From d106d7b0aa514c727099b1ee9bde94ec8c4d68fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 17 Feb 2021 23:39:14 +0100 Subject: rename tests to be valid identifiers --- progs/bench/add.sy | 6 ------ progs/bench/fib-iter.sy | 14 -------------- progs/bench/fib_iter.sy | 14 ++++++++++++++ progs/bench/sum.sy | 6 ++++++ 4 files changed, 20 insertions(+), 20 deletions(-) delete mode 100644 progs/bench/add.sy delete mode 100644 progs/bench/fib-iter.sy create mode 100644 progs/bench/fib_iter.sy create mode 100644 progs/bench/sum.sy diff --git a/progs/bench/add.sy b/progs/bench/add.sy deleted file mode 100644 index bf3a867..0000000 --- a/progs/bench/add.sy +++ /dev/null @@ -1,6 +0,0 @@ -// Adds the numbers 0 to 10000 -sum := 0 -for i := 0, i <= 1000000, i += 1 { - sum += i -} -sum <=> 500000500000 diff --git a/progs/bench/fib-iter.sy b/progs/bench/fib-iter.sy deleted file mode 100644 index b6ff3d8..0000000 --- a/progs/bench/fib-iter.sy +++ /dev/null @@ -1,14 +0,0 @@ -// A fibonacci implementation that is a little -// less awefull. But we run it 10000 times instead. -j := 0 -for , j < 10000, j = j + 1 { - a := 0 - b := 1 - - for i := 0, i < 50, i = i + 1 { - c := a - a = b - b = c + b - } - a <=> 12586269025 -} diff --git a/progs/bench/fib_iter.sy b/progs/bench/fib_iter.sy new file mode 100644 index 0000000..b6ff3d8 --- /dev/null +++ b/progs/bench/fib_iter.sy @@ -0,0 +1,14 @@ +// A fibonacci implementation that is a little +// less awefull. But we run it 10000 times instead. +j := 0 +for , j < 10000, j = j + 1 { + a := 0 + b := 1 + + for i := 0, i < 50, i = i + 1 { + c := a + a = b + b = c + b + } + a <=> 12586269025 +} diff --git a/progs/bench/sum.sy b/progs/bench/sum.sy new file mode 100644 index 0000000..bf3a867 --- /dev/null +++ b/progs/bench/sum.sy @@ -0,0 +1,6 @@ +// Adds the numbers 0 to 10000 +sum := 0 +for i := 0, i <= 1000000, i += 1 { + sum += i +} +sum <=> 500000500000 -- cgit v1.2.1 From 6b9b43565c66e1da12d775ffd2881a9ea461d604 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 17 Feb 2021 23:46:20 +0100 Subject: bring back the benching --- benches/sylt_benchmark.rs | 56 +++++++++++++++++++---------------------------- src/vm.rs | 5 +++-- 2 files changed, 25 insertions(+), 36 deletions(-) diff --git a/benches/sylt_benchmark.rs b/benches/sylt_benchmark.rs index a68a762..e77a916 100644 --- a/benches/sylt_benchmark.rs +++ b/benches/sylt_benchmark.rs @@ -1,42 +1,30 @@ use criterion::{criterion_group, criterion_main, Criterion}; +use std::fs; use std::path::Path; -pub fn fib_50(c: &mut Criterion) { - let prog = -" -j := 0 -for , j < 1000, j = j + 1 { - a := 0 - b := 1 - - for i := 0, i < 50, i = i + 1 { - c := a - a = b - b = c + b - } - a <=> 12586269025 -} -"; - let compiled = sylt::compiler::compile("main", Path::new("prog"), sylt::tokenizer::string_to_tokens(prog)).unwrap(); - c.bench_function("fib 50", |b| b.iter(|| sylt::vm::run_block(&compiled).unwrap())); +macro_rules! bench_file { + ( $name:ident ) => { + pub fn $name(c: &mut Criterion) { + let prog = fs::read_to_string(Path::new(&format!("progs/bench/{}.sy", stringify!($name)))) + .unwrap(); + c.bench_function(stringify!($name), |b| { + b.iter(|| { + sylt::run_string(&prog, false, Vec::new()).unwrap(); + }) + }); + } + }; } -pub fn fib_90(c: &mut Criterion) { - let prog = -" -a := 0 -b := 1 +macro_rules! bench { + ( [ $( $name:ident ),* ] ) => { + $(bench_file!($name);)* -for i := 0, i < 90, i = i + 1 { - c := a - a = b - b = c + b -} -a <=> 2880067194370816120 -"; - let compiled = sylt::compiler::compile("main", Path::new("prog"), sylt::tokenizer::string_to_tokens(prog)).unwrap(); - c.bench_function("fib 90", |b| b.iter(|| sylt::vm::run_block(&compiled).unwrap())); + criterion_group!(benches, $( $name ),* ); + criterion_main!(benches); + } } -criterion_group!(benches, fib_50, fib_90); -criterion_main!(benches); +// List of all benchmarks to run +bench!([fib, fib_iter, sum]); + diff --git a/src/vm.rs b/src/vm.rs index c4d72a1..4ed19ff 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -480,8 +480,9 @@ impl VM { self.frame().block.borrow().ops[self.frame().ip]); } - // Initalizes the VM for running. Run cannot be called before this. - pub(crate) fn init(&mut self, prog: &Prog) { + /// Initalizes the VM for running. Run cannot be called before this. + /// You do not have to call this. + pub fn init(&mut self, prog: &Prog) { let block = Rc::clone(&prog.blocks[0]); self.blobs = prog.blobs.clone(); self.constants = prog.constants.clone(); -- cgit v1.2.1 From 51949c9a917385cff9925830a45bd78385930686 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Wed, 17 Feb 2021 23:48:32 +0100 Subject: lower the times to something more maintainable --- progs/bench/fib.sy | 2 +- progs/bench/fib_iter.sy | 4 ++-- progs/bench/sum.sy | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/progs/bench/fib.sy b/progs/bench/fib.sy index a6504bf..bd1aaa4 100644 --- a/progs/bench/fib.sy +++ b/progs/bench/fib.sy @@ -7,4 +7,4 @@ fib :: fn a:int -> int { ret fib(a - 1) + fib(a - 2) } // 23 is around where things start getting slow. -fib(28) <=> 317811 +fib(23) <=> 28657 diff --git a/progs/bench/fib_iter.sy b/progs/bench/fib_iter.sy index b6ff3d8..0e188e8 100644 --- a/progs/bench/fib_iter.sy +++ b/progs/bench/fib_iter.sy @@ -1,7 +1,7 @@ // A fibonacci implementation that is a little -// less awefull. But we run it 10000 times instead. +// less awefull. But we run it 1000 times instead. j := 0 -for , j < 10000, j = j + 1 { +for , j < 1000, j = j + 1 { a := 0 b := 1 diff --git a/progs/bench/sum.sy b/progs/bench/sum.sy index bf3a867..bb6870f 100644 --- a/progs/bench/sum.sy +++ b/progs/bench/sum.sy @@ -1,6 +1,6 @@ // Adds the numbers 0 to 10000 sum := 0 -for i := 0, i <= 1000000, i += 1 { +for i := 0, i <= 100000, i += 1 { sum += i } -sum <=> 500000500000 +sum <=> 5000050000 -- cgit v1.2.1 From 5c26782c500bb9aee86ba7b35b2f145c1dd87dc2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Thu, 18 Feb 2021 20:11:24 +0100 Subject: hide vm::init --- src/vm.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/vm.rs b/src/vm.rs index 4ed19ff..e961b73 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -480,8 +480,7 @@ impl VM { self.frame().block.borrow().ops[self.frame().ip]); } - /// Initalizes the VM for running. Run cannot be called before this. - /// You do not have to call this. + #[doc(hidden)] pub fn init(&mut self, prog: &Prog) { let block = Rc::clone(&prog.blocks[0]); self.blobs = prog.blobs.clone(); -- cgit v1.2.1 From 367d7b32a2825f6e4c8ef3b5423ceb1cd2b62bd0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Edvard=20Th=C3=B6rnros?= Date: Thu, 18 Feb 2021 20:12:06 +0100 Subject: Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Gustav Sörnäs --- progs/bench/fib.sy | 2 +- progs/bench/fib_iter.sy | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/progs/bench/fib.sy b/progs/bench/fib.sy index bd1aaa4..de68f5c 100644 --- a/progs/bench/fib.sy +++ b/progs/bench/fib.sy @@ -1,4 +1,4 @@ -// The worst implementation of fibonacci calculations +// The worst implementation of Fibonacci calculations // possible. FYI, it can be done in constant time. fib :: fn a:int -> int { if a < 2 { diff --git a/progs/bench/fib_iter.sy b/progs/bench/fib_iter.sy index 0e188e8..c51469a 100644 --- a/progs/bench/fib_iter.sy +++ b/progs/bench/fib_iter.sy @@ -1,5 +1,5 @@ -// A fibonacci implementation that is a little -// less awefull. But we run it 1000 times instead. +// A Fibonacci implementation that is a little +// less awful. But we run it 1000 times instead. j := 0 for , j < 1000, j = j + 1 { a := 0 -- cgit v1.2.1