parfor

Execute for-loop iterations in parallel on workers

Syntax

parfor loopVar = initVal:endVal; statements;end

parfor loopVar = initVal:step:endVal; statements;end

parfor(loopVar = initVal:endVal); statements; end

parfor(loopVar = initVal:step:endVal); statements; end

parfor(___,M); statements; end

parfor(___,opts); statements; end

parfor(___,cluster); statements; end

parfor(___,pool); statements; end

Description

Simple Form

parfor loopVar = initVal:endVal; statements;end executes for-loop iterations in parallel on workers in a parallel pool.

MATLAB^® executes the loop body commands in statements for values of loopVar between initVal and endVal. loopVar specifies a vector of integer values with a step size of 1. If you have Parallel Computing Toolbox™, the iterations of statements can execute on a parallel pool of workers on your multi-core computer or cluster. As with a for-loop, you can include a single line or multiple lines in statements.

To find out how parfor can help increase your throughput, see Decide When to Use parfor.

parfor differs from a traditional for-loop in the following ways:

• MATLAB loop iterations in parallel in a nondeterministic order. This means that you might need to modify your code to use parfor. For more help, see Convert for-Loops into parfor-Loops.

• If you use this syntax, loop iterations must be consecutive increasing integer values.

• The body of the parfor-loop must be independent. One loop iteration cannot depend on a previous iteration, because the iterations are executed in a nondeterministic order. For more help, see Ensure That parfor-Loop Iterations Are Independent.

• You cannot use a parfor-loop inside another parfor-loop. For more help, see Nested parfor and for-Loops and Other parfor Requirements.

parfor loopVar = initVal:step:endVal; statements;end increments loopVar by the value of step on each iteration, or decrements loopVar when the value of step is negative. step must be 1 or -1. Use this syntax to run parfor-loops with a descending loop index variable.

If you use this syntax, loop iterations must be consecutive integer values.

Before R2026a: step must be 1 and loop iterations must be consecutive, increasing integer values.

Advanced Form with Additional Options

parfor(loopVar = initVal:endVal); statements; end and parfor(loopVar = initVal:step:endVal); statements; end also execute loop iterations in parallel on workers in a parallel pool. Use parenthesis around the loop expression to allow for additional options.

parfor(___,M); statements; end uses M to specify the maximum number of workers from the parallel pool to use in evaluating statements in the loop body. M must be a nonnegative integer.

By default, MATLAB uses the available workers in your parallel pool. You can change the default number of workers in your parallel pool using the PreferredPoolNumWorkers property of the default profile. For all factors that can affect your default pool size, see Factors That Affect Pool Size. You can override the default number of workers in a parallel pool by using the parpool function. When no workers are available in the pool or M is zero, MATLAB still executes the loop body in a nondeterministic order, but not in parallel. Use this syntax to switch between parallel and serial execution when testing your code.

With this syntax, to execute the iterations in parallel, you must have a parallel pool of workers. By default, if you execute parfor, you automatically create a parallel pool of workers on the parallel environment defined by your default profile. The default parallel environment is Processes. You can change your profile in Parallel Settings. For more details, see Specify Your Parallel Settings.

parfor(___,opts); statements; end uses opts to specify the resources to use in evaluating statements in the loop body. Create a set of parfor options using the parforOptions function. With this approach, you can run parfor on a cluster without first creating a parallel pool and control how parfor partitions the iterations into subranges for the workers.

parfor(___,cluster); statements; end executes statements on workers in cluster without creating a parallel pool. This is equivalent to executing parfor (loopVar = initVal:endVal,parforOptions(cluster)); statements; end.

parfor(___,pool); statements; end executes statements on the parallel pool specified by the parallel.Pool object pool. Use this syntax when you want to evaluate parfor statements on a pool other than the pool the gcp function returns. (since R2025a)

Examples

Convert for-Loop Into parfor-Loop

Create a parfor-loop for a computationally intensive task and measure the resulting speedup.

In the MATLAB Editor, enter the following for-loop. To measure the time elapsed, add tic and toc.

tic
n = 200;
A = 500;
a = zeros(1,n);
for ii = 1:n
    a(ii) = max(abs(eig(rand(A))));
end
toc

Run the script, and note the elapsed time.

Elapsed time is 31.935373 seconds.

In the script, replace the for-loop with a parfor-loop.

tic
n = 200;
A = 500;
a = zeros(1,n);
parfor ii = 1:n
    a(ii) = max(abs(eig(rand(A))));
end
toc

Run the new script, and run it again. The first run is slower than the second run, because the parallel pool has to be started, and you have to make the code available to the workers. Note the elapsed time for the second run.

By default, MATLAB automatically opens a parallel pool of workers on your local machine.

Elapsed time is 10.760068 seconds. 

Observe that you speed up your calculation by converting the for-loop into a parfor-loop on four workers. You might reduce the elapsed time further by increasing the number of workers in your parallel pool. For more information, see Convert for-Loops into parfor-Loops and Scale Up parfor-Loops to Cluster and Cloud.

Test parfor-Loops by Switching Between Parallel and Serial Execution

You can specify the maximum number of workers M for a parfor-loop. Set M=0 to run the body of the loop in the desktop MATLAB, without using workers, even if a pool is open. When M = 0, MATLAB still executes the loop body in a nondeterministic order, but not in parallel, so that you can check whether your parfor-loops are independent and suitable to run on workers. This is the simplest way to allow you to debug the contents of a parfor-loop. You cannot set breakpoints directly in the body of the parfor-loop, but you can set breakpoints in functions called from the body of the parfor-loop.

Specify M = 0 to run the body of a parfor-loop in the desktop MATLAB, even if a pool is open.

 M = 0;                     % M specifies maximum number of workers
 y = ones(1,100);
 parfor(ii = 1:100,M)
      y(ii) = ii;
 end

To control the number of workers in your parallel pool, see Specify Your Parallel Settings and parpool.

Measure Data Transferred to Workers Using a parfor-Loop

To measure how much data is transferred to and from the workers in your current parallel pool, add ticBytes(gcp) and tocBytes(gcp) before and after the parfor-loop. Use gcp as an argument to get the current parallel pool.

Delete your current parallel pool if you still have one.

delete(gcp('nocreate'))

tic
ticBytes(gcp);
n = 200;
A = 500;
a = zeros(1,n);
parfor ii = 1:n
    a(ii) = max(abs(eig(rand(A))));
end
tocBytes(gcp)
toc

Run the new script, and run it again. The first run is slower than the second run, because the parallel pool has to be started, and you have to make the code available to the workers.

By default, MATLAB automatically opens a parallel pool of workers on your local machine.

Starting parallel pool (parpool) using the 'Processes' profile ... connected to 4 workers.
...
             BytesSentToWorkers    BytesReceivedFromWorkers
             __________________    ________________________

    1        15340                  7024                   
    2        13328                  5712                   
    3        13328                  5704                   
    4        13328                  5728                   
    Total    55324                 24168                   

You can use the ticBytes and tocBytes results to examine the amount of data transferred to and from the workers in a parallel pool. In this example, the data transfer is small. For more information about parfor-loops, see Decide When to Use parfor and Convert for-Loops into parfor-Loops.

Run parfor on a Cluster Without a Parallel Pool

Create a cluster object using the parcluster function, and create a set of parfor options with it. By default, parcluster uses your default cluster profile. Check your default profile on the MATLAB Home tab, in Parallel > Select Parallel Environment.

cluster = parcluster;

To run parfor computations directly in the cluster, pass the cluster object as the second input argument to parfor.

When you use this approach, parfor can use all the available workers in the cluster, and workers become available as soon as the loop completes. This approach is also useful if your cluster does not support parallel pools. If you want to control other options, including partitioning of iterations, use parforOptions.

values = [3 3 3 7 3 3 3];
parfor (idx=1:numel(values),cluster)
    out(idx) = norm(pinv(rand(values(idx)*1e3)));
end

Use this syntax to run parfor on a large cluster without consuming workers for longer than necessary.

Run parfor-Loops on Specific Pool

You can specify the pool to run a parfor-loop when you want to use a pool other than the pool the gcp function returns.

Start a parallel pool of 30 workers on a cluster with the profile name myCluster

myClusterPool = parpool("myCluster",30);

Create a pool partition using the first 12 workers from the pool.

parforWorkers = myClusterPool.Workers(1:12);
parforPool = partition(myClusterPool,"Workers",parforWorkers);

To run the parfor-loop on the pool partition, pass the parforPool pool object as the second input argument to parfor.

values = [3 8 5 7 3 12 3];
parfor(idx = 1:numel(values),parforPool)
    a(idx) = norm(pinv(rand(values(i)*1e3)));
end

Run parfor-Loop with Descending Range

Since R2026a

Use a parfor-loop with a descending loop variable index range to evaluate a mathematical expression on the workers.

Specify an initial value of 12, step size of -1, and an end value of 1. The parfor-loop iterates from 12 down to 1.

parfor k = 12:-1:1
    out(k) = (5.*(k+8))./2;
end

Input Arguments

loopVar — Loop index

integer

Loop index variable with initial value initVal and final value endVal. The variable can be any numeric type and the value must be an integer.

Make sure that your parfor-loop variables are consecutive integers. For more details, see Troubleshoot Variables in parfor-Loops.

Before R2026a: Loop iterations must be consecutive, increasing integer values.

The range of the parfor-loop variable must not exceed the supported range. For more help, see Avoid Overflows in parfor-Loops.

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

initVal — Initial value of loop index

integer

Initial value loop index variable, loopVar. The variable can be any numeric type and the value must be an integer. With endVal, specifies the parfor range vector, when in the form M:N.

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

endVal — Final value of loop index

integer

Final value loop index variable, loopVar. The variable can be any numeric type and the value must be an integer. With initVal, specifies the parfor range vector, when in the form M:N.

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

step — Step size of loop index

1 | -1

Step size of loop index, loopVar. The variable can be any numeric type and must be an integer of value 1 or -1 to ensure the loop iterations are consecutive integer values.

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

statements — Loop body

text

Loop body, specified as text. The series of MATLAB commands to execute in the parfor-loop.

You might need to modify your code to use parfor-loops. For more help, see Convert for-Loops into parfor-Loops

Do not nest parfor-loops, see Nested parfor and for-Loops and Other parfor Requirements.

M — Maximum number of workers running in parallel

number of workers in the parallel pool (default) | nonnegative integer

Maximum number of workers running in parallel, specified as a nonnegative integer. If you specify an upper limit, MATLAB uses no more than this number, even if additional workers are available. If you request more workers than the number of available workers, then MATLAB uses the maximum number of workers available at the time of the call. If the loop iterations are fewer than the number of workers, some workers perform no work.

If parfor cannot run on multiple workers (for example, if only one core is available or M is 0), MATLAB executes the loop in a serial manner. In this case, MATLAB still executes the loop body in a nondeterministic order. Use this syntax to switch between parallel and serial when testing your code.

opts — parfor options

parforOptions object

parfor options, specified as a ClusterOptions object. Use the parforOptions function to create a set of parfor options.

Example: opts = parforOptions(parcluster);

cluster — Cluster

parallel.Cluster

Cluster, specified as a parallel.Cluster object, on which parfor runs. To create a cluster object, use the parcluster function.

Example: cluster = parcluster('Processes')

Data Types: parallel.Cluster

pool — Pool evaluating statements

parallel.Pool object

Since R2025a

Pool, specified as a parallel.Pool object, on which parfor runs.

• To create a parallel pool, use the parpoolfunction.

• To use a subset of an existing pool, use the partition function.

Limitations

• Noncommutative reductions are not supported in parfor-loops when the step size is negative. (since R2026a)

Tips

• Use a parfor-loop when:

  • You have many loop iterations of a simple calculation. parfor divides the loop iterations into groups so that each thread can execute one group of iterations.

  • You have some loop iterations that take a long time to execute.

• Do not use a parfor-loop when an iteration in your loop depends on the results of other iterations.

  Reductions are one exception to this rule. A reduction variable accumulates a value that depends on all the iterations together, but is independent of the iteration order. For more information, see Reduction Variables.

• When you use parfor, you have to wait for the loop to complete to obtain your results. Your client MATLAB is blocked and you cannot break out of the loop early. If you want to obtain intermediate results, or break out of a for-loop early, try parfeval instead.

• Unless you specify a cluster object or a pool object, a parfor-loop runs on the existing parallel pool. If no pool exists, parfor starts a new parallel pool, unless the automatic starting of pools is disabled in your parallel settings. If there is no parallel pool and parfor cannot start one, the loop runs serially in the client session.

• If the AutoAttachFiles property in the cluster profile for the parallel pool is set to true, MATLAB performs an analysis on a parfor-loop to determine what code files are necessary for its execution, see listAutoAttachedFiles. Then MATLAB automatically attaches those files to the parallel pool so that the code is available to the workers.

• You cannot call scripts directly in a parfor-loop. However, you can call functions that call scripts.

• Do not use clear inside a parfor-loop because it violates workspace transparency. For more details, see Ensure Transparency in parfor-Loops or spmd Statements.

• You can run Simulink^® models in parallel with the parsim command instead of using parfor-loops. For more information and examples of using Simulink in parallel, see Running Multiple Simulations in Simulink (Simulink).

• For GPU computations:

  • Do not use a parfor-loop if you have a single GPU and your loop iterations all use the same GPU. GPUs contain many microprocessors that can perform computations in parallel and trying to further parallelize GPU computations using a parfor-loop is unlikely to speed up your code.

  • Use a parfor-loop if you have multiple GPUs and your computations use GPU-enabled functions. For more information about using multiple GPUs in a parfor-loop, see Run MATLAB Functions on Multiple GPUs.

Extended Capabilities

C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

This function supports C/C++ code generation with the limitations:

• Treated as a for-loop in a MATLAB Function block or when used with fiaccel.

• See parfor (MATLAB Coder) in MATLAB Coder™.

For more details, see Generate Code with Parallel for-Loops (MATLAB Coder).

GPU Code Generation

Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Refer to the usage notes and limitations in the C/C++ Code Generation section. The same usage notes and limitations apply to GPU code generation.

Thread-Based Environment

Run code in the background using MATLAB® backgroundPool or accelerate code with Parallel Computing Toolbox™ ThreadPool.

The parfor function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

Version History

Introduced in R2008a

R2026a: Use consecutive decreasing integers as loop variables

Starting in R2026a, you can now use consecutive decreasing integers as loop index variables in a parfor-loop. Loop index variables that are consecutive decreasing integers allow you to simplify code where reverse iteration is needed. MATLAB continues to execute parfor-loop iterations in a nondeterministic order.

For example, use a parfor-loop to square a number for values of n between 10 and 1. The loop index variable range n has a range step value of -1.

parfor n = 10:-1:1
  out(n) = n^2;
end

R2025a: Specify pool argument to parfor function

You can now specify the parallel pool that the parfor function uses to evaluate statements. Use this syntax to evaluate parfor statements on a pool other than the pool the gcp function returns.

R2024b: Use colon-vector indexing expressions with sliced variables

Starting in R2024b, you can now use colon-vector indexing expressions to index sliced input and output variables in parfor-loops. The colon-vector indexing expression must be in the form j:k or j:k:l.

For example, to assign values only to columns 3 to 7 of the output variable out, use the vector 3:7 as a subscript when you index the sliced variable.

out = zeros(10);
parfor i = 1:10
    out(i,3:7) = rand(1,5);
end

You can use either simple broadcast variables or scalar integer constants in the colon-vector indexing expressions. Temporary variables or complicated expressions are not supported.

R2024a: Specify maximum number of thread workers in parfor-loop

Starting in R2024a, you can now specify the maximum number of workers when running parfor-loops on a thread-based parallel pool.