1756 Rinnakkaisalgoritmien suunnittelu

1. 1756 Rinnakkaisalgoritmien suunnittelu Rinnakkaisuuden hyödyntämisen perustekniikat J. Porras

2. Yleistä • Rinnakkaisten algoritmien luominen eri tarkoituksiin on peräkkäistä hankalampaa • Yleisten kaikkiin ympäristöihin soveltuvien metodien puutteen korvaa kokoelma erilaisia tekniikoita, jotka on havaittu tehokkaiksi eri ongelmilla

3. Tekniikat (Jájá) • Tasapainotettu puu (balanced tree) • Pointterihyppely (pointer jumping) • Hajoita ja hallitse (Divide and Conquer) • Ositus (Partitioning) • Liukuhihnoitus (pipelining) • Hitaan ja nopean menetelmän yhdistäminen (accelerated cascading) • Symmetrian hajoittaminen (symmetry breaking)

4. Tasapainotettu puu • Tasapainotetun puun menetelmässä syöte-elementit sijoitetaan puun lehtiin ja niillä suoritettavat operaatiot välisolmuihin Esim. Summan laskenta • Menetelmän käyttökelpoisuus perustuu pitkälti siihen kuinka nopeasti alipuuhun sisältyvä informaatio voidaan kerätä

5. Tasapainotettu puu • Esimerkki: Prefix-sum algoritmi • Olkoon meillä n elementin sarja {x1, x2, … xn} • Sarjan prefix sum on n osasummaa si = x1*x2*…*xi, 1 < i < n • Yksinkertainen peräkkäinen ratkaisu Lasketaan si si-1:stä si = si-1*xi, 2 < i < n O(n) aikakompleksisuus

6. Tasapainotettu puu • Rinnakkainen Prefix sum -menetelmä • Käytetään tasapainotettu puu -tekniikkaa • Ylöspäin mentäessä välisolmut edustavat * operaatiota • Alaspäin tultaessa lesketaan prefix sum:mia kunkin tason solmuille

7. Tasapainotettu puu • Esimerkki: 8 elementin prefix sum • Ensimmäisellä aika-askeleella: y1 = x1*x2, y2 = x3*x4, y3 = x5*x6, y4 = x7*x8 • Toisella aika-askeleella y’1 = y1*y2, y’2 = y3*y4 • Kolmannella aika-askeleella y’’1 = y’1*y’2 • Koska n = 8, neljännellä aika-askeleella suoritetaan vain s1 = x1 (= y’’1 = z’’1)

8. Tasapainotettu puu • Neljännellä aika-askeleella rekursio alkaa purkautua s1 = x1 (= y’’1 = z’’1) • Viidennellä aika-askeleella (n = 2) s1 = x1 = y’1 , s2 = z’1 = • Kuudennella aika-askeleella (n = 4) s1 = x1 = y1 , s2 = z1 = s3 = z1 * x3 = s4 = z2 = • Viimeisellä seitsemännellä aika-askeleella saadaan summat s1 - s8

9. Tasapainotettu puu • Prefix sum • Syötteen koolla n = 2k, algoritmi vie ajan 2k+1 • k ensimmäistä askelta kuluu ylöspäin mennessä • k viimeistä askelta alaspäin tultaessa • Prefix sum algoritmin kompleksisuus on: Aikakompleksisuus T(n) = O(logn) Työkompleksisuus W(n) = O(n)

10. Tasapainotettu puu • Todistus k:n induktiolla: syötteen koko n = 2k • k = 0 tapaus hoituu algoritmin 1. Askeleella • Oletetaan, että algoritmi toimii oikein kaikille syötteille kun n = 2k • Todistetaan, että algoritmi laskee minkä tahansa n = 2k+1 pituisen syötteen prefix sum:mat

11. Tasapainotettu puu • Muuttujissa z1, z2, …, zn/2 on sarjan {y1, y2, … , yn/2} prefix sum:mat (induktiohypoteesin mukaan) • zj = y1 * y2 *…* yj eli zj = x1 * x2 *…* x2j-1 * x2j eli zj on s2j:n prefix sum 1 < j < n/2 • jos i = 2j, niin si = zi/2 • jos i = 1, tapaus triviaali • jos i = 2j + 1, niin si = s2j+1 = s2j*x2j+1 = z(i-1/2)*xi

12. Tasapainotettu puu • Prefix sum algoritmi ei kaipaa millään askeleella yhtäaikaista luku- tai kirjoitus-operaatiota • toimii siis EREW PRAM:ssa • Tasapainotettu puu -menetelmää käytetään paljon rinnakkaisalgoritmien kehittelyssä • Menetelmän ei tarvitse rajoittua vain bi-naaripuihin, vaan se soveltuu myös muihin

13. Pointterihyppely • Pointterihyppely tarjoaa yksinkertaisen ja tehokkaan menetelmän linkitettyihin listoi-hin tai puihin perustuvan datan käsittelyyn • Pointterihyppelyssä käytetään hyväksi solmusta toiseen osoittavia pointtereita (joita pitkin rakenteessa edetään)

14. Pointterihyppely • Suunnattu puu (root-directed tree) T on suunnattu graafi, jossa on olemassa solmu r, siten että: • kaikille v  V -{r} uloslähtevien linkkien määrä on 1 ja r:lle 0 • kaikille v  V -{r} on olemassa suunnattu polku v:stä r:ään

15. Pointterihyppely • Esimerkki: metsän juurien etsiminen • Olkoon F metsä, joka koostuu useista suunnatuista puista • Esitetään F n:n mittaisena vektorina P siten, että P(i) = j, jos (i,j) on linkki F:ssä (eli j on i:n vanhempi) • Juurelle P(i) = i • Määritetään kunkin solmun j juuri S(j), 1<j<n

16. Pointterihyppely • Peräkkäinen ratkaisu: • Etsitään juuret ja päivitetään lapsille tiedot • O(n) aikakompleksisuus • Rinnakkainen ratkaisu: • Määritellään kullekin solmulle seuraaja S(i) siten, että alkuun se on P(i) • Käytetään pointterihyppelyä muuttamaan seuraaja aina seuraavan solmun seuraajaan

17. Pointterihyppely • Kun tekniikkaa käytetään useita kertoja, lähestyy solmun seuraaja-informaatio puun juurta, lopulta paljastaen juuren • Pointterihyppelyn kompleksisuus: • aikakompleksisuus O(logn) • työkompleksisuus O(nlogn)

18. Pointterihyppely • Pointterihyppelyä kutsutaan myös nimellä Path Doubling, koska etäisyys solmun ja seuraajan välillä aina kaksinkertaistuu (ellei seuraaja ole juuri) • k:nnella iteraatiolla i:n ja S(i):n välinen etäisyys on 2k ellei S(i) ole juuri • Menetelmä voi vaatia yhtäaikaista luku-operaatiota (eli tarvitaan CREW PRAM)

19. Hajoita ja hallitse • Divide and Conquer • Koostuu kolmesta askeleesta: • hajoitetaan ongelma useaan lähes samankokoi-seen osaan • ratkaistaan osat (rekursiivisesti) • yhdistetään osatulokset kokonaisratkaisuksi • Tekniikan käyttökelpoisuus riippuu pitkälti 1. ja 3. vaiheen tehokkuudesta

20. Hajoita ja hallitse • Konveksipeite -ongelma (Convex hull) • Olkoon meillä n pisteen joukko S = (p1,…, pn) • Jokaisella pisteellä on (x,y) koordinaatit • S:n konveksipeite on pienin mahdollinen polygoni Q, joka sisältää kaikki S:n n pistettä • Polygoni Q on konveksi, jos mille tahansa kahdelle pisteelle p ja q, viivesegmentti, jonka päätepisteet p ja q ovat, on kokonaisuudessaan Q:n sisällä

21. Hajoita ja hallitse • Konveksin peitteen ongelmassa pyritään määräämään S:n pisteet CH(S) (jossakin järjestyksessä) siten, että ne määräävät polygonin Q • Konveksin peitteen peräkkäinen ratkaisu käyttämällä hajoita ja hallitse tekniikkaa vie ajan O(n log n).

22. Hajoita ja hallitse • Rinnakkainen ratkaisu käyttämällä hajoita ja hallitse tekniikkaa: • Olkoon p ja q pisteet S:ssä siten, että ne edus-tavat pienintä ja suurinta x koordinaattia => Ne siis kuuluvat selvästi CH(S):ään • Samalla ne jakavat peitteen ylempään UH(S) p-q ja alempaan LH(S) q-p osaan • Koska ratkaisu on periaatteessa sama molem-mille osille, keskitytään vain ylemmän osan ratkaisuun

23. Hajoita ja hallitse • Oletetaan, että n luvun lajittelu voidaan suorit-taa O(log n) ajassa ja O(nlog n) operaatiolla • Oletetaan myös, että kahdella pisteellä ei ole samaa x tai y koordinaattia ja n on kahden potenssi • Alustetaan tehtävä lajittelemalla pisteet pi x- koordinaattinsa perusteella x(p1) < x(p2) < … < x(pn)

24. Hajoita ja hallitse • Olkoon meillä S:n osajoukot S1 = (p1, p2, …, pn/2) ja S2 = (pn/2 + 1, ... , pn) • Oletetaan, että UH(S1) ja UH(S2) on ratkaistu • Yhteinen ylätangentti UH(S1):n ja UH(S2):n välillä jättää UH(S1):n ja UH(S2):n alleen • Yhteisen ylätangentin etsintä voidaan suorittaa O(log n) ajassa (peräkkäisellä binaarisella etsinnällä)

25. Hajoita ja hallitse • Olkoot UH(S1) = (q1, ..., qs) ja UH(S2) = (q’1, ..., q’t) osajoukkojen konveksit peitteet • Jos yhteinen ylätangentti on (qi,q’j), niin UH(S) koostuu i ensimmäisestä UH(S1):n elementistä ja t-j+1 viimeisestä UH(S2):n elementistä eli UH(S) = (q1, ... , qi, q’j, ... , q’t) • Menetelmä, jolla UH(S1) ja UH(S2) yhdistetään vaatii yhtäaikaista lukuominaisuutta (yhteisen ylätangentin määrääminen)

26. Hajoita ja hallitse • Algoritmi laskee ylemmän peitteen n pisteelle ajassa O(log2n) ja suorittaa O(nlog n) operaa-tiota Algoritmi on siis kustannusoptimaalinen • Algoritmia voidaan tehostaa n -hajoita ja hallitse menetelmällä ja liukuhinoitetulla hajoita ja hallitse menetelmällä • Optimaalinen aika ongelmalle on O(log n)

27. Ositus • Partitioning • Ositusmenetlmä voidaan jakaa kahteen vaiheeseen: • Jaetaan ongelma p itsenäiseen lähes samanko-koiseen osaongelmaan • Ratkaistaan p osaongelmaa rinnakkaisesti p prosessorilla

28. Ositus • Ajatus lähes sama kuin hajoita ja hallitse menetelmässä, mutta siinä missä hajoita ja hallitse keskittyy tehokkaan yhdistämis-menetelmän käyttöön, ositus perustuu ongelman tehokkaaseen jakamiseen siten, että osat on helppo yhdistää • Yksinkertaisimmillaan menetelmä jakaa ongelman p ei-päällekkäiseen osaan ja nämä p osaa sitten ratkaistaan erillisesti

29. Ositus • Joukkojen yhdistäminen: • Olkoon meillä joukko S, joka on täydellisesti järjestetty eli kaikille a,b  S joko a  b tai b  a • Olkoon A = (a1, ... ,an) ja B = (b1, ... ,bn) kasva-vat joukot, joiden elementit on saatu joukosta S • Tarkastellaan ongelmaa, missä joukot A ja B tulee yhdistää yhdeksi järjestetyksi joukoksi C • Yksinkertainen peräkkäinen ratkaisu vie ajan O(n)

30. Ositus • Yksinkertainen yhdistämisalgoritmi: • Olkoon X = (x1, ... , xt) sarja, jonka elementit ovat joukosta S • Määritellään x:n arvo (x  S) rank(x:X) siten, että se on niiden X:ssä olevien elementtien määrä, jotka ovat pienempiä kuin x • Olkoon Y = (y1, ... ,ys) satunnainen sarja ele-menttejä S:stä • Y:n yhdistäminen X:ään määrittää sarjan rank(Y:X) = (r1, ... ,rs), missä ri = rank(yi:X)

31. Ositus • Esimerkki: • X = (25, -13, 26, 31, 54, 7) ja Y = (13, 27, -27) • Rank(Y:X) = (2, 4, 0) • Oletetaan, että yhdistettävien jonojen A ja B elementit ovat erillisiä • Yhdistämisongelma voidaan nähdä ongelmana, missä jokainen A:n tai B:n elementti rankataan joukkoon A  B • Jos rank(x:A  B) = i, niin ci = x

32. Ositus • Koska rank(x:A  B) = rank(x:A) + rank(x:B), voidaan yhdistämisongelma ratkaista määrit-tämällä rank(A:B) ja rank(B:A) • Koska molempiin pätee samat periaatteet, rat-kaistaan jälleen vain toinen osaongelmista eli rank(B:A) • Olkoon bi satunnainen B:n elementti

33. Ositus • Koska A on järjestetty, löydetään bi A:sta bi-näärisellä etsintäalgoritmilla eli verrataan bi:tä A:n keskimmäiseen elementtiin ja edetään sen mukaan onko A:n alkio liian suuri vai pieni • Peräkkäinen etsintä vie ajan O(log n). • Kun algoritmia sovelletaan rinnakkaisesti kaikkiin B:n elementteihin, saamme tuloksen ajassa O(log n) O(n log n) operaatiolla ei kustannusoptimaalinen (Seq. O(n))

34. Liukuhihnoitus • Liukuhihinoitus -menetelmä noudattaa sa-moja periaatteita kuin tietokoneiden sisäi-nen liukuhihnoitus • Liukuhihnoituksella mahdollistetaan usei-den käskyjen samanaikainen suoritus (eri vaiheissa) • Liukuhihnoituksessa ongelma jaetaan ali-ongelmiin, joita suoritetaan järjestyksessä, mutta yhtäaikaisesti muiden kanssa

35. Liukuhihnoitus • 2-3 puun käsittely liukuhihnoituksella: • 2-3 puu on puu, jossa jokaisella sisäisellä solmulla on kaksi tai kolme lasta ja jokainen polku juuresta lehtiin on saman mittainen • h korkuisessa puussa lehtien lukumäärä on välillä 2h - 3h • Jos lehtien lukumäärä on n, niin puun korkeus on (log n).

36. Liukuhihnoitus • 2-3 puulla voidaan esittää järjestetty lista siten, että lehdet sisältävät listan elementit järjestyk-sessä vasemmalta oikealle • Välisolmuilla on muuttujat L, M ja R, jotka kertovat solmun alipuiden suurimmat elementit • Esimerkki: • A = (1,2,3,4,5,6,7) Tämä voidaan esittää 2-3 puuna. • Notaatiolla i:j:k voidaan esittää sisäisen solmun  suurimmat elementit

37. Liukuhihnoitus • 2-3 puun perusoperaatiot • Etsintä, lisäys poisto voidaan suorittaa ajassa O(log n), kun elementtejä on n kappaletta • Etsintä voidaan helposti toteuttaa binaarisella etsinnällä • Elementin b lisäys voidaan aloittaa sen kohde-paikan etsinnällä • Etsitään lehti u siten, että tähän lehteen talletetulle ai:lle pätee ai< b < ai+1

38. Liukuhihnoitus • b:n arvosta riippuu tarvittavat toimenpiteet: • Jos b = ai, niin mitään ei tarvitse tehdä • Muussa tapauksessa luodaan solmu u’ • u’ asetetaan välittömästi u:n oikealle puolelle • Jos puussa on operaation jälkeen kolme alipuuta, niin voimme lopettaa • Jos alipuita on neljä, täytyy puu jakaa kahteen osaan • Lisäyksen aikana L, M ja R muuttujia päivite-tään vastaavasti

39. Liukuhihnoitus • Usean elementin lisääminen puuhun: • Oletetaan, että puussa on n elementtiä ja halu-amme lisätä k elementtiä, missä k < n • Jos käytetään edellistä lisäysoperaatiota peräk-käisesti, niin k elementin lisäys vie O(k log n) ajan peräkkäisesti • Liukuhihnoitusta käyttämällä voidaan sama teh-tävä suorittaa rinnakkaisesti O(log n) ajassa O(klog n) operaatiolla (kustannusoptimaalinen)

40. Liukuhihnoitus • Esivalmistelu: • Esivalmisteluna voidaan pitää ensimmäisen ja viimeisen elementin b1 ja bk sijoitusta puuhun • Tällä varmistetaan, että sijoitettavat elementit mahtuvat aina kahden elementin väliin • Esivalmistelu vie ajan O(log n)

