LEKSIONE PER SISTEMET E SHPERNDARA DHE

PARALELEDEGA INFORMATIKE EKONOMIKE

Neki Frasheri

Tirane, 2012

1

Table of ContentsHYRJE..................................................................................................................................................3

Sistemet sekuenciale dhe paralele....................................................................................................3Nevoja per perpunime paralele........................................................................................................4Perpunimi paralel i te dhenave.........................................................................................................4

HYRJE NE OpenMP............................................................................................................................5ARKITEKTURAT PARALELE...........................................................................................................8

Arkitektura SISD.............................................................................................................................8Arkitektura SIMD............................................................................................................................8Arkitektura GPU..............................................................................................................................9Arkitektura HyperThread...............................................................................................................11Arkitektura MIMD.........................................................................................................................11Arkitektura CPU Multi-core..........................................................................................................12Arkitektura GRID..........................................................................................................................13

ARKITEKTURA E KUJTESAVE.....................................................................................................15Kategorizimi i Kujtesave...............................................................................................................15Sistemet paralele me kujtese te perbashket....................................................................................16Kujtesa ne sistemet GPU...............................................................................................................17Kujtesa e Jashtme dhe Skedaret.....................................................................................................18

KOMUNIKIMI MIDIS PROCESEVE..............................................................................................20Paralelizimi i te Dhenave dhe Rasti i OpenMP.............................................................................20OpenMP.........................................................................................................................................21RPC (Remote Procedure Call).......................................................................................................21

MESSAGE PASSING INTERFACE (MPI).......................................................................................25Krijimi i proceseve paralele MPI...................................................................................................26Komunikimi Midis Proceseve MPI...............................................................................................26Parametrat e Procedurave ne MPI.................................................................................................28

ZHVILLIMI I PROGRAMEVE PARALELE....................................................................................32Coptimi dhe Paralelizimi i Algoritmit...........................................................................................32Kompleksiteti i Algoritmeve Paralele............................................................................................40

2

HYRJE

Sistemet sekuenciale dhe paralele

Kompjuteri i Fon Nojman:

– perbehet nga CPU dhe Kujtesa

– ne Kujtese mbahet vargy i instruksioneve dhe te dhenat

– cdo instruksion ne CPU vepron mbi nje te dhene nga Kujtesa

– instruksionet ekzekutohen njeri pas tjetrit ~ sekuencialisht ne CPU

Programimi klasik presupozon ekzekutim sekuencial te instrucksioneve.

Sot procesoret kane te pakten 2 core (alias “CPU”).

Programet ekzekutohen si procese te pavarur sekuenciale ne core e ndryshme.

A mund te “thyhet” principi i sekuencialitetit?

Pjeserisht po.

Shembull:

Mbledhja e dy vektoreve c[i] = a[i] + b[i]; per i=1,2,...,n

Rradha e punes ne sistemin sekuencial:

1. i=1 => CPU

2. a[i] => CPU

3. CPU + b[i] => CPU

4. CPU => c[i]

5. i=i+1 => CPU

6. … perseritje e grupit te instruksioneve <1:6>

Ku: CPU ketu perfaqeson regjister ne procesor.

Koha e ekzekutimit eshte T = n * DT

ku DT ~ koha e ekzekutimit te grupit te instruksioneve <1:6> .

Veprimi i mbledhjes te dy elementeve ne pozicionin “i” eshte veprim i pavarur dhe

mund te kryhet pavaresissht nga mbledhjet e tjera. Po te disponojme numer te

mjaftueshem CPU-sh mund te kryejme secilen nga mbledhjet ne nje CPU te vecante dhe

koha e ekzekutimit do te shkurtohej “n” here: T1 = T / n = DT

3

Nevoja per perpunime paralele

– modelime dhe simulime ekonomike

– klimatologji: dinamika e atmosferes dhe oqeaneve

– biologji: dinamika dhe bashkeveprimi i molekulave komplekse

– fizike: bashkeveprimi i nje numri te madh trupash

– etj...

Shembull:

Inversioni i anomalive te gravitetit ne gjeofizike.

Matet intensiteti i gravitetit ne siperfaqen e Tokes dhe perftohet nje matrice 2D ~

anomalia.

Kerkohet shperndarja e densitetit te mases nentoke ~ nje matrice “prismatike” 3D qe

perfaqeson “gjeoseksionin”.

Problemi eshte i “keq-pozuar” - zgjidhja nuk eshte as e vetme as e qendrueshme.

Ne nje sistem me 1000 procesore per nje gjeoseksion 3D me permasa 4x4x2 km i

coptuar ne matricen 3D me 2,099,601 elemente qe perfqesojne kuboide me permasa

50x50x50m te nentokes u deshen 27 ore llogaritje. Per te njejtin model por me kuboide

me permasa 25m do te duhej nje vit llogaritjesh ne sistemin me 1000 procesore.

Rendi i veprimeve eshte O(N^8), ku N eshte numri i elementeve ne nje brinje te

gjeoseksionit prizmatik.

Perpunimi paralel i te dhenave

Konsiston ne coptimin e grupeve te veprimeve dhe ekzekutimin e tyre ne procesore / core te

vecanta, dhe me pas ne integrimin e copave rezultateve ne nje te vetme. Eventualisht kjo mund te

kerkoje modifikimin e algoritmit llogarites.

Jo cdo algoritem pranon / mund te paralelizohet.

Mundesia e paralelizimit dhe rruga per realizimin e tij varen nga:

– algoritmi (mundesia e ndarjes ne “copa” paralele te pavarura)

– arkitektura e bashkesise se procesoreve

– arkitektura e kujteses (dhe lidhja e saj me procesoret)

– gjuha e programimit

Shembull:

a) mbjedhja e dy vektoreve paralelizohet lehte c[i] = a[i] + b[i]

4

b) shuma e termave te nje vektori paralelizohet me veshtiresi S = Σ a[i]

HYRJE NE OpenMPLibrari me modulet per manaxhimin e thread paralele.

Gjuhet e programimit C dhe FORTRAN

Sistemet MS-Windows dhe Linux

Kompilimi behet duke shtuar parametrin “-fopenmp”:

gcc -fopenmp program.c -o program

Ekzekutimi behet normalisht.

Koncepti baze: paralelizimi realizohet duke krijuar (klonuar) thread paralele qe mund te

ekzekutohen ne core te ndryshme (kur ka me shume thread se core kemi konkurence per kapjen e

kohes te CPU duke cenuar efektin e paralelizimit).

Dallimi midis “procese” dhe “thread” ne perdorimin e kujteses:

– proceset perdorin hapesira vetiake te kujteses

– thread ndajne te njejten hapesire kujtese

Thread paralele krijohen duke “klonuar” (kujto konanden “fork” ne Linux) procesin rrenje (qe

krijohet kur programi leshohet per ekzekutim):

Procesibaze

vvv

forkwwwww

Threadparalel

.

.

.

wwwww

Threadparalel

.

.

.

.wwwww

Threadparalel

.

.

.

.wwwww

Threadparalel

.

.

.

.wwwww

5

proces

proces

proces

threadthreadthread

...

join v

vv

join...

join...

join...

join...

Ku: v ~ kod qe ekzekutohet vetem ne procesin baze (sekuencial)

w ~ kodi qe ekzekutohet sekuencialisht por i perseritur ne thread paralele

Strukture qe paralelizohet relativisht lehte eshte cikli “For” ne rastin kur iteracionet e tij jane te

pavarur nga njeri tjetri.

Shembull:

Paralelizohet lehte:

for i=1 to nc[i] = a[i] + b[i]

Paralelizohet me veshtiresi:

for i=1 to ns = s + a[i]

Shembull:

Ne disa raste me ndryshime te vogla iteracionet mund te behen te pavarur:

Iteracione te ndervarur:

for i=1 to nj = j + 5c[j] = a[j] + b[j]

Iteracione te pavarur:

for i=1 to nj = i * 5c[j] = a[j] + b[j]

Analiza e shumes te vektoreve:

Kodi i shumes te dy vektoreve:

for i = 1 to nc[i] = a[i] + b[i]

Numri i iteracioneve: n

Numri i thread paralele: m

Cdo thread duhet te kryeje: k = int(n/m) iteracione

for i=1 to k

thread 0 >>>>>>>>>>>>>>x>>>>>>>>>>>>>>>>>>x>>>>>>>>>>>>>

for i=k+1 to 2kthread 1 ..............->>>>>>>>>>>>>>>>>>-.............

for i=2k+1 to 3kthread 2 ..............->>>>>>>>>>>>>>>>>>-.............

. . .

for i=(m-1)k+1 to nthread 3 ..............->>>>>>>>>>>>>>>>>>-.............

Kodi i nevojshem per klonimin e thread dhe ribashkimin e tyre ndertohet nga kompilatori.

6

Programisti e kontrollon procesin e ndertimit te kodit te paralelizueshem duke perdorur direktiven

PRAGMA:

#pragma omp parallel num_threads(m)

Shembull:

Mbledhja e dy vektoreve

#pragma omp parallel num_threads(m)

for (i=0; i<n; i++)

c[i] = a[i] + b[i];

Shembull:

Riformulim i mbledhjes te dy vektoreve

#pragma omp parallel num_threads(m)

for (i=0; i<n; i++)

{ S = a[i] + b[i];

c[i] = S

}

Problem me variablin lokal “S”: thread paralele duhet te konkurojne per kapjen e tij.

Zgjidhja (kujto variablat lokale te procedurave) eshte duke e deklaruar variablin lokal

“S” si “privat” per cdo thread:

#pragma omp parallel num_threads(m) private(S,...)

for (i=0; i<n; i++)

{ S = a[i] + b[i];

c[i] = S

}

7

ARKITEKTURAT PARALELE

Arkitektura SISD

SISD ~ Single Instruction Single Data ~ arkitektura klasike sekuenciale:

CPU

RAM

koha

>>>>>>>>>>>>

>>>>>>>>>>>>

>>>>>>>>>>>>

>>>>>>>>>>>>

Ku: ~ kalimi i nje instruksioni nga RAM ne CPU

~ shkembim i nje te dhene midis RAM dhe CPU

Rasti i mbledhjes te dy vektoreve: c[i] = a[i] + b[i]

Konsierojme problemin te thjeshtezuar:

– nje instruskion mbledhjeje

– shume cifte te dhenash te pavarura mbi te cilat vepron instruksioni i mpledhjes

Per rastet e nje situate te tille per veprime elementare ne CPU, kjo e fundit eshte ndertuar sipas parimit te “konvejerit te punes” ~ pipeline / SIMD:

Arkitektura SIMD

SIMD ~ Single Instruction Multiple Data

Arkitektura njihet dhe me emrin “vektoriale”, e specializuar per veprimet me vektoret.

Ndertimi i brenshem i CPU me blloqe (koncepti i firmware ~ mikro-instruksione):

Instruksioni ekzekutohet i “shumefishuar” si vargje mikro-instruksionesh dhe paralelisht me njeri

tjetrin – mikro-instruksioni i seciles kopje te instruksionit ne nje bllok te CPU, cdo kopje e

instruksiont trajton nje te dhene te veten:

instruksioni ~ mi-1 => mi-2 => mi-3 => mi-4

8

IN OUT

IN OUTmi-2data3

mi-1data4

mi-3data2

mi-4data1

Figura me poshte tregon zhvendosjen e te dhenave neper blloqet e mikro-instruksioneve te CPU:

Instruksioni si varg mikro-instruksionesh

mi-1 mi-2 mi-3 mi-4

Koha

data1 hyn ne CPU data1

data2 hyn ne CPU data2 data1

data3 hyn ne CPU data3 data2 data1

data4 hyn ne CPU data4 data3 data2 data1

Procesoret Intel kane arkitekture pipeline. Optimizimi i kodit per shfrytezimin e paralelizimit mund

te behet duke perdorur kompilatoret Intel.

Arkitektura GPU

Procesoret grafike (GPU ~ Graphic Processing Unit) te nivelit te larte NVIDIA dhe AMD

RAEDON shfrytezojne konceptin SIMD per te pershpejtuar veprimet e renderizimit te imazheve ne

levizje.

core core core core core cache

core core core core core cache

core core core core core cache

core core core core core cache

core core core core core cache

core core core core core cache

Si e tille GPU mund te perdoret per llogaritje paralele sipas logjikes SIMD – i njejti kod “GPU”

ekzekutohet ne secilen core te GPU me te dhena te ndryshme.

Programimi behet duke perdorur zgejrimet e gjuhes C:

– OpenCL

– CUDA (rasti i NVIDIA)

Programisti karton kodin “kernel” qe duhet te ekzekutohet ne core-t e GPU dhe duhet te parashikoje

9

KU

JTE

SA

E

PER

BA

SHK

ET

transferimin e te dhenave nga RAM ne kujtesen e GPU.

Ku: ~ CPU kontrollon shkembimet midis RAM dhe GPU

~ transferim kodi dhe te dhenash midis RAM dhe GPU

Shembull:

Mbledhja e dy vektoreve.

Kodi klasik:

for i = 1 to n

c[i] = a[i] + b[i]

Kodi “kernel” per GPU ne parim do te ishte (i thjeshtezuar):

c[i] = a[i] + b[i]

qe do te perseritej ne secilen core te GPU me vleren perkatese te indeksit “i” (ne kete

shembull detajet e programimit te GPU nuk jane paraqitur).

Ekzekutimi i kodit klasik do te kerkonte 99% te kohes te CPU, ndersa ekzekutimi me

ndihmen e nje GPU me 48 core ekrkoi vetem 3% kohe te CPU.

Per te punuar me GPU duhet:

– te instalohen gjuhet perkatese (OpenCL dhe / ose CUDA)

– te programohet vecas kodi per CPU dhe vecas kodi per GPU

– te parashikohen shkembimet e te dhenave midis RAM dhe GPU

10

BUS

CPU RAM CPU

Kodi “kernel”

Te dhenat

Arkitektura HyperThread

Ne disa kategori procesoresh Intel eshte realizuar e ashtuquajtura teknologji hyperthread.

Arkitektura e nje CPU klasike (nje core e vetme) eshte:

mjedisii

thread

ALU

Kur thread i zene vendin njeri tjetrit ne CPU, duhet te ndrohet dhe mjedisi i therad (vlerat e

regjistrave, tabelat e faqeve te kujteses etj), gje qe kerkon njefare kohe.

Ne CPU hyperthread eshte shumefishuar elektronika e mjedisit te thread:

mjedisii

thread

mjedisii

thread

ALU

Ne kete menyre CPU mban njekohesisht 2 (ose me shume (?)) mjedise per thread te ndryshem,

duke mundesuar pershpejtimin e shkembimit te thread ne CPU (shmanget koha e shkembimit te

mjediseve). Nga pikpamja e shpejtesise te punes, nje core me dy hyperthread punon sikur te ishte

“nje core e gjysem”.

Arkitektura MIMD

MIMD ~ Multiple Instruction Multiple Data

Rasti “kalsik” i kesaj arkitekture do te ishte nje makine me shume procesore / core te lidhur njeri me

tjetrin ne formen e nje matrice:

11

Pergjithesisht makina te tilla jane te ralla dhe perdoren per perpunime speciale. Programimi i tyre,

sistemet operative dhe gjuhet e programimit jane teper te nderlikuara.

Sot perdoren gjeresisht sisteme paralele me te thjeshta – cluster me CPU te lidhura midis tyre ne nje

BUS. Makina te tilla kane zakonisht disa CPU, secila me nje ose disa core:

Rrjeti lokal i nje laboratori mund te trajtohet si nje “makine paralele” e tille ~ cluster me CPU

(shiko dhe arkitekturen grid).

Problemi me kete arkitekture eshte shkembimi i te dhenave midis CPU-ve. Brenda nje nyjeje

CPU+RAM mund te punohet me thread paralele qe ndajne te njejten zone kujtese, ndersa

shkembimi i te dhenave midis nyjeve (e thene ndryshe – midis proceseve) kerkon mekanizma te

vecante. Nje i tille eshte MPI – Message Passing Interface.

Zgjidhja MPI konsiston ne “klonimin” e proceseve (perfshi kujtesen), duke krijuar nga procesi baze

(i startuar me fillimin e ekzekutimit te programit) nje grup procesesh analoge paralele qe

ekzekutohen ne CPU te ndryshme. Programisti mund te kontrolloje rrjedhen e ekzekutimit duke

mundesuar qe procese te ndryshme te ekzekutojne copa kodi te ndryshme, duke realizuar

perafersisht logjiken MIMD.

MPI eshte nje librari plotesuese per gjuhet C dhe FORTRAN, qe permban modulet e klonimit te

proceseve dhe procedurat e shkembimit te mesazheve midis proceseve.

Kompilimi behet me komanden “mpicc” dhe ekzekutimi me komanden “mpirun”.

Arkitektura CPU Multi-core

Arkitektura multi-core konsiston ne CPU te perbere nga disa njesi te vecanta te pavarura perpunimi,

e thene ndryshe disa CPU ne nje chip te vetem:

12

RAM

CPU

RAM

CPU

RAM

CPU

RAM

CPU

RAM

CPU

core core core core

cache cache cache cache

CACHE

BUS

RAM

Sot shumica e PC-ve kane CPU me dy ose me shume core.

Arkitektura GRID

Grid eshte nje sistem paralel i perbere nga disa nyje CPU+RAM te lidhura ne rrjet lokal ~ cluster

me PC. Cdo nyje / PC eshte teresisht e pavarur dhe ka sistemin e vet operativ te zakonshem (MS-

Windows ose Linux). Shpesh rrjetat lokale konfigurohen te punojne si grid gjate nates. MPI mund

te perdoret per komunikimin midis proceseve ne nyjet e ndryshme, por ekzekutimi i nje programi

paralel ne nje cluster te tille kerkon mbeshtetjen nga middleware i nevojshem per te klonuar

proceset ne makina te pavarura. Per me teper mbi grid dhe middleware perkates shiko sistemet

CONDOR dhe GLOBUS.

Midleueri grid duhet te zgjithe tre detyra:

a) te verifikoje certifikatat e perdoruesve dhe te sistemeve qe bashkeveprojne ne grid, te monitoroje

gjendjen e sistemit, te mbaje historikun e ngjarjeve dhe vellimin e puneve te kryera nga

perdoruesit.

b) te mare kerkesat per ekzekutim nga perdoruesit dhe, duke u bazuar ne informacionin mbi

ngarkesen e castit te segementeve (cluster”) te vecanta te grid, te dergoje punet per ekzekutim ne

segmentet me pak te ngarkuar.

c) te mbaje regjistrin me skedaret e rezervuar ne pika te ndryshme te sistemit, te ofroje mundesine e

kapjes te skedareve nga perdoruesit, dhe te sinkronizoje permbajtjen e kopjeve shumefishe.

13

UserInterface

Intranet / Internet

“dispecer”Siguria+ Monitorimi

14

Segmentet / cluster grid perbehen nga :

1. LAN

2. Computer Element (CE ~ host i “dispetcerit” lokal)

3. Storage Element (SE ~ sistemi qe ofron hapesire disku)

4. Monitoring node (MON)

5. Work Node (WN ~ kompjuterat qe ekzekutojne punet)

6. Softueri:

(a) Administratori i puneve (pbs, torque, maui ...)

(b) Administratori i skedareve (gridftp …)

(c) Sistemi i informacionit (bdii …)

(d) Sistemi i monitorimit (mon ...)

“Grid” i shperndare ka topologji te ngjashme si ne figure:

– “dispecer” global

– monitorues global

– segmente grid

“Dispeceri” global komunikon me nje cluster grid vetem me CE dhe SE.

Siguria ne sistemet grid bazohet ne certifikatat elektronike. Cdo perdorues dhe cdo nyje kopjuterike

me te drejta per shkembime me “dispetcerin” (CE, SE, MON) duhet te kete certifikaten e vet te

leshuar nga autoritete CA te njohur nga sistemi.

Per te shmangur perdorimin e vazhdueshem te nje certifikate, qe sjell rezikun e zberthimit te saj nga

pale te treta, ndiqet praktika e perdorimit te certifikatave te perkoheshme. Me ndihmen e certifikates

permanente sistemi qe do te komunikoje me dike gjeneron nje certifikate te perkoheshme (e quajtur

dhe “proxy”) dhe e perdor ate per pune gjate nje sesioni brenda nje afati kohor te caktuar (zakonisht

~ 24 ore).

Cdo kompjuter pune (WN) mund te jete multi-core. Paralelizimi ne grid eshte i mundur kur te

dhenat fillestare te aplikimit mund te coptohen dhe perpunohet ne menyre te pavarur ne WN te

dnryshme, ose kur perdoret MPI qe mundeson shkembimin e te dhenave midis proceseve ne WN te

ndryshme.

15

ARKITEKTURA E KUJTESAVE

Kategorizimi i Kujtesave

Perseritje: Thread dhe Procese

Nje nga dallimet midis thread dhe procese eshte puna me kujtesen:

Kujtesa e perbashket RAM RAM RAMkujtese vetiake kujtese vetiake kujtese vetiake proces_0 proces_1 proces_2

thread_0 thread_1 thread_2

Thread ndajne te njejten zone kujtese, ndoshta duke patur dhe dicka “personale”. Thread mund te

komunikojme midis tyre nepermjet kujteses kryesore te perbashket.

Proceset perdorin [seksione] te vecanta kujtese. Proceset mund te komunikojne midis tyre me

ndihmen e sistemit te shfrytezimit.

Perfundime: Kategorizimi i kujtesave

E pare ne kendveshtimin e harduerit, si thread dhe procese jane kode ne ekzekutim ne ne ndonje

CPU (alias core).Komunikimi midis CPU dhe RAM behet nepermjet kujtesave cache te cdo CPU:

RAMcache

cache cache cache

core_0 core_1 core_2

Ne nje CPU mund te ndodhet nje cache e perbashket per te tera core-t dhe cdo core te kete cache e

vet. Kjo logjike mund te shtrihet ne sistemet e shperndara.

Si rregull ne sistemet e shperndara cdo nyje (computer node) ka RAM e vet, dhe nuk ka komunikim

direkt midis RAM ne nyjet e vecanta, pervetse nepermjet sistemeve te shfrytezimit dhe midleuerit te

nevojshem. Ne rastin e nje cluster me PC kemi:

PC_a PC_b PC_c

core_0 core_1 core_0 core_1 core_0 core_1

cache cache cache cache cache cache

cache cache cache

RAM RAM RAM

OS + Midleuer

LAN

16

E pare ne teresi,

– cdo core ka cache e vet,

– grupet “PC” me core kane kujtesa dhe cache te perbashketa

– grupet “PC” me core kane RAM te perbashket

Perfundimi: dallohen tre kategori kujesash:

1. kujtesa e shperndare

2. kujtesa e ndare/perbashket [shared]

3. kujtesa cache

a) vetiake e cdo core

b) e perbashket si CPU

Problem me kujetsen e ndare: konkurimi per kapjen e kujteses nga thread/procese konkurente (ne te

njekten CPU).

Ky kategorizim percakton dhe teknikat e programimit paralel (dhe ne pergjithesi te programimit te

sistemeve te shperndara):

1. Shkembimet midis proceseve ne CPU te ndryshme dhe kujteses te shperndare behen vetem

nepermjet midleuerit - MPI

2. Shkembimet midis thread ne nje CPU dhe kujteses te ndare/perbashket behen si nepermjet

midleuerit MPI dhe OpenMP

3. Cache kontrollohet nga hardueri ... duhet mare ne konsiderate per te patur performance ne

kohe

Optimizimi i punes mund te realizohet nese midis CPU perdoret MPI dhe midis core ne nje CPU

perdoret OpenMP, vecanerisht nese hardueri eshte i tipit “multithread”.

Sistemet paralele me kujtese te perbashket

Ndersa ne sistemet cluster cdo CPU ka pak core, kemi dhe sisteme paralele te “integruara” ku

shume core (qindra ...) ndajne te njejten RAM:

RAM

core core core core core core core core core core

Ndersa ne nje cluster duhet te perdorim MPI per komunikimin midis proceseve, nje sistem te tille

17

me kujetse te perbashket mund te punohet edhe vetem me OpenMP. Por platforma te tilla jane te

pakta. Ne shumicen e rasteve sistemet paralele bazohen ne cluster.

Kujtojme se sistemet cloud pergjithesisht realizohen ne cluster. Ne dallim nga cluster “tradicional”

si grup PC i lidhur ne LAN, ne sistemet paralele te ketij lloji per lidhjen midis tyre te CPU perdoren

switch me gjeresi bande disa [dhjetra] Gbps.

Kujtesa ne sistemet GPU

Organizimi tipik i arkitektures GPU:

core core core core core core core core cacheKujtesa

e Perbashket

