ParallelTable much slower than Table on RandomReal with arbitrary precision

Question

So I was trying a very simple example (Mathematica 11.0.1)

AbsoluteTiming[
 A1 = Table[
    RandomReal[WorkingPrecision -> 30], {ii, 1, 1000}, {jj, 1, 
     1000}];]
{0.752044, Null}

And then in parallel

AbsoluteTiming[
 A1 = ParallelTable[
    RandomReal[WorkingPrecision -> 30], {ii, 1, 1000}, {jj, 1, 
     1000}];]
{6.35024, Null}

(which is after running it at least once so that definitions and stuff get distributed). It is clearly much slower than Table. This timing is independent of the number of kernels I launch - that is - it remains unchanged for LaunchKernels[n], where n is any integer different than 0 up to the maximum number of kernels I have (tried it on a machine with 12).

I also tried doing thing like

$MinPrecision = 30; $MaxPrecision = Infinity;
ParallelEvaluate[$MinPrecision = 30; $MaxPrecision = 
  Infinity;]; DistributeDefinitions[$MinPrecision, $MaxPrecision];

and then

AbsoluteTiming[
 A1 = ParallelTable[
    RandomReal[WorkingPrecision -> $MinPrecision], {ii, 1, 1000}, {jj,
      1, 1000}];]
{6.38118, Null}

Which is again much slower than Table. I would like to know why is this happening, so that I can avoid this type of behaviour.

Answer 1

First of all, the best way to do this calculation is

RandomReal[1, {1000, 1000}, 
   WorkingPrecision -> 30]; // AbsoluteTiming
(* {0.312959, Null} *)

Why is the parallel version slow? There can be many reasons, and unfortunately I do not have the time to verify which one it is here. However, I strongly suspect that it is data transfer overhead.

This computation is generally very fast, but it produces huge data that needs to be transferred back to the main kernel. Moreover, that data is arbitrary precision, which means that each number needs to be sent over MathLink independently (instead of sending a packed array in one go). This is exactly the situation where I would expect the parallel tools to perform badly.

You can test this yourself by trying to pass data of this size and type through MathLink (see e.g. LinkWrite, or otherwise use DistributeDefinitions).

---

Update: Here's a benchmark for MathLink transfer of such a large arbitrary precision array. This shows that it is indeed the data transfer that is slow.

link = LinkCreate[LinkMode -> Loopback];

arr = RandomReal[1, {1000, 1000}, WorkingPrecision -> 30];

LinkWrite[link, arr] // AbsoluteTiming
(* {4.30156, Null} *)

arr2 = LinkRead[link]; // AbsoluteTiming
(* {6.9221, Null} *)

The slowness is due to the fact that this is not a packed array (arbitrary precision arrays cannot be), and thus each element is sent with a separate MathLink call.

Compare how much faster it is to transfer a packed array:

parr = RandomReal[1, {1000, 1000}]; (* packed machine precision array *)

LinkWrite[link, parr] // AbsoluteTiming
(* {0.004155, Null} *)

parr2 = LinkRead[link]; // AbsoluteTiming
(* {0.005705, Null} *)