Análisis y Modelos para SGI O2000

Transcripción

1 Apéndice D Análisis y Modelos para SGI O2 En este apéndice se modelan y analizan el algoritmo de ordenación Radix sort y las técnicas de particionado Reverse Sorting, Counting Split y la técnica combinada de estas dos, Mutant Reverse Sorting, en un computador SGI O2 con procesadores R1K. El análisis se efectúa estudiando las ejecuciones reales y los modelos desarrollados para estos algoritmos. En concreto, se han realizado los modelos para el algoritmo de ordenación Radix sort y las técnicas de particionado Reverse Sorting y Counting Split. En este apéndice se mostrará una comparativa de los obtenidos con este modelo y las ejecuciones reales. Para la técnica combinada Mutant Reverse Sorting, se muestran las ejecuciones reales para comprobar que ésta elige la mejor técnica de particionado dependiendo de las características de los datos y el computador. Para esto, se muestra una comparativa de los resultados obtenidos para esta técnica con los resultados para Reverse Sorting y Counting Split. Los resultados de los algoritmos de ordenación secuenciales y paralelos, que proponemos en esta tesis (los cuales utilizan el particionado Mutant Reverse Sorting), se muestran en los Capítulos 4 y 5 respectivamente. La filosofía y nomenclatura de los modelos desarrollados se explican en el Apéndice B. Las características de el SGI O2 y los procesadores R1K se explican en el Capítulo 1, las más importantes están resumidas en la Tabla 1.1 del mismo Capítulo. D.1. Análisis de Radix sort Las Figuras D.1 y D.2 muestran los de las ejecuciones reales sobre un R1K, ordenando con Radix sort diferentes conjuntos de datos para claves de 32 y 64 bits respectivamente. En las Figuras mostramos los según el modelo desarrollado con líneas discontinuas. Veremos el desarrollo detallado de este modelo en la sección 173

2 174 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 siguiente. Con líneas discontinuas se muestran los según el modelo desarrollado, que veremos en detalle en la sección siguiente R R n*1k Figura D.1: Ordenación con Radix sort para claves y punteros de 32 bits para un R1K. R se refiere a los resultados de ejecución y R a los según nuestro modelo; ambas curvas son para una distribución Random R R n*1k Figura D.2: Ordenación con Radix sort para claves y punteros de 64 bits para un R1K. R se refiere a los resultados de ejecución y R a los según nuestro modelo. El número de dígitos es m = 8. En ambas figuras podemos observar un aumento del número de a partir de 256K y 128K elementos para 32 y 64 bits respectivamente. Tal y como pasaba con un Power4 (mostrado en el Capítulo 2 de la tesis), Radix sort no explota adecuadamente la localidad de los datos. A partir de un cierto tamaño del conjunto de datos, Radix sort empieza a tener un mayor número de fallos de cache y TLB por elemento ordenado (número total de fallos dividido entre n, que es el número de elementos a ordenar). Aquí, además, el número de fallos de TLB es notablemente superior al obtenido con Power4. Esto es debido a que el número de entradas de TLB es de sólo 64 entradas

3 D.1. ANÁLISIS DE RADIX SORT 175 R1K Fallos/n 32 bits 64 bits Primer Nivel 2,868 9,5 (,5 / 1,125) Segundo Nivel,541 2,81 (,125 /,193) TLB 3,18 6,22 (,1 /,778) Tabla D.1: Fallos del primer y segundo nivel de cache y de TLB, dividido entre el total de elementos a ordenar, n=2m para una distribución Random. Para 64 bits mostramos resultados para un número de dígitos m = 8 y diferenciamos la parte correspondiente al paso de Conteo y la media por Movimiento. en un R1K, en contraposición de las 124 entradas del TLB de un Power4. Por consiguiente, si los dígitos de las claves en Radix sort son de 8 bits (ya sea para claves de 32 o 64 bits), eso significa que posiblemente estemos escribiendo en 256 páginas de memoria diferentes del vector destino D durante los pasos de movimiento del algoritmo Radix sort. Esto provoca que la probabilidad de conflicto en el TLB sea mucho mayor, próxima a 1. Los fallos de los diferentes niveles de memoria cache y TLB por elemento ordenado se muestran en la Tabla D.1. Para los datos de 64 bits se muestran el número de fallos por elemento ordenado del paso de conteo y el de movimiento por separado y entre paréntesis. Se puede observar que el número de fallos de TLB es bastante elevado y se acerca a 1 fallo por elemento ordenado para el paso de movimiento. Para más detalles sobre las causas de este número de fallos elevado, véase el Capítulo 2. Modelo En esta sección se va a modelar el algoritmo Radix sort según el modelo secuencial descrito en el apéndice B para el procesador R1K de un SGI O2. Para ello, analizaremos cada uno de los pasos del algoritmo (ver Capítulo 2 para más detalle sobre el Algoritmo) 1. Paso (1) - Inicialización de Contadores: Los de este paso se pueden despreciar ya que sabemos que los dígitos no son muy grandes. 2. Paso (2) - Conteo: Al igual que se hizo con el Power4, nos centraremos en los para cada iteración separados según debido a: accesos al primer nivel de memoria cache, fallos de memoria cache, fallos de TLB y operaciones que no son de lectura ni escritura.

