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

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

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

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

Вложенные for-Циклы: Требования и ограничения

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

Код слева недопустим, поскольку он пытается изменить значение вложенного 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