1. Comprender `parfor` y sus limitaciones:
* Qué es: `parfor` (paralelo para bucle) le permite ejecutar iteraciones de un bucle en paralelo en múltiples trabajadores en un grupo de Matlab (comenzó a usar 'Parpool`). Esto puede reducir drásticamente el tiempo de ejecución para ciertos tipos de algoritmos.
* restricciones de clave: Comprender las restricciones de `parfor` es crucial para evitar errores y garantizar la paralelización correcta. Los principales son:
* Independencia: Las iteraciones del bucle * deben * ser independientes entre sí. No debe haber dependencias de datos entre iteraciones. Una iteración no puede leer datos escritos por otra iteración o escribir datos que sean lees por otra iteración. Violando esto es una fuente común de errores.
* Reducciones: Si necesita combinar los resultados de múltiples iteraciones (por ejemplo, valores de suma), use variables de reducción (ver más abajo).
* Clasificación variable: `parfor` clasifica las variables en varios tipos:
* Variable de bucle: La variable de índice de bucle (por ejemplo, `i` en` para i =1:n`).
* Variables de bucle Slice: Una variable simple que no tiene dependencia de la variable de bucle en sí.
* Variable de transmisión: Una variable definida * antes * el `parfor` bucle que se lee pero no se modifica dentro del bucle. El mismo valor de la variable es utilizado por todos los trabajadores. Puede ser una matriz o objeto grande.
* Variable de reducción: Una variable utilizada para acumular resultados a través de iteraciones (por ejemplo, sumar valores, encontrar un mínimo, concatenar matrices). Requiere un manejo especial.
* Variables temporales/locales: Variables creadas * Inside * El `parfor` bucle cuyos valores no son necesarios fuera del bucle. Estos son trabajadores-privados.
* Variables indexadas: Variables como `a (i)` o `b {i}` cuya dependencia de `i` depende de cómo se usan` a` o `b`. El clasificador automático de Matlab debe clasificarlos correctamente.
* Restricciones de indexación: La indexación en matrices dentro del `parfor` bucle tiene limitaciones para garantizar la independencia. Los errores comunes implican tratar de escribir al mismo índice de múltiples iteraciones. El índice de matriz debe depender directamente de la variable de bucle. Indexación anidada como `a (b (i))` puede causar problemas.
* Llamadas de función: Llamar a funciones externas (especialmente aquellas no escritas en MATLAB) dentro de los bucles de `parfor` puede introducir cuellos de botella de serialización, negando algunas de las ganancias de rendimiento. Intente evitar llamadas de función o en línea el código de función si es posible.
* Conciencia del espacio de trabajo: Cada trabajador tiene su propio espacio de trabajo. Las variables definidas dentro del bucle no están disponibles automáticamente en el espacio de trabajo principal de MATLAB después de que se complete el bucle (a menos que sean variables de reducción o vuelvan a pasar a través de la parte de la variable de bucle).
2. Pasos para optimizar con `parfor`:
1. Identificar secciones paralelizables:
* Busque `for` bucles que realicen cálculos independientes en cada iteración. Estos son candidatos principales para la conversión a `parfor`.
* Analice su código para ver si las dependencias de datos se pueden eliminar o minimizar. A veces, se necesita una ligera reorganización del algoritmo para que sea adecuada para la ejecución paralela.
2. Convierta el bucle a `parfor`:
* Reemplace `for` con` parfor`:`parfor i =1:n ... end`.
* Matlab's Automatic Check: MATLAB analiza automáticamente el `` parfor` bucle para posibles problemas. Emitirá advertencias o errores si detecta dependencias u otras violaciones de las reglas de "parfor`. Revise cuidadosamente estos mensajes.
3. Variables de reducción de manejo:
* Si necesita combinar los resultados de las iteraciones, use una variable de reducción. MATLAB proporciona soporte incorporado para operaciones de reducción comunes:
* suma: `x =x + expr;`
* Multiplicación: `x =x * expr;`
* Concatenación:
* `x =[x, expr];` (concatenación en cuanto a columna)
* `x =[x; Expr]; `(Concatenación en cuanto a hilera)
* mínimo/máximo:
* `x =min (x, exp);`
* `x =max (x, exp);`
* Operaciones lógicas:
* `x =x &&expr;` (lógico y)
* `x =x || expr; `(Lógico OR)
* Concatenación de matriz de células: `x ={x {:}, expr};`
* Ejemplo:
`` `Matlab
n =1000;
resultado =0; % Inicializar * antes * el bucle parfor
parfor i =1:n
resultado =resultado + i^2; % Reducción de suma
fin
disp (resultado);
`` `` ``
4. matrices prealocables:
* Si está escribiendo resultados en una matriz dentro del `parfor` bucle, prealicate la matriz * antes * del bucle. Esto evita que Matlab cambie el tamaño de la matriz repetidamente, que puede ser un cuello de botella de rendimiento importante, especialmente en paralelo.
* Ejemplo:
`` `Matlab
n =1000;
resultados =ceros (1, n); % Pre-Allocate
parfor i =1:n
resultados (i) =i^2;
fin
`` `` ``
5. Minimizar la transferencia de datos:
* La transferencia de datos entre el cliente MATLAB y los trabajadores puede ser una sobrecarga significativa.
* Variables de transmisión: Asegúrese de que las variables de entrada grandes que solo se lean dentro del bucle se clasifiquen correctamente como variables de transmisión definiéndolas * antes de * el `parfor` bucle.
* Mantenga los datos locales: Evite la comunicación innecesaria de los datos entre los trabajadores y el cliente.
6. Evite las llamadas de función (si es posible):
* Las llamadas de función dentro de un bucle `parfor` pueden introducir sobrecargas debido a la serialización y la comunicación. Si es posible, en línea el código de la función directamente en el bucle.
* Si debe usar una función, asegúrese de que esté diseñado para la ejecución paralela y minimice la comunicación.
7. Aguele el número de trabajadores:
* El número óptimo de trabajadores depende del problema específico, el hardware (número de núcleos, la memoria) y la sobrecarga de la paralelización.
* Experimente con diferentes números de trabajadores que usan `Parpool` para encontrar la configuración que produce el mejor rendimiento. Comenzar a más trabajadores de los que tiene núcleos de CPU generalmente * no * mejora el rendimiento, e incluso puede degradarlo debido a la sobrecarga de cambio de contexto.
* Use `GCP` para verificar el grupo actual y su tamaño.
8. Perfil:
* Use el Profiler de Matlab (`perfil on`,` perfil off`, `perfil viewer`) para identificar cuellos de botella de rendimiento dentro del bucle 'Parfor`. Esto puede ayudarlo a identificar áreas donde se necesita más optimización. Mire específicamente las funciones llamadas y el tiempo dedicado a comunicaciones o transferencias de datos.
Ejemplo:simulación de Monte Carlo
Supongamos que desea estimar el valor de PI usando una simulación de Monte Carlo:
`` `Matlab
n =1e7; % Número de puntos aleatorios
% De versión serie
tic
adentro_circle =0;
para i =1:n
x =rand ();
y =rand ();
Si x^2 + y^2 <=1
adentro_circle =adentro_circle + 1;
fin
fin
PI_ESTIME_SERIAL =4 * Inside_circle / n;
Time_serial =toc;
% De versión paralela con parfor
tic
adentro_circle_par =0;
parfor i =1:n
x =rand ();
y =rand ();
Si x^2 + y^2 <=1
adentro_circle_par =adentro_circle_par + 1;
fin
fin
pi_estimate_par =4 * adentro_circle_par / n;
Time_parfor =toc;
% De versión paralela con reducción
tic
parpool; % Comienza la piscina paralela
adentro_circle_reduced =0;
parfor i =1:n
x =rand ();
y =rand ();
Si x^2 + y^2 <=1
adentro_circle_reduced =adentro_circle_reduced + 1; % Variable de reducción
fin
fin
eliminar (GCP ('nocreate')); % Cerrar Parpool
PI_ESTIME_REDUCED =4 * Inside_circle_reduced / n;
TIME_REDUCED =TOC;
Disp (['Estimación de PI serial:' num2str (PI_ESTIME_SERIAL) 'TIEMPO:' NUM2STR (TIME_SERIAL)]);
disp (['parfor pi estimación:' num2str (pi_estimate_par) 'tiempo:' num2str (time_parfor)]);
Disp (['parfor estimación de Pi reducida:' num2str (pi_estimate_reduced) 'tiempo:' num2str (time_reduced)]);
`` `` ``
Explicación:
* La versión serie es un bucle estándar 'For`.
* La primera versión paralela con PARFOR se ejecutará en paralelo, pero no dará el resultado correcto. El problema es que `adentro_circle_par` es modificado por varios trabajadores a la vez, lo que resulta en actualizaciones perdidas.
* La segunda versión paralela con `parfor` y una variable de reducción es la versión correcta y optimizada. La reducción `adentro_circle_reduced =adentro_circle_reduced + 1;` le dice a MATLAB que acumule correctamente los resultados de cada trabajador sin condiciones de carrera.
* A `parpool` se inicializa antes de usar` parfor`, y se cierra después con 'delete (GCP (' nocreate ')) `. El `('' nocree ')` asegura que si un grupo no existe, Matlab no intentará crear uno (lo que puede conducir a errores).
Consideraciones clave y solución de problemas:
* carreras de datos: El error más común son las carreras de datos donde múltiples iteraciones intentan escribir en la misma ubicación de memoria simultáneamente. Matlab intenta detectarlos, pero a veces pueden ser sutiles.
* Depuración: La depuración de `parfor` loops puede ser un desafío. Considere correr con un pequeño número de iteraciones primero para aislar problemas. Use puntos de interrupción estratégicamente. MATLAB tiene algunas herramientas de depuración paralela, pero a menudo son menos efectivas que la inspección de código cuidadosa.
* Overhead: La paralelización introduce gastos generales (creando trabajadores, transferir datos). Si el cálculo dentro de cada iteración es muy pequeño, la sobrecarga podría superar los beneficios de la paralelización.
* Límites de hardware: El número de trabajadores generalmente debe ser menor o igual al número de núcleos físicos en su máquina.
* Versiones de Matlab: El comportamiento de `parfor` y la caja de herramientas de computación paralela puede variar ligeramente entre las versiones de MATLAB. Consulte la documentación oficial de MATLAB para la versión específica que está utilizando.
Al seguir cuidadosamente estas pautas y comprender las limitaciones de 'Parfor`, puede utilizarlo de manera efectiva para optimizar sus programas MATLAB y lograr mejoras significativas de rendimiento para tareas computacionalmente intensivas. Recuerde probar siempre su código a fondo para garantizar la corrección.