Algoritmos y Programación Paralela High Performance Fortran

Algoritmos y Programación
Paralela
High Performance Fortran
Contenidos
Motivación de HPF
High Performance Fortran
Directivas de HPF
Compiladores
Motivación de HPF
Fortran
fuertemente orientado al cálculo
adoptado ampliamente por la comunidad científica
Cálculo científico = intrínsecamente pesado
Como en la informática en general, no resulta fácil cambiar algo que funciona. Hay reticencia ha pasar
código a otros lenguajes.
Paralelizar aquello que merezca la pena. Cálculo pesado != cálculo paralelizable, aunque sí es candidato a
intentar paralelizar para obtener mayor ganancia.
Motivación de HPF
Alternativa 1: OpenMP
dimensiones de
problemas científicos
tendencia a arquitecturas
de memoria distribuida
distribución de
iteraciones:
<--- los datos se mueven hacia el procesador que
tiene asignada la computación.
Ante problemas de grandes dimensiones de datos, en esquemas centralizados tenemos problemas
derivados de la necesidad de paginación. En esquemas distribuidos, se pueden obtener mejores
rendimientos al fraccionar los datos.
exige reescritura de código. Existe extensión de OpenMP
NO
para Fortran.
HPF especifica la distribución de los datos: computación realizada por el propietario del dato resultado.
Motivación de HPF
Alternativa 2: MPI
esquema de Paso de
Mensajes
reescritura de código
más oscuro y complicado
no tiene sentido en
arquitecturas de memoria
compartida
Esquema totalmente distinto a Fortran, donde se ha de gestionar el movimiento de datos, la ubicación y la
sincronización.
Paso de mensajes y memoria compartida no implican restricción en el hardware, sólo son modelos de
programación. Puede simularse cualquiera de los modelos en cualquiera de las dos arquitecturas.
PROGRAM SUM
REAL A(100), BUFF(100)
PROGRAM SUM
IF (PID == 0) THEN
REAL A(10000)
DO IP = 0, 99
READ (9) A
READ (9) BUFF(1:100)
IF (IP == 0)
A(1:100) =
BUFF(1:100)
ELSE SEND(IP,BUFF,100)
ENDDO
SUM = 0.0
DO I = 1, 10000
SUM = SUM + A(I)
ENDDO
ELSE RECV(0,A,100)
PRINT SUM
ENDIF
END
IF (PID == 0) SEND(1,SUM,1)
IF (PID > 0) RECV(PID-1,T,1)
SUM = SUM + T
usando llamadas MPI----->
IF (PID < 99) SEND(PID+1,SUM,1)
ELSE SEND(0,SUM,1)
ENDIF
IF (PID == 0) PRINT SUM;
High Performance Fortran
Extensión de Fortran 90
operaciones vectoriales.
allocamiento dinámico.
permite definir tipos de datos estructurados.
recursión.
Promovido por el High Performance Fortran
Forum (HPFF):
http://www.hpfpc.org/index-E.html
Características de Fortran 90 con respecto al original, por ejemplo Fortran 77, además de soportar
conceptos de programación orientada objetos
High Performance Fortran
Objetivos:
Soportar paralelismo a nivel de datos.
Pocas directivas.
mínimas modificaciones del código existente.
código más limpio e intuitivo.
que trabaje el compilador (rendimiento difícil de prever), no el
programador.
Obtener buenos resultados en arquitecturas MIMD y
SIMD.
Soportar optimizar los códigos en diferentes
hardware.
Compatibilidad hacia atrás: si se trabaja con un
compilador HPF se interpretan
las directivas. Sino, se
toman como comentarios.
High Performance Fortran
PROGRAM SUM
PROGRAM SUM
REAL A(10000)
REAL A(10000)
READ (9) A
!HPF$ DISTRIBUTE A(BLOCK)
SUM = 0.0
READ (9) A
DO I = 1, 10000
SUM = 0.0
DO I = 1, 10000
SUM = SUM + A(I)
SUM = SUM + A(I)
ENDDO
ENDDO
PRINT SUM
PRINT SUM
END
END
usando llamadas HPF----->
Similar paradigma, código similar al original
High Performance Fortran
Características (I):
relajar la ejecución síncrona de las
instrucciones, buscando esa ejecución
tanto en computadores SIMD como MIMD
|
|
|
V
Paradigma de Paralelismo de Datos.
Modelo SPMD: cada procesador ejecuta el mismo
programa asíncronamente.
Tanto en máquinas de memoria compartida como
distribuida
Espacio de direcciones global:
el programador ve una única memoria
se deja al compilador (con ayuda de las directivas) la tarea de
distribuir los datos, acceder a memoria, gestionar las
comunicaciones, etc...
Procesadores virtuales: son mapeados a los
procesadores físicos.
High Performance Fortran
Características (II):
Cada procesador opera sobre un subconjunto de los
datos.
Distribución de los datos. Permite especificar qué
datos procesa cada procesador: computación realizada
por el propietario del dato resultado.
Proceso de compilación muy complejo (difícil obtener
altos rendimientos).
Considerado como estándar.
frente a otros, también lenguajes de paralelismo de datos,
como CM-Fortran, Fortran D, Vienna-Fortran.
HPF-Craft: implementación de HPF soportada por
plataformas MPP.
Directivas de HPF
Formato: !HPF$ <directiva>
Tipos Directivas:
PROCESSOR
DISTRIBUTE
ALING
FORALL
INDEPENDENT
Funciones Intrínsecas:
NUMBER_OF_PROCESSORS()
PROCESSORS_SHAPE()
afectan a las prestaciones del código
ejecutable, no a su significado
HPF es basado en directivas, para
evitar modificar el código existente lo
más posible (similar a OpenMP, pero
éste es para sistemas de memoria
centralizada y HPF intenta ser tanto
para centralizada como distribuída)
Directivas de HPF: PROCESSOR
Establece una malla lógica de procesadores.
!HPF$ PROCESSOR, DIMENSION(4) :: P1
!HPF$ PROCESSOR, DIMENSION(2,2) :: P2
!HPF$ PROCESSOR, DIMENSION(2,1,2) :: P3
Por lo general, mapeo
uno-a-uno.
Las dimensiones sin especificar toman valor por defecto igual a 1. Permitiendo linealizar las dimensiones
se dejan sin indicar.
que
Se ha escrito mucho sobre el mapeo de datos a los procesadores virtuales, pero poco se ha dicho sobre el
mapeo de procesadores virtuales a físicos.
Directivas de HPF: DISTRIBUTE
Especifica la distribución de los datos entre las
unidades de procesamiento.
!HPF$ DISTRIBUTE (BLOCK) ONTO P1 :: A
!HPF$ DISTRIBUTE (CYCLIC) ONTO P1 :: B
!HPF$ DISTRIBUTE (CYCLIC,BLOCK) ONTO P2 :: B
Variantes:
BLOCK(k)
CYCLIC(k)
Directivas de HPF: DISTRIBUTE
BLOCK
REAL, DIMENSION(16) :: A
!HPF$ PROCESSOR, DIMENSION(4) :: P1
!HPF$ DISTRIBUTE (BLOCK) ONTO P1 :: A
BLOCK + *
REAL X(12,12)
!HPF$ DISTRIBUTE X(BLOCK,*)
BLOCK + BLOCK
!HPF$ DISTRIBUTE Y(BLOCK,BLOCK)
Directivas de HPF: DISTRIBUTE
CYCLYC
REAL, DIMENSION(16) :: A
!HPF$ PROCESSOR, DIMENSION(4) :: P1
!HPF$ DISTRIBUTE (CYCLYC) ONTO P1 :: A
* + CYCLIC
REAL X(12,12)
!HPF$ DISTRIBUTE X(*,CYCLIC)
CYCLIC + CYCLIC
!HPF$ DISTRIBUTE
Y(CYCLIC(2),CYCLIC(3))
Directivas de HPF: ALING
Fuerza a los elementos de un vector o matriz a
ser alineados en la misma ubicación que los
de la plantilla.
!HPF$ ALIGN array(lista-fuente)
WITH target(lista-destino)
!HPF$ ALIGN (lista-fuente)
WITH target(lista-destino) :: array
Crea una relación entre el array y target de
modo que para todos los valores de
array(lista-fuente) y target(lista-detino) se
almacenan en el mismo procesador.
Directivas de HPF: ALING
REAL X(6,6),Y(6,6),W(5),Z(3)
!HPF$ ALIGN Y(i,j) WITH X(j,i)
!HPF$ ALIGN W(k) WITH X(k,*)
!HPF$ ALIGN Z(l) WITH Y(3,2*l-1)
X
Y
W
Z
Directivas de HPF: ALING
Estrecha relación con la directiva DISTRIBUTE.
Indiferentemente de la distribución, todos los
elementos alineados, se garantiza que se mapean
sobre el mismo procesador.
La modificación de una sola línea cambia todas las
distribuciones de datos (interesante cuando el código
es portado).
Se juega con ambas directivas:
!HPF$ DISTRIBUTE X(BLOCK,*)
!HPF$ DISTRIBUTE X(*,BLOCK) Directivas de HPF: FORALL
Diferenciar sentencias secuenciales de
sentencias paralelas.
“for” secuencial != sentencia paralela (FORALL)
Conceptualmente, ejecuta cada entrada en
paralelo.
Para bucles sin dependencias.
FORALL (i=2:n)
A(i) = A(i-1)
END FORALL
Directivas de HPF: INDEPENDENT
Válida para bucles DO clásicos y para
construcciones FORALL.
Determina que la porción del programa pueda
ser ejecutada en un orden arbitrario.
!HPF$ INDEPENDENT
DO I = 1, 100
A(P(I)) = B(I)
END DO
Directivas de HPF: Funciones
Intrínsecas
Obtener valores reales, específicos del
hardware:
NUMBER_OF_PROCESSORS()
PROCESSORS_SHAPE()
MAXLOC() + DIM
MINLOC() + DIM
Compiladores
ADAPTOR
2 componentes básicas:
Fadapt: traduce de HPF a Fortran90.
Dalib: se encarga del paralelismo.
Traduce a paso de mensajes para memoria
distribuida.
Multithread para memoria comopartida.
Multithreading (invoca a las rutinas de OpenMP)
PGHPF
Southampton Translation
Japoneses...