Relative performance of the Julia language

Question

I was just reviewing the Mathematica benchmark code linked from the Julia language home page http://julialang.org/. The stated goal of the benchmarks is to test the performance of specific algorithms, expressed in a reasonable idiom in each language, and all languages use the same algorithm.

In particular, the Fibonacci benchmarks are all recursive, and the Mathematica code reads

ClearAll[fib];
fib = Compile[{{n, _Integer}}, 
    If[n < 2, n, fib[n - 1] + fib[n - 2]],
    CompilationTarget -> "WVM"
];

Now, dynamic programming is certainly a reasonable idiom in Mathematica:

fib[n_Integer]:= fib[n]= If[n < 2, n, fib[n - 1] + fib[n - 2]]

and this dynamic uncompiled code will be much faster than the benchmark code, especially for large n (unless the WVM compiler is smart enough to do automatic memoization).

The test only computes fib[20] and it would be most interesting to try say fib[100] in the various languages (the times for R, MATLAB, and OCTAVE are excessive even for n=20).

It would also be useful, I think, for better coding of all the benchmark examples, if someone has the time and energy ...

Answer 1

I wrote the code in question... It is pretty much a line for line port of the Julia version of the benchmark:

Julia:

fib(n) = n < 2 ? n : fib(n-1) + fib(n-2)

Mathematica:

fib = Compile[{{n, _Integer}},
    If[n < 2, n, fib[n - 1] + fib[n - 2]],
    CompilationTarget -> "WVM" 
    (* WVM is faster than C in this case because of the recursive calls *)
];

It was never intended it to be an example of idiomatic Mathematica code. I did however actively chose not to use memoization because the benchmark states: "all languages use the same algorithm".

On my use of Compile: Since the code is very procedural it was very amenable to use with Compile. Most of the time it was as simple as wrapping the functions with Compile. I do recognize that it is sort of gaming the benchmark and perhaps it should have been excluded.

I am open to doing a rewrite of the code that does things in a more idiomatic style if there is any interest but I doubt the people over at Julia really care much.

(Sorry this isn't just a comment. I don't have the reputation to make comments)

Edit: I just tested the more idiomatic:

ClearAll[fib];
fib[0] = 0;
fib[1] = 1;
fib[n_] := fib[n - 1] + fib[n - 2];

It turns out this is only about 3 times slower than the WVM compiled version.