Paralelización especulativa

Transcripción

1 Sergio Aldea Departamento de Informática Universidad de Valladolid MUI-TIC, curso / 48

2 Índice Conceptos fundamentales Ejecución especulativa por software Especulación + OpenMP Conclusiones 2 / 48

3 Conceptos fundamentales Ejecución especulativa por software Especulación + OpenMP Conclusiones 3 / 48

4 Conceptos fundamentales Paralelismo: motivación Por qué no basta con CPUs más rápidas? Razones teóricas: Límites físicos al rendimiento de un único chip: velocidad de la luz, tamaño de los átomos, disipación del calor... Razones prácticas: Desarrollar nuevos chips es extremadamente caro Solución Utilizar varias CPU para cooperar en la resolución del problema 4 / 48

5 Conceptos fundamentales Paralelismo: motivación Y esto... para qué sirve? Programas de tiempo real Procesamiento masivo de datos (Big Data) Aplicaciones biológicas/médicas. Ej: Plegamiento de proteínas Simulaciones de matemática financiera Técnicas criptográficas Etc, etc... 5 / 48

6 Conceptos fundamentales Paralelización de algoritmos Dos alternativas: manual y automática La paralelización manual de algoritmos es una tarea difícil Requiere conocimientos del problema a paralelizar Requiere conocimientos de las librerías de comunicaciones Requiere conocimientos del hardware subyacente Por otra parte, las soluciones paralelas obtenidas no suelen ser aplicables a otras arquitecturas Solución ideal: dejar la paralelización en manos del compilador 6 / 48

7 Conceptos fundamentales Mecanismos de paralelización automática Identifican fragmentos de código que pueden ejecutarse en paralelo (típicamente bucles) 1. Paralelización automática en tiempo de compilación 2. Paralelización automática en tiempo de ejecución Modelos inspector-ejecutor Modelos de paralelización especulativa Todos están íntimamente ligados al análisis de dependencias Relación entre las lecturas y escrituras sobre una variable que ocurren en distintas iteraciones Afectan a la posibilidad de ejecutar en paralelo un bucle 7 / 48

8 Conceptos fundamentales Ejemplo de dependencia de datos Supongamos el siguiente bucle: do i = 1, lhs=sv[x] SV[x]=rhs end do 8 / 48

9 Conceptos fundamentales Ejemplo de dependencia de datos Con cuatro procesadores podría dividirse el trabajo así: Thread 1 Thread 2 Thread 3 Thread 4 do i = 1, lhs=sv[x] SV[x]=rhs end do do i = 26, lhs=sv[x] SV[x]=rhs end do do i = 51, lhs=sv[x] SV[x]=rhs end do do i = 75, lhs=sv[x] SV[x]=rhs end do 9 / 48

10 Conceptos fundamentales Ejemplo de dependencia de datos Sin embargo, dependiendo del valor de x puede producirse una violación de dependencia: Thread 1 Thread 2 Thread 3 Thread 4 do i = 1, lhs=sv[x] SV[x]=rhs end do do i = 26, lhs=sv[x] SV[x]=rhs end do do i = 51, lhs=sv[x] SV[x]=rhs end do do i = 75, lhs=sv[x] SV[x]=rhs end do 10 / 48

11 Conceptos fundamentales Tipos de dependencia Dependencias WAR (Write After Read): se lee de una variable en una iteración y se escribe sobre ella en una iteración posterior (i1) B = A + C (i2) C = A + D Dependencias WAW (Write After Write): se escribe sobre una misma variable en dos iteraciones consecutivas (i1) B = E + C (i2) B = A + D Dependencias RAW (Read After Write): se escribe en una variable en una iteración y se lee de ella en una iteración posterior (i1) A = B + C (i2) D = A + C 11 / 48

12 Conceptos fundamentales Tipos de dependencia Las dependencias RAW son las más conflictivas Thread 1 Thread 2 Thread 3 Thread 4 do i = 1, lhs=sv[x] SV[x]=rhs end do do i = 26, lhs=sv[x] SV[x]=rhs end do do i = 51, lhs=sv[x] SV[x]=rhs end do do i = 75, lhs=sv[x] SV[x]=rhs end do Si x no es conocido en tiempo de compilación, el compilador no puede paralelizar el bucle. 12 / 48

13 Conceptos fundamentales Modelos de paralelización especulativa En lugar de intentar determinar las dependencias entre las iteraciones, se ejecuta el bucle en paralelo suponiendo que no hay dependencias (ejecución optimista ) Un mecanismo de control (hardware o software) debe encargarse de detectar violaciones de dependencia en tiempo de ejecución y descartar los valores calculados incorrectamente Para cada variable compartida se comprueba si alguno de los hilos que se encuentra ejecutando iteraciones posteriores del bucle ha utilizado un valor antiguo de esa variable. 13 / 48

14 Conceptos fundamentales Ejemplo de aplicación: Cierre convexo Los puntos se procesan uno por uno Algoritmo incremental aleatorizado cuyo número esperado de dependencias está relacionado con la forma del conjunto de datos de entrada. 14 / 48

15 Conceptos fundamentales Ejemplo de aplicación: Cierre convexo Si el nuevo punto cae dentro, la solución no cambia 15 / 48

16 Conceptos fundamentales Ejemplo de aplicación: Cierre convexo Si el nuevo punto cae fuera, la solución sí que cambia 16 / 48

17 Conceptos fundamentales Ejemplo de aplicación: Cierre convexo Si el nuevo punto cae fuera, la solución sí que cambia 17 / 48

18 Conceptos fundamentales Ejemplo de aplicación: Cierre convexo 6 5 Speculative Secuencial 2D-Hull, square input set Especulativo: Speed-ups de hasta 5x con 20 procesadores. 18 / 48

19 Conceptos fundamentales : Ejemplo Thread 1 Thread 2 Thread 3 Thread 4 t10 t0 t1 t3 1) x=1; el thread 1 obtiene el valor de SV[1] 3) x=4; el thread 2 obtiene el valor de SV[4] LocalVar1 = SV[x] SV[x] = LocalVar2 t2 t4 t6 LocalVar1 = SV[x] SV[x] = LocalVar2 t5 t8 t10 5) x=1; el thread 3 obtiene SV[1] del thread 1 LocalVar1 = SV[x] SV[x] = LocalVar2 t6 t7 t9 4) x=1; el thread 4 obtiene SV[1] del thread 1 LocalVar1 = SV[x] SV[x] = LocalVar2 2) El thread 1 escribe en el elemento SV[1] 6) El thread 3 escribe en el elemento SV[1] Tiempo 7) Se detecta una violación de dependencia: se descartan los resultados del thread 4 19 / 48

20 Conceptos fundamentales Operaciones involucradas Thread 1 Thread 2 Thread 3 Thread 4 (i = 1, x = 1) (i = 2, x = 1) (i = 3, x = 2) (i = 4, x = 2) t0 (Thread no especulativo) Escritura especulativa: detección de dependencias (Thread más especulativo) t1 LocalVar1 = SV[x] t2 t3 SV[x] = LocalVar2 t4 t6 LocalVar1 = SV[x] SV[x] = LocalVar2 t5 t8 t10 LocalVar1 = SV[x] SV[x] = LocalVar2 t6 t7 t9 LocalVar1 = SV[x] SV[x] = LocalVar2 Tiempo Consolidación (commit) en orden de las iteraciones correctas Lectura especulativa: obtención del valor más reciente 20 / 48

21 Conceptos fundamentales Resumen de operaciones a realizar Todas las lecturas sobre variables especulativas deben devolver el valor más reciente posible Todas las escrituras sobre variables especulativas deben comprobar que no se producen eventuales violaciones de dependencia. Al final del bloque de iteraciones, cada thread debe realizar una operación de consolidación (commit) de los resultados calculados. 21 / 48

22 Conceptos fundamentales Ejecución especulativa por software Especulación + OpenMP Conclusiones 22 / 48

23 Ejecución especulativa por software Ejecución especulativa por software No requiere cambios en el hardware de la máquina, pero requiere una compilación específica y añade sobrecargas a la ejecución Se añade código al bucle original para la detección y gestión de dependencias La existencia de dependencias puede comprobarse: Al final de la ejecución paralela Al final de la ejecución de un conjunto de iteraciones En cada operación de memoria Los commits parciales y/o finales también se realizan por software 23 / 48

24 Ejecución especulativa por software Modificaciones en la estructura del bucle Supongamos un bucle de N iteraciones, y queremos que se ejecuta en P procesadores. Se reemplaza el bucle por un doall de 1 a P. Cada procesador se encarga de ejecutar un bloque de iteraciones consecutivas. Cuando termina, invoca una función que le asigna un bloque nuevo. Cuando todos terminan, se da por finalizada la ejecución especulativa del bucle. 24 / 48

25 Ejecución especulativa por software Modificaciones en el cuerpo del bucle Todas las lecturas sobre variables especulativas se reemplazan por una función que recupera el valor más reciente para la variable. Todas las escrituras sobre variables especulativas se reemplazan por una función que realiza la escritura y detecta eventuales violaciones de dependencia. Cada thread ejecuta al final de su bloque una función que consolida los resultados calculados y asigna el nuevo bloque de iteraciones a ejecutar. 25 / 48

26 Ejecución especulativa por software Modificaciones antes del bucle Se utiliza OpenMP para clasificar el uso de las variables. Se etiquetan como privadas las variables sobre las que siempre se escribe en una iteración antes de utilizarlas. Se etiquetan como compartidas las variables que sólo se leen. El resto de variables son susceptibles de sufrir una violación de dependencia, son especulativas, pero se etiquetan como compartidas. 26 / 48

27 Ejecución especulativa por software Breve descripción de OpenMP API para programar sistemas de memoria compartida NO es un lenguaje de programación for (i=0; i<10; i++) { b[i] = a[i] + a[i-1] } #pragma omp parallel for for (i=0; i<10; i++) { b[i] = a[i] + a[i-1] } Crea hilos y reparte trabajo entre ellos Variables privadas (a cada hilo) y compartidas No detecta dependencias Nosotros las gestionamos mediante una librería de paralelización especulativa. 27 / 48

28 Ejecución especulativa por software Ejemplo de modificación manual 1: char a; float b; 1: char a; float b; char temp; float value, int tid, threads;... 2: specinit(); 3: threads = omp get num threads(); 4: specstart(max); 5: #pragma openmp parallel for \ private (i,tid,temp,value,...) shared (a,b,threads,...) 6: for (i=0; i<max; i++) { 6: for (tid=0; tid<threads; tid++) { 7: while(true) { 8: i = assign following chunk(tid, MAX,...); Original loop code, part 1 Original loop code, part 1 9: a = f(b); 9: specload(&b, sizeof(b),..., &value); 10: temp = f(value); 11: specstore(&a, sizeof(a),..., &temp); Original loop code, part 2 Original loop code, part 2 12: commit or discard data(tid,...); 13: if(no chunks left(tid, MAX,...)) break; 14: } 15: } 15: } (a) Original (b) Código transformado 28 / 48

29 Ejecución especulativa por software Problemas paralelización especulativa manual Requiere conocimientos del problema a paralelizar Requiere conocimientos de la libreria TLS utilizada Requiere tiempo No estaría bien que todo ese proceso de transformación fuera automático? Solución 1. Definir una nueva cláusula speculative para etiquetar las variables especulativas 2. Modificar un compilador para que: reconozca la cláusula realice las transformaciones necesarias 29 / 48

