• documentation
main content

execute for-凯发k8网页登录

execute for-loop iterations in parallel on workers

syntax

parfor loopvar = initval:endval; statements; end
parfor (loopvar = initval:endval,m); statements; end
parfor (loopvar = initval:endval,opts); statements; end
parfor (loopvar = initval:endval,cluster); statements; end

description

example

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 increasing by 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 .

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

  • loop iterations are executed in parallel in a nondeterministic order. this means that you might need to modify your code to use parfor. for more help, see .

  • 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 .

  • you cannot use a parfor-loop inside another parfor-loop. for more help, see .

example

parfor (loopvar = initval:endval,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 numworkers or preferredpoolnumworkers property of the default profile. for all factors that can affect your default pool size, see . 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 preferences. for more details, see specify your parallel preferences.

parfor (loopvar = initval:endval,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 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.

example

parfor (loopvar = initval:endval,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.

examples

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 i = 1:n
    a(i) = 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 i = 1:n
    a(i) = 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 and scale up parfor-loops to cluster and cloud.

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 (i = 1:100,m)
      y(i) = i;
 end

to control the number of workers in your parallel pool, see specify your parallel preferences and parpool.

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 i = 1:n
    a(i) = 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 and .

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 .

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

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

input arguments

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 increasing integers. for more help, see .

the range of the parfor-loop variable must not exceed the supported range. for more help, see .

data types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

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, which must be of the form m:n.

data types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

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, which must be of the form m:n.

data types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

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

do not nest parfor-loops, see .

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.

parfor options, specified as a clusteroptions object. use the function to create a set of parfor options.

example: opts = parforoptions(parcluster);

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

example: cluster = parcluster('processes')

data types: parallel.cluster

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 .

  • 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 instead.

  • unless you specify a cluster 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 preferences. 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 . 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 inside a parfor loop because it violates workspace transparency. see .

  • 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 (simulink).

version history

introduced in r2008a

see also

| | | | | | | | |

topics

网站地图