LEKSIONE PER SISTEMET E SHPERNDARA DHE PARALELE

LEKSIONE PER SISTEMET E
SHPERNDARA DHE
PARALELE
DEGA INFORMATIKE EKONOMIKE
Neki Frasheri
Tirane, 2012
1

Table of Contents
HYRJE..................................................................................................................................................3
Sistemet sekuenciale dhe paralele....................................................................................................3
Nevoja per perpunime paralele........................................................................................................4
Perpunimi paralel i te dhenave.........................................................................................................4
HYRJE NE OpenMP............................................................................................................................5
ARKITEKTURAT PARALELE...........................................................................................................8
Arkitektura SISD.............................................................................................................................8
Arkitektura SIMD............................................................................................................................8
Arkitektura GPU..............................................................................................................................9
Arkitektura HyperThread...............................................................................................................11
Arkitektura MIMD.........................................................................................................................11
Arkitektura CPU Multi-core..........................................................................................................12
Arkitektura GRID..........................................................................................................................13
ARKITEKTURA E KUJTESAVE.....................................................................................................15
Kategorizimi i Kujtesave...............................................................................................................15
Sistemet paralele me kujtese te perbashket....................................................................................16
Kujtesa ne sistemet GPU...............................................................................................................17
Kujtesa e Jashtme dhe Skedaret.....................................................................................................18
KOMUNIKIMI MIDIS PROCESEVE..............................................................................................20
Paralelizimi i te Dhenave dhe Rasti i OpenMP.............................................................................20
OpenMP.........................................................................................................................................21
RPC (Remote Procedure Call).......................................................................................................21
MESSAGE PASSING INTERFACE (MPI).......................................................................................25
Krijimi i proceseve paralele MPI...................................................................................................26
Komunikimi Midis Proceseve MPI...............................................................................................26
Parametrat e Procedurave ne MPI.................................................................................................28
ZHVILLIMI I PROGRAMEVE PARALELE....................................................................................32
Coptimi dhe Paralelizimi i Algoritmit...........................................................................................32
Kompleksiteti 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
Ku: CPU ketu perfaqeson regjister ne procesor.
Koha e ekzekutimit eshte T = n * DT
ku DT ~ koha e ekzekutimit te grupit te instruksioneve .
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

) shuma e termave te nje vektori paralelizohet me veshtiresi S = Σ a[i]
HYRJE NE OpenMP
Librari 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):
Procesi
baze
v
v
v
fork
w
w
w
w
w
proces
proces
Thread
paralel
.
.
.
w
w
w
w
w
proces
Thread
paralel
.
.
.
.
w
w
w
w
w
thread
thread
thread
...
Thread
paralel
.
.
.
.
w
w
w
w
w
Thread
paralel
.
.
.
.
w
w
w
w
w
5

join
v
v
v
join
.
.
.
join
.
.
.
Ku: v ~ kod qe ekzekutohet vetem ne procesin baze (sekuencial)
join
.
.
.
w ~ kodi qe ekzekutohet sekuencialisht por i perseritur ne thread paralele
join
.
.
.
Strukture qe paralelizohet relativisht lehte eshte cikli “For” ne rastin kur iteracionet e tij jane te
pavarur nga njeri tjetri.
Shembull:
Shembull:
Paralelizohet lehte:
for i=1 to n
c[i] = a[i] + b[i]
Paralelizohet me veshtiresi:
for i=1 to n
s = s + a[i]
Ne disa raste me ndryshime te vogla iteracionet mund te behen te pavarur:
Iteracione te ndervarur:
Analiza e shumes te vektoreve:
Kodi i shumes te dy vektoreve:
for i=1 to n
j = j + 5
c[j] = a[j] + b[j]
for i = 1 to n
c[i] = a[i] + b[i]
Numri i iteracioneve: n
Numri i thread paralele: m
Cdo thread duhet te kryeje: k = int(n/m) iteracione
Iteracione te pavarur:
for i=1 to n
j = i * 5
c[j] = a[j] + b[j]
for i=1 to k
thread 0 >>>>>>>>>>>>>>x>>>>>>>>>>>>>>>>>>x>>>>>>>>>>>>>
for i=k+1 to 2k
thread 1 ..............->>>>>>>>>>>>>>>>>>-.............
for i=2k+1 to 3k
thread 2 ..............->>>>>>>>>>>>>>>>>>-.............
. . .
for i=(m-1)k+1 to n
thread 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:
Shembull:
Shembull:
#pragma omp parallel num_threads(m)
Mbledhja e dy vektoreve
#pragma omp parallel num_threads(m)
for (i=0; i

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):
IN
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:
IN
instruksioni ~ mi-1 => mi-2 => mi-3 => mi-4
mi-1
data4
mi-2
data3
mi-3
data2
mi-4
data1
OUT
OUT
8

Figura me poshte tregon zhvendosjen e te dhenave neper blloqet e mikro-instruksioneve te CPU:
Instruksioni si varg
mikro-instruksionesh
Koha
data1 hyn ne CPU data1
data2 hyn ne CPU data2 data1
mi-1 mi-2 mi-3 mi-4
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
KUJTESA
E
PERBASHKET
9

