WOLFRAM

Wolfram Language & System Documentation Center

ParallelArray[f,n]

generates in parallel a list of length n, with elements f[i], evaluated.

ParallelArray[f,{n1,n2,…}]

generates in parallel an array of nested lists, with elements f[i1,i2,…].

ParallelArray[f,{n1,n2,…},{r1,r2,…}]

generates in parallel a list using the index origins ri (default 1).

ParallelArray[f,dims,origin,h]

uses head h, rather than List, for each level of the array.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Options  
Method  
DistributedContexts  
ProgressReporting  
Possible Issues  
See Also
Related Guides
History
Cite this Page

ParallelArray

ParallelArray[f,n]

generates in parallel a list of length n, with elements f[i], evaluated.

ParallelArray[f,{n1,n2,…}]

generates in parallel an array of nested lists, with elements f[i1,i2,…].

ParallelArray[f,{n1,n2,…},{r1,r2,…}]

generates in parallel a list using the index origins ri (default 1).

ParallelArray[f,dims,origin,h]

uses head h, rather than List, for each level of the array.

Details and Options

  • ParallelArray is a parallel version of Array, which automatically distributes different evaluations of expr among different kernels and processors.
  • ParallelArray will give the same results as Array, except for side effects during the computation.
  • Parallelize[Array[f,n]] is equivalent to ParallelArray[f,n].
  • If an instance of ParallelArray cannot be parallelized, it is evaluated using Array.
  • The following options can be given:
  • Method Automaticgranularity of parallelization
    DistributedContexts $DistributedContextscontexts used to distribute symbols to parallel computations
    ProgressReporting $ProgressReportingwhether 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"->ebreak the computation into at most e pieces per kernel
    "ItemsPerEvaluation"->mbreak the computation into evaluations of at most m subunits each
    Automaticcompromise 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  (4)

ParallelArray works like Array, but in parallel:

Wolfram Language code: Array[(Pause[1];f[#])&, 4]//AbsoluteTiming
Wolfram Language code: ParallelArray[(Pause[1];f[#])&, 4]//AbsoluteTiming

Generate a array:

Wolfram Language code: ParallelArray[f, {3, 2}]

Generate a array:

Wolfram Language code: ParallelArray[10#1 + #2&, {3, 4}]

Use index origin 0 instead of 1:

Wolfram Language code: ParallelArray[f, 10, 0]

Start with indices 0 and 4 instead of 1:

Wolfram Language code: ParallelArray[f, {2, 3}, {0, 4}]

Used h instead of List for the result expression:

Wolfram Language code: ParallelArray[f, {3, 2}, 1, h]

Options  (13)

Method  (6)

Break the computation into the smallest possible subunits:

Wolfram Language code: ParallelArray[Labeled[Framed[#], $KernelID]&, 10, Method -> "FinestGrained"]

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

Wolfram Language code: ParallelArray[Labeled[Framed[#], $KernelID]&, 10, Method -> "CoarsestGrained"]

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

Wolfram Language code: ParallelArray[Labeled[Framed[#], $KernelID]&, 12, Method -> "EvaluationsPerKernel" -> 2]

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

Wolfram Language code: ParallelArray[Labeled[Framed[#], $KernelID]&, 18, Method -> "ItemsPerEvaluation" -> 5]

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

Wolfram Language code: ParallelArray[Labeled[Framed[#], $KernelID]&, 18, Method -> Automatic]

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

Wolfram Language code: ParallelArray[PrimeQ[2 ^ # - 1]&, 20, 4410, Method -> "FinestGrained"]

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

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

DistributedContexts  (5)

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

Wolfram Language code: remote[x_] := Labeled[Framed[x], $KernelID]
Wolfram Language code: ParallelArray[remote, 4]

Do not distribute any definitions of functions:

Wolfram Language code: local[x_] := Labeled[Framed[x], $KernelID]
Wolfram Language code: ParallelArray[local, 4, DistributedContexts -> None]

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

Wolfram Language code: a`f[x_] := Labeled[Framed[x], $KernelID]
Wolfram Language code: ParallelArray[a`f, 4, DistributedContexts -> Automatic]

Distribute only definitions in the given contexts:

Wolfram Language code: b`g[x_] := Labeled[Framed[x], $KernelID]
Wolfram Language code: ParallelArray[b`f, 4, DistributedContexts -> {"a`"}]

Restore the value of the DistributedContexts option to its default:

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

ProgressReporting  (2)

Do not show a temporary progress report:

Wolfram Language code: res = ParallelArray[PrimeQ[2 ^ # - 1]&, 10000, ProgressReporting -> False];

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

Wolfram Language code: res = ParallelArray[PrimeQ[2 ^ # - 1]&, 10000, Method -> "FinestGrained", ProgressReporting -> True];

Possible Issues  (2)

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

Wolfram Language code: ftest[n_] := Labeled[Framed[PrimeQ[2 ^ n - 1]], $KernelID]
Wolfram Language code: ParallelArray[ftest, 10, DistributedContexts -> None]

Define the function on all parallel kernels:

Wolfram Language code: DistributeDefinitions[ftest]

The function is now evaluated on the parallel kernels:

Wolfram Language code: ParallelArray[ftest, 10, DistributedContexts -> None]

Definitions of functions in the current context are distributed automatically:

Wolfram Language code: gtest[n_] := Labeled[Framed[PrimeQ[2 ^ n - 1]], $KernelID]
Wolfram Language code: ParallelArray[gtest, 10]

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

Wolfram Language code: ctx`mtest[n_] := Labeled[Framed[PrimeQ[2 ^ n - 1]], $KernelID]
Wolfram Language code: ParallelArray[ctx`mtest, 10]

Use DistributeDefinitions to distribute such definitions:

Wolfram Language code: DistributeDefinitions[ctx`mtest];
Wolfram Language code: ParallelArray[ctx`mtest, 10]

Alternatively, set the DistributedContexts option to include all contexts:

Wolfram Language code: cty`mtest[n_] := Labeled[Framed[PrimeQ[2 ^ n - 1]], $KernelID]
Wolfram Language code: ParallelArray[cty`mtest, 10, DistributedContexts -> Automatic]
Wolfram Research (2008), ParallelArray, Wolfram Language function, https://reference.wolfram.com/language/ref/ParallelArray.html (updated 2021).

Text

Wolfram Research (2008), ParallelArray, Wolfram Language function, https://reference.wolfram.com/language/ref/ParallelArray.html (updated 2021).

CMS

Wolfram Language. 2008. "ParallelArray." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2021. https://reference.wolfram.com/language/ref/ParallelArray.html.

APA

Wolfram Language. (2008). ParallelArray. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/ParallelArray.html

BibTeX

@misc{reference.wolfram_2026_parallelarray, author="Wolfram Research", title="{ParallelArray}", year="2021", howpublished="\url{https://reference.wolfram.com/language/ref/ParallelArray.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_parallelarray, organization={Wolfram Research}, title={ParallelArray}, year={2021}, url={https://reference.wolfram.com/language/ref/ParallelArray.html}, note=[Accessed: 13-June-2026]}