neki frasheri - itc.upt.alitc.upt.al/_opsys/nf-op_sys-v2.pdf · programe qe marin ne hyrje nje...
TRANSCRIPT
Neki Frasheri
LEKSIONE PER SISTEMET E SHFRYTEZIMIT
DEGA INFORMATIKE
Tirane, 2012
1
Pasqyra e LendesHYRJE..................................................................................................................................................................................3
Mbi Historine e Makinave Llogaritese...........................................................................................................................3Mbi Fillimet e Historise se Kompjuterave......................................................................................................................5Kompjuterat pa Sisteme Shfrytezimi..............................................................................................................................8
KUPTIMI I MULTIPROGRAMIMIT................................................................................................................................13Kompjuterat ne Industri dhe Banka..............................................................................................................................13Multiprogramimi dhe Ndarja e Kohes..........................................................................................................................15Mbi Sistemin e Nderprerjeve........................................................................................................................................17Problematika e Sistemeve te Shfrytezimit....................................................................................................................19Evolucioni i Sistemeve te Shfrytezimit dhe Hardueri...................................................................................................20
SISTEMET E SHFRYTEZIMIT TE DISKUT...................................................................................................................22Programimi i nje Sistemi Shfrytezimi te Thjeshte........................................................................................................23Vendosja e DOS ne Kujtese..........................................................................................................................................26Sistemet e Shfrytezimit me Multiprogramim ...............................................................................................................28
MODELET E SISTEMEVE TE SHFRYTEZIMIT...........................................................................................................29Modeli i Arkitektures Monolite.....................................................................................................................................29Modeli i Arkitektures me Shtresa..................................................................................................................................30Modeli i Arkitektures Klient – Server ..........................................................................................................................32Modeli i Arkitektures me Makina Virtuale ..................................................................................................................33
PROCESET........................................................................................................................................................................34Kuptimi i Procesit.........................................................................................................................................................34Gjendjet e Procesit........................................................................................................................................................38Politikat e Rradheve......................................................................................................................................................39Konkurenca e Proceseve...............................................................................................................................................41Perjashtimi Reciprok.....................................................................................................................................................43
C'aktivizimi i nderprerjeve......................................................................................................................................43Variablat Celes/Flamur............................................................................................................................................44Fjetja dhe Zgjimi.....................................................................................................................................................47
Semaforet......................................................................................................................................................................49Sinkronizimi i Proceseve..............................................................................................................................................51Bllokimet (deadlocks)...................................................................................................................................................51
SISTEMI I HYRJE – DALJEVE.......................................................................................................................................56BAZAT E KOMPILIMIT...................................................................................................................................................60ADMINISTRIMI I KUJTESES.........................................................................................................................................63
Sistemi i administrimit te kujteses................................................................................................................................63Principi i adresimit........................................................................................................................................................64Skemat e administrimit te kujteses................................................................................................................................66Aspekte te shfrytezimit te kujteses................................................................................................................................72Probleme te Mbrojtjes ..................................................................................................................................................73
SISTEMET E SKEDAREVE.............................................................................................................................................75Skedaret dhe Sistemet e Skedareve...............................................................................................................................75Strukturat e Skedareve..................................................................................................................................................76Atributet e Skedareve....................................................................................................................................................77Direktorite.....................................................................................................................................................................78Realizimi i Sistemit te Skedareve.................................................................................................................................80
Sistemi i skedareve ne Unix / Linux.......................................................................................................................81Sistemet e skedareve ne MS Windows....................................................................................................................82
Kujdesi per Skedaret.....................................................................................................................................................84Procesi i Booting i Sistemit te Shfrytezimit.......................................................................................................................86ELEMENTE TE MBROJTJES TE SISTEMEVE..............................................................................................................89
Problemet e Sigurise.....................................................................................................................................................89Elementet Baze te Mbrojtjes.........................................................................................................................................90
SISTEMET MULTIPROCESOR.......................................................................................................................................93Paralelizimi ne Kompjuterat e Zakonshem...................................................................................................................93Sistemet Klasike Paralele..............................................................................................................................................95Sistemet e Shperndara...................................................................................................................................................96
2
HYRJE
Termi “sisteme shfrytezimi” rrjedh nga frengjishhtja “systeme d'exploitation”, nje perkthim i
deformuar i termit orgjinal anglisht “operating system”. Termi frengjisht u fut ne Shqiperi ne vitet
80 me krijimin e rrjetit informatik me paisje te firmes BULL France (ish Honeywell-Bull).
Lexuesi duhet te rikujtoje lenden e Arkitektures te Kompjuterave, ndertimin e CPU (ALU, regjistrat
si PC, adrese, baze, akumulator), RAM (dekoduesi, kujtesa e organizuar si varg qelizash / fjalesh te
formuara nga 1 / 2 / 4 Bajte me nga 8 bite, mekanizmin DMA (Direct Memory Access)),
mekanizmin e nderprerjeve (IRQ / interrupt ~ sinjal elektrik qe detyron procesorin te nderprese
ekzekutimin e nje vargu instruksionesh dhe te filloje ekzekutimin e nje vargu tjeter, duke vendosur
paraprakisht vlerat e regjistrave ne nje stive per ti rimare dhe rifilluar me vone ekzekutimin e vargut
te nderprere), si parakusht per pervehtesimin e ciklit te leksioneve mbi sistemet e shfrytezimit.
Mbi Historine e Makinave Llogaritese
Ne procesin e llogaritjes per zgjidhjen e nje problemi marin pjese:
– metoda e zgjidhjes algoritmi
(ne mendje ose ne leter)
– mjeti llogarites
(truri, ose mjet mekanik / elektronik)
– te dhenat e regjistruara diku
(ne leter ose kujtese)
Realizimi i manual i porcesit llogarites paraqet dy probleme:
– koha e llogaritjes
– siguria e rezultatit
Automatizimi i llogaritjeve mundeson shkurtimin e kohes se llogaritjeve dhe rritjen e sigurise se
rezultateve, vecanerisht kur kerkohet perseritje e llogaritjeve me te dhena te tjera. Per kete qe ne
lashtesi jane ndertuar makina automatike, historikisht mekanike deri ne fillimet e shekullit XX kur
filloi te perdorej elektriciteti
Shembuj makinash per automatizimin e llogaritjeve ndeshen qe ne lashtesi:
3
– Antikythera (periudha e antikitetit)
makine mekanike e dedikuar per llogaritje astronomije (?)
– Kutia muzikore
mund te konsiderohet si shembull automatizimi “llogaritjesh”
– Makina e Babbage (shekulli XIX)
modeli i pare i nje makine mekanike te programueshme
– Altair 8800 (vitet 70)
mikrokompjuteri i pare komercial i suksesshem
– X2, (Qendra e Matematikes Llogaritese Tirane, 1971)
nje nga kompjuterat e pare te perdorur ne Shqiperi ...
Antikythera supozohet se ishte e dedikuar per llogaritje sipas disa formulave te caktuara, ndoshta
per llogaritjen e pozicionit te disa trupave qiellore; si e tille mund te konsiderohet e “ngurtesuar”.
Ndersa me kutine muzikore ndeshim ne konceptin e “procesorit” - mekanizmi i prodhimit te
tingujve (shufrat me gjatesi te ndryshme) dhe “kujtesa” - cillindri me kunja qe kur prekin shurat
shkaktojne tingellimin e tyre; duke ndryshuar cilindrin kutija muzikore mund te luaje pjese
muzikore te ndryshme – mund te programohet. Ndersa makina e Babbage, Altair8800 dhe X2 ishin
makina teresisht te programueshme por pa sisteme shfrytezimi; si te tilla perdorimi i tyre ishte i
veshtire. Makina e Babbage, duke qene dhe mekanike, nuk u vu kurre ne pune; Altair8800 u perdor
nga amatoret dhe i hapi rruge krijimit te mikrokompjuterave moderne duke filluar me Apple te
4
Steve Jobs dhe Steve Vozniak; ndersa X2 u perdor per 15 vjet ne Qendren e Matematikes
Llogaritese, deri ne 1985 kur u krijua rrjeti i pare informatik ne Tirane dhe Instituti i Informatikes
dhe Matematikes te Zbatuar (INIMA), duhet kujtuar se regjistrimi i popullsise i vitit 1978 u realizua
ne nje makine te ngjashme me X2. Kompjuterat si Altair8800 dhe X2 krahas veshtiresive te
perdorimit ofronin nje perparesi qe sot nuk ekziston me – perdoruesi mund te “shikonte” cfare
ndodhte brenda ne makine, gje qe sot eshte praktikisht e pamundur – sistemet informatike sot jane
teper “transparente” per perdoruesin dhe me lindjen e sistemeve “cloud' kjo transparence behet
ekstremale - “kuti e zeze”.
Mbi Fillimet e Historise se Kompjuterave
Ky cikel leksionesh per sistemet e shfrytezimit fillon me analizen e makinave Altair8800 dhe X2
pikerisht per te shfrytezuar te qenurit e tyre “makina te hapura” – “kuti te bardha”. Makinat si
Altair8800 dhe X2 kishin ne parim te njejten arkitekture si kompjuterat e sotem:
CPU RAM
BUS
Kontrollor I/O Kontrollor I/O ... Kontrollor I/O Kontrollor I/O
Kjo ngjashmeri arkitekturore na lejon ti perdorim per te spjeguar fillimet e sistemeve te
shfrytezimit. Makina X2 ekziston tashme vetem ne pak fotografi, ndersa per Altair8800 mund te
shkarkohet nga Interneti (http://simh.trailing-edge.com/) nje simulator me te cilin mund te punohet
si me makinen orgjinale:
pamje e plakes te perparme te makines Altair8800
5
pamje e simulatorit te makines Altair8800
Altair ka nje procesor te thjeshte, ku gjendet nje regjister adresash (Program Counter), dhe nje
akumulator. Duke filluar nga siper, rrjeshti i llampave djathtas pasquron gjendjen e regjistrit te
adresave (8 llampa ~ bit), nen te rrjeshti i 16 llampave qe pasqyrojne gjendjen e qelizes te RAM ne
adresen qe ndodhet ne regjistrin e adresave, nen te rrjeshti i 16 celsave pozicioni binar i te cileve
mundeson perdoruesin te fute ne makine vlera binare per ti regjistruar ne RAM, dhe se fundi rrjeshti
i celsave te komandimit.
Ora (Clock) e procesorit mund te nderpritet dhe riniset me celsin [STOP]/[RUN].
Me ndihmen e rrjeshtit te 16 celsave perdoruesi mund te fiksoje nje adrese te RAM dhe me pas te
regjistroje ne kete adrese nje vlere binare. Celsi [EXAMINE]/[EX NEXT] mundeson afishimin ne
vargun e llampave te vleres binare qe ndodhet ne RAM ne adresen e fiksuar tek celsat, ndersa celsi
[DEPOSIT]/[DEP NEXT] ben regjistrimin ne RAM ne adresen e fiksuar me pare te vleres binare
nga vargu i celsave. Ne te dy rastet pozicioni [... NEXT] mundeson punen me adresen pasardhese.
Perdoruesi duhet te fute ne kujtese, duke manipuluar me celsat, vlerat binare qe perfaqesojne
komandat e programit dhe te dhenat fillestare. Me pas me celsin [RUN] leshon makinen ne pune
duke aktivizuar oren (clock) e CPU. Me mbarimin ellogaritjeve perdoruesi duhet te nxjere nga
RAM rezultatet, njeri pas tjetrit dhe ne format binar, perseri duke manipuluar me celsat.
6
Ne parim, me pak pune elektronike Altair8800 mund te shndrohet ne nje kompjuter me “miqesor”:
kontrollor Altair8800
kontrollor
a
f
i
s
h
u
e
s
Tastiere – kontrollor – Altair8800 – kontrollor – afishues
Ne vecanti tek Altair8800 mund te shtojme, paralelisht me tastieren, edhe nje paisje leximi me shirit
(leter ose magnetik), si dhe paralel me afishuesin edhe nje printer. Ne kete rast do te supozojme se
procesori ka edhe komandat per zgjedhjen e kanalit te hyrjes (tastiere ose lexues shiriti) dhe te
kanalit te daljes (afishues ose printer). Altair8800 imagjinar i paisur me lexues shiriti dhe printer do
te ishte i ngjashem me maikinen X2.
Makina X2 kishte kujtese me kapacitet 48KB, nje “hic” ne krahasim me teknologjine e sotme.
Megjithate si dje dhe sot kompjuterat e zakonshem punojne sipas nje parimi (Von Nojman):
– programi dhe te dhenat regjistrohen ne kujtese
– procesori lexon komandat / instruksionet e programit njeri pas tjetrit
– komandat perbehen nga kodi i veprimit dhe adresa e objektit mbi te cilin veprohet
– per cdo komande procesori mbi te dhenat vepron / lexon / shkruan ne kujtese.
Parimi i Nojman na lejon ti referohemi shembullit te makines X2 per te trajtuar historine e
zhvillimit te sistemeve te shfrytezimit.
7
Kompjuterat pa Sisteme Shfrytezimi
Sistemet kompjuterike te gjenerates te dyte (me tranzistore) perbeheshin nga:
paisje leximisistemi qendrorCPU = RAM
paisje shtypi
konsola e komandimit
Ne vecanti, Pamja e konsoles te makines X2 ishte:
regjistri adresaveregjistri i komandaveakumulatoret A, B, Ccelsa komandimi (perfshi zerimin)
tre rradhe me celsa lidhur me tre fjalet e para te kujtesesbutoni i leshimit
Celsi i zerimit perdorej per zerimin e regjistrave te procesorit. Me zerimin e PC (Program Counter)
dhe shtypjen e butonit te leshimit (qe vinte ne pune oren e procesorit), procesori fillonte
ekzekutimin e komandave qe ndodheshin ne fillim te kujteses – praktikisht komandat e vendosura
ne tre rradhet me celsa te pllakes horizontale te konsoles te komandimit.
Makina X2 ishte lidhur me nje paisje leximi shirit letre
(perfolente). Perfolenta lexohej optikisht duke kaluar
midis nje llampe dhe nje grupi me fotoelemente.
Fotografia eshte bere pas heqjes nga perdorimi te
makines, mbi paisjen e leximit dallohen te ekspozuar dy
kubet e kujteses RAM ku cdo bit realizohej me unaza
ferromagentike.
8
Programi dhe te dhenat, ne format binar, shtypeshin ne perfolente. Ne fund vendosej nje karaketr
special qe intetrpretohej si shenje ndalimi nga paisja e leximit. Procedura e punes qe kryente
operatori per ekzekutimin e nje programi ishte:
a) Vendosej ne paisjen e leximit bobinen me perfolenten e programit dhe te dhenave
b) Zeroheshin regjistrat e procesorit
c) Vendoseshin ne tre rradhet e celsave te kujteses komandat e lezximit.
Ne trajte simbolike (kujto mnemonikat e gjuhes asembler) komandat ishin:
READ_TAPE #device
STORE XXXX
STOP
GOTO YYYY
ku: XXXX ~ adresa ne RAM ku do te filloje vendosja e Bajteve te lexuar
YYYY ~ adresa ne RAM e komandes te pare te programit qe duhet ekzekutuar
d) shtypej butoni i leshimit.
Pas shtypjes te butonit te leshimin fillonte punen ora e procesorit dhe ky i fundit ekzekutimin e
komandave duke filluar nga adresa zero e kujteses:
– aktivizohej paisja e leximit
– procesori fillonte regjistrimin ne kujtese duke filluar nga adresa XXXX e RAM te vargut te
Bajteve qe vinin nga paisja e leximit
– me ndeshjen e karakterit special te ndalimit ne shirit paisja e leximit ndalonte
– procesori kalonte ne komanden pasardhese [STOP] dhe ndalonte (ndalonte ora e procesorit),
kjo mundesonte operatorin te vendoste shirit tjeter ose vlera te reja ne dy rradhet e para te
celsave (tashme te “ekzekutuar” nga procesori e qe mund te per futje te dhenash)
– rishtypej (nga operatori) butoni i leshimit dhe rifillonte punen ora / procesori duke
ekzekutuar komanden pasardhese [GOTO YYYY], me kete komande procesori vendoste ne
regjistrin PC vleren YYYY dhe kalonte ne ekzekutimin e komandes qe ndodhej ne kete
adrese te RAM
9
Programisti duhej te kishte parashikuar daljen ne shtyp te rezultateve.
Sic shikohet, puna me kete makine kishte veshtiresi dhe mund te kryhej vetem nga specialistet:
– hartimi i programit ne gjuhen e procesorit ne format binar
– pergatitja e te dhenave ne format binar
– administrimi i kujteses duke caktuar ku do te vendosej programi dhe te dhenat
– pergatitja e udhezimeve per operatorin
Nje permiresim / lehtesim i punes u arrit me perdorimin e kompilatoreve. Kompilatoret jane
programe qe marin ne hyrje nje tekst – proogram te shkrojtur ne gjuhe te zhvilluar (FORTRAN,
COBOL, ALGOL, C etj.) dhe jep ne dalje programin e perkthyer ne gjuhen e procesorit.
Ne rastin e makines X2 u perdor kompilatori i gjuhes ALGOL60. Duke shmangur detajet e pa
nevojshme, ideja e procesit te permiresuar te punes ishte:
– operatori vendoste dy bobina perfolentash
‐ kompilatorin (ne format binar ne gjuhen e procesorit)
‐ programin dhe te dhenat e perdoruesit (ne format “njerezor”)
Ekzekutimi i programit kryhej ne dy etapa:
– lexohej dhe ekzekutohej kompilatori, i cili:
‐ lexonte nga shiriti programin dhe te dhenat e perdoruesit
‐ i perkthente ne format binar dhe ne gjuhen e procesorit
‐ linte ne kujtese programin dhe te dhenat binare
– ne mbarim te kompilimit makina ndalonte
– operatori vendoste komandat per rifillimin e punes te makines per ekzekutimin e programit
te perdoruesit, tashme binar dhe ne kujtese, dhe rishtypte butonin e leshimit
– makina ekzekutonte programin e perdoruesit.
Problemi tjeter per kete menyre pune kishte te bente me efektivitetin e perdorimit ne kohe te
procesorit – nje paisje me kosto teper te larte per periudhen historike ne fjale. Grafikisht perdorimi i
kohes te punes do te ishte:
10
shfrytezimi i kohes se punes ne makinen X2
Shmangia e ketij problemi u arrit duke automatizuar punen e operatorit. Per te mundesuar nje
automatizim te tille duhej qe programistet te parashikonin:
– vendosjen e programeve ne kujtese duke filluar nga e njejta adrese XXXX ne RAM
– komanden e pare te programit te vendosir ne te njejten adrese YYYY ne RAM
– komanden e fundit te programit [GOTO 0000] per te realizuar “kercimin” e procesorit ne
adresen zero, pra rifilimin e punes ne makinen X2.
Programet me te dhenat perkatese renditeshin ne te njejtin shirit ne forme “treni”, te ndare nga njeri
tjetri nga karakteri special i ndalimit.
Koncepti i trenit te puneve
Operatori vendoste ne fillim te dites te punes shiritin ne paisjen e leximit dhe leshonte makinen ne
pune duke filluar nga adresa zero. Makina lexonte programin e pare me te dhenat perkatese, e
ekzekutonte duke mbaruar me [GOTO 0000], pra duke “kercyer” ne adresen zero pe rte rifilluar
leximin e programit pasardhes ne”trenin e puneve”. Nderhyrja e operatorit ishte e pa nevojshme
deri ne mbarimin e puneve ne shirit.
Kosto e paisjeve te pergatitjes te shiritave dhe e shtypit te te dhenave nga shiriti ishin me kosto
relativisht te ulet, dhe mund te perdoreshin disa prej tyre ne paralel per te optimizuar shfrytezimin e
procesorit duke rritur kohen e punes te tij.
11
koha
Pune procesori
Pune pergatitje
Shfrytezimi procesorit duke “paralelizuar” pergatitjen
Vendosja e komandave ne kujtese behej sipas nje skeme si me poshte.
addr RAM Treni i puneve
0000 READ_TAPE
STORE XXXX
GOTO YYYY
XXXX
YYYY
GOTO 0000
Treshja e komandave [READ_TAPE][STORE][GOTO YYYY] mund te konsiderohet si
“embrion” i sistemit te shfrytezimit. Ne rast se keto komanda to te ishin te regjistruara ne nje
kujtese te tipit ROM, pra te mos fshiheshin nga nderprerja e energjise ne makine, do te shmangej
nderhyrja e operatorit ne konsolen e komandimit. Nese programet dhe te dhenat do te mund te
12
regjistroheshin paraprakisht (ne nje fare menyre) ne nje kujtese te jashtme me kapacitet te madh, do
te mund te shmangej nderhyrja e operatorit edhe me vendosjen dhe heqjen e shiritave nga paisja e
leximit (ne rastin e makines X2 kompilatori i gjuhes ALGOL60 ishte i regjstruar ne nje cilinder
magnetik te perhershem, dhe operatori punonte vetem me shiritat e perdoruesve).
Shmangia e nderhyrjeve te vazhdueshme te operatorit ne punen e makines solli si lehtesimin e
procedurave te punes dhe shfrytezimin relativisht te mire te kohes te punes te procesorit, duke i bere
keto makina (qe kishin ate “embrion” sistemi shfrytezimi) te perdorshme jashte laboratoreve
speciale – ne industri dhe banka. Por perdorimi jashte laboratorit i kompjuterave snxori ne dukje
probleme te reja qe nxiten zhvillimin e sistemeve te shfrytezimit tej shkalles embrionale.
KUPTIMI I MULTIPROGRAMIMIT
Kompjuterat ne Industri dhe Banka
Perdorimi i kompjuterave ne industri dhe banka ndori ne dukje diferencat midis problemeve
inxhinerike dhe ekonomike:
– problemet inxhinerike karakterizoheshin nga shume llogaritje me pak te dhena
– problemet ekonomike karakterizoheshin nga pak llogaritje me shume te dhena
Kjo difference ndikonte ne shfrytezimin e kohes se punes te procesorit – paisje teper e kushtueshme
per ato vite. Kujtesa RAM mbetej e kufizuar si rezultat i kufizimit te hapesires te adresimit te
procesorit (gjatesia e regjistrit te adresave) dhe kosto e larte e elektronikes perkatese. Si pasoje
bankat duhej te mbanin te dhenat ne kujtesa te jashtme (shirit magnetik) qe procesori i lexonte dhe
perpunonte pjese-pjese. Kujtesat e jashtme ishin (si dhe sot disqet magnetike) paisje elektro-
mekanike dhe si te tilla kishin shpejtesi pune teper te vogel krahasuar me procesoret. Si perfundim
shfrytezimi i kohes te procesorit krahasuar me kohen e hyrje-daljeve me kujtesat e jashme ishte per
te dy kategorite e problemeve i ndryshem:
– ne problemet inxhinerike dominonte koha e procesorit
– ne problemet ekonomike dominonte koha e shkembimeve me kujtesat e jashtme
13
shfrytezimi i kohes ne problemet inxhinerike
shfrytezimi i kohes ne problemet ekonomike
Krahas problemit ekonomik te shfrytezimit te kohes te procesorit ne bankat, perdoruesit kishin dhe
kerkesa te tjera:
– ne perpunimet qe kerkonin kohe procesori perdoruesit qe kerkonin pak kohe pune duhej te
prisnin kohe relaitivisht te gjate deri sa makina te mbaronte ekzekutimin e proogramit te
rradhes nese ky i fundit zgjaste shume
– ne perpunimet qe shfrytezonin shume te dhena procesori duhej te ishte i lidhur paralelisht
me disa paisje kujtesash te jashtme apo paisje te tjera per hyrje / dalje te dhenash
– ne problemet inxhinerike perdoriesit interesoheshin edhe per daljen e rezultateve ne menyre
grafike
– filloi te rritej interesi per shkembimin e te dhenave midis kompjuterave (rrjetat)
– etj.
Kjo teresi problemesh detyroi inxhineret ti kushtonin rendesi zhvillimit te sistemeve te shfrytezimit,
duke filluar me multiprogramimin.
14
koha
Pune procesori
Komunikim me periferik
koha
Pune procesori
Komunikim me periferik
Multiprogramimi dhe Ndarja e Kohes
Koncepti i multiprogramimit eshte i thjeshte – per sa kohe procesori pret te kryhet nje shkembim
me nje periferik te ngadalshem, ai mund te punoje per nje program tjeter.
Duke supozuar qe makina ka vetem nje procesor, vetem nje program mund te jete ne ekzekutim.
Programet e tjere ne kujtese mbeten ne gjendje pritjeje – per komunikim me periferiket ose per
kohen e procesorit. Sistemi i shqrytezimit ne kete mes luan rolin e drejtuesit duke percaktuar kush
program ka rradhen e ekzekutimit:
Prog.1 ...
Prog.2 ...
Prog.3 ...
Prog.4 ...
Sistem ...
Ku:
Ne gadishmeri
Ne pritje duke kryer shkembime me periferiket
Ne pune (ne procesor)
Nje paraqitje tjeter grafike e procesit te ekzekutimit te programeve njeri pas tjetrit eshte si ne figure:
15
Kur nje program kerkon te
komunikoje me nje periferik (gje qe
zakonisht zgjat shume krahasuar me
shpejtesine e procesorit), duhet ti lere
vendin nje programi tjeter te vazhdoje
ekzekutimin ne procesor. Me kete rast
vlerat e regjistrave te procesorit duhet
te regjistrohen diku, per tu rivendosur
kur programit qe nderpritet ti vije
rradha per te vazhduar ekzekutimin.
Per programin qe i “ze vendin” ne
procesor atij qe nderpritet, do te duhet
qe vlerat e regjistrave te rivendosen
ne procesor per te mundesuar
vazhdimin e punes aty ku ishte
nderprere.
Gjithashtu duhet te zgjidhet per ekzekutim njeri nga programet ne gadishmeri. Organizimi i punes
per keto veprime behet nga nje program i specializuar – sistemi i shfrytezimit duke perdorur
mekanizmin e nderprerjeve (interrupt / interrupt request (IRQ)).
Ne kuptimin e muliprogramimit nderprerja e ekzekutimit te nje programi behet kur ky i fundit
kerkon te komunikoje me periferiket. Nje moment i tille eshte i pa parashikueshem, pavaresisht nga
intensiteti i komunikimeve te tilla.
Per te standartizuar punen dhe per ti dhene cdo programi nje mundesi ekzekutimi ne “paralel” me
programet e tjera, u perdoren nderprerje shtese te gjeneruara nga ora (clock) e procesorit. Ne
parametrat e harduerit percaktohet nje “kuant” kohe (disa milisekonda (?)), dhe procesori mer sinjal
nderprerje per cdo mbarim te ketij intervali. Ne kete menyre mundesohet riciklimi ne procesor i tere
programeve njeri pas tjetrit pa pritur qe ndonje prej tyre te “kujtohet” te nderprese vehten (duke
kerkuar komunikim me periferiket). Por ka dhe situata kur, per vete natyren e procesit llogarites, nje
cope kodi e programit nuk mund te nderpritet – kemi te bejme me te ashtuquajturin “seksion kritik”.
Ky mekanizem njihet si “time sharing” per tu dalluar nga kuptimi i pergjithshem i
multiprogramimit.
16
Mbi Sistemin e Nderprerjeve
Mund te mendohet se sistemi i shfrytezimit kryen tere organizimin e punes, por kjo ide ka nje
problem – kush do te organizoje shkembimin e vlerave te regjistrave per vete sistemin e
shfrytezimit (???). Ky problem zgjidhet nga mekanizmi i nderprerjeve te procesorit:
– nderprerje hardueri, qe kryhen nga sinjale qe procesori mer nga jashte
– nderprerje softueri, qe shkaktohen nga komanda te vecanta te procesorit
Nderprerjet shoqerohen edhe nja nje numer qe sherben per kategorizimin e tyre. Kur procesori mer
nje nderprerje, hardueri kryhen dy veprime
– regjistron vlerat e regjistrave te procesorit ne nje stive te posacme
– realizon nje kercim (JUMP) ne nje adrese te caktuar (duke perdorur numrin e IRQ si indeks)
Adresat e kercimit jane te renditura diku ne nje zone te parapercaktuar fikse ne kujtese – vektori i
nderprerjeve. Ne keto adresa ndodhen procedurat qe duhet te ekzekutohen per trajtimin e
nderprerjeve.
Mund te mendojme se kur makina fillon punen, programi i pare qe ngarkohet ne kujtese eshte
sistemi i shfrytezimit, ky i fundit vendos ne vektorin e nderprerjeve adresat e procedurave te veta
per trantimin e nderprerjeve.
Nje program ne ekzekutim kerkon komunikim me nje periferik nepermjet nje nderprerjeje softuer.
Procesori automatikisht nderpret punen duke kaluar ne ekzekutimin e procedures pergjegjese per
nderprerjen, pra kontrolli i procesorit i kalon sistemit te shfrytezimit. Ndersa nderprerjet harduer
mund te vijne ne procesor nga kontrolloret e paisjeve periferike dhe ne kete rast duhen aktivizuar
procedurat per komunikimin me keto paisje.
17
Mund te ndodhe qe gjate ekzekutimit te procedures te nje nderprerjeje IRQ1 te ndodhe nje
nderprerje e dyte IRQ2. Makines mund ti duhet te nderprese ekzekutimin e procedures te IRQ2 dhe
te filloje proceduren per IRD2. Gjate ekzekutimit te procedures te IRQ2 mund te vije kerkese per
nderprerje te re IRQ3 dhe perseri makines mund ti duhet te nderprese proceduren e IRQ2 dhe te
filloje ate te IRQ3...
Ketu ka vend per disa komente.
Jo te tera nderprerjet jane te te njejtes rendesi/perparesi, pra nese gjate trajtimit te nje nderprerjeje
vjen nje nderprerje me perparesi me te ulet, trajtimi per te duhet te prese. Jo cdo cope kodi qe eshte
ne ekzekutim kur vjen nje nderprerje mund te nderpritet – "seksionet kritike" nuk duhet te
nderpriten pavaresisht nga kerkesat per nderprerje, per shembull.
Kalimi i vlerave te regjistrave te procesorit ne stive dhe anasjelltas nga stiva ne procesor realizohet
nga hardueri, programisti mund te nderhyje vetem ne logjiken e trajtimit te nderprerjeve duke
prekur kodet e procedurave perkatese si pjese e sistemit te shfrytezimit.
Stiva e permendur me siper i sherben direkt harduerit te procesorit per ruajtjen e vlerave te
regjistrave te nderprerjeve dhe per te qene sa me afer tij ajo mbahet ne elektroniken e procesorit
(ndryshe nga stivat e programeve qe mbajne parametrat e procedurave qe therrasin njera tjetren dhe
ndodhen ne kujtesen e kompjuterit).
Komandat e harduerit qe realizojne komunikimin me periferiket ekzekutohen nga procesori duke u
mbeshtetur ne BIOS, ku ndodhen informacione mbi specifikat e harduerit (firmuer / shtrese
abstraksioni qe fsheh harduerin).
18
...
STACK
PROCregisters
IRQ1 registers
IRQ2 registers
Program "PROC" IRQ1 IRQ2 IRQ3 IRQ2 IRQ1 PROC ...
IRQ1 IRQ2 IRQ3
Problematika e Sistemeve te Shfrytezimit
Pershkrimi i dukurive qe ndodhin ne kumpjuter gjate realizimit te ndarjes te kohes midis disa
programeve kerkon automatizimin e disa gjerave:
– administrimi i ndarjes te kujteses – leximi i disa programeve dhe vendosja e tyre ne zona te
vecanta ne kujtese
– mbrojtja e kujteses – pengimi i nje programi te preke zonat e kujteses te programeve te tjere
– mundesia e shkembimit te te dhenave midis programeve
– administrimi i rradhes te ekzekutimit te programeve – kur nje program ne ekzekutim duhet
te prese shkembimin me nje periferik, kur nga programet e tjere qe ndodhen ne kujtese duhet
te vazhdoje ekzekutimin
– organizimi i te dhenave (perfshi programet) ne kujtesat e jashtme ne forme skedaresh te
dallueshem nga emri
– mbrojtja e skedareve – pendimi i nje programi / perdoruesi te preke skedaret e te tjereve
– administrimi i komunikimit te procesorit me paisjet e shumellojshme periferike
– administrimi i komunikimit midis kompjuterave
Kjo teresi detyrash nuk mund te realizohej nga ato pak komanda qe u trajtuan ne kapitullim e
mesiperm. E thene me pak fjale, u be i nevojshem ndertimi dhe perdorimi i sistemeve te
shfrytezimit qe:
– fshehin kompleksitetin e harduerit dhe softuerit
– drejtojne punen e perberesve te kompjuterit sipas rregullave te percaktuara
– sherbejne si nderfaqes midis perdoruesit dhe burimeve te kompjuterit
Ne kuadrin e detyres te fundit – nderfaqimi me perdoruesin, eshte dhe ofrimi i mundesise per
perdoruesit te mbajne programet dhe te dhenat e tyre ne nje kujtese te jashtme. Kjo kerkon edhe
mndesine per perdoruesin te zgjedhe lehtesisht programin qe do te ekzekutoje.
Keto dy kerkesa jane kritike per lehtesine e perdorimit te kompjuterit, si per sistemet mainframe me
multiprogramim dhe per mikrokompjuterat e hershem qe punonin me monoprogramim (pa ndarje
kohe). Per kete aresye vazhdimi i studimit te sistemeve te shfrytezimit do te behet duke u nisir nga
niveli “embrional” i siperpermendur drejt sistemeve te shfrytezimit te diskut (DOS) me
monoprogramim, dhe me pas sistemeve me multiprogramim.
Skematikisht vendi i sistemit te shfrytezimit ne kompleksin harduer ~ softuer eshte si ne figure:
19
App. 1 App. 2 App. 3 App. ... App. N
Sistemi Shfrytezimit
Hardueri
Kjo figure klasike duhet te interpretohet drejt – sistemi i shfrytezimit dhe programet e perdoruesit
jane njelloj kode qe ekzekutohen ne procesor:
App. 1 App. 2 App. 3 App. ... App. N S.S.1 S.S.2 S.S....
CPU + RAM
Kontrolloret e periferikeve
Periferiket
Dallimi midis programeve te perdoruesit dhe copave te sistemit te shfrytezimit (qe ekzekutohen si
“programe” me vehte) qendron ne:
– programet e perdoruesit dhe sistemi i shfrytezimit kapin “njelloj” procesorin dhe kujetsen e
brenshme RAM (sistemi i shfrytezimit me perparesi ndersa programet e perdoruesve me
kufizime)
– programet e perdoruesit duhet ti kerkojne ndihme sistemit te shfrytezimit per te realizuar
komunikimin me periferiket
Evolucioni i Sistemeve te Shfrytezimit dhe Hardueri
Sistemet e shfrytezimit linden nga nevoja per te shfrytezuar sa me mire procesorin – pjesa qendrore
e kompjuterit te hershem dhe me kosto shume te larte, nderkohe qe paisjet periferike qe mundesonin
lidhjen me perdoruesit ishin me kosto te ulet dhe mundesonin disa perdorues njeheresh ne
“parallel”. Zgjidhja ishte tek ndarja e kohes te procesorit midis disa programeve.
Shpikja e mikroprocesorit me kosto shume te ulet mundesoi ndertimin e mikrokompjuterave
personale dhe “zhvleresoi” kerkesen per pune “paralele” te disa programeve. Por vetem
perkohesisht – me rritjen e kapaciteteve (frekuenca e ores te procesorit dhe kapaciteti i kujtesave) u
pa me interes kalimi ne multiprogramim edhe per mikrokompjuterat (zhvillimi i MS-Windows,
Unix / Linux / FreeBSD).
20
Vitet e fundit rritja e frekuences te ores te procesorit eshte bere gjithnje e me e veshtire. Por meqe
sistemet aktuale jane me multiprogramim, rritja e shpejtesise te punes te kompjuetrit realizohet edhe
nepermjet rritjes te numrit te procesoreve, duke mundesuar qe programet e vecante te ekzekutohen
realisht ne paralel ne procesore te ndryshem. Shtimi i procesoreve ne nje sistem kompjuterik eshte i
veshtire ne vetvete, pasi lidhet me ndryshime te gjithe skemes elektronike te kompjuterit. Per
shmangien e kesaj veshtiresie jane ndertuar procesore “multi-berthame (core)” me shume njesi
perpunuese brenda tyre. Praktikisht kompjuterat e sotem ne treg jane me te pakten dy berthama, qe
jo vetem shpejton punen e komputerit por krijon mundesi per perdoruesit te punojne edhe me
algoritme paralele.
Normalisht ne nje sistem multi-core programet ndahen ne grupe “paralele” (ne kuptimin e
multiprogramimit) dhe brenda nje grupi konkurojne per kohen e berthames perkatese. Berthamat
brenda nje procesori konkurojne midis tyre per shfrytezimin e perberesve te perbashket te
procesorit, kujtesat cache dhe per komunikim me BUS.
Per lehtesimin e komunikimit me periferiket elektronika e kujtesave te brenshme RAM eshte
plotesuar me mekanizmin DMA (Direct Memory Access), qe i mundeson periferiket te shkembejne
te dhena me zona (buffer) te paracaktuara ne RAM pa nevojen e ndermjetesise te procesorit.
Procesori dhe periferiket komunikojne midis tyre me ndihmen e nderprerjeve per te sinjalizuar
kerkesat dhe kryerjen e tyre, si dhe konkurojne midis tyre per kapjen e BUS per shkembim te
dhenash me kujtesen RAM.
21
SISTEMET E SHFRYTEZIMIT TE DISKUTFillojme nga makina X2 dhe treni i puneve i trajtuar me siper:
Gjendja e kujteses ne kete makine do te ishte:
addr RAM Treni i puneve
0000 READ_TAPE
STORE XXXX
GOTO YYYY
XXXX
YYYY
GOTO 0000
22
YY
YY
-XX
XX
Programimi i nje Sistemi Shfrytezimi te Thjeshte
Konsiderojme makinen X2 te plotesuar me periferiket:
– tastiere per dhenien e komandave
– ekran / printer afishues afishim mesazhesh (komanda dhe
te dhena / rezultate)
– kujtese e jashtme, ku ndodhen skedaret me programe dhe
te dhena, te identifikuar me emer.
Konsiderojme skemen e punes:
– makina vihet ne gjendje pune dhe bije ne nje cikel, duke
filluar nga adresa 0000, ku pret karakteret nga tastiera
– perdoruesi shtyp ne tastiere emrin e programit qe do te
ekzekutoje
– makina rendit karakteret e mara nga tastiera ne nje buffer dhe i afoshon ne ekran
– me marrjen nga tastiera te karakterit [ENTER] makina del nga cikli i tastieres dhe tenton te
ngarkoje ne kujtese (duke filluar nga adresa XXXX) programin me emrin sipas komandes
qe ka dhene perdoruesi
– nese ky ngarkim eshte i mundur, makina ekzekuton komanden GOTO YYYY per te filluar
ekzekutimin e programit te ngarkuar.
– Supozohet se cdo program i fillon komandat ne adresen YYYY-XXXX (intervali me vije te
pikezuar ne figure), dhe se mbaron me komanden GOTO 0000
Detyra eshte te programohet nje program qe do te realizonte funskionet e mesiperme. Logjika e nje
programi te tille e shprehur ne nje gjuhe simbolike do te ishte:
L1: read_from_keyboard ( ch )store ( ch, buffer)display ( ch )if ch='<enter>' goto L2goto L1
L2: rc = search_external_file ( buffer )if rc = <error> display (“Error”)else begin
rc = load_external_file (buffer, XXXX)if rc = <error> display (“Error”)else goto YYYY
end
23
> dir
Ku: rc ~ variabel numerik per kapjen e kodit te kthimit te procedurave
ch ~ variabel karakter per kapjen e kodit ASCII nga tastiera
buffer ~ variabel string per mbledhjen e karaktereve nga tastiera duke formuar komanden
XXXX ~ adresa ne kujtese ku fillon vendosja e programit nga kujtesa e jashtme
YYYY ~ adresa ne kujtese ku ndodhet komanda e pare e programit
Ky program do te duhej te ngarkohej duke filluar nga adresa 0000 e kujteses gjate ndezjes te
makines, per shembull duke qene i regjistruar ne nje kujtese ROM.
Adresat XXXX dhe YYYY jane te fiksuara dhe te gjithe programet duhet te zbatojne “distancen”
YYYYXXXX midis fillimit te skedarit program dhe bajtit te pare te komandes nga fillon ekzekutimi
Nese duhet te shtojme disa programe te gatshme per perdoruesin, per ta ndihmuar ne listimin e
emrave te skedareve ne kujtesen e jashtme, afishimin e permbajtjes te nje skedari apo regjistrimin e
tij nga tastiera (kopjim), apo fshirjen e nje skedari, programit te mesiperm duhet ti shtojme
procedurat perkatese:
L1: read_from_keyboard ( CH )store( CH, buffer)display ( CH )if CH='<enter>' goto L2goto L1
L2: case bufferbegin
“dir”: // kodi procedures DIRTOV = load_external_ToVdisplay ( TOV )goto L1
“copy”: ... // kodi i procedures COPY...goto L1
...default:
RC = search_external_file ( buffer )if RC = <error> display (“Error”)else begin
RC = load_external_file (buffer, XXXX)if RC = <error> display (“Error”)else goto YYYYendif
endifgoto L1
endcase
24
Nje program i tille do te sherbente si “Disk Operating System” per nje mikrokompjuter te thjeshte.
Ne mikrokompjuterat e pare DOS plotesohej edhe me nje interpretues te gjuehs BASIC, gje qe
lejonte perdoruesin me te ndezur makinen te mund te punonte me kete gjuhe, te hartonte programe
dhe ti regjistronte ne kujtesen e jashtme per ti riperdorur me vone. Skema e funksionimit te makines
te paisur me sistemin DOS eshte si ne figure:
Po te detajonim dhe komunikimin e programit te perdoruesit me diskun, funskionimi do te ishte:
25
Vendosja e DOS ne Kujtese
Konsiderojme nje mikrokompjuter imagjinar te thjeshte qe punon ne monoprogramim. Gjate
ndezjes se tij ne kujtese duhet te gjendet DOS ne menyre qe CPU te mund te filloje te ekzekutimin
nga adresa zero (zupozohet se ne momentin e ndezjes Program Counter eshte zero) dhe te “kerceje”
ne adresen L1 ku fillon DOS. Ne kujtese duhet te ndodhen edhe vektoret e nderprerjeve, procedurat
per trajtimin e nderprerjeve dhe stiva perkatese, dhe qelizat per varjablat rc, ch, buffer etj.
Kodi i DOS dhe i procedurave te nderprerjeve jane te fiksuar, dhe si te tille mund te vendosen ne
nje kujtese te tipit ROM (per te mos u fshire kur makina fiket). Ndersa stivat dhe variablat kane
permbajtje dinamike te rastit dhe duhet te vendosen ne kujtese te tipit RAM.
Duke supozuar se Program Counter ne momentin e ndezjes ka vleren zero dhe se gjate ndezjes DOS
kopjohet ne nje menyre (per shembull nga ROM ne RAM) ne fillim te kujteses qendrore, mund te
perfytyrohet vendosja e DOS si ne figure:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
26
adresa KUJTESA koment
0000 goto L1 kercim ne adresen e fillimit te DOS
0001 goto Irq_1 vektori nderprerjes IRQ_1
0002 goto Irq_2 vektori nderprerjes IRQ_2
... ... ...
000n Goto Irq_n vektori nderprerjes IRQ_n
L1 read_from_keyboard(CH)
Kodi i DOS...
L2 ...
...
End DOS
Irq_1 procedure...
Kodi i procedures per IRQ_1...
return
Irq_2 procedure...
Kodi i procedures per IRQ_2...
return
... ... ...
Irq_n procedure...
Kodi i procedures per IRQ_n...
return
<stack> Zona e stives per nderprerjet
rc
Zona e varjablave te DOSch
buffer
...
xxxx
Zona e kujteses per programin e perdoruesit- zona fillon ne adresen XXXX- ne YYY eshte fillimi i komandave
yyyy ...
27
Sistemet e Shfrytezimit me Multiprogramim
Me siper u trajtua ne parim nje sistem i thjeshte shfrytezimi per mjedis monoprogramimi. Per
sistemet me multiprogramim duhet te zgjidhen nje sere detyrash komplekse, per te cilat sistemi i
shfrytezimit duhet te plotesohet me procedurat perkatese:
• Administrimi i kujteses qendrore dhe ndarja e saj midis programeve
• Administrimi i kujtesave periferike dhe sistemit te skedareve
• Komunikimi me paisjet e jashtme
• Realizimi i mundesive grafike
• Komunikimi me rrjetat
• Multiprogramimi , paralelizmi dhe konkurenca
• Mbrojtja e programeve dhe perdoruesve
• Autorizimi i perdoruesve
• Mbrojtja nga nderhyrjet e pa-autorizuara
• Evidentimi i ngjarjeve dhe i kostos
Ne kapitujt ne vazhdim do te trajtohen parimet e zgjidhjes te ketyre detyrave ne sistemet e
shfrytezimit. Praktikisht psoftueri qe u pershkrua ne seksionin paraardhes duhet te plotesohet me
procedurat perkatese. Simbolikisht pamja e kujteses do te ishte:
adresa KUJTESA koment
0000 goto L1 kercim ne adresen e fillimit te DOS
0001 Goto Irq_1vektoret e nderprerjeve IRQ_x
... ...
L1 read_from...Kodi i DOS
... ...
Irq_1 procedure...Kodi i procedurave per IRQ_x
... ...
procedure... Kodi i procedurave per administrimin e kujteses
procedure... Kodi i procedurave per multiprogramimin
procedure... Kodi i procedurave per administrimin e perdoruesve
procedure... Kodi i procedurave per I/O me periferiket (driver)
procedure... Kodi i procedurave per nderfaqesin grafik
... ...
Hapesira e kujteses per perdoruesit ...
28
MODELET E SISTEMEVE TE SHFRYTEZIMIT
Modeli i Arkitektures Monolite
Nje program mund te shikohet si bashkesi procedurash qe therrasin njera tjetren. Si i tille, nje sistem
real shfrytezimi perbehet nga nje numer i madh procedurash, qe grafikisht mundb te paraqiten me
ndihmen e nje grafi, ku nyjet perfaqesojne procedurat ndersa harqet thirrjet midis tyre:
Per nje program te perfaqesuar me nje graf te crregullt mund te thuhet se ka arkitekture monolite.
Arkitektura monolite jo vetem veshtireson kolaudimin dhe zhvillimin e metejshem te softuerit, por
sjell me vehte dhe rezikun qe ne situata te caktuara ekzekutimi te nderpritet me mesazh te tipit
“stack overflow” (derdhje e stives). Thirrjet e procedurave gjate ekzzekutimit te nje programi
realizohen duke shfrytezuar nje pjese te kujteses qe i edhte vene programit ne dispozicion si stive,
ne te cilen per cdo thirrje procedure regjistrohet nje shtrese ku vendosen adresa e kthimit, fjalet e
kujteses per parametrat e procedures, dhe fjalet e kujteses per variablat lokale te procedures (kjo
shtrese “fshihet” nga stiva kur procedura mbaron dhe ekzekutimi kthehet ne proceduren thirrese).
Thirrja e perseritur e procedurave – rekursiviteti (i kontrolluar – rezultat i programimit te nje
algoritmi rekursiv, ose i pa kontrolluar – rezultat i gabimeve ne programim) shoqerohet me rritje te
vazhdueshme te stives qe mund te shpjere ne mbushjen e zones te kujteses te rezervuar per te.
Problemi i “mbajtjes ne kontroll” te softuerit zgjidhet duke vendosur disa rregullane thirrjen e
procedurave. Me poshte do te paraqiten arkitekturat tipike te sistemeve te shfrytezimit.
Rikujtojme se per veprimet themelore arithmetike si programet e perdoruesve dhe sistemi i
shfrytezimit ekzekutohen direkt ne procesor. Vetem per veprime speciale (administrimi i kujteses,
administrimi i rradhes te ekzekutimit, komunikimi me periferiket etj.) programet e perdoruesit duhet
ti kerkojne ndihme sistemit te shfrytezimit.
Mund te supozojme se koamndat e procesorit ndahen ne dy grupe – komanda baze dhe komanda
speciale. Kur ekzekutohen programet e perdoruesit procesori mund te ekzekutoje vetem komandat
29
baze (moda “user”), ndersa kur ekzekutohen procedurat e sistemit te shfrytezimit procesori mund ti
ekzekutoje te tera komandat (moda “kernel”). Sistemi i shfrytezimit eshhte programi i pare qe
ekzekutohet kur ndizet makina, si dhe eshte ai qe lezhon per ekzekutim programet e perdoruesit. Si i
tille ka mundesi te konfiguroje procesorin te punoje ne moden “user” per perdoruesit duke
rezervuar moden e privilegjuar “kernel” per vehten.
Modelet e arkitektures qe do te diskutohen kane te bejne per marredheniet midis programeve te
perdoruesit (aplikimet) dhe procesorit ne moden “kernel” duke patur sistemin e shfrytezimit si
nderfaqes.
Modeli i Arkitektures me Shtresa
Procedurat e sistemit te shfrytezimit organizohen ne nje hierarki shtresore. Procedrat e nje shtrese
mund te therrasin vetem ato te shtreses se meposhtme.
30
SistemiShfrytezimit
VM
Aplikimi
Procedure Procedure
Proc. baze Proc. bazeProc. baze
Hardueri
thirrje te sistemit
Hardueri
Berthamae Sistemit
Aplikimet
Hardueri
Procese[mode]
Perdoruesi
Procese [mode] Sistemi
Ne kushte normale programisti mund te therrase nga programi vetem procedurat e shtreses te
siperme te sistemit. Keto procedura ofrohen te grumbulluara ne librari qe i bashkengjiten
kompilatorit per ndertimin e programit te ekzekutueshem. Programisti mund te “ngjite” kodin e
procedurave nga librarite statike ne kodin e programit te ekzekutueshem, ose mund te parashikoje
qe sistemi i shfrytezimi ti ngarkoje ato nga librarite dinamike gjate ekzekutimit.
Procedurat e shtreses se poshtme jane te pershtatura ndaj harduerit konkret, abstragojne specifikat e
ketij hardueri, dhe mund te shikohen si nje “harduer virtual” (makine virtuale) mbi te cilin ngrihet
pjesa tjeter e sistemit te shfrytezimit. Dallimi i kesaj shtrese lehteson ndryshimin e sistemit ne
varesi te ndryshimit te harduerit.
Paraqitja e mesieprme eshte e thjeshtezuar. Ne fakt ne bashkesine e procedurave te sistemeve te
shfrytezimit dallohen disa shtresa, qe shpesh paraqiten edhe ne formen e unazave. Rregulli eshte
gjithmone i njejte – thirrjet lejohen nga nje shtrese e siperme ne ate direkt me te poshtme, pa
kapercime. Per me teper mund te realizohen edhe mekanizma (procedura) speciale qe mundesojne
thirrjet e kontrolluara midis shtresave (portat e thirrjes).
Shtresa e jashtme (e siperme) e sistemit njihet edhe me emrin “guacke” (shell). Ajo sherben si
nderfaqes midis perdoruesit dhe pjeses tjeter te sistemit. Ndersa shtresa e fundit (unaza qendrore) ka
funskionet qe veprojne direkt mbi harduerin dhe njihet me emrin “berthame” (kernel).
31
Modeli i Arkitektures Klient – Server
Pa perjashtuar hierarkine shtresore te procedurave, sistemi i shfrytezimit shikohet si bashkesi
“programesh te pavarur” qe mund te qendrojne ne kujtese ne gjendje “gjumi” (server) per tu
aktivizuar kur kerkohen nga programet e perdoruesit (klient).
Ne kete rast mund te mendohet qe si
programet e perdoruesit dhe copat e
sistemit pozicionohen ne te njejtin nivel
mbi berthamen e sistemit. Por per te
perfituar sherbimet e sistemit programet e
perdoruesit (klientet) duhet ti kerkojne
ndihme, nepermjet berthames, copave
(server) te sistemit.
Ne Linux copat “server” te sistemit njihen
me emrin “daemon”.
Berthama kryen gjithashtu funskionet e multiprogramimit dhe komunikimit me harduerin. Per keto
funskione berthama i pergjigjet vetem kerkesave nga copat “server” te sistemit.
32
Aplikime
Librarite dinamike te I/O
Administrimi kujteses
Multi-Programimi
Hardueri
Administrimi i I/O me Hw
appli BERTHAMA
X
thirrjesistemi
thirrje epalejuarsistemi
porte e thirrjeste sistemit
APLIKIME
User (klient)OS (server)
CPU
mikro-berthama
proces
proces
proces
proces
proces
proces
proces
proces
thirrjesistemi
Modeli i Arkitektures me Makina Virtuale
Modeli me makina virtuale perben nje zgjerim te kuptimit te sistemit te shfrytezimit dhe perdoret
gjeresisht sot vecanerisht ne platformat “cloud”. Virtualizimi lehteson transferimin e funskioneve
nga nje harduer ne tjetrin ne rast difektesh dhe / ose rishperndarje e detyrave ne nje “cluster” per te
ballancuar ngarkesen.
Berthama e sistemit ne rastin e makinave
virtuale ekzekuton ne multiprogramim disa
“procesore” virtuale. Mbi secilin nga keta
“procesore” mund te ekzekutohet nga nje
sistem vecante shfrytezimi (sisteme te
ndryshme mbi “procesore” te ndryshem).
Per perdoruesin e njejta makine funksionon
sikur te ishin disa makina secila me sistemin e
vet te shfrytezimit.
Berthama krijon ne diskun e makines, per cdo
sistem shfrytezimi qe ekzekutohet mbi nje
procesor virtual, nje skedar hapesiren e te cilit
sistemi ne fjale e administron sikur te ishte disk fizik i vecante. Nje “disk virtual” i tille mund te
kopjohet lehtesisht nga nje makine reale ne tjetren duke transferuar keshtu funskionalitetet e
sistemit se bashku me aplikimet e instaluara mbi te.
Sistemet e vecanta te shfrytezimit mbi makinen virtuale komunikojne me harduerin nepermjet
berthames, perfhsi dhe kartat e rrjetit (nqs. ka). Per me teper mund te komunikojne njeri me tjetrin
sikur te ishin ne makina te vecanta ne nje rrjet lokal. Kjo mundeson eksperimentimin e platformave
komplekse ne nje kompjuter te vetem.
33
Hardueri (CPU)
“super” berthame
“CPU” “CPU” “CPU” “CPU”
proces
proces
proces
proces
proces
proces
OS3 OS4
proces
proces
proces
proces
proces
proces
OS1 OS2
PROCESET
Kuptimi i Procesit
Process quhet nje “cope” programi ne ekzekutim. Themi “cope” pasi nje program mund te
ekzekutohet si nje grup procesesh. Proceset jane autonome ndaj njeri tjetrit. Procedurat e sistemit te
shfrytezimit dhe programet e perdoruesit ekzekutohen si procese.
Cdo proces ka ne perdorim disa burime:
– hapesire kujtese per
‐ kodin e programit
‐ te dhenat
‐ stiva per thirrjen e procedurave
‐ “heap” per variablat me gjatesi dinamike
– struktura me atributet / parametrat / metadata te procesit
‐ PCB (Process Control Block)
‐ administrohet nga sistemi i shfrytezimit
‐ gjendet ne zonen e kujteses te rezervuar per sistemin
‐ permban:
‧ numrin identifikues te procesit (PID)
‧ tabelen me treguesit (pointer) per kujtesen e zoteruar nga procesi
‧ imazhi i regjistrave te procesorit (mban vlerat e regjistrave kur procesi nderpritet ne
kuadrin e multiprogramimit per te mundesuar rivazhdimin e ekzekutimit)
‧ treguesit per strukturat e skedareve te hapur nga procesi (File Control Block)
‧ etj.
34
Fragment i deklarimit te struktures te PCB (Tannenbaum)
Gjate fillimit te punes te kompjuterit aktivizohet procesi “rrenje” i sistemit te shfrytezimit, i cli
aktivizon proceset e tjere, perfshi procesin qe realizon “guacken” – shtresen e jashtme te sistemit qe
nderfaqon me perdoruesit. Guacka ne pergjigje te komandave te perdoruesit aktivizon proceset e
nevojshme per realizimin e komandave. Ne gjuhen C jane tipike disa procedura si fork / kill qe
perdoren per krijimin e dhe zhdukjen e proceseve.
Cdo proces zoteron nje hapesire kujtese, te ofruar nga sistemi i shfrytezimit ne momentin e
aktivizimit te procesit. Synimi i sistemit eshte te pengoje qe nje proces te nderhyje ne hapesiren e
kujteses te nje procesi tjeter.
35
fork
call
return
kill
Procesi A
Procesi B
P1
P2 P8 Pd
P9 Pe
Pa
Pb Pc
P5
P6 Pf
PgP7
struct proc { struct stackframe_s p_reg; /* process' registers saved in stack frame */ proc_nr_t p_nr; /* number of this process (for fast access) */ struct priv *p_priv; /* system privileges structure
*/ char p_rts_flags; /* sending, receiving, etc.
*/ char p_misc_flags; /* Flags that do suspend the process
*/ char p_priority; /* current scheduling priority
*/ char p_max_priority; /* maximum scheduling priority
*/ . . .
Kufizimi i procesit brenda hapesires vetiake te kujteses rezultoi nje pengese per ekzekutimin e nje
programi si nje grup procesesh paralele ne sistemet multi-procesor. Per shmangien e ketij problemi
perdoret kuptimi i thread – procese qe perdorin te njejten hapesire kujtese:
Thread si dhe procedurat, krahas hapesires “globale” te kujteses ne dispozicion, mund te kene edhe
zona kujtese private (variablat lokale).
Vendi i nje procesi ne sistem jepet ne figure:
Sistemi i shfrytezimit administron bashkesine e proceseve nepermjet tabeles te PCB-ve ne kuadrin e
multiprogramimit, duke i aktivizuar me rradhe per ekzekutim ne procesor. Parimi baze i rradhes
eshte standardi FIFO (First In First Out) dhe njihet me emrin “Round Robin”:
36
proces
thread
1 proces = 1 thread 1 proces = n thread
Mund te konceptohet nje mekanizem qe realizon nderprerjen e nje procesi per ti elne vendin nje
procesi tjeter ne CPU.
Nga sa eshte thene me siper, dime qe mekanizmi i multiprogramimit – versioni i “kohes se ndare
(time sharing)” - kontrollohet nga nderprerjet e gjeneruara nga ora (clock) e harduerit. Sistemi i
shfrytezimit fillon punen si nje proces i vetem, dhe ne kete rast nuk ka nevoje per multiprogramim.
Gjate punes te ketij procesi fillestar mund te konfigurohet procesori duke percaktuar intervalin e
kohes per cdo proces dhe duke aktivizuar harduerin e ores per gjenerimin e nderprerjeve.
Me “mbritjen” ne procesor te nderprerjes te ores, qe sinjalizon se procesi ne ekzekutim e ka
mbaruar intervalin e kohes te CPU dhe duhet ti leshoje vendin nje tjetri, vepron hardueri i
procesorit:
– kopjon regjistrat e procesorit ne stiven e procesorit
– kryen nje thirrje indirekte nepermjet vektorit te nderprerjes ne kujtese te procedures qe
tajton nderprerjen e kohes
Procedura e trajtimit te nderprerjeve te kohes therret proceduren e sistemit te shfrytezimit te
ngarkuar me trajtimin e multiprogramimit, e cila:
37
– kopjon kopjen e regjistrave te procesorit nga stiva e procesorit ne PCB e procesit qe u
nderpre
– zgjedh procesin e pare ne rradhen e proceseve qe presin per kohen e CPU dhe kopjon kopjen
e regjistrave te procesorit nga PCB e ketij procesi ne stiven e procesorit (duke zevendesuar
kopjen e regjistrave te procesit qe u nderpre)
– kryen “RETURN” ne proceduren e nderprerjes te kohes.
Procedura e nderprerjes te kohes vazhdon ekzekutimin duke kryer daljen nga trajtimi i nderprerjes,
veprim qe kryhet nga hardueri qe kopjon kopjen e regjistrave (tashme vlerat i perkasin procesit qe
do te filloje ekzekutimin) nga stiva e procesorit ne regjistrat e procesor. Ne kete menyre ndryshohet
dhe vlera e “program counter” qe tashme shenon ne kodin e procesit qe fillon ekzekutimin. Vetiu
ekzekutimi vazhdon tek kodi i procesit te ri.
Gjendjet e Procesit
Karakteristika e mjedisit ne multiprogramim eshte ekzistenca e disa proceseve ne kujtese, por ne nje
makine me nje procesor vetem njeri prej tyre mund te jete ne ekzekutim. Normalisht proceset e tjere
duhet te presin rradhen per te kaluar ne ekzekutim ne procesor, dhe ndoshta ndonjerit prej proceseve
i duhet te prese per te kryer shkembime (I/O) me paisjet periferike (qe pergjithesisht kane shpejtesi
te ulet). Kemi keshtu bashkesine e gjendjeve te mundeshme te nje procesi:
• Planifikim (scheduled) – sistemi (“guacka”) ka mare komanden e perdoruesit por nuk e ka
leshuar procesin perkates
• Gati (ready) – procesi pret per kohen e CPU
• Ekzekutim (running) – procesi kontrollon CPU
• Bllokuar / pritje (blocked / waiting) – procesi pret nje ngjarje I/O
• Fundore (terminated) – procesi ka mbaruar dhe sistemi pritet te liroje zonen perkatese te
kujteses
Ndryshimi i gjendjeve behet nga procesi “supervizor” i sistemit te shfrytezimit sipas rregullave:
38
RUN READY
WAITING
2
3
4
1Scheduled.
5
6Terminated
1. Kalimi 1 behet kur procesi i kerkuar nga perdoruesi futet ne rradhen e pritjes per ekzekutim
2. Kalimi 2 behet ne kuadrin e ndarjes te kohes te komanduar nga nderprerjet qe gjenerohen
nga ora (clock) e procesorit (procesi ka plotesuar kuoten e rradhes te kohes ne CPU)
3. Kalimi 3 behet nga supervozori i sistemit kur procesori lirohet gjate multiprogramimit dhe
duhet aktivizuar nje nga proceset e nderprere
4. Kalimi 4 behet kur procesi nuk mund te vazhdoje per shkak te nje ngjarjeje (kerkese per
hyrje-dalje, nderprerje nga jashte, krijim situate bllokimi ...)
5. Kalimi 5 behet kur mbaron kushti i kalimit (4) (perfundon hyrje-dalja, perfundon trajtimi i
nderprerjes, perfundon situata bllokuese ...)
6. Kalimi 6 behet kur mbaron ekzekutimi i procesit dhe pritet lirimi i kujteses perkatese.
Nese ne gjendjen RUN mund te jete vetem nje proces (makina me nje procesor), ne gjendjet e tjera
mund te jene shume procese qe duhet te vendosen ne rradhe pritjeje. Cdo gjendje ka rradhet e veta,
te vendosura ne hapesiren e kujteses dhe te administruara nga sistemi i shfrytezimit:
Politikat e Rradheve
Skema me e thjeshte e administrimit te rradheve eshte ajo FIFO e realizuar nga mekanizmi Round
Robin, qe i trajton proceset si “absolutisht” te barabarte. Kjo barazi “absolute” mund te krijoje
probleme me optimizimin e perdorimit te burimeve te kompjuterit – disa procese mund te jene per
probleme kritike qe kerkojne perparesi (proceset e berthames te sistemit dhe ndoshta nje pjese e
proceseve te perdoruesit). Per shembull, nese jane aktive nje proces interaktiv qe shumicen e kohes
eshte ne pritje te komandave te perdoruesit dhe nje proces batch (jo interaktiv) qe kerkon shume
kohe ne procesor, ky i fundit mund te krijoje ngadalesi ne procesin interaktiv; ne kete rast ulja e
39
perparesise te procesit batch nuk e pengon te ekzekutohet nderkohe qe nuk pengohet as ai
interaktiv.
Futja e kuptimit te klasave te proceseve me perparesi te ndryshme kerkon qe gjendja READY te
lidhet me disa rradhe pritjeje per cdo klase. Politikat e mundeshme te administrimit te klasave jane
te shumellojta:
– drejtesia – cdo proces te mare pjesen e vet te barabarte te kohes se CPU
– eficensa – CPU te shfrytezohet 100%
– koha e pergjigjes te minimizohet per perdoruesit interaktve
– koha totale e punes te minimizohet
– percueshmeria (numrii i puneve) te maksimizohet
Optimizimi nderlikohet edhe nga fakti qe sjellja e proceseve eshte e paparashikuar. Si rjeddhoje
perdoren dy mekanizma per administrimin e perparesive:
• “Plotesues” [completion]
• “Parashikues” [preemptive]
Sic u dha me siper, Round Robin synon ti jape cdo procesi sipas aprimit FIFO nje interval kohe te
barabarte ne CPU:
Madhesia e ketij intervali – kuanti i kohes zakonsiht merret i rendit 100 ms.
Ne rastin e klasave te perparesive, cdo klase ka rradhen e vet qe administrohet nga Round Robin.
40
P1
P0P9 P8 P7
P6
P2 P3 P4 P5
Perparesia 0
Perparesia 1
Perparesia 2
Perparesia x
P01 P02
P11 P12 P13
P21 P22 P23
Px1 Px2
P23
Klasat e perparesise mund te jene statike ose dinamike. Si rregull nuk keshillohet ndryshimi i
perparesise te ndonje procesi, sidomos per proceset e sistemit; vetem ne raste te vecanta mund te
jete me interes te zvogelohet perparesia e ndonje procesi perdoruesi per te lehtesuar interaktivitetin
me sistemin. Ne Ms_Windows perparesia e proceseve mund te ndryshohet nepermjet
Task_Manager, ndersa ne Unix/Linux mund te perdoret komanda nice .
Dinamizmi i perparesive realizohet ne menyra te ndryshme:
• Zvogelimi gradual i perparesise (problematike per proceset interaktive)
• Perparesi punes me te shkurter (nese mund te parashikohet koha)
• Trajtimi i komandave ineraktive si pune te vecanta (parashikimi i kohes sipas sjelljes)
• Manaxhimi me “llotari” (duke perdorur llotari shtese per proceset perparesore dhe duke
qarkulluar llotarite midis proceseve)
Nje menyre e thjeshte per trajtimin e perparesive eshte administrimi me dy nivele, duke vendosur
nje pjese te proceseve [me perpari te ulet] ne disk per lirimin e kujteses. Supervizori ndan kohen e
CPU per proceset ne kujtese. Periodikisht proceset qe kane shume kohe ne kujtese kalojne ne disk
dhe proceset me shume kohe ne disk kalojne ne kujtese. Supervizori punon ne dy nivele perparesie,
me nnivel te ulet per proceset ne kujtese dhe me nivel te larte per shkembimin e proceseve midis
diskut dhe kujteses.
Si rregull, Supervizori nuk konsideron specifikat e perdoruesve ne trajtimin e perparesive dhe vete
mekanizmat e supervizorit ndahe nga politikat e dhenies perparesi proceseve nga perdoruesi.
Konkurenca e Proceseve
Hardueri dhe berthama e sistemit te shfrytezimit u ofrojne funksionalitete ~ burime proceseve te
ndryshme. Ne varesi nga karakteri i nje burimi, mund te pranohet ose jo kapja e tij njekohesisht nga
disa procese. Shembull tipik i nje burimi qe nuk mund te kapet njekohesisht (nuk mund te ndahet)
midis dy proceseve eshte printeri, per me teper ky burim eshte elektromekanik teper i ngadalte, nese
kapet nga nje proces per nje kohe te gjate te tjereve mund tu duhet te bllokohen ne pritje.
Konkurenca midis proceseve shfaqet me situaten e gares per kapjen e burimeve te perbashketa
(shared), kur disa procese kerkojne “njekohesisht” kapjen e te njejtit burim. Nese nje proces e ka
kapur nje burim, ka vend pyetja “a lejohet nderprerja e nje procesi qe ka kapur burimin?”
Pergjithesisht duhet te shmangen rastet kur mosnderprerja e procesit te zgjase sa kohezgjatja e vete
kapjes, pasi kjo do te bllokonte ne prijte te tejzgjatur proceset e tjere. Logjika qe perdoret eshte
41
burimi te “kycet” kur kapet nga nje proces dhe te “c'kycet” kur lirohet prej tij. Por vete grupi i
komandave te procesorit qe realizon kycjen dhe c'kycjen e nje burimi duhet te mos nderpritet, pasi
mund te shkaktohet perplasje e dy proceseve duke i prishur punen njeri tjetrit. Copat e kodit te
programit qe nuk lejojne nderprerje quhen seksion kritik. Ne percaktimin e nje seksioni kritik nuk
behen supozime per shpejtesine e CPU. Nuk lejohen dy procese njekohesisht ne seksion kritik,
proceset jashte seksioneve kritike nuk duhet te bllokojne proceset ne seksione kritike, dhe asnje
proces nuk duhet te prese pambarim per te hyre ne seksion kritik.
Me shembullin e printerit mund te sqarohet mekanizmi qe shmang perplasjen e proceseve ne kete
paisje – proceseve nuk u lejohet te komunikojne direkt me printerin por me nje proces te vecante te
sistemit, i quajtur spooler. Spooler mbledh rezultatet e printimit nga proceset e ndryshme ne nje
rradhe pritjeje (pjeserisht ne kujtese dhe pjeserisht ne disk), duke mos i penguar te vazhdojne
ekzekutimin, dhe ne menyre te pavarur dergon rezultatet ne printer kur krijohet mundesia (printeri
gati per pune dhe i lire):
Proces A ====== ............... ............... ====== ............... ............... ====== ............... ...............
Proces B ............... ====== ............... ............... ====== ............... ............... ====== ...............
Proces C ............... ............... ====== ............... ............... ====== ............... ............... ======
Spooler
Printer
Administrimi i rradhes te spoolerit behet nga procesi perkates i sistemit. Por per te ilustruar
problemin e konkurences te proceseve mund te supozojme per nje moment se cdo proces i
regjistron vete te dhenat ne nje bllok te lire te spoolerit. Per kete procesi A fillimisht duhet te gjeje
bllokun e pare te lire, dhe me pas te filloje shkrimin ne te te te dhenave. Nese ne momentin midis
ketyre dy veprimeve ndodh nje nderprerje multiprogramimi nga ora (clock) e procesorit, procesi A
duhet te nderpritet per ti lene vend procesit B. Nese procesi B do te shtype ne spooler kerkon
bllokun e pare te lire dhe gjen po ate qe qe kish gjetur procesi A (procesi A e gjeti bllokun por nuk
arriti ta “kyce” pasi u nderpre). Me tej procesit A i rivjen rradha per ekzekutim dhe vazhdon aty ku
ishte nderprere – shkrimi ne bllokun qe e quan te lire, por qe tashme eshhte perdorur nga procesi B
duke i prishur ketij te fundit punen e bere:
42
Zgjidhja e problemit te perplasjes te proceseve ne te njejtin burim behet me mekanizmat e
perjashtimit reciprok – proceset perjashtojne njeri tjetrin nga burimi pa cenuar multiprogramimin.
Perjashtimi Reciprok
Disa nga mekanizmat tradicionale te perjashtimit reciprok jane:
– C’aktivizimi i nderprerjeve
– Variablat celes / flamur
– Fjetja dhe zgjimi
– Semaforet
C'aktivizimi i nderprerjeve
Mund te perdoret per mbrojtjen e proceseve ne seksion kritik.
Procesi qe hyn ne seksion kritik c’aktivizon
nderprerjet duke penguar ndarjen e kohes (qe
komandohet nga nderprerjet e gjeneruara nga
ora e sistemit), dhe ne dalje te seksionit kritik ri-
aktivizon nderprerjet.
Ky mekanizem eshhte efektiv por problematik:
– kontrolli i nderprerjeve lihet ne doren e
perdoruesit / programistit dhe mund te
Procesi A ne seksion kritik===<<<<<<<<<<<<<< clock IRQ...<<<<<<<<<<<<<< clock IRQ==IRQ OFF
43
abuzohet me te
– kohezgjatja e seksionit kritik mund te jete e
madhe duke penalizuar multiprogramimin
– nuk vlen ne sistemet multi-procesor: nje
proces qe ekzekutohet ne nje procesor mund
te bllokoje nderprerjet ne te por jo ne
procesoret e tjere ku proceset vazhdojne te
ekzekutohen dhe mund te tentojne po ato
burime si dhe procesi ne seksion kritik.
Por ky mekanizem eshte me vlere per sistemin e
shfrytezimit - per sigurimin e seksioneve kritike
te vete sistemit.
= X<<< clock IRQ==== X<<< clock IRQ==== X<<< clock IRQ=IRQ ON=<<<<<<<<<<<<<< clock IRQ...
Variablat Celes/Flamur
Burimet shoqerohen me nga nje variabel logjik i quajtur “celes” ose “flamur”. Variabli celes mer
vlerat (me mareveshje):
• celsi = 0 ~ kur burimi eshte i lire
• celsi = 1 ~ kur burimi eshte i zene.
Nje proces para se te tentoje te punoje me burimin duhet te testoje celsin, nese e gjen te “kycur”
(vlera = 1) duhet te riperserise testin deri sa burimi te “c'kycet”; nese burimi eshte i lire duhet ta
“kyce” duke bere celsin = 1, per ta “c'kycur” duke e bere celsin = 0 ne mbarim te punes me burimin.
Ky algoritem ka problem intervalin e kohes midis veprimeve te testimit te celsit dhe kycjes te
burimit – nje nderprerje e ores te sistemit per multiproogramim do te krijonte premisat e perplasjes
me ndonje proces tjeter. Bllokimi i nderprerjeve do te ishte nje zgjidhje, por duke ja ngarkuar
procesurave te sistemit te shfrytezimit manipulimin e variablit celes.
44
Perdorimi i variablit celes do te zgjidhte problemin imagjinar te perplasjes ne spooler te dy
proceseve:
45
Call set_flag(F)
Call unset_flag(F)
eksk
luzi
vite
t
F
seksionkritik
seksionkritik
unset_flag (F){ Int off F:=0 Int on}
set_flag (F){ Int off; while (F==1) { Int on; Int off }; F:=1; Int on;}
Procesi A Proces i Sistemit(berthama)
Krahasimi midis seksioneve kritike me bllokim nderprerjesh dhe me variabel celes eshte ne figure:
Mekanizmi i variablave celes eshte teper i perdorshem ne programim per te kontrolluar rrjedhen e
ekzekutimit te nje programi, por eshte problematik ne rastin e kontrollit te kapjes te burimeve –
46
Per
gatit
:
Bllo
kim
: cel
esi:=
1
Rradha e Spooler
Procesi A
Procesi Bsh
krua
n
☼
Procesi A ka ekskluzivitet mbi spooler
Seksion kritik
Lirim
: cel
esi:=
0
Procesi B ka akses mbi spooler
Int Int
procesi qe e gjen burimin e zene duhet te prese me nje cikel
while (F==1) { Int on; Int off }
Nese nder dhjete procese njeri duhet te prese ne kete menyre, humbasin 10% e cikleve te ores te
procesorit; shtate procese ne pritje do te shkaktonin 70% te cikleve te humbur. Mekanizmi duhet te
permiresohet per ti detyruar proceset te kalojne ne gjendje WAIT.
Fjetja dhe Zgjimi
Kalimi ne gjendje WAIT i proceseve qe ndeshen me burime te zena behet duke perdorur dy
procesura te sistemit per trajtimin e variablit celes:
– procedura sleep
nqs. variabli celes eshte i lire behet celsi = 1 dhe procesi vazhdon duke zene burimin
nqs. variabli celes eshhte i zene procesi kalon ne gjendjen WAIT
– procedura wakeup
variabli celes = 0
nqs. ka proces ne pritje per burimin, ai kalohet ne gjendjen READY
Procesi qe kerkon burimin therret proceduren sleep,
dhe kur mbaron pune duhet ta liroje ate me proceduren
wakeup. Duhet shpresuar qe programisti te kete
parashikuar ne menyre korrekte perdorimin e procedures
te “zgjimit”.
Ne menyre qe te perballohen disa procese ne pritje,
variabli celes duhet te shoqerohet me nje strukture rradhe
pritjeje. Si variabli celes dhe strukturat e tjera qe mund ta
shoqerojne ate gjenden ne kujtese ne zonen e rezervuar
per sistemin e shfrytezimit dhe jane te padukshme per
perdoruesin.
Model i thjeshte per procedurat e “fjetjes” dhe “zgjimit”
jepen ne figuren e meposhtme:
47
Call sleep(F)
Call wakeup(F)
F
wai
tre
ady
Ne situata reale disa procese mund te kerkojne burimin dhe te perfundojne perkohesisht ne gjendjen
WAIT. Per mbajtjen e PID te ktyre proceseve duhet nje strukture te dhenash rradhe e lidhur me
variablin flamur (ne vend te variablit te thjeshte F.PID). Mekanizmi i “fjetje/zgjimit” me rradhe
pritjeje te proceseve eshte i realizuar tek semaforet.
Forcimi i seksionit kritik eshte i domosdoshem ne proceduren sleep, pasi per kapjen e burimit
kerkohen te pakten dy instruksione te procesorit – “test” dhe “set”, qe mund te nderpriten nga
multiprogramimi duke krijuar premisa per perplasjen e dy proceseve tek burimi. Ndersa lirimi i
burimit kerkon vetem nje instruksion procesori “set” dhe ne parim nuk ka nevoje per seksion kritik.
48
Celesi eshte strukture F = {int C; int PID}Ku: C ~ celesi
PID ~ mbajtesi i identifikatorit te procesit
“sleep” kalon procesin thirres ne gjendjen “pritje”
sleep (C){
IRQ off;
// fillimi seksionit kritikif (F.C==0) // “test” i variablit flamur{
F.PID:=(PID); // procesi kalon ne WAITcall_system_state_wait(PID);// call_system_state_wait ne dalje ben “IRQ on”// per mbylljen e seksionit kritik
} // vazhdimi i ekzekutimit me lirimin e burimit
F.C:=0; // “set” i variablit flamur// fund i seksionit kritik
IRQ on;}
“wakeup” zgjon procesin e rene ne gjendje “pritje”
wakeup (C){
IRQ off;F.C:=1; // “set” i variablit flamurif (F.PID!=NULL) call_system_state_ready(F.PID);IRQ on;
}
Semaforet
Semaforet u propozuan nga Dijkstra per te shmangur problemin e teknikes sleep/wakeup, rrjedhoje
e “humbjes” eventuale te ndonje thirrjeje wakeup qe shpije ne mbetjen e proceseve ne rradhen
WAIT. Per kete variabli flamur behet i tipit integer qe numeron thirrjet e prealizuara wakeup.
Procedurat e sistemit qe perdoren per semaforet jane down dhe up.
• down (~sleep) teston semaforin
Nqs. zero => procesi kalon ne gjendje WAIT pa plotesuar “down”
Nqs. pozitive => zvogelon me 1 semaforin dhe vazhdon punen
• up (~wakeup) rrit me 1 vleren e semaforit
Nqs. ka procese ne rradhen WAIT, supervizori i sistemit “zgjon” ne gjendjen RUN te
parin prej tyre dhe e lejon te perfundoje “down”
Kodi i down eshte seksion kritik dhe si i tille kufizohet nga bllokim – c'bllokimi i nderprerjeve.
Semafori si strukture te dhenash perbehet nga numratori dhe rradha e proceseve ne WAIT.
IRQ OFF
...
IRQ ON.
Shembull
Sistem klient – server per transferim te dhenash:
‐ server mbush blloqet e nje buferi me te dhena
‐ klienti lexon blloqet e te dhenave nga buferi
‐ zgjidhja behet duke perdorur tre semafore:
‐ plot ~ numeron blloqet e mbushur te buferit (nqs. zero klienti kalon ne WAIT)
‐ bosh ~ numeron blloqet e zbrazur te buferit (nqs. zero serveri kalon ne WAIT)
‐ mex ~ semafori i perjashtimit reciprok (“mutual exclusion”)
Kodi simbolik i klientit dhe serverit do te ishte:
49
numrator
PID 1 PID 2 PID 3 PID 4
SS
klienti buffer serveri
void server(void) void server(void)
{ {
while (TRUE) while (TRUE)
{ {
down(&plot); down(&bosh);
down(&MEX); down(&MEX);
get_buffer(); fill_buffer();
up(&MEX); up(&MEX);
up(&bosh); up(&plot);
} }
} }
MEX
Klienti kerkon te lexoje ne bufer dhe ben down mbi semaforim plot, nese numratori perkates eshte
zero buferi eshte bosh dhe klienti kalon ne WAIT, nese jo klienti vazhdon dhe tenton bllokimin e
buferit per te mos u perplasur me serverin. Me mbarimin e leximit klienti c'bllokon buferin dhe ben
up ne semaforin bosh pasi faktikisht ka zbrazur nej bllok te buferit dhe ky fakt duhet te pasqyrohet
ne numratorin e semaforit.
Serveri vepron me menyre te ngjashme, para se te tentoje mbushjen e nje blloku te buferit ben
down ne semaforin bosh, nese numratori perkates eshte zero nuk ka blloqe te zbrazura dhe serveri
kalon ne WAIT, ne se jo serveri vazhdon dhe tenton bllokimin e buferit per te mos u perplasur me
klientin. Me mbarimin e mbushjes te nje blloku serveri ben up ne semaforin plot per te rritur
numratorin perkates me +1 duke pasqyruar faktin qe numri i blloqeve te mbushur u rrit.
Programimi me semaforet eshte problematik pasi nje ngaterin i rradhes te thirrjeve te tyre mundte
shkaktoje bllokime pa rrugedalje. Per shembull, ne rastin e sistemit klient – server me siper,
ndryshimi i rradhes te veprimeve nga “down(&plot); down(&MEX);“ ne “down(&MEX);
down(&plot);“ shkakton bllokim kur buferi eshte i zbrazur: klienti bllokon buferin ne MEX,
duke ndaluar serverin te nderhyje per ta mbushur ate, dhe me pas bllokohet vete ne plot; kur serveri
tenton te mbushe buferin bllokohet ne semaforin MEX pa arritur te veproje dhe te c'bllokoje
klientin.
50
plot
bosh
Sinkronizimi i Proceseve
Nga te tre semaforet ne shembullin e mesiperm, dy perdoren per sinkronizim midis dy proceseve
klient dhe server, ndersa vetem i treti per perjashtimin reciprok ne kapjen e buferit.
Mekanizem klasik per sinkronizimin e proceseve eshte shkembimi i mesazheve midis tyre. Ne
parim kjo realizohet me ndihmen e thirrjeve te sistemit send dhe receive. Mesazhet shkembehen me
ndihmen e sistemit te shfrytezimit. Procesi dergues ekzekuton send(&message) duke transferuar
mesazhin ne nje bufer te sistemit, prej nga mund te merret nga procesi dergues me thirrjen
receive(&message). Per te garantuar sinkronizimin preferohet qe ne sistem te jete parashikuar
konfirmimi i marrjes nepermjet kthimit te nje kodi pergjigjeje “ACK”; ne kete rast kur konfirmimi
vonohet sistemi perserit thirrjen send.
Mekanizmi jo vetem mundeson sinkronizimin (renditjen e ngjarjeve ne kohe ne menyren e duhur)
por dhe shkembimin e te dhenave midis proceseve.
Duke mare parasysh nje shumellojshhmeri mesazhesh qe mudn te shkembehen midis proceseve,
cdo mesazh shoqerohet me nje strukture te dhenash identifikuese, ne te cilen mund te gjendet nje
numer identifikues i mesazhit dhe nje identifikator i procesit dergues. Mundesia per procesin mares
te identifikoje (autentikoje) procesin dergues eshte kritike per sigurine e sistemit.
Bllokimet (deadlocks)
Skema klasike e dy proceseve X dhe Y qe bllokojne njeri tjetrin duke kapur “kryq” burimet tregohet
ne figure:
Kur X kerkon burimin B2 kalon ne WAIT duke mbajtur te bllokuar B1, ndersa Y tenton B1 dhe
kalon ne WAIT duke mbajtur te bllokuar B2. Situata eshte pa rrugedalje.
Shembulli klasik i situatave bllokuese eshte ai i “tryezes te filozofeve”:
51
X Y
B2
B1
wait wait
Per te ngrene spageti secili nga filozofet
duhet te perdore nga dy pirunj qe i kane ne
te dy anet e pjates, nese nuk i kane kapur
fqinjet. Filozofi mund te ndodhet ne nje
nga tre gjendjet:
• duke filozofuar (duke i lene pirunjte e
vet te lire)
• duke ngrene (duke i perdorur te dy
purinjte)
• duke mbajtur njerin nga pirunjte dhe
duke pritur lirimin e tjetrit (kur fqinji
te filloje te filozofoje)
Nje zgjidhje e problemit gjendet ne
literature me perdorimin e semaforeve.
Direktiva parbegin realizon leshimin ne
paralel te 5 thread qe perfaqesojne
filozofet. Secili pirun eshte i “lidhur” me
nje semafor fork[i]. Semafori shtese room
perdoret per te kufizuar numrin e
filozofeve ne dhome, per te lene nje vend
te lire ne tryeze si parakusht per te
shmangur bllokimin kur te tera vendet jane
te zena dhe secili nga filozofet mbetet me nje pirun duke pritur te dytin – rasti i “rrethit vicioz”.
Burimet ndahen ne dy kategori:
– Burime “te trajtueshem” (preemtable), te cilet mund tu hiqen perkohesisht proceseve qe i
kane kapur per te dale nga situata bllokuese (shembull: kur dy procese bllokojne njeri tjetrin
per mungese kujtese, njeri mund te transferohet perkohesisht ne disk – swapping – duke
liruar kujtesen per procesin tjeter).
– Burime te “pa trajtueshem” (non-preemtable), te cilet pasi jane kapur nga nje proces nuk
mund ti hiqen pa i shkateruar punen (shembull: printeri pasi ka filluar punen per nje proces
nuk mund ti hiqet pa i prishur punen).
52
Pergjithesisht bllokimet ndodhin kur proceset “pengojne” njeri tjetrin, dhe kjo dukuri shfaqet ne
disa versione. Versionet e konditave per situatat bllokuese jane percaktuar nga Coffman:
– Kryqezimi i perjashtimeve reciproke (mutual exclusion i dy proceseve)
– Kapja e burimit nga nje proces qe me tej kalon ne gjendje WAIT (hold and wait)
– Qenia e nje burimi i pa – trajtueshem (non-preemptive, printeri per shembull)
– Pritja e njeri tjetrit e disa proceseve ne “rreth vicioz” (circular wait)
Strategjite per shmangien e bllokimeve perfshijne:
– Injorimi i problemit (nqs probabiliteti i ngjarjes eshte i ulet)
– Detektimi i bllokimeve dhe rimarja (rifillimi i proceseve bllokuese)
– Shmangia dinamike (shmangia e situatave bllokuese)
– Parandalimi duke mohuar konditat qe krijojne bllokime
Injorimi i problemit rezulton nje zgjidhje inxhineriike praktike e pelqueshtme vecanerisht per
sistemet e vogla (mikrookompjuterat personale) qe mund te rileshohen pa humbje pune te medha
(nese reziku u bllokimit te sistemit eshte i krahasueshem per shembull me rezikun e nderprerjes te
energjise elektrike, atehere ai mund te mosperfillet). Por ne sistemet e shperndara bllokimet
reciproke jane nje problem real.
Detektimi i nje gjendje bllokimi mund te behet duke perdorur grafet. Algoritmet e sistemit mund te
gjenerojne nje graf ku si proceset dhe burimet paraqiten si nyje te grafit; kapja e nje burimi nga nje
proces paraqitet ne graf me nje hark te orientuar nga nyja burim ne nyjen proces (burimi i perket
procesit), ndersa kerkesat e proceseve per burimet e zena paraqiten me harqe te orientuar nga nyja
proces drejt nyjes burim (procesi kerkon burimin). Ekzistenca e cikleve ne kete graf tregon kryq-
bllokimin e proceseve tek burimet. Sistemi i shfrytezimit mund te ndertohet i tille qe periodikisht te
ndertoje grafin e lidhjeve proces – burim dhe te zbuloje ndonje bllokim te mundshem.
Proceset bllokuese mund te rifillojne nga e para, ose nga nje “pike kontrolli” (checkpoint) i
meparshem; ne piken e kontrollit sistemi ben nje “fotografi” te procesit dhe e rezervon ne disk, per
te shkangur rifillimin e procesit nga e para. Realizimi i “pikave te kontrollit” duhet te parshikohet
nga programuesi duke realizuar thirrjet perkatese te sistemit.
Shmangia e bllokimeve mund te behet ne disa menyra.
Ne varesi te shkakut te bllokimit mund te mendohen dhe mjete per zgjidhjen e tyre
53
kondita zgjidhja kondita zgjidhja
perjashtimi reciprok spooling jo-parashikuese liro burimet para kapjes
kap dhe prit kap gjithe burimet pritja rrethore rendit burimet
Perjashtimi reciprok ne kapjen e burimeve mund te shmanget duke perdorur kuptimin e spooler per
cdo burim – proceset nuk e kapin vete burimin po i dergojne kerkesat ne spooler perkates dhe ky i
fundit i realizon ato sipas rradhes, proceset kalojne ne pritje te pergjigjes nga spooler por nuk e
bllokojne ate, ndersa vete spooler duke qene i vetem para burimeve nuk ka pse bije ne gjendje
bllokimi.
Nese nuk perdoret spooler duhet te kontrollohet kapja e burimeve. Mund te praktikohet kapja e tere
burimeve ne fillim te punes te procesit eshte nje menyre tjeter per te garantuar burimet duke mos
rezikuar bllokimin gjate ekzekutimit; ne kete rast procesi qe kerkon te filloje duhet te prese deri sa
te jene disponibel te tere burimet qe ai kerkon; sistemi i shfrytezimit duhet te adminsitroje nje
rradhe pritjeje duke zbatuar politikat perkatese per proceset qe kerkojne te kapin burimet para
fillimit te punes. Ekstremi tjeter eshte lirimi i tere burimeve para se te kerkohet nje burim i ri, ne
kete rast procesi mund te kaloje ne pritje te burimit por nderkohe i ka liruar burimet e kapura duke
shmangur kryq-bllokimin me ndonje proces tjeter; por ne pergjithesi jo te tere burimet “pranojne” te
lirohen para kohe (printeri per shembull). Renditja e burimeve gjithashtu mundeson shmangien e
bllokimeve – burimet mund te kapen vetem sipas renditjes se tyre – nese burimi A eshte para
burimit B dhe A eshte kapur nga procesi P1, procesi P2 nuk mund te “kaperceje” A per te kapur B
per aq kohe sa A eshte i bllokuar dhe formalisht duhet te “prese” ne A qe ti hapet rruga per kapjen e
B te renditur pas A; per cdo burim sistemi i shfrytezimit duhet te administroje rradhet perkatese te
pritjes te proceseve.
Parandalimi i bllokimeve eshte i mundur, per shembull, duke perdorur algoritmin e bankierit
(Dijkstra). Per N procese dhe M burime, algoritmi punon mbi strukturat e te dhenave:
– vektori i “ofertes te castit” i cdo burimi [OFi]
– matrica MxN me maksimumin e kerkesave per cdo proces per cdo burim [MAXij]
– matrica MxN me numrin e instancave te cdo burimi te kapur nga cdo proces [KAPij]
– matrica MxN me numrin e kerkesave shtese per cdo burim te cdo procesi [DUAij]
Ka vend barazimi: DUAij=MAXij – KAPij
54
Supozohet qe ne fillim te punes cdo proces deklaron maksimumin e instancave te cdo burimi qe do
te kerkoje gjate ekzekutimit. Sistemi i shfrytezimit do te konsideroje gjendje “gabim” cdo kerkese
te nje procesi gjate ekzekutimit per instanca me shume nga cka deklaruar ne fillim te punes. Nese
kerkesa eshte jo me e madhe se sasia disponibel e instancave te burimit ajo mund plotesohet
ndryshe procesi duket te kaloje ne gjendjen e pritjes (wait).
Algoritmi bazohet ne supozimin se ne cdo cast sasia e instancave disponibel eshte e tille qe ekziston
nje proces te cilit mund ti plotesohen te tera kerkesat dhe ai te mbaroje normalisht duke i liruar
burimet e zena. Vetem ne kete rast gjendja e sistemit konsiderohet e sigurte.
Kur nje proces gjate ekzekutimit ben nje kerkese normale per nje burim (nuk tejkalon maksimumin
e deklaruar dhe instancat e kerkuara te burimit jane disponibel) algoritmi supozon ploetsimin e
kerkeses dhe vlereson gjendjen e sistemit per secilin nga proceset aktive; nese gjendja rezulton e
sigurte kerkesa plotesohet, nese gjendja rezulton e pa sigurte (per asnje nga proceset nuk plotesohet
mundesia te kape maksimumin e burimeve dhe te mbaroje normalisht) atehere ekziston reziku i nje
bllokimi ne te ardhmen dhe sistemi i shfrytezimit mund ta vendose procesin qe beri kerkesen ne
gjendjen e pritjes (wait) deri sa sistemi te rezultoje ne gjendje te sigurte.
55
SISTEMI I HYRJE – DALJEVESistemi i hyrje – daljeve realizon komunikimin e njesise qendrore (CPU + RAM) me paisjet
periferike. Paisjet periferike jane te shumellojshme si ne elektroniken e tyre dhe ne protokollet e
komunikimit, si pasoje lidhja e tyre ne BUS te njesise qendrore nuk mund te behet drejtperdrejt por
nepermjet qarqeve ndihmes – kontrolloret e periferikeve, qe kane detyre te pershtasin si nga ana
elektronike dhe e rregullave te komunikimit paisjet me BUS-in.
Ne varesi te menyres te komunikimit me BUS,
paisjet periferike klasifikohen si me poshte:
– paisje bllok – komunikimi behet me
blloqe karakteresh (disk, shirit, …)
– paisje karakter – komunikimi behet ne
baze karakteri (tastiera, mouse, …)
– paisje speciale (clock …)
Komunikimi midis kontrollorit dhe paisjes
perkatese eshte i vecante dhe jashte temes te
ketij kursi. Komunikimi midis kontrollorit dhe
BUS behet per shkembimin e te dhenave,
sinjaleve dhe komandave me kujtesen dhe
procesorin. Kontrollori komunikon me sinjale
me procesorin nepermjet nderprerjeve, ndersa
shkemben te dhenat dhe komandat me kujtesen.
56
CPU RAM clock control control control control
HDD
PRINTER MONITOR TASTIERE
kontrollori
RAM
busIRQ
regjistrat
regjistrat
komande
Ne kompjuterat e sotem gjenden disa kontrollore standarte per paisje si tastiera, mouse, ekrani,
porta seriale (RS232), porta paralele. Sot nje pjese e ketyre kontrolloreve jane integruar ne nje
nderfaqes te vetem USB (Universal Serial Bus). USB sherben si nje “korridor” i perbashket ku
mund te lidhen shume paisje qe perdorin se bashku te njejten nderfaqes per te shkembyer te dhenat
ne BUS, qe te mos ngaterohen me njera tjetren per cdo paisje e projektuar per tu lidhur ne USB
perdoret nje kod identifikimi te vecante per ta dalluar nga paisjet e tjera. Per paisje shtese apo
speciale duhen montuar kontrolloret perkates ne motherboard.
Ne arkitekturen e kompjuterave te sotem funksionon mekanismi i quajtur DMA (Direct Memory
Access) qe mundeson shkembimin e e te dhenave me kujtesen pa nderhyrjen e procesorit, duke
mundesuar edhe dukurine e multiiprogramimit. Me po pa DMA, per cdo tip paisje periferike ne
kujtese sistemi rezervon disa fjale qe i sherbejne per komunikimin me paisjen.
Kur sistemi kerkon te komunikoje me paisjen periferike, ai vendos ne zonen e kujteses te rezervuar
per paisjen kodin e komandes qe duhet te zbatoje paisja periferike, dhe me pas sinjalizon paisjen per
te vepruar.
Ne rastin e leximit nga paisja, kontrollori pa DMA lexon nje bllok nga paisja ne buferin e
brendshem, dergon IRQ ne procesor per te sinjalizuar sistemin, dhe ky i fundit kopjon bajt-pas-bajti
nga regjistri kontrollorit ne kujtesen e kompjuterit. Ndersa kontrollori me DMA lexon nje bllok nga
paisja ne buferin e brendshem dhe me pas kopjon buferin ne DMA (kujtesa e kompjuterit), me pas
dergon IRQ ne procesor per te sinjalizuar sistemin se blloku i te dhenave eshte ne kujtese.
Ne rastin e shkrimit ne paisje veprimet kryhen ne rradhen e kundert – sistemi vendos ne kujtesen e
dedikuar per paisjen te dhenat dhe sinjalizon kontrollorin, ky i fundit i kopjon te dhenat nga kujtesa
ne regjistrat e vet (ne rastin pa DMA me ndihmen e procesorit, ne rastin me DMA direkt nga kujtesa
ndersa procesori punon per lloagri te vet), dhe me pas i dergon ne paisje.
NE projektimin e sistemeve te shfrytezimit duhet te meret ne kosndierate plotesimi i disa kerkesa.
Sistemi duhet te jete sa me i pavarur ndaj shumellojshmerise te paisjeve, teknikat e programimit
duhet te mos varen nga lloji i paisjeve. Pper kete behet nje unifikim i emertimit te paisjeve, qe
trajtohen si “skedare speciale” dhe percaktohen nepermjet kuptimit te PATH (ne Linux per shembull
paisjet periferike dallohen si skedare ne direktorine /dev/). Sistemi dhe elektronika duhet te
sigurojne dallimin e gabimeve dhe te veprojne per ti shmangur ato duke perdorur kodet e detektimit
dhe korrigjimit te gabimeve, si dhe duke perseritur veprimet ne rastin e gabimeve te pa
korrigjueshme. Sistemi duhet te konsideroje mundesine e ndarjes te nje paisjeje midis disa
perdoruesve.
57
Per te siguruar pavaresine maksimale te sistemit te shfrytezimit nga shumellojshemria e periferikeve
perdoret kuptimi i arkitektures me shtresa te sistemit. Shtresat e siperme te sistemit duhet te jene te
pavarura nga periferiket – per to periferiket jane thjesht skedare disi speciale. Nga ana tjeter,
komunikimi me periferiket inicohet me ndihmen e nderprerjeve dhe shtresa e poshtme e sistemit
perbehet nga procedurat e trajtimit te nderprerjeve qe sherbejne thjesht si “postier”.
Per te realizuar pershtatjen e logjikes te
sistemit me ate te paisjes duhet te
konsiderohet nje shtrese ndermjetese midis
trajtuesit te nderprerjeve dhe pjeses te pavarur
te sistemit e perbere nga procedura specifike
per cdo paisje periferike – drivers. Drivers
duhet te komunikojne me pjesen e siieprme te
sistemit, te perkthejne “gjuhen” e sistemit ne
ate te paisjes,
dhe te komunikojne me vete paisjen nepermjet kontrollorit perkates.
Ne sistemet e vjeter te shfrytezimit instalimi ne harduer i cdo paisjeje duhej te shoqerohej me
instalimin e driver perkates ne sistem. Sot sistemet shoqerohen me librari te drivers per paisjet me
popullore ne treg, nderkohe qe ne disa raste eshte e nevojshme instalimi manual i drivers. Nje
lehetsi tjeter sot eshte sistemi “Plug-and-Play” - nje protokoll standart qe lejon paisjen ne momentin
e instalimit te komunikoje me sistemin dhe ta udhezoje ate per instalimin automatik te driver
perkates.
Duhet theksuar se pergjithesisht si kontrolloret edhe paisjet kane elektroniken e tyre qe funksionin
sipas nje logjike shpesh e “ngurtesuar” ne kontrollor / paisje ne formen e nje softueri – i
ashtuquajtur “firmuer (firmware)”. Ne disa raste ekziston mundesia e nderhyrjes ne firmuerin e
kontrollorit ose te paisjes, si rregull duke perdorur programe speciale te hartuara nga vete prodhuesi
i paisjes, per te instaluar versione te reja te firmuerit (keto nderhyrje duhet te behen me kujde ste
madh duke konsiltuar ne detaje dokumentacionin teknik perkates, pasi veprimet e gabuara mudn te
nxjerin paisjet jashte perdorimit).
Procesi qe kerkon te shkembeje te dhena me nje periferik mund te komunikoje drejtperdrejt me te
ose nepermjet nje spooler. Perdorimi i spooler eshte i preferueshem pasi shmanget reziku qe
proceset e eprdoruesit te bllokojne njeri tjetrin dhe komunikimi me spooler eshte i shpejte,
gjithesesi procesit normalisht do ti duhet te prese nje pergjigje:
58
User Level Software
Independent Software
Device Driver
Interrupt Handler
CONTROLLERHW
SW
OS
App
– Procesi kerkon hyrje/dalje
– dergon kerkesen ne kontrollor / spooler
– kryen down mbi semaforin perkates duke
kaluar ne gjendje pritje (wait)
… kerkesa e procesit trajtohet nga driver ...
– Kontrollori / spooler perfundon veprimin dhe
dergon IRQ ne procesor
– Trajtuesi i nderprerjes c’bllokon procesin ne
priitje duke kryer up mbi semaforin perkates
– Procesi vazhdon ekzekutimin
Driver sherben si ndermjetes midis kontrollorit dhe sistemit (procesit qe kerkon hyrje/dalje ose
spooler) duke shkembyer te dhenat ne nje format te unifikuar te pavarur nga paisja, dhe duke
organizuar shkrimin / leximin e te dhenave ne regjistrat e kontrollorit ne format specifik te paisjes.
Driver mund te prese ne semafor deri sa kontrolori te kryeje veprimin dhe riaktivizohet nga trajtimi
i nderprerjes qe dergon kontrollori.
Shtresat e sistemit te pavarura nga periferiket nderfaqojne me drivers ne menyre unike, kujdesen
per moslejimin e kapjes te paisjeve nga procese te paautorizuar, administrojne bufer te komunikimit
per te mare ne kosiderate ndryshimet ne shpejtesite e komunikimit. Administrimin e skedareve,
analizen dhe raportimin e gabimeve te diktuara nga drivers.
Perdoruesi programon duke perdorur procedura te tipit:
• write(fd, buffer, nbytes)
• read(fd, buffer, nbytes)
ku “fd” percakton PATH per tek paisja (skedari ne rastin e diskut), “buffer” zona e kujteses ku jane
te dhenat, dhe “nbytes” numri i te dhenave (bajteve). Keto procedura pershtatin parametrat e
perdoruesit per thirrjet e sistemit ne shtresat e meposhtme, formatojne mesazhet e hyrjes dhe daljes
dhe therrasin procedurat / proceset e sistemit per plotesimin e punes, ne vecanti procesin spooler.
59
process kontrollor
Send requestCall wait state
IRQSwitch to Ready
BAZAT E KOMPILIMITNje ide mbi bazat e kompilimit ndihmon te kuptohen problemet dhe zgjidhjet per administrimin e
kujteses te kompjuterit ne kushtet e multprogramimit.
Ne makinat e para qe punonin ne monoprogramim problemi i administrimit te kujteses ishte i
thjeshte – dihej qe programi do te vendosej ne kujtese duke filluar nga nje adrese e paracaktuar
XXXX dhe perdoruesi mund te programonte duke ju referuar kesaj adrese fillestare. Ne kushtet e
multiprogramimit programi dhe te dhenat mund te vendosen kudo ne kujtese dhe programimi duhet
te jete i pavarur nga vendosja konkrete e programit. Kjo pavaresi realizohet ne nivel hardueri:
– perdoruesi programon me “adresa relative” duke supozuar nje kujtese imagjinare teresisht
ne dispozicion me adrese fillestare 0000 (zero)
– programi vendoset nga sistemi i shfrytezimit ne kujtese duke filluar nga nje adrese BBBB
dhe kjo adrese fillestare mbahet ne nje “regjister baze” te procesorit
– hardueri realizon adresimin fzik ne kujtese duke e llogaritur ate sipas formules
adrese_fizike = BBBB + adrese_relative
Perdoruesi sot perdor gjuhe te zhvilluara si C, Basic, Fortran etj ne te cilat te dhenat mbahen ne
variabla simbolike, si dhe nje pjese e procedurave jane po simbolike sin(), sqrt(), printf(), strcpy()
etj (kodi i te cilave eshte diku ne ndonje librari te sistemit). Si kryhet shndrimi i ketyre variablave
simbolike ne adresa relative per tu realizuar me tej ne kompjuter? Ky proces realizohet ne disa hapa
qe kryhen nga dy programe speciale – kompilatori dhe lidhesi (linker). Ne mjediset e sotme te
programimit perdoruesi mund ti kryeje keto hapa me nje komande te vetme (build).
Kompilatori mer nga perdoruesi programin ne gjuhen e zhvilluar “burim” dhe e transformon ate ne
kod “objekt” pothuaj te ekzekutueshem – eshte i tille pasi nje pjese e adresave relative kane mbetur
pa u llogaritur. Eshte programi i dyte – lidhesi – qe lexon programin objekt, tenton te llogarite
adresat relative qe mungojne duke kerkuar variablat dhe procedurat simbolike ne librarite e sistemit,
dhe nese arrin ti “lidhe” keto simbole prodhon kodin e ekzekutueshem.
Puna e kompilatorit fillon me lexomin si varg karakteresh programi burim, dallohen fjalet kyce te
gjuhes si if, for, while dhe veprimet arithmetike e logjike nga simbolet qe perfaqesojne variabla
vlerash dhe emra procedurash, dhe ndertohet Tabela e Simboleve. Me pas kodi i programit burim
shndrohet ne gjuhe po simbolike asembler dhe llogaritet sa hapesire kujtese do te zere si kodi dhe te
dhenat. Informacioni mbi vendosjen e kodit dhe te dhenave ne kujtese pasqyrohet ne tabelen e
60
simboleve. Me pas kodi asembler transformohet ne kod binar te ekzekutueshem nga procesori, duke
zevendesuar variablat simbolike me adresat e tyre relative nga tabela e simboleve (ato variabla per
te cilat eshte percaktuar tashme adresa relative). Ne kete menyre eshte ndertuar kodi objekt i
programit, dhe vete tabela e simboleve i bashkohet ketij kodi qe regjistrohet ne disk zakonisht si
skedar me prapashtesen .obj .
Me tej aktivizohet lidhesi, i cili lexon kodin objekt me tabelen e simboleve dhe simbolet e
papercaktuar ne kujtese – te ashtuquajturit “te jashtem (external)” tentohet te gjenden diku neper
librarite e sistemit, nese gjenden llogariten adresat relative perkatese dhe zbatohen ne kodin objekt,
duke prodhuar kodin e ekzekutueshem.
Ne vecanti kodi i procedurave te jashtme kopjohet si shtese ne kodin objekt duke e plotesuar ate. Ky
kopjim behet nga lidhesi per procedurat e jashtme te kategorise “statike” qe kopjohen ne kodin e
ekzekutueshem ne menyre te perhershme; ndersa per procedurat e jashtme te kategorise “dinamike”
kopjimi behet perkohesisht ne kohen e ekzekutimit nga “ngarkuesi” – moduli i sistemit te
shfrytezimit qe ngarkon per ekzekutim programet nga disku ne kujtese duke vendosur edhe vleren e
regjistrit baze te procesorit. Perdorimi i procedurave te jashte dinamike ben te mundur zvogelimin e
madhesise te skedareve te ekzekutueshem, por kerko qe librarite e ketyre procedurave te jene
prezente ne disk ne vende te njohura nga sistemi i shfrytezimit.
Shembull – programi burim:
float a,b,cinput (b,c)a=b+cprint (a)
Simbolet “a”, “b”, “c” perfaqesojne adresa kujtese per mbajtjen e numrave reale, te
deklaruara nga perdoruesi. Kompilatori i transformon ne adresa relative kujtese duke filluar
nga nje adrese si per shembull 1000 (ne varesi edhe te vendosjes te kodit te ekzekutueshem
dhe te parametrave – metadatave qe e shoqerojne ate).
Simbolet “input”, “print” perfaqesojne adresa kujtese ku duhet te gjenden procedurat e
leximit dhe shkrimit. Kompilatori mund ti percaktoje adresat e procedurave vetem per ato
procedura qe jane shtjelluar nga perdoruesi ne program – adresat relative te simboleve
“input” dhe “print” mbeten te papercaktuara dhe vete simbolet konsiderohen si “te jashtem”
(external).
Tabela e simboleve do te ishte disi e trajtes:
61
SIMBOLI ADRESA RELATIVE ATRIBUTE
a 1001 float
b 1002 float
c 1003 float
input ? external
print ? external
... ... ...
Gjate fazes te lidhjes gjenden neper librarite e sistemit simbolet “input” dhe “print” dhe
llogaritet se kur te kopjohen ne kujtese do te vendosen ne adresat perkatesisht “1101” dhe
“1201”. Kodi objekt dhe ai i ekzekutueshem, te paraqitur ne asembler, tregohen ne tabele:
Programi Objekt Programi i Ekzekutueshem
CALL input, 1002, 1003LDA 1002ADDA 1003STA 1001CALL print, 1001
CALL 1101, 1002, 1003LDA 1002ADDA 1003STA 1001CALL 1201, 1001
62
ADMINISTRIMI I KUJTESESNe historikun e informatikes viheht re nje dukuri e shprehur nga Ligji i Parkinsonit: me rritjen e
kapacitetit te kiujteses rritet dhe madhesia e programeve qe tentojne ta mbushin ate.
Sistemi i administrimit te kujteses
Modulet e sistemit te shfrytezimit qe merren me administrimin e kujteses njihen me kodin MMS
(Memory Management System). Detyrat e MMS perfshijne:
– Percaktimi i zonave te kujteses ku vendosen programet e ndryshme dhe te dhenat perkatese
– Garantimi qe programet te mos dalin nga zonat e paracaktuara te kujteses (gabimet e tipit
“segment fault”, “buffer overflow” etj.)
– Zhvendosja e “copave” te hapesires se kujteses midis RAM dhe DISK
Te dhenat dhe kodi i proceseve aktive mbahet ne kujtesen qendrore RAM, pjeset me te perdorshme
te tyre kopjohen nga procesori ne kujtesen e vet cache, dhe per te zmadhuar artificialisht hapesiren
e kujteses perdoret edhe nje pjese e diskut (page_system_file ose swap_partition).
Ka dallim themelor mbi administrimin e kujteses ne sismetet me mono programim ndaj atyre me
multiprogramim:
Mono Programim Multi Programim
63
Drivers
Program
Berthama
Drivers
Program 1
Program 2
Program 3
Berthama
Kompleksiteti i MMS ne multiprogramim lidhet me disa probleme:
– “rivendosjen (relocation)”. Programisti nuk mund te parashikoje ku do te vendoset programi
si proces per ekzekutim ne kujtese; per me teper gjate ekzekutimit procesi mund te
zhvendoset ne disk per te liruar kujtese ne dobi te nje procesi tjeter dhe me pas te rikthehet
ne kujtese (swapping). Eshte perdorur edhe “mbivendosja (overlay)”, kur programi i
ekzekutueshem ndahej ne copa dhe copat ngarkoheshin ne kujtese kur u vinte rradha e
ekzekutimit duke u mbivendosur njera mbi tjetren per te zene sa me pak hapesire kujtese.
– Mbrojtja (protection). Proceset nuk duhet ti referohen zonave te kujteses te proceseve te
tjere pa autorizim. Kjo kondite eshte e pamundur te verifikohet gjate kompilimit pasi adresat
fizike njihen vetem gjate ekzekutimit dhe programi mund te rivendoset. Kontrolli i adresave
fizike behet gjate ekzekutimit nga hardueri.
– Ndashmeria (sharing). Eventualisht mund te lejohen disa procese te kapin te njejten zone
kujtese me te dhenat te perbashketa, gje qe kerkon mbikqyrje nga MMS per te mos lejuar
shkelje te hapesirave vetiake te kujteses. Ne vecanti preferohet qe proceset qe ekzekutojne te
njejtin kod te kapin te njejten kopje te programit se sa secili te kete kopjen e vet te kodit.
Principi i adresimit
Sic u tregua dhe ne kapitullin mbi kompilimin, adresat ne programin e ekzekutueshem jane relative.
Gjate ngarkimit ne kujtese ngarkuesi (loader) i
“transformon” ne adresa fizike duke percaktuar
bazen e adresimit. Procesori llogarit adresat
fizike duke mbledhur regjistrin baze me adresat
relative:
adrese_fizike = regjister_base + adrese_relative
Duke ju referuar shembullit per kompilimin,
adresimi fizik realizohet si ne figure.
zona e kujteses e zene nga programi
kujtesa e zene nga te dhenat dhe stiva
kujteses e procedurave standarde
64
Addr. fizike 274569
Reg. Baze / 0000
100110021003
1101
1201
b (275571)
print (275770)
input (275670)
c (275572)
a (275570)
Programi ekzekutueshem
Llogaritja e adresave fizike kryhet nga hardueri i procesorit sipas skemes:
Mbrojtja e kujteses midis proceseve realizohet po nga hardueri, duke perdorur edhe nje regjister te
dyte qe mban kufirin limit te hapesires te zene nga procesi:
Gjendja e gabimit gjeneron nje nderprerje nepermjet te ciles sinjalizohet sistemi i shfrytezimit per
ngjarjen, nese problemi ka ndodhur ne nje proces perdoruesi ai nderpritet (abort / crash), ndersa
nese eshte proces i vete sistemit shkaktohet nderprerja e punes e vete kompjuterit (system crash).
Ne varesi te konfigurimit te sistemit, ne keto raste mund te kryhet automatikisht nje kopje e kujteses
ne disk (memory dump) qe i mundeson programistit te analizoje situaten e gabimit dhe te beje
korrigjimet perkatese ne program (edhe nese gabimi eshte shkaktuar nga te dhenat duhet
permiresuar programi per detektimin ne kohe te situatave te gabuara).
65
Registri irivendosjes
+
14000
MMU
Adrese Llogjike
346
Adrese Fizike
Kujtesa14346
Regjistri i Rivendosjes (Relocation Register) => Regjistri Baze
CPU
ADD
Regjistri ikomandave
346
CPU
Reg. Limit
<
error
no
Reg. Reloc.
+yes
AdreseFizike
Kujtesa
MMU
AdreseLlogjike
Skemat e administrimit te kujteses
Historikisht skemat e administrimit te kujteses kane evoluar, megjithate eshte me interes nje
pershkrim i tyre pasi problematika dhe zgjidhjet jane karakteristike per programimin ne pergjithesi:
– Ndarja fikse
– Ndarja dinamike
– Segmentimi
– Faqosja
– Kujtesa virtuale
Ndarja fikse e kujteses kupton coptimin e saj ne pjese me madhesi te barabarte, dhe cdo procesi i
vihet ne dispozicion nje cope e vetme.
Nje proces qe kerkon kujtese jo me shume se nje
ndarje ngarkohet dhe ekzekutohet, ndryshe duhet
ristrukturuar programi duke perdorur mbivendosjet
(overlays).
Nqs. gjithe ndarjet jane te mbushura, sistemi mund
te zhvendose ndonje proces ne disk (swapping).
Kujtesa perdoret pa eficience – cdo program sado i
vogel bllokon nje ndarje te tere (fragmentimi i
brendshem).
Nje zgjidhje e problemit te fragmentimit ishte ndarja ne copa fikse me
madhesi te ndryshueshme. Atehere ne parim behej e mundur qe procesit
ti jepej kujtese ne perputhje me kerkesen. Nese copat e kujteses me
madhesi te pershtatshme ishin te zena, proceset mund te vendoseshin ne
rradhe pritje, nderkohe sistemi mund te kishte hapesira te lira. Sistemi
mund te perdorte nje rradhe te vetme per te tere proceset, ose rradhe te
vecanta per cdo kategori cope kujtese. Skema e perdorimit te rradheve eshte si ne figure:
66
ndarja
procesi
Nje zgjidhje per zbutjen e vonesave perdorimit te rradheve ishte metodika e ndarjes dinamike te
kujteses, duke i dhene cdo procesi aq kujtese sa kerkon, nese ka kujtese te lire. Ne kete menyre
shmanget problemi i fragmentimit te brenshem. Ne fillim te punes te sistemit proceset vendosen
njeri pas tjetrit pa hapesira kujtese bosh midis tyre, por me kalimin e kohes dhe mbarimin e disa
proceseve krijohen “vrima” – hapesira boshe midis proceseve. Ne kete menyre krijohet
fragmentimi i jashtem – fjale kujtese te lira mund te kete shume por copa me madhesine e
pershtatshme per te futur nje proces mund te mos gjenden. Nje zgjidhje u njoh me emrin
“mbledhesi i thermijave” – nje modul i sistemit qe periodikisht zhvendos proceset ne kujtese per te
“kompaktesuar” copat e lira te kujteses. Nje zgjidhje e dyte ishhte zhvendosja e perkoheshme e
proceseve ne disk per te hapur kujtesen per proceset e reja. Te dy zgjidhjet jane te kushtueshme
lidhur me kohen e punes, pasi zhvendosja e blloqeve te kujteses kerkon angazhimin e procesorit,
ndersa disku elektromekanik eshte i ngadalte.
Vendosja e procesit ne kujtese behej me politika te ndryshme: ndarja e pare te pershtatshme, ndarja
me e mire (best fit), ndarja me te vogel te pershtatshme, ndarja e pershtatshme pasardhese (next fit),
ndarja e pare te pershtatshme duke filluar nga vendodhja e fundit ... Por keto politika vetem sa
ndikonin ne topologjine e fragmentimit.
Skema e funskionimit te metodes dinamike eshte si ne figure:
67
OS OS
Rradhe processes
Proceset e reja
Proceset e reja
Rradhe processes
Segmentimi i kujteses ishte nje permiresim i metodes te ndarjes dinamike. Parimi i segmentimit
eshte coptimi i programit dhe te dhenave ne copa kujtese te vecanta – segmentet. Segmentimi tipik
behej duke ndare procesin ne tre segmente – kodi, te dhenat dhe stiva. Ne varesi te struktures te
kodit dhe te dhenave, programisti mund te parameterizoje kompilatorin te ndaje ne me shume
segmente. Kjo gje mundeson nje minimizim te fragmentimit te jashtem nderkohe qe shmanget
fragmentimi i brenshem. Sipas nevojes per kujtese te lire segmentet me pak te perdorshme mund te
zhvendosen perkohesisht ne disk.
Sistemi mban ne PCB e cdo procesi tabelen e segmenteve perkatese – fillimi (adresa fizike),
gjatesia dhe atributed e cdo segmenti. Gjithashtu sistemi mban tabejen e copave telira te kujteses.
Kur procesi eshte ne ekzekutim – gjendja “RUN”, tabela e segmenteve vendoset ne regjistrat
perkates te procesorit. Adresa logjike e nje fjale te kujteses sic ndeshet ne kodin e programit ndahet
nga hardueri i procesorit ne dy pjese – numri i segmentit dhe zhvendosja relative brenda segmentit.
Hardueri nxjerr adresen fizike te fillimit te segmentit nga tabela dhe e vendos ne regjistrin baze te
procesorit. Skema e llogaritjes e kujetses fizike nga numri i segmentit dhe zhvendosja relative eshte
si ne figure:
68
OS
P1
P2
P3
P4
P5
P6
P6P5P4P3P2P1
OS
P1
P2
P4
P6
OS
P1
P2
P4
P6
P7
?
OS
P1
P2
P4
P6
P7
kerkesa per
kujtese
Pro
cesi i Ko
mp
akte
simit te
Ku
jteses
Faqosja e kujteses si permiresim i metodes te segmentimit dhe eshte sot metoda kryesore e
administrimit te kujteses. Ideja eshte e thjeshte – perdoren segmentet me madhesi te njejte te vogel,
si rregull fuqi e 2 e rendit disa kilo bajt.
69
0111101110011000
0111101110100000
0 1 1 0 0 1
0 0 0 1 1 0
0 0 0 1 0 1012
Adrese Fizike (16 bit)
Adrese Logjike (16 bit)
Segmenti (6 bit) Zhvendosja (10 bit)
Tabela e SegmenteveFillimi (Baza) Gjatesia
Test per numrin e faqeve ?
0 1 1 0 0 1
0 0 0 1 1 0
0 0 0 1 0 1
Test per gjatesine e segmentit ?
Tabela e faqeve e procesit 2
Tabela e faqeve e procesit 1
Tabela e faqeve e procesit 3
Tabela e faqeve te lira
KUJTESA KUJTESA
Ne kete menyre kodi dhe te dhenat coptohen ne shume faqe qe mund te vendosen kudo ku ka
hapesire te lire kujtese. Ne figure tregohet se si futet ne kujtese nje proces i trete duke shfrytezuar
copat e lira te kujteses te lena nga proceset tjere. Fragmentimi i jashtem eleminohet pasi faqet kane
te njejten madhesi dhe cdo sope e lire kujtese eshte disa faqe te plota, ndersa fragmentimi i
brenshem minimizohet vetem ne faqen e fundit te nje programi.
Ne menyre te ngjashme me kujtesen e segmentuar, per cdo proces sistemi mban ne PCB tabejen e
faqeve, qe kopjohet ne regjistrat perkates te procesorut kur procesi eshte ne ekzekutim; si dhe nje
tabele per faqet e lira te kujteses. Ne rast nevoje disa faqe mund te zhvendosen ne disk per te liruar
vend ne kujtese. Tabela e faqeve eshte me e thjeshte se ajo e segmenteve – ka vetem adresen fizike
te faqes, gjatesia e tyre eshte konstante. Hardueri i procesorit ndertohet sipas te njejtit algoritem per
llogaritjen e adresave fizike si dhe tek segmentimi, me ndryshimin e vetem se madhesia e segmentit
eshte konstante.
Kuptimi i Kujteses Virtuale sqaron se si perdoret sot teknika e faqosjes te kujteses.
Kujtesa fizike RAM perfytyrohet si nje skelet per vendosjen e faqeve (frames). Kompilimi i
programit behet duke supozuar nje hapesire vetiake kujtese logjike – virtuale qe shikohet si nje varg
faqesh. Tabela e faqeve e secilit nga proceset tregon ne ne cilen frame te kujteses fizike vendoset
secila faqe logjike e procesit, si dhe atributet e faqes (kod apo te dhena, frekuenca e perdorimit,
vendodhja RAM/disk etj.). Faqet me pak te perdorshme mund te vendosen ne disk – swapping ne
nje skedar special te sistemit (MS Windows) ose ne nje ndarje te vecante te diksut (swap ne Linux).
Sistemi i shfrytezimit regjistron ne tabelen e faqeve frekuencen e perdorimit te faqeve – mekanizmi
i “vjetersimit” te faqeve, dhe faqet me pak te perdorura dergohen ne disk (swapping) nese duhet te
lirohen frames ne RAM per faqet e procesit ne ekzekutim.
Kujtesa virtuale (faqet) pasqyrimi i faqeve ne frames RAM (frames)
70
Sot perdoret kombinimi i teknikes te segmenteve me ate te faqeve – nje grup faqesh te
njepasnjeshme trajtohen si nje bllok i vetem – si segment. Kjo gje lehteson shkembimin e faqeve
midis RAM dhe disk pasi leximi dhe shkrimi i disa faqeve ne disk behen ne menyre sekuenciale
duke shmangur kercimet e kokes magnetike te diskut. Ky nderlikim nuk cenon procesin e hartimit
dhe kompilimit te programeve – kujtesa "logjike" konsiderohet gjihmone si nje e tere me fillim ne
zero. Nderkohe hardueri i ndan adresat logjike jo me ne dy pjese (numri i faqes dhe zhevndosja
relative brenda faqes), por ne tre pjese – numri i segmentit, numri i faqes ne segment, dhe
zhvendosja relative brenda faqes. Per cdo proces sistemi i shfrytezimit mban dy tabela – tabelen me
te dhenat per segmentet dhe ate me te dhenat per faqet, dhe adresimi kryhet si ne figure:
adresa logjike => segmenti faqja ne segment adresa relative ne faqe
tabela e segmenteve
tabela e faqeve
add & test
adresa fizike
71
Aspekte te shfrytezimit te kujteses
Se pari, duhet kuptuar mire si administrohet kujtesa gjate thirrjes te procedurave. Ne keto raste
duhet hapesire kujtese per parametrat e thirrjes te procedures si dhe per variablat lokale te saj. Per
kete qellim kompilatori parashikon kodin per administrimin e nje stive vetiake te procesit gjate
thirrjes te procedurave:
Programisti duhet te kete kujdes te vecante per te shmangur rekursivitetin e pa kontrolluar ne
thirrjen e procedurave, qe do te shpinte ne mbushjen e faqeve te dedikuara per stiven dhe abortimin
e procesit (“stack overflow”).
Programisti duhet te shmange deklarimin statik te tabelave te medha por te perdore zenien dinamike
te kujteses duke perdorur proceduren malloc, e cila i kerkon sistemit faqe shtese kujtese sipas
nevojes.
Puna me variablat dinamike si stringjet ne gjuhet si Basic realizohet duke perdorur nje hapesire disa
faqe te ndare ne blloqe te vegjel (heap), ne te cilet formohen struktura te dhenash liste per kete
kategori variablash ne varesi te madhesise konkrete ne caste te ndryshme gjate ekzekutimit.
variabli
72
Stack ptr
Stack ptr
mainproc A
proc Bproc A Kodi
Programit
Te Dhenat Statike
param A
te dhenat lokale A
Kodi Programit
Te Dhenat Statike
param A
te dhenat lokale A
param Bte dhenat lokale B
Kodi Programit
Te Dhenat Statike
param A
te dhenat lokale A
param Bte dhenat lokale B
param A
te dhenat lokale A
Stack ptr
call A call B call A
Probleme te Mbrojtjes
Problemi i mbrojtjes i nje sistemi informatik ka disa aspekte:
– mbrojtja e segmenteve te kujteses te nje procesi nga proceset e tjere
– mbrojtja e te dhenave te nje perdoruesi ne kujtesen e jashtme nga perdoruesit e tjere
– ndalimi i perdorimit te nje programi nga perdorues te caktuar
– kategorizimi i menyrave te kapjes te nje burimi te kompjuterit dhe klasifikimi i perdoruesve
sipas te drejtave per kategorite e kapjes te burimeve
Mbrojtja e kujteses qendrore (RAM) lidhet me proceset dhe qendron ne moslejimin e kapercimit te
tabeles se faqeve dhe te fundit te seciles faqe. Kjo gje sigurohet nga hardueri qe teston adresimin e
cdo instruksioni dhe sinjalizimin me ndihmen e nje nderprerjeje te sistemit te shfrytezimit per
shkeljet. Eshte sistemi i shfrytezimit qe duhet te vendose cfare do te behet me procesin shkeles; si
rregull procesi shkeles duhet te nderpritet, por edhe mund te lejohet me kusht ne rastet kur proceset
duhet te shkembejne te dhena midis tyre (nen kontrollin e sistemit – procesit mund ti lejohet lexim
dhe shkrim ose vetem lexim). Gjithashtu MMS duhet te kujdeset qe gjate shkembimit te faqeve
midis RAM dhe diskut (swapping) te mos ndodhe mbivendosja e faqeve.
Perdoruesit e sistemit mund te jene individe ose aplikime (me sakt "individe" imagjinare perdories
te aplikimeve specifike si ne rastin e sherbimeve server). Perdoruesit dallohen nga emri (user
name) dhe, per individet reale, zakonisht perdoren fjalet e fshehta te kalimit si mjet identifikimi
("perdoruesit" aplikime nuk kane fjale kalimi dhe vetem sistemi i shfrytezimit mund te luaje ate
rol). Pergjithesisht sistemi njeh nje perdorues special – "superperdoruesi" / administratori / root qe
ka te drejtat maksimale mbi burimet e kompjuterit. Perdoruesit ndahen ne grupe, dhe te drejtat e
kapjes te burimeve kategorizohen edhe sipas perdoruesve edhe sipas grupeve (per te lejuar punen ne
grup).
Ne mjedisin Linux lista e perdoruesve gjendet ne skedarin /etc/passwd, ndersa perberja e
grupeve ne /etc/group, qe mund te lexohen nga te gjithe por sistemi lejon vetem
superperdoruesin root te shkruaje ne to (pra vetem ai mund te shtoje, te heqe ose te ndryshohe
atributet e nje perdoruesi). Ndersa fjalet e kalimit mbahen ne skedarin /etc/shadow qe eshte i
kapshem vetem (!) nga superperdoruesi root.
Fjalet e kalimit ne sistemet e ndryshme rregjistrohen te kriptuara me algoritme te pa kthyeshme, te
tille qe per ta nuk ekzistojne formula qe dekriptojne tekstin e kriptuar ne tekst te pakriptuar. Kur
perdoruesi jep fjalen e vet te kalimit per identifikim, sistemi e kripton pastaj e krahason me
versionin po te kriptuar qe eshte ne skedarin perkates ne disk.
73
Perdoruesit duhet te zgjedhin fjale kalimi te nderlikuara dhe jo fjale fjalori, pasi gjithmone ekziston
mundesia qe dikush te tentoje te dekriptoje nje fjale kalimi duke testuar te tera fjalet e fjalorit
("sulmi i forces brutale").
Algoritmet e kriptimit te fjaleve te kalimit ne sistemet informatike jane te mirenjohura, dhe Linux
perdor algoritmin e quajtur MD5 (shembull “alfaalfa” => “jshdfu6yiuwdhfv2rfiuhcv9872rf”).
Kuptimi i perdoruesit dhe atributet e tij perdoren gjeresisht nga sistemi i shfrytezimit per mbrojtjen
e skedareve ne disk. Tre kaetgorite baze te kapjes te nje skedari jane:
– lexim
– shkrim
– ekzekutim (listim per direktorite)
Ne Linux keto te drejta specifikohen per perdoruesin "pronar" te skedarit, per perdoruesit e nje
grupi ku ben pjese "pronari", dhe per perdoruesit e tjere.
Ndersa mbrojtja e kujteses qendrore si rregull behet ne nivel procesi, vete proceset kategorizohen ne
"procese perdorues" per te cilet procesori pranon nje bashkesi te kufizuar instruksionesh, dhe
"procese kernel" qe jane proceset themelore te sistemit te shfrytezimit dhe kane te ndrejten te
ekzekutojne ne procesor te tere bashkesine e instruksioneve (per shembull te bllokojne / c'bllokojne
nderprerjet).
Eshte nje proces "kernel" i sistemit qe realizon aktivizimin e proceseve te tjere duke u dhene dhe
atributin "perdorues" / "kernel" qe shenohet ne PCB perkatese te procesit te ri, dhe gjate punes
eshte po nje proces "kernel" i sistemit qe para ekzekutimit te nje procesi ndryshon gjendjen e
procesorit ne moden "perdorues" / "kernel" sipas rastit.
Mbrojtja e aplikimeve nga shfrytezimi prej perdoruesve te pa autorizuar behet duke kufizuar te
drejtat per "ekzekutim" te skedareve perkates te aplikimit ne disk – sistemi nuk pranon te leshoje
per ekzekutim nje skedar programi nese perdoruesi eshte i pa autorizuar per te bere "ekzekutim".
74
SISTEMET E SKEDAREVE
Skedaret dhe Sistemet e Skedareve
Skedaret ("file")jane nje forme e organizimit te te dhenave ne kujtesat e jashtme sipas natyres se
tyre dhe perdoruesit, dhe ne pergjithesi nje model abstrakt per komunikimin me periferiket.
Perdoruesi punon me skedaret sipas skemes "skedari hapet, shkruhet / lexohet, mbyllet". Skedaret
mundesojne ruajtjen afatgjate te informacionit pas mbarimit te procesit qe e ka perdorur, ruajtjen e
sasive shume te medha te informacionit, dhe mundesine qe disa procese te kapin informacionin ne
menyre konkurente.
Adresimi fizik i te dhenave ne kujtesat e jashtme (tipi disk) behet sipas cilindrit – pistes – sektorit
duke qene ky i fundit njesia baze e lexim / shkrimit. Ne kujetsen e jashtme krahas te dhenave te
perdoruesit regjistrohen nga vete sistemi edhe shume metadata qe karakterizojne keto te dhena, nje
pjese e te cilave jane te padukshme per perdoruesin. Perdorimi i kuptimit te skedarit dhe i sistemit te
skedareve ndihmon ne fshehjen e kompleksitetit te organizimit fizik te diksut.
Skedaret grupohen ne direktori (directory, folder), qe jane ne vetvete skedare te posacem qe
mbajne emra skedaresh me vendodhjen e tyre ne disk dhe atribute te tjera. Struktura e direktorive
dhe e skedareve perben te ashtuquajturin "sistemi i skedareve (file system)". Siatemi i skedareve
organizohet ne trajte strukture peme dhe cdo nyje e pemes (direktori ose skedar) mund te
identifikohet ne dy menyra duke treguar "shtegun (path)":
– PATH nga rrenja e sistemit te skedareve
– PATH nga direktoria korente
Skedaret mbrohen per te mos lejuar kapjen nga perdorues ose me menyre kapjeje te pa autorizuar.
Ne sistemet Unix / Linux mbrojtja tregohet me 10 bit qe mbahen si atribute ne direktorine perkatese
(shilo listingun e nje direktorie me komanden "ls l"):
kodi 1+9 bit “d rwx rwx rwx”
ku: d ~ bit qe tregon se kemi te bejme me direktori
r ~ bit qe tregon te drejten e leximit
w ~ bit qe tregon te drejten e shkrimit
x ~ bit qe tregon te drejten e ekzekutimit (te listimit per direktorite)
Jane tre grupe rwx perkatesisht per Pronarin, Grup_Perdoruesish dhe Perdorues_te_Tjere.
75
Ne Unix / Linux gjendet nje direktori e posacme /dev/ skedaret e te ciles perfaqesojne paisjet e
mundeshme periferike te sistemit. Qe sistemi te komunikoje me paisjet periferike ato duhet te
"montohen (mount)" ne ndonje direktori / skedar te zakonshem. Procesi i montimit sqarohet ne
figure duke supozuar komanden e montimit "mount /dev/hdb1 /mnt/dskb". Ne rrenjen e diskut B
("/dev/hdb1") ndodhet direktoria "/data" e cila pas montimit te diskut ne direktorine
"/mnt/dskb" te diskut A ("/dev/hda1") kapet nga sistemi si "/mnt/dskb/data":
Strukturat e Skedareve
Organizimi ibrenshem i skedareve mund te shikohet ne tre menyra:
a) varg bitesh / bajtesh
b) varg regjistrimesh (records)
c) strukture peme (tree)
Skedaret me strukture varg regjistrimesh karakterizohet ne disa aspekte:
– ne pergjithesi te dhenat brenda nje regjistrimi jane te strukturuara
– regjistrimet mund te jene te tipeve te ndryshme (si gjatesi dhe si strukture)
– ne skedaret me regjistrime me gjatesi te njejte mundet adresimi relativ i regjistrimeve per te
kapur nje regjistrim te caktuar ne rastin kur dihet vendi (numri rendor) i tij ne skedar.
Skedaret me strukture peme jane tipike per rastin e regjistrimeve me gjatesi te ndryshme duke i
indeskuar sipas nje fushe te caktuar celes, dhe kapja me zgjedhje e nje regjistrimi behet me adresim
76
/dev/hda1 /dev/hdb1
“tunel”
/mnt
/mnt/dskb
Disku A Disku B
/data/mnt/diskb/data
rrenja
sipas vleres te celsit, ne kete rast sistemi i shfrytezimit duhet te kryeje nje bredhje ne strukturen
peme epr te arritur tek regjistrimi i kerkuar.
Te dhenat ne skedaret me strukture varg bajtesh ose regjistrimesh me gjatesi te ndryshme mund te
kapen vetem ne menyre sekuenciale nga fillimi i skedarit, pa mundesi zgjedhjeje. Strukturat varg
bajtesh mund te shikohen si struktura regjistrimesh me gjatesi te njejte qe mund te kapen me
zgjedhje adresim relativ ne nivel bajti, por eshte problem njohja e pozicionit te fillimit te te dhenes
qe kerkohet per te mundesuar kapjen direkte te saj.
Skedaret binare (me strukture varg bitesh / bajtesh) duhet te kene nje strukture te brendshme te
njohur ose nga sistemi i shfrytezimit (skedaret e ekzekutueshem, librarite), ose nga ndonje aplikim
(si Word per skedaret .doc, apo Acrobat Reader per skedaret .pdf etj.). Skedaret e
ekzekutueshem ne Unix / Linux kane nje strukture te ngjashme me sa me poshte:
– koka (header) e skedarit, me numrin magjik (kodi i vecante per nje tip te caktuar skedari), gjatesine, adresen relative e fillimit te ekzekutimit te kodit etj.
– kodi i ekzekutueshem i programit
– strukturat per te dhenat e programit
– bitet e politikes te rivendosjes ne kujtese
– tabela e simboleve (shiko kapitullin per kompilatoret)
Kapja e disa te dhenave te caktuara me nje skedar mund te behet, ne varesi te struktures te skedarit,
ne disa menyra:
– sekuenciale, duke filluar nga fillimi i skedarit
– e rastit relative (random) kur dihet pozicioni i fillimit te te dhenes (si numer bajti ose numer rendor regjistrimi me gjatesi te njejte)
– e rastit me celes, per strukturat peme.
Si rregull sistemi i shfrytezimit i shikon skedaret si varg bajtesh, trajtimi i tyre sipas struktures se
brenshme varet nga programet me te cilat perdoruesi punon me skedaret.
Atributet e Skedareve
Cdo skedar (ose direktori) dallohet nga emri dhe, qe te jete e kapshme, duhet te jete e "regjistruar"
ne nje direktori "prind" (vetem direktoria rrenje nuk ka print). Direktorite jane skedare me strukture
varg regjistrimesh, ku cdo regjistrim mban metadatat e nje skedari te regjistruar ne te. Ne direktori
jane dhe dy regjistrime speciale qe lidhin direktorine me vehten (regjistrimi me emrin "." dhe me
direktorine prind. (regjistrimi me "..").
77
Metadatat – ndryshe atributet e skedarit perfshijne informacione si:
• Emri i skedarit• Mbrojtja
◦ Kush ka te drejte kapje◦ Menyrat e kapjes
• Krijuesi• Pronari• Gjatesia aktuale• Gjatesia maksimale• Koha e krijimit• Koha e modifikimit • Koha e kapjes se fundit
• Flamure◦ i fshehur◦ i sistemit◦ vetem-per-lexim◦ i perkohshem◦ i bllokuar◦ etj.
• Fjalekalimi• Gjatesia e regjistrimit• Fusha celes• …
Veprimet qe mund te kryhen me skedaret perfshijne:
• Krijimi [create]• Hapja [open]• Leximi [read]• Shkrimi [write]• Shtimi [append]
• Mbyllja [close]• Leximi atributeve [get_attributes]• Shkrimi atributeve [set_attributes]• Riemerimi [rename]• Prishja [delete]
Prishja e nje skedari nuk do te thote fshirje e te dhenave por vetem prishje e regjistrimit te skedarit
ne direktorine perkatese. Per me teper ne sistemet aktuale veprimi i fshirjes te nje skedari nga
programet e adminsitrimit te sistemit te skedareve thjesht e transferojne skedarin ne nje direktori te
vecante, duke i mundesuar perdoruesit ta rimare skedarin nese eshte prishur gabimisht, ndersa
"boshatisja" e kesaj direktorie "kosh" behet me komande te vecante.
Direktorite
Nga sa u tha me siper – direktorite jane skedare speciale qe mbajne metadatat e skedareve (dhe
direktorive) duke formuar strukturen pemore te sistemit te skedareve.
Nje skedar mund te jete i regjistruar ne disa direktori, por gjithmone njera prej tyre – ajo ku
regjistrohet skedari kur krijohet per here te pare – eshte direktoria paresore e skedarit dhe prishja e
kerij regjistrimi prish skedarin; ndersa regjistrimet ne direktorite e tjera ku mund te regjistrohet
skedari jane dytesore (shortcut ose symbolic link) dhe prishja e tyre nuk cenon skedarin.
Ekziston mundesia e krijimit te nje "tuneli" nga nje direktori A tek nje direktori B, ne kete rast
permbajtja e direktorise A nuk prishet por "zhduket" per perdoruesin, persa kohe qe ekziston ky
78
"tunel" kur perdoruesi futet ne direktorine A sistemi "kercen" automatikisht ne direktorine B. Ne
linux krijimi dhe prishja e ketyre "tuneleve" behet me komandat mount dhe umount.
Struktura pemore e sistemit te skedareve
• Direktoria rrenje
• Direktori
• Skedare
• Te drejtat e kapjes
• Lidhje ose "tunel"
Struktura e brendshme e nje direktorie mund te shikohet si tabele (rregjistrimet si rrjeshta):
Direktorite tipike te sistemit MS-Windows jane (emrat mund te ndryshojne ne varesi te versionit):
• “/windows” ... sistemi i shfrytezimit
• “/documents and settings” ... mjediset e punes te perdoruesve
• “/program files” ... aplikimet e perdoruesit
79
…
skedar4
skedar3
skedar2
skedar1
…
adrese
adrese
adrese
adrese
…
atribute
atribute
atribute
atribute
Ne Unix / Linux direktorite tipike jane:
• "/bin", "/lib", "/usr", "/sbin", … sistemi i shrytezimit (i ekzekutueshem)
• "/etc", "/var", … sistemi i shrytezimit (konfigurimi dhe statistikat (logs))
• "/usr" ... edhe aplikime te perdoruesit
• "/root" ... mjedisi i punes i administratorit
• "/home" ... mjediset e punes te perdoruesve
Veprimet me direktorite jane njelloj ne koncept si per skedaret por komandat e sistemit jane te
ndryshme. Per shembull ne Linux afishimi ne terminal i nje skedari tekst mund te behet me
komantat si cat ose more, ndersa listimi i permbajtjes te nje direktorie me komandat ls (vetem
emrat) ose "ls l" (emrat dhe atributet kryesore).
Realizimi i Sistemit te Skedareve
Ne organizimin (shtrirjen) ne kujtesen e jashtme te sistemit te skedareve mund te zbatohen skemat e
zakonshme te strukturave te te dhenave. Ne rastin e shiritave magnetike per shembull, skedaret
vendoseshin njeri pas tjetrit dhe kapja e tyre behej ne menyre sekuenciale, nderkohe qe ndryshimi i
nje skedari ishte problematik dhe prishja shoqerohej me dukurine e fragmentimit te hapesires te
kujteses:
Organizimi i skedareve si nje liste e lidhur mund te zgjidhte disa probleme por mbetej kapja
sekuenciale e tyre si tek shiritat:
Sot perdoret mekanizmi i indeksimit i kombinuar me listat:
80
Kujtesat e jashtme konsiderohen te perbera nga sektoret (njesia baze e lexim / shkrimit) qe
grupohen ne cluster per te rritur shpejtesine e punes – paisja e kujteses veprimet i ben ne baze
sektori nderkohe qe sistemi veprimet me skedaret i ben ne baze cluster.
Si rregull sistemi i skedareve ne kujtesen e jashtme perbehet ne koncept nga tre pjese:
– koka (header, sektori #0) me metadatat e sistemit te skedareve, ku gjendet edhe "harta" e
kujteses qe tregon clusters e zene dhe ata te lire
– direktoria rrenje
– hapesira per direktorite, skedaret dhe struktura ndihmese (nese ka)
Sistemet e ndryshme te shfrytezimit kete koncept e konkretizojne ne menyra te ndryshme.
Sistemi i skedareve ne Unix / Linux
Ne Unix / Linux "harta" e kujteses eshte e tipit "bitmap" – nje varg bitesh qe perfaqesojne clusters
te kujteses, vlera e te cileve 0/1 tregon nese cluster perkates eshte i lire apo i zene.
Ne direktorite per cdo skedar krahas emrit dhe atributeve gjendet dhe adresa e fillimit e nje
strukture speciale "vetiake" te dhenash te quajtura "i-node" qe indeksojne clusters tek te cilet
shtrihet skedari:
Ku: cyan ~ inodes, gjelber ~ ckusters te skedarit.
81
atributet
single
double
triple
Direktoria
inode emri skedarit
i-node
Struktura e sistemit te skedareve Unix / Linux ne teresine e vet eshte si ne figure (ku dallohen
bitmap dhe zinxhirezimi i clusters i nje skedari):
Sistemet e skedareve ne MS Windows
Ne sistemin MS Windows ndeshen dy formate sisteme skedaresh – i vjetri FAT (File Allocation
nable) dhe i riu NTFS (New Technology File System). Sistemi i vjeter FAT ka dy nen-versione te
ashtuquajtur 16bit dhe 32bit ne varesi te gjatesise te fjales te perdorur per clusters.
Sistemi FAT karakterizohet nga zgjerimi i kuptimit te bitmap – ne vend te paraqitjes te clusters ne
koken e sistemit me bit perdoret nje tabele (FAT) me fjale 16 / 32 bit, cdo cluster perfaqesohet nga
fjala e rradhes ne kete "harte", dhe ne cdo fjale shenohet numri rendor i cluster ku vazhdon shtrirja
e skedarit:
Kode te vecanta perdoren per te treguar nese cluster eshte i fundit i skedarit ose nese eshte i lire. Ne
direktorite krahas emrave te cdo skedari gjendet dhe numri rendor i cluster te pare, prej nga sistemi
orientohet per te kapur zkedarin nderkohe qe ne "harte" tregohet si zinxhirezohet shtrirja e skedarit.
Ne koken e sistemit "harta" FAT gjendet ne dy kopje. Ky dyfishim i sherben integritetit te sistemit te
skedareve – cdo ndryshim ne shtrirjen e nje skedari duhet te pasqyrohet ne FAT dhe ne rast
nderprerjesh brutale te sistemit gjate shkrimit ne FAT prishja e struktures te kesaj te fundit shkakton
turbullimin e gjithe sistemit dhe rezikon humbjen e te dhenave.
Sistemi FAT ne versionin 32 bit mundeson punen me kujtesa te jashtme te madhesise 2TB – 16TB
ne varesi te madhesise te sektorit (perkatesisht 512B deri 4096B); si dhe ka kufizimin ne madhesine
e nje skedari ne jo me shume se 4GB, e lidhur kjo me gjatesine e fushes qe mban madhesine e
skedarit tek atributet e ketij te fundit.
82
Duke filluar nga versioni Windows NT 3.1 Microsoft ka perdorur formatin e ri per sistemet e
skedareve NTFS. Koka e sistemit njihet me emrin MFT (Master File Table) dhe ndarja e kujteses se
jashtme eshte si ne figure:
MFT MFT ext skedare 3 skedare
Ku:
– MFT ~ koka e sistemit te skedareve
– MFT ext ~ hapesire e lire per zgjerimin e MFT (rreth 12% e hapesires se kujteses)
– skedare ~ hapesira per skedaret
– 3 ~ kopje e 3 regjistrimeve te para te MFT (per sigurine e sistemit),
si rregull ne mezin e kapesires te kujteses dhe e pa levizeshme.
Ne koncept cdo regjistrim i MFT permban metadatat e nje skedari, dhe 16 skedaret (regjistrimet) e
para te MFT kane metadatat hemelore te sistemit, perfshi dhe bitmap e clusters te lire.
Cdo skedar identifikohet nga nje numer 64 bit – numri rendor i regjistrimit perkates ne MFT, ku
gjendet dhe lista e clusters:
Numerimi i clusters behet ne dy menyra – "virtuale (VNC)" dhe "logjike (LNC)". Zona "DATA" e
regjistrimit mund te mbaje vete te dhenat e skedarit nese ky eshte i vogel; ose listen e clusters, dhe
nese kjo liste eshte e gjate ne fund te zones vendoset nje pointer per tek nje bllok shtese per
vazhdimin e listes te clusters.
Direktorite ne NTFS jane te organizuara si strukture peme per te lehtesuar bredhjen dhe trajtimin e
tyre. Cdo bllok i direktorise permban emrin e skedarit, atributed baze dhe identifikatorin e
regjistrimit te skedarit ne MFT.
83
Sistemi NTFS eshte shume i sigurte ndaj nderprerjeve brutale te punes – per cdo ndryshim ne disk
parashikohet ruajtja e gjendjes te meparshme ne nje skedar historik (log file) dhe vetem nese
ndryshimi perfundon me sukses regjistrimi perkates ne kete historik shenohet si "i kryer". Windows
gjate fillimit te punes perdor informacionin historik per te rikthyer ne gjendjen normale te
ndryshimeve te mbetura pezull nga nje nderprerje e kaluar.
Ne sistemin NTFS parashikohen nivelet e ndryshme te mbrojtjes te skedareve ne varesi te
perdoruesve dhe te kategorise se veprimit qe kerkohet te kryhet.
Kujdesi per Skedaret
Puna me skedaret lidhet me ekzistencen e te dhenave (a jane ato ne kujtesen e jashtme), me
besueshmerine e te dhenave (a jane ato qe na duhen) dhe integritetin e te dhenave (a jane ato te pa
korruptuara).
Ekzistenca e skedareve sigurohet nepermjet arshivimit (backup) periodik te tyre ne kujtesa te
jashtme te levizeshme qe mbahen te sigurta larg vendodhjes te kompjuterit. Ne rast se sistemi i
skedareve demtohet, duke perdorur arshiven behet e mundur rivendosja (restore) e gjendjes me
humbje relativisht minimale (ndryshimet ne periudhen midis arshivimit dhe rivendosjes).
Ekzistenca e skedareve duhet kuptuar si relative. Skedaret mund te humbasin si per shkak
demtimesh por edhe nga keq-organizimi i sistemit te skedareve. Ka rendesi te madhe organizimi i
direktorive ne varesi te puneve qe kryhen dhe te periudhave kohore, si dhe emertimi i skedareve ne
menyre te tille qe nga emri te mund te kuptohet problemi, versioni i skedarit dhe data e krijimit ose
ndryshimit. Ne te kunderten skedaret edhe pse mund te ndodhen te paprekur ne disk mbeten te
pakapshem nga perdoruesi.
Korruptimi i te dhenave mund te ndodhe kur shfaqen difekte fizike ne kujtesen e jashtme, kur ka
nderprerje brutale gjate shkrimit ne skedar, ose nga veprimtaria e programeve demtuese si "kali i
trojes". Ne pergjithesi sistemi arrin te diktoje sektoret fizikisht te demtuar pasi veprimi mbi to jep
gjithmone gabim tek kodet e kotrollit qe shoqerojne sektorin (CRC – Cyclic Redundancy Code).
Ndersa demtimet e tjera mund te dallohen nga programet qe perdoren per trajtimin e skedareve (kur
cenohen metadatat e te dhenave) ose nga vete perdoruesi.
Si rregull sistemi i shfrytezimit kontrollon integritetin e kujteses se jashtme gjate fillimit te punes
dhe ne rast difektesh tenton ti riparoje ato fillimisht ne menyre automatike, dhe nese kjo eshte e
pamundur i jepet mundesia perdoruesit te nderhyje per te zgjedhur alternativat e riparimit.
84
Dy probleme qe dalin me kalimin e kohes dhe duhet te mbahen nen kontroll nga perdoruesi jane
fragmentimi dhe skedaret e perkohshem. Fragmentimi i jashtem i sistemit te skedareve eshte dukuri
e ngjashme me ate te kujteses se brendshme, me kalimin e kohes vjen duke u renduar dhe ul
shpejtesine e punes te sistemit. Dersa skedaret e perkohshem krijohen nga programe te ndryshme ne
menyre transparente per perdoruesin, dhe ka arste kur mbeten ne kujtesen e jashtme pa u prishur kur
mbaron punen programi qe i ka krijuar. Me kalimin e kohes vellimi i zene nga skedare te tille mund
te behet i konsiderueshem duke zvogeluar ndjeshem hapesiren e lire te kujteses se jashtme.
Perdoruesi duhet te kujdeset periodikisht si per defragmentimin e kujteses se jashtme dhe per
prishjen e skedareve te perkohshem. Procesi i defragmentimit qendron ne zhvendosjen e copave te
skedareve per ti kompaktesuar, kerkon kohe dhe mbart rezikun e demtimit te vete sistemit te
skedareve nese nuk kryhet me programe te dedikuara per versionin konkret te sistemit.
85
Procesi i Booting i Sistemit te ShfrytezimitNe fillimin e leksioneve eshte supozuar se sistemi i shfrytezimit ndodhet i regjistruar ne nje bllok te
tipit ROM te kujteses se brendshme RAM, kur kompjuteri ndizet hardueri fillon ekzekutimin nga
sistemi i shfrytezimit ne ROM. Kjo zgjidhje u perdor ne gjeneratat e para te mikrokompjuterave por
rezultoi jo e pershtatshme per shkak te veshtiresise ne ndryshimin e sistemit nga perdoruesit e
zakonshem (permbajtja e ROM eshte e ose pandryshueshme ose mund te ndryshohet me programe
speciale). Prandaj sot ndiqet praktika e mbajtjes te sistemit te shfrytezimit ne nje kujtese te jashtme,
Si rregull kujtesa e jashtme eshte "disk i ngurte" (HDD – Hard Disk Device). Por sot per kete qellim
perdoren dhe "kujtesa te ngurta" (SSD – Solid State Drive) elektronika e te cilave e ruan gjendjen
edhe ne mungese te energjise elektrike. SSD jane paisje vetem elektronike, pa perberes magentike
dhe elektromekanike, dhe per te cilat emertimi "disk" eshte thjesht simbolik. Per kete aresye ne
leksione eshte perdorur termi "kujtese e jashtme" ne vend te termit tradicional "disk".
Per te mundesuar ngarkimin per ekzekutim te sistemit te shfrytezimit nga kujtesa e jashtme ne ate te
brendshme ne ROM gjendet kodi i quajtur “BIOS” i perbere nga:
– programet e testimit te harduerit
– metadatat e harduerit
– programi i ngarkimit te sistemit te shfrytezimit nga kujtesa e jashhtme
Kodi i ngarkimi tte sistemit te shfrytezimit nga kujtesa e jashtme ne ate te brendshme njihet me
emrin “ibootstrap”, vete procesi “booting” ose shkurt “iboot”.
BIOS nuk mund te “dije” detajet e cdo lloj sistemi shfrytezimi qe mund te gjendet ne disk. Per kete
aresye projektuesit kane konceptuar BIOS qe te supozoje se ne sektorin #0 te kujteses se jashtme te
gjendet kodi i duhur per ngarkimin ne kujtesen qendrore te brenshme te sistemit te shfrytezimit, kod
ky i instaluar atje gjate instalimit te sistemit te shfrytezimit ne disk dhe i pershtatur te gjeje ne disk
skedaret e duhur te sistemit.
Per te mundesuar perdorimin sa me te mire te hapesires te kujtesave te jashtme eshte konceptuar
ndarja e kujteses se jashtme ne disa “disqe logjike ~ ndarje (partition)”. Sektori i pare #0 i cdo
disku logjik si pjese e kujteses se jashtme quhet boot sector, ndersa sektori #0 i vete kujteses se
jashtme Main Boot Sector (MBR):
86
Cdo disk logjik “sillet” sikur te ishhte nje disk fizik i sakonshem dhe mban nje sistem skedaresh te
vetin. Per te mundesuar qe sistemi i shfrytezimit te administroje disa disqe logjike eshte menduar qe
sektori #0 i kujteses se jashtme te mbaje Tabelen e Ndarjeve, te te cilen shenohet fillimi, gjatesia
dhe tipi i cdo disku logjik, si dhe nga kush ndarje [aktive] duhet te behet ngarkimi i sistemit te
shfrytezimit. Kjo tabele u konceptua per kater disqe logjike, dhe me pas per ta kapercyer kete
kufizim u mendua qe ndarjet te jene “primare (te zakonshme)” ose “te zgjeruara ~ extended (qe
mund te ndahen ne disa ndarje)”. Keshtu edhe ndarjet e zgjeruara fillojne me nje Tabele Ndarjesh.
Bootstrap i BIOS kerkon ne sektorin #0 te kujteses se jashtme nese ka kod per vazhdimin e booting,
e ngarkon ate ne kujtese dhe kalon atje ekzekutimin. Bootstrap nga sektori #0 i kujteses se jashtme
konsulton Tabelen e Ndarjeve per te gjetur kush eshte ndarja aktive dhe tenton te ngarkoje ne
kujtese vazhdimin e kodit te booting nga sektori #0 i ndarjes aktive. Ky i fundit eshte i konfiguruar
(gjate instalimit te sistemit) te gjeje ne disk dhe te ngarkoje ne kujtese modulet e sistemit te
shfrytezimit.
Kjo logjike mundesoj qe perdoruesi te instaloje ne disk disa sisteme shhfrytezimi te ndryshem secili
ne disk logjik te vecante. Bootstrap i BIOS i ofron perdoruesit mudnesine te zgjedhe, nepermjet nje
menuje te konfigurueshte, se nga cila kujtese e jashtme do te tentohet te ngarkohet sistemi. Me tej
bootstrap nga sektori #0 i kujteses se jashtme, nese eshte programuar i tille, mund to ofroje
perdoruesit mundesine te zgjedhe nepermjet nje menuje sistemin e shfrytezimit. Ne mungese te
kerij programi_menu te bootstrap perdoruesi duhet te shfrytezoje manualisht modulet e
administrimit te kujeses se jashtme (te njohura si Disk Management System / Tool) per te percaktuar
ndarjen aktive ne Tabelen e Ndarjeve te kujteses se jashtme.
87
Ndarje Kryesore Ndarje Llogjike Ndarje Llogjike
Ndarje e Zgjeruar (extended)
Hapesira e te dhenave
FAT (File Allocation Table)
Boot Record
MBR & Tabela e Ndarjeve
Sisemet Linux sot perdorin si bootstrap nje program te quajtur GRUB qe ndodhet ne diskun logjik
te vete Linux. Gjate instalimit te Linux programi i instalimit kontrollon diskun per prezencen e
sistemeve te tjere dhe konfiguron menune e GRUB per ti mundesuar perdoruesit zgjedhjen e
sistemit te shfrytezimit. Ndersa MS Windows nuk i njeh sistemet e tjera qe kujtesen e jashtme
(peprjashtuar versionet e vete Windows). Si pasoje:
– fillimisht duhet instaluar MS Windows pastaj Linux ose ndonje sistem tjeter
– nese gjate punes prishet struktura e bootstrap ne nje kujtese te jashtme ku gjendet edhe
sistemi Linux, duhet te ri-instalohet GRUB per te mundesuar booting me zgjedhje
– nese prishet struktura e bootstrap ne nje kujtese te jashtme qe ka vetem MS Windows, duhet
te rivendoset sektori #0 i kujteses duke ri-regjistruar MBR (Main Boot Record) duke
perdorur programet perkatese nga Microsoft.
Sistemet e administrimit te kujtesave te jashtme si dhe programe te posacme lejojne krijimin,
prishjen dhe ndryshimin e madhesise ose zhvendosjen (gjithmone nese ka hapesire te lire) te
ndarjeve. Kjo lejon perdoruesin qe ne nje makine te pa peperdorur te mund te ngushhtoje nje ndarje
per te krijuar hapesire per nje ndarje tjeter (si dhe instalimin e nje sistemi tjeter). Nese makina eshte
perdorur ekziston mundesia qe ndonje skedar te jete vendosur ne fund te ndarjes dhe ngjeshja e saj
do ta shkateronte duke korruptuar sistemin e skedareve. Ne vecanti ne sistemin NTFS ne mezin e
ndarjes gjendet si e pa levizeshme kopja e kokes te sistemit qe nuk duhet cenuar (pra ndarja mund te
ngushtohet deri ne masen ~ 45% nese pas mezit te saj nuk ka skedare).
Se fundi duhet te theksohet se eshhte praktike e keshillueshme qe kujtesa e jashtme – disku edhe
nese eshte i organizuar me nje ndarje te vetme ne fabrike, te coptohet ne dy ndarje per te vecuar
programet nga te dhenat; ne kete menyre ri-instalimi i sistemit ose i programeve nuk rezikon
prishjen e te dhenave.
88
ELEMENTE TE MBROJTJES TE SISTEMEVEMbrojtja e sistemeve informatike realizohet nepermjet disa hallkave, nje nga kryesoret eshte
mbrojtja ne nivelin e sistemit te shfrytezimit. Disa elemente te kesaj mbrojtjeje jane permendur me
siper – identifikimi i perdoruesve dhe klasifikimi i menyres te kapjes te skedareve. Mbrojtja
pergjithesisht eshte e kundert me komoditetin e perdoruesit. Arritja e nje mbrojtjeje optimale
kushtezohet nga lloji i te dhenave dhe programeve qe gjenden ne sistem nepermjet konceptimit dhe
realzimit te nje politike mbrojtjeje te caktuar.
Problemet e Sigurise
Prishja e sigurise ne sistemet informatike shfaqet ne disa menyra:
– vjedhje e te dhenave
– prishje e te dhenave
– shftrytezim i kapaciteteve softuer (ekzekutim i programeve) te paautorizuaur
– shftrytezim i kapaciteteve harduer (kujtese, printer etj.) te pa autorizuar
– demtim i softuerit ose harduerit
– sulmi ndaj sistemeve te tjere nepermjet rrjetit i ndergjegjshem, ose i pa ndergjegjshem (kur
sistemi infektohet nga programe “kali trojes”).
Thyerja e sigurise te nje sistemi mund te realizohet ne shume menyra (duke supozuar se nuk jane
mare masat mbrojtjese te duhura), duuke pergjuar trafikun e rrjetit ose duke nderhyre ne sistemet e
huaja per instalimin atje te nje “kale troje”. Ky term i huazuajtur nga historia perdoret per te
cilesuar programe demprurese qe instalohen fshehurazi perdoruesit ne sistem nepermjet disa
kanaleve (nepermjet rrjetit ose nga perdorimi i kujtesavete jashtme te levizeshme):
– instalimi i cdo lloj programi “terheqes” nga rrjeti
– infektimi nga viruse (copa kodi qe i bashkengjiten nje programi dhe shumojne vehten kur
programi ekzekutohet nga perdoruesi), qe te shperndahen si nepermjet ekzekutimit te
programeve te infektuar dhe nepermjet hapjes te dokumentave me makro te infektuara
– infektimi nga “krimba (iworms)” – programe qe shfrytezojne “portat” e sistemeve te huaja te
hapura pa kujdes ne rrjet per te kopjuar dhe ekzekutuar atje vehten e tyre.
89
“Kali trojes” i aktivizuar ne nje sistem mund te demtoje te dhenat dhe softuerin, por edhe mund te
kopjoje te dhena kritike (ne vencanti fjalet e kalimit ose numrat e kartave te kreditit) si direkt nga
kujtesa e jashtme por edhe duke pergjuar shtypjen e tastieres nga perdoruesi; te dhenat e pergjuara i
me tej mund te dergohen fshehurazi perdoruesit tek autori i “kalit te trojes” duke e mundesuar ate
(autorin) te kryeje veprime ndoshta fitimprurese per vehten por ne dem te perdoruesit.
Per me teper infektimi i nje sistemi mund ta ktheje ate ne burim sulmesh kunder sistemeve te tjera,
si per perhapjen e infeksionit, dergimin e mesazheve me permbajtje te demshme, deri tek “sulmi i
mohimit (DoS – Denial of Service)” – bombabrdimi i nje sistemi te huaj me mesazhe ne ate shkalle
qe e bllokon ate. “Infeksionet” mund te programohen ne menyre qe te punojne si “bombe logjike
me plasje te vonuar”, duke qendruar ne qetesi per nje periudhe kohe dhe duke u aktivizuar ne nje
moment te caktuar nepermjet nje ngacmimi nga jashte ose ne base te dates dhe ores te sistemit.
Elementet Baze te Mbrojtjes
Mbrojtja e sistemit fillon tek mundesia e kontaktit fizik me kompjuterin. Pavaresisht se sistemi
mund te jete i mbrojtur ne nivelin e perdoruesit, nje person i paautorizuar ne kontakt fizik me
sistemin ka mundesi te inicializoje sistemin me ndihmen e nje media te jashtme (CD, memory flash)
dhe te kape te dhenat ne kujtesen e jashtme perfshi skedaret e konfigurimit te mbrojtjes. Mbrojtja e
ndaj kontaktit fizik me persona te paautorizuar eshte vecanerisht kritike per sistemet server. Per
sistemet e lidhur ne rrjet “kontakti fizik” mund te realizohet edhe nepermjet rrjetit.
Klasifikimi korrekt i perdoruesve dhe i te drejtave te tyre perben hapin e dyte te mbrojtjes. Ketu ka
rendesi te vecante perdorimi i fjaleve te kalimit sa me te nderlikuara dhe sa me larg fjaleve te
fjalorit. Si rregull fjalet e kalimit regjistrohen ne sistem dhe qarkullojne ne rrjet te kriptuara me
algoritme pa kthim, por perdorimi i vazhdueshem i nje fjale kalimi, vecanerisht ne kushtet e lidhjes
ne rrjet ne kompjuterave, zvogelon gradualisht sigurine e saj pasi dikush qe arrin te pergjoje
trafikun ne rrjet me kohe mund te arrije te gjeje fjalen e kalimit te pakriptuar.
Ne sistemet kritike zbatohet edhe praktika e fjaleve te kalimit te perkoheshme, te cilat ndryshohen
periodikisht automatikisht; ne keto sisteme perdoren procedura pune qe lejojne vetem perdoruesin e
autorizuar te gjeje fjalen e rradhes te kalimit, duke zvogeluar ne minimum mundesine e gjetjes te
fjales te kalimit nepermjet pergjimit te rrjetit. Gjithashtu mund te perdoren edhe mjetet biometrike
te identifikimit.
Arshivimi periodik i te dhenave ne media qe mbahen larg sistemit perben nje teknike mbrojtje ndaj
demtimeve si per shkaqe fizike dhe nderhyrje te paautorizuara, qe kufizon ne kohe shkallen e
90
demtimit. Por efektiviteti i perdorimit te kesaj teknike eshte i lidhur ngushte me mundesine e
identifikimit te nderhyrjeve te paautorizuara ne sistem, nese kjo gje nuk arrihet sistemi i korruptuar
mund te arshivohet si te ishte i rregulllt dhe nga rivendosja e tij nuk mundesohet shmangia e
problemit.
Kriptimi i te dhenave dhe / ose shoqerimi i tyre me kode te kontrollit (kodet Hash) mundeson si
zvogelimin e mundesise te kapjes te te dhenave nga pale te paautorizuara, dhe diktimin ne kohe te
cdo ndryshimi te paautorizuar te te dhenave apo programeve. Per kete qellim ne sistemet
informatike perdoren nje seri algoritmesh kriptimi, si dhe teknikat e certifikatave elektronike dhe
firmave elektronike.
Teknikat e kriptperdorin algoritme te mirenjohur dhe te standartizuar per ngaterimin e te dhenave ne
menyre qe te behen te pakuptueshme. Fshehtesia arrihet nepermjet parametrizimit te ketyre
algoritmeve me celsat (strings – vargje bitesh) e fshehte te kriptimit. Keta algoritme perdoren
gjeresisht sot vecanerisht ne komunikimet pa tel. Sistemet informatike gjenerojne dhe shkembejne
midis tyre celsat e kriptimit sa hete qe duhet te komunikojne ne menyre te sigurte.
Ne vecanti mund te permendim algoritmet asimetrike qe perdorin dy celsa – te dhenat qe kriptohen
me njerin celes dekriptohen vetem me tjetrin. Duke mbajtur njerin pre tyre te fshehte (privat) dhe
tjetrin te njohur nga te gjithe (publik) behet e mundur te dergohen mesazhe te kriptuar por dhe te
garantohet autoresia e mesazhit: nje tekst i kriptuar me celsin publik te marresit mund te dekriptohet
vetem nga marresi (qe ka celsin privat), ndersa nje tekst i kriptuar me celsin privat te derguesit
mund te dekriptohet nga kushdo qe di celsin perkates publik por vetem derguesi me celsin e vet
privat mund ta prodhoje ate tekst te kriptuar.
Celsat publike garantohen nga autoritetet e certifikimit elektronik. Firma elektronike nuk eshte gje
tjeter vecse kodi H i tekstit i kriptuar me celsin privat te autorit (kushdo mund ta dekriptoje ate kod
dhe te verifikoje perputhjen me tekstin, por vetem autori mund ta prodhoje ate kod te kriptuar).
Mbrojtja e objekteve te vecanta ne nje sistem informatik planifikohet dhe realizohet duke perdorur
kuptimin e “domenit te mbrojtjes” - bashkesine cifteve { objekt , te_drejta }. Nje version i
thjeshtezuar i realizimit te ketij kuptimi gjendet tek atributet e mbrojtjes te cdo skedari. Vecanerisht
kur ekzekutohet nje program, procesi perkates identifikohet nga sistemi midis te tjerash edhe me
kodin e perdoruesit uid edhe me kodin e grupit te perdoruesve gid. Ky kombinim { uid, gid }
eshte percaktues per te drejtat e procesit ne kapjen e burimeve te sistemit. Per te mundesuar nje
detajim me te imet te domeneve te mbrotjes perdoren te ashtuquajturat “listat e kontrollit te kapjes”
(ACL – Access Control List) per burimet kritike te sistemit.
91
Ne sistemet Linux ndryshimi i “pronarit” te skedarit dhe te grupit te tij, si dhe i biteve per te drejtat
Read/Write/Execute per treshen “pronar”/”grup”/”te_tjere” behet me komandat chown, chgrp,
cgmod.
Vendosja e te drejtave te kapjes te burimeve te sistemit si rregull duhet te behet ne dy hapa:
1) vendosen te drejtat implicite te kapjes si “moskapje”, dhe me pas ...
2) hapen vetem ato te drejta kapjeje qe parashikohen ne politiken e mbrojtjes.
Ky parim “bllokim total pastaj hapje e kontrolluar” perdoret gjeresisht ne sistemet dhe rrjetat
informatike.
Mbrojtja nga viruset behet ne rradhe te pare duke mos hapur cdo skedar qe i del perdoruesit perpara,
edhe sikur te jete derguar nga persona ndoshta te njohur (identiteti i derguesit te mesazheve te
postes elektronike per shembull eshte lehetsisht i falsifikueshem). Se dyti duhet instalimi i
programeve antivirus dhe perditesimi i vazhdueshem i tyre (keto programe mbrojne relativisht mire
ndaj viruseve te njohur, por pergjithesisht jane te pafuqishem ndaj viruseve qe sapo dalin).
Mbrojtja nga “krimbat” behet duke mbyllur “portat” e teperta me te cilat sistemi komunikon me
rrjetin, si dhe duke perditesuar sistemin e shfrytezimit dhe programet e punes per te eleminuar
gabimet ne programimin e tyre qe mund te lejojne depertimin e “krimbave”. Mjete te tjera kunder
infektimit nga rrjeti jane “muret e zjarrit (Firewall)” qe sot jane pjese e cdo sistemi shfrytezimi, si
dhe sistemet e diktimit te nderhyrjeve (IDS – Intrusion Detection System); por keto jane ceshtje qe
trajtohen me detaje ne lenden e rrjetave informatike.
Informacion mbi rreziqet nga viruset dhe krimbat gjendet ne faqet e Internetit te kompanive qe
prodhojne antiviruse, si dhe ne faqet e organizatave qe meren me problemet e mbrojtjes te
sistemeve informatike:
• CERT [Computer Emergency Response Team]
• CSRT [Computer Security Response Team]
• CSIRT [Computer Security Incident Response Team]
E thene me pak fjale, kryesore ne mbrojtjen informatike eshte kujdesi – shumefishimi i te dhenave
ne disa kopje dhe konsiderata per Internetin si nje mjedis teper i ndotur dhe i rezikshem.
92
SISTEMET MULTIPROCESOR
Paralelizimi ne Kompjuterat e Zakonshem
Sistemet multiprocesor karakterizohen nga disa CPU te lidhura ne nje BUS, kujtese te brendshme
RAM dhe kontrolloret e periferikeve te perbashketa. CPU mund te jene procesore te vecante ose
edhe 2 – 4 “cores” ne nje procesor te vetem (ne kete rast disa nga perberesit e procesorit si niveli i
jashtem i cache jane te perbashket). Ne secilen nga CPU mund te ekzekutohet nje proces ne
menyre te pavarur nga te tjeret – kemi ekzekutim ne paralel te disa proceseve. Paralelizmi mund te
mos jete i plote pasi gjithesesi proceset mund te konkurojne per kapjen e BUS dhe RAM, por
praktikisht mund te konsiderohet si ekzekutim paralel.
Kompjuterat e sotem zakonisht kane te pakten dy core, ndersa kartat grafike (GPU – Graphical
Processing Unit) te nivelit te larte kane nga dhjetra deri mijra core. Shumefishimi i icores ne nje
kompjuter lejon programimin paralel qe ka perparesine e shkurtimit te kohes te ekzekutimit te nje
programi. Paralelizimi i nje programi varet nga natyra e algoritmit. Shembull tipik i nje algoritmi qe
pranon paralelizim eshte mbledhja e dy vektoreve:
for (i=0; i<n; i++) c[i] = a[i] + b[i];
I ekzekutuar ne nje procesor te vetem realizimi i llogaritjeve kerkon n cikle kohe (duke mare nje
cikel kohe per kryerjen e nje mbledhjeje). Por mbledhjet jane te pavarura dhe mund te shperndahen
ne procesore m te ndryshem dhe nekete rast per kryerjen e llogaritjeve duhen n/m cikle kohe.
93
Sistemi Shfrytezimit
CPU1
K1
CPU2
K2
CPU3
K3
CPU4
K4
APLIKIMET
KUJTESA & PERIFERIKET
proceset
Nje teknike e thjeshte programimi me threads paralele eshte e ashtuquajtura OpenMP – nje standard
programimi i materializuar ne nje librari qe tashme gjendet e integruar ne kompilatoret moderne.
Nje cikel i zakonshem mund te paralelizohet lehte (shiko shembullin me poshte) me kusht qe
iteracionet te jene te pavarur nga njeri tjetri, duke shtuar para instruksionit ciklik direktiven
“#PRAGMA”.
Shembull: mbledhja e dy vektoreve:
#include <omp.h> #include <stdio.h> int main (int argc, char *argv[]) { int i,N,NT;
float s,a[256],b[256],c[256];sscanf (argv[1],"%d",&NT);sscanf (argv[2],"%d",&N);input_array(N,a); input array(N,b);// activate parallel theading#pragma omp parallel for num_threads(NT)
private(s) for (i=0; i<N; i++) { s = a[i] + b[i];
c[i] = s; } output_array(N,c);return 0;
}Ku kompilimi behet me komanden “gcc fopenmp”.
Procedurat input_array dhe output_array nuk jane paraqitur te shtjelluara.
Cikli for (i=0; i<N; i++) coptohet ne NT pjese te pavarura qe ekzekutohen nga
94
CPU CPU CPU CPU CPU CPU
KUJTESA & PERIFERIKET
Sistemi Shfrytezimit
Procesi________
threads paralele. Variabli s eshte futur si shembull i variablave private – ne program eshte
deklaruar nje variabel por secili nga threads duhet te perdore versionin e vet te variablit –
private – per te mos i prishur punen njeri tjetrit. Nese kompjuteri ka c cores keta NT threads
do te ekzekutohen pjeserisht ne paralel duke shkurtuar kohen e ekzekutimit me faktor 1/c .
Sistemet Klasike Paralele
Sistemet klasike paralele karakterizohen nga numer i madh procesoresh te organizuar ne tre modele
arkitekturore:
– Sistemet SIMD (single instruction ~ multiple data)
Cdo procesor ekzekuton te njejtin varg instruksionesh por me te dhena te ndryshme. Modeli
njihet dhe me emrin “arkitekture vektoriale” ose “pipeline”:
Kartat grafike GPU punojne sipas ketij parimi. Edhe paralelizimi me OpenMP mund te futet
ne kete kategori – te njejtat instruksione te ciklit ekzekutohen me te dhena te ndryshme.
– MIMD (multiple instructions ~ multiple data)
Secili procesor punon ne menyre te pavarur me instruksione te ndryshme nga procesoret e
tjere, si dhe mund te komunikoje me procesoret fqinje:
Si ndertimi i kesaj arkitekture dhe programimi eshhte teper i veshtire, si pasoje kjo lloj
arkitekture ndeshet vetem ne kompjuter teper te vecante.
Ne vecanti kartat grafike GPU kane nje arkitekture si ne figure (djathtas) krahasuar me nje procesor
multicore:
95
CPU CPU CPU CPU CPU CPUinstruksioni rezultatet
kujtesa
CPU CPU CPU CPU CPU CPU
CPU CPU CPU CPU CPU CPU
CPU CPU CPU CPU CPU CPU
Programimi ne paralel i kartave GPU mund te behet me mjediset e zhvillimit C te quajtur CUDA
(per kartat NVIDIA) dhe OpenCL. Keto mjedise plotesojne gjuhen C me librarite e nevojshme per
paralelizim sipas logjikes SIMD – e njejta procedure llogaritese realizohet si bashkesi threads
paralele ne cores grafike por me grupe te ndryshme te dhenash. Programisti duhet gjithashtu te
parashikoje transferimin e te dhenave nga kujtesa qendrore RAM ne kujtesen grafike dhe
anasjelltas.
Sistemet e Shperndara
Sistemet e shperndara perbehen nga disa aplikime qe ekzekutohen ne makina te ndryshme te lidhura
ne rrjet dhe qe bashkepunojne per te arritur zgjidhjen e nje problemi te caktuar. Tipike jane sistemet
klient – server ku nje aplikim i kerkon sherbime nje aplikimi tjeter:
Ne sistemet e shperndara komplekse nje aplikim mund te funksionoje edhe si klient edhe si server.
Shembull tipik i aplikimeve klient server jane sistemet qe i ofrojne perdoruesit kapjen e bazave te te
dhenave nepermjet ciftit brouser – uebserver, ku brouser eshte klient i uebserver dhe ky i fundit
klient i serverit te bazes te te dhenave.
Ne vecanti sistemet P2P te shkembimit te skedareve ne Internet jane rrjet ciftesh klient – server, ku
96
PC – B PC – A
detyraaplikimiklient
aplikimserver
rrjet
PC – C
aplikimserver
rrjet
cdo nyje e sistemit fuksionon edhe si klient edhe si server. Numri i nyjeve ne sistemet P2P eshte
relaitivisht i madh dhe i pa kontrolluar, dhe per te realizuar kontaktin midis nyjeve qe duhet te
shkembejne skedare ne keto rrjeta funskionojne nyje te posacme koordinuese.
Ne pergjithesi ndertimi i aplikimeve te shperndara behet duke u mbeshtetur ne Middleware – shtrese
sofuteri midis aplikimit dhe sistemeve te shfrytezimit, qe realizon pavaresine e aplikimit nga
sistemet e shfrytezimit dhe koordinon punen midis copave te aplikimit qe ekzekutohen ne
kompjuterat e vecante.
Kategori e vecante sistemesh te shperndara jane sistemet grid. Keto sisteme sherbejne per ndarjen e
detyrave llogaritese neper kompjuterat e ndryshem ne rrjet pjese e sistemit grid. Sot ne sistemet
grid lidhen mijra kompjuter ne coptuar ne rrjeta lokale (clusters) te pavarura me shtrirje
kontinentale e me tej (shiko projektin evropian InSPIRE ne http://www.egi.eu/ ):
97
MIDDLEWARE
CPU
OS
CPU
OS
CPU
OS
CPU
OS
APLIKIMET
INTERNET
Sistemet dhe perdoruesit ne grid autentikohen me ndihmen e certifikatave elektronike. Proceset
llogaritese ne kompjuterat e ndryshem mund te komunikojne midis tyre duke perdorur funskionet e
Middleware MPI (Message Passing Interface). Perdoruesit grupohen ne “organizata virtuale” sipas
profilit te punes dhe clusters e ndryshem ofrojne kapacitete llogaritese, rezervuese, aplikime, te
dhena per organizatat e ndryshme.
Sot koncepti grid eshte zhvilluar me tej ne cloud – perdoruesit i ofrohen ne menyre transparente
kapacitete rezervuese dhe perpunuese diku ne ndonje kompjuter ne grid. Per me teper keto burime
mund te realizohen ne grid mbi makina virtuale te cilat administratori grid mund ti zhvendose me
lehtesi nga nje kompjuter grid ne tjetrin per te optimizuar shperndarjen e ngarkeses ose shmangien e
sistemeve difektoze.
Nje shembull “ekzotik” i sistemeve te shperndara eshte projekti BOINC, fillimisht i realizuar per
projektin SETI (Search for Extra Terrestrial Intelligence). Ne projektin BOINC perdorues te
Internetit ne menyre vullnerate vene ne dispozicion te proceseve super – voluminoze llogaritese nga
fusha si fizika, kimia, biologjia, matematika kapacitetet e lira te kompjuterave personale. Nepermjet
Internetit softueri BOINC i instaluar si screensaver ne kompjuterin personal kontakton serverin,
mer prej tij nje bllok te dhenash, kryen lllgaritjet dhe i kthen serverit rezultatet:
Duek perdorur BOINC projektet nga shkencat e ndryshme qe kerkojne kapacitete llogaritese te
medha por kane pak burime kane arritur te shperndajne nagrkese llogaritese ne qindra mije
kompjutera personale ne Internet duke siguruar kapacitete llogaritese te krahasueshme me
superkompjuterat.
98
INTERNETI
SERVER
PCScreensaver
PCScreensaver
PCScreensaver
99