8. Begizten Paralelizazioa eta Atazen Banaketa Arkitektura Paraleloak IF - EHU 8. Begizten Paralelizazioa eta Atazen Banaketa - Sarrera - Begizten paralelizazioa - Sinkronizazio-mekanismoak - Optimizazio nagusiak - Iterazioen (atazen) banaketa - Atal paraleloak

Sarrera  Helburua: programak P aldiz azkarrago exekutatzea; kasu partikular bat: begiztak.  Paraleloan exekuta daitezkeen atazak identifikatu behar dira (dependentzien analisia). Prozesuak sinkronizatu behar dira. Prozesuak prozesadoreetara banatu behar dira.  Adi: eraginkortasuna!

Sarrera  Paralelismo motak (1) (a) Datu-paralelismoa P0 P1 P2 do i = 1, 3000 A(i) = fun(i) enddo do i = 1, 1000 do i = 1001, 2000 do i = 2001, 3000 A(i) = fun(i) A(i) = fun(i) A(i) = fun(i) enddo enddo enddo P0 P1 P2

Sarrera  Paralelismo motak (1) (b) Funtzio-paralelismoa P0 P1 F1 F2

▪ ale xehea (fine grain) ataza “txikiak” ▪ ale ertaina Sarrera  Paralelismo motak (2) ▪ ale xehea (fine grain) ataza “txikiak” komunikazio asko ▪ ale ertaina ▪ ale larria (coarse grain) ataza “handiak” komunikazio gutxi

 Atazen arteko dependentziak? Sarrera  Atazen arteko dependentziak? P0 P1 F1 F2 F3 F4 Sinkronizazioa - globala (hesiak) - gertaerak (puntutik puntura)

▪ SPMD (Single-Program-Multiple-Data) Sarrera  Bi eredu: ▪ Nagusi/Morroi Hari (thread) nagusiak P hari sortzen ditu une jakin batean, paraleloan exekuta daitezen; ataza bukatutakoan, “hiltzen” dira. ▪ SPMD (Single-Program-Multiple-Data) Programaren P kopia (berdinak) exekutatzen dira. Atazak bereizteko, prozesuen identifikado-reak erabiltzen dira (pid).

ale xehea / ertaina Sarrera  Begizten paralelizazioa begiztaren iterazioen banaketa dependentzien analisia  Modu eraginkorrean. Programatzailea edo konpiladorea?

Sarrera  Eskuarki, eta salbuespenak salbuespen, kodearen paralelizazioa (dependentzien analisia, lan-banaketa…) programatzaileak berak egin behar du. Hori dela eta, begiztak eraginkorki paraleliza-tzeko ohiko aukerak analizatu behar ditugu.

Sarrera  Kodearen frakzio handi bat exekutatu behar da paraleloan; ez ahaztu Amdahl-en legea.  Kodearen paralelizazioak (bektorizazioak bezalaxe) begiztaren aginduen jatorrizko ordena aldatzen du. Beraz, aginduen arteko datu-dependentziak kontuan hartu behar dira.

Sarrera Adibidez: Paraleloan do i = 0, N-1 A(i) = A(i) + 1 enddo L0 +0 S0 L1 +1 S1 L2 +2 S2 ... P0: L0 +0 S0 P1: L1 +1 S1 P2: L2 +2 S2 … ... Paraleloan L2 L0 +2 L1 +0 +1 S2 S1 S0 ...

Sarrera: datu-depend. i: A = ... j: = A i: = A ... j: A = WAW i: A = benetako dependentziak izen-dependentziak  dependentzia RAW i: A = ... j: = A  antidependentzia WAR i: = A ... j: A =  irteera-dependentzia WAW i: A = ... j: A = i j

Sarrera: datu-depend. Begiztak + Dependentzia-grafoak + Dependentziaren distantzia do i = 2, N-2 1 A(i) = B(i) + 2 2 C(i) = A(i-2) + A(i+1) enddo A(2) = B(2) + 2 C(2) = A(0) + A(3) A(3) = B(3) + 2 C(3) = A(1) + A(4) A(4) = B(4) + 2 C(4) = A(2) + A(5) A(5) = B(5) + 2 C(5) = A(3) + A(6) 1 2 A, 2 A, 1

Sarrera: depend.-grafoak 1 2 3 4 5 A, 0 A, 2 do i = 2, N-31 1 A(i) = B(i) + 2 2 C(i) = A(i-2) 3 D(i+1) = C(i) + C(i+1) 4 B(i+1) = B(i) + 1 5 D(i+30) = A(i) enddo B, 1 C, 0 C, 1 D, 29 B, 1

Sarrera: depend.-grafoak + Iterazio-espazioa i j do i = 2, N-1 do j = 1, N-2 1 A(i,j) = A(i,j-1) * 2 2 C(i,j) = A(i-2,j+1) + 1 enddo 1 2 A 2,-1 A 0,1

Sarrera: depend.-proba  Dependentzia-proba automatikoa: begiztaren indizearen funtzio linealak soilik. a*i+b L1 L2 i c*i+d do i = L1, L2 X(a*i+b) = = X(c*i+d) enddo i1 i2 d - b ZKH(c,a)  Z → ez dago depend.

Begizten paralelizazioa  Begizten iterazioak prozesadoreen artean banatu behar dira, baina, jakina, datu-dependentziak errespetatu behar dira. Arazoa distantzia > 0 duten dependentziak dira, eta, batik bat, dependentzia-grafoan zikloak osatzen dituztenak.

Begizten paralelizazioa  Begiztak beti exekuta daitezke P prozesadore erabiliz, dependentziak errespetatzeko behar den sinkronizazioa gehituta… …baina horrek ez du esan nahi beti egin behar denik, kostu orokorra kontuan hartu behar baita: kalkulua + sinkronizazioa (komunikazioa).

Helburuak: Begizten paralelizazioa  Begizten iterazioak prozesadoreetara banatzea, “aldi berean” exekuta daitezen.  Ahal bada, prozesuen arteko sinkronizazioa erabili behar izan gabe (0 distantziako depen-dentziak).  Makinaren ezaugarrien arabera (komunikazio-sarea, lan-banaketa…), tamaina jakin bateko atazak sortzea.

Begizten paralelizazioa  Agian, prozesadore kopuru mugatua erabili beharko da.  Adi eraginkortasunari (ad., cache memoriaren erabilera).

Begizten paralelizazioa > Adibideak do i = 0, N-1 A(i) = A(i) + 1 B(i) = A(i) * 2 enddo P0 P1 P2 P3

? Begizten paralelizazioa > Adibideak do i = 0, N-2 A(i) = B(i) + 1 B(i+1) = A(i) * 2 enddo P0 P1 P2 P3 ?

Begizten paralelizazioa > Adibideak P0 P0 P1 P1 do i = 0, N-3 A(i+2) = A(i) + 1 enddo

Begizten paralelizazioa > Adibideak i j do i = 0, N-1 do j = 1, M-1 A(i,j) = A(i,j-1) + 1 enddo P0 P1 P2 P3

Begizten paralelizazioa > Adibideak i j P0 P1 P2 P3 do i = 0, N-1 do j = 1, M-1 A(i,j) = A(i,j-1) + 1 enddo

Begizten paralelizazioa  Aginduen arteko dependentziak 0 distantziakoak baldin badira, hau da, iterazioak independenteak badira, iterazioak nahi den moduan bana daitezke prozesadoreetara, sinkronizazioa erabili gabe: doall.  Iterazioen arteko dependentziak baldin badaude, baina denak “aurrerantz” badoaz, sinkronizazio-hesiak erabil daitezke: forall (edo doall + barrier).  Dependentzia-zikloak baldin badaude, puntutik pun-turako sinkronizazioa erabili behar da: doacross.

Doall begiztak  Iterazioak independenteak dira, eta banaketa nahi den moduan egin daiteke: doall. do i = 0, N-1 C(i) = C(i) * C(i) A(i) = C(i) + B(i) D(i) = C(i) / A(i) enddo doall i = 0, N-1 C(i) = C(i) * C(i) A(i) = C(i) + B(i) D(i) = C(i) / A(i) enddoall 1 2 3 C, 0 A, 0 i=0 1 2 3

Forall begiztak  Iterazioen arteko dependentziak daude, baina denak aurrerantz doaz: forall.  Dependentzia bakoitza hesi baten bidez sinkroniza daiteke: prozesuek zain geratuko dira agindu jakin bat denok exekutatu arte.  Behar dena baino sinkronizazio gehiago gehitzen da, baina oso metodo sinplea da.

Forall begiztak do i = 1, N-1 C(i) = C(i) * C(i) A(i) = C(i) + B(i) D(i) = C(i-1) / A(i) enddo forall i = 1, N-1 C(i) = C(i) * C(i) A(i) = C(i) + B(i) HESIA (...) D(i) = C(i-1) / A(i) endforall 1 2 3 C, 0 A, 0 C, 1 i=1 2 3 4 hesia

Forall begiztak doall i = 1, N-1 C(i) = C(i) * C(i) A(i) = C(i) + B(i) enddoall [ HESIA (...) ] D(i) = C(i-1) / A(i) do i = 1, N-1 C(i) = C(i) * C(i) A(i) = C(i) + B(i) D(i) = C(i-1) / A(i) enddo 1 2 3 C, 0 A, 0 C, 1 i=1 2 3 4 hesia

 Dependentziak sinkronizatzeko, gertaera-bektoreak: Doacross begiztak  Dependentziek zikloak osatzen dituzte: doacross, ekoizle/kontsumitzaile motako sinkronizazioa.  Dependentziak sinkronizatzeko, gertaera-bektoreak: post (gA,i)  gA(i) := 1 wait (gA,i)  itxaron gA(i) = 1 izan arte  gA(i) = 0 bada, oraindik ez da exekutatu sinkronizatzen ari den aginduaren i iterazioa.

Doacross begiztak do i = 2, N-2 A(i) = B(i-2) + 1 doacross i = 2, N-2 B(i+1) = A(i-2) * 2 enddo doacross i = 2, N-2 wait (gB,i-3) A(i) = B(i-2) + 1 post (gA,i) wait (gA,i-2) B(i+1) = A(i-2) * 2 post (gB,i) enddoacross 1 2 A,2 B,3 1 1 1 . . . 2 2 2 . . . 1 1 1 2 2 2 i=2 3 4 5 6 7

Doacross begiztak do i = 2, N-2 A(i) = B(i-2) + 1 doacross i = 2, N-2 B(i+1) = A(i-2) * 2 enddo doacross i = 2, N-2 wait (gB,i-3) A(i) = B(i-2) + 1 post (gA,i) wait (gA,i-2) B(i+1) = A(i-2) * 2 post (gB,i) enddoacross , 3 1 2 A,2 B,3 12 13 14 22 23 24 15 16 17 25 26 27 ... P0 P1 P2

?? Doacross begiztak  ADI: paralelizatzea ez da beti egokia do i = 0, N-2 A(i) = B(i) + C(i) B(i+1) = A(i) / 2 enddo doacross i = 0, N-2 wait (gB,i-1) A(i) = B(i) + C(i) B(i+1) = A(i) / 2 post (gB,i) enddoacross 1 2 p w … ?? 1 2 A,0 B,1

 Bi dimentsioko gertaera-bektoreak Doacross begiztak  Bi dimentsioko gertaera-bektoreak do i = 0, N-2 do j = 0, N-2 A(i+1,j+1) = A(i+1,j) + 1 B(i,j) = A(i,j) enddo doacross i = 0, N-2 do j = 0, N-2 A(i+1,j+1) = A(i+1,j) + 1 post (gA,i,j) wait (gA,i-1,j-1) B(i,j) = A(i,j) enddo enddoacross P0 P1 P2 P3

 Antidependentziak / Irteera-dependentziak Beste dependentziak  Antidependentziak / Irteera-dependentziak Prozesuen artean baldin badira, sinkronizatu egin behar dira. do i = 0, N-3 A(i) = B(i+2) / A(i) B(i) = B(i) + C(i) enddo doacross i = 0, N-3 A(i) = B(i+2) / A(i) post (gB,i) wait (gB,i-2) B(i) = B(i) + C(i) enddoacross LD B(i+2) post ... wait ST B(i) 1 2 B,2

If aginduak  If motako aginduak do i = 1, N-1 if (B(i) > 0) then A(i) = A(i) + B(i) C(i) = A(i-1) / 2 endif enddo doacross i = 1, N-1 if (B(i) > 0) then A(i) = A(i) + B(i) post (gA,i) wait (gA,i-1) C(i) = A(i-1) / 2 endif enddoacross else post (gA,i) endif 1 2 A,1

Sinkroniz.-mekanismoak  Nola sinkronizatu aginduak? • gertaera-bektoreen bidez (post/wait) - hasieratzea - tamaina (memoria) - adi! partekatze faltsua • kontagailuen bidez

Sinkroniz.-kontagailuak  Sinkronizazio-kontagailu bat dependentzia bakoitzeko - prozesuek ordena hertsian gehitzen dute kontagailua, agindu horren exekuzioa bukatu dela adierazteko. - kA = j j arteko iterazio guztiak bukatu dira, baina j+1 iterazioa ez. i = 0 1 2 3 4 5 6 7 8 9... gA(i) = 1 1 1 0 1 0 1 1 0 0... kA = 2

Sinkroniz.-kontagailuak  Nola sinkronizatu dependentzia bat kontagailu baten bidez: - i iterazioa exekutatu ondoren, itxaron egin behar da kontagailua i-1 izan arte (hau da, agindu horren exekuzioa i-1 iteraziora heldu arte): wait (kA,i-1) → itxaron kA = i-1 izan arte - gero, gehitu kontagailua, i iterazioa ere exekutatu dela adierazteko: post (kA,i) → kA := kA + 1 (kA := i)

Sinkroniz.-kontagailuak do i = 3, N-1 C(i) = C(i) * D(i-3) A(i) = C(i) + B(i) D(i) = C(i-1) / A(i) enddo doacross i = 3, N-1 wait (gD,i-3) C(i) = C(i) * D(i-3) post (gC,i) A(i) = C(i) + B(i) wait (gC,i-1) D(i) = C(i-1) / A(i) post (gD,i) enddoacross doacross i = 3, N-1 wait (kD,i-3) C(i) = C(i) * D(i-3) wait (kC,i-1) post (kC,i) A(i) = C(i) + B(i) D(i) = C(i-1) / A(i) wait (kD,i-1) post (kD,i) enddoacross 1 2 3 C, 0 A, 0 C,1 D,3 1 1 1 2 2 2 3 3 3

Sinkroniz.-kontagailuak do i = 3, N-1 C(i) = C(i) * D(i-3) A(i) = C(i) + B(i) D(i) = C(i-1) / A(i) enddo doacross i = 3, N-1 C(i) = C(i) * D(i-3) wait (kC,i-1) post (kC,i) A(i) = C(i) + B(i) D(i) = C(i-1) / A(i) enddoacross P0 1 2 3 C, 0 A, 0 C,1 D,3 1 1 1 2 2 2 3 3 3 Sinkronizazioa minimizatu

Adibide bat doacross i = ... doacross i = ... [ 1 ] forall i = ... post (gA,i) wait (gA,i-1) [ 2 ] post (gC,i) [ 3 ] wait (gC,i-2) [ 4 ] enddoacross doacross i = ... [ 1 ] wait (kA,i-1) post (kA,i) [ 2 ] wait (kC,i-1) post (kC,i) [ 3 ] [ 4 ] enddoacross forall i = ... [ 1 ] hesia(...) [ 2 ] [ 3 ] [ 4 ] endforall 1 2 3 A, 1 C, 2 B,0 A,0 4