core core core core core core core core cache

core core core core core core core core cache

core core core core core core core core cache

BUS

CPU RAM

Cfare mund te thuhet:

• Core jane grupuar ne blloqe, cdo bllok ka kujtesen e vet (“cache”) => e vogel ...

• Bashkesia e blloqeve ndan kujtesen e perbashket => e madhe ...

• Kodi paralel duhet te kopjohet nga RAM ne kujtesen e GPU per tu ekzekutuar sipas SIMD

neper core.

• Te dhenat dhe rezultate duhet te shkembehen midis RAM dhe kujteses te GPU ...

• Thread brenda nje blloku duhet te konkurojne per kapjen e cache, nderkohe qe core ne

pergjithesi duhet te konkurojne per kapjen e kujteses te perbashket. Problemi eshte ne

shkrim !!!

Shfrytezimi efektiv i kapaciteteve paralele te GPU kerkoj jo vetem algoritmimin duke konsideruar

paralelizimin SIMD, por dhe koston nga shfrytezimi i kujteses:

• shkembimi i te dhenave midis RAM dhe GPU

• shfrytezimi i kujteses te GPU nga thread

18

Kujtesa e Jashtme dhe Skedaret

Kujtesa e jashtme nenkupton disqet magnetike (Hard Disk Devices) dhe paisjet e tjera si CD dhe

USB-memory-stick.

Ne sistemet paralele te tipit cluster nyjet kompjuter (me Sistemin e Shfrytezimit OS dhe Sistemin e

Skedareve FS vetiake) te vecanta kane disqet e tyre te vecanta dhe komunikimi me to mund te behet

nepermjet NFS (Network File System).

RAM RAM RAM RAM RAM RAM

CPU CPU CPU CPU CPU CPU

HDD HDD HDD HDD HDD HDD

OS/FS OS/FS OS/FS OS/FS OS/FS OS/FS

N F S

L A N

Pavaresisht nga shkalla e integrimit te sistemit paralel dhe perdorimi i NFS, puna me skedaret

paraqet problemin e konkurences – disa thread / procese paralele punojne ne kuadrin e te njejtit

algoritem per te njejtin problem dhe probabiliteti qe te lexojne dhe shkruajne ne njejtet skedare

eshte i larte.

Rezikshemria e kompromentimit te te dhenave nga konkurenca e pa kontrolluar varion ne varesi te

menyres te kapjes te skedareve:

Menyra e Kapjes N procese ne leximN procese ne lexim1 proces ne shkrim

N procese ne shkrim

Rezikshmeria Nuk ka E mesme E larte

Problematika Nuk ka

Mund te shkaktoje prishje te sinkronizimit

te punes midis proceseve

Proceset mund te prishin te dhenat e njeri

tjetrit

Problem tjeter eshte ndarja e nje skedari ne “copa” per proceset e ndryshme paralele:

Proces 0 Proces 1 Proces 2 Proces 3 Proces 4 Proces 5

V V V V V V

Copa I Copa II Copa III Copa IV Copa V Copa VI

Skedaret vetem ne lexim mund te happen ne menyren e zakonshme, por nese proceset duhet ta

19

ndajne copat e skedarit programisti duhet te parashikoje kapjen relative.

Zgjidhja “universale” eshte puna konkurente me skedaret, qe nenkupton cdo proces kap ne lexim /

shkrim vetem copen e tij. Kjo mund te behet me procedurat perkatese qe ofrohen nga librarite e

programimit paralel.

OpenMP nuk ka parashikon trajtim te konkurences per skedaret dhe pergjegjesia bije mbi

programistin...

MPI parashikon procedurat per konkurencen e skedareve:

– skedari shikohet si bashkesi “qelizash” me ndihmen e “pamjes/maskes” (view):

∙ zhvendosja ne bajte (pointer) e pamejs nga fillimi skedarit

∙ tipi elementar (?) i te dhenave (etype), [variabel i thjeshte ose strukture]

∙ “pamja-maske” mbi skedarin (filetype)

– futet kuptimi i “tipit derivat te te dhenave” (derived data type)

∙ shembull: nqs. 'x' eshte etype qe perfaqeson nje “qelize”, 'oxxooo' eshte nje tip derivat qe

perfaqeson qelizen e dyte dhe te trete te nje skedari, ku 'o' perfaqeson “vrime” (qelize qe

nuk konsiderohet) ~ alias “filetype”

– Per tre procese “pamja” ne fillim te skedarit do te ishte (shembull):

∙ (0, X, XXOOOO) ~ procesi i pare kap dy qelizat e para

∙ (0, X, OOXXOO) ~ procesi i dyte kap qelizat e trete dhe katert

∙ (0, X, OOOOXX) ~ procesi i trete kap qelizat e peste dhe gjashte

∙ Me tej pamja mund te zhvendoset duke avancuar pointer ne fillimin e grupit te dyte te

qelizave, respektivisht per secilin proces:

(sizeof(XXXXXX), X, XXOOOO)

(sizeof(XXXXXX), X, OOXXOO)

(sizeof(XXXXXX), X, OOOOXX)

∙ Procesi i pare e shikon skedarin si:

XXOOOO XXOOOO XXOOOO XXOOOO ...

∙ Procesi i dyte e shikon skedarin si:

OOXXOO OOXXOO OOXXOO OOXXOO ...

∙ Procesi i trete e shikon skedarin si:

OOOOXX OOOOXX OOOOXX OOOOXX ...

– cdo proces punon me “qelizen” e vet duke perdorur funksionet specifike te MPI:

∙ MPI_File_Open

∙ MPI_File_Write

∙ MPI_File_Read

∙ MPI_File_Close

20

KOMUNIKIMI MIDIS PROCESEVE

Paralelizimi i te Dhenave dhe Rasti i OpenMP

Tre kategori problemesh:

1. Paralelizimi i plote

Te dhenat fillestare mund te perpunohen teresisht vecas.

Shembull: mbledhja e dy vektoreve

c[i] = a[i] + b[i]

Bashkesia {i=1,...,n} mund te ndahet ne copa te pavarura {{i=ns,nt}}

Rezultati final meret nga bashkimi mekanik i copave.

Perpunimi mund te behet ne nje bashkesi procesesh paralele qe kryejne te njejten

skeme llogaritjesh, pa nevoje nderkomunikimi (per shkak llogaritjesh) midis tyre.

Llogaritjet mund te kryhen ne grup kompjuterash te pavarur, duke ndare punen

manualisht ose me ndihmen e nje midleware. Tipike ne sistemet cluster / grid.

2. Paralelizimi i pjesshem

Te dhenat mund te coptohen ne copa te pavarura gjate perpunimit dhe keto copa mund te

perpunohen ne paralel.

Shembull: shuma e elementeve te nje vektori

S = Σ1n a[i]

Mund te ndahet ne copa te pavarura { S = Σnsnt

a[i] } por per rezultatin final

duhet te shumohen rezultatet nga copat paralele.

Perpunimi mund te behet ne nje bashkesi procesesh paralele qe kryejne te njejten

skeme llogaritjesh, por duhet realizuar nderkomunikimi midis tyre per

shperndarjen dhe grumbullimin e rezultateve te pjeseshme.

Llogaritjet mund te kryhen ne nje kompjuter multi-procesor duke perdorur

OpenMP ose ne nje cluster-grid duke perdorur MPI.

3. Paralelizimi i veshtire

Te dhenat pjeserisht mund te perpunohen pavaresisht nga njera tjetra nga procese te vecante

qe kryejne detyra te ndryshme (skema logaritese te ndryshme) dhe kane nevoje per

nderkomunikim te rastit midis tyre.

Llogaritjet mund te kryhen me perdorimin e MPI, RPC (Remote Procedure Calls) ose duke

21

programuar direkt ne rrjet me socket.

OpenMP

Eshte teknike e thejshte paralelizimi qe mund te ndaje perpunimin e te dhenave (konkretisht nje

cikel for) ne copa qe realizohen nga thread paralele.

Normalisht cdo thread kryen te njejten skeme llogaritese por me te dhena te ndryshme. Megjithate

duke perdorur funksionin omp_get_thread_num() programisti mund te kape numrin rendor te

thread dhe te parashikoje ndryshime te skemes llogaritese ne thread te vecante.

Nderkomunikimi midis thread i mundshem vetem nepermjet ndarjes te te dhenave (fillestare ose

rezultate te pjeseshme) ne kujtesen e perbashket (shared). Programisti duhet te kujdeset per