30 Conceptos fundamentales Ejecución especulativa por software Especulación + OpenMP Conclusiones 30 / 48

31 Especulación + OpenMP Nueva cláusula OpenMP: speculative Identifica aquellas variables conflictivas, que pueden ocasionar violaciones de dependencia #pragma omp parallel for speculative (list) for-loop Ejemplo: #pragma omp parallel for default(none) private(i, Q, aux) speculative(a) for (i = 0; i < MAX; i++) { Q = i % (MAX) + 1; aux = a[q-1]; } Q = (4 * aux) % (MAX) + 1; a[q-1] = aux; 31 / 48

32 Especulación + OpenMP Qué cambios implica la cláusula speculative? 1. Inicializar el motor (specinit() y spectart()) 2. Cambiar la definición del bucle para repartir el trabajo entre los hilos 3. Reemplazar cada escritura/lectura por su variante especulativa (specload() y specstore()) 4. Comprobar dependencias, y consolidar las iteraciones correctas 32 / 48

33 Especulación + OpenMP Qué cambios implica la cláusula speculative? 1: char a; float b; 1: char a; float b; char temp; float value, int tid, threads;... 2: specinit(); 3: threads = omp get num threads(); 4: specstart(max); 5: #pragma openmp parallel for \ 5: #pragma openmp parallel for \ private (i) speculative (a,b) private (i,tid,temp,value,...) shared (a,b,threads,...) 6: for (i=0; i<max; i++) { 6: for (tid=0; tid<threads; tid++) { 7: while(true) { 8: i = assign following chunk(tid, MAX,...); Original loop code, part 1 Original loop code, part 1 9: a = f(b); 9: specload(&b, sizeof(b),..., &value); 10: temp = f(value); 11: specstore(&a, sizeof(a),..., &temp); Original loop code, part 2 Original loop code, part 2 12: commit or discard data(tid,...); 13: if(no chunks left(tid, MAX,...)) break; 14: } 15: } 15: } (a) Original anotado (b) Código generado automáticamente en GCC 33 / 48

34 Especulación + OpenMP Implementación en un compilador Durante la compilación: la cláusula debe ser reconocida como válida, y activar las transformaciones necesarias para paralelizar especulativamente el bucle. Enlazar con la librería de paralelización especulativa. Compilador elegido: GCC Maduro, estable, con soporte para más de 30 arquitecturas. Mayor impacto mediático. Mediante el mecanismo de plugins de GCC. 34 / 48

35 Especulación + OpenMP Arquitectura GCC C parser Front End Middle End Back End GIMPLE RTL C++ parser Plugin Pass Fortran parser GENERIC Interprocedural Optimizer RTL Optimizer Call Graph Manager Java parser SSA Optimizer Final Code Generation Pass Manager Assembly 1. Reconocimiento de la cláusula: Actualización del parser de GCC. 2. Transformaciones: Realizadas por un plugin, que actúa sobre el código en GIMPLE, antes de que el compilador realice el resto de optimizaciones. 35 / 48

36 Especulación + OpenMP Proceso de compilación Compiler parameters: - Threads - Block size Programmer Code C + OpenMP with speculative clause GCC plugin Linker Binary executable TLS Runtime library Ejecución: $ atlas --threads T --block B -c example.c 36 / 48

37 Especulación + OpenMP Ventajas cláusula speculative Menor número de ĺıneas para paralelizar un código Sólo requiere clasificar las variables utilizadas en el bucle No es necesario conocer los detalles de la librería especulativa Independencia del motor especulativo subyacente Permite paralelizar bucles que de otro modo no serían paralelizables 37 / 48

