Wolfram Language & System Documentation Center

ParallelDo

ParallelDo[expr,{i_max}]

evaluates expr in parallel i_max times.

ParallelDo[expr,{i,i_max}]

evaluates expr in parallel with the variable i successively taking on the values 1 through i_max (in steps of 1).

ParallelDo[expr,{i,i_min,i_max}]

starts with i=i_min.

ParallelDo[expr,{i,i_min,i_max,di}]

uses steps di.

ParallelDo[expr,{i,{i₁,i₂,…}}]

uses the successive values i₁, i₂, ….

ParallelDo[expr,{i,i_min,i_max},{j,j_min,j_max},…]

evaluates expr looping in parallel over different values of j, etc. for each i.

ParallelDo

ParallelDo[expr,{i_max}]

evaluates expr in parallel i_max times.

ParallelDo[expr,{i,i_max}]

evaluates expr in parallel with the variable i successively taking on the values 1 through i_max (in steps of 1).

ParallelDo[expr,{i,i_min,i_max}]

starts with i=i_min.

ParallelDo[expr,{i,i_min,i_max,di}]

uses steps di.

ParallelDo[expr,{i,{i₁,i₂,…}}]

uses the successive values i₁, i₂, ….

ParallelDo[expr,{i,i_min,i_max},{j,j_min,j_max},…]

evaluates expr looping in parallel over different values of j, etc. for each i.

Details and Options

ParallelDo is a parallel version of Do that automatically distributes different evaluations of expr among different kernels and processors.
If side effects involve unshared variables, they will in general work differently than in Do.
Parallelize[Do[expr,iter, …]] is equivalent to ParallelDo[expr,iter,…].
The following options can be given:

Method	Automatic	granularity of parallelization
DistributedContexts	$DistributedContexts	contexts used to distribute symbols to parallel computations
ProgressReporting	$ProgressReporting	whether to report the progress of the computation

The Method option specifies the parallelization method to use. Possible settings include:

	"CoarsestGrained"	break the computation into as many pieces as there are available kernels
	"FinestGrained"	break the computation into the smallest possible subunits
	"EvaluationsPerKernel"->e	break the computation into at most e pieces per kernel
	"ItemsPerEvaluation"->m	break the computation into evaluations of at most m subunits each
	Automatic	compromise between overhead and load balancing

Method->"CoarsestGrained" is suitable for computations involving many subunits, all of which take the same amount of time. It minimizes overhead, but does not provide any load balancing.
Method->"FinestGrained" is suitable for computations involving few subunits whose evaluations take different amounts of time. It leads to higher overhead, but maximizes load balancing.
The DistributedContexts option specifies which symbols appearing in expr have their definitions automatically distributed to all available kernels before the computation.
The default value is DistributedContexts:>$DistributedContexts with $DistributedContexts:=$Context, which distributes definitions of all symbols in the current context, but does not distribute definitions of symbols from packages.
The ProgressReporting option specifies whether to report the progress of the parallel computation.
The default value is ProgressReporting:>$ProgressReporting.

Examples

open all close all

Basic Examples (3)

ParallelDo works like Do, but in parallel:

Wolfram Language code: Do[Pause[1];f[i], {i, 4}]//AbsoluteTiming

Wolfram Language code: ParallelDo[Pause[1];f[i], {i, 4}]//AbsoluteTiming

No results are returned by ParallelDo:

Wolfram Language code: ParallelDo[Print[i], {i, 4}]

Use a shared variable to communicate results found to the master kernel:

Wolfram Language code: SetSharedVariable[pr]

Wolfram Language code:

pr = {};
ParallelDo[If[PrimeQ[2 ^ i - 1], AppendTo[pr, i]], {i, 2000, 10000}]
pr

Options (9)

Method (2)

Calculations with vastly differing runtimes should be parallelized as finely as possible:

Wolfram Language code: ParallelDo[If[PrimeQ[2 ^ i - 1], Print[i]], {i, 4000, 5000}, Method -> "FinestGrained"]

A large number of simple calculations should be distributed into as few batches as possible:

Wolfram Language code: BinCounts[ParallelMap[Mod[Floor[# * Pi], 10]&, Range[10000], Method -> "CoarsestGrained"], {0, 10}]

DistributedContexts (5)

By default, definitions in the current context are distributed automatically:

Wolfram Language code: remote[x_] := {$KernelID, x ^ 3}

Wolfram Language code: ParallelDo[Print[remote[i]], {i, 4}]

Do not distribute any definitions of functions:

Wolfram Language code: kid := $KernelID

Wolfram Language code: ParallelDo[Print[kid], {i, 4}, DistributedContexts -> None]

Distribute definitions for all symbols in all contexts appearing in a parallel computation:

Wolfram Language code: a`kid := $KernelID

Wolfram Language code: ParallelDo[Print[a`kid], {i, 4}, DistributedContexts -> Automatic]

Distribute only definitions in the given contexts:

Wolfram Language code: b`kid := $KernelID

Wolfram Language code: ParallelDo[Print[b`kid], {i, 4}, DistributedContexts -> {"a`"}]

Restore the value of the DistributedContexts option to its default:

Wolfram Language code: SetOptions[ParallelDo, DistributedContexts :> $DistributedContexts]

ProgressReporting (2)

Do not show a temporary progress report:

Wolfram Language code: ParallelDo[If[PrimeQ[2 ^ i - 1], Print[i]], {i, 4000, 5000}, ProgressReporting -> False]

Use Method"FinestGrained" for the most accurate progress report:

Wolfram Language code: ParallelDo[If[PrimeQ[2 ^ i - 1], Print[i]], {i, 4000, 10000}, Method -> "FinestGrained", ProgressReporting -> True]

Applications (1)

Generate a number of animation frames and save them to individual files:

Wolfram Language code:

With[{frames = 60, R = 12}, 
	ParallelDo[
	Export["drum-" <> ToString[PaddedForm[t, 3, NumberPadding -> "0"]] <> ".gif", RevolutionPlot3D[Sin[t / frames * 2 * Pi]BesselJ[0, r], {r, 0, R}, PlotRange -> {{-R, R}, {-R, R}, {-1, 1}}]]
	, {t, 0, frames - 1}]
	]

Import every 5 file and display it: