Map a function in parallel:

Generate a table in parallel:

Functions defined interactively can immediately be used in parallel:

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

Listable functions of several arguments:

Only the right side of an assignment is parallelized:

Elements of a compound expression are parallelized one after the other:

Parallelize the generation of video frames:

Search for Mersenne primes:

Watch the results appear as they are found:

Compute a whole table of visualizations:

Search a range in parallel for local minima:

Choose the best one:

Use a shared function to record timing results as they are generated:

Set up a dynamic bar chart with the timing results:

Run a series of calculations with vastly varying runtimes:

For data parallel functions, Parallelize is implemented in terms of ParallelCombine :

Parallel speedup can be measured with a calculation that takes a known amount of time:

Define a number of tasks with known runtimes:

The time for a sequential execution is the sum of the individual times:

Measure the speedup for parallel execution:

Finest-grained scheduling gives better load balancing and higher speedup:

Scheduling large tasks first gives even better results:

Form the arithmetic expression 1⊗2⊗3⊗4⊗5⊗6⊗7⊗8⊗9 for ⊗ chosen from +, –, *, /:

Each list of arithmetic operations gives a simple calculation:

Evaluating it is easy:

Find all sequences of arithmetic operations that give 0:

Display the corresponding expressions:

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 :

Set up a random number generator that is suitable for parallel use and initialize each kernel:

Expressions that cannot be parallelized are evaluated normally:

Side effects cannot be used in the function mapped in parallel:

Use a shared variable to support side effects:

If no subkernels are available, the result is computed on the master kernel:

If a function used is not distributed first, the result may still appear to be correct:

Only if the function is distributed is the result actually calculated on the available 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:

Explicitly distribute the definition of a function:

Modify the definition:

The modified definition is automatically distributed:

Suppress the automatic distribution of definitions:

Symbols defined only on the subkernels are not distributed automatically:

The value of $DistributedContexts is not used in Parallelize :

Set the value of the DistributedContexts option of Parallelize :

Restore all settings to their default values:

Trivial operations may take longer when parallelized:

Display nontrivial automata as they are found: