rust/src/test/bench/shootout-pfib.rs

115 lines
2.6 KiB
Rust
Raw Normal View History

// -*- rust -*-
// xfail-pretty
/*
A parallel version of fibonacci numbers.
This version is meant mostly as a way of stressing and benchmarking
the task system. It supports a lot of command-line arguments to
control how it runs.
*/
use std;
import std::{time, getopts};
import io::writer_util;
import int::range;
import comm::port;
import comm::chan;
import comm::send;
import comm::recv;
import core::result;
import result::{ok, err};
2011-07-27 07:19:39 -05:00
fn fib(n: int) -> int {
2012-01-06 22:55:56 -06:00
fn pfib(c: chan<int>, n: int) {
2011-07-27 07:19:39 -05:00
if n == 0 {
2011-08-13 18:03:28 -05:00
send(c, 0);
} else if n <= 2 {
2011-08-13 18:03:28 -05:00
send(c, 1);
2011-07-27 07:19:39 -05:00
} else {
let p = port();
2012-01-06 22:55:56 -06:00
let ch = chan(p);
task::spawn {|| pfib(ch, n - 1); };
task::spawn {|| pfib(ch, n - 2); };
send(c, recv(p) + recv(p));
}
}
let p = port();
2012-01-06 22:55:56 -06:00
let ch = chan(p);
let t = task::spawn {|| pfib(ch, n); };
ret recv(p);
}
2011-07-27 07:19:39 -05:00
type config = {stress: bool};
2011-07-07 19:28:20 -05:00
fn parse_opts(argv: [str]) -> config {
2011-09-02 17:34:58 -05:00
let opts = [getopts::optflag("stress")];
2011-07-07 19:28:20 -05:00
2011-08-15 18:38:23 -05:00
let opt_args = vec::slice(argv, 1u, vec::len(argv));
2011-07-07 19:28:20 -05:00
2011-07-27 07:19:39 -05:00
2011-08-12 01:27:32 -05:00
alt getopts::getopts(opt_args, opts) {
ok(m) { ret {stress: getopts::opt_present(m, "stress")} }
err(_) { fail; }
2011-07-07 19:28:20 -05:00
}
}
2011-10-20 22:34:04 -05:00
fn stress_task(&&id: int) {
2011-07-27 07:19:39 -05:00
let i = 0;
loop {
2011-07-27 07:19:39 -05:00
let n = 15;
assert (fib(n) == fib(n));
2011-07-07 19:28:20 -05:00
i += 1;
#error("%d: Completed %d iterations", id, i);
2011-07-07 19:28:20 -05:00
}
}
2011-07-27 07:19:39 -05:00
fn stress(num_tasks: int) {
2012-02-18 18:34:42 -06:00
let results = [];
range(0, num_tasks) {|i|
2012-03-12 17:52:30 -05:00
let builder = task::task_builder();
2012-02-18 18:34:42 -06:00
results += [task::future_result(builder)];
task::run(builder) {|| stress_task(i); }
}
2012-02-18 18:34:42 -06:00
for r in results { future::get(r); }
2011-07-07 19:28:20 -05:00
}
2011-09-02 17:34:58 -05:00
fn main(argv: [str]) {
2011-08-15 18:38:23 -05:00
if vec::len(argv) == 1u {
assert (fib(8) == 21);
log(debug, fib(8));
2011-07-27 07:19:39 -05:00
} else {
// Interactive mode! Wooo!!!!
let opts = parse_opts(argv);
2011-07-27 07:19:39 -05:00
2011-07-27 07:19:39 -05:00
if opts.stress {
2011-07-07 19:28:20 -05:00
stress(2);
2011-07-27 07:19:39 -05:00
} else {
let max = option::get(uint::parse_buf(str::bytes(argv[1]),
10u)) as int;
2011-07-27 07:19:39 -05:00
let num_trials = 10;
2011-08-11 21:14:38 -05:00
let out = io::stdout();
range(1, max + 1) {|n|
range(0, num_trials) {|i|
2011-07-27 07:19:39 -05:00
let start = time::precise_time_ns();
let fibn = fib(n);
let stop = time::precise_time_ns();
2011-07-27 07:19:39 -05:00
let elapsed = stop - start;
2011-09-02 17:34:58 -05:00
out.write_line(#fmt["%d\t%d\t%s", n, fibn,
u64::str(elapsed)]);
}
}
}
}
}