ARKITEKTURA PARALELOAK 05-06 ABIADURA HANDIKO SISTEMA PARALELOEN PROGRAMAZIOA ARKITEKTURA PARALELOAK 05-06

aplikazio paraleloen programazioa  MIMD motako sistema paraleloen arkitektura bietako bat izan daiteke: memoria konpartitua eta memoria banatua.  Aplikazio paraleloak programatzea oso desberdina da eredu batean eta bestean. ARKITEKTURA PARALELOAK 05-06

aplikazio paraleloen programazioa  Memoria banaturiko (MPP) sistemen programazioa mezu-ematearen bidez, MPI erabiliz egiten da.  Memoria konpartitutako sistemetan, aldiz, SMP sistemetan batik bat, gaurko estandarra OpenMP da.  Beste aukera batzuk: UPC (Unified Parallel C). shrmem (Cray) ARKITEKTURA PARALELOAK 05-06

programazio paraleloaren ereduak earth simulator ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 OpenMP laburpena ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 OpenMP (sarrera)  OpenMP da gaurko estandarra memoria konpartitutako sistemak programatzeko. Hiru ezaugarri hauek ditu: eramangarria da, paralelismo inkrementala ahalbidetzen du, eta hardwarearen independentea da. Fabrikatzaile nagusiek sortu eta babesten dute: HP-Compaq, IBM, SUN, SG, ... ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 OpenMP (sarrera)  Ez da programazio-hizkuntza berri bat, API (application programming interface) bat baizik, osagai hauekin:  sasiaginduak konpiladorearentzat (C) #pragma omp <sasiagindua>  biblioteka-funtzio bakan batzuk  ingurune-aldagai batzuk ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 OpenMP (sarrera)  OpenMP-k aplikatzen duen programazio-eredua Fork - Join da. Une batean, “master” hariak p hari sortzen ditu, paraleloan exekuta daitezen. master haria FORK atal paraleloa JOIN ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 OpenMP (sarrera)  Master hariak sorturiko hari guztiek kode-kopia berdina exekutatuko dute. Hari bakoitzak identifikadore bat darama.  Honela bereiziko dira exekutatuko diren atazak:  SPMD eredu baten bidez (if id == ...)  lan-banaketa egiten duten eraikitzaile espezifikoen bidez (Work Sharing) ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 OpenMP (sarrera) Laburbilduz, programa serie batetik abiatuta, OpenMP programa paralelo bat lortzeko, gehitu behar dira:  sasiaginduak, atal paraleloak (kode errepikatua), lan-banaketa (hari bakoitzeko ataza bat), edota harien arteko sinkronizazioa adierazteko.  biblioteka-funtzioak (include <omp.h>) hariak kudeatzeko edo sinkronizatzeko. ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 adibidea main () { for (i=0; i<1000; i++) { A[i] = A[i] + 1; B = B + A[i]; } printf(“ B = %d \n”, B); #pragma omp parallel private(tid) { } tid = omp_get_thread_num(); printf (“ %d haria abiatu da \n”, tid); #pragma omp for schedule(static) reduction(+:B) if (tid==0) ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 oinarrizko ideiak 0 Prozesu paraleloak (threads). 1 ATAL PARALELOAK. Aldagaien esparrua. 2 LAN-BANAKETA. For begiztak. Iterazioen planifikazioa. Sections / Single / ... 3 SINKRONIZAZIOA: sekzio kritikoak, sarrailak, hesiak. ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 oinarrizko ideiak 0 Hari kopurua  estatikoki, ingurune-aldagai bat: > export OMP_NUM_THREADS = 10  dinamikoki, funtzio baten bidez: omp_set_num_threads (10); ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 atal paraleloak 1 ATAL PARALELOAK (parallel regions) # pragma omp parallel (klausulak) Hari bakoitzean errepikatu, eta paraleloan exekutatuko den kode zati bat da. Atal paralelo baten aldagaiak konpartituak (hari guztienak, shared) edo pribatuak (desberdinak hari bakoitzean) izan daitezke. Aldagaien izaera klausulen bidez definitzen da. ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 atal paraleloak adibide sinple bat: #include <stdio.h> #include <omp.h> #define N 12 int i, tid, A[N]; main () { omp_set_num_threads (4); #pragma omp parallel { tid = omp_get_thread_num (); printf (“%d haria abian \n”, tid); A[tid] = 10 + tid; printf (“%d hariak bukatu du \n”, tid); } for (i=0; i<N; i++) printf (“A(%d) = %d \n”, i, A[i]); private(tid) shared(A) hesia ARKITEKTURA PARALELOAK 05-06

lan-banaketa: begiztak Begiztak ditugu paralelismoa modu “sinplean” ustiatzeko gunerik nagusiak (ale xeheko paralelismoa). Jakina, ez da nahikoa errepikapen hutsa. Adibidez, #pragma omp parallel shared(A) private(i) { for (i=0; i<100; i++) A[i] = A[i] + 1; } ? ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 for begiztak Honako hau egin beharko genuke: #pragma omp parallel shared(A) private(tid, nth, hasi, buka, i) { tid = omp_get_thread_num(); nth = omp_get_num_threads(); hasi = tid * N / nth; buka = (tid+1) * N / nth; for (i=hasi; i<buka; i++) A[i] = A[i] + 1; } ! ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 for begiztak #pragma omp parallel { #pragma omp for (klausulak) for (i=0; i<100; i++) A[i] = A[i] + 1; } aldagaien esparrua planifikazioa sinkronizazioa 0..24 25..49 50..74 75..99 hesia ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 for begiztak #pragma omp parallel for private (j, X) for (i=0; i<N; i++) for (j=0; j<M; j++) { X = B[i][j] * B[i][j]; A[i][j] = A[i][j] + X; C[i][j] = X * 2 + 1; } for (i=0; i<N; i++) for (j=0; j<M; j++) { X = B[i][j] * B[i][j]; A[i][j] = A[i][j] + X; C[i][j] = X * 2 + 1; } Kanpo-begizta ari gara paralelizatzen: barneko begizta exekutatuko dute hariek. Ale “ertaineko” paralelismoa. X eta j aldagaiak pribatu gisa deklaratu behar dira! ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 for begiztak for (i=0; i<N; i++) #pragma omp parallel for private (X) for (j=0; j<M; j++) { X = B[i][j] * B[i][j]; A[i][j] = A[i][j] + X; C[i][j] = X * 2 + 1; } for (i=0; i<N; i++) for (j=0; j<M; j++) { X = B[i][j] * B[i][j]; A[i][j] = A[i][j] + X; C[i][j] = X * 2 + 1; } Barne begizta ari gara paralelizatzen: ale xeheko paralelismoa. X aldagaia pribatua da. ARKITEKTURA PARALELOAK 05-06

iterazioen planifikazioa  Nola banatzen dira begizta baten iterazioak harien artean? Begiztaren bukaeran hesi bat dagoenez, harien lan-karga ez badago orekatuta eraginkortasun-galera nabaria izango da.  Schedule klausulak ahalbidetzen du hainbat banaketa-estrategia adieraztea, hala estatikoak nola dinamikoak. ARKITEKTURA PARALELOAK 05-06

iterazioen planifikazioa adibide bat #pragma omp parallel for shared(A) schedule(static, 16) { for (i=0; i<100; i++) A[i] = A[i] + 1; } gogoratu: estatikoa kostu baxua / datuen ingurutasun ona dinamikoa kostu altuagoa / lan-karga orekatuagoa ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 lan-banaketa  Sections: ataza desberdinak banatzea #pragma omp sections [klausulak] { fun1(); #pragma omp section fun2(); fun3(); } fun1 fun2 fun3  Single: ataza berezia hari bakar batentzat atal paralelo baten barruan ARKITEKTURA PARALELOAK 05-06

harien sinkronizazioa Ezin badira eliminatu harien arteko datu-dependentziak, orduan sinkronizatu egin behar da haien exekuzioa. OpenMP-k sinkronizazio-funtzio ohikoenak eskaintzen ditu: elkarrekiko esklusioa eta gertaeren bidezko sinkronizazioa. ARKITEKTURA PARALELOAK 05-06

harien sinkronizazioa a. Sekzio Kritikoak (critical) MAX = -infinitu; MIN = infinitu; #pragma omp parallel for for (i=0; i<N; i++) { #pragma omp critical (M1) { if (A[i] > MAX) MAX = A[i] } #pragma omp critical (M2) { if (A[i] < MIN) MIN = A[i] } } MAX = -infinitu; MIN = infinitu; for (i=0; i<N; i++) { if (A[i] > MAX) MAX = A[i] if (A[i] < MIN) MIN = A[i] } ARKITEKTURA PARALELOAK 05-06

harien sinkronizazioa  atomic Sekzio kritiko berezi bat, RMW motako eragiketa sinple bat egiteko. Esaterako, ... #pragma omp atomic X = X +1; ARKITEKTURA PARALELOAK 05-06

harien sinkronizazioa b. Sarrailak -- omp_set_lock (&S) sarraila hartu, edo itxoin egiten du libre izan arte. -- omp_unset_lock (&S) sarraila askatzen du. -- omp_test_lock (&S) sarrailaren balioa aztertzen du; T/F itzultzen du. ARKITEKTURA PARALELOAK 05-06

harien sinkronizazioa #pragma omp parallel private(nire_it) { omp_set_lock(&S1); nire_it = i; i = i + 1; omp_unset_lock(&S1); while (nire_it<N) A[nire_it] = A[nire_it] +1; } adibidea ARKITEKTURA PARALELOAK 05-06

harien sinkronizazioa c. Sinkronizazio Globala: barrier #pragma omp parallel private(tid) { tid = omp_get_thread_num(); A[tid] = func1(tid); #pragma omp for for (i=0; i<N; i++) B[i] = func2(A, i); for (i=0; i<N; i++) C[i] = func3(A, B, i); A[tid] = func4(tid); } #pragma omp barrier nowait ARKITEKTURA PARALELOAK 05-06

adibide bat: pi zenbakiaren kalkulua static long iter_kop = 100000; double pauso; void main () { int i; double x, pi, batura = 0.0; pauso = 1.0 / (double) iter_kop; for (i = 1; i <= iter_kop; i++) { x = (i - 0.5) * pauso; batura = batura + 4.0 / (1.0 + x*x); } pi = batura * pauso; ARKITEKTURA PARALELOAK 05-06

Ebazpena thread-en bidez: Win32 API #include <windows.h> #define NUM_THREADS 8 HANDLE thread_handles[NUM_THREADS]; CRITICAL_SECTION hUpdateMutex; static long iter_kop = 100000; double pauso; double batura_globala = 0.0; void Pi (void *arg) { int i, start; double x, batura = 0.0; start = *(int *) arg; pauso = 1.0 / (double) iter_kop; for (i = start; i <= iter_kop; i = i + NUM_THREADS) { x = (i - 0.5) * pauso; batura = batura + 4.0 / (1.0 + x*x); } EnterCriticalSection(&hUpdateMutex); batura_globala += batura; LeaveCriticalSection(&hUpdateMutex); void main () { double pi; int i; DWORD threadID; int threadArg[NUM_THREADS]; for (i = 0; i < NUM_THREADS; i++) threadArg[i] = i + 1; InitializeCriticalSection(&hUpdateMutex); { thread_handles[i] = CreateThread(0, 0, (LPTHREAD_START_ROUTINE) Pi, &threadArg[i], 0, &threadID); } WaitForMultipleObjects(NUM_THREADS, thread_handles, TRUE, INFINITE); pi = batura_globala * pauso; printf (" pi = %f \n", pi); Kodea hazi da! ARKITEKTURA PARALELOAK 05-06

Ebazpena: sinpletasuna  Thread-bibliotekak: Programatzaileak prozesu osoa kontrolatzen du ADI: programatzaileak prozesu osoa kontrolatu behar du Oro har, gero eta kontrol gehiago, gero eta konplexutasun handiago programatzaile-arentzat. Erabilgarriagoa litzateke aukera sinpleago bat. ARKITEKTURA PARALELOAK 05-06

1. aukera Atal paraleloak (SPMD programa) Hariek kode bera exekutatzen dute; hariaren identifikadorea erabiltzen da lan konkretu bat exekutatzeko. #include <omp.h> static long iter_kop = 100000; double pauso; #define NUM_THREADS 8 void main () { int i; double x, pi, batura[NUM_THREADS]; pauso = 1.0 / (double) iter_kop; omp_set_num_threads(NUM_THREADS); #pragma omp parallel { double x; int id; id = omp_get_thread_num(); for (i = id, batura[id] = 0.0; i < iter_kop; i = i + NUM_THREADS) { x = (i - 0.5) * pauso; batura[id] += 4.0 / (1.0 + x*x); } for (i = 0, pi = 0.0; i < NUM_THREADS; i++) pi += batura[i] * pauso; ARKITEKTURA PARALELOAK 05-06

2. aukera: Aldagai pribatuak eta sekzio kritikoa #include <omp.h> static long iter_kop = 100000; double pauso; #define NUM_THREADS 8 void main () { int i; double x, batura, pi=0.0; pauso = 1.0 / (double) iter_kop; omp_set_num_threads(NUM_THREADS); #pragma omp parallel private (x, batura) { id = omp_get_thread_num(); for (i = id, batura = 0.0; i < iter_kop; i = i + NUM_THREADS) { x = (i - 0.5) * pauso; batura += 4.0 / (1.0 + x*x); } #pragma omp critical pi += batura * pauso Ez da bektore bat sortu behar batura lokalak gordetzeko. ARKITEKTURA PARALELOAK 05-06

OpenMP soluzioa Parallel for eta reduction #include <omp.h> static long iter_kop = 100000; double pauso; #define NUM_THREADS 8 void main () { int i; double x, pi, batura = 0.0; pauso = 1.0 / (double) iter_kop; omp_set_num_threads(NUM_THREADS); #pragma omp parallel for reduction(+:batura) private(x) for (i = 1; i <= iter_kop; i++) { x = (i - 0.5) * pauso; batura = batura + 4.0 / (1.0 + x*x); } pi = batura * pauso; OpenMP kodea sinple eta laburra da ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 Erreferentziak LIBURUAK • R. Chandra et al. Parallel Programming in OpenMP Morgan Kaufmann, 2001. WEB • www.openmp.org (2.0 espezifikazioa, softwarea, …) KONPILADOREAK • ordaintzekoak (++) dohain: adibidez, Inteleko C/C++ konpiladorea ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 MPI laburpena ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 sarrera  Memoria konpartitutako sistemetan (SMP edo DSM) aukera OpenMP bada, memoria banatutako sistemak programatzeko gaurko “estandarra”, mezu-ematearen bidez, MPI da (message-passing interface).  MPI1/MPI2 “konplexu” eta zabala da. ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 sarrera  Komunikazio-funtzio multzo handi bat, prozesadoreen artean mezuak bidaltzeko. Bilatzen dena: eramangarritasuna, eraginkortasuna, ...  MPI-k esplizituki adierazten du prozesuen arteko komunikazioa, hau da: -- datu-mugimendua -- sinkronizazioa ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 komunikazio motak  Bi komunikazio mota: • puntutik puntura • globala  MPIk gauzatzen duen paralelismo-eredua SPMD da. if (pid == 1) BIDALI_pid2-ra else if (pid == 2) HARTU_pid1-etik Gogoratu: prozesu bakoitzak helbideratze-espazio propio eta independentea dauka. ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 komunikazio motak  Hainbat komunikazio-estrategia: IGO HAR • sinkronoa RTS - transmisio-baimena eskatzen da (itxoin) RTR - transmisioa onartzen da D - datuak bidaltzen dira (igorle-bufferretik hartzaile-bufferrera) ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 komunikazio motak  Hainbat komunikazio-estrategia: • buffered IGO HAR erabil. s.e. s.e. erabil. ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 komunikazio motak  Hainbat komunikazio-estrategia: • blokeakorra / ez blokeakorra Itxoin egiten da komunikazioa gauzatzen den arte (edo bufferra libre izan arte), edo, bestela, jarraitzen da exekuzioarekin eta egiaztatzen da geroago komunikazioa bete den ala ez. Sinkronoa blokeakorra da beti. Buffered motakoan, bi aukerak daude. ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 komunikazio motak  Estrategia bakoitzak abantailak eta desabantailak ditu: -- sinkronoa: hartzailea prest badago mezuak hartzeko, azkarragoa da; mezuaren kopia bat aurrezten dugu. Adi: blokeakorra denez, litekeena da deadlock bat gertatzea! -- buffered: igorlea ez da blokeatzen hartzailea ez badago prest, baina mezuaren kopia(k) egin behar dira. ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 sarrera  Prozesuak estatikoki kudeatzen dira (kopurua eta esleipena) (MPI2n dinamikoki ere bai). Prozesuek identifikadore bana daramate: pid.  Exekuzio paraleloan parte hartzen duten prozesuak “komunikatzaile”-tan biltzen dira. Komunikatzaile baten prozesuak bakarrik komunika daitezke haien artean. MPI_COMM_WORLD komunikatzailea hasieran sortzen da, eta prozesu guztiak biltzen ditu. ARKITEKTURA PARALELOAK 05-06

oinarrizko MPI funtzioak  152 funtziok osatzen dute MPI, baina 6 dira funtzio nagusiak: programak hasi eta bukatzeko, 2 prozesu kopurua kontrolatzeko, 2 komunikaziorako, 2 Sintaxia: MPI_ Funtzioa () ARKITEKTURA PARALELOAK 05-06

oinarrizko MPI funtzioak  Programen hasiera eta bukaera: MPI_Init (&argc, &argv); MPI_Finalize (); Bi MPI funtzio hauek dira lehena eta azkena edozein programatan. ARKITEKTURA PARALELOAK 05-06

oinarrizko MPI funtzioak  Prozesuak identifikatzeko MPI_Comm_rank (comm, &pid); Itzultzen du pid: prozesuaren identifikadorea comm komunikatzailearen barruan. (ad.: MPI_COMM_WORLD). MPI_Comm_size (comm, &prk); Itzultzen du prk: comm komunikatzailearen prozesu kopurua. ARKITEKTURA PARALELOAK 05-06

oinarrizko MPI funtzioak  Adibide sinple bat #include <stdio.h> #include “mpi.h” main (int argc, char *argv[]) { int pid, prk; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &pid); MPI_Comm_size(MPI_COMM_WORLD, &prk); printf(“%d prozesua (%d-tik) abian \n”, pid, prk); MPI_Finalize(); } ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 send eta receive  A eta B prozesuen arteko komunikazioa bi funtzio hauen bidez egin daiteke: A prozesuak “send” funtzioa exekutatu behar du B prozesuak “receive” funtzioa exekutatu behar du A B send recv Adi: Komunikazioa lankidetza-prozesu bat da. Bi funtzioetako bat ez bada exekutatzen, komunikazioa ez da gauzatzen (eta agian deadlock bat gertatuko da!). ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 send eta receive Hauek dira MPIn ditugun oinarrizko bi komunikazio-funtzioak:  MPI_Send (&message, count, datatype, dest, tag, comm); • mezua: <message, count, datatype> • hartzailea: <dest, comm> • tag: mezu mota (mota, ordena, ...) ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 send eta receive  MPI_Recv (&message, count, datatype, source, tag, comm, &status); • mezua: <message, count, datatype> • igorlea: <source, comm> • tag • status: hartu den mezuari buruzko kontrol-informazioa • MPI_Recv blokeakorra da ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 adibidea #include <stdio.h> #include “mpi.h” #define N 100; int main (int argc, char **argv) { int pid, prk, igor, hart, datk, tag; double VA[N]; MPI_Status info; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD,&pid); MPI_Comm_size(MPI_COMM_WORLD,&prk); printf(“%d/%d pr. abian\n”,pid,prk); if (pid==0) { for (i=0;i<N;i++) VA[i] = i; tag = 0; MPI_Send(VA, N, MPI_DOUBLE, prk-1, tag, MPI_COMM_WORLD); } else if (pid == prk-1) { MPI_Recv(VA, N, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &info); MPI_Get_count(&info, MPI_DOUBLE, &datk); printf(“Datuak %d prozesadoretik; tag = %d, datk = %d \n”, info.MPI_SOURCE, info.MPI_TAG, datk); for (i=0;i<datk;i++) printf(“%4d”, VA[i]); printf(“\n”); } MPI_Finalize(); ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 send/receive gehiago  Sinkronoa: MPI_Ssend (&mes, count, datatype, dest, tag, comm); ez du kontrola itzultzen harik eta hartzaileak mezua hartzen duen arte  Berehalakoa: MPI_Isend (...); komunikazioa bete dela jakin ahal izateko: MPI_Test (...) 0 edo 1 itzultzen du MPI_Wait (...) itxaron bete arte ARKITEKTURA PARALELOAK 05-06

komunikazio kolektiboak  Hainbat aplikaziotan, komunikazioa prozesu askoren artean egin behar da, batera. Komunikazioa globala da komunikatzailearen prozesu guztiek parte hartzen badute.  Adibidez: broadcast bat; datuak bidaltzen dira prozesadore batetik gainerako guztietara. Banan-banan begizta baten barruan? ARKITEKTURA PARALELOAK 05-06

komunikazio kolektiboak  Komunikazio kolektiboko funtzioak blokeakorrak dira. Komunikatzailearen prozesu guztiek exekutatu behar dute funtzioa.  Hiru mota -- datu-mugimenduak -- eragiketa kolektiboak -- sinkronizazioa ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 KK: datu-mugimenduak Broadcast: datuak bidaltzeko prozesadore batetik (root) gainerakoetara. P0 P1 P2 P3 A P0 P1 P2 P3 A A • Bidaltze-begizta bat? ez da eraginkorra! • Egokiagoa litzateke arbola bezalako egitura bat antolatzea komunikazioa egiteko (inplem. arabera) ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 KK: datu-mugimenduak P0 P1 P2 P3 A B D C Gather P0 P1 P2 P3 A B D C B C D P0 P1 P2 P3 A B C D Scatter P0 P1 P2 P3 A B C D B D C ARKITEKTURA PARALELOAK 05-06

KK: eragiketa kolektiboak Reduce (arbola) P0 P1 P2 P3 A B D C P0 P1 P2 P3 A B D C +B+C+D ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 KK: sinkronizazioa  Sinkronizazio-hesiak komunikatzailearen prozesu guztien arteko sinkronizazio globala. MPI_Barrier (comm); Funtzioa blokeatzen da harik eta prozesu guztiak exekutatu arte. ARKITEKTURA PARALELOAK 05-06

Komunikazio kolektiboak Adibidea: V(i) = V(i) *  V(j) batura = 0; for (j=0; j<N; i++) batura = batura + V[j]; for (i=0; i<N; i++) V[i] = V[i] * batura; 1. Irakurri N (pid = 0) 2. Broadcast N/prk (bektore lokalaren tamaina) 3. Scatter V bektorea (dagozkien zatiak) 4. Batura partzialen kalkulua 5. Allreduce batura partzialak (denok lortzen dute batura) 6. Kalkulu lokala: V(i) * batura 7. Gather emaitzak 8. Inprimatu emaitza (pid = 0) ARKITEKTURA PARALELOAK 05-06

ad.: pi zenbakiaren kalkulua #include <stdio.h> #include <mat.h> #include “mpi.h” int main (int argc, char **argv) { int pid, prk, i, n; double PI = 3.1415926536; double pi_lok, pi_glob, h, batura, x; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD,&pid); MPI_Comm_size(MPI_COMM_WORLD,&prk); if (pid==0) { printf(“tarte kopurua”; scanf("%d",&n); } MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD); h = 1.0 / (double) n; batura = 0.0; for (i=pid+1; i<=n; i+=prk) { x = h * ((double)i - 0.5); batura += 4.0 / (1.0 + x*x); } pi_lok = h * batura; MPI_Reduce(&pi_lok, &pi_glob, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); if (pid == 0) printf("pi(+/-) = %.16f, errorea = %.16f\n", pi_glob, fabs(pi_glob - PI)); MPI_Finalize(); } ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 MPI-ren gauzatzeak  banaketa askekoak: MPICH / LAM  oro har, cluster motako makina batean exekutatu baiuno lehen, zera behar da: - sistema paraleloa soatzen durten makina-zerrenda fitxategi batean izatea. - “deamon” bat exekutatzea makina bakoitzean. - adieraztea, exekutatu behar denean, sortu nahi den prozesu kopurua: mpirun -np 8 pi ARKITEKTURA PARALELOAK 05-06

ARKITEKTURA PARALELOAK 05-06 erreferentziak LIBURUAK • P. S. Pacheco: Parallel Programming with MPI Morgan Kaufmann, 1997. • W. Groop et al.: Using MPI. Portable Parallel Programming with the Message Passing Interface (2. ed.). MIT Press, 1999. • M. Snir et al.: MPI - The complete reference (vol. 1 y 2). The MIT Press, 1998. • I. Foster: Designing and Building Parallel Programs. Addison Wesley. WEB • www-unix.mcs.anl.gov/mpi/ (dena) ARKITEKTURA PARALELOAK 05-06