Optimizazio nagusiak 0. Konstanteen definizioak eta indukzio-aldagaiak desegitea. 1. Berezkoak ez diren dependentzia guztiak ezabatzea. Esaterako, do i = 0, N-1 X = A(i) * B(i) C(i) = SQRT(X) D(i) = X - 1 enddo doall i = 0, N-1 X(i) = A(i) * B(i) C(i) = SQRT(X(i)) D(i) = X(i) - 1 enddoall X aldagaia pribatua bihurtu ez da bektore bat erabilli behar, nahikoa da X aldagaia pribatua dela adieraztea

Optimizazio nagusiak 2. Begiztaren fisioa. Seriean exekutatu behar den zati bat baldin badago, zatitu begizta bi partetan (edo gehiago), ahal dena paraleloan exekutatzeko. do i = 1, N-1 A(i) = A(i-1) / 2 D(i) = D(i) + 1 enddo do i = 1, N-1 A(i) = A(i-1) / 2 enddo doall i = 1, N-1 D(i) = D(i) + 1 enddoall

3. Dependentziak ordenatzea (aurrerantz). Optimizazio nagusiak 3. Dependentziak ordenatzea (aurrerantz). do i = 1, N-1 A(i) = D(i-1) / 2 D(i) = C(i) + 1 enddo forall i = 1, N-1 D(i) = C(i) + 1 HESIA (...) A(i) = D(i-1) / 2 endforall 1 2 D, 1 2………….1 2………1 2…….1 1…2.. ??

4. Dependentziak lerrokatzea: peeling. Optimizazio nagusiak 4. Dependentziak lerrokatzea: peeling. do i = 1, N-1 A(i) = B(i) C(i) = A(i-1) + 2 enddo C(1) = A(0) + 2 doall i = 1, N-2 A(i) = B(i) C(i+1) = A(i) + 2 enddoall A(N-1) = B(N-1) 1 2 A, 1

Optimizazio nagusiak do i = 2, N-1 1 A(i) = B(i) C(i) = A(i-1) + A(i-2) enddo 1 2 A, 2 A, 1 do i = 2, N-1 A(i) = B(i) X(i) = B(i) C(i) = X(i-1) + A(i-2) enddo C(2) = A(1) + A(0) C(3) = B(2) + A(1) doall i = 2, N-3 A(i) = B(i) X(i+1) = B(i+1) C(i+2) = X(i+1) + A(i) enddoall A(N-2) = B(N-2) A(N-1) = B(N-1) 1’ 2 A, 2 X, 1 1

5. Hari independenteak sortzea Optimizazio nagusiak 5. Hari independenteak sortzea do i = 0, N-3 A(i+1) = B(i) + 1 B(i+2) = A(i) * 3 C(i) = B(i+2) - 2 enddo B(2) = A(0) * 3 C(0) = B(2) - 2 doall k = 0, 2 do i = pid, N-4, 3 A(i+1) = B(i) + 1 B(i+3) = A(i+1) * 3 C(i+1) = B(i+3) – 2 enddo enddoall A(N-2) = B(N-3) + 1 1 2 3 B,0 B,2 A,1 1 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 3

6. Sinkronizazioa minimizatzea Optimizazio nagusiak 6. Sinkronizazioa minimizatzea 1 2 3 B,0 B,1 A,1 4 5 C,1 C,2 D,0 do i = 2, N-1 B(i) = B(i) + 1 C(i) = C(i) / 3 A(i) = B(i) + C(i-1) D(i) = A(i-1) * C(i-2) E(i) = D(i) + B(i-1) enddo doacross i = 2, N-1 B(i) = B(i) + 1 C(i) = C(i) / 3 post (gC,i) wait (gC,i-1) A(i) = B(i) + C(i-1) post (gA,i) wait (gA,i-1) D(i) = A(i-1) * C(i-2) E(i) = D(i) + B(i-1) enddoacross 1 2 3 4 5 i=2 3 4 ...

7. Bi dimentsioko begiztak: begizta-trukea. Optimizazio nagusiak 7. Bi dimentsioko begiztak: begizta-trukea. do j do_par i do i do_par j do_par i do j do_par j do i

Optimizazio nagusiak Adibidez: do i = 1, N-1 do j = 0, N-1 2 3 4 do i = 1, N-1 do j = 0, N-1 A(i,j) = A(i-1,j) + 1 enddo do i = 1, N-1 doall j = 0, N-1 A(i,j) = A(i-1,j) + 1 enddoall enddo

Optimizazio nagusiak Adibidez: do i = 1, N-1 do j = 0, N-1 2 3 4 do i = 1, N-1 do j = 0, N-1 A(i,j) = A(i-1,j) + 1 enddo doall j = 0, N-1 do i = 1, N-1 A(i,j) = A(i-1,j) + 1 enddo enddoall

8. Bi dimentsioko begiztak: noranzko-aldaketa. Optimizazio nagusiak 8. Bi dimentsioko begiztak: noranzko-aldaketa. do i = 1, 100 do j = 0, 2 A(i,j) = A(i,j) - 1 D(i) = A(i-1,j+1) * 3 enddo j=0 1 2 i=1 2 3 4 do j = 2, 0, -1 doall i = 1, 100 A(i,j) = A(i,j) - 1 D(i) = A(i-1,j+1) * 3 enddoall enddo

Optimizazio nagusiak 9. Skew do i = 1, N do j = 1, N A(i,j) = A(i-1,j) + A(i,j-1) enddo do j = 1, 2N-1 doall i = max(1,j-N+1), min(j,N) A(i,j-(i-1)) = A(i-1,j-(i-1)) + A(i,j-1-(i-1)) enddoall enddo

10. Ohiko beste zenbait optimizazio: Optimizazio nagusiak 10. Ohiko beste zenbait optimizazio: Alearen tamaina handitzeko eta paralelizazioaren gainkarga arintzeko. - Bi begizta batean bildu (esanahia mantentzen bada!): fusioa. - Bi dimentsioko begizta dimentsio bakarreko begizta bihurtu: kolapsoa edo koalestzentzia. - …

 Baina iterazio baino prozesadore gutxiago badago? Iterazioen banaketa  Nola banatzen dira begizten iterazioak (atazak, oro har) prozesadoreen artean? Iterazio adinako prozesadore badago, agian bat prozesadoreko.  Baina iterazio baino prozesadore gutxiago badago? Banaketa (scheduling) izan daiteke: estatikoa: programa konpilatzen denean. dinamikoa: programa exekutatzen ari denean.

Iterazioen banaketa  Helburua: banatzen diren atazen exekuzio-denborak berdintsuak izatea, hutsarteak saihesteko (load balancing).  Nolanahi ere den, adi dependentziei (sinkronizazioa), ale-tamainari, atzipenen lokaltasunari, eta banaketaren kostuari.

Iterazioen banaketa  Banaketa estatikoa Programa konpilatzen denean erabakitzen da zer exekutatuko duen prozesu bakoitzak. Beraz, erabakita dago exekuzioa hasi baino lehen. Prozesuek aldagai pribatu bana erabiltzen dute identifikadore gisa: pid (0..P-1). Oinarrizko bi aukerak: ondoz ondokoa eta tartekatua.

▪ Ondoz ondokoa ▪ Tartekatua Iterazioen banaketa 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 ▪ Tartekatua 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 hasi = pid * N/P buka = (pid+1) * N/P – 1 do i = hasi, buka ... enddo do i = pid, N, P ... enddo - Ez zaio gainkargarik gehitzen prozesuen exekuzioari. - Baina ez da prozesuen arteko lan-kargaren oreka ziurtatzen. - Cache memoriako atzipenen lokaltasuna kontrola daiteke.

