operaciones con matrices densas
DESCRIPTION
Operaciones con Matrices Densas. Glen D. Rodríguez R. Algoritmos Paralelos Basado en material de J. Demmel. Revisión de BLAS. Bloques básicos de operaciones de alg. Lineal. Las librerías paralelas llaman a las funciones seriales en cada CPU: deben ser veloces! - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/1.jpg)
Operaciones con Matrices Densas
Glen D. Rodríguez R.
Algoritmos Paralelos
Basado en material de J. Demmel
![Page 2: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/2.jpg)
Revisión de BLAS
Nivel BLAS Ex. # mem refs # flops q
1 “axpy”, prod escalar
3n 2n1 2/3
2 Mult. Matriz-vector
n2 2n2 2
3 Mult Matriz-matriz
4n2 2n3 n/2
• Bloques básicos de operaciones de alg. Lineal.•Las librerías paralelas llaman a las funciones seriales en cada CPU: deben ser veloces!•Recordar la eficiencia del algor. q = # flops / # refs mem
• A mayor q, más rápido el algoritmo en computadorasreales con jerarquía de memoria
• “axpy” (ax plus y): y = *x + y, con escalar, x e y vectores
![Page 3: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/3.jpg)
Varias particiones de data en proc. paralelos para matrices
0123012301230123
0 1 2 3 0 1 2 3
1) Bloques de columnas en 1D2) Columnas cíclicas en 1D
3) Bloques cíclicos de cols. 1D
4) Cambiar columnas por filas en los casos 1,2,3 y salen 3 casos análogos
Generalizar otros
0 1 0 1 0 1 0 12 3 2 3 2 3 2 30 1 0 1 0 1 0 12 3 2 3 2 3 2 30 1 0 1 0 1 0 12 3 2 3 2 3 2 30 1 0 1 0 1 0 12 3 2 3 2 3 2 3
6) Bloques cíclicos 2D
0 1 2 3
0 1
2 35) Bloques (sub matrices) en 2D
![Page 4: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/4.jpg)
Multiplicación paralela matriz vector Computar y = y + A*x, con A matriz densa Partición:
Bloques de filas en 1D
A(i) es el bloque de filas tamaño n por n/p asignado al procesador i,
x(i) e y(i) son los segmentos de x,y asignados al proc.“i”
Algoritmo: Para todos los procesadores i Broadcast x(i) Computar y(i) = y(i) + A(i)*x
Algoritmo use la formulay(i) = y(i) + A(i)*x = y(i) + j A(i,j)*x(j)
x
y
P0
P1
P2
P3
P0 P1 P2 P3
![Page 5: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/5.jpg)
Multip. matriz vector y = y + A*x Una partición por columnas elimina el broadcast de x
Pero implicaría un mpi_reduce para obtener el valor de y
Una partición de bloques 2D use broadcast y reducción, ambos en un subconjunto de procesadores sqrt(p) si tenemos una distribución cuadrada de procesadores (2x2,
3x3, 4x4, 5x5, etc.)
P0 P1 P2 P3
P0 P1 P2 P3
P4 P5 P6 P7
P8 P9 P10 P11
P12 P13 P14 P15
![Page 6: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/6.jpg)
Multiplicación de matrices en paralelo Computar C=C+A*B Usando algoritmo básico: 2*n3 Flops Variables:
Partición de la data Topología de las máquinas Scheduling (calendarización) de la comunicación
Uso de modelos de performance para diseñar el algoritmo Tiempo comunicación= “latencia” + #words *tiempo-por-word
= + n* Eficiencia (en cualquier modelo):
serial time / (p * parallel time) = speedup / p speedup perfecto (lineal) es “p” efficiency = 1 = 100%
![Page 7: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/7.jpg)
Algoritmo trivial Si hay suficiente espacio de memoria en
cada procesador para guardar todos los elementos de A, B y C; entonces dividir solo el cálculo pero no la data.
A BxC +
Todos guardan la totalidad de A, B, C. Los valores iniciales se comunican con broadcastPara matrices de tamaño nxn, cada procesadordebe usar memoria= tamaño word x 3n2
![Page 8: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/8.jpg)
Mejora al trivial Se ahorra algo de memoria si se divide la
memoria de C y de A, pero no de B. La división es por bloques de filas 1D Ver programa ejemplo
Para matrices de tamaño nxn, si hay p procesadores,cada procesador debe usar memoria = tamaño word x (n2 + 2n2/p)
A
Proc. 0Proc. 1Proc. 2Proc. 3…Proc. p-2Proc. p-1
![Page 9: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/9.jpg)
Multiplic. matrices con partición columnas 1D
Asumir matrices de n x n con n divisible por p
A(i) es el bloque de columnas tamaño n por n/p asignado al proc.”i” (lo mismo para B(i) y C(i))
B(i,j) es un sub-bloque tamaño n/p por n/p de B(i) desde la fila j*n/p hasta la fila ((j+1)*n/p)-1
Algoritmo usa la formulaC(i) = C(i) + A*B(i) = C(i) + j A(j)*B(j,i)
p0 p1 p2 p3 p5 p4 p6 p7
Suposición razonable para análisis, no para programar
![Page 10: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/10.jpg)
Partición 1D en Bus ó Anillo
Algoritmo usa la formula
C(i) = C(i) + A*B(i) = C(i) + j A(j)*B(j,i)
Primero, considerar una máquina que usa bus y sin broadcast: solo un par de procesadores pueden comunicarse a la vez (ej.: ethernet)
Luego, considerar procesadores en un anillo: todos los procesadores se pueden comunicar con sus vecinos inmediatos a la vez.
![Page 11: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/11.jpg)
MatMul: Partición 1D en Bus sin Broadcast
Algoritmo simplón:
C(myproc) = C(myproc) + A(myproc)*B(myproc,myproc)
for i = 0 to p-1
for j = 0 to p-1 except i
if (myproc == i) send A(i) al procesador j
if (myproc == j)
receive A(i) del procesador i
C(myproc) = C(myproc) + A(i)*B(i,myproc)
barrier
Costo del loop interno :
computación: 2*n*(n/p)2 = 2*n3/p2
comunicación: + *n2 /p
![Page 12: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/12.jpg)
Continua…Costo del loop interno:
computación: 2*n*(n/p)2 = 2*n3/p2
comunicación: + *n2 /p … aprox.
Solo un par de procesadores (i , j) están activos en una iteración,
y de ellos, sólo i esta computando
=> el algoritmo es prácticamente serial
Tiempo de ejecución:
= (p*(p-1) + 1)*computación + p*(p-1)*comunicación
~= 2*n3 + p2* + p*n2* Es peor que el tiempo serial y crece con p.
Quién lo usaría si es malo? ojo, no acelera tiempo de ejecución pero por lo menos aumenta la memoria disponible.
![Page 13: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/13.jpg)
Matmul en columnas 1D y en un anillo
• Pares de procesadores se pueden comunicar a la vez
Copiar A(myproc) en Tmp
C(myproc) = C(myproc) + Tmp*B(myproc , myproc)
for j = 1 to p-1
Send Tmp al procesador myproc+1 mod p
Receive Tmp del procesador myproc-1 mod p
C(myproc) = C(myproc) + Tmp*B( myproc-j mod p , myproc)
• Misma idea que en el paralelismo de N-body, usar un buffer de variables temporales
• Tiempo del loop interno = 2*( + *n2/p) + 2*n*(n/p)2
![Page 14: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/14.jpg)
Matmul en columnas 1D y en un anillo
Tiempo del loop interno= 2*( + *n2/p) + 2*n*(n/p)2
Tiempo Total = 2*n* (n/p)2 + (p-1) * Tiempo loop interno ~ 2*n3/p + 2*p* + 2**n2
Optimo para partición 1D en Ring o Bus, aún con Broadcast: Speedup perfecto para aritmética A(myproc) debe moverse a los demás procesadores, cuesta
por lo menos: (p-1)*costo de enviar n*(n/p) words
Eficiencia paralela = 2*n3 / (p * Tiempo Total paralelo)
= 1/(1 + * p2/(2*n3) + * p/(2*n) )
= 1/ (1 + O(p/n)) Se acerca a 1 si n/p crece (o si , se achican)
![Page 15: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/15.jpg)
MatMul en particiones 2D
Considerar procesadores en malla 2D (física o lógica) Procs. se pueden comunicar con 4 vecinos inmediatos
Broadcast a lo largo de filas y columnas
Asumir p procesadores forman una malla de sxs
p(0,0) p(0,1) p(0,2)
p(1,0) p(1,1) p(1,2)
p(2,0) p(2,1) p(2,2)
p(0,0) p(0,1) p(0,2)
p(1,0) p(1,1) p(1,2)
p(2,0) p(2,1) p(2,2)
p(0,0) p(0,1) p(0,2)
p(1,0) p(1,1) p(1,2)
p(2,0) p(2,1) p(2,2)
= *
![Page 16: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/16.jpg)
Algoritmo de Cannon
… C(i,j) = C(i,j) + A(i,k)*B(k,j)
… se asume que s = sqrt(p) es entero
forall i=0 to s-1 … “mover” A
desplaz. circular-izq. de la fila i de A en “i” posiciones
… tal que A(i,j) es sobreescrito por A(i,(j+i)mod s)
forall i=0 to s-1 … “mover” B
desplaz.circular-arriba de columna i de B en “i” pos.
…tal que that B(i,j) es sobreescrito por B((i+j)mod s), j)
for k=0 to s-1 … secuencial
forall i=0 to s-1 and j=0 to s-1 … todos procs. en paralelo
C(i,j) = C(i,j) + A(i,j)*B(i,j)
despl.circular-izq para cada fila de A en 1
despl.circular-arriba para cada columna de B en 1
k
![Page 17: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/17.jpg)
C(1,2) = A(1,0) * B(0,2) + A(1,1) * B(1,2) + A(1,2) * B(2,2)
MatMul con Cannon
![Page 18: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/18.jpg)
Paso inicial para mover Matrices en Cannon Input inicial por bloques
Después de 1er movimiento, antes de multiplicar
A(0,1) A(0,2)
A(1,0)
A(2,0)
A(1,1) A(1,2)
A(2,1)A(2,2)
A(0,0)
B(0,1) B(0,2)
B(1,0)
B(2,0)
B(1,1) B(1,2)
B(2,1) B(2,2)
B(0,0)A(0,1) A(0,2)
A(1,0)
A(2,0)
A(1,1) A(1,2)
A(2,1) A(2,2)
A(0,0)
B(0,1)
B(0,2)B(1,0)
B(2,0)
B(1,1)
B(1,2)
B(2,1)
B(2,2)B(0,0)
![Page 19: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/19.jpg)
Siguientes movimientos en Cannon 1er. paso
2do. paso
3er. paso
A(0,1) A(0,2)
A(1,0)
A(2,0)
A(1,1) A(1,2)
A(2,1)A(2,2)
A(0,0)
B(0,1)
B(0,2)B(1,0)
B(2,0)
B(1,1)
B(1,2)
B(2,1)
B(2,2)B(0,0)
A(0,1) A(0,2)
A(1,0)
A(2,0)
A(1,2)
A(2,1)
B(0,1)
B(0,2)B(1,0)
B(2,0)
B(1,1)
B(1,2)
B(2,1)
B(2,2)B(0,0)
A(0,1)A(0,2)
A(1,0)
A(2,0)
A(1,1) A(1,2)
A(2,1) A(2,2)
A(0,0) B(0,1)
B(0,2)B(1,0)
B(2,0)
B(1,1)
B(1,2)
B(2,1)
B(2,2)B(0,0)
A(1,1)
A(2,2)
A(0,0)
![Page 20: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/20.jpg)
Costo del Algoritmo de Cannon forall i=0 to s-1 … recordar que s = sqrt(p)
despl.circ.izq. fila i de A en i … costo = s*( + *n2/p)
forall i=0 to s-1
desp.circ.arr. columna i de B en i … costo = s*( + *n2/p)
for k=0 to s-1
forall i=0 to s-1 and j=0 to s-1
C(i,j) = C(i,j) + A(i,j)*B(i,j) … costo = 2*(n/s)3 = 2*n3/p3/2
despl.circ.izq. cada fila de A en 1 … costo = + *n2/p
desp.circ.arr. cada columna de B en 1 … costo = + *n2/p
° Tiempo Total = 2*n3/p + 4* s* + 4**n2/s ° Eficiencia Paralela = 2*n3 / (p * Tiempo Total paralelo)
= 1/( 1 + * 2*(s/n)3 + * 2*(s/n) ) = 1/(1 + O(sqrt(p)/n)) ° Se acerca a 1 si crece n/s = n/sqrt(p) = sqrt(data por procesador)° Mejor que 1D, que tiene eficiencia= 1/(1 + O(p/n))
![Page 21: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/21.jpg)
Pros y Contras de Cannon
Se optimiza la computación local Difícil de generalizar para:
Valores de p que no son cuadrados perfectos Matrices A y B no son cuadradas Dimensiones de A, B que no son divisibles por
s=sqrt(p) A y B no “alineadas” en la forma en que están
guardadas en los procesadores Bloques cíclicos
Consume memoria (copias extra de matrices locales)
![Page 22: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/22.jpg)
Algoritmo SUMMA
SUMMA = Scalable Universal Matrix Multiply Un poco menos eficiente, pero es más sencillo
y más fácil de generalizar Link: slides de van de Geijn y Watts
www.netlib.org/lapack/lawns/lawn96.ps Ideas similares aparecieron en muchas ocasiones
Usado en PBLAS = Parallel BLAS www.netlib.org/lapack/lawns/lawn100.ps
![Page 23: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/23.jpg)
SUMMA
* =i
j
A(i,k)
k
k
B(k,j)
• i, j representan todas las filas, columnas asignadas a un procesador
• k es una sola fila o columna; o un bloque de b filas o columnas
• C(i,j) = C(i,j) + k A(i,k)*B(k,j)
• Asumir una malla de pr por pc procesadores (pr = pc = 4
en el ejemplo de arriba) . El número de procesadores no necesariamente debe ser cuadrado perfecto.
C(i,j)
Proc(1,1)
Proc(2,1)
Proc(pr,pc)
![Page 24: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/24.jpg)
SUMMA
For k=0 to n-1 … ó (n/b)-1 donde b es el tamaño de bloque
… b= # columnas en A(i,k) y # filas en B(k,j)
for all i = 1 to pr … en paralelo
dueño de A(i,k) le hace broadcast a todos los procs. de esa fila
for all j = 1 to pc … en paralelo
dueño de B(k,j) le hace broadcast a todos los procs. de esa col.
Receive A(i,k) en Acol
Receive B(k,j) en Brow
C_myproc = C_myproc + Acol * Brow
* =i
j
A(i,k)
k
k
B(k,j)
C(i,j)
![Page 25: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/25.jpg)
Performance de SUMMA
For k=0 to n/b-1
for all i = 1 to s … s = sqrt(p)
dueño de A(i,k) le hace bc. a todos los procs. de la fila
… tiempo = log s *( + * b*n/s), usando árbol
for all j = 1 to s
dueño de B(k,j) le hace bc. a todos los procs. de la col.
… tiempo = log s *( + * b*n/s), usando árbol
Receive A(i,k) en Acol
Receive B(k,j) en Brow
C_myproc = C_myproc + Acol * Brow
… tiempo= 2*(n/s)2*b
° Tiempo Total = 2*n3/p + * log p * n/b + * log p * n2 /s
° Solo para simplificar análisis, asumir s = sqrt(p)
![Page 26: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/26.jpg)
Performance de SUMMA
• Tiempo total = 2*n3/p + * log p * n/b + * log p * n2 /s
• Eficiencia Paralela =
1/(1 + * log p * p / (2*b*n2) + * log p * s/(2*n) )
• ~Mismo término de Cannon, excepto por el factor log p
log p crece lento, así que no es problema
• Término con latencia () puede ser mayor, dependiendo de b
Cuando b=1, se tiene * log p * n
Si b se acerca a n/s, término se achica hacia
* log p * s (log p veces Cannon)
• Storage temporal crece como 2*b*n/s
• Se puede cambiar b para disminuir latencia a costa de la necesidad de más memoria
![Page 27: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/27.jpg)
Librería paralela ScaLAPACK
![Page 28: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/28.jpg)
PDGEMM = rutina PBLAS para multipl. matrices
Observaciones: Para N fijo, si P aumenta, Mflops aumenta, pero menos que 100% eficiencia Para P fijo, si N aumenta, Mflops (eficiencia) aumenta
DGEMM = rutina BLAS para multip. matrices
Max. Velocidad para PDGEMM = # Procs * veloc. de DGEMM
Observaciones (mismas arriba): Eficiencia por lo menos 48% Para N fijo, si P aumenta, eficiencia cae Para P fijo, si N aumenta, eficiencia aumenta
![Page 29: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/29.jpg)
Notación para el algoritmo de Fox
Los índices comienzan en 0 para las sub matrices, pero comienzan en 1 para filas y columnas de procesadores
![Page 30: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/30.jpg)
Algoritmo de Fox (Broadcast, Multiply, y Roll)
![Page 31: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/31.jpg)
Primer paso -- index n=0 en suma de sub-bloque
![Page 32: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/32.jpg)
Segundo paso -- index n=1 en suma de sub-bloque
![Page 33: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/33.jpg)
Segundo paso, continuado
![Page 34: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/34.jpg)
El algoritmo completo para un elemento
![Page 35: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/35.jpg)
MPI: grupos de procesadores y comunicación colectiva
Necesitamos “broadcasts parciales” a lo largo de las filas en Fox (y de las columnas también en SUMMA)
Y rolls (desplazamientos en 1) en las columnas en Fox (parecido en Cannon)
Estas son “comunicaciones colectivas” “Broadcasts de filas” son broadcasts es sub-grupos especiales
de procesadores Rolls se hacen como una variante del MPI_SENDRECV con
“condiciones de frontera ciclicas” También hay rutinas especiales MPI para definir la malla 2D de
procesadores
![Page 36: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/36.jpg)
Broadcast en el caso de la Matriz completa
MatMul usando Fox o Summa con MPI emplea broadcast como comunicación básica
Usaremos esta aplicación para discutir 3 enfoques del broadcast Trivial Logarítmico Pipe (tubo)
Que tiene diferente performance dependiendo en el tamaño del mensaje y la arquitectura del hardware.
![Page 37: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/37.jpg)
Implementación Broadcast trivial y del logarítmico
![Page 38: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/38.jpg)
Broadcast de pipe o tubo En el caso que el tamaño del mensaje es grande, otras implementaciones son
posibles o deseables, ya que será necesario hacer broadcast del mensaje previa sub división en una secuencia de mensajes más chicos.
El broadcast puede establecer un camino (o varios) desde el procesador origen y que visita a los demás procesadores de un grupo.
El mensaje es enviado desde la fuente a lo largo del camino en un “tubo”, donde cada procesador recibe un bloque del mensaje desdensupredecesor y lo envia luego a su sucesor.
La performance de este broadcast es por lo tanto el tiempo para enviar el mensaje al procesador al final del camino más la latencia de inicializar y terminar el “tubo”. Tiempo = (Tamaño del mensaje +Tamaño de un paquete(√N – 2)) *tcomm
Para granos suficientemente gruesos, el pipe es mejor que el log. Alta latencia es mala para este enfoque de “tubo” MPI usa logarítmico, pero se puede “adoptar” el trivial.
![Page 39: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/39.jpg)
Esquema de Operación
![Page 40: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/40.jpg)
Análisis de performance
![Page 41: Operaciones con Matrices Densas](https://reader036.vdocuments.net/reader036/viewer/2022082207/56812b0f550346895d8f023d/html5/thumbnails/41.jpg)
Resumen de MatMul paralela 1D
Bus sin broadcast – más lento que serial Comunicación al vecino más próximo en anillo (o bus con
broadcast): Eficiencia = 1/(1 + O(p/n)) 2D
Cannon Eficiencia = 1/(1+O(sqrt(p) /n+* sqrt(p) /n)) Difícil de generalizar para arbitrarios p, n, bloques cíclicos, alineamientos
SUMMA Eficiencia = 1/(1 + O(log p * p / (b*n2) + log p * sqrt(p) /n)) Más genérico b chico => menos memoria, menos eficiencia b grande => más memoria, más eficiencia