ParallelTable

ParallelTable[expr,{i_max}]

generates in parallel a list of i_max copies of expr.

ParallelTable[expr,{i,i_max}]

generates in parallel a list of the values of expr when i runs from 1 to i_max.

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

starts with i=i_min.

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

uses steps di.

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

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

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

gives a nested list. The list associated with i is outermost.

Details and Options

ParallelTable is a parallel version of Table which automatically distributes different evaluations of expr among different kernels and processors.
ParallelTable will give the same results as Table, except for side effects during the computation.
Parallelize[Table[expr,iter, …]] is equivalent to ParallelTable[expr,iter,…].
If an instance of ParallelTable cannot be parallelized it is evaluated using Table.
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 allclose all

Basic Examples (6)

ParallelTable works like Table, but in parallel:

A table of the first 10 squares:

A table with i running from 0 to 20 in steps of 2:

Make a 4×3 matrix:

Plot a table:

Longer computations display information about their progress and estimated time to completion:

Scope (5)

The index in the table can run backward:

Make a triangular array:

Make a 3x2x4 array, or tensor:

Iterate over an existing list:

Make an array from existing lists:

Generalizations & Extensions (1)

The table index can have symbolic values:

Options (13)

Method (6)

Break the computation into the smallest possible subunits:

Break the computation into as many pieces as there are available kernels:

Break the computation into at most 2 evaluations per kernel for the entire job:

Break the computation into evaluations of at most 5 elements each:

The default option setting balances evaluation size and number of evaluations:

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

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

DistributedContexts (5)

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

Do not distribute any definitions of functions:

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

Distribute only definitions in the given contexts:

Restore the value of the DistributedContexts option to its default:

ProgressReporting (2)

Do not show a temporary progress report:

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

Applications (5)

Solve and plot a differential equation for many initial conditions and animate the results:

Explore different parameter values for the sine-Gordon equation in two spatial dimensions:

Apply different algorithms to the same set of data:

Apply a list of different filters to the same image and display the result:

Or apply a list of effects:

Generate 10 frames from an animation and save them to individual files:

Run several batches in parallel:

Each run returns one frame which can be used for checking the correctness:

Remove the generated files:

Quickly show the evaluation of several nontrivial cellular automata:

Properties & Relations (10)

Parallelization happens along the outermost (first) index:

Using multiple iteration specifications is equivalent to nesting Table functions:

ParallelDo evaluates the same sequence of expressions as ParallelTable:

ParallelSum effectively applies Plus to results from ParallelTable:

ParallelArray iterates over successive integers:

Map applies a function to successive elements in a list:

Table can substitute successive elements in a list into an expression:

ParallelTable iterating over a given list is equivalent to ParallelCombine:

ParallelTable can be implemented with WaitAll and ParallelSubmit:

Parallelization at the innermost level of a multidimensional table:

Functions defined interactively are automatically distributed to all kernels when needed:

Distribute definitions manually and disable automatic distribution:

For functions from a package, use ParallelNeeds rather than DistributeDefinitions:

Possible Issues (3)

A function used that is not known on the parallel kernels may lead to sequential evaluation:

Define the function on all parallel kernels:

The function is now evaluated on the parallel kernels:

Definitions of functions in the current context are distributed automatically:

Definitions from contexts other than the default context are not distributed automatically:

Use DistributeDefinitions to distribute such definitions:

Alternatively, set the DistributedContexts option to include all contexts:

Trivial operations may take longer when parallelized:

Neat Examples (2)

Visualize the Mandelbrot set:

Calculate and display the Feigenbaum (or bifurcation) diagram of the logistics map: