Algoritmen en Datastructuren III Partim: Parallelle algoritmen - caagt

2.1. Het gedeelde-geheugenmodel 9
Algoritme 2.1 Berekenen van matrix-vector-vermenigvuldiging
Input: n×n matrix A en vector x; aantal processoren p met r = n/p geheel; processornummer i;
Output: componenten y (i−1)r+1,...,yir van y = Ax in globale variabele
1: global read (x, z)
2: global read (A (i−1)r+1:ir,1:n, B)
3: Bereken w ← Bz
4: global write (w, y (i−1)r+1:ir)
Algoritme 2.2 Berekenen van matrix-vector-vermenigvuldiging (met verkorte notatie)
Input: n×n matrix A en vector x; aantal processoren p met r = n/p geheel; processornummer i;
Output: componenten y (i−1)r+1,...,yir van y = Ax in globale variabele
1: Bereken y (i−1)r+1:ir ← A (i−1)r+1:ir,1:nx
stel z ← x+y
global write (z, c)
met a,b,c gedeelde variabelen, en x,y,z lokale variabelen.
Voorbeeld 2.1.1 (Matrix-vector-vermenigvuldiging). Beschouw het vermenigvuldigen van een
n×n matrix A met een vector x van orde n, die beiden in het gedeelde geheugen opgeslagen zijn.
Veronderstel dat we over p processoren Pi beschikken, met p ≤ n en r = n/p geheel, en dat we
in het asynchroon model werken.
Een eenvoudig parallel algoritme bestaat in het opsplitsen van A in p blokken A (i) van r rijen,
waarbij elke processor Pi de vector x en een blok A (i) uit het gedeeld geheugen leest en het
product A (i) x berekent. Dit levert r componenten van de resultaatvector.
Algoritme 2.1 geeft de pseudocode voor processor Pi. Merk op dat alle processoren in stap 1
tegelijkertijd toegang moeten hebben tot de globale variabele x. Daarentegen zullen twee processoren
nooit tegelijkertijd naar dezelfde globale geheugenplaats proberen te schrijven.
Met de eerder vermelde verkorte notatie bekomen we de pseudocode zoals getoond in Algoritme
2.2.
De parallelle tijd van dit algoritme is Tp(n) = Θ(n 2 /p). De kost is Cp(n) = pΘ(n 2 /p) = Θ(n 2 ),
hetgeen precies de tijd van het sequentiële algoritme is. Het algoritme is dus kost-optimaal.
Een belangrijk aspect van dit algoritme is het feit dat de processoren hun activiteiten niet hoeven
te synchroniseren – dit is te danken aan de manier waarop de berekeningen gepartitioneerd
werden. Door de matrix op te splitsen in blokken van rijen zijn de berekeningen die door de
verschillende processoren gebeuren, onafhankelijk van elkaar.
Als we daarentegen de matrix zouden opsplitsen in blokken van kolommen, m.a.w. als A =
(A (1) ,...,A (r) ) en x = (x (1) ,...,x (r) ), dan wordt het product y = Ax gegeven door y = A (1) x (1) +
···+A (r) x (r) . Elke processor Pi kan dus z (i) = A (i) x (i) berekenen, na het inlezen van A (i) en x (i)
uit het gedeelde geheugen. Maar geen enkele processor mag beginnen met het berekenen van
Algoritmen en Datastructuren III Veerle.Fack@UGent.be