4 176 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 Accesos al primer nivel de memoria cache. Se realiza una lectura para obtener la clave del vector fuente (C a ciclos). Con esta clave se actualiza el valor de un contador por cada dígito, es decir, d contadores. Esta actualización supone d lecturas que sólo se pueden lanzar a ejecutar de una en una (d +C a 1) y d escrituras que también se tienen que lanzar una a una (d + C a 1). El coste para los accesos al primer nivel de cache es: cpu accesos = C a + 2(d + C a 1) = 3C a + 2(d 1) Fallos de memoria cache. Por un lado, tenemos la lectura de las claves del vector fuente, que es secuencial. A diferencia del Power4, en el R1K no hay prefetch hardware que se active al detectar fallos de cache en accesos secuenciales. Por lo tanto, se contarán todos los fallos obligatorios y de capacidad que se produzcan accediendo a las estructuras de datos. En este caso accedemos al vector fuente de forma secuencial (C f1 /R 1 +C f2 /R 2 ciclos por fallos de primer y segundo nivel de cache). Por otro lado, se realiza la actualización de un contador. Sin embargo, por el hecho de que el número de contadores es reducido y se acceden frecuentemente, supondremos que estos contadores siempre se encuentran en el primer nivel de memoria cache. Además, en la actualización, las escrituras se realizan solamente en el primer nivel de cache si el dato está presente en ese nivel de memoria. Por consiguiente, la actualización de los contadores no incrementa los debido a fallos de memoria cache, que es de: mem mc = C f1 /R 1 + C f2 /R 2 Fallos de TLB: Fallos obligatorios y de capacidad accediendo al vector fuente. El número total de debido a estos fallos es de: mem TLB = C ftlb /R page Operaciones que no son lecturas ni escrituras: El número de debido a estas operaciones es despreciable ya que se solapan con los accesos al primer nivel de cache para actualizar los contadores. El número de para este paso es el siguiente: cont = 3C a + 2(d 1) + C f1 /R 1 + C f2 /R 2 + C ftlb /R page 3. Paso (3) - Suma Parcial: El coste para este paso lo podemos despreciar.

5 D.1. ANÁLISIS DE RADIX SORT Paso (4) - Movimientos: Analizaremos los para un sólo movimiento. En el cálculo de los para todo el algoritmo de Radix sort lo multiplicaremos por el número de movimientos, d (uno para cada dígito). Lo analizaremos de la misma forma que lo hicimos para el paso de conteo (Paso (2)). Los para un paso de movimiento son debidos a varios aspectos: Accesos al primer nivel de memoria cache: Lectura de la clave y el puntero del vector fuente. El procesador R1K sólo dispone de una unidad funcional de lectura y/o escritura, por consiguiente, el número de de las dos lecturas es de 2+(C a 1) ciclos. Después se lee el contador asociado al valor del dígito ( C a ciclos). Finalmente, se actualiza el contador y se escribe la clave y el puntero en el vector destino, por lo que hay tres escrituras que se traducen en 3 + (C a 1) ciclos. cpu accesos = 3 + 3C a Fallos de memoria cache. En la lectura del vector fuente tenemos la misma penalización vista en el paso de conteo ( C f1 /R 1 + C f2 /R 2 ciclos ). Además, tenemos la escritura de la clave y el puntero en el vector destino D y la actualización del contador correspondiente. Cuando se escribe en cada una de las particiones, sobre el vector D, esta escritura es secuencial con respecto a cada partición. Por consiguiente, para las escrituras en el vector D contamos los fallos obligatorios y de capacidad, por lo que tenemos C f1 /R 1 + C f2 /R 2 ciclos más. En cuanto a la actualización del contador, tendremos que todos los contadores están en el primer nivel de memoria y por consiguiente, no habrá fallos. Así, los para este apartado son: mem mc = 2(C f1 /R 1 + C f2 /R 2 ) Fallos de TLB: Por un lado, tenemos la penalización por fallos obligatorios y de capacidad, leyendo el vector fuente (C ftlb /R page ciclos) y escribiendo en el vector destino (C ftlb /R page ciclos). El vector fuente se accede de forma secuencial. Tal y como se ha comentado antes, se puede considerar que la escritura sobre el vector destino también se hace de forma secuencial. Por otro lado, debido a que estamos trabajando con dígitos de 8 bits y, por consiguiente se estarán creando 256 particiones, es posible que tengamos 256 páginas de memoria activas. Por lo tanto, el número de fallos de TLB puede ser mucho mayor que el número de fallos de TLB únicamente debidos

6 178 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 a los fallos obligatorios y de capacidad ya que el número de entradas de TLB del R1K es 64. En las Figuras D.1 y D.2 se muestran los del modelo suponiendo la probabilidad de fallo por conflicto p f tal que que la probabilidad de fallo de TLB escribiendo en el vector destino D sea 1. El número de por fallos de TLB asciende a: 2 cpu TLB = C ftlb ( + p f ) R page Operaciones que no son de lectura ni escritura: Este coste es despreciable El número de de un movimiento es, por lo tanto: mov = 3 + 3C a + 2( C f1 + C f2 ) R 1 R C ftlb ( + p f ) R page El número total de del algoritmo de Radix sort es de: rad = 3(1 + d)c a + 5d + (1 + 2d)( C f1 R 1 + C f2 R 2 ) + (1 + 2d) C ftlb R page + dc ftlb p f D.2. Reverse Sorting D.2.1. Análisis del Algoritmo Secuencial Las Figuras D.3 y D.4 muestran los resultados de las ejecuciones sobre un R1K para conjuntos de datos que no pueden ser mapeados por el TLB (2M bytes de memoria) para claves de 32 y 64 bits respectivamente. Para ambas figuras, en la gráfica de la izquierda se muestran resultados para diferentes números de claves y punteros. En la gráfica de la derecha mostramos los resultados para 2M datos de clave y puntero. En las Figuras se muestran con líneas discontinuas los según el modelo que se detalla en la sección siguiente. Podemos observar lo siguiente:

7 D.2. REVERSE SORTING R R S2 S2 D1 D Mov S. Par. Count Ini n*1k R R S2 D1 Figura D.3: experimentales (continua) y del modelo (discontinua) para Reverse Sorting para distribuciones Random, S2 y D1, de 1K a 2M elementos de 32 bits (izquierda). para 2M de datos divididos en los de los diferentes pasos de Reverse Sorting (derecha) n*1k R R S2 S2 D1 D Mov S. Par. Count Ini R R S2 D1 Figura D.4: experimentales (continua) y del modelo (discontinua) para Reverse Sorting para distribuciones Random, S2 y D1, de 1K a 2M elementos de 64 bits (izquierda). para 2M de datos divididos en los de los diferentes pasos de Reverse Sorting (derecha).

8 18 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 Para claves de 32 bits (Figura D.3), el número de para las distribuciones S2 y D1 es mayor que el de la distribución Random. Esto es debido a que para datos con distribuciones S2 y D1, el particionado con Reverse Sorting tiene que realizar 2 y 7 iteraciones de Reverse Sorting respectivamente, mientras que para la distribución Random sólo es necesaria una iteración. Esto se puede observar mejor en los invertidos para cada una de las distribuciones en los pasos de conteo y movimiento mostrados en la gráfica de la derecha de la Figura D.3. Otra cosa que podemos observar es que a partir de 5K elementos, el coste para las tres distribuciones de datos aumenta más o menos significativamente. A partir de 5K elementos, el vector a ordenar S ya no cabe en el segundo nivel de cache del R1K y, por consiguiente, se tiene que ir a buscar dos veces a memoria; una en el paso de conteo y otra en el paso de movimiento ya que el vector fuente no estará en la cache de un paso al otro debido a los conflictos y a la capacidad de la cache. Para conjuntos de datos de menos 5K, el vector fuente está en el segundo nivel de memoria cache para la segunda lectura que se realiza en el paso de movimiento. Para claves de 64 bits (Figura D.4) el número de iteraciones de Reverse Sorting para S2 y D1 es aún mayor que para 32 bits. Para el caso de D1, se tienen que hacer 13 iteraciones de Reverse Sorting. Esto se debe a que cada vez que se haga una iteración de Reverse Sorting obtendremos una partición con todos los datos y el resto de particiones vacías. El proceso de particionado se acabará cuando no haya más bits a ordenar de la clave, es decir, tras 64 b r iteraciones de Reverse Sorting, siendo b r = 5. Para S2, el incremento en el número de iteraciones de Reverse Sorting necesarias se observa en los 5K elementos, de ahí el aumento del número de. Cuando el número de elementos a ordenar es inferior a 5K, la primera partición efectiva que hacemos con una iteración de Reverse Sorting, nos divide los datos en conjuntos que ya no precisan más particionado. Para un número mayor de elementos, es preciso realizar otro particionado. A parte, sea cual sea la distribución, cuando el conjunto de datos supera los 2K elementos, el número de aumenta. Para ese conjunto de datos a ordenar, las estructuras para realizar la ordenación no caben en el segundo nivel de cache. Además, en el caso de la distribución S2, cuando el conjunto de datos es superior a 1M de datos, las particiones obtenidas en la primera iteración de Reverse Sorting también superan los 2K elementos. De ahí el incremento del número de en la segunda iteración de Reverse Sorting ya que las particiones

9 D.2. REVERSE SORTING 181 R1K 32 bits 64 bits Fallos/n C C m M M m C C m M M m Primer Nivel,25,25,5,5,5,5 1, 1, Segundo Nivel,6,6,12,12,12,12,25,25 TLB,,,,,,,, Tabla D.2: Fallos de acceso al primer y segundo nivel de cache y de TLB, dividido entre el total de elementos a ordenar, 2M datos para una distribución Random. C y M son el paso de conteo y de movimiento respectivamente. C m y M m son los cálculos según nuestro modelo. que se tienen que particionar otra vez, no caben en el segundo nivel de memoria cache. En la tabla D.2 se muestran los fallos de memoria cache y de TLB según el modelo desarrollado (C m y M m, para el paso de conteo y movimiento respectivamente) y las ejecuciones reales por elemento ordenado, es decir, dividido entre n. Los resultados son para 2M datos de 32 y 64 bits a ordenar. Como podemos observar, el modelo se aproxima mucho a las ejecuciones reales. De los resultados se desprende que se ha conseguido reducir significativamente el número de fallos de TLB al aplicar el algoritmo de conteo, cuando antes para Radix sort se tenía un número significativo de fallos. En la Tabla se muestra que el número de fallos de TLB por elemento a ordenar es,; en realidad es de,1 y,2 para 32 y 64 bits respectivamente, lo cual es realmente poco significativo. Modelo para Reverse Sorting Secuencial A continuación modelaremos el coste en de una iteración de Reverse Sorting. En el modelo para la técnica Reverse Sorting tenemos en cuenta las mismas suposiciones que para el modelo de Radix sort para este computador. Una iteración de Reverse Sorting consta de los siguientes pasos: 1. Paso (1) - Inicialización Contadores: El coste para este paso es despreciable. 2. Paso (2) - Conteo: El razonamiento es el mismo que para el paso de conteo de Radix sort. Sin embargo, aquí sólo se incrementa un contador, por lo que el número de por accesos al primer nivel de cache será menor. El número de