konkurencen e thread ne kapjen e kujteses per shkrim per te shmangur perplasjet apo bllokimet

reciproke.

RPC (Remote Procedure Call)

RPC eshte me e gjere se kuadri i programimit paralel dhe mundeson zhvillimin e aplikimeve te

shperndara (ku copat e ndryshme te aplikimit mund te ekzekutohen edhe paralelisht) duke zgjeruar

kuptimin e thirrjes te procedurave nga brenda nje sistemi operativ (rasti klasik) midis sistemeve

operative te ndryshme mbi nje rrjet (rasti i shperndare - “thirrje ne distance:

22

Per realizimin e thirrjes te nje procedure ne distance veprohet sipas parimit “klient – server”.

Procesi ne makinen A (klienti) kerkon te therrase nje procedure ne makinen B (serveri).

Qe te mund te behet nje gje e tille duhet:

a. Ne makinen klient A programi qe kerkon thirrjen duhet te kete te inkorporuar (gjate

kompilimit+lidhjes) procedurat e RPC per thirrje ne distance, konkretisht rpc_call(), ku si

parameter jepen identifikuesi i procedures qe duhet thirrur ne makinen server B dhe te dhenat e

nevojshme. Programisti i programit klient nuk merret me detajet si realizohet thirrja.

b. Ne makinen server B duhet te jete aktiv sherbimi RPC qe pret thirrjet nga distanca, organizon

realizimin e tyre ne lokal dhe dergimin e rezultateve ne makinen klient.

Per te siguruar pavresine e sistemit RPC nga shumellojshmeria e procedurave, thirrja ne makinen

klient “lehtesohet” nepermjet nje cope kodi stub klient qe pergatit thirrjen ne varesi te detajeve te

procedures qe thirret. Ne makinen server sherbimi RPC ndihmohet nga nje tjeter stub server qe

merret me detajet e thirrjes te procedures konkrete.

Praktikisht ne te tre makinat ku behet:

– zhvillimi i aplikimit

– ekzekutimi i programit klient

– ekzekutimi i procedurave te thirrura nga distanca

duhet te jete instaluar paketa perkatese e softuerit RPC.

Procedurat RPC “parakompilohen” me ndihmen e komandes rpcgen, e cila krijon kater skedare

ne gjuhen C:

rpcgen rpcprog.x

– rpcprog_clnt.c ~ kodi i stub klient

– rpcprog_svc.c ~ kodi i stub server

– rpcprog_xdr.c ~ kodi per eXxternal Data Representation

– rpcprog.h ~ kodi header perkates

Keto skedare perfshihen ne kompilimin e aplikimit.

RPC eshte e pavarur nga lloji i platformes harduer dhe softuer te makinave klient dhe server. Kjo

gje mundeson bashkeveprimin e sistemeve te ndryshme ne rrjet, nderkohe qe vete puna e RPC

nderlikohet ngaqe duhet te kujdeset per formatet e te dhenave (qe eventualisht mund te jene te

ndryshme ne makinat A dhe B).

Procedurat RPC ne makinen server duhet te “regjistrohen” qe te njihen dhe te mund te aktivizohen

nga sherbimi RPC me ndihmen e procedures rpc_reg(). Ekziston edhe nje numer procedurash te

23

gatshme (te regjistruara) qe ndodhen ne librarine librpcsvc.

Thirrja e nje procedure ne distance behet me proceduren rpc_call(), qe ka nente parametra:

int rpc_call

(char *host, // server nameu_long prognum, // numri i procedures ne severu_long versnum, // versioni i serveritxdrproc_t inproc, // filtri XDR per kodimin e argumentavechar *in, // pointer per argumentatxdrproc_t outproc, // filtri XDR per kodimin e rezultatevechar *out, // adresa ku do te vendosen rezultatetchar *nettype, // lloji i transportit ne rrjet

)

Nga nje interpretim i kuptimit te prametrave, cdo procedure e PRC identifikohet me nje

numer ne server:

ne grupe 0x20000000 sipas skemes:

0x0 - 0x1fffffff ~ paracaktuar nga IANA0x20000000 - 0x3fffffff ~ percaktohet / propozohet nga perdoruesit0x40000000 - 0x5fffffff ~ transient0x60000000 – 0x........ ~ e rezervuar

Ka dhe disa procedura RPC klient te gatshme, qe mund te thirren pa ndihmen e rpc_call:

Routine Description

rnusers Return number of users on remote machine

rusers Return information about users on remote machine

havedisk Determine if remote machine has disk

rstats Get performance data from remote kernel

rwall Write to specified remote machines

… …

Disa procedura te tjera si ether(), mount(), rquota(), spray() nuk gjenden ne

librarite e gatshme por kane numrat perkates te paracektuar. Nje liste e pjesshme e procedurave

RPC te “para-numeruara” eshte:

RPC Number Program Description

100000 PMAPPROG port mapper

100001 RSTATPROG remote stats

100002 RUSERSPROG remote users

100003 NFSPROG network file system

24

100004 YPPROG yellow pages

… … …

Ne transmetimin e te dhenave (argumenta dhe rezultate) RPC perdor nje format standard te pavarur

nga platformat External Data Representation (XDR). Te dhenat “serializohen” ne formatin XDR

para dergimit dhe “deserializohen” ne marrje, veprime qe kryhen nga nga stub perkates. Te dhenat

elementare serializohen ne 4 bajt pavaresisht nga tipi i tyre ne makinen konkrete. Tipet baze jane:

xdr_int() xdr_u_int() xdr_enum()

xdr_long() xdr_u_long() xdr_bool()

xdr_short() xdr_u_short() xdr_wrapstring()

xdr_char() xdr_u_char()

si dhe “blloqet parafabrikuese”:

xdr_array() xdr_bytes() xdr_reference()

xdr_vector() xdr_union() xdr_pointer()

xdr_string() xdr_opaque()

Programisti gjate zhvillimit te nje aplikimi qe perdor RPC duhet:

– harton kodin standard ne C per aplikimin duke parashikuar thirrjet e procedurave RPC

– harton kodin specifik RPC dhe e parakompilon me rpcgen

∙ percakton tipet e te dhenave argument dhe rezultat per procedurat RPC

∙ percakton numrat e procedurave RPC ne segmentin e rezervuar per perdoruesit

– bashkon kodin standard C me skedaret e prodhuar nga rpcgen

– kompilon kodin e bashkuar

Protokolli RPC eshte percaktuar nga IETF fillimisht ne RFC1831 ne 1995 (versioni 1) dhe

modifikuar me RFC5531 [http://tools.ietf.org/html/rfc5531] ne 2009 (versioni 2). Perdoruesit mund

te aplikojne tek IANA per “zyrtarizimin” e numrave te procedurave RPC vetiake.

Shenim:

• IANA eshte “Internet Assigned Numbers Authority” [http://www.iana.org/] dhe administron

klasat e numrave IP, serverat rrenje te sistemit DNS dhe protokollet.

• IETF eshte “Internet Engineering Task Force” [http://www.ietf.org/] dhe perpunon

standardet dhe specifikimet e protokolleve te Internetit.

…

25

MESSAGE PASSING INTERFACE (MPI)Behet fjale per “klonimin” e nje processi ne disa procese paralele, gje qe lejon kryerjen e

llogaritjeve paralele ne disa CPU. Teknologjia MPI realizon “klonimin” dhe komunikimin midis

proceseve. E ekzekutuar ne nje makine (nje sistem shfrytezimi i vetem), MPI mundeson

shfrytezimin paralel te disa core te CPU. Ndersa ne rast perdorimi ne cluster do te duhet dhe nje

middleware “dispetcer” per te shperndare proceset e klonuara ne makina te ndryshme, zgjidhje qe

perdoret ne sistemet grid.

Krahasuar me OpenMP, kjo e fundit punon me thread paralele qe ndajne te njejten hapesire kujtese

(klonimi konsiston ne shumefishimin e PCB dhe ndoshta te ndonje cope kujtese per variabla

private). Klonimi iproceseve nenkupton shumefishimin e gjithe hapesires te kujteses qe ze procesi

baze, gje qe kerkon hapesire kujtese dhe kohe pune te sistemit. Per kete aresye paralelizimi me

OpenMP mund te “coptohet” gjate kodit, ndersa ai me MPI eshte mire te behet ne fillim te procesit

baze. Ne rastin e MPI duhet te perdoret identifikimi i proceseve per te kontrolluar kush nga proceset

do te kryeje llogaritje paralele e kush sekuenciale.

Per krahasim jepet figura e meposhtme:

T0 T1 T2 T3 T4 T5 P0 P1 P2 P3 P4 P5

ku:

Thread / proces baze

Perpunim paralel

26

Krijimi i proceseve paralele MPI

Si rregull, klonimi i proceseve ne MPI behet ne fillim te procesit baze duke thirrur proceduren:

MPI_Init (&argc,&argv)

Kjo procedure thirret vetem nje here dhe para thirrjes te procedurave te tjera te MPI. Dy argumentat

sherbejne per te derguar ne proceset e klonuar vlerat e parametrave te ekzekutimit te programit.

Ne fund te punes ne te tere proceset duhet te ekzekutohet thirrja e procedures MPI_Finalize().

Numri identifikues i proceseve paralele eshte i rendesishem per te dalluar segmentet e kodit

sekuencial nga ato paralele. Per me teper numri i proceseve paralele percaktohet ne komanden e

ekzekutimit te programit (ndryshe nga OpenMP ku ky numer vendoset ne direktiven #pragma ne

kodin e programit). Per keto aresye si rregull pas thirrjes te MPI_Init perdoren dy procedura te

tjeraMPI:

MPI_Comm_size (comm,&size)MPI_Comm_rank (comm,&rank)

ku:

– size ~ numri i proceseve paralele

– rank ~ numri identifikues i procesit konkret (duke filluar nga zero)

– comm ~ i ashtuquajturi “communicator”. Ne MPI proceset paralele mund te grupohen dhe

te komunikojne brenda grupeve. Per kete qellim perdoret identifikuesi i communicator. Ne

do te kufizohemi ne rastin klasik me nje communicator MPI_COMM_WORLD.

Me tej, midis thirrjeve te procedurave te fillimit dhe mbarimit te sesionit MPI, programisti mund te

perdore rankun e proceseve per te diferencuar punen qe do te kryejne (duke ndare pjeset

sekuenciale te kodit nga ato paralele); si dhe procedurat e komunikimit midis proceseve per

shkembimin e te dhenave ndermjetese gjate llogaritjeve dhe per te sinkronizuar veprimet midis

proceseve paralele.

Komunikimi Midis Proceseve MPI

Komunikimi midis proceseve behet me nderhyrjen e sistemit te shfrytezimit (dhe middleware nese

eshte edhe ky funskional). Mesazhet nga buffer i aplikimit – dhenesi – depozitohen ne buffer te

sistemit dhe prej andej kapen nga marresi kur ky i fundit therret proceduren perkatese (qe kryen

transferimin nga buffer i sistemit ne ate te aplikimit):

27

Procesi A SISTEMI Procesi B

MPI_Send(buffer)

buffer

(buffer)MPI_Recv

Procedurat tipike te komunikimit midis proceseve kategorizohen sipas tabeles:

proces – me – proces(point-to-point)

komunikim ne grup(collective)

bllokueseasinkrone

MPI_SendMPI_Recv

MPI_BcastMPI_ScatterMPI_Gather

sinkroneMPI_SsendMPI_Recv

MPI_BarrierMPI_Reduce

jo-bllokueseasinkrone

MPI_IsendMPI_Irecv

sinkrone MPI_Issend + MPI_Wait / MPI_TestMPI_Irecv

Klasifikimi “bllokues / jo-bllokues” ka te beje me cfare ndodh kur nje proces dergon nje mesazh:

“bllokohet” deri sa te transferohet mesazhi ne buffer te sistemit, apo “nuk bllokohet” pavaresisht

nese mesazhi eshte bere ky transferim.

Klasifikimi “asinkron / sinkron” ka te beje me me cfare ndodh kur nje proces dergon nje mesazh:

bllokohet (sinkrone)deri sa te konfirmohet marrja apo vazhdon punen (asinkrone) me te dale

mesazhi nga buffer i vet drejt atij te sistemit. Bllokimi sinkron ben sinkronizim midis proceseve.

Ne kategorine e komunikimeve ne grup MPI_Barrier eshte e dedikuar per sinkronizimin.

Procedurat si MPI_Bcast,MPI_Scatter,MPI_Gather mund te jene sinkronizuese ose jo ne

varesi te librarise MPI konkrete, Pergjithesisht bllokimi he sinkronizimi mund te kene specifika te

vecanta ne librari MPI te dnryshme.

Procedurat e tipit MPI_Send dhe MPI_Recv sherbejne per dergimin dhe marjen e mesazhit nga

nje proces tek nje tjeter. Procedura MPI_Bcast mundeson dergimin e nje mesazhi nga nje proces

tek gjithe proceset e tjere te grupit. Cifti i procedurave MPI_Scatter dhe MPI_Gather

sherbejne per coptimin e nje array (bashkesi te dhenash – vektor, matrice, string etj.) midis

proceseve te grupit, dhe ribashkimin e saj; keto jane procedura tipike per coptimin e te dhenave per

perpunim paralel ne nje grup procesesh paralele. MPI_Reduce bashkon grupe te dhenash duke

28

kryer veprime me elementet korespondues (shiko specifikimin me poshte)

Parametrat e Procedurave ne MPI

Dallojme disa raste komunikimi.

MPI_Barrier (comm)

ku:

– comm ~ communicator

MPI_Bcast (*buffer, count, datatype, root, comm)

ku:

– buffer ~ pointer i buffer me te dhena– count ~ numri i elementeve ne buffer– datatype ~ tipi i te elementeve ne buffer– root ~ ranku i procesit dergues– comm ~ communicator

MPI_Send (&bufer, count, datatype, destination, tag, comm)

ku:

– buffer ~ pointer i buffer me te dhena– count ~ numri i elementeve ne buffer– datatype ~ tipi i te elementeve ne buffer– denstination ~ ranku i procesit marres– tag ~ numer natyral per identifikimin e mesazhit– comm ~ communicator

MPI_Recv (&buffer,count,datatype,source,tag,comm,&status)

ku:

– buffer ~ pointer i buffer me te dhena– count ~ numri i elementeve ne buffer– datatype ~ tipi i te elementeve ne buffer– source ~ ranku i procesit dergues– tag ~ numer natyral per identifikimin e mesazhit– comm ~ communicator– status ~ strukture e perbere nga rank dhe tag {MPI_Status.MPI_SOURCE,

MPI_Status.MPI_TAG)

Procedurat MPI_Scatter, MPI_Gather bazohen tek coptimi i nje bashkesi te dhenash dhe

29

shperndarja e copave ne procese sipas skemes 1 <=> n :

P0 P1 P2 P3 P4

b0 = a0 b0 = a3 b0 = a6 b0 = a9 b0 = a12

b1 = a1 b2 = a4 b1 = a7 b1 = a10 b1 = a13

b2 = a2 b2 = a5 b2 = a8 b2 = a11 b2 = a14

a0

a1

a2

a3

a4

a5

a6

a7

a8

a9

a10

a11

a12

a13

a14

Ndryshe vepron MPI_Reduce:

P0 P1 P2 P3 P4

b0 b0 b0 b0 b0

b1 b2 b1 b1 b1

b2 b2 b2 b2 b2

a0=@b0

a1=@b1

a2=@b2

ku '@' simbolizon kombinimin e gjithe elementeve bi sipas nje veprimi '@', shembull ai = Σ bi

30

MPI_Scatter ( &sendbuf,sendcount,sendtype,

&recvbuf,recvcount,recvtype,root,comm)ku:

– sendbuf ~ pointer i buffer me te dhenat qe dergohen (ex. &A[rank*count])– sendcount ~ numri i elementeve qe dergohen – sendtype ~ tipi i te elementeve qe dergohen– recvbuf ~ pointer i buffer me te dhenat qe merren– recvcount ~ numri i elementeve qe merren– recvtype ~ tipi i te elementeve qe merren– root ~ ranku i procesit dergues– comm ~ communicator

MPI_Gather ( &sendbuf,sendcount,sendtype,&recvbuf,recvcount,recvtype,root,comm)

ku:– sendbuf ~ pointer i buffer me te dhenat qe dergohen– sendcount ~ numri i elementeve qe dergohen – sendtype ~ tipi i te elementeve qe dergohen– recvbuf ~ pointer i buffer me te dhenat e plota (ex. &A[0])– recvcount ~ numri i elementeve qe merren– recvtype ~ tipi i te elementeve qe merren– root ~ ranku i procesit marres– comm ~ communicator

MPI_Reduce (&sendbuf,&recvbuf,count,datatype,oper,root,comm)ku:

– sendbuf ~ pointer i buffer me te dhenat qe dergohen (ex. &A[rank*count])– recvbuf ~ pointer i buffer me te dhenat qe merren– count ~ numri i elementeve qe merren– datatype ~ tipi i te elementeve qe dergohen– oper ~ tipi i veprimit (MPI_MIN, MPI_MAX, MPI_SUM, MPI_PROD, … )– root ~ ranku i procesit marres– comm ~ communicator

Procedura te tjera si MPI_Allgather, MPI_Allreduce kryejne veprimet perkatese por sipas skemes n <=> n.

MPI_Allgather(&sendbuf,sendcnt,sendtyp,&recbuf,reccnt,rectyp,comm)

MPI_Allreduce (&sendbuf,&recvbuf,count,datatype,oper,comm)

Sic vihet re, ne keto raste mungon ranku i procesit rrenje (root) qe shperndan ose mbledh te dhenat.

Me interes eshte dhe procedura e leximit te ores te sistemit, qe lejon te vleresohet koha e

llogaritjeve (walltime) :

31

double start_time, end_time, exe_time;start_time = MPI_Wtime();

.

.

.end_time = MPI_Wtime();exe_time = end_time – start_time;

Walltime eshte koha nga fillimi i ekzekutimit te nje cope kode deri ne mbarim, duke eprfshire dhe

intervalet e pritjes (koha ne gjendjet GATI dhe PRITJE te procesit). Gjetja e kohet neto te

ekzekutimit, kohes te punes te sistemit per llogari te procesit dhe perqindjen e punes te CPU per

procesin mund te behet (ne sistemet Linux) duke kryer ekzekutimin nepermjet komandes

/usr/bin/time:

(/usr/bin/time ./program … ) 1>time.out 2>time.out

(/usr/bin/time mpirun ./program … ) 1>time.out 2>time.out

rezultati i te ciles ne skedarin tekst “time.out” ka trajten:

96.15 user 340.36 system 0:08.67 elapsed 5029% CPU

(0avgtext+0avgdata 412352maxresident)k

0inputs+48outputs (0major+2334673minor)pagefaults 0swaps

ku:

– user ~ koha neto shumore e ekzekutimit te grupit te proceseve paralele

– system ~ koha neto shumore e punes te sistemit

– elapsed ~ koha nga fillimi i ekzekutimit te programit ne mbarimin e tij e shprehur ne

[[ore:]minuta:]sekonda

– CPU ~ perqindja shumore e punes e cores te CPU per grupin e proceseve paralele

Koha mesatare e nje thread / proces gjendet si raport i kohes “user” me numrin e proceseve.

Perqindja e punes e nje core te CPU gjendet si raport i CPU% me numrin e cores.

32

ZHVILLIMI I PROGRAMEVE PARALELE

Coptimi dhe Paralelizimi i Algoritmit

Programet paralele ofrojne efektivitetin maksimal ne kohe kur paralelizimi i algoritmit behet ne

perputhje me topologjine e harduerit paralel ku do te ekzekutohet programi. Efektiviteti kushetzohet

nga disa faktore qe lidhen me konkurencen misis proceseve paralele:

– koha e CPU (nese procese me shume se core)

– kapja e BUS per komunikim me njesite e tjera te harduerit

– puna me kujtesen cache per cores qe e kane te perbashket (kapja dhe permbajtja)

– puna me kujtesen e ndare

– puna me kujtesat e jashtme

– puna me kontrolloret e rrjetit

– etj.

Ne parim mund te dallohen kater topologji sistemesh paralele:

1. vektor (linear array) procesoresh

2. Peme binare procesoresh

3. matrice (two-dimensional mesh) procesoresh

4. bashkesi procesoresh me variabla te ndare (shared)

Karaketrizimi i topologjive per nje grup me p procesore behet me parametrat e perkufizuar si:

– diametri ~ me e gjata nga distancat me te shkurtra midis dy procesoreve

– grada maksimale e nyjes (maximum node degree) ~ maksimumi i kanaleve te nder-

komunikimit te nje procesori me procesoret e tjere

– W(p) ~ numri total i veprimeve elementare te kryer nga p procesoret (puna / energjia

kompjuterike)

– T(p) ~ koha e ekzekutimit me p procesore

– T(1) = W(1) dhe T(p) ≤ W(p)

– Pershpejtimi S(p) = T(1) / T(p)

– Eficensa E(p ) = T(1) / (p*T(p))

33

– “bolleku” (redundancy) R(p) = W(p) / W(1)

– Perdorimi U(p) = W(p) / (p*T(p))

– Cilesia Q(p) = T^3(1) / (p*T^2(p)*W(p))

Shembull: shuma e 16 numrave ne topologji paralele binare me 8 procesore:

T(1) = W(1) = 15

W(8) = 15 T(8) = 4 E(8) = 15/(8 × 4) = 47%

S(8) = 15/4 = 3.75 R(8) = 15/15 = 1 Q(8) = 1.76

Eficensa e ulet eshte rezultat i munegses te paralelizimit afer rrenjes te pemes (fig.)

Po te llogariten si veprim elementar edhe transferimet (shigjetat ne figure) merret:

W(8) = 22 T(8) = 7 E(8) = 15/(8*7) = 27%

S(8) = 15/7 = 2.14 R(8) = 22/15 = 1.47 Q(8) = 0.39

34

Topologjia paralele vektor

Shembull i topologjise paralele vektor jepet ne figure:

Diametri i nje vektori prej p procesoresh eshte D = p – 1 dhe shkalla maksimale e nyjeve d = 2.

Krahasuar me topologjine tipike vektor, topologjia e modifikuar “unaze” (ring) ka D = [p/2] .

Topologjia paralele peme binare

Shembull i topologjise paralele binare jepet ne figure (kujto vetite e pemeve “pemet e balancuara”,

“pemet komplete” etj.):

Per topologjine peme binare grada e nyjeve eshte d = 3, ndersa diametri varet nga tipi i pemes:

– pema e komplete D = 2 log2 (p + 1) – 2

– pema e balancuar D = 2 log 2 p | 2 log 2 p – 1 ne varesi te nivelit te gjetheve

35

Topologjia paralele matrice eshte si ne figure (rasti i thjeshte dhe ai toroidal)

Diametri i topologjise matrice me p = r*q procesore eshte D = D = r + q – 2 dhe minimizohet ne

rastin e matricave katrore D = 2 r – 2. Ne rastin e matrices toroidale D = r/2 + q/2, ndersa grada e

nyjeve ne te dy rastet eshte d = 4.

Topologjia me kujtese te ndare mund te modelohet si nje graf i plote (ku cdo nyje lidhet me tere

nyjet e tjera):

36

Ne topologjite graf i plote me p procesore grada e nyjeve eshte d = p – 1 ndersa diametri D = 1.

Me gjithe perparesite teorike, sistemi paralel me topologji graf i plote eshte shume i veshtire per tu

realizuar.

Shembull – renditje ne topologji vektoriale:

37

Hapat per daljen e rezultateve nuk jane paraqitur. Supozohet se sistemi i procesoreve mund te

lexoje/shkruaje nga kujtesa nje vlere ne cdo hap.

Duke supozuar se te dhenat jane neper procesore, mund te perdoret renditja “tek-cift”:

38

Shembull : renditje ne topologji peme binare

Bobble Sort ne dy faza:

– faza I: cdo nyje mer vlerat me te vogla nga nen-pemet perkatese => minimali ne rrenje (fig)

– faza II: rrenja shperndan elementet sipas rradhes ne nyjet bij te saj …

Ne rastin me te keq te gjithe vlerat duhet te kalojne neper rrenje ~ “gryka e shishes”

39

Shembull : renditja me “prerje” ( shearsort ) ne topologji matrice:

Renditja kryhet ne (log2r) + 1 faza:

1. rrjeshtat renditen ne forme “gjarperi”: cift ne rritje tek ne zbritje

2. kollonat renditen nga lart poshte

3. ne fazen e fundit rrjeshtat rirenditen te pavarur

40

Kompleksiteti i Algoritmeve Paralele

Analiza e kompleksitetit te algoritmeve:

– e sakte: shuma e peshuar e treguesve per numrin e veprimeve te ndryshme

– e perafert: analiza asimptotike => perdoret ne praktike

Percaktimi i relacioneve O, Ω dhe Ɵ per dy funskione f(n) dhe g(n)

• f(n)=O(g(n)) nqs. per n>no => f(n)<c•g(n) 

• f(n)=Ω(g(n)) nqs. per n>no => f(n)>c•g(n) 

• f(n)=Ɵ(g(n)) nqs. per n>no => c•g(n)<f(n)<c'•g(n) 

Perkufizime:

• funskion sublinear: f(x)<c•(fx) per x>xc shembull: f(x)=sqr(x)

• funksion superlinear: f(x)>c•x per cdo x>xc shembull: f(x)=x^2

Shembull:

Sublinear O(1) constant

O(log n) logarithmic

Linear O(n)

Superlinear O(n^c) polynomial, c>1

O(2^n) exponential

Keto perkufizime shfrytezohen per vleresimin e cilesise te algortimeve ne disa aspekte:

– koha e ekzekutimit (running time)

– kerkesa per burime (kujtese, disk kapacitete komunikimi ...)

– kosto e zhvillimit, kolaudimit, mirembajtjes

– portabiliteti

Koha e ekzekutimit eshte tipike ne vleresimin e cilesise te algortimeve paralele. Synohet qe koha e

ekzekutimit te kufizohet nga lart sipas nje rendi sa me te ulet kur permasat e problemit rriten shume.

Nderkohe kufizimi nga poshte mund te sherbeje si tregues per hapesiren e mundeshme te

permiresimit te algoritmit.

41

Shembull:

0 1 2 3 4 5 6 7 8 9 100

102030405060708090

100f(x)

x^2

sqr(x)

1 101

10

100f(x)

x^2

sqr(x)

0 100 200 300 400 500 6000

50000

100000

150000

200000

250000

300000f(x)

x^2

sqr(x)

1 10 1001

10

100

1000

10000

100000

1000000f(x)

x^2

sqr(x)

Algoritmi quhet optimal kur kufijte e poshtem dhe te siperm konvergjojne asimptotikisht (shembujt

e mesiperm nuk jane te tille). Ne rast optimaliteti nuk eshte e mundur qe rendi te zvogelohet

asimptotikisht dhe e vetmja gje qe mund te behet eshte ndryshimi i konstanteve (shembull

zvogelimi nga 4•n^2 ne 3•n^2).

Le te jete T(n,p) koha e ekzekutimit te problemit me madhesi n ne nje makine me p procesore.

Konsiderojme matjen e kostos nepermjet numrit te procesoreve. Algoritmi quhet:

• optimal sipas kohes nqs. T(n,p)=g(n,p), ku g(n,p) eshte kufiri i poshtem i kohes

• optimal sipas kosto-kohes nqs. p•T(n,p)=T(n,1) perdorimi=bolleku=1

• eficient sipas kosto-kohes nqs. p•T(n,p)= (T(n,1)) Ɵ perdorimi=bolleku= (1)Ɵ

Verejtje: numri i hapave mund te mos jete proporcional me kohen e ekzekutimit.

42

Klasat e Kompleksitetit

Problemet mund te klasifikohen sipas veshtiresise te zgjidhjes. Duke perdorur kohen e ekzekutimit

ne nje makine me nje procesor (makina deterministike e Turingut), mund te percaktohen klasat:

• Algoritmet me kohe ekzekutimi te kufizuar nga lart nga polinome => klasa P (polinomjale)

Edhe ne rast se polinomi eshte i rendit te larte, mund te ekzistoje mundesia e permiresimit te

algoritmit – algoritmet e klases P quhen edeh “te trajtueshem lehtesisht” (tractable)

• Algoritmet determinsitike me kohe ekzekutimi eksponenciale konsiderohen “te pa-

trajtueshem” (intractable). Nje problem me madhesi n qe kerkon 2^n instruksione, per

n=100 ne nje makine me 1 GIPS kerkon 400 G shekuj. Algoritmet e pa trajtueshem, per te

cilet korrektesia e zgjidhjes mund te verifikohet ne kohe polinomjale, quhen te klases NP

(polinomjale jo-deterministike).

Perpunimi paralel eshte efektiv kruesisht epr problemet e klases P, ndersa nuk eshte i mundur si

rregull per problemet e klases NP.

Ne 1979 Niclaus Pippenger sugjeroi nje nenklase te P te perbere nga algoritmet efektivisht te

paralelizueshem qe mund te zgjidhen ne periudha kohore polinomjale sipas madhesise te problemit

T(p)=O(logkn) duke perdorur jo me shume se nje sasi polinomjale procesoresh p=O(n). Kjo

nenklase njihet si “klasa NC”.

Nje forme e dobet e klases NC percaktohet si teza e paralelizimit kompjuterik:

Cdo gje qe mund te llogaritet me nje makine Turingu duke perdorur hapesire

polinomjalisht te kufizuar ne nje kohe te pakufizuar mund te llogaritet ne nje makine

paralele ne nje kohe polinomjale duke eprdorur nje numer te pakufizuar procesoresh,

dhe anasjelltas.

Modelet e Paralelizimit

– perca dhe sundo

Coptohet problemi me madhesi n ne nen-probleme vogla me madhesi s, duke shpenzuar nje

kohe Td(n)

Nen-problemet zgjidhen vecash ne nje kohe T(s)<T(n)

Rezultatet e pjeseshme kombinohen ne nje kohe Tc(n)

43

Koha totale e llogaritjeve eshte T(n)=Td(n)+T(s)+Tc(n)

– Randomization

Perdorimi i metodave te rastit per vendim-marje ne zgjidhjen e problemit ne “paralel”:

‧ random sampling: coptimi i rastit i grupeve te te dhenave per perpunim paralel

‧ random input: kapje e rastit e te dhenave per te shmangur grupimet e keqija (bad data

patterns)

‧ random searching: kerkimi i rastit i elementeve me karakteristika te caktuara

‧ random control: zgjedhja e rastit e ndonje parametri te algoritmit

‧ thyerja e simetrise: algoritme te caktuara deterministike mund te shfaqim dukuri ciklike

qe shpijen ne deadlock. Rastesia mund te ndihmoje ne daljen nga qorrsokaku.

‧ perafrimi: ne rastin e algortimeve iterative numri i iteracioneve mund te percaktohet

“apriori” ne varesi te kohes ne dispozicion, duke ofruar zgjidhje te perafert.

– Rekurenca

Teoreme: nqs. ƒ(n)=a•ƒ(n/b)+h(n) zgjidhja asimtotike e rekurences eshte:

f(n)= (Ɵ nlogba) nqs. h(n)=O(nlogba­ε)

f(n)= (Ɵ nlogba•logn) nqs. h(n)=Ɵ(nlogba)

f(n)= (h(n))Ɵ nqs. h(n)= (Ω nlogba+ε)

ku: h(n) eshte koha per coptimin e problemit dhe bashkimin e nen-rezultateve

‧ b eshte numri i nen-problemeve me madhesi n/b

‧ a eshte numri i “blloqeve” (batch) te ekzekutimit 1<a<b

44

Shembull:

Vleresimi i kompleksitetit ne problemin e fushes

gravitacionale:

– problemi direkt – llogaritja e efektit

gravitacional te trupit

– problemi invers – gjetja e trupit nga

efekti gravitacional

– burimi i fushes gravitacionale percaktohet nga nje matrice 3D (NxNxN)

– fusha gravitacionale llogaritet ne nje siperfaqe te perfaqesuar nga matrice 2D (NxN)

– llogaritja e efektit te nje elementi 3D ne nje pike 2D ~ “llogaritje elementare”

– numri i llogaritjeve elementare per efektin e nje elementi 3D ne matricen 2D eshte N^3

– numri i veprimeve elementare per mbulimin e matrices 2D eshte (N^3)(N^2)=N^5

– koha e llogaritjeve eshte e rendit O(N^5)

– per te njejtin problem ne varesi te permasave te matricave efekti i elementit 3D proporcional

me vellimin e tij, invers-proporcional me N^3

– ne problemin invers koha e llogaritjes e efektit te trupit ne siperfaqe eshte O(N^8)

Ne zgjidhjen iterative te problemit invers ne sisteme paralele koha eshte:

45

46