Programación de Memoria Compartida

Presentación del tema: "Programación de Memoria Compartida"— Transcripción de la presentación:

1 Programación de Memoria Compartida
openMP

2 El Modelo de Memoria Compartida
Los procesadores interactuan uno con otro mediante variables compartidas. OpenMP es el estandar para programación de memoria compartida.

3 ¿Que es openMP? openMP es una especificación para una implementación portable de paralelismo en FORTRAN y C/C++. La especificación provee directivos de compilador, rutinas de biblioteca que se pueden usar para controlar paralelismo.

4 Paralelismo Fork/Join
Inicialmente solamente el hilo maestro está activo El hilo maestro ejecuta el código secuencial Fork: El hilo maestro crea hilos adicionales para ejecutar el código paralelo Join: Al finalizar de código paralelo, los hilos creados mueren o se suspendien

5 Ejemplo #include <omp.h> #include <stdio.h>
int main (int argc, char *argv[]) { #pragma omp parallel printf(“Hello world\n”); return 0; }

6 El Modelo de Memoria Compartida vs. el Modelo que Pasa Mensajes (#1)
El número de hilos es 1 al principio y al final y cambia dinámicamente durante de la ejecutación del programa El Modelo que pasa mensajes Todos los procesos estan activos durante de la ejecutacion del programa.

7 Paralelización Incremental
Un programa secuencial es un caso especial de un programa de memoria compartida Paralelización incremental es el procesos de convertir un programa secuencial a un programa paralelo poco a poco

8 Un Bucle for Paralelo Las iteraciones de un bucle for se pueden ejecutar en paralelo si ninguna iteración depende de otra anterior. Ejemplos: Las iteraciones de - for (i=first;i<size;i += prime; marked[i]=1) se pueden ejecutar en paralelo, pero -for (i=1;i<=n;i++) suma += suma + v[i] no

9 Pragmas Una pragma en C o C++ es un directivo al compilador.
La sintaxis es #pragma omp <el resto de la pragma> Ejemplo: #pragma omp parallel for es una directriz que dice al compilador que trate a paralelizar el bucle for que sigue

10 La Pragma for Paralelo #pragma omp parallel for
for (i = 0; i < N; i++) a[i] = b[i] + c[i]; El compilador tiene que verificar que cuando se ejecuta, habrá disponible la información necesaria para llevar a cabo las iteraciones

11 La sintaxis de la pragma for paralelo

12 El Contexto de Ejecutación
Todo hilo tiene un contexto de ejecutación, que consiste del espacio de direcciones que el hilo puede aceder El contexto de ejecutación incluye variables estáticas, estructuras dinámicamente asignadas, y variables en el “run-time stack”

13 “Variables Compartidas y Variables Privadas
Una variable compartida tiene la misma dirección en el contexto de ejecutación de cada hilo. Una variable privada tiene una dirección distinta en el contexto de ejecutación de cada hilo. Un hilo no puede aceder las variables privadas de otro hilo.

14 Función omp_set_num_threads
Se usa para asignar el número de hilos a ser activos en secciones paralelas del código Se puede llamar en varios puntos del programa void omp_set_num_threads (int t)

15 omp_get_thread_num()
Todo hilo tiene una identificación que es el número del hilo omp_get_thread_num() devuelve el número del hilo

16 Función omp_get_num_procs
Devuelve el número de procesadores fisicos que están dispondible para el uso del programa paralelo int omp_get_num_procs (void)

17 Hello World #include <omp.h> #include <stdio.h>
int main (int argc, char *argv[]) { int p,th_id; p=omp_get_num_procs(); omp_set_num_threads(p); #pragma omp parallel private(th_id); { th_id = omp_get_thread_num(); printf("Hello World from thread %d\n", th_id); } return 0;

18 Pragmas - REPASO Una pragma en C o C++ es un directivo al compilador.
La sintaxis es #pragma omp <el resto de la pragma> Ejemplo: #pragma omp parallel for es una directriz que dice al compilador que trate a paralelizar el bucle for que sigue

19 La sintaxis de la pragma for paralelo

20 Ejemplo 1 #pragma omp parallel for for (i=0;i<(int) sqrt(x);i++)
{ a[i] = 2.3*i; if (i < 10) b[i]=a[i]; }

21 Ejemplo 2 flag = 0; for (i=0;(i<n) & (!flag);i++){ a[i] = 2.3*i;
if (a[i] < b[i]) flag = 1); } No se puede paralelizar el bucle pues no no satisface el requisito de sintaxis.

22 Ejemplo 3 for (i=0;i<n;i++) { a[i] = foo(i);
if (a[i] < b[i]) break; } No se puede paralelizar un bucle cuyo cuerpo contiene break, return, o exit.

23 Variables privadas y compartidas
#pragma omp parallel <clausula> bloque La clausula puede ser private (lista de variables) shared (lista de variables) y otras.

24 Variables privadas y compartidas(2)
Una variable compartida tiene la misma dirección en el contexto de ejecutación de cada hilo Una variable privada tiene una dirección distinta en el contexto de ejecutación de cada hilo Cada variable en el cuerpo de un bucle paralelo, excepto la variable de iteración, que no se especifica como privada es compartida.

25 Ejemplo //Despues de ejecutar el siguiente código, debe ser cierto que a[i] <= b[i] para todo i #pragma omp parallel for for (i=0;i<n;i++) if (a[i] > b[i]) {temp=a[i];a[i]=b[i]; b[i]=temp;} ¿Funciona este código?

26 Ejemplo(continuado) No funciona correctamente, pues la variable temp debe ser privada //El código correcto #pragma omp parallel for private(temp) for (i=0;i<n;i++) if (a[i] > b[i]) {temp=a[i];a[i]=b[i]; b[i]=temp;}

27 Grafos con Pesos Un grafo dirigido en la cual hay asociado con cada arista un número positivo (el “peso”) se llama un grafo dirigido con pesos. El largo de una trayectoria de un vértice u a otro vértice v es la suma de los pesos de las aristas que componen la trayectoria.

28 El Problema de Todos Pares Distancias mas Cortas
Dado un grafo dirigido con pesos, ¿cuales son las trayectorias de largos mínimos (es decir “distancias mas cortas”) entre todos los pares de vértices?

29 La Matríz de Adyacencias
Representar un grafo dirigido con pesos G con n vértices por una matríz AG como sigue: Si 1,2, … ,n son los vértices, entonces el elemento en la fila #i y la columna #j es 0 si i=j, es ∞ (un número mas grande que cualquier peso) si no hay arista de I a j, y es el peso de la arista de i a j si tal arista existe. Llamemos AG la matríz de adyacencias.

30 El Algoritmo de Floyd for (k= 0;k<n;k++) for (i =0;i< n;i++)
for (j= 0;j<n;j++) a[i,j]  min (a[i,j], a[i,k] + a[k,j])

31 Ejemplo 6 3 ∞ 4 1 5 2 A B C D E 4 A B 3 6 1 3 C 5 1 D 2 E Matríz de Adyacencias

32 ¿Como se puede paralelizar el Algoritmo de Floyd para openMP?
for (k= 0;k<n;k++) for (i =0;i< n;i++) for (j= 0;j<n;j++) a[i,j]  min (a[i,j], a[i,k] + a[k,j]) El bucle exterior no se puede paralelizar, pues las itereraciones no son independientes. Cada uno de los otros bucles es paralelizable.

33 ¿Cual es el mejor? ¿Paralelizar el bucle en el medio o el mas interior?
Mejor paralelizar el bucle en el medio para Evitar el costo de multiplos fork-join.

34 ¿Como se puede paralelizar el siguiente código?
x[0] = complex_function(); for (i=0;j<n;i++) { for (j=1;j<4;j++) x[j]=g(i,x[j-1]); answer[i] = x[1] – x[3];}

35 Como se puede paralelizar el siguiente código:
x[0] = complex_function(); for (i=0;j<n;i++) { for (j=1;j<4;j++) x[j]=g(i,x[j-1]); answer[i] = x[1] – x[3];} Se puede hacer el bucle exterior paralelo si hacemos j y x privadas. Sin embargo, x[0] se necesita en la primera iteración del bucle interior.

36 firstprivate Se podría mover la inicialización de x[0] a dentro del bucle anterior, pero es caro. Mejor usar la cláusula firstprivate. x[0] = complex_function(); #pragma omp parallel for private[j] firstprivate(x) for (i-0;j<n;i++) { for (j=1;j<4;j++) x[j]=g(i,x[j-1]); answer[i] = x[1] – x[3];}

37 firstprivate Se podría mover la inicialización de x[0] a dentro del bucle anterior, pero es caro. Mejor usar la cláusula firstprivate. x[0] = complex_function(); #pragma omp parallel for private[j] firstprivate(x) for (i-0;j<n;i++) { for (j=1;j<4;j++) x[j]=g(i,x[j-1]); answer[i] = x[1] – x[3];}

38 firstprivate (cont) Se usa para crear una variable privada que tiene su valor inicial igual al valor de la variable controlada por el hilo maestro cuando se entra el bucle. Si un hilo cambia el valor de una variable en alguna iteración, entonces este valor será el valor de la variable en iteraciones subsecuentes

39 lastprivate La secuencialmente última iteración es la última iteración que se lleva a cabo cuando el bucle se ejecuta secuencialmente La cláusula lastprivate se usa para copiar el valor privado del hilo que ejecutó la secuencialmente última iteración a la copia del hilo maestro

40 Ejemplo for (i=0;i<n;i++){ x[0] = 1.0; for (j=1;j<4;j++)
x[j] = x[j-1] * (i+1); sum_of_powers[i] = x[0]+x[1]+x[2]+x[3]; } n_cubed = x[3]; Si se paraleliza el bucle exterior, no se puede predecir el valor de x[3]!

41 Una solución para que x[3]=n3
#pragma omp parallel for private(j) lastprivate(x) for (i=0;i<n;i++){ x[0] = 1.0; for (j=1;j<4;j++) x[j] = x[j-1] * (i+1); sum_of_powers[i] = x[0]+x[1]+x[2]+x[3]; } n_cubed = x[3];

42 La Regla Rectangulo para Computar 
 = ∫01 4/(1+x2) dx La Regla de Rectangulo consiste de estimar el area debajo de la curva y=4/(1+x2) entre x=0 y x=1 mediante areas de rectangulos

43 Código para aproximar 
double area, pi, x; int i, n; ... area = 0.0; for (i = 0; i < n; i++) { x += (i+0.5)/n; area += 4.0/(1.0 + x*x); } pi = area / n;

44 ¿Como se puede paralelizar el código para aproximar a ?
for (i = 0; i < n; i++) { x += (i+0.5)/n; area += 4.0/(1.0 + x*x); } Si dos hilos, digamos A y B están ejecutando dos iteraciones, entonces B podria intentar a poner area al dia mientras que A está haciendo lo mismo, B podría usar el valor de area antes de que A ha terminado a poner su nuevo valor Esto se llama una “condición de carrera”

45 La Pragma critical #pragma omp critical bloque de código
garantiza que solamente un hilo ejecuta el bloque a la vez

46 Código correcto, pero no eficiente
double area, pi, x; int i, n; ... area = 0.0; #pragma omp parallel for private(x) for (i = 0; i < n; i++) { x += (i+0.5)/n; #pragma omp critical area += 4.0/(1.0 + x*x); } pi = area / n;

47 Ineficiente porque … Poner area al dia a dentro de una sección crítica no es eficiente ya que Solamente un hilo puede ejecutar la asignación a la vez, es decir, es código secuencial. El tiempo para ejecutarla puede ser una parte significativa del bucle

48 Reducciones Se puede añadir una cláusula de reducción a una pragma parallel for Hay que especificar la operación y la variable OpenMP lleva cuenta de los resultados parciales y los combina despues de ejecutar el bucle

49 La Cláusula reduction La sintaxis es: reduction (<op> :<variable>) Operadores + Suma * Producto & Bitwise and | Bitwise or ^ Bitwise exclusive or && Logical and || Logical or

50 El Código  con la Cláusula reduction
double area, pi, x; int i, n; ... area = 0.0; #pragma omp parallel for \ private(x) reduction(+:area) for (i = 0; i < n; i++) { x = (i + 0.5)/n; area += 4.0/(1.0 + x*x); } pi = area / n;

51 Compilar y Ejecutar en mathcluster
Para compilar: cc –fopenmp prog.c –o prog Para ejecutar: ./prog

52 Para medir tiempo en OpenMP
Ejemplo: double empezar,terminar; empezar=omp_get_wtime( ); … algun código terminar=omp_get_wtime(); printf(“TIEMPO=%lf\n”,empezar-terminar) El resultado es en segundos.

53 Resultados de Ejecutar pi.c en mathcluster
hilos tiempo speedup

54 La multiplicación matríz-vector
Para computar y = Ax = [aij]x donde A es m X n y x es n X 1: for (i=0;i<m;i++){ y[i] = 0; for (j=0;j<n;j++) y[i] = y[i] + A[i][j] * x[j]; } f

55 Paralelizar el bucle exterior
#pragma omp parallel for private(j) for (i=0;i<m;i++){ y[i] = 0; for (j=0;j<n;j++) y[i] = y[i] + A[i][j] * x[j]; } f

56 Paralelizar el bucle interior
for (i=0;i<m;i++){ tmp = 0.0; #pragma omp parallel for reduction(+:tmp) for (j=0;j<n;j++) tmp = tmp + A[i][j] * x[j]; y[i]=tmp; } f

57 Matrices Esparcidas Una matríz es esparcida si la mayoria de sus elementos son iguales a cero. Los algoritmos ordinarios aplicados a matrices esparicidas, no son lo mas eficientes pues ocupan mucho espacio y gastan operaciones de mas.

58 “Compressed Sparse Row Format” (CSR)
El format de fila esparcida comprimida matríz A mXn de una consiste de: (1) Un arreglo, vals, de los elementos no cero. (2) Un arreglo, cols, de los números de columna en las cuales cada elemento de vals aparece. (3) Un arreglo, filas, donde filas[i] es el indice en el arreglo vals del primer elemento no cero de la fila i, i =0,1, ... , m-1, y filas[m] = nz, la cantidad de elementos no cero de A.

59 Ejemplo 1 Determinar el formato CSR (o sea los arreglos vals, cols y filas) para la siguiente matriz:

60 Ejemplo 2 Determinar la matríz cuya representación se da por
vals: cols: filas:

61 La multiplicación de una matriz nXn en el formato CSR por un vector
for(i=0;i<n;i++) { y[i]=0; for(k=filas[i];k<filas[i+1];k++) {j=cols[k]; y[i] += vals[k]*x[j]; }

62 Paralelizar el bucle exterior
#pragma omp parallel for private(j,k) for(i=0;i<n;i++) { y[i]=0; for(k=filas[i];k<filas[i+1];k++) {j=cols[k]; y[i] += vals[k]*x[j]; }

63 Repaso #pragma omp <algo mas>:
#pragma omp parallel <clausula> #pragma omp parallel for <clausula> #pragma omp critical La clausula puede ser: private<lista de variables> shared<private<lista de variables> firstprivate<lista de variables> lastprivate<lista de variables> reducion<,op>:<variable>

64 Repaso 2 Funciones OpenMP: void omp_set_num_threads(int t)
int omp_get_num_threads() int omp_get_thread_num() Int omp_get_num_procs()

65 Otro uso del la Pragma parallel
Ejemplo: ¿Como se puede optimizar lo siguiente? for (i = 0; i < m; i++) { low = a[i]; high = b[i]; if (low > high) { printf ("Exiting (%d)\n", i); break; } for (j = low; j < high; j++) c[j] = (c[j] - a[i])/b[i]; No se puede paralelizar el bucle exterior pues contiene break.

66 Primer Intento #pragma omp parallel private(i,j)
for (i = 0; i < m; i++) { low = a[i]; high = b[i]; if (low > high) { printf ("Exiting (%d)\n", i); break; } for (j = low; j < high; j++) c[j] = (c[j] - a[i])/b[i]; Ahora, cada hilo va a ejectar todas las iteraciones del bucle interior. Nos gustaria que los hilos los compartan.

67 Segundo Intento #pragma omp parallel private(i,j)
for (i = 0; i < m; i++) { low = a[i]; high = b[i]; if (low > high) { printf ("Exiting (%d)\n", i); break; } #pragma omp for for (j = low; j < high; j++) c[j] = (c[j] - a[i])/b[i];

68 La pragma for #pragma omp for <bucle for>
dentro de una región paralela dice al compilador particionar las iteraciones entre los hilos

69 Segundo Intento Ahora hay solamente un problema: Cada hilo va a escribir un mensaje “Exiting..” #pragma omp parallel private(i,j) for (i = 0; i < m; i++) { low = a[i]; high = b[i]; if (low > high) { printf ("Exiting (%d)\n", i); break; } #pragma omp for for (j = low; j < high; j++) c[j] = (c[j] - a[i])/b[i];

70 Tercer Intento #pragma omp parallel private(i,j)
for (i = 0; i < m; i++) { low = a[i]; high = b[i]; if (low > high) { #prama omp single printf ("Exiting (%d)\n", i); break; } #pragma omp for for (j = low; j < high; j++) c[j] = (c[j] - a[i])/b[i];

71 La Pragma single #pragma omp single <bloque de código>
dice al compilar que solamente un solo hilo deberia ejecutar el bloque que sigue.

72 Cuarto Intento Finalmente se puede remover la barrera al finalizar del segundo bucle #pragma omp parallel private(i,j,low,high) for (i = 0; i < m; i++) { low = a[i]; high = b[i]; if (low > high) { #prama omp single printf ("Exiting (%d)\n", i); break; } #pragma omp for nowait for (j = low; j < high; j++) c[j] = (c[j] - a[i])/b[i];}

73 La cláusula nowait Cuando se añade a un bucle for paralelo, elimina la barrera al finalizar de un bucle.

74 Dos Tipos de Paralelismo de Data
La paralelización del bucles for Ejemplos: El computo de π, el algoritmo de Floyd Paralelismo de data mas general – la creación de una región paralela mediante la pragma omp parallel Ejemplos: hello, satisfacer un circuito

75 Paralelismo Funcional
Hasta ahora hemos considerado paralelismo de data nada mas OpenMP nos permite asignar hilos distintos a partes distintas del código (paralelismo funcional)

76 Ejemplo de Paralelismo Funcional
v = alpha(); w = beta(); x = gamma(v, w); y = delta(); printf ("%6.2f\n", epsilon(x,y)); Se puede ejecutar alpha, beta, and delta en paralelo.

77 La pragma parallel sections
Precede un bloque de k bloques de código que se puede ejecutar en paralelo por k hilos La sintaxis: #pragma omp parallel sections

78 La pragma section Precede cada bloque de código dentro del bloque grande Se puede omitir para el primer bloque después de la pragma parallel sections La sintaxis: #pragma omp section

79 Ejemplo de parallel sections
#pragma omp parallel sections { #pragma omp section /* Opcional */ v = alpha(); #pragma omp section w = beta(); y = delta(); } x = gamma(v, w); printf ("%6.2f\n", epsilon(x,y));

80 Otra Posibilidad Ejecutar alpha y beta en paralelo. Ejecutar gama y
delta en paralelo.

81 La otra posibilidad - usar dos secciones paralelas
#pragma omp parallel sections { #pragma omp section v=alpha(); #pragama omp section w=beta(); } y=delta(); x=gamma(v,w); printf(“%6.2f\n”,epsilon(x,y);

82 Uso de la pragma sections
#pragma omp parallel { #pragma omp sections #pragma omp section v = alpha(); w = beta(); } x = gamma(v, w); y = delta(); printf ("%6.2f\n", epsilon(x,y));

83 La pragma sections Aparece a dentro de un bloque paralelo de código
Tiene el mismo significado como la pragma parallel sections Varias pragmas sections dentro de un bloque paralelo podría reducir los gastos de fork/join

84 Ejemplo de secciones #pragma omp parallel sections {
#pragma omp section for(i=0;i<n;i++) c[i]=a[i]+b[i]; for(j=0;j<n;j++) d[j]=e[j]+f[j]; } Los dos bucles se ejecutan en paralelo, pero cada uno se ejecuta secuencialmente.

85 Una posibilidad mejor #pragma omp parallel { #pragma omp for
for(i=0;i<n;i++) c[i]=a[i]+b[i]; for(j=0;j<n;j++) d[j]=e[j]+f[j]; }

86 o simplemente #pragma parallel for for(i=0;i<n;i++) {
c[i]=a[i]+b[i]; d[i]=e[i]+f[i]; }

87 Mejormiento en el Rendimiento de Bucles Paralelos
(1) Invertiendo bucles (2) Ejecutando los bucles condicionalmente (3) Mediante el uso de schedule

88 (1) Invertiendo los Bucles
Muchos fork/joins puede empeorar el rendimiento Invertir bucles puede mejorar el rendimiento si Hay paralelismo en el bucle interio El bucle exterior se puede paralelizar después de la inversión. La inversión no disminuye la razón de “cache hits”

89 Ejemplo-Invertir bucles
for(i=1;i<m;i++) for(j=0;j<n;j++) a[i][j]=2*a[i-1][j] El bucle exterior no se puede paralelizar pues contiene dependencias. El bucle interior se puede paralelizar pues no contiene dependencias.

90 Paralelizar el bucle interior
for(i=1;i<m;i++) #pragma omp parallel for for(j=0;j<n;j++) a[i][j]=2*a[i-1][j] Ahora, hay m fork-joins.

91 Invertir los bucles #pragma omp parallel for private(i)
for(j=0;j<n;j++) for(i=1;i<m;i++) a[i][j]=2*a[i-1][j] Comparando tiempos en mathcluster con 4 hilos para este segmento de código con el anterior con m=n=100, este segment era 4 veces mas rápido a pesar de los aparente “cache misses”

92 Memoria Cache Memoria rápida que reduce el tiempo necesario para que el CPU busque un dato Almanace copias de los datos de las localizaciones de la memoria principal mas usadas. Un “cache hit” refiere a un intento exitoso de buscar un dato en el cache. Un “cache miss” refiere a un intento de buscar un dato en el cache que no está

93 Ejemplo de cache miss #pragma parallel for private (i)
for (j=0;j<100;j++) for (i=0;i<100;i++) a[i][j]=1; En mathcluster con 4 hilos, este segmento es 5 veces mas lento que el segmento que resulta invertiendo los bucles. En general, habran “cache misses” cuando el bucle exterior acede a los columnas pues C almanace los arreglos bidimensionales fila por fila.

94 (2) Ejecutando Bucles Condicionalmente
Si un bucle tiene pocas iteraciones, los gastos generales podría ser mayor que la economia de ejecutación paralela. La cláusula if instruye al compilador determinar si el bucle se debe ejecutar en paralelo. #pragma omp parallel for if(n > 5000)

95 (3) Usando la cláusula schedule
Las iteraciones de un bucles pueden variar mucho en duración. Se puede usar una cláusula schedule para indicar como las iteraciones se asignan a los hilos.

96 Dos tipos de schedule estática y dinámica
Schedule estática: todas las iteraciones se asignan a los hilos antes de ejecutarla Schedule dinámica: solamente algunas iteraciones se asignan al prinicipio de la ejecutación de un bucle. Las otras iteraciones se asignan a hilos que terminan sus iteraciones asignadas.

97 Estático vs. Dinámico Static scheduling:
-Gastos generales menores (“low overhead”) Dynamic scheduling Gastos generales mayores Puede reduce el imbalance de trabajo

98 Chunks Un chunk es un conjunto contiguo de iteraciones que se asignan a hilos Aumentar el tamaño de un chunk reduce los gastos generales y podría aumentar el “cache hit rate” Disminuir el tamaño de chunk permite uno a obtener un balance mas preciso del trabajo

99 La Cláusula schedule La sintaxis: schedule (<tipo>[,<chunk> ]) Se requiere tipo, pero el tamaño del chunk es opcional El tipo puede ser static dynamic guided runtime

100 Opciones para schedule
schedule(static): asignar bloques de aproximadamente n/t iteraciones contiguas a cada hilo schedule(static,C): asignar chunks de tamaño C schedule(dynamic): asignar dinámicamente iteracones una por una. schedule(dynamic,C): asignar dinámicamente C iteraciones a la vez

101 Opciones para schedule (cont)
schedule(guided, C): asignar chunks dinámicamente. Los tamaños de los chunks decrecen dependiendo de la implementación. C es el tamaño mínimo. schedule(guided): Lo mismo excepto 1 es el tamaño mínimo. schedule(runtime): el tipo de schedule se escoge al tiempo de ejecutación basado en el valor de la variable omp_schedule.

102 Ejemplo #pragma omp parallel for schedule(dynamic,1) private(j)
for (i=1;i<n;i++) for (j=0;j<i;j++) b[j+n*i]=a[j+n*i]+a[j+n*(i-1)]

103 Ejemplo #pragma omp parallel for for (i=1;i<n;i++)
for (j=0;j<i;j++) b[j+n*i]=a[j+n*i]+a[j+n*(i-1)] Sufre de imbalance (“load imbalance”). El largo del bucle interior varia de 1 iteración (cuando i=1) hasta n -1 iteraciones (cuando i=n-1).

104 Ejemplo-Balancear con schedule
#pragma omp parallel for schedule(dynamic 1) private(j) for (i=1;i<n;i++) for (j=0;j<i;j++) b[j+n*i]=a[j+n*i]+a[j+n*(i-1)] El tiempo para este segmento (para n=200) era como 25% mas rápido en mathcluster.