10 182 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 es: cont = 3C a + (C f1 /R 1 + C f2 /R 2 ) + + (C ftlb /R page ) 3. Paso (3) - Suma Parcial: Los para este paso son despreciables. 4. Paso (4) - Movimiento: Los del paso de movimiento son exactamente los mismos que los de un paso de movimiento de Radix sort. mov = 3 + 3C a + + 2(C f1 /R 1 + C f2 /R 2 ) + + 2C ftlb /R page El número total de de una iteración de Reverse Sorting es el siguiente: sec una itrev = 3 + 6C a + + 3(C f1 /R 1 + C f2 /R 2 ) + + 3C ftlb /R page Para calcular el número total de invertidos en el particionado con Reverse Sorting se calcularía de la misma forma que se hizo para el computador basado en p63, en la sección C.2.1 del Apéndice C. D.2.2. Análisis del Algoritmo Paralelo En la Figura D.5 se muestran los invertidos al particionar con Reverse Sorting Paralelo cuando se realizan 1, 2, ó 3 iteraciones de Reverse Sorting. En estas figuras distinguimos los (acumulado) para los pasos más significativos del particionado paralelo. La gráfica de arriba muestra los para 2M de datos a ordenar de claves de 64 bits para una cantidad de 2 a 32 procesadores. La gráfica de abajo muestra los para 2PM de datos a ordenar de claves de 64 bits, es decir 2M datos por procesador, para 2 a 32 procesadores. Los que se muestran son, de arriba a abajo, de preparación de mensajes (prepare), para el Paso (5) de comunicación de datos (All to All), para la comunicación de los contadores (Paso (2) del algoritmo, (Comunicación de contadores, transpose), por cálculo y evaluación de la repartición de particiones, Paso (3) del algoritmo (Eval) y por Reverse Soring local, Paso (1). No mostramos los resultados para 32 bits porque las conclusiones que obtenemos son las mismas. En la misma gráfica mostramos, con líneas discontinuas, los según el

11 D.2. REVERSE SORTING 183 modelo que explicamos en la siguiente sección. Modelo y ejecuciones reales muestran la misma tendencia en. Por un lado, analizando la gráfica de arriba de la Figura D.5, donde el conjunto a ordenar entre todos los procesadores es de 2M datos de clave y puntero, podemos llegar a estas conclusiones: Para un mismo número de procesadores, si aumenta el número de iteraciones de Reverse Sorting, los para los pasos de Reverse Sorting Local y comunicación de contadores aumentan. Para el paso de Reverse Sorting Local es lógico ya que se realizan más iteraciones de Reverse Sorting. En cuanto al paso de comunicación de contadores también es normal que aumente ya que cada iteración adicional significa más comunicación de contadores para saber el número de datos por partición. Para un mismo número de iteraciones, al aumentar el número de procesadores, el coste de comunicación de contadores (transpose en la gráfica) aumenta. Esto se puede observar fácilmente cuando el número de iteraciones es 3. Para un mismo número de datos a comunicar y un mismo número de iteraciones, cuando aumentamos el número de procesadores, los de comunicación de datos (Alltoall en la Figura) disminuyen; a excepción de cuando pasamos de 16 a 32 procesadores debido al desequilibrio de carga. El ancho de banda entre procesadores dentro o fuera de un mismo nodo no es muy diferente. Por consiguiente, no hay el aumento de que se produce en el computador basado en p63 cuando se tienen que comunicar datos entre diferentes nodos. En el SGI Origin 2, a diferencia del computador basado en p63, no hay aumento del número de para comunicar la misma cantidad de datos cuando vamos aumentando el número de procesadores. En el computador basado en p63 se produce un aumento de los por la reducción del ancho de banda cuando se pasa de comunicar datos sólo dentro de un nodo a cuando se comunican entre nodos. Para el computador SGI O2, la diferencia entre anchos de banda que se puede conseguir no es tan grande y sólo es la comunicación entre dos procesadores la que se ve beneficiada. Por otro lado, analizando el comportamiento del algoritmo cuando se ordenan 2M datos por procesador en la gráfica de arriba de la Figura D.5, se observa lo siguiente: Los pasos con un número de ciclos totales constante, Prepare y Eval en las gráficas, reducen el número de al aumentar el número de elementos a ordenar con respecto a los para ordenar un número total fijo de datos. El número de de comunicación de contadores es menor. Sin embargo, a partir de la cuarta iteración de Reverse Sorting (no mostrada en la Figura), este paso empieza a ser significativo.

12 184 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O Prepare All to all Transpose Eval Reverse Local Modelo Figura D.5: invertidos en los pasos de Reverse Sorting paralelo para 2M (arriba) y 2PM (abajo) elementos de clave y puntero de 64 bits con el SGI O2 usando de 2 a 32 procesadores. Se muestran los resultados para cuando Reverse Sorting debe hacer 1,2, ó 3 iteraciones.

13 D.2. REVERSE SORTING 185 El número de de comunicación de datos (All to All), para un mismo número de iteraciones, siempre se reducen al aumentar el número de procesadores. En el SGI O2, ya sea con un número total fijo de elementos o un número fijo de elementos por procesador, los de preparación de mensajes (Prepare en las Figuras) es menos significativo que en el computador basado en p63, ya que el número de particiones obtenidas en la primera iteración de Reverse Sorting es menor. Ahora el tamaño del dígito de Reverse Sorting es b r = 5 para todas las iteraciones, creándose solamente 32 particiones. En el computador con p63, en la primera iteración se crean 512 particiones, por lo que la preparación de estas particiones es más costosa. Finalmente, se analiza el desequilibrio de carga obtenido para dos distribuciones de datos: Random y Gaussian. Aquí entendemos desequilibrio de carga como la desviación estándar con respecto a distribuir equitativamente los datos entre los procesadores. No se estudia qué sucede con el resto de distribuciones de datos analizadas en este documento porque sabemos que serían necesarias más de 2 iteraciones de Reverse Sorting y, por consiguiente, el número de sería significativamente alto. En una distribución Gaussian, se necesitan 2 iteraciones para conseguir un equilibrio de carga entre los procesadores. En las Figuras D.6 y D.7 se muestra el desequilibrio de carga obtenido para un número fijo de datos a ordenar (izquierda) y para un número de datos fijo por procesador (derecha) para las distribuciones Random y Gaussian respectivamente. Nótese que el rango de% es hasta 1% para la gráfica de la izquierda y 1% para la de la derecha. El desequilibrio de carga obtenido cuando el número de elementos a ordenar es fijo por procesador es muy reducido. Sin embargo, cuando el número total de elementos a ordenar es fijo, el desequilibrio de carga aumenta a medida que aumentamos el número de procesadores. Las causas de este aumento en son las siguientes: 1. Por un lado, el número de particiones que realizamos, 32, es pequeño en comparación con el número de procesadores que va aumentando. 2. Por otro lado, permitimos un desequilibrio de carga que puede hacer que haya procesadores que se queden sin elementos a ordenar. Esto es debido a que se quiere evitar tener que pagar un mayor número de por tener que realizar más iteraciones de Reverse Sorting. Modelo para Reverse Sorting Paralelo El tipo de modelo paralelo que seguimos es el que describimos en el Apéndice B. El modelo para el particionado con Reverse Sorting paralelo es el mismo que el desarrollado para el computador basado en p63 en el Apéndice C, variando τ, α y los de alguno de los cal ; esto último por tener diferente procesador y jerarquía de

14 186 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 1 Desq. 2M 1. Desq. 2P M % 4 % Figura D.6: Desequilibrio de carga según la desviación estándar para 2M datos a ordenar (izquierda) y 2P M datos a ordenar (derecha). Resultados para una distribución Random en el SGI O2, variando el número de procesadores. 1 Desq. 2M 1. Desq. 2P M % 4 % Figura D.7: Desequilibrio de carga según la desviación estándar para 2M datos a ordenar (izquierda) y 2P M datos a ordenar (derecha). Resultados para una distribución Gaussian en el SGI O2, variando el número de procesadores.

15 D.3. COUNTING SPLIT memoria. Para el computador SGI O2, τ es 5 ciclos y α es = 1,42 ciclos 3(,16) por byte. La Figura D.8 muestra los según el modelo para las diferentes partes del algoritmo de particionado Reverse Sorting Paralelo. En estas figuras se muestran los para 1, 2 y 3 iteraciones de Reverse Sorting paralelo. En estas figuras distinguimos el coste (acumulado) para los pasos más significativos del particionado paralelo tal y como se explicó en la sección anterior. La gráfica de arriba muestra los para ordenar 2M datos de clave y puntero de 64 bits entre todos los procesadores y la gráfica de abajo muestra los para ordenar 2M de datos de clave y puntero de 64 bits por procesador. Los para cada una de las partes distinguidas en la Figura, muestran la misma tendencia que las mostradas en la Figura D.7 donde se muestran las ejecuciones reales. Por lo tanto, las conclusiones que se extraen son las mismas que se dieron en la sección anterior. D.3. Counting Split D.3.1. Análisis del Algoritmo Secuencial En las Figuras D.9 y D.1 mostramos los para el particionado con Counting Split, realizando 32 particiones, para 32 y 64 bits respectivamente. En ellas mostramos los de ejecuciones reales para distribuciones Random, S2 y D1 con líneas continuas, y con líneas discontinuas, los según el modelo que desarrollamos en la siguiente sección para una distribución Random. Al igual que vimos con el Power4, los para el paso de conteo del Counting Split tiene un peso más significativo que el que obtuvimos para Reverse Sorting, cuando sólo es preciso realizar una iteración de Reverse Sorting. En la gráfica de la derecha de las Figuras D.9 y D.1 se observa que los del conteo según el modelo es mayor que los reales. La razón está en que en el modelo no hemos supuesto ningún tipo de solapamiento entre las operaciones de comparación y acceso a memoria en el paso de conteo. Esto lo creemos así porque los fallos de memoria cache y TLB por dato ordenado para el modelo y ejecución real son muy similares. En la tabla D.3 mostramos los fallos de primer y segundo nivel de cache, y de TLB para modelo y ejecución para 2M de datos (de 32 y 64 bits). Por otro lado, en la Tabla D.3 se dice que el número de fallos de TLB por elemento a ordenar es,, aunque en realidad es menor que,19 para ambos tipos de datos. En cualquier caso, es muy poco significativo y esto es porque el particionado es consciente de la jerarquía de memoria. Finalmente, en el R1K, no se observa una disminución notable del número de para la distribución D1 con respecto a los cuando se particiona una distribución Random, aunque el número de fallos de predicción de saltos se reduce drásticamente. Esto es debido a que la penalización media por una mala predicción de salto en el

16 188 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 1 8 All to all Transpose Eval Reverse Local Figura D.8: invertidos, según el modelo, en los pasos de Reverse Sorting paralelo para 2M datos (arriba) y 2PM datos (abajo) de clave y puntero de 64 bits con el SGI O2 usando de 2 a 32 procesadores. Se muestran los para cuando se hacen 1,2 ó 3 iteraciones de Reverse Sorting.

17 D.3. COUNTING SPLIT 189 R1K 32 bits 64 bits Fallos/n C C m M M m C C m M M m Primer Nivel,28,28,53,53,53,53 1,3 1,3 Segundo Nivel,6,7,13,12,12,13,26,25 TLB,,,,,,,, Tabla D.3: Fallos de acceso al primer y segundo nivel de cache y de traducción del TLB, dividido entre el total de elementos a ordenar, 2M datos para una distribución Random. C y M son el paso de conteo (4.2) y de movimiento (4.4) respectivamente. C m y M m son los cálculos según nuestro modelo para estos pasos R R S2 D Mov S. Par. Count Ini n*1k R R S2 D1 Figura D.9: experimentales (continua) y del modelo (discontinua) para el Counting Split para distribuciones Random, S2 y D1, de 1K a 2M elementos de 32 bits (izquierda). para 4M de datos, divididos en los diferentes pasos del Counting Split (derecha).

18 19 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O R R S2 D Mov S. Par. Count Ini n*1k R R S2 D1 Figura D.1: experimentales (continua) y del modelo (discontinua) para el Counting Split para distribuciones Random, S2 y D1, de 1K a 2M elementos de 64 bits (izquierda). para 2M de datos, divididos en los diferentes pasos del Counting Split (derecha). R1K es de 5 ciclos de procesador.se debe recordar que para Power4, la disminución en es notable porque cada fallo de predicción de saltos supone un mínimo de 12 ciclos de penalización. Por lo que cuando se reducen los fallos de predicción, el rendimiento del algoritmo crece, es decir, se reduce el número de. Es importante resaltar que se ha hecho una implementación desenrollada de la búsqueda binaria para el Counting Split. La búsqueda binaria se hace en el paso de conteo del algoritmo de Counting Split. Para ello, en la Figura D.11 se muestran los para la implementación de la búsqueda binaria explícita (desenrollada) y una implementación con un bucle cuando particionamos un conjunto de 2M datos de clave y punteros de 64 bits y una distribución Random. Como se puede observar, la diferencia en es notable. Entre las diferentes causas, tenemos que posiblemente nos ahorremos instrucciones de saltos, que el compilador tiene mayor número de instrucciones a intercalar, y, además, que posiblemente se reduzcan los accesos a memoria ya que las claves del vector de separadores se guardan en variables, que posiblemente acaben guardándose en registros. Modelo para el Counting Split Secuencial Nos vamos a centrar en los pasos (4.2) y (4.4), conteo y movimiento respectivamente, del Algoritmo 8 explicado en el Capítulo 3. El resto de pasos tienen un número de despreciable si suponemos q << n. Así, los para el paso de conteo y movimiento son los siguientes: Paso (4.2) Conteo:

19 D.3. COUNTING SPLIT Bucle Desenrollado # particiones Figura D.11: Particionado con el Counting Split para diferente número de particiones. El conjunto de datos que particionamos es de 2M de claves y punteros de 64 bits para un R1K. Accesos al primer nivel de cache. Por un lado, tenemos la lectura secuencial del vector fuente cuyo coste es el mismo que para el Reverse Sorting (C a ciclos). Por otro lado, tenemos la escritura en el vector indice particion y la actualización del contador (lectura y escritura) correspondiente al valor del dígito. Estos tres accesos últimos accesos suponen C a (C a 1) ciclos. El número total de para el acceso al primer nivel de cache es: cpu accesos = C a + C a C a = 1 + 3C a Fallos de memoria cache. Por un lado, suponemos que los contadores están en el primer nivel de memoria cache ya que son pocos en número y se acceden frecuentemente. Por otro lado, al vector fuente S y al vector indice particion se accede de forma secuencial. Por lo tanto, tenemos que la penalización por fallos obligatorios y de capacidad del vector fuente es C f1 /R 1 + C f2 /R 2 ciclos. Como el tamaño de un elemento del vector indice particion es 1 byte, tendremos un fallo cada T linea1 o T linea2 elementos accedidos. T linea1 y T linea2 son los tamaños en bytes de las líneas del primer y segundo niveles de cache respectivamente. En este caso, la penalización accediendo al vector indice particion es de C f1 /T linea1 + C f2 /T linea2 ciclos. El número de acumulado es: mem mc = C f1 (1/R 1 + 1/T linea1 ) + C f2 (1/R 2 + 1/T linea2 ) Fallos de TLB: Fallos obligatorios y de capacidad accediendo al vector fuente (C ftlb /R page ciclos) y el vector indice particion (C ftlb /T page ciclos).

20 192 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 T page es el tamaño de una página de memoria en bytes. En el caso del vector indice particion se produce un fallo cada T page elementos accedidos ya que cada elemento del vector es de 1 byte. Por consiguiente, C ftlb /T page es un número de ciclos despreciable. Así, el número de total es de: mem TLB = C ftlb /R page Operaciones que no son ni lecturas ni escrituras: Al igual que pasaba en el computador basado en p63, el número de para este paso no es despreciable ya que tenemos que realizar una búsqueda binaria. Aquí, sin embargo, la penalización de predicciones de saltos incorrectas es menor que para un Power4. Llamaremos k al número de ciclos medio por comparación y predicción incorrecta de salto que se paga por cada comparación. Los en este caso son: cpu opers = k log(s) Por lo tanto, el número de para el paso de conteo es el siguiente: cont = 1 + 3C a + C f1 ( 1 R T linea1 ) + C f2 ( 1 R T linea2 ) + + C ftlb R page + + k log(s) Paso (4.4) - Movimiento: En el movimiento tenemos casi los mismos que para Reverse Sorting. Sin embargo, ahora, para saber a qué partición pertenece una clave, realizamos una lectura del vector indice particion. Así, ese acceso al vector de índices afecta de la siguiente forma a los diferentes aspectos que distinguimos para calcular los totales: Accesos al primer nivel de cache. Hay un mayor número de de acceso al primer nivel de cache ya que se debe acceder al vector indice particion. Ahora el número de es : cpu accesos = 4 + 3C a en contraposición a los 3+3C a para el paso de movimiento de Reverse Sorting.

21 D.3. COUNTING SPLIT 193 Fallos de memoria cache. También en los fallos de memoria cache tenemos una mayor penalización, a los 2C f1 (1/R 1 + 1/R 2 ) ciclos para Reverse Sorting en este paso, se añaden los C f1 /T linea1 + C f2 /T linea2 ciclos de acceso al vector indice particion. El número de es de: mem mc = C f1 ( 1 R T linea1 ) + C f2 ( 1 R T linea2 ) Fallos de TLB: La penalización por acceso al vector indice particion es mínima ya que los elementos de este vector son de 1 byte y se fallaría 1 vez cada 16K elementos accedidos. Por lo tanto, los debido a fallos de TLB son debidos únicamente a los accesos a los vectores fuente y destino, es decir: mem TLB = 2 C ftlb R page Operaciones que no son ni lecturas ni escrituras: Los para este punto son poco significativos. Por lo tanto, el número de para el paso de movimiento es de: mov = 4 + 3C a + C f1 ( 1 R T linea1 ) + C f2 ( 1 R T linea2 ) + 2 C ftlb R page El número total de del particionado con Counting Split en el SGI O2 con R1K es de: D.3.2. sec cs = 5 + 6C a + + C f1 ( 3 R T linea1 ) + C f2 ( 3 R T linea2 ) C ftlb R page + + k log(s) Análisis del Algoritmo Paralelo Las Figuras D.12 y D.13 muestran los de ejecuciones reales obtenidos al variar q (256P (1 en las Figuras), 512P (2), 124P (3) y 248P (4)) para las distribuciones

22 194 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 de datos Random y D5 respectivamente. Mostramos los para un número total de 2M elementos a ordenar fijado (gráficas de arriba) y 2P M datos (2M elementos por procesador, gráficas de abajo), variando el número de procesadores. En las Figuras se muestran los divididos en las mismas partes en que se mostró en secciones anteriores. En la Figura D.12 también se muestran con líneas discontinuas los según el modelo desarrollado para este particionado. El coste adicional en las Figuras acumula los de los pasos 7 a 11 del algoritmo Counting Split paralelo. En estas Figuras se puede observar que los destinados a estos pasos es mayor para una distribución Random que para una distribución D5. Esto es debido a que el número de particiones frontera que no son de duplicados, y por consiguiente se deben particionar otra vez, es mayor en el caso de la distribución Random. Para D5, una de las particiones sólo contiene duplicados y, por consiguiente, el particionado de ésta consiste en asignar un tanto por ciento de la partición a cada procesador. Por lo general, lo que se puede observar es lo mismo que observamos para el computador basado en p63, con la diferencia que, al igual que comentamos para Reverse Sorting paralelo, no hay un aumento en el número de al comunicar un mismo número de datos, cuando se aumenta el número de procesadores. Esto es debido a que no hay una gran diferencia entre el ancho de banda disponible para comunicar datos dentro de un nodo y entre nodos. Finalmente, en la Figura D.14 se muestran los desequilibrios de carga obtenidos en las ejecuciones con la técnica de particionado del Counting Split paralelo. En las gráficas mostramos el desequilibrio de carga obtenido para las distribuciones de datos Random, D5 y Gaussian, variando el número de muestreos a realizar. Cuando el número de elementos a ordenar por procesador es fijo y el número de muestreos es de q = 248P, el tanto por ciento de desequilibrio de carga obtenido no supera el 1 % del número de elementos que le corresponderían a cada procesador. Sin embargo, si nos fijamos en el desequilibrio de carga cuando el número de elementos a ordenar es fijo, éste es significativo. Este desequilibrio es mayor cuando el número de procesadores aumenta. Las causas son las mismas que indicamos para Reverse Sorting paralelo. Modelo para Counting Split Paralelo La Figura D.15 muestra los según el modelo desarrollado para Counting Split paralelo variando el parámetro q ( 256P (1 en la Figura), 512P (2), 124P (3), 248P (4), 496 (5) y 8192P (6)). Se muestran los para el particionado de un número total de elementos a ordenar fijado a 2M datos (gráfica de arriba) y un número fijo de elementos (2M) por procesador, variando el número de procesadores. Como podemos observar, y tal y como se observaba en el computador basado en p63, a partir de q = 248, el número de según el modelo es elevado, por lo que decidimos realizar las ejecuciones hasta q = 248P. Las conclusiones que podemos extraer son las mismas

23 D.3. COUNTING SPLIT Prepare Adicional All to All Transpose Counting Local Broad. Split Radix Com. Muestreo Modelo Prepare Adicional All to All Transpose Counting Local Broad. Split Radix Com. Muestreo Modelo Figura D.12: del particionado con Counting Split variando q (256P (1), 512P(2), 124P(3) y 248P(4)) y P (de 2 a 32) para 2M (arriba) y 2PM (abajo) de datos a ordenar. Los resultados son para una distribución Random. Las líneas discontinuas muestran totales según nuestro modelo para q hasta 496P y 8192P.

24 196 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O Prepare Adicional All to All Transpose Counting Local Broad. Split Radix Com. Muestreo Prepare Adicional All to All Transpose Counting Local Broad. Split Radix Com. Muestreo Figura D.13: El mismo análisis que en la Figura D.12 pero para una distribución D5.

25 D.3. COUNTING SPLIT Desq. 2M 1 Desq. 2M 1 Desq. 2M Desq. 2P M 1 Desq. 2P M 1 Desq. 2P M Figura D.14: Desequilibrio de carga obtenido con Counting Split variando q (256P(1), 512P(2), 124P(3) y 248P(4)) y P (de 2 a 32) para 2M (arriba) y 2PM (abajo) de datos de 64 bits. De izquierda a derecha, corresponden al particionado de datos con distribución Random, D5 y Gaussian.

26 198 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 que se extrajeron para las ejecuciones reales en la sección anterior Adicional All to All Transpose Counting Local Broad. Split Radix Com. Muestreo Adicional All to All Transpose Counting Local Broad. Split Radix Com. Muestreo Figura D.15:, según el modelo, del particionado con Counting Split variando q (256P (1), 512P(2), 124P(3), 248P(4), 496P(5) y 8192P) y P (de 2 a 16) para 2M (arriba) y 2PM (abajo) de datos a ordenar. Finalmente, y para ver qué sucedería si el ancho de banda aumentara (α menor), se ha modelado cuál sería el comportamiento de este tipo de particionado en el SGI Origin 2 si el ancho de banda fuera el ancho de banda pico, es decir 78MB/s. Por lo tanto, α es 2 ciclos/byte. Eso se muestra en la figura D.16 donde se pueden observar los para ordenar 2M datos de 64 bits variando el número de procesadores, y el número q de muestreos, tal y como se hizo anteriormente. Por un lado, lo que se puede observar es que al aumentar el ancho de banda, los para lo que llamamos coste adicional en las gráficas ( acumulado de los pasos 7 al 11 del algoritmo) se reduce. Por lo tanto, sabiendo que este coste adicional de realizar particionado extra

27 D.4. MUTANT REVERSE SORTING 199 para conseguir un buen equilibrio de carga disminuye, se podría pensar en reducir el número de muestreos por procesador. Con ello, se podría reducir el coste relativo de la ordenación de estos muestreos aunque después pueda significar tener que particionar más particiones frontera. En este caso, el coste adicional no sería tan costoso. Por otro lado, el número de de comunicación de datos también se reduce Adicional All to All Transpose Counting Local Broad. Split Radix Com. Muestreo Figura D.16:, según el modelo, para el particionado paralelo con Counting Split suponiendo el ancho de banda de pico de el SGI O2. D.4. Mutant Reverse Sorting En esta sección se muestran los de la técnica Mutant Reverse Sorting que combina Reverse Sorting y Counting Split. Los resultados son para el SGI O2 con procesadores R1K. D.4.1. Análisis del Algoritmo Secuencial Las Figuras D.17 y D.18 muestran los resultados de particionar con Reverse Sorting, Counting Split y Mutant Reverse Sorting (RSM) para datos de 32 y 64 bits respectivamente. Se muestran los para distribuciones de datos Random, S2, S4 y D1. En todas las gráficas, RSM aparece con líneas continuas con marcas en forma de rombo. Reverse Sorting se muestra con una línea continua y Counting Split en línea discontinua, sin marcas. Como se puede observar, RSM se adapta a la distribución de datos y opta por la técnica de particionado que ofrece mejor rendimiento en cada momento. El número de invertidos por esta técnica es parecido a la que obtiene mejores resultados entre las dos que combina, Reverse Sorting y Counting Split.

28 2 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 CS RS RSM n*1k (Random) n*1k (S2) n*1k (S4) n*1k (D1) Figura D.17: Comparativa en del particionado de claves y punteros de 32 bits con Reverse Sorting (RS), Counting Split (CS) y Mutant Reverse Sorting (RSM). Se muestran resultados para una distribución Random, S2, S4 y D1.

29 D.4. MUTANT REVERSE SORTING CS RS RSM n*1k (Random) n*1k (S2) n*1k (S4) n*1k (D1) Figura D.18: Comparativa en del particionado de claves y punteros de 64 bits con Reverse Sorting (RS), Counting Split (CS) y Mutant Reverse Sorting (RSM). Se muestran resultados para una distribución Random, S2, S4 y D1.

30 22 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2 Tanto para claves de 32 bits como para claves de 64 bits se observa que Reverse Sorting muestra un buen rendimiento para la distribución de datos Random. Para el resto, Counting Split ofrece mejor rendimiento. En el computador basado en p63, en cambio, para 32 bits, Reverse Sorting ofrece un buen rendimiento para las distribuciones S2 y S4. Esto se debe básicamente a dos aspectos: 1. El número de de una iteración de Reverse Sorting es relativamente más alto con respecto al particionado con Counting Split en el SGI O2 que en el computador con p63. Por lo que, teniendo que hacer un mismo número de iteraciones de Reverse Sorting en los dos computadores, en el SGI O2 el número total de de Reverse Sorting podría ser mayor que el de Counting Split antes. 2. El dígito de Reverse Sorting (b r bits) que podemos escoger en el computador basado en p63, sin incurrir en fallos de TLB durante el particionado, es 32 veces mayor que el del SGI O2. Por lo tanto, con una iteración de Reverse Sorting se ordena mayor número de bits de la clave en el computador con p63. Esto hace que una iteración de Reverse Sorting en el computador con p63 sea más eficaz ya que hace más trabajo que una iteración de Reverse Sorting en el SGI O2, suponiendo quizás, un menor número de iteraciones necesarias de Reverse Sorting. D.4.2. Análisis del Algoritmo Paralelo En la Figura D.19 se muestran los para el particionado de 4MP datos con Reverse Sorting, Counting Split y Mutant Reverse Sorting paralelo para diferentes distribuciones de datos. En la gráfica de arriba se muestran los resultados en para P=2 procesadores. En la gráfica de abajo se muestran los resultados para P=32 procesadores. Los resultados son similares a los mostrados para el computador basado en p63. Mutant Reverse Sorting se adapta y opta por la mejor técnica. El Reverse Sorting paralelo es capaz de obtener un buen equilibrio de carga para las distribuciones Random (para 2 y 32 procesadores), D5 (para 2 procesadores) y S2 (para 2 procesadores), sin superar las 3 iteraciones de Reverse Sorting; pero sólo ofrece mejor rendimiento que Counting Split para las distribuciones Random. En el caso de D5 y 2 procesadores es, como se explicó para el computador con p63, un caso especial; la mitad de los datos van a un procesador de forma directa porque una de las particiones creadas está formada por la mitad de los datos y con una iteración de Reverse Sorting conseguimos distribuirlo entre los 2 procesadores.

31 D.4. MUTANT REVERSE SORTING CS RS RSM Random S2 S4 D5 D CS RS RSM Random S2 S4 D5 D1 Figura D.19: para el particionado de claves y punteros de 64 bits con Reverse Sorting (RS), Counting Split (CS) y Mutant Reverse Sorting (RSM). Mostramos resultados para el particionado de 2MP datos para P=2 (arriba) y P=32 (abajo) procesadores, para una distribución Random, S2, S4 y D1.

32 24 APÉNDICE D. ANÁLISIS Y MODELOS PARA SGI O2