Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi

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

1 Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Lezione n°3 Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi 1

2 Un semplice esempio di algoritmo su P-RAM di tipo CR-W
Si adoperano n processori Cerca(A, n, x) begin indice = -1 for i = 0 to n-1 pardo Pi: if A[ i ] = x then indice = i return indice end Il modello adoperato richiede solo la lettura concorrente di x se si assume che gli A[ i ] siano tutti distinti. Se invece si accetta che il vettore A possa contenere elementi ripetuti allora più processori possono scrivere concorrentemente la variabile indice e il modello necessario in tal caso è la P-RAM CRCW (con scrittura concorrente basata su priorità dei processori). In entrambi i casi il tempo parallelo è costante

3 Con il broadcast su P-RAM ER-W
Si adoperano n processori Cerca(A, n, x) begin Broadcast(x) indice = -1 for i = 0 to n-1 pardo Pi: if A[ i ] = x [ i ] then indice = i return indice end Tempo parallelo logaritmico Se gli A[ i ] sono tutti distinti il modello è P-RAM EREW altrimenti è ERCW per la scrittura dell’indice (scrittura concorrente basata su priorità dei processori)

4 Trasportabilità degli algoritmi
Dati due differenti modelli di computazione M e M’, si dice che un algoritmo A progettato per la computazione C sul modello M è trasportabile sul modello M’ se l’algoritmo A’ che computa C sul modello M’ è ottenibile da A tramite l’applicazione di un insieme finito di regole fisse. Il broadcast su PRAM è un primo esempio di trasportabilità di un algoritmo: se su una PRAM CR tutti i processori vogliono leggere la stessa informazione, pagando un tempo O(logn) per il broadcast si può trasportare l’algoritmo su una PRAM ER. Vediamo come affrontare la trasportabilità della scrittura concorrente da PRAM CW a PRAM EW.

5 Simulazione della lettura concorrente (caso generale)
Problema: n processori P1, P2, …, Pn vogliono leggere il contenuto di k celle di memoria (in generale k<n e non tutti i processori vogliono leggere dalla stessa locazione di memoria) su una P-RAM di tipo EREW. Algoritmo: Passo 1: si costruisca M, vettore di coppie del tipo (Pi, Lj), ciascuna indicante che il processore i-esimo vuole leggere la j-esima locazione di memoria (i=0…n-1, j=1…k). Questo vettore viene ordinato in modo stabile, rispetto ai valori Lj (la stabilità garantisce l’ordinamento delle coppie). Passo 2: si raggruppino i processori rispetto alla comune locazione di memoria a cui vogliono accedere, si individuino gli inizializzatori di ogni blocco e si caratterizzino gli elementi in ogni blocco. Passo 3: il primo processore di ogni blocco legge la locazione corrispondente e poi attiva un’operazione di broadcast sul blocco. Passo 4: tutti i processori in parallelo leggono l’informazione richiesta. AA 5

6 PASSI 1 e 2 Passo 1: for i = 0 to -1 pardo
Pi: M[ i ] = (i, Lj) // coppie (proc, loc) sort(M, loc); Passo 2: P0: iniz[ 0 ] = true; B[ 0 ] = 1 for i = 1 to n-1 pardo Pi: if M[ i ].loc  M[ i-1 ].loc then iniz[ i ] = true; B[ i ] = 1 else iniz[ i ] = false; B[ i ] = 0 PrefixSum(B, n) Il vettore B è utilizzato per identificare il blocco di appartenenza di ogni processore 1 2 3 4 5 Proc 8 9 Loc T F iniz B

7 PASSO 3 Invece di eseguire k broadcast differenti (uno per blocco) si esegue un unico broadcast multiplo che tiene conto della separazione in blocchi Passo 3: // Broadcast multiplo for i = 0 to n-1 pardo Pi: if iniz[ i ] then D[ i ] = contenuto di M[ i ].loc for j = 0 to log n -1 do Pi: if iniz[ i ] and i+2j<n and B[ i ] = B[ i+2j ] then D[ i+2j ] = D[ i ] iniz[ i+2j ] = true T F iniz x y z D 1 2 3 B

8 PASSO 4 Passo 4: for i = 0 to n-1 pardo
Proc 1 2 5 4 3 Passo 4: for i = 0 to n-1 pardo // chi aveva richiesto l’i-esimo dato Pi: R[ M[ i ].proc ] = D[ i ] // nel registro del proc i-esimo // si carica il dato voluto Ri = R[ i ] Al termine ogni processore i avrà nel suo registro R il dato contenuto alla locazione Lj inizialmente specificata. Tempo Parallelo: Passo 1: Tsort Passo 2: Tprefixsum Passo 3: logaritmico Passo 4: costante Loc 3 3 3 8 8 9 D x x x y y z R y x x z y x

9 Scrittura Concorrente
Nei modelli a scrittura concorrente, quando più processori richiedono di scrivere in una stessa locazione di memoria condivisa, viene consentita la scrittura ad un solo processore in accordo con uno dei seguenti criteri di scelta: stabilita una scala di priorità tra i processori, si permette la scrittura solo al processore nella prima posizione della scala (CRCW prioritaria); supposto che tutti i processori vogliano scrivere lo stesso valore, consentire la scrittura ad uno qualunque dei processori (CRCW arbitraria). Esistono in letteratura altri criteri, anche se meno usati, che permettono ad un fissato processore di scrivere nella cella di memoria il valore di una funzione di tutti i dati (ad esempio il massimo, lo xor, la somma).

10 Simulazione della scrittura concorrente: stessa informazione
Sia dato un algoritmo per PRAM CW con scrittura concorrente di valori identici. L’operazione compiuta da tutti i processori di scrivere nella stessa locazione R viene simulata su PRAM EW dal solo processore P0, dopo aver controllato che tutti i valori ai scritti dai rispettivi Pi siano uguali*. Questo controllo si effettua usando un vettore A con tutti i valori da scrivere e un vettore di booleani utilizzato per riportare le eventuali diversità nei valori di A: for j = 0 to n-1 pardo Pj: A[ j ] = aj; B[ j ] = true for i = 1 to log n do for j = 0 to (n/2i -1) pardo Pj: if A[ j ]  A[ j+ n/2i ] or not B[ j ] or not B[ j+ n/2i ] then B[ j ] = false P0: if B[ 0 ] then R = A[ 0 ] Il tempo parallelo richiesto è O(log n) * Questo controllo su PRAM CW si suppone effettuato a livello hardware

11 Simulazione della scrittura concorrente: funzione dei valori
La simulazione di PRAM CW con scrittura del massimo valore (o della somma o di qualsiasi altra funzione commutativa f dei valori) viene eseguita su PRAM EW semplicemente utilizzando la tecnica della metà per il computo di f su un vettore A: for j = 0 to n-1 pardo Pj: A[ j ] = aj for i = 1 to log n do for j = 0 to (n/2i -1) pardo Pj: A[ j ] = f ( A[ j ], A[ j+ n/2i ] ) P0: R = A[ 0 ] Con lo stesso schema si può simulare anche la scrittura concorrente basata su priorità (ad esempio in funzione dell’indice del processore che vuole scrivere). In entrambi i casi la simulazione richiede tempo parallelo logaritmico.