ARKITEKTURA PARALELOAK 05-06

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

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

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

programazio paraleloaren ereduak
earth simulator ARKITEKTURA PARALELOAK

OpenMP laburpena ARKITEKTURA PARALELOAK

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#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

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

adibide bat: pi zenbakiaren kalkulua
static long iter_kop = ; 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 / (1.0 + x*x); } pi = batura * pauso; ARKITEKTURA PARALELOAK

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 = ; 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 / (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

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

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 = ; 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

2. aukera: Aldagai pribatuak eta sekzio kritikoa
#include <omp.h> static long iter_kop = ; 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

OpenMP soluzioa Parallel for eta reduction
#include <omp.h> static long iter_kop = ; 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 / (1.0 + x*x); } pi = batura * pauso; OpenMP kodea sinple eta laburra da ARKITEKTURA PARALELOAK

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

MPI laburpena ARKITEKTURA PARALELOAK

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

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

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

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

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

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

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

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

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

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

 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

 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

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

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

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

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

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

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

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

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

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

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

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

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

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 = ; 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

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

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

ARKITEKTURA PARALELOAK 05-06

Presentaciones similares

Presentación del tema: "ARKITEKTURA PARALELOAK 05-06"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

ARKITEKTURA PARALELOAK 05-06

Presentaciones similares

Presentación del tema: "ARKITEKTURA PARALELOAK 05-06"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback