Casting MapResult

[jmh530 via Digitalmars-d-learn]

On Tuesday, 16 June 2015 at 16:37:35 UTC, John Colvin wrote:
> If you want really fast exponentiation of an array though, you 
> want to use SIMD. Something like http://www.yeppp.info would be 
> easy to use from D.

I've been looking into SIMD a little. It turns out that core.simd 
only works for DMD on Linux machines. Not sure about the other 
compilers, but I was a bit stuck for a little on it. I read a 
little on SIMD as I had no real understanding of it before you 
mentioned it. At least I understand why all the types on 
core.simd were so small. My initial reaction was there's no way I 
would want to write a code just for float[4], but now I'm like 
"oh that's the whole point".

Anyway, I might try to put something together on my other machine 
one of these days, but I was able to make a little bit more 
progress with D's std.parallelism. The foreach loops work great, 
even on Windows, with little extra work required.

That being said, I'm not seeing any speed-up from parallel map. I 
put some code below doing some variations on std.algorithm.map 
and taskPool.map. The more the memory allocation (through .array) 
the longer everything takes. Keeping things as ranges seems to be 
much faster.

The most interesting result to me was that the taskPool.map was 
slower than std.algorithm.map in each case. Maybe a difference 
between being semi-eager versus lazy. The code below doesn't show 
it, but it seems like the parallel foreach loop is faster than 
std.algorithm.map or taskPool.map when doing everything with 
arrays.



import std.datetime;
import std.parallelism;
import std.conv : to;
import std.math : exp;
import std.stdio : writeln;
import std.array : array;
import std.range : iota;

enum real x_size = 100_000;

void f0()
{
	auto y = std.algorithm.map!(a => exp(a))(iota(x_size));
}

void f1()
{
	auto y = taskPool.map!exp(iota(x_size));
}

void f2()
{
	auto y = std.algorithm.map!(a => exp(a))(iota(x_size)).array;
}

void f3()
{
	auto y = taskPool.map!exp(iota(x_size)).array;
}

void f4()
{
	auto y = std.algorithm.map!(a => exp(a))(iota(x_size).array);
}

void f5()
{
	auto y = taskPool.map!exp(iota(x_size).array);
}

void f6()
{
	auto y = std.algorithm.map!(a => 
exp(a))(iota(x_size).array).array;
}

void f7()
{
	auto y = taskPool.map!exp(iota(x_size).array).array;
}

void main() {
	auto r = benchmark!(f0, f1, f2, f3, f4, f5, f6, f7)(100);
	auto f0Result = to!Duration(r[0]);
	auto f1Result = to!Duration(r[1]);
	auto f2Result = to!Duration(r[2]);
	auto f3Result = to!Duration(r[3]);
	auto f4Result = to!Duration(r[4]);
	auto f5Result = to!Duration(r[5]);
	auto f6Result = to!Duration(r[6]);
	auto f7Result = to!Duration(r[7]);
	writeln(f0Result);			//prints ~ 17us on my machine
	writeln(f1Result);			//prints ~ 4.3ms on my machine
	writeln(f2Result);			//prints ~ 1.7s on my machine
	writeln(f3Result);			//prints ~ 3.5s on my machine
	writeln(f4Result);			//prints ~ 471ms on my machine
	writeln(f5Result);			//prints ~ 473ms on my machine
	writeln(f6Result);			//prints ~ 1.9s on my machine
	writeln(f7Result);			//prints ~ 3.9s on my machine
}