Zoltan Geller

Operativni sistemi
Bele ke sa predavanja profesora Zorana Budimca 2000/2001

Univerzitet u Novom Sadu Prirodno-matemati ki fakultet Departman za matematiku i informatiku

2003

SADR AJ

SADR AJ ..................................................................................................................................1 PREDGOVOR ...................................................................................................................6 UVOD ...............................................................................................................................................7

JE OPERATIVNI SISTEM ?............................................................................................................7 TA

ISTORIJA OPERATIVNIH SISTEMA ......................................................8 OSNOVNI POJMOVI, KONCEPTI OS-A ............................................10

PROCESI ..........................................................................................................................................10
STANJA PROCESA .................................................................................................................................11 PCB PROCESS CONTROL BLOCK..................................................................................................12 OPERACIJE SA PROCESIMA ..............................................................................................................13 ODNOS PROCESA ..................................................................................................................................13 PODELA OPERATIVNIH SISTEMA U ODNOSU NA PROCESE...................................................13 TE I LAKI PROCESI ........................................................................................................................13 KI KONKURENTNO PROGRAMIRANJE................................................................................................15

FAJL SISTEM ............................................................................................................................15 SISTEMSKI POZIVI ...........................................................................................................16 KOMANDNI INTERPRETER ....................................................................................16 PREKIDI ..........................................................................................................................................16 JEZGRO OS-A ...........................................................................................................................18

DIZAJN, STRUKTURA OPERATIVNIH SISTEMA..............18

MONOLITNI SISTEMI ....................................................................................................18 SLOJEVITA REALIZACIJA ......................................................................................19
1

VIRTUELNE MA INE ......................................................................................................20 KLIJENT-SERVER MODEL ......................................................................................20

SINHRONIZACIJA PROCESA ......................................................22

KRITI NA OBLAST ......................................................................................................22 SOFTVERSKA REALIZACIJA KRITI NE OBLASTI .....23
DEKKEROV ALGORITAM ..........................................................................................27 PETERSENOV ALGORITAM ....................................................................................28

HARDVERSKA REALIZACIJA KRITI NE OBLASTI ...29 REALIZACIJA POMO U SISTEMSKIH POZIVA................31

SLEEP & WAKEUP ...............................................................................................................32 SEMAFORI ...................................................................................................................................33 BROJA I DOGA AJA .....................................................................................................36 MONITORI I USLOVNE PROMENLJIVE ....................................................37 EKVIVALENCIJA SISTEMA ZA SINHRONIZACIJU PROCESA ........................................................................................................................................40
IMPLEMENTACIJA MONITORA KORI ENJEM SEMAFORA .................................................40 IMPLEMENTACIJA SEMAFORA POMO U MONITORA ............................................................41

KLASI NI PROBLEMI SINHRONIZACIJE ..................................43

PROBLEM JEDU IH FILOZOFA .........................................................................43 PROBLEM ITAOCA I PISACA .............................................................................46 PROBLEM USPAVANOG BERBERINA ..........................................................47

KOMUNIKACIJA TE KIH PROCESA..................................................49 DISPE ER .................................................................................................................................51

UPRAVLJANJE MEMORIJOM ...................................................56

UPRAVLJANJE MEMORIJOM BEZ SWAPPINGA I PAGINGA .....................................................................................................................................57
MONOPROGRAMIRANJE ..........................................................................................57 MULTIPROGRAMIRANJE .........................................................................................58
FIXNE PARTICIJE ......................................................................................................................58 RELOKACIJA I ZA TITA .....................................................................................................59

UPRAVLJANJE MEMORIJOM SA SWAPPINGOM ...........61

MULTIPROGRAMIRANJE SA PROMENLJIVIM PARTICIJAMA ..........................................................................................................................61 STRUKTURE PODATAKA ZA UPRAVLJANJE MEMORIJOM
.....................................................................................................................................................................61 BITNE MAPE ...........................................................................................................................................62 POVEZANE LISTE .................................................................................................................................62 SISTEM DRUGOVA ...............................................................................................................................63

ALGORITMI ZA IZBOR PRAZNE PARTICIJE ......................................64

VIRTUELNA MEMORIJA .....................................................................................65

OVERLAY .......................................................................................................................................65 VIRTUELNA MEMORIJA .............................................................................................65 PAGING (STRANI ENJE) .............................................................................................66 IZBOR STRANICA ZA U ITAVANJE ............................................................68 IZBOR STRANICA ZA IZBACIVANJE ............................................................69 DALJI PROBLEMI STRANI ENJA ....................................................................72
BELADY-JEVA ANOMALIJA .............................................................................................72 RADNI SKUP (WORKING SET) ........................................................................................73 LOKALNOST I GLOBALNOST .........................................................................................74

SEGMENTACIJA

...................................................................................................................74

FAJL SISTEM.................................................................................................................76
FAJL SISTEM SA KORISNI KE TA KE GLEDI .....76 TA
FAJLOVI
.........................................................................................................................................76 IMENOVANJE ........................................................................................................................................76 STRUKTURA FAJLOVA .......................................................................................................................77 TIPOVI FAJLOVA ..................................................................................................................................77 NA IN PRISTUPA FAJLOVIMA ........................................................................................................77 ATRIBUTI FAJLOVA ............................................................................................................................77 OPERACIJE SA FAJLOVIMA .............................................................................................................78

DIREKTORIJUMI

.................................................................................................................78

OPERACIJE SA DIREKTORIJUMIMA ..............................................................................................79

REALIZACIJA FAJL SISTEMA .....................................................................80

NEISKORI ENI BLOKOVI ......................................................................................80 IMPLEMENTACIJA FAJLOVA (ZAUZETI BLOKOVI) ................82 IMPLEMENTACIJA DIREKTORIJUMA .......................................................85
LINKOVI .............................................................................................................................................86

POUZDANOST I PERFORMANSE FAJL SISTEMA ...........87

POUZDANOST FAJL SISTEMA ..............................................................................87
LO BLOKOVI .............................................................................................................................87 I SIGURNOSNE KOPIJE (BACKUP) .................................................................................87 KONZISTENTNOST ..................................................................................................................87

PERFORMANSE FAJL SISTEMA .........................................................................88

OPTIMIZACIJA DISKA ............................................................................................89

ALGORITMI ZA OPTIMIZACIJU POMERANJA GLAVE ...........................90

ZAGLAVLJIVANJE ...........................................................................................91
RESURSI
............................................................................................................................................91

ZAGLAVLJIVANJE ...................................................................................................................91
4

PREVENCIJA .............................................................................................................................92 IZBEGAVANJE ........................................................................................................................93

BANKAROV ALGORITAM...................................................................................................................93

DETEKCIJA ................................................................................................................................95 OPORAVAK ................................................................................................................................95 IZGLADNJIVANJE ..............................................................................................................96

SIGURNOST I ZA TITA ...........................................................................97

SIGURNOST..............................................................................................................................97
NEKOLIKO POZNATIH GRE AKA U RANIJIM OPERATIVNIM SISTEMIMA ......................................................................................................................................97 TREBA DA RADI OSOBA KOJA PROVALJUJE ? ..................................98 TA

PRINCIPI ZA OSTVARIVANJE SIGURNOSTI........................................99 PROVERA IDENTITETA ................................................................................................99

KAKO IZABRATI LOZINKU I DA LI JE ONA DOVOLJNA? ....................99

ZA TITA......................................................................................................................................100

PREDGOVOR

Skripta koju upravo itate predstavlja beleke sa predavanja profesora Zorana Budimca iz predmeta Operativni Sistemi, odr anih 2000/2001 godine, Prirodno-Matemati ki Fakultet, Novi Sad. Nastala je na osnovu slede ih knjiga, skripti i bele : aka Sveska sa belekama slede ih studenata : Zoltan Geller, Igor Mladenovi , Agne Sepei Andrew S. Tanenbaum : Modern Operating Systems Skripta Dejana pegara Beny Bal zs, F k M rk, Kiss Istv n, Kczy Annam ria, Kondorosi K roly, M sz ros Tam s, Rom n Gyula, Szeber nyi Imre, Sziray Jzsef: Oper cis Rendszerek M rnki Megkzel sben t 5. Knapp G bor, Dr.Adamis Guszt v: Oper cis Rendszerek 6. Zoran Budimac, Mirjana Ivanovi , ura Pauni : Programski jezik Modula-2 7. Dragoslav Peovi : Sinhronizacija procesa (skripta) Poglavlje SIGURNOST I ZA TITA je u celosti i bez promena preuzet iz skripte Dejana pegara. 1. 2. 3. 4.

UVOD

Softver se mo podeliti u dve grupe: e 1. sistemski programi upravljaju ra unarom 2. korisni ki (aplikacioni) programi reavaju probleme korisnika Operativni sistem je fundamentalni deo sistemskih programa, iji je zadatak upravljanje resursima ra unara i koji obezbeuje osnovu za pisanje aplikacionih programa. Kako obezbeuje OS osnovu za pisanje aplikacionih programa? Odgovor: Ra unar je kompleksni sistem sastavljen od raznih delova, kao to su: procesor, memorija, diskovi, tastatura, mi, tampa , skener itd. Pisanje programa na taj na in da se ti delovi ra unara programiraju direktno je vrlo te posao. Zato je dolo do ideje da se stavi jedan sloj izmeu ak aplikacionih programa i hardvera. Uloga tog sloja je da obezbedi neki interfejs (ili virtuelnu ma inu) ostalim programima radi lakeg i bezbednijeg pristupa hardveru. Taj sloj je upravo OS. Sada imamo slede u situaciju:

office baze podataka kompajleri,interpreteri editori operativni sistem mainski jezik mikro programi fizi ki ureaji

igre linkeri

Korisni ki programi Sistemski programi HARDVER

Na najni nivou imamo fizi ke ure aje fizi ki delovi ra unara. Iznad tog sloja su mikro em programi direktno kontroliu fizi ke ureaje i obezbeuju interfejs prema slede em nivou. Predstavljaju elementarne korake od kojih se sastoje instrukcije mainskog jezika. Ma inski jezik je skup instrukcija koje procesor direktno razume (izvrava ih pomo u svojih mikro programa). Glavna funkcija operativnog sistema je sakrivanje detalje ovih ni nivoa od ostalih programa i ih pru anje niza jednostavnijih instrukcija za pristup hardveru.

je operativni sistem ? ta
1. OS kao pro irena (extended) ili virtuelna (virtual) ma ina arhitektura (niz instrukcija, organizacija memorije, IO, itd.) ra unara na nivou mainskog jezika je primitivna i nije pogodna za programiranje. Kao primer, mo emo uzeti NEC PD765 kontroler za disketni ureaj (koristi se na personalnim ra unarima). Taj kontroler ima 16 komandi. Najosnovnije komande su READ i WRITE i zahtevaju 13 parametara koja su smetena u 9 bajtova. Prilikom

pristupa disketnom ureaju, treba voditi ra una o tome, da li je motor uklju en, pa treba na i stazu, pa sektor itd - i to bi trebalo raditi svaki put kada elimo neto pisati ili itati sa diskete. Zadatak OS-a kao proirene ili virtuelne maine je upravo to da te stvari radi umesto nas i da nam pru neke funkcije vieg nivoa apstrakcije radi pristupa hardveru. a 2. OS kao upravlja resursima (resource manager) RESURS obuhvata sve to je programu potreban za rad (memorija, procesor, disk, tampa , skener, itd.). Kao upravlja resursima OS ima zadatak, da vodi ra una u resursima ra unara da zadovolji potrebe programa, da prati koji program koristi koje resurse, itd. Primer: imamo viekorisni ki sistem: dva korisnika istovremeno neto tampati OS je du da vodi ra una o tome da programi tih ele an korisnika dou do tampa a kao resursa i da se podaci ne meaju

Istorija operativnih sistema

Istoriju operativnih sistema emo posmatrati preko istorije ra unara:

1. Generacija: (1945-1955) - ra unari pravljeni od vakuumskih cevi. Ra unari su bili ogromnih dimenzija i jako skupi (koristio ih je vojska), u jednom ra unaru je bilo ak i do 20.000 cevi, bili su jako spori, programirao se na mainskom jeziku, programski jezici (ulku uju i i asemblera) i operativni sistemi su bili nepoznati. Ljudi koji su radili na tim ra unarima radili su sve: od programiranja do odr avanja ra unara. 2. Generacija: (1955-1965) ra unari se prave od tranzistora, postaju manji, pouzdaniji i jeftiniji tako da su ih mogli kupovati (pored vojske) i velike korporacije, univerziteti itd. Ra unari su bili odvojeni u posebnim sobama. Programeri piu programe na papiru u programskom jeziku FORTRAN, zatim se ti programi prenose na buene kartice. Buene kartice se ostavljaju u sobi sa poslovima (input room). Sistem operator pokupi buene kartice, u ra unar ubaci kartice sa FORTRAN kompajlerom, pa buene kartice sa programom koji treba izvriti. Ra unar odradi posao i razultat se dobija isto na buenim karticama, koje se prenose u prostoriju sa rezultatima (output room). Ovde se mnogo vremena troi na etanje izmeu raznih prostorija sa buenim karticama. Jo uvek nema operativnog sistema. Uvodi se slede e poboljanje: - paketna obrada (batch system) u sobi sa poslovima se sakuplja jedna koli ina sli nih (npr. svi zahtevaju fortran kompajler) poslova (programa), koji se pomo u jeftinijeg ra unara (npr. IBM 1401) prenosi na magnetnu traku. Nakon toga se magnetna traka prenosi u sobu sa glavnom ra unarom mo niji i skuplji ra unar predvien za izvravanje programa (npr. IBM 7094), na glavni ra unar se u itava poseban program koji je zadu da sa trake sa poslovima redom u itava programe i izvrava ih. Taj program je en predak dana njih OS-a. Nakon izvravanja programa, rezultat se snima na drugu magnetnu traku. Kada su svi poslovi (programi) odraeni, operator stavlja drugu traku sa programima, a traku sa rezultatima prenosi do tre eg ra unara koji je zadu za prebacivanje rezultata sa en

magnetne trake na buene kartice to je ponovo neki jeftiniji ra unar (npr. IBM 1401). Manji ra unari nisu vezani za glavni ra unar, rade off-line. Tipi an izgled poslova (na karticama):
$JOB, ,programer,. $FORTRAN fortranski program $LOAD $RUN ulazni podaci $END // // // // // ime posla i neki podaci treba nam FORTRAN kompajler program u FORTRANU koji treba prevesti uitaj preveden program izvri program sa sledeim podacima :

// kraj posla

3. Generacija : (1965-1980) ra unari se prave od integrisanih kola (IC) po etkom 60-ih ve ina proizvoa a ra unara proizvodi dve vrste ra unara : jednu ja u verziju (kao IBM 7094) i jednu slabiju (kao IBM 1401) to je skup poduhvat. Novi korisnici ra unara slabije ele ra unare koji su jeftiniji, a posle nekog vremena treba im ja i model koji je u stanju da izvri sve stare programe, ali br IBM taj problem pokuava reiti uvoenjem Systema/360. To je e. serija kompatibilnih ra unara razli itih snaga. Svaki od ovih ra unara je pogodan i za nau nu i za poslovnu primenu, pa je time podela ra unara na dve vrste nestala. Ovaj koncept su preuzeli i ostali proizvoa i ra unara. Ra unari iz serije System/360 su radili pod operativnim sistemom OS/360 koji je bio jako glomazan i prepun greaka. Razvija se nova disciplina : softversko innjerstvo. Multiprogramiranje (multiprogramming) : kada program eka na rezultate IO operacija, procesor je neiskori en, pa se javlja gubljenje procesorskog vremena to nije problem kod nau no-orijentisanih programa, koji retko koriste IO operacije, ali jeste kod poslovnih programa. Kao reenje, javlja se multiprogramiranje: memorija se deli na particije u kojima se u itavaju razli iti programi (jobs-poslovi). Dok neki program eka na neke IO operacije, procesor mo izvravati drugi program. Na taj na in, ako imamo dovoljan broj programa u e memoriji, procesor je u stalnoj upotrebi. SPOOL (Simultaneous Peripheral Operation On Line) prebacivanje sadr buenih aja kartica na disk (traku) pomo u posebnog ureaja a bez procesora. Zna i procesor izvrava program u memoriji, a paralelno se disk puni novim poslovima (jobs,programi). Kada jedan program zavri sa radom, procesor na njegovo mesto mo u itati drugi program sa diska. Isto e se koristi i za izlazne podatke. Podela vremena (time-sharing): kod prve generacije, imali smo jednu grupu ljudi koji su koristili ra unar, programer je napisao program, ubacio u ra unar i dobio rezultate, nije ekao na obradu ostalih programa (jobs). Kod paketne obrade programer donese program na buenim karticama, pa na rezultate ponekad eka i nekoliko sati. Ako ima greku u kodu, izgubi pola dana na ekanje. Kao reenje uvodi se time-sharing (podela vremena): svaki korisnik ima tastaturu i monitor (terminal) koji su priklju eni na glavni ra unar. To je jedan oblik multiprogramiranja. Procesorsko vreme razli itim terminalima dodeljuje OS na osnovu dva kriterijuma: - ekanje na IO operacije - istek dodeljenog vremena (uvodi se pojam quantum-a to je koli ina vremena nakon ijeg isteka kontrola se predaje drugom programu; multiprogramming + quantum = time-sharing). MULTICS (MULTIplexed Information and Computing Service) neuspela ideja (MIT,Bell Labs,General Electric) da se napravi mo an ra unar koji e biti u stanju da radi sa velikim brojem terminala. Kao osnovu, uzeli su model distribucije elektri ne energije: elim da sluam radio, samo ga uklju im na struju Isto su hteli napraviti sa ra unarima: u jednom gradu

imamo mo an centralni ra unar, a graani imaju terminale, kojima se pristupa tom ra unaru predak ra unarskih mre i Interneta. a Minira unari: prvi minira unar je DEC-ov (Digital Equipment Corporation) PDP-1, do tada najmanji i najjeftinij ra unar. Kotao je samo $120.000 UNIX: Ken Thompson, jedan od nau nika firme Bell Labs, koji je radio na projektu MULTICS, uzeo je jedan PDP-7 minira unar i napisao za taj ra unar mini verziju MULTICS-a od tog projekta je posle nastao UNIX (UNI = jedan , X = CS Computing Service). 4. Generacija: (1980-1990) Personalni Ra unari razvoj personalnih ra unara po eo je pojavom LSI (Large Scale Integration veliki stepen integracije) ipova. Minira unari su bili dovoljno jeftini, da ih imaju i vie departmana iste firme ili univerziteta, a personalni ra unari su postali dovoljno jeftini da ih imaju i pojedinci. Primer personalnih ra unara: Spectrum, Commodore, Atari. Zatim IBM PC, Apple Macintosh , itd. Javljaju se prvi pravi operativni sistemi kao to su MS-DOS,UNIX,itd. Prave se programi za korisnike, koji nisu stru njaci za ra unare, pa se razvija i korisni ki interfejs programa. Dolazi do razvoja grafi kog okru enja. Pored klasi nih operativnih sistema javljaju se i dve nove vrste: Mreni OS ra unari su povezani u mreu, svaki ra unar ima svoj OS koji meusobno komuniciraju pomo u nekog protokola (operativni sistemi mogu biti razli iti, potrebno je samo zajedni ki protokol, tj. zajedni ki jezik za komunikaciju). Korisnik jednog ra unara, mo se prijaviti na drugi, preuzeti neke fajlove itd. Korisnik zna da nije sam u mre svestan e i, je razli itih ra unara sa kojima komunicira preko mre Mre mogu biti lokalne i globalne. e. e Distribuirani OS korisnici ga vide kao jedno-procesorski sistem, ali u stvari radi sa vie procesora. Imamo vie ra unara povezanih u mre ali samo jedan OS, koji upravlja svim u, resursima u mre U pravom distribuiranom sistemu korisnik ne treba da vodi ra una o tome, i. gde su njegovi fajlovi smeteni ili gde se izvrava njegov program, to je posao OS-a. Distribuirani OS se dakle ponaa kao jedinstvena celina. Korisnik nije svestan toga da je u mre sa drugim ra unarima, njemu to izgleda kao da je jedan ra unar. i

Osnovni pojmovi, koncepti OS-a

Imamo hardver, operativni sistem i korisni ke programe. Videli smo da je jedan od zadataka OS-a da sakrije hardver od aplikacionih programa, odnosno da obezbedi laki pristup hardveru. To se ostvaruje preko niza proirenih instrukcija, koji se zovu sistemski pozivi (system calls).

Procesi
Procesi predstavljaju jedan od najva nijih koncepata operativnih sistema. Program je niz instrukcija koji ostvaruje neki algoritam. Proces je program u statusu izvravanja, zajedno sa svim

10

resursima koji su potrebni za rad programa. Zna i: program je fajl na disku. Kada se taj fajl u ita u memoriju i po inje da se izvrava dobijemo proces.

Stanja procesa
Procesi se nalaze u jednom od slede ih stanja: proces se izvr ava (RUNNING) - procesor upravo izvrava kod ovog procesa proces je spreman, ali se ne izvrava (READY) - proces je dobio sve potrebne resurse, spreman je za izvravanje, eka procesora proces je blokiran, eka na neto (npr. eka tampa a da zavri sa tampanjem BLOCKED) - za dalji rad procesa potrebni su neki resursi, koji trenutno nisu na raspolaganju, eka IO operaciju, rezultat nekog drugog procesa itd.

Imamo 4 prelaska izmeu razli itih stanja: 1. proces prelazi iz stanja IZVR AVANJA u stanje BLOKIRAN kada su mu za dalje izvravanje potrebni neki resursi, koji trenutno nisu dostupni. Ovu promenu stanja vri sam proces: predaje zahtev za neki resurs, pa eka tog resursa. Npr.: poalje zahtev skeneru da skenira neku sliku, i eka rezultat skeniranja 2. proces prelazi iz stanja IZVR AVANJA u stanje SPREMAN ako mu istekne dodeljeno procesorsko vreme (time-sharing) tada proces prelazi u listu procesa koji ekaju na procesor 3. proces prelazi iz stanja SPREMAN u stanje IZVR AVANJA kada se procesor oslobodi i mo da izvrava kod posmatranog procesa (izabere se iz liste ekanja po e nekom kriterijumu i izvrava se) 4. proces prelazi iz stanja BLOKIRAN u stanje SPREMAN, kada doe do potrebnih resursa i spreman je za dalji rad, ali procesor trenutno nije slobodan, pa prelazi u listu ekanja (npr. skener je zavrio skeniranje, i sad proces mo nastaviti sa radom e (spreman je), ali procesor je trenutno zauzet izvravanjem nekog drugog procesa, pa mora da eka u red ) Kod nekih operativnih sistemima procesi mogu biti i suspendovani (suspended). Na taj na in dobijamo jo dva stanja: - proces je suspendovan i spreman (ako je dolo do suspendovanja u stanju spreman) - proces je suspendovan i blokiran (ako je dolo do suspendovanja u stanju blokiran) i slede i dijagram:

11

Proces koji je suspendovan, prestaje da se takmi i za resurse, oslobaaju se resursi koje je zaouzeo, ali ostaje i dalje proces. Proces koji je u stanju suspendovan i blokiran prelazi u stanje suspendovan i spreman, ako postaje spreman, tj. ako mo da nastavi sa radom (npr. proces poalje zahtev skeneru da skenira sliku, eka da e skener zavri sa radom, pa se blokira, u meuvremenu se suspendira, pa postaje suspendovan i blokiran, kada skener zavri skeniranje, proces prelazi iz stanja suspendovan i blokiran u stanje suspendovan i spreman.) Iz stanja suspendovan i blokiran u stanje blokiran i iz stanja suspendovan i spreman u stanje spreman procesi mogu pre i samo explicitno, tj. zahtevom korisnika. Iz stanja spreman u stanje suspendovan i spreman proces prelazi iz nekog od slede ih razloga : - prevelik broj spremnih procesa procesi se suspendiraju kao zatita od preoptere ivanja sistema - explicitno suspendiranje procesa od strane korisnika (npr. da bi korisnik mogao proveriti neke meurezultate izvravanja procesa i nakon toga mogao nastaviti rad bez ponovnog pokretanja celog programa.) - izbegavanje zaglavljivanja (dead lock) do zaglavljivanja se dolazi kada dva (ili vie) procesa blokiraju jedan drugi u izvravanju (npr. procesu P1 treba resurs A koji je kod procesa P2, a procesu P2 treba resurs B koji dr P1 ovi procesi su se i zaglavili, jer nijedan od njih ne mo nastaviti sa radom u ovom slu aju jedan od e procesa se suspenduje, pa drugi mo da odradi svoj zadatak, pa kada se resursi e oslobode i prvi e mo i da zavri svoj rad).

PCB Process Control Block

Posmatrajmo slede u situaciju: imamo multiprogramirano okru enje sa dva procesa. Proces P1 se izvrava dok ne doe do blokiranja zbog ekanja na neki dogaaj (npr. skeniranje). Tada krenemo sa izvravanjem procesa P2 koji se nakon nekog vremena isto postaje blokiran. U meuvremenu se desi dogaaj na koji je ekao proces P1 i sada mo emo nastaviti sa izvravanjem. Da bismo znali, gde treba nastaviti, potrebno je pamtiti neke informacije o procesu. Upravo tome slu PCB tj. Process Control i Block. Svakom procesu se dodeljuje jedinstveni PCB koji sadr informacije koje su potrebne za nastavak i izvravanja tog procesa. Te informacije uklju uju: - jedinstveni identifikator procesa (pid process ID) - stanje procesa - prioritet procesa (iz liste ekanja biramo najpre procese sa ve im prioritetima) - adresa memorije gde se nalazi proces - adrese zauzetih resursa

12

sadr registara procesora, itd. aj

PCB-ovi svih procesa u memoriji smetaju se u neki niz ili povezanu listu.

Operacije sa procesima
Operativni sistem treba da obezbedi slede e operacije sa procesima: kreiranje novog procesa (kreiranjem PCB-a) unitavanje procesa (brisanjem PCB-a iz liste) menjanje stanja procesa menjanje prioriteta procesa izbor procesa za izvravanje (dodela procesora nekom procesu context switch) sinhronizacija procesa komunikacija izmeu procesa itd.

Odnos procesa
I sami procesi mogu kreirati nove procese. U tom slu aju proces koji kreira novi proces zove se roditelj a novi proces dete, pa je odnos procesa hijerarhijski (u obliku stabla). Izmeu roditelja i deteta mo emo imati dve vrste veze: 1. proces-roditelj kreira novog procesa i eka dok proces-dete zavri sa radom 2. proces-roditelj kreira novog procesa i nastavljaju sa radom oba procesa (rade paralelno)

Podela operativnih sistema u odnosu na procese

Operativni sistemi mogu podr avati: monotasking (jednoprocesni, monoprogramiranje) : u memoriji istovremeno imamo samo jedan program, tj. istovremeno se izvrava samo jedan proces (npr. DOS) multitasking (vieprocesni, multiprogramiranje) : u memoriji istovremeno imamo i vie programa, tj. istovremeno se izvravaju i vie procesa (npr. Windows,Linux)

U odnosu na broja korisnika, operativni sistemi mogu biti: monouser (jednokorisni ki): npr. DOS (jednokorisni ki,jednoprocesni), Windows 98 (jednokorisni ki, vieprocesni ) multiuser (viekorisni ki): npr. UNIX (viekorisni ki, vieprocesni)

Te ki i laki procesi
Procesi se dele na te ke i na lake procese. Da bismo videli razliku izmeu ove dve vrste procesa, posmatrajmo najpre kako procesi koriste memoriju. Za izvravanje nekog procesa, potrebno je 4 dela (vrste) memorije: - heap - stack - memorija za globalne promenljive - memorija za kod procesa

13

Memorija zauzeta od strane nekog procesa izgleda na slede i na in:

HEAP STACK globalne promenljive kod procesa

HEAP (hrpa) je deo memorije koji je rezervisan za dinami ke promenljive, tj. za promenljive koje se stvaraju u toku izvravanja programa. Npr. u Moduli-2 zauzimanje memorije (kreiranje dinami ke promenljive) se vri naredbom ALLOCATE iz modula Storage, a oslobaanje zauzete memorije naredbom DEALLOCATE isto iz modula Storage. Pristup dinami ki kreiranim promenljivama se ostvaruje pomo u pokaziva a. To su promenljive koje sadr po etnu adresu zauzete memorije. Na jednu e istu dinami ku promenljivu mogu pokazivati i vie pokaziva a. Ako smo zauzeli neku koli inu memorije i nemamo vie ni jednog pokaziva a na tu memoriju, taj deo HEAP-a je izgubljen (nemamo vie pristupa, ne znamo adresu zauzete memorije, ne mo emo je osloboditi) to se zove smee u memoriji (garbage) i mo dovesti do ozbiljnih greaka u radu programa. Ovaj problem se kod nekih OS-a reava pomo u e sakuplja a smea (garbage collector) koji vode ra una o zauzetim delovima memorije: npr. broje pokaziva e na zauzetu memoriju i ako taj broja postaje nula, oslobaaju memoriju. Postoje i programski jezici koji imaju ugraen sakuplja otpadaka kao to su Java, PC Scheme itd. STACK (stek) je deo memorije koji je rezervisan za uvanje lokalnih promenljivih, parametara procedura, povratnih adresa itd. Pod DOS-om maximalna veli ina steka-a je 64Kb, a maximalna veli ina heap-a je 640Kb. Veli ina heap-a i stack-a je unapred odreena i ne mo se menjati u toku izvravanja programa. Stek se e puni prema gore a heap se puni prema dole. Npr. u Turbo Pascalu postoji direktiva (kompajler vri prevod izvornog koda u funkciji direktiva ugraenih u izvorni kod) $M koja odreuje veli inu heap-a i stack-a na slede i na in: {$M veli inaSteka,heapMin,heapMax}. Podela procesa na teke i lake procese vri se na osnovu toga, kako koriste gore navedene delove memorije : svaki te ki proces ima sopstveni memorijski prostor za kod, globalne promenljive, stek i heap koju ne deli ni sa kim, pristup tim delovima ima samo dati proces. laki procesi (niti, threads) mogu deliti memorijski prostor za kod, globalne promenljive i heap. Stek se ne mo deliti jer ne mo e emo unapred znati koji proces koristi stek: proces A stavi neto na stek i nastavlja rad, dolazi proces B i on isto stavi neto na stek, A je zavrio svoj rad i sad su mu potrebni podaci sa steka, a tamo su podaci procesa B Zna i laki procesi imaju sopstveni stek a mogu deliti kod,globalne promenljive i heap.

Programski jezici, koji omogu avaju kreiranje lakih procesa: Java,Modula-2,Concurrent Pascal,Ada,itd. U M2 laki procesi su zapakovani u teke procese, kompajler deli vreme izmeu vie procesa. Postoje operativni sistemi, koji podr avaju:

14

1. samo teke procese (UNIX) 2. samo lake procese (Oberon) 3. podr avaju i teke i lake procese (Windows) Problem komunikacije kod tekih procesa je u tome, to su oni meusobno odvojeni, tj. ne dele nijedan deo memorije. Kako nemaju zajedni ku memoriju, operativni sistem mora obezbediti neke strukture i mehanizme za me uprocesnu komunikaciju (interprocess communication). Laki procesi mogu bez problema komunicirati jer dele odreene delove memorije. Kod njih se javlja problem sinhronizacije.

Konkurentno programiranje
Kod SEKVENCIJALNOG programiranja, podrazumevamo da se prorgam sastoji od niza naredbi koji se izvrava u ta no odreenom redosledu od strane jednog procesora. Zna i sekvencijalni program predstavlja ta no jedan proces koji se izvrava od po etka do kraja na jednom procesoru. KONKURENTNO programiranje uzima u obzir mogu nost postojanja i vie procesora, pa se konkurentni program sastoji od vie nezavisnih procesa ili zadataka (task), koji se mogu istovremeno izvravati. Stil konkurentnog programiranja koristimo kada se zadatak mo razbiti na vie meusobno e relativno nezavisnih delova procesa, koji se mogu istovremeno izvravati. Konkurentni programi se mogu izvrsavati i na ra unaru sa jednim procesorom i na ra unaru sa vie procesora. Konkurentno programiranje se koristi kod programiranja operativnih sistema, simulacija itd. Npr.: elimo napisati program za simulaciju igre jednog fudbalskog tima. Sekvencijalno: piemo program koji vodi ra una o svakom igra u tima. Konkurentno: za svaki igra piemo jedinstvenu proceduru te procedure se izvravaju istovremeno.

Fajl sistem (file system)

Videli smo da je operativni sistem du da obezbedi laki pristup hardveru programima na viim an nivoima. Na isti na in, treba da obezbedi i apstraktniji pogled na fajlove, na fajl sistem. Zna i, programi na viim nivoima ne treba da vode ra una o tome, kako su u stvari fajlovi smeteni na disku, o tome e voditi ra una OS. Za rad sa fajlovima, OS treba da obezbedi operacije, kao to su: - otvaranje fajlova - zatvaranje fajlova - promena pozicije fajl-pokaziva a (FilePos) - itanje iz fajlova - pisanje u fajlove - kreiranje novih fajlova - brisanje postoje ih fajlova - reimenovanje,kopiranje, itd. Mnogi operativni sistemi podr avaju i koncept direktorijuma, kao na in grupisanja fajlova pa obezbeuju i operacije za rad sa njima. Elementi direktorijuma mogu biti fajlovi i drugi direktorijumi, tako dolazimo do fajl sistema u obliku stabla.

15

Sistemski pozivi (system calls)

Aplikacioni programi komuniciraju sa OS-om pomo u sistemskih poziva, tj. preko operacija (funkcija) definisanih od strane OS-a. Sistemski pozivi se realizuju pomo u sistema prekida: korisni ki program postavlja parametre sistemskog poziva na odreene memorijske lokacije ili registre procesora, inicira prekid, OS preuzima kontrolu, uzima parametre, izvri tra radnje, rezultat stavi u odreene ene memorijske lokacije ili u registre i vra a kontrolu programu. Sistemske pozive esto podr i hardver, tj. procesor, na taj na in to razlikuje dva re rada: ava ima korisni ki reim (user mode) i sistemski reim (kernel mode, system mode, supervisor mode) rada. Korisni ki programi mogu raditi isklju ivo u korisni kom re rada procesora, sistemski re rada je imu im predvien za OS. Ako korisni ki program pokua izvriti neku operaciju koja je dozvoljena samo u sistemskom re imu rada, kontrola se predaje OS-u. Prilikom sistemskih poziva procesor prelazi iz korisni kog re rada u sistemski, OS obradi poziv pa se procesor vra a u korisni ki re rada. ima im Primer sistemskog poziva u TopSpeed Moduli-2 pod DOS-om :
FROM SYSTEM IMPORT Registers ; FROM Lib IMPORT Dos ; VAR r : Registers ; BEGIN r.AH : = 02H ;

r.DL : = BYTE(A) ; Dos ( r ) END

// // // // // //

broj sistemskog poziva: servisa DOS-a 02H oznaava servis za ispis jednog karaktera na standardni izlaz ekran karaketer koji treba ispisati: parametar sistemskog poziva sistemski poziv

Komandni interpreter (shell)

Operativni sistem je zadu za sistemske pozive. Komandni interpreter interpretira komande en korisnika i izvrava ih oslanjaju i se na sistemske pozive OS-a. To je deo OS-a koji je vidljiv za korisnike ra unara. Npr. u DOS-u to izgleda na slede i na in: komandni interpreter nakon startovanja ispisuje prompt, i eka komande korisnika: C:\TEMP\dir Komandni interpreter je primarni interfejs izmeu korisnika i operativnog sistema.U DOS-u to je fajl COMMAND.COM.

Prekidi (interrupts)
Imamo galvni procesor, koji izvrava programe i imamo IO ureaje (disk,tampa ,skener,itd.). Svaki IO ureaj ima svoj kontroler koji sadr neki slabiji procesor koji je jedino zadu za upravljanje i en tim ureajem i za komunikaciju sa glavnim procesorom. Imamo dve strategije za upravljanje ureajima:

16

1. polling: u odreenim vremenskim intervalima glavni procesor prekida svoj rad i proveri da li neki kontroler ima neku poruku za njega, ako ima, obradi poruku i nastavlja sa radom 2. prekidi (interrupt): glavni procesor radi svoj posao, i ureaji rade svoj posao. Ako ureaj zavri svoj posao ili doe do neke greke, ureaj o tome obavetava glavni procesor zahtevom za prekid (interrupt request). Kada procesor dobije zahtev za prekid, prekida svoj rad, zapamti gde je stao, obradi prekid, pa nastavlja sa radom tamo gde je bio prekinut (ako prekid ne predstavlja neku fatalnu greku, takvu da se rad ne mo nastaviti). e
Primer: Mama kuva ru ak a dete se igra. Ako je polling, mama svakih 10 sekundi proveri ta dete radi i ako neto ne valja onda dotr i da mu pomogne. Ako su interapti onda ga ne proverava. Ali, dete se pose e i po ne da pla e. To je interapt. Mama skine erpe sa poreta (prekine proces pravljenja ru ka) zapamti gde je stala, locira dete (pogleda u tabelu), previje ga i poljubi (obradi prekid), vrati se u kuhinju, seti se gde je stala i nastavi sa kuvanjem. Ako se dete ba unakazilo, mama suspenduje proces pravljenja ru ka i vodi dete na urgentno.

Nedostaci polling strategije: 1. ureaj mora ekati na glavni procesor da bi predao svoju poruku (koja mo biti npr. vrlo e va poruka o greci) na 2. procesor prekida svoj rad u odreenim vremenskim intervalima i kada nema nikakvih poruka Obrada prekida se izvrava po slede em algoritmu: procesor radi svoj zadatak sti zahtev za prekid e sa uva se stanje trenutnog procesa onemogu avaju se dalji prekidi u tabeli prekida (interrupt table - uva adrese procedura za obradu svih mogu ih prekida) tra se adresa procedure za obradu prekida i izvrava se procedura za obradu prekida omogu avaju se dalji prekidi nastavlja se rad na prekinutom procesu

Vrste prekida: 1. Hardverski prekidi generiu se od strane hardvera, mogu biti: 1. prekidi koji se mogu maskirati (maskable interrupt) ove prekide procesor mo ignorisati ako je dobio takvu naredbu (npr. pritisnuta je e tipka na tastaturi) 2. prekidi koji se ne mogu maskirati (non maskable interrupt) prekidi ija obrada ne mo biti odlo to su neke ozbiljne greke hardvera e ena (npr. greka memorije) 2. Softverski prekidi prekidi generisani od strane programa 3. Sistemski pozivi (jesu softverski prekidi) 4. Izuzeci (exceptions) generiu se od strane procesora, npr. ako se pokua deliti sa nulom

17

Jezgro OS-a (kernel,nucleus,core)

Jezgro je deo operativnog sistema, koji obavlja najbitnije operacije: upravljanje prekidima kreiranje i unitavanje procesa odabiranje procesa iz liste spremnih procesa (context switch) suspenzija i nastavljanje procesa sinhronizacija procesa komunikacija izmeu procesa manipulacije sa PCB-om podrka za ulaz/izlaz (IO) upravljanje memorijom upravljanje fajl sistemom, itd.

Dizajn, struktura operativnih sistema

Monolitni sistemi (monolithic systems)

U prolosti monolitni sistemi su predstavljali naj e u organizaciju OS-a. Ovaj na in organizacije OS-a dobio je naziv The Big Mess velika zbrka, vide emo zato. OS je realizovan kao skup procedura, od kojih svaka mo pozvati svaku ako je to potrebno. Korisni ki programi servise OS-a e koriste na slede i na in: parametri sistemskog poziva se smetaju u odreena mesta, kao to su registri procesora ili stek, pa sledi specijalna operacija poziv jezgra OS-a (kernel call). Ova operacija prebacuje procesor iz korisni kog reima rada u sistemski reim rada i kontrolu predaje OS-u. U korisni kom re imu rada nisu dozvoljene neke komande procesora, a u sistemskom re imu mogu se koristiti sve operacije poznate od strane procesora. Posle poziva jezgru, OS preuzima kontrolu, na osnovu parametara poziva odreuje koju sistemsku proceduru treba pozvati i poziva tu proceduru i na kraju se kontrola vra a korisni kom programu. Zna i OS ima slede u strukturu (sastoji se od 3 sloja): 1. glavni program koji obrauje sistemske pozive 2. skup sistemskih procedura koje se pozivaju prilikom sistemskih poziva 3. skup pomo nih procedura koje se koriste od strane sistemskih procedura

18

korisni ki programi, korisni ki re im

Slojevita realizacija (layered systems)

Kod slojevite realizacije OS se deli na razli ite slojeve na hijerarhijski na in: svaki sloj se gradi na slojeve ispod njega. Prvi OS koji je napravljen na ovaj na in je OS sa imemom THE (Technische Hogeschool Eindhoven) od strane E.W.Dijkstre. THE se sajtojao od 6 sloja na slede i na in:

5. 4. 3. 2. 1. 0.

komandni interpreter korisni ki programi ulazne,izlazne operacije procesi upravljanje memorijom procesor i multiprogramming

Nulti sloj se bavi upravljanjem procesora, obezbeuje prebacivanje izmeu razli itih procesa. Prvi sloj upravlja memorijom: zauzima potrebnu memoriju za procese. Slojevi iznad prvog sloja ne treba da brinu o memorijskim potrebama, to e umesto njih uraditi prvi sloj. Drugi sloj upravlja komunikacijom izmeu razli itih procesa i komandnog interpretatora. Tre i sloj obavlja ulazno\izlazne operacije. Slojevi 0..3 predstavljaju jezgro OS-a i rade u sistemskom re rada. imu Na etvrtom nivou imamo korisni ke programe oni ne treba da se brinu ni oko procesa, memorije,komandnog interpretera, IO operacija, sve to obavljaju slojevi ispod. Zna i bitna razlika izme u monolitne i slojevite realizacije je u tome, to se OS kod monolitne strukture sastoji od skupa procedura bez ikakvog grupisanja ili hijerarhije, a kod slojevite realizacije OS se deli na vie slojeva od kojih se svaki oslanja na slojeve ispod, i gde svaki sloj ima ta no odreenu funkciju (upravlja ta no odreenim resursima).

19

Kod MULTICS sistema umesto slojeva, koriste se koncetri ni prstenovi. Kada neka procedura iz ve eg (spoljanijeg) prstena pozvati neki servis nekog manjeg (unutranijeg) prstena to e uraditi eli pomo u poziva koji je sli an sistemkim pozivima.

Virtuelne ma ine (virtual machines)

Struktura virtuelnih maina je izraena od strane firme IBM na slede i na in: imamo na najni em nivou hardver, iznad hardvera imamo sistem koji se zove monitor virtuelnih ma ina (virtual machine monitor) i koji obezbeuje niz virtuelnih ma ina - to nisu proirene maine kao operativni sistemi koji pru niz proirenih i jednostavnijih operacija za pristup hardveru, ve su ta ne kopije hardvera ispod aju monitora virtuelnih maina. Zatim se na te virtuelne maine mogu biti instalirani operativni sistemi koji mogu biti i razli iti. Sistemske pozive korisni kih programa primaju odgovaraju i operativni sistemi, a hardverske operacije koje alju ti OS-ovi prema svojim virtuelnim mainama hvata monitor virtuelnih maina i realizuje ih u skladu sa hardverom ispod sebe. Kao primer mo emo navesti IBM-ov VM/370.

aplikacija 1 operativni sistem 1

aplikacija 2 operativni sistem 2 monitor virtuelnih maina HARDVER

aplikacija 3 operativni sistem 3

Klijent-server model (client-server model)

U ovom modelu, procese delimo na dve vrste: klijent procesi (client process) predstavljaju procese korisnika i server procesi (server process) koji su zadu za obradu klijentskih procesa. I eni klijentni i serverski procesi rade u korisni kom re imu rada. Kernel OS-a je zadu za komunikaciju en izmeu klijentskih i serverskih procesa. Server procesi su delovi OS-a i grupisani su prema tome koje funkcije obavljaju: proces serveri (zadu za procese), fajl serveri (zadu za fajl sistem), serveri eni eni memorije itd. Svi serveri rade u korisni kom re imu, pa nemaju direktan pristup hardveru. Prednosti ovog modela: 1. OS je razbijen na manje delove (servere) koji se mogu odr avati nezavisno 2. ako doe do greke u nekom serveru, ne mora pasti i ceo sistem 3. pogodan je za pravljenje distribuiranog sistema: razli iti serveri mogu se izvravati na razli itim ra unarima (koji su naravno povezani), kada neki klijent proces poalje neku poruku nekom serverskom procesu, ne treba da vodi ra una o tome, kako e sti i poruka do servera, to je zadatak kernela. Isto tako, kernel e znati kako da vrati odgovor. Postoji jo jedna stvar kod ovog modela, o emu treba voditi ra una: neke funkcije OS-a ne mogu se ili se teko mogu realizovati u korisni kom re imu rada. Imamo dve mogu nosti da reimo ovaj problem: 1. imamo neke kriti ne server procese koji se izvravaju u sistemskom re imu rada i imaju direktan pristup harveru, ali sa ostalim procesima komuniciraju kao to se to radi u ovom modelu

20

2. neke kriti ne mehanizme ugraujemo u sam kernel, a pravimo server u korisni kom re imu koji sadr samo interfejs tih operacija i klijentni proces 1 klijentni proces 2 server procesa server memorije

fajl server

.........

KERNEL

21

SINHRONIZACIJA PROCESA

Kriti na oblast (critical section)

Posmatrajmo slede i primer: imamo dva terminala A i B. Na oba terminala po jedan proces. Ti procesi vode ra una o broju pritiskanja tipke ENTER. Taj broj se uva u zajedni koj promenljivoj broja . Program tih procesa je dat pomo u slede eg pseudo-koda: ako se pritisne ENTER: 1. uzmi vrednost brojaa 2. poveaj vrednost za 1 3. vrati novu vrednost u broja Posmatrajmo sada slede u situaciju: neka je broja =5, i neka se na terminalu A pritisne ENTER, proces A uzima vrednost broja a i pove ava je za jedan u tom trenutku se zbog ne ega doe do zastoja u izvravanju procesa A. Sada, dok proces A eka, neka se pritisne ENTER na drugom terminalu i neka proces B izvri sva tri koraka tada e vrednost broja a biti 6. Neka sada proces A nastavi sa radom. Zna i on je primio za vrednost broja a 5, pove ao je za jedan i postavio vrednost broja a na 6. Dva puta je pritisnut ENTER, a broja ima vrednost 6!! Ovu greku mo emo izbe i tako to emo zabraniti procesu B (A) da ue u deo gde pristupa broja u ako je drugi proces ve uao u taj deo. Zna i, proces B e da sa eka da proces A zavri svoj rad sa zajedni kom promenljivom i tek e tada po eti sa radom. Kriti na oblast (critical section) je deo programskog koda za koji va ako je neki proces i: unutar svoje kriti ne oblasti, ni jedan drugi proces ne sme biti unutar svoje kriti ne oblasti. Drugim re ima, proces ne sme biti prekinut dok se nalazi u svojoj kriti noj oblasti. Kriti na oblast se posmatra kao neprekidiv niz operacija (kao jedna primitivna operacija). Odreivanje dela programskog koda koji predstavlja kriti nu oblast je zadatak programera. Kriti na oblast mo se realizovati : e - softverski - hardverski - pomo u operativnog sistema (sistemski pozivi)

22

Softverska realizacija kriti ne oblasti

Pretpostavke i osobine softverskog reenja : 0. Unutar kriti ne oblasti istovremeno mo se nalaziti najvie do jedan proces. e 1. Kriti na oblast se realizuje softverski bez pomo i operativnog sistema. 2. Prilikom razvoja programa ne uzimamo u obzir pretpostavke ni o brzini, ni o broju procesora. 3. Ni jedan proces koji je izvan svoje kriti ne oblasti ne sme spre iti druge procese da uu u svoje kriti ne oblasti. Jedino proces unutar kriti ne oblasti mo spre iti ostale e procese da uu u k.o. 4. Ni jedan proces ne sme neograni eno dugo ekati da ue u svoju kriti nu oblast. Algoritam mora garantovati svakom procesu mogu nost ulaska u kriti nu oblast. Slede i primeri ilustruju probleme softverske realizacije kriti ne oblasti. Svi programi su dati pomo u pseudo-koda:
MODULE Version1 ; VAR processNumber : CARDINAL ; // teki proces // pomona promenljiva

PROCEDURE Process1 ; // prvi laki proces BEGIN LOOP WHILE processNumber = 2 DO END ; // ekamo dok je red na P2 KriticnaOblast1 ; processNumber := 2 ; OstaleStvari1 END END Process1 ; PROCEDURE Process2 ; BEGIN LOOP WHILE processNumber = 1 DO END ; KriticnaOblast2 ; processNumber := 1 ; OstaleStvari2 END END Process2 ; BEGIN processNumber := 1 ; PARBEGIN ; Process1 ; Process2 ; PAREND END Version1. // drugi laki proces // ekamo dok je red na P1

23

Sadr pomo ne promenljive processNumber je index onog procesa koji se nalazi u kriti noj aj oblasti. PARBEGIN i PAREND su pseudo-naredbe. Ozna avaju da procedure koje se pozivaju izmeu njih treba izvravati paralelno. Analiza: ovaj algoritam radi dobro: istovremeno mo biti najvie do jedan proces u svojoj e kriti noj oblasti. Nedostatak ovog algoritma je: procesi ulaze u svoje k.o. alternativno, tj u slede em redosledu: Process1, Process2, Process1, Process2,... Obja njenje: poto smo na po etku stavili processNumber:=1, sigurno e Process1 biti prvi, koji e u i u k.o., prilikom izlaska iz k.o., on e staviti processNumber:=2 i time onemogu iti sebi da ue u k.o, odnosno dozvoli e da Process2 ue u k.o. Neka sada Process2 ue u k.o, pa prilikom izlaska stavi processNumber:=1 i neka sada ovaj proces zaglavi u delu OstaleStvari2 dovoljno dugo vremena, da Process1 ue i izae iz k.o. Sada je processNumber=2 (to je postavio Process1), Process2 radi neto to dugo traje u delu OstaleStvari2 to zna i da nije unutar kriti ne oblasti, pa bi Process1 mogao slobodno u i, ali ne mo jer je e processNumber=2, to zna i da mora sa ekati da Process2 zavri sa radom i da ponovo ue i izae iz svoje kriti ne oblasti.
MODULE Version2 ; VAR P1_INSIDE, P2_INSIDE : BOOLEAN ; PROCEDURE Process1 ; BEGIN LOOP WHILE P2_INSIDE DO END ; P1_INSIDE := TRUE ; KriticnaOblast1 ; P1_INSIDE := FALSE ; OstaleStvari1 END END Process1; PROCEDURE Process2 ; BEGIN LOOP WHILE P1_INSIDE DO END ; P2_INSIDE := TRUE ; KriticnaOblast2 ; P2_INSIDE := FALSE ; OstaleStvari2 END END Process2; BEGIN P1_INSIDE := FALSE ; P2_INSIDE := FALSE ; PARBEGIN ; Process1 ; Process2 ; PAREND END Version2.

// ekamo dok je P2 unutra // ulazimo // izlazimo

// ekamo dok je P1 unutra // ulazimo // izlazimo

24

Analiza: uvoenjem dve logi ke promenljive P1_INSIDE i P2_INSIDE (imaju vrednost TRUE, ako su odgovaraju i procesi unutar svojih k.o.) reili smo problem alternativnog izvravanja, ali smo dobili algoritam koji ne radi!! Obja njenje: krenimo od po etka: P1_INSIDE:=FALSE, P2_INSIDE:=FALSE. Pp. da je Process1 stigao prvi do WHILE petlje, on odmah ide i dalje, poto je P2_INSIDE=FALSE, neka u ovom trenutku i Process2 doe do WHILE petlje, i on e nastaviti sa radom, poto je jo uvek P1_INSIDE=FALSE i dobili smo da e oba procesa istovremeno u i u k.o. Zna i do problema dolazimo, ako se proces prekine izmeu WHILE petlje i reda Px_INSIDE:=TRUE.

MODULE Version3 ; VAR p1WantsToEnter, p2WantsToEnter : BOOLEAN ; PROCEDURE Process1 ; BEGIN LOOP p1WantsToEnter := TRUE ; WHILE p2WantsToEnter DO END ; KriticnaOblast1 ; p1WantsToEnter := FALSE ; OstaleStvari1 END END Process1; PROCEDURE Process2 ; BEGIN LOOP p2WantsToEnter := TRUE ; WHILE p1WantsToEnter DO END ; KriticnaOblast2 ; p2WantsToEnter := FALSE ; OstaleStvari2 END END Process2; BEGIN p1WantsToEnter := FALSE ; p2WantsToEnter := FALSE ; PARBEGIN ; Process1 ; Process2 ; PAREND END Version3.

// javimo da P1 eli ui // dok P2 eli ui, ekamo // izlazimo

// javimo da P2 eli ui // dok P1 eli ui, ekamo // izlazimo

Promenljive p1WantsToEnter i p2WantsToEnter ozna avaju da odgovaraju i proces u i u eli kriti nu oblast. Analiza: algoritam ne radi!! Obja njenje: pp. da se procesi izvravaju istovremeno Process1 e staviti p1WantsToEnter:=TRUE a Process2 stavlja p2WantsToEnter:=TRUE. Zatim e oba procesa zaglaviti unutar WHILE petlje: Process1 e ekati na Process2 i obrnuto to se zove zaglavljivanje (dead lock). Oba procesa ekaju na neki dogaaj koji se nikada ne e desiti.

25

MODULE Version4 ; VAR p1WantsToEnter, p2WantsToEnter : BOOLEAN ; PROCEDURE Process1 ; BEGIN LOOP p1WantsToEnter := TRUE ; WHILE p2WantsToEnter DO p1WantsToEnter := FALSE ; DELAY ( maliInterval1 ) ; p1WantsToEnter := TRUE END; KriticnaOblast1 ; p1WantsToEnter := FALSE ; OstaleStvari1 END END Process1; PROCEDURE Process2 ; BEGIN LOOP p2WantsToEnter := TRUE ; WHILE p1WantsToEnter DO p2WantsToEnter := FALSE ; DELAY ( maliInterval2 ) ; p2WantsToEnter := TRUE END; KriticnaOblast2 ; p2WantsToEnter := FALSE ; OstaleStvari2 END END Process2; BEGIN p1WantsToEnter := FALSE ; p2WantsToEnter := FALSE ; PARBEGIN ; Process1 ; Process2 ; PAREND END Version4.

// // // // //

javimo da P1 eli ui sve dok P2 eli ui odustajemo od toga da P1 ue ekamo malo,da to P2 primeti javimo da P1 eli ui

// izlazimo

// // // // //

javimo da P2 eli ui sve dok P1 eli ui odustajemo od toga da P2 ue ekamo malo,da to P1 primeti javimo da P2 eli ui

// izlazimo

Analiza: ova verzija zamalo da radi, ali postoji mogu nost greke. Pp. da se procesi izvravaju paralelno: Process1 stavlja p1WantsToEnter:=TRUE, Process2 stavlja p2WantsToEnter:=TRUE, zatim oba procesa uu u WHILE petlju, oba procesa za neko vreme odustaju od ulaska u k.o. Process1 eka u trajanju maliInterval1 a Process2 u trajanju maliInterval2. Neka generatori slu ajnih brojeva generiu iste vrednosti, tj neka je maliInterval1=maliInterval2, tada e ponovo biti p1WantsToEnter:=TRUE i p2WantsToEnter:=TRUE i sve po injemo iz po etka. Zna i, mada je mala verovatno a da oba generatora slu ajnih brojeva izgeneriu isti niz vrednosti, postoji mogu nost da ovaj algoritam ne radi i da doe do zaglavljivanja (dead lock) a to mo dovesti do vrlo e ozbiljnih greaka npr. ako se algoritam koristi za upravljanje nuklearnom elektranom, saobra ajem itd.

26

Do zaglavljivanja dolazimo i ako se procesi izvravaju ba alternativno: izvrimo jednu naredbu prvog procesa, pa jednu naredbu drugog procesa, pa jednu naredbu prvog, itd.

Dekkerov algoritam
MODULE Dekker ; VAR p1WantsToEnter, p2WantsToEnter : BOOLEAN ; favouredProcess : ( first,second ) ;

PROCEDURE Process1 ; BEGIN LOOP p1WantsToEnter := TRUE ; // P1 javlja da eli ui WHILE p2WantsToEnter DO // sve dok P2 eli ui IF favouredProcess = second THEN // ako P2 ima prednost p1WantsToEnter := FALSE ; // P1 odustaje WHILE favouredProcess = second DO END; // eka prednost p1WantsToEnter := TRUE // pa javi da eli ui END END; KriticnaOblast1 ; favouredProcess := second ; // prednost dajemo P2-u p1WantsToEnter := FALSE ; // izlaz OstaleStvari1 END END Process1; PROCEDURE Process2 ; BEGIN LOOP p2WantsToEnter := TRUE ; // P2 javlja da eli ui WHILE p1WantsToEnter DO // sve dok P1 eli ui IF favouredProcess = first THEN // ako P1 ima prednost p2WantsToEnter := FALSE ; // P2 odustaje WHILE favouredProcess = first DO END ; // eka prednost p2WantsToEnter := TRUE // pa javi da eli ui END END; KriticnaOblast2 ; favouredProcess := first ; // prednost dajemo P1-u p2WantsToEnter := FALSE ; // izlaz OstaleStvari2 END END Process2; BEGIN p1WantsToEnter := FALSE ; p2WantsToEnter := FALSE ; favouredProcess := first ; PARBEGIN ; Process1 ;

27

Process2 ; PAREND END Dekker.

Analiza: u emu je razlika izme u Dekkerovog algoritma i Verzije 4? Kod Dekkerovog algoritma uvodi se jo jedna pomo na promenljiva, favouredProcess, koja ozna ava koji proces ima prednost (tj. ve i prioritet). Ne mogu oba procesa istovremeno u i u kriti nu oblast (greka druge verzije): pp. da oba procesa istovremeno daju zahtev za ulazak poto postoji prioritet procesa, u i e onaj koji ima ve i prioritet, a drugi e odustati od ulaska i ekati u WHILE petlji dok dobije prednost. Tada drugi proces ulazi u k.o. a prvi e ekati. Nema zaglavljivanja (greka tre e verzije): proces koji nema prednost odusta e od toga da ue u k.o. time e omogu iti drugom procesu da ue. Nema zaglavljivanja (greka etvrte verzije): poto prilikom ekanja umesto generatora slu ajnih brojeva proveravamo da li smo dobili prednost, ne mo do i do zaglavljivanja. e Nema alternacije (greka prve verzije): zato to umesto jedne pomo ne promenljive (processNumber) koristimo dve logi ke: p1WantsToEnter, p2WantsToEnter. Dekkerov algoritam (1965) je dugo bio najbolje re enje za softversku realizaciju sinhronizacije. 1981 Petersen objavljuje novo, kra e i lepe reenje.

Petersenov algoritam
MODULE Petersen ; VAR p1WantsToEnter, p2WantsToEnter : BOOLEAN ; favouredProcess : ( first,second ) ;

PROCEDURE Process1 ; BEGIN LOOP p1WantsToEnter := TRUE ; // javimo da P1 eli ui favouredProcess := second ; // dajemo prednost drugom proc. WHILE p2WantsToEnter AND // sve dok P2 eli ui i ( favouredProcess = second ) DO END ; // P2 ima prednost // ekamo KriticnaOblast1 ; p1WantsToEnter := FALSE ; // izlaz OstaleStvari1 END END Process1; PROCEDURE Process2 ; BEGIN LOOP p2WantsToEnter := TRUE ; // favouredProcess := first ; // WHILE p1WantsToEnter AND // ( favouredProcess = first ) KriticnaOblast2 ;

javimo da P2 eli ui dajemo prednost prvom proc. sve dok P1 eli ui i DO END ; // P1 ima prednost // ekamo

28

p2WantsToEnter := FALSE ; OstaleStvari2 END END Process2 ; BEGIN p1WantsToEnter := FALSE ; p2WantsToEnter := FALSE ; favouredProcess := first ; PARBEGIN ; Process1 ; Process2 ; PAREND END Petersen ;

// izlaz

Analiza: Petersenov algoritam koristi iste pomo ne procedure kao i Dekkerov algoritam, ali je kod mnogo jednostavniji. Proverimo da li izbegava greke prethodnih algoritama: Ne mogu oba procesa istovremeno u i u kriti nu oblast (greka druge verzije): zbog pomo ne promenljive favouredProcess uvek e u i samo jedan i to onaj proces koji ima prednost. Nema zaglavljivanja (greka tre e verzije): proces koji nema prednost, ne odustaje ali e i dalje ekati na prednost. Drugi proces e mo i u i u k.o jer ima prednost, pa e vrednost logi kog izraza u WHILE petlji biti: TRUE AND FALSE, a to je FALSE, to zna i da proces mo u i u k.o. e Nema zaglavljivanja (greka etvrte verzije): poto ne mo biti istovremeno e favouredProcess=first i favouredProcess=second, tj. ne mogu oba procesa istovremeno imati prednost (jer promenljiva favouredProcess ne mo imati istovremeno dve vrednosti, ili je first ili je second) ne e postoji mogu nost da oba procesa neograni eno dugo ostanu unutar WHILE petlje. Nema alternacije (greka prve verzije): neka se Process2 zaglavi u deo OstaleStvari2 dovoljno dugo, da Process1 krene iz po etka. Tada je p2WantToEnter=FALSE, p1WantToEnter=TRUE, favouredProcess=second, vrednost logi kog izraza WHILE petlje prvog procesa bi e FALSE AND TRUE = FALSE, pa Process1 mo ponovo u i u k.o. a da ne eka na Process2. e

Hardverska realizacija kriti ne oblasti

Kriti na oblast mo se implementirati i na nivou harvera ako postoji procesorska instrukcija e koja to podr ava. Neka je to npr. naredba TestAndSet ( a,b ), koja radi slede e tri stvari: 1. ita vrednost logi ke promenljive b 2. kopira tu vrednost u logi ku promenljivu a 3. postavlja vrednost promenljive b na TRUE Kako je TestAndSet naredba procesora, ona se izvrava kao jedna operacija, tj. ne mo biti e prekinuta. Operacija TestAndSet garantuje, da promenljivama a i b istovremeno moe pristupiti samo jedan procesor, to zna i da se ova operacija ne moe biti paralelno izvr ena na vi e 29

procesora. (u praksi a predstavlja neki registar procesora, a b neku memorijsku lokaciju) Sada, kada imamo podrku hardvera za realizaciju kriti ne oblasti, mo emo koristiti slede i algoritam:

MODULE TAS ; VAR inside : BOOLEAN ; // globalna pomona promenljiva

PROCEDURE Process1 ; VAR firstCannotEnter : BOOLEAN ; // lokalna pomona promenljiva BEGIN LOOP firstCannotEnter := TRUE ; // javimo da P1 ne moe ui WHILE firstCannotEnter DO // sve dok P1 ne moe ui TestAndSet(firstCannotEnter,inside) // nedeljiva operacija END; KriticnaOblast1 ; inside := FALSE ; // izlaz OstaleStvari1 END END Process1; PROCEDURE Process2 ; VAR secondCannotEnter : BOOLEAN ; // lokalna pomona promenljiva BEGIN LOOP secondCannotEnter := TRUE ; // javimo da P2 ne moe ui WHILE secondCannotEnter DO // sve dok P2 ne moe ui TestAndSet(secondCannotEnter,inside) // nedeljiva operacija END; KriticnaOblast2 ; inside := FALSE ; // izlaz OstaleStvari2 END END Process2; BEGIN active := FALSE ; PARBEGIN ; Process1 ; Process2 ; PAREND END TAS.

Analiza: kod ovog algoritma koristimo jednu globalnu pomo nu promenljivu inside koja ozna ava, da li se neki proces nalazi unutar svoje kriti ne oblasti. Pored te globalne, svaki proces ima i jednu pomo nu promenljivu, koja ozna ava da li dati proces mo u i u k.o. e Ne mogu oba procesa istovremeno u i u kriti nu oblast (greka druge verzije): pp. da oba procesa stignu istovremeno do WHILE petlje. Tada je inside=FALSE, firstCannotEnter=TRUE, secondCannotEnter=TRUE. Oba procesa e u i u petlju, ali poto je naredba TestAndSet nedeljiva, i garantuje da se ne mo paralelno izvravati na vie procesora, sigurno je da e samo jedan proces uspeti e da je izvri. Neka je to Process1. Tada e biti firstCannotEnter=FALSE i inside=TRUE. to zna i, da e 30

Process1 u i u kriti nu oblast. Za sve ostale procese e va inside=TRUE, pa e svaka pomo na iti lokalna promenljiva uzeti tu vrednost, i ti procesi e i dalje ekati unutar WHILE petlje. Nema zaglavljivanja (greka tre e verzije): zbog nedeljivosti naredbe TestAndSet. Nema zaglavljivanja (greka etvrte verzije): ne postoji mogu nost da nakon prvog ulaska u WHILE petlju istovremeno bude firstCannotEnter=TRUE i secondCannotEnter=TRUE zbog naredbe TestAndSet i zbog toga to je inside=FALSE. Nema alternacije (greka prve verzije): neka se Process2 dovoljno dugo zaglavi, tako da Process1 stigne ponovo do WHILE petlje. Tada je firstCannotEnter=TRUE i inside=FALSE (Process1 je postavio ovu vrednost, poto je ve jednom uao i izaao iz svoje k.o.). Tada e Process1 jednom u i u WHILE petlju, ali e posle instrukcije TestAndSet biti firstCannotEnter=FALSE i inside=TRUE, pa e ponovo u i.

Realizacija pomou sistemskih poziva

Nedostatak i softverske i hardverske realizacije je to to se dolazi do pojave koja se zove busy waiting (zaposleno ekanje): proces se neprestano vrti unutar WHILE petlje, ne radi nita korisno, svaki put samo proverava vrednost neke promenljive da bi saznao da li mo u i u svoju kriti nu oblast ili ne. e Zna i i pored toga to dati proces ne radi nita korisno, troi procesorsko vreme, a poto znamo da unutar kriti ne oblasti istovremeno mo biti samo jedan proces, mo e emo zamisliti i situaciju da imamo 1001 procesa od kojih se jedan nalazi unutar k.o, a ostali stoje u jednom mestu, vrte se u krugu unutar WHILE petlje. Tako imamo jedan proces koji radi neto korisno i 1000 procesa koji ekaju i na taj jedan troe procesorsko vreme. Drugi nedostatak prethodnih realizacija je u tome to ne vode ra una o prioritetima procesa: mo se desiti da najprioritetniji proces ue u kriti nu oblast, tek posle mnotva neprioritetnih procesa. e Da bismo izbegli ove nedostatke softverske i hardverske realizacije, koristi emo pomo operativnog sistema, tj. kriti nu oblast emo realizovati pomo u sistemskih poziva. Kod ove realizacije, kada proces eka da ue u kriti nu oblast, postaje blokiran (blocked), sve dok ga neki drugi proces ne odblokira. Sve varijante sinhronizacije procesa pomo u sistemskih poziva ilustrova emo na PROBLEMU PROIZVO A A I POTRO A (The Producer-Consumer Problem): imamo jednog proizvoa a i A jednog potroa a. Proizvoa neto proizvodi to je proces koji puni neki bafer. Potroa troi ono to je proizvoac proizveo to je proces koji prazni bafer (uzima elemente iz bafera). Proizvoa mo da e proizvodi dok skladite (bafer) ne postane pun, a potroa mo da troi dok skladite (bafer) ne postane e prazan. U tim situacijama, proizvoa odnosno potroa odlazi na spavanje.

31

Sleep & WakeUp

Kod ove realizacije koristimo dva sistemska poziva: Sleep (spavaj) i WakeUp (probudi se). Sistemski poziv Sleep blokira onog procesa koji ga je pozvao, a WakeUp ( x ) probuuje procesa x . U slu aju problema proizvoa a i potroa a, ove pozive koristimo na slede i na in: Kada proizvoa vidi da nema mesta u baferu, ode da spava (postaje blokiran) pomo u naredbe Sleep u tom stanju ostaje sve dok ga potroa ne probudi. Kada potroa vidi da je bafer prazan, odlazi na spavanje u tom stanju ostaje sve dok ga proizvoa ne probudi. Proizvoa e probuditi potroa a kada stavi prvi elemenat u bafer to zna i da je pre toga bafer bio prazan, pa potroa spava. Potroa e probuditi proizvoa a kada konstatuje da je zaspao, a ima mesta u baferu.

MODULE Sleep&WakeUp ; CONST n = 100 ; VAR // veliina bafera

count : CARDINAL ; // broj elemenata u baferu bafer : ARRAY [1..n] OF INTEGER ;

PROCEDURE Producer ; // proizvoa VAR item : INTEGER ; BEGIN LOOP ProduceItem ( item ) ; // proizvodi elemenat IF count = n THEN // ako je bafer pun, Sleep // spavaj END; EnterItem ( bafer,item ) ; // inae, ubaci elemenat u bafer INC ( count ) ; // poveaj broja IF count = 1 THEN // ako smo stavili prvi elemenat, WakeUp ( Consumer ) // probudi potroaa, poto je spavao END END END Producer ; PROCEDURE Consumer ; // potroa VAR item : INTEGER ; BEGIN LOOP IF count = 0 THEN // ako je bafer prazan, Sleep // spavaj END; RemoveItem ( bafer, item ) ; // inae, uzmi elemenat iz bafera DEC ( count ) ; // smanji broja IF count = n-1 THEN // ako je bafer bio pun, WakeUp ( Producer ) // probudi proizvoaa END; ConsumeItem ( item ) // radi neto sa preuzetom elementom END END Consumer ; BEGIN count := 0 ;

32

Init ( bafer ) ; PARBEGIN ; Producer ; Consumer ; PAREND END Sleep&WakeUp ;

Analiza: algoritam ne radi!! Obja njenje: posmatrajmo slede u situaciju: neka je bafer prazan, tada je count=0, neka se izvrava proces potroa a. Potroa pogleda vrednost count-a, vidi da je nula, i ue unutar IF naredbe. Neka se u tom trenutku, potroa prekida (pre nego to izvri naredbu Sleep) , i procesorsko vreme se daje proizvoa u. Proizvoa proizvodi jedan elemenat, vidi da bafer nije pun, stavi elemenat u bafer i pove a broja za jedan. Tada primeti da je pre toga bafer bio prazan, pa shvati da je potroa zaspao (tu je problem: potroa je bio prekinut pre nego to je uspeo da zaspi) i pokua ga probuditi. Po to potro a jo ne spava, ta informacija se gubi. Sada potroa ponovo dobije procesor i ode da spava poto je ubeen da je bafer prazan. Nakon izvesnog vremena, proizvoa e napuniti bafer do kraja i odlazi na spavanje eka potroa a da ga probudi. I tako, i potroa i proizvoa spavaju do beskona nosti..., tj. javlja se zaglavljivanje (deadlock). U emu je problem? Problem je u kori enju zajedni ke, globalne promenljive count!! Da bi sinhronizacija bila uspena, pristup toj promenljivoj treba da bude unutar kriti ne oblasti!! (unutar kriti ne oblasti istovremeno mo biti samo jedan proces) to u ovom slu aju ne va e i.

Semafori (semaphores)
Kori enje semafora za sinhronizaciju procesa predlo je Dijkstra (1965). Semafor je apstraktni io tip podataka, koji se koristi kao broja buenja. Ako je vrednost semafora nula (0), to zna i da nije dolo do buenja, ako je vrednost semafora pozitivan broj, ozna ava broj sa uvanih buenja. Nad semaforima definiemo dve nedeljive operacije: Up (S) i Down (S). Operacija Down (S) radi na slede i na in: uzima vrednost semafora S i proverava da li je ta vrednost ve a od nule (u tom slu aju imamo sa uvanih buenja) ako jeste, smanjuje vrednost semafora za jedan i vra a kontrolu. Ako je vrednost semafora S jednak nuli, to zna i da nemamo vie sa uvanih buenja, proces odlazi na spavanje. Operacija Down, mo se posmatrati kao generalizacija operacije e Sleep. Operacija Up (S) radi na slede i na in: ako neki procesi spavaju ekaju na semaforu S probuuje jedan od tih procesa. Izbor procesa je zadatak operativnog sistema (mo biti slu ajan). U e ovom slu aju se vrednost semafora S ne menja, tj. ostaje nula, ali emo imati za jedan manji broj spavaju ih procesa. Ako je vrednost semafora S ve a od nule, tada se samo pove ava ta vrednost za jedan. Operacija Up mo se posmatrati kao generalizacija operacije WakeUp. e Vano je zapamtiti da su operacije Down i Up nedeljive, tj. ako smo po eli sa izvravanjem, ne mo emo biti prekinuti dok ne budemo zavrili. Rad ovih naredbi mo emo opisati pomo u slede ih pseudo-kodova:

Down ( s ) :

IF s > 0 THEN DEC ( s ) ELSE uspavaj proces koji je pozvao Down ( s ) END;

33

Up ( s ) :

IF ima uspavanih procesa na semaforu s THEN probudi jedan od procesa koji ekaju na semaforu s ELSE INC ( s ) END;

Pored gore navedenih operacija, mo emo definisati i slede e dve: - Init (S,n) inicijalizuje semafor S sa vredno u n, - Value (S) vra a vrednost semafora S. BINARNI SEMAFORI predstavljaju poseban tip semafora koji se inicijalizuju sa 1 (jedan) i koji se koriste za spre avanje ulaska vie od jednog procesa u kriti nu oblast. Ako svaki proces pre ulaska u svoju k.o. pozove Down i nakon izlaska pozove Up, binarni semafori garantuju me usobno isklju ivanje (mutual exlusion) zbog toga se ti semafori esto ozna avaju sa imenom mutex (od MUTual EXclusion). Vrednost binarnih semafora mo biti samo 1 ili 0 i imaju slede e zna enje: e 0 neki proces je unutar kriti ne oblasti 1 ni jedan proces nije unutar kriti ne oblasti Kako do pove avanja mutex semafora dolazi samo pri izlasku iz kriti ne oblasti naredbom Up, ne mo dobiti vrednost ve u od 1, poto da bi neki proces izaao iz k.o., mora najpre da ue, a pri ulasku e poziva naredbu Down, koja e ili smanjiti za 1 vrednost mutex-a ili e (ako je ve 0) proces biti poslat na spavanje a znamo da se mutex inicijalizuje sa 1. Problem proizvoa a i potroa a se pomo u semafora reava na slede i na in:

MODULE Semaphores ; CONST n = 100 ; VAR bafer : ARRAY [1..n] OF INTEGER ; mutex,empty,full : Semaphore ;

// semafori

PROCEDURE Producer ; // proizvoa VAR item : INTEGER ; BEGIN LOOP ProduceItem ( item ) ; // proizvodi elemenat Down ( empty ) ; // ako nema slobodnog mesta, ekaj Down ( mutex ) ; // ako je neko unutar k.o., ekaj EnterItem ( bafer,item ) ; Up ( mutex ) ; // izlazak iz k. o. Up ( full ) // javi, da smo neto stavili u bafer END END Producer ; PROCEDURE Consumer ; VAR item : INTEGER ; BEGIN LOOP // potroa

34

Down ( full ) ; Down ( mutex ) ; RemoveItem ( bafer,item Up ( mutex ) ; Up ( empty ) ; ConsumeItem ( item ) END END Consumer ; BEGIN Init ( mutex,1 ) ; Init ( full,0 ) ; Init ( empty,n ) ; PARBEGIN ; Producer ; Consumer ; PAREND END Semaphores ;

// ako nema nita u baferu, ekamo // ako je ve neko unutar k. o., ekaj ) ; // izlazak iz k.o. // javi, da smo neto vadili iz bafera

Analiza: koristimo 3 semafora: mutex,full,empty. Mutex se inicijalizuje sa 1, to ozna ava da nema procesa unutar k.o., full se inicijalizuje sa 0, ozna ava broj zauzetih mesta u baferu, empty se inicijalizuje sa n, i ozna ava da je broj praznih mesta u baferu n, tj. da je bafer potpuno prazan. Posmatrajmo rad proizvo a a: pozivanjem Down(empty) obezbeujemo, da u slu aju da nema vie slobodnih mesta u baferu (empty=0), proces ode na spavanje, a ako ima, Down(mutex) obezbeuje ulazak u k.o. tek ako nema nikoga unutar, ina e opet spavanje. Izlaskom iz k.o., naredba Up(mutex) javlja potroa u, da mo u i u k.o. mutex je tu sigurno 0, pa ako potroa eka na e mutexu, bi e probuen, ina e mutex postaje 1. Na kraju sledi naredba Up(full), tj javimo da smo stavili neto u bafer, pa ako potroa eka na to, bi e probuen. Posmatrajmo rad potro a a: pozivanjem Down(full) obezbeujemo, da u slu aju da je bafer prazan (full=0), proces ode na spavanje, a ako nije prazan, Down(mutex) obezbeuje ulazak u k.o. tek ako proizvoa nije unutar, ina e opet spavanje. Izlaskom iz k.o., naredba Up(mutex) javlja proizvoa u, da mo u i u k.o., ako (tj. spava na semaforu mutex), ako proizvoa ne u i, bi e e eli eli mutex=1. Na kraju sledi naredba Up(empty), tj. javimo da smo uzeli neto iz bafera, pa ako proizvoa eka na to, bi e probuen. Va je primetiti da ovde koristimo dva tipa semafora: no 1. mutex koristimo da bismo obezbedili da unutar kriti ne oblasti u istom trenutku nalazi najvie do jedan proces 2. empty,full koristimo da bismo obezbedili sinhronizaciju izmeu procesa proizvoa a i procesa potroa a. Ova realizacija radi bez problema to se ti e implementacije semafora, ali pogreno kori enje semafora mo dovesti do ozbiljnih greaka: npr. pp. da je bafer pun, tada ako kod proizvo a a najre e stavimo Down(mutex), pa tek onda Down(empty), dolazimo do slede e situacije: proizvoa je uao u kriti nu oblast i ne mo biti prekinut, a poto je bafer pun, otiao je i na spavanje tada, potroa vidi e da bafer nije prazan, ali e i on zaspati jer ne mo u i u k.o. zbog proizvoa a i tako dolazimo do e zaglavljivanja.

35

Broja i doga aja (event counters)

Broja i dogaaja (event counters, Reed, Kanodia, 1979) predstavljaju apstraktni tip podataka, nad kojim se definiu slede e operacije: 1. 2. 3. 4. Init ( e ) inicijalizuje broja e, Read ( e ) vra a trenutnu vrednost broja a dogaaja e, Advance ( e ) pove ava vrednost broja a e za jedan Await ( e,v ) eka dok vrednost broja a e ne postane ve e ili jednako od v

Vano je napomenuti, da se vrednost broja a dogaaja uvek pove ava, nikada se ne smanjuje, ne mo se podesiti na e eljenu vrednost (vrednost b.d. mo se samo itati i pove avati). Inicijalna vrednost e broja a je nula. Realizacija problema proizvoa a i potroa a pomo u broja a dogaaja izgleda na slede i na in:

MODULE ECounters ; CONST n = 100 ; VAR bafer : ARRAY [1..n] OF INTEGER ; in,out : EventCounter ; PROCEDURE Producer ; VAR item : INTEGER ; count : INTEGER ; // BEGIN count := 0 ; LOOP ProduceItem ( item ) ; INC ( count ) ; Await ( out, count n ); EnterItem ( bafer,item ) ; Advance ( in ) END END Producer;

// brojai dogaaja // proizvoac ukupan broj proizvedenih elemenata

// proizvodi elemenat // poveaj broj proizvedenih elem. // spavaj ako nema mesta u baferu // poveaj broja in za jedan

PROCEDURE Consumer ; // VAR item : INTEGER ; count : INTEGER ; // BEGIN count := 0 ; LOOP INC ( count ) ; Await ( in, count ) ; RemoveItem ( bafer,item ) ; Advance ( out ) ; ConsumeItem ( item ) END END Consumer ;

potroa ukupan broj potroenih elemenata

// poveaj broj potroenih elem. // spavaj, ako je bafer prazan // poveaj broja out za jedan

36

BEGIN Init ( in ) ; Init ( out ) ; PARBEGIN ; Producer ; Consumer PAREND END ECounters.

Analiza: algoritam koristi dva broja a dogaaja: in ozna ava broj ubacivanja u bafer (ukupan broj uba enih elemenata od startovanja programa) , a out broj preuzimanja iz bafera (ukupan broj preuzetih elemenata od startovanja programa). Pri tome mora va da je in uvek ve i ili jednak od out-a (u iti suprotnom, dobijamo da je preuzeto vie elemenata nego to je uba eno, to je nemogu e), ali razlika izmeu in-a i out-a ne sme biti ve a od n, tj. od veli ine bafera (u suprotnom, dolazimo do situacije, da smo ubacili vie elemenata, nego to bafer mo primiti). e Posmatrajmo rad proizvo a a: nakon to proizvoa proizvede novi elemenat, pove a broj proizvedenih elemenata i naredbom Await(out,count-n) proveri da li ima mesta u baferu da stavi novi elemenat. Kada imamo mesto za novi elemenat? Ako je broj slobodnih mesta u baferu ve i od 1, tj ako je potroa potroio barem count-n elemenata (ako je out=count-1, onda je bafer prazan, ako je out=count-2, onda imamo n-1 mesta u baferu,...,ako je out=count-n, onda imamo jedno slobodno mesto u baferu). Rad e sigurno po eti proizvoa , jer se inicijalno stavlja in=0,out=0, pa e va 0=out>=1-n, iti gde je naravno n>=1. Pri izlasku iz kriti ne oblasti, proizvoa javlja da je uspeno ubacio novi elemenat u bafer naredbom Advance(in). Posmatrajmo rad potro a a: u prvom koraku se pove ava broj potroenih elemenata, a zatim se eka da proizvoa proizvede dovoljan broj elemenata sa naredbom Await(in,count), tj. potroa mo uzeti k-ti elemenat iz bafera, tek ako je proizvoa proizveo barem k elemenata. e

Monitori (monitors) i uslovne promenljive (condition variables)

Prilikom analize rada algoritma za reavanja problema proizvoa a i potroa a pomo u semafora uo ili smo da neispravno kori enje semafora (lo redosled) mo dovesti do zaglavljivanja. Semafori e rade savreno, ali ako ih pogreno koristimo mogu se javiti ozbiljne greke u radu programa. Zna i, bilo bi po eljno na i neki mehanizam koji bi olakao pisanje korektnih programa. Upravo je to bila pokreta ka ideja koja je dovela do razvoja koncepta monitora. Monitor predstavlja skup procedura, promenljivih, tipova podataka, konstanti itd. koji su grupisani u specijalni modul ili paket. Kori enje monitora za sinhronizaciju procesa predlo su Hoare ili (1974) i Brinch Hansen (1975). Monitori predstavljaju specijalne module, sa slede im karakteristikama : 1. procedure iz monitora mo istovremeno pozvati najvie do jedan proces, zna i ako je e proces A pozvao neku proceduru monitora X, tada ni jedan drugi proces ne mo pozvati e ni jednu proceduru iz tog monitora, dok ta procedura ne zavri sa radom, 2. procedure monitora se izvravaju bez prekida Monitori nasuprot semafora predstavljaju karakteristiku programskih jezika, a ne operativnih sistema. To zna i da kompajleri tih jezika znaju da sa tim modulima treba raditi na poseban na in: na osnovu prethodnih karakteristika.

37

Pomo u monitora lako mo emo reiti probleme vezanih za kriti ne oblasti: kriti nu oblast ubacimo u monitor a ostalo je zadatak kompajlera. Programski jezici koji podr avaju monitore: Modula-2, Concurrent Pascal, Concurrent Euclid, itd. Monitori predstavljaju dobro reenje za kriti nu oblast, ali to nije dovoljno: potrebno je na i neko reenje i za to da se proces, koji je pozvao neku proceduru iz monitora pree u stanje BLOKIRAN (blocked) ako je to potrebno (npr. ako proizvoa primeti da nema mesta u baferu, treba da ode na spavanje i time omogu i da potroa ue u svoju kriti nu oblast pozivanjem neke procedure iz monitora). Da bismo ovaj problem reili, uvodimo pojam uslovnih promenljivih (condition variables). Uslovne promenljive su globalne promenljive (vidi ih svaki proces), nad kojima se definiu slede e nedeljive operacije (poto su nedeljive, moraju biti unutar monitora!!): 1. Init ( c ) inicijalizuje uslovnu promenljivu c 2. Wait ( c ) blokira (uspava) proces koji je pozvao naredbu Wait na uslovnoj promenljivoj c zna i, ovaj proces postaje blokiran ( eka na signal c), a kontrola se predaje nekom drugom procesu koji sada ve mo u i u kriti nu oblast. e 3. Signal ( c ) alje signal c ostalim procesima ako postoji neki proces koji eka na ovaj signal, treba da se probudi i da nastavi sa radom. Ovde dolazimo do problema, jer izgleda da emo imati dva procesa unutar monitora: jedan koji je pozvao nardbu Signal (c), i drugi koji je ekao na taj signal i sad je probuen. Imamo dva pristupa za reenje ovog problema: Hoare je predlo slede e: neka proces koji je pozvao Signal postaje io suspendovan, a proces koji je probuen nastavi sa radom. Ideja Hansena je slede a: proces koji je pozvao Signal, mora iza i iz monitora, tj. Signal mora biti poslednja naredba odgovaraju e procedure monitora, tako e probueni proces biti jedini u monitoru i mo e nastaviti svoj rad. Mi emo koristiti Hansenovo reenje. Ako nemamo ni jedan proces koji eka na signal c, tekui proces nastavlja sa radom a signal se gubi. 4. Awaited ( c ) vra a logi ku vrednost TRUE, ako neki proces eka (spava) na uslovnoj promenljivoj c, odnosno FALSE, ako takav proces ne postoji Za demonstraciju kori enja monitora za reavanje problema proizvoa a i potroa a koristimo programski jezik Modula-2 (program je zadat u pseudo-kodu) :

DEFINITION MODULE Monitor ; PROCEDURE EnterItem ( item : INTEGER ) ; PROCEDURE RemoveItem ( VAR item : INTEGER ) ; END Monitor.

IMPLEMENTATION MODULE Monitor[1000]; // modul, koji predstavlja monitor CONST n = 100 ; VAR count : CARDINAL ; // index elemenata bafer : ARRAY [1..n] OF INTEGER ; notFull, notEmpty : CondVAR ; // uslovne promenljive, signali PROCEDURE EnterItem ( item : INTEGER ) ; // ubacivanje u bafer BEGIN IF count = n THEN // ako je bafer pun, Wait ( notFull ) // spavamo, dok nam potroa

38

END; INC ( count ) ; bafer [ count ] := item ; IF count = 1 THEN Signal ( notEmpty ) END END EnterItem;

// ne javi, da nije pun

// bafer je bio prazan, // potroa je verovatno spavao // traba ga probuditi

PROCEDURE RemoveItem (VAR item : INTEGER); // izbacivanje iz bafera BEGIN IF count = 0 THEN // ako je bafer prazan, Wait ( notEmpty ) // spavamo, dok nam proizvoa END; // ne javi, da nije prazan item := bafer [ count ] ; DEC ( count ) ; IF count = n-1 THEN // bafer je bio pun, Signal ( notFull ) // proizvoa je verovatno spavao END // treba ga probuditi END RemoveItem ; BEGIN count := 0 ; Init ( notFull ) ; Init ( notEmpty ) END Monitor.

MODULE Primer ; FROM Monitor IMPORT EnterItem, RemoveItem ; PROCEDURE Producer ; VAR item : INTEGER ; BEGIN LOOP ProduceItem ( item ) ; EnterItem ( item ) END END Producer ; PROCEDURE Consumer ; BEGIN LOOP RemoveItem ( item ) ; ConsumeItem ( item ) END END Consumer ; BEGIN PARBEGIN ; Producer ; Consumer PAREND END Primer. // koristimo monitor // proizvoa

// potroa

39

Primedba: radi jednostavnosti, odnos potroa a i proizvoa a je realizovan na osnovu LIFO (Last In First Out) sistema, to zna i: onaj elemenat koji je poslednji put uba en u bafer, bi e prvi izba en (bafer se puni prema gore a prazni se prema dole).

Ekvivalencija sistema za sinhronizaciju procesa

Problem ekvivalencije sistema za sinhronizaciju procesa glasi: da li i kako mo emo pomo u datog mehanizma sinhronizacije realizovati neki drugi mehanizam. Pokaza emo da se monitori mogu biti implementirani na osnovu semafora i obrnuto.

Implementacija monitora kori enjem semafora

Pretpostavimo da operativni sistem podr ava rad sa semaforima. ta nam je potrebno za realizaciju monitora? Treba obezbediti: - da procedure iz monitora istovremeno mo pozvati najvie do jedan proces e - da se procedure monitora izvravaju bez prekida - rad sa uslovnim promenljivama Problem kriti ne oblasti (prva dva uslova) reavamo na slede i na in: Svakom monitoru dodeljujemo jedan binarni semafor koji se inicijalizuje sa vredno u 1 (podsetimo se: binarni semafori mogu imati samo vrednost 1 (ozna ava da nema ni jednog procesa unutar kriti ne oblasti) ili 0 (ozna ava da je neki proces unutar k.o.) , inicijalno uzimaju vrednost 1). Neka se taj semafor zove mutex. Njegov zadatak je da kontrolie ulazak u monitor (pozivanje procedura monitora). Kada kompajler vidi da sledi poziv neke procedure iz nekog monitora, on e pre tog poziva ubaciti poziv slede e procedure : PROCEDURE EnterMonitor ( mutex ) ; BEGIN Down ( mutex ) END EnterMonitor ; Ova procedura garantuje da se procedure datog monitora ne izvravaju paralelno, naime, ako proces A pozove neku proceduru monitora X, kompajler e automatski ubaciti poziv procedure EnterMonitor, pa e mutex postati 0. Neka sada i proces B pozove neku proceduru monitora X, tada se ponovo poziva EnterMonitor, pa poto je mutex=0, proces B ide na spavanje. Isto tako ovaj postupak garantuje i neprekidno izvravanje procedura monitora. Posmatrajmo sada problem uslovnih promenljivih! Posmatrajmo na koje na ine mo neki e proces iza i iz monitora (kako mogu procedure monitora zavriti svoj rad). Imamo 3 mogu nosti: 1. naredbom Wait (c), to zna i da postaje blokiran i neki drugi proces dobija mogu nost ulaska u kriti nu oblast (u ovom slu aju zapravo nema pravog izlaska iz monitora, proces jednostavno postaje blokiran da bi pustio drugi proces da ue u k.o.) 2. naredbom Signal (c), to zna i da alje signal c, to mo dovesti do buenja nekog procesa e koji eka na taj signal 3. normalno, tj. ne e pozvati Signal

40

Reenje je slede e: svakoj uslovnoj promenljivoj pridruujemo po jedan semafor koji se inicijalizuje na nulu. U tre em slu aju, jednostavno treba pozvati proceduru LeaveNormally, koja e probuditi jednog procesa koji eka na ulazak u k.o, ako takav proces postoji (i ostavi e mutex odgovaraju eg monitora na nuli), a ako takav proces ne postoji pove ava vrednost mutexa (poto je mutex binarni semafor, bi e mutex=1), to e zna iti da nema nikoga unutar k.o. PROCEDURE LeaveNormally ( mutex ) ; BEGIN Up ( mutex ) END LeaveNormally; U slu aju poziva naredbe Wait (c), treba pozvati slede u proceduru: PROCEDURE Wait ( mutex,c ) ; BEGIN Up ( mutex ) ; Down ( c ) END Wait; Naredba Up ( mutex ) radi slede e: ako postoji neki proces koji spava na mutexu, bi e probuen, ako ne, mutex postaje 1, to ozna ava da se ni jedan proces ne nalazi unutar odgovaraju eg monitora. Naredbom Down ( c ) dobijamo da se proces blokira na semaforu c. U slu aju da se procedura zavrava naredbom Signal (c), potrebno je pozvati slede u proceduru: PROCEDURE LeaveWithSignal ( c ) ; BEGIN Up ( c ) END LeaveWithSignal ; Ova procedura probuuje procesa koji eka na signal c. Panja!! Ovde se pretpostavlja sledee: iz procedure monitora izlazimo sa operacijom Signal (c), samo ako je to potrebno, tj. samo ako smo sigurni da postoji neki proces koji eka na taj signal. U tom slu aju, ne treba nam Up ( mutex ), tj, ne treba javiti da nema nikoga unutar kriti ne oblasti, jer je to neta no: kako neko eka na signal c, to zna i da je pozvao proceduru Wait ( mutex,c ) unutar kriti ne oblasti i taj proces e nastaviti svoj rad unutar k.o., pa mora ostati mutex=0.

Implementacija semafora pomou monitora

Sada emo pretpostaviti da operativni sistem podr ava monitore i uslovne promenljive za sinhronizaciju lakih procesa, pa emo na osnovu njih implementirati semafore. Ideja je slede a: za svaki semafor treba nam po jedan broja buenja i jedna uslovna promenljiva. Reenje je dat u obliku pseudokoda koji se oslanja na karakteristike programskog jezika Modula-2:

41

DEFINITION MODULE Semaphores ; // interfejs modula semafori TYPE Semaphore ; // nedostupni tip podataka PROCEDURE Init ( VAR s : Semaphore ; v : CARDINAL ) ; PROCEDURE Down ( s : Semaphore ) ; PROCEDURE Up ( s : Semaphore ) ; PROCEDURE Value ( s : Semaphore ) : CARDINAL ; PROCEDURE Kill ( s : Semaphore ) ; END Semaphore ; IMPLEMENTATION MODULE Semaphores [1000] ; TYPE Semaphore SemDesc = POINTER TO SemDesc ; // Semafor je pokaziva na slog = RECORD signal : CondVAR ; // uslovna promenljiva count : CARDINAL // broja END; v : CARDINAL) ;

PROCEDURE Init (VAR s : Semaphore ; // inicijalizacija semafora BEGIN NEW ( s ) ; // s^.count := v ; // Init ( s^.signal ) // END Init ;

alokacija memorije inicijalizacija brojaa ini. uslovne promenljive

PROCEDURE Down ( s : Semaphore ) ; BEGIN IF s^.count = 0 THEN // ako je broja na nuli, Wait ( s^.signal ) // ekamo na signal (spavamo) ELSE // inae, imamo signal, pa DEC ( s^.count ) // ne treba spavati, moemo dalje, END // samo treba javiti da nismo zasp. END Down ; PROCEDURE Up ( s : Semaphore ) ; BEGIN IF Awaited ( s^.signal ) THEN Signal ( s^.signal ) ELSE INC ( s^.count ) END END Up ;

// ako neko eka na signal, // bie probuen, // ako niko ne eka, // zapamtimo da smo imali signal

PROCEDURE Value ( s : Semaphore ) : CARDINAL ; BEGIN RETURN s^.count END Value ; PROCEDURE Kill ( VAR s : Semaphore ) : CARDINAL ; BEGIN FREE ( s ) // ako semafor vie nije potreban, END Kill; // treba osloboditi zauzetu mem. END Semaphores;

42

Klasi ni problemi sinhronizacije

Problem jeduih filozofa (The Dining Philosophers Problem)

Problem jedu ih filozofa poti e od Dijkstre, a glasi ovako: pet filozofa sede oko okruglog stola. Ispred svakog filozofa nalazi se po jedan tanjir sa pagetom. Izmeu svaka dva tanjira postavljena je po jedna viljuka. Filozofi su svoj posvetili razmiljanju. Ako postanu gladni, jedu pagete, pa ponovo ivot razmiljaju. Problem je u tome, to da bi neki filozof mogao jesti, potrebne su mu dve viljuke. Zato kada filozof postane gladan, pogleda, da li mo uzeti obe viljuke, ako mo jede (za to vreme njegovi e e susedi ne mogu jesti), ako ne mo ode na spavanje dok viljuke ne postanu slobodne. Zadatak je e, slede i: napisati program koji e reiti problem ovih filozofa, tj. koji e uspeno sinhronizovati rad 5 procesa koji predstavljaju filozofe.

O igledno reenje bi izgledalo na slede i na in:

PROCEDURE Philosopher ; BEGIN LOOP Think ; TakeFork ( leftside ) ; TakeFork ( rightside ) ; Eat ; PutFork ( leftside ) ; PutFork ( rightside ) ; END END Philisopher;

// // // // // // // //

razmiljaj uzmi viljuku sa leve strane, ako ne moes ekaj uzmi viljuku sa desne strane, ako ne moes ekaj jedi vrati levu viljuku vrati desnu viljuku

43

Ovakvo re enje nee raditi: pp. da se svi procesi izvravaju paralelno, tada e svaki filozof uzeti levu viljuku i onda e svaki od njih ekati na svog desnog suseda da mu da desnu viljuku dolazimo do zaglavljivanja. Pokuajmo sada, slede e: uzmimo levu viljuku, pa ako desna nije slobodna, vratimo levu ekamo neko vreme, pa ponovo uzmemo levu itd. Na alost ni ova ideja nam ne e pomo i: ponovo pp. da svi procesi rade paralelno, i da e na neki na in svi ekati istu koli inu vremena, tada opet niko ne e jesti ovaj algoritam e mo raditi, ali mo do i do zastoja ako svi generatori slu ajnih brojeva generiu da e iste brojeve, to u nekim slu ajevima mo dovesti do katastrofalnih rezultata (npr. upravljanje e nuklearnim elektranama, saobra ajem ili raketama itd.). Mogli bismo koristiti jedan binarni semafor, pa staviti Down(mutex) ispred TakeFork(leftside) i Up(mutex) iza PutFork(rightside) takav algoritam bi sigurno radio: najpre pogledamo da li postoji neki filozof koji ve jede, ako jeste, eka emo da zavri ru ak, ako niko nejede, red je na nas. Nedostatak je u tome, to e istovremeno jesti samo jedan filozof, tj. koristi emo samo dve viljuke od pet, a mogli bismo etri, tj. mogli bi i dva filozofa jesti istovremeno. Pravo reenje kori enjem semafora izgleda na slede i na in:

MODULE Philosophers ; CONST n = 5 ; // broj filozofa

TYPE State = ( thinking, hungry, eating ) ; // stanja filozofa : razmilja,gladan,jede VAR mutex : Semaphore ; states : ARRAY [1..n] OF State ; s : ARRAY [1..n] OF Semaphore ; // binarni semafor // stanja filozofa // pomoni semafori

PROCEDURE Philosopher ( i : CARDINAL ) ; // i oznaava redni broj filozofa BEGIN LOOP Think ; // razmiljaj TakeForks ( i ) ; // uzmi viljuke Eat ; // jedi PutForks ( i ) // vrati viljuke END END Philosopher ; PROCEDURE TakeForks ( i : CARDINAL ) ; // i oznaava redni broj filozofa BEGIN Down ( mutex ) ; // ulazak u kritinu oblast states [ i ] := hungry ; // filozof je gladan Test ( i ) ; // ako bar jedan od suseda jede, Up ( mutex ) ; // izlazimo iz kritine oblasti, Down ( s[i] ) // ali emo ekati na viljuku (moda na obe) END TakeForks ; PROCEDURE PutForks ( i : CARDINAL ) ; // i oznaava redni broj filozofa BEGIN

44

Down ( mutex ) ; states [ i ] := thinking ; Test ( left ( i ) ) ; Test ( right ( i ) ) ; Up ( mutex ) END PutForks ;

// // // // // //

ulazak u k.o. filozof prestaje da jede, poinje razmiljati javimo levom filozofu javimo desnom filozofu izlaz iz k.o.

PROCEDURE Test ( i : CARDINAL ) ; // i oznaava redni broj filozofa BEGIN IF ( states [ i ] = hungry ) AND // ako je na filozof gladan, ( states [ left ( i ) ] <> eating ) AND // a ni levi filozof, (states[ right ( i ) ] <> eating) // ni desni filozof ne jede, THEN states[i] := eating ; // na filozof moe slobodno jesti Up ( s [ i ] ) // pa ga treba probuditi END END Test ; BEGIN Init ( mutex,0 ); Init ( s[1],1 ); states[1]:=thinking; ... Init ( s[n],1 ); states[n]:=thinking; PARBEGIN ; Philosopher ( 1 ) ; ... Philosopher ( n ) ; PAREND END Philosophers.

Analiza: Posmatrajmo rad programa. Neka neki filozof (A) postane gladan, tada pogleda levog i desnog suseda, ako ni jedan od njih ne jede, to zna i da je i leva i desna viljuka slobodna, pa mo da e jede (to se odvija u proceduri Test) i poalje signal na svoj semafor, da ne bi zaspao pri izlasku iz procedure TakeForks. Ako bar jedan od suseda jede, ne mo uzeti obe viljuke, pa ne mo ni jesti, zato e e e ekati na svom semaforu to obezbeuje Down operacija na kraju procedure TakeForks. Pretpostavimo sada da je ovaj na filozof (A) uspeo da uzme obe viljuke i po eo da jede. Neka sada ogladi filozof (B) pored njega. Taj isto javi da je gladan i ode da testira susede. Vidi da filozof (A) pored njega jede, pa ne mo uzeti viljuku (filozofi su vrlo miroljubivi, pa ne e silom oduzeti viljuku od e suseda) zato e da zaspi na svom semaforu. Nakon izvesnog vremena filozof A prestaje da jede, i ka e ostalima: idem ja da razmiljam. Ali pre nego to izae iz procedure PutForks, javi susedima da mu viljuke vie nisu potrebne, tako to e pozvati Test i za levog i za desnog suseda. Kada pozove Test za filozofa B (koji gladan eka na svom semaforu), uz pretpostavku da ni drugi sused od B ne jede, B e po eti da jede (state[B]:=eating) i dobija signal na svom semaforu da mo iza i iz procedure e TakeForks i nastaviti svoj rad. Problem jeduih filozofa je koristan za modeliranje procesa koji se takmi e za ekskluzivan pristup nekim resursima (tj. datim resursima istovremeno mo pristupiti samo jedan proces). e

45

Problem itaoca i pisaca (The Readers and Writers Problem)

Problem itaoca i pisaca je koristan za modeliranje pristupa bazi podataka. Imamo neku bazu podataka, nekoliko procesa koji upisivati podatke u bazu i nekoliko procesa koji itati ele ele podatke iz baze kako to realizovati a da ne doemo do problema? Moramo se dr slede ih pravila: ati - istovremena itanja mo emo dopustiti jer procesi- itaoci ne smetaju jedan drugom - istovremeno itanje i pisanje nije dozvoljeno, jer mo emo do i do toga da proces koji ita pro ita pogrene podatke (proces A po ne itati, nakon nekog vremena doe proces B i izmeni neke podatke u bazi, proces A pro ita pogrene podatke, dobija loe informacije i pokrene proces samounitavanja svemirske letelice...) - istovremena pisanja nisu dozvoljena, jer mogu prouzrokovati ozbiljne greke Mi emo ovde posmatrati problem jednog pisca i ve eg broja italaca. Ideja reenja je slede a: kada pisac pie, itaocima je zabranjem pristup, dok itaoci itaju, piscu je zabranjen da pie.

MODULE RW ; VAR mutex : Semaphore ; // binarni semafor za kontrolu pristupa globalnoj prom. rc db : Semaphore ; // binarni semafor za kontrolu pristupa bazi podataka rc : CARDINAL ; // broja itaoca koji istovremeno itaju iz baze PROCEDURE Writer ; BEGIN LOOP GetData ; Down ( db ) ; WriteToDataBase ; Up ( db ) END END Write ; // pisac sakupi podatke koje eli upisati u bazu ekaj ako nema pristup bazi pii podatke u bazu javi da si zavrio sa radom

// // // //

PROCEDURE Reader ; // italac BEGIN LOOP Down ( mutex ) ; // elimo pristup brojau INC ( rc ) ; // poveava se broj itaoca IF rc = 1 THEN // ako smo prvi, Down ( db ) // treba traiti pristup bazi podataka END; // inae ne treba jer je baza ve otvorena Up ( mutex ) ; // mogu ostali itaoci pristupiti rc-u ReadFromDataBase ; // itamo iz baze Down ( mutex ) ; // traimo ekskluzivni pristup brojau DEC ( rc ) ; // smanjimo broj itaoca IF rc = 0 THEN // ako smo mi zadnji, Up ( db ) // javimo da moe pisa pristupiti bazi END; Up ( mutex ); // mogu ostali itaoci pristupiti rc-u UseData // koristimo proitane podatke

46

END END Reader ; BEGIN Init ( mutex,1 ) ; Init ( db, 1 ) ; rc := 0 ; PARBEGIN ; Writer ; Reader ; ... PAREND END RW ;

// niko jo nije pristupio rc-u // niko jo nije pristupio bazi

Analiza: kada italac po da ita iz baze podataka, najpre proveri da li mo pristupiti eli e globalnoj promenljivoj rc koja ozna ava broj onih itaoca koji istovremeno (u datom trenutku) itaju iz baze. Ako ne mo eka na semaforu mutex. Ako mo onda gleda: ako je on prvi od itaoca koji e, e, ele itati iz baze, onda mora zatra pristup bazi podataka preko semafora db. Ako pisac ve pie, onda e iti ekati na tom semaforu. Ako ne, onda e dopustiti ostalim itaocima pristup rc-u. Zatim e itati iz baze. Posle toga ponovo tra pristup rc-u, kada dobije pristup, onda proverava da li je on mo zadnji od i da itaoca, ako jeste, onda nikom (iz skupa itaoca) vie nije potrebna baza, pa e javiti da mo neko drugi e pristupiti. Zna i prvi itaoc e zatra pristup bazi (to istovremeno ne mogu uraditi i vie njih zbog iti semafora mutex), kada dobije pristup, baza e biti otvorena za sve itaoce. Poslednji itaoc ima zadatak da zatvori bazu i time omogu i piscu (ili mo nekom itaocu koji ponovo itati) pristup. da eli Nedostatak ovog re enja je u tome to favorizuje itaoce: ako pisac po da upie neto u bazu, eli mora sa ekati da svi itaoci odustanu od itanja, pa se mo desiti da jako dugo ne dobije pristup. Ova e pojava se zove izgladnjivanje (starvation).

Problem uspavanog berberina (The Sleeping Barber Problem)

U frizerskom salonu radi jedan berberin. U prostoriji imamo jednu stolicu za ianje i n stolica za muterije koji ekaju da dobiju novu frizuru. Ako nema ni jedne muterije, berber sedi na svoju stolicu i spava. Kada ue prva muterija, budi berberina, sedi na stolicu za ianje i berber ga ia. Slede a muterija koja doe, sedi na jednu od tih n stolica za ekanje, ako ima mesta, i eka svoj red, ako nema mesta odustaje od ianja.
// broj stolica za ekanje // // // // da li je berberin slobodan za ianje da li ima muterija za kontrolu pristupa promen. waiting broj muterija koja ekaju na ianje

CONST n = 5 ; VAR barber : Semaphore ; customers : Semaphore ; mutex : Semaphore ; waiting : CARDINAL ; PROCEDURE Barber ; BEGIN

// berberin

47

LOOP Down ( customers ) ; Down ( mutex ) ; DEC ( waiting ) ; Up ( barber ) ; Up ( mutex ) ; CutHair END END Barber ; PROCEDURE Customer ; BEGIN Down ( mutex ) ; IF waiting < n THEN INC ( waiting ) ; Up ( customers ) ; Up ( mutex ) ; Down ( barber ) ; GetHairCut ELSE Up ( mutex ) END END Customer ; Inicijalizacija :

// // // // // //

ako nema muterija, berberin spava traimo pristup globalnoj prom. waiting smanjimo broj muterija koji ekaju javimo, da ianje moe poeti pustimo promenljivu waiting ianje

// muterija // // // // // // // // // traimo pristup prom. waiting ako ima mesta za ekanje, ostajemo, poveamo broj onih koji ekaju javimo da ima muterije pustimo prom. waiting ekamo berberina ianje ako nema mesta, odustajemo od ianja i javimo, da nam ne treba prom. waiting

Init ( barber,0 ) ; // berberin spava Init ( customers,0 ) ; // nema ni jedne muterije Init ( mutex,1 ); // pristup waiting-u je dozvoljen waiting := 0 ; // ne eka niko na ianje

Analiza: Na po etku nema muterije (Init (customers,0 , waiting=0)). Dolazi prva muterija, vidi da ima mesta (waiting<n), zauzme jedno mesto za ekanje (INC(waiting)), pa javi da je stigla (Up(customers)), zatim eka na berberina (Down(barber)). Berberin eka muteriju (Down(customers)). Kada se berberin probudi (Up(customers) u proceduri Customer), ka e muteriji da pree na stolicu za ianje i smanji broja za ekanje (DEC(waiting)), zatim ka e muteriji: dobro, ja sam spreman (Up(barber)), muterija to primi na znanje (izlazi iz Down(barber)) i po inje ianje. Ako imamo vie muterija koja ekaju, izbor muterije koja e pre i na stolicu za ianje je posao operativnog sistema. Ako Petar stigne u frizersku radnju i vidi da nema mesta za ekanje, odustaje od nove frizure (ELSE grana) i ode ku i da gleda utakmicu.

48

Komunikacija te kih procesa

Kao to smo ve rekli, problem komunikacije kod tekih procesa je u tome, to su oni meusobno odvojeni, tj. ne dele nijedan deo memorije. Kako nemaju zajedni ku memoriju, operativni sistem mora obezbediti neke strukture i mehanizme za me uprocesnu komunikaciju (interprocess communication). Upravo zbog toga to te ki procesi ne dele ni ta zajedni ko, mehanizmi koje smo koristili za sinhronizaciju lakih procesa ne mogu se primeniti. Nastaju novi problemi, ako posmatramo mre ra unara, gde je potrebno obezbediti komunikaciju izmeu razli itih tekih procesa u koji se mo izvravaju na razli itim platformama (razli iti procesori, razli iti operativni sistemi itd.) da koji su mo fizi ki jako udaljeni. da Komunikacija izmeu tekih proces se odvija slanjem poruka (message passing) i pomo u operativnog sistema. OS treba da vodi ra una o slede im stvarima: 1. Mo do i do toga da se poruka negde izgubi u mre da bismo izbegli greke koje na e i ovaj na in mogu nastati, mogli bismo usvojiti slede i dogovor: primilac poruke je du an da obavesti poaljioca da je primio poruku. Ako poaljilac ne dobije potvrdu o prijemu poruke unutar odreenog vremenskog intervala, mo ponovo poslati svoju poruku. e 2. Mo do i do toga da poruka stigne na odredite, i primilac poalje potvrdu ali se sada e potvrda negde izgubi i ne stigne do poaljioca unutar predvienog vremeskog intervala. Tada e poaljioc misliti da poruka nije stigla do cilja i posla e ponovo istu poruku a primilac e dva puta dobiti istu poruku. Zbog toga je dobro da se razne poruke mogu jasno identifikovati, tj. da primilac ima mogu nost da razlikuje novu poruku od duplikata. To se mo ostvariti npr. pridru e ivanjem identifikacionih brojeva. 3. Potrebno je obezbediti jedinstvenu identifikaciju izvora i cilja poruke (treba jedinstveno identifikovati kome je poruka namenjena u mre na kom ra unaru, kom procesu). i: 4. Problemi u preformansama kada gledamo dva teka procesa koja se izvravaju na istom ra unaru a komuniciraju porukama. Sinhronizacija i komunikacija lakih procesa pomo u semafora ili monitora je mnogo br (laki procesi dele zajedni ki deo memorije). a Komunikacija tekih procesa se odvija pomo u operativnog sistema: poaljioc alje poruku operativnom sistemu, koji alje dalje prema primiocu. Posmatrajmo sada, kako bismo mogli realizovati meuprocesnu komunikaciju zasnovanu na porukama: poruke mogu biti direktno upu eni na jedinstvenu adresu nekog procesa (svaki proces mora imati jedinstveni identifikacioni broj - PID (Process ID), ovde nastaju komplikacije ak i pri komunikaciji izmeu procesa koji se izvravaju na istoj maini, poto se PIDovi mogu menjati (proces A komunucira sa procesom B, korisnik ubije proces B i pokrene neke druge procese, nakon nekog vremena ponovo pokrene proces B koji sada dobija drugi pid)). Drugi na in je da se komunikacija odvija preko posebnih struktura podataka. Postoje dve strukture koje se koriste: mailbox (po tansko sandu e) i pipe (cev). Razlika izmeu ove dve strukture je u tome, to mailbox jasno razlikuje poruke (zna veli inu svake poruke, zna gde je granica izmeu dve poruke) a pipe ne vodi ra una o granicama poruka: primalac treba znati koliko bajtova treba da preuzme iz pipe-a. Mailbox se ponaa kao red opslu ivanja, tj. kao FIFO (First In First Out) struktura (prva poruka koja je stigla, bi e prva izvaena). se de ava ako proces eli poslati neku poruku a nema vi e mesta u mailboxu, ili ako eli ta da uzme poruku a mailbox je prazan? Imamo dve mogu nosti: 1. Proces se obavetava da ne mo poslati poruku (odnosno da nije stigla ni jedna poruka), pa je e na procesu ta e raditi

49

2. Proces odlazi na spavanje (blokira se) dok ne bude mogao poslati poruku (odnosno, dok tra poruka ne stigne). ena Koliko su veliki mailboxovi odnosno pipeovi? Kapacitet (broj poruka koja mailbox mo e primiti, odnosno veli ina pipe-a npr. u bajtovima) odreuju procesi. Ako mailbox mo primiti najvie do e jednu poruku, govorimo o randevuu (rendevouz). Za realizaciju komunikacije izmeu tekih procesa potrebno je obezbediti dve operacije: - SEND ( mailbox, message ) alje poruku message u potansko sandu e mailbox, - RECEIVE ( mailbox, message ) preuzima poruku iz potanskog sandu eta mailbox u message. Kori enje poruka emo demonstrirati na problemu proizvoa a i potroa a.

CONST n = 100 ; PROCEDURE Producer ; VAR item : INTEGER ; m : Message ; BEGIN LOOP ProduceItem ( item ) ; RECEIVE ( Consumer, m ) ; BuildMessage ( m,item ) ; SEND ( Consumer,m ) END END Producer ;

// veliina mailboxa // proizvoa // poruka

// // // //

proizvodi elemenat uzmi (ekaj na) poruku od potroaa napravi poruku poalji poruku potroau

PROCEDURE Consumer ; // potroa VAR item, i : INTEGER ; m : Message ; // poruka BEGIN MakeEmpty ( m ) ; FOR i := 1 TO n DO // na poetku, SEND ( Producer, m ) // aljemo n praznih poruka proizvoau END; LOOP RECEIVE ( Producer, m ) ; // uzmi poruku od proizvoaa ExtractItem ( m,item ) ; // izvadi elemenat iz poruke MakeEmpty ( m ) ; SEND ( Producer,m ) ; // obavesti proizv. da je poruka izvaena ConsumeItem ( item ) // koristi elemenat END END Consumer ;

Analiza: potroa i proizvoa su se dogovorili, da e potroa poslati praznu poruku proizvoa u im je spreman da primi novu poruku. Na po etku rada, potroa poalje n praznih poruka da bi time obavestio potroa a da je spreman za baferisanje ukupno n poruka (ima mailbox kapaciteta n). Zatim eka poruku od proizvoa a. Ako proizvoa krene prvi, on e nakon to proizvede novi elemenat, ekati na poruku od potroa a (RECEIVE(Consumer,m)). Kada poruka stigne, upakuje novi elemenat u poruku (BuildMessage(m,item)) i alje potroa u (SEND(Consumer,m)). Kada potroa dobije poruku od proizvoa a, vadi elemenat iz poruke (ExtractItem(m,item)) i alje praznu poruku nazad (SEND(Producer,m)) da bi obavestio proizvoa a da je preuzeo poruku i da je spreman za slede u poruku. 50

Dispe er (dispatcher, scheduler)

Setimo se da se procesi mogu nalaziti u jednom od slede ih stanja: 1. IZVR AVA SE (RUNNING) kada procesor izvrava kod datog procesa 2. SPREMAN JE (READY) proces je spreman za izvravanje, eka da dobije procesora 3. BLOKIRAN JE (BLOCKED) proces eka na rezultat neke akcije (npr. eka neku IO operaciju). Proces prelazi iz stanja IZVR AVANJA u stanje BLOKIRAN ako su mu za dalji rad potrebni neki resursi koji trenuta no nisu dostupni uzrok ovog prelaza je sam proces. Iz stanja BLOKIRAN mo pre i u stanje SPREMAN, kada dobije sve potrebne resurse za rad i sada treba da eka na e procesora. Iz stanja SPREMAN proces prelazi u stanje IZVR AVANJA kada se izabere iz liste spremnih procesa i procesor po inje izvravati njegov kod. Proces prelazi iz stanja IZVR AVANJA u stanje SPREMAN, kada istekne dodeljeno procesorsko vreme. Prelaze izmeu stanja IZVR AVA SE i SPREMAN JE kontrolie deo operativnog sistema, koji se zove DISPE ER ili EDULER. Zna i dispe er je taj koji e odrediti koji proces dobija procesorsko vreme i koliko vremena dobija za izvravanje. Izvravanje dispe era mora biti dovoljno brzo, da se procesorsko vreme ne bi troilo na njega, upravo zbog toga mora biti deo jezgra operativnog sistema i uvek biti u operativnoj memoriji. Do izvravanja dispe era mo do i u slede im situacijama: e 1. proces koji se trenutno izvrava zavrava svoj rad (tada treba izabrati novi proces za izvravanje) 2. proces se odblokira (probudi se) 3. proces se blokira 4. procesu u stanju izvravanja istekne dodeljeno procesorsko vreme Dodela procesorskog vremena nekom procesu, tj. slanje nekog procesa iz stanja izvravanja u stanje spreman i izbor drugog procesa za izvravanje se zove context switching (menjanje okruenja). U prvom, tre em i etvrtom slu aju sigurno dolazi do menjanja okru enja (ako imamo vie od jednog procesa), u drugom ne mora. Mo emo razlikovati dve vrste dispe era: 1. PREKIDLJIVI (PREEMPTIVE) izvravanje procesa mo biti prekinuto od strane e dispe era bilo kada. Tada proces prelazi u stanje spreman i njegovo izvravanje se mo e nastaviti kasnije. 2. NEPREKIDLJIVI (NON PREEMTIVE) izvravanje procesa ne mo biti prekinuto od e strane dispe era, jedino sam proces mo menjati svoje stanje (npr. zavri svoj rad, postaje e blokiran jer eka na neki dogaaj ili resurs itd.) Algoritam dispe era mora uzeti u obzir slede a o ekivanja: 1. Fernost (fairnest) svaki proces mora dobiti ansu za izvravanje, 2. Efikasnost procesor mora biti maximalno iskori en,

51

3. Treba da obezbedi kratko vreme odziva (response time) interaktivnih procesa (da ne bi dolo do toga da korisnik pritisne S i eka pola dana dok se S pojavi na ekranu), 4. Treba da obezbedi to krae vreme izvr avanja paketnih (batch - oni koji malo komuniciraju sa korisnikom a vie neto rade) programa (turnaround time) 5. Treba da ima to veu propusnost (throughput), tj. treba da to ve i broj paketnih procesa zavri svoj rad u nekoj jedinici vremena. Vrlo je teko na i optimalan algoritam, koji bi ispunio sva prethodna o ekivanja. Na primer, ako imamo i interaktivne i paketne procese, tre i i etvrti kriterijumi su u koliziji: ako dozvolimo kratko vreme odziva interaktivnih procesa, oni e neprestano prekidati paketne procese, pa e njihovo vreme izvravanja rasti. Obrnuto, ako pustimo paketne procese da odrade svoj zadatak to br interaktivnim e, procesima emo produ vreme odziva. iti Da bi operativni sistem mogao odlu iti da li je dolo vreme da izvri menjanje okru enja (tj. da izabere drugi proces za izvravanje), pomo sti ve sa hardverskog nivoa. Hardverski sat 50 do 60 puta e u sekundi generie prekid, OS dobija kontrolu. Tada ima mogu nost da odlu i, da li je dolo vreme da procesor dobije neki drugi proces. Sada emo razmatrati razne algoritme dispe era.

1. Round Robin algoritam (preemtive, nema prioriteta)

Round Robin je jedan od najstarijih, najjednostavnijih i naj e e kori enih algoritama. Spremni procesi se stavljaju u kru listu, svakom procesu se pridru vremenski interval kvantum nu uje (quantum) vremena. Nakon isteka tog vremena, proces e biti prekinut od strane OS-a a kontrola se predaje slede em procesu u listi. Ako se proces blokira ili zavri rad pre isteka kvantuma, dispe er se aktivira i bira slede i proces za izvravanje. Poto dispe er ide redom po kru listi, ovaj algoritam noj garantuje fernost (svaki proces e dobiti ansu za izvravanje).

Problemi nastaju pri izboru du kvantuma: ako je kvantum previe kratak, dispe er e se ine izvravati e e, pa troimo vie procesorskog vremena za prebacivanje sa jednog na drugi proces. Ako je kvantum preduga ak, mo se desiti da vreme odziva nekih interaktivnih procesa bude prevelik. e Primer1: neka je kvantum 20ms, a neka menjanje procesa traje 5ms. To zna i da emo za jednu sekundu imati 800ms korisno iskori avanje procesora (u vidu izvravanja procesa) i 200ms potroeno na dispe er, tj. 20% vremena odlazi na administraciju. Primer2: neka je kvantum 500ms i neka menjanje procesa traje 5ms. Posmatrajmo slede u situaciju: imamo viekorisni ki sistem sa 10 korisnika od kojih svaki koristi svoj editor texta. Neka svi

52

tipkaju neto po tastaturi. Round robin ide okolo, prvi korisnik e rezultat videti odmah, drugi za 505ms, tre i za 1010, deseti za 4545ms, tj nakon skoro 5 sekundi ekanja...

2. Najstariji proces (First Come First Served) (non preemtive, nema prioriteta)
Spremni procesi se stavljaju u red opslu ivanja, pa se izvravaju redom i to bez prekida proces radi dok ne zavri svoj rad ili ne postaje blokiran. Izvravanje dobija uvek najstariji proces. Nedostatak ovog algoritma je u slede em: uzmimo da imamo jedan proces koji se izvrava jako dugo i iza njega vie kra ih procesa. Tada e mnotvo kratkih poslova dugo ekati zbog tog jednog sporog. Preptostavimo sada, da se taj spori proces zablokira pre nego to zavri svoj rad tada se prebacuje na pocetak reda opslu ivanja ( im bude spreman). Neka kratki poslovi zavre svoj rad mnogo pre nego to se spori proces odblokira. Tada emo imati situaciju da procesor nita ne radi eka na odblokiranje.

3. Prioritetno raspore ivanje (priority scheduling) (preemtive, prioritetni )

Jedan nedostatak Round Robin algoritma je u tome, to su svi procesi ravnopravni, tj. da ne pretpostavlja mogu nost postojanja va nijih i manje va procesa. Ideja o pridru nih ivanju prioriteta procesima se uvodi kod prioritetnog rasporeivanja. Prioriteti mogu biti: 1. stati ki svakom procesu se pridru prioritet kada se u ita u memoriju uje 2. dinami ki prioritet procesa se menja u toku izvravanja. Imamo dva pristupa: 1. procese stavimo u jednu prioritetnu listu i uvek biramo najprioritetniji proces 2. procese grupiemo u prioritetne klase, klasu biramo na osnovu prioriteta a za izbor procesa unutar klase koristimo Round Robin algoritam. Kao nedostatak prioritetnog rasporeivanja javlja se slede i problem: mo se desiti da manje e prioritetni procesi nikada ne dou do procesora ova pojava se zove izgladnjivanje (starvation). Problem bismo mogli izbe i tako to emo prioritet procesa koji se trenutno izvrava prilikom svakog prekida hardverskog sata smanjiti za jedan. Ako prioritete dinami ki odreuje OS, dobro je uzeti u obzir slede a razmatranja: - procesi koji intenzivno koriste IO ureaje treba da imaju ve i prioritet, jer im procesor treba u kra im intervalima ( es e su blokirani). - procesi koji intenzivno koriste procesor i operativnu memoriju treba da imaju manji prioritet Obja njenje: da bismo procesor maksimalno iskoristiti, dobro je pustiti najpre procese iz prve grupe, oni e procesor zauzeti relativno kratko, zatim e se blokirati, pa se mogu slobodno izvravati procesi iz druge grupe. Ako bi oni imali ve i prioritet, procesi iz prve grupe bi dugo ekali da bi na kratko vreme dobili procesor i dugo e zauzimati mesto u operativnoj memoriji. Prioritet procesa mogli bismo ra unati na slede i na in: neka je veli ina kvantuma 100ms. Tada, ako od toga proces koristi procesor u 20ms, dobi e prioritet 100/20=5, ako koristi u 50ms, dobija prioritet 100/50=2, ako koristi 100ms, dobija prioritet 100/100=1. Ve i broj ozna ava ve i prioritet.

4. Vi estruki redovi (multiple queues) (preemtive, prioritetni)

Posmatrajmo slede u situaciju: imamo sistem sa malo memorije, ali elimo multitasking. Neka menjanje procesa traje 5ms kada su procesi u memoriji. Poto sada nemamo dovoljno memorije da svi

53

spremni procesi budu u memoriji, mora emo pristupiti disku da bismo dovukli procese, odnosno, da bismo sa uvali trenutno stanje procesa koji se zamenjuje to e jako pove ati vreme administracije. Ako je kvantum mali, esto emo pristupati disku, ako je kvantum veliki, vreme odziva se pove ava. Reenje izgleda na slede i na in: procese emo grupisati u prioritetne klase (svaka klasa predstavlja jedan red opslu ivnja). Procesi iz najprioritetnije klase e dobiti 1 kvantum za izvravanje, procesi iz druge klase 2 kvantuma, procesi iz tre e klase 4 kvantuma, oni iz etvrte klase 8 kvantuma itd. Ako proces iz neke klase iskoristi sve svoje kvantume bez blokiranja, ide u slede u klasu (dobija vie kvantuma). Oni procesi koji nisu interaktivni, tj. intenzivno koriste procesor, dobijaju sve vie kvantuma. klasa 1 2 3 4 5 6 7 broj kvantuma 1 2 4 8 16 32 64

Primer: imamo proces, kome treba 100 kvantuma da zavri svoj rad. Nemamo dovojno memorije, pa mora biti preba en na disk svaki put kad potroi procesorsko vreme. Ako radimo na standardan na in (svi procesi dobijaju po jedan kvantum, pa gube procesor), tada da bi ovaj program doao do kraja svog rada, potrebno ga je 100 puta prebaciti sa i na disk. Ako koristimo ovu tehniku, potrebno je samo 7 puta. Problem: ta ako proces, nakon odreenog vremena po inje da bude interaktivan? Jedno reenje: Svaki put kad se za dati proces pritisne ENTER, ide prema gore po klasama. Rezultat: korisnici shvate da lupaju i ENTER dobijaju na prioritetu... i po inje trka ko mo br pritiskati ENTER... e e

5. Prvo najkrai posao (Shortest Job First) (non preemtive, nema prioriteta )
Cilj ovog algoritma je da se to vie poslova uradi za neko odreeno vreme. Radi na slede i na in: od svih spremnih procesa bira onaj, za koji procenjuje da e najbr zavriti svoj rad. Procesi se ne e prekidaju (non preempitve). Koristi se pri radu sa paketnim procesima (koji intenzivno koriste procesor a retko komuniciraju sa korisnikom) istog prioriteta. Da bi algoritam funkcionisao, potrebna je procena du rada pojedinih procesa. ine Primer: imamo 4 procesa : A,B,C,D ije su du rada 8,2,3,4 minuta. Pogledajmo dva redosleda ine izvravanja: 1. ABCD 2. BCDA (prvo najkra i posao) Ra unamo prose no vreme zavretka pojedinih procesa (algoritam je neprekidljiv):

1. A=8, B=10, C=13, D=17, prose no = (8+10+13+17)/4 = 48/4 = 12 2. B=2, C=5, D=9, A=17, prose no = (2+5+9+17)/4 = 33/4 = 8.25 U prvom slu aju, za 9 minuta uspemo zavriti samo jedan posao (A) , a u drugom slu aju ak tri poslova (B,C,D).

54

Posmatrajmo sada interaktivne procese. Kod njih se javlja jo jedan faktor: korisnik. Da bismo mogli koristiti ovaj algoritam, potrebno je na i neki na in za procenjivanje du izvravanja. Na ine primer: pretpostavimo da procesi funkcioniu na slede i na in: ekaju na komandu, kada se pritisne ENTER (ozna ava kraj komande), izvravaju komandu. Procenu emo vriti tako to emo meriti vreme izmeu dva ENTERA. Ako je ENTER prvi put pritisnut u trenutku T0, a drugi put u trenutku T1, onda emo tre i proceniti na osnovu formule a*T0 + (1-a)*T1, gde je a neka konstanta (obi no ). Ako stavimo a= , dobijamo niz: T0, T0/2 + T1/2, T0/4 + T1/4 + T2/2, T0/8 + T1/8 + T2/4 + T3/4

6. Garantovano raspore ivanje

Prva ideja: imamo n korisnika u sistemu (npr. n terminala na jedan procesor), OS garantuje da e svaki korisnik dobiti 1/n od ukupne snage procesora. Kako to izvesti? Pratimo korisnika i gledamo koliko su svi njegovi procesi vremenski koristili procesor od kada je korisnik po eo svoj rad na terminalu. (npr. korisnik je po eo rad pre dva sata a procesor je od tada radio na njegovim procesima 95 minuta). Sada gledamo, kad je doao prvi korisnik i koliko je od tada utroeno procesorskog vremena. To vreme delimo sa brojem trenutno ulogovanih korisnika i dobijamo koliko je trebalo da dobiju od procesorskog vremena. Tada emo birati procese onog korisnika koji je dobio najmanju pa procesora. nju Druga ideja: vremenska garancija - vremensko ograni avanje procesa: proces mora biti izvren za neko odreeno vreme.

7. Dvo-nivovski dispe er (two-level scheduling)

Ovaj se algoritam primenjuje kada imamo malo operativne memorije, pa se neki od spremnih procesa uvaju na disku. Radimo na slede i na in: koristimo dva dispe era. Najpre u itamo nekoliko spremnih procesa sa diska u memoriju i sada neko vreme dispe er nieg nivoa radi samo sa tim procesima. Posle odreenog vremena dolazi dispe er vi eg nivoa i ka dorbo, ovi procesi su bili e: dovoljno dugo izvravani, sada u ih lepo prebaciti na disk neka se malo odmore, a sa diska u doneti neke nove procese neka procesor malo izvrava njihove kodove. Dispe er ni nivoa to primi na znanje eg i svu svoju pa daje novim procesima. nju

55

UPRAVLJANJE MEMORIJOM

Mo emo razlikovati 3 vrste memorije : 1. eksterna memorija (najve eg kapaciteta, najsporiji, najjeftiniji) 2. interna memorija (manjeg kapaciteta, br skuplji) i, 3. ke (cache) memorija (najmanjeg kapaciteta, najbr najskuplji) i, Nas e najvie interesovati interna memorija (operativna memorija) i njen odnos sa eksternom memorijom. Procesor mo izvravati samo procese koji su u internoj memoriji. Kako je operativna e memorija relativno malog kapaciteta, dolazimo do slede ih problema: 1. proces je ve i od interne memorije (i kod monoprogramiranja i kod multiprogramiranja) 2. nemamo dovoljno memorije da u itamo sve spremne procese (kod multiprogramiranja) Deo operativnog sistema koji upravlja kori enjem memorije zove se upravlja memorije (memory manager). Njegov zadatak je da vodi ra una o tome, koji delovi memorije su zauzeti, koji delovi su slobodni, da zauzme potrebnu koli inu memorije za nove procese odnosno da oslobodi memoriju zauzetu od strane nekog procesa, i da upravlja prebacivanjem procesa iz interne u eksternu memoriju i obrnuto pri tome mora voditi ra una o tome, da procesi ne tete jedni drugima, a ni operativnom sistemu. U slu aju kada nemamo dovoljno interne memorije, koriste se slede e tehnike: 1. SWAPPING (prebacivanje procesa) ako nemamo dovoljno mesta u operativnoj memoriji za smetanje svih spremnih procesa, neki se izbacuju na disk. Kada je potrebno, celi spremni procesi iz interne memorije se prebacuju na disk, odnosno spremni procesi sa diska se prebacuju u internu memoriju. 2. PAGING (strani enje) delove procesa dr na disku, u itavaju se po potrebi imo

56

Upravljanje memorijom bez swappinga i paginga

Monoprogramiranje (monoprogramming)
Monoprogramiranje zna i da istovremeno u internoj memoriji ra unara mo nalaziti samo e jedan proces. Najjednostavniji na in je da u internoj memoriji imamo samo jedan proces: pustimo korisnika da u ita program koji i taj program tada dobija apsolutnu kontrolu nad ra unarom (radi ta eli, ho e i gde ho e, pristupa onim delovima memorije kojima i koristi one ureaje koje i kako eli eli eli). Kod ovog pristupa ne treba nam ni operativni sistem, ni posebni drajveri za razne ureaje: program koji se u itava u memoriju je potpuno sam i oslanja se isklju ivo na sebe. Mora znati sve to mu je potrebno: kako da koristi memoriju, kako da koristi tastaturu, disk, tampa i sve ostalo to mu je potrebno da izvri svoj zadatak. Kada taj program zavri sa radom, mo se u itati slede i program, koji isto tako mora znati e da rukuje sa svim ureajima koje koristi. Ova metoda je ve davno naputena, poto je vrlo neprakti na programeri moraju ugraditi sve potrebne drajvere u svaki program. Ako nema dovoljno memorije, programer mora na i neko reenje: optimizuje kod, ili e program razbiti na manje funkcionalne delove koji se mogu samostalno izvravati ili neto tre e. Drugi na in je da se memorija deli izme u operativnog sistema i jednog korisni kog programa. Kada se ra unar uklju i, u itava se operativni sistem bez njega se ra unar ne mo koristiti. e Tada na monitoru dobijemo komandni prompt, pa korisnik izdaje naredbe operativnom sistemu. Ka e: izbrii ekran (npr. CLS u DOS-u) ili izlistaj sve fajlove u teku em direktorijumu (npr. DIR u DOS-u), ili u itaj taj i taj program. Ako OS prepozna komandu, pokuava ga izvriti, ako ne, javlja greku i eka slede u naredbu. Korisnikov program se u itava u preostali deo memorije i tamo se izvrava. Vie nije potrebno u svaki program ugraditi i sve potrebne drajvere, jer je OS zadu da obezbedi sve potrebne en funkcije. Imamo vie na ina za raspodelu memorije: 1. OS se u itava u donji deo RAM-a (Random Access Memory memorija koja se mo i itati i e isati) , a ostatak memorije je na raspolaganju korisni kim programima 2. OS se nalazi u ROM-u (Read Only Memory memorija koja se mo samo itati) na vrhu e memorije a korisni ki program ispod njega 3. OS se nalazi u donjem delu RAM-a, drajveri u ROM-u na vrhu memorije a izmeu korisni ki program Osnovni skup funkcija za rad sa ureajima mo biti smeten u poseban deo ROM memorije koji e se zove BIOS (Basic Input Output System). OS se oslanja na BIOS, a korisni ki programi mogu pozivati i funkcije OS-a i funkcije BIOS-a. Ni ovde nemamo pravu podrku OS-a za upravljanje memorijom (u slu aju da je proces prevelik, dobi emo poruku o tome, da nemamo dovoljno memorije). Neka razvojna okru enja, pru mogu nost aju da se program razbije na delove, pa se u itava onaj deo koji je potreban za rad (npr. Turbo Pascal podr sli nu tehniku, koja se zove overlay: program se deli na razne unit-e. Uzmemo skup nekih unitava a i pravimo od njih objektni fajl (prevedemo ih u jedan fajl), tokom izvravanja glavnog programa, ako pozovemo neku funkciju iz nekog od ovih unit-a, odgovaraju i unit se u itava sa diska u memoriju. Pri tome se zauzima onoliko memorije koliko je potrebno za najve i unit. )

57

Multiprogramiranje (multiprogramming)
Multiprogramiranje zna i da istovremeno imamo i vie spremnih procesa u internoj memoriji. Neki razlozi za uvo enje multiprogramiranja: rad sa vie korisnika: imamo ra unar i nekoliko terminala bolje iskori avanje procesorskog vremena (dok proces A eka na podatke sa diska, procesor bi mogao izvravati proces B koji da ra una vrednost broja na to ve i eli broj decimala...) jednokorisni ki sistemi: dok piemo u text editoru, ho emo sluati muziku sa CD-a, a elimo da nam tampa iztampa horoskop koji je u meuvremenu preuzet sa interneta, itd.

Fixne particije
Posmatrajmo drugi na in kod monoprogramiranja: memorija se deli na dva dela jedan deo koristi OS, a drugi deo je namenjen korisni kim programima. Ve bismo ovde mogli ostvariti swapping: spremni procesi ekaju na disku, biramo jedan koji se u itava u memoriju i izvrava se neko vreme, zatim se vra a na disk, pa biramo drugi itd. Jedan veliki nedostatak ove realizacije je sporost. Diskovi su mnogo sporiji od memorije, pa emo mnogo vremena izgubiti na menjanje procesa. Proirimo ovu ideju na slede i na in: podelimo memoriju na meusobno nezavisne i odvojene delove particije. U svaku particiju emo u itati proces koji je spreman za izvravanje, taj proces vidi samo svoju particiju i misli, da je sam u memoriji. Particije se odreuju nakon startovanja sistema ru no, od strane operatora sistema. Kako odrediti veli inu particija? Imamo dva pristupa: - neka su sve particije iste veli ine nedostak: particija je veli ine 1MB, a u njoj se izvrava proces veli ine 100KB, cela particija je zauzeta, a 90% raspolo memorije ive u toj particiji je neiskori en - neka su particije razli ith veli ina imamo manje i ve e particije, u svaku particiju stavljamo proces koji najbolje iskori ava raspolo memoriju ivu Liste ekanja: imamo dve mogu nosti: 1. svaka particija ima svoju listu ekanja novi proces se stavlja u listu najpogodnije particije (gledamo da imamo to manje neiskori ene memorije). Nedostatak ovog pristupa: mo se desiti da na listama ekanja manjih procesa e eka 100 procesa a lista neke ve e particije je prazna. 2. imamo jednu listu ekanja za sve particije kada neka particija postaje slobodna, upravlja memorije pregleda listu ekanja i bira slede i proces. Izbor procesa mo se vriti na dva osnovna na ina: e a.) biramo proces koji je najbli u redu ekanja i mo da stane u datu i e particiju. Nedostatak: imamo na raspolaganju veliku particiju, ali je mali proces bli nego veliki, pa e mali proces biti u itan u veliku particiju e gubimo mnogo memorije na mali proces. b.) biramo najve i od svih onih procesa koji mogu stati u datu particiju. Nedostatak: mali procesi su diskriminisani, uvek biramo ve e procese. Reenja za izbegavanje navedenih nedostataka:

58

1. definiemo dovoljan broj dovoljno malih particija (u koje mogu stati samo mali procesi a ne i veliki) 2. uvodimo slede e pravilo: ni jedan proces ne mo biti presko en vie od k e puta. Svaki proces dobija po jedan broja , svaki put kad se dati proces presko i, pove ava se broja . Ako pri tra enju procesa upravlja memorije vidi da je proces presko en k puta, u itava ga u particiju, a broja se resetuje bez obzira na to da postoji neki proces koji je ve i od njega a isto stane u posmatranu particiju. Veli inu broja k odreuje sistem operator.

U principu, mogli bismo swapping realizovati i sa fixnim particijama: svaki put kada se neki proces blokira, prebacimo ga na disk, a u tako osloboenu particiju u itamo drugi spreman proces. Prakti no gledano, ne emo dobiti dobre rezultate u iskori avanju memorije: mo emo imati male procese, koje u itavamo u ve e particije, pa gubimo mnogo memorije. To se zove unutra nja fragmentacija (internal fragmentation).

Relokacija i za tita
Relokacija
Particionisanjem memorije dolazimo do situacije, da jedan isti proces mo biti u itan i izvravan e u razli itim particijama. To dovodi do problema relokacije, naime prilikom prevoenja programa kompajler (prevodilac) generie objektne fajlove koji sadr logi ke adrese. Zatim dolazi linker e (povezilac) i povezuje sve kori ene (i prevedene) module u jedan izvrni fajl. Da bi to uradio, potrebno je da zna po etnu fizi ku adresu gde e program biti u itan i izvravan. Poto je to za vreme povezivanja nepoznato, i linker e morati da koristi logi ke adrese. Zna i sada imamo izvrni fajl sa logi kim adresama. Poto ne znamo fizi ke adrese za vreme prevoenja programa (ne znamo unapred u kojoj e particij program biti u itan), koristimo logi ke adrese pa neko treba da izmeni te adrese za vreme u itavanja naeg programa u memoriju. Imamo dve mogu nosti: 1. Adrese e postaviti punilac (loader). Punilac je deo OS-a koji je zadu da u ita program sa en diska u memoriju. Kako on ve zna, u koju particiju treba u itati, mo reiti i problem e relokacije, tako to e izmeniti sve potrebne adrese u programu, tako da se mo izvriti e unutar te particije. Kako e punilac znati koje adrese treba izmeniti? Tako to e linker

59

obezbediti potrebne informacije: ubaci e spisak onih mesta u programu gde se nalaze adrese. Nedostatak je slaba zatita: punilac mo proveriti adrese koje su mu poznate zahvaljuju i e linkera ali nita vie. Program mo izgenerisati adresu koja ne spada unutar svoje particije. e Drugi nedostatak je u tome to se program ne mo pomerati po memoriji nakon u itavanja a e da se sve adrese ne ra unaju iz po etka. 2. Hardverska podr ka: procesor treba da ima dva posebna registra: base register (bazni registar) i limit register (grani ni registar). Bazni registar uva po etnu adresu particije gde je proces u itan, a grani ni registar krajnju adresu te particije (ili veli inu particije). Punilac u ovom slu aju ne menja adrese procesa, jednostavno samo u ita proces u particiju i postavi vrednost baznog registra. Zna i sada u memoriji imamo proces sa logi kim adresama. Svaki put prilikom adresiranja, uzima se logi ka adresa programa i sabira se sa sadr ajem baznog registra i tako se dobija fizi ka adresa. Hardverska podrka reava i problem zatite: kada se izra unava fizi ka adresa memorije kojoj program pristupiti, jednostavno se uporeuje sa eli sadr ajem grani nog registra. Kori enje baznog registra za relokaciju pru jo jednu mogu nost: program se mo a e pomerati po memoriji za vreme izvravanja - jer su sve adrese logi ke, a fizi ke se ra unaju na osnovu baznog registra. Program prebacimo na neku drugu po etnu adresu, postavimo sadr aj baznog registra i izvravanje se mo nastaviti. e Napomena: razlika izmedju EXE i COM fajlova u DOS-u je upravo u relokatibilnosti. EXE fajlovi su relokatibilni, mogu se u itati po evi od bilo koje memorijske adrese i izvravati. COM fajlovi nisu relokatibilni i ne mogu biti ve i od 64KB.

Za tita
Problem zatite mo emo formulisati ovako: kako mo emo spre iti procesa koji je u itan u particiju A da pristupi sadr particije B? Imamo dva reenja: aju 1. Memorija se deli na blokove fixne veli ine (npr. 1KB, 4KB ili neto drugo), svakom bloku se dodeljuje 4-bitni zatitni kod. Proces mo pristupati samo onim blokovima, iji kod odgovara e kodu koji je dobio proces. Kodovima upravlja operativni sistem. (Ovo reenje je naputeno.) 2. Kori enjem baznog i grani nog registra

60

Upravljanje memorijom sa swappingom

U slu aju da nemamo dovoljno interne memorije za uvanje svih spremnih procesa, moramo neke procese izbaciti u eksternu memoriju, a kada je to potrebno, moramo ih vratiti u internu memoriju i nastaviti njihovo izvravanje. To se zove swapping.

Multiprogramiranje sa promenljivim particijama

Da bismo izbegli problem unutranje fragmentacije (internal fragmentation) uvodimo promenljive particije: veli ina pojedinih particija se odreuje na osnovu procesa koji se u ita u memoriju. Nemamo unapred odreen broj particija sa unapred odreenim veli inama. Kada se proces u ita, zauzima onoliko memorije koliko mu je potrebno (ako imamo dovoljno memorije). Razlika izme u fixnih i promenljivih particija: kod fixnih particija, broj, veli ina, pa i lokacija svih particija je odreena unapred pri startovanju sistema od strane sistem operatora. Kod promenljivih particija ne znamo unapred ni broj, ni veli inu ni lokaciju particija ti parametri se odreuju dinami ki i zavise od procesa koji se izvravaju. Kori enje promenljivih particija donosi neke druge komplikacije: Problem spolja nje fragmentacije (external fragmentation): posmatrajmo slede u situaciju: memorija je ispunjena sa procesima (particijama razli itih dimenzija). Neka procesi A i B, redom veli ine 1MB i 2MB, zavre svoj rad, oni se izbacuju iz memorije, na njihovo mesto redom u itamo procese C i D veli ine 500KB i 1.5MB. Sada dolazi proces X kome treba 1MB memorije za rad, ta no je da imamo jo 1MB slobodnog mesta, ali ne na jednom mestu. Ovaj problem, mogli bismo reiti tako to emo pomerati sve procese tako da se sve slobodne particije nalaze na jednom mestu kontinualno (to se zove kompakcija - compaction). Veliki nedostatak je sporost, pa je mo pametnije da proces X eka dok se da ne oslobodi dovoljna koli ina memorije. Drugi problem je u slede em: mo emo imati procese koji rastu, tj. nakon u itavanja zahtevaju dodatnu memoriju za dinami ke promenljive ili za stek. Imamo vie reenja: 1. Procesi su du da prilikom u itavanja u memoriju jave maksimalnu veli inu heapa i stacka. ni 2. Proces se ubija (prekida) uz poruku o greci 3. Proces se prebacuje na disk i eka da se potrebna koli ina memorije oslobodi Tre i problem je to to treba voditi ra una o tome, gde se nalaze zauzete particije i koje su njihove veli ine, odnosno gde se nalaze prazne particije i koje su njihove veli ine.

Strukture podataka za upravljanje memorijom

Za voenje evidencije o zauzetosti memorije (o zauzetim particijama) i o rupama izmeu particija (slobodna memorija) mo emo koristiti slede e strukture: 1. Bitne mape (bit maps) 2. Povezane liste (linked lists) 3. Sistem drugova (buddy sistem)

61

Bitne mape (bit maps)

Memoriju delimo na delove iste veli ine. Svakom delu dodeljujemo po jedan bit na slede i na in: 1 ozna ava da je taj deo zauzeto, 0 da je slobodno (ili obrnuto). Tako dolazimo do niza nula i jedinica (bitova) koji se zove bitna mapa memorije. Pitanje: koje veli ine treba da budu ovi delovi memorije ? Ako je veli ina delova 32bita (4 bajta), onda za bitnu mapu koristimo 1/33 od ukupne memorije. Ako su delovi manji, bitna mapa je ve a (ako je veli ina delova 16bita, onda za bitnu mapu koristimo 1/17 od ukupne memorije: od 512MB ode na administraciju oko 30MB) i tra enje slobodne memorije (niz nula) je spora. Ako su delovi ve i, kvarimo iskori enost memorije: neka su delovi veli ine 4KB, ako proces zauzme 1KB od nekog dela, 3KB ostaje neiskori en, ali ne mo biti alociran od strane e drugog procesa jer je formalno zauzeto.

Povezane liste (linked lists)

Memorija je ili zauzeta od strane nekog procesa (P) ili je slobodna (rupa, H hole). Povezane liste gradimo od slogova slede e strukture: P ili H po etna adresa veli ina slede i

Prvo polje sloga ozna ava tip memorije: P ozna ava da se radi o procesu, H da se radi o slobodnoj memoriji. Drugo polje sadr po etnu adresu dela memorije koju opisuje dati slog. Tre e polje veli inu i opisane memorije, a etvrto polje sadr pokaziva na slede i slog. i Upravljanje memorijom se odvija na slede i na in: Zauzimanje memorije: imamo proces, tra imo dovoljno veliku rupu u memoriji. Pretra ujemo povezanu listu, tra imo slog tipa H (rupa) dovoljne veli ine. Ako naemo, umesto H upiemo P, i eventualno ubacimo novi vor tipa H (ako proces ne zauzima celu rupu, ostaje nam neka manja rupa). Osloba anje memorije: proces A zavri sa radom, oslobodimo zauzetu memoriju. Tada jednostavno stavimo H umesto P ako se i ispred i iza procesa A nalazi neki drugi proces (a ne slobodna memorija), ina e vrimo a uriranje liste: - ako je ispred procesa A slobodna memorija X a iza proces B, menjamo X i izbacimo A,tj. : X.veliina := X.veliina + A.veliina ; X.sledei := A.sledei ; Free ( A ) - ako je ispred procesa A proces B a iza slobodna memorija X, menjamo A i izbacimo X: A.veliina := A.veliina + X.veliina ;

62

A.sledei := X.sledei ; Free ( X ) ako je ispred procesa A slobodna memorija X a iza slobodna memorija Y, menjamo X i izbacimo A i Y: X.veliina := X.veliina + A.veliina + Y.veliina ; X.sledei := Y.sledei ; Free ( A ) ; Free ( Y ) ;

Sistem drugova (Buddy system)

Upravlja memorije koristi po jednu listu za blokove slobodne memorije veli ine 1,2,4,8,16,32,64, itd. bajtova sve do ukupne veli ine memorije, po stepenima dvojke. Uzmimo na primer, da imamo 1MB memorije, tada emo imati 21 listu (2^0=1 ... 2^20=1MB). Na po etku cela memorija je prazna, pa u listi za rupe od 1MB imamo jedan slog, a ostale liste su prazne. 1024KB

Sada dolazi proces A veli ine 70KB. Najmanja particija u koju mo stati jeste ona od 128KB e (mora biti stepen od 2). Na alost, lista koja sadr particije te veli ine je prazna. Zato emo particiju od i 1MB razbiti na dva dela od 512KB (ovi delovi se zovu drugovi buddy), pa emo prvi razbiti na dva dela od 256KB, i jo jednom, prvi delimo na dva dela od 128KB. U prvu particiju stavimo proces: A 128 128 256 512

Sada lista od 128Kb sadr dva vora (jedan je zauzet P, a drugi je slobodan H), a liste od i 256KB i 512KB sadr po jedan slobodan vor. Ovde ve vidimo nedostatak ovog sistema: za proces od e 70KB zauzimamo itavu particiju od 128KB, tj. gubimo 58KB memorije (unutranja fragmentacija). Neka sada doe proces B veli ine 35KB. Potrebno je zauzeti particiju veli ine 64KB. Lista za takve particije je prazna. Zato delimo prvu slobodnu particiju od 128KB na dva dela od 64KB, u jednu ubacimo proces B a druga ostaje prazna. Sada imamo po jedan vor u listama za 128KB,256KB i 512KB i dva vora u listi za 64KB. A 128 B 64 64 256 512

Novi proces C od 80KB ubacujemo tako to delimo 256KB na dva dela od 128KB, u prvi ubacimo C a drugi ostaje prazan: A 128 B 64 64 C 128 128 512

Posmatrajmo sada stanje memorije: zauzeli smo 128+64+128=320KB za tri procesa ukupne veli ine 70+35+80=195KB.

63

Drugari su susedne rupe iste velicine: A i B (da su rupe) nisu drugovi, ali to jesu npr. B (kao rupa) i rupa pored nje. Ako neki proces zavri sa radom, proverimo veli inu rupe koja nastaje. Ako u susedstvu ima druga, formiramo duplo ve u rupu od te dve rupe. Va je da veli ina novoformirane rupe bude neki no stepen od 2 ako to nije slu aj, odustajemo od spajanja.

Algoritmi za izbor prazne particije

Uze emo povezane liste za strukturu upravljanja memorijom. Pretpostavka je da su liste sortirane na osnovu po etnih adresa. 1. Prvi odgovarajui (FIRST FIT): upravlja memorijom pretra povezanu listu od po etka uje do kraja i novi proces stavlja u prvu rupu koja je dovoljna velika. Ako je rupa iste veli ine kao i sam proces, jednostavno menjamo tip sloga iz H (rupa) u P (proces), ako je rupa ve a, menjamo tip iz H na P, postavimo veli inu, zatim iza tog sloga ubacimo jo jedan koji e reprezentovati rupu koja preostaje. Ovo je najbolji algoritam. 2. Sledei odgovarajui (NEXT FIT): radi na isti na in kao first fit, samo ne kre e svaki put od po etka liste, ve od mesta gde je poslednji put stao. Pokazuje sli ne performanse kao first fit. 3. Najmanja particija (BEST FIT): svaki put pretra celu listu i tra najmanju rupu u koju uje i mo stati dati proces. Sporiji je od prva dva algoritma jer mora svaki put pre i celu listu. e Pored toga dolazi do ve e spoljanje segmentacije (gubimo vie memorije nego kod prethodna dva algoritma): poto uvek tra imo najmanju mogu u rupu a mala je verovatno a da e ta rupa biti po bajtu iste veli ine kao proces, pa dobijamo mnotvo malih rupa koja se ne mogu ni na ta iskoristiti (bez grupisanja na jedno mesto a to je jako spora operacija i izbegava se). 4. Najvea particija (WORST FIT): radi na isti na in kao best fit, samo to uvek tra najve u i mogu u rupu. Pretpostavka je slede a: ako proces stavimo u najve u mogu u rupu, imamo ve u ansu da ostatak bude dovoljno veliko da u njega stane neki drugi proces. Simulacije su pokazale da je worst fit najloiji algoritam. Do sada smo pretpostavili da koristimo jednu povezanu listu u kojoj se nalaze procesi i rupe sortirani po po etnim adresama. Sada emo razmatrati neke mogu e varijacije ovih algoritama: 1. Koristimo dve liste jednu listu za procese i jednu listu za rupe. Dobra strana je brzina (ne treba pre i i preko procesa). Loa strana je pove ana kompleksnost a uriranja: ako proces postaje rupa mora se izbaciti iz liste za procese a ubaciti u listu za rupe. Ako rupa postaje proces, mora se prebaciti iz liste za rupe u listu za procese poto emo verovatno dobiti i novu rupu, moramo zauzeti memoriju za novi slog i ubaciti u listu za rupe. 2. Ako koristimo dve liste, mogli bismo listu za rupe sortirati po veli ini tada best fit i worst fit veoma brzo rade (postaju efikasni kao i first fit). 3. Koristimo posebnu listu za procese i vie lista za rupe. Formiramo liste rupa esto kori enih veli ina. Npr. 4KB, 8KB, 20KB itd. Neobi ne (rupe nepredvienih veli ina) stavljamo u posebnu listu. Ovaj algoritam se zove quick fit dobra strana je brzina, loa strana je komplikovanost a uriranja (naro ito kada proces postaje rupa, pa treba videti da li su susedi rupe radi spajanja u ve u rupu). 64

Virtuelna memorija (virtual memory)

Znamo da procesor mo izvravati samo procese koji su u internoj memoriji. Kako je operativna e memorija relativno malog kapaciteta, dolazimo do slede ih problema: 1. proces je ve i od interne memorije (i kod monoprogramiranja i kod multiprogramiranja) 2. nemamo dovoljno memorije da u itamo sve spremne procese (kod multiprogramiranja)

Overlay
U slu aju, da je na program ve i od operativne memorije, kao reenje mo emo koristiti tehniku koja se zove overlay. Program delimo na meusobno relativno nezavisne delove. Ti delovi e formirati pakete koji se u itavaju po potrebi za vreme izvravanja, sa diska u memoriju. Inicijalno se zauzima onoliko memorije koliko je potrebno za najve i paket (pored mesta za one delove programa koji stalno moraju biti u memoriji tj. za pakete overlay-a rezerviemo poseban deo memorije). Zatim, u toku rada programa, kada pozovemo neku proceduru iz nekog paketa koji se nalazi na disku. bi e preba en sa diska u internu memoriju umesto trenutnog paketa. Overlaj paketi mogi biti posebni fajlovi na disku (pored EXE programa i nekoliko OVR fajlova). Primer: ozna imo glavni program sa A, a pakete sa B,C,D,E. Naka je glavni program veli ine 700KB, a paketi redom veli ine 120KB, 200KB, 150KB, 75KB. Neka imamo na raspolaganju 1MB slobodne memorije. Vidimo, da je ukupna veli ina naeg programa bez kori enja ove tehnike skoro 1.3MB to je vie nego to imamo. Ako koristimo overlay tehniku, treba nam ukupno 700 + 200 (veli ina najve eg paketa) = 900 KB i na program mo biti izvren. e

Virtuelna memorija
Iako prebacivanje raznih overlay paketa sa diska u memoriju i nazad mo biti zadatak OS-a, e razbijanje programa na manje, meusobno relativno nezavisnih delova je posao programera. Razbijanje velikih programa u manje delove je mukotrpan i dosadan zadatak. Zato su programeri odlu ili da i taj zadatak predaju OS-u. OS treba jednom napisati i onda e on uzeti stvari u ruke, pa ne treba kod pisanja svakog programa razmiljati o razbijanju na delove. Osnovna ideja je da pustimo lepo programera neka napie program veli ine koje i onda e OS voditi ra una o tome da u memoriji budu samo oni delovi eli, procesa (i kod i podaci) koji su u datom trenutku potrebni, a ostatak neka eka na disku. Zna i jedan deo procesa je u internoj memoriji a drugi deo je u eksternoj memoriji, a sam proces nema pojma o tome njemu se ini da ima dovoljno operativne memorije i da se itav proces nalazi u internoj. Druga ije re eno: ako nema dovoljno memorije, uze emo malo od diska procesi ne e znati za to, mo korisnik da kada primeti usporavanje rada programa. Ova ideja mo se koristiti i sa multiprogramiranjem: ako imamo 1MB memorije i vie procesa e veli ine 2MB, nekoliko njih e dobiti 256KB za rad, a ostali ekaju na disku (ovde koristimo i 65

swapping). Ako je procesu A potreban neki deo sa diska, tada - poto eka na I/O operaciju postaje blokiran i kontrola se predaje drugom procesu.

Paging (strani enje)

Paging se koristi kao tehnika za realizaciju virtuelne memorije. Nemamo dovoljno interne memorije da bismo u itali ceo proces, pa koristimo virtuelnu memoriju memoriju koja je ve a od fizi ke interne memorije. Proces nema pojma o tome da se izvrava u virtuelnoj memoriji, ubeen je da je u internoj memoriji i ponaa se u skladu sa time: pristupa memorijskim lokacijama koje fizi ki mo da ne postoje. Zato je za realizaciju virtuelne memorije potrebna pomo od strane hardvera. Memorijska adresa generisana od strane programa zove se virtualna adresa iz virtualnog adresnog prostora. Kod ra unara bez virtuelne memorije, adresa generisana od strane procesa ide direktno od procesora ka memoriji. Ako koristimo virtuelnu memoriju, virtuelna memorija ide najpre do dela procesora koji se zove jedinica za upravljanje memorijom (MMU Memory Managment Unit), koja virtuelnu adresu pretvara u fizi ku memorijsku adresu:

Virtuelni adresni prostor (virtuelna memorija) se deli na blokove iste veli ine. Ti blokovi se nazivaju virtuelnim stranicama (virtual pages). Isto tako internu memoriju delimo na blokove iste veli ine. Ti blokovi se zovu okviri za stranice (page frames). Virtuelne stranice i okviri za stranice imaju iste veli ine. Ra unanje fizi ke adrese na osnovu virtuelne adrese se radi na osnovu tabele stranica (page table) koja predstavlja preslikavanje virtuelnih stranica u fizi ke stranice. Ova tabela se dodeljuje svakom procesu i menja se u toku izvravanja procesa: ako proces pristupiti nekoj adresi eli koja se nalazi na virtuelnoj stranici koja nije u itana u internu memoriju, moramo izbaciti neki okvir za stranice iz operativne memorije (ako je cela operativna memorija ve zauzeta) na eksternu memoriju a iz eksterne memorije moramo dovu i tra stranicu na mesto izba enog okvira za stranice. enu Posmatrajmo sada slede i primer: imamo ra unar koji radi sa 16-bitnim adresama, to zna i da zna adresirati 64KB virtuelne memorije. Pretpostavimo da ovaj ra unar ima ukupno 32KB operativne memorije. Zna i i pored toga da vidi 64KB, bez virtuelne memorije ne mo emo u itati programe ve ih od 32KB. Neka su virtuelne stranice (pa i okviri stranica) veli ine 4KB. Neka imamo neki proces kome treba 64KB virtuelne memorije i imamo slede e preslikavanje virtuelnih stranica u okvire za stranice (X ozna ava da data virtualna stranica nije u itana u internu memoriju):

66

Neka sada proces pokua pristupiti memoriji na virtuelnoj adresi 0. Centralni procesor (CPU) alje adresu jedinici za upravljanje memorijom (MMU), koja proverava tablicu stranica i vidi da je data virtuelna stranica (0 4K) u itana u drugi okvir (8 12K) interne memorije. Zato alje zahtev dalje internoj memoriji radi pristupa memoriji sa adresom 8192. Neka sada proces zatra pristup memoriji na virtuelnoj adresi 9000. CPU alje tu adresu MMU-u, i MMU pogleda tablicu stranica i vidi da je odgovaraju a virtuelna stranica (8 12K) u itana u esti okvir fizi ke memorije (24 28K), zato alje zahtev prema internoj memoriji radi pristupa memoriji sa adresom 25384 (9000 8192 = 808, 24576 + 808 = 25384). Neka u tre em primeru proces pokua pristupiti virtuelnoj memoriji na adresi 26000. CPU alje adresu MMU-u, MMU gleda u tablicu stranica, vidi da tra virtuelna stranica nije u itana u internu ena memoriju, ne mo slati zahtev!! Zbog toga MMU generie prekid koji se zove NEPOSTOJE A e STRANICA (PAGE FAULT). Tada kontrolu preuzima operativni sistem. OS najpre izabere jedan okvir iz interne memorije. Sadr tog okvira prenosi na disk, a na to mesto u ita tra virtuelnu stranicu, aj enu a urira tabelu stranica vrati broja instrukcije nazad i pusti neka proces pokua ponovo.

Kako radi MMU ?

Neka CPU alje adresu 8196 = 0010000000000100. Tu adresu delimo na dva dela: 4 najzna anija bita ozna avaju index unutar tabeli stranica, a ostalih 12 bita ofset adresu unutar date stranice. Tako mo emo imati ukupno 16 virtuelnih stranica (od 0 do 15), a sa 12 bita mo emo adresirati ukupno 2^12 = 4096 = 4KB memorije. (Zato smo adresni prostor delili na 4KB stranice.) Tabela stranica sadr dakle 16 i polja. Svako polje e biti predstavljen pomo u 4 bita: 3 najzna ajnija bita daju redni broj okvira stranica a najmanje zna ajni bit informaciju o tome da li je data virtuelna stranica u itana u internu memoriju (1 jeste, 0 nije). Taj bit se zove bit prisutnosti (present/absent bit). Fizi ku adresu formiramo na slede i na in: na osnovu 4 najzna ajnija bita adrese dobijene od CPU-a (0010) , uzmemo index okvira stranice (110) , pogledamo da li je data stranica u itana u internu memoriju (1 jeste, ako nije, generiemo page fault prekid) i samo iza 110 dodajemo ostatak adrese (000000000100), pa dobijamo 110000000000100. Prva 3 najzna ajnija bita ozna avaju okvir stranice, a ostalih 12 bitova daju ofset adresu unutar tog

67

okvira. Kako imamo 3 bita za okvire, mo emo imati ukupno 8 okvira. Vidimo da je dobijena fizi ka adresa petnaestnobitna (15), to omogu ava adresiranje do 32KB memorije.

Izbor stranica za u itavanje (fetch-strategy)

Imamo dve osnovne strategije: 1. U itavanje po potrebi (demand paging): u itavamo samo jednu stranicu onu koju tra i MMU. Dobra strana je to u internoj memoriji dr imo samo one stranice koje su stvarno potrebne. Loa strana je sporost. 2. U itavanje sa predvi anjem (anticipatory paging): OS pokua predvideti, pogoditi koje stranice e biti potrebne za rad procesa i u itava te stranice ako ba nema ta da radi a ni disk nije zauzet. Ako pogodi koje stranice treba u itati, smanjuje se broj page fault-a i izvravanje procesa dobija na brzinu. Ako ne, od u itavanja nemamo nikakvu korist. Kako cena interne memorije pada a kapacitet raste, ova strategija postaje sve popularnija. (imamo dovoljno memorije da u itamo jo neke stranice, pa ako smo pogodili dobro je, ako nismo, onda nita).

68

Izbor okvira za izbacivanje (page replacement algorithms)

Kada doe do prekida page fault, koji javlja OS-u da MMU nije naao tra virtuelnu stranicu enu meu okvirima unutar interne memorije, OS treba da odredi u koji e okvir u itati potrebnu stranicu (odnosno, sadr kog okvira e izbaciti iz operativne memorije). aj Ako je sadr izabranog okvira menjan, OS mora ga prebaciti na disk (da bi sa uvao izmene), aj ako sadr nije menjan, onda samo treba u itati novu virtuelnu stranicu. aj Sada emo razmatrati neke algoritme za izbor okvira koji e biti izba en iz interne memorije: 1. Optimalni algoritam 2. NRU (okvir koji nismo skoro koristili) 3. FIFO algoritam (okvir koji smo najpre u itali) 4. Druga ansa (varijanta FIFO algoritma) 5. Satni algoritam 6. LRU (okvir koji smo najdavnije koristi) 7. NFU (okvir koji je najree kori en najmanji broj puta) 8. NFU sa starenjem

1. Optimalni algoritam (Optimal Page Replacement Algorithm)

Kada doe do page fault-a, optimalni algoritam e truditi da izbaci onu stranicu za koju smatra da e najkasnije biti potrebna. Zna i, ako vidimo da e stranica A biti potrebna nakon 100 instrukcija, a stranica B za 1000 instrukcija, onda je bolje da izbacimo stranicu B time emo javljanje slede eg page faulta odlo najdu to mo iti e emo. MMU ne voli prekidati svoj rad i javljati OS-u da nije naao neku stranicu, zato se trudimo da odlo prekide to du imo e. Ova je najbolja mogu a strategija, ali na alost ne mo se implementirati. Ne postoji na in da OS e doe do potrebne informacije o tome, kada e koja stranica biti potrebna. (Trebalo bi na neki na in predvideti rad procesa.)

2. NRU Not Recently Used (okvir koji nismo skoro koristili)

Strategija je slede a: izbacujemo onu stranicu kojoj nismo skoro pristupili. Pretpostavimo da je svakom okviru pridru dva bita: R (referenced) ozna ava da li smo eno pristupili ( itali ili pisali) tom okviru, odnosno M (modified) da li smo menjali sadr tog okvira. Ako aj hardver ra unara ne podr ove bitove, mogu se implementirati na nivou OS-a. ava Pri po etku rada procesa svi R-ovi i M-ovi dobijaju vrednost 0. Zatim pri svakom prekidu hardverskog sata OS brie vrednost R-ova (stavlja R=0) da bi mogao razlikovati stranice koje su skoro kori ene od onih koje nisu. Ako je R=1, to zna i da je datom okviru pristupljeno u zadnjih 20ms (ako hardverski sat generie prekid svakih 20ms). Kada u itamo neku stranicu sa eksterne u internu memoriju stavimo M=0 (sadr okvira nije aj menjano). Ako doe do menjanja sadr stranice, stavimo M=1 to onda ozna ava da emo morati aja sadr tog okvira prebaciti na disk (da bismo sa uvali promene) ako za izbacivanje izaberemo ba taj aj okvir. Na osnovu vrednosti R i M bitova okvire delimo u klase :

69

klasa 0 1 2 3

R 0 0 1 1

M 0 1 0 1

opis okviru nismo pristupili u zadnjih 20ms, sadr nije aj menjan okviru nismo pristupili u zadnjih 20ms, ali je sadr aj menjan okviru smo pristupili u zadnjih 20ms, ali nije menjan sadr aj okviru smo pristupili u zadnjih 20ms, i menjan je sadr aj

NRU algoritam bira proizvoljan okvir iz prve neprazne klase sa manjim brojem. Zna i ako mo emo, biramo okvir iz klase 0, ako ne, onda iz klase 1, ako ne, onda iz klase 2, i tek na kraju iz klase 3. Prednost: jednostavan je za implementaciju i za razumevanje. Nedostatak: ne pravi dovoljno finu razliku izmeu stranica iste klase (ne vodimo ra una o broju pristupa ni o broju menjanja sadr okvira). aja

3. FIFO algoritam okvir koji smo najpre u itali (First In First Out Page Replacement Algorithm)
Izbacujemo onu stranicu koju smo najranije u itali. Ovaj algoritam pretpostavlja da ako je neka stranica davno u itana, verovatno je ve odradila svoj deo posla i da e u budu nosti manje biti potrebna od stranica koja su stigla posle nje. Nedostatak ovog pristupa je to to emo izbaciti stranicu ak i ako je esto koristimo samo zato to je ostarela. Zbog ovog nedostatka ovaj algoritam se u ovoj verziji ne koristi.

4. Druga ansa varijanta FIFO algoritma (Second Chance Page Replamcement Algorithm)
Koristi istu strategiju kao FIFO algoritam uz dodatak da uzima u obzir i kori enost stranica time pokuava izbe i nedostatak FIFO reenja. Kao pomo , koristimo vrednost R (referenced) bitova (1 ako smo pristupili stranici, 0 ako nismo). Kada treba izbaciti stranicu, uzmemo zadnju iz reda ekanja, pogledamo R bit. Ako je R=0, to zna i da je stranica dugo u memoriji a da joj nismo pristupili dakle, nije potrebna, mo se izbaciti i u itati nova. Ako je R=1, to zna i da je stranica dugo u memoriji, ali smo e je nedavno koristili. Tada emo staviti R=0 a stranicu prebacimo na po etak reda opslu ivanja gledamo slede u stranicu. Zna i, ako je stranica kori ena dobija jo jednu ansu. Ako su sve stranice kori ene, algoritam e staviti R=0 za svaku, pa e po eti ponovo od najstarije stranice. Sada je ve R=0, pa e biti izba ena. Algoritam sigurno nalazi okvir za bacenje. Ako je R=0 za sve stranice, ovaj se algoritam ponaa isto kao i FIFO verzija.

5. Satni algoritam (Clock Page Replacement Algorithm)

Nadogradnja algoritma druga ansa. Stranice stavljamo u kru listu. Pokaziva pokazuje na nu stranicu koja je najranije u itana. Kada treba izbaciti stranicu, proverimo R bit stranice na koju pokazuje na pokaziva . Ako je R=0, stranica se izbacuje a na njeno mesto se u itava nova stranica. Ako je R=1, stavimo R=0 i pomeramo pokaziva na slede u stranicu tra dalje. Na ovaj na in izbegavamo stalno imo pomeranje opisa stranica sa po etka reda opslu ivanja na kraj (to se javlja kod algoritma druga ansa) time poboljavamo performansu. Nedostatak satnog i prethodnog algoritma je u tome to ne vode ra una o tome koliko puta smo pristupili pojedinim stranicama. Satni algoritam je najbolji u skupu koji ine tre i, etvrti i peti algoritam. 70

6. LRU okvir koji smo najdavnije koristili (Least Recently Used Page Replacement Algorithm)
Biramo onu stranicu koju smo najdavnije koristili: stranice sa kojima smo radili u bliskoj prolosti, verovatno e nam trebati i u bliskoj budu nosti. Ovaj algoritam radi jako dobro, ali se teko ostvaruje. Implementacija zahteva podrku od strane hardvera. Imamo nekoliko realizacija: 1. Pomou broja a (hardverska podr ka): procesor ima broja instrukcija. Kada se ra unar startuje, broja se resetuje na nulu. Nakon svake instrukcije pove amo ga za jedan. Svaki okvir ima svoj interni broja . Svaki put kada pristupimo okviru, prebacimo sadr broja a aj procesora u interni broja okvira. Kada doe do page fault prekida, upravlja memorijom pregleda sve interne broja e i bira stranicu iji je broja najmanji (to zna i da je kori ena najdavnije). Nedostatak: pri svakom pristupu memorije moramo izvriti plus jedan pristup radi prebacivanja sadr glavnog broja a u lokalni. aja 2. Pomou povezane liste (softversko re enje): sli no kao kod FIFO algoritma, stranice stavljamo u red opslu ivanja. Kada se javlja page fault prekid, biramo prvu iz reda, novu stavljamo na kraj reda. Svaki put kada pristupimo nekoj stranici, a uriramo listu: stranicu vadimo iz liste i prebacimo na kraj reda. Ova realizacija je jako spora: pri svakom pristupu memoriji moramo a urirati listu. 3. Pomou dvodimenzionalnog niza (matrice hardverska podr ka): imamo matricu formata NxN, gde N ozna ava broj okvira interne memorije. Matrica se inicializuje na nulu (nulamatrica). Prilikom pristupa k-tom okviru, k-tu vrstu matrice ispunimo sa jedinicama a k-tu kolonu sa nulama. Tada vrste ozna avaju mladost odgovaraju e stranice u binarnom zapisu (to je broj ve i, stranica je kori ena u bli prolosti). Biramo stranicu sa najmanjim oj brojem. Primer: neka imamo 4 okvira, tada nam treba matrica formata 4x4, neka je redosled pristupa slede i : 1,1,2,3,1,4. Tada emo izbaciti drugu stranicu jer je ona najdavnije kori ena. 1 0 0 0 0 2 1 0 0 0 3 1 0 0 0 4 1 0 0 0 1 0 0 0 0 2 1 0 0 0 3 1 0 0 0 4 1 0 0 0 1 0 1 0 0 2 0 0 0 0 3 1 1 0 0 4 1 1 0 0

1 2 3 4

1 2 3 4

1 0 1 1 0

2 0 0 1 0

3 0 0 0 0

4 1 1 1 0

1 0 0 0 0

2 1 0 1 0

3 1 0 0 0

4 1 1 1 0

1 0 0 0 1

2 1 0 1 1

3 1 0 0 1

4 0 0 0 0

7. NFU okvir koji najre e koristimo (Not Frequently Used Page Replacement Algorithm)
Biramo stranicu koja je najree (najmanji broj puta) kori ena. Oslanja se na R bit: svaki okvir ima svoj broja i R bit. R bit ozna ava da li smo pritupili datoj stranici u predhidnih 20ms. Inicijalna vrednost i broja a i R bita je 0. Pri svakom prekidu hardverskog sata OS pogleda sve R-bitove, doda

71

vrednost unutranjim broja ima i resetuje R. Kada pristupimo stranici R bit se setuje. Prilikom page faulta bacimo stranicu iji broja ima najmanju vrednost. Nedostaci: 1. algoritam sve pamti: stranice koje smo nekada esto koristili ostaju u memoriji i pored toga to vie nisu potrebne. 2. nove stranice kre u od nule, stare imaju prednost, pa emo izbaciti tek u itanu stranicu

8. NFU sa starenjem (Not Frequently Used with aging)

Pokuava izbe i nedostatak NFU algoritma da ne bi sve pamtio ura unava i starost stranice: OS prilikom svakog prekida hardverskog sata pomera bitove (shiftuje) unutranjeg broja a prema desno (najmanje zna ajni bit se gubi), a vrednost R bita se postavi na najzna ajniju poziciju (prvi bit sa leve strane). Izbacujemo stranicu iji broja ima najmanju vrednost. Uporedimo rad isto NFU algoritma i NFU algoritma sa starenjem na jednom primeru: Sa NFU algoritmom: broja 1000 0010 1000 0000 R 1 0 0 1 broja 1001 0010 1000 0001 R 1 1 0 1 broja 1010 0011 1000 0010

1 2 3 4

Vidimo da smo nekada tre u stranicu esto koristili a kako NFU pamti sve, broja tre e stranice ima ve u vrednost nego broja stranice 4 kojoj smo u bliskoj prolosti pristupili ak dva puta, a ipak e ta biti izba ena. Sa NFU algoritmom sa starenjem: broja 1000 0010 1000 0000 R 1 0 0 1 broja 1100 0001 0100 1000 R 1 1 0 1 broja 1110 1000 0010 1100

1 2 3 4

Ovde ve uzimamo u obzir i starost stranice: ta no je da smo tre u stranicu nekada mo e e da koristili, ali u bliskoj prolosti ona nam nije bila potrebna, pa e biti izba ena.

Dalji problemi strani enja

Belady-jeva anomalija
Bilo bi logi no da sa pove avanjem broja okvira stranica imamo manji broj page fault-a (ako imamo vie interne memorije, mo emo ve i broj virtuelnih stranica u itati, pa o ekujemo manji broj page

72

fault-a). Belady (Laszlo Belady, IBM-ov nau nik, 1969) je naao kontraprimer u slu aju FIFO algoritma, pa se ova pojava zove Belady-jeva anomalija. Neka imamo proces sa pet virtuelnih stranica i neka imamo na raspolaganju najpre 4 a zatim 3 okvira u internoj memoriji. Dobijamo slede u situaciju: Sa 3 okvira: pristup stranici 0. okvir 1. okvir 2. okvir page fault 0 0 1 0 1 X 2 0 1 2 X 3 3 1 2 X 0 3 0 2 X 1 3 0 1 X 4 4 0 1 X 0 4 0 1 1 4 0 1 2 4 2 1 X 3 4 2 3 X 4 4 2 3 0 0 2 3 X 1 0 1 3 X

Ukupan broj page faulta: 11 Sa 4 okvira: pristup stranici 0. okvir 1. okvir 2. okvir 3. okvir page fault 0 0 1 0 1 2 0 1 2 X 3 0 1 2 3 X 0 0 1 2 3 1 0 1 2 3 4 4 1 2 3 X 0 4 0 2 3 X 1 4 0 1 3 X 2 4 0 1 2 X 3 3 0 1 2 X 4 3 4 1 2 X 0 3 4 0 2 X 1 3 4 0 1 X

Ukupan broj page faulta: 12

Radni skup (Working Set)

Radni skup procesa ine one virtuelne stranice koje proces trenutno koristi. Ako je celi radni skup u memoriji, proces e raditi bez mnogo page faulta dok ne pree u neku drugu fazu rada. Ako je radna memorija premala da bismo u itali radni skup procesa, dolazimo do ve eg broja page faulta i izvravanje se usporava. Ako imamo sistem sa time-sharingom, esto je potrebno ceo proces (sve njegove stranice) prebaciti na disk, da bi neki drugi spreman proces dobio CPU za izvravanje. Pitanje je: ta uraditi pri vra anju procesa u memoriju. Najjednostavnije reenje je, ne raditi nita posebno, ostaviti neka proces generie svoje page faultove sve dok se ne u itava radni skup. To se zove u itavanje po zahtevu (demand paging) i nije ba neko efikasno reenje izvravanje procesa se usporava i gubimo dodatno procesorsko vreme zbog stalnih prekida. Zbog toga mnogi sistemi vode ra una o radnim skupovima i ne putaju rad procesa dok se ne uvere da je u itan u memoriju. To se zove model radnog skupa (working set model Denning, 1970). U itavanje stranica pre dozvole za rad zove se prepaging. Za implementaciju modela radnog skupa, potrebno je da OS ima mogu nost da vodi ra una o tome koje stranice spadaju u taj skup. Jedno reenje je kori enje NFU algoritma sa starenjem: OS posmatra n (odreuje se eksperimentalno) najzna ajnijih bitova unutranjih broja a i ka ako tu imamo e: setovane bitove (1), stranica pripada radnom skupu, ako nemamo (to zna i da neko vreme nismo pristupili toj stranici), ne pripada.

73

Lokalnost i globalnost
Postavlja se pitanje: kako raspodeliti okvire meu procesima? Imamo dva pristupa: 1. Loakalni pristup: svaki proces dobija odreen broj okvira i taj broj se ne mo menjati. Ako e doe do page faulta, onda stranicu za bacanje biramo u skupu dodeljenih okvira. Nedostatak: broj virtuelnih stranica procesa je ve a od dodeljenog broja okvira u internoj memoriji, dobar deo memorije je slobodna, ali ne mo emo u itati nove stranice bez izbacivanja ve u itanih zbog fixnog broja pridru enih okvira. Drugi nedostatak: proces prelazi u neko stanje u kome od pridru enih 100 okvira koristi samo 25 gubimo mnogo memorije, jer niko drugi ne mo e pristupiti tim nekori enim okvirima. 2. Globalni pristup: broj pridru enih okvira nije ograni eno. Memoriju delimo na okvire, svaki proces uzima koliko mo Ako proces A generie page fault, tada za razliku od lokalnog e. pristupa, stranicu koja e biti izba ena ne emo tra samo u skupu okvira prirdru iti enih za taj proces, ve u skupu svih okvira. Zna i mo se desiti, da OS odlu i da izbaci neki okvir e procesa B a na to mesto ubaci tra stranicu procesa A. Globalni pristup pokazuje bolje enu rezultate.

Segmentacija (segmentation)
Do sada smo koristili linearni adresni prostor: po inje od nule i ide do nekog maximuma, ceo proces se posmatra kao linearna struktura. Koristili smo tehniku overlaya da bismo program razbili na delove i delove u itavali po potrebi da bismo mogli izvravati programe koji su ve i od raspolo ive memorije. Zatim smo brigu o razbijanju programa na delove prepustili operativnom sistemu uvoenjem paginga. Sve do sada smo smatrali da je adresni prostor procesa linearan. Neki nedostaci ovog pristupa: ako bilo koju proceduru izmenimo, moramo prevoditi ceo program jer je adresni prostor linearan, pa ako izmenimo veli inu te procedure, menjaju se sve adrese iza nje, ili mo do i do rasta steka za vreme e izvravanja programa tako da se stek napuni, pa se podaci piu na deo gde se nalazi kod programa kako obezbediti efikasnu zatiti od toga itd. Ideja segmentacije je da se svakom procesu dodeli vie linearnih adresnih prostora koji po inju od nule i idu do nekog maksimuma. Ti prostori ili delovi procesa se nazivaju segmentima. Svaki segment predstavlja linearnu memoriju. Segmenti predstavljaju funkcionalne delove programa kao to su: kod programa, stek, heap, ali segment mo da sadr i samo jednu proceduru ili niz ili neto drugo. Veli ina e i svakog segmenta mo se menjati za vreme izvravanja od nule do nekog maksimuma. Razli iti segmenti e mogu biti razli itih veli ina. Poto svaki segment ima svoj adresni prostor (linearan), razli iti segmenti nemaju uticaja jedan na drugi. Sa uvoenjem segmentacije adresiranje zahteva dve adrese: jednu segmentnu adresu koja identifikuje segment i jednu ofset adresu koja daje adresu unutar tog segmenta. Zna i adrese su oblika (segment, ofset). Neke pogodnosti segmentacije:

74

Ako koristimo segmentaciju, i procedure stavimo u posebne segmente, ne moramo kao kod linearnog pristupa svaki put kad izmenimo neku proceduru prevoditi ceo program. Poto je svaki segment nezavisan i ima svoj linearni adresni prostor, dovoljno je prevesti samo onu proceduru koju smo izmenili. Poto segmenti uglavnom sadr samo jedan tip struktura: npr. samo stek, samo kod procedure, e samo neki niz, razni segmenti mogu imati razne tipove zatite. Npr. segment procedure mo se samo e izvravati, u stek smemo i pisati i itati, elemente niza mo emo samo itati (konstantni niz) itd. Kako svaki segment ima sopstveni adresni prostor, otvara se mogu nost kori enja deljenih, zajedni kih biblioteka (shared library). Biblioteke koje koriste skoro svi programi (npr. za grafi ko okru enje) ne emo ugraditi u svaki program posebno, ve emo napraviti poseban segment koji e svi programi deliti. Tako nema potrebe da te biblioteke u itamo u adresni prostor svakog procesa, ve je dovoljna jedna kopija u memoriji svi e to koristiti. Da bi OS mogao preuzeti brigu o segmentima, potrebno je da ima slede e informacije: po etna adresa segmenta, veli ina (du ina) segmenta, tip segmenta, bezbednosni podaci. Ove informacije se uvaju u tabeli segmenata. Uporeivanje strani enja i segmentacije: STRANI ENJE da li je programer svestan kori enja date tehnike ? broj linearnih adresnih prostora da li adresni prostori mogu biti ve i od fizi ke memorije ? da li mo emo procedure (kod) i podatke fizi ki odvojiti i posebno zatititi ? da li postoji mogu nost deljenja procedura meu razli itim procesima mo emo li lako radtiti sa strukturama promenljivih veli ina NE JEDAN DA SEGMENTACIJA DA VI E DA

NE

DA

NE

DA

NE

DA da bismo omogu ili razbijanje programa na logi ke celine ( procedure, podaci ) koje imaju svoje adresne prostore, da bismo omogu ili deljenje i zatitu

zato je tehnika izmiljena ?

da bismo dobili dovoljno veliki linearni adresni prostor ak i ako nemamo dovoljno interne memorije

Postoje sistemi koji kombinovano koriste strani enje i segmentaciju. Kod takvih sistema koristimo tro-dimenzionalno adresiranje: (adresa segmenta, adresa stranice, ofset adresa) segmente delimo na stranice.

75

FAJL SISTEM

Svakom programu je potrebna mogu nost da sa uva neke informacije neke podatke procesi mogu uvati unutar svog adresnog prostora (promenljive, konstante). Za neke procese to je dovoljno, za neke je potrebno neko drugo reenje. Nedostaci uvanja podataka u internoj memoriji: - mali kapacitet - kada proces zavri sa radom, podaci se gube - ra unar se blokira ili nestane struja podaci se gube - esto je potrebno da istim podacima istovremeno pristupi vie procesa Zbog ovih nedostataka, postoji potreba da se neki podaci uvaju odvojeno od adresnog prostora u eksternoj memoriji u obliku fajlova. Kriterijumi za dugoro no uvanje podataka: - ve i kapacitet - podaci moraju biti sa uvani i nakon to proces zavri sa radom, i nakon to se ra unar isklju i - mogu nost istovremenog pristupa vie procesa Deo operativnog sistema koji je zadu za rad sa fajlovima zove se fajl sistem (file system). en Vodi ra una o strukturi, na inu imenovanja, na inu kori enja, o zatiti i o implementaciji itavog fajl sistema. esto se pod pojmom fajl sistem podrazumeva struktura direktorijuma i fajlova.

Fajl sistem sa korisni ke ta ke gledi ta

Fajlovi (files)
Fajlovi predstavljaju apstrakciju: pru mogu nost da se podaci uvaju na disku i da se pro itaju aju sa diska a da pri tome korisnik ne treba da zna detalje implementacije: kako su i gde su podaci sa uvani ili kako zapravo diskovi rade. Upravo OS ima zadatak da obavi tu apstrakciju, odnosno da sakrije detalje realizacije i da pru interfejs na viem nivou. i

Imenovanje (file naming)

Pravila imenovanja fajlova razlikuje se od sistema do sistema. Uglavnom svi sistemi koriste niz znakova za imenovanje fajlova. Neki sistemi dozvoljavaju i kori enje specijalnih znakova i brojeva. Neki prave razliku izmeu malih i velikih slova (UNIX) a neki ne (DOS).

76

Pod DOS-om imena fajlova se sastoje od dva dela: ime fajla (8 karaktera) i tipa (ekstenzije, do 3 karaktera) fajla koji su razdvojeni ta kom: readme.txt. Mo emo koristiti mala i velika slova, brojeve i neke specijalne znakove. Ne pravi se razlika izmeu malih i velikih slova. UNIX dozvoljava imena du do 255 karaktera. Ime mo biti sastavljeno od proizvoljnog ine e broja delova odvojenih ta kom. Pravi se razlika izmeu velikih i malih slova. Mo emo koristiti i brojeve i neke specijalne znakove.

Struktura fajlova (file structure)

Najpoznatije strukture su: 1. Fajl je niz bajtova. OS ne vodi ra una o tome ta se nalazi u fajlovima, sve to vidi su bajtovi. Korisni ki programi su oni koji treba da dodeljuju zna enje fajlovima (tj. da znaju kako treba gledati na taj niz bajtova). Ovu realizaciju koriste DOS, UNIX, Windows. 2. Fajl je niz slogova iste veli ine. Ova realizacija je naputena. 3. Fajl u obliku B-stabla. Koristi se za brzo pretra ivanje fajla po zadatom klju u.

Tipovi fajlova (file types)

Mnogi operativni sistemi razlikuju vie tipova fajlova: regularni fajlovi: obi ni, korisnikovi fajlovi (obi ni nizovi bajtova): mogu biti ASCII ili binarni fajlovi (ovu razliku pravimo mi a ne OS). ASCII fajlovi sadr tekst, a e binarni fajlovi bilo ta drugo. direktorijumi: sistemski fajlovi koji sadr informacije o strukturi fajl sistema e ure ajni fajlovi: pod Unixom ureajima pridru ujemo fajlove (ako elimo tampati, piemo u odgovaraju i fajl). specijalni fajlovi: zavise od OS-a. Npr. pod DOS-om imamo specijalan fajl koji sadr i ime diska

Na in pristupa fajlovima (file access)

sekvencijalni pristup: bajtovima (podacima) u fajlu mo emo pristupiti samo redom, tj. da bismo pro itali n-ti bajt, moramo iz itati prethodnih n-1 bajtova. Koristi se na primer kod trake. direktan pristup: mo emo sko iti na bilo koji bajt unutar fajla i iz itati (ili upisati) taj bajt pomeramo glavu za itanje na odgovaraju e mesto i uradimo ono to elimo.

Atributi fajlova (file attributes)

Svaki fajl ima svoje ime i sadr Pored ovih informacija svi operativni sistemi uvaju jo neke aj. dodatne podatke o fajlovima, kao to su vreme nastanka fajla, veli ina fajla itd. Te dodatne podatke zovemo atributima fajla. Neki mogu i atributi: kreator vlasnik read-only (samo za itanje) system (sistemski fajl deo OS-a) hidden (sakriven fajl)

77

vreme poslednje modifikacije vreme poslednjeg pristupa vreme kreiranja prava pristupa veli ina fajla maximalna dozvoljena veli ina, itd.

Operacije sa fajlovima (file operations)

Svaki OS ima svoj skup sistemskih poziva za rad sa fajlovima. Naj e e operacije su: CREATE ( ime ) DELETE ( ime ) OPEN ( ime ) CLOSE ( fd ) READ ( fd ) WRITE ( fd,ta ) - kreiranje novog, praznog fajla - brisanje fajla - otvaranje (pripremanje) fajla za rad, operacija vra a jedinstveni deskriptor fajla (file descriptor fd) - zatvaranje fajla koji je prethodno otvoren - ita jedan bajt ili vie bajtova iz prethodno otvorenog fajla od trenutne pozicije fajl-pokazivaca (file pointer) - pie jedan ili vie bajtova u prethodno otvoren fajl od trenutne pozicije pokaziva a. Ako je pokaziva na kraju fajla, podaci se dodaju na kraj. - isto kao WRITE, sa razlikom da se novi podaci dodaju na kraj fajla - pomera pokaziva fajla na zadatu poziciju - vra a atribute fajla - postavlja (menja) atribute fajla - menja ime fajla

APPEND ( fd,ta ) SEEK ( fd,pos ) GETATTRIBUTES ( ime ) SETATTRIBUTES ( ime,atr ) RENAME ( ime,novoime )

Direktorijumi (directories)
Direktorijumi su specijalni fajlovi koji sadr spisak fajlova unutar tog direktorijuma. Svakom e fajlu odgovara po jedan slog koji sadr ime fajla i jo neke dodatne informacije (atributi, gde se fajl i nalazi na disku itd.). Unutar istog direktorijuma ne mo emo imati dva (ili vie) fajla sa istom imenom. Na osnovu dozvoljenog broja direktorijuma mo emo razlikovati slede e fajl sisteme: 1. Podr avaju samo jedan direktorijum: imamo samo jedan direktorijum, sve programe i sve fajlove stavljamo u taj direktorijum neprakti no reenje iz vie razloga: teko emo odvojiti fajlove razli itih programa, ako imamo mnogo korisnika javljaju se teko e oko imenovanja fajlova. 2. Podr avaju direktorijume do dubine 2: imamo glavni direktorijum (korenski direktorijum - root directory) i nekoliko poddirektorujuma. Npr. svaki korisnik bi mogao imati sopstveni direktorijum. Time smo izbegli problem konflikta imena fajlova razli itih korisnika, ali nismo reili problem onih korisnika koji grupisati svoje fajlove u logi ke celine. ele 3. Podr avaju hijerarhijsku strukturu direktorijuma u obliku stabla: svaki direktorijum pored fajlova mo sadr i vie poddirektorijuma. e ati

78

Ako koristimo hijerarhisjku strukturu, u razli itim direktorijumima mo emo imati istoimene fajlove. Zato je potrebno na i neku tehniku za jedinstvenu identifikaciju fajlova. Ako elimo pristupiti nekoj datoteci, mora emo zadati i putanju (path) do te datoteke. Imamo dve mogu nosti: 1. Apsolutna putanja (absolute path): kre emo od korenskog direktorijuma i redom navodimo imena svih direktorijuma na putu do naeg fajla. 2. Relativna putanja (relative path): kre emo od tekueg direktorijuma (current directory) i navodimo put do direktorijuma u kojem se nalazi tra fajl. Mnogi sistemi dodaju svakom eni folderu (direktorijumu) dva specijalna fajla: . (ta ka reprezentuje teku i folder) i .. (dve ta ke predstavlja nadreeni (roditelj) direktorijum). Primer: apsolutna putanja: Programi\Posao\kalk.exe relativna putanja: ..\Posao\kalk.exe (ako je teku i direktorijum npr. Programi\Zabava)

Operacije sa direktorijumima
Sli no kao i kod fajlova, svaki OS ima svoj skup sistemskih poziva za rad sa folderima. Neke mogu e operacije: CREATE DELETE OPENDIR CLOSEDIR READDIR RENAME LINK - kreiranje novog (praznog) direktorijuma - brisanje praznog dirktorijuma - otvaranje fajla-direktorijuma za itanje - zatvaranje fajla-direktorijuma - itanje sadr fajla-direktorijuma aja - reimenovanje direktorijuma - pod UNIXOM: ako elimo da jedan te isti fajl bude u vie direktorijuma, nema potrebe da ceo fajl prekopiramo u svaki direktorijum, umesto toga u jedan emo staviti sam fajl a u ostale samo pokaziva na taj fajl. Taj pokaziva se zove link (veza). Kada pristupamo linku, pristupi emo fajlu na koji link pokazuje. - brie link na fajl

UNLINK

79

Realizacija fajl sistema

Imamo dva pristupa uvanju fajlova na disku : - fajl od n bajtova se uva kao kontinualan niz bajtova nedostatak: ako se veli ina fajla pove ava, najverovatnije emo morati ceo fajl premestiti na neko drugo mesto. Ova strategija je naputena. - fajlovi se razbijaju u blokove fiksne veli ine, koji ne moraju biti kontinualno smeteni na disk Posmatrajmo realizaciju sa blokovima: fajlovi se uvaju u blokovima fiksne veli ine. Npr. jedan blok je veli ine 4KB, veli ina fajla je 9KB. Tada emo zauzeti 3 bloka za taj fajl, odnosno 12KB. U poslednjem bloku uvamo samo 1KB korisne informacije, a ostalih 3KB je izgubljeno jer je ceo blok zauzet od strane naeg fajla. Prednost velikih blokova je brzina a nedostatak je loa iskori enost prostora diska. Prednost malih blokova je bolje iskori avanje prostora a nedostatak je sporost poto koristimo veliki broj malih blokova, da bismo u itali fajl moramo vie puta pozicionirati glavu diska. Standardne veli ine blokova su od 512B do 8KB. Ako je adresiranje blokova 16-bitna, mo emo razlikovati 2^16 = 65536 razli itih blokova. To zna i da emo videti od 32MB (sa blokovima od 512B) do 512MB.

Neiskori eni blokovi

Neka su blokovi veli ine 1KB i neka je adresiranje 16-bitna. Imamo dva standardna na ina za evidenciju slobodnih blokova: 1. Pomou POVEZANE LISTE: dva pristupa: na po etku svakog bloka uvamo adresu slede eg praznog bloka. Treba samo zapamtiti adresu prvog bloka, jer emo tamo na i adresu drugog itd. Prednost: ne gubimo dodatan prostor za evidenciju slobodnih blokova (blokovi su ionako prazni, pa nita ne gubimo ako stavimo pokaziva na slede i blok). Nedostatak: sporost obilazak liste zahteva neprestano pozicioniranje diska.

80

povezanu listu uvamo u posebnim (praznim) blokovima. Umesto toga da u svakom praznom bloku uvamo adresu slede eg, listu praznih blokova smestimo u posebne blokove.Svaki blok sadr niz adresa praznih blokova, a na kraju svakog bloka imamo i adresu slede eg bloka sa adresama praznih blokova. Prednost: ve a brzina obilaska. Neka su blokovi veli ine 1KB, neka imamo 16-bitno adresiranje i disk od 20MB. Tada imamo ukupno 20*1024=20480 blokova. Unutar jednog bloka mo emo uvati 511 adresa praznih blokova (+ adresa slede eg bloka = 512 adresa, 16-bitne (dvobajtne) adrese, pa 512*2=1024), pa nam treba 40 blokova za administraciju. Broj blokova kori enih za evidenciju se menja sa menjanjem popunjenosti diska.

2. Pomou BITNE MAPE: svakom bloku diska dodeljujemo po jedan bit. Ako je blok zauzet, stavimo 0, ako je prazan stavimo 1 (ili obrnuto). Ako je kapacitet diska n blokova, treba nam n bitova za bitnu mapu diska. Bitnu mapu uvamo u ta no odreenim blokovima diska. Ako je k-ti blok zauzet, onda je vrednost k-tog bita bitne mape 0, a ako je prazan, onda je 1. Ako je veli ina blokova 1KB a kapacitet diska 20MB, veli ina bitne mape je 20*1024=20480 bitova, odnosno 2560bajtova=2.5KB, tj zauzima 3 bloka diska. Ako imamo dovoljno memorije da u itamo celu bit-mapu, pretra ivanje je br od pretra e ivanja povezane liste. Ako nemamo dovoljno memorije (npr. mo emo u itati samo jedan blok) tada je bolje reenje povezana lista: jedan blok sadr adresu 511 slobodnog bloka. i

81

Implementacija fajlova (zauzeti blokovi)

1. Kontinualni blokovi
Najednostavniji na in je da za svaki fajl zauzmemo onoliko kontinualnih blokova koliko treba. Prednost je laka implementacija: da bismo locirali neki fajl, treba samo zapamtiti prvi blok i veli inu fajla. Druga prednost je brzina pristupa podacima (i sekvencijalno i direktno). Nedostatak je to u ve ini slu ajeva ne znamo unapred maksimalnu veli inu naih fajlova. Ako fajl izraste iz predvienog broja blokova, moramo pretra disk da bismo nali potreban broj kontinualno rasporeenih slobodnih iti blokova. Ako naemo, treba prebaciti ceo fajl na novo mesto, ako ne naemo, mo emo pokuati sa grupisanjem slobodnih blokova na jedno mesto (premetanjem zauzetih blokova). Vrlo neefekasna realizacija. Javlja se problem eksterne fragmentacije.

2. Povezana lista
Blokove zauzetih od strane nekog fajla stavimo u povezanu listu. Treba samo zapamtiti adresu prvog bloka. U svakom bloku uvamo adresu slede eg bloka, kao kod evidencije slobodnih blokova pomo u povezane liste na osnovu prvog na ina. Prednosti: ako fajl raste, samo zauzmemo bilo koji neiskori en blok i a uriramo povezanu listu ne javlja se problem eksterne fragmentacije. Nedostaci: - ne podr direktan pristup fajlu ako nam treba neka informacija koja se nalazi u ava zadnjem bloku, da bismo doli do zadnjeg bloka moramo pro i kroz celu listu (moramo posetiti svaki blok da bismo dobili adresu slede eg bloka). - veli ina korisne informacije u blokovima vie nije stepen od 2 (zato to nam treba mesto za adresu slede eg bloka)

3. FAT (File Allocation Table)

FAT je tabela koja ima onoliko elemenata koliko imamo blokova na disku. Ako se u k-tom bloku nalazi neki fajl, tada k-ti elemenat FAT-a sadr adresu slede eg bloka koji taj fajl zauzima ili nulu koja i ozna ava da je to poslednji blok fajla. Kori enjem FAT-a izbegavamo nedostatke povezane liste: ceo blok mo emo iskoristiti za uvanje korisnih informacija (nije potrebno oduzeti deo za adresu slede eg bloka), i bolje je podr direktan pristup sadr fajla direktan pristup ni ovde nije u potpunosti an aju podr jer ako trebamo pristup 10-tom bloku fajla, moramo pomo u FAT-a na i adresu tog bloka, ali je an pretra ivanje mnogo br informacije su na jednom mestu, ne treba obilaziti svaki blok da bismo doli e: do adrese slede eg bloka. FAT se koristi npr. kod operativnih sistema DOS,Win9x. Primer: neka PERA.TXT zauzima blokove 7,2,4,1 a DJURA.DOC blokove 8,5. Tada dobijamo slede u tabelu alokacije:

82

4. i- vorovi (i-nodes)
Svakom fajlu dodeljujemo jednu malu tabelu koja se zove i- vor (i-node) ili index- vor (indexnode) i koja sadr atribute fajla i adrese zauzetih blokova: i

83

Zna i: i- vor sadr atribute fajla i adrese prvih nekoliko blokova zauzetih od strane datoteke. Ako i su ti blokovi dovoljni, onda je i- vor spreman. Ako nisu, koristi se i polje SIB=Single Indirect Block koji pokazuje na blok koji sadr adrese dodatnih blokova. Neka su blokovi veli ine 1KB, neka se koristi i 32-bitno adresiranje, onda svaki blok mo da sadr 256 adresa. Tako pomo u SIB-a dolazimo do e i dodatnih 256 blokova. Ako ni to nije dovoljno, koristimo i polje DIB=Double Indirect Block koji pokazuje na blok koji sadr dodatne adrese SIB-ova. Ako ni to nije dovoljno, onda koristimo i polje i TIB=Tripple Indirect Block, koji pokazuje na blok sa dodatnim adresama DIB-ova. Tako dolazimo do slede e tablice:

84

 TA KORISTIMO samo i- vor i- vor + SIB i- vor + SIB + DIB i- vor + SIB + DIB + TIB

MAKSIMALAN BROJ BLOKOVA 10 10+256 10+256+256*256 10+256+256^2+256^3

Implementacija direktorijuma
1. CP/M
CP/M je viekorisni ki OS, ima samo jedan direktorijum. Svi fajlovi svih korisnika su tamo. Svakom fajlu se dodeljuje jedan ili ve i broj slogova sa slede im poljima: broj bajtova opis 1 8 3 1 2 1

kod ime korisnika fajla

ekstenzija redni broj adresa adresa adresa ( tip ) broj rezervisano zauzetih prvog drugog ....... bloka fajla opisa blokova bloka bloka 16.

Svaki korisnik ima svoj jedinstveni idenkifikacioni broj koji se uva u prvom bajtu zna i mo emo imati najvie do 256 korisnika. Zatim sledi ime i tip fajla. Posle toga redni broj opisa ako fajlu nije dovoljno 16 blokova, dobija jo jedan opis. Prvi opis ima redni broj 0, drugi 1 itd. Razlika izmeu ovih slogova je jedino u rednom broju i u listi zauzetih blokova. Karakteristika CP/M sistema je da ne zna ta nu veli inu fajlova (bajt-po-bajt), ve samo blokovsku veli inu.

2. MS-DOS
Podr hijerarhijsku realizaciju direktorijuma. Fajlovima se dodeljuju slogovi slede e strukture: ava broj bajtova opis 8 ime fajla 3 1 10 2 2 2 adresa prvog bloka 4 veli ina fajla u bajtovima

ekstenzija vreme datum atributi rezervisano (tip) fajla kreiranja kreiranja

Jednokorisni ki, zna ta nu veli inu fajlova (u bajtovima). Pogledamo u slogu adresu prvog bloka, a adrese ostalih tra u FAT-u. imo

3. UNIX
Najjednostavnije reenje: uvamo samo adresu i- vora i ime fajla. Atributi fajla se nalaze unutar i vora.

85

broj bajtova opis

2 adresa i- vora

14 ime fajla

Primer: kako OS nalazi putanju /usr/ast/mbox ? Objanjenje emo dati pomo u UNIXove realizacije: krenemo od korenskog direktorijuma (i- vor korenskog direktorijuma je na fiksiranom mestu bloku), otvorimo fajl direktorijuma sadr slogove oblika (adresa i- vora, ime fajla). Potra slog i imo sa imenom fajla usr i uzmemo adresu i- vora. Odemo do tog i- vora sadr atribute za usr i adrese i blokova gde je sadr tog fajla-direktorijuma. U tim blokovima tra aj imo slog sa imenom fajla ast i uzmemo adresu i- vora. Odemo do tog i- vora i u navedenim blokovima (sadr fajla-direktorijuma ast) aj tra slog sa imenom fajla mbox da bismo dobili adresu i- vora. imo

Linkovi
Link predstavlja sredstvo pomo u kojeg mo emo iz vie direktorijuma pristupiti istom fajlu (isti fajl mo emo videti ispod vie direktorijuma). Pod Unixom linkove delimo na tvrde i meke (simboli ke). Tvrdi link: pri kreiranju tvrdog linka, pravi se samo novi slog u direktorijumu sa imenom fajla za koji pravimo link i stavimo adresu i- vora originalne datoteke. Zna i, vie imena pokazuju na isti i- vor. Da bismo vodili ra una o broju linkova, i- vorovi u skupu atributa fajla treba da uvaju i taj podatak. Ako u nekom folderu izdamo komandu za brisanje fajla, OS najpre pogleda broj tvrdih linkova ako je 1, brie se slog iz direktorijuma i oslobaaju se blokovi zauzeti od strane fajla. Ako imamo vie linkova, brie se samo slog iz direktorijuma a broja linkova se smanji za jedan. Meki link (simboli ki link): pri kreiranju mekog linka, pravi se novi fajl tipa link (pravimo i vor za novi fajl, i eventualno zauzmemo jo jedan blok za sadr fajla a sadr je jedino putanja do aj aj fajla na koji link pokazuje, zatim ubacimo novi slog u direktorijum sa adresom novog link-fajla). Broja linkova originala se ne menja. Ako izdamo komandu za brisanje originalnog fajla, OS ne vodi ra una o simboli kim linkovima, brie fajl (ako nema vie tvrdih linkova). Ako sada pokuamo pristupiti originalu preko mekog linka, OS ne e na i putanju, pa e javiti da fajl ne postoji. Ako izbriemo simboli ki link, to nema nikakvog uticaja na original. Problem mekih linkova: sporost da bi OS doao do sadr original, mora najpre na i i- vor aja link-fajla, zatim blok sa sadr ajem link-fajla, pa da iz ita putanju, da potra original u hijerarhiji i direktorijuma i kona no, na kraju da otvori originalnu datoteku za rad. Mogli bismo malo poboljati performanse ako putanju stavimo direktno u i- vor linka. Prednost mekih linkova: meki link poto sadr putanju originala a ne adresu i- vora mo i e pokazati na bilo koji fajl bilo gde na mre ak i na Internetu. i, Mo emo imati jo neke probleme pri kori enju linkova: npr. imamo fajl PERA.TXT u direktorijumu /usr/pera i tvrdi link u folderu /usr/pera/doc. Kopiramo /usr/pera zajedno sa svim poddirektorijumima. Treba dodatna pa da ne pravimo dve kopije od PERA.TXT. nja

86

Pouzdanost i performanse fajl sistema

Pouzdanost fajl sistema

Lo i blokovi
Mediji za uvanje podataka mogu imati loe blokove fizi ki ote ene delove medije. Za izbegavanje loih blokova imamo dva reenja: Hardversko kontroler diska vodi ra una o loim blokovima, ako elimo pristupiti ote enom bloku (radi pisanja), kontroler e na zahtev preusmeriti ka drugom, neote enom (i nekori enom) bloku. Softversko korisnik ili OS pravi poseban fajl koji sadr sve loe blokove na disku. Na taj na in i ti blokovi su izba eni iz skupa slobodnih (neiskori enih) blokova.

Sigurnosne kopije (backup)

Pored eliminisanja loih blokova, radi pove anja pouzdanosti sistema, po eljno je u odreenim vremenskim intervalima napraviti sigurnosne kopije va fajlova. To mo uraditi i sam korisnik ili nih e OS. Neke tehnike: 1. Koristimo dva diska A i B. Oba diska delimo na dva dela: deo za podatke i deo za sigurnosne kopije. Kada doe vreme za backup, prekopiramo podatke diska A u deo diska B za sigurnosne kopije, a podatke diska B u deo za sigurnosne kopije diska A. Na taj na in, ako se pokvari bilo koji disk, na drugom disku imamo sve podatke. Nedostatak: troimo jako mnogo mesta za sigurnosne kopije i jako mnogo vremena za backup. 2. Ne emo prekopirati sve podatke, samo fajlove koji su izmenjeni od poslednjeg backup-a. MSDOS npr. ima podrku za ovaj na in arhiviranja: svaki fajl ima atribut bit sa imenom archive kada izvimo backup, ovaj bit se resetuje. Ako izmenimo sadr fajla, bit se setuje. aj

Konzistentnost (file system consistency)

Mnogi sistemi pro itaju sadr nekih blokova, rade sa njima u memoriji i piu ih natrag na disk aj kasnije. Ako padne sistem pre nego to uspemo vratiti promenjene blokove, mo do i do problema. Ako e je re o blokovima koji sadr i- vorove ili opise direktorijuma, greka mo biti vrlo ozbiljna. Da bismo e e izbegli takve situacije, potrebno je obezbediti neke pomo ne programe za ispravljanje nastalih greaka. Npr. scandisk pod DOS-om ili Windowsima. Imamo dve vrste provere konzistentnosti: 1. Konzistentnost blokova: pravimo tabelu za blokove. Za svaki blok stavimo po dva broja a: prvi pokazuje koliko puta se dati blok javlja u listi zauzetih blokova, a drugi u listi slobodnih blokova. Tada idemo redom po i- vorovima i gledamo koje blokove koriste fajlovi pri tome pove avamo prvi broja odgovaraju ih blokova. Zatim gledamo listu slobodnih blokova (ili bitnu mapu) i isto tako pove amo drugi broja . Na kraju dobijamo rezultat: - ako je vrednost jednog broja a 1 a drugog 0, onda je sve u redu blok je ili zauzet ili slobodan

87

ako je vrednost oba broja a 0, zna i da blok nije ni zauzet, ni slobodan greka!, nali smo blok koji je izgubljen: nije iskori en a ne mo biti ni u budu nosti jer nije ni e evidentiran kao slobodan. Reenje: proglasimo ga slobodnim ako je vrednost prvog broja a 0 a drugog ve i od 1 to zna i, da je blok evidentiran vie puta kao slobodan (mo biti samo u slu aju da koristimo povezanu listu, u e slu aju bitne mape to se ne mo desiti). Reenje: popravimo listu slobodnih blokova e izbacimo duplikate ako je vrednost prvog broja a ve i od 1 a vrednost drugog nula blok pripada vie od jednog fajla. Reenje: ako blok pripada n fajlu, zauzmemo jos n-1 blokova, prekopiramo sadr u te blokove i a aj uriramo i- vorove. Posle, za svaki slu aj javimo i korisniku ta smo uradili. ako je vrednost oba broja a ve i od 0 to zna i da je blok evidentiran i kao zauzet i kao slobodan. Reenje: izbacimo iz liste slobodnih blokova.

2. Konzistentnost fajlova: Idemo po folderima od korenskog direktorijuma i za svaki i- vor dodeljujemo po jedan broja . Svaki put kad naiemo na isti fajl, pove amo broja . Na kraju idemo redom po i- vorovima i uporeujemo tako dobijen broja sa broja em tvrdih linkova unutar i- vora. Rezultat mo biti: e - vrednost broja a odgovara broju tvrdih linkova nutar i- vora nema greaka - vrednost broja a je ve i od broja tvrdih linkova greka!! Ako izbriemo fajl, mo se e desiti da imamo link na neiskori en blok. Posle neko iskoristi taj blok i sad imamo link koji pokazuje na ko zna ta... Reenje: broja tvrdih linkova preuzima vrednost drugog broja a - broj tvrdih linkova je ve i od vrednosti broja a greka!! ak i ako svi korisnici izbriu sve tvrde linkove na fajl, blok ne e biti preba en u skup slobodnih blokova. Reenje: broja tvrdih linkova uzima vrednost drugog broja a.

Performanse fajl sistema

Pristup disku je mnogo sporiji od pristupa memoriji, pa su mnogi sistemi dizajnirani tako da se smanji broj pristupa disku. Za ostvarenje tog cilja, naj e e se koristi bafer ili ke (buffer, cache). Ke se sastoji od skupa blokova koji logi ki pripadaju disku, ali se, radi br pristupa, uvaju u memoriji. eg Ako se javlja zahtev za pristup nekom bloku, najpre proverimo da li je u keu, ako jeste, uzmemo podatke iz kea. Ako nije, u itamo sa diska u ke, i podatke itamo iz kea. Ako treba u itati neki blok sa diska u ke, potrebno je izabrati neki blok koji e biti izba en iz kea. Za izbor mo emo koristiti sve algoritme koje smo koristili kod strani enja (paging). Ako je blok, koji se izbacuje izmenjen, moramo njegov sadr vratiti na disk. aj Uzmimo na primer LRU algoritam. Pri izboru bloka za izbacivanje treba uzeti u obzir i slede e stvari: 1. Da li e blok uskoro ponovo biti potreban ? Blokove delimo u grupe: i- vororovi, SIB,DIB,TIB, deo direktorijuma, popunjen blok, parcijalno popunjen blok. Parcijalno popunjene blokove stavimo na kraj liste jer emo verovatno jo upisivati podatke u njih, popunjeni blokovi idu na po etak liste da bi se to pre izbacili na disk.

88

2. Da li je blok od esencijalne vanosti za konzistentnost fajl sistema? (i- vorovi, direktorijumi) Ako je blok bitan za konzistenciju fajl sistema, treba ga to pre prebaciti na disk. Time emo smanjiti mogu nost greaka ako doe do pada sistema. U ovu grupu spadaju blokovi i vorova, SIB,DIB,TIB,direktorijumi. 3. Briga o korisnicima. Vodimo ra una o tome da o uvamo konzistentnost fajl sistema, pa guramo bitne blokove ka po etku liste da ih to pre prebacimo na disk. Korisnik pie izvetaj u text editoru. Napie 10 stranica, ak i ako periodi no ka editoru da prebaci dokument na disk, postoji dobra ansa e da ostane u keu dajemo prednost bitnijim blokovima. Ode struja na trenutak, nemamo UPS, odu tih 10 stranica sa strujom. Fajl sistem je konzistentan, a korisnik je besan, lupa po tastaturi i baca monitor preko prozora. Neka reenja: UNIX: imamo proces koji se zove sync. Njegov zadatak je da svakih 30 sekundi protr i kroz ke i prebaci sve izmenjene blokove na disk. Na taj na in, ako doe do pada sistema, gubimo samo rad posledjnih 30 sekundi. To je efikasno, ali nepouzdano reenje DOS: svaki izmenjen blok odmah se prebacuje na disk. Time se popravlja pouzdanost, ali se kvari efikasnost prakti no ubrzanje imamo samo kada itamo sadr bloka koji je u keu. aj Pored kea, i sami korisni ki programi mogu imati svoje interne bafere za skladitenje podataka to dodatno komplicira stvari. Keiranje nije jedini na in za poboljanje performanse fajl sistema. Druga tehnika je da blokove kojima emo verovatno pristupati istovremeno, stavimo to bli to mo e emo (da smanjimo vreme pozicioniranja).

Optimizacija diska

Prednosti diska u odnosu na internu memoriju: - mnogo ve i kapacitet - mnogo manja cena - podaci se ne gube nakon isklju ivanja ra unara Disk mo emo zamisliti koa niz magnetnih plo a, pri emu piemo na obe strane plo e. Ispod i iznad svake plo e nalazi se po jedna glava za itanje/pisanje. Glava diska mo da se kre e horizontalno, e a plo e se rotiraju. Povrinu plo a delimo na slede e delove:

89

Staza (track) deo povrine plo e koje se mo obi i rotiranjem plo e bez pomeranja glave e (koncentri ni krugovi). Cilindar (cylinder) sve staze iste veli ine na svim plo ama (uzimajuci u obzir obe strane) Sektor (sector) staze delimo u sektore sektori predstavljaju najmanju jedinicu za prenos podataka sa i na disk. Prilikom pristupa disku radi itanja/pisanja ekamo na: 1. vreme pozicioniranja glave na odgovaraju i cilindar (na odgovaraju u stazu seek time) horizontalno pomeranje glave 2. vreme koje je potrebno da rotiranjem tra sektor dovodi ispod glave (latency time) eni 3. vreme koje je potrebno za prenos podataka (transfer time) Ako imamo multiprogramirano okru enje, mo emo imati i vie procesa koji ekaju da bi dobili pristup podacima na disku. Ovi procesi se povezuju na neku listu ekanja i kontroler diska redom zadovoljava zahteve. Ako su zahtevani podaci jako rasuti po disku, gubimo mnogo vremena za pozicioniranje glave, zato se koriste algoritmi za izbor procesa. Ideja je da biramo proces koji pristup eli sektoru koji je najbli trenutnom polo glave. Pri tome moramo voditi ra una o slede im stvarima: e aju - to ve a propusnost (to ve i broj prenosa u jedinici vremena) - to manje prose no vreme ekanja - to manja varijansa (razlika izmeu prose ne i pojedina nih vremena ekanja)

Algoritmi za optimizaciju pomeranja glave

1. Prvi u redu (FCFS First Come First Served): zahtevi se zadovoljavanju po redu nastavnka. Nema nikakve optimizacije. 2. Najblii zahtev (SSTF Shortest Seek Time First): Zadovoljavamo onaj proces koji potra podatak koji se nalazi najbli trenutnoj poziciji glave. Nedostatak je to mo do i uje e e do pojave izgladnjivanja (starvation) radimo sa procesima koji tra neto u blizini, a neki e proces, koji itati sa udaljenog mesta eka nepredvidljivo dugo. eli 3. Skeniranje (SCAN): glava se neprestano pomera u odreenom pravcu (npr. prema sredini diska). Zadovoljavamo onaj zahtev koji je najbli glavi u datom pravcu. Kada glava stigne do i centra ili nema vie zahteva u tom pravcu, vra a se unazad. Nedostatak: sektori na sredini se obilaze u relativno pravilnim ali ve im intervalima, dok sektore na ivici plo e i u centru plo e posetimo dva puta unutar malog vremesnkog intervala (najpre u jednom pravcu, pa u drugom pravcu) a onda ekamo du vreme da se glava vrati. e 4. N-SCAN: radi isto kao SCAN, sa razlikom da uzima u obzir samo n onih zahteva koji su bili ve prisutni kada se glava po ela pomerati u datom pravcu. Zahtevi koji stignu u meuvremenu, mora e da ekaju. 5. Skeniranje u jednom pravcu (C-SCAN Circular Scan): radi sli no kao scan, sa razlikom da skenira samo u jednom pravcu: ide od ivice ka centru diska i zadovoljava zahteve, kada stigne do centra, prebaci se nazad na ivicu i ponovo ide ka centru. Time je obezbeeno da glava provodi istu kolu inu vremena i nad sredinjim i nad spoljanjim trakama.

90

ZAGLAVLJIVANJE (deadlock)

Resursi (resources)
Resurs je sve to je nekom procesu potrebno za izvravanje: procesor,memorija, fajlovi, tampa , skener itd. Resursi se dele u dve velike grupe: 1. Resursi koji mogu biti oduzeti od procesa a da to nema uticaja na sam proces (preemtive resource). Npr. procesor, memorija. 2. Resursi koji ne mogu biti oduzeti od procesa (nonpreemtive resource). Npr. tampa . Ako proces A preda zahtev za neki ovakav resurs koji je ve zauzet od strane procesa B, postaje blokiran (ode na spavanje) dok dati resurs ne postane ponovo slobodan.

Zaglavljivanje (deadlock)
Zaglavljivanje je situacija kada dva ili vie procesa ekaju na neki dogaaj koji se nikada ne e dogoditi. Npr. proces A eka da ga probudi proces B a proces B eka da ga probudi proces A tako lepo obojica spavaju ekaju i onog drugog za buenje. Drugi primer: procesi A i B neto da tampaju sa ele magnentne trake. Kre e proces A i zauzme tampa . Tada dolazi proces B i zauzme traku. Sada A pogleda na traku vidi da je zauzeta i blokira se. Proces B pogleda tampa , vidi da je zauzeto i blokira se. Proces A eka na dogaaj da se traka oslobodi i ne puta tampa a. Proces B eka na dogaaj da se tampa oslobodi i ne puta traku. Niko nita ne puta, svi ekaju. Vizuelno:

Zaglavljeni: proces P1 je zauzeo resurs R1, ali mu je za dalji rad potreban i R2, koji je zauzet od strane procesa P2, a za dalji rad tog procesa treba resurs R1.

91

Coffman (1971) je dokazao da postoje 4 neophodna uslova za mogu nost javjlanja zaglavljivanja: 1. Me usobno isklju ivanje (mutual exclusion). Procesi imaju eksluzivnu kontrolu nad resursima: proces P1 zauzme resurs R1 i niko drugi ne mo koristiti taj resurs, ak ni ako P1 e ne koristi (npr. zauzme tampa ali ne tampa). 2. Zauzimanje i ekanje (hold and wait). Procesi uvaju svoje resurse dok ekaju na druge resurse: proces P1 uva resurs R1 a eka na R2. 3. Resursi ne mogu biti silom oduzeti (nonpreemtive resourses). Resursi zauzeti od strane procesa ne mogu biti oduzeti od strane OS-a. Proces mora da zavri svoj rad da bi on sam oslobodio zauzete resurse: proces P1 je zauzeo R1 i ne mo emo ga oduzeti dok P1 ne zavri svoj rad i sam ne oslobodi resurs. 4. Cirkularna veza izme u procesa (circular wait). Proces P1 tra resurs R2 koji je zauzet od i strane procesa P2, a P2 tra R1 koji je zauzet od strane P1. i Vano je napomenuti da je istovremeno prisustvo sva etri uslova neophodno za pojavu zaglavljivanja. Ako neki uslov nije ispunjen, zaglavljivanje nije mogue. Mogu e strategije borbe protiv zaglavljivanja : 0. Ne radimo ni ta (najjednostavnije reenje: procesi su blokirani? Resetujemo ra unar.) 1. Prevencija OS dizajniramo tako da ne mo do i do zaglavljivanja e 2. Izbegavanje OS je takav da postoji mogu nost zaglavljivanja, ali implementiramo neke algoritme za izbegavanje 3. Detekcija OS ne zna ni za prevenciju ni za izbegavanje, ali ume da otkrije zaglavljivanje i da o tome obavesti korisnika 4. Oporavak znamo da su neki procesi zaglavljeni i pokuamo reiti problem

Prevencija (prevention)
Prevencija predstavlja najbolje reenje i podrazumeva da pravimo OS tako da nikada ne mo e do i do zaglavljivanja. To emo posti i ako onemogu imo bar 1 od navedena 4 uslova. Me usobno isklju ivanje: OS koji ne pru mogu nost meusobnog isklju ivanja ne e biti a popularan: Pera zauzme tampa i po ne da tampa cenovnik komponenata. Dolazi Milica i preuzme tampa za tampanje horoskopa. Rezultat: cenovnik sa horoskopom. Zna i prvi uslov ne emo dirati, ako procesu treba eksluzivna kontrola, dobija ekskluzivnu kontrolu. Zauzimanje i ekanje: Treba onemogu iti da proces zauzme neki resurs i da uva taj resurs dok eka na neke druge resurse. Jedno reenje je da zahtevamo da procesi predaju listu svih potrebnih resursa pre nego to po ne njihovo izvravanje. Ako neki resursi nisu dostupni, proces e ekati. Ako su svi resursi dostupni, izvravanje mo po eti. Imamo vie problema: neki procesi ne znaju unapred koje sve e resurse e koristiti, resursi ne e biti optimalno kori eni: proces traba da pro ita neke podatke sa diska, zatim tri sata neto izra unava i onda tampa rezultat. Kako zahtevamo da svi resursi budu zauzeti istovremeno, tampa e biti zauzet tri sata bez kori enja.

92

Resursi ne mogu biti silom oduzeti: Imamo dva reenja: Kod prvog reenja, ako proces javi zahtev za neki resurs, a resurs je nedostupan, OS oduzima sve resurse koje je proces do sada zauzeo i proces mo nastaviti sa radom tek kada su svi potrebni resursi na raspolaganju. Mo se do i do e e izgladnjivanja (starvation). Drugo reenje: ako proces javi zahtev za neki resurs i nema slobodnih primeraka tog resursa, OS pokua oduzeti od procesa koji su takav resurs ve zauzeli ali ekaju na druge resurse. Ako ni to ne poma proces ode na spavanje. I tu se mo do i do izgladnjivanja. e, e Cirkularna veza izme u procesa: svakom resursu dodelimo jedinstveni broj, a od procesa o ekujemo da potuju slede e pravilo: resurse mogu zahtevati po rastu em redosledu. Zna i ako je proces dobio resurs sa brojem 5, mo zahtevati samo resurse iznad 5. Tada sigurno ne emo imati cirkularnu e vezu meu procesima: proces A dr resurs Ri, proces B dr resurs Rj. Tada ako je i>j, A ne e mo i i i tra resurs Rj. Ako je i<j, onda B ne e mo i tra resurs Ri. Nedostaci: iti iti - teko e oko numerisanja resursa - ako sistemu dodamo nove resurse, moramo ponovo izvriti numerisanje

Izbegavanje (avoidance)
Pretpostavka je da OS nismo dizajnirali tako da zaglavljivanja budu nemogu a, ali emo potra iti neke algoritme i tehnike za izbegavanje. Da bismo izbegli zaglavljivanja, sistem mora biti u stanju da svaki put kada dobije zahtev za zauzimanje resursa, odlu i da li je zauzimanje bezbedno ili nije. Ako zauzimanje nije bezbedno (vodi do zaglavljivanja), zahtev se odbija.

Bankarov algoritam
Bankarov algoritam poti e od Dijsktre (1965) i radi na slede i na in: imamo banku i ve i broj korisnika. Korisnici tra zajam od banke radi realizovanja svojih projekata. Svaki korisnik mora javiti e bankaru, koja je maksimalna koli ina novca koji je njemu potreban. Banka ima kona ne resurse. Pozajmljeni novac mogu vratiti samo oni korisnici koji su uspeli da zavre svoje projekte, a da bi zavrili svoje projekte moraju dobiti prijavljenu maksimalnu koli inu novca. Ako bankar nije dovoljno pametan, mo se desiti da ostane bez novca a da ni jedan korisnik ne zavri sa radom korisnici su se zaglavili. e Pretpostavke za kori enje bankarovog algoritma: - imamo fiksni broj resursa: M - imamo fiksni broj procesa: N - svaki proces unapred javi maksimalnu koli inu potrebnih resursa - broj najavljenih (potrebnih) resursa od strane jednog procesa mora biti manji od M (bankar mora imati dovoljno novca) - operativni sistem garantuje da e svaki proces dobiti potrebne resurse unutar kona nog vremenskog intervala (niko ne e beskona no ekati ako bankar nema dovoljno novca, ka korisniku da malo sa eka i garantuje da e u kona nom vremenu dati e potrebnu koli inu novca) - proces ne sme da la broj trenutno zauzetih resursa mora biti manji ili jednak od e: najavljenog maksimalnog broja resursa (korisnik ne sme da krade novac iz banke) - proces garantuje, da e kada dobije sve potrebne resurse, u kona nom vremenu zavriti sa radom i vrati e sve zauzete resurse (korisnik mora garantovati bankaru da e vratiti sav pozajmljeni novac u kona nom vremenu nakon realizovanja projekta)

93

Trenutno stanje OS zovemo: SIGURNO STANJE ako OS mo omogu iti svakom procesu da zavri svoj rad u e kona nom vremenu (ako bankar mo garantovati da e svi korisnici dobiti potrebnu e koli inu novca u kona nom vremenu). NESIGURNO STANJE ako OS ne mo garantovati da e svaki proces dobiti e najavljen broj resursa.

Bankarov algoritam radi na sledei na in: ako neki proces javi da mu je potreban neki resurs, OS simulira budu nost: pogleda ta e se desiti ako zadovolji zahtev. Ako zadovoljavanje zahteva vodi do sigurnog stanja, proces dobija resurs. Ako zadovoljenje zahteva vodi do nesigurnog stanja, zahtev se odbija. Primer sigurnog stanja: Neka je broj resursa sistema 12. PROCES A B C BROJ ZAUZETIH RESURSA 1 4 5 MAKSIMALNO TRAENO 4 6 8

Tada na raspolaganju imamo jo 2 slobodna resursa. Stanje je sigurno: ako proces B dobija 2 preostala resursa, ima e sve potrebne resurse i zavri e svoj rad u kona nom vremenu. Tada emo imati 6 slobodnih resursa. Tada i proces A i proces C mogu dobiti potrebnih 3 resursa i mogu zavriti svoj rad. Prelazak iz sigurne u nesigurno stanje: pp. da C tra 1 resurs i OS daje taj resurs. Tada emo na i raspolaganju imati jo jedan slobodan resurs. Procesu A su potrebna 4, procesu B 2 a procesu C jo 2 resursa. OS ima 1. To je nesigurno stanje. Niko ne mo garantovati da e neki od procesa mo i vratiti e neke resurse (ili da e neki proces uspeti da zavri svoj rad i sa manjim brojem resursa). Nesigurno stanje ne vodi obavezno u zaglavljivanje, ali mogunost postoji. NESIGURNO STANJE ZNA I DA NE MO EMO GARANTOVATI DA NE E DO I DO ZAGLAVLJIVANJA. Zato e OS, kad vidi da zadovoljavanje zahteva vodi u nesigurno stanje, odbiti zahtev i proces C e morati da eka. Primer nesigurnog stanja: Neka je broj resursa sistema 12. PROCES A B C BROJ ZAUZETIH RESURSA 8 2 1 MAKSIMALNO TRAENO 10 5 3

Tada na raspolaganju imamo jo jedan slobodan resurs. Stanje je nesigurno: Nemamo dovoljno slobodnih resursa da bilo koji proces dobija maksimalnu koli inu. To ne zna i da emo obavezno do i do zaglavljivanja, samo nas informie o tome da je zaglavljivanje mogu e.

94

Nedostaci Bankarovog algoritma: fiksan broj resursa fiksan broj procesa u praksi nije lako ostvariti garanciju OSa da e svaki proces dobiti sve potrebne resurse u praksi nije lako ostvariti garanciju procesa da e ako dobije sve potrebne resurse zavriti rad u kona nom vremenu postoje situacije kada procesi ne mogu unapred znati maksimalan broj potrebnih resursa (npr. interaktivni sistemi razvoj dogaaja zavisi i od korisnika)

Detekcija (detection)
Pretpostavimo da OS nema mogu nost prevencije ni izbegavanja, ali elimo imati mogu nost detekcije ako doe do zaglavljivanja, barem da budemo svesni toga i javimo korisniku da neto ne valja. Jedno reenje je da OS vodi ra una o odnosima procesa i resursa pomo u usmerenog grafa. Ako je resurs R1 zauzet od strane procesa P1, strelica vodi od R1 do P1. Ako proces P1 eka na resurs R2, strelica vodi od P1 do R2. Do zaglavljivanja dolazimo ako se javljaju ciklusi u grafu. Zna i algoritam za detekciju pretra usmeren graf resursa i procesa. Ako nae ciklus, javi korisniku da su se odgovaraju i uje procesi zaglavili. Pitanje je koliko esto treba pokrenuti algoritam za datekciju? OS bi mogao nakon svake dodele, pri svakom zahtevu za resursom izvriti proveru. To bi obezbedio najraniju detekciju zaglavljivanja, ali bi jako usporavao rad sistema. Kao bolje reenje, mogli bismo algoritam za detekciju pokrenuti u odreenim vremenskim intervalima. Time emo manje ugroziti performanse sistema, malo emo kasniti sa detekcijom, ali poto nemamo druge mehanizme za borbu protiv zaglavljivanja, nije preterano bitno da emo par sekundi zakasniti.

Oporavak (recovery)
Kod ove strategije, malo smo unapredili OS: ume da detektuje zaglavljivanja a pored toga pokuava i da se oporavi od toga. Imamo vie na ina: Mogli bismo zaglavljene procese suspendirati. Time emo oduzeti sve resurse tih procesa, vie ne e takmi iti za resurse, ne e troiti procesorsko vreme, ali e i dalje ostati procesi. Obavestimo korisnika da smo ih iz tog i tog razloga suspendirali, pa neka korisnik izabere ta e sa njima. Drugi na in je da ih ubijemo. Mo emo ih sve odjednom ubiti ili jedan po jedan, pa videti ta e se desiti, ako su ostali jo uvek zaglavljeni ubijemo jo jedan itd. Ovaj algoritam mo se lako e implementirati i efikasno reava problem zaglavljivanja, ali ba i ne pru neki oporavak. a Prilikom izbora procesa koji e biti ubijen, trebalo bi uzeti u obzir slede e parametre: - broj zauzetih resursa mo imamo ve u ansu za pobedu ako ubijemo proces koji da dr ve i broj resursa i - broj tra enih resursa trebalo bi izbaciti proces koji eka na ve i broj resursa, jer mo emo pretpostaviti da e ponovo upasti u zaglavljivanje - koli ina obavljenog posla (potroeno vreme procesora, rad sa IO ureajima) bolje da ubijemo proces koji je tek po eo svoj rad a ne neki koji je ve pri kraju

95

prioritet procesa treba birati proces to manjeg prioriteta (va procesi imaju niji prednost za ivot) Trei na in je da poku amo privremeno oduzeti neke resurse od nekog procesa i damo ih drugom procesu. Zna i, oduzmemo resurs od procesa A, dajemo ga procesu B, kada se resurs oslobodi vratimo ga procesu A i o ekujemo da bez nekih ozbiljnih posledica A ume da nastavi svoj rad. Ovaj na in oporavka je esto vrlo teko implementirati ili ak nemogu e zavisi od prirode resursa. etvrti na in je da poku amo proces prebaciti u neko prethodno stanje. Ovde pretpostavljamo da sistem operator vodi dnevnik nevaljalih procesa. Zna i operator zna koji procesi su skloni zaglavljivanju, pa za te procese postavlja ta ke provere (checkpoint). Svaki put kada proces doe do te ta ke, sa uva se na disku. Ako doe do zaglavljivanja, pogledamo koji resursi su potrebni i vratimo proces u neko prethodno stanje a resurse dajemo drugom zaglavljenom procesu. Ako sada prvi proces ponovo tra te resurse, mora e da eka. Kod izbora procesa koji e biti vra en u neko prethodno stanje i mo emo uzeti u obzir parametre iz drugog na ina oporavka. -

Izgladnjivanje (starvation)
Izgladnjivanje je pojava sli na zaglavljivanju, ali nije tako opasna, jer do zaglavljivanja i ne dolazi. Ako imamo multiprogramirano okru enje, procesi se takmi e za resurse ( ekaju u redu). OS mora imati neku strategiju za izbor procesa koji e slede i dobiti odreeni resurs. Ako ta politika izbora nije dovoljno demokratska, mo se desiti da neki proces nikada ne doe do tra e enog resursa. Svaki put doe neki drugi proces koji na osnovu politike OS-a ima ve i prioritet i nosi resurs sa sobom. Na proces nije zaglavljen ve mirno eka u redu deset godina, jer ne mo nita protiv politike OS-a. e

96

SIGURNOST I ZA TITA

Sigurnost

Postoji potreba da operativni sistem onemogu i neautorizovani pristup podacima svakog korisnika. Sigurnost i zatita su usko vezani za fajl sistem (o operativnoj memoriji smo ranije pri ali). Dakle, potrebno je onemogu iti pristup nekim fajlovima. Sigurnost se odnosi na opti - filozofski pojam, dok zatitu predstavljaju usvojeni principi sigurnosti koji se realizuju na nekom operativnom sistemu. Kada sigurnost fajl sistema mo biti ugro e ena? via sila (udar groma, po zemljotres...) ar, hardverska i softverska greka ljudske greke

Jedan od na ina na koji se branimo od gubitka va podataka je pravljenje rezervnih kopija nih (backupa) koje se potom uvaju na sigurnom mestu. Pored ovih slu ajnih postoje i namerni napadi na sigurnost fajl sistema. Lica koja pristupiti ele zabranjenim fajlovima mogu biti: laici, koji nisu zlobni ali ako im se pru prilika da zavire u tuu potu to e i uraditi. i oni za koje zaobila enje mehanizama zatite predstavlja intelektualni izazov. oni koji da izvuku materijalnu korist iz toga (prevarom, ucenom,...) ele pijuni (vojni, privredni,...)

Nekoliko poznatih gre aka u ranijim operativnim sistemima

UNIX u fajlu /etc/passwords uva spisak svih korisnika sistema u obliku <korisni ko_ime kriptovana_lozinka identifikacoini_broj grupa ime prezime ...> Ovaj fajl je svima dostupan za itanje. Postoji komanda UNIX-a lpr koja se koristi za tampanje fajlova. Ova komanda izmeu ostalih ima i opciju brisanja fajla pa se njom mo obrisati i fajl e passwords. Brisanjem ovog fajla ni jedan korisnik se vie ne mo prijaviti na sistem. e Takoe u UNIX-u. Proces koji je pokrenuo neki program ima ista prava kao i njegov vlasnik. Postoji bit koji kontrolie prava i on se zove setuid. Ako je setuid setovan tada proces koji ga je pokrenuo ima sva prava. Korisnik (nasilnik) iz svog procesa pokrene proces koji ima setuid postavljen na

97

1 (na primer mkdir) i zatim ga nasilno prekine. Pod UNIX-om postoji standardni fajl core koji operativni sistem kreira i popunjava kada doe do greke pri izvravanju programa. Ako korisnik predhodno napravi u svom direktorijumu fajl core kao link na fajl /etc/passwords neki sadr e biti direktno upisan u aj njega. Ovo je mogu e zato to je u trenutku prekida proces imao postavljen setuid na 1 tj. imao je sve privilegije. Uz malo muke, ono to se upisuje mo li iti na sadr passwords pa se korisnik na taj na in e aj dopie. MULTICS je imao loe zati ene mehanizme za paketne obrade. Bilo je mogu e u itati podatke sa trake, odnosno kartice i snimiti ih bilo gde. Jedini uslov je bio da se to uradi paketno a ne interaktivno. Ljudi su tada pravili svoje editore koje su snimali u direktorijum odakle ukrasti fajl. Kada bi korisnik ele pokrenuo takav editor ne bi bio svestan da dok on kuca, program mu paketno krade podatke. Ovakvi programi, koji osim to rade ono emu su namenjeni rade i neto kriom se nazivaju trojanski konji. TENEX - Digital DEC10 je takoe imao neke mane: za svaki Page Fault se mogla zaka iti proizvoljna procedura pristup svakom fajlu se kontrolisao lozinkom i to interaktivno lozinka se proveravala slovo po slovo. im bi naiao na slovo koje ne odgovara, javio bi greku

Neka neki program da pristupi zati enom faju. On pokuava sa nekom lozinkom koja se eli napravi tako da prvo slovo le u jednoj stranici memorije a ostatak u drugoj. Memorija se popuni i (nebitnim stvarima) tako da se u njoj nae samo prva stranica. Ovo je potrebno da bi dolo do Page Faulta nakon to se obradi prvo slovo lozinke. Na Page Fault se zaka i procedura koja obavetava o svakom Page Fault-u. Tako, ako se pogodi prvo slovo procedura e odreagovati na Page Fault i obavestiti korisnika, a ako ne operativni sistem e javiti da je lozinka pogrena. Kada se pogodi prvo slovo onda se lozinka tako teluje da prva dva slova budu u jednoj stranici a ostatak u drugoj i postupak se ponavlja. Za lozinku od 6 od 30 mogu ih znakova grubom silom bi trebalo izvriti 30 6 provera, a na ovaj na in samo 30 6 = 180 . Operativni sistem OS/360 je omogu avao da se u toku ra unanja u pozadini neto ita. Lozinka se pri kopiranju proveravala u dva navrata i to prvi put se proveravalo smemo li uopte kopirati sa trake u zadati fajl a drugi put kada kopiranje zaista i po ne (ali tada se nije proveravalo i ime fajla). Ako se izmeu ove dve provere promeni ime fajla, bilo je mogu e kopirati preko nekog fajla bez obzira da li se imala njegova lozinka ili ne.

treba da radi osoba koja provaljuje ? ta

Treba da gleda deo diska sa izba enim stranicama iz memorije. Operativni sitem ih nekad ne obrie posle swap-ovanja pa se tu mogu kriti vredni podaci. Treba da poziva nepostoje e sistemske pozive ili postoje e ali sa pogrenim parametrima. Postoji mogu nost da e se operativni sistem zbuniti pa se iz takvih situacija mo neto korisno zaklju iti. e Pri procesu prijavljivanja nekako ga nasilno prekinuti. Tako se mo mo zaobi i da e proveravanje lozinke. Modifikacija strukture podataka koja se koristi za pozivanje servisa operativnog sistema mo zbuniti operativni sistem pa se opet mo neto korisno saznati. e e

98

Mo da napravi program koji simulira prijavljivanje. Pokrene takav program i napusti e ra unar. Slede i korisnik seda za ra unar i unosi svoju lozinku koju program negde zapamti pa zatim pozove pravi program za prijavljivanje. Raditi sve to uputstva ka da nije dozvoljeno, da je opasno ... u armirati sekretaricu ?

Principi za ostvarivanje sigurnosti

Dizajn zatite treba da bude javan. Treba dobro realizovati principe (pa se hvaliti). Podrazumevaju i na in pristupa svakom objektu - fajlu je bez pristupa tj niko ne sme da mu pristupi. U praksi nikad nije ba tako ali je neto logi no, na primer vlasnik ima sve privilegije a ostali nikakve. Uvek se tra teku a prava pristupa.. e Svaki proces treba da zapo ne rad sa to manje privilegija. Ako su potrebne ve e, onda se naknadno eksplicitno pove aju. Mehanizam zatite treba da bude jednostavan, uniforman, od po etka zamiljen. Mehanizam zatite treba da bude psiholiki prihvatljiv.

Provera identiteta
Ni jedan korisnik se ne bi smeo la predstaviti. Korisnik ne sme koristiti resurse ako nije no ovla en. Uobi ajeni na in provere identiteta je putem lozinke. Pri prijavljivanju na UNIX sistem potrebno je uneti login (korisni ko ime pod kojim smo poznati operativnom sistemu) i password (lozinka). UNIX tada proverava u fajlu etc/passwords da li postoji odgovaraju e ime i da li lozinka odgovara. Lozinka je jednostrano ifrirana to zna i da ne postoji na in da se nakon kriptovanja vrati u prvobitno stanje.

Kako izabrati lozinku i da li je ona dovoljna?

Teoretski je mogu e napraviti 957 lozinki du sedam karaktera to je i vie nego dovoljno. Ali ine korisnici prave kra e lozinke i ne koriste sve mogu e karaktere. Takoe, korisnici su skloni standardnim, predvidivim lozinkama. Tokom nekog istra ivanja pokuale su se provaliti lozinke koje ljudi koriste. Upotrebljavana su imena i prezimena korisnika, imena njihovih ena, dece, brojevi automobilskih tablica, datumi roenja i sli no. Kada su tako napravljene lozinke uporeene sa pravim vie od 85% je bilo pogoeno. Zato se uvode dodatne provere. Generatori slu ajnih brojeva. Lozinka se dodatno ifrira 12-bitnim brojem koji je jedinstven za svakog korisnika? Jednokratne lozinke. Korisnik ima knji sa lozinkama, pro ita koja mu treba, icu iskoristi je pa dobije drugu. Li na pitanja. Pri prvom prijavljivanju se korisniku postavljaju li na pitanja, pa se ponekad proverava identitet korisnika pomo u njih.

99

Korisniku se pri prvom prijavljivanju dodeli algoritam, na primer x 2 . Pri kasnijim prijavljivanjima od korisnika se zahteva ime, lozinka i da mu se neki broj. Korisnik tada unosi ime, lozinku i reenje. Pri odabiranju lozinke se mogu postavljati uslovi tako da lozinka na kraju mora ispasti nelogi na. Na primer, korisnik u lozinci mora da iskoristi est znakova od kojih jedan mora biti specijalan, jedan mora biti veliko slovo, jedan mora biti cifra,...

Ako je provera identiteta jako bitna onda se koristi i fizi ka provera (koja nije ba jako popularna od strane korisnika). Mo se proveravati zenica, krv, otisci prstiju,... e

Za tita

Fajl1[r] Fajl2[rw] Domen1

Fajl3[r] Fajl4[rw] Fajl5[rx]

Fajl6[r] Stampac[w] Ploter[w]

Domen2

Domen3

Svakom objektu se dodele tri slova koja ozna avaju prava pristupa. Na primer (objekat,rwx). Domen je skup parova (objekat,prava).Kada se proces po ne izvravati dodeli mu se domen i tada on mo da pristupa samo objektima iz tog domena i to kako su prioriteti zadani.Oni koji dele domene sa e vremena na vreme mogu menjati domen. Domeni se predstavljaju matricama. Na primer:

Dom 1 Dom 2 Dom 3

Fajl 1 R

Fajl 2 RW

Fajl 4

Fajl 4

Fajl 5

Stamp ac

Fajl 6

Plote r

D1

D2 Ente r

D3

RW

RX

W W R W

Poslednje tri kolone slu za prelazak iz jednog domena u drugi. e

100

Kako su ovakve matrice prili no retko popunjene, obi no se predstavljaju druga ije i to po vrstama ili kolonama pri emu se pamte samo korisni podaci. Ako se matrica pamti po kolonama onda se naziva Acces Control List (ACL), a ako se pamti po vrstama C-lista. Na primer, po kolonama. Domen je korisnik+grupa: Fajl0 - (Pera,*,rwx) Fajl1 - (Djoka,system,rwx) Fajl2 - (Pera,*,rw)(Mika,osoblje,r)(Aca,nastavnici,rx) Fajl3 - (Pera,*, )(*,studenti,rwx) Fajlu Fajl0 mo da pristupa Pera iz bilo koje grupe i da radi sve. e Fajlu Fajl1 mo da pristupa Djoka iz grupe system i da radi sve. e Fajlu Fajl2 mogu da pristupaju Pera iz bilo koje grupe (da ita i pie), Mika iz grupe osoblje (da ita) i Aca iz grupe nastavnici (da ita i izvrava). Fajlu Fajl3 Pera iz bilo koje grupe ne mo da pristupi ni na koji na in dok svi korisnici iz grupe studenti e mogu da rade sve. U UNIX-u su svakom fajlu pridru 9 bitova kojima se odreuju prioriteti. Prva tri se odnose na eni vlasnika, druga tri na grupu kojoj vlasnik pripada, a poslednja tri na sve ostale korisnike. r bit ozna ava pravo itanja, w bit ozna ava pravo pisanja, a x bit ozna ava pravo izvravanja fajla. Na primer, 111101100 zna i da: vlasnik mo da ita i pie u fajl i da ga izvrava fajl e grupa kojoj vlasnik pripada mo da ita i izvrava fajl e svi ostali mogu samo da itaju fajl. rw x v l a s n i k rw x g r u p a rw x o s t a l i

101