O `Parfor 'Loop no MATLAB é uma ferramenta poderosa para tarefas paralelizantes de intensas computacionalmente. Aqui está um detalhamento de como utilizá -lo efetivamente para otimização:

1. Compreendendo `parfor 'e suas restrições:

* O que é: `parfor '(paralelo para loop) permite executar iterações de um loop em paralelo entre vários trabalhadores em um pool Matlab (começou a usar o` parpool`). Isso pode reduzir drasticamente o tempo de execução para certos tipos de algoritmos.
* Restrições de chave: Compreender as restrições de `parfor 'é crucial para evitar erros e garantir a paralelização correta. Os principais são:
* Independência: Iterações do loop * devem * ser independentes uma da outra. Não deve haver dependências de dados entre as iterações. Uma iteração não pode ler dados escritos por outra iteração ou gravar dados que serão lidos por outra iteração. Violar essa é uma fonte comum de bugs.
* Reduções: Se você precisar combinar resultados de múltiplas iterações (por exemplo, valores de soma), use variáveis ​​de redução (veja abaixo).
* Classificação variável: `Parfor 'classifica as variáveis ​​em vários tipos:
* Variável de loop: A variável do índice de loop (por exemplo, `i` em` para i =1:n`).
* Variáveis ​​de loop Slice: Uma variável simples que não depende da própria variável de loop.
* Variável de transmissão: Uma variável definida * antes * do loop `parfor 'que é lido, mas não modificado no loop. O mesmo valor da variável é usado por todos os trabalhadores. Pode ser uma matriz ou objeto grande.
* Variável de redução: Uma variável usada para acumular resultados entre as iterações (por exemplo, valores de somando, encontrando um mínimo de matrizes concatenando). Requer manuseio especial.
* variáveis ​​temporárias/locais: Variáveis ​​criadas * dentro * o loop `parfor 'cujos valores não são necessários fora do loop. Estes são trabalhadores-privados.
* Variáveis ​​indexadas: Variáveis ​​como `a (i)` ou `b {i}` cuja dependência de 'i' depende de como 'a` ou' b 'são usadas. O classificador automático do MATLAB deve classificá -los corretamente.
* Restrições de indexação: A indexação em matrizes dentro do `Parfor 'Loop tem limitações para garantir a independência. Erros comuns envolvem tentar escrever para o mesmo índice a partir de várias iterações. O índice de matriz deve ser diretamente dependente da variável loop. A indexação aninhada como `a (b (i))` pode causar problemas.
* Chamadas de função: Chamando funções externas (especialmente aquelas não escritas no MATLAB) em `` parfor 'loops podem introduzir gargalos de serialização, negando alguns dos ganhos de desempenho. Tente evitar chamadas de função ou embrulhar o código da função, se possível.
* Consciência do espaço de trabalho: Cada trabalhador tem seu próprio espaço de trabalho. As variáveis ​​definidas no loop não estão disponíveis automaticamente no espaço de trabalho principal do MATLAB após a conclusão do loop (a menos que sejam variáveis ​​de redução ou transmitidas de volta pela fatia da variável de loop).

2. Etapas para otimizar com `parfor ':

1. Identifique seções paralelizáveis:

* Procure `loops que executam cálculos independentes em cada iteração. Estes são os principais candidatos à conversão em `parfor '.
* Analise seu código para ver se as dependências de dados podem ser removidas ou minimizadas. Às vezes, é necessária uma ligeira reorganização do algoritmo para torná -lo adequado para execução paralela.

2. converta o loop em `parfor ':

* Substitua `para` por` parfor ':`parfor I =1:n ... end`.
* Verificação automática do MATLAB: O MATLAB analisa automaticamente o loop `parfor 'para problemas em potencial. Ele emitirá avisos ou erros se detectar dependências ou outras violações das regras `parfor '. Revise cuidadosamente essas mensagens.

3. Variáveis ​​de redução de manuseio:

* Se você precisar combinar resultados das iterações, use uma variável de redução. O MATLAB fornece suporte interno para operações de redução comum:
* Resumo: `x =x + expr;`
* multiplicação: `x =x * expr;`
* Concatenação:
* `x =[x, expr];` (concatenação em colunas)
* `x =[x; expr]; `(concatenação emoção)
* Mínimo/máximo:
* `x =min (x, expr);`
* `x =max (x, expr);`
* operações lógicas:
* `x =x &&expr;` (lógico e)
* `x =x || expr; `(lógico ou)
* Concatenação da matriz de células: `x ={x {:}, expr};`
* Exemplo:

`` `Matlab
n =1000;
resultado =0; % Inicialize * antes * do loop parfor
parfor I =1:n
resultado =resultado + i^2; % De redução de soma
fim
disp (resultado);
`` `

4. Matrizes pré-alocadas:

* Se você estiver escrevendo resultados para uma matriz dentro do loop `parfor ', pré-alocem a matriz * antes * do loop. Isso impede que o Matlab redimensione repetidamente a matriz, que pode ser um grande gargalo de desempenho, especialmente em paralelo.
* Exemplo:

`` `Matlab
n =1000;
resultados =zeros (1, n); % Pré-alocada
parfor I =1:n
resultados (i) =i^2;
fim
`` `

5. Minimize a transferência de dados:

* A transferência de dados entre o cliente MATLAB e os trabalhadores pode ser uma sobrecarga significativa.
* Variáveis ​​de transmissão: Verifique se as grandes variáveis ​​de entrada que são lidas apenas dentro do loop são classificadas adequadamente como variáveis ​​de transmissão definindo -as * antes * do loop `parfor '.
* Mantenha os dados locais: Evite comunicação desnecessária de dados entre os trabalhadores e o cliente.

