A simple example: RosettaCode's Universal Turing Machine (5-state, 2-symbol probable Busy Beaver machine from Wikipedia) In V9 time = 225 seconds, in V10 322 seconds (Windows i5 desktop).

Not much to do but hope for better performance. I think I hear more disk swapping but that's not measured (yet).

The Benchmarking says that MMA10 is faster - at least on my machine (MacBook Pro, 2.8GHz i7, 16GB RAM, SSD).

Needs["Benchmarking`"]
BenchmarkReport[]

gives

for Mathematica 9 and

for Mathematica 10. That means that the score went up by more or less 20%, which constitutes quite a nice speed gain. In version 9 have noticed that the same task is quite a bit slower on a Mac than on a Linux machine - I do not have access to Windows. So the speed increase could be due to an optimisation for OSX. We also benchmarked to more Macs, and a standard iMac got a speed gain of about 40%.

Here's the data in another, more detailed form:

{"MachineName" -> "marcos-mbp", "System" -> "Mac OS X x86 (64-bit)",
"BenchmarkName" -> "MathematicaMark9", "FullVersionNumber" -> "9.0.1", "Date" -> "July 11, 2014", "BenchmarkResult" -> 1.101, "TotalTime" -> 12.568, "Results" -> {{"Data Fitting", 0.493}, {"Digits of Pi", 0.65}, {"Discrete Fourier Transform", 0.82}, {"Eigenvalues of a Matrix", 0.665}, {"Elementary Functions", 1.141}, {"Gamma Function", 0.549}, {"Large Integer Multiplication", 0.552}, {"Matrix Arithmetic", 1.016}, {"Matrix Multiplication", 1.377}, {"Matrix Transpose", 0.802}, {"Numerical Integration", 0.663}, {"Polynomial Expansion", 0.119}, {"Random Number Sort", 1.561}, {"Singular Value Decomposition", 0.998}, {"Solving a Linear System", 1.162}}}

and

{"MachineName" -> "marcos-mbp", "System" -> "Mac OS X x86 (64-bit)",
"BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "10.0.0",
"Date" -> "July 11, 2014", "BenchmarkResult" -> 1.236, "TotalTime" -> 11.197, "Results" -> {{"Data Fitting", 0.862}, {"Digits of Pi", 0.444}, {"Discrete Fourier Transform", 0.567}, {"Eigenvalues of a Matrix", 0.572}, {"Elementary Functions", 0.843}, {"Gamma Function", 0.585}, {"Large Integer Multiplication", 0.466}, {"Matrix Arithmetic", 2.012}, {"Matrix Multiplication", 0.616}, {"Matrix Transpose", 0.808}, {"Numerical Integration", 0.735}, {"Polynomial Expansion", 0.147}, {"Random Number Sort", 1.164}, {"Singular Value Decomposition", 0.78}, {"Solving a Linear System", 0.596}}}

We can plot this:

If this is correct Matrix arithmetic became slower, from 1.016 in MMA9 to 2.012 in MMA10. Many other functions became faster.

Cheers, M.

No, we do not really know whether they are identical, but the 3.07Ghz i7 950 (8 cores) is set to 1 in both benchmarks, i.e. the benchmarks are normalised to that machine. So there is a hope that they are the same.

More interestingly, it appears that all its individual timings for all individual tests are the same for the i7 in V9 and V10 , too, so that could suggest that the benchmarks are supposed to be the same. In fact, none of the machines that are in both benchmarks have changed the individual timings. So they are probably all the same tests run in V9. The comparison on the V10 benchmark are most likely compared to the machines in V9 - at least for the "older" machines. The top scorer in the V10 benchmark is the Mac Pro, which might have been tested under V10. I agree that much of this is mere speculation.

You are absolutely right, it would indeed be nice to know which bits are slower and why. It is strange that "Matrix Arithmetic" got quite a bit slower. Can anyone run the benchmark on something other than OSX? It appeared in MMA9 that OSX was a bit slower than Linux systems that had lower specifications. I think that we ran Windows in a sandbox (parallels or so) on a Mac and MM9 was faster there than on OSX.

I have tested a couple of my programs and they do appear to run faster in MMA10 than in MMA9.

Cheers, Marco

Hi Douglas,

yes, it appears that the "old machines" are not benchmarked with the new release, but if the tests are the same and I compare my own computer with both versions, i.e. MMA9 and MMA10, that should be valid, shouldn't it?

I meant the argument to suggest that the benchmark tests are probably the same for both versions, which is likely based on the numbers for the "standard machines". So, then it should be valid to compare the two versions 9/10 on the same machine.

M.

I can also reproduce a longer processing time (about 20%) with my Windows 8.1 machine (4 cores/8 logical processors): 186s (V9) - 228s (v10)

The web page has the exact code I uploaded. Put Timing[ ] around any driver/test. The last one is the long-running example.