Speed and the MapThread function

Question

Can anyone help explain why MapThread is so slow in this simple case?

p = 0.1;
t = Table[1, {10^6}];
SeedRandom[1000];
AbsoluteTiming[a = Map[# RandomChoice[{p, 1 - p} -> {1, 0}] &, t];]
SeedRandom[1000];
AbsoluteTiming[b = MapThread[# RandomChoice[{p, 1 - p} -> {1, 0}] &, {t}];]
Norm[a-b]

outputs

{0.555723, Null}
{3.696282, Null}
0

Answer 1

This is because of the compilation that kicks in automatically if the list in Map exceeds a certain number of elements.

"MapCompileLength" /. ("CompileOptions" /. SystemOptions["CompileOptions"])
(* Out: 100 *)

shows that the default setting is that if the list contains more than 100 elements then Map will be compiled. MapThread on the other hand does not seem to use automatic compilation.

This piece of code will test our hypothesis. Don't forget to reset the setting or restart the kernel once you're done:

SetSystemOptions["CompileOptions" -> "MapCompileLength" -> Infinity]

p = 0.1;
t = Table[1, {10^6}];
SeedRandom[1000];
AbsoluteTiming[a = Map[# RandomChoice[{p, 1 - p} -> {1, 0}] &, t];]
SeedRandom[1000];
AbsoluteTiming[
 b = MapThread[# RandomChoice[{p, 1 - p} -> {1, 0}] &, {t}];]
Norm[a - b]

(* Out: {3.57806, Null}, {3.66936, Null}, 0 *)

Answer 2

Map is automatically compiled. Yes, even with RandomChoice. Try it:

f = Compile[{{p, _Real, 0}, {t, _Integer, 1}}, 
  Map[# RandomChoice[{p, 1 - p} -> {1, 0}] &, t]
 ];
f // InputForm (* -> clean bytecode *)

Check its performance:

p = 0.1;
t = Table[1, {10^6}];
SeedRandom[1000];

AbsoluteTiming[a = Map[# RandomChoice[{p, 1 - p} -> {1, 0}] &,t];] (* -> 0.578125 seconds *)

AbsoluteTiming[c = f[0.1, t];] (* -> 0.593750 seconds *)

The timings are the same, so this is the solution. It's also the reason that Map doesn't unpack and MapThread does. (Compiled code only works with packed arrays.)

MapThread doesn't have this ability and uses the uncompiled code. Map will be the same if it is not allowed to compile, as Pickett shows in his answer.