Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi Algoritmi paralleli di ordinamento Lezione n°14 Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi 1

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

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).

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

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.

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)

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).

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= (y0, y1, …, ) costituito dall’insieme degli elementi massimi dei blocchi, yi= B(i(logm-1)). Si calcola rango(Y:A) e si ottiene (r0, r1, …, rm/logm), con r0= 0, ri= rango(yi:A), 1≤i≤logm-1, rm/logm=n e si divide A in blocchi consecutivi: A0=(a1, …, ar1), A1=(ar1+1, …, ar2), …, Ar(m/llogm)-1= (ar(m/llogm)-1, …, ar(m/llogm)). 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.

Esempio di applicazione dell’algoritmo di fusione B = [ 3, 9, 16, 17 ] rango(9:A) = 3 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

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

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. Gli elementi di Ai e Bi vengono posizionati nel vettore risultante C in tempo parallelo costante tenuto conto che: ogni Ai contribuisce con (ri+1 – ri); ogni Bj contribuisce con log m elementi. Il tempo totale richiesto è pertanto 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).

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

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, in 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 (ottenuto per ripetute fusioni parziali) e permette di ottenere un tempo parallelo logaritmico per l’intero algoritmo di ordinamento.