41. Liukuhihnoitus • Etsitään rinnakkaisesti kaikki b elementtien paikat puusta • Tämä vaihe vie O(log n) ajan ja O(k log n) operaatiota • Ryhmitellään b elementit sarjoihin, joiden tulee mahtua kahden peräkkäisen lehden väliin • Merkitään näitä sarjoja Bi:llä |Bi| = ki, 1 < i < n-1

42. Liukuhihnoitus • Luodaan alkuun lehti li , joka sisältää bi:n ja liitetään se vanhempansa yhteyteen • 1 tason välisolmuilla voi olla nyt max. 6 lasta • Kaikille 1 tason solmuille v, joilla on yli 3 lasta muodostetaan uusi välisolmu v’ ja jaetaan lap-set v:n ja v’:n välillä • Prosessia jatketaan ylöspäin kunnes saavutetaan juuri • Juuressa peräkkäiskäsittely

43. Liukuhihnoitus • k elemettiä voidaan lisätä puuhun O(log n) ajas-sa käyttämällä O(klog n) operaatiota, kun ki< 1 • Yleisessä tapauksessa, ki voi olla > 1, edellistä algoritmia toteutetaan ryhmien Bi keskimmäi-sille elementeille • Näiden elemettien lisääminen voidaan suorittaa O(log n) ajassa. Samalla ketjun pituus puolittuu • O(log k) iteraation jälkeen kaikki elementit on saatu lisättyä puuhun. Kokonaisajaksi saadaan O(log k log n)

44. Liukuhihnoitus • Liukuhihnoituksella tätä aikaa voidaan parantaa • Ajatellaan yhtä askelta aina yhtenä vaiheena • Kun ensimmäisen vaiheen elementit on lisätty 1-tasolla, voidaan aloitaa toinen vaihe, … • Kukin vaihe etenee puussa ylöspäin taso kerrallaan ja muuttaa tarvittaessa puun muotoa • Algoritmi vie O(log n + log k) ajan ja O(klog n) operaatiota

45. Hitaan ja nopean menetelmän yhdistäminen • Accelerated cascading • Menetelmä perustuu kahden erillisen algo-ritmin yhdistämiseen: • Hidas ja kustannusoptimaalinen • Nopea ja ei-optimaalinen

46. Hitaan ja nopean menetelmän yhdistäminen • Joukon maksimin etsintä: • Olkoon X = {x1, x2, … xn} sarja elementtejä, joiden maksimi xi on tarkoitus etsiä • Peräkkäinen ratkaisu on triviaali ja voidaan ratkaista lineaarisesti ajassa O(n) • Käydään läpi kaikki elementit ja verrataan aina kulloinkin suurimpaan

47. Hitaan ja nopean menetelmän yhdistäminen • Oletuksia: • Oletetaan, että xi:t ovat erillisiä • Muussa tapauksessa voimme korvata xi:t parilla (xi,i) ja laajentaa relaation > seuraavasti (xi,i) > (xj,j) joss xi > xj tai xi = xj ja i > j • Maksimielementti voidaan ratkaista helposti tasapainotetulla puulla ajassa O(log n) käyttä-mällä O(n) operaatiota • Kustannusoptimaalinen ratkaisu

48. Hitaan ja nopean menetelmän yhdistäminen • Tasapainotetun puun käyttö muodostaa tässä menetlmässä hitaan ja optimaalisen algoritmin • Nopeampi ratkaisu saadaan käyttämällä tuplalogaritmista puurakennetta • Oletettavasti tämä ei kuitenkaan ole kustannus-optimaalinen

49. Hitaan ja nopean menetelmän yhdistäminen • Tuplalogaritminen puurakenne: • Puu muodostetaan siten ,että solmun u alipui-den lukumäärälle pätee nu , missä nu on puun u alipuiden lehtien määrä • Puun välisolmut sisältävät alipuidensa maksi-mielementin • Edellä esitetty ehto solmun alipuille pakottaa rakenteen tuplalogaritmiseksi

50. Hitaan ja nopean menetelmän yhdistäminen • Tuplalogaritmisen puurakenteen käyttökel-poisuus perustuu pitkälti vakioaikaiseen maksimin etsintään • riippumatta elementtien määrästä • Oletetaan, että tällainen algoritmi on olemassa • vie ajan O(1) ja O(p2) operaatiota