Algoritmos Matriciales por Bloques

Transcripción

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 1

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 2

3 Trabajo por bloques En las operaciones anteriores los costes son: Coste Computacional Memoria Vector-vector n n Matriz-vector n 2 n 2 Matriz-matriz n 3 n 2 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 3

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 4

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 5

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; Algoritmo sin bloques (normal). Acceso elemento a elemento. 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; Problemas pequeños: buenas prestaciones pues caben en memoria de niveles bajos de la jerarquía. Problemas grandes: peores prestaciones. 6

7 Multiplicación de matrices A tb B tb j C tb j i k k i s 7

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; Algoritmo por bloques. s=(double *) malloc(sizeof(double)* tb * Acceso tb); y operaciones por for(i=0;i<fa;i=i+ tb) bloques. for(j=0;j<cb;j=j+ tb) Buenas prestaciones independiente del tamaño. matriz_cero(s, tb, tb, tb); El tamaño de bloque es parámetro a determinar. 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); } } free(s); copiar_matriz(s,tb, tb, tb,&c[i*ldc+j], tb, tb,ldc); 8

9 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; Multiplicación de matrices for(i=0;i<fa;i++) da=&a[i*lda]; void for(j=0;j<cb;j++) 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) db=&b[j]; int i,j,k; double *s; s=c[i*ldc+j]; for(k=0,kb=0;k<ca;k++,kb=kb+ldb) Algoritmo por bloques. s=(double *) malloc(sizeof(double)* tb * Acceso tb); y operaciones por for(i=0;i<fa;i=i+ s=s+da[k]*db[kb]; tb) bloques. } for(j=0;j<cb;j=j+ tb) Buenas prestaciones c[i*ldc+j]=s; independiente del tamaño. } matriz_cero(s, tb, tb, tb); El tamaño de bloque es } } parámetro a determinar. 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); } } free(s); copiar_matriz(s,tb, tb, tb,&c[i*ldc+j], tb, tb,ldc); 9

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; Algoritmo por bloques dobles. La operación sobre bloques s=(double *) malloc(sizeof(double)* tb * tb); no es la multiplicación for(i=0;i<fa;i=i+ tb) directa, sino por bloques. Tenemos dos tamaños for(j=0;j<cb;j=j+ tb) de bloque. 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); } 10

11 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; } Multiplicación de matrices s=(double *) malloc(sizeof(double)*tbp*tbp); 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 for(j=0;j<cb;j=j+tbp) ldc,int tb,int tbp) copiar_matriz(&c[i*ldc+j],tbp,tbp,ldc,s,tbp,tbp,tbp); int i,j,k; double *s; Algoritmo por bloques dobles. La operación sobre bloques for(i=0;i<fa;i=i+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); s=(double *) malloc(sizeof(double)* tb * tb); no es la multiplicación for(i=0;i<fa;i=i+ tb) directa, sino por bloques. Tenemos dos tamaños for(j=0;j<cb;j=j+ tb) de bloque. matriz_cero(s, tb, tb, tb); for(k=0;k<ca;k=k+ tb) } copiar_matriz(s,tbp,tbp,tbp,&c[i*ldc+j],tbp,tbp,ldc); } } free(s); } free(s); 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); 11

12 Multiplicación de matrices Almacenamiento por bloques: matriz almacenamiento posible acceso más rápido a los datos dentro de las operaciones por bloques 12

13 Multiplicación de matrices Multiplicación de matrices, en portátil antiguo: Método\tamaño normal bloques Reducción 76% bloques dobles

14 Multiplicación de matrices Multiplicación de matrices, en SUN Ultra 1: Método\tamaño Normal Traspuesta Bloques Bloq tras Almac blo Bl tr al bl Bloq dob Reducción 93% 14

15 Multiplicación de matrices Multiplicación de matrices,en kefren, pentium 4: Método\tamaño Normal Traspuesta Reducción 79% Bloques Bloq dob

16 Multiplicación de matrices Multiplicación de matrices,en PC actual (2016): Método\tamaño Normal Traspuesta Bloques

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 17

