Algoritmos de Ordenación

Paralelos

Autor:
Miguel Angel Botella Tomey
 Índice
 Introducción
 Rank Sort
 Algoritmos de comparación-intercambio
 Bubble Sort
 Shearsort
 Mergesort
– Simple
– Odd-Even
– Bitonic
 Quicksort
– Simple
– Hypercube
 Bibliografía

2
 Introducción
 Tipos de algoritmos de ordenación:
– No basados en las operaciones comparación-intercambio.
 Complejidad mayor que los basados en operaciones
comparación-intercambio.
 Sistemas de memoria compartida.
 Ejemplo: Rank Sort.
– Basados en operaciones comparación-intercambio.
 Complejidad menor que los no basados en operaciones
comparación-intercambio.
 Sistemas de memoria distribuida.
 Divide y vencerás.
 Ejemplos: Bubble Sort, Mergesort, Quicksort.

3
 Índice
 Introducción
 Rank Sort
 Algoritmos de comparación-intercambio
 Bubble Sort
 Shearsort
 Mergesort
– Simple
– Odd-Even
– Bitonic
 Quicksort
– Simple
– Hypercube
 Bibliografía
4
 Rank Sort (I)
 Para el elemento actual se cuentan el número de elementos
menores que él. Ese número (rank) será la posición que ocupe.
 Acceso compartido a una lista de elementos sistemas de
memoria compartida.

 También en memoria distribuida

5
 Rank Sort (II)
 Algoritmo Secuencial

– Para comparar un elemento con el resto se necesitan (n-1)

pasos; para compararlos todos serían n(n-1) pasos.
– Complejidad: O(n2).

6
 Rank Sort (III)
 Algoritmo paralelo usando n procesadores

– Tenemos un procesador para calcular el orden de cada elemento y

un contador por cada elemento.
– Todos hacen en paralelo (n-1) pasos.
– Complejidad: O(n).

7
 Rank Sort (IV)
 Algoritmo paralelo usando n2 procesadores
– Se usan (n-1) procesadores para calcular la posición del elemento y
un contador para cada elemento.
– Incremento del contador en paralelo: O(1).
– Incremento del contador secuencialmente.
 1 paso para la iniciar el contador.
 1 paso de la comparación
en paralelo.
 (n-1) pasos para incrementar.
 Requiere como máximo
(n+1) pasos.
 Complejidad: O(n)

8
 Rank Sort (y V)
– Usando estructura de árbol se puede reducir el tiempo.

 Complejidad: O(logn)

9
 Índice
 Introducción
 Rank Sort
 Algoritmos de comparación-intercambio
 Bubble Sort
 Shearsort
 Mergesort
– Simple
– Odd-Even
– Bitonic
 Quicksort
– Simple
– Hypercube
 Bibliografía

10
 Algortimos comparación-intercambio
(I)

 Dos elementos A y B son comparados. Si A>B (A<B), A y B son

intercambiados entre sus respectivas zonas. En otro caso, no se
intercambian.
 Dos mecanismos para comparación-intercambio:
– Un solo procesador realiza la comparación: P1 envía su elemento a
P2 y este lo compara con el suyo. El elemento mayor (menor) será
devuelto a P1, mientras que el elemento menor (mayor) se lo
quedará P2.
– Ambos procesadores realizan la comparación: P1 envía su
elemento a P2 y este hace lo mismo hacia P1 con el suyo. Los dos
procesadores realizan la comparación y P1 se quedará con el
elemento mayor (menor), mientras que P2 guardará el menor
(mayor).
 Indicados para sistemas de memoria distribuida.
11
 Algortimos comparación-intercambio
(II)

Un solo procesador realiza la comparación

Pseudo código
Procesador P1
send (&A,P2);
recv (&A,P2);

Procesador P2
recv (&A,P1);
if (A > B) {
send (&B,P1);
B = A;
} else
send (&A,P1);
12
 Algortimos comparación-intercambio
(III)

Ambos procesadores realizan la comparación

Pseudo código
Procesador P1
send (&A,P2);
recv (&B,P2);
If (A > B) A = B;
Procesador P2
recv (&A,P1);
send (&B,P1);
if (A > B) B = A;

13
 Algortimos comparación-intercambio
(y IV)

14
 Índice
 Introducción
 Rank Sort
 Algoritmos de comparación-intercambio
 Bubble Sort
 Shearsort
 Mergesort
– Simple
– Odd-Even
– Bitonic
 Quicksort
– Simple
– Hypercube
 Bibliografía

15
 Bubble sort (I)
 Los elementos mayores se van moviendo hacia el final de la lista en cada
fase. 4 2 7 8 5 1 3 6
4 2 7 8 5 1 3 6
F
A 2 4 7 8 5 1 3 6
S 2 4 7 8 5 1 3 6
E
1 2 4 7 8 5 1 3 6
2 4 7 5 8 1 3 6
2 4 7 5 1 8 3 6
2 4 7 5 1 3 8 6
F 2 4 7 5 1 3 6 8
A
2 4 7 5 1 3 6 8
S
E 2 4 7 5 1 3 6 8
2 2 4 5 7 1 3 6 8
...
2 4 5 1 7 3 6 8
16
 Bubble sort (II)
 Algoritmo secuencial
for (i = n-1; i > 0; i--) Suponiendo que una operación
comp-interc tiene complejidad O(1)
for (j = 0; j < i; j++) {
k = j + 1;
if (a[j] > a[k]) { Fase 1: (n-1) comp-interc
temp = a[j]; Fase 2: (n-2) comp-interc
a[j] = a[k]; ....
a[k] = temp; Total comparaciones-intercambios
}
n(n-1)/2
}
Complejidad: O(n2)
17
 Bubble sort (III)
 Algoritmo paralelo (Odd-Even Transposition Sort)
– Bubble sort es inherentemente secuencial ya que una iteración no
puede empezar hasta que la anterior finalice.
– Modificación: se introduce una estructura de pipeline.
– Dos pasos:
 Fase Par (Even): los elementos en posiciones pares se comparan con los
de su derecha.
 Fase Impar (Odd): los elementos en posiciones impares se comparan
con los de su derecha.
– Complejidad:
 Con n=p tenemos O(n) comparaciones-intercambios.
 Con n>p tenemos O(n/p) comparaciones-intercambios.

18
 Bubble sort (y IV)

F P0 P1 P2 P3 P4 P5 P6 P7

4 2 7 8 5 1 3 6
0p 4 2 7 8 5 1 3 6
1i 2 4 7 8 1 5 3 6
2p 2 4 7 1 8 3 5 6
3i 2 4 1 7 3 8 5 6
4p 2 1 4 3 7 5 8 6
5i 1 2 3 4 5 7 6 8
6p 1 2 3 4 5 6 7 8
7i 1 2 3 4 5 6 7 8
19
 Índice
 Introducción
 Rank Sort
 Algoritmos de comparación-intercambio
 Bubble Sort
 Shearsort
 Mergesort
– Simple
– Odd-Even
– Bitonic
 Quicksort
– Simple
– Hypercube
 Bibliografía

20
 Shearsort (I)
 ¿Qué ocurre si la secuencia de elementos está lógicamente
dispuesta sobre una tabla?

Más pequeño

 Secuencia “snakelike”

Más grande

21
 Shearsort (II)
 Algoritmo secuencial
– Fases pares (2,4,6,...)
 Cada columna se ordena de menor a mayor independientemente.
– Fases impares (1,3,5,...)
 Filas pares: se ordenan de mayor a menor.
 Filas impares: se ordenan de menor a mayor.
– Complejidad para n elementos y una tabla de  n x  n:
O( n(logn+1))

22
 Shearsort (III)
Fila

1 4 14 8 2 2 4 8 14 1 4 7 3

2 10 3 13 16 16 13 10 3 2 5 8 6

3 7 15 1 5 1 5 7 15 12 11 9 14

4 12 6 11 9 12 11 9 6 16 13 10 15

Inicio Fase 1 Fase 2

1 1 3 4 7 1 3 4 2 1 2 3 4

2 8 6 5 2 8 6 5 7 8 7 6 5

3 9 11 12 14 9 11 12 10 9 10 11 12

4 16 15 13 10 16 15 13 14 16 15 14 13

23 Fase 3 Fase 4 Fase 5 - Fin

 Shearsort (IV)
 Algoritmo paralelo
– Teniendo un procesador por fila podemos paralelizar las fases
impares.
– Usando transposición entre fases podemos paralelizar también las
fases pares.

Fase Impar Transposición Fase Par

24
 Shearsort (V)
Fila

1 4 14 8 2 2 4 8 14 2 16 1 12

2 10 3 13 16 16 13 10 3 4 13 5 11

3 7 15 1 5 1 5 7 15 8 10 7 9

4 12 6 11 9 12 11 9 6 14 3 15 6

Inicio Fase 1 Transposición

1 1 2 12 16 1 4 7 3 1 3 4 7

2 4 5 11 13 2 5 8 6 8 6 5 2

3 7 8 9 10 12 11 9 14 9 11 12 14

4 3 6 14 15 16 13 10 15 16 15 13 10

25 Fase 2 Transposición Fase 3

 Shearsort (y VI)
Fila

1 1 8 9 16 1 8 9 16 1 3 4 2

2 3 6 11 15 3 6 11 15 8 6 5 7

3 4 5 12 13 4 5 12 13 9 11 12 10

4 7 2 14 10 2 7 10 14 16 15 13 14

Transposición Fase 4 Transposición

1 1 2 3 4 Complejidad
-En cada iteración, cada procesador ordena
2 8 7 6 5
su fila en O( nlog  n) pasos.
3 9 10 11 12 -Cada transposición necesita  n( n-1)
comunicaciones: O(n).
4 16 15 14 13

26 Fase 5 - Fin
 Índice
 Introducción
 Rank Sort
 Algoritmos de comparación-intercambio
 Bubble Sort
 Shearsort
 Mergesort
– Simple
– Odd-Even
– Bitonic
 Quicksort
– Simple
– Hypercube
 Bibliografía
27
 Mergesort (I)
 Algoritmo divide y vencerás.
– División de un problema en otros de menor complejidad.
– Objetivo: hacer la división y combinación de los subproblemas de
forma eficiente.
– Características:
 Cálculo de la solución de los subproblemas en paralelo.
 Combinación de los subproblemas en paralelo.
 Posible sincronización entre subproblemas.
– Normalmente es el esquema más apropiado para paralelizar (innato
en los problemas paralelos).

28
 Mergesort (II)
 Algoritmo secuencial
– Fase de división:
 La lista ordenada de divide por la mitad.
 Cada mitad se vuelve a dividir por la mitad.
 Así hasta que queden listas de un solo elemento.
– Fase de mezcla:
 Se mezclan pares de listas de un solo elemento.
 Las nuevas listas obtenidas se vuelven a mezclar en pares.
 Así hasta obtener una sola lista mezclada y ordenada.
– Complejidad: O(nlogn).

29
 Mergesort (III)
4 2 7 8 5 1 3 6

4 2 7 8 5 1 3 6

4 2 7 8 5 1 3 6

4 2 7 8 5 1 3 6

2 4 7 8 1 5 3 6

2 4 7 8 1 3 5 6

30 1 2 3 4 5 6 7 8
 Mergesort (IV)
 Algoritmo paralelo simple (n procesadores)
P0
P0 P4

P0 P2 P4 P6

P0 P1 P2 P3 P4 P5 P6 P7

P0 P2 P4 P6

P0 P4
P0
31
 Mergesort (V)
– Análisis algortimo paralelo simple
 Comunicaciones
tstartup+(n/2)tdata P0 P4
tstartup+(n/4)tdata P0 P2;P4 P6
tstartup+(n/8)tdata P0 P1;P2 P3;P4 P5;P6 P7
tcomm=2(tstartup+(n/2)tdata+tstartup+(n/4)tdata + tstartup+(n/8)tdata+...) =
2 ((logp)tstartup+ntdata )
 Computación (mezcla)