38 Especulación + OpenMP Evaluación Ejemplo de aplicaciones sintética : 0: #define NITER : int array[max], array2[max]; 2: struct card{ int field; }; 3: struct card p1 = {3}, p2 = {99999}, p3 = {11111}; 4: char aux char = a ; 5: double aux double = 3.435; 6: int i, j;... 7: #pragma omp parallel for default (none) \ 8: private(i, j) shared(array1, p2) \ 9: speculative(p1, p3, aux char, aux double, array2) 10: for ( i = 0 ; i < NITER ; i++ ) { 11: for ( j = 0 ; j < NITER ; j++ ) { 12: if (i <= 1000) p1.field = array[i % 4] + j; 13: else array2[i % 4] = p1.field; 14: if (i > 2000) aux char = i % aux char % 48; 15: else aux char = i % 20 + array[i % 4] % ; 16: if (i > 1500) aux double = array[i % 4] / (i+1) + aux double; 17: else array2[i % 4] = (int) (aux double / i*j) + (array2[(i+j) % 4] + i*j) % ; 18: if (i*j > 10000) p1 = p2; else p3 = p1; 19: } 20: } 38 / 48

39 Especulación + OpenMP Especulación manual vs. automática Número de ĺıneas requeridas para paralelizar especulativamente de forma manual vs. automática, y su rendimiento relativo. # de ĺıneas Rendimiento relativo por # de procesadores Aplicación Auto Manual D-Hull Delaunay hmmer Average Rendimientos similares para manual y automático: ±1,72 %. Manualmente, el número de ĺıneas a añadir/modificar depende del número de accesos a variables especulativas. 39 / 48

40 Especulación + OpenMP Duda razonable Vale bien, pero... El programador aún tiene que hacer el esfuerzo de analizar el código y clasificar las variables según su uso. 40 / 48

41 Especulación + OpenMP Proyecto MUI-TIC Original C file XMLCetus XML Modified XML Sirius Resulting C file XML Intel profiling information Profilazer XML augmented Loopest Analysis report XMLCetus: Genera un representación XML a partir de un código fuente. Profilazer: Extiende el fichero XML con información de profiling Loopest: Analiza el fichero XML y extrae información Sirius: Transforma XML a C. 41 / 48

42 Especulación + OpenMP Proyecto MUI-TIC Los informes permite al programador saber: Por cada bucle, la clasificación de las variables según su uso Reconocimiento de barreras al paralelismo: Funciones I/O, gestión de memoria, etc. Trazas de dependencias de una variable en diferentes puntos del código Tiempo de ejecución de cada bucle respecto del total Obtener una visión global del grado de paralelismo de la aplicación 42 / 48

43 Conceptos fundamentales Ejecución especulativa por software Especulación + OpenMP Conclusiones 43 / 48

44 Conclusiones Conclusiones La ejecución especulativa presenta un gran potencial para la extracción del paralelismo inherente a muchos bucles. Añadir soporte para paralelización especulativa a OpenMP incrementa el número de bucles que se pueden paralelizar mediante este modelo. Potencialmente, permite transformar cualquier bucle en un bucle paralelo (sin importar las dependencias) Si el programador no está seguro sobre las dependencias, podría etiquetar esas variables como especulativas. 44 / 48

45 Conclusiones Conclusiones El proceso es transparente para los programadores. No necesitan conocer nada del modelo de paralelización especulativa subyacente. Sólo necesitan añadir una ĺınea de código. El compilador detecta la nueva cláusula speculative, y realiza todas las transformaciones necesarias para paralelizar el código. Independientemente del tipo de datos de las variables: punteros, estructuras, etc. 45 / 48

46 Conclusiones Conclusiones La pregunta de cuál es el potencial real de la ejecución especulativa por software sigue pendiente de respuesta. Seguimos trabajando en dos áreas relacionadas: La transformación automática de bucles secuenciales en bucles susceptibles de ser ejecutados especulativamente. Una ejecución especulativa eficiente y robusta, que pueda utilizarse en aplicaciones comerciales. (Álvaro Estébanez) 46 / 48

47 PREGUNTAS? 47 / 48

48 Sergio Aldea Departamento de Informática Universidad de Valladolid MUI-TIC, curso / 48