Iterazioen banaketa  Lan-kargaren oreka estatikoa (finkoa) do i = 1, 80 if (A(i) > 0) kalkulatu() enddo beste ataza baten esleipen dinamikoa 1-20 21-40 41-60 61-80 estatikoa (finkoa) 1-10 21-30 11-20 31-40 Tex Tex

Iterazioen banaketa  Banaketa dinamikoa Lan-karga orekatuta mantentzeko, “ataza ilara” bat antolatzen da. Prozesu batek ataza baten exekuzioa bukatzen duenean (begiztaren zati bat), beste bat hartzen du ilaratik. Oinarrizko bi aukera: banatzen diren begizta zatiak tamaina berdinekoak dira beti, edo, exekuzioa aurrera joan ahala, gero eta txikiagoak dira.

 Self / Chunk scheduling Iterazioen banaketa  Self / Chunk scheduling Iterazioak banan-banan banatzen dira, edo multzoka. LOCK (S); nik = i; i = i + Z; Z = 1  self UNLOCK (S); while (nik <= N-1) endwhile Gainkarga gehitzen zaio begiztaren exekuzioari. Alderatu behar dira exekuzio-denbora eta esleipenarena. do j = nik, min(nik+Z-1, N-1) ... enddo LOCK (S) nik = i; i = i + Z; UNLOCK (S)

▪ Guided exekutatzeko falta den zatiaren parte proportzionala: Iterazioen banaketa  Guided / Trapezoid scheduling Banatzen diren begizta zatiak gero eta txikiagoak dira, bukaerara hurbiltzen den neurrian. ▪ Guided exekutatzeko falta den zatiaren parte proportzionala: Zs = (N – i) / P (goiko zenbaki osoa) edo, baliokidea dena, Zs = Zs-1 (1 - 1/P)

Iterazioen banaketa ▪ Trapezoid zatien tamaina konstante batez txikiagotzen da: Zs+1 = Zs - k esleipen-eragiketa Z1 Zn 1 k 2 i Z2

Iterazioen banaketa  Oro har, atazen exekuzio-denbora berdintsua izatea bilatzen du banaketa dinamikoak, baina: - banaketaren kostua (overhead) kontuan hartu behar da, atazen exekuzioarekin alderatuta. - datu-atzipenen lokaltasuna eta partekatze faltsuaren arazoak ere kontuan hartu behar dira.

▪ trapezoid (Z1 = 76, Zn = 4 >> k = 3) Iterazioen banaketa  Adibide bat (1.000 iterazio independente, 4 prozesadore): ▪ chunk (Z = 100) 100 100 100 100 100 100 100 100 100 100 (10) ▪ guided falta dira: 1000 750 562 421 … 17 12 9 6 4 3 2 1 banatzen dira: 250 188 141 106 … 5 3 3 2 1 1 1 1 (22) ▪ trapezoid (Z1 = 76, Zn = 4 >> k = 3) 76 73 70 67 … 16 13 10 7 4 (25)

 Prozedura- edo funtzio-mailako paralelismoa: Atal paraleloak  Prozedura- edo funtzio-mailako paralelismoa: - Fork / Join eredua - Parallel sections Fork F1 F2 Join F3 F4 F5 doall k = 0, 1 if (pid = 0) then F1 if (pid = 1) then F2 endoall [hesia] if (pid = 0) then F3 if (pid = 1) then F4 F5 F2 F3 F1 F4 F5

Beg. Par. | Atal Paraleloak Arkitektura Paraleloak IF - EHU Beg. Par. | Atal Paraleloak  Prozedura- edo funtzio-mailako paralelismoa: - Fork / Join eredua - Parallel sections F2 F3 F1 F4 F5 Fork Join doall k = 0, 1 if (pid=0) then F1 if (pid=1) then F2 endoall [hesia] if (pid=0) then F3 if (pid=1) then F4