Monitor doesn't work with ParallelTable

Question

I can't monitor ParallelTable:

Monitor[ParallelTable[Pause[3]; i, {i, 1, 10}], i]

just displays i until it is finished.

Do you guys know of alternatives?

Answer 1

One way is to set a shared variable that would be assigned to an iterator variable, and monitor that:

SetSharedVariable[j]
Monitor[
   ParallelTable[j = n;Length[FactorInteger[2^n - 1]], {n, 50, 300}], 
   j
]

This may make sense if the computation for each i is rather intensive, so that the overhead of communication with the main kernel is negligible. Note also that the results you see are not generally in sequential order, since they depend on how ParallelTable schedules the computations to available kernels. As to the original example, here is a modified version,

SetSharedVariable[j]
Monitor[ParallelTable[Pause[RandomReal[{0.5, 4.}]];j = i, {i, 1, 10}], j]

where the intervals to pause are random, so that not all kernels finish computing at the same time.

EDIT

As mentioned by @Szabolcs in the comments,

• You could use j++ in place of j=i, if you are mostly interested in the overall progress
• One should be aware of what type of communication overhead this induces.

Here is one way to find out:

j = 0;
First@AbsoluteTiming[ParallelTable[j++, {i, 1, 1000}];]/1000

which returns 0.0028 on my machine.

Answer 2

Modifying some ideas suggested here, and a suggestions from Leonid in the comments:

SetAttributes[monitorParallelTable,HoldAll]
monitorParallelTable[expr_,iter__List,updatethreshold_]:=
 Module[{counter=1,thresh=updatethreshold},
  SetSharedVariable[counter];
  ParallelEvaluate[localcounter=1;];
  Monitor[
   ParallelTable[
    If[localcounter>=thresh,counter=counter+localcounter;localcounter=1,
     localcounter++];expr,iter],
   counter]
 ]

Basically, each kernel keeps a working tally of the number of elements it's solved, which dumps to a shared counter once it crosses an adjustable threshold. For example:

monitorParallelTable[Pause[RandomReal[{0.5, 4.}]]; n, {n, 5000}, 2]

Also, this should work for nested Table, e.g.

monitorParallelTable[Pause[RandomReal[{0.5, 4.}]]; n, {n, 5000}, {m,300}, 2]

A quick check on AbsoluteTiming shows the performance hit as a function of the threshold value:

Edit Not entirely sure why, but the counter that is monitored goes from 1 to (Maximum Iterations)/(number of kernels) rather than from 1 to (Maximum iterations)

Answer 3

This is my final code for implementing a long calculation (demonstrated here over a plane of values) to ensure that all processors are being used and code to monitor the progress, with estimates of time remaining. The last line exports the data to a location specified in that line, so that you can easily come back to it and use it later.

(* First define your function using this format f[x_,z_], presumably \
you may have many function definitions that build off of one another, \
this is where the physics goes *)
f[x_, z_] := N[Sin[ x z]]
(* Now define the boundaries of the plane that you wish to calculate \
values over *)
xmin = 1;
xmax = 2 \[Pi];
zmin = 1;
zmax = 8;
(* Now define how many points you wish to calculate the function \
along each axis, note that the total number of calculatons will be \
xstep*ystep.
I reccomend running this prelminarily with a small number of points \
(ie 10 x 10) to determine the average time per point, so that you may \
predict how many points will take a given amout of time *)
xstep = 100;
zstep = 100;
(* You shouldn't have to touch any of the code from 1here1 to, unless \
you want to run several of these statement and are worried about the \
names of the various tables, in which case rename tab1, but don't \
forget to change the name in the export command *)
timestart = AbsoluteTime[];
counter = 0;
SetSharedVariable[counter];
PrintTemporary[Dynamic[
   "Percent Completed: " <> 
    ToString[N[(counter*100)/((xstep + 1) (zstep + 1))]]
    <> "% \nTime elapsed: " <> ToString[AbsoluteTime[] - timestart] <>
     " s \nEstimated Time remaining: " <> 
    ToString[(((xstep + 1) (zstep + 1) - counter) (AbsoluteTime[] - 
        timestart))/counter]
   ]];
tab1 = ParallelTable[counter++; 
   N[f[x, z]], {x, xmin, xmax, N[Abs[xmin - xmax]/xstep]}, {z, zmin, 
    zmax, N[Abs[zmin - zmax]/zstep]}];
timeend = AbsoluteTime[];
Print["Total calculation time: ", timeend - timestart, " s"]
Print["Average time per data point: ", (
 timeend - timestart)/((xstep + 1) (zstep + 1)), " s"]
(* 1here1 *)
(* Change the location and file name, I suggest something that is \
meaningful and you will be able to remember easily *) 
Export["C:\\Users\\Ben\\Documents\\Code for group\\example.dat", tab1]