Документация

Вложенный parfor- Циклы

Вы не можете использовать parfor- цикл в другом parfor- цикл. Как пример, следующее вложение parfor- циклы не позволены:

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

Анализатор кода в MATLAB^® Редактор отмечает использование parfor в другом parfor- цикл:

Вы не можете вложить parfor- циклы, потому что распараллеливание может быть выполнено только на одном уровне. Поэтому выберите который цикл запуститься параллельно, и преобразовать другой цикл в for- цикл.

Рассмотрите следующие проблемы эффективности при контакте с вложенными циклами:

Можно также использовать функцию, которая использует parfor и встройте его в parfor- цикл. Распараллеливание происходит только на внешнем уровне. В следующем примере вызовите функцию MyFun.m во внешнем parfor- цикл. Внутренний parfor- цикл, встроенный в MyFun.m запуски последовательно, не параллельно.

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. Если ваш код не придерживается инструкций и ограничений, помеченных как требуется, вы получаете ошибку. 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 'local' 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