18 Factorización LU Cada A ij, L ij, U ij de tamaño b n : Paso 1: L 00 U 00 =A 00 Factorización sin bloques Paso 2: L 00 U 01 =A 01 Sistema múltiple triangular inferior ( bloques?) Paso 3: L 10 U 00 =A 10 Sistema múltiple triangular superior ( bloques?) Paso 4: A 11 =L 10 U 01 + L 11 U 11 A 11 =A 11 - L 10 U 01, por bloques y seguir trabajando con el nuevo valor de A 11 18

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 19

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 20

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 Paso 1: L 00 U 00 =A 00 Factorización sin bloques 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 21

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 Paso 1: L 00 U 00 =A 00 Factorización sin bloques 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 22

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 Paso 1: L 00 U 00 =A 00 Factorización sin bloques 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 23

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 Paso 2: L 00 U 01 =A 01 Sistema múltiple triangular inferior 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 24

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 Paso 2: L 00 U 01 =A 01 Sistema múltiple triangular inferior 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 25

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 Paso 2: L 00 U 01 =A 01 Sistema múltiple triangular inferior 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 26

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, Paso 3: L 10 U 00 =A 10 Sistema múltiple triangular superior &a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4 } } } 27

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, Paso 3: L 10 U 00 =A 10 Sistema múltiple triangular superior &a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4 } } } 28

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, Paso 3: L 10 U 00 =A 10 Sistema múltiple triangular superior &a[i*lda+i+f],f,ca-i-c,lda,&a[(i+f)*lda+i+c],fa-i-f,ca-i-c,lda); //4 } } } 29

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) Paso 4: A 11 =L 10 U 01 + L 11 U 11 A 11 =A 11 - L 10 U 01 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 30

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) Paso 4: A 11 =L 10 U 01 + L 11 U 11 A 11 =A 11 - L 10 U 01 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 31

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) Paso 4: A 11 =L 10 U 01 + L 11 U 11 A 11 =A 11 - L 10 U 01 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 32

33 Factorización LU en mi portátil antiguo: tamaño bloque\matriz sin bloques

34 Factorización LU en PC actual (2016): tamaño bloque\matriz sin bloques

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 35

36 Optimización Automática: Tamaño de bloque óptimo Diseño 1.Crear la rutina Ejecución 6. Ejecutar la rutina 2. Modelar la rutina 5. Seleccionar valores de los parámetros algorítmicos 3. Crear el sistema de gestión de la rutina Instalación 4. Obtener información del sistema 36

37 Optimización Automática. Ejemplo: Factorización LU 1.Crear la rutina DGETF2: Paso 1: L 00 U 00 =A 00 Factorización sin bloques DTRSM: Paso 2: L 00 U 01 =A 01 Sistema múltiple triangular inferior DTRSM: Paso 3: L 10 U 00 =A 10 Sistema múltiple triangular superior DGEMM: Paso 4: A 11 =L 10 U 01 + L 11 U 11 A 11 =A 11 - L 10 U 01 37

38 Optimización Automática. Ejemplo: Factorización LU 2. Modelar el tiempo de ejecución: T EXEC 2 3 n 3 k 3 _ DGEMM bn 3 _ DTRSM n: el tamaño del problema a resolver SP: parámetros del sistema k 3_DGEMM, k 3_DTRSM, k 2_DGETF2 2 k 2 _ DGETF2 coste computacional de una operación básica realizada por rutinas utilizadas (DGEMM, DTRSM, DGETF2) 1 3 b 2 nk AP: parámetros algorítmicos b: tamaño de bloque 38

39 Optimización Automática. Ejemplo: Factorización LU 4. Obtener información del sistema 39

40 Optimización Automática. Ejemplo: Factorización LU 5. Seleccionar valores de los AP 40

41 Optimización Automática. Ejemplo: Factorización LU 6. Ejecución de la rutina 41

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 42

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 ================= 43

44 Trabajo alumnos. Uso de colas en HeteroSolar Matriz de datos de entrada $ cat matriz_matriz.input Envío trabajo a la cola $ qsub matriz_matriz.pbs Luna Compruebo cola $ qstat Job id Name User Time Use S Queue 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: seg 44

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 45

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 46