Rinnakkaistietokoneet luento 5 521475S
Silmukalliset ohjelmat Silmukat joissa ei ole riippuvuussyklejä voidaan vektoroida eli suorittaa silmukan vektorointi Jokainen yksittäinen käsky silmukan rungossa voidaan suorittaa kaikille iteratiolle samanaikaisesti Esim: do i = 1,n S1: a(i) = b(i+1) + c(i) S2: b(i) = a(i) + 5 Silmukassa on datariippuvuus ja epäriippuvuus lauseiden S1 ja S2 välillä (kts. kuva 3.4) Lauseiden välillä ei kuitenkaan ole sykliä, joka estäisi vektoroinnin Esimerkki silmukka voidaankin vektoroida täydellisesti ja se voidaan kirjoittaa vektoroidussa muodossa: a(1:n) = b(2:n+1) + c(1:n) b(1:n) = a(1:n) + 5 nämä kaksi vektoroitua lauseketta voidaan siis suorittaa peräkkäin ja kumpikin niistä suorittaa operaation usealle datalle (kaikille iteraatioille) samanaikaisesti
Katsotaan silmukkaa, jossa on datariippuvuussykli, jota ei voida poistaa do i = 1,N S1: d(i) = a(i+1) + 3 S2: a(i) = b(i-1) + c(i) S3: b(i) = a(i) 5 Kuvasta 3.5 nähdään, että lauseiden S3 ja S2 välillä on syklinen riippuvuus: seuraava iteraatio käyttää edellisen laskemaa b:n arvoa (riippuvuusvektori d = 1) Lause S1 voidaan vektoroida, koska se on syklin ulkopuolella: silmukka voidaan vektoroida osittain Osittain vektoroitu silmukka: S1: d(1:n) = a(2:n+1) + 3 do i = 1,N S2: a(i) = b(i-1) + c(i) S3: b(i) = a(i) 5
Jotkin vektorioperaatiot muuntavat vektorin skalaariksi, esim. kahden vektorin sisätulo: do i = 1,n S1: a(i) = b(i) * c(i) S2: dot = dot + a(i) Tämä silmukka voidaan vektoroida: S1: a(1,n) = b(1,n) * c(1,n) S2: dot = sum(a(1:n)) missä sum-operaatio laskee argumentin elementit yhteen
DOALL on rinnakkais-fortran rakenne jolla ilmaistaan, että silmukan kaikki iteraatiot suoritetaan rinnakkain (edellyttää sopivaa rinnakkaistietokonetta) Jokainen silmukan iteraatio muunnetaan itsenäiseksi prosessiksi DOALL:n käyttö edellyttää, että silmukan iteraatioiden välillä ei ole riippuvuuksia Koska riippumattomat iteraatiot voidaan suorittaa satunnaisessa järjestyksessä, voidaan kukin iteraatio ajaa omalla prosessorillaan Iteraatioiden riippumattomuus testataan käyttäen data riippuvuuksia Jos datariippuvuusmatriisissa on rivi, jonka kaikki elementit ovat nollia, kaikki iteraatiot ovat riippumattomia tästä indeksisä: ts. riippuvuusvektoreilla ei ole kyseisen indeksin määrittelemää ulottuvuutta joten ei voi löytyä riippuvuuksia, jotka yhdistäisivät eri (ko. indeksin) iteraatioita
Esim: do i = 1,n S1: a(i) = b(i) + c(i) S2: d(i) = a(i) + 2 Silmukalla ei ole iteraatioiden välisiä riippuvuuksia (yksi riippuvuusvektori ja se on d = 0) Silmukka voidaan muuntaa rinnakkaismuotoon rinnakkaislaskentaa varten: DOALL i = 1,n S1: a(i) = b(i) + c(i) S2: d(i) = a(i) + 2 end DOALL Olettaen, että käytössä on n prosessoria, silmukan evaluointi nopeutuu (luokkaa) n kertaisesti: jokainen iteraatio voidaan osoittaa omalle prosessorilleen (mikä ilmaistaa ohjelmoijan toimesta käyttämällä DOALL rakennetta)
DOACROSS on toinen rinnakkaiskielten rakenenne, jota voidaan hyödyntää silmukoiden rinnakkaislaskennassa Jokaisesta silmukan iteraatiosta tulee prosessi mutta prosessit eivät ole täysin riippumattomia toisistaan DOACROSS rakennetta käytetään, kun iteraatioden välillä on riippuvuuksia Nämä riippuvuuden huomioidaan epäsuoran tai suoran synkronoinnin kautta
Esim: do i = 1,n S1: a(i) = b(i) + c(i) S2: d(i) = b(i-1) + c(i) S3: e(i) = a(i-1) + d(i-2) Silmukalla on kaksi riippuvuutta (kts. kuva 3.6) d1 = 1 (a:n kautta) ja d2 = 2 (d:n kautta) Silmukka voidaan suorittaa rinnakkain käyttäen DOACROSSrakennetta: DOACROSS i = 1,n S1: a(i) = b(i) + c(i) S2: d(i) = b(i-1) + c(i) syncronization d1 syncronization d2 S3: e(i) = a(i-1) + d(i-2) end DOACROSS
Jokainen iteraatio voidaan osoittaa eri prosessorille: synkronointilauseet varmistavat, että lause S3 suoritetaan vasta, kun riippuvuudet (kts. kuva 3.6) on huomioitu DOACROSS silmukoissa rinnakkaisuus saadaan hyödynnettyä niiden lauseiden kautta, jotka voidaan suorittaa yht aikaa Iteraatioiden välillä on kuitenkin osoittain määrätty suoritusjärjestys, koska yhden iteraation täytyy odottaa joidenkin käskyjen suoritusta toisessa iteraatiossa
Kuva 3.6 yksi prosessori suorittaa yhden iteraation: lauseet S1-3 suoritetaan peräkkäin d1 d2 synkronointi: d1, d2
Silmukan lauseiden uudelleen järjestely on usein tarpeen rinnakkaisuuden kasvattamiseksi Esim: do i = 1,n S1: b(i) = a(i-2) + 2 S2: a(i) = d(i) + c(i) S3: c(i) = a(i-1) + 3 Silmukalla on riippuvuus d1 lauseiden S2 ja S1 välillä (a:n kautta) ja d2 lauseiden S2 ja S3 välillä (myös a:n kautta) Silmukka ei sovi DOACROSS rakenteen kanssa käytettäväksi, koska toinen riippuvuuksista on ylempään lauseeseen, joka estää kahden iteraation päässä olevan lauseen S1 laskenna aloittamisen, ennen S2:n laskennan päättymistä Yksinkertaisesti vaihtamalla S2:n ja S1:n paikkoja saadaan esiin rinnakkaisuutta jota voidaan hyödyntää: riippuvuudet ovat nyt alempiin lauseisiin
doacross i = i,n S2: a(i) = d(i) + c(i) synchronization d1 synchronization d2 S1: b(i) = a(i-2) + 2 S3: c(i) = a(i-1) + 3 across Jokaisesta silmukan iteraatiosta tulee nyt oma prosessi omalle prosessorille kasvaneen rinnakkaisuuden ansiosta (kts. kuva 3.7 ja 3.8)
Kuva 3.7
Kuva 3.8 S prosessori lauseen id
Esimerkki DOACROSS rakenteesta sisäkkäisten silmukoiden tapauksessa: do i = 1,n do j = 1,n S1: a(i,j) = b(i,j-1) + 2 S2: b(i,j) = a(i,j) + b(i-1, j-1) Silmukalla on kolme riippuvuutta ja riippuvuusmatriisi on: D 0 = 0 0 1 a b b 1 1 i j
Tämä ohjelma voidaan suorittaa käyttämällä DOACROSS-rakennetta rinnakkaistamalla uloin silmukka: doacross i = 1,n do j = 1,n S1: a(i,j) = b(i,j-1) + 2 S2: b(i,j) = a(i,j) + b(i-1,j-1) across Kuva 3.9 esittää aika-avaruusdiagrammia silmukalle: jokainen rivi edustaa yhden prosessorin prosessia Yksi synkronointi tapahtuma tarvitaan, koska riippuvuudella d3 on i-komponentti, joka aiheuttaa riippuvuuden eri i:n iteraatioiden välille: sykronointitapahtuma varmistaa, että yksi prosessori on evaluoinut lauseen S2 ennen kuin tämän lauseen tiedosta riippuvainen prosessori voi aloittaa oman S2 lauseen evaluoinnin Jos kaikkien prosessoreiden laskenta aloitetaan samalla ajan hetkellä, synkronointi tapahtuu välillisesti laskennan ajallisen etenemisen kautta (kts. kuva 3.9) ilman tarvetta suoraan (eksplisiittiseen) synkronointiin (ei tarvita synchronization lausetta) Jos eri prosessorit toimivat täysin asynkronisesti ja eivät olisi homogeenisiä, lauseen S2 suoritusta pitäisi edeltää lause: synchronization d3, jolla varmistettaisiin, että riippuvuusvektorin d3 päässä oleva prosessori, ei aloita S2:n evaluointia, ennenkuin b:n arvo on laskettu riippuvuuden alkupäässä
Kuva 3.9 (i,j) silmukan runko: lauseet 1 ja 2
Liukuhihnoitusmuunnos hajauttaa silmukan itsenäiset osat eri prosessorien laskettavaksi ja ketjuttaa iteraatiot toisiinsa ajan suhteen Esim. do i = 1,n S1;S2;...;Sm Oletetaan, että riippuvuusgraafi tälle silmukalle on kuvan 3.10 kaltainen, eli kaikilla lauseilla on riippuvuus edellisen iteraation vastaavaan lauseeseen Liukuhihnoittamalla lauseiden suoritukset (kts. kuva 3.11 m = 3 ja N = 4) voidaan itsenäiset lausekkeet evaluoida eri prosessoreissa samanaikaisesti käyttämällä m kpl prosessoreita Tähän siis päästää hajauttamalla rakenteellisesti itsenäisesti suoritettavat lauseet eri prosessoreille ja liukuhihnoittamalla iteraatiot ajassa: silmukan suoritusaika on n (jokaisella aikayksiköllä lasketaan yksi iteraatio, jonka suoritus koostuu m:stä lauseesta tai vaiheesta )
Kuva 3.10: riippuvuudet esimerkissä 3.10
Edellisen esimerkin aika-avaruusdisgrammi käytettäessä DOACROSS muunnosta on esitetty kuvassa 3.11b Silmukan lauseet suoritetaan peräkkäin n:ssä prosessorissa Laskenta-aika tässä tapauksessa on n + m -1 Jos n on pieni ja m suuri liukuhihnoitus on merkittävästi nopeampi tapa kuin DOACROSS: tässä esimerkissä liukuhihnoitus ei myöskään vaadi prosessoreiden välistä kommunikointia
Kuva 3.11 riippuvuudet käytettäessä DOACROSS-muunnosta riippuvuudet käytettäessä liukuhihnoitusmuunnosta