mjhjmtu

I am using Mathematica 11.3 and this seems to me to be a bug. I would like, if possible, some idea on a workaround.

Here is an example of a trivial code that works as expected:

nI = 10;
(NM[#] := Print[#] ) & /@ Range[1, nI];
LaunchKernels;
DistributeDefinitions[NM];

That is, the code above generates no output, as expected.

Now, if the first line is changed to

nI = 20;

The same code leads to 40 lines being printed! From 1 to 20 two times.

For some reason, the DistributeDefinitions is forcing the definition of NM to be executed, and I do not want that to happen before I use ParallelSubmit and WaitAll. I tried this in two computers with Mathematica 11.3, any ideas on what is happening?

TL;DR;

Execute the following code to fix the problem:

DistributeDefinitions;
DownValues[Parallel`Protected`DistDefs] =
 DownValues[Parallel`Protected`DistDefs] /.
 HoldPattern[
 u : Parallel`Parallel`Private`updates =
 rhs_Language`ExtendedFullDefinition
 ] :>
 (
 u = Replace[
 rhs,
 defs : (_HoldPattern -> _) .. :> With[
 res = RuleDelayed @@@ Unevaluated@defs,
 res /; True
 ],
 4
 ]
 );

What does this do?

As mentioned in the comments, the issue is that Language`ExtendedFullDefinition seems to change the return format at 18 down-values. This causes the subsequent manipulations of DistributeDefinitions on the returned Language`DefinitionList[…] expression to leak the evaluation of the definitions (as their r.h.s. are no longer protected by the HoldRest attribute of RuleDelayed).

The code above fixes this by wrapping the call to Language`ExtendedFullDefinition (which happens in Parallel`Protected`DistDefs) with a piece of code that replaces definitions of the form HoldPattern[…]->… with HoldPattern[…]:>…, which prevents the evaluation leak.

When dealing with a larger number of definitions my recommendation is to disable the automatic distribution of definitions with

$DistributedContexts = None

and simply redo the definitions on all parallel kernels:

nI = 20;
(NM[#] := Print[#]) & /@ Range[1, nI];

With[nI = nI, ParallelEvaluate[(NM[#] := Print[#])& /@ Range[1, nI];]]

It's faster, too.