1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 // This test creates a bunch of tasks that simultaneously send to each
12 // other in a ring. The messages should all be basically
14 // This is like msgsend-ring-pipes but adapted to use Arcs.
16 // This also serves as a pipes test, because Arcs are implemented with pipes.
21 use sync::{Arc, Future, Mutex};
26 type pipe = Arc<Mutex<Vec<uint>>>;
28 fn send(p: &pipe, msg: uint) {
29 let mut arr = p.lock();
33 fn recv(p: &pipe) -> uint {
34 let mut arr = p.lock();
35 while arr.is_empty() {
41 fn init() -> (pipe,pipe) {
42 let m = Arc::new(Mutex::new(Vec::new()));
47 fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) {
48 let mut num_chan = Some(num_chan);
49 let mut num_port = Some(num_port);
50 // Send/Receive lots of messages.
51 for j in range(0u, count) {
52 //println!("task %?, iter %?", i, j);
53 let num_chan2 = num_chan.take_unwrap();
54 let num_port2 = num_port.take_unwrap();
55 send(&num_chan2, i * j);
56 num_chan = Some(num_chan2);
57 let _n = recv(&num_port2);
59 num_port = Some(num_port2);
64 let args = os::args();
65 let args = if os::getenv("RUST_BENCH").is_some() {
66 vec!(~"", ~"100", ~"10000")
67 } else if args.len() <= 1u {
68 vec!(~"", ~"10", ~"100")
70 args.clone().move_iter().collect()
73 let num_tasks = from_str::<uint>(*args.get(1)).unwrap();
74 let msg_per_task = from_str::<uint>(*args.get(2)).unwrap();
76 let (mut num_chan, num_port) = init();
78 let start = time::precise_time_s();
81 let mut futures = Vec::new();
83 for i in range(1u, num_tasks) {
84 //println!("spawning %?", i);
85 let (new_chan, num_port) = init();
86 let num_chan_2 = num_chan.clone();
87 let new_future = Future::spawn(proc() {
88 thread_ring(i, msg_per_task, num_chan_2, num_port)
90 futures.push(new_future);
95 thread_ring(0, msg_per_task, num_chan, num_port);
98 for f in futures.mut_iter() {
102 let stop = time::precise_time_s();
104 // all done, report stats.
105 let num_msgs = num_tasks * msg_per_task;
106 let elapsed = (stop - start);
107 let rate = (num_msgs as f64) / elapsed;
109 println!("Sent {} messages in {} seconds", num_msgs, elapsed);
110 println!(" {} messages / second", rate);
111 println!(" {} μs / message", 1000000. / rate);