The results are a bit slower than before because I made some changes to the code after I had done the original benchmarks and I haven’t re-optimised the code paths again. In the original benchmarks, I hand optimised the Cylon code paths eliminating every extra branch and un-needed call in the most commonly used paths. I’ll do that again when we release the multi-threaded version later in the year.
Results
This is on a 2.8GHz Pentium 4 with 1.5GB of memory.
| Pentium |
count |
debug |
nodebug |
overhead |
| factorial |
100000 |
25.109 |
20.938 |
20% |
| linear |
100000000 |
87.031 |
59.859 |
45% |
And this is on a 1GHz Celeron with 1GB of memory.
| Celeron |
count |
debug |
nodebug |
overhead |
| factorial |
100000 |
144.348 |
95.978 |
50% |
| linear |
100000000 |
178.336 |
106.974 |
66% |
I’ve also done the benchmarks on a Core Duo 6600 with 2GB of memory.
| Core Duo |
count |
debug |
nodebug |
overhead |
| factorial |
100000 |
14.844 |
14.297 |
4% |
| linear |
100000000 |
44.203 |
27.344 |
62% |
Interesting.
I’ve done the Core Duo one several times with various values of the count and got the same ratios (yes, I did check that I was actually running the debugger).
I can’t figure out what is going on with the factorial Core Duo or why the linear measure is slower than on the Pentium 4 – but those are the figures I got. I would guess that there might be something odd in the Ruby interpreter that causes this – last time I looked it was compiled using Microsoft C++ v6. Equally, there might be something weird in my code that throwing the benchmarks. When I get a bit more time (when I do the multithreaded version), I’ll recompile Ruby using the latest C++ compiler and see what I get.
Conclusion
It seems to me that my Pentium 4 benchmarks are pretty much in line with what I got previously. They are a bit slower than the first benchmarks, and that’s down to me not optimising things as far as I did initially. It’s certainly not twice as slow.
The Celeron doesn’t show as much of an improvement as the Pentium 4 for some reason. However, it’s a pretty ancient machine - over 6 years old now .
The Core Duo results need more exploration. In one case the Cylon debugger only adds 4% in overhead (which I find difficult to believe, but those are indeed the results) while for the linear test, it adds 60% overhead. It’s still nothing like twice the overhead.
It would seem that there’s more to the Intel Core Duo than meets the eye.
Code
The code I used is here. It’s very simple:
def fac(n)
n == 1 ? 1 : n * fac(n-1)
end
count = 0
tstart = Time.new
#0.upto(100000) {fac(50)}
0.upto(100000000) {count += 1}
tend = Time.new
puts "%10.3f" % tstart
puts "%10.3f" % tend.to_f
diff = tend - tstart
puts "%10.3f" % diff.to_f
Add to del.icio.us