Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi

Presentazione sul tema: "Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi"— Transcript della presentazione:

1 Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi
Algoritmi paralleli di ordinamento Lezione n°15 Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi 1

2 Algoritmo pari/dispari
L’idea base è quella di far lavorare prima tutti i processori di indice pari e poi quelli di indice dispari per evitare letture e scritture concorrenti nei confronti. for s = 1 to n/2 do for i = 0 to i < n-1 step 2 pardo Pi: if x[i] > x[i+1] then swap(x[i], x[i+1]) for i = 1 to i < n-1 step 2 pardo Richiede tempo O(n) su una PRAM EREW con O(n) processori. Il costo complessivo è O(n2). 1 2 3 4 5 6 s=1 pari 8 9 s=1 dispari s=2 pari s=2 dispari s=3 pari s=3 dispari Fine AA

3 Algoritmo pari/dispari con p < n processori
Ogni processore Pi gestisce un blocco Si composto di b = n/p elementi. Pi: ordina Si in modo sequenziale for s = 0 to p/2 do for i = 0 to i < p-1 step 2 pardo Pi: Si' = Merge(Si, Si+1) Si = Si' [0, b-1] Si+1 = Si' [b, 2b-1] for i = 1 to i < p-1 step 2 pardo for i = 0 to p-1 pardo I tempo richiesto è Tp = O(n/p log (n/p)) + p/2 O(n/p). Quando abbiamo p = O(log n) il tempo Tp diventa O(n): in tal caso il costo totale è O(n log n). AA

4 Ordinamento su PRAM CRCW
Sfruttiamo la scrittura concorrente per ottenere un semplice algoritmo di ordinamento. Assumiamo una PRAM CRCW con scrittura concorrente della somma dei valori scritti. for i = 0 to n-1 pardo for j = 0 to n-1 pardo Pi,j: if (x[ i ] > x[ j ]) or (x[ i ] = x[ j ] and i > j) then c[ i ] = 1 Pi,1: x[ c[ i ] ] = x[ i ] Con n2 processori il tempo richiesto è O(1), Il costo totale è quindi O(n2). xiniz 7 1 5 2 3 8 4 C 3 1 2 4 xfin 3 1 5 2 7 4 8 Risultati dei confronti effettuati i j 1 2 3 4 F V AA

5 Il concetto di rango Dati X = (x1, x2, …, xt), Y = (y1, y2, …, ys) e z, con z, xi e yj nello stesso insieme U, definiamo: 1. rango(z:X) = numero di elementi in X  z Es: X = (-3,8,-2,5), z = 1, rango(z:X) = 2 2. rango(Y:X) = (r1, r2, … rs) con ri = rango(yi:X) Es: X = (15,-3,12,1,-5), Y = (3,-13,-2), rango(Y:X) = (3,0,2) Si noti inoltre che vale la relazione*: rango(x:AB) = rango(x:A) + rango(x:B) *Nota: per semplicità assumiamo che i valori siano tutti distinti. AA

6 Fondere tramite rango Il problema di fondere due vettori ordinati A e B in un unico vettore C si può risolvere calcolando il rango degli elementi di A rispetto a B e di quelli di B rispetto ad A: rango(x:AB) è esattamente la posizione in cui l’elemento x si trova nel vettore C. L’algoritmo di Ricerca Binaria può essere utilizzato per calcolare il rango di un elemento in un vettore, ed in particolare il rango di ogni elemento di A in B e viceversa. Con tali informazioni possiamo calcolare C. Esempio: A=(-2, -1, 8) B=(3,6) AB=(-2, -1, 8, 3, 6) rango(A:B)=(0, 0, 2) rango(B:A)=(2,2) rango=(1, 2, 5, 3, 4) C=(-2, -1, 3, 6, 8) AA

7 Inserire una sequenza “breve” in un vettore ordinato
Siano X=(x1, x2, …, xn) un vettore ordinato e Y=(y1, …, ym) una sequenza di valori qualunque tale che m=O(ns) con 0≤s≤1. Utilizziamo un numero di processori pari ad N=n/m = (n1-s). È possibile inserire ciascun valore yi nella sequenza X determinando rango (yi:X) in tempo O(m log2(n+2) / log2(N+1)) Quando m << n (ovvero se s  0) si ha N=O(n) e tempo O(1). Quando m=O(n) (s  1) si ha N=O(1) e tempo O(n log n). AA

8 Algoritmo di fusione tramite rango
Input: A=(a1, a2, …, an), B=(b1, b2, …, bm), ordinati in modo crescente (m≤n). Output: C=(c1, c2, …, cn+m), ordinato in modo crescente. Idea: si partiziona il vettore B in (m / log m) blocchi consecutivi di log(m) elementi ciascuno B0, B1, … e si crea il vettore Y costituito dall’insieme degli elementi massimi dei blocchi. Si calcola rango(Y:A)=(r1, r2, …, rm) e si divide A in blocchi consecutivi A0=(a1, …, ar1), A1=(ar1+1, …, ar2), … Poiché A0 e B0 contengono elementi minori di tutti gli altri elementi di A e B, fondendo A0 e B0 tramite rango si ottiene la sequenza ordinata dei primi elementi di C. Iterando il ragionamento su tutte le coppie Ai e Bi si ottiene l’intero vettore C ordinato. AA

9 Complessità dell’algoritmo di fusione
Per completare la fusione di A e B (cioè per calcolare la posizione di ciascun valore nel vettore finale) si dovranno fondere tutte le coppie di sottovettori (Ai, Bi). Utilizzando l’inserimento di una seq. breve in un vettore ordinato ciò si può fare in O(log m) tempo con |Ai| processori. Quindi con n processori tutte le coppie possono essere fuse contemporaneamente in tempo logaritmico. Bisogna inoltre tener conto di quanti elementi ci sono in tutti gli Aj e Bj (j<i) per posizionare gli elementi di Ai e Bi nel vettore risultante C: il valore r[i] (indice di inizio di Ai) da il contributo totale degli Aj; i * log m è il contributo di tutti i Bj. Il tempo totale richiesto è O(log n) con n processori su PRAM CREW. Esistono anche algoritmi che riducono la complessità temporale a O(log log n) portando quindi il costo totale a O(n log log n). AA

10 Esempio di applicazione dell’algoritmo di fusione
B = [ 3, 9, 16, 17 ] rango(9:A) = rango(17:A) = 6 r = [ 0, 3, 6, 8 ] B0 = [ 3, 9 ] B1 = [ 16, 17 ] A0 = [ 4, 6, 7 ] A1 = [ 10, 12, 15] A2 = [ 18, 20 ] log m log m AA

11 Dettaglio del partizionamento
begin P0: r [ 0 ] = 0 r [ m / log m ] = n for i = 1 to m/log m -1 pardo Pi: r [ i ] = rango(B[ i * log m -1] : A) for i = 0 to m/log m -1 pardo Pi: Bi = (B[ i * log m ], …, B[ (i+1) * log m -1]) Ai = (A[ r [ i ] ], …, A[ r [i+1] -1]) end AA

12 Ordinamento per fusione
La versione parallela del ben noto algoritmo mergesort si può descrivere tramite un albero binario completo di altezza logn che contiene nelle foglie gli n elementi da ordinare. Al passo k-esimo lavorano in parallelo tutti i processori assegnati ai nodi del livello* logn-k ed ogni processore esegue la fusione dei valori presenti nei suoi nodi figli. Ad ogni passo il tempo parallelo richiesto è determinato dall’algoritmo di fusione utilizzato e il numero di passi è pari all’altezza dell’albero. Per quanto detto in precedenza, il miglior costo che si può avere per questo algoritmo è pertanto pari a O(n logn loglog n), non ottimo, anche se molto efficiente. * si suppone che la radice sia a livello 0 e le foglie a livello logn AA

13 Verso un ordinamento ottimo
Nel 1988 R. Cole presentò sul SIAM Journal Computing la prima versione del pipelined merge sort (poi conosciuto come algoritmo di Cole) che riduceva il calcolo delle fusioni ad ogni livello. Da allora varianti e raffinamenti dell’algoritmo si sono susseguiti in letteratura fino a raggiungere un costo ottimo su PRAM EREW. L’idea di Cole per eliminare il tempo dovuto all’operazione di fusione è nata dal constatare che le operazioni di fusione dei sottovettori non è necessario compierle in un sol passo, dato che per arrivare alla soluzione bisogna percorrere tutto l’albero, dalle foglie alla radice. Il calcolo delle fusioni ad ogni singolo livello si può pertanto realizzare in un numero costante di passi fondendo, ad ogni passo, opportuni valori scelti a campione. Questi valori campione, di numero costante, richiedono tempo parallelo O(1) per essere calcolati, confrontati ed inseriti provvisoriamente nel vettore soluzione parziale. Il calcolo di nuovi campioni ad ogni livello garantisce la realizzazione alla radice del vettore ordinato (ottenute per ripetute fusioni parziali) e garantendo un tempo parallelo logaritmico per l’intero algoritmo di ordinamento. AA