2012-12-10 19:32:48 -06:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2012-07-12 14:51:47 -05:00
|
|
|
// A port of the simplistic benchmark from
|
|
|
|
//
|
|
|
|
// http://github.com/PaulKeeble/ScalaVErlangAgents
|
|
|
|
//
|
|
|
|
// I *think* it's the same, more or less.
|
|
|
|
|
2013-05-20 19:07:24 -05:00
|
|
|
extern mod extra;
|
2012-07-12 14:51:47 -05:00
|
|
|
|
2013-05-24 21:35:29 -05:00
|
|
|
use std::os;
|
|
|
|
use std::task;
|
|
|
|
use std::uint;
|
2012-07-12 14:51:47 -05:00
|
|
|
|
2013-07-17 14:31:20 -05:00
|
|
|
fn move_out<T>(_x: T) {}
|
2012-07-12 14:51:47 -05:00
|
|
|
|
|
|
|
enum request {
|
|
|
|
get_count,
|
|
|
|
bytes(uint),
|
|
|
|
stop
|
|
|
|
}
|
|
|
|
|
2013-07-31 01:39:58 -05:00
|
|
|
fn server(requests: &Port<request>, responses: &Chan<uint>) {
|
2013-07-02 14:47:32 -05:00
|
|
|
let mut count: uint = 0;
|
2012-07-12 14:51:47 -05:00
|
|
|
let mut done = false;
|
|
|
|
while !done {
|
2013-12-15 20:17:43 -06:00
|
|
|
match requests.recv_opt() {
|
2013-07-02 14:47:32 -05:00
|
|
|
Some(get_count) => { responses.send(count.clone()); }
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(bytes(b)) => {
|
2013-10-21 15:08:31 -05:00
|
|
|
//error!("server: received {:?} bytes", b);
|
2012-07-12 14:51:47 -05:00
|
|
|
count += b;
|
|
|
|
}
|
2012-08-20 14:23:37 -05:00
|
|
|
None => { done = true; }
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => { }
|
2012-07-12 14:51:47 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
responses.send(count);
|
2013-10-21 15:08:31 -05:00
|
|
|
//error!("server exiting");
|
2012-07-12 14:51:47 -05:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn run(args: &[~str]) {
|
2013-12-15 20:17:43 -06:00
|
|
|
let (from_child, to_parent) = Chan::new();
|
2012-07-12 14:51:47 -05:00
|
|
|
|
2013-09-15 00:27:32 -05:00
|
|
|
let size = from_str::<uint>(args[1]).unwrap();
|
|
|
|
let workers = from_str::<uint>(args[2]).unwrap();
|
2012-07-12 14:51:47 -05:00
|
|
|
let num_bytes = 100;
|
2013-05-20 19:07:24 -05:00
|
|
|
let start = extra::time::precise_time_s();
|
2012-07-12 14:51:47 -05:00
|
|
|
let mut worker_results = ~[];
|
2013-12-15 20:17:43 -06:00
|
|
|
let from_parent = if workers == 1 {
|
|
|
|
let (from_parent, to_child) = Chan::new();
|
2013-05-06 21:29:04 -05:00
|
|
|
let mut builder = task::task();
|
2013-10-18 03:38:46 -05:00
|
|
|
worker_results.push(builder.future_result());
|
2014-01-27 17:29:50 -06:00
|
|
|
builder.spawn(proc() {
|
2013-08-03 11:45:23 -05:00
|
|
|
for _ in range(0u, size / workers) {
|
2013-10-21 15:08:31 -05:00
|
|
|
//error!("worker {:?}: sending {:?} bytes", i, num_bytes);
|
2012-07-12 14:51:47 -05:00
|
|
|
to_child.send(bytes(num_bytes));
|
|
|
|
}
|
2013-10-21 15:08:31 -05:00
|
|
|
//error!("worker {:?} exiting", i);
|
2014-01-27 17:29:50 -06:00
|
|
|
});
|
2013-12-15 20:17:43 -06:00
|
|
|
from_parent
|
|
|
|
} else {
|
Rewrite channels yet again for upgradeability
This, the Nth rewrite of channels, is not a rewrite of the core logic behind
channels, but rather their API usage. In the past, we had the distinction
between oneshot, stream, and shared channels, but the most recent rewrite
dropped oneshots in favor of streams and shared channels.
This distinction of stream vs shared has shown that it's not quite what we'd
like either, and this moves the `std::comm` module in the direction of "one
channel to rule them all". There now remains only one Chan and one Port.
This new channel is actually a hybrid oneshot/stream/shared channel under the
hood in order to optimize for the use cases in question. Additionally, this also
reduces the cognitive burden of having to choose between a Chan or a SharedChan
in an API.
My simple benchmarks show no reduction in efficiency over the existing channels
today, and a 3x improvement in the oneshot case. I sadly don't have a
pre-last-rewrite compiler to test out the old old oneshots, but I would imagine
that the performance is comparable, but slightly slower (due to atomic reference
counting).
This commit also brings the bonus bugfix to channels that the pending queue of
messages are all dropped when a Port disappears rather then when both the Port
and the Chan disappear.
2014-01-08 20:31:48 -06:00
|
|
|
let (from_parent, to_child) = Chan::new();
|
2013-12-15 20:17:43 -06:00
|
|
|
for _ in range(0u, workers) {
|
|
|
|
let to_child = to_child.clone();
|
|
|
|
let mut builder = task::task();
|
|
|
|
worker_results.push(builder.future_result());
|
2014-01-27 17:29:50 -06:00
|
|
|
builder.spawn(proc() {
|
2013-12-15 20:17:43 -06:00
|
|
|
for _ in range(0u, size / workers) {
|
|
|
|
//error!("worker {:?}: sending {:?} bytes", i, num_bytes);
|
|
|
|
to_child.send(bytes(num_bytes));
|
|
|
|
}
|
|
|
|
//error!("worker {:?} exiting", i);
|
2014-01-27 17:29:50 -06:00
|
|
|
});
|
2013-12-15 20:17:43 -06:00
|
|
|
}
|
|
|
|
from_parent
|
|
|
|
};
|
2014-01-27 17:29:50 -06:00
|
|
|
task::spawn(proc() {
|
2013-04-26 16:04:39 -05:00
|
|
|
server(&from_parent, &to_parent);
|
2014-01-27 17:29:50 -06:00
|
|
|
});
|
2012-07-12 14:51:47 -05:00
|
|
|
|
2013-08-03 11:45:23 -05:00
|
|
|
for r in worker_results.iter() {
|
2012-10-22 21:01:37 -05:00
|
|
|
r.recv();
|
2012-09-18 23:41:37 -05:00
|
|
|
}
|
|
|
|
|
2013-10-21 15:08:31 -05:00
|
|
|
//error!("sending stop message");
|
2013-12-15 20:17:43 -06:00
|
|
|
//to_child.send(stop);
|
|
|
|
//move_out(to_child);
|
2012-07-12 14:51:47 -05:00
|
|
|
let result = from_child.recv();
|
2013-05-20 19:07:24 -05:00
|
|
|
let end = extra::time::precise_time_s();
|
2012-07-12 14:51:47 -05:00
|
|
|
let elapsed = end - start;
|
2013-10-13 20:48:47 -05:00
|
|
|
print!("Count is {:?}\n", result);
|
|
|
|
print!("Test took {:?} seconds\n", elapsed);
|
2013-09-26 01:26:09 -05:00
|
|
|
let thruput = ((size / workers * workers) as f64) / (elapsed as f64);
|
2013-10-13 20:48:47 -05:00
|
|
|
print!("Throughput={} per sec\n", thruput);
|
2013-05-18 21:02:45 -05:00
|
|
|
assert_eq!(result, num_bytes * size);
|
2012-07-12 14:51:47 -05:00
|
|
|
}
|
|
|
|
|
2012-10-03 21:16:27 -05:00
|
|
|
fn main() {
|
|
|
|
let args = os::args();
|
2013-07-17 14:31:20 -05:00
|
|
|
let args = if os::getenv("RUST_BENCH").is_some() {
|
2012-07-14 00:57:48 -05:00
|
|
|
~[~"", ~"1000000", ~"8"]
|
2012-07-12 14:51:47 -05:00
|
|
|
} else if args.len() <= 1u {
|
2012-07-14 00:57:48 -05:00
|
|
|
~[~"", ~"10000", ~"4"]
|
2012-07-12 14:51:47 -05:00
|
|
|
} else {
|
2013-07-02 14:47:32 -05:00
|
|
|
args.clone()
|
2013-05-03 18:25:04 -05:00
|
|
|
};
|
2012-07-12 14:51:47 -05:00
|
|
|
|
2013-10-21 15:08:31 -05:00
|
|
|
info!("{:?}", args);
|
2012-07-12 14:51:47 -05:00
|
|
|
run(args);
|
|
|
|
}
|