嵌套 parfor 循环

不能在另一个 parfor 循环内使用 parfor 循环。例如，不允许以下 parfor 循环嵌套：

parfor i = 1:10
    parfor j = 1:5
        ...
    end
end

MATLAB^® 编辑器中的代码分析器标记了另一个 parfor 循环内 parfor 的使用：

您不能嵌套 parfor 循环，因为并行化只能在一个级别执行。因此，选择要并行运行的循环，并将另一个循环转换为 for 循环。

处理嵌套循环时请考虑以下性能问题：

您还可以使用使用 parfor 的函数并将其嵌入 parfor 循环中。并行化仅发生在外层。在下面的示例中，在外部 parfor 循环内调用函数 MyFun.m。MyFun.m 中嵌入的内部 parfor 循环按顺序运行，而不是并行。

parfor i = 1:10
    MyFun(i)
end

function MyFun(i)
    parfor j = 1:5
        ...
    end
end

将嵌套的 for 循环转换为 parfor 循环

嵌套循环的典型用法是使用单循环变量来索引一个维度，并使用嵌套循环变量来索引另一个维度来遍历数组。基本形式为：

X = zeros(n,m);
for a = 1:n
    for b = 1:m
        X(a,b) = fun(a,b)
    end
end

下面的代码展示了一个简单的示例。使用 tic 和 toc 来测量所需的计算时间。

A = 100;
tic
for i = 1:100
    for j = 1:100
        a(i,j) = max(abs(eig(rand(A))));
    end
end
toc

Elapsed time is 49.376732 seconds.

您可以并行化任一嵌套循环，但不能并行运行两者。原因是并行池中的工作单元无法启动或访问进一步的并行池。

如果将 i 计数的循环转换为 parfor 循环，则池中的每个工作单元都会使用 j 循环计数器执行嵌套循环。j 循环本身不能在每个工作单元上作为 parfor 运行。

由于并行处理会产生开销，因此您必须谨慎选择是否要将内部或外部 for 循环转换为 parfor 循环。下面的示例显示了如何测量并行开销。

首先仅将外部 for 循环转换为 parfor 循环。使用 tic 和 toc 来测量所需的计算时间。使用 ticBytes 和 tocBytes 来测量在并行池中从工作单元传输的数据量。

运行新代码，然后再次运行。第一次运行比后续运行慢，因为并行池需要一些时间来启动并让代码可供工作单元使用。

A = 100;
tic
ticBytes(gcp);
parfor i = 1:100
    for j = 1:100
        a(i,j) = max(abs(eig(rand(A))));
    end
end
tocBytes(gcp)
toc

             BytesSentToWorkers    BytesReceivedFromWorkers
             __________________    ________________________

    1             32984                 24512              
    2             33784                 25312              
    3             33784                 25312              
    4             34584                 26112              
    Total    1.3514e+05            1.0125e+05              

Elapsed time is 14.130674 seconds.

接下来仅将内部循环转换为 parfor 循环。像前一种情况一样测量所需时间和传输的数据。

A = 100;
tic
ticBytes(gcp);
for i = 1:100
    parfor j = 1:100
        a(i,j) = max(abs(eig(rand(A))));
    end
end
tocBytes(gcp)
toc

             BytesSentToWorkers    BytesReceivedFromWorkers
             __________________    ________________________

    1        1.3496e+06             5.487e+05              
    2        1.3496e+06            5.4858e+05              
    3        1.3677e+06            5.6034e+05              
    4        1.3476e+06            5.4717e+05              
    Total    5.4144e+06            2.2048e+06              

Elapsed time is 48.631737 seconds.

如果将内循环转换为 parfor 循环，则传输的时间和数据量都会比并行外循环大得多。在这种情况下，经过的时间几乎与嵌套的 for 循环示例中的时间相同。与并行运行外循环相比，加速比更小，因为有更多的数据传输，因此有更多的并行开销。因此，如果并行执行内部循环，与运行串行 for 循环相比，不会获得任何计算优势。

如果您想减少并行开销并加快计算速度，请并行运行外循环。

如果您转换内部循环，则外部循环的每次迭代都会启动单独的 parfor 循环。也就是说，内循环转换创建了 100 个 parfor 循环。每次 parfor 执行都会产生开销。如果您想减少并行开销，您应该并行运行外循环，因为开销只发生一次。

嵌套的 for 循环：要求和限制

如果您想将嵌套的 for 循环转换为 parfor 循环，则必须确保循环变量被正确分类，请参阅 排除 parfor 循环中的变量故障。如果您的代码不遵守标记为 Required 的准则和限制，您将收到错误。MATLAB 在读取代码时会捕获其中一些错误。这些错误被标记为必需（静态）。

在下面的示例中，左边的代码不起作用，因为您通过函数调用定义了 for 循环的上限。右侧的代码提供了一种解决方法，首先在 parfor 循环外定义一个广播或常量变量：

A = zeros(100, 200);
parfor i = 1:size(A, 1)
    for j = 1:size(A, 2)
        A(i, j) = i + j;
    end
end

A = zeros(100, 200);
n = size(A, 2);
parfor i = 1:size(A,1)
    for j = 1:n
        A(i, j) = i + j;
    end
end

必须遵守此限制。如果嵌套的 for 循环变量在 parfor 循环中的任何地方（除其 for 语句之外）发生更改，则不能保证 for 循环变量索引的区域在每个工作单元上都可用。

左边的代码无效，因为它试图修改循环主体中嵌套的 for 循环变量 j 值。右侧的代码提供了一种解决方法，即将嵌套的 for 循环变量分配给临时变量 t，然后更新 t。

A = zeros(10); 
parfor i = 1:10 
    for j = 1:10 
        A(i, j) = 1; 
        j = j+1; 
    end
end

A = zeros(10); 
parfor i = 1:10 
    for j = 1:10 
        A(i, j) = 1;  
        t = j;
        t = t + 1;
    end
end

必须遵守此限制。如果对嵌套的 for 循环变量进行索引，则不能保证迭代是独立的。

左边的示例是无效的，因为它试图索引嵌套的 for 循环变量 j。右边的示例删除了这个索引。

A = zeros(10); 
parfor i = 1:10 
    for j = 1:10 
        j(1);
    end
end

A = zeros(10); 
parfor i = 1:10 
    for j = 1:10 
        j;
    end
end

例如，以下左侧的代码不起作用，但右侧的代码起作用：

A = zeros(4, 11);
parfor i = 1:4
    for j = 1:10
        A(i, j + 1) = i + j;
    end
end

A = zeros(4, 11);
parfor i = 1:4
    for j = 2:11
        A(i, j) = i + j - 1;
    end
end

在下面的示例中，左边的代码不起作用，因为 A 在嵌套的 for 循环内被切片和索引。右边的代码能够正常工作，因为在嵌套循环之外将 v 分配给了 A：

A = zeros(4, 10);
parfor i = 1:4
    for j = 1:10
        A(i, j) = i + j;
    end
    disp(A(i, j))
end

A = zeros(4, 10);
parfor i = 1:4
    v = zeros(1, 10);
    for j = 1:10
        v(j) = i + j;
    end
    disp(v(j))
    A(i, :) = v;
end

parfor 循环限制

function A = pfeg
    function out = nfcn(in)
        out = 1 + in;
    end
    
    fcn = @nfcn;
    
    parfor idx = 1:10
        A(idx) = feval(fcn, idx);
    end
end

>> pfeg
Starting parallel pool (parpool) using the 'Processes' profile ... connected to 4 workers.

ans =

     2     3     4     5     6     7     8     9    10    11

x = 1:10;
parfor i=1:10
    temp = x(i);
    anonymousFunction = @() 2*temp;
    x(i) = anonymousFunction() + i;
end
disp(x);

a = 'a';
myFunction(a)

function X = myFunction(a)
    name = inputname(1);
    
    parfor i=1:2
        X(i).(name) = i;
    end
end

myFunction('a','b')

function X = myFunction(a,b)
    nin = nargin;
    parfor i=1:2
        X(i) = i*nin;
    end
end