6. Evite chamadas de função (se possível):

* As chamadas de função dentro de um loop `parfor 'podem introduzir despesas gerais devido à serialização e comunicação. Se possível, compre o código da função diretamente no loop.
* Se você precisar usar uma função, verifique se ela foi projetada para execução paralela e minimizar a comunicação.

7. Sintonize o número de trabalhadores:

* O número ideal de trabalhadores depende do problema específico, do hardware (número de núcleos, memória) e sobrecarga da paralelização.
* Experimente o número diferente de trabalhadores usando o `Parpool 'para encontrar a configuração que produz o melhor desempenho. Começar mais trabalhadores do que você tem núcleos de CPU geralmente * não * melhora o desempenho e pode até degradá -lo devido à sobrecarga de comutação de contexto.
* Use `gcp` para verificar o pool atual e seu tamanho.

8. perfil:

* Use o Profiler do MATLAB (`perfil em`,` perfil off`, `visualizador de perfil) para identificar gargalos de desempenho dentro do loop` parfor '. Isso pode ajudá -lo a identificar áreas onde é necessária uma otimização adicional. Observe especificamente as funções chamadas e o tempo gasto em comunicações ou transferências de dados.

Exemplo:Simulação Monte Carlo

Digamos que você queira estimar o valor do PI usando uma simulação de Monte Carlo:

`` `Matlab
n =1e7; % Número de pontos aleatórios

% Versão em série
tique
interno_circle =0;
para i =1:n
x =rand ();
y =rand ();
Se x^2 + y^2 <=1
insension_circle =interno_circle + 1;
fim
fim
pi_estimate_serial =4 * interno_circle / n;
time_serial =toC;

% Versão paralela com parfor
tique
interno_circle_par =0;
parfor I =1:n
x =rand ();
y =rand ();
Se x^2 + y^2 <=1
insension_circle_par =insent_circle_par + 1;
fim
fim
PI_ESTIMATIME_PAR =4 * dentro_circle_par / n;
time_parFor =TOC;


% Versão paralela com redução
tique
Parpool; % Inicie o pool paralelo
interno_circle_reduct =0;
parfor I =1:n
x =rand ();
y =rand ();
Se x^2 + y^2 <=1
insension_circle_reduct =inside_circle_redden + 1; % De variável de redução
fim
fim
excluir (GCP ('Nocreate')); % Fechar parpool
PI_ESTIMATIME_REDUDE =4 * dentro_circle_reduct / n;
the time_reduct =toC;



Disp (['PI serial Pi:' num2str (pi_estimate_serial) 'tempo:' num2str (time_serial)]);
disp (['parfor Pi estimativa:' num2str (pi_estimate_par) 'time:' num2str (time_parfor)]);
Disp (['PARFE Reduced Pi Estimativa:' num2str (pi_estimate_reduct) 'tempo:' num2str (the time_redod)]);
`` `

Explicação:

* A versão em série é um loop padrão `para`.
* A primeira versão paralela ao Parfor será executada em paralelo, mas não fornecerá o resultado correto. O problema é que `Inside_circle_par` é modificado por vários trabalhadores ao mesmo tempo, resultando em atualizações perdidas.
* A segunda versão paralela com `parfor 'e uma variável de redução é a versão correta e otimizada. A redução `interna_circle_reduct =centinha_circle_reddend + 1;` diz ao MATLAB para acumular adequadamente os resultados de cada trabalhador sem condições de corrida.
* A `parpool` é inicializado antes de usar` parfor 'e fechado após com `excluir (gcp (' nocreate '))`. O `('Nocreate')` garante que, se um pool não existir, o MATLAB não tentará criar um (o que pode levar a erros).

Considerações -chave e solução de problemas:

* Races de dados: O erro mais comum são as corridas de dados em que várias iterações tentam gravar no mesmo local de memória simultaneamente. O Matlab tenta detectá -los, mas às vezes eles podem ser sutis.
* Depuração: Debugar `Parfor 'Loops pode ser um desafio. Considere a execução com um pequeno número de iterações primeiro para isolar problemas. Use pontos de interrupção estrategicamente. O MATLAB possui algumas ferramentas de depuração paralela, mas geralmente são menos eficazes do que a inspeção cuidadosa do código.
* Sobrecarga: A paralelização introduz sobrecarga (criando trabalhadores, transferindo dados). Se o cálculo em cada iteração for muito pequeno, a sobrecarga poderá superar os benefícios da paralelização.
* Limites de hardware : O número de trabalhadores geralmente deve ser menor ou igual ao número de núcleos físicos em sua máquina.
* versões MATLAB: O comportamento de `parfor 'e a caixa de ferramentas de computação paralela pode variar ligeiramente entre as versões do MATLAB. Consulte a documentação oficial do MATLAB para a versão específica que você está usando.

Ao seguir cuidadosamente essas diretrizes e entender as limitações do `Parfor ', você pode utilizá -lo efetivamente para otimizar seus programas MATLAB e obter melhorias significativas de desempenho para tarefas intensivas em computação. Lembre -se de sempre testar seu código completamente para garantir a correção.