1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// 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.
// This test creates a bunch of tasks that simultaneously send to each
// other in a ring. The messages should all be basically
// independent.
// This is like msgsend-ring-pipes but adapted to use Arcs.
// This also serves as a pipes test, because Arcs are implemented with pipes.
extern mod extra;
use extra::arc;
use extra::future::Future;
use extra::time;
use std::cell::Cell;
use std::os;
use std::uint;
// A poor man's pipe.
type pipe = arc::MutexArc<~[uint]>;
fn send(p: &pipe, msg: uint) {
unsafe {
do p.access_cond |state, cond| {
state.push(msg);
cond.signal();
}
}
}
fn recv(p: &pipe) -> uint {
unsafe {
do p.access_cond |state, cond| {
while state.is_empty() {
cond.wait();
}
state.pop()
}
}
}
fn init() -> (pipe,pipe) {
let m = arc::MutexArc::new(~[]);
((&m).clone(), m)
}
fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) {
let mut num_chan = Some(num_chan);
let mut num_port = Some(num_port);
// Send/Receive lots of messages.
for j in range(0u, count) {
//error!("task %?, iter %?", i, j);
let num_chan2 = num_chan.take_unwrap();
let num_port2 = num_port.take_unwrap();
send(&num_chan2, i * j);
num_chan = Some(num_chan2);
let _n = recv(&num_port2);
//log(error, _n);
num_port = Some(num_port2);
};
}
fn main() {
let args = os::args();
let args = if os::getenv("RUST_BENCH").is_some() {
~[~"", ~"100", ~"10000"]
} else if args.len() <= 1u {
~[~"", ~"10", ~"100"]
} else {
args.clone()
};
let num_tasks = from_str::<uint>(args[1]).unwrap();
let msg_per_task = from_str::<uint>(args[2]).unwrap();
let (num_chan, num_port) = init();
let num_chan = Cell::new(num_chan);
let start = time::precise_time_s();
// create the ring
let mut futures = ~[];
for i in range(1u, num_tasks) {
//error!("spawning %?", i);
let (new_chan, num_port) = init();
let num_chan2 = Cell::new(num_chan.take());
let num_port = Cell::new(num_port);
let new_future = do Future::spawn() {
let num_chan = num_chan2.take();
let num_port1 = num_port.take();
thread_ring(i, msg_per_task, num_chan, num_port1)
};
futures.push(new_future);
num_chan.put_back(new_chan);
};
// do our iteration
thread_ring(0, msg_per_task, num_chan.take(), num_port);
// synchronize
for f in futures.mut_iter() {
f.get()
}
let stop = time::precise_time_s();
// all done, report stats.
let num_msgs = num_tasks * msg_per_task;
let elapsed = (stop - start);
let rate = (num_msgs as float) / elapsed;
printfln!("Sent %? messages in %? seconds", num_msgs, elapsed);
printfln!(" %? messages / second", rate);
printfln!(" %? μs / message", 1000000. / rate);
}
|
