Algoritmos Matriciales por Bloquesdis.um.es/~domingo/apuntes/PPCAP/1718/PPCAP_AlgMatBlo.pdf3 Trabajo...
Transcript of Algoritmos Matriciales por Bloquesdis.um.es/~domingo/apuntes/PPCAP/1718/PPCAP_AlgMatBlo.pdf3 Trabajo...
1
Master en Nuevas Tecnologías en Informática Programación Paralela y Computación de Altas Prestaciones
Algoritmos Matriciales por Bloques
Javier Cuenca & Domingo Giménez Grupo de Investigación en Computación Científica y Programación Paralela
Universidad de Murcia
2
Contenido
Trabajo por bloques
Multiplicación de matrices
Factorización LU
Optimización automática: Tamaño de bloque óptimo
Trabajo de los alumnos. Uso de colas en HeteroSolar
Trabajo de los alumnos. Ejercicios
3
Trabajo por bloques
En las operaciones anteriores los costes son:
Coste Computacional Memoria
Vector-vector n n
Matriz-vector n2 n2
Matriz-matriz n3 n2
Desarrollando algoritmos con operaciones matriz-matriz, para el mismo número de operaciones aritméticas menos accesos a memoria menor tiempo de ejecución
Usado en el desarrollo de librerías desde los 80 (BLAS-3, LAPACK)
Posibilidad de migración a rutinas paralelas más escalables
4
Trabajo por bloques
La reducción varía de un sistema a otro
¿Cómo se sabe el tamaño de bloque óptimo? Varía con:
Sistema
Problema a resolver
Tamaño del problema
Con lo que el método preferido también varía con el tamaño y el sistema (polialgoritmos)
Difícil determinar a priori mejor método y parámetros métodos de
optimización automática
5
Contenido
Trabajo por bloques
Multiplicación de matrices
Factorización LU
Optimización automática: Tamaño de bloque óptimo
Trabajo de los alumnos. Uso de colas en HeteroSolar
Trabajo de los alumnos. Ejercicios
6
Multiplicación de matrices void matriz_matriz_ld (double *a,int fa,int ca,int lda,
double *b,int fb,int cb,int ldb,double *c,int fc,int
cc,int ldc)
{ int i,j,k;
double s;
for(i=0;i<fa;i++)
for(j=0;j<cb;j++)
{
s=0.;
for(k=0;k<ca;k++)
s+=a[i*lda+k]*b[k*ldb+j];
c[i*ldc+j]=s;
}
Algoritmo sin bloques (normal). Acceso elemento a elemento. Problemas pequeños: buenas prestaciones pues caben en memoria de niveles bajos de la jerarquía. Problemas grandes: peores prestaciones.
8
Multiplicación de matrices
void matriz_matriz_bloques (double *a,int fa,int ca,int lda,double
*b,int fb,int cb,int ldb,double *c,int fc,int cc,int ldc,int tb)
{ int i,j,k; double *s;
s=(double *) malloc(sizeof(double)* tb * tb);
for(i=0;i<fa;i=i+ tb)
for(j=0;j<cb;j=j+ tb)
{
matriz_cero(s, tb, tb, tb);
for(k=0;k<ca;k=k+ tb)
multiplicar_acumular_matrices(&a[i*lda+k], tb,
tb,lda,&b[k*ldb+j],tb, tb,ldb,s, tb, tb, tb);
copiar_matriz(s,tb, tb, tb,&c[i*ldc+j], tb, tb,ldc);
}
free(s);
}
Algoritmo por bloques. Acceso y operaciones por bloques . Buenas prestaciones independiente del tamaño. El tamaño de bloque es parámetro a determinar.
9
Multiplicación de matrices void matriz_matriz_bloques (double *a,int fa,int ca,int lda,double
*b,int fb,int cb,int ldb,double *c,int fc,int cc,int ldc,int tb)
{ int i,j,k; double *s;
s=(double *) malloc(sizeof(double)* tb * tb);
for(i=0;i<fa;i=i+ tb)
for(j=0;j<cb;j=j+ tb)
{
matriz_cero(s, tb, tb, tb);
for(k=0;k<ca;k=k+ tb)
multiplicar_acumular_matrices(&a[i*lda+k], tb,
tb,lda,&b[k*ldb+j],tb, tb,ldb,s, tb, tb, tb);
copiar_matriz(s,tb, tb, tb,&c[i*ldc+j], tb, tb,ldc);
}
free(s);
}
Algoritmo por bloques. Acceso y operaciones por bloques . Buenas prestaciones independiente del tamaño. El tamaño de bloque es parámetro a determinar.
void multiplicar_acumular_matrices(double *a,int fa,int ca,int lda,double *b,int
fb,int cb,int ldb,double *c,int fc,int cc,int ldc)
{
int i,j,k,kb;
double *da,*db,s;
for(i=0;i<fa;i++)
{
da=&a[i*lda];
for(j=0;j<cb;j++)
{
db=&b[j];
s=c[i*ldc+j];
for(k=0,kb=0;k<ca;k++,kb=kb+ldb)
{
s=s+da[k]*db[kb];
}
c[i*ldc+j]=s;
}
}
}
10
Multiplicación de matrices
void matriz_matriz_bloquesdobles (double *a,int fa,int ca,int
lda,double *b,int fb,int cb,int ldb,double *c,int fc,int cc,int
ldc,int tb,int tbp)
{ int i,j,k; double *s;
s=(double *) malloc(sizeof(double)* tb * tb);
for(i=0;i<fa;i=i+ tb)
for(j=0;j<cb;j=j+ tb)
{
matriz_cero(s, tb, tb, tb);
for(k=0;k<ca;k=k+ tb)
multiplicar_acumular_bloques(&a[i*lda+k],tb,
tb,lda,&b[k*ldb+j],tb,tb,ldb,s,tb,tb, tb, tbp);
copiar_matriz(s, tb, tb, tb,&c[i*ldc+j], tb, tb,ldc);
}
free(s);
}
Algoritmo por bloques dobles. La operación sobre bloques no es la multiplicación directa, sino por bloques. Tenemos dos tamaños de bloque.
11
Multiplicación de matrices void matriz_matriz_bloquesdobles (double *a,int fa,int ca,int
lda,double *b,int fb,int cb,int ldb,double *c,int fc,int cc,int
ldc,int tb,int tbp)
{ int i,j,k; double *s;
s=(double *) malloc(sizeof(double)* tb * tb);
for(i=0;i<fa;i=i+ tb)
for(j=0;j<cb;j=j+ tb)
{
matriz_cero(s, tb, tb, tb);
for(k=0;k<ca;k=k+ tb)
multiplicar_acumular_bloques(&a[i*lda+k],tb,
tb,lda,&b[k*ldb+j],tb,tb,ldb,s,tb,tb, tb, tbp);
copiar_matriz(s, tb, tb, tb,&c[i*ldc+j], tb, tb,ldc);
}
free(s);
}
Algoritmo por bloques dobles. La operación sobre bloques no es la multiplicación directa, sino por bloques. Tenemos dos tamaños de bloque.
void multiplicar_acumular_bloques(double *a,int fa,int ca,int lda,double *b,int fb,int cb,int ldb,double
*c,int fc,int cc,int ldc,int tbp)
{
int i,j,k;
double *s;
s=(double *) malloc(sizeof(double)*tbp*tbp);
for(i=0;i<fa;i=i+tbp)
{
for(j=0;j<cb;j=j+tbp)
{
copiar_matriz(&c[i*ldc+j],tbp,tbp,ldc,s,tbp,tbp,tbp);
for(k=0;k<ca;k=k+tbp)
{
multiplicar_acumular_matrices(&a[i*lda+k],tbp,tbp,lda,&b[k*ldb+j],tbp,tbp,ldb,s,tbp,tbp,tbp);
}
copiar_matriz(s,tbp,tbp,tbp,&c[i*ldc+j],tbp,tbp,ldc);
}
}
free(s);
12
Multiplicación de matrices
Almacenamiento por bloques:
matriz 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
almacenamiento 0 1 4 5 2 3 6 7 8 9 12 13 10 11 14 15
posible acceso más rápido a los datos dentro de las operaciones por bloques
13
Multiplicación de matrices
Multiplicación de matrices, en portátil antiguo: Método\tamaño 1000 1200 1400
normal 12.70 21.95 36.41
bloques 25 3.69 6.30 9.25
50 3.56 5.90 8.71
100 4.25 6.33 8.95
bloques 25 5 4.67 7.87 10.89
dobles 50 10 5.03 8.08 12.93
50 25 4.53 7.16 11.11
100 20 4.87 7.33 10.97
100 25 4.78 7.06 9.92
100 50 3.90 5.85 8.92
Reducción 76%
14
Multiplicación de matrices
Multiplicación de matrices, en SUN Ultra 1: Método\tamaño 200 400 800
Normal 0.2179 13.4601 217.5464
Traspuesta 0.2013 3.3653 27.9945
Bloques 10 0.2880 2.5901 21.9029
25 0.2192 1.8347 14.9642
50 0.2161 1.7709 14.2502
Bloq tras 10 0.2937 2.5026 20.4405
25 0.2195 1.8009 14.6415
50 0.2152 1.7628 14.1806
Almac blo 10 0.2949 2.5122 20.3762
25 0.2277 1.8490 14.8625
50 0.2296 1.8429 14.7314
Bl tr al bl 10 0.2925 2.4985 20.1975
25 0.2244 1.8082 14.5282
50 0.2231 1.7147 13.6553
Bloq dob 20 5 0.6105 4.9363 39.9594
20 10 0.3206 2.6669 19.7044
50 10 0.3039 2.4542 19.7044
50 25 0.2370 1.9221 15.5190
Reducción 93%
15
Multiplicación de matrices
Multiplicación de matrices,en kefren, pentium 4: Método\tamaño 200 400 800
Normal 0.0463 0.7854 7.9686
Traspuesta 0.0231 0.2875 2.3190
Bloques 10 0.0255 0.2493 2.0327
25 0.0265 0.2033 1.6928
50 0.0219 0.1785 1.6594
Bloq dob 20 5 0.0393 0.3669 3.4955
20 10 0.0269 0.3090 2.4424
50 10 0.0316 0.2232 2.2768
50 25 0.0215 0.1755 1.4726
Reducción 79%
16
Multiplicación de matrices
Multiplicación de matrices,en PC actual (2016):
Método\tamaño 500 1000 1500
Normal 1.02 13.62 54.85
Traspuesta 0.60 5.04 17.08
Bloques
50 0.87 6.55 20.94
100 0.86 6.29 21.08
17
Contenido
Trabajo por bloques
Multiplicación de matrices
Factorización LU
Optimización automática: Tamaño de bloque óptimo
Trabajo de los alumnos. Uso de colas en HeteroSolar
Trabajo de los alumnos. Ejercicios
18
Factorización LU
Cada Aij, L
ij, U
ij de tamaño b×n :
Paso 1: L00
U00
=A00 Factorización sin bloques
Paso 2: L00
U01
=A01 Sistema múltiple triangular inferior (¿bloques?)
Paso 3: L10 U00=A10 Sistema múltiple triangular superior (¿bloques?)
Paso 4: A11
=L10
U01
+ L11
U11
A’11
=A11
- L
10 U
01 , por bloques
y seguir trabajando con el nuevo valor de A’11
19
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+c],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
20
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+c],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
21
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 1: L00
U00
=A00 Factorización sin bloques
22
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 1: L00
U00
=A00 Factorización sin bloques
23
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 1: L00
U00
=A00 Factorización sin bloques
24
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 2: L00
U01
=A01 Sistema múltiple triangular inferior
25
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 2: L00
U01
=A01 Sistema múltiple triangular inferior
26
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 2: L00
U01
=A01 Sistema múltiple triangular inferior
27
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 3: L10
U00
=A10 Sistema múltiple triangular superior
28
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 3: L10
U00
=A10 Sistema múltiple triangular superior
29
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 3: L10
U00
=A10 Sistema múltiple triangular superior
30
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+c],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 4: A11
=L10
U01
+ L11
U11
A’ 11
=A11
- L
10 U
01
31
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+c],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 4: A11
=L10
U01
+ L11
U11
A’ 11
=A11
- L
10 U
01
32
Factorización LU
void lu_bloques (double *a,int fa,int ca,int lda,int tb)
{int i,j,k,f,c;
for(i=0;i<fa;i=i+tb)
{
f=(tb<fa-i ? tb : fa-i); c=(tb<ca-i ? tb : ca-i);
lu(&a[i*lda+i],f,c,lda); //1
if(i+tb<fa)
{
sistema_triangular_inferior(&a[i*lda+i],f,c,lda,&a[i*lda+i+c],f,ca-i-c,lda); //2
sistema_triangular_superior(&a[i*lda+i],f,c,lda,&a[(i+f)*lda+i], fa-i-f, c,lda);//3
multiplicar_restar_matrices(&a[(i+f)*lda+i],fa-i-f,c,lda,
&a[i*lda+i+c],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4
} } }
Paso 4: A11
=L10
U01
+ L11
U11
A’ 11
=A11
- L
10 U
01
33
Factorización LU
en mi portátil antiguo: tamaño bloque\matriz 800 1000
1 2.10 4.01
12 1.42 2.78
25 1.29 2.27
37 1.24 2.37
44 1.20 2.00
50 1.22 2.32
100 1.47 2.24
200 2.29 3.47
400 2.17 3.67
sin bloques 1.73 3.43
34
Factorización LU
en PC actual (2016): tamaño bloque\matriz 500 1000 2000 4000
1 0.50 4.04 32.70
25 0.29 2.31 18.55
50 0.28 2.25 18.26 148.19
100 0.29 2.29 18.20
250 0.30 2.36 18.53
sin bloques 0.31 2.49 20.19 161.23
35
Contenido
Trabajo por bloques
Multiplicación de matrices
Factorización LU
Optimización automática: Tamaño de bloque óptimo
Trabajo de los alumnos. Uso de colas en HeteroSolar
Trabajo de los alumnos. Ejercicios
36
Optimización Automática: Tamaño de bloque óptimo
2. Modelar la
rutina
3. Crear el sistema de
gestión de la rutina
1.Crear la rutina
Diseño
4. Obtener información del
sistema
Instalación
5. Seleccionar valores de
los parámetros algorítmicos
6. Ejecutar la rutina
Ejecución
37
1.Crear la rutina
DGETF2: Paso 1: L00 U00=A00 Factorización sin bloques
DTRSM: Paso 2: L00
U01
=A01 Sistema múltiple triangular inferior
DTRSM: Paso 3: L10
U00
=A10 Sistema múltiple triangular superior
DGEMM: Paso 4: A11
=L10
U01
+ L11
U11
A’ 11
=A11
- L
10 U
01
Optimización Automática. Ejemplo: Factorización LU
38
2. Modelar el tiempo de ejecución:
n: el tamaño del problema a resolver
SP: parámetros del sistema
k3_DGEMM, k3_DTRSM, k2_DGETF2
coste computacional de una operación básica realizada por
rutinas utilizadas (DGEMM, DTRSM, DGETF2)
AP: parámetros algorítmicos
b: tamaño de bloque
2_2
2
_3
2
_3
3
3
1
3
2DGETFDTRSMDGEMMEXEC nkbkbnknT
Optimización Automática. Ejemplo: Factorización LU
42
Contenido
Trabajo por bloques
Multiplicación de matrices
Factorización LU
Optimización automática: Tamaño de bloque óptimo
Trabajo de los alumnos. Uso de colas en HeteroSolar
Trabajo de los alumnos. Ejercicios
43
Trabajo alumnos.
Uso de colas en HeteroSolar
$cat matriz_matriz.pbs
#!/bin/bash
#PBS -q batch
#PBS -lnodes=marte:ppn=1
#PBS -lwalltime=01:00:00
#================ INICIO =================
#Cargamos entorno de ejecucion
source /etc/profile.d/modules.sh
# en este caso no hace falta cargar ningun modulo
# module load nada
# Nos aseguramos que estamos en el directorio desde el que se envio el trabajo con qsub
echo "Me muevo del directorio $PWD al directorio de trabajo $PBS_O_WORKDIR"
cd $PBS_O_WORKDIR
echo "Nodo donde se ha planificado el trabajo:"
cat $PBS_NODEFILE
echo "Ahora ejecutamos las tareas secuenciales...“
./matriz_matriz < matriz_matriz.input
#================ FIN =================
44
Trabajo alumnos.
Uso de colas en HeteroSolar
Matriz de datos de entrada $ cat matriz_matriz.input
1000 1000 1000
1 10
Envío trabajo a la cola $ qsub matriz_matriz.pbs
27714.Luna
Compruebo cola $ qstat
Job id Name User Time Use S Queue
------------------------- ---------------- --------------- -------- - -----
27714.luna ...iz_matriz.pbs javiercm 0 R batch
Y, transcurrido un tiempo… tengo el resultado: $ cat matriz_matriz.pbs.o27714
Me muevo del directorio /home_nfs/javiercm al directorio de trabajo
/home_nfs/javiercm/ejemplos_algmatblo_profesor
Nodo donde se ha planificado el trabajo:
Marte
Ahora ejecutamos las tareas secuenciales...
De las filas y columnas de la primera matriz y las columnas de la segunda: De los
valores inferior y superior: Tama▒o 1000: 16.100924 seg
45
Contenido
Trabajo por bloques
Multiplicación de matrices
Factorización LU
Optimización automática: Tamaño de bloque óptimo
Trabajo de los alumnos. Uso de colas en HeteroSolar
Trabajo de los alumnos. Ejercicios
46
Trabajo alumnos.
Ejercicios
Conectarse a luna.inf.um.es
Copiar a tu directorio los ejemplos que están en: /home/javiercm/ejemplos_algmatblo
Probar ejemplos:
Compilar: gcc –o programa programa.c io.c –lm
Ejecutar: cola batch, maquinas: marte ó mercurio
Comparar los tiempos de las multiplicaciones matriciales (bloques y no bloques)
En las multiplicaciones matriciales por bloques quitar la restricción de:
tamaño de las matrices = multiplo del tamaño de bloque
Programar LU con bloques (esquema transparencia 16)
Comprobar resultado correcto LU con bloques (compararando con LU sin bloques)
Comparar los tiempos de la factorización LU con bloques y LU sin bloques
Comparar los tiempos de la factorización LU con bloques usando diferentes multiplicaciones matriciales y/o una combinación de ellas