transferimin e te dhenave nga RAM ne kujtesen e GPU.
Ku: ~ CPU kontrollon shkembimet midis RAM dhe GPU
Shembull:
~ transferim kodi dhe te dhenash midis RAM dhe GPU
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:
BUS
CPU RAM CPU
Kodi “kernel”
Te dhenat
– 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

Arkitektura HyperThread
Ne disa kategori procesoresh Intel eshte realizuar e ashtuquajtura teknologji hyperthread.
Arkitektura e nje CPU klasike (nje core e vetme) eshte:
mjedisi
i
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:
mjedisi
i
thread
ALU
mjedisi
i
thread
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:
RAM
CPU
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.
RAM
CPU
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
RAM
CPU
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:
RAM
CPU
RAM
CPU
12

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.
Siguria
+ Monitorimi
User
Interface
Intranet / Internet
“dispecer”
13

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 RAM
kujtese 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:
RAM
cache
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 cache
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
Cfare mund te thuhet:
BUS
CPU RAM
Kujtesa
e
Perbashket
• 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 lexim
N procese ne lexim
1 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
Problem tjeter eshte ndarja e nje skedari ne “copa” per proceset e ndryshme paralele:
Proceset mund te
prishin te dhenat e njeri
tjetrit
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]
2. Paralelizimi i pjesshem
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.
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
n
S = Σ1 a[i]
3. Paralelizimi i veshtire
nt
Mund te ndahet ne copa te pavarura { S = Σns
duhet te shumohen rezultatet nga copat paralele.
a[i] } por per rezultatin final
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.
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

OpenMP
programuar direkt ne rrjet me socket.
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 name
u_long prognum, // numri i procedures ne sever
u_long versnum, // versioni i serverit
xdrproc_t inproc, // filtri XDR per kodimin e argumentave
char *in, // pointer per argumentat
xdrproc_t outproc, // filtri XDR per kodimin e rezultateve
char *out, // adresa ku do te vendosen rezultatet
char *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 IANA
0x20000000 - 0x3fffffff ~ percaktohet / propozohet nga perdoruesit
0x40000000 - 0x5fffffff ~ transient
0x60000000 – 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:
ku:
T0 T1 T2 T3 T4 T5 P0 P1 P2 P3 P4 P5
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:
ku:
MPI_Comm_size (comm,&size)
MPI_Comm_rank (comm,&rank)
– 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
Procedurat tipike te komunikimit midis proceseve kategorizohen sipas tabeles:
bllokuese
jo-bllokuese
asinkrone MPI_Send
MPI_Recv
sinkrone MPI_Ssend
MPI_Recv
asinkrone MPI_Isend
MPI_Irecv
proces – me – proces
(point-to-point)
sinkrone MPI_Issend + MPI_Wait / MPI_Test
MPI_Irecv
(buffer)
MPI_Recv
komunikim ne grup
(collective)
MPI_Bcast
MPI_Scatter
MPI_Gather
MPI_Barrier
MPI_Reduce
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.
ku:
ku:
ku:
ku:
MPI_Barrier (comm)
– comm ~ communicator
MPI_Bcast (*buffer, count, datatype, root, comm)
– 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)
– 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)
– 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

ku:
ku:
ku:
MPI_Scatter ( &sendbuf,sendcount,sendtype,
&recvbuf,recvcount,recvtype,root,comm)
– 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)
– 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)
– 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:
ku:
96.15 user 340.36 system 0:08.67 elapsed 5029% CPU
(0avgtext+0avgdata 412352maxresident)k
0inputs+48outputs (0major+2334673minor)pagefaults 0swaps
– 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⎣log2 p ⎦ | 2⎣log2 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)no => f(n)>c•g(n)
• f(n)=Ɵ(g(n)) nqs. per n>no => c•g(n)

Shembull:
100
90
80
70
60
50
40
30
20
10
0
300000
250000
200000
150000
100000
50000
f(x)
x^2
sqr(x)
0 1 2 3 4 5 6 7 8 9 10
f(x)
x^2
sqr(x)
0
0 100 200 300 400 500 600
100
10
f(x)
x^2
sqr(x)
1
1 10
1000000
100000
10000
1000
100
10
f(x)
x^2
sqr(x)
1
1 10 100
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(log k n) 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)

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
– Rekurenca
“apriori” ne varesi te kohes ne dispozicion, duke ofruar zgjidhje te perafert.
Teoreme: nqs. ƒ(n)=a•ƒ(n/b)+h(n) zgjidhja asimtotike e rekurences eshte:
f(n)= Ɵ( nlog b a ) nqs. h(n)=O(nlog b a­ε )
f(n)= Ɵ( nlog b a•logn) nqs. h(n)=Ɵ(nlog b a )
f(n)= Ɵ(h(n)) nqs. h(n)= Ω( nlog b a+ε )
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

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