Today we’re going to take a brief look at message passing performance in Rust. Rust is already pretty quick on this front, but there are some really obvious possibilities for making it even faster. It looks like I’ll be spending most of the summer working on this, so I thought it’d be good to start out with some baseline performance numbers. Rust’s testsuite has a benchmark called msgsend.rs, which is a microbenchmark for message passing performance. It is based on a benchmark from Paul Keeble that original compared Erlang and Scala. Here’s a table summarizing the results:
| Language | Messages per second | Comparison |
| Scala | 378,740 | 100.0% |
| Rust | 175,373 | 46.3% |
| Erlang (Bare) | 78,670 | 20.8% |
| Erlang (OTP) | 76,405 | 20.2% |
These numbers were generated on an Early 2011 MacBook Pro 2.3 GHz Intel Core i7 with 8GB RAM and Lion 10.7.4. Don’t read too much into these numbers; they are incredibly unscientific. The only real use for them will be to see if running the same benchmark for Rust in a few weeks yields a larger number. It’s also worth noting that my results disagree with the original author, who saw Erlang performing about 6 times faster than Scala. I suspect that Erlang’s message passing may not be as efficient on Mac OS X, but I do not know what system the tests were originally run on.
So, where do we go from here? I mentioned that there are some obvious first steps. The most obvious is that right now sending a message involves taking a global lock. In effect, this means we can only send one message in a time. Suppose we had four tasks, A, B, C and D, where A was sending to B and C to D. Intuitively, these two sends should be completely independent of each other, but this is not currently the case in Rust. This is one thing I hope to change.
It would be nice if we could do at least some of the communication without any locks at all, using a lock-free data structure. This is worth experimenting with, but we’ll have to wait for the benchmarks to show whether this is the best idea.
Somewhat orthogonal to message passing performance, I hope to be able to implement more of the communication system in Rust itself. When the communication system was first written, we had to put almost all of it in the runtime library that was written in C++. Rust is significantly more powerful now, and it seems like it would not take too much more work to write the communication system almost entirely in Rust.
What does the test do? Do you have the source?
It wouldn’t surprise me if the latest scala code is using java-native fork-join, or maybe the newer test is using Akka instead of the legacy Scala actor library, Akka is multiple times faster.
Hi Gustavo,
I thought I had included a link to the source for the Scala and Erlang benchmarks, but it looks like I forgot it. They’re based off of Paul Keeble’s original test, but I made a couple of tweaks, mostly to the build system. My version is available here: https://github.com/eholk/ScalaVErlangAgents
[...] Rust Message Passing Performance [...]
[...] of these are sufficient to run the msgsend benchmark that I talked about at the beginning of all of this. Here are the results, combined with the previous [...]