Scalability in std.parallelism

["Nordlöw"]

In the following test code given below of std.parallelism I get 
some interesting results:

when compiled as

dmd -release -noboundscheck -O -inline -w -wi -wi  
~/Work/justd/t_parallelism.d -oft_parallelism

My scalability measures says the following

3.14159 took 221[ms]
3.14159 took 727[ms]
Speedup 3.28959
-5.80829e+09 took 33[ms]
-5.80829e+09 took 201[ms]
Speedup 6.09091

Why do I get a larger speed for a simpler map function?
Shouldn't it be the opposite?
I've always read that the more calculations I perform on each 
memory access the better the speedup...

Anyhow the speedups are great!

I'm sitting on a Intel Quad core with 8 hyperthreads.


Sample code follows:



import std.algorithm, std.parallelism, std.range, std.datetime, 
std.stdio;

void test1 () {
     immutable n = 100_000_000;
     immutable delta = 1.0 / n;

     auto piTerm(int i) {
         immutable x = (i - 0.5) * delta;
         return delta / (1.0 + x*x);
     }

     auto nums = n.iota.map!piTerm; // numbers
     StopWatch sw;

     sw.reset();
     sw.start();
     immutable pi = 4.0*taskPool.reduce!"a+b"(nums);
     sw.stop();
     immutable ms = sw.peek().msecs;
     writeln(pi, " took ", ms, "[ms]");

     sw.reset();
     sw.start();
     immutable pi_ = 4.0*std.algorithm.reduce!"a+b"(nums);
     sw.stop();
     immutable ms_ = sw.peek().msecs;
     writeln(pi_, " took ", ms_, "[ms]");

     writeln("Speedup ", cast(real)ms_ / ms);
}

auto square(T)(T i) @safe pure nothrow { return i*i; }

void test2 () {
     immutable n = 100_000_000;
     immutable delta = 1.0 / n;

     auto nums = n.iota.map!square; // numbers
     StopWatch sw;

     sw.reset();
     sw.start();
     immutable pi = 4.0*taskPool.reduce!"a+b"(nums);
     sw.stop();
     immutable ms = sw.peek().msecs;
     writeln(pi, " took ", ms, "[ms]");

     sw.reset();
     sw.start();
     immutable pi_ = 4.0*std.algorithm.reduce!"a+b"(nums);
     sw.stop();
     immutable ms_ = sw.peek().msecs;
     writeln(pi_, " took ", ms_, "[ms]");

     writeln("Speedup ", cast(real)ms_ / ms);
}

void main () {
     test1();
     test2();
}