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

Вложенный parfor- Петли

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

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

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

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

При работе с вложенными циклами необходимо учитывать следующие проблемы с производительностью:

Также можно использовать функцию, использующую parfor и встроить его в parfor-луп. Параллелизация происходит только на внешнем уровне. В следующем примере вызовите функцию MyFun.m внутри внешней parfor-луп. Внутреннее parfor-loop встроен в 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-loop, затем каждый работник в пуле выполняет вложенные циклы с помощью 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Пример -loop. Ускорение меньше, чем параллельное выполнение внешнего цикла, потому что у вас больше передачи данных и, следовательно, больше параллельных служебных данных. Поэтому при параллельном выполнении внутреннего цикла вычислительные преимущества по сравнению с последовательным for-луп.

Если вы хотите уменьшить параллельные издержки и ускорить вычисления, запустите внешний цикл параллельно.

Если вместо этого преобразовать внутренний цикл, то каждая итерация внешнего цикла инициирует отдельный parfor-луп. То есть преобразование внутреннего цикла создает 100 parfor-контуры. Каждый из нескольких parfor казни влекут за собой накладные расходы. Если требуется уменьшить накладные расходы параллельно, следует запустить внешний цикл параллельно, поскольку накладные расходы возникают только один раз.

Вложенный for-Контуры: требования и ограничения

Если требуется преобразовать вложенный элемент for-закольцовывание в parfor-loop, необходимо убедиться, что переменные цикла правильно классифицированы, см. раздел Устранение неполадок с переменными в parfor-Loops. Если ваш код не соответствует инструкциям и ограничениям, помеченным как обязательный, вы получите ошибку. MATLAB обнаруживает некоторые из этих ошибок во время чтения кода. Эти ошибки помечены как обязательные (статические).

В следующем примере код слева не работает, поскольку вы определяете верхний предел for-закольцовывание вызовом функции. Код справа обеспечивает обходной путь путем определения широковещательной или постоянной переменной за пределами parfor-loop:

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переменная -loop изменяется в любом месте parfor-контур, отличный от его for оператор, регион, индексированный forПеременная -loop не гарантированно доступна для каждого работника.

Код слева недопустим, поскольку пытается изменить значение вложенного forпеременная -loop j в теле петли. Код справа обеспечивает обходной путь путем назначения вложенного forпеременная -loop во временную переменную 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Переменная -loop индексирована, итерации не гарантированы как независимые.

Пример слева недопустим, поскольку он пытается индексировать вложенный forпеременная -loop 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