tcomp=1 P0;P2;P4;P6
tcomp=3 P0;P4
tcomp=7 P0
tcomp= (2i-1) (desde i=1 hasta logp)
– Complejidad: para n=p se tiene O(p); para n>p se tiene O(n/p).
32
 Mergesort (VI)
 Algoritmo Odd-Even Mergesort
– Dadas dos listas ordenadas:
 L1 = {a1,a2,a3,...} y L2 = {b1,b2,b3,...}
– Mezcla estas dos listas en una sola siguiendo estas reglas:
 Los elementos con índice impar (odd) son mezclados en una lista L3 (ci).
 Los elementos con índice par (even) son mezclados en otra lista L4 (di).
 La lista L5 final ordenada se obtiene asi:
– e1=c1
– e2i = min {ci+1,di}
– e2i+1 = max {ci+1,di}
– Uso de un hipercubo para una mayor eficiencia.
– Complejidad para n procesadores: O(log2n)

33
 Mergesort (VII)

L1 L2
1 3 4 7 2 5 6 8
a1 a2 a3 a4 b1 b2 b3 b4

L3 L4
1 2 4 6 3 5 7 8
c1 c2 c3 c4 d1 d2 d3 d4
L5
1 2 3 4 5 6 7 8
e1 e2 e3 e4 e5 e6 e7 e8

34
 Mergesort (VIII)
 Algoritmo Bitonic Mergesort
– Secuencia bitónica:
 secuencia de elementos a0,a1,a2,...,an que se incremente monótamente y
cuando llega a un máximo se decrementa monótamente.
 secuencia de elementos a0,a1,a2,...,an que si desplazamos cíclicamente
se sigue cumpliendo el anterior punto.

35
 Mergesort (IX)
 Mezcla bitónica:
– Si realizamos las operaciones comparación-intercambio con los
elementos ai y ai+(n/2) obtenemos dos secuencias bitónicas, teniendo
una de ellas los elementos menores y la otra los elementos mayores.
3 5 8 9 7 4 2 1

3 4 2 1 7 5 8 9

2 1 3 4 7 5 8 9

1 2 3 4 5 6 7 8
36
 Mergesort (X)
 Como proceder (para 8 elementos) en caso de que la secuencia
de elementos no sea bitónica:
– Fase 1: Convertir cada par de elementos adyacentes en una
secuencia incremental y la siguiente decremental.
– Fase 2: Dividir secuencias bitónicas de 4 elementos en secuencias
bitónicas de 2 elementos. Ordenar cada secuencia de 4 elementos
(incrementando o decrementando) y mezclar con mezcla bitonic en
una secuencia de 8 elementos.
– Fase 3: Ordenar la secuencia de 8 elementos con mezcla bitónica.
 Complejidad: O(log2n) para n procesadores.

37
 Mergesort (y XI)
8 3 4 7 9 2 1 5

Fase 1 3 8 7 4 2 9 5 1 n=2 ai con ai+1

Fase 2 3 4 7 8 5 9 2 1 n=4 ai con ai+2

Fase 2 3 4 7 8 9 5 2 1 n=2 ai con ai+1

Fase 3 3 4 2 1 9 5 7 8 n=8 ai con ai+4

Fase 3 2 1 3 4 7 5 9 8 n=4 ai con ai+2

38 Fase 3 1 2 3 4 5 7 8 9 n=2 ai con ai+1

 Índice
 Introducción
 Rank Sort
 Algoritmos de comparación-intercambio
 Bubble Sort
 Shearsort
 Mergesort
– Simple
– Odd-Even
– Bitonic
 Quicksort
– Simple
– Hypercube
 Bibliografía

39
 Quicksort (I)
 Algoritmo divide y vencerás.
 Algoritmo secuencial
– Pasos:
 Selección de un pivote inicial que divida la lista de elementos.
 Todos los elementos menores que el pivote irán a una lista, y los demás a
la otra lista.
 Para cada una de las sublistas se elije de nuevo otro pivote y se repite el
proceso de división.
 La división finalizará cuando todas las sublistas estén ordenadas.
– Interesante elegir un buen pivote (balanceo de sublistas).
– Complejidad O(nlogn).

40
 Quicksort (II)

4 2 7 8 5 1 3 6

3 2 1 4 5 7 8 6

2 1 3 4 5 7 8 6

1 2 3 6 7 8

El proceso “vencerás” se dará cuando vayan

terminando las llamadas recursivas.

41
 Quicksort (III)
 Algoritmo paralelo simple (n procesadores)

P0

P0 P4

P0 P2 P4 P6

P0 P1 P6 P7

42
 Quicksort (V)
– Análisis algortimo paralelo simple (suponemos un pivote ideal)
 Comunicaciones
tstartup+(n/2)tdata
tstartup+(n/4)tdata
tstartup+(n/8)tdata ...
tcomm= (tstartup+(n/2)tdata+tstartup+(n/4)tdata + tstartup+(n/8)tdata+...) =
(logp)tstartup+ntdata
 Computación
tcomp= n + n/2 + n/4 + n/8+ = ... = 2n
– Complejidad:
 Mejor situación: O(2n).
 Peor situación: O(n2); elección del primer elemento de una sublista.

43
 Quicksort (VI)
 Algoritmo paralelo en un Hipercubo
– Algoritmo simple puede ser ¡¡¡ menos eficiente que el secuencial !!!
– ¿Cómo dividir un hipercubo?
 Dado un hipercubo d-dimensional, se divide en dos hipercubos (d-1)-
dimensionales.
 Ejemplo: Hipercubo tri-dimensional.

100 110 000 010100 110 000 001100 101

000 010
101 111 001 011101 111 010 011110 111
001 011

44
 Quicksort (VII)
– Pasos (supongamos un hipercubo lógico de procesadores):
 Un procesador elige un pivote y lo envía por broadcast al resto.
 Se divide la lista de elementos con el pivote.
 Cada procesador con su dimensión a 0 envían los elementos mayores al
pivote a su procesador adyacente con su dimensión a 1. Al revés ocurre
igual, excepto por se envía los elementos menores al pivote.
 Cada procesador une lo que queda de su lista con la recibida.
 Estos 2 últimos pasos se repiten recursivamente (logd) veces.
 Finalmente, cada sublista es ordenada secuencialmente en cada
procesador.
– Importante: elección de un buen pivote.
– Variación: hyperquicksort
 Paso inicial de ordenamiento: elimina el último paso anterior y facilita la
elección del pivote.
45
 Quicksort (VIII)

46
 Quicksort (y IX)
– Análisis:
Computación
 Selección del pivote: O(1).
 Particionar en paralelo ‘x’ elementos a enviar (para elementos
ordenados): O(logx).
 Mezcla de los datos (la sublista mayor tiene ‘x’ elementos): O(x).
tcomp = O(1) + O(logx) + O(x)
Comunicación
 Broadcast del pivote: d(d-1)/2(tstartup+tdata)
 Datos recibidos (‘x’ elementos) de la partición: tstartup+(x/2)tdata.
tcomm = d(d-1)/2(tstartup+tdata) + tstartup+(x/2)tdata
Complejidad Total
tcomp + tcomm
 El broadcast del pivote lo más costoso: usar mecanismo eficientes.
47
 Índice
 Introducción
 Rank Sort
 Algoritmos de comparación-intercambio
 Bubble Sort
 Shearsort
 Mergesort
– Simple
– Odd-Even
– Bitonic
 Quicksort
– Simple
– Hypercube
 Bibliografía

48
 Bibliografía
 Kumar, Grama, Gupta, Karypis: Introduction to Parallel
Computing. Design and Analysis of Algorithms. The Benjamin
Cumming Publishing Company. 1994. Segunda edición.
 Barry Wilkinson, Michael Allen: Parallel programming. Prentice-
Hall. 1999.

49