---

yaml
---
r: 13630
b: refs/heads/master
c: 40559ea
h: refs/heads/master
v: v3

Author: eholk

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: dc3862bf58297b75a0e3d4dfdf1f66b56f51dd1d
+refs/heads/master: 40559ea83961df06c82f76c333ce4c9604f12449
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/test/bench/msgsend-ring-new.rs

@@ -0,0 +1,76 @@
+// This test creates a bunch of tasks that simultaneously send to each
+// other in a ring. The messages should all be basically
+// independent. It's designed to hammer the global kernel lock, so
+// that things will look really good once we get that lock out of the
+// message path.
+
+import newcomm::*;
+import future::future;
+
+use std;
+import std::time;
+
+fn thread_ring(i: uint,
+               count: uint,
+               num_chan: chan<uint>,
+               num_port: port<uint>) {
+    // Send/Receive lots of messages.
+    for uint::range(0u, count) {|j|
+        num_chan.send(i * j);
+        num_port.recv();
+    };
+}
+
+fn main(args: [str]) {
+    let args = if os::getenv("RUST_BENCH").is_some() {
+        ["", "100", "10000"]
+    } else if args.len() <= 1u {
+        ["", "100", "1000"]
+    } else {
+        args
+    };        
+
+    let num_tasks = option::get(uint::from_str(args[1]));
+    let msg_per_task = option::get(uint::from_str(args[2]));
+
+    let num_port = port();
+    let mut num_chan = chan(num_port);
+
+    let start = time::precise_time_s();
+
+    // create the ring
+    let mut futures = [];
+
+    for uint::range(1u, num_tasks) {|i|
+        let get_chan = port();
+        let get_chan_chan = chan(get_chan);
+        {
+            let num_chan = num_chan.clone();
+            futures += [future::spawn {|move num_chan, move get_chan_chan|
+                let p = port();
+                get_chan_chan.send(chan(p));
+                thread_ring(i, msg_per_task, num_chan,  p)
+            }];
+        }
+        
+        num_chan = get_chan.recv();
+    };
+
+    // do our iteration
+    thread_ring(0u, msg_per_task, num_chan, num_port);
+
+    // synchronize
+    for futures.each {|f| 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;
+
+    io::println(#fmt("Sent %? messages in %? seconds",
+                     num_msgs, elapsed));
+    io::println(#fmt("  %? messages / second", rate));
+    io::println(#fmt("  %? μs / message", 1000000. / rate));
+}