Operativni sistemi-Haris Ribić

UNIVERZITET U SARAJEVUELEKTROTEHNIČKI FAKULTET

Operativni sistemi

----------------------------------------------------------------------------------------------Sarajevo, 2014. godina

2 Operativni sistemi

Materijal pripremili Nazif Husović, Enisa Brka, Samir Ribić

Operativni sistemi 3

SadržajPredgovor............................................................................................................................................11 1 Uvod u operativne sisteme.............................................................................................................12

1.1 Šta je operativni sistem..............................................................................................12 1.2 Računarski sistem......................................................................................................13 1.3 Istorija operativnih sistema........................................................................................14 1.4 Vrste operativnih sistema..........................................................................................18 1.5 Podjela po broju korisnika i procesa..........................................................................18 1.6 Podjela po načinu obrade..........................................................................................18 1.7 Sistemi s grupnom obradom (batch sistemi)..............................................................18 1.8 Multiprogramirani batch sistemi...............................................................................20 1.9 Sistemi dijeljenog vremena (time sharing)................................................................20 1.10 Kombinovani sistemi...............................................................................................21 1.11 Podjela po funkcionalnim osobinama......................................................................21 1.12 Jezgro operativnog sistema......................................................................................23 1.13 Dizajn jezgra os-a....................................................................................................23 1.14 Monolitni sistemi.....................................................................................................23 1.15 Slojeviti sistemi.......................................................................................................24 1.16 Prstenasti sistem......................................................................................................24 1.17 Os s mikrojezgrom..................................................................................................25 1.18 Hibridno jezgro.......................................................................................................26 1.19 Os preko virtuelnih mašina......................................................................................26 1.20 Exokernel................................................................................................................27 1.21 Prekidi.....................................................................................................................27 1.22 Sistemski poziv.......................................................................................................29 1.23 API pozivi...............................................................................................................30 1.24 POSIX API..............................................................................................................32 1.25 DOS API.................................................................................................................32 1.26 WINDOWS API......................................................................................................33

2 Upravljanje procesima....................................................................................................................36 2.1 Procesi.......................................................................................................................36 2.2 Koncept procesa........................................................................................................36 2.3 Model procesa...........................................................................................................36 2.4 Pokretanje procesa.....................................................................................................38 2.5 Završetak procesa......................................................................................................39 2.6 Hijerarhija procesa....................................................................................................39 2.7 Stanja procesa............................................................................................................40 2.8 Prošireni dijagram stanja procesa..............................................................................41 2.9 Implementiranje procesa...........................................................................................42 2.10 Raspoređivanje procesa...........................................................................................42 2.11 Redovi raspoređivanja (engl. scheduling queues)....................................................42 2.12 Raspoređivači..........................................................................................................44 2.13 Promjena konteksta (engl. context switch)..............................................................44 2.14 Windows API funkcije za procese...........................................................................44 2.15 Unix funkcije za upravljanje procesima..................................................................45


2.16 Programske niti (engl. threads)................................................................................46 2.17 Model niti................................................................................................................46 2.18 Upotreba niti............................................................................................................48 2.19 Implementacija niti u korisničkom prostoru............................................................51 2.20 Implementacija niti u jezgru....................................................................................53 2.21 Hibridna implementacija.........................................................................................54 2.22 Raspoređivanje aktiviranja......................................................................................55 2.23 Pop-Up niti..............................................................................................................56 2.24 Pretvaranje jednonitnog u višenitni kod..................................................................56 2.25 Windows funkcije za rad s nitima u korisničkom prostoru......................................58 2.26 Windows funkcije za rad s nitima u jezgru..............................................................58 2.27 Posix niti.................................................................................................................58

3 Raspoređivanje procesora...............................................................................................................60 3.1 Uvod u raspoređivanje...............................................................................................60 3.2 Redovi čekanja procesa.............................................................................................60 3.3 Ponašanje procesa.....................................................................................................61 3.4 Kada rasporediti procese...........................................................................................61 3.5 Dispečer....................................................................................................................62 3.6 Kategorije algoritma za raspoređivanje.....................................................................64 3.7 Ciljevi algoritama za raspoređivanje.........................................................................65 3.8 Raspoređivanje na tri nivoa.......................................................................................67 3.9 Raspoređivanje u pozadinskim sistemima.................................................................69 3.10 FCFS.......................................................................................................................69 3.11 SJF (Shortest Job First)...........................................................................................70 3.12 SRTN.......................................................................................................................71 3.13 Raspoređivanje u interaktivnim sistemima..............................................................71 3.14 Round-Robin raspoređivanje...................................................................................71 3.15 Prioritetno raspoređivanje.......................................................................................72 3.16 Višestruki redovi čekanja.........................................................................................74 3.17 Raspoređivanje sa više nivoa sa povratnom spregom(engl. Multilevel Feedback Queue(MFQ)....................................................................................................................75 3.18 Garantirano raspoređivanje.....................................................................................75 3.19 Lutrijsko raspoređivanje..........................................................................................76 3.20 A“Fair-Share Scheduling”.......................................................................................77 3.21 Raspoređivanje u sistemima realnog vremena.........................................................77 3.22 Kategorije algoritama za raspoređivanje u realnom vremenu..................................79 3.23 Algoritam najraniji rok prvo....................................................................................79 3.24 Raspoređivanje monotonom stopom.......................................................................80 3.25 Dijeljenje resursa.....................................................................................................81 3.26 Prioritetna inverzija.................................................................................................81 3.27 Rješenja prioritetne inverzije...................................................................................82 3.28 Raspoređivanje u multimedijalnim sistemima.........................................................82 3.29 Raspoređivanje threadova.......................................................................................83 3.30 Uvod u raspoređivanje procesa kod UNIX-a...........................................................85 3.31 Raspoređivanje u više-procesorskim sistemima......................................................87 3.32 Klasifikacija višeprocesorskih sistema....................................................................87


3.33 Sinhronizacija i granularnost procesa......................................................................88 3.34 Dodjela procesa procesorima...................................................................................88 3.35 Raspoređivanje procesa na pojedinačnom procesoru u višeprocesorskim sistemioma.........................................................................................................................................89 3.36 Raspoređivanje niti u višeprocesorskim sistemma..................................................90 3.37 Podjela opterećenja..................................................................................................90 3.38 Družbeno raspoređivanje.........................................................................................90 3.39 Dodjela posvećenog procesora................................................................................91 3.40 Dinamičko raspoređivanje.......................................................................................92 3.41 Posix funkcije koje podešavaju algoritme raspoređivanja.......................................92 3.42 Windows funkcije koje podešavaju algoritme raspoređivanja.................................93 3.43 Zadaci:.....................................................................................................................93

4 Sinhronizacija procesa....................................................................................................................96 4.1 Dijeljenje i natjecanje................................................................................................96 4.2 Kritična sekcija..........................................................................................................97 4.3 Međusobno isključivanje sa zaposlenim čekanjem...................................................99 4.4 Zabrana prekida.........................................................................................................99 4.5 Dijeljena varijabla.....................................................................................................99 4.6 Peterson-oovo rješenje............................................................................................100 4.7 TSL Instrukcija........................................................................................................102 4.8 Blokiranje i deblokiranje procesa............................................................................103 4.9 Semafori..................................................................................................................103 4.10 Mutex-i..................................................................................................................106 4.11 Windows API za sinhroizaciju...............................................................................106 4.12 Posix API za sinhroizaciju.....................................................................................107 4.13 Monitori................................................................................................................107 4.14 Barijere..................................................................................................................109 4.15 Sinhronizacija procesa - Klasični problemi sinhronizacije....................................109 4.16 Problem proizvođač – potrošač..............................................................................110 4.17 Rješavanje problema Proizvođač-Potrošač koristeći semafore..............................111 4.18 Problem filozofa koji jedu.....................................................................................113 4.19 Problem čitača i pisača..........................................................................................115 4.20 Rješenje problema čitač - pisač.............................................................................115 4.21 BACI – Ben Ari Concurrent interpreter.................................................................117 4.22 Međuprocesna komunikacija.................................................................................127 4.23 Neimenovani UNIX pipe-i....................................................................................128 4.24 Windows API za komunikaciju cijevima i Mail slotovima....................................129 4.25 Prosljeđivanje poruka............................................................................................130 4.26 Projektna pitanja za sistem prosljeđivanja poruka.................................................130 4.27 Problem proizvođač – potrošač korsteći prosljeđivanje poruka.............................131 4.28 Windows API, prosljeđivanje poruka....................................................................132 4.29 Posix API za poruke..............................................................................................133 4.30 Signali...................................................................................................................133 4.31 Alarmi....................................................................................................................136

5 Upravljanje resursima i potpuni zastoji........................................................................................138 5.1 Poptuni zastoji (engl. Deadlocks)............................................................................138


5.2 Resursi.....................................................................................................................138 5.3 Oduzivi i neoduzivi resesursi..................................................................................139 5.4 Uslovi za pojavu potpnog zastoja............................................................................139 5.5 Modeliranje potpunog zastoj (graf dodjele resursa)................................................140 5.6 Grafovi modeliranja zastoja sa više resusra iste vrste..............................................142 5.7 Strategije rješavanja potpunog zastoja.....................................................................143 5.8 Nojev algoritam - ignorisanje problema..................................................................143 5.9 Detekcija i otklanjanje potpunog zastoja.................................................................143 5.10 Detekcija potpunog zastoja sa jednim resursom svakog tipa.................................144 5.11 Detekcija potpunog zastoja sa više resursa svakog tipa.........................................145 5.12 Oporavak od potpunog zastoja..............................................................................146 5.13 Oporavak pomoću oduzimanja..............................................................................146 5.14 Oporavak pomoću povratka na staro stanje (engl. rollback)..................................147 5.15 Oporavak ubijanjem procesa.................................................................................147 5.16 Izbjegavanje potpunog zastoja...............................................................................147 5.17 Trajektorije resursa................................................................................................147 5.18 Sigurna i nesigurna stanja......................................................................................148 5.19 Bankarski algoritam za jedan resurs......................................................................149 5.20 Bankarev algoritam za više resursa.......................................................................150 5.21 Sprečavanje potpunog zastoja...............................................................................151 5.22 Napadanje uslova uzajamnog isključivanja...........................................................151 5.23 Napadanje stanja prisvajanja i čekanja..................................................................151 5.24 Napadanje uslova neoduzivih resursa....................................................................151 5.25 Napadanje ciklusa čekanja....................................................................................151 5.26 Two-phase locking.................................................................................................152 5.27 Potpuni zastoji bez resursa....................................................................................152 5.28 Izgladnjivanje - umiranje procesa..........................................................................153 5.29 Windows API za potpune zastoje..........................................................................153 5.30 Zaključak...............................................................................................................153

6 Upravljanje memorijom................................................................................................................154 6.1 Osnove upravljanja memorijom..............................................................................154 6.2 Dodjeljivanje memorije procesima..........................................................................155 6.3 Razdvajanje fizičkog i logičkog adresnog prostora programa i vezivanje adresa....155 6.4 Monoprogramiranje bez izbacivanja ili upravljanja stranicama..............................156 6.5 Multiprogramiranje sa fiksnim particijam...............................................................157 6.6 Razlozi za uvođenje multiprogramiranja:................................................................157 6.7 Modeliranje multiprogramiranja..............................................................................159 6.8 Analiza kod multiprogramiranja..............................................................................159 6.9 Relokacija................................................................................................................160 6.10 Zaštita....................................................................................................................161 6.11 Upravljanje memorijom sa swappingom...............................................................161 6.12 Multiprogramiranje sa promenljivim particijama..................................................161 6.13 Windows API za upravljanje memorijom..............................................................163 6.14 Posix API za upravljanje memorijom....................................................................163 6.15 Strukture podataka za upravljanje memorijom......................................................163 6.16 Upravljanje memorijom sa bit mapama.................................................................164


6.17 Upravljanje memorijom sa povezanim listama (linked lists).................................164 6.18 Sistem drugova (Buddy system)............................................................................165 6.19 Algoritmi za izbor prazne particije........................................................................166 6.20 Odvojen instrukcijski prostor i prostor podataka...................................................168 6.21 Segmentacija (segmentation).................................................................................168 6.22 Dijeljene biblioteke...............................................................................................170 6.23 Windows API za dijeljene datoteke.......................................................................170 6.24 Posix API za dijeljene datoteke.............................................................................171

7 Virtuelna memorija.......................................................................................................................172 7.1 Straničenje (paging)................................................................................................172 7.2 Kako radi MMU?....................................................................................................174 7.3 Tabele stranica.........................................................................................................174 7.4 Informacije u tabeli stranica....................................................................................175 7.5 Spremnik za prevođenje TLB – Translation Lookaside Buffer................................175 7.6 Invertovana tabela stranica......................................................................................176 7.7 Hijerarhijsko straničenje..........................................................................................177 7.8 Izbor stranica za učitavanje (fetch-strategy)............................................................177 7.9 Algoritmi za izbor stranice za zamjenjivanje (page replacement algorithms)..........178 7.10 Optimalni algoritam (Optimal Page Replacement Algorithm)...............................178 7.11 NRU (Not Recently Used): okvir koji nije skoro korišten.....................................179 7.12 FIFO (First-In, First-Out algoritam): prvi učitani okvir.........................................180 7.13 Druga šansa (Second Chance): varijanta FIFO algoritma......................................181 7.14 Satni (Clock page) algoritam.................................................................................182 7.15 Least recently used (LRU) algoritam.....................................................................182 7.16 NFU (Not Frequently Used): najrjeđe korišten okvir............................................184 7.17 NFU sa starenjem..................................................................................................185 7.18 Algoritam sa radnim skupom (working set algoritam)..........................................185 7.19 WSClock algoritam zamjene stranica....................................................................187 7.20 Pregled algoritama za zamjenu stranica.................................................................188 7.21 Beladayeva anomalija............................................................................................189 7.22 Stack algoritam......................................................................................................189 7.23 Raspodjela okvira..................................................................................................190 7.24 Lokalne i globalne strategije straničenja...............................................................191 7.25 Efekat zasićenja.....................................................................................................192 7.26 Kontrola opterećenja.............................................................................................192 7.27 Veličina stranice....................................................................................................192 7.28 Dijeljene stranice...................................................................................................193 7.29 Memorijski mapirane datoteke..............................................................................193 7.30 Pozadinski program za brisanje stranica................................................................195 7.31 Postupak kod greške stranice.................................................................................195 7.32 Windows API za upravljanje stranicama i dijeljenom memorijom........................195 7.33 Posix API za upravljanje stranicama i dijeljenom memorijom..............................196 7.34 Poređenje straničenja i segmentacije.....................................................................196 7.35 Segmentacija sa straničenjem................................................................................196 7.36 i386 memorijska arhitektura..................................................................................197

8 Ulazno-izlazni sistem računara.....................................................................................................201


8.1 Klasificiranje uređaja..............................................................................................201 8.2 Hardverska struktura U/I sistema............................................................................203 8.3 Memorijski mapirani i izolirani U/I.........................................................................204 8.4 Interfejs između U/I kontrolera i uređaja konektovanog na njega...........................205 8.5 Programirani U/I.....................................................................................................205 8.6 U/I vođeni prekidima...............................................................................................206 8.7 DMA (Direct Memory Access)................................................................................208 8.8 Ciljevi i funkcije U/I softvera..................................................................................210 8.9 Struktura softvera U/I sistema.................................................................................210 8.10 Obrađivači interapta..............................................................................................211 8.11 Drajveri..................................................................................................................211 8.12 Funkcije dijela U/I softvera nezavisnog od uređaja...............................................217 8.13 Usluge koje obezbjeđuje ulazno-izlazni sistem.....................................................218 8.14 Raspoređivanje ulazno-izlaznih operacija.............................................................218 8.15 Baferovanje...........................................................................................................218 8.16 Keširanje...............................................................................................................219 8.17 U/I sistem u korisničkom prostoru........................................................................219 8.18 Windows API za pristup periferijskim uređajima..................................................220 8.19 Posix API za pristup periferijskim uređajima........................................................220 8.20 Drajver sata...........................................................................................................220 8.21 Upravljanje napajanjem.........................................................................................221

9 Uređaji razumljivi korisniku.........................................................................................................223 9.1 Ulazni softver: tastatura...........................................................................................223 9.2 Ulazni softver: miš..................................................................................................223 9.3 Ekranski hardver.....................................................................................................224 9.4 Znakovni terminali..................................................................................................226 9.5 Windows konzolne funkcije....................................................................................226 9.6 WINDOWS GDI.....................................................................................................227 9.7 Posix terminal api....................................................................................................229 9.8 Štampači..................................................................................................................229 9.9 Štampanje u Windows.............................................................................................232 9.10 Linux/Unix štampanje...........................................................................................233 9.11 Dodirni ekrani........................................................................................................234 9.12 Tekstualni korisnički interfejs................................................................................235 9.13 Skriptni jezici u DOS i Windows...........................................................................236 9.14 Unix Shell..............................................................................................................238 9.15 GUI.......................................................................................................................248 9.16 WINDOWS API GUI PROGRAM.......................................................................250 9.17 X Window sistem..................................................................................................253 9.18 Window manager, Display manager, Session manager i Desktop.........................256

10 Sekundarna memorija.................................................................................................................258 10.1 Magnetni diskovi...................................................................................................258 10.2 Organizacija diska.................................................................................................258 10.3 Pojednostavljen prikaz hard diska.........................................................................259 10.4 Parametri koji određuju performanse diska...........................................................261 10.5 Formatiranje diska i pravljenje particija................................................................262


10.6 Preplitanja i zakretanja u transformaciji logičkih sektora u fizičke.......................263 10.7 Proces podizanja sistema na PC računarima..........................................................264 10.8 Raspoređivanje zahtjeva za rad sa diskom.............................................................266 10.9 FCFS.....................................................................................................................266 10.10 SSTF....................................................................................................................267 10.11 SCAN..................................................................................................................267 10.12 C-SCAN..............................................................................................................268 10.13 LOOK i C-LOOK................................................................................................268 10.14 Raspoređivanje diska u multimedijalnim sistemima............................................269 10.15 Povećanje pouzdanosti........................................................................................270 10.16 RAID strukture....................................................................................................270 10.17 RAID nivo 0........................................................................................................272 10.18 RAID nivo 1........................................................................................................272 10.19 RAID nivo 2........................................................................................................272 10.20 RAID nivo 3........................................................................................................273 10.21 RAID nivo 4........................................................................................................273 10.22 RAID nivo 5........................................................................................................274 10.23 RAID nivo 6........................................................................................................274 10.24 Hibridni RAID 0+1 i 10......................................................................................274 10.25 SSD diskovi.........................................................................................................275 10.26 Upravljanje Swap prostorom...............................................................................276 10.27 Priključivanje diskova.........................................................................................276 10.28 Izmjenjivi mediji.................................................................................................277 10.29 Magnetni izmjenjivi mediji.................................................................................277 10.30 Optički mediji CD, CDROM, DVD....................................................................279 10.31 USB uređaji.........................................................................................................280 10.32 Windows i Posix API za disk kao fizički uređaj..................................................281

11 Datotečni sistemi........................................................................................................................282 11.1 Uvod......................................................................................................................282 11.2 Datoteke................................................................................................................283 11.3 Imenovanje datoteka..............................................................................................283 11.4 Struktura datoteke..................................................................................................284 11.5 Tipovi datoteka......................................................................................................285 11.6 Pristup datotekama................................................................................................286 11.7 Datotečni atributi...................................................................................................287 11.8 Datotečne operacije...............................................................................................289 11.9 Operacije nad datotekom -C funkcije....................................................................290 11.10 WINDOWS API DATOTEČNI SISTEM............................................................290 11.11 POSIX API DATOTEČNI SISTEM....................................................................291 11.12 Datotečni deskriptor............................................................................................292 11.13 Primjer pristupa datotekama s Unix sistemskim pozivima..................................293 11.14 Direktoriji............................................................................................................294 11.15 Jednostavan direktorij..........................................................................................294 11.16 Jedan direktorij po korisniku...............................................................................295 11.17 Hijerarhijski sistem direktorija............................................................................296 11.18 Imena staza datoteka............................................................................................296


11.19 Operacija nad direktorijima.................................................................................297 11.20 Implementacija datotečnog sistema.....................................................................298 11.21 Organizacija datotečnog sistema..........................................................................298 11.22 Implementacija datoteka......................................................................................301 11.23 Kontinualna alokacija datoteka............................................................................301 11.24 Alokacija datoteka ulančanim listama.................................................................302 11.25 Alokacija sa ulančanim listama koje koriste memoriju........................................303 11.26 Indeksni čvorovi (engl. I-Nodes).........................................................................304 11.27 Implementacija direktorija...................................................................................305 11.28 Djeljene datoteke.................................................................................................306 11.29 Direktoriji u Unix-u.............................................................................................309 11.30 Direktoriji u NTFS..............................................................................................314 11.31 Upravljanje diskovnim prostorom.......................................................................317 11.32 Veličina bloka......................................................................................................317 11.33 Vođenje evidencije o slobodnim blokovima........................................................320 11.34 Pouzdanost datotečnog sistema...........................................................................321 11.35 Spašavanje podataka (engl. Backups)..................................................................322 11.36 Tehnička pitanja...................................................................................................324 11.37 Konzistentnost datotečnog sistema......................................................................325 11.38 Performanse datotečnog sistema..........................................................................328 11.39 Keširanje..............................................................................................................328 11.40 Čitanje blokova unaprijed....................................................................................330 11.41 Smanjenje kretanja glave diska............................................................................330 11.42 Log-Structured File Systems...............................................................................331

12 Sigurnost računarskih sistema....................................................................................................334 12.1 Sigurnosna okolina................................................................................................334 12.2 Prijetnje.................................................................................................................334 12.3 Uljezi.....................................................................................................................335 12.4 Zlonamjerni programi............................................................................................336 12.5 Virus......................................................................................................................336 12.6 Crv.........................................................................................................................337 12.7 Trojanac.................................................................................................................337 12.8 Logička bomba......................................................................................................337 12.9 Spywere.................................................................................................................337 12.10 Slučajan gubitak podataka...................................................................................338 12.11 Uobičajeni sigurnosni napadi..............................................................................338 12.12 Principi projektovanja sigurnosti.........................................................................339 12.13 Autentifikacija korisnika.....................................................................................340 12.14 Lozinke................................................................................................................340 12.15 Fizička identifikacija...........................................................................................341 12.16 Protumjere...........................................................................................................342 12.17 Zaštitni mehanizmi..............................................................................................343 12.18 Zaštitni domeni....................................................................................................343 12.19 Liste kontrola pristupa.........................................................................................345 12.20 Capabilities..........................................................................................................348 12.21 Tajni kanali (engl. Covert Channels)...................................................................350


13 Arhitektura Microsot-ovih operativnih sistema..........................................................................353 14 Arhitektura Unix-Linux..............................................................................................................367 15 Mobilni operativni sistemi..........................................................................................................372

12 Predgovor

PredgovorOvo je skripta iz operativnih sistema.

Uvod u operativne sisteme 13

1 Uvod u operativne sisteme 1.1 Šta je operativni sistem

Operativni sistem je program koji služi kao interfejs između korisnika računara i računarskog hardvera.

Dvije osnovne uloge operativnog sistema su• Pružiti korisniku okruženje koje će mu omogućiti efikasno izvršenje programa• Stvoriti pogodno korisničko okruženje

Pogodno korisničko okruženje se postiže time što se operativni sistem može gledati kao proširena mašina. Arhitektura (set instrukcija, organizacije memorije, I/O, i bus strukturu) većine kompjutera na nivou mašinski jezik je primitivna i neugodna da se programira, pogotovo za ulaz i izlaz. Na primjer, da se flopi disk programira koristeći samo naredbe njegovog kontrolera mora se brinuti o pakovanju parametara, paljenju motora, rekalibraciji kontrolera, itd. Ne ulazeći u stvarne detalje, trebalo bi biti jasno da prosječan programer vjerojatno ne želi da se previše intimno uključi u programiranje diskova. Umjesto toga, ono što programer želi je jednostavna, apstrakcija na visokom nivou kojom će se baviti. U slučaju diskova, tipična apstrakcije bi da je disk sadrži kolekciju pod nazivom datoteke. Svaka datoteka može se otvoriti za čitanje ili pisanje, a zatim čitati ili pisati, i na kraju zatvoriti. Detalji kao što su da li ili ne snimanje koristi modificirane frekvencijske modulacije, i kakvo je trenutno stanje motora se ne bi trebalo da se pojavi u apstrakciji predstavljenoj korisniku. U tom smislu, funkcija operativnog sistema je predstaviti korisnika sa ekvivalent produženog mašine ili virtualni stroj koji je lakše programirati od osnovnog hardvera.

Okruženje za efikasno izvršenje programa se postiže time što operativni sistem ima funkciju upravljača resursima Moderni kompjuter sastoji se od procesora, memorije, tajmera, diskovi, miševa, mrežnih interfejsa, printera, kao i širokog spektar drugih uređaja. Zamislite što bi se dogodilo da tri programa koji rade na nekim računaru pokušaju da ispišu svoje izlaz istovremeno na istom štampaču. U prvih nekoliko redova ispisa može biti iz programa 1, u narednih nekoliko iz programa 2, onda su neki od programa 3, i tako dalje. Rezultat bi bio haos. Operativni sistem može izbjeći problem čuvajući sve izlaze predodređene za štampač na disku. Kada se završi jedan program, operativni sistem onda može kopirati svoj izlaz iz datoteke diska gdje je pohranjen na štampač, dok u isto vrijeme drugi program može nastaviti generiranje više izlaza, ne obraćajući pažnju na činjenicu da je izlaz nije stvarno na pisač. Kada računar (ili mreža) ima više korisnika, potreba za upravljanjem i zaštitom memorije, I /O uređaja, i drugih resursa je još veća, jer korisnici bi u suprotnom ometali jedni druge. Osim toga, korisnici često moraju da dijele ne samo hardver, ali podatke (datoteke, baze podataka, itd), kao i. Ukratko, ovaj pogled na operativni sistem smatra da je primarni zadatak da prati ko koristi koje resurse, da odobri zahtjeve resursa, mjeri korištenje, i posreduje izmeđusuprotstavljenih zahtjeva iz različitih programa i korisnika.

14 Uvod u operativne sisteme

1.2 Računarski sistemModeran kompjuterski sistem se sastoji od jednog ili više procesora, neke glavne

memorije, diskovi, pisači, tastaturu, prikaz, mrežnih sučelja, i drugi input / output uređaja. Sve u svemu, kompleksan sistem. Pisanje programa koji prate svih ovih komponenti i koristiti ih ispravno, a kamoli optimalno, je izuzetno težak posao. Iz tog razloga, kompjuteri su opremljeni sa slojem softvera pod nazivom operativnog sistema, čiji je posao da upravlja svim ovim uređajima i pružaju korisnicima programa sa jednostavnije sučelje za hardver.

Postavljanje operativnog sistema je prikazano na slici. Na dnu je hardver, koji, u mnogim slučajevima, sam se sastoji od dva ili više nivoa (ili slojeva). Najniži nivo sadrži fizičke uređaje, koji se sastoji od čipova, žica, napajanja, katodnih cijevi i sličnio.

Sljedeći dolazi nivo mikroarhitekture, u kojem fizički uređaji su grupisani zajedno da formiraju funkcionalne cjeline. Obično ovaj nivo sadrži neke registre interne za CPU (Central Processing Unit) i put podataka do aritmetičko logičke jedinice. U svakom ciklusu, jedan ili dva operanda se dohvate iz registara i kombinuju u aritmetičko logičkoj jedinici (na primjer, sabiranjem ili Boolean I). Rezultat je pohranjen u jednom ili više registara. Na nekim računarima, to kontroliše softver, nazvan mikroprogram. Na drugim računarima, to je pod kontrolom direktno hardvera kola.

Svrha mikroarhitekture je da se izvrši neki skup instrukcija. Neke od tih instrukcija se mogu obaviti u jednom ciklusu dohvatanja i prepoznavanja, a neke zahtijevaju više njih. Ove instrukcijee mogu koristiti registre ili druge hardverske objekte. Zajedno, hardver i instrukcije vidljive u asemblerskom jeziku formiraju ISA (Instruction Set Architecture) nivo. Ovaj nivo se često naziva mašinski jezik. No programiranje na ovom nivou je dosta kompleksno, jer je previše vezano za osobine hardvera.

Da bi se sakrila ta kompleksnost, postoje operativni sistemi. Sastoji se od sloja softver koji (djelomično) skriva hardvera i daje programeru zgodniji skup instrukcija za rad. Na primjer, čitati blok datoteka je konceptualno jednostavnije nego da se brinu o detaljima kretanja glave diska, čekanja da se smiri, i tako dalje.

Računarski sistem 15

Na vrhu operativnog sistema je ostatak sistemskog softvera. Ovdje se nalazi školjka, prozorski sistem, kompajleri, uređivači, i slični programi aplikacijski nezavisni.

Konačno, iznad sistemskog programa dolaze programi aplikacija. Ovi programi su kupljeni ili pisani od strane korisnika da riješe svoje posebne probleme, kao što su obrada teksta, proračunske tablice, inženjering proračuna, ili čuvanje informacija u bazi podataka.

Šta obuhvata operativni sistem u ovim slojevima, postoje tri stanovišta. Najuže stanovište operativnim sistemom smatra samo onaj dio koji se nalazi u

jezgru i obavlja spomenute funkcije. On je zaštićen od korisnika ometanja od strane hardvera (zanemarujući za trenutak neke starije ili jeftine mikroprocesore koji nemaju zaštitu hardver). Objašnjenje za ovo stanovište je da se školjka ili kompajler mogu mijenjati, ali raspoređivač procesora ne. No, ovo stanovište je previše akademsko. Stotine miliona korisnika koji uspješno koriste Windows i prepoznaju ga po njegovom korisničkom interfejsu, bi bili prilično iznenađeni da čuju da to zapravo nije operativni sistem, nego da je on sadržan u jednoj datoteci NTOSKRNL.EXE, koja sama ne može ništa uraditi.

Po tradicionalnom shvatanju, pored jezgra operativnog sistema, on sadrži i potreban minimum za rad, dakle kernel (jezgro) koje obavlja osnovne funkcije OS i uvijek se nalazi u memoriji, skup uslužnih sistemskih programa i školjku – komandni ili grafički korisnički interfejs (GUI) prema funkcijama OS.

Moderno shvatanje je nastalo pod komercijalnim uticajem. U operativni sistem ulazi ono što je njegov proizvođač sastavio u jedinstvenu cjelinu. To uključuje i odgovarajući skup aplikativnih programa bez kojih bi sistem također radio. Na primjer, uz Windows se isporučuju pregledač Internet Explorer, i uređivač teksta WordPad, i oni se za većinu korisnika smatraju njegovim dijelom. Poznat je slučaj suđenja protiv Microsoft-a iz 1998. godine kada je ova kompanija optužena za monopol na operativne sisteme zbog isporučivanja Internet Explorer-a (ranije samostalnog proizvoda) zajedno s operativnim sistemom, pa je u odbrani demonstrirano da bi njegovo isključivanje umanjilo performance i stabilnost sistema. No ovo stanovište je previše široko sa stanovišta proučavanja teorije operativnih sistema.

1.3 Istorija operativnih sistemaOperativni sistemi su se razvijali kroz godine. Operativni sistemi su istorijski bili

usko vezani za arhitekturu računala na kojima rade, ali se historija više puta ponavljala.

Prva generacija (1944-1955, releji, vakuumske cijevi i ploče s programom): Nakon neuspješnog napora Babbage da napravi mehanički digitalni računar je, ostvaren je mali napredak u izgradnji digitalnih kompjutera do Drugog svjetskog rata. Oko sredine-1940, Howard Aiken na Harvardu, John von Neumann na Institutu za Advanced Study u Princetonu, J. Presper Eckert i William Mauchley na University of Pennsylvania, i Konrad Zuse u Njemačkoj, između ostalog, sve uspjeli izgraditi


mašine za izračunavanje. Prvo su se koristili mehanički releji, ali su bili vrlo spori, s vremenom ciklusa mjerenim u sekundama. Releji su kasnije zamijenjen vakuumskim cijevima. Ove mašine su bile ogromne, zauzimale su cijelu sobu sa desetinama hiljada vakuumskih cijevi, ali su i dalje milione puta sporije nego što je najjeftiniji personalnih kompjutera danas dostupni. U tim ranim danima, a jedna grupa ljudi dizajnira, gradi, programira, upravlja i održava svaku mašinu. Svo programiranje je učinjeno u apsolutnom mašinskom jeziku, često ožičeno na pločama za kontrolu osnovnih funkcija uređaja. Programski jezici su nepoznati (čak i asemblerski jezik je nepoznat). Operativni sistemi nisu postojali. Uobičajena je operacija bila za programera da se prijavi blok vremena na tabli na zidu, a zatim doći do strojarnice, ubacitu svoje ploče u kompjuter, i provesti narednih nekoliko sati u nadi da će nijedna od 20.000 vakuumskih cijevi ispala u toku u bijegu. Gotovo svi problemi bili numeričke proračunie, kao što su pravljenje tablice sinuse, kosinuse i logaritmima. Do ranih 1950-ih godina, rutina je donekle popravila uvođenjem bušene kartice. Sada je moguće pisati programe na karticama i čitati ih umjesto ploča ali, postupak je bio isti,

Druga generacija (1955-1965) tranzistori, Batch Sistemi Uvođenje tranzistora u sredinom 1950-ih promijenilo je sliku radikalno. Računari su postali dovoljno pouzdani da bi mogli biti proizvedeni i prodavani uz očekivanje da će nastaviti raditi dovoljno dugo da se uradi neki koristan rad. Po prvi put, bilo je jasno razdvajanje između dizajnera, graditelja, operateri, programeri, i osoblja za održavanje.

Te mašine, sada zvane mainframe, bile su zaključane u posebno klimatizirane sobe, s osobljem profesionalnih operatera da ih vode. Samo velike korporacije ili velikih vladinih agencija ili univerziteta mogli priuštiti multimilionsku cijenu. Da bie pokrenuo posao (npr., program ili skup programa), programer bi prvo napisati program na papiru (u FORTRAN ili asembler), a zatim ukucati na karticama. On bi onda donio skup kartica do ulazne sobe i predao ga u jednom od operatera i čekao dok izlaz ne postane spreman. Kada računar završi posao koji trenutno radi, operator će otići do pisača i otkine izlaz i iznese ga. S obzirom na visoke troškove opreme, ne čudi da su ljudi brzo tražili načine za smanjenje izgubljenog vremena. Rješenje u to vrijeme su bili batch sistema. Ideja je bila da se prikupi skup pun radnih mjesta u ulaznim sobu i onda ih pročitati na magnetsku traku pomoću malog i relativno jeftinu računara, koja se zatim odnosi na veliki računar namijenjen obradi. Nakon otprilike sat vremena prikupljanja skupa poslova s radnih mjesta, traka se premota i dovede u sobu za mašinu, gdje se montiran na tape drive. Operator zatim učitati poseban program (predak današnjeg operativnog sistema), koji pozov na prvi posao sa trake i izvede. Izlaz je napisan na drugu traku, umjesto da se štampa. Nakon svakog posla, operativni sistem automatski pročitati sljedeći zadatak iz trake i pokrene ga. Kada je završena cijela grupa, operator je uklonio ulazne i izlazne traka, zamijenio ulaznu traku sa sljedećom grupom, i doveo izlaznu traku na računar za štampanje.

Treća generacija (1965-1980) IC i multiprogramiranje. Razvoj i održavanje dvije potpuno različita linije proizvoda (za unos podataka i obradu) je skupo za proizvođača. Osim toga, mnogi novi kupaci su u početku trebali malu mašinu, ali su

Istorija operativnih sistema 17

je kasnije prerali i poželjeli veću mašinu na kojoj će pokrenuti sve svoje stare programe, ali brže. IBM pokušao riješiti oba problema na jednim potezom uvođenjem System/360. To je prvi veliki računr koji koristite (male) integrirane krugovi (IC), na taj način pružajući veliku prednost u odnosu cijena/performanse u odnosu na mašine druge generacije, koje su izgradili od pojedinačnih tranzistora. To je bio neposredan uspjeh, a ideja porodice kompatibilnih kompjutera je uskoro usvojena od strane svih drugih velikih proizvođača. Potomci ovih mašina su još uvijek u upotrebi na računarskim centrima danas. Danas se često koriste za upravljanje ogromne baze podataka (npr., za avionske rezervacije sisteme) ili kao serveri za World Wide Web stranice koje se moraju obraditi hiljade zahtjeva u sekundi. Uprkos ogromne veličine i problema zbog toga, OS/360 i slični operativni sistemi proizvedeni od strane ostalih proizvođača kompjutera zapravo zadovoljavaju većinu svojih kupaca prilično dobro. Oni također populariziraju nekoliko ključnih tehnika kojih nema u drugoj generaciju operativnih sistema. Vjerojatno najvažnija je multiprogramiranje. Dok je jedan posao čekao I/O da završi, drugi posao može koristiti CPU. Ako ima dovoljno radnih mjesta, CPU može držati zauzeti gotovo 100 posto vremena. Imati više radnih mjesta sigurno u memoriju odjednom zahtijeva poseban hardver za zaštitu svakog posla nestašluka od one drugog, sistem je bio su opremljeni ovim hardverom. Nakon toga je nastala varijanta multiprogramiranja, dijeljeno vrijeme u kojem svaki korisnik ima priključen terminala. U ovakvom sistemu sistemu, ako od 20 korisnka koji su prijavljeni i 17 od njih razmišljaju ili govori ili pije kafu, CPU može biti dodijeljen u red za tri posla koje žele uslugu. Prvi manje-više uspješni operativni sistemi u dijeljenom vremenu su CTSS, MULTICS. Nakon pojave mini računara počevši od DEC PDP-1 sve do PDP-11, cijene računara padaju i tada nastaje UNIX operativni sistem, pojednostavljenjem MULTICS sistema, koji je postao popularan u akademskom svijetu, vladinim agencijama i mnogim firmama. Iz ovog perioda treba pomenuti i operativni sistem VAX/VMS.

Četvrta generacija (1980-danas) Personalni računar Sa razvojem LSI (Large Scale Integration) kola, čipova koji sadrži hiljade tranzistora na kvadratni centimetar silikona, došlo se do personalnih računara. Što se tiče arhitekture, personalnih kompjuteri (u početku pod nazivom mikroračunari) nisu svi bili toliko različiti od miniračunara PDP-11 klase, ali u smislu cijene su svakako bili drugačiji. Gdje je miniračunar je omogućio odjelu u kompaniji ili univerzitetu vlastiti kompjuter, mikroprocesorski čip je omogućio za pojedinca njegov ili njen lični računar. Lični računari su često bili opremljeni programskim jezikom BASIC u ROM-u Godine 1974, kada je Intel izašao sa 8080, prvi 8-bitni CPU opće namjene, poželio je operativni sistem za 8080, u cilju testiranja. Intel je pitao jednog od svojih savjetnika, Gary Kildall, da ga napiše. Kildall zatim je napisao disk-based operativni sustav nazvan CP/M i osnovao Digital Research, za dalji razvoj i prodaju CP / M što joj je omogućilo da u potpunosti dominira svijet mikroračunarskih za oko 5 godina. U ranim 1980-ih, IBM osmišlja IBM PC i nakon neuspješnog kontakta s Digital Research, obratio se firmi Microsoft čiji je vlasnik Bill Gates ponudio paket s operativnim sistemom i BASIC interpreterom. Gates je otkupio ranu verziju DOS i


angažovao njengovof Tim Paterson-a, da ga doradi. Revidirani sistem je preimenovan u MS-DOS (Microsoft Disk Operating System) i brzo počeo dominirati IBM PC tržištu. CP/M, MS-DOS, i drugim operativni sistemi za rano mikroračunare su svi bazirani na korisnike upisivanjem u komandi sa tastature. To se na kraju promijenilo zbog istraživanja koje je vršio Doug Engelbart na Stanford Research Institute u 1960. Engelbart izmislio GUI (Graphical User Interface), i uveo prozore, ikone, menije i miša. Ove ideje su usvojeni od strane istraživača na Xerox PARC. Jednog dana, Steve Jobs, koji je koji je izmislio Apple računalo u svojoj garaži, posjetio PARC, vidio GUI, i odmah shvatio njegovu potencijalnu vrijednost., Nakon prvog projekta Lisa, Apple Macintosh, bio je veliki uspjeh, ne samo zato što je mnogo jeftinije nego Lisa, već i zato što je user friendly, što znači da je namijenjen za korisnika koji ne samo da nije znao ništa o kompjuterima, nego nije imao apsolutno nikakvu namjeru učenja. Kada je Microsoft odlučio izgraditi nasljednika MS-DOS-a, bio je pod jakim utjecajem uspjeha Macintosh, pa proizvodi sistem GUI zvani Windows, koji je prvobitno bio na vrhu MS-DOS, a počevši od 1995 samostalne verzije Windows, Windows 95, i Windows NT . GUI je postao popularan i na Unix sistemima koji su također postali dostupni na personalnim računarima, pod nazivom X Windows sistema proizvodi na MIT, a popularna je postala besplatna podvarijanta Unix jezgra, Linux. Zanimljiv razvoj, koji je počeo odvija u sredinom 1980-ih je rast mreža osobnih računala, mrežni operativni sistemi, i distribuirani operativnih sistema (Tanenbaum i Van Steen, 2002).U operativni sistem mreže, korisnici su svjesni postojanja više računala i mogu prijaviti na udaljenim mašinama i kopirati datoteke iz jedne mašine na drugu. Povezivanjem ovih mreža nastala je globalna računarska mreža Internet.

Peta generacija 1990 - sada, mobilni računari (mobile computers). O petoj generaciji se češće govorilo u budućnosti, kao o računarima vještačke inteligencije. Međutim gotovo neprimjetno su džepni računari, počevši od Psion Palm, programabilnih kalkulatora, bežičnih mreža, mobitela s dodatnim rokovnicima i ponekom video igrom, do tableta po prodanosti prevazišli personalne računare. Sve više su korištene web aplikacije, globalno pozicioniranje (GPS), ekrane osjetljive na dodir, beskontaktne kartice, džepni Internet, socijalne mreže. Nastaju operativni sistemi iOS, Windows CE, Android, Simbian, BlackBerry itd.

Treba reći da se historija ponavlja. Početni računari nove generacije su slabijih mogućnosti od najboljih računara prethodne generacije, pa se koncepti koji su postojali ranije ne mogu odmah primijeniti. Na primjer, prvi mikroračunar, Altair 8080 se programirao kontrolnom pločom (1975), baš kao i prvi mainframe računari (1945). Zatim nastaju jednoprogramski računari (1978-1990), koji su u mainframe svijetu postojali već od 1950. Sistemi u dijeljenom vremenu su se na mainframe računarima pojavili oko 1965, na mikroračunarima oko 1985, a na džepnim računarima oko 2000. Višeprocesorski sistemi su na mainframe nastali oko 1975, godine, na desktop računare su došli oko 2000, a na džepne oko 2010. godine. Slično tome, neki algoritmi operativnih sistema koji su u svoje vrijeme bili napušteni zbog

Istorija operativnih sistema 19

lošeg iskorištenja hardvera se ponovo javljaju kada iskorištenost hardvera postaje manje bitna od drugih zahtjeva poput brzine.

1.4 Vrste operativnih sistemaOperativne sisteme moguće je klasifikovati na više načina. Mogu se praviti podjele

na osnovu broja korisnika i/ili procesa, prema načinu obrade poslova, prema distribuciji procesorske snage i ostalih resursa ili prema namjeni i funkcionalnim osobinama

1.5 Podjela po broju korisnika i procesaPo broju korisnika koji istovremeno koriste računar, operativni sistemi se dijele na

jednokorisničke (engl. single-user) i višekorisnički (engl. Multiuser). Jednokorisnički operativni sistem je najčešći tip OS koji se koristi na kućnom računaru, kao i na računarima u uredima i drugim radnim okruženjima. Virtualna mašina se kreira za samo jednog korisnika. Višekorisnički računari zahtijevaju jaču hardversku konfiguraciju i omogućavaju simultani prisup više korisnika istovremeno (preko posebnih terminala)

Po broju procesa koji se mogu istovremeno izvršavati operativne sisteme dijelimo na jednoprocesne (engl. single-tasking, singleprocess) i višeprocesne (engl. multitasking. Multiprocess).

Kombinovani pristupi od ove dvije podjele su• Jednokorisnički jednoprocesni (engl. single-user, singletasking) operativni

sistemi, čiji je glavni predstavnik MS-DOS• Jednokorisnički višeprocesni (engl. single-user, multitasking) u koji spadaju

OS/2, MS Windows, Android• Višekorisnički višeprocesni (engl. multiuser, multitasking), kakvi su npr UNIX,

OS/360, VMS, MS Windows Terminal Server

1.6 Podjela po načinu obradePo načinu obrade sisteme možemo podijeliti na• Sisteme sa grupnom obradom (engl. Batch) kod kojih se obavlja predaja

poslova na izvršenje posredstvom ulaznih jedinica. Obrada se obavlja u nizu i nema komunikacije između korisnika i posla

• Interaktivni sistemi (engl. Interactive systems) kada korisnici komuniciraju sa svojim poslovima u okruženju s dijeljenim vremenom

• Kombinovani sistemi kod kojih se po karakteristikama zadatka oni obavljaju po želji grupnom obradom ili interaktivnim radom. (primjer IBM DOS/360)

1.7 Sistemi s grupnom obradom (batch sistemi)Najraniji operativni sistemi su sistemi s grupnom obradom. Koristili su ih prvi

računari 1960-ih i 70-ih. Primjer ovakvog sistema je IBM IBSYS. Najčešći ulazni uređaji su čitač kartica i magnetne trake, a izlazni uređaj i linijski štampač, bušač


kartica i magnetne trake. Ovi sistemi nemaju interakcije sa korisnikom. Korisnik pripremi posao (job) za obradu koji sadrži program i podatke, operater to postavi na sistem, pokrene izvršavanje i vrati korisniku rezultat (izlazni podaci ili izvještaj o grešci).

Jedan job može izgledati ovako:$JOB user_spec ; ime korisnika$FORTRAN ; Učitaj FORTRAN kompajlerKartice s izvornim kodom$LOAD ; Učitaj kompajlirani program$RUN ; Pokreni programdata cards$EOJ ; Kraj posla

$JOB user_spec ; novi korisnik$LOAD application$RUNdata$EOJ

OS je stalno u memoriji i samo redom učitava poslove i prelazi na njih, držeći ih u

Uočeno je međutim da iskorištenje procesora nije dovoljno. Proces učitavanja podataka i programa je dosta spor i za to vrijeme procesor je neiskorišten.

Multiprogramirani batch sistemi 21

1.8 Multiprogramirani batch sistemiUvođenjem diska omogućeno je da se poslovi smjeste na uređaj s direktnim

pristupom. I dalje se pripremi grupa zadataka, ali oni se sada ne izvršavaju nužno onim redoslijedom kojim su poslani. Kada je jedan od poslova u stanju čekanja, operativni sistem može da pređe na izvršavanje drugog posla. Izbor posla iz skupa raspoloživih poslova (pool), koji će se učitati u memoriju i izvršavati zove se raspoređivanje poslova (job scheduling). Multiprogramiranje (multiprogramming) omogućava izvršavanje više poslova uporedo; dok jedan čeka na završetak I/O operacije, CPU izvršava drugi posao. Uvođenje multiprogramiranja otvara više pitanja.

• Kako iz skupa svih poslova izabrati one koji će se učitati u memoriju i izvršavati – job scheduling

• Kako smjestiti poslove različite veličine u memoriju – memory management• Kada posao koga CPU trenutno izvršava zatraži U/I operaciju, kako izabrati

slijedeći koga će CPU izvršavati – CPU scheduling• Kako preći sa izvršavanja jednog posla na izvršavanje drugog – context switch• Kako opsluživati zahtjeve za U/I operacijom na dijeljenom uređaju – I/O

device scheduling• Kako spriječiti da jedan posao slučajno ili namjerno ugrozi memorijski

sadržaj drugog – protection

1.9 Sistemi dijeljenog vremena (time sharing)Batch sistemi ne pružaju korisniku mogućnost interakcije sa zadatkom dok se on

izvršava. Time-sharing ili multitasking je logički nastavak multiprogramiranja. To je tehnika dijeljenja vremena tako da se proces izvršava u malom intervalu. CPU izvršava više zadataka tako što se prebacuje između njih. Ovo prebacivanje se dešava tako često da korisnik može uticati na svaki od programa u izvršenju. Time su omogućene dvije vrste interaktivnih sistema.

1. Interaktivni računarski sistem koji pruža on-line komunikaciju između korisnika i sistema. (primjer MS Windows)

2. Sistem sa dijeljenim vremenom koji pruža mogućnost da više korisnika dijeli jedan računar. (promjer VAX/VMS)

Kod ovih sistema uvodi se novi pojam, pojam procesa, koji predstavlja izvršavanje nekog programa nad datim skupom podataka. Pojmovi program i proces su slični, ali ipak različiti jer je program pasivni a proces aktivni entitet koji uključuje i stanje memorije i procesora u toku izvršenja. Program je poput kuharskog recepta, a proces je stvarno kuhanje. Tako više procesa može biti aktivirano nad istim programom, a moguće su sve četiri kombinacije odnosa broja programa i procesa kod operativnih sistema, iako su neke dosta rijetke.

1. Monoprogramski, monoprocesni su specijalizovani ili ugrađeni (embedded) sistemi za upravljanje nekim hardverom. Primjer predstavljaju kalkulatori,


dječji laptopi, Nintendo Gameboy i slično. Izvršavaju jedan program koji se ne kopira u memoriji.

2. Multiprogramski, monoprocesni sistemi dopuštaju da se od mnoštva programa učita jedan u memoriju. Primjer su CP/M i MS DOS za personalni računar starije generacije koji može imati u memoriji i izvršavati samo jedan program u jednom trenutku ili prvi batch sistemi

3. Monoprogramski, multiprocesni su specijalizovani sistem posebne namjene sa više korisnika kao što je web server na čipu, WIZnet Embedded Web Server. Kada više korisnika istovremeno pristupa, može se pokrenuti nekoliko kopija njegovog jedinog program akoji on poznaje

4. Multiprogramski, multiprocesni su svi moderni OS opšte namjene

1.10 Kombinovani sistemiI nakon uvođenja sistema s dijeljenim vremenom, neki poslovi su se rutinski i dalje

obrađivali grupnom obradom. Skup bušenih kartica sa poslovima zamijenile su datoteke s uputstvima (ali je ponegdje kao u kontrolnom jeziku JCL za IBM z/OS ostala terminologija da se jedan red u toj datoteci zove kartica). I u pretežno interaktivnim sistemima postoji mogućnost da se neki poslovi automatizuju primjenom skriptnih jezika.

1.11 Podjela po funkcionalnim osobinamaPo funkcionalnim osobinama, operativni sistemi mogu se podijeliti na više

kategorija, pri čemu mnogi operativni sistemi istovremeno pripadaju u nekoliko kategorija. Te kategorije su:

• Mainframe operativni sistemi namijenjeni su za fizički velike mašine. U prvom periodu su uglavnom bili batch sistemi, gdje su se slični poslovi udruživali u grupe i zajednički obrađivali. Vremenom se uvodila tehnika multiprogramiranja i automatskog sekvenciranja, čime se bez operatora se prebacuje kontrola sa jednog posla na drugi

• Operativni sistemi za sisteme sa dijeljenim vremenom (engl.time-sharing systems) omogućavaju svakom korisniku komunikaciju sa svojim poslom i OS-om u toku rada. Tehnika multiprogramiranja omogućava da se više poslova se nalazi u memoriji istovremeno, a tehnika dijeljenja vremenaradi na principu da poslije isteka vremenskog kvantuma svaki posao mora predati kontorlu drugom poslu i sačekati svoj novi kvantum

• Operativni sistemi za desktop sisteme su namijenjeni jednom korisniku po pristupačnoj cijeni. Prve verzije ovih sistema su imale skromne performanse. Kasnije je razvijen grafički korisnički interfejs (GUI). Sistemi su dosta fleksibilni, prilagodljivi i široko korišteni. Primjeri su DOS, MS Windows, Novell NetWare, UNIX, Linux

• Operativni sistemi za višeprocesorske sisteme (engl.multiprocessor systems) predviđeni su za sisteme sa više procesora koji komuniciraju putem zatvorenih komunikacionih linija a smješteni su u istom kućištu. Komunikacija i

Podjela po funkcionalnim osobinama 23

sinhronizacija između procesora putem djeljive memorije. Mogu se realizovat na dva osnovna principa. U simetričnom multiprocesiranju svi procesori su ravnopravni i izvršavaju i korisničke programe i operativni sistem. Kod asimetričnog multiprocesiranja svakom procesoru je dodijeljen specifičan zadatak, a master procesor dodjeljuje zadatak ostalim procesorima.

• Mrežni operativni sistemi (engl. network OS) omogućavaju komunikaciju računara povezanih u mrežu sa visokim stepenom autonomije. Korisnici mogu pristupati resursima udaljenih mašina na dva načina; Daljinsko prijavljivanje na sistem (remote login) i razmjenom datoteka sa udaljenim sistemom (remote file transfer). Svaki računar ima svoj OS, a međusobno razmjenjuju podatke pomoću odgovarajućih protokola. OS mogu biti različiti – potreban je samo zajednički protokol (zajednički jezik za komunikaciju)

• Distribuirani sistemi (engl. distributed systems) Osim dijeljenja datoteka i resursa, distribuiraju i procese. Korisnik vidi jednoprocesorski sistem. Više računara povezanih u mrežu a jedan OS upravlja svim resursima. Korisnik ne mora znati da je umrežen sa drugim računarima pa se cio sistem vidi kao jedan računar. Kolekcija procesora tj. računara koji ne dijele memoriju i sistemski sat. Svaki procesor ima lokalnu memoriju a komuniciraju putem LAN-a (lokalna mreža) ili WAN-a (mreža širokog područja)

• Udruženi sistemi (engl. clustered systems) ili klasteri se sastoje od udruženih računara čvrsto povezanih LAN mrežom. Postoje dvije vrste udruživanja: Asimetrično (jedan server -čvor izvršava aplikaciju, ostali prateći -monitoring serveri) je namijenjeno za povećanje pouzdaniosti, drugi se serveri uključuju tek u slučaju pada glavnog. Simetrično udruživanje povećava performanse, gdje su sviserveri aktivni i svi izvršavaju aplikaciju).

• Operativni sistemi za upravljanje u realnom vremenu (engl. real-time systems) su specijalni OS kod kojih se očekuje odgovor u tačno definisanom vremenskom intervalu. Koriste se kao specijalni grafički sistemi, sistemi za medicinsku grafiku, sistemi za industrijsku kontrolu,kontrolisanje naučnih eksperimenata. Izvori podataka su senzorski uređaji, razni prekidači, A/D i D/A konvertori.

• Ručni sistemi (engl. handheld systems), se koriste na uređajima malih dimenzija kao što su PDA uređaji (engl. Personal Digital Assistants), mobilni telefoni, tableti itd. Osnovna karakteristika ovih sistema je mobilnost, ali imaju Slabije hardverske resursu od desktop računara (manje memorije, procesori su skromnijih mogućnosti, mali ekrani, ulazni hardver je manje ugodan)

• Ugrađeni sistemi (embedded systems) vrlo često su uređaji čiji korisnik i ne zna da su u pitanju računarski sistemi, poput POS kasa, pametnih kartica, savremenih televizora, kontrolora veš mašina i slično.


1.12 Jezgro operativnog sistemaJezgro operativnog sistema (engl. nukleus, kernel) je srž operativnog sistema.

Jezgro operativnog sistema je zaduženo za upravljanje sistemskim resursima i za komunikaciju između komponenti hardvera i softvera. Jezgro je osnovna komponenta operativnog sistema koja predstavlja najniži apstracijski sloj izveden u softveru a zadatak mu je da izvršava kritične funkcije operativnog sistema: upravljanje primarnom i sekundarnom memorijom, upravljanje procesima; sinhronizacija, stvaranje, gašenje, izvršavanje, izmjena konteksta (eng. context switch), interprocesna komunikacija, upravljanje prekidima.

Jezgro je interfejs između hardvera i ostalih slojeva operativnog sistema. Izuzetak ovog pristupa je slojevita NT arhitektura gdje se ispod jezgra nalazi sloj apstrakcije hardvera (engl. Hardware Abstraction Layer, HAL) .Osnovna funkcija jezgra je upravljanje procesima - dodjeljivanje procesora procesima koji je nedjeljiv resurs.

Preduslovi za ostvarenje osnovne funkcije jezgra na nivou hardvera su: mehanizam prekida, zaštita mehanizama adresiranja memorije, skup privilegovanih instrukcija i sat realnog vremena. Mehanizam prekida obezbjeđuje izvršenje upravljačkog programa (prekidne rutine) tako što prebacuje kontrolu sa korisničkog na upravljački program. Zaštita mehanizama adresiranja memorije onemogućava da jedan proces upiše svoje podatke u prostor memorije dodjeljen drugom procesu. Skup privilegovanih instrukcija je skup instrukcija dostupnih operativnom sistemu ali ne i korisničkom programu. Korisnički program izvršava privilegovane instrukcije samo putem sistemskih poziva. Satni mehanizam realnog vremena kontroliše i evidentira potrošnju resursa računara za sve pojedinačne procese.

1.13 Dizajn jezgra os-aU narednim poglavljima, će se opisati sedam različitih arhitektura jezgra

operativnog sistema. To su monolitni, slojevito, prstenasto, mikrokernel, hibridno jezgro, jezgro preko virtuelnih mašina i egzokernel

1.14 Monolitni sistemiDaleko najčešći način organizacije, mogao bi se zvati veliki nered. Struktura je da

nema strukture. Operativni sistem je napisan kao skup podprograma, od kojih svaki može pozvati bilo koji od onog drugog kad god je to potrebno. Kada se koristi ova tehniku, svaki podprogram u sistemu ima dobro definisano sučelje u pogledu parametara i rezultata, a svaki od njih je slobodan pozvati bilo koji drugi

Čak i u monolitnim sistemima, međutim, moguće je imati bar malo strukture. Usluge (sistemki poziv) koje se traže od operativnog sistema započinju stavljanjem parametara u dobro definisanom mjestu (npr. na stack), a zatim izvršava instrukcija zamke. Ova instrukcija prebacuje mašinu iz režima korisnika u režim jezgra i zatim kontrolu preuzme operativni sistem. On zatim dohvaća parametre i određuje što sistemski poziv treba da izvrši. Nakon toga, indeksom se nađe mjesto u tablici koja sadrži pokazivač na podprogram koji izvodi sistemski poziv.

Monolitni sistemi 25

Ova organizacija ukazuje na osnovnu strukturu za operativni sistem:• Glavni program koji poziva tražene podprograme servisa.• Skup uslužnih podprograma koji obavljaju sistemske pozive.• Skup zajedničkih procedura koje pomažu procedurama servisa.

1.15 Slojeviti sistemiGeneralizacija strukture sa tri spoemenuta dijela monolitnog jezgra je organizirati

operativni sistem kao hijerarhiju slojeva, svaki izgrađeni jedan ispod drugog. Prvi sistem izgrađen na ovaj način je sistem izgrađen na Technische Hogeschool Eindhoven u Nizozemskoj. Sistem je imao 6 slojeva, kao što je prikazano na slici. Sloj 0 se bavio dodjelom procesora, prebacivanjem između procesa kada je do prekida došlo ili tajmera istekao. Slojevi iznad predstavljaju druge grupe funkcija operativnog sistema. Osnovno pravilo je da je dopušteno pozivati samo rutine iz istog ili nižih slojeva od sloja u kome se rutine nalaze. Na taj način se smanjuje mogućnost da modifikacija jednog dijela operativnog sistema pokvari njegov ostatak. Pristup, međutim ima i nedostatak. Zamislimo da operativnom sistemu treba dodati mrežne mogućnosti. Kako je riječ o novom sloju treba ga negdje staviti. Ako se stavi ispod sloja datotečnog sistema, mrežni sloj neće moći čitati konfiguraciju mreže, npr. tablice za definisanje izlaza mreže. Ako se stavi iznad tog sloja, tada operativni sistem neće moći imati dijeljenje datoteka na virtualnim mrežnim diskovima.

1.16 Prstenasti sistemDalja generalizacija koncepta slojeva se pojavila u MULTICS sistemu. Umjesto

slojeva, MULTICS je opisan kao da ima niz koncentričnih prstenova, gdje su unutrašnji više privilegovani od vanjskog (što je efektivno ista stvar). Kada je podprogram u vanjskom prstenu želio pozvati nešto u unutrašnjem prstenu, to je morao da izvrši ekvivalentnim sistemskim pozivom, to jest, TRAP instrukcijom čiji se parametri pažljivo provjere poziva.


Dok je nanošenje slojeva stvarno samo dizajnerska pomoć, jer su svi dijelovi sistema na kraju povezani u jedan programski objekt, u MULTICS, mehanizam prstena je vrlo prisutan u vrijeme izvođenja i sprovodi od strane hardvera. Prsteni ne grupišu procedure nužno po funkcionalnosti nego po zaštiti.

1.17 Os s mikrojezgromTrend u modernim operativnim sistemima je ukloniti je više moguće iz kernel

moda, ostavljajući minimalni mikrokernel. Uobičajeni pristup je da se implementira većinu operativnog sistema u korisničkim procesima. Za zatražiti uslugu, kao što je čitanje blok datoteke, korisnik procesa (sada poznat kao proces klijent) šalje zahtjev na server proces, koji onda obavlja posao i vraća odgovor.

U ovom modelu, sve što kernel radi je održavanje komunikacije između klijenta i poslužitelja. Razdvajanjem operativni sistem na dijelove, od kojih je svaka samo upravlja jedan aspekt sistema, kao što su usluge datoteke, procesi, terminal, ili memorija, svaki dio postaje mali i upravljiv. Osim toga, jer se svi serveri izvode u korisničkom a ne u kernel režimu, nemaju direktan pristup hardveru. Kao posljedica toga, ako je se desi greška na serveru datotečnog sistema, usluga datoteka se može srušiti, ali to obično neće oboriti cijelu mašinu. Pošto su podsistemi u odvojenim adresnim prostorima, oni ne mogu komunicirati pozivima podprograma ili dijeljenom memorijom. Umjesto toga sistemski procesi razmjenjuju poruke čijim raspoređivanjem upravlja mikrojezgro.

Mana mikrojezgra je u lošijim performansama, jer se izmjena iz sistemskog u korisnički režim rada dešava prilično često. Najpoznatiji operativni sistemi s ovom

Os s mikrojezgrom 27

vrstom jezgra su Unix kompatibilni Mach i Minix. Minix 3 je pored toga što je namijenjen za nastavu, takođe vrlo pouzdan zbog ideje o reinkarnacijskom serveru. On proziva registrovane podsisteme i u slučaju pada nekog od njih ponovo ga pokreće ako je to moguće.

1.18 Hibridno jezgroSpajanjem ideja monolitnog jezgra sa mikrokernelom nastaju hibridna jezgra.

Sistem je razdvojen na osnovno jezgro vrlo male funkcionalnosti (obično samo obrada prekida i raspoređivanje procesa) i dijelove za upravljanje resursima, ali oni ostaju u istom adresnom prostoru. Time se smanjuje pouzdanost u odnosu na čisto mikrojezgro ali povećava brzina. Ipak, sistem je bolje interno struktuiran od monolitnog jezgra. Najpoznatiji primjer ovakvog jezgra je Windows NT serija. Njegov dio koji se zove kernel je mali, ali se resursima upravlja koristeći Executive. Aplikativni programi, međutim nje pozivaju direktno sistemske pozive u jezgru, nego servere podsistema koji komuniciraju s jezgrom i omogućavaju da se po želji poziva Windows, OS/2 ili Posix sistemski pozivi (iako većina programa ostaje s Windows pozivima).

1.19 Os preko virtuelnih mašinaU IBM sistemu VM/370 uveden je novi koncept, operativni sistem preko

vietuelnih mašina, Srce sistema, monitor virtuelnih mašina, radi na golom hardvera i radi multiprogramiranje, pružajući ne nekoliko virtualnih mašina na sljedeći sloj gore, kao što je prikazano na slici. Međutim, za razliku od svih ostalih operativnih sistema, te virtualne mašine nisu proširena mašina, s datotekama i ostalim lijepim karakteristikama. Umjesto toga, oni su tačna kopije golog hardvera, uključujući kernel/korisnika režim, I / O, prekide, i sve što ostalo prava mašina ima.

Pošto je svaka virtualna mašina identična pravom hardver, svaka može raditi bilo koji operativni sistem koji će izravno raditi na golom hardvera. Različite virtualne mašine mogu, i pokrenuti različite operativne sisteme. Na primjer neke izvršavaju jedan od potomaka OS/360 za serije ili obradu transakcija, dok su ostale raditi


jedanokorisničke, interaktivne sisteme pod nazivom CMS (Conversational Monitor System).

Prošlo je puno godina, dok se ova ideja nije postala izvodiva na mikroračunarima. Procesori Core 2 uključuju režim virtualizacije koji generišu izuzetke pri svakoj instrukciji čije ponašanje treba simulirati da virtuelna mašina izgleda kao prava.Tako postaje moguća realizacija operativnih sistema sa slojem virtualne mašine između hardvera i operativnog sistema. U današnjoj terminologiji, monitor virtuelnih mašina se zove hipervizor tipa 1, čiji je primjer Oracle VM. Ovo treba razlikovati od hipervizora tipa 2, koji se izvršava na kao korisnički program u već pokrenutom

1.20 ExokernelSa VM/370, svaki korisnik proces dobiva potpunu kopiju stvarnog računalo. Uz

virtualni 8086 mod na Pentium-u, ili hipervizor tipa 2 svaki korisnik proces dobiva potpuna kopija drugog računar. Idući korak dalje, istraživači na MIT-u su izgradili sistem Aegis koji daje svaki korisniku klon stvarnog računara, ali sa podskupom resursa. Tako jedna virtualna mašina može dobiti disk blokove 0-1023, sljedeća bi se mogla dobiti blokove 1024-2047, i tako dalje.

Na donjem sloju, koji radi u kernel modu, je program pod nazivom exokernel. Njegov posao je da izdvoji resurse za virtualne mašine, a zatim provjeri pokušaje kako se oni koriste kako bi bili sigurni da neko ne pokušava koristiti tuđe resurse. Svaki virtualni stroj na nivou korisnika može pokrenuti vlastiti operativni sistem, osim da je svaki od njih je ograničen samo na dio resursa Prednost exokernel sheme je da štedi sloj mapiranja. U drugom dizajnu, svaka virtualna mašina misli da ima svoj disk, s blokovima od 0 do N, tako da monitor virtualnih mašina stroj monitor mora održavati tablice korištenih disk adresa. Uz exokernel, nije potrebno ovo raspoređivanje. U exokernel treba voditi samo računa o tome koji virtualni stroj je dodijeljen kojem resursu.

1.21 Prekidi Pošto u modernim operativnim sistemima jezgro i korisnički proces rade u

odvojenim memorijskim prostorima i sa različitim privilegijama, postoji česta potreba prelaska između ta dva režima rada.

Prekidi 29

Ako je procesor radi u režimu jezgra, može se preći u korisnički režim rada postavljanjem statusnog registra koji definira način rada. Nakon što se prešlo u korisnički režim, međutim , ne može se jednostavno preći na rad u kernel modu, jer bi to bilo kršenje privilegija. Prelazak iz korisničkog u režim jezgra odvija se preko softverskog prekida, hardverskog prekida i izuzetaka. Za ovo troje, upotrebićemo generički pojam zamka (trap), iako se tim pojmom često označava samo prvi od njih.

Softverski prekid. Softverski prekid inicira se kada korisnik pozove specijalnu instrukciju. Tada se prisiljava program da skoči na dobro poznatu adresu na osnovu broja prekida, koji je predviđen kao parametar. Primjeri softverskog prekida se mogu naći na većini procesora, kao što su instrukcije int ili sysenter na Intel procesorima ; syscall na AMD procesorima ili SWI na ARM procesorima .

Izuzeci Što se događa ako korisnik programa pokušava da izvrši instrukciju koja je dostupna samo u režimu jezgra, ili pokušava pristupiti memorijskom prostor koji nije dostupan za to? U slučajevima kao što je ovaj dešava se izuzetak. Procesori imaju definisan skup izuzetaka koje poznaju. Na primjer , to može biti kršenje pristupa memoriji, ilegalne instrukcije, kršenje pristupa registru, dijeljenja nulom , ili pristup nepostojeće memorije. Iako se izuzeci ne očekuje od strane programera , oni su kao odgovor na izvršenje trenutne instrukcije. Imajte na umu da Intel procesora prije Core 2 Duo nisu generisali zamku kada je korisnički program pokušao da izvrši privilegovane instrukcije, nego su bili ignorisani. To je otežavalo pravljenje virtualnih mašina.

Hardverski prekid nastaje kada vanjski sistem događaj koji šalje prekid signal procesor, kao što je završetak DMA ( pristup direktne memorije ) transfera od hardvera, kao što je kontroler diska . Hardverski prekidi mogu nastati spontano, a u bilo koje vrijeme . Oni nisu u funkciji instrukcije koja se trenutno izvršava i prisiljavaju je na spontanu promjenu kontrole .

Tok kontrole Uprkos konfuzija u terminologiji , krajnji rezultat svih tih zamki je isti. Svaka zamka ima pridružen niz i procesor skače na adresu u memoriji koja se temelji na broju zamke u tabeli vektora prekida. Zamka djeluje kao spontani poziv potprograma . Sadašnji programski brojač je gurnut na stack i program skače na dobro poznatu adresu. Ta adresa obično se nalazi u tablici vektora. Pri tome se izvrši prebacivanje iz korisničkog režima u kernel režim. Tablica je popunjena pri inicijalizaciji operativnog sistema, i njene elemente može mijenjati samo operativni sistem. Budući da se ona ne može mijenjati od strane korisnika, operativni sistem je uvjeren da programska kontrola ide na samo dobro definirane tačke u operativnom sistemu.

Nakon ulaska u zamku, izvodi se kod operativnog sistema i , kada je operativni sistem je spreman da prenese kontrolu nazad u korisnički režim, izvršava povratak (naredba IRET na Intel procesorima). To uključuje povratak procesora natrag u korisnički način rada i prebacuje kontrolu na adresu na vrhu steka.

Svakom od ovih zamki drugačije upravlja operativni sistem.


• U slučaju softverskog prekida provjere se parametri. Ako oni predstavljaju regularan način poziva usluge operativnog sistema, prelazi se na odgovarajuću rutinu, sistemski poziv.

• Ako je u pitanju bio izuzetak, provjeri se šta ga je izazvalo. Može se desiti na primjer, da se pristupalo regularnoj memorijskoj lokaciji, ali ona nije trenutno dostupna. U ovom slučaju, operativni sistem bi učita potreban komad memorije i ponovi instrukciju. Ako akcija nije bila valjana, kao što pokušaju pristupa nevažećoj memorijskoj lokaciji, operativni sistem može poslati određeni signal procesu ili ga prekinuti. U nekim slučajevima, kao što je virtualizacija, operativni sistem možda će morati da simulira akcije privilegovanih instrukcija i zatim se vratiti kontrolu natrag na sljedeće instrukcije u korisničkom procesu

• Za razliku od softverskih prekida i izuzetaka, hardverski prekida nastaje spontano zbog nekih događaja koji su nevezani za trenutne instrukcije. Operativni sistem biti sigurni da ne mijenja stanje izvršavanja procesa pri obradi hardverskog prekida

1.22 Sistemski pozivProgram često treba pročitati datoteku, pisati na neki uređaj, ili možda pokrenuti

neki drugi program. Za sve ovo je potrebna intervencija operativnog sistema. Veza između programa operativnog sistema i korisnik je skup sistemskih poziva ( open, close, read, fork, execve , itd ) . Izrada sistem poziva koristi mehanizam zamku da se prebacite na dobro definirane tačke u kernel , radi u kernel modu .

Izvršavanje sistem poziva obično uključuje čuvanje parametara na posebno formiran stek , skladištenje broja sistemskog poziva (svaka funkcija ima odgovarajući broj) , a zatim izdavanje instrukcije za softverski prekid za prebacivanje kontrole da operativni sistem radi u režimu jezgra.

Na primjer, za sistemski poziv getpid (dobavljanje identifikatora procesa ) na Intel/Linux sistemima stavlja se broj 20 u registar EAX (20 je redni broj koji odgovara na getpid sistemski poziv), a zatim izvršava INT 80h , koja generira softverski prekid. Rezultat će se dobiti u registru EAX. U verziji jezgra 3.13 ima 350 sistemskih poziva. Pozivaju se tako da se u EAX stavi redni broj sistemskog poziva, a njegovi parametri redom smiještaju u EBX, ECX, EDX, ESI, EDI Oni koji se najčešće koriste imaju manje redne brojeve. Tako, od broja 1 sistemski pozivi su redom: exit, fork, read, write, open, close, waitpid, creat,link, unlink, execve, chdir, time, mknod, chmod,lchown, break, oldstat, lseek, getpid, mount, umount,setuid, getuid, stime, ptrace, alarm, oldfstat, pause,utime, stty, gtty, access, nice, ftime, sync, kill, rename, mkdir, rmdir, dup, pipe, times, prof, brk,setgid, getgid, signal, geteuid, getegid, acct, umount2, lock, ioctl, fcntl, mpx, setpgid, ulimit, oldolduname, umask, chroot, ustat, dup2, getppid, getpgrp, setsid,sigaction, sgetmask, ssetmask, setreuid, setregid,sigsuspend, sigpending, sethostname, setrlimit, getrlimit,getrusage, gettimeofday, settimeofday, getgroups, setgroups,select, symlink, oldlstat, readlink, uselib, swapon,reboot, readdir, mmap, munmap, truncate, ftruncate, fchmod, fchown,

Sistemski poziv 31

getpriority, setpriority, profil, statfs,fstatfs, ioperm, socketcall, syslog, setitimer, getitimer,stat, lstat, fstat ...

I Windows NT i njegovi nasljednici (npr Windows 8) imaju sličan način sistemskog poziva, ali je on vrlo malo poznat. Da se pozove usluga jezgra operativnog sistema koristi se jedna od tri instrukcije: INT 2Eh (na starijim sistemima), sysenter (na novijim Intel procesorima) i syscall (na AMD procesorima). Na primjer za poziv NtQuerySystemInformation može se pisati.

NtQuerySystemInformation: mov eax, 97h lea edx, [esp+4] int 2Eh ; ili sysenter, syscall ret 10h

Kao i kod poziva funkcija, kernel treba biti oprezan da spasi sve korisničke registre i sve obnovi ih prije nego što se vrati. Sva ovo ružnoća skrivena je od programera sa skupom biblioteke rutina koje odgovaraju svakom sistemskom poziva. Biblioteke rutine spase parametre , izdaju zamku, i kopiraju rezultate natrag na korisnički stek tako da sistemski poziv izgleda baš kao redovni poziva funkcije.

Generalno, sistemi pružaju biblioteke ili API koji se nalazi između normalnog programa i operativnog sistema. Na Unix-like sistema, taj API je obično dio implementacija C biblioteke (libc), kao što su glibc , koja pruža omot funkcije za sistemske pozive , koji se često zove isto kao sistemski poziv koga pozivaju. Na Windows NT, taj API se zove Native API, u ntdll.dll biblioteci, nedokumentirani API koga koriste implementacije regularnog Windows API i neposredno koriste neki sistemski programi na Windows. Poziv funkcije biblioteke predstavlja običan poziv podprograma, koji sam po sebi ne prelazi u režim jezgra, ali prepakuje parametre i pozove odgovarajući softverski prekid. Na ovaj način biblioteka , koja postoji između jezgra OS i aplikacija, povećava prenosivost.

Na sistemima sa exokernel, biblioteka je posebno važna kao posrednik. Sa exokernel, biblioteka kernel API na vrlo niskom nivou, i pružaju apstrakcije i upravljanje resursima.

1.23 API poziviMada postoje biblioteke koje omogućavaju programeru da poziva sistemske

pozive, češće se koriste viši nivoi apstrakcije. Sistemski pozivi su često nedokumentovani i nekompatibilni između verzija operativnih sistema. Na primjer, direktno pozivanje sistemskog poziva u Linux-u koristeći INT 80h će raditi samo na datom procesoru, ili čak konkretnoj verziji jezgra Linux-a za taj procesor.

Umjesto toga, prilikom programiranja na nekom programskom jeziku, preporučuje se da programer koristi samo API (application programming interface) operativnog sistema, ili ako želi postići i manju ovisnost o operativnom sistemu, API vezan za dati programski jezik. API definiše kako neke softverske komponente međusobno reaguju s drugim.


U slučaju Windows programerima je na raspolaganju više skupova API, raznih nivoa. Kao ilustracija, navešće se ime funkcije koja radi pokretanje novog procesa u svakom od njih i verzije Windows-a u kojima je ovaj API moguće pozivati.Naziv Verzije

WindowsNamjena Funkcija za

kreiranje procesa

Kernel API NT,2000,XP, Vista,7,8

Skup funkcija u režimu jezgra. Pozivaju ga samo drajveri.

PspCreateProcess.

Native API NT,2000, XP, Vista, 7, 8

klasični sistemski poziv i izaziva prelazak u režim jezgra. Koristi ga zanemariv broj programa, na primjer checkdisk.

NtCreateProcess.

Win32 API 95,98,ME,NT,2000,XP, Vista, 7, 8

Smješten je u velikom broju dijeljenih datoteka i poziva se kao funkcije u C. Uz njega su još i objektno bazirani API (pozivaju se kao C++ objekti bez nasljeđivanja) COM, DirectX, ActiveX, najviše korišten

CreateProcess

.NET API XP,Vista, 7, 8 uključuje veliku biblioteku za objektno-orijentisane jezike i pruža priličnu neovisnost od programskog jezika

Process.Start

WinRT 8 objektno-orijentisani API dizajniran za saradnju s drugim jezicima koristeći metapodatke

Windows.System.Launcher.LaunchFileAsync

Win16 API 1,2,3,95,98, ME,NT,2000, XP, Vista

šesnaestbitna verzija Windows WinExec

DOS API 1,2,3,95,98, ME,NT,2000, XP, Vista

Programi za MSDOS INT 21, AH=4Bh

Java API 98,ME,2000 za izvršavanje programa u jeziku Java

Runtime.exec

OS/2 API NT, 2000 Izvršavanje programa pisanih za OS/2

DosExecPgm

Posix API NT, 2000, XP Izvršavanje programa pisanih za Unix

fork, execve

POSIX API 33

1.24 POSIX API Sistemi nastali na bazi Unix koriste POSIX API. je prijenosni standard za funkcije

operativnog sistema. Ako aplikacije koriste ovaj API, biće daleko lakše prenositi ih s jednog operativnog sistema na drugi, bez obzira koje se jezgro koristi. Ovaj standard opisuje određene zajedničke usluge, API, koje kompatibilan operativni sistem mora pružiti softveru (npr. utičnice, datoteke i niti) zajedno sa konvencijama o tome kako ih treba pozvati iz programa. Ideja je da će program napisan za jednu POSIX-kompatibilni OS biti lakše prebačen na drugi POSIX usklađen OS nego na OS koji nije POSIX usklađen. To je razlog zašto je mnogo lakše prebaciti aplikaciju iz, recimo, FreeBSD na Linux nego iz FreeBSD na Windows.

Sljedeći primjer u jeziku C pokazuje kako se koristi funkcija open, koja je dio Posix API.

#include <fcntl.h>...int fd;mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;char *filename = "/tmp/file";...fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, mode);...C program

1.25 DOS APINa operativnom sistemu MS DOS API funkcije se pozivaju mašinskom

instrukcijom INT 21h, (i još nekim drugim INT naredbama) pa izgledaju kao sistemski pozivi. Ali, ovaj operativni sistem nema razliku između korisničkog režima i režima jezgra. Prije poziva ove instrukcije u registru AH se nalazi broj funkcije, a u ostalim registrima dodatni parametri. Vrijednosti AH registra kojim se bira poziv su navedene u tabeli. Jezgro ovog sistema je datotema MSDOS.SYS u kojoj se nalazi implementacija datih poziva.


Primjer: Napusti programMOV AH,4ChMOV AL,0INT 21h

1.26 WINDOWS APIWindows API je ime najvažnijih funkcija namijenjenih programerima apli

raspoloživih u Microsoft Windows operativnim sistemima. Dizajniran je za upotrebu u C/C++ programima i predstavlja najdirektniji način za interakciju između Windows sistema i softverskih aplikacija.

Funkcionalnost koju nudi Windows API grupiše se u osam kategorija.Osnovne usluge Ovaj dio Windows API-ja pruža pristup najvažnijim resursima

koje pruža Windows sistem. Uključeni su datotečni sistem, pristup uređajima, procesi i niti, pristup Windows registry-ju, i praćenju grešaka. Ove funkcije se nalaze unutar datoteka kernel32.dll i advapi32.dll.

Grafičke funkcije (GDI) Ove funkcije omogućavaju izlaz na monitore, štampače i druge izlazne uređaje. Funkcije su locirane u datoteci gdi32.dll, a od Windows XP i u datoteci gdiplus.dll.

Korisnički interfejs U korisnički interfejs spadaju funkcije koje omogućavaju upravljanje prozorima, osnovnim kontrolama ( kao što su dugmad i klizne trake), naprednim kontrolama (progresne trake, kartice), prijem ulaza miša i tastature i druge funkcionalnosti povezane s grafičkim interfejsom. Ova jedinica je locirana u user32.dllcomctl32.dll. U korisnički interfejs spada i grupa funkcija koja prikazuje standardne Windows dijaloške prozore za otvaranje i snimanje datoteka, izbor boja, fonta itd, koje su locirane su u comdlg32.dll. Jedna grupacija funkcija korisničkog

WINDOWS API 35

interfejsa služi za kontrolu školjke operativnog sistema (Program manager, Explorer) i locirana je u bibliotekama shell32.dll i shlwapi.dll.

Mrežni servisi Mrežni servisi pružaju različite usluge operativnog sistema vezane za pristup računarskoj mreži. U tu kategoriju spadaju NetBIOS (mogućnost imenovanja računara), Winsock (pravljenje Internet servera), NetDDE (razmjena podataka preko mreže), RPC (pokretanje programa na daljinu) i mnogi drugi.

Web API funkcije Internet Explorer je integriran u operativni sistem počevši od Windows 98, pa se funkcije koje pruža web pregledač također mogu koristiti iz korisničkih programa. Ove funkcije se nalaze u grafičkoj kontroli koja uključuje web pregledač u aplikacije (shdocvw.dll i mshtml.dll); u servisu urlmon.dll, koji pruža COM objekte za prepoznavanje adresa na webu; u biblioteci za višejezični pristup (mlang.dll); skupu komponenti za filtriranje slike DirectX Transforms; u podršci za XML ; u pristupu Windows adresaru.

Multimedijalni APIji za aplikacije koje se bave animacijom i zvukom, postoje dvije vrste API-ja. Jedan je lociranWINMM.DLL i omogućuje pristup zvučnoj kartici. Drugi se zove DirectX i namijenjen je pisanju igara. On uključuje Direct3D kao alternativa biblioteci OpenGL za pristup 3D akceleracijskom hardveru,• DirectDraw za pristup ekranu kao dvodimenzionalnoj video memoriji, DirectSound za pristup zvučnoj kartici na niskom nivou, DirectInput za komunikaciju s ulaznim uređajima kao što su džojstici i tastature, DirectPlay kao infrastruktura za igre više igrača., DirectShow za prikaz video filmova u igrama i pravljenje medija plejera

Pored ovih API-ja dodana je i OpenGL biblioteka za trodimenzionalni prikaz i uAPI za interakciju između programa Windows API se prvenstveno bavi

interakcijom između Operativnog sistema i aplikacije. Za komunikaciju između Windows aplikacija, Microsoft je razvio skup tehnologija pored glavnog Windows API. Najstarija je bila Dynamic Data Exchange (DDE), nakon nje Object Linking and Embedding (OLE) i dalje Component Object Model (COM).

36 Upravljanje procesima

2 Upravljanje procesimaOperativni sistem omogućava izvršavanje korisničkih programa.

2.1 ProcesiRani računariski sistemi nisu omogućavali izvršenje više od jednog programa

istovremeno. Ovaj program je imao potpunu kontrolu nad sistemom i pristup svim resursima. U današnje vrijeme, računarski sistemi dozvoljavaju istovremeno prebacivanje više programa u memoriju i njihovo konkurentno izvršavanje. Prebacivanjem CPU između procesa, odnosno programa u izvršenju, operativni sistem postaje efikasniji. Centralni koncept u svakom operativnom sistemu je proces: apstrakcija jednog aktivnog programa.

2.2 Koncept procesaModerni računari mogu istovremeno raditi više stvari istovremeno. Računar može

čitati sa diska i prikazati tekst na monitoru ili printeru dok neki korisnički program radi. U multitasking sistemu CPU prelazi sa programa na program pri čemu svaki program može računati sa određenim vremenskim intervalom. Preciznije, u svakom trenutku na CPU se izvršava samo jedan program. U vremenskom intervalu od 1 s može biti obrađeno više programa što korisniku daje osjećaj paralelnog rada. Nekad se u ovom kontekstu govori o kvaziparalelnosti da bi se istakla razlika u odnosu na pravu hardversku paralelnost u višeprocesorskim sistemima, gdje dvije ili više CPU dijeli istu memoriju. Proces je program u izvršenju i mora izvršavati sekvencijalno, to znači da se u jednom trenutku na jednoprocesorskom sistemu izvršava samo jedna instrukcija.

Proces je više od programskog koda, on uključuje trenutne aktivnosti prezentirane vrijednošću programskog brojača (program counter) i sadržajem procesorskih registara. Za razliku od procesa koji je aktivan entitet program je pasivan entitet.

2.3 Model procesaU ovom modelu je čitav softver a nekad takođe i operativni sistem organizovan

kao veliki broj sekvencijalnih procesa. Svaki proces ima svoju virtualnu CPU. U realnosti CPU se prebacuje između procesa. Da bi se shvatio sistem lakše je zamisliti veliki broj (kvazi)- paralelnih procesa nego pokušavati zadržati pregled o tome da se CPU prebacuje između programa. Ovo brzo prebacivanje se naziva multiprogramiranje.

Model procesa 37

Slika (a) prikazuje memoriju jednog računara koji paralelno računa 4 programa. Na slici (b) vidimo 4 procesa od kojih svaki ima neovisno upravljanje tokom, i radi nezavisno od drugih. Na slici (c) vidimo napredovanje svih procesa tokom dužeg vremenskog intervala iako je u jednom trenutku aktivan samo jedan proces. Zbog prelaska CPU između procesa brzina kojom proces radi nije jedinstvena i vjerovatno je nije moguće reproducirati kad se isti proces ponovo aktivira. Brzina izvršavanja većine procesa je pod uticajem relativne brzine različitih procesa.

Svaki proces ima tri fundamentalna memorijska dijela:- Programska sekcija koja se ne mijenja i koja sadrži programski kod,- Stek sekcija (engl. steck section) koja sadrži privremene podatke

(parametre za procedura, povratne adrese, lokalne promjenjive),- Sekcija podataka (engl. data section) koja sadrži globalne promjenjive. Proces

obuhvata i vrijednost programskog brojača (engl. program counter).Za realizaciju modela procesa, operativni sistem održava tabelu, koja se

naziva tabela procesa, i koja po procesu ima jednu rubriku. Ova rubrika sadrži informacije o stanju procesa, programskom brojaču, steck pointeru, zauzetosti memorije, stanju njegovih otvorenih podataka, podacima o upravljanju i raspoređivanju i sve druge informacije koje se moraju snimiti kad proces prelazi iz stanja izvršavanja (engl. running) u stanje spreman (engl. ready) ili stanje blokiran (engl. blocked). Tako je svaki proces u operativnom sistemu predstavljen procesnim kontrolnim blokom (PCB- process controle block). PCB je prikazan na slici.

Proces je u operativnom sistemu predstavljen putem podatkovne strukture poznate pod imenom process control block (PCB) ili proces deskriptor. PCB sadrži važne informacije o određenom procesu, direktno ili indirektno:

- Trenutno stanje procesa: ready, running, waiting, i dr.;- Jedinstvenu identifikaciju procesa (ime ili jedinstveni identifikator procesa PID);- Pokazivač na proces roditelj;- Pokazivač na child proces (ako postoji);


- Prioritet procesa (dio koji se odnosi na raspoređivanje CPU);- Pokazivač koji pokazuje na memoriju procesa;- Područje registara;- Informacije o memoriji procesa;- Lista otvorenih datoteka;- Status zauzetih ulazno-izlaznih resursa;- Procesor na kome radi (ako ima više procesora).PCB je određen skladišni prostor koji dozvoljava operativnom sistemu lociranje

informacija o procesu. To je struktura podataka koja definiše proces operativnom sistemu.

Kontekst procesa čine podaci koji se čuvaju prilikom oduzimanja procesora, a njih generiše sam hardver. Prelazak CPU na drugi proces zahtjeva snimanje stanja tekućeg procesa i pozivanje snimljenih podataka novog procesa. Kada doće do promjene konteksta (engl. context switch) jezgro snima konetkst starog (tekućeg) procesa u PCB (Process Control Block) i puni sačuvani kontekst procesa koji je raspoređen za rad na CPU.

Stanje procesa može biti novi, spreman, aktivan, čeka, itd.Programski brojač pokazuje adresu slijedeće instrukcije koja za ovaj proces treba

biti izvršena.CPU registri se mijenjaju kada je u pitanju tip ili veličina, zavisno od arhitekture

računara. Ovde se ubrajaju akumulatori, indeksni registri, stek pointeri i registri opšte namjene uključujući i condition-code informaciju.

Informacija o raspoređivanju CPU uključuje prioritet procesa i bilo koje druge parametre karakteristične za raspoređivanje CPU.

Informacija o upravljanju memorijom može uključivati informaciju o vrijednosti baznog i limit registra, tabele stranica zavisno od memorijskog sistema koji se koristi.

Accounting informacija uključuje korišteno CPU vrijeme, realno korišteno vrijeme, vremenske limite, broj procesa itd.

Informacija o statusu U/I: uključuje listu U/I uređaja dodijeljenih procesu, listu otvorenih datoteka itd.

Pomoću tabele procesa može se pojasniti kako nastaje iluzija više paralelnih sekvencijalnih procesa na jednoj mašini sa jednom CPU i više U/I uređaja.

2.4 Pokretanje procesaPostoje četri događaja koje uzrokuju pokretanje jednog procesa:1. inicijalizacija sistema,2. sistemski poziv za pokretanjem procesa kroz neki drugi proces,3. korisnički zahtjev za stvaranjem procesa,4. inicijalizacija batch poslova.Prilikom inicijalizacije sistema pokreće se više procesa. Neke od tih procesa su

procesi koji rade u prvom planu, što znači procesi koji komuniciraju sa korisnicima i završavaju zadatke za njih. Ostali su pozadinski procesi, koji izvršavaju specijalne

Pokretanje procesa 39

funkcije i ne pipadaju određenim korisnicima. Napr. pozadinski proces može biti proces za prijem e-mail poruka, koji uglavnom ništa ne radi i samo prilikom pristizanja e-mail poruke postaje aktivan. Ovi pozadinski procesi se nazivaju demoni (deamons). U UNIX sistem možemo koristiti program ps za prikaz svih aktivnih procesa. Kod Windows sistema kombinacija Ctrl-Alt-Del tipki prikazuje aktivne procese.

Pored stvaranja procesa prilikom inicijalizacije sistema procesi se mogu i kasnije pokrenuti. Često aktivni procesi pokreću sistemske pozive za stvaranje jednog ili više novih procesa. Stvaranje novih procesa je posebno onda korisno kada je moguće izdijeliti posao na više nezavisnih ali povezanih procesa.

U interaktivnom sistemu korisnik pokreće program davanjem komande ili duplim klikom na ikonu. Svaka ovakva akcija pokreće novi proces.

Zadnja situacija u kojoj se pokreće proces javlja se kod batch (grupnog) procesiranja u velikim mainframe računarima. Korisnik prenosi batch posao na sistem. Čim sistem odluči da ima dovoljno sredstava za obradu novog zadatka pokreće novi proces i u okviru njega obrađuje slijedeći zadatak.

2.5 Završetak procesaPrije ili kasnije proces završava na osnovu jednog od sljedećih uslova:1. normalni izlaz (dobrovoljno),2. izlaz sa greškom (dobrovoljno),3. fatalna greška (nije dobrovoljno),4. ubijen (killed) od strane drugog procesa (nije dobrovoljno).Većina procesa završavaju kad su ispunili svoj zadatak. Većina grafički

orijentisanih programa ima mogućnost dobrovoljnog završetka (exit, close, quit).Drugi razlog za završetak može biti jedna značajna greška, napr. ulazni podaci ne

postoje. Treći razlog za završetak je greška prouzrokovana kroz sam proces. Ovo se dešava najčešće zbog programske greške. Kod ovakve greške proces se ne završava pojavom ovakve greške već biva prekinut. Četvrti razlog za završtak je sistemski poziv od strane nekog drugog procesa koji upućuje operativni sistem da terminira neki proces.

2.6 Hijerarhija procesaU nekim sistemima nakon stvaranja child procesa postoji između roditeljskog i

child procesa određena veza. Kad child proces stvara dalje procese stvara se hijerarhija. U UNIX sistemu proces zajedno sa svim child procesima i njihovi child procesima gradi familiju. Nasuprot tome, kod Windows sistema ne postoji procesna hijerarhija, s tim što od verzije Windows 8 postoji hijerarhija grupe procesa koja se zove job.

Sistemskim pozivom fork zahtijeva se kreiranje novog procesa. Kada proces koji se trenutno izvodi pokrene novi proces, pokrenuti proces postaje "dijete" procesa "roditelja" koji ga je pokrenuo. Dijete dobija kopije segmenta instrukcija i segmenta podataka od roditelja. U stvari, pošto se segment instrukcija normalno ne


mijenja, jezgra može uštediti vrijeme i memoriju tako da postavi taj segment kao zajednički za oba procesa (sve dok ga jedan od njih ne odluči inicijalizirati novim programom). Također, dijete nasljeđuje većinu sistemskih podataka od roditelja.

Sistemski poziv wait suspenduje izvršenje pozivajućeg procesa dok neki od procesa djece završi (ili bude zaustavljen za vrijeme praćenja). Ponekad je poželjno da roditelj pričeka da dijete završi. Recimo zanima ga sa kakvim exit kodom je proces dijete završio. Za to služi sistemski poziv wait(). On blokira proces koji ga je pozvao sve dok jedno od njegovih djeteta ne završi. Kada proces dijete završi roditelj preuzme exit kod te obriše proces dijete.

Postavlja se pitanje što ako proces dijete završi sa radom a roditelj ga ne čeka sa wait(). Proces dijete neće nestati jer bi se onda izgubili podaci o tome sa kakvim exit kodom je završio. Tada proces dijete postaje zombie proces i ps će za njega pod STAT ispisati Z. Roditelj procesi trebaju počisti zombije djecu za sobom. Ukoliko proces roditelj završi bez wait poziva njegovu djecu naslijedi init proces (PID=1) koji onda počisti svu zombije djecu koji dobije.

Osim fork i wait još jedna bitna sistemska funkcija je exec(). Pomoću nje proces koji ju pozove prestaje sa izvođenjem trenutnog programa i počinje sa drugim (koji je naveden kao argument).

Postoje tri načina kako može završiti proces: pozivom exit, primitkom signala ili padom sistema (nestanak napajanja ili slično).

2.7 Stanja procesa

Procesi često moraju komunicirati sa ostalim procesima. Jedan proces može kao izlaz dati podatke koje drugi proces koristi kao ulazne podatke. Proces je blokiran ako ne može dalje raditi. Uglavnom se to dešava zbog čekanja na ulazne podatke koji još nisu na raspolaganju. Moguće je da proces bude zaustavljen jer operativni sistem odluči da dodjeli procesor nekom drugom procesu.

Prilikom izvršenja procesa on mijenja stanja. Stanje procesa se definiše trenutnom aktivnošću procesa. Svaki proces može biti u jednom od slijedećih stanja, koja su prikazana na slici.

- New- novi: proces je upravo kreiran.- Running – aktivan (izvršava se): instrukcije se izvršavaju.- Waiting (blocked) – čeka (blokiran): proces čeka na pojavu nekog događaja

kao što je neka U/I operacija.- Ready – spreman: proces čeka da bude dodijeljen procesoru.

Stanja procesa 41

- Terminated – završen: proces je završio izvršenje.Stanja ready i running su slična, u oba stanja proces je spreman za rad, s tim da mu

u stanju ready CPU nije na raspolaganju. Stanje blokiran (waiting, blocked) se razlikuje po tome što proces ne može raditi čak i kad CPU ne bi imala ništa drugo raditi, zato što on čeka na neki vanjski događaj. Kao što vidimo osim kreiranja i završavanja procesa postoje četri moguća prelaza između stanja procesa.

1. Kad proces primjeti da dalje ne može raditi, jer čeka na neke ulazne podatke ili na U/I operaciju, dolazi do prelaza iz stanja running u stanje waiting. U nekim sistemima proces mora pozvati sistemski poziv block ili pause da se može naći u ovom stanju. U Unix sistemu se proces automatski blokira kad čita iz pipe-a ili specijalnih podataka i ne nalazi tamo nikakve podatke.

2. Prelaze iz stanja ready u running završava raspoređivač procesa (engl. scheduler), dio operativnog sistem, a da proces sam to i ne primjećuje.

3. Jednako kao kod prethodnog prelaza, prelaz iz stanja running u ready završava raspoređivač procesa (engl. scheduler), dio operativnog sistem, a da proces sam to i ne primjećuje.

4. Prelaz iz waiting u ready se dešava nakon nekog vanjskog događaja na koji je proces čekao. U slučaju da u tom trenutku ni jedan drugi proces nije aktivan pokreće se i prelaz iz ready u running i proces dolazi u aktivno stanje. U suprotnom, proces čeka u stanju ready dok ne dođe na red.

2.8 Prošireni dijagram stanja procesa

U nekim operativnim sistemima postoji mogućnost privremenog prekida izvršenja procesa (engl. suspend) – proces prestaje da se takmiči za resurse. Izvršenje procesa se može suspendovati samo u stanjima wait i ready tako nastaju dva dodatna stanja: suspended- ready (suspendovan u stanju čekanja na procesor) i suspended-wait (suspendovan u stanju čekanja na resurs).


Na proširenom dijagramu stanja se sada nalaze nove tranzicije:- ready - suspended ready: Ovaj prelaz se dešava kada je previše procesa u stanju

ready, treba izbjeći zastoj pa korisnik eksplicitno suspenduje proces.- wait - suspended wait Situacija je slična kao u prethodnom slučaju samo je

proces bio u stanju wait.- suspended wait – suspended ready: Ovaj prelaz se dešava kada se resurs

neophodan za dalje izvršenje procesa oslobodi ali proces je i dalje suspendovan.- suspended ready - ready: Ovaj prelaz se dešava na eksplicitni zahtjev

korisnika, proces je odmrznut i dovodi se na kraj reda čekanja na procesor.- suspended wait – wait: Ova tranzicija se dešava kada je proces odmrznut ali

resurs neophodan za njegovo izvršenje nije oslobođen. I ovaj prelaz je moguća samo na eksplicitan zahtjev korisnika.

Neki procesi pokreću programa kojima se upravlja kroz komande koje unosi korisnik. Drugi procesi su dio sistema. Slika prikazuje jedan model u kome je najniži sloj operativnog sistema raspoređivač (scheduler) iznad koga leži veliki broj procesa. Čitava obrada prekida i podaci koji se odnose na pokretanje i zaustavljanje procesa, skriveni su u bloku označenom sa scheduler – raspoređivač procesa.

2.9 Implementiranje procesaZa realizaciju modela procesa, operativni sistem održava tabelu, koja se

naziva tabela procesa, i koja po procesu ima jednu rubriku. Ova rubrika sadrži informacije o stanju procesa, programskom brojaču, pokazivaču steka, zauzetosti memorije, stanju njegovih otvorenih podataka, podacima o upravljanju i raspoređivanju i sve druge informacije koje se moraju snimiti kad proces prelazi iz stanja running u stanje ready ili blocked.

2.10 Raspoređivanje procesaCilj multiprogramiranja je da postignemo da je u sistemu uvijek neki proces

aktivan kako bi maksimizirali iskorištenost CPU. Cilj diljeljnja vremena je prebacivati CPU između procesa tako često da korisnik može interaktivno komunicirati sa svakim aktivnim programom. Za jednoprocesorski sitem uvijek će samo jedan proces biti aktivan. Ako imamo više procesa ostali će morati čekati sve dok im CPU ne bude dodijeljena.

2.11 Redovi raspoređivanja (engl. scheduling queues)Kada proces uđe u sistem stavlja se u red poslova (zadataka). Ovaj red se sastoji

od svih procesa u sistemu. Procesi koji se nalaze u glavnoj memoriji su

Redovi raspoređivanja (engl. scheduling queues) 43

spremni i čekaju na izvršenje, smješteni su u listu označenu kao ready queue. Postoje i drugi redovi u sistemu. Lista procesa koji čekaju na neki uređaj se zove device queue. Svaki uređaj ima svoj vlastit red. Slika prikazuje ready queue i različite device queue.

Uobičajen način predstavljanja kada se govori o raspoređivanju procesa je dijagram redova kao što je prikazano na slici.

Svaki pravougaonik predstavlja red. Prisutni su dva tipa redova, red procesa koji su spremni za izvršenje na procesoru (ready queue) i redovi za uređaje. Kružna polja predstavljaju resurse koji služe redovima a strelice nam prikazuju tok procesa u sistemu. Kada je proces aktivan jedan od slijedećih događaja može nastupiti:

- ostati bez procesora kada mu istekne vremenski kvantum,- napraviti novi proces i čekati u blokiranom stanju da se novi proces izvrši,- ostati bez procesora kad se dogodi prekid,


- postaviti U/I zahtjev, nakon čega se prebacuje u red čakanja na ulazno-izlazni uređaj, tj. postaje blokiran.

2.12 RaspoređivačiProces se tokom svog života u sistemu pomjera između različitih redova.

Zadatak operativnog sistema je da ne neki način u svrhu raspoređivanja i dodjeljivanja resursa izabere neki proces. Ovo vrši raspoređivač (engl. scheduler). U batch sistemu često je više procesa nego što može biti izvršeno odmah. Ovi procesi se tipično prebacuju na disk gdje se čuvaju do kasnijeg izvršenja. Dugoročni (engl. long-term) raspoređivač poslova izabira proces, puni ga u memoriju za izvršenje. Kratkoročni raspoređivač poslova (engl. short-term scheduler) bira između procesa koji su spremni za izvršenje i dodjeljuje CPU jednom od njih. Osnovna razlika je u frekvenciji rada ova dva raspoređivača.

2.13 Promjena konteksta (engl. context switch)Prebacivanje CPU na drugi proces zahtjeva snimanje stanja starog procesa i

pozivanje snimljenog stanja novog procesa. Ovaj zadatak se zove promjena konteksta. Vrijeme potrebno za promjenu konteksta veoma zavisi od hardverske podrške. Ono podrazumjeva, najjednostavnije rečeno, pomjeranje pokazivača na trenutni skup registara. Ukoliko ima više aktivnih procesa nego registara sistem kopira vrijednosti registara u memoriju.

Moderni procesori imaju jedinicu za upravljanje memorijom MMU (engl. memory management unit) koje sprečavaju da neki proces prepisuje adresni prostor drugog procesa. Prebacivanje sa jednog procesa na drugi – promjena konteksta – znači reprogramiranje MMU da pokazuje na drugi adresni prostor i snimanje podataka o procesu i vraćanje podataka o drugom procesu. Svaki proces je izoliran od drugih. Komunikacija između procesa zahtjeva specijalne funkcije koje se zovu signali i pipes. Što više procesa radi sve je veći udio vremena u kome CPU i operativni sistem vrše promjenu konteksta. Može se desiti da se potroši više vremena na promjenu konteksta. Za rješenje ovog problema u neki situacijama uvode se programske niti (engl. threads). Programske niti su kao child procesi, osim što sve programske niti vezane za jedan proces dijele isti adresni porstor. Prednost programskih niti je da se troši manje CPU vremena za prebacivanje između programskih niti zato što nema potrebe za promjenom adresnog prostora. Programske niti mogu lakše komunicirati međusobno zato što dijele isti adresni prostor.

2.14 Windows API funkcije za proceseSistemski pozivi u Windows operativnim sistemima imaju tendenciju velikog broja

parametara i preciznog podešavanja. Za upravljanje procesima najvažnije funkcije su sljedeće:

• CreateProcess(lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,

Windows API funkcije za procese 45

lpCurrentDirectory, lpStartupInfo, lpProcessInformation) -Kreira novi proces. LpStartup info pokazuje na veliku strukturu koja opisuje dimenzije prozora i oznake ulaza/izlaza

• CreateProcessAsUser(hToken, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes, bInheritHandles,dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation) - Kreira novi proces kao drugi korisnik

• ExitProcess(uExitCode) Završava trenutni proces• GetCurrentProcessId () Dobavlja identifikator trenutnog procesa• OpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId) Otvara proces i

dobija njegov rukovatelj• QueryFullProcessImageName( hProcess, dwFlags, lpExeName, lpdwSize)

Saznaje ime procesa iz rukovatelja• TerminateProcess(hProcess, uExitCode) Prekida izvršenje drugog procesa• EnumProcesses(pProcessIds, wArraySize, pBytesReturned) Očitava

identifikatore svih procesaProcese je moguće grupisati u veće jedinice, koje se zovu Job. Uz njihovu pomoč

je moguće npr. Istovremeno prekinuti više procesa. Važnije funkcije za zad s job-ovima su sljedeće.

• CreateJobObject( lpJobAttributes,lpName) -Kreira Job, grupni objekt kojim se može uticati na više procesa

• OpenJobObject(dwDesiredAccess,bInheritHandles, lpName) -Otvara postojeći Job

• AssignProcessToJobObject(hJob, hProcess) - Dodaje proces u Job• TerminateJobObject( hJob, uExitCode) - Prekida sve procese vezane u Job

2.15 Unix funkcije za upravljanje procesimaDizajn Unix sistemskih poziva za pokretanje i kontrolu procesa je daleko

jednostavniji. Funkcije imaju malo parametara. Najvažnije funkcije za rad s pojedinačnim procesima su sljedeće.

• fork(); Kreiraj dijete proces• execl( pcPath, pcArg, ...); Izvrši program iz datoteke• execlp( pcFile, pcArg, ...); Izvrši program iz datoteke• execv( pcPath, pcArgv[]); Izvrši program iz datoteke• execvp( pcFile, pcArgv[]); Izvrši program iz datoteke• waitpid(idPid, piStatus, iOptions); Čekaj završetak procesa• exit(iStatus); Završi trenutni proces• int kill(idPid, iSig); Šalji signal procesu• unsigned int sleep(uiSeconds); Spavaj navedeni broj sekundi• int pause(); Čekaj signal• unsigned int alarm(uiSeconds); Postavi alarm za slanje signala


• getpid(); Dobavi identifikacjiju procesa• getppid(); Identifikacija roditeljskog procesa

Može se pristupati i grupama procesa koristeći neke od sljedećih sistemskih funkcija.

• setpgid(iProcessId, iProcessGroup); Premješta proces u grupu procesa• getpgid(iProcessId); Vraća grupu procesa za proces• getpgrp(void); Vraća grupu procesa za trenutni proces• int kill(iProcessGroup, iSignal); Šalje signal grupi, ID grupe mora biti

negativan broj

2.16 Programske niti (engl. threads)U tradicionalnim operativnim sistemima svaki proces ima vlastiti adresni

prostor i nit izvođenja instrukcija. Bez obzira na to često je poželjno više niti u kvazi-paraleno pokrenuti u istom adresnom prostoru.

2.17 Model nitiProcesi koji su razmatrani bazirani su na dva nezavisna koncepta: grupiranje

resursa i izvršenje. Jedan način gledanja na procese je kroz grupiranje zajedničkih resursa. Proces ima adresni prostor koji sadrži programski tekst i podatke kao i druge resurse. Programka nit je osnovna jedinica korištenja CPU. Programske niti se ponekad nazivaju laki (lightweight) proces LWP, ona ima svoj programski brojača, skupa registara i stek prostora. On dijeli sa svojom partnerskom niti kodnu sekciju, sekciju podataka, resurse operativnog sistema. Nit i proces su različiti koncepti i moraju se tretirati odvojeno. Procesi grupiraju resurse, niti su osnovni entiteti koji se izvršavaju na CPU.

Niti proširuju model procesa za mogućnost višestrukih izvršenja u istom okruženju, sa visokim stepenom nezavisnosti. Više niti koje su aktivni paralelno u jednom procesu je analogno sa više procesa koji su aktivni na jednom računaru. U prvom slučaju niti dijele adresni prostor, otvorene datoteke i druge resurse. U drugom slučaju procesi dijele fizičku memoriju, diskove, printer i druge resurse. Zato što niti imaju neke osobine procesa poneka se zovu lightweight procesi. Termin višestruke niti (multithreading) se koristi da opiše situaciju pri kojoj se dozvoljava više niti unutar procesa.

Slika (a) prikazuje tri tradicionalna procesa. Svaki proces ima svoj adresni prostor i nit izvršenja instrukcija. Na slici (b) vidimo jedan proces sa tri niti. Iako u oba slučaja imamo tri niti, na slici (a) svaka radi u drugom adresnom prostoru dok na

Model niti 47

slici (b) one dijele jedan adresni prostor. Ova slika nam prikazuje kako radi multiprogramiranje procesa.

Prelaskom između različitih procesa sistem stvara iluziju odvojenih sekvencijalnih procesa koji rade paralelno. Multithreading radi na isti način. CPU se prebacuje između različitih niti stvarajući iluziju niti koji rade paralelno ali na sporijoj CPU nego što je realna. Različite niti u procesu nisu toliko nezavisne kao različiti procesi. Sve niti imaju isti adresni prostor što znači da dijele i iste globalne varijable. S obzirom da jedna nit može pristupiti svakoj memorijskoj adresi unutar adresnog prostora, on može čitati ili pisati ili potpuno obrisati stack druge niti. Nema zaštite između niti, jer nije moguća i nije potrebna. Za razliku od različitih procesa koji mogu biti od različitih korisnika, proces uvijek posjeduje jedan korisnik, koji je vjerovatno kreirao višestruke niti izvršenja. Osim dijeljenja resursa, dijele i otvorene datoteke, child procese i signale kao što je prikazano na slici. Zato je organizacija na prethodnoj slici (a) korištena kad procesi nisu povezani dok je na slici (b) odgovarajuća kad su niti u stvari dio istog posla i aktivno i blisko sarađuju.

Resursi karakteristični za proces Resursi karakteristični za programsku nitAdresni porstor Programski brojačGlobalne varijable RegistreOtvorene datoteke StekChild procese StanjeAlarmiSignali i signal handleriAccounting informacije

Elementi prve kolone su karakteristični za proces, a druge kolone za niti. Npr. ako jedna nit otvori datoteku, datoteka je vidljiva ostalim nitima u procesu i oni je mogu čitati i upisivati. Kad bi svaka programska nit imala svoj adresni prostor, otvorene datoteke, alarme, i dr to bi bio odvojen proces.

Sa konceptom niti je mogućnost da višestruke niti izvršenja, dijele skup resursa tako da mogu zajedno blisko raditi, prilikom izvršavanja nekih zadataka.

Kao i tradicionalni proces sa samo jednom niti, programska nit može biti u jednom od nekoliko stanja: new, running, blocked, ready, ili terminated. Aktivna nit trenutno ima CPU. Blokirana nit čeka na neki događaj koji će je deblokirati. Npr. kada nit izvodi sistemski poziv za čitanje sa tastature, blokiran je dok se unese nešto na tastaturi. Nit može čekati na neki vanjski događaj da je odblokira ili na neku drugu nit. Prelasci između stanja niti su isti kao između procesa. Značajno je shvatiti da svaka nit ima svoj vlastiti stek, kao što je prikazano na slici. Svaki nit poziva različite procedure i ima različitu izvršnu istoriju i zato joj je potreban vlastiti stek.


Kada je prisutan multithreading, proces normalno započinje sa jednom niti. Ova nit ima sposobnost da kreira nove niti koja automatski radi u adresnom prostoru niti koja je kreira. Ponekad niti grade hijerarhiju, sa roditelj - child odnosom. Kreiranje i terminiranje niti su slični kreiranju i terminiranju procesa.

Za niti je značajno da mogu dobrovoljno predati CPU s obzirom da nema dijeljenja vremena tako da i druge niti mogu raditi. Drugi pozivi dozvoljavaju nitima da čekaju na neku drugu nit da završe posao, da najave da su završili itd.

2.18 Upotreba nitiNakon što smo objasnili šta su niti, moramo objasniti zašto su potrebni.-Osnovni razlog za korištenje niti je da u mnogo aplikacija imamo istovremeno

više aktivnosti. Neke aktivnosti se mogu blokirati s vremena na vrijeme. Sa razlaganjem takvih aplikacija na višestruke sekvencijalne niti koje rade kvazi-paralelno, programski model postaje jednostavniji. Ovaj argument smo sreli već ranije kod procesa. Sa nitima dodajemo novi element: mogućnost da paralelni entiteti dijele adresni prostor i sve svoje podatke. Ova mogućnost je od velikog značaja za neke aplikacije.

-Drugi argument za uvođenje niti je taj što oni nemaju resursa vezanih za sebe tako da ih je lakše kreirati a i uništiti u odnosu na procese. U mnogim sistemima kreiranje niti ide 100 puta brže u odnosu na kreiranje procesa.

-Treći razlog u korist niti je takođe vezan za performanse. Ukoliko imamo niti koji dozvoljavaju preklapanje aktivnosti, to ubrzava aplikacije. Konačno, niti su korisne u sistemu gdje postoji više CPU-a, gdje postoji realni paralelizam.

Kao prvi primjer razmotrimo obradu teksta. Jedan broj programa za obradu teksta prikazuje dokument na ekranu formatiran onako kako će biti prikazan na papiru. Prelom stranice i prelazak u novi red se nalazi na korektnoj i finalnoj poziciji tako da korisnik može pregledati i promijeniti dokument ako je potrebno. Pretpostavimo da korisnik piše knjigu. Za autora je jednostavnije da drži čitavu knjigu u jednoj datoteci, da bi mu bilo jednostavnije da pretražuje po temama, izvodi generalne promjene itd. Alternativa je da je svako poglavlje odvojena datoteka. Međutim držanje svih poglavlja i potpoglavlja u posebnim datotekama nema smisla kad se moraju uraditi globalne promjene na nivou knjige, s obzirom da bi tad trebalo editovati stotine datoteka.

Upotreba niti 49

Razmotrimo sada šta se desi kada korisnik izbriše jednu rečenicu sa prve strane dokumenta od 800 strana. Recimo da nakon te promjene korisnik želi napraviti drugu promjenu na stranici broj 600, te ukucava komandu koja govori programu da ide na stranicu 600. Program je sad primoran da ponovo formatira sve do 600 strane da bi mogao znati šta se tačno nalazi na toj stranici. Vjerovatno će doći do kašnjenja u izvršenju što dovodi do nezadovoljstva korisnika.

Zamislimo da je program za obradu teksta napisan kao program sa dvije niti. Jedana nit komunicira sa korisnicima, a druga vrši formatiranje u pozadini. Čim je rečenica izbrisana sa stranice 1 interaktivna nit kaže niti za ponovno formatiranje da formatira cijelu knjigu. U međuvremenu interaktivna nit nastavlja da osluškuje tastaturu i miša i odgovara na jednostavne komande kako što je scrolling stranice 1, dok u pozadini radi druga nit. Sa malo sreće ovo formatiranje će biti završeno prije nego što korisnik zatraži da vidi stranicu 600, tako da ona istog trenutka može biti prikazana.

Zašto ne dodati treću nit? Mnogi programi za obradu teksta imaju mogućnost automatskog snimanja podataka na disk svaki par minuta da bi zaštitili korisnika od gubitka podataka koji mogu biti prouzrokovani padom programa, sistema ili nestankom struje. Treća nit se može brinuti za disk backup bez mješanja sa prve dvije niti. Situacija sa tri niti je prikazana na slici.

Kad bi program bio sa jednom niti, uvijek kad bi se pokrenuo disk backup, komande sa tastature ili miša bile bi ignorisane sve dok se backup ne završi. Korisnik bi imao program loših performansi. Alternativno komande sa tastature i miša mogu prekinuti disk backup dozvoljavajući dobre performanse ali vodeći komplikovanom programu kojim se upravlja pomoću prekida. Sa tri niti programski model je mnogo jednostavniji. Prva nit samo komunicira sa korisnikom. Druga nit reformatira dokument kada mu je to naloženo. Treća nit periodično upisuje sadržaj RAM-a na disk.

Treba biti jasno da tri odvojena procesa ne bi funkcionisala ovdje pošto sve tri niti operišu na istom dokumentu. Time što imamo tri niti umjesto tri procesa, oni dijele istu memoriju i zato svi imaju pristup dokumentu koji se edituje.


Analogna situacija postoji kod mnogo drugih interaktivnih programa. Na primjer program za tabelarno proračunavanje je program koji dozvoljava korisniku da uređuje matricu gdje su neki od elemenata podaci koje obezbjeđuje korisnik. Drugi elementi su bazirani na unesenim podacima i izračunati pomoću formula. Kada korisnik promjeni jedan element mnogo drugih elemenata se ponovo moraju računati. Ako imamo pozadinsku nit za to računanje, interaktivna nit može dozvoliti korisniku i dodatne promjene dok se računanje odvija u pozadinu. Slično kao u prethodnom primjeru, treća nit se može brinuti za periodični disk backup.

Sada razmotrimo drugi primjer gdje su programske niti korisne: server za World Wide Web site. Zahtjevi za stranicama dolaze na server i zahtijevane stranice se šalju klijentima. Kod većine Web sajtova, obično postoje stranice kojima se češće pristupa. Web serveri koriste ovu činjenicu da poboljšaju performanse, čuvanjem ovakvih stranica u glavnoj memoriji da bi eliminisali potrebu da se one uzimaju sa diska. Takva kolekcija se zove cache i koristi se u mnogim drugim kontekstima.

Jedan način za organizaciju servera je prikazan na slici. Ovdje imamo jednu nit dispečer koja čita dolazne zahtjeve iz mreže. Poslije pregledanja zahtjeva, dispečer bira praznu (tj. blokiran) radnu nit i prosljeđuje joj zahtjev, moguće upisivanjem pointera na poruku u specijalnu riječ povezanu sa svakom niti. Dispečer onda budi uspavanu radnu nit, prebacujući je iz blokiranog u aktivno stanje.

Kada se worker probudi, provjerava da vidi da li zahtjev može biti zadovoljen Web page keša u koji sve niti imaju pristup. Ako ne može onda započinje read operaciju da dobije stranicu sa diska i on blokira dok ova operacija nije završena. Dok je ova nit blokiran operacijom na disku druga nit je izabran da radi, taj druga nit je vjerovatno dispečer, tako da se završi više posla. Ovaj model dozvoljava serveru da bude konstruisan kao kolekcija sekvencijalnih niti.

Dispečer program se sastoji od beskonačne petlje za uzimanje zadataka i predavanje istih workeru. Kod svakog workera se sastoji od beskonačne petlje koja se opet sastoji od prihvaćanja zahtjeva od dispečera i provjere Web keša, da vidi da li je stranica tu prisutna. Ako je tako ona se dostavlja klijentu i thread blokira aktivnost do novog zahtjeva. Ako nije pribavlja stranicu sa diska dostavlja je

Upotreba niti 51

klijentu i blokira rad čekajući na novi zahtjev. Razmotrimo kako bi Web server trebao biti napisan bez niti.

Jedna mogićnost je da radi kao jedna nit. Osnovna petlja Web servera dobiva zahtjev, pregleda ga i nastavlja do završetka prije uzimanja sljedećeg zahtjeva. Dok čeka na disk, server je prazan i ne obrađuje ni jedan drugi dolazeći zadatak. Ako Web server radi na dodjeljenoj mašini (koja služi samo za tu svrhu) što je najčešće slučaj, CPU je prazna dokWeb server čeka na disk. Rezultat je da puno manje zahtjeva može biti obrađeno. Niti postižu puno bolje preformanse a svaka nit je programirana sekvencijalno na uobičajen način.

Do sad smo vidjeli mogući dizajn za višenitni server i jednonitni server.Niti omogućavaju da očuvamo koncept sekvencijalnih procesa, koji pravi

blokirajuće sistemske pozive i da pored toga postignemo paralelizam. Blokirajući sistemski pozivi (blocking system calls) olakšavaju programiranje a paralelizam poboljšava performanse. Jednonitni server održava jednostavnost blokirajućih sistemski poziva, ali ima lošije performanse.

Proces može biti struktuisan sa ulaznom niti, programskom niti za obradu i izlaznom niti. Ulazna programska nit učitava podatke u ulazni bafer. Nit za obradu uzima podatke iz bafera i obrađuje ih. Izlazna programska nit piše rezultat na disk. Na ovaj način ulaz, obrada i izlaz se mogu dešavati u isto vrijeme.

2.19 Implementacija niti u korisničkom prostoruPostoje dva osnovna načina za implementaciju programskih niti: u korisničkom

prostoru i u jezgru. Pored toga postoji i hibridna implemantacija.Prvi metod je da se paket programske niti postavi potpuno u korisnički prostor.

Jezgro ne zna ništa o njemu. Što se jezgra tiče, to je običan jednonitni proces. Prva i najočiglednija prednost je da programske niti na korisničkom nivou (user-level thread) mogu biti implementirani na operativnom sistemu koji ne podržava programske niti. Većina operativnih sistema su bili u ovoj kategoriji a neki su još uvijek. Sve ovakve implementacije imaju istu generalnu strukturu koja je ilustrirana na slici.


Niti rade na vrhu run-time sistema, koji je kolekcija procedura koje upravljaju nitima. Kada se niti nalaze u korisničkom prostoru, svaki proces treba svoju privatnu tabelu niti da čuva zapis o programskim nitima procesa. Ova tabela je analogna tabeli procesa osim što ona čuva podatke o osobinama niti kao što su programski brojač niti, stek pointer, registri, stanja itd.

Ovom tabelom upravlja run-time sistem. Kada se nit pomjera u aktivno ili blokirano stanje informacija koja je potrebna za ponovni start je smještena u tabeli programski niti, na tačno isti način na koji jezgro smješta informacije o procesima u tabelu procesa. Ako nit uradi nešto što može prouzrokovati da ona bude lokalno blokiran, npr. čekanje na drugu nit u njenom procesu da završi posao poziva run-time sistemsku proceduru. Ova procedura provjerava da vidi da li nit mora biti stavljen u stanje blokiran. Ako je tako snime registre u tabelu niti, traži u tabeli na nit koja je spremna na rad, i u registre puni sa vrijednostima nove niti. Čim su se stack pointer i programski brojač prebačeni, nova nit automatski oživlja. Ako mašina ima instrukciju da snimi sve registre i drugu instrukciju da ih napuni, sve može biti urađenu u nekoliko instrukcija. Preusmjeravanje niti na ovaj način, je brže nego preskakanje u jezgro, i to je značajan argument u korist programskih niti na korisničkom nivou.

Međutim postoji jedna ključna razlika u odnosu na procese. Procedura koja snima stanja niti i raspoređivač su samo lokalne procedure, tako da je pozvati njih efikasnije neko praviti poziv jezgru. Ovo čini raspoređivanje niti veoma brzim.

Programske niti na korisničkom nivou takođe imaju i druge prednosti. Dozvoljavaju svakom procesu da ima svoj algoritam raspoređivanja. Za neke aplikacije na primjer, nit za prikupljanje otpada, plus je to što se ne mora brinuti da je nit zaustavljena u nezgodnom trenutku.

Uprkos boljim performansama, programske niti na korisničkom nivou imaju neke velike probleme. Prvi od ovih je kako je blokirajući sistemski poziv implementiran. Zamislimo da nit čita sa tastature prije nego je pritisnuta neka tipka.

Dozvoliti niti da pravi sistemski poziv je u stvari nedopustivo, s obzirom da bi to zaustavilo sve niti. Glavna prednost korištenja niti je bila dozvoliti svima da koriste blokirajuće pozive, ali da se spriječi da jedna blokirana nit utiče na druge. Teško je vidjeti kako ovaj cilj može biti postignut sa blokirajućim sistemskim pozivima.

Svi sistemski pozivi mogu biti promjenjeni u neblokirajuće (npr. čitanje sa tastature bi samo vratilo 0 bajta ako ni jedan karakter još nije u baferu),ali ovakav zahtjev za promjenama u operativnom sistemu nije atraktivan. Osim toga jedan argument u korist niti na korisničkom nivou je bio da oni mogu raditi sa postojećim operativnim sistemima.

Moguća je druga alternativa u slučaju događaja gdje je moguće unaprjed reći da li će poziv blokirati. U nekim verzijama UNIX-a postoji sistemski poziv select koji može reći da li će doći do blokiranja kod budućeg read poziva. Ako je sigurno da read neće blokirati on se izvodi. Ako je će ovaj poziv biti blokiran on se onda ne izvodi. Umjesto toga se pokreće neka druga nit. Sljedeći put kad run-sistem dobije kontrolu, može ponovo provjeriti je li poziv read sada siguran.

Implementacija niti u korisničkom prostoru 53

Ovaj pristup zahtjeve ponovno pisanje dijelova biblioteke sistemskih poziva, neefikasan je i neelegantan, ali nema puno izbora. Kod postavljen oko sistemskog poziva da se izvrši provjera, zove se jacket i wrapper.

Drugi problem sa nitima na korisničkom nivou je da ako jedna programska nit počne rad ni jedna druga nit u tom procesu neće raditi osim ako prva nit ne prepusti CPU dobrovoljno. Unutar jednog procesa nema prekida na bazi sata, što ne daje mogućnost raspoređivanja na principu da svi dođu na red. Jedno moguće rješenje za niti koje bi vječno radile, je da run-time sistem zahtjeva signal sata (prekid) jednom u sekundi da preda kontrolu, ali i ovo je problematično.

Drugi vjerovatno najteži argument protiv niti na korisničkom nivou je da programeri žele niti upravo u aplikacijama gdje one često blokiraju, kao što višenitni Web server.

2.20 Implementacija niti u jezgruRazmotrimo sada situaciju u kojoj jezgro zna za niti i upravlja njima. Nije

potreban run-time sistem kao što se vidi na slici. Nema tabele niti u svakom procesu. Umjesto toga jezgro ima tabelu programskih niti koja prati sve niti u sistemu. Kad nit želi da kreira ili da uništi postojeću nit, pravi poziv u jezgro, koje onda kreira ili uništava niti tako što obnavlja njihovu tabelu.

Ova tabela niti u jezgru, drži registre niti, stanja, i druge informacije. Informacije su iste kao i kod niti na korisničkom nivou ali se sada nalaze u jezgru a ne u korisničkom prostoru. Ove informacije su podskup informacije koje uređuje jezgro o svojim jednonitnim procesima. Osim toga jezgro uređuje tradicionalnu tabelu procesa da sačuva informaciju o procesima.

Svi pozivi koji bi mogli blokirati niti su implementirani kao sistemski pozivi sa puno većom cijenom nego poziv u run-time sistem proceduru.

Kada nit blokira, jezgro ima mogućnost da pokrene drugu programsku nit iz istog procesa, ako je spremna, ili neku nit iz nekog drugog procesa. Sa nitima na korisničkom nivou, run- time sistem drži aktivnim niti iz vlastitog procesa dok mu jezgro ne oduzme CPU.


Zbog relativno veće cijene kreiranja i uništavanja niti u jezgru, neki sistemi recikliraju svoje programske niti. Kad su niti uništeni označe se kao not runnable, a na strukturu podataka jezgra ne utiče se na neki drugi način. Kasnije kada se nova nit mora kreirati, stara nit je reaktiviran. Recikliranje je takođe moguće kod ta niti na korisničkom nivou ali pošto je thread menadžment overhead značajno manji nema puno razloga da se ovo radi.

Niti u jezgru ne zahtjevaju nikakve nove neblokirajuće sistemske pozive. Osnovni nedostatak je da sistemski pozivi prouzrokuju veće troškove tako da ukoliko se operacije na nitima (kreacija, terminiranje) često javljaju, nastaće veći overhead

2.21 Hibridna implementacijaIstraživani su različiti načini da se kombinuju prednosti niti na korisničkom nivou

sa nitima u jezgru. Jedan način je korištenje programskih niti u jezgru i multipleksiranje korisničkih tredova na neke ili sve niti u jezgru kao što prikazuje slika.

U ovom dizajnu jezgro je svjesno samo programskih niti u jezgru i bavi sa njihovim raspoređivanjem. Neke od ovih niti mogu imati višestruke niti na korisničkom nivou multipleksirana na njima. Ove niti na korisničkom nivou se kreiraju, uništavaju i raspoređuju kao niti na korisničkom nivou u procesu koji je aktivan u operativnom sistemu koji radi bez multithreading mogućnosti. U ovom modelu svaka nit u jezgru ima neki skup niti na korisničkom nivou.

Hibridna implementacija pruža tri načina kako se niti u korisničkom prostoru pridružuju nitima u jezgru.

U modelu više u jednu (engl. Many-to-one), više korisničkih niti se mapira u jednu nit u jezgru. Upravljanje nitima se odvija na korisničkom nivou. Ako neka niti obavi bilo koji blokirajući sistemski poziv, blokiraće se cio proces, tj. sve niti. Samo jedna nit može pristupati jezgru u jednom trenutku. Kod ovog modela ne može se iskoristiti višeprocesorska arhitektura, da se pojedine niti procesa izvršavaju na različitim procesorima.

Model jedna u jednu (engl. One-to-one) je karakterističan za Windows NT, Windows 2000/XP/2003 i OS/2. Svaka korisnička nit se mapira u jednu nit u jezgru. Na ovaj način obezbjeđeno mnogo bolje konkurentno izvršavanje niti, a više niti iz jezgra se mogu izvršavati paralelno na višeprocesorskoj arhitekturi. Mana pristupa je

Hibridna implementacija 55

što mnogi sistemi ograničavaju maksimalan broj niti jezgra, pa pristup nije dovoljno skalabilan.

Model više u više (engl. Many-to-many), znači da se više korisničkih niti mapira se u manji ili isti broj niti jezgra. To je najkompleksniji ali i najkvalitetniji model

2.22 Raspoređivanje aktiviranjaRazličiti istraživači su pokušali da kombinuju prednost niti na korisničkom

nivou (dobre performanse) sa prednostima niti u jezgru (da se ne mora koristiti puno trikova da bi stvari radile). Opisaćemo takav pristup (Anderson et al. (1992)), nazvan raspoređivanje aktiviranja. Sličan rad je razmatran od strane Edler et al. (1988) i Scott et al. (1990).

Cilj raspoređivanja aktiviranja je imitacija funkcionalnosti niti u jezgru ali sa boljim performansama i većom fleksibilnošću koja je obično povezana sa paketima programskih niti implemantiranim u korisničkom prostoru. Posebno, korisničke niti ne trebaju praviti specijalne neblokirajuće sistemske pozive ili provjere da li je sigurno da napravi određene sistemske pozive. Kada nit blokira na sistemskom pozivu treba biti moguće pokrenuti druge niti unutar istog procesa ako postoji spremna programska nit.

Efikasnost je postignuta sa izbjegavanjem nepotrebnih tranzicija između korisničkog prostora i jezgra. Ako nit blokira čekajući na drugu nit da uradi nešto, na primjer, nema razloga da se uključuje jezgro, zato se štedi overhead user-kernel tranzicije. Run-time sistem može blokirati sinhroniziranu nit i pokrenuti novu.

Kada se koristi aktivacija raspoređivanja, jezgro dodjeljuje određen broj virtualnih procesora svakom procesu i pušta da run-time sistem dodjeljuje niti procesorima. Ovaj mehanizam takođe može biti korišten na multiprocesoru gdje virtualni porcesori mogu biti stvarne CPU. Broj virtualnih procesora dodjeljenih procesu je inicijalno jedan, ali proces može zatražiti više i takođe može vratiti procesor ako mu više nije potreban. Jezgro može takođe oduzeti virtualne procesore koji su već dodjeljeni procesima da ih dodjeli procesima kojima su više potrebni.

Osnovna ideja iza ove šeme je da kad jezgro zna da je nit blokirana, jezgro obavještava run- time sistem procesa, prosljeđujući broj niti koja je u pitanju i opis događaja koji se desio. Ovo obavještavanje se dešava tako što jezgro aktivira run-time sistem na poznatoj polaznoj adresi. Ovaj mehanizam se zove upcall.

Jednom aktiviran na ovaj način run-time sistem može izvršiti ponovno raspoređivanje svojih programskih niti, tipično označavajući trenutnu nit kao blokiranu, i uzimajući sljedeću nit sa ready liste, postavljanjem registara i ponovnim startanjem. Kasnije kada jezgro sazna da izvorna nit može ponovo raditi (npr. pipe iz koje je pokušavao čitati sada sadrži podatke) pravi drugi upcall run-time sistemu da ga informiše o ovom događaju. Run-time sistem može sam odlučiti da restarta blokiranu nit odmah ili da ga stavi na ready listu da bi se mogao kasnije pokrenuti.

Kada se pojavi hardverski prekid dok korisnička nit radi, prekinuta CPU prelazi u mod jezgra. Ako je prekid izazvan događajem koji nije od interesa za prekinuti


proces, kada je interapt handler završio, stavlja prekinutu nit u stanje u kome je bio prije interapta. Međutim ako je proces zainteresovan za prekid, prekinuta nit se ne restarta. Umjesto toga, prekinuta nit se suspendira i run-time sistem je pokrenut na virtualnoj CPU sa stanjem prekinute niti na steku. Tad je do run-time sistema da odluči koju će nit pokrenuti na CPU, prekinutu, novi spremni ili neki treći izbor.

Prigovor raspoređivanju aktivacije je fundamentalno oslanjanje na upcall, koncept koji povrjeđuje strukturu slojevitog sistema. U normalnim uslovima sloj n nudi određene usluge koje sloj n+1 može pozvati, ali sloj n ne mora pozvati procedure u sloju n+1. Upcall koncept ne slijedi ovaj princip.

2.23 Pop-Up nitiProgramske niti su često korisni u distribuiranim sistemima. Jedan značajan

primjer je kako se upravlja dolazećom porukom koja traži uslugu. Tradicionalni pristup je imati proces ili nit blokiranu na receive sistemski poziv čekajući na dolazeću poruku. Kad poruka stigne on prihvata poruku i obrađuje je. Međutim, moguć je potpuno drugačiji pristup u kome pristizanje poruke uzrokuje da sistem kreira novu nit koja će se baviti porukom. Takava nit se zove pop- up thread i ilustrovan je na slici.

Ključna prednost pop-up niti ja da pošto su potpuno nove, nemaju nikave istorije (registri, stekovi itd)., koja mora biti pohranjena. Svaka starta nova i identičan je sa ostalim. To nam omogućava brzu kreaciju takve niti. Nova nit je dodjeljen dolazećoj poruci. Rezultat korištenja pop-up niti je da kašnjenje između pristizanja poruke i početka obrade može biti veoma kratko.

Za korištenje pop-up niti potrebno je malo planirati. Na primjer, u kom procesu radi nit? Ako sistem podržava aktivnost niti u kontekstu jezgra, nit može tamo raditi. Aktiviranje pop-up niti u prostoru jezgra je obično lakše i brže nago staviti ih u korisnički prostor. Pop-up nit u prostoru jezgra može lako pristupiti tabelama u jezgru i U/I uređajima, što može biti potrebno za obradu prekida.

2.24 Pretvaranje jednonitnog u višenitni kodMnogo postojećih programa je napisano za jednonitne procese. Konvretovanje

ovih u višenitne je mnogo komplikovanije nego što izgleda na prvi pogled.

Pretvaranje jednonitnog u višenitni kod 57

Za početak, kod niti se normalno sastoji od višestrukih procedura, upravo kao proces. Oni mogu imati lokalne varijable, globalne varijable i proceduralne parametre. Lokalne varijable i parametri ne prouzrokuju probleme ali varijable koje su globalne za nit ali ne i za čitav program prouzrokuju. Ove varijable su globalne u smislu da ih mnoge procedure untar niti koriste, a da ih druge niti ne koriste.

Kao primjer razmotrimo errno varijable korištenu u Unix-u. Kada proces ili nit pravi sistemski poziv koji ne uspjeva, kod o grešci se stavlja u errno. Na slici nit 1 izvršava sistemski poziv access da otkrije ima li dozvolu da pristupi određenoj datoteci. Operativni sistem vraća odgovor u globalnoj varijabli errno. Nakon što se kontrola vratila niti 1 ali prije nego što ima šansu da pročita errno, raspoređivač odlučuje da je nit 1 dovoljno dugo imao CPU i odlučuje da se prebaci na nit 2. Nit 2 izvršava jedan open poziv koji propada, što dovodi do ponovnog upisivanja u errno i access kod niti 1 se gubi zauvijek. Kad nit 1 starta kasnije pročitaće pogrešnu vrijednost i ponašaće se nekorektno.

Različita rješenja ovog problema su moguća. Jedno je da se zabrane globalne varijable potpuno. Koliko god da je ova ideja vrijedna, ona je u konfliktu sa većinom postojećeg softvera. Druga je dodjeljivanje svakoj niti njegove vlastite privatne globalne varijable kao što je prikazano na slici.

Na ovaj način svaka nit ima svoju privatnu kopiju errno i druge globalne varijable tako da se izbjegavaju konflikti. Ustvari ova odluka kreira novo područje, varijable


vidIjive svim procedurama niti uz postojeće područje varijabli vidljivih samo jednoj poceduri ili varijable vidljive svuda u programu.

Međutim pristup privatnim globalnim varijablama je komplikovana, kako većina programskih jezika ima način izražavanja lokalnih i globalnih varijabli ali ne i neke međuforme.

Moguće je odrediti blok memorije za globalne varijable i onda ove kao dodatne operacije predati niti. Iako ovo nije elegantno rješenje ono funkcioniše.

Alternativno bi se mogle uvesti nove bibliotečne procedure za kreiranje čitanje i postavljanje ovih za niti globalnih varijabli.

2.25 Windows funkcije za rad s nitima u korisničkom prostoru

Niti u korisničkom prostoru u Windows API se zovu vlakna. (fiber). Iako su inferiorne nitima u jezgru (thread), uvedene su radi lakšeg prenošenja aplikacija s drugih operativnih sistema ili pravljenje vlastitog algoritma raspoređivanja. Svako vlakno ima svoju proceduru i dobrovoljno poziva takvu proceduru druge niti pozivom funkcije SwitchToFiber. Slijede važnije funkcije za rad s vlaknima.

• CreateFiber(dwStackSize,lpStartAddress,lpParameter) - Kreira objekt vlakna (niti koje raspoređuje korisnički program)

• FiberProc(lpParameter) - Podprogram svakog vlakna• SwitchToFiber(lpFiber) - Prelazi na podprogram vlakna• DeleteFiber(lpFiber) - Uklanja postojeće vlakno

2.26 Windows funkcije za rad s nitima u jezgruSlijedi nekoliko sistemskih poziva Windows-a za raspoređivanje niti u jezgru.• CreateThread(lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter,

dwCreationFlags,lpThreadId) Kreira programsku nit i vraća rukovatelj na nju• ExitThread(dwExitCode) Završava nit koja je pozvala ovu funkciju• GetCurrentThread() Vraća rukovatelj na nit koja je pozvala ovu funkciju• OpenThread(dwDesiredAccess, bInheritHandle, dwThreadId) Uzima

rukovatelj određene niti• ResumeThread(hThread) Nastavlja suspendovanu nit• Sleep (dwMilliseconds) Suspenduje nit na određeno vrijeme• SuspendThread(hThread) Suspenduje navedenu nit• SwitchToThread() Dobrovoljno predaje izvršenje drugoj niti• TerminateThread( hThread,dwExitCode) Prekida navedenu nit

2.27 Posix nitiJezgra sistema Unix porodice su različite unutrašnje arhitekture , pa se niti

implementiraju kao dodatna biblioteka. Ova biblioteka kasnije može biti implementirana da koristi postojeće niti u jezgru, ili ako jezgro ne podržava niti, onda je implementirana u korisničkom prostoru.

Posix niti 59

• pthread_create (pThread, pAttr, pStart_routine,pArg)Kreira nit• pthread_exit (pStatus)

Prekida nit koja je pozvala ovu funkciju i prosljeđuje status nitima koje su se povezale na nju

• pthread_cancel (pThread)Prekida navedenu nit• pthread_attr_init (pAttr)

pthread_attr_destroy (pAttr)Kreira ili uništava objekt s atributim niti• pthread_join (pThreadid,ppStatus)

Čeka da se navedena nit završi, oslobodi njene resurse i nastavi izvršenje trenutne niti

• pthread_detach (pThreadid)Oslobađa resurse završene niti ili najavljuje oslobađanje kada bide završena• pthread_attr_setdetachstate (pAttr, iDetachState)

pthread_attr_getdetachstate (pAttr, pDetachState) pthread_attr_getstacksize (pAttr, pStackSize)pthread_attr_setstacksize (pAttr, iStackSize)pthread_attr_getstackaddr (pAttr, ppStackAddr)pthread_attr_setstackaddr (pAttr, pStackAddr)Postavlja ili čita atribute niti: stanje oslobađanja resursa, veličinu steka i početnu

adresu steka.

60 Raspoređivanje procesora

3 Raspoređivanje procesoraKod multi-programiranja, često imamo situaciju da se više procesa natječe za

procesor u isto vrijeme. Kada ima više procesa u procesorskom redu čekanja (engl. ready queue) i postoji samo jedan raspoloživ procesor, operativni sistem mora odlučiti koji od proces da pokrene, odnosno da ga dovede na procesor. Dio operativnog sistema koji pravi ovaj izbor se naziva raspoređivač (engl. scheduler). Pri tome raspoređivač koristi algoritam koji ćemo zvati algoritmom raspoređivanja.

Raspoređivanje se odnosi i na procese i na thread-ove. U početku, govorimo o raspoređivanju procesa a kasnije razmotrićemo neka pitanja u vezi raspoređivanje thread-a.

3.1 Uvod u raspoređivanjeU ranim danima, kod batch sistema, sa ulazom u obliku programa na

magnetnoj traci, algoritam raspoređivanja je bio veoma jednostavan: samo izvrši sljedeći job na traci. Kod sistema sa raspodijeljenim vremenom (engl. timesharing sistems), algoritam postaje znatno kompleksniji, jer postoji više korisnika koji čekaju da budu usluženi. Takođe može biti jedan ili više batch procesa. Na personalnom računaru možete pomisliti da samo ima jedan aktivan proces. Međutim, postoje često pozadinski job-ovi, takvi kao što su deamon-i za prijem i slanje elektronske pošte.

3.2 Redovi čekanja procesa

Većina raspoređivača odabira proces koji će doći na red za izvršenje gledajući procese raspoređene u neku dinamičku strukturu, kao što su ulančane liste, stabla ili tablice. Elementi tih struktura su kontrolni blokovi procesa ili pokazivači na njih. Te strukture su redovi čekanja.

Stanja procesa i njihovi prelazi se mapiraju u prebacivanje kontrolnog bloka procesa u odgovarajući red čekanja.

Redovi čekanja procesa 61

Tako na primjer, spremni procesi za izvršenje ulaze u red čekanja spremnih procesa (engl.ready queue). Ovaj red čekanja može biti uređen kao ulančana lista. Zaglavlje reda čekanja spremnih procesa sadrži pokazivače na prvi i posljednji PCB u listi. Svaki PCB ima pokazivač koji ukazuje na sljedeći proces u redu čekanja spremnih procesa. Pored ovog reda, postoje i drugi redovi čekanja, poput reda čekanja za Ulaz/izlaz (engl. I/O Queue), reda čekanja na završetak procesa, reda čekanja na slobodnu memoriju itd.

3.3 Ponašanje procesaGotovo svi procesi se naizmjenično izvršavaju sa U/I zahtjevima, kao što je to

prikazano na slici 4.1. Tipično, procesor izvršava proces izvjesno vrijeme bez zaustavljanja, a onda, recimo, izda se sistemski poziv za čitanje ili pisanje datoteke. Kada se sitemski poziv završi, procesor nastavlja sa izvršavanjem jer mu treba još podataka, itd. Primjetimo da se neke ulazno izlazne aktivnosti računaju kao izvršavanje na procesoru. Na primjer, procesor kopira bite u video RAM da bi ažirirao ekran; ovo nije U/I jer je procesor aktivan. U/I, u pravom smislu, je kada proces ulazi u stanje blokiranja čekajući na eksterni uređaj da završi svoj posao.

Izvršavanje na procesoru se smjenjuje sa periodima čekanja na U/I. (a) CPU-vezani procesi. (b) U/I-vezani procesi.

Važno je primjetiti na slici, da neki procesi kao što je prikazano pos 1.a, troše većinu njihovog vremena na procesoru, dok drugi, tako kao što su prikazani na slici 1.b, troše većinu vremena čekajući na izvršenje U/I operacija. Ove prve ćemo zvati “vezani za procesor” a ove druge “vezani za U/I”. Procesi “vezani za procesor”, imaju duga vremena izvršavanja na procesoru i rijetka čekanja na U/I, dok procesi “vezani za U/I” imaju kratka vremena izvršavanja na procesoru, i dakle česta čekanja na U/I.

3.4 Kada rasporediti procesePostoji veliki broj slučajeva u kojima se zahtjeva raspoređivanje. Prvo,

raspoređivanje se zahtjeva u dva slučaja:1. Kada proces završi izvođenje,2. Kada se proces blokira na U/I ili na semafor.


U svakom od ovih slučajeva, proces koji se izvršavao na procesoru, prestaje sa svojim izvršavanjem i mora se izabrati sljedeći proces koji će se dovesti na procesor. Postoje tri druga slučaja kada se raspoređivanje obično izvodi, mada logički nije apsolutno potrebno da se uradi tog trenutka:

1. Kada se novi proces kreira,2. Kada se desi U/I prekid,3. Kada se desi prekid sata.U slučaju kreiranja novog procesa, ima smisla da se ponovno preračunaju prioriteti

u ovom trenutku. U nekim slučajevima, proces roditelj će moći zahtjevati različit prioritet procesa dijete. U slučaju prekida koji dolazi od U/I uređaja, ovaj prekid obično znači da je U/I završio svoj posao. Poslije tog prekida, proces koji je bio blokiran može se prevesti u stanje spremnih procesa.

U slučaju prekida sata, to je prilika da se odluči da li se tekući proces izvršava dovoljno dugo. U odnosu kako rade sa prekidima sata, algoritmi raspoređivanja se mogu podjeliti u dvije kategorije. Kod non-preemptive algoritama raspoređivanja proces se izabere za izvršavanje i pusti se da se izvršava dok se ne blokira (ili zbog U/I ili zbog čekanja na drugi proces) ili dok on dobrovoljno oslobodi procesor (sistemskim pozivom ili završetkom procesa). Kod preemptive algoritma za raspoređivanje izabira se proces za izvršavanje i pusti da se izvršava maksimalno fiksno vrijeme. Ako se još želi izvršavati na kraju tog vremenskog intervala, proces se skida sa procesora i raspoređivač bira drugi proces za izvršenje (ako postoji). Preemptive raspoređivač zahtjeva da se desi prekid sata, pa kada se proces nađe na kraju vremenskog intervala onda se upravljanje procesorom predao raspoređivaču. Ako prekidi sata nisu raspoloživi, nonpreemptive raspoređivanje je jedina opcija.

3.5 DispečerRaspoređivanje procesa se obavlja dok se izvršava programski kod jezgra, obično

pozvan hardverskim prekidom ili sistemskim pozivom. Nakon što kratkoročni raspoređivač odredi koji se naredni proces izvršava, dispečer prepušta procesor tom procesu. Osnovne funkcije su:

• Izmjena konteksta, tj. priprema registara i konfiguracije memorije• Izmjena iz sistemskog u korisnički način rada• Skok na odgovarajuću lokaciju u korisničkom programu

Kašnjenje kod izmjene procesa (engl. Dispatch Latency)predstavlja vrijeme da se zaustavi jedan proces i pokrene drugi. To vrijeme kond nekih algoritama raspoređivanja može biti značajan procent ukupnog rada procesora. Stoga, dispečer, koji predstavlja čisti interni rad treba da bude veoma brz.

Sljedeći primjer iz kernela, pisan u jezicima C i 8086 asembler, nastavnog sistema MTX ilustruje jedan dispečer. Varijabla running sadrži adresu kontrolnog bloka procesa. U njemu jedno polje ima mjesto za čuvanje pokazivača steka. Izmjena konteksta snimi registre na stek, sačuva pokazivač steka i pozove raspoređivač.

Dispečer 63

_tswitch: SAVE: push ax push bx push cx push dx push bp push si push di pushf mov bx,_running ; bx -> proc mov 2[bx],sp FIND: call _scheduler CRESUME: mov bx,_running mov sp,2[bx] ; load sp with proc.ksp popf pop di pop si pop bp pop dx pop cx pop bx pop ax retmain(){ printf("Welcome to the 460 Multitasking System\n"); initialize(); printf("P0 switch to P1\n"); tswitch(); printf("P0 resumes: all dead, happy ending\n");}

int scheduler(){ PROC *p; p = running->next; while (p->status != READY && p != running) p = p->next; if (p == running) running = &proc[0]; else running = p; printf("\n-----------------------------\n"); printf("next running proc = %d\n", running->pid); printf("-----------------------------\n");}

Izmjena konteksta na 386 i jačim procesorima se obavlja znatno brže zahvaljujući task registru. Procesori na PC računarima mogu obaviti izmjenu konteksta jednom


instrukcijom skoka ili poziva podprograma, ako je u opisu segmenta (o tome u 7. lekciji) segment predstavljen kao task segment.

Tada će se snimiti svi registri na lokaciju koju pokazuje skriveni registar TS, u njega upisati nova adresa koja predstavlja adresu skoka i napuniti svi registri sa te adrese. Registri su raspoređeni prema strukturi prikazanoj na slici.

3.6 Kategorije algoritma za raspoređivanjeNije iznenađujuće da se u različitim okruženjima, koriste različiti algoritmi za

raspoređivanje. Ovo proizilazi iz činjenice da različite aplikacione oblasti i različite vrste operativnih sistema imaju različite ciljeve. Drugim riječima, ono što raspoređivač treba da optimizira nije isto u svim sistemima. Četiri značajno različita okruženja su:

1. Pozadinsko obavljanje poslova (engl. Batch)2. Interaktivno3. Okruženje realnog vremena4. Više-procesorsko okruženje

Kategorije algoritma za raspoređivanje 65

Kod sistema koji obavljaju poslove pozadinski, ne postoji korisnička nestrpljivost čekanja brzog odgovora na njegovom terminalu. Kao posljedica ovog, često su prihvatljivi nonpreemptive algoritmi raspoređivanja kao i preemptive algoritmi raspoređivanja sa dugim vremenskim periodima za svaki proces. Ovaj pristup redukuje izmjene procesa na procesoru i na taj način se poboljšavaju performance (jer ima manje internog rada).

U okruženju sa interaktivnim korisnicima, skidanje procesa sa procesora (preemption) je od suštinskog značaja da ne dozvoli jednom procesu da okupira procesor i zabrani servise drugim. Čak iako se proces ne izvršava u petlji, zbog programskih bug-ova, jedan proces može izbaciti sve druge veoma dugo. Skidanje procesa sa procesora je potrebno da se spriječi ovakvo ponašanje.

U sistemima sa realnim vremenom, skidanje procesa sa procesora je prilično slobodno, ponekad ne treba jer procesi znaju da se ne smiju dugo izvršavati, već urade svoj posao brzo i blokiraju se. Razlika sa interaktivnim sistemima je da sistemi realnog vremena izvršavaju programe čija je namjera isporuka podataka drugim aplikacijama. Interaktivni sistemi su opšte namjene i mogu pokretati programe koji nisu kooperativni ili čak maliciozni.

3.7 Ciljevi algoritama za raspoređivanjeU cilju projektovanja novog algoritma za raspoređivanje, potrebno je imati

predođžbe šta dobar algoritam bi trebao da uradi. Neki ciljevi zavise od okoline (batch, interaktivni, ili real-time), ali postoje i neki koji su poželjni u svim slučajevima. Neki ciljevi su prikazani u tabeli ispod.

Neki ciljevi algoritama za raspoređivanjeZa sve sisteme Poštenost – daje svakom procesu pošteno dijeljenje

procesoraProvođenje politike – donesena politika se provodiOdržavanje balansa – održavanje svih djelova

sistema zauzetim

Pozadinski sistemi (engl. Batch systems )

Maksimizira propusnost (engl. Throughput ) job-ova po satu

Vrijeme boravka u sistemu – minimizira vrijeme između početka i završetka procesa

Iskorišćenost procesora – iskorišćenost procesora se održava

Interaktivni sistemi Vrijeme odgovora - brz odgovor na zahtjeveKorisnikova očekivanja – proporcionalna u skladu

sa zahtjevima

Sistemi realnog vremena Ispunjavanje deadline-a ne gubeći podatkePredvidivo izbjegava degradaciju sistema kod

multimedijalnih sistema


U svim okruženjima, poštenost je važna. Procesi koji se mogu porediti bi trebali dobiti i servise koji se mogu porediti. Dajući jednom procesu mnogo više procesorskog vremena nego drugom sličnom procesu, nije pošteno. Naravno, različite kategorije procesa se mogu tretirati različito.

Drugi opšti cilj je održavanje svih djelova procesa zauzetim kada je to moguće. Ako procesor i U/I uređaji mogu raditi cijelo vrijeme, više poslova može biti završeno u jedinici vremena nego u sistemu gdje su komponente nezaposlene. Ako imamo procese vezane za procesor zajedno sa procesima vezanim za U/I u memoriji zajedno, onda je to bolje nego punjenje i izvršavanje procesa vezanih za procesor, i kada oni završe, punjenje i izvršavanje U/I vezanih procesa. Ako se ova strategija koristi, kada se izvršavaju procesi vezani za procesor, oni će se boriti za procesor a disk će biti nezaposlen. Kasnije, kada procesi vezani za U/I uđu u memoriju, oni će se natjecati za disk a procesor će uglavnom biti nezaposlen. Bolje je održavati cijeli sistem zajedno sa pažljivim miješanjem procesa, kako bi iskorisitli nezaposlenosti resursa, u ovom slučaju diska i procesora, i posao završili ranije.

Rukovodioci u računarskim centrima velikih firmi izvršavaju mnogo batch jobova, tipično posmatraju tri mjere da bi vidjeli kako njihov sistem funkcionira: propusnost, vrijeme boravka joba u sistemu, i iskorišćenost procesora. Propusnost predstavlja broj jobova koji se završi u jedinici vremena (recimo 1 satu). Kažemo da je propusnost veća ako se završi 50 jobova u nekom vremenskom period od sistema koji to uradi sa 40 jobova u u istom periodu. Vrijeme boravka u sistemu predstavlja srednje vrijeme boravka procesa u sistemu od momenta kada je ušao u sistem do momenta kada završi svoje izvođenje.

Algoritam za raspoređivanje koji maksimizira propusnost ne smije nužno minimizirati vrijeme boravka u sistemu. Na primjer, za dati skup kratkih i dugih jobova, ako raspoređivač izvršava kratke jobove i nikad ne izvršava duge jobove može postići izvrsnu propusnost (mnogo kratkih jobova u nekom period vremena) ali na račun ogromnih vremena boravka u sistemu za duge jobove. Ako kratki jobovi stižu konstantnim intenzitetom, dugi jobovi se ne mogu nikada izvršiti, dobijajući vrijeme boravka u sistemu beskonačnim dok se postiže visoka propusnost.

Iskorišćenost procesora je važna kod batch sistema jer je na takvim sistemu procesor izuzetno važan. Rukovodioc računskog centra se osjeća krivim ako mu procesor ne radi cijelo vrijeme. Međutim ovo nije tako važna mjera. Koristeći iskorišćenost procesora kao mjeru je slično kao kod formule 1, koliko obrtaja u minuti može da postigne motor.

Za interaktivne sisteme, posebno timesharing sisteme, različiti ciljevi se postavljaju. Jedan od najvažnijih je minimiziranje vremena odgovora, što predstavlja vrijeme između izdavanja komande i dobijanja rezultata. Na personalnom računaru, gdje se izvršavaju pozadinski poslovi (na primjer, čitanje i spašavanje mail-a iz

Ciljevi algoritama za raspoređivanje 67

mreže), korisnički zahtjev za pokretanje programa ili otvaranja datoteke bi trebao imati prednost nad pozadinskim poslovima. Ako imamo da u sistemu interaktivni zahtjevi idu prvi onda se “primjeti” da sistem ima dobar servis.

Sljedeće pitanje bi se moglo nazvati proporcionalnost. Korisnici često imaju mišljenje (ali često netačno) o tome koliko dugo bi trebalo nešto trajati. Kada neki zahtjev, za koji se zna da traje dugo, korisnici to prihvataju, a kada neki zahtjev za koji korisnici znaju da traje kratko, uzima dugo vremena, to iritira korisnike. Na primjer, klikanjem na ikonu za poziv interneta koristeći analogni modem traje 45 sekundi da bi se veza uspostavila i korisnici to prihvataju kao činjenicu, tako je i teško se mjenja. S druge strane, ako klikanjem na ikonu za prekid veze, traje 45 sekundi, korisnik će poslije 30 sekundi biti veoma ljut. Ovakvo ponašanje je zbog činjenice da korisnik doživljava da je uspostavljanje veze brži proces od raskidanja iste. U nekim slučajevima (takav kao što je ovaj), raspoređivač ne može uraditi ništa u vezi vremena odgovora, ali u drugim slučajevima on može, posebno kada postoji kašnjenje zbog lošeg organizovanja redosljeda procesa spremnih za izvršavanje.

Sistemi realnog vremena imaju različite karakteristike u odnosu na interaktivne sisteme, a to znači i različite ciljeve raspoređivanja. Oni se karakterišu činjenicom da rokovi moraju ili bi bar trebali biti postignuti. Na primjer, ako računar kontroliše uređaj koji proizvodi podatke određenim intenzitetom, ne uspije da izvrši proces koji sakuplja podatke može završiti sa gubljenjem podataka. Dakle, glavni zahtjev od sistema realnog vremena je da se poslovi stignu izvršiti na vrijeme, odnosno prije krajnjeg roka kada treba biti završen posao (engl. Deadline).

U nekim sistemima realnog vremena, posebno onih koji uključuju multimediju, predvidivost je važna. Ako se deadline ne postigne, to ne mora biti fatalno ali će doći do degradacije, recimo zvuka. Video ima slične problem, ali je uho osjetljivije nego oko. Da bi izbjegli ovaj problem, raspoređivanje procesa bi trebalo biti jako predvidivo i uobičajeno.

3.8 Raspoređivanje na tri nivoaBatch sistemi dozvoljavaju raspoređivanje na tri različita nivoa, kao što je to

prikazano na slici ispod. Ako jobovi stižu u sistem oni se inicijalno smještaju u ulazni red čekanja smješten na disku.

Raspoređivač koji dozvoljava da jobovi mogu ući u sistem, odlučuje koji od jobova da uvede u sistem. Ostali se drže u ulaznom redu čekanja dok se ne izaberu. Tipični algoritam za upravljanje pristupom sistemu bi mogao posmatrati jobove vezane za procesor i jobove vezane za U/I. Alternativni pristup bi bio da kratke jobove prihvata odmah dok dugi jobovi bi mogli da čekaju. Ovaj pristupni raspoređivač (engl. admission scheduler) drži neke jobove u ulaznom redu čekanja i može da dozvoli jobovima koji dođu kasnije da uđu u sistem ako je to njegov izbor.


Kada se job prihvati da uđe u sistem, za njega se kreira proces i on se može natjecati za procesor. Međutim, moglo bi se desiti da broj procesa je tako veliki da za njih nema mjesta u memoriji. U tom slučaju, neke od procesa treba izbaciti na disk (operacija swap out). Drugi nivo raspoređivanja je odlučivanje o procesima koji trebaju ostati u memoriji a koje bi trebalo držati na disku. Ovaj raspoređivač ćemo zvati raspoređivačem memorije, pošto on odlučuje koje procese će držati u memoriji a koje na disku.

Ova odluka treba da se inicira često da bi dozvolila procesima na disku da dobiju traženi servis. Međutim, pošto je operacija dovođenja procesa sa diska veoma “skupa” (čitaj dugo traje), ove odluke ne bi trebalo da se iniciraju duže od 1 sekunde. Ako se sadržaj glavne memorije izmjenjuje često, veliki iznos diskovne propusnosti se gubi i na taj način se obaraju performance U/I zahtjeva sa diska.

Da bi optimizirali performance u cijelini, memorijski raspoređivač bi mogao željeti da pažljivo odluči koliko procesa želi da ima u memoriji i kakvih procesa. Ova veličina se naziva stepenom multiprogramiranja. Ako on ima informacije o procesima znajući da li je proces vezan za procesor ili za U/I, on može pokušati da održi u memoriji mješavinu i jednih i drugih. Kao gruba aproksimacija, recimo ako neka klasa procesa troši 20% vremena, održavajući pet takvih procesa bi ugrubo mogli zaposliti procesor.

Da bi napravio odluku, memorijski raspoređivač periodično pregledava svaki proces na disku da bi odlučio da li da ga dovuče u memoriju. Među kriterijima koje može koristiti da bi napravio odluku su sljedeći:

1. Koliko je prošlo vremena od trenutka izbacivanja ili ubacivanja procesa u memoriju?

2. Koliko je procesorskog vremena koristio?3. Koliko je veliki proces? (s manjim procesima je lakše raditi)4. Koliko je važan proces?Treći nivo raspoređivanja je preuzimanje jednog od spremnih procesa u memoriju

da bi se izvršio sljedeći. Često se ovaj raspoređivač zove raspoređivačem procesora i on je onaj na koji ljudi misle kada govore o raspoređivaču. Bilo koji pogodan algoritam se može koristiti ovdje i preemptive i nonpreemptive. U nastavku će biti prikazana skupina algoritama vezani za ova tri okruženja.

Raspoređivanje u pozadinskim sistemima 69

3.9 Raspoređivanje u pozadinskim sistemimaPoslije razmatranja opštih pitanja raspoređivanja prelazimo na pojedinačne

algoritme raspoređivanja. U ovom dijelu, razmotrićemo algoritme koji se primjenjuju u batch sistemima. U sljedećem dijelu pozabavićemo se interaktivnim sistemima kao i sistemima u realnom vremenu. Ukažimo i na algoritme koji se koriste i u batch i u interaktivnim sistemima. O ovome će biti riječi kasnije, a sada se fokusirajmo na algoritme koji su samo pogodni za batch sisteme.

3.10 FCFSVjerovatno najednostavniji od svih algoritama za raspoređivanje je

nonpreemptive algoritam FCFS (engl. first-come first-served). Kod ovog algoritma, procesi se pridružuju procesoru u redosljedu njihovih zahtjeva. U osnovi, postoji jedan red čekanja spremnih procesa. Kada se prvi proces kreira u sistemu, on odmah dobije procesor i dozvoljeno mu je da ga drži koliko hoće. Ako drugi procesi zatraže procesor, oni se smještaju na kraj reda čekanja spremnih procesa. Kada se izvršni proces blokira, onda se na procesor dovodi prvi proces iz liste spremnih procesa. Kada blokirani proces postane spreman za izvršavanje (recimo, proces je tražio čitanje datoteke i zbog toga postao blokiran, a kada se čitanje završi on stiče uslove da bude deblokiran), onda se on smješta u red čekanja spremnih procesa.

Na sljedećoj slici prikazana su vremena dolaska i trajanja tri procesa u proizvoljnim vremenskim jedinicama, te Gantov dijagram koji prikazuje kada će se koji proces zaista izvršavati. Zbog dužine procesa P1, procesi P2 i P3 će čekati na izvršenje dosta vremena.

Velika vrijednost ovog algoritma je što se lako razumije i lako programira. Pošteno je u istom smislu kupiti karte za koncert čekajući u redu formiranom na FCFS način. Kod ovog algoritma, povezana lista održava evidenciju o svim


spremnim procesima. Dovođenje procesa na procesor, predstavlja uklanjanje prvog elementa liste iz reda čekanja spremnih procesa. Dodavanje novog procesa predstavlja se dodavanjem na kraj liste. Šta može biti jednostavnije?

Nažalost, FCFS algoritam ima i značajne nedostatke. Pretpostavimo da postoji proces vezan za procesor koji se izvršava 1 sec i mnogo procesa vezanih za U/I koji koriste malo procesorskog vremena ali svaki treba da obavi 1000 operacija čitanja diska da bi završio svoje izvođenje. Proces vezan za procesor se izvršava 1 sekundu a onda čita blok sa diska. Svi drugi U/I vezani procesi sada počnu izvođenje i pokrenu operacije čitanja diska. Kada proces vezan za procesor dobije svoj blok, on se izvrši još 1 sekundu praćen sa procesima vezanim za U/I.

Konačan rezultat je da svaku proces U/I vezan dobija da čita 1 blok u sekundi i to će trajati 1000 sekundi da završi. Kod algoritma za raspoređivanje koji bi skidao procese sa procesora svakih 10 msec, U/I procesi bi završili za 10 sekundi umjesto za 1000 sekundi a da ne degradira performance procesa vezanog za procesor značajno.

Efekat konvoja se javlja kod ovog algoritma ako se procesi povremeno suspenduju, a različitih su profila. Da se ilustruje ovaj efekat, neka se istovremeno izvršava CPU vezani proces (npr. Inverzija matrice) i U/I vezani procesi (npr. čekanja na unos s tastature). Neka ima n-1 job u sistemu koji su U/I vezani i 1 job koji je CPU vezan. I/O vezani jobovi prolaze brzo kroz red spremnih procesa i suspenduju se sami čekajući na U/I. CPU vezani job stiže na početak reda čekanja i izvršava se do završetka. U/I vezani jobovi ponovno se vraćaju u red spremnih procesa i čekaju dok se CPU vezani job ne završi. Pri tome ne rade ništa, jer čekaju na CPU vezani job. Kada CPU vezani job završi, drugi procesi odrade poslove s procesorom i brzo pređu na čekanje U/I ponovno. CPU postaje nezaposlen.

3.11 SJF (Shortest Job First)Sada posmatrajmo drugi, nonpreemptive batch, algoritam koji pretpostavlja da su

vremena izvršavanja poznata unaprijed. Recimo, u osiguravajućoj firmi, može se pretpostaviti sasvim tačno koliko će trajati izvršenje procesa koji obrađuje 1000 zahtjeva, pošto se sličan posao radi svaki dan. Kada nekoliko jednako važnih procesa se nalazi u redu spremnih procesa čekajući da budu pokrenuti, raspoređivač uzima proces koji će se najkraće izvršavati i dovodi ga na procesor. Na slici ispod, imamo 4 procesa A,B, C i D sa vremenima izvršavanja 8, 4, 4, i 4 minuta, respektivno. Ako se počnu izvršavati u ovom redosljedu, ukupno vrijeme boravka za proces A će biti 8 minuta, za B 12 minuta, za C 16 minuta i za D 20 minuta sa srednjom vrijednošću boravka procesa u sistemu od 14 minuta.

SJF (Shortest Job First) 71

Razmotrimo izvršavanje ova 4 procesa koristeći algoritam raspoređivanja SJF, kao što je prikazano na slici pod b). Ukupno vrijeme boravka u sistemu je sada 4, 8, 12, i 20 minuta sa srednjim vremenom boravka od 11 minuta. SJF se može dokazati da je optimalan. Razmotrimo slučaj sa 4 procesa sa vremenima izvršavanja a,b,c i d, respektivno. Prvi proces završava u vremenu a, drugi u vremenu a+b itd. Srednje vrijeme boravka u sistemu je (4a+3b+2c+d)/4. Jasno je da vrijeme “a” doprinosi više srednjoj vrijednosti nego druga vremena, tako da bi on i trebao biti najkraći proces, zatim b, pa c i na kraju d koji ima efekta samo na svoje sopstveno vrijeme boravka. Važno je ukazati na činjenicu da je SJF optimalan samo kada su svi procesi raspoloživi simultano (recimo, svi počinju da se izvršavaju u isto vrijeme). Kao primjer, razmotrimo 5 procesa, od A do E, sa vremenima izvršavanja 2,4,1,1 i njihova vremena dolazaka su 0,0,3,3 i 3. U početku, samo A i B mogu se birati pošto drugi procesi nisu još stigli u sistem. Koristeći algoritam SJF izvršićemo procese u redosljedu A,B,C,D,E, sa srednjom vrijednošću čekanja od 4.6. Međutim, ako ih pokrenemo u redosljedu B,C,D,E,A imaćemo srednju vrijednost čekanje 4.4.

3.12 SRTNPreemptive verzija SJF algoritma predstavljena je algoritmom SRTN (engl.

shortest remaining time next). Kod ovog algoritma, raspoređivač uvijek izabira proces čije je preostalo vrijeme za izvršavanje najkraće. I ovdje, vrijeme izvršavanje treba biti poznato unaprijed. Kada novi proces dolazi u sistem, njegovo ukupno vrijeme se poredi sa vremenom preostalim za tekući proces. Ako novi proces treba manje vremena da završi izvođenje od tekućeg procesa na procesoru, tekući proces se skida sa procesora i novi proces započinje izvođenje. Ova shema dozvoljava novim kratkim procesima da dobiju dobar servis.

3.13 Raspoređivanje u interaktivnim sistemimaU ovom djelu razmatraćemo neke algoritme koji se koriste u interaktivnim

sistemima. Svi oni se mogu koristiti i kod raspoređivača procesora kod pozadinskih sistema. Kod ovih sistema nije moguć raspoređivač na tri nivoa već samo na dva: raspoređivač memorije i raspoređivač procesora. U nastavku se fokusirajmo na algoritme koji se koriste kod raspoređivača procesora.

3.14 Round-Robin raspoređivanjeJedan od najstarijih, najjednostavnijih i najpoštenijih i široko korišćenih

algoritama je round-robin algoritam. Svakom procesu se pridružuje jedan vremenski interval, koji se naziva kvantum, u kome je dozvoljeno procesu da se izvršava. Ako se proces još izvršava na kraju kvantuma, proces se skida sa procesora i dovodi se novi proces na procesor. Ako se proces blokirao ili završio izvođenje prije nego što je kvantum istekao, vrši se izmjena konteksta na procesoru i novi proces može dobiti svoj kvantum. Algoritam Round-robin je jednostavan za implementaciju. Svi raspoređivači treba da održavaju listu procesa koji se izvršavaju,


kao što je to prikazano na slici ispod, pod a). Kada proces iskoristi svoj kvantum, on se postavlja na kraj liste kao što je pruikazano na slici pod b).

Jedino interesantno pitanje kod round robina je dužina kvantuma. Izmjena procesa na procesoru zahtjeva neko vrijeme za rad, koje se odnosi na neke administrativne poslove, punjenje registara i memorijskih pokazivača procesa, ažuriranje raznih tabela i lista, brisanje i punjenje memorijskog keša i sl. Pretpostavimo da izmjena procesa traje 1 msec a uključuje izmjenu memorijskih pokazivača različitih procesa, brisanje i punjenje keša i sl. Pretpostavimo da je kvantum jednak 4 msec. Sa ovim parametrima, poslije 4 msec korisnog rada, procesor mora potrošiti 1 msec na izmjeni procesa. To znači da će 20% procesorskog vremena biti izgubljeno na izmjeni procesa, što pretstavlja značajan gubitak vremena.

Da bi povećali efikasnost procesora, trebalo bi postaviti vrijednost kvantuma na, recimo, 100 msec. U ovom slučaju gubitak vremena na procesoru je samo 1%. Razmotrimo šta će se desiti na timesharing sistemima ako deset interaktivnih korisnika pristisnu tipku CR u isto vrijeme. Deset procesa će se smjestiti u listu spremnih procesa za izvršenje. Ako je procesor prazan, prvi će početi odmah da se izvršava, drugi početi 100 msec kasnije itd. Posljednji treba da sačeka 1 sec prije nego što dobije šansu, pretpostavljajući da svi drugi procesi koriste pune kvantume. Većina korisnika bi primijetila da je odgovor za 1 sec trom.

Drugi faktor je ako se kvantum postavi na dužinu koja je veća od srednjeg vremena koje procesi provode na procesoru, skidanje sa procesora će se rijetko dešavati. Zaista, većina procesa će izvršiti operacije blokiranja prije nego što kvantum istekne uzrokujući izmjenu procesa. Eliminisanjem skidanja procesa sa procesora se povećavaju performance jer se izmjena procesa dešava samo kad je to logički potrebno, a to je u slučaju blokiranja procesa, jer ne može nastaviti, jer je logički vezan za neki događaj.

Zaključak bi se mogao formulisati na sljedeći način: ako se postavlja kvantum veoma malim, to uzrokuje previše izmjena procesa i snižava efikasnost procesora. Ako kvantum postavimo isuviše velikim uzrokuje veoma loš odgovor na kratke interaktivne zahtjeve. Kvantum od 20 do 50 msec je često prihvatljiv kompromis.

3.15 Prioritetno raspoređivanjeRound-robin raspoređivanje pretpostavlja unaprijed da su svi procesi jednako

važni dajući im jednak kvantum. Često, ljudi koji imaju ili rade na računarima sa više korisnika imaju drugačiji pristup ovom problemu. Na univerzitetu, prihvatljiv redosljed bi bio da prvo dekan ima pristup a zatim profesori, sekretarice i studenti. Pokušaj da se eksterni faktori uzmu u obzir dovodi do prioritetnog

Prioritetno raspoređivanje 73

raspoređivanja. Osnovna ideja je jasna: svakom procesu se pridružuje prioritet dok proces koji ima najveći prioritet može da se izvršava.

Čak i na PC sa jednim korisnikom, mogu postajati višestruki procesi, pri čemu su neki važniji od drugih. Na primjer, deamon proces koji šalje elektronsku poštu u pozadini bi trebao imati niži prioritet nego proces koji prikazuje video sadržaj na ekranu.

Da bi spriječili visoko prioritetne procese da se ne izvršavaju beskonačno dugo, raspoređivač smije smanjiti prioritet tekućeg procesa koji se izvršava na svakom prekidu sata. Ako ova akcija prourokuje da njegov prioritet padne ispod prioriteta sljedećeg procesa sa najvećim prioritetom, izmjena procesa će se desiti. Alternativno, svakom procesu se može pridružiti kvantum u kome se može izvršavati. Kada se kvantum u potpunosti iskoristi, sljedeći najoprioritetniji proces se može izvršavati.

Prioriteti se pridružuju procesima statički i dinamički. Na vojnim računarima, procesi koje pokreću generali imaju prioritet 100, pukovnici sa prioritettom 90, majori sa 80, kapetani sa 70, poručnici sa 60, itd. Slično, u komercijalom računarskom centru, gdje se iznajmljuje vrijeme za obradu, visoko prioritetni jobovi bi mogli koštati 100 dolara za 1 sat, srednji prioritet 75 dolara/sat i niski prioritet 50 dolara/sat. Unix ima komandu “nice” koja dozvoljava korisniku da dobrovoljno reducira prioritet svog procesa u cilju da bude “pažljiv” prema drugim korisnicima. Niko nikad ovo ne koristi.

Prioriteti se, takođe, mogu dodjeljivati i dinamički da bi se postigli određeni ciljevi. Na primjer, neki procesu su vezani za U/I i većinu vremena troše čekajući na završetak U/I operacija. Kadgod takav proces zatraži procesor, trebalo bi mu dati procesor odmah, da mu se dozvoli da pokrene sljedeći U/I zahtjev koji se može izvoditi paralelno sa drugim procesom koji se nalazi na procesoru. Čineći da procesi vezani za U/I čekaju dugo na procesor dovodi do činjenice da oni nepotrebno zauzimaju i memoriju jako dugo. Jednostavan algoritam koji će dati dobar servis za procese vezane za U/I je postavljanje prioriteta na 1/f gdje je f dio posljednjeg kvantuma koji je proces koristio. Proces koji je koristio 1 msec od 50 msec će dobiti prioritet 50, dok proces koji je koristio 25 msec prije blokiranja će dobiti prioritet 2 a proces koji koristi cijeli kvantum će dobiti prioritet 1.

Često je zgodno da se grupa procesa nalazi u klasi prioriteta i koristi prioritetno raspoređivanje među klasama ali round-robin raspoređivanje u svakoj klasi. Na slici, ispod, prikazan je sistem sa četiri klase prioriteta. Algoritam raspoređivanja radi na sljedeći način: dok god ima izvršivih procesa u prioritetnoj klasi 4, pokreni svaki proces u klasi za kvantum na round –robin način, i ne brini o klasama nižeg prioriteta. Ako je prioritetna klasa 4 prazna, onda pokreni procese u prioritettnoj klasi 3 na round robin način. Ako su i klase 3 i 4 prazne, onda koristi klasu 2 na round robin način, itd. Ako se prioriteti ne podešavaju dinamičku u skladu sa okruženjem, niže prioritetne klase mogu nikada ne doći na processor (kažemo “gladovati” za procesorom do smrti).


MINIX 3 koristi sličan sistem kao na slici iznad, mada ima šesnaest prioritetnih klasa u osnovnoj konfiguraciji. MINIX 3 stavlja sljedeće procese u najvišu prioritetnu klasu: U/I drivere, i servere, upravljač memorijom, datotečni sistem i mrežu). Inicijalni prioritet svakog procesa je definisan za vrijeme kompiliranja programa. U/I koji dolazi od sporih uređaja može imati niži prioritet od U/I koji dolazi od brzih uređaja ili čak i servera. Korisnički procesi, u principu, imaju niži prioritet nego komponente operativnog sistema, ali svi prioriteti se mogu promjeniti u toku izvođenja.

3.16 Višestruki redovi čekanjaJedan od najranijih prioritetnih raspoređivača je bio CTSS (Corbató et al., 1962).

CTSS je imao jedan problem što je izmjena procesa bila vrlo spora jer se na računaru 7094 mogao držati samo jedan proces u memoriji. Svaka izmjena je značila izbacivanje tekućeg procesa na disk i čitanje novog procesa sa diska. CTSS dizajneri su shvatili da da je efikasnije dati procesu vezanom za procesor veliki kvantum jedanput u neko vrijeme nego da mu se daju mali kvantumi često, da bi redukovali operacije izbacivanja procesa na disk i vraćanje novog procesa sa diska(engl. swaping). S druge strane, dajući svim procesima veliki kvantum bi značio slabo vrijeme odgovora, kao što smo ranije primijetili. Njihovo rješenje je bilo da se postave prioritetne klase. Procesi u klasi najvećeg prioriteta su se izvršavali po jedan kvantum. Procesi u sljedećoj najvišoj klasi su se izvršavali po dva kvantuma. Procesi u sljedećoj klasi su se izvršavali po 4 kvantuma itd. Kad god proces iskoristi kvantum u cijelosti on se premješta u klasu koja je ispod.

Kao primjer, razmotrimo proces koji treba da se izvršava bez prekida 100 kvantuma. Njemu će inicijalno biti dodijeljen jedan kvantum, a onda će biti izbačen. Sljedeći put će dobiti dva kvantuma prije nego što bude izbačen na disk. U sljedećim pokretanjima dobiće 4,8,16,32 i 64 kvantuma mada je trebao samo 37 kvantuma od ukupnih 64 kvantuma da bi završio svoje izvođenje. U ovom slučaju je potrebno samo 7 izbacivanja na disk umjesto 100 sa čistim round robin algoritmom. Štaviše, što proces tone dublje u prioritetnom redu čekanja, on će se izvršavati još manje frekventno, čuvajući procesor za kratke, interaktivne poslove.

Raspoređivanje sa više nivoa sa povratnom spregom(engl. Multilevel Feedback Queue(MFQ) 75

3.17 Raspoređivanje sa više nivoa sa povratnom spregom(engl. Multilevel Feedback Queue(MFQ)

U tehnici usluživanja MQS ne postoji mobilnost procesa između nivoa. To znači da se nadolazeći procesi smještaju u redove čekanja na osnovu unaprijed date klasifikacije i ostaje u ovom redu čekanja dok god postoji.

Kod tehnike raspoređivanja MFQ, prioriteti procesa se može mijenjati na osnovu rezultata korišćenja procesora. Procesi koji zahtijevaju više procesor su niži po važnosti dok procesi koji su vezani za ulaz/izlaz i češće oslobađaju prerano procesor blokiranjem, važnost im se povećava.

Ova tehnika sprečava umiranje procesa i daje procesima koji su vezani za ulaz/izlaz promjene na osnovu kojih se prosljeđuju procesu preklapajući se sa procesima vezanim za procesor. Pokazuje dobre osobine u borbi sa "konvojskim" efektom.

Raspoređivanje među različitim redovima čekanja može se izvesti promjenom dužine ili frekvencije vremenskog odsječka. Raspoređivanje unutar svakog reda čekanja se, takođe, može mijenjati.

Mada ova tehnika raspoređivanje zvuči vrlo zgodno, ona je u sušti vrlo kompleksna. Ovaj tip tehnike raspoređivanje je definisan sa slijedećim parametrima:

· Brojem redova čekanja· metodama za raspoređivanje u svakom redu čekanja· metodom za raspoređivanje između redova čekanja· metodom sa podizanje prioriteta procesu· metodom za smanjenja prioriteta procesu

wewe

3.18 Garantirano raspoređivanjePotpuno različit pristup kod raspoređivanja je da se daju realna obećanja korisniku

o perfromansama. Jedno od realnih obećanja je: ako postoji n korisnika na sistemu, vi ćete dobiti 1/n procesorskog vremena. Slično, u sistemu sa jednim korisnikom sa n procesa koji se izvršavaju, svaki proces bi mogao dobiti 1/n procesorskog vremena.


Da bi kvalitetno obavio svoja obećanja, sistem mora voditi evidenciju kako svaki proces koristi procesor od svog nastanka. Sistem zatim izračunava iznos korišćenog procesorskog vremena za svaki proces djeleći ga sa n. Pošto je iznos dato vremena poznat onda se izračunava odnos između vremena provedenog na procesoru i vremena datog procesu za obradu. Ako je odnos jednak 0.5 to znači da je proces koristio samo 50% vremena na procesoru u odnosu na vrijeme koje je mogao koristiti. Algoritam traži proces sa najmanjim odnosom dok njegov odnos se ne promjeni tako da bude nešto viši od najbližeg odnosa drugog procesa.

3.19 Lutrijsko raspoređivanjeBilo bi dobra ideja da obećamo korisnicima da znaju kako bi se njihovi procesi

mogli izvršavati na procesoru, ali je to teško implementirati. Međutim, može se koristiti drugi algoritam da daje slične predvidive rezultate sa puno jednostavnijom implementacijom. Ovaj algoritam se zove lutrijsko raspoređivanje (engl. lottery scheduling) (Waldspurger and Weihl, 1994).

Osnovna ideja je da se procesima daju tiketi za razne sistemske resurse, takve kao što su, recimo procesorsko vrijeme. Kad god odluka o raspoređivanju treba da se napravi, lutrijski tiket se izabira slučajno i proces koji drži taj tiket dobija resurs. Kada se primjeni na raspoređivanje procesora, sistem može imati lutrijski tiket 50 puta u sekundi dok svaki vlasnik tiketa dobija 20 msec procesorskog vremena.

“Svi procesi su jednaki ali su neki više jednaki” – više važni procesi mogu dobiti dodatne tikete da bi povećali svoju šansu za dobitak. Ako postoji 100 tiketa za podjelu, i jedan proces drži 20, onda on će on imati 20% šanse da dobije svaki tiket. Na duže staze, dobiće 20 procenata procesorskog vremena. Nasuprot prioritetnom raspoređivaču, gdje je vrlo teško kazati za process koji ima prioritet 40 šta to znači, ovdje je pravilo jasno: Proces drži dio f tiketa za koje će dobti dio f resursa.

Lutrijsko raspoređivanje ima nekoliko interesantnih karakteristika: Na primjer, ako se pojavi novi process i dobije tikete, do sljedećeg dijeljenja tikete imaće šansu da dobije resurse proporcionalno broju tiketa koje drži. Drugim riječima, lutrijsko raspoređivanje je jako osjetljivo.

Kooperirajući procesi mogu izmjeniti tikete ako oni žele. Na primjer, kada proces klijent pošalje poruku server procesu i onda se blokira, on može dati sve svoje tikete serveru da bi povećao šanse da se server počne izvršavati kao sljedeći proces. Kada server završi, on vraća tikete tako da se proces klijent može izvršavati ponovo.

Lutrijsko raspoređivanje može se koristiti da razrješi probleme koji su teški da se rade sa drugim metodama. Jedan primjer predstavlja video server u kome nekoliko procesa obrađuje video tokove za njihove klijente ali sa različitim intenzitetom. Pretpostavimo da procesi trebaju tokove sa intenzitetima 10, 20 i 25 okvira/sec. Ako alociramo ovim procesima 10,20 i 25 tiketa respektivno, oni će automatski podjeliti vrijeme na procesoru u približno tačnoj proporciji koja je 10:20:25.

Na sljedećoj slici ilustrovano je kako je ovaj algoritam skalabilan. Neka poslovi niskog prioriteta dobijaju po 1 tiket, a poslovi visokog prioriteta po 10 tiketa.

Lutrijsko raspoređivanje 77

Procesa visokog prioriteta

Procesa niskog prioriteta

%CPU za 1 proces visokog prioriteta

%CPU za 1 procese niskog prioriteta

1 1 91 9

0 2 0 50

2 0 50 0

10 1 9,9 0,99

1 10 50 6

3.20 A“Fair-Share Scheduling”Do sada smo pretpostavljali da je svaki proces raspodijeljen na svoj način, bez

posmatranja ko mu je vlasnik. Kao posljedicu ovog pristupa, možemo imati slučaj kada korisnik 1 pokreće devet procesa a korisnik 2 pokreće 1 proces, kod garantiranog raspoređivanja, korisnik 1 dobija 90% procesorskog vremena a korisnik 2 dobija 10% procesorskog vremena.

Da bi spriječili ovu situaciju, neki sistemi uzimaju u obzir ko je vlasnik procesa prije raspoređivanja. U ovom slučaju, svakom korisniku se alocira neki dio procesorskog vremena i raspoređivač dodjeljuje procesorsko vrijeme u skladu sa unaprijed pridruženim vremenom za svakog vlasnika. Ako dva korisnika imaju obećanje da će dobiti 50% procesorskog vremena onda će to i dobiti bez obzira koliko jedan korisnik pokrenuo procesa.

Na primjer, razmotrimo sistem da dva korisnika, kojima je obećano da će dobiti 50% procesorskog vremena. Jedan korisnik ima 4 procesa, A,B,C i D, a korisnik 2 ima samo jedan proces E. Ako se koristi raspoređivanje tipa round-robin, moguća sekvenca raspoređivanja koja će biti u skladu sa zahtjevima korisnika bi izgledala ovako: A E B E C E D E A E B E C E D E ...

Ako je korisniku 1 dato 2 puta više vremena neko korisniku 1 onda bi sekvenca izgledala ovako: A B E C D E A B E C D E ...

Brojne druge mogućnosti postoje i mogu se koristiti u zavisnosti kako ćemo pojam dijeljenja (čitaj “poštenosti”) definisati.

3.21 Raspoređivanje u sistemima realnog vremenaU sistemima realnog vremena, vrijeme igra veoma važnu ulogu. Jedan ili više

fizičkih uređaja koji su izvan računara djeluju na računar, tako da računar mora da odgovori prema njima unutar fiksnog intervala vremena. Na primjer, računar dobija sa CD diska bite, koji dolaze sa uređaja, i mora ih konvertovati u muziku unutar vrlo malog vremenskog intervala. Ako se ne stigne da odgovori unutar pomenutog intervala vremena to bi moglo imati posljedice na zvuk. Drugi sistemi realnog vremena su, recimo, praćenje pacijenta u bolnici u jedinici intenzivne njege,


autopilot u avionu, upravljanje robotom u automatiziranim fabrikama i sl. U svim ovim slučajevima odgovor mora biti na vrijeme, inače neće trebati nikako.

Sistemi u realnom vremenu imaju posebne kriterije koje treba poštovati.Determinizam: Ovaj kriterij govori koliko OS kasni sa odzivom prije potvrde

interapta ili sistemskog poziva. Operacije se obično obavljaju na fiksnom, predefinisanom vremenu, ili s određenim vremenskim intervalima. Dok se u jednoprocesnom sistemu to vrijeme i može znati za specijalne procese, kada se više procesa takmiči za resurse ili procesorsko vrijeme, nijedan OS neće biti deterministički.

Responsivnost: Zajedno s determinizmom određuje vrijeme odgovora na vanjske događaje. Ovo je kritično za sisteme u realnom vremenu koji moraju zadovoljiti vremenske zahtjeve koje daju ljudi, uređaji ili tokovi iz sistema. Ovdje se brine o tome koliko treba nakon potvrde da OS obradi interapt.

Korisnička kontrola: Mnogo šira u sistemima realnog vremena nego kod običnih operativnih sistema. Ovdje je bitno da korisnik može fino da podešava prioritete procesa. Korisnik određuje koji procesi su kritični da se moraju izvršiti na vrijeme ili uopšte ne. U ovim sistemima korisnici mogu postaviti i karakteristike poput straničenja, procesa koji su stalno u memoriji, algoritama disk transfera, prava procesa raznih prioriteta:

Pouzdanost: Ovo je vrlo važno za sisteme u realnom vremenu. Gubitak ili degradacija performansi može imati katastrofalne posljedice, poput finansijskih gubitaka, oštećenja opreme ili gubitka života-

Fail soft operacija: U slučaju pada sistema, sistem treba da padne na takav način da sačuva što više sposobnosti i podataka. Sistem u realnom vremenu je stabilan, ako sistem ispunjava rokove najprioritenijih zadataka, čak i ako neki manje kritični rokovi nisu zadovoljeni

Sistemi realnog vremena su svrstani u dvije kategorije: hard real time sistemi, gdje se krajnji odgovori (engl. deadline) moraju postići, i soft real sistemi, nepostizanje krajnjeg odgovora u predviđenom intervalu je nepoželjna ali ipak tolerantna. U oba slučaja, ponašanje sistema realnog vremena se postiže dijeljenjem programa u jedan skup procesa, čije je ponašanje i predvidljivost poznata unaprijed. Ovi procesi su, po pravilu, kratkotrajni i završavaju u vremenima manjim od 1 sec. Kada se desi eksterni događaj, zadatak raspoređivača je da rasporedi procese na takav način da se vremena krajnjih odgovora mogu postići.

Događaji na koje mora odgovoriti sistem u realnom vremenu mogu se podijeliti na periodične (koji se dešavaju u pravilnim intervalima) i neperiodični (koji se dešavaju nepredvidivo). Računarski sistem treba da je u stanju da odgovori na višestruke periodične tokove događaja. U zavisnosti koliko vremena svaki događaj zahtjeva za obradu, možda se ne može stići da se obrade svi događaji. Na primjer, ako ima m periodičnih događaja, a događaj i se dešava sa periodom Pi i zahtjeva Ci

Raspoređivanje u sistemima realnog vremena 79

sekundi procesorskog vremena da bi obradio događaj, onda se sa ovim opterećenjem može “boriti” ako

U sistemima realnog vremena kod kojih se ovaj kriterij postigne (suma svih pojedniačnih odnosa manja je od 1), se kaže da se mogu raporediti. Na primjer, u soft real time sistemu sa tri periodična događaja, sa periodima 100, 200, i 500 msec respektivno. Ako ovi događaji zahtijevaju 50, 30 i 100 msec procesorskog vremena po događaju, respektivno, sistem ih može rasporediti jer je 0.5 + 0.15 + 0.2 < 1. Ako se doda četvrti događaj sa periodom od 1 sekunde, sistem ih može rasporediti sve dok ovaj događaj ne bude trebao više od 150 msec procesorskog vremena po događaju. U ovi izračunavanjima se podrazumijeva da interni rad kod izmjene konteksta je tako mali da se može ignorisati.

3.22 Kategorije algoritama za raspoređivanje u realnom vremenu

Algoritmi raspoređivanja u sistemima realnog vremena mogu biti statički i dinamički. Statički algoritmi prave odluke o raspoređivanju prije nego se započne raspodjela. Statičko raspoređivanje radi samo kada postoje informacije raspoložive unaprijed o opterećenju potrebnom da se izvrši i da se postignu ispunjenja krajnjih vremena odgovora. Statički algoritmi mogu biti s statičkim tabelama i preemptivnim algoritmima.. Pristupi s statičkim tabelama imaju već ranije definisano kada se koji proces treba izvršavati. Nakon što se izvede statička analiza izvodivih rasporeda, rezultat je raspored koji određuje kada proces mora početi Statički pristup s preemptivnim algoritmima obavi statičku analizu, ali ne pravi raspored. Analiza se koristi za dodjelu prioriteta, pa se koristi prioritetni preemptivni raspoređivač.

Dinamički algoritmi raspoređivanja odluku o raspoređivanju obavljaju u toku rada procesa i takođe se dijele u dvije kategorije, sa planiranjem i s najboljim trudom. Dinamički pristup s planiranjem pri izvršavanju, gledajući zadatke koji su u redovima čekanja generiše raspored koji odredi kada pokrenuti koji zadatak. S druge strane, dinamički pristupi s najboljim trudom ne vrše analizu izvodivosti, nego sistem proba zadovoljiti sve rokove i prekida pokrenute procese čiji je rok istekao ,

Algoritmima raspoređivanja u realnom vremenu treba više informacija, nego algoritmima za raspoređivanje i interaktivnim sistemima. O svakom procesu treba čuvati vrijeme kada je proces spreman, kada mora početi, kada mora završiti, koliko mu treba da uradi posao, zahtjevi resursa, prioritet i raspodjela podzadataka.

3.23 Algoritam najraniji rok prvoU ovom algoritmu, procesi koji se mogu rasporediti se raspoređuju tako da se prije

izvršavaju oni procesi čiji rok završetka dolazi ranije. Algoritam omogućava veći broj procesa da se izvrši u odnosu na statički definisane prioritete. Ali pri velikom


opterećenju, skup procesa čiji uslovi izvršenja neće biti zadovoljeni je teško predvidljiv, što za sisteme u realnom vremenu može biti kobno.

Da se uporedi ponašanje ovog algoritma u odnosu na statičke prioritete, posmatraće se dva periodična procesa A i B, pri čemu A dolazi svakih 20 ms, i svaki odsječak traje po 10 ms, dok B dolazi svakih 50 ms i svaki odsječak traje 25 ms. Rokovi procesa su prije narednog odsječka.

Dijagrami raspoređivanja za prioritetne algoritme gdje je A ili B većeg prioriteta, odnosno kada se koristi algoritam najranijeg rasporeda prvo, izgleda ovako:

3.24 Raspoređivanje monotonom stopomSistemi realnog vremena najčešće koriste algoritam kod koga se kraćim procesima

ili kraćim odsječcima periodičnog procesa dodjeljuje veći prioritet. Pokazano je da za n periodičnih procesa perioda Ti, od kojih svaki traje Ci vremena, a rokovi su jednaki periodu, izvodivost se može izračunati gledajući iskorištenje procesora.

Raspoređivanje monotonom stopom 81

Pošto je Svi zahtjevi za ispunjenje periodičnih poslova fiksnog trajanja s rokom jednakim

periodu se mogu ispuniti kada je iskorištenje sistema za ovakve poslove do 69%. Preostalih 31% se može dodijeliti procesima koji nisu tipa realnog vremena.

3.25 Dijeljenje resursaProcesi treba da dijele resurse da bi komunicirali i obrađivali podatke. Aspekt

multithreading programiranja nije posebno specifičan u sistemima realnog vremena ili embedded sistemima.

U bilo koje vrijeme, kad dva procesa dijele resurs, takav kao memorijski bafer, u sistemu koji koristi raspoređivač baziran na prioritetima, jedan od njih će obično imati veći prioritet. Visoko prioritetni procesi očekuju da budu usluženi što je moguće prije, odnosno čim postanu spremni. Međutim, ako proces sa nižim prioritetom koristi njihov dijeljeni resurs kada proritetniji process postane spreman za izvršenje onda više prioritetni proces mora čekati na process koji ima niži prioritet da završi sa korišćenjem resursa. Kažemo da prioritetniji proces čeka na resurs. Ako ovaj proces se mora izvršiti za neko određeno vrijeme onda se mora iznaći najgori scenario “otključavanja” za sve dijeljene resurse i uzeti u obzir prilikom projektovanja. Ako su kumulativno vremena otključavanja velika, shema dijeljenja resursa mora se ponovno projektovati.

3.26 Prioritetna inverzijaMnogi komercijalni operativni sistemi u realnom vremenu (RTOS – real time

operating system) koriste raspoređivač sa pražnjenjm sa procesora (engl. preemptive). Ovi sistemi pridružuju svakom procesu jednistven nivo prioriteta. Raspoređivač obezbjeđuje da od spremnih procesa koji se nalaze u redu čekanja na processor, proces sa najvećim prioritetom se izabira i dovodi na procesor. Da bi mogao ispuniti ovu funkciju, raspoređivač mora biti u stanju da skine sa procesora, u proces koji ima niži prioritet u toku njegovog izvršavanja.

Zbog toga što procesi djele resurse, događaji koji se dešavaju izvan kontrole raspoređivača mogu spriječiti izvršavanje spremnih procesa visokog prioriteta kad bi trebalo. Ako se ovo desi, proces neće odgovoriti u predefinisanom periodu i doći će do greške. Prioritetna inverzija je termin za scenario u kojem spremni procesi visokog prioriteta ne uspijevaju da se izvrše a trebali bi.

Pravi problem nastaje kada proces srednjeg nivoa prioriteta izbaci sa procesora proces koji je nižeg nivoa prioriteta koji koristi, kažemo drži, dijeljeni resurs na koji proces višeg prioriteta čeka. S obzirom da je proces većeg prioriteta spreman da se izvrši a izvršava se proces srednjeg nivoa prioriteta dolazimo do situacije koja se zove prioritetna inverzija.

Opisana sekvenca događaja je ilustrovana na slici.


Proces niskog prioriteta L i visokog prioriteta H djele isti resurs. Pošto L dođe do resursa, proces H postaje spreman da se izvrši. Međutim, proces H mora čekati na proces L da se završi i oslobodi resurs, dakle on čeka na resurs. Prije nego proces L završi sa resursom, proces M postaje spreman da se izvrši i izbacuje sa procesora proces L. Dok se M izvršava, a možda još procesa tipa M, proces H sa najvećim prioritetom i dalje čeka. Mnoge prioritetne inverzije su bezopasne ili uglavnom uzrokuju kašnjenja procesa koji bi trebali da se izvrše na vrijeme. Ali ponekad se prioritetna inverzija dešava i uzrokuje kritičan rad sistema. Takav događaj se desio na misiji MARS Pathfinder 1997. Ova misija je poznata po kolor slikama visoke rezolucije koje su slane na zemlju.

3.27 Rješenja prioritetne inverzijeIstraživači na ovom problemu okrenuli su se ka dva rješenja: Prvo se naziva

nasljeđe prioriteta kod koje proces sa nižim prioritetom nasljeđuje prioritet procesa visokog prioriteta koji čeka na dijeljeni resurs. Ovo će se desiti čim proces H počne čekati. Ovaj pristup zahtijeva podršku operativnog sistema. Drugo rješenje, tkz. prioritetni vrh, gdje se pridružuje prioritet svakom resursu. Raspoređivač onda prenosi prioritet resursa na proces koji pristupa resursu. Pridruženi prioritet resursu je prioritet korisnika sa najvećim prioritetom plus jedan. Kada takav proces završi posao njegov prioritet ostaje onakav kakav je bio.

3.28 Raspoređivanje u multimedijalnim sistemimaU multimedijalnom svijetu često se koristi video na zahtjev, koji predstavlja

mogućnost da potrošači kod kuće odaberu film koristeći svoje daljinske upravljače televizije (ili miš) i da ga prikazuju na svojim TV-u (ili računaeskom monitoru) na licu mjesta. Video server je snažan računar koji čuva mnoge filmove u svom sistemu datoteka i izvodi ih na zahtjev. Ponekad se mainframe računari koriste kao video serveri, jer je povezivanje, recimo, 1000 velikih diskova na mainframe jednostavno, dok povezivanje 1000 diskova na običan računar ozbiljan problem. Serveri multimedijalnih datoteka (digitalnih filmova), trebaju da reprodukuju datoteke u predvidljivom vremenskom okviru. Najjednostavnija vrsta video servera je onaj koji može podržati prikaz fiksni broj filmova, gdje svi koriste isti broj kadrova u sekundi,

Raspoređivanje u multimedijalnim sistemima 83

video rezolucije, brzinu prijenosa podataka, i druge parametara. Pod ovim okolnostima, jednostavan, ali efikasan algoritam rasporeda je da Za svaki film, postoji jedan proces (ili nit) čiji je posao da čita film iz diska jedan kadar po kadar, a zatim prenosi taj kadar za korisnika. Budući da svi procesi su jednako važni, imaju istu količinu posla po kadru, round-robin raspoređivanje radi posao dobro. Jedini dodatak potreban standardnm algorirmima raspoređivanja algoritama je tajming mehanizam kako bi bili sigurni da svaki proces radi na ispravnoj frekvenciji.

Nažalost, ovaj model se rijetko primjenjuje u stvarnosti. Broj korisnika se mijenja kako gledoci dolaze i odlaze, a veličina okvira se razlikuje divlje zbog prirode video kompresije, dok različiti filmovi mogu imati različite rezolucije. Kao posljedica toga, različiti procesi mogu da rade na različitim frekvencijama, sa različitim obimom posla, i sa različitim rokovima kojima se rad mora biti završen.

Stoga se u ovakvim sistemima koriste algoritmi za raspoređivanje u realnom vremenu. Između dva popularna algoritma, najraniji rok prvo i stopa monotonog rasporeda, ovdje se algoritam najraniji rok prvo pokazuje kao bolji, jer ima bolju propusnost, iako slabiju predvidljivost.

3.29 Raspoređivanje threadovaKada se izvršava nekoliko procesa od kojih svaki ima po nekoliko threadova,

onda postoje dva nivoa paralelizma: procesi i thread-ovi. Raspoređivanje u takvim sistemima se značajno razlikuje u zavisnosti da ili su podržani korisnički thread-i, sistemski kredovi ili obje vrste threadova.

Korisnički threadovi: Pošto kernel nije svjestan postojanja thread-ova, on radi, kao što uvije radi, uzimanjem procesa, recimo A, i davanjem procesora u dužini njegovog kvantuma. Raspoređivač threadova, koji se nalazi unutar procesa A odlučuje koji thread da pokrene, recimo A1. Pošto ovdje nema prekida sata za višestruke thredove, ovaj thread može nastaviti izvršavanje toliko dugo koliko on hoće. Ako iskoristi cijeli procesov kvantum onda će kernel izabrati drugi proces i dati mu procesor.

Kada se proces A na kraju ponovno pokrene, thread A1 će nastaviti izvršavanje. On će nastaviti da troši cijelo dodijeljeno vrijeme procesu A sve dok ne završi. Međutim, njegovo asocialno ponašanje neće imati efekta na druge procese. Oni će kad tad dobiti odgovarajući dio vremena za procesor bez obzira šta se dešava unutar procesa A.


Razmotrimo slučaj kada thread-i procesa A imaju malo posla da izvrše na procesoru, na primjer 5 msec rada unutar 50 msec kvantuma. Kao posljedica ovog, svaki thread se izvršava i po završetku predaje procesor ka raspoređivaču threadova. Ovo bi moglo voditi sekvenci izvršavanja A1, A2, A3, A1, A2, A3, A1, A2, A3, A1, prije nego što kernel ne izvrši izmjenu na proces B. Ovo je ilustrirano na slici (a)

Slika:(a) Moguće raspoređivanje threadova na korisničkom nivou sa 50 msec kvantumom procesa i threadovima koji se izvršavaju u dužini 5 msec.

(b) Moguće raspoređivanje threadova na kernel nivou sa istim karakteristikama kao pod a

Algoritam za rapoređivanje koji se koristi u run/time sistemima može biti bilo koji od onih pomenutih ranije. U praksi, round-robin raspoređivanje i prioritetno raspoređivanje su načešći. Jedino ograničenje je odsustvo sata koji bi poslužio za prekid threada koji se izvršava isuviše dugo.

Threadovi na sistemskom nivou: Ovdje kernel preuzima pojedinačni thread da bi ga izvršio. On ne treba da uzima u obzir kojem procesu thread pripada, ali može ako želi. Threadu se da kvantum i ako ga istroši on se nasilno prekida. Sa kvantumom od 50 msec i thread-om koji se blokira svakih 5 msec, redosljed threadova, za neki period od 30 msec, bi mogao izgledti ovako: A1, B1, A2, B2, A3, B3, što nije moguće sa ovim parametrima i threadovima na korisničkom nivou. Ova situacija je opisana na slici b.

Glavna razlika između threadova na korisničkom nivou i threadova na sistemskom nivou su performase. Izvršavajući izmjenu threada kod korisničkih threadova potrebno je izvršiti puno mašinskih instrukcija. Kod sistemskih threadova zahtjeva se puna izmjena konteksta, promjena memorijske mape, označavanjem keša nevažećim i nekoliko je stepena sporija. S druge strane, kod sistemskih threadova, postoji blokiranje threada na U/I operaciju koja ne blokira cijeli process kao što se to radi kod korisničkih threadova.

Uvod u raspoređivanje procesa kod UNIX-a 85

3.30 Uvod u raspoređivanje procesa kod UNIX-aIneresantno je vidjeti kako izgledaju ove tehnike u jedno stvarnom operativnom

sistemu, takvom kao što je UNIX. Ovakva tehnika raspoređivanja se koristi, sa malim varijacijama, kod AT&T SVR3 i 4.3BSD. Noviji UNIX sistemi koriste nešto složenije pristupe.

PrioritetiRaspoređivanje u UNIX sistemima je bazirano na prioritetima. Priorite procesa

može biti od 0 do 127 pri čemu niži broj označava viši prioritet. Postoje opsezi prioriteta tako da prioriteti od 0-49 predstavljaju prioritete sistemskih procesa. I korisnički i sistemski procesi mogu imati prioritet unutar punog opsega prioriteta. Ovo sprečava da korisnički procesi mogu biti ugroženi sistemskim procesima.

ParametriProcesi variraju priorite raspoređivanja koristeći nekoliko faktora. Ovi faktori su

smješteni u strukturi proc koja sadrži slijedeća polja:· p_pri - tekući prioritet raspoređivanja· p_uspri - prioritet procesa u korisničkom načinu rada· p_cpu - mjera korišćenja procesora· p_nice - korisnički podatak koji govori o važnosti procesaPodizanje prioriteta u sistemskom načinu radaPodatak p_pri predstavlja broj u opsegu od 0-127 koji predstavlja prioritet

procesa. Ovo je vrijednost koju raspoređivač koristi da bi izabrao proces koji će proslijediti na procesor. Ova vrijednost je ista kao p_usrpri. Međutim, ova vrijednost može biti manja čineći na taj način proces važnijim, tačnije prioritetnijim u trenutku kada proces izvodi sistemski poziv.

Tradicionalni UNIX sistem nema kernel sa mogućnošću pražnjenja procesa sa procesora. Ovo bi moglo da znači da samo jedan proces bi mogao biti u sistemskom stanju. Ako je proces blokiran, dok izvodi sistemski poziv, drugi korisnički procesi bi se mogli izvršavati ali ne i drugi sistemski pozivi i funkcije. Iz ovih razloga, proces koji je blokiran dok izvodi sistemski poziv često bi mogao imati vrijednost p_pri nisku kako bi što prije završio svoj posao u kernelu i vratio se u korisnički način rada. Ovo dozvoljava drugim procesima koji su blokirani po ulasku u kernel da počnu napredovati u izvršenju. Kada se završi izvođenje sistemskog poziva onda se vrijednost p_pri procesa ponovno postavi na vrijednost p_usrpri.

Prioritet korisničkih procesaPrioritet koji proces dobija unutar kernela poslije povratka iz reda čekanja

blokiranih procesa se naziva prioritet spavanja (engl. sleep priority). Postoje različite veličine ovog prioriteta koje se mjenjaju u zavisnosti od uslova blokiranja. Na primjer, kod terminalskog ulaza/izlaza je 28 a za ulaz/izlaz sa diska je 20.

Prioritet raspoređivanja procesa u korisničkom načinu rada zavisi od tri faktora:· standarni, unaprijed definisani, priorite za korisnički način rada, PUSER je

tipično jednak 50.· Dosadšnje korišćenje procesora, p_cpu· Vrijednost pridružena procesu, p_nice


Vrijednost p_usr je poznata sistemu i u najviše implementacija je jednaka 50 i ukazuje na najveći nivo raspoređivanja za korisničke procese.

Vrijednost p_nice je predefinisana sa 0, ali je korisnik može povećati. Prisjetimo se da procesi koje treba rasporediti na procesor su inverzno proporcionalni prioritetu. Povećavanjem vrijednosti p_nice proces smanjuje svoju vjerovatnoću da bude izabran. Procesi to rade ako se dugo izvršavaju ili su neinteraktivni pozadinski procesi.

Vođenje evidencije o korišćenju procesoraVrijednost koja se nalazi u p_cpu je mjera korišćenja procesora do trenutka

posmatranja. Vrijednost joj može biti u opsegu od 0 do 127 i inicijalno je postavljena na 0. Svake desetine sekunde, servisna rutina prekida koja radi sa prekidima sata realnog vremena inkrementira vrijednost p_cpu za tekući proces.

Svake 1 sekunde druga servisna rutina smanjuje vrijednost p_cpu svih procesa koji se izvršavaju ili ne. Kod SVR3 sistema ovde se koristi fiksno smanjenje vrijednosti za 0.5. Problem sa fiksnim smanjenjem je da to podiže prioritet gotovo svim procesima ako je opterećenje sistema veliko, pošto samo nekoliko procesa dobija procesor. Ovo dovodi do situacije da je polje p_cpu neznačajno. Prijektanti 4.3BSD razriješili su ovaj problem uvođenjem varijabilnog smanjenja (engl. decay) koji je u funkciji srednjeg sistemskog opterećenja, srednjeg broja procesa u redu spremnih procesa u toku poslednje sekunde. Formula izgleda ovako:

Decay_factor = (2 * load_average)/( 2 * load_average + 1)Formula za prioritet procesa u korisničkom načinu radaRaspoređivač izračunava prioritet korisničkih procesa na osnovu slijedečih

faktora: P_usrpri = PUSER + (p_cpu/4) + (2 * p_nice)ImplementacijaNa DEC VAX sistemima ovo je napravljeno efikasnije i 127 prioriteta svrstani

su u 32 reda čekanja od kojih svaki drži procese čiji su prioriteti u opsegu od 4 prioritetna nivoa (0-3, 4-7, 8-11, 12-15, 16-19, itd.). Nešto slično smo vidjeli na MINIX-u sa 16 prioritetnih nivoa, ranije.

Sistem održava 32bitnu masku. Svaki bit predstavlja jedan red čekanja. Ako je bit postavljen, tada ima procesa u redu čekanja a ako je bit jednak 0 tada je red čekanja prazan. Sistem postavlja ovaj bit na jednicu čim vidi da red nije prazan. Ra raspoređivanje proces iz reda čekanja koristi se round-robin disciplina usluživanja. Round robin sa kvantumom od 100 ms se primjenjuje na sve procese u okviru istog reda čekanja. Ako stiže proces sa nižim prioritetom, odnosno važniji proces, proces će biti raspoređen na kraju tekućeg izabranog kvantuma procesa.

Uvod u raspoređivanje procesa kod UNIX-a 87

3.31 Raspoređivanje u više-procesorskim sistemimaStalna želja za povećanjem brzine računara se dugo zadovoljavala povećanjem

frekvencije računara uz smanjenje broja ciklusa po instrukciji. Ali brzina svjetlosti, koja definiše i brzinu struje u provodnicima ili svjetlosti u optičkom vlaknu na oko 2 cm/ns odrežuje da na 10GHz frekvenciji u jednom ciklusu signal može da pređe samo 2cm, što bi značilo da kompjuter treba biti te veličine da dimenzije najduže staze ne mogu prelaziti 1 cm, samo da signal ode i vrati se u jednom otkucaju sata. Izrada ovako malog kompjutera može biti moguća, ali onda se dešava još jedan fundamentalni problem: rasipanje topline. Što se brže pokreće računar, više zagrijavanja se stvara, a za manji kompjuter je teže da se riješi ova vrućina. Već na Pentium sistemima CPU hladnjak je veći od samog procesora.

Jedan od pristupa za veću brzinu kroz masovno paralelna računala. Ove mašine sastoje od mnogo procesora, od kojih svaka radi na "normalnom" brzinom (šta god to može značiti u datoj godini), ali koje kolektivno imaju daleko više računarske snage nego jedan CPU. Visoko paralelne kompjuteri se često koriste za probleme kao što su predviđanje vremena, modeliranje strujanja vazduha oko avionskog krila, simuliranja u svjetskoj ekonomiji, itd.

3.32 Klasifikacija višeprocesorskih sistemaViše-procesorske sisteme možemo podijeliti u tri klase.1) Labavo vezani ili distribuirani multiprocesor ili klaster. Sastoji se od relativno

autonomnih sistema, svaki procesor ima vlastitu glavnu memoriju i UI kanale. Ovi sistemi su bazirani na računarskim mrežama i poslovi raspoređivanja se svode na na algoritme raspoređivanja jednog procesora, ali više pitanja ima oko međuprocesne komunikacije i sinhronizacije.

2) Funkcionalno specijalizovani procesori. Kod ovih sistema, glavni procesor opšte namjene kontroliše specijalizovane procesore koji mu pružaju usluge. Na primjer, postoje procesori za operacije u pokretnom zarezu, 3D grafiku, očitavanje tastature,


generisanje zvuka. Ovi procesori dijele memoriju i U/I kanale s glavnim procesorom, ali način komunikacije s njima ide kao s svakim ulazno-izlaznim uređajem

3) Blisko vezani multiprocesori. Sastoji se od skupa procesora koji dijele zajedničku memoriju i pod udruženom kontrolom OS. Ovi procesori izvršavaju programe opšte namjene i o njihovom raspoređivanju biće riječi u ovom poglavlju.

3.33 Sinhronizacija i granularnost procesaPonašanje algoritama za raspoređivanje u više-procesorskim sistemima zavisi od

toga koliko često treba obavljati sinhronizaciju između procesa. U sljedećoj tabeli je pokazano nekoliko nivoa granularnosti.

GranularnostOpis Sinhronizacijski interval (instrukcije)Fina Paralelizam u jednom toku instrukcija <20Srednja Paralelizam unutar aplikacije 20-200Gruba Multiprocesiranje konkurentnih procesa 200-2000Vrlo gruba Distribuiranje procesa kroz mrežu da se

formira jedinstveno računsko okruženje2000-1000000

Nezavisna Više nevezanih procesa neprimjenjivo

3.34 Dodjela procesa procesorimaAko pretpostavimo da je arhitektura multiprocesorskih sistema uniformna, u

smislu da nijedan procesor nema posebnu prednost u pristupu glavnoj memoriji ili I/O uređajima , onda je najjednostavniji pristup raspoređivanju da se tretira procesor kao objedinjeni resurs i dodijele procesima procesori na zahtjev. Tada se postavlja pitanje da li zadatak treba biti statički ili dinamičke. U statičkom pristupu, proces je trajno dodijeljen jednom procesor od pokretanja do njegovog završetka , a zatim namjenski kratkoročni red čekanja se održava za svaki procesor. Prednost ovog pristupa je da može biti manje posla u rasporedu funkciju , jer je zadatak procesoru dodijeljen jednom i za sve . Također , namjensko korištenja procesora omogućava strategiju poznatu kao grupni ili družbeni raspored , kao što je objašnjeno kasnije.

Nedostatak statičkog dodjeljivanja je da jedan procesor može biti u stanju mirovanja , sa praznim redom čekanja, dok drugi procesor ima veći red čekanja. Da bi se spriječila ova situacija , može se koristiti zajednički red čekanja. Svi procesi idu u jedan globalni red i trebalo bi da su svi procesori dostupni. Tako, za života proces , proces može biti izvršen na različitim procesorima u različitim vremenima. U tijesno povezanoj arhitekturi s zajedničkom memorijom, informacije o kontekstu za sve procese će biti na raspolaganju svim procesorima, a samim tim i troškovi zakazivanja procesa će biti nezavisni od identiteta procesora na kojem su planirani. Pored ovoga, druga opcija je dinamičko balansiranje opterećenja, u kome se procesi sele iz reda za za jedan procesor u red za drugi procesor .

Bez obzira da li procesi su posvećeni procesoru, neko sredstva je potrebno za dodijeliti procese procesorima. Dva pristupa se koriste : master/slave i parnjaci.

Dodjela procesa procesorima 89

Sa master/slave arhitekturom, ključne funkcije jezgra operativnog sistema uvijek rade na određenom procesoru. Drugi procesori mogu izvršiti samo korisničke programe. Master je odgovoran za zakazivanje poslova. Kada je proces aktivan , ako slave treba uslugu ( npr. U/I poziv ) , mora poslati zahtjev prema master procesoru i čekati da se obavi usluga. Ovaj pristup je vrlo jednostavan i zahtijeva malo poboljšanje u jednoprocesorski operativni sistem. Rješavanje sukoba je pojednostavljen jer je jedan procesor ima kontrolu nad svim memorijskim i U/I resursima . Postoje tri nedostatka ovog pristupa : Kvar na masteru ruši čitav sistem, na sistemima s većim brojem procesora master može postati performanse usko grlo, a kada je broj procesora razmjerno mali master procesor je nedovoljno iskorišten jer ne izvršava korisničke programe.

U peer arhitekturi , kernel može izvršiti na bilo procesor , i svaki procesor radi samostalno raspoređivanje iz bazena raspoloživih procesa . Ovaj pristup komplicira operativni sistem. Operativni sistem mora osigurati da dva procesora ne biraju isti proces i da se procesi nisu nekako izgubili iz reda. Morati se uvesti tehnike za razrješavanje sukoba i sinhronizaciju konkurentnih zahtjeva za resursima.

Postoji , naravno, spektar pristupa između ova dva ekstrema. Jedan od pristupa je da se više procesora posveti izvršenju jezgra umjesto samo jednog . Drugi pristup je jednostavno upravljati razlikom između potreba procesa i drugim procesima na osnovu prioriteta i istorije izvršenja .

3.35 Raspoređivanje procesa na pojedinačnom procesoru u višeprocesorskim sistemioma

Kada svaki proces je statički dodijeljen procesoru za vrijeme svog izvršenja, postavlja se novo pitanje: Da li da se procesor multiprogramira? Prva reakcija čitatelja može biti da se pita zašto se to pitanje treba postaviti, čini se posebno rasipno vezati procesor sa jednim procesom kada taj proces može često biti blokiran dok čeka I/O ili sinhronizaciju.

U tradicionalnim multiprocesorskim sistemima, koji se bavi krupnom ili nezavisnom granularnosti sinhronizacije, jasno je da bi svaki pojedinačni procesor trebao biti u mogućnosti da se prebaci između više procesa za postizanje većeg korištenja i stoga boljih performansi. Međutim, za srednje-zrnaste pokrenute aplikacije na višeprocesorskim sistemima sa mnogim procesora , situacija je manje jasna . Kada je dostupno mnogo procesora, više nije najvažnije da svaki procesor bude zauzet što je više moguće. Umjesto toga, interes je da se pružaju najbolje performanse, u prosjeku , za aplikacije. Aplikacija koja se sastoji od više niti može se izvršavati loše , osim ako sve njene niti dostupne za izvršenje istovremeno.

Pitanje koje se odnose na multiprocesorsko raspoređivanje je stvarni izbor procesa za pokretanje. Na jednoprocesorskim sistemima , upotreba prioriteta ili sofisticiranih algoritama raspoređivanja na osnovu prethodnog korištenja može poboljšati performanse u odnosu na jednostavnu - FCFS strategiju. Kada uzmemo u obzir više procesora, te složenosti mogu biti nepotrebne ili čak kontraproduktivne, i jednostavniji pristup može biti efikasniji s manje nepotrebnog posla. To je zato što


duži procesi na višeprocesorskom sistemu čine FCFS manje zagušujućim, jer procesi koji čekaju na završetak dužih procesa mogu dobiti i drugi procesor. U slučaju rasporeda niti , nova pitanja dolaze u igru koja mogu biti važnija od prioriteta ili istorije.

.

3.36 Raspoređivanje niti u višeprocesorskim sistemmaKao što smo vidjeli, sa teme, koncept izvršenja niti je odvojen od ostatka definicije

procesa. Aplikacija može biti implementirana kao skup niti, koje sarađuju i izvršavaju se istovremeno u istom adresnom prostoru. Na jednom procesoru, niti se mogu koristiti kao pomoć strukturiranju programa i da se preklapaju I/O sa obradom. Zbog minimalne cijene u prebacivanja niti u odnosu na prebacivanje procesa, ove prednosti su ostvarene sa malo troškova. Međutim, u prednosti niti postaju evidentne u višeprocesorskim sistemima. U takvom okruženju, niti se mogu koristiti za eksploataciju pravog paralelizma u aplikaciji. Ako razne niti aplikacije se istovremeno izvršavaju na posebnom procesorima, dramatični dobici u performansama su mogući. Za raspoređivanje niti na višeprocesorskim sistemima, koristi se više pristupa kao što su podjela opterećenja, družbeno raspoređivanje, dodjela posvećenog procesora i dinamičko raspoređivanje

3.37 Podjela opterećenjaOvo je najjednostavniji pristup, direktno prenesen iz jednoprocesorskog okruženja.

U jednom zajedničkom redu čekanja nalaze se sve niti i redom dodjeljuju pojedinom procesoru kada god on postaje slobodan. Mogu se koristiti algoritmi poput

• FCFS• prvo najmanji broj niti• preemptivno prvo najmanji broj niti

Prednosti ovog pristupa je što je opterećenje ravnomjerno raspoređeno između procesora i nije potreban organizovan raspoređivač. Mane pristupa su što centralni red čekanja zauzima dio memorije koji zahtijeva uzajamno isključenje, što može voditi do uskih grla. Dalje, zaustavljene niti nakon reaktiviranja rijetko nastavljaju na istom procesoru, čime je manja efikasnost njegovog memorijskog keša. Konačno, ako sve niti pripadaju istom nizu niti, malo je vjerovatno da će sve one dobiti pristup procesorima u isto vrijeme. Tada, ako je potrebna saradnja između niti izmjena konteksta može znatno pokvariti performanse.

3.38 Družbeno raspoređivanjeDružbeno raspoređivanje (gang scheduling) je istovremeno raspoređivanje niti koje

čine jedan proces. U odnosu na podjelu opterećenja, pristup ima više prednosti: manje blokiranja sinhronizacije, manje izmjena procesa, manje posla kod raspoređivanja, poboljšane performanse. Algoritam je koristan za srednje i grubo granularne aplikacije, čiji jedan dio se ne izvršava kada je drugi spreman za rad.

Družbeno raspoređivanje 91

Ovaj pristup zahtijeva alokaciju procesora. Pretpostavimo da imamo N procesora i M aplikacija, od kojih svaka ima N ili manje niti. Tada se obično daje svakoj aplikaciji 1/M raspoloživog vremena na N procesora , koristeći vremenske odsječke. Međutim, na sljedećoj slici se vidi da to nije uvijek dobra strategija. U primjeru s 4 procesora i dvije aplikacije, od kojih je jedna jednonitna, a druga ima 4 niti ako se obijema aplikacijama dodijeli jednako vrijeme u procesorima, tri procesora koja izvršavaju jednonitnu aplikaciju su neaktivna dok se ona izvršava. Tada je ukupno zauzeće resursa 37,5%. S druge strane, ako se procesu s više niti dodijeli više vremena, tada se neiskorištenost smanjuje.

3.39 Dodjela posvećenog procesoraEkstremna varijanta družbenog raspoređivanja se sastoji u tome da kada se

rasporedi aplikacija, svaka od njenih niti dodijeljena procesoru ostaje mu dodijeljena do završetka aplikacije. Pri prvom pogledu, ovo je veliki gubitak resursa. Ako se nit aplikacije blokira zbog čekanja na U/I ili sinhronizacije s drugom niti, tada procesor koji izvršava ovu nit ostaje neaktivan. Time nema više multiprogramiranja sistema. No, imaju dva opravdanja za ovaj pristup. Prvo je da u vrlo paralelnim sistemima, s stotinama procesora, iskorištenost procesora više nije važna kao metrika efektivnosti ili performansi. Drugo opravdanje potiče od činjenice da izbjegavanje izmjene procesa u programu može drastično ubrzati taj program.

Dokaz za ovo opravdanje je na sljedećoj slici. Na šesnaest procesorskom sistemu pokrenute su aplikacije Furijeove transformacije i množenja matrica, razdijeljene u niti. Aplikacije dijele račun u više niti. No, ubrzanje sa povećanjem broja niti raste dok se ne dostigne broj procesora. Nakon toga, daljnje povećanje broja niti sano usporava procesor.


3.40 Dinamičko raspoređivanjeZa neke aplikacije je moguće obezbijediti jezičke i sistemske alate koji

omogućavaju dinamički promjenu niti. To bi omogućilo da OS prilagodi opterećenje radi poboljšanja iskorištenosti.

Ovdje operativni sistem i aplikacija utiču na odluke o raspoređivanju. Odgovornost raspoređivanja OS je ograničena na dodjelu procesora Prednost ove metode u odnosu na družbenu raspodjelu ili posvećeni procesor je da aplikacija može imati korist od toga. Procesi sa većim brojem prioriteta, odnosno manje važniji procesi, se neće izvršiti dok se redovi čekanja sa nižim prioritetnim brojem ne isprazne. Redovi čekanja se provjeravaju pomoću maske bita svaki put kada se proces ili blokira ili vremenski period pridružen nekom procesu istekne.

3.41 Posix funkcije koje podešavaju algoritme raspoređivanja

Neke funkcije koje utiču na algoritam raspoređivanja su date na sljedećoj listi.• pthread_setschedparam(pThread, iPolicy, psParam);

Postavlja algoritam raspoređivanja niti i prioritet. Parametar iPolicy zavisi od i psParam zavise od OS, na primjer iPolicy može biti SCHED_OTHER, SCHED_FIFO, SCHED_RR, a psParam struktura koja među ostalim poljima sadrži prioritet

• pthread_getschedparam(pThread, pPolicy, psParam);Očitava parametre raspoređivanja niti• nice(iInc);

Proces dodjeljuje dio prioriteta samom sebi, manji broj veći prioritet

Windows funkcije koje podešavaju algoritme raspoređivanja 93

3.42 Windows funkcije koje podešavaju algoritme raspoređivanja

Sljedeče API funkcije mogu da mijenjaju parametre algoritma raspoređivanja.• GetCurrentProcessorNumber()

Vraća redni broj procesora koji izvršava proces• GetPriorityClass(hProcess)

Vraća kategoriju prioriteta procesa• GetProcessTimes(hProcess,lpCreationTime,lpExitTime,

lpKernelTime,lpUserTime)Vraća koliko je vremena proces proveo u pojedinim režimima OS• SetPriorityClass( hProcess,dwPriorityClass)

Postavlja klasu prioriteta procesa• GetThreadPriority(hThread)

Vraća prioritet niti• SetThreadPriority(hThread,nPriority)

Postavlja prioritet niti

3.43 Zadaci:1. Dat je skup procesa čije su dužine izvršavanja na procesoru date u msec.

Proces Vrijeme izvršavanja Prioritet

P1 10 3P2 1 1P3 2 3P4 1 4P5 5 2

Pretpostavimo da procesi stižu u redoslijedu P1, P2, P3, P4 i P5 i svi u vremenu t=0.

a) Nacrtati Guntt-ove dijagrame ilustrirajući izvršenje ovih procesa koristeći FCFS, SJF, sa prioritetom bez pražnjenja procesora, RR raspodjelu sa kvantumom q=1.

b) Koliko je ukupno vrijeme zadržavanja procesa u sistemu za svaki proces i za svaki alogoritam raspoređivanja dat u a)?

c) Koliko je vrijeme čekanja za svaki proces i za svaki algoritam raspoređivanja dat u a)?d) Koji od algoritama raspoređivanja daje minimalno srednje vrijeme čekanja za sve procese?

2. Pretpostavimo da slijedeći procesi stižu na izvršenje u vremenima datim u tabeli u kojoj se nalazi i vrijeme izvršavanja procesa. Koristeći disciplinu


usluživanja bez pražnjenja procesora odgovorite na slijedeća pitanja:

P r o c e s V r ij e m e s t i z a n j a V r ij e m e i z v r š a v a n j a P1 0.0 8P2 0.4 4P3 1.0 1a) Koje je srednje vrijeme ukupnog boravka ovih procesa u sistemu ako se koristi FCFS algoritam raspoređivanja?b) Koje je srednje vrijeme ukupnog boravka ovih procesa u sistemu ako se koristi SJF algoritam raspoređivanja?c) Za algoritam SJF se predpostavlja da će poboljšati performase. Primjetimo da ako počnemo izvršavati proces P1 u trenutku 0, ne znamo da će dva kraća procesa brzo doći na sistem. Izračunajmo koliko će srednje vrijeme boravka procesa u sistemu biti ako procesor ostane prazan 1 jedinicu vremena a onda se koristi SJF algoritam raspoređivanja. Primjetimo da procesi P1 i P2 čekaju u toku ovog praznog vremena tako da se njihovo vrijeme čekanja može povećati. Ovaj algoritam mogao bi se zvati raspoređivanje sa znanjem o budućem ponašanju.

3. Razmotrimo varijantu algoritma raspoređivanja RR gdje su ulazi u red spremnih procesa pokazivači na PCB-ove.a) Koji će biti efekat stavljanja dva pointera istog procesa u red spremnih procesa.?b) Koje će biti osnovne prednosti i mane ovakvog pristupa?c) Kako se može modifikovati osnovni RR algoritam da se postigne isti efekat bez dupliciranja pokazivača?Odgovor:a) Proces će povećati svoj prioritet dobivanjem vremena više puta tako da možemo reći da proces ima poseban tretman,b) Prednost je da važniji poslovi bi mogli imati više vremena, drugim riječima, veći prioritet u tretmanu. Posljedice ovakvog ponašanja su u sporijem izvođenju kraćih poslova.c) Dozvoljavajući veće vrijeme procesima koje želimo ubrzati, drugim riječima, dvije ili više vrijednosti za kvantum predvidjeti u šemi RR.4. Koje su prednosti ako postoje različite veličine vremenskih kvantuma na različitim nivoima višenivo-skog sistema čekanja?Odgovor: Procesi koji trebaju frekventnija servisiranja, na primjer interaktivni proces kao što je editor, mogu biti smješteni u red čekanja sa malim vremenskim kvantumom. Procesi koji nemaju potrebu za čestim servisiranjem mogu biti stavljeni u red čekanja sa većim kvantumom čime zahtjevaju manje izmjena konteksta da bi završili obradu čineći efikasniju upotrebu računara.5. Razmotrimo slijedeći algoritam za prioritetno raspoređivanje sa pražnjenjem baziran na dinamičkoj izmjeni prioriteta. Veći brojevi prioriteta znače veći prioritet. Kada proces čeka na procesor (u redu spremnih procesa ) njegov prioritet se mjenja na alfa, dok kada se izvršava njegov prioritet se promjeni na beta. Svi procesi sa

Zadaci: 95

prioritetom 0 ulaze u red čekanja spremnih procesa. Parametri alfa i beta mogu se postaviti tako da daju različite algoritme za raspoređivanje.a) Koji je algoritam ako je beta>alfa>0?b) Koji je algoritam ako je alfa<beta<0?Odgovor:a) FCFSb) LIFO6. Pretpostavimo da je algoritam raspoređivanja (na nivou kratkoročnog raspoređivanja) favorizuje one procese koji su koristili najmanje procesorskog vremena u prošlosti. Zašto ovaj algoritam favorizuje U/I programe a još ne "ubija" programe vezane za procesor?Odgovor: Favorizovaće U/I programe zato što im je relativno kratko vrijeme na procesoru, međutim, programi vezani za procesor neće "umrijeti" zato što se predhodni odriču procesora relativno često kad rade svoj U/I.

96 Sinhronizacija procesa


4.1 Dijeljenje i natjecanjeKooperirajući procesi ili thread-ovi često dijele resurse. Neki od ovih resursa mogu

se koristiti konkurentno sa bilo kojim brojem procesa, dok drugi mogu biti korišćeni samo od jednog procesa u nekom trenutku vremena.

Kada se više procesa izvršava istovremeno u sistemu, a dijele neki resurs, mogući su konflikti. Zamislimo da postoje dvije niti ili procesa (nazovimo ih proces 1 i proces 2) koje istovremeno unos podatke u neki zajednički niz istim algoritmom, učitavši trenutnu poziciju niza u varijablu next_free, zatim smjeste podatak na tu poziciju i uvećaju pokazivač trenutne pozicije. Kada bi se cijela ta akcija obavila za proces 1, a zatim za proces 2, ispravnim redosljedom, podaci bi bili ispravno uneseni.

Ali, šta ako se Proces 2 počeo izvršiti nakon što je Proces 1 pročitao vrijednost trenutne pozicije u nizu, ali je nije još promijenio? Tada će oba procesa vidjeti istu trenutnu poziciju i jedna od njihovih upisanih vrijednosti će biti oštećena.

Dijeljenje i natjecanje 97

Zrak u prostoriji može se dijeliti među svim bez koordinacije jer nema potrebe da se koordinira disanje prisutnih u prostoriji. Međutim štampač ne bi mogao biti korišćen na taj način. Sigurno da postoji način, da se svi korisnici koji žele štampač, dogovore o redosljedu njegovog korišćenja ili da se odlože datoteke materijala za štampu na disk a da sistem izvrši štampanje u skladu sa nekim pravilima.

U svakom slučaju, osjećamo potrebu za koordinacijom među korisnicima koji žele pristupiti jednom resursu. Drugi primjer bi mogla biti raskrsnica sa semaforima na kojoj učesnici u saobraćaju žele da prođu raskrsnicu bezbjedno (da koriste resurs) dok drugi čekaju da dođu u priliku da ga koriste.

Pravila koja definišu kako bi trebalo biti dijeljeni resursi se naziva disciplinom dijeljenja resursa. Najčešća disciplina dijeljenja resursa je međusobno isključivanje (engl. mutual exclusion) ali postoje i druge discipline dijeljenja resursa. Kod pravila međusobnog isključivanja imamo slučaj da kada proces koristi resurs onda niti jedan drugi proces ne može koristiti resurs.

4.2 Kritična sekcijaKako da izbjegnemo stanje natjecanja? Ovdje je potrebno pronaći način da se

zabrani više od jednog procesa da čita i piše dijeljene podatke u isto vrijeme. Ovakva situacija se pojavljuje na mnogim mjestima kao što su dijeljena memorija, dijeljene datoteke i sl. Drugim riječima može se reći da ono što tražimo je međusobna isključivost kojom se osiguravamo da kada jedan proces koristi dijeljenu varijablu ili datoteku, dugi procesi neće biti u stanju obavljati istu stvar. To znači da problemi nastaju kada jedan proces počne da koristi dijeljeni resur a drugi proces taj isti resurs nije oslobodio. Izbor odgovarajućih operacija kojim se postiže međusobna


isključivost je osnovno pitanje kod projektovanja operativnih sistema i u nastavku će predstavljati predmet našeg proučavanja.

Često u toku svojeg izvođenje proces ne koristi dijeljene varijable i tada ne dolazi do problema međusobnog isključivanja. Međutim često se procesi nalaze u situacijama da koriste dijeljene resurse, podatke ili datoteke. Kako mi rukujemo sa resursima iz programa? Naravno, pisanjem koda. Dio programa koji radi sa resursima na način da mu je potrebno međusobno isključivanje ili neki drugi tipovi zaštite se naziva kritična sekcija. Primijetimo, u praksi, čak i jedna linija koda u jeziku visokog nivoa može predstavljati kritičnu sekciju jer je jedna linija koda u jeziku visokog nivoa predstavljena sa nekoliko linija koda u mašinskom jeziku koji se može prekinuti. Ukoliko uredimo stvari na takav način da dva procesa ulaze u kritičnu sekciju u isto vrijeme tada se to stanje naziva stanjem natjecanja i postoje načini kako dozvoliti jednom procesu da uđe u kritičnu sekciju a drugim procesima zabraniti pristup kritičnoj sekciji.

Mada ovaj zahtjev sprječava stanje natjecanja, on nije dovoljan da bi se procesi odvijali paralelno i efikasno djeleći informacije međusobno korišćenjem dijeljenih podataka. Potreno je definisati četiri stanja da bi se održalo dobro riješenje međusobnog isključivanja procesa:

1. Dva proces ne smiju biti u njihovoj kritičnoj sekciji2. Ne bi smjele se praviti pretpostavke o brzini i broju procesora3. Ne smije se dozvoliti procesu koji se izvršava izvan kritične sekcije da blokira

druge procese4. Proces ne bi trabao da čeka beskonačno da bi ušao u kritičnu sekcijuPonašanje koje želimo je prikazano na slici. Proces A ulazi u kritičnu sekciju u

trenutku T1. Malo kasnije u trenutku T2 proces B pokušava da uđe u kritičnu sekciju ali ne uspijeva jer je drugi proces već u kritičnoj sekciji. U kritičnoj sekciji može biti samo jedan proces.

Kao posljedica ovog, proces B se privremeno suspenduje do trenutka T3 kada proces A napušta kritičnu sekciju i na taj način dozvoljava procesu B da odmah uđe u kritičnu sekciju. Kada proces B napusti kritičnu sekciju imamo situaciju gdje nema procesa u kritičnoj sekciji.

Međusobno isključivanje sa zaposlenim čekanjem 99

4.3 Međusobno isključivanje sa zaposlenim čekanjemU ovom djelu ćemo se baviti različitim metodama za postizanje međusobne

isključivosti procesa, tako dok je jedan proces zaposlen i ažurira dijeljenu memoriju u svojoj kritičnoj sekciji dugi procesi neće moći uću u istu kritičnu sekciju i uzrokovati probleme,

4.4 Zabrana prekidaNajednostavnije rješenje je da svaki proces zabrani sve prekide odmah po

ulasku u kritičnu sekciju i omogući ih odmah po izlasku iz kritične sekcije. Kao rezultat rada sata realnog vremena i prekida dolazi do izmjene procesa na procesoru, pa ako zabranimo prekide procesor se ne može dodjeliti drugom procesu. Dakle kada jedan proces zabrabi prekide on može ažurirati dijeljenu memoriju bez bojazni da drugi proces može pristupiti njegovim podacima.

Ovaj pristup nije poželjan jer nije mudro dati korisničkim procesima snagu da zabrane prekide. Pretpostavimo da jedan takav proces ima takve ovlasti, šta će se desiti ako on po izlasku iz kritične sekcije ne omogući prekide? To bi značilo da bi sistem brzo prestao sa radom. Kod multiprocesorskih sistema, sa dva ili više procesora, onemogućavanje prekida je važeće samo na procesoru na kome je komanda izdana dok drugi procesor nastavlja sa izvršavanjem i može pristupiti dijeljenoj memoriji.

S druge strane, često je pogodno za kernel da zabrani prekide za nekoliko instrukcija dok ažurira varijable. Ako se prekid desi kada se lista spremnih procesa nalazi u nekonzistentnom stanju, stanje natjecanja bi se moglo desiti.

U zaključku, kažimo da je zabrana prekida često korisna tehnika u samom operativnom sistemu ali nije pogodna za mehanizme međusobnog isključivanja za korisničke procese.

4.5 Dijeljena varijablaKao drugi pokušaj, pogledajmo softverska rješenja. Neka imamo jednu dijeljenu

varijablu koja je inicirana na 0. Kada proces hoće da uđe u kritičnu sekciju on prvo testira varijablu. Ako je varijabla jednaka 0, proces je postavi na 1 i ulazi u kritičnu sekciju. Ako je varijabla već postavljena na 1 proces čeka dok ne postane jednaka 0. Dakle, 0 znači da nema procesa u kritičnoj sekciji kod 1 znači da je proces u kritičnoj sekciji.

Međutim ovdje postoji problem. Pretpostavimo da jedan proces čita varijablu i vidi da je jednaka 0. Prije nego što je ne postavi na 1, dolazi do raspoređivanja drugog procesa i njegovog pokretanja i on postavi dijeljenu varijablu na 1. Kada se prvi proces ponovno pokrene, on je već video da je varijabla postavljena na 0 i postavlja je na 1 i tada oba procesa ulaze u kritičnu sekciju u isto vrijeme. Ako pomislimo da je prvi proces morao ponovno provjeravati stanje varijable tada nismo u pravu jer proces ne zna šta se u međuvremenu desilo i takav pristup neće pomoći. Znači, stanje natjecanja se dešava kada drugi proces modifikuje dijeljenu varijablu nakon što je prvi proces uradio provjeru varijable.


Striktna promjenaTreći pristup problemu međusobnog isključivanja je prikazan na slici ispod.while (TRUE){ while(turn != 0); /* petlja * / kritična_sekcija (); turn = 1; kod_izvan_kritične_sekcije();}(a)

while (TRUE) {while(turn != 1); /* petlja * /kritična_sekcija (); turn = 0; kod_izvan_kritične_sekcije();

}(b)

U oba slučaja, primjetite znak ; koji se završava while iskaz. Na slici , cjelobrojna varijabla turn, inicirana na 0, održava redosljed ulazaka u kritičnu sekciju i ispituje i ažurira dijeljenu varijablu. Inicijalno, proces 1 testira varijablu turn, nalazi da je jednaka 0 i ulazi u kritičnu sekciju. Proces 2, takođe nalazi da je varijabla 0 i počne da se izvršava u petlji neprekidno provjeravajući da li je varijabla turn postala jednaka 1. Stalno provjeravanje varijable dok se neka vrijednost ne pojavi se naziva “zaposlenim čekanjem”. Ova situacija nije poželjna jer troši vrijeme na procesoru. Zaposleno čekanje se koristi samo kada se s razlogom očekuje da će vrijeme čekanja biti kratko. Varijabla kojom se izvodi zaposleno čekanja se zove varijabla zaključavanje (engl. spin lock).

Kada proces 1 napusti kritičnu sekciju, on postavlja varijablu turn na 1, dozvoljavajući procesu 2 da uđe u kritičnu sekciju. Pretpostavimo da proces 2 završi svoju sekciju brzo tako da su oba procesa su izvan kritične sekcije sa varijablom turn postavljenom na 0. Sada proces 1 brzo izvrši svoju kritičnu sekciju, izlazeći iz kritične sekcije i postavljajući varijablu turn na 1. U ovom trenutku varijabla turn ima vrijednost 1 i oba procesa su izvan kritične sekcije.

Odjednom, proces 1, koji je završio svoj kod izvan kritične sekcije, dođe na vrh petlje da bi ušao ponovno u kritičnu sekciju. Nažalost, nije mu dozvoljeno da uđe sada u kritičnu sekciju zato što je varijabla turn postavljena na 1 a proces 2 je zaposlen u svom kodu izvan kritične sekcije. Na ovaj način proces 1 čeka na iskazu while sve dok proces 2 ne postavi varijablu turn na 0. Ovakva ideja nije dobra u slučajevima kada je jedan proces brži od drugog.

Ova situacija narušava stanje 3 postavljenog iznad: proces 1 je bio blokiran sa procesom koji nije u njegovoj kritičnoj sekciji. Mada ovaj algoritam spriječava sva natjecanja za kritičnom sekcijom, on nije ozbiljan kandidat kao rješenje problema međusobnog isključivanja jer narušava stanje 3.

4.6 Peterson-oovo rješenjeKombinujući ideju sa redosljedom izvršavanja procesa i ideju sa varijablama

zaključavanja, matematičar T.Dekker je prvi izveo softversko rješenje za problem međusobnog isključivanja koji ne zahtjeva striktnu izmjenu procesa.

Peterson-oovo rješenje 101

1981 gopdine, G.L. Peterson je otkrio mnogo jednostavniji način da se postigne međusobno isključivanje procesa. Njegov algoritam nije prikazan u nastavku, ali su prikazane procedure za ulazak i izlazak iz kritične sekcije što je dovoljno.

#define FALSE 0#define TRUE 1#define N 2 /* broj procesa */int turn; /* čiji je redosljed? */int interested[N]; /* sve vrijednosti inicijalno na 0 (FALSE)*/void ulazak_u_sekciju(int process) /* proces je 0 ili 1 */{int other; /* broj drugog procesa */other = 1 - process; /* prvi proces */interested[process] = TRUE; /* pokazuješ interosovanje za ulazak u k.s. */turn = process; /* postavi zastavicu */while (turn == process && interested[other] == TRUE) ;}void izlazak_iz_sekcije(int process) /* proces: koji napušta kritičnu sekciju */{interested[process] = FALSE; /* ukazuje na izlazak iz kritične sekcije*/}

Prije korišćenja dijeljene varijable (t.j. prije ulaska u kritičnu sekciju), svaki proces poziva proceduru ulazak_u_sekciju(int process) sa svojim brojem procesa, 0 ili 1 kao parameter. Ovaj poziv će uzrokovati čekanje, ako je potrebno, dok ne bude siguran da može ući u kritičnu sekciju. Posle završetka posla sa dijeljenim varijablama, čitaj boravka u kritičnoj sekciji, proces poziva proceduru izlazak_iz_sekcije(int process) da oslobodi kritičnu sekciju i omogući drugim procesima njeno korišćenje.

Da vidimo kako funkcioniše algoritam. U početku, niti jedan proces se ne nalazi u kritičnoj sekciji. Sada proces 0 poziva proceduru za ulazak u kritičnu sekciju. On ukazuje da je zainteresovan za ulazak u kritičnu sekciju postavljanjem njegovog elementa niza i varijable turn na 0. Pošto proces 1 nije zainteresovan za ulazak u kritičnu sekciju, procedura za ulazak se odmah izvršava. Ako proces 1 pozove proceduru za ulazak u kritičnu sekciju, on će čekati sve dok interested[0] ne postane FALSE, jedan događaj koji će se desiti kada proces 0 pozove proceduru za napuštanje kritične sekcije.

Sada razmotrimo slučaj kada oba procesa pozovu proceduru za ulazak u kritičnu sekciju gotovo istovremeno. Oba će smjestiti njihov broj procesa u varijablu turn. Ko god da je upisao prvi, posljednji zapis se računa a prethodni briše. Pretpostavimo da je proces 1 smjestio svoju vrijednost posljednji, tako da je turn jednak 1. Kada oba procesa dođu na izvršavanje while iskaza, proces nula odmah ulazi u kritičnu sekciju dok proces 1 se vrti u petlji i ne ulazi u kritičnu sekciju.


4.7 TSL InstrukcijaPogledajmo sada na prijedloge koji zahtjevaju hardversku pomoć. Monogi

računari, posebno oni koji su projektovani sa višestrukim procesorima, imaju instrukciju tipa

TSL RX,LOCKa znači provjeri i postavi (engl. Test and Set Lock) koja radi na sljedeći način: čita

sadržaj memorijske riječi LOCK u registar RX i onda smješta vrijenost različitu od 0 u memorijsku lokaciju LOCK. Operacija čitanja riječi i pisnje u nju su nedjeljive, kažemo atomske, tako da drugi procesi ne mogu pristupiti varijabli sve dok se instrukcija ne završi. Procesor izvršava TSL instrukciju i zaključava memorijski bus da bi zabranio drugim procesorima da pristupe memoriji dok se instrukcija ne završi.

Da bi koristili instrukciju TSL, korističemo dijeljenu varijablu LOCK da bi napravili koordinirani pristup dijeljenoj memoriji. Kada je LOCK jednaka 0, bilo koji proces je može postaviti na 1 korišćenjem TSL instrukcije a zatim čitati i pisati dijeljenu memoriju. Kada se završi ove operacije, proces postavlja varijablu LOCK opet na 0 korišćenjem jedne instrukcije move.

Kako se ova instrukcija koristi da bi se spriječila dva procesa od simultanog ulaska u kritičnu sekciju? Ovo rješenje je dato na slici ispod.

ulazak_u_kritičnu_sekciju:TSL REGISTER,LOCK ; kopiraj LOCK u registar i postavi LOCK na 1CMP REGISTER,#0 ;| da li je LOCK bio nula?JNE ulazak_u_kriticnu_sekciju ; ako nije bio nula, LOCK je bio postavljen, ; dakle vrti se u petljiRET ; vrati se pozivaocu; ulazak u kritičnu sekciju dozvoljenizlazak_iz_kritične_sekcije:MOVE LOCK,#0 ; smjesti 0 u varijablu LOCK RET ; vrati se pozivaocuPrva instrukcija kopira staru vrijednost varijable LOCK u registar i onda

postavlja varijablu LOCK na 1. Zatim se stara vrijednost poredi sa 0. Ako rezltat poređenja nije 0, zaključavanje je već postavljeno tako da program ide nazad na početak i vrši testiranje ponovno. Prije ili kasnije ova varijabla će biti jednaka 0, kada proces koji se izvršava u kritičnoj sekciji završi sa svojom kritičnom sekcijom, i povratkom iz potprogarama. Oslobađanje kritične sekcije je jednostavno i izvodi se smiještanjem 0 u varijablu LOCK. Nisu potrebne posebne instrukcije.

Jedno rješenje problema kritične sekcije je sada jasno. Prije ulaska u kritičnu sekciju proces treba da pozove potprogram ulazak_u_kritičnu_sekciju, koji izvodi zaposleno čekanje dok se zaključavanje ne oslobodi i onda dobije zaključavanje i potprogram završi izvođenje. Nakon završetka izvođenja kritične sekcije proces mora pozvati potprogram izlazak_iz_kritične_sekcije koji postavlja 0 u varijablu LOCK. Kao kod svih rješenja baziranih na kritičnim sekcijama procesi moraju pozvati potprograme ulazak_u_kritičnu_sekciju i izlazak_iz_kritične_sekcije u odgovarajuća vremena i metode koje je potrebno odraditi.

Blokiranje i deblokiranje procesa 103

4.8 Blokiranje i deblokiranje procesaI Peterson-ovo rješenje i rješenje koje koristi TSL instrukciju su korektna, ali oba

posjeduju manjkavost koja se zove “zaposleno čekanje”. U stvari, šta rade ova pomenuta rješenja: kada proces želi da uđe u kritičnu sekciju, on provjerava da vidi da li je ulaz dozvoljen. Ako nije, proces se vrti u petlji i čeka svoj ulazak.

Ne samo da ovaj pristup troši procesorsko vrijeme nego može dovesti do neželjenih efekata. Neka u računaru se izvršavaju dva procesa, H sa visokim prioritetom i L sa niskim prioritetom koji djele kritičnu sekciju. Pravila raspoređivanja su takva da se H izvršava kad god je u redu spremnih procesa za izvršavanje. U nekom momentu, sa L procesom koji se nalazi u kritičnoj sekciji, H postane spreman za izvršavanje (t.j. kada se završi jedna U/I operacija). H sada počne da se izvršava i radi “zaposleno čekanje” jer L nikako ne može da dođe na procesor dok se H proces izvršava, odnosno L nikada ne dobije šansu da napusti kritičnu sekciju tako da H proces čeka zauvijek. Ova situacija se pominje nekada kao problem prioritetne inverzije.

Sada pogledajmo na neke funkcije za međuprocesnu komunikaciju koje blokiraju proces umjesto onih koje troše vrijeme procesora kada im nije dozvoljeno da uđu u kritične sekcije. Jedne od najednostavnijih su funkcije sleep i wakeup. Funkcija sleep predstavlja sistemski poziv koji uzrokuje da se pozivaoc blokira, odnosno da se suspenduje dok ga drugi proces deblokira iz nekog razloga. Proces deblokiranja se izvodi funkcijom wakeup sa jednim parametrom koji predstavlja proces koji treba deblokirati.

4.9 SemaforiE.W.Dijkstra (1965) sugerisao korišćenje cjelobrojne varijable da bi se računao

broj deblokiranja porocesa i bio spašen za upotrebu. U ovom prijedlogu, nova vrijabla, nazvana semafor je uvedena. Semafor je mogao imati vrijednost 0 i ukazivao je da nema deblokiranja procesa dok je pozitivna vrijednost ukazivala da jedan broj procesa čeka na deblokiranje.

Predložene su dvije operacije, down i up (koje su uopštene operacije sleep i wakeup, respektivno). Down operacija na semaforu provjerava da vidi da li je vrijednost semafor veća od 0. Ako jeste, smanji je za 1 i nastavi sa izvršavanjem. Ako je vrijednost jednaka 0, proces se blokira bez završavanja operacije down za neko vrijeme. Provjeravanje vrijednosti, njena izmjena i moguće blokiranje se izvode u jednoj, nedjeljivoj, atomskoj operaciji. To znači da kada jedna operacija nad semaforskom varijablom se pokrene da drugi procesi ne mogu pristupiti semaforskoj varijabli sve dok se operacija ne završi ili dođe do blokiranja. Ova atomičnost (mogućnost izvođenja koda bez prekida) je suština kod rješavanja problema sinhronizacije i izbjegavanja stanja natjecanje.

Operacija up povećava vrijednost semafora za 1. Ako je postojao jedan ili više procesa koji su blokirani na semaforu, koji nisu bili u stanju da završe ranije izdane down operacije, jedan od procesa se izabira i na taj način mu je dozvoljeno da završi svoju down operaciju i nastavi sa svojim izvođenjem. Dakle, poslije izvođenje jedne


up operacije na semaforu sa procesima koji su blokirani na njemu, semafor će ostati jednak 0 ali će biti deblokiran proces koji je bio blokiran na njemu (iz stanja blokiran biće preveden u stanje spremnih procesa za izvršenje). Operacija povećanja vrijednosti semaforske varijable i deblokiranja procesa je takođe nedjeljiva. Proces se nikada ne blokira kada izvodi operaciju up.

U originalnom radu Dijkstra koristi imena p (hol. Proberen – testiraj) i v (hol. verhogen – povećaj za jedan) umjesto down i up, respektivno. Ove operacije su prvi put bile uvedene u jeziku Algol 68. U literature se koriste i operacije wait i signal koje se odnose na operacije down i up.

Pseudo kod, prikazan ispod, ilustrira semantiku ove dvije operacije nad semaforom.P(sem) /* proberen – testiraj, operacija wait(sem) */{ while (sem <= 0); sem = sem – 1;}V(sem) /* verhogen – inkrementiraj, opeacija signal(sem) */{ sem = sem + 1;}

U cilju da obezbijedimo da kritična sekcija sa semaforima ostane zaštićena koristićemo TSL instrukciju i njene funkcije za ulazak i izlazak iz kritične sekcije. Na ovaj način pomoću osnovnih funkcija izgrađujemo složenije funkcije.p(csem) { while (1) { ulazak u k.s.; if (csem.value <= 0) { izlazak_iz_k.s.; continue; } else { csem.value = csem.value – 1; izlazak_iz_k.s.; break; } }}v(csem) { ulazak u k.s.; csem.value = csem.value + 1; izlazak_iz_k.s.;}

Pogledajmo pažljivo implementaciju P(csem). Ako je natjecanje za kritičnu sekciju veliko i/ili je kritična sekcija dovoljno velika, onda se može potrošiti značajno puno vremena. Mnogi procesi će zauzimati procesor i neće ništa radini osim što će trošiti

Semafori 105

cikluse čekajući na proces u redu spremnih procesa da se izvrše i oslobode kritičnu sekciju. Ovo zaposleno čekanje čini veliko natjecanje za kritičnom sekcijom još gorim.

Ali nije sve izgubljeno. Uz pomoć operativnog sistema, možemo implementirati semafore tako da pozivajući proces će se blokirati umjesto da se vrti u operaciji P() i čeka na V() operaciju da se «probudi» i izvrši ponovno. Pseudo kod prikazuje implementaciju takvih semafora koji se još nazivaju blokirajući semafori.

p(sem) { while (1) { acquire_mutex (csem.mutex); ulazak u k.s. if (csem.value <= 0) { Insert_queue (getpid(), csem.queue); Release_mutex_and_block (csem.mutex); /* atomski: lost wake-up */ } else { csem.value = csem.value – 1; Release_mutex (csem.mutex); // izlazak iz kritične sekcije Break; } }}v(csem){acquire_mutex (csem.mutex); // ulazak u k.s. csem.value = csem.value + 1;dequeue_and_wakeup (csem.queue); // prevođenje procesa iz stanja// blokiranosti u red spremnih procesaRelease_mutex (csem.mutex); // izlazak iz k.s.}

Primjetimo da izvođenje funkcije P() nad procesom mora atomski postati blokiran i osloboditi mutex. Ovo je zato da se ne desi rizik «izgubljenog buđenja» procesa. Zamislimo slučaj kada se izvrše dvije različite operacije: release_mutex(xsem.mutex) i sleep(). Ako se desi izmjena konteksta između ove dvije funkcije može se doći u situaciju da drugi proces izvrši operaciju V() i pokuša da probudi uspavani proces i oslobodi iz reda čekanja. Nažalost, prvi proces još nije ušao u red čekanja blokiranih procesa tako da buđenje može da ne uspije, i kad proces opet nastavi izvođenje doći će u stanje blokiranja i tada neće postojati operacija buđenja koja bi ga trebala izvaditi iz reda čekanja.

Operacioni sistemi obezbjeđuju ovu podršku u obliku sistemskog poziva sleep() koji uzima semafor mutex kao parametar. Kernel onda može osloboditi mutex i staviti proces u stanje spavanja (blokiran i suspendovan) u jednoj okolini oslobođenoj od prekida, odnosno zaštićenu.


4.10 Mutex-iKada semaforska mogućnost za brojanje nije potrebna, pojednostavljena verzija

semafora se koristi i on se naziva mutex. Mutex je dobar samo za upravljanje međusobnim isključivanjem za neki dijeljeni resurs ili dio koda. Oni su jednostavni za implementaciju i vrlo efikasni tako da ih to čini posebno korisnim threadova koji se implementiraju u potpunosti u korisničkom adresnom prostoru (threadovi na korisničkom nivou).

Mutex je varijabla koja može biti u jednom od dva stanja: otključanom ili zaključanom. Zbog samo dva stanja koje je potrebno memorisati, dovoljno je samo 1 bit ali se u praksi često korsiti cjelobrojna varijabla sa vrijednosšću 0 koja znači nezaključan i sve druge vrijednosti koje znači zaključan. Sa mutex-ima se koriste dvije procedure. Kada jedan proces ili thread treba da pristupi kritičnoj sekciji onda koristi proceduru mutex_lock. Ukoliko je tada mutex otključan, što znači da je pristup kritičnoj sekciji koda dozvoljen, poziv procedure je uspješan i pozvani proces ili thread može ući u kritičnu sekciju. S druge strane, ako je mutex zaključan, znači pristup kritičnoj sekciji nije dozvoljen, onda proces pozivaoc se blokira sve dok proces u kritičnoj sekciji ne završi i pozove mutex_unlock. Ako je više procesa blokirano na mutex-u, jedan od njih se izabira i on dobija pristup kritičnoj sekciji

4.11 Windows API za sinhroizacijuWindows API poznaje semafore i mutex-e i ako se njihova imena navode u obliku

stringa kao parametara može se koristiti i između procesa, ne samo niti. Funkcije Windows API-ja za sinhronizaciju su

• InitializeCriticalSectionAndSpinCount( lpCriticalSection, dwSpinCount) Inicijalizira kritičnu sekciju i brojač pokušaja ulaska

• EnterCriticalSection(lpCriticalSection) Čeka na ulaz u kritičnu sekciju i uđe kada je slobodna

• TryEnterCriticalSection( lpCriticalSection) Pokušava ući u kritičnu sekciju bez čekanja

• LeaveCriticalSection(lpCriticalSection) Otključava kritičnu sekciju• DeleteCriticalSection(lpCriticalSection) Briše kritičnu sekciju• WaitForSingleObject(hHandle,dwMilliseconds) Čeka na oslobađanje

sinhronizacijskog objekta ii navedeno vrijeme• WaitForMultipleObjects(nCount,lpHandles, bWaitAll,dwMilliseconds) Čeka

na oslobađanje bar jednog ili svih sinhronizacijskih objekata• CreateMutex(lpMutexAttributes,bInitialOwner, lpName) Kreira objekt

uzajamnog isključenja• OpenMutex( dwDesiredAccess, bInheritHandle,lpName) Otvara postojeći

Mutex• CloseHandle(hObject) Zatvara sinhronizacijski objekt• CreateEvent( lpEventAttributes, bManualReset,bInitialState,lpName) Kreira ili

otvara objekt događaja

Windows API za sinhroizaciju 107

• CreateSemaphore(lpSemaphoreAttributes, lInitialCount,lMaximumCount,lpName) Kreira semafor

• ReleaseSemaphore( hSemaphore, lReleaseCount,lpPreviousCount) Uvećava vrijednost semafora

4.12 Posix API za sinhroizacijuU ovom, API za sinhronizaciju semaforima koriste se sljedeće funkcije.

• sem_open(pcName,iOflag,iNmode,iValue)Povezuje se ili kreira imenovani semafor

• sem_init(pSem,iPshared,iValue) Inicijalizira neimenovani semafor• sem_close(pSem) Završava vezu s otvorenim semaforom• sem_unlink(pcName) Završava vezu s otvorenim semaforom i uklanja ga kada

ga zadnji proces prestane koristiti• sem_destroy(pSem) Uklanja semaforsku strukturu neimenovanog semafora• sem_getvalue(pSem,pValue) Kopira vrijednost semafora u cijeli broj• sem_wait(pSem), sem_trywait(pSem) Blokira se kada semafor drži drugi

proces ili vraća grešku• sem_post(pSem) Povećava brojač semafora

.

4.13 MonitoriRad sa semaforima kod međuprocesne komunikacije izgleda lako. Međutim,

problem nastaje kada se koristi više semafora i osnovno pitanje je koliko ste pažljivi sa korišćenjem semafora. Jedan mali previd može vas dovesti do nepredvidivog ponašanja koda.

Da bi bilo jednostavnije pisanje korektnih programa, Brinch Hansen (1973) i Hoare (1974) predložili su sinhronizacionu mogućnost na višem nivou koju su nazvali monitor. Monitor predstavlja skup procedura, promjenljivih i struktura podataka koje su sve grupisane zajedno u posebnu vrstu modula. Procesi mogu zvati procedure u monitoru kad god žele, ali ne mogu direktno pristupiti internim strukturama podataka iz procedura koje se nalaze izvan monitora. Na slici ispod je dat primjer monitora.monitor example integer i; condition c;procedure producer (x); . . . end;procedure consumer (x);.. end;end monitor;


Monitor ima ključnu karakteristiku koja ga čini korisnim za postizanje međusobnog isključivanja: samo jedan proces može biti aktivan u monitoru u bilo kojem trenutku. Monitori su konstrukcije programskih jezika tako da kompajler zna da su one posebne i mora raditi sa pozivima na procedure u monitoru različito od poziva drugih procedura. Kada jedan proces pozove proceduru u monitoru, prvih nekoliko instrukcija procedure će izvršiti kontrolu da ustanovi da li je neki drugi proces već aktivan u monitoru (koristi proceduru). Ako ustanovi da se proces nalazi u monitoru pozivajući proces će biti suspendovan sve dok drugi proces ne napusti monitor. Ako nema drugih procesa koji su u monitoru proces koji je napravio poziv ka monitoru može ući u monitor.

Zadatak kompajlera je da implementira međusobno isključivanje na ulazu u monitor, ali je uobičajen način da se koristi mutex ili binarni semafor. Zato što ovaj pristup monitoru uređuje kompajler a ne programer, manje je vjerovatno da će doći do greške. U svakom slučaju, programer koji piše monitor ne mora biti svjestan kako će to kompajler uraditi da bi se postigla međusobna isključivost. Dovoljno je da zna da pokušavajući da se uđe u kritičnu sekciju u monitoru, biće dozvoljeno samo jednom procesu da koristi datu kritičnu sekciju u jednom trenutku.

Mada monitori obezbjeđuju jednostavan način da se postigne međusobno isključenje procesa, to ponekad nije dovoljno. Takođe je potrebno imati mehanizme koji blokiraju procese ako ne mogu da uđu u monitor. U primjeru proizvođač – potrošač, jednostavno je testirati sve procese na pun i prazan bafer u procedurama monitora, ali kako bi trebalo proizvođača blokirati ako nađe da je bafer pun? Rješenje je povezano sa uvođenjem uslovnih varijabli sa dvije operacije koje se mogu izvoditi nad njima, wait i signal. Kada monitor procedura otkrije da se proces ne može dalje nastaviti (t.j. proizvođač nađe da je bafer pun), on izvršava jednu operaciju wait na nekoj uslovnoj varijabli, recimo full. Ova akcija uzrokuje da se pozivni proces blokira. To dozvoljava drugom procesu, kome je bio prethodni ulaz zabranjen da nastavi sa izvršavanjem, odnosno da uđe u monitor.

Drugi proces, na primjer, potrošač, može deblokirati (čitaj probuditi) blokiranog partnera (čitaj uspavanog) izvodeći operaciju signal. Hoare je predložio da dozvoli da novi deblokirani proces se izvrši suspedujući drugi proces. Brinsh Hansen je predložio da proces koji izvrši operaciju signal mora odmah izaći iz monitora. Drugim rječima, iskaz signal se može pojaviti samo kao krajnji iskaz u monitor proceduri . U primjeru koristimo prijedlog Brinch Hansen-a jer je jednostavniji i lakši za implementaciju. Ako se izvrši operacija signal nad uslovnom varijablom na koju čeka nekoliko procesa, samo jedan od njih će se izabrati u skaldu sa pravilima raspoređivanja.

Postoji i treće rješenje, u kome se dozvoljava procesu koji je izvršio signal operaciju da nastavi izvršavanje i dozvoljava se procesima koji čekaju da se izvrše da to urade tek što proces koji je izdao operaciju signal završi svoje izvođenje.

Uslovne varijable nisu brojači. One ne akumuliraju događaje za kasniju upotrebu na način kako to rade semafori.

Barijere 109

4.14 BarijereDok smo do sada imali prilike govoriti o tehnikama sinhronizacije dva procesa,

barijere predstavljaju mehanizam za sinhronizaciju grupe procesa. Neke aplikacije su podijeljenje u faze I imaju pravilo da se nijedan process ne smije izvršavati u sljedećoj fazi ako svi procesi nisu spremni da uđu u tu fazu. Ovakvo ponašanje u aplikacijama se može postići postavljanjem barijere na kraju svake faze. Kada jedan proces u grupi procesa dostigne barijeru, on se blokira dok svi procesi ne dostignu istu barijeru. Ove operacije su ilustrirane na slici ispod.

Na slici pod a) se mogu vidjeti četiri procesa koji se približavaju barijeri. Ovo znači da su u fazi izračunavanja ali da nisu još završili sa obradom za koji su zaduženi i da nisu još stigli na granicu barijere. Poslije izvjesnog vremena, prvi proces završava izvođenje poslova za koje je bio zadužen u ovoj fazi. Po stizanju na barijeru, izvršava funkcije vezane za barijeru preko poziva bibliotetskih funkcija i proces se blokira na barijeri. Nešto kasnije, drugi i treći proces završavaju izvršenje u toku prve faze i po dolasku na barijeru izvršavaju funkcije barijere ( slika b). Nakraju, kada posljednji process C stigne na barijeru, i pri izvršenju funkcija barijere dolazi do deblokiranja svih procesa koji su čekali na barijeri, vid slika pod c.

Korišćenje barijere. (a) Procesi se približavaju barijeri. (b) svi procesi osim jednog su blokirani na barijeri. (c) Kada posljednji proces stigne na barijeru, svi procesi se deblokiraju

4.15 Sinhronizacija procesa - Klasični problemi sinhronizacije

Literatura koja se odnose na probleme međuprocesne komunikacije je puna primjera koji se diskutuju i koriste različite sinhronizacione metode. Usljedećem djelu pozabavićemo se sa tri takva primjera:o Problem proizvođač – potrošačo Problem čitač – pisačo Problem filozofa koji jedu


4.16 Problem proizvođač – potrošačKao primjer kako se ove funkcije koriste u praksi, razmotrimo problem proizvođač

– potrošač, poznat i pod nazivom problem ograničenog bafera. Dva procesa djele zajednički bafer fiksne veličine. Jedan od njih, proizvođač, stavlja informacije u bafer a drugi ih uzima (kažemo koristi). Problemi se javljaju kada proizvođač želi da stavi novi element u bafer a bafer je već pun. Za proizvođača je rješenje da se blokira i da se deblokira kada potrošač ukloni iz bafera jedan ili više elemenata. Slično, ako potrošač želi da ukloni jedan element iz bafera i vidi da je bafer prazan treba da se blokira sve dok proizvođač ne stavi element u bafer i deblokira ga.

Ovaj pristup zvuči sasvim jednostavno, ali dovodi do neke vrste stanja natjecanja kao što smo vidjeli ranije. Da bi vodili evidenciju o broju elemenata u baferu, potrebna nam je varijabla count. Ako se u baferu može držati N elemenata kod proizvođača će prvi testirati da vidi da li je count jednak N. Ako jeste izvršiće svoje blokiranje procesa a ako nije, proizvođač će dodavati element u bafer i povećavati count za 1.

Kod potrošača je sličan: prvo se testira count da bi se vidjelo da li je jednak 0. Ako jeste, onda se vrši blokiranje procesa potrošač a ako nije jednak 0 uklanja element iz dijeljenog bafera i smanjuje za 1 varijablu count. Svaki od procesa imaju zadatak da vide da li je drugi proces u stanju blokiranosti i ako treba da ih deblokiraju (operacija wakeup). Kod za proizvođača i potrošača je prikazan ispod:

#define N 100 /* broj mjesta u baferu */

int count = 0; /* broj elemenata u baferu */

void producer(void){int item;

while (TRUE){ /* stalno ponavljanje */item = produce_item(); /* proizvodi sljedeći element - item*/if (count == N) sleep(); /* ako je bafer pun, izvrši blokiranje */insert_item(item); /* ubaci element item u bafer */count = count + 1; /* povećaj brojač elemenata u baferu */if (count == 1) wakeup(consumer); /* da li je bafer bio prazan? */}}void consumer(void)

{int item;while (TRUE){ /* stalna petlja */

if (count == 0) sleep(); /* ako je bafer prazan, izvrši blokiranje

Problem proizvođač – potrošač 111

operacijom sleep() */item = remove_item(); /* izvadi element iz bafera */count = count - 1; /* smanji brojač elemenata u baferu */if (count ==N 1) wakeup(producer); /* da li je bafer bio pun? – ako jeste deblokiraj proizvođača */consume_item(item); /* štampaj element */

}}Da bi izrazili sistemske pozive takve kao što su sleep i wakeup u C-u, prikazani su

kao pozivi bibliotetskih rutina. Oni nisu djelovi standardne C biblioteke ali vjerovatno su raspoloživi na bilo kojem sistemu koji u stvari ima ove sistemske pozive. Procedure enter_item i remove_item, koje nisu ovdje prikazane, rade ubacivanje elementa u bafer i vađenje elemenata iz bafera.

Sada se vratimo problemu natjecanja. Ono se može desiti zato što pristupamo varijabli count. Sljedeća situacija bi se mogla desiti. Bafer je prazan i potrošač je pročitao count da vidi da li je jednak 0. U tom trenutku, raspoređivač odluči da zaustavi proces koji se izvršavao i da pokrene proces proizvođač. Proizvoča unosi novi element u bafer i povećava brojač koji sada iznosi 1. Shvatajući da je brojač bio jednak 0, potrošač se mora blokirati dok proizvođač, zato što je count jednak 1 misli da proces potrošač treba probuditi. Nažalost, potrošač nije stigao da odradi operaciju deblokiranja a signal buđenje će se izgubiti. Kada se potrošač pokrene kasnije testiraće vrijednost count koju je prethodno pročitao i naći će da je to 0 i blokiraće sam sebe. Prije ili kasnije proizvođač će napuniti bafer i takođe će se blokirati (operacija sleep). Oba će biti blokirani zauvijek.

Suštinski problem ovdje je da poslani signal deblokiranja procesa, koji još nije blokiran, je izgubljen. Ako nije izgubljen, onda je sve u redu. Ovaj problem bi mogli riješiti dodavanjem jednog biti kod deblokiranja procesa. Kada se signal deblokiranja pošalje procesu koji još nije blokiran, ovaj bit se postavi. Kasnije, kada proces pokuša da se blokira, ako je tak bit postavlje, treba ga oboriti i proces će još ostati deblokiran. Na taj način bi se moghlo spriječiti da oba procesa ne diđu u stanje blokiranosti.

4.17 Rješavanje problema Proizvođač-Potrošač koristeći semafore

Semafori razrješavaju problem gubitka operacije deblokiranja, kao što je prikazano na slici 6. Suština je da su implementirani na jedan nedjeljiv način. Normalan način implementacije operacija up i down je preko sistemskih poziva, gdje operativni sistem nakratko zabrani sve prekide dok se vrši kritična operacija testiranja semafora. Ako se koriste višestruki procesori, onda svaki semafor treba da bude zaštićen sa varijablom, sa TSL instrukcijom koja se koristi da se osiguramo da samo jedan procesor u jedinici vremena vrši testiranje semafora.


Producer(){ while (1) {<<< proizvedi element >>> P(empty); /* postoji li prazan element bafera, blokiraj proces ako ga nema

*/ P(mutex); /* traži kritičnu sekciju –dijeljeni bafer */<<< kritična sekcija >>>< V(mutex); /* oslobodi kritičnu sekciju */ V(full); /* povećaj broj punih mjesta */ }}

Consumer(){while(1){ P(full); P(mutex);<<< kritična sekcija: ukloni element iz dijeljenog bafera >>>V(mutex);V(empty);}}Ovo rješenje koristi tri semafora: jedan koji se zove full i služi za brojanje

popunjenih mjesta u baferu, jedan koji se zove empty koji služi za brojanje praznih mjesta u baferu i jedan koji se zove mutex i služi da proizvođač i potrošač ne pristupe baferu istovremeno ( kažemo za međusobno isključivanje). Inicijalno varijabla full je jednaka 0, varijabla empty je inicijalno jednaka broj praznih elemenata u baferu (veličini bafera) i mutex je postavljen na 1. Semafori koji se inicijaliziraju na 1 i koriste ih dva ili više procesa da se osiguraju da samo jedan uđe u kritičnu sekciju u isto vrijeme se nazivaju binarnim semaforima. Ako svaki proces izvrši operaciju down prije ulaska u kritičnu sekciju i operaciju up poslije napuštanja kritične sekcije, međusobno isključivanje među procesima je zagarantirano.

Kako imamo na raspolaganju dobre operacije za međuprocesnu komunikaciju, pogledajmo kada se koriste. U sistemu koji koristi semaphore, prirodan način je da se sakriju prekidi i da imamo semafor postavljen na 0 i pridržun svakom U/I uređaju. Poslije pokretanja U/I uređaja, proces kojim upravljamo datim uređajem izvršava operaciju down na datom semaforu, dakle odmah se blokira. Kada dođe do prekida, onda handler prekida izvršava operaciju up na tom semaforu što omogućuje procesu koji je čekao na semafor da pređe u stanje spremnih procesa i da brzo dođe na izvršenje.

Rješavanje problema Proizvođač-Potrošač koristeći semafore 113

U ovom primjeru, imamo korišćenje semafora na dva različita načina. Mutex-i se koriste za međusobno isključivanje procesa kod pristupa dijeljenoj varijabli. On je napravljen da garantuje samo jednom procesu u datom trenutku da će pristupiti baferu za čitanje i pisanje. Međusobno isključivanje se koristi da spriječi haos.

Druga upotreba semafora je za sinhronizaciju. Semafori full i empty su potrebni da bi garantovali da se izvjesni niz događaja desi ili ne desi. U ovom slučaju oni obezbjeđuju da proizvođač prestane izvršavanje kada je bafer pun a potrošač prestane izvršavanje kada je bafer prazan. Ovaj način korišćenje je različiti od međusobnog isključivanja.

4.18 Problem filozofa koji jeduDijkstra je 1965 predložio rješenje sinhronizacionog problema koji nazivamo

problem filozofa koji jedu. Problem se može prikazati na sljedeći način. Pet filozofa sjede za okruglim stolom. Svaki filozof ima tanjir sa špagetama. Za jedenje špageta potrebno je koristiti dvije viljuške. Između dva tanjira se nalazi po jedna viljuška. Raspored na tabeli je prikazan na slici ispod.

Proces koji obavljaju filozofi se sastoji od periodičnog jedenja i razmišljanja. Kada filozof postane gladan on pokušava da dobije lijevu i desnu viljšku. Ako je uspješno dobio dvije viljuške, on počne da jede izvjesno vrijeme, a onda spušta viljuške i nastavlja da razmišlja. Ključno pitanje je: možete li se napisati program za svakog filozofa da radi ono što se pretpostavlja da radi a da nikada ne dođe u situaciju da ne može da obavlja svoje funkcije. Ispod je prikazano rješenje problema:Slika: neispravno rješenje za problem filozofa

#define N 5 /* broj filozofa */void philosopher(int i)/* i: broj filozofa,od 0 do 4 */{

while (TRUE) {think(); filozof razmišlja */take_fork(i); /* uzima lijevu viljušku */ take_fork((i+1) % N); /* uzima desnu viljušku ;

/ % je modulo operator */eat(); /* yum-yum, spaghetti */put_fork(i); /* stavlja lijevu viljušku na sto */put_fork((i+1)%N); /* stavlja desnu na sto */


}}

Može se modifikovati program tako da nakon uzimanja lijeve viljuške, program provjerava da vidi da li je desna viljuška raspoloživa. Ako nije, filozof spušta lijevu viljušku na sto, čeka izvjesno vrijeme i onda ponavlja cijeli proces. Ovaj pristup ima isuviše grešaka, mada su iz različitih razloga. Filozofi bi mogli početi algoritam simultano, uzimajući njihove lijeve viljuške i uvidjevši da njihova desna viljuška nije raspoloživa, zatim spuštaju svoje lijeve viljuške, čekaju,uzimaju svoje lijeve viljuške ponovno i tako zauvijek. Situacija kao ova u kojoj svi programi nastavljaju se izvršavati beskonačno dugo ali ne uspijevaju da naprave napredak se naziva umiranjem procesa.

Razmotrimo pristup kada filozofi razmišljaju proizvoljan broj vremenskih jedinica prije nego što pokušaju ponovno tražiti kako ne bi nastupili u isto vrijeme. Ovakav pristup će dati rezultate i broj grešaka će se znatno smanjiti. Međutim, želimo napisati aplikaciju koja nikada ne griješi i vrši sinhronizaciju procesa korektno.

Rješenje je dato u sljedećem dijelu i omogućuje maksimalni paralelizam među procesima. Koristi jedan niz, stanje da vodi evidenciju da li filozof jede, razmišlja ili je gladan (kada pokušava da dobije dvije viljuške). Filozof se može premjestiti u stanje “jede” samo ako nijedan susjed ne jede. Susjedi filozofa su definisani sa makroima LEFT i RIGHT. Drugim riječima, ako je i jednak

2 onda je LEFT jednako 1 a RIGHT jednako 3.#define N 5 /* number of philosophers */#define LEFT (i+N-1)%N /* number of i's left neighbor */#define RIGHT (i+1)%N /* number of i's right neighbor */#define THINKING 0 /* philosopher is thinking */#define HUNGRY 1 /* philosopher is trying to get forks */#define EATING 2 /* philosopher is eating */typedef int semaphore; semaphores are a special kind of int */int state[N]; /* array to keep track of everyone's state */ semaphore mutex = 1;* mutual exclusion for critical regions */ semaphore s[N]; /* one semaphore per philosopher */void philosopher(int i)/* i: philosopher number, from 0 to N1 */{while (TRUE){ /* repeat forever */think(); /* philosopher is thinking */ take_forks(i); /* acquire two forks or block */ eat(); /* yum-yum, spaghetti */ put_forks(i); /* put both forks back on table */}}void take_forks(int i) /* i:philosopher number, from 0 to N1 */{down(&mutex); /* enter critical region */state[i] = HUNGRY; /* record fact that philosopher i hungry */

Problem filozofa koji jedu 115

test(i); /* try to acquire 2 forks */up(&mutex); /* exit critical region */down(&s[i]); /* block if forks were not acquired */}void put_forks(i) /* i: philosopher number, from 0 to N1 */{down(&mutex); /* enter critical region */state[i] = THINKING; /* philosopher has finished eating */test(LEFT); /* see if left neighbor can now eat */

test(RIGHT); /* see if right neighbor can now eat */ up(&mutex); /* exit critical region */}void test(i) /* i: philosopher number, from 0 to N1* /{if (state[i] == HUNGRY && state[LEFT] != EATING &&

state[RIGHT] != EATING) {state[i] = EATING;up(&s[i]);}}

Program koristi niz semafora, jedan po filozofu, tako da se gladni filozofi mogu blokirati ako je njihova viljuška zauzeta. Primjetimo da svaki proces izvršava proceduru filozof kao svoj osnovni kod dok druge procedure, take_forks, put_forks i test su obične procedure i nalaze se u procesu.

4.19 Problem čitača i pisačaProblem filozofa koji jedu je koristan za modeliranje procesa koji se najteču

za ekskluzivan pristup ograničenom broju resursa, takvih kao što su U/I uređaji. Drugi, poznati, problem predstavlja problem čitača i pisača kojim se modelira pristup bazama podataka (Courtois at al., 971). Zamislimo, na primjer, jedan sistem za rezervaciju karata, sa mnogo procesa koji se natječu u želji da pristupe sistemu čitajući ili pišući svoje zahtjeve. Prihvatljivo je da imamo više procesa koji čitaju baze podataka u isto vrijeme, ali ako neki od procesa želi da ažurira (čitaj piše) bazu podataka nijedan drugi proces ne smije imati pristup bazi podataka, čak ni “čitači” (procesi koji čitaju bazu podataka). Kako da se izgradi program za čitače i pisače u bazu podataka. Jedno rješenje je prikazano na slici ispod.

4.20 Rješenje problema čitač - pisač.U ovom rješenju, prvi čitač koji dobije pristup bazi podataka izvršava operaciju

down() na semaforu db. Sljedeći čitači treba samo da povećaju brojač rc za jedan. Kada čitači napuštaju bazu podataka, oni smanjuju brojač za jedan i posljednji ćitač izvršava up() proceduru koja omogućuje blokiranim pisačima, ako ih ima, da dobiju pristup bazi podataka.


typedef int semaphore; /* use your imagination */ semaphore mutex = 1; /* controls access to 'rc' */ semaphore db = 1; /* controls access to the database */ int rc = 0; /* # of processes reading or wanting to */

void reader(void){while (TRUE){ /* repeat forever */down(&mutex); /* get exclusive access to 'rc' */rc = rc + 1; /* one reader more now */if (rc == 1) down(&db); /* if this is the first reader ... */ up(&mutex); /* release exclusive access to 'rc' */ read_data_base(); /* access the data */down(&mutex); /* get exclusive access to 'rc' */rc = rc- 1; /* one reader fewer now */if (rc == 0) up(&db); /* if this is the last reader ... */ up(&mutex); /* release exclusive access to 'rc' */ use_data_read(); /* noncritical region */}}

void writer(void){while (TRUE){ /* repeat forever */ think_up_data(); /* noncritical region */ down(&db); /* get exclusive access */ write_data_base(); /* update the data */up(&db); /* release exclusive access */}}

Pretpostavimo da, dok jedan čitač koriste bazu podataka, drugi čitač može doći i takva situacija je prihvatljiva. Pretpostavimo da sada dolazi pisač. On ne može pristupiti bazi podataka pošto mora imati eksluzivno pravo pristupa, tako da se pisač mora suspendovati. Kasnije mogu dolaziti i dodatni čitači povećavajući broj čitača. To znači, dok god je jedan čitač aktivan čitači mogu pristupati bazi podataka. Kao posljedica takve strategije, dok god postoje aktivni čitači novi čitači mogu pristupati bazi podataka, a to znači da je pisač biti blokiran bez obzira kada je stigao. Recimo, ako novi čitači stižu, recimo svake 2 sekunde i svaki čitač treba za čitanje baze podataka 5 sekundi, onda pisač neće nikada dobiti pravo pristupa bazi podataka.

Da bi spriječili ovakvu situaciju program bi trebalo nešto promjeniti: kada čitač stiže a pisač je blokiran, čitača treba blokirati iza pisača umjesto da mu se da šansa da odmah pristupi bazi podataka. Na ovaj način, pisač mora da čeka na čitače koji su bili aktivni kada je je pisač tražio zahtjev za pristup bazi podataka a ne mora da čeka na one pisače koji su došli iza njega. Mana ovog rješenja je da se postiže manja konkurentnost a na taj način i lošije performase.

BACI – Ben Ari Concurrent interpreter 117

4.21 BACI – Ben Ari Concurrent interpreterNastavni programski jezik za upoznavanje koncepata konkurentog programiranja.

BACI C— je podskup jezika C++. Dakle, prati se C/C++ sintaksa uz neka ograničenja i nove tipove. Alternativno, postoji i Pascal verzija. Nije namijenjem razvoju aplikacija, nego za školske eksperimente iz sinhronizacije procesa.

Ovo su njegove sintaksne osobine:1. Nema drugih datoteka osim standardnog ulaza-izlaza: cout, cin i endl.2. Samo prosti C/C++ tipovi postoje u C— BACI: int i char. Podržane su konstante

prostih tipova. (Sve varijable moraju biti definisane na početku kodnog bloka gdje se pojavlju.)

3. Podržan je string tip i nege ugrađene funkcije: stringCopy, stringCompare, stringConcat, etc.

4. Podržani su nizovi prostih tipova i string tipova. Deklaracija nizova prati uobičajenu C sintaksu.

5. Podržane su procedure i funkcije sa stgandardnim pravilima uključujući opseg varijabli i rekurziju. Parametri se prosljeđuju po vrijednosti ili referenci. Izvršenje počinje od main().

6. Izvršne naredbe su if-else, switch/case, for, while, do-while, break i continue. Sintaksa ovih naredbi je kao u standardnom C/C++.

Postoje konstrukcije za realizaciju konkurentosti1. cobeginLista procesa koji se konkurentno izvršavaju uokvirena je u cobegin blok. Takvi

blokovi se ne mogu gnijezditi i moraju se nalaziti u glavnom programu. PCODE naredbe koje pripadaju nabrojanim procedurama se prepliću interpreterom u slučajnom redoslijedu, tako da višestruko izvršavanje istog programa koji ima cobegin blok će izgledati nedeterminističko. Glavni program se zaustavlja dok se svi procesi u cobegin bloku ne zaustave, nakon čega glavni program nastavlja izvršavanje naredbi iza bloka. Na primjer:cobegin {proc1( ... ); proc2( ... ); ... ; procN( ... );}

2. semaforisemaphore je predefinisana vrijednost u BACI. On je nenegativna varijabla kojoj

se može pristupiti samo na ograničen način. BACI također ima podtip binarysem koji je binarni semafor koji samo predpostavlja vrijednosti 0 i 1. Semaforske funkcije uključuju:

* initialsem ( semaphore, integer_expression ): Inicijalizira semafor na navedenu vrijednost.

* p ( semaphore) ili wait (semaphore): Ako je semaphore > 0 umanji semafor za 1 i vrati se, čime pozivalac može nastaviti izvršenje. Ako je semaphore = 0, pozivalac se prebacuje u čekanje.

* v ( semaphore) ili signal (semaphore): Ako je semaphore = 0 i jedan ili više procesa čekaju na semafor, slučajno probudi jedan od čekajućih procesa. Ako ni jedan


proces ne čeka na semafor, uvećaj semafor za jedan. U svakom slučaju, pozivalac nastavlja s izvršenjem.

3. monitoriBACI podržava i Hoareove monitore s nekim ograničenjima. Monitor je C— blok

s nekim dodatnim mogućnostima. Sve funkcije u monitorskim blokovima su vidljive spolja, ali monitorske varijable nisu pristupačne van bloka i mogu ih čitati samo monitorske funkcije. Monitor se može deklarisati samo na globalnom nivou i monitori se ne mogu gnijezditi. Samo jedna monitorska procedura se može izvršavati u jednom trenutku, pa se monitori mogu koristiti za uzajamno isključivanje. Tri konstrukcije se koriste za kontrolu konkurentnosti u monitoru condition varijable, waitc (wait on condition), i signalc (signal a condition).

* condition varijables su pristupačne samo u monitorskim funkcijama. Condition varijabla nikada nema vrijednost, ona je prosto nešto na šta se čeka i što se signalizira.

* void waitc (condition cond, int prio): monitorski proces je blokiran i dodijeljen mu je prioritet prio za ponovno buđenje. Ova akcija blokiranja omogućava izvršavanje drugih monitorskih procesa ako je neki spreman.

* void waitc (condition cond): ista semantika kao waitc, ali se dodjeljuje podrayumijevani prioritet 10.

* void signalc (condition cond): Probudi proces koji čeka na cond , inače ne radi ništa.

* void empty (condition cond): Vraća 1 ako nema procesa koji čekaju na condition cond a 0 ako ih ima.

4. Druge konkurentne konstrukcije* atomic : Ako je funkcija definisana kao atomic, ona nije preključiva. Interpreter

neće prekinuti atomičku funkciju.* void suspend ( void ): smješta pozivaoca u stanje čekanja.* void revive ( int process_id ): reaktivira proces s datom oznakom.* int which_proc( void ): Vraća oznako trenutnog procesa.* int random (int range): vraća slučajan broj između 0 i range -1, uključivo.Kompajler, a zatim interpreter p-koda se pokreće iz komandne linije i svaki od

primjera treba startati više puta, jer svaki primjer ponaša drugačije pri drugom startu.Ako niste razumjeli kako se unosi i izvršava evo primjera

edit haos.cm(ili drugi editor, npr kwrite, note u koji će se unijeti ili program)

bacc haos.cmbainterp haos.pcobainterp haos.pcobainterp haos.pcobainterp haos.pco

Primjer 1: Haos


Svako izvršavanje je različito. Nekada se prvo izvrši funkcija koja ispisuje slovo A, a nekada ona koja ispisuje slovo B ili C. I prekidi se dešavaju usred ispisa na ekran. Ovo ilustruje borbu za resurs, u ovom slučaju ekran.

void HelloA () { cout << "Hello from A" <<endl;}void HelloB () { cout << "Hello from B" <<endl;}void HelloC () { cout << "Hello from C" <<endl;}main () { cobegin { HelloA(); HelloB(); HelloC(); }}

Primjer 2: Haos je veci sto su procesi duzi Prekidanje programa je još uočljivije nego u prethodnom primjeru, jer su funkcije

za prikaz duže.


void HelloA () {int i,j; for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "A"; cout << endl; }}void HelloB () {int i,j; for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "B"; cout << endl; }}void HelloC () {int i,j; for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "C"; cout << endl; }}main () { cobegin { HelloA(); HelloB(); HelloC(); }}

Primjer 3: Uzajamno isključivanje semaforima Redoslijed nije i dalje predvidiv. Ali, više nema prekidanja ured ispisa. Semafori

su realizovali uzajamno isključivanje. Semafor je inicijaliziran na 1. Krene li izvršenje bilo koje procedure, pokrene se wait. On umanji semafor na 0 i sprječava da wait nad istim semaforom nastavi izvršavanje. Tek kada je tekst ispisan, naredba signal inkrementira semafor za jedan i time se može nastaviti izvršavanje zaustavljenih rutina u wait..


semaphore mut;void HelloA () { wait(mut); cout << "Hello from A" <<endl; signal(mut);}void HelloB () { wait(mut); cout << "Hello from B" <<endl; signal(mut);}void HelloC () { wait(mut); cout << "Hello from C" <<endl; signal(mut);}main () { initialsem(mut,1); cobegin { HelloA(); HelloB(); HelloC(); }}

Primjer 4: Uzajamno iskljucivanje atomskim funkcijama

Ključna riječ atomic sprječava prekidanje funkcije. Zašto postoje i semafori? Nekada je potrebno blokirati samo one procese koji pristupaju istim resursima, što se postiže semaforima, dok atomic prekida izvršenje svih ostalih procesa dok se on ne završi.

atomic void HelloA () { cout << "Hello from A" <<endl;}atomic void HelloB () { cout << "Hello from B" <<endl;}atomic void HelloC () { cout << "Hello from C" <<endl;}main () { cobegin { HelloA(); HelloB(); HelloC(); }}

Primjer 5: Postavljanje redoslijeda izvrsavanja semaforima


Treba primijetiti da su semafori enda i endb postavljeni na 0, te da podprogram HelloC čeka da se završe i HelloA i HelloB. Tako se HelloC uvijek izvršava posljednji.

semaphore enda,endb,mut;void HelloA () { wait(mut); cout << "Hello from A" <<endl; signal(mut); signal(enda);}void HelloB () { wait(mut); cout << "Hello from B" <<endl; signal(mut); signal(endb);}void HelloC () { wait(enda); wait(endb); wait(mut); cout << "Hello from C" <<endl; signal(mut);}main () { initialsem(enda,0); initialsem(endb,0); initialsem(mut,1); cobegin { HelloA(); HelloB(); HelloC(); }}

Primjer 6: Limitiranje broja procesa semaforima

Od pet procesa, dva se izvršavaju istovremeno, što je postignuto inicijalizacijom semafora na 2


semaphore limit;void HelloA () {int i,j; wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "A"; cout << endl; } signal(limit);}void HelloB () {int i,j; wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "B"; cout << endl; } signal(limit);}void HelloC () {int i,j; wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "C"; cout << endl;} signal(limit);}void HelloD () {int i,j; wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "D"; cout << endl; } signal(limit);}


void HelloE () {int i,j; wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "E"; cout << endl; } signal(limit);}

main () { initialsem(limit,2); cobegin { HelloA(); HelloB(); HelloC(); HelloD(); HelloE(); }}

Primjer 7: Limitiranje broja procesa semaforima s razlicitim prioritetom Uočava se da se D i E nikada ne razmjenjuju istovremeno, a ako su D ili E

startani, da se tada mogu razmjenjivati sa najviše dva od tri procesa A,B,C.semaphore limit;void HelloA () {int i,j; wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "A"; cout << endl; } signal(limit);}void HelloB () {int i,j; wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "B"; cout << endl; } signal(limit);}


void HelloC () {int i,j; wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "C"; cout << endl; } signal(limit);}void HelloD () {int i,j; wait(limit); wait(limit); wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "D"; cout << endl; } signal(limit); signal(limit); signal(limit);}void HelloE () {int i,j; wait(limit); wait(limit); wait(limit); for (i=1;i<=5; i++) { for (j=1;j<=5; j++) cout << "E"; cout << endl; } signal(limit); signal(limit); signal(limit);}main () { initialsem(limit,5); cobegin { HelloA(); HelloB(); HelloC(); HelloD(); HelloE(); }}


Primjer 8: Simulacija instrukcije TestAndSet TestAndSet je najprimitivnija potrebna mašinska instrukcija za realizaciju

konkurentnosti. Ona daje kao rezultat prethodnu vrijednost memorijske lokacije i postavlja je na 1. Pazite na tackazarez iza naredbe

while (test_and_set(lock)) /* wait */ ;Ukidanjem ove while petlje, procesi se razmjenjuju prilikom ispisa na ekran.

sprobajte i verziju bez ove petlje.

atomic int test_and_set(int& target) { int u; u = target; target = 1; return u;}int lock = 0;void proc(int id) { int i = 0; int j; while(i < 10) { while (test_and_set(lock)) /* wait */ ; for (j=1;j<=50;j++) cout << id; lock = 0; i++; }}main() { cobegin { proc(1); proc(2); proc(3); }}

Primjer 9: Monitori Uzajamno isključivanje se može realizovati i smiještanjem procedura unutar monitora.monitor testmon { void HelloA () { cout << "Hello from A" <<endl; } void HelloB () { cout << "Hello from B" <<endl; } void HelloC () { cout << "Hello from C" <<endl; }}main () { cobegin { HelloA(); HelloB(); HelloC(); }}


Primjer 10: Monitorske procedure WAITC i SIGNALC

U ovom primjeru se vidi razlika između semaforskih wait/signal (koje se baziraju na vrijednostima semafora i čekanju ako je ona manja od 1) i monitorskih waitc i signalc (koje koriste condition varijable koje nemaju vrijednost u klasičnom smislu te riječi.

monitor simple_monitor { int finish; condition Cwait; void say_hello (char id) { if ( id == 'C' ) { if ( finish != 2 ) waitc( Cwait ); } cout << "hello from process " << id << endl; if ( id != 'C' ) { finish++; // cout << "id is" << id << " and finish is " << finish << endl; if ( finish == 2 ) signalc( Cwait ); } }// initialise the integer values to 0 init { finish = 0; } }void A(){ say_hello( 'A' ); }void B(){ say_hello( 'B' ); }void C() { say_hello( 'C' ); }main() { cobegin { A(); B(); C(); } cout << " all finished " << endl;}

4.22 Međuprocesna komunikacijaTehnike za međuprocesnu komunikaciju obezbjeđuju metode pomoću kojih

višestruki process mogu da komuniciraju jedan sa drugim. Nabrojimo nekoliko tehnika za međuprocesnu komunikaciju koje su na raspolaganju u Linuxu:

o Jednosmjerni UNIX pipe-i (neimenovani)


o Imenovani pipe-io Redovi za poruke tipa SYSVo Skup semafora tipa SYSVo dijeljena memorija tipa SYSVo Mrežni socketi tipa Berkeleyo Dvosmjerni pipe-i (STREAMS pipe-i)

Kada se koriste ove tehnike efikasno, obezbjeđuju dobru platformu za razvoj aplikacija tipa klijent / server na bilo kojem UNIX-u, uključujući i Linux.

4.23 Neimenovani UNIX pipe-iPipe predstavlja jednosmjeran komunikacioni kanal između dva procesa u

UNIX-u. Bilo koji pipe ima dva kraja: jedan za pisanje i jedan za čitanje. Svaki od ovih krajeva ima odgovarajući cjelobrojni deskriptor nešto slično koo datotečni deskriptor. Oba deskriptora su rezultat kreiranja pipe-a sistemskim pozivom pipe(). Koristeći pipe, jedan process može puniti bajte na kraj za pisanja a neki drugi process može preuzimati ovaj tok bajta na kraju za čitanje.

Neimenovani pipe-i se koriste uglavnom da se izmjene poruke između povezanih procesa ( na primjer, između dva procesa dijete koji imaju isti process roditelj). Pipe se može koristiti za međusobnu komunikaciju između procesa roditelj i njegove djece, kao i neku drugu kombinaciju procesa, recimo procesa djeda i unuka i sl. Sa logičke tačke gledišta, pipe je specijalna datoteka i ako je ga kreirao neki proces onda ga mogu koristiti bilo koji par procesa uključujući proces creator kao i sve procese koji je on kreirao. Neimenovani pipe se kreira korišćenjem sistemskog poziva pipe():

ret = pipe (fd);gdje ret predstavlja povratni kod tipa integer a fd predstavlja dvodimenzionalni niz

int fd[2], koji dobija vrijednosti nakon izvršenja sistemskog poziva. Sistemski poziv pipe() vraća 0 ako je uspješan ili -1 u slučaju greške. Ako je sistemski poziv uspješan, onda prvi element fd[0] predstavlja datotećni deskriptor za čitanje i fd[1] predstavlja datotečni deskriptor za pisanje na kreiranom pipe-u.

Na primjer. Neka proces roditelj na početku kreira pipe a zatim kreira dva procesa djete. Jedan od ovih procesa dijete trebao bi da izvrši neke komande u komandnom jeziku ( recimo «who») i da piše rezultat od ove komande u pipe. Drugi proces dijete trebao bi da izvrši neke druge komand (na primjer, “sort”) uzimajući njegov ulaz sa istog pipe-a.

Dakle, potpuni efekat izvršenja dva procesa dijete može se predstaviti kao niz od dvije komade u komandom jeziku ( shell )

who | sort,gdje znak “|“ predstavlja operaciju pipe u komandom jeziku (vidi sliku ispod).U nastavku je dat primjer programa koji se koristi za ove svrhe.

Neimenovani UNIX pipe-i 129

/* Program sa neimenovanim pipe-ima */#include <stdio.h>#include <unistd.h>main (){ int fd[2]; /* Niz od dva deskriptora za neimenovani pipe */ int pid; /* Variabla za identifikacu procesa */ /* Pipe treba kreirati prije bilo kojeg fork()-a Razumjete li zašto ? */ if (pipe(fd) < 0){ perror ("PIPE – greška u kreiranju "); exit (1); } pid = fork (); /* Proces roditelj: kreiranje prvog procesa dijete*/ if (pid == 0) { /* prvi process dijete počinje ovdje */ dup2 (fd[0],0); /* Standarni ulaz će se uzeti sa pipe-a */ close (fd[1]); /* Drugi kraj pipe-a će se zatvoriti za ovaj proces jer se neće koristiti */ execlp ("sort", "sort", 0); /* Pokreni “sort” komandu pipe-a */ } else /* Ovdje process roditelj nastavlja */ pid = fork (); /* Proces roditelj: kreiranje drugog procesa dijete */ if (pid == 0) { /* Drugi process dijete počinje ovdje */ dup2 (fd[1],1); /* Standarni izlaz će biti na kraju pipe-a*/ close (fd[0]); /* Ulaz u pipe je zatvoren za jer se ne koristi */ execlp ("who", "who", 0); /* Komanda “who” koja proslijdi izlaz na pip-e*/ } else { /* Proces roditelj zatvara pipe i čeka da procesi djeca završe */ close (fd[0]); close (fd[1]); wait (0); wait (0); }}

Napomena: Bibliotetska funkcija dup2(fd1,fd2) pravi dupliranje datotečnog deskriptora fd1 u fd2 Ako se fd2 odnosi na već otvodenu datoteku, onda se ova datoteka prvo zatvara. Da bi razumjeli ovu funkciju detaljnije, vidi komandu man dup2.

4.24 Windows API za komunikaciju cijevima i Mail slotovima

Cijevi u Wndowsu služe za komunikaciju aplikacija koristeći funkcije za pisanje datoteka. Kreiraju se sljedećim funkcijama:


• CreatePipe(phReadPipe,phWritePipe,lpPipeAttributes,nSize) Kreira neimenovanu cijev

• CreateNamedPipe(lpName,dwOpenMode,dwPipeMode, nMaxInstances,nOutBufferSize,nInBufferSize,nDefaultTimeOut, lpSecurityAttributes) Kreira imenovanu cijev

• ConnectNamedPipe(hNamedPipe,lpOverlapped); Postavlja server za imenovanu cijev

Pored ovoga komunikacija preko mailslot radi na isti način, samo se koriste druge virutalne datoteke.

Mailslot: virtuelna datoteka kojoj se šalju podaci koristeći funkcije za pristup datotekama LPTSTR SlotName = TEXT("\\\\.\\mailslot\\sample_mailslot");

4.25 Prosljeđivanje porukaOva metoda međuprocesne komunikacije se naziva prosljeđivanje poruka. Metoda

koristi dvije funikcije, send i receive koje predstavljaju jezičke konstrukcije a ne sistemske pozive operativnom sistemu. Kao takve on se mogu ugraditi u bibliotetske funkcije, kao na primjer:

send(odredište, &poruka);ireceive(izvor, &popruka);

Poziv send() salje poruku ka datom odredištu dok poziv receive() prima poruku od odgovarajućeg pošiljaoca, ili od bilo koga, ako mu to nije važno. Ako nema poruke, process koji prima poruke će se blokirati sve dok ne stigne neka poruka. Moguće je napisati alternativnu funkciju receive() koja završava odmah sa kodom greške (tipa nema poruka).

4.26 Projektna pitanja za sistem prosljeđivanja porukaSistem prosljeđivanja poruka ima više problema kod projektovanja nego što su to

imali semafori i monitori, posebno ako su međusobno povezani procesi na različitim računarima u mreži. Na primjer, poruke mogu biti izgubljene u mreži. Da se osiguramo od gubitaka poruka, pošiljaoc može poslati posebnu poruku potvrde uspješnog prijema. Ako pošiljaoc ne primi poruku potvrde prijema unutar nekog vremenskog intervala, on vrši ponovno slanje poruke (retransmisija poruke).

Razmotrimo šta će se desiti ako primaoc primi korektno poruku ali se potvrda o njenom prijemu zagubi. Pošiljaoc će izvršiti retransmisiju poruku tako da će je primaoc dobiti dva puta. Izuzetno je važno da primaoc može razlikovati novu poruku od prethodno primljene poruke. Obično. Ovakav problem se razrješava stavljanjem niza brojeva u svaku originalnu poruku. Ako primaoc primi poruku koja ima isti broj kao već primnjena poruka onda on zna da to predstavlja duplikat poruke i odbaciće je.

Sistemi za prosljeđivanje poruka treba da se bave i pitanjem imenovanja poruka tako da procesi navedeni u operacijama send i receive ne budu nejasni. Autentičnost

Projektna pitanja za sistem prosljeđivanja poruka 131

je takođe pitanje u ovom sistemu prosljeđivanje poruka: kao pošiljaoc može reći da komunicira sa pravim serverom a ne sa “varalicom”? Pored toga postoje i projektna pitanja kada pošiljaoc i primaoc nisu na istim računarima. Jedno od ovih su performance. Kopiranjem poruka od jednog procesa do drugog je uvijek sporuje nego izvršavanje semaforskih operacija ili ulaska u monitor. Da bi poboljšao performance, Cheriton sugeriše ograničenu veličinu poruka koji bi mogle stati u registre a onda prosljeđivati poruke koristeći registre.

4.27 Problem proizvođač – potrošač korsteći prosljeđivanje poruka

Pogledajmo sada kako problem proizvođač potrošač može biti razrješen koristeći tehniku prosljeđivanja poruka. Rješenje je dato na slici ispod. Pretpostavimo da su sve poruke iste veličine i da su poslane a nepotvrđene poruke, baferovane od strane operativnog sistema. U ovom rješenju, ukupno se koristi N poruka. Potrošač počinje slanjem N praznih poruka pošiljaocu. Kada proizvođač ima potrebu da jedan element preda korisniku, on uzima praznu poruku, puni je i šalje primaocu. Na ovaj način, ukupan broj poruka u sistemu ostaje konstantan u vremenu, tako da u njih mogu smjestiti dati iznos memorije unaprijed.

#define N 100 /* number of slots in the buffer */

void producer(void){ int item; message m; /* message buffer */ while (TRUE) { item = produce_item(); /* generate something to put buffer */ } receive(consumer, &m); /* wait for an empty to arrive */ build_message(&m, item); /* construct a message to send */ send(consumer, &m); /* send item to consumer */}

void consumer(void) { int item, i; message m; for (i = 0; i < N; i++) send(producer, &m); /* send N empties */ while (TRUE) { receive(producer, &m); /* get message containing item */ item = extract_item(&m); /* extract item from message */ send(producer, &m); /* send back empty reply */ consume_item(item); /* do some1thing with the item */ }}

Ako proizvođač radi brže od potrošača, sve poruke će se napuniti. Proizvođač će se blokirati čekajući na jednu praznu poruku koj atreba da dođe. Ako potrošač radi brže,


onda će se slično desiti: sve poruke će biti prazne čekajući od proizvođača da ih napuni, dok će se potrošač blokirati čekajući na pune poruke.

Mnoge varijante su moguće sa prosljeđivanjem poruka. Za početak, da vidimo kako se adresiraju poruke. Jedan način je da se pridruži svakom procesu jedinstvena adresa na koju bi se smještala poruka. Drugi način je da se definiše struktura podataka, nazvana poštansko sanduče (engl. mailbox). Poštansko sanduće je mjesto u koje se smješta jedan broj poruka, koji se navede kod kreiranja mailbox-a. Kada se koriste mailbox-i onda su adresni parametric u operacijama send i receive mailbox-i a ne process. Kada jedan process pokuša da pošalje u mailbox koji je pun, dolazi do blokiranja procesa sve dok se bar jedna poruka ne ukloni iz mailbox-a čineći prazan prostor za novu poruku.

Za problem proizvođač potrođač, i proizvođač i potrošač bi trebali kreirati mailbox-e dovoljne dužine da drže N poruka. Proizvođač će poslati poruke koje sadrže podatke u mailbox potrošača, a potrošač će poslati prazne poruke u mailbox proizvođača. Kada se koriste mailbox-i mehanizam baferovanja je jasan: odredišni mailbox drži poruke koje su poslane ka procesu potrošač ali nisu još potvrđene.

Drugi ekstrem, kod rada sa mailbox-a, je elimisanje baferovanja. Kod ovakvog pristupa imamo sljedeću situaciju. Ako je send izvršen prije receive, proces koji šalje se blokira dok se ne probudi potrošač i izda receive. U tom momentu se poruka kopira direktno od pošiljaoca ka primaocu bez baferovanja. Slično, ako je prvo receive izvršen, primaoc se blokira dok se jedan send ne desi. Ova strategija je poznata pod nazivom randezvous. Lakša je za implementaciju od baferovanja poruka ali je manje fleksibilna pošto i pošiljaoc i primaoc su priniđeni da se izvršavaju.

Kod operativnog sistema MINIX 3, koristi se metoda rendezvous sa fiksnom veličinom poruka za za komunikaciju unutar operativnog sistema. Korisnički procesi, takođe koriste ovu metodu za komunikaciju sa komponentama operativnog sistema. Međuprocesna komunikacija između korisničkih procesa u MINIX 3 ( i UNIX-u) se izvodi preko pipe-a, koji u suštini predstavljaju mailbox-e. Jedina suštinska razlika između sistema za prosljeđivanje poruka i pipe mehanizma je da pipe-i ne čuvaju granice poruka. Drugim rječima, ako jedan process piše 10 poruka od 100 bajta u pipe a drugi process process čita 1000 bajta iz pipe-a, process koji čita dobiće svih 10 poruka odjednom. Kod sistema sa prosljeđivanje poruka, svaka operacija read vraća samo jednu poruku. Međutim, ako se procesi unaprijed «dogovore» da da čitaju i šalju poruke fiksne dužine ili ograničene nekim «graničnikom» koji označava kraj poruke, problemi se neće desti.

Sistem za prosljeđivanje poruka se uglavnom koristi kod sistema sa paralelnim programiranjem. Jedan dobro poznati sistem za prosljeđivanje poruka je MPI (engl. Message Passing Interface). Ima široku primjenu u naučnim obradama.

4.28 Windows API, prosljeđivanje porukaSve windows aplikacije osim nekih konzolnih koriste poruke za komunikaciju

između prozora. Neke funkcije za prosljeđivanje poruka su:

Windows API, prosljeđivanje poruka 133

• GetMessage(lpMsg,hWnd, wMsgFilterMin, wMsgFilterMax) Preuzima sljedeću poruku u redu čekanja na sve poruke između prozora i čeka ako nema poruka

• PeekMessage(lpMsg,hWnd, wMsgFilterMin, wMsgFilterMax,wRemoveMsg) Preuzima sljedeću poruku u redu čekanja na sve poruke između prozora ali ne čeka ako nema poruka

• DispatchMessage(lpmsg) Šalje narednu poruku u redu čekanja Windows sam odredi kojem prozoru je namijenjena

• SendMessage (hWnd, Msg,wParam,lParam) Direktno šalje poruku navedenom prozoru

Svaka poruka ima svoj kod. Za prebacivanje podataka opšte namjene se koriste poruke koda WM_COPYDATA, ili WM_DDE_DATA. Ako se koriste WM_DDE_DATA treba inicijalizacija komunikacije koristeći poruke WM_DDE_ADVISE, WM_DDE_INITIATE, inicijalizacija DDE prijenosa

4.29 Posix API za porukeU POSIX API poruke se prosljeđuju sljedećim funkcijama.• mq_open(pcName, iOflag) Povezuje se na red poruka• mq_close(mqdes) Završava konekciju s otvorenim redom poruka• mq_unlink(pcName) Završava konekciju s otvorenim redom poruka i nakon

zadnje poruke uklanja i red poruka• mq_send(mqdes, pcMsg_ptr,iMsg_len, uiMsg_prio) Stavlja poruku u red

poruka• mq_receive(mqdes, pcMsg_ptr,iMsg_len, pMsg_prio) Prima i uklanja

najstariju najprioritetniju poruku• mq_notify(mqdes, pSevp) Izvještava proces ili nit da je poruka dostupna u

redu čekanja• mq_setattr(mqdes, pNewattr, pOldattr)• mq_getattr(mqdes, struct mq_attr *attr) Postavlja ili čita atribute reda čekanja

poruka

4.30 SignaliSignali predstavljaju kompleksne operacije za upravljanje procesima. Signal je

neka vrsta prekida programa. Na primjer, kada pritisnete CTRL^C onda šaljete signal SIGINT ka vašem programu. Kada napravite grešku kod pristupa nedozvoljenom segmentu onda se signal SIGSEGV šalje vašem programu.

Vaš program ima više načina da radi sa signalima. Unaprijed su definisane određene akcije koje će se desiti na pojavu određenih signala. Na primjer, kada pritisnete CTRL^C program će obično završiti izvođenje. Ova akcija je predefinisana za signal SIGINT. Kada pritisnete CTRL^\ ili pristupite nedozvoljenom segmentu vaš program će napraviti sliku memorije kod pada (engl.


dump core) i završiti izvođenje. Ovo su primjeri predefinisanih akcija za signale SIGQUIT i SIGSEGV.

Možete predefinisati akcije procesa kada dobijete signal i na taj način možete napisati vrlo fleksibilne programe. Kada se signal generiše, operativni sistmem preuzima procesor od tekućeg procesa koji se izvršavao. On spašava tekuće stanje prekinutog procesa na stek i poziva handler prekida za dati signal. Na primjer, predefinisani handler prekida za SIGINT uzrokuje da program završi izvođenje. Predefinisani handler prekida za SIGSEGV i SIGQUIT uzrokuje da program napravi sliku memorije kod pada i završi izvođenje. Po završetku izvođenja handlera prekida operativni sistem preuzima kontrolu i vraća stanje prekinutog procesa sa steak. Program obično nastavlja na mjestu gdje je prekinuo ali u nekim slučajevima i ne.

Može se koristiti funkcija signal() za definisanje handlera prekida. Za više informacija vidjeti komandu man 3v signal, ili sličnu u zavisnosti od sistema.

Primjer 1 - s1.c#include < signal.h >void cntl_c_handler(int dummy) { printf("Pritisnuli ste cntl-c\n"); signal(SIGINT, cntl_c_handler);}main() { int i, j; signal(SIGINT, cntl_c_handler); for (j = 0; j < 40; j++) { for (i = 0; i < 1000000; i++); }}

Signali 135

Ovaj program postavlja handler prekida za signal SIGINT. Kada korisnik pritisne CTRL^C operativni sistem će spasiti stanje programa i izvršiti cntl_c_handler. Po povratku iz handlera prekida operativni sistem nastavlja izvršavanje programa od mjesta gdje je prekinut. Svaki put kad se pritisne CTRL^C izvršiće se cntl_c_handler.

Takođe treba primjetiti u primjeru 1 da je napravljen ponovni signal() da bi se opet pozvao handler prekida. Kod nekih sistema ako se ovo ne napravi onda se instalira predefinisani handler prekida za CTRL^C. Na nekim sistemima ne trebate raditi ponovni signal().

Može se raditi sa različitim signalima u programu. U primjeru 2 definišu se različiti handleri signala i to za CNTL-C (koji je SIGINT), i CNTL-\ (koji je SIGQUIT). Program štampa vrijednosti i i j kada se generiše signal. Primjetite da varijable i i j moraju biti globalne varijable. Ovo je primjer kada morate koristiti globalne varijable.


Primjer 2 – c2.c

#include <signal.h>int i, j;void cntl_c_handler(int dummy) { printf("Pritisnuli ste cntl-c. j je %d - i je %d\n", j, i); signal(SIGINT, cntl_c_handler);}void cntl_bs_handler(int dummy) { printf("Pritisnuli ste cntl-\\. j je %d - i je %d\n", j, i); signal(SIGQUIT, cntl_bs_handler);}main() { signal(SIGINT, cntl_c_handler); signal(SIGQUIT, cntl_bs_handler); for (j = 0; j < 200; j++) { for (i = 0; i < 1000000; i++); }}

Poslije kompiliranje i pokretanja programa i višestrukog pritiskanja CNTL^C i CNTL-\:

UNIX> c2^CPritisnuli ste cntl-c. j je 2 - i je 539943^CPritisnuli ste cntl-c. j je 2 - i je 919180^\Pritisnuli ste cntl-\. j je 4 - i je 413031^CPritisnuli ste cntl-c. j je 5 - i je 20458^\Pritisnuli ste cntl-\. j je 6 - i je 73316^\Pritisnuli ste cntl-\. j je 6 - i je 683034^CPritisnuli ste cntl-c. j je 7 - i je 292244^CPritisnuli ste cntl-c. j je 13 - i je 738661^\Pritisnuli ste cntl-\. j je 14 - i je 789583^\Pritisnuli ste cntl-\. j je 16 - i je 42225^\Pritisnuli ste cntl-\. j je 16 - i je 209458^CPritisnuli ste cntl-c. j je 17 - i je 260584^\Pritisnuli ste cntl-\. j je 19 - i je 982514UNIX>

4.31 Alarmi Drugi način korišćenja signalnih handlera je «sat sa alarmom». Funkcija alarm(n)

po povratku poslije n sekundi će uzrokovati da se desi signal SIGALRM. Ako ste postavili singlani handler za ovaj signal onda ga možete «uhvatiti» i uraditi što god želite da uradite. Na primjer, c3.c je kao c1.c samo što štampa poruku poslije izvršavanja programa od 3 sekunde. Primjetimo da funkcija alarm() radi sa aproksimiranim vrijednostima – to nije baš tri sekunde i smatraćemo ga bliskim toj vrijednosti. Za više informacija vidi man stranice za funkciju alarm().

Alarmi 137

#include <signal.h>int i, j;void alarm_handler(int dummy){ printf("Tri sekunde su prošle: j = %d. i = %d\n", j, i); signal(SIGALRM, alarm_handler);}main() { signal(SIGALRM, alarm_handler); alarm(3); for (j = 0; j < 200; j++) { for (i = 0; i < 1000000; i++); }}

UNIX> c3

Tri sekunde su prošle: j = 26. i = 638663UNIX>

Na kraju, primjer c4.c pokazuje kako vam UNIX može slati alarm svake sekunde.

Program - c4.c

#include <signal.h>int i, j, seconds;void alarm_handler(int dummy) { seconds++; printf("%d second%s just passed: j = %d. i = %d\n", seconds, (seconds == 1) ? "" : "s", j, i); signal(SIGALRM, alarm_handler); alarm(1);}main() { seconds = 0; signal(SIGALRM, alarm_handler); alarm(1); for (j = 0; j < 200; j++) { for (i = 0; i < 1000000; i++); }}UNIX> c41 second just passed: j = 8. i = 8235342 seconds just passed: j = 17. i = 7157353 seconds just passed: j = 26. i = 6106044 seconds just passed: j = 35. i = 513675UNIX>

138 Upravljanje resursima i potpuni zastoji

5 Upravljanje resursima i potpuni zastoji 5.1 Poptuni zastoji (engl. Deadlocks)

Računarski sistemi sadrže veliki broj resursa čije je istovremeno korištenje ograničeno na samo jedan proces. Tipični primjeri su printeri, uređaji za trake, sistemske tabele. Operativni sistemi moraju imati mogućnost da u određenom vremenskom periodu dodijele odgovarajući resurs samo jednom procesu.

Puno aplikacije postavlja zahtjev za samostalno korištenje više resursa odjednom. Uzmimo kao primjer dva procesa koji žele skenirati dokument i snimiti ga na CD. Proces A rezerviše skener, proces B radi nešto drugo i prvo zahtjeva CD pisač. U slijedećem koraku proces A pokušava dobiti pristup CD pisaču što ne uspjeva pošto ga proces B još nije pustio. Proces B zahtjeva skener umjesto da oslobodi CD pisač. U tom trenutku su oba procesa blokirana i ne mogu izaći iz ove situacije. Ovakva situacija se zove potpuni zastoj (engl. deadlock). Potpuni zastoji se mogu dešavati i na mreži, gdje se uređaji printer i skener dijele između korisnika. Kada ovi resursi mogu biti rezervisani sa bilo kog računara može doći do iste vrste zastoja. Još komplikovanija situacija se može desiti ukoliko je u igri više korisnika i više uređaja.

Potpuni zastoji se mogu izazvati ne samo zbog U/I uređaja nego i zbog puno drugih situacija. Npr. u aplikacija sa bazom podataka može se desiti da program blokira dio podataka na kojima radi da nebi došlo do preklapanja. Kad proces A blokira skup podataka R1 i proces B blokira skup podataka R2, i kad svaki pokušava doći do skupa podataka onog drugog imamo situaciju sa potpunim zastojem. Zaključak je da potpuni zastoji dolaze kako kroz hardverske tako i kroz softverske resurse.

Potpuni zastoj se može definisati na slijedeći način:Skup procesa se nalazi u stanju potpunog zastoja ako svaki proces u skupu

čeka na neki događaj koji može proizvesti jedino neki proces iz tog skupa.S obzirom da svi procesi čekaju ni jedan od njih neće izazvati neki od događaja

koji mogu probuditi neki od procesa iz skupa, i svi procesi nastavljaju da čekaju zauvijek. Za ovaj model pretpostavlajmo da procesi imaju samo jednu programsku nit i da nema mogućih prekida koji bi probudili blokirani proces. Stanje bez prekida sprečava npr. da neki alarm probudi proces koji bi mogao izazvati događaj koji bi opet oslobodio druge procese. U većini slučajeva, svaki član skupa čeka da oslobađanje resursa koje trenutno zauzima drugi proces. Drugim riječima skup procesa u potpunom zastoju čeka na resurse koje posjeduje skup procesa u potpunom zastoju. Ni jedan proces se ne može aktivirati, ni jedan ne može osloboditi resurse i ni jedan ne može biti probuđen. Broj procesa i broj i vrsta resursa nisu važni. Ova izjava važi za bilo koju vrstu resursa, hardversku i softversku.

5.2 ResursiRezervisane objekte nazivamo jednim opštim imenom resursi. Resurs može biti

fizički uređaj ali i jedinica informacije.

Oduzivi i neoduzivi resesursi 139

5.3 Oduzivi i neoduzivi resesursiPostoje dvije vrste resursa: oduzivi i neoduzivi resursi. Oduzivi resurs (engl.

preemptable) može biti oduzet procesu, koji ga posjeduje, bez loših posljedica. Jedan primjer za to je memorija.

Primjer za ovo nalazimo u jednom sistemu sa 32MB memorije i jednim printerom. U sistemu su aktivna 2 procesa veličine 32MB koji žele nešto printati. A rezerviše printer i počinje sa obradom podataka koji se trebaju isprintati. Prije nego što je završio biva prekinut pošto je prekoračio svoj dodjeljeni vremenski intreval. Nakon toga se izvršava proces B koji bezuspješno pokušava rezervisati printer. Nalazimo se u jednoj mogućoj situciji potpunog zastoja s obzirom da A posjeduje printer a B memoriju, i ni jedan ne može dalje raditi bez resursa onog drugog. Na sreću, moguće je od procesa B oduzeti memoriju i dodjeliti je procesu A, sada A može završiti započeti posao, i ne dolazi do potpunog zastoja.

Nasuprot tome, neoduzivi resursi (engl. nonpreemptable) ne mogu biti oduzeti vlasniku, a da ne dođe do greške. Oduzeti CD pisač procesu koji zapisuje podatke na CD značilo bi uništiti CD.

Korištenje jednog resursa sastoji se iz tri slljedeća koraka:1. zahtjev za resursom (engl. request),2. korištenje resursa (engl. use),3. oslobađanje resursa (engl. release).Ako je resurs zauzet, proces koji ga zahtjeva mora čekati. Neki operativni sistemi

automatski blokiraju proces, ako dođe do neuspunjenog zahtjeva za resursom i bude ga (aktiviraju) kad je resurs slobodan. Drugi javljaju grešku, a proces sam mora čekati i kasnije ponovo pokušati. Proces kome jedan zatraženi resurs nije dodjeljen nalazi se u jednoj petlji: zatraži resurs, kratko čeka i onda ponovo zatraži isti resurs. Iako ovakav proces nije blokiran praktično se može smatrati blokiranim jer on ne radi ništa korisno.

Kod nekih vrsta resursa, sam se proces brine za dodjelu resursa (npr. baze podataka). Jedna mogućnost upravljanja resursima je dodjela semafora svakom resursu.

5.4 Uslovi za pojavu potpnog zastojaPrema Coffman et al. (1971) sljedeći uslovi moraju biti ispunjeni za potpuni zastoj:1. Uzajamno isljučivanje. Svaki proces ili je dodjeljen tačno jednom

procesu ili je dostupan. Drugi proces koji zahtijeva taj isti resurs, mora čekati dok se resurs ne oslobodi.

2. Stanje prisvajanja resursa i čekanja na drugi (engl. hold and wait condition) Proces koji trenutno drži resurse dodijeljene ranije može zatražiti nove resurse.

3. Nema oduzivih resursa (engl. no preemption condition). Prethodno dodjeljeni resursi ne mogu biti nasilno oduzeti procesu. Proces ih mora samostalno osloboditi.

4. Kružno čekanje (engl. circular wait condition). Mora postojati kružni lanac dva ili više procesa, od kojih svi čekaju na resurs koji drži sljedeći član lanca.


Ova sva četri stanja moraju biti prisutna da bi došlo do potpunog zastoja. Ako je jedan odustan, potpuni zastoj nije moguć.

5.5 Modeliranje potpunog zastoj (graf dodjele resursa)Ova četri uslova se mogu modelirati uz pomoć grafova. Graf se sastoji od skupa

objekata - čvorova i skupa strelica. Grafovi imaju dvije vrste čvorova. Procesi koji su predstavljeni kao krugovi i resursi predstavljeni kvadratom. Strelica od resurs-čvora ka jednom proces-čvoru znači da su resursi zatraženi od procesa i da ih on zauzima.

Slika prikazuje modeliranje potpunog zastoja pomoću grafova. Strelica od procesa ka resursu znači da proces čeka na resurs. Treća slika prikazuje stanje potpunog zastoja: proces C čeka na resurs T koji je upravo zauzet od procesa D. Proces D ne pušta resurs T zato što čeka na resurs U koji je zauzet od procesa C. Oba procesa će vječno čekati.

Sa grafa se može uočiti stanje zastoja:- ukoliko graf ne sadrži kružni tok, zastoja sigurno nema;- ako graf sadrži najmanje jedan kružni tok zastoj je moguć. Kad svi resursi koji

pripadaju kružnom toku sadrže tačno jednu instancu, zastoj se dogodio. Ukoliko resursi u kružnom toku sadrže više instanci, može se desiti da zastoja nema.

Pogledajmo sada primjer gdje grafovi za modeliranje potpunog zastoja mogu biti korišteni. Imamo tri procesa A, B i C i tri resursa R, S i T. Slike (a) – (c) nam prikazuju kako se resursi rezervišu i oslobađaju. Operativni sistem može u svakom trenutku aktivirati bilo koji neblokirani proces. Može izvršiti proces A, zatim kad je on gotov proces B a zatim proces C. Ovaj redosljed ne vodi potpunom zastoju pošto ne postoji konkurencija oko resursa ali nema ni paralelnog izvršavanja procesa. Ovo tzv. sekvencijalno izvođenje procesa nije optimalno.

Modeliranje potpunog zastoj (graf dodjele resursa) 141

Pretpostavimo sada da koristimo Round Robin algoritam raspoređivanja. Mogući redosljed zahtjeva je prikazan na slici (d). Slike (e) - (j) pokazuju 6 pripadajućih grafova. Nakon četvrtog zahtjeva A blokira i čeka da se S oslobodi. U slijedeća dva koraka blokiraju B i C što na kraju vodi potpunom zastoju na slici (j).

Međutim operativni sistem može izabrati redosljed izvršavanja. On može odbiti dodjeljivanje resursa nekom procesu ako bi to vodilo potpunom zastoju i umjesto toga blokirati proces. Ako operativni sistem prepozna mogućnost potpunog zastoja može blokirati proces B umjesto da mu dodjeli resurs S. Situacija za zahtjevima i odobrenjima na slijedećoj slici (l) – (q) ne vodi ka potpunom zastoju. Nakon koraka (q) proces B može dobiti resurs S, jer je A gotov a C ima sve što mu je potrebno. Takođe ako B kasnije traži T i zatim bude blokiran ne dolazi do potpunog zastoja zato što C može završiti i onda osloboditi T.


5.6 Grafovi modeliranja zastoja sa više resusra iste vrsteSkupovi procesa P, resursi R i strelica dodjele i zahtjeva E:P = {P1, P2, P3, P4}R = {R1, R2, R3, R4}E = {P1 → R1, P2 → R3, R1 → P2,R2 → P2, R2 → P1, R3 → P3}Instance sredstava:jedna instanca resursa R1 dvije instance resursa R2jedna instanca resursa R3 dvije instance resursa R4Stanja procesaproces P1 drži jednu instancu resursa R2 i čeka na resurs R1,proces P2 drži resurs R1 i jednu instancu resursa R2, a čeka na resurs R3.proces P3 drži resurs R3.

Sljedeći slučaj predstavlja potpuni zastoj

Sljedeći primjer pokazuje da kada ima više resursa iste vrste da postojanje kružnog čekanja ne znači nužno potpuni zastoj. Kada proces P4 završi s radom, tada se može

Grafovi modeliranja zastoja sa više resusra iste vrste 143

ispuniti zahtjev procesa P3, koji zatim svojim završetkom oslobađa i P1. Postoji i drugi način razrješenja (Koji?)

5.7 Strategije rješavanja potpunog zastojaU osnovi postoje četiri strategije za rješavanje problema potpunog zastoja:1. Ignorisati problem.2. Prepoznati i otkloniti. Dozvoliti pojavu potpunog zastoja, prepoznati potpuni

zastoj i nešto poduzeti protiv toga.3. Dinamičko sprečavanje kroz pažljivo upravljanje resursima (Izbjegavanje

potpunog zastoja).4. Sprečavanje potpunog zastoja. Treba se pobrinuti da jedan od četri uslova

koji su neophodni za potpuni zastoj ne bude ispunjen.

5.8 Nojev algoritam - ignorisanje problemaNajjednostavniji algoritam je nojev alogoritam. Zavući glavu u pijesak i praviti se

kao da problem ne postoji. Mišljenja o ovom algoritmu su podjeljena. Mamtematičari uglavnom misle da potpuni zastoji trebaju po svaku cijenu biti spriječeni. Inženjeri se pitaju koliko se često pojavljuje potpuni zastoj i koliko često sistem iz nekog drugog razloga ne funkcionioše. Ako se potpuni zastoj u prosjeku pojavi jednom u pet godina a drugi hardverski ili softverski problemi se javljaju puno češće, čak sedmično, ulaganja u otklanjanje ili sprečavanje potpunog zastoja se ne isplate.

Unix i Windows, ignorišu ovaj problem, jer većina korisnika povremeno pojavljivanje potpunog zastoja neće smetati.

5.9 Detekcija i otklanjanje potpunog zastojaDrugi način je prepoznavanje i otklanjanje potpunog zastoja. Kod ove tehnike

sistem ne pokušava da sprječi pojavljivanje potpunog zastoja. Umjesto toga, potpuni zastoji su dozvoljeni a sistem pokušava da ih prepozna i da učini nešto da ih otkloni.

U ovom slučaju sistem mora obezbijediti:


- algoritam za detekciju zastoja, koji ispituje da li je došlo do zastoja,- algoritam za oporavak od zastoja.

5.10 Detekcija potpunog zastoja sa jednim resursom svakog tipa

Za jedan sistem sa po jednim resursem svakog tipa možemo predstaviti grafom na slici. Ako ovaj sistem sadrži jednu ili više petlji, nalazi se u stanju potpunog zastoja.

1. A zauzima R i zahtjeva S.2. B ne zauzima ništa, zahtjeva T.3. C ne zauzima ništa, zahtjeva S.4. D zauzima U, zahtjeva S i T.5. E zazuzima T i zahtjeva V.6. F zauzima W i zahtjeva S.7. G zauzima V i zahtjeva U.Postavlja se pitanje je da li je ovaj sistem u potpunom zastoju i ako jeste, ko

učestvuje u potpunom zastoju?

Može se lako prepoznati da graf sadrži jednu petlju. Ova petlja odgovara potpunom zastoju u kome učestvuju procesi D, E i G. Procesi A, C i F ne učestvuju u petlji a resurs S se dodjeljuje procesima po redu, jedan za drugim.

Iako je relativno jednostavno petlju, tj potpuni zastoj prepoznati koristeći grafički prikaz, u stvarnim sistemima su nam potrebni algoritmi.

Slijedeći primjer algoritma je vrlo jednostavan. On se završava čim nađe petlju ili kad ne postoji nikakva petlja, od podataka koristi listu čvorova. Dok radi, algoritam označava pregledane čvorove da bi izbjegao ponovno pregledanje. Algoritam uzima svaki čvor iz grafa, i posmatra ga kao korijen stabla, koje se provjerava u dubinu, ukoliko naiđe na čvor koji je već provjeravao to znači da je pronašao potpuni zastoj. Ako su sve linije koje vode dalje od čvora već označene, skače na prethodni čvor. Kada dođe do startnog čvora i ne može ići dalje ovaj dio grafa je slobodan od petlje, ako ovo važi za čitav graf, sistem nema potpunog zastoja.

Pokazaćemo to na datom primjeru. Redosljed je proizvoljan.-Uzmimo prvi čvor R i inicijaliziramo L kao praznu listu. Slijedimo jedini mogući

put ka A, L=[R,A]. Od A idemo ka S, S je ćorsokak, pa se moramo vratiti na A,

Detekcija potpunog zastoja sa jednim resursom svakog tipa 145

od A nemamo drugih linija i vraćamo se ka R. Sa ovim je naša obrada čvora R završena.

-Sad pokrećemo algoritam od A i inicijaliziramo praznu listu i ova pretraga se brzo završava nastavljamo se B dalje. Sad lista sadrži B,T,E,V,G,U,D. Na ovom mjestu slučajno biramo jednu od linija koje vode od D. Ako biramo S nalazimo se u ćorsokaku i vraćamo se na D i preostaje nam samo T. Tako da lista sadrži B,T,E,V,G,U,D,T. Našli smo petlju i algoritam završava svoj rad.

5.11 Detekcija potpunog zastoja sa više resursa svakog tipa

Kada postoji više instanci jednog resursa, potreban je drugi pristup za detekciju potpunog zastoja. Opisujemo algoritam baziran na matricama za prepoznavanje potpunog zastoja među porcesima P 1 do P n . Broja klasa resursa je m sa E i resursa klase i (1 ≤ i ≤ m ).E je vektor resursa i daje broj resursa koje od svake klase imamo na raspolaganju. U svakom trenutku su neki resursi zauzeti. Vektor resursa A sadrži za svaki resurs i broj slobodnih instanci. Potreben su nam još dvije matrice, matrica alociranja C i matrica zahtjeva R. Red i matrice C sadrži broj resursa koje od svake klase zauzima proces P i . C ij je broj resursa

klase j, koje proces i zauzima. Analogno je R ij broje resursa j koje bi proces i

želio. Slika prikazuje opisanu strukturu podataka.

Pošto je svaki resurs slobodan ili zauzet važi slijedećen

∑Cij + Aj = E ji=1Drugim rječima, za svaku klasu resursa je suma svih zauzetih resursa i svih

slobodnih resursa jednaka ukupnom broju resursa.Algoritam za detekciju potpunog zastoja zasniva se na poređenju vektora.

Definišemo relaciju ≤ tako da A ≤ B, kada je svaki element A, manji ili jednak odgovarajućem elementu B.


Na počretku algoritma je svaki proces neoznačen. Kada se jedan proces označi, to znači da on može do kraja završiti svoj rad i nije uključen u neki potpuni zastoj. Kada se algoritam završi, svaki neoznačeni proces učestvuje u nekom potpunom zastoju.

Algoritam za detekciju potpunog zastoja glasi:1. Traži jedan neoznačeni proces P i , za koji je i-ti red R manji ili jednak A.

2. Ako takav proces postoji, saberi i-ti red C sa A, označi proces i idi na korak 1.3. U suprotnom završi algoritam.Ako se neki procesi nikad ne mogu izvršiti nalaze se u potpunom zastoju. Slika

prikazuje primjer na kome možemo isprobati algoritam. U ovom primjeru imamo tri procesa i četri klase resursa. Proces 1 zauzima jedan skener, proces 2 dvije trake i jedan CD. Proces 3 zauzima jedan ploter, i dva skenera. Matrica R pokazuje koje resurse svakom procesu još dodatno trebaju. Da bi smo izveli naš algoritam tražimo prvo proces čiji zahtjevi mogu biti ispunjeni. Treći proces traži resurse koji su još dostupni. On se izvršava i oslobađa svoje resurse, A=(2,2,2,0). Sad proces 2 može dalje raditi i nakon što je on oslobodio svoje resurse A=(4,2,2,1). Sad se može izvršiti zadnji proces tako da nema potpunog zastoja.

5.12 Oporavak od potpunog zastojaPretpostavimo da je algoritam za detekciju potpunog zastoja bio uspješan i otkiro

jedan potpuni zastoj. Šta se sad dešava? Postoji li mogućnost za otklanjanje potpunog zastoja i pokretanje sistema. Sada ćemo razmotriti mogućnosti za oporavak od potpunog zastoja.

5.13 Oporavak pomoću oduzimanjaU neki slučajevima je moguće jednom procesu oduzeti neki resurs te ga dodjeliti

drugom procesu. Često se ovo radi manuelno, naročito kod mainframe računara sa batch pogonom. Da li je moguće jednom procesu oduzeti resurs i staviti ga na raspolaganje drugom procesu i na kraju ga ponovo dati prvom procesu, a da on to ne primjeti zavisi jako od vrste resursa. Otkloniti potpuni zastoj na ovaj način je često

Oporavak pomoću oduzimanja 147

nemoguće. Izbor procesa koji se suspendira zavisi prvenstveno koje je lako oduzeti i ponovo bratiti.

5.14 Oporavak pomoću povratka na staro stanje (engl. rollback)

Kada sistem dizajner zna da su potpunoi zastoji mogući, mogu se pobrinuti za to da stanja procesa budu u ravnomjernim razmacima (engl. checkpoint) zapisana tako da proces može kasnije nastaviti rad počev od te tačke. Checkpoint sadrži sadržaj memorije i pripadajuće resurse. Ovaj metod je najuspješniji kada novi checkpoint ne prepiše stari.

Kada se primjeti potpuni zastoj, proces koji posjeduje potrebne resurse će se vratiti na tačku (checkpoint) u kojoj još nije rezervisao te resurse. Rad iza ove tačke će biti izgubljen. Oslobođeni resursi se dodjeljuju drugom procesu koji učestvuje u potpunom zastoju. Kada vraćeni proces pokušava dobiti resurse, mora čekati dok oni opet ne budu slobodni.

5.15 Oporavak ubijanjem procesaNajjednostavniji ali i najgrublji način otklanjanja potpunog zastoja je prekid

rada jednog ili više procesa. Pri tome se može raditi o jednom procesu iz petlje. Sa malo sreće ostali procesi mogu dalje raditi. Ako ne, mogu se prekinuti i dalji procesi dok se ne prekine potpuni zastoj. Alternativno, žrtva može biti i neki drugi proces koji ne učestvuje u petlji, i pri tome se veoma pažljivo mora izabrati proces koji zauzima resurse potrebne nekom procesu u petlji. Kada je to moguće treba prekinuti onaj proces koji se bez neugodnih pojava ponovo pokrenuti.

5.16 Izbjegavanje potpunog zastojaIzbjegavanje zastoja je moguće ukoliko operativni sistem ima informacije o

procesima i resursima koje će oni zahtijevati prilikom svog izvršenja. Sistem koji zna šta proces želi, može napraviti redosljed opsluživanja zahtjeva tako da izbjegne potpuni zastoj. Prilikom svakog novog zahtjeva za resursom, sistem analizira trenutno stanje resursa i nakon toga odlučuje da li će se resurs dodijeliti procesu koji je postavio zahtjev ili će se taj proces blokirati kako bi se izbjegao potpuni zastoj. Do sad smo pretpostavljali da jedan proces sve resurse zahtjeva odjednom što uglavnom nije slučaj. Sistem smije dodijeliti resurs procesu ukoliko je to bezopasno. Postavlja se pitanje može li se potpuni zastoj pouzdano sprječiti kroz donošenje pravih odluka prilikom dodjele resursa. Potpuni zastoj se može sprječiti ali samo kad unaprijed posjedujemo potrebne informacije.

5.17 Trajektorije resursaNajznačajniji algoritam za sprečavanje potpunog zastoja bazira se na konceptu

sigurnih stanja.


Na slici vidimo model koji se bavi sa dva procesa i dva resursa, npr. printerom i ploterom. Horizontalna koordinata predstavlja broj instrukcija koje izvodi proces A. Vertikalna koordinata predstavlja instrukcije koje izvodi proces B. U tački I1 proces A treba printer a u tački I2 ploter. Printer i ploter će biti oslobođeni u I3 i I4. Proce B treba ploter od I5 do I7 i printer od I6 do I8. Svaka tačka u dijagramu predstavlja zajedničko stanje oba procesa. Dok ni jedan ne radi stanje je u polaznoj tački p. Ako raspoređivač prvo pokrene A dolazimo do tačke q. U ovom trenutku trajektorij se kreće prema gore što znači da B počinje raditi. Sa samo jednim procsorom putevi mogu voditi ili horizontalno ili vertikalno. Treba naglasiti da je kretanje na trajektoriju resursa je uvijek prema desno ili prema gore. Nikad prema dole ili lijevo pošto procesi ne mogu raditi unazad. Čim A na putu od r ka s pređe I1, rezerviše printer. U tački t rezerviše B ploter. Označeni dijelovi su posebno interesantni Područja u kojima oba zauzimaju printer ili oba ploter su nedostižna jer je ovo nemoguće. Ako sistem uđe u područje ograničeno sa I1, I2, I5 i I6 potpuni zastoj se ne može spriječiti. Ovaj čitav kvadrat je nesiguran i u njega se ne smije ući. U tački t je jedina sigurna mogućnost A pustiti da radi do I4. Ovdje je značajna činjenica da B u trenutku t zahtjeva jedan resurs, sistem odlučuje da li će ga on i dobiti. Ako B dobije resurs sistem ulazi u jedno nesigurno područje i zaključno ulazi u potpuni zastoj. Da bi se spriječio potpuni zastoj B treba biti blokiran dok A ne dobije i ploter i oslobodi ga.

5.18 Sigurna i nesigurna stanjaAlgoritam za sprečavanje potpunog zastoja koristi informacije prikazane na slici

(matrice). U svakom trenutku se određuje aktuelno stanje kroz E, A, C i R. Stanje je sigurno kada ne postoji potpuni zastoj i postoji redosljed raspoređivanja koji ne vodi u potpuni zastoj čak i kad svi procesi zatraže maksimalan broj resursa. Ovaj koncept se najbolje može pokazati na primjeru.

Slika prikazuje stanje u kome proces A zauzima tri instance resursa a kasnije će ukupno trebati 9. B zauzima 2 a trebaće ukupno 4. C ima takođe 2 ukupno treba 7. Ukupno postoji 10 instanci resursa, 7 su već zauzeti, a trenutno su još tri dostupna.

Sigurna i nesigurna stanja 149

Stanje na slici (a) je sigurno jer postoji redosljed dodjeljivanja takav da svi procesi mogu završiti svoj rad do kraja. Raspoređivač je rasporedio proces B koji je rezervisao dva dalja resursa (b). Čim je B završio nalazimo se u stanju na slici (c). Sada scheduler može izvršiti C (d). Kad je C završio imamo stanja kao na slici (e). Sada je 6 instanci koje su potreben procesu A slobodno. Stanje na slici (e) je sigurno. Iz ovoga je jasno da sistem može kroz pažljivo raspoređivanje sprječiti potpuni zastoj.

Sada ćemo poćo od istog stanja kao na prethodnoj slici, s tom razlikom da A dobiva jedan dalji resurs što je prikazano na slici (b). Možemo li ovdje pronaći redosljed dodjeljivanja resursa koji je siguran? Raspoređivač može odlučiti da se izvršiti B, (slika (c)). Čim B završi imamo situaciju kao na slici (d). Imamo samo 4 slobodne instance resursa a svaki proces treba 5. Redosljed dodjeljivanja koji bi garantovao izvršenje ne postoji. Ovo nesigurno stanje još uvijek nije potpuni zastoj, može se desiti da čak jedan proces završi svoj rad, da drugi oslobodi neke resurse prije nego što rezerviše nove ali to se u nesigurnom stanju ne može garantovati.

5.19 Bankarski algoritam za jedan resursJedan poznati algoritam za izbjegavanje potpunog zastoja je bankarov

algoritam (engl. Banker´s Algorithm). Ovaj algoritam je proširenje algoritma za detekciju potpunog zastoja. On slijedi primjer kako bankar može zadovoljiti zahtjeve za kreditom jedne grupe ljudi. Algoritam provjerava kod svakog zahtjeva za kredit, da li kredit može voditi ka nesigurnom stanju. Ako kredit vodi sigurnomstanju, biće odobren, ako ne biće odbijen.

Bankarski algoritam se može primijeniti ako su ispunjeni slijedeći uslovi:- resursi imaju uglavnom više instanci;- svaki proces mora unaprijed deklarisati najveći broj instanci svakog resursa

koji želi da koristi;- kad proces zahtijeva resurs, sistem procjenjuje da li će poslije toga ostati u

sigurnom stanju. Ako ostaje u sigurnom stanju, proces će dobiti resurs, u protivnom, proces mora sačekati da drugi proces oslobodi neki resurs;

- proces koji dobije resurse mora ih vratiti u konačnom roku.


Prva slika prikazuje četri korisnika od kojih svaki ima makismalan broj kreditnih jedinica. Bankar zna da neće svi korisnici svoje maksimume odmah iskoristiti zato rezerviše 10 umjesto 22.

U ovoj analogiji su korisnici procesi, kreditne jedinice resursi. Korisnici se brinu za svoj posao i povremeno zatraže kredit. U jednom trenutku imaćemo stanje kao na slici (b). Ovo stanje je sigurno zato što bankar može sve zahtjeve osim C odložiti. Nakon što C završi može se B ili D odobriti kredit. Šta bi bilo kad kada bi B tražio još jednu kreditnu jedinicu. Stigli bi smo u nesigurno stanje (c). Nesigurno stanje ne vodi neizbježno potpunom zastoju jer ne mora značiti da će svi korisnici iskoristiti maksimum.

Bankarski algoritma ispituje svaki zahtjev čim on pristigne i zaključuje da li će rezultat biti sigurno stanje. Da bi utvrdio da li je stanje sigurno, algoritam ispituje da li još ima dovoljno preostalih resursa koji bi bili zadovoljavajući za drugog korisnika.

5.20 Bankarev algoritam za više resursaBankarski algoritam se može poopštiti na više resursa, a to nam prikazuje sljedeća

slika.

Ovde vidimo dvije matrice. Lijeva pokazuje koliko instanci iz svake kalse resursa, svaki od pet procesa upravo zauzima. Desna pokazuje koliko resursa svaki proces još treba prije nego što završi. Tri vektora desno na slici prikazuju ukupan broj resursa E, zauzete resurse i dostupne resurse A.

Sada možemo dati algoritam koji ispituje da li je stanje sigurno.Traži jedan red u R koji je manji ili jedna A. Ako se takav ne može naći sistem ne

može završiti ni jedan proces i nalazi se u potpunom zastoju.Pretpostavimo da proces koji odgovara ovom redu sve neophodne resurse

rezerviše i završava svoje izvršenje. Proces se označi kao završen i njegovi resursi se dodaju A.

Bankarev algoritam za više resursa 151

Koraci 1 i 2 se ponavljaju sve dok svi porcesi ne budu označeni ili dok sistem ne završi u potpunom zastoju. U prvom slučaju stanje je sigurno a u drugom nesigurno.

Ako u prvom koraku na raspolaganju stoji više procesa, nije značajno koji će se prvi izvršiti. Ovaj algoritam se koristi samo uveoma malom broju sistema jer je beskoristan u praksi za sisteme gdje broj procesa nije konstantan. Osim toga rijetko se unaprijed zna koliko će resursa neki proces trebati.

5.21 Sprečavanje potpunog zastojaDo zastoja dolazi samo ako su istovremeno ispunjena četiri uslova (navedena na

početku teksta) za nastajanje potpunog zastoja. Ovaj metod podrazumjeva neispunjenje barem jednog od ova četiri uslova.

5.22 Napadanje uslova uzajamnog isključivanjaPrvo ćemo se pozabaviti uslovom uzajamnog isključivanja. Kroz spooling može se

više procesa istovremeno zadovoljiti. U ovom modelu samo printer deamon rezerviše printer. S obzirom da on nikad ne zahtjeva neki drugi resurs. Na žalost spooling se ne može primjeniti za sve vrste resursa. U osnovi ovoga je ideja, resurse dodjeljivati samo kada je to neophodno, i pobrinuti se za to što je moguće manje procesa samostalno zahtjevaju resurse.

5.23 Napadanje stanja prisvajanja i čekanjaAko možemo sprječiti da proces čeka na resurse dok druge resures drži zauzete

možemo sprječiti potpuni zastoj. Mogući pristup je da svi procesi sve resurse unaprijed zahtjevaju. Ako su resursi dostupni, oni će mu se dodjeliti. Ako je jedan ili više resursa zauzet, neće se ni drugi resursi rezervisati i proces mora čekati.

Jedan očigledan problem kod ovakvog pristupa je da većina procesa ne zna unaprijed koliko će resursa trebati. Kada bi zanli mogao bi se primjeniti bankarski algoritam. Ovaj metod opterećuje i nerentabilno koristi resurse.

5.24 Napadanje uslova neoduzivih resursaNapad na treći uslov (neoduzivi resursi), obećava još manje uspjeha.

Nasilno oduzeti procesu printer na kome on upravo printa je prilično teško a u najgorem slučaju nemoguće.

5.25 Napadanje ciklusa čekanjaOstao nam je još jedan uslov. Jedna mogućnost ovde je jednom procesu

istovremeno dozvoliti samo jedan resurs. Ako mu je potreban još jedan mora prvo osloboditi prvi resurs. Za proces koji kopira podatke sa trake na disk ovo nije moguće.

Druga mogućnost je resurse numerisati kao što je prikazano na slici.


Svaki proces može zatražiti resurse kad god želi ali to mora raditi po datom redosljedu. Sa ovim pravilom je graf zauzimanja i zahtjeva uvijek bez petlji.

Druga varijanta je da svaki proces smije zahtjevati resurs koji ima veći broj od resursa koji je proces trenutno zauzima.

Na kraju je dat tabelarni sažetak svih načina sprečavanja potpunog zastoja.

5.26 Two-phase lockingIako ni sprečavanje ni otklanjanje potpunog zastoja ne obećava puno postoji

mnogo odličnih algoritam za specijalne primjene. U bazama podataka, često se dešava da jedan proces blokira određene podatke da bi onda na njima radio. Ako više procesa pristupa bazi podataka opasnost da se pojavi potpuni zastoj je veća. U ovakvim slučajevima primjenjuje se two-phase locking.

U prvoj fazi proces pokušava de blokira sve podatke koje želi obraditi. Ako je to uspio počinje sa drugom fazom gdje obrađuje ove podatke i onda ih oslobađa. U prvoj fazi nema pravog rada.

Ako proces u prvoj fazi naiđe na blokirane podatke, on oslobađa sve podatke i počinje iz početka. Može se reći da je to slično situaciji gdje proces sve podatke unaprjed rezerviše. Postoje i varijante gdje proces ne počinje iz početka kad naiđe na blokadu, ovo može voditi u potpuni zastoj.

Ova strategija se ne može uvijek primjenjivati, npr u real-time sistemima ne možemo prekinuti poroces i početi iz početka samo zato što je naišao na blokiran resurs. Algoritam funkcioniše u situacijam gdje se programer pobrinuo za to da program u prvoj fazi može biti u svakom trenutku prekinut i ponovo pokrenut.

5.27 Potpuni zastoji bez resursaDo sad smo razmatrali potpune zastoje u vezi sa resursima. Procesi mogu doći u

stanje potpunog zastoja gdje ne učestvuju nikakvi resursi. Npr. potpuni zastoj može nastati u situaciji u kojoj svaki od dva procesa čeka da onaj drugi poduzme nešto.

Izgladnjivanje - umiranje procesa 153

5.28 Izgladnjivanje - umiranje procesaJedan problem usko povezan sa problemom potpunog zastoja je tzv.

izgladnjivanje. U jednom dinamičkom sistemu stalno dolazi do zahtjeva za resursima. Sistem određuje prema određenoj strategiji koji proces u kome trenutku dobiva neki resurs. Može se desiti da ove procedure vode tome da neki proces nikad ne dođe u priliku da se aktivira iako se ni jednom nije našao u potpunom zastoju. Strategija FCFS (first come first served) se brine da proces koji najduže čeka bude poslužen.

5.29 Windows API za potpune zastojeZaključno sa Windows XP, u Windows je korišten nojev algoritam. Samo za razvoj

drajvera postojao je eksterni alat koji obavlja provjere da li potpuni zastoj može desiti (prevencija). Od Windows Vista uvedene su četiri funkcije za detekciju potpunog zastoja u višenitnim programima.

• OpenThreadWaitChainSession(dwFlags,pfCallback) Otvara sesiju za dobijanje liste niti koje su u čekanju

• GetThreadWaitChain(hWctHandle,pContext,dwFlags,dwThreadId,lpNodeCount,pNodeInfoArray,lpIsCycle) Dobavlja lanac čekanja na niti

• WaitChainCallback(hWctHandle, pContext,dwCallbackStatus,lpNodeCount,pNodeInfoArray,pIsCycle) Povratna korisnička funkcija

• CloseThreadWaitChainSession(hWctHandle) Zatvara sesiju za dobijanje liste niti koje su u čekanju

5.30 ZaključakPotpuni zastoji mogu biti problem u svakom operativnom sistemu. Oni nastaju

kada u jednoj grupi procesa svaki proces ima sam pravo pristupa nekom resursu i svaki ima potrebu za još jednim daljim resursom koji pripada drugom procesu iz grupe. Svi procesi iz grupe su blokirani i ne mogu dalje raditi. Potpuni zastoji mogu biti spriječeni tako da se sistem prati koja su stanja sigurna a koja nisu. Sigurno stanje je stanje gdje postoji niz događaja koji garantuju, da svi procesi mogu do kraja završiti svoj posao. Nesigurno stanje ne daje takvu garanciju. Bankarski algoritam sprečava potpuni zastoj tako što ispunjava zahtjeve za resursima kada vode sigurnom stanju.

Potpuni zastoji mogu biti spriječeni ne-ispunjenjem jednog od uslova za nastajanje potpunog zastoja. Kada npr. svaki proces istovremeno sa drugima posjeduje samo jedan resurs, ne ispunjava se uslovi cikličnog čekanja i potpuni zastoj se ne može pojaviti. Potpuni zastoj se može spriječiti i tako što se svi resursi numerišu i zahtjeva da ih svaki proces može zatražiti strogo po redu.

154 Upravljanje memorijom

6 Upravljanje memorijomnbnnb

6.1 Osnove upravljanja memorijomRačunarski sistem obično sadrži više vrsta memorije: primarna memorija,

sekundarna memorija, tercijarna memorija, off-line memorija i mrežna memorija. Primarna memorija je povezana na centralnu procesorsku jedinicu računara. Primarna memorija se tipično sastoji od tri tipa memorije: procesorski registri, keš memorija (engl. cache) i glavna (interna) memorija.

Procesorski registri sadrže informacije koje su potrebne aritmetičko logičkoj jedinici da izvršava trenutnu operaciju. To je najbrža vrsta memorije, integrisana u CPU. Keš memorija je specijalan tip interne memorije koja se koristi za poboljšanje performansi. Neke informacije iz glavne memorije nalaze se i u keš memoriji koja je manja ali brža od glavne memorije.

Glavna memorija sadrži programe u izvršenju kao i podatke koje ovi programi koriste. Aritmetičko logička jedinica može brzo prenositi podatke između procesorskih registara i glavne memorije, odnosno lokacije koju zovemo memorijska adresa. Ova memorija - RAM (engl. random access memory) povezana je sa CPU putem memorijske sabirnice (engl. memory bus).

Sekundarna memorija za pristup informaciji, zahtjeva korištenje ulazno/izlaznih kanala a koristi se za dugotrajno smiještanje podataka. Većina računarskih sistema koriste ovu vrstu memorije kao virtualnu memoriju koja se koristi da prividno poveća veličinu glavne memorije računarskog sistema. Sekundarna memorija obično ima mnogo veći kapacitet u odnosu na glavnu memoriju ali je i značajno sporija. Tvrdi diskovi (engl. hard disks) je tipičan primjer sekundarne memorije koja se koristi u računarskim sistemima.

Tercijarna memorija je sistem memorije koji se koristi za specijalnu namjenu kod velikih računarskih sistema različite poslovne ili naučne namjene. Ova memorija se po potrebi, automatizirano konektuje ili diskonektuje. Off-line memorija je memorija koja se lako može diskonektovati a koristi se za arhiviranje podataka. Primjer ovakeve memorije su diskete, optički diskovi, USB diskovi, ili magnetne trake. Mrežna memorija je bilo koji tip memorije koji uključuje pristup informaciji putem računarske mreže.

Osim ove podjele postoje i drugi načini za podjelu memorije.Ovde obrađujemo prvenstveno internu memoriju (operativnu memoriju) i

njen odnos sa eksternom memorijom. Procesor može izvršavati samo procese koji su u internoj memoriji. Kako je operativna memorija relativno malog kapaciteta, dolazimo do slijedećih ih problema:

1. proces je već od interne memorije (i kod monoprogramiranja i kod multiprogramiranja),

2. nemamo dovoljno memorije da učitamo sve spremne procese (kod multiprogramiranja). Osnovni ciljevi sloja upravljanja memorijom su:

Dodjeljivanje memorije procesima. 155

6.2 Dodjeljivanje memorije procesima.Memorija se dijeli na najmanje dvije particije od kojih je jedna particija

namjenjena jezgru operativnog sistema (engl. kernel space) a druga particija, najčešće viši dijelovi, dodjeljena je korisničkim procesima (engl. user space). Uobičajeno je da se na najnižem dijelu memorije nalazi tabela prekidnih rutina.

U korisničkom adresnom prostoru nalaze se procesi u redu čekanja na procesor. Pored tog reda čekanja postoje i procesi koji sa diska nastoje da uđu u red čekanja na procesor. Uslov za to je da se procesu prvo dodijeli potrebna memorija. Tehnika dodjele memorije može biti kontinualna ili diskontinualna alokacija. Kod kontinualne alokacije i logički i fizički adresni prostor se sastoje od kontinualnog niza memorijskih adresa. Memorijske particije dodjeljene procesima mogu biti jednake ili različite. Kod diskontinualne alokacije memorije fizički adresni prostor ne predstavlja kontinualni niz memorijski adresa. Straničenje, segmentacija i straničenje sa segmentacijom spadaju u ovu vrstu dodjele memorije.

6.3 Razdvajanje fizičkog i logičkog adresnog prostora programa i vezivanje adresa.

Program sa diska mora mora biti učitan u memoriju unutar adresnog prostora novostvorenog procesa. Zavisno od metode upravljanja memorijom koja se koristi porces se u toku izvršenja može više puta pomjeriti na relaciji disk-memorija.

Korisnički program prolazi kroz više faza tokom kojih se memorijska adresa predstavlja na različite načine. Prevodilac (engl. compiler) prevodi izvorni kod programa i vezuje simboličke adrese iz izvornog koda za relativne adrese koje punilac (engl. loader) pretvara u apsolutne prilikom učitavanja programa u momoriju.

Dio operativnog sistema koji upravlja korištenjem memorije zove se upravljač memorije (engl. memory manager). Njegov zadatak je da vodi računa o tome, koji dijelovi memorije su zauzeti, koji dijelovi 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 slijedeće tehnike:1. SWAPPING (prebacivanje procesa) – ako nemamo dovoljno mjesta u

operativnoj memoriji za smiještanje svih spremnih procesa, neki se izbacuju na disk. Kada je potrebno, cijeli spremni procesi iz interne memorije se prebacuju na disk, odnosno spremni procesi sa diska se prebacuju u internu memoriju.

2. PAGING (straničenje) – dijelove procesa držimo na disku, a učitavaju se po potrebi.

Postoje dvije klase upravljanja memorijom: prva klasa koja prebacuje procese koji se izvršavaju između glavne memorije i diska (swapping i paging (straničenje)) i druga koja to ne radi. Druga klasa je jednostavnija i zato ćemo je prvo obrađivati.


6.4 Monoprogramiranje bez izbacivanja ili upravljanja stranicama

Najjednostavnija strategija upravljanja memorijom u jednom trenutku dozvoljava rad samo jednom programu, u memoriji se u jednom trenutku može nalaziti samo jedan program.

1. Najjednostavniji način je da u internoj memoriji imamo samo jedan proces: pustimo korisnika da učita program koji želi, i taj program tada dobija apsolutnu kontrolu nad računarom (radi šta hoće i gdje hoće, pristupa onim dijelovima memorije kojima želi i koristi one uređaje koje želi i kako želi). Kod ovog pristupa ne treba nam ni operativni sistem, ni posebni drajveri za razne uređaje: 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 izvrši svoj zadatak. Kada taj program završi sa radom, može se učitati slijedeći program, koji isto tako mora znati da rukuje sa svim uređajima koje koristi. Ova metoda je već davno napuštena, pošto je vrlo nepraktična – programeri moraju ugraditi sve potrebne drajvere u svaki program. Ako nema dovoljno memorije, programer mora naći neko rješenje: optimizuje kod, ili će program razbiti na manje funkcionalne dijelove koji se mogu samostalno izvršavati ili nešto treće.

2. Drugi način je da se memorija dijeli 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že koristiti. Korisnik izdaje naredbe operativnom sistemu. Ako OS prepozna komandu, pokušava ga izvršiti, ako ne, javlja grešku i čeka slijedeću naredbu. Korisnikov program se učitava u preostali dio memorije i tamo se izvršava. Više nije potrebno u svaki program ugraditi i sve potrebne drajvere, jer je OS zadužen da obezbjedi sve potrebne funkcije. Imamo više načina za raspodjelu memorije:

1. OS se učitava u donji dio RAM-a (Random Access Memory – memorija koja se može i čitati i

pisati) , a ostatak memorije je na raspolaganju korisničkim programima2. OS se nalazi u ROM-u (Read Only Memory – memorija koja se može samo

čitati) na vrhu memorije a korisnički program ispod njega3. OS se nalazi u donjem delu RAM-a, drajveri u ROM-u na vrhu memorije a

između korisnički program. Osnovni skup funkcija za rad sa uređajima može biti smješten u poseban dio ROM memorije koji 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.

Slika prikazuje varijacije ove strategije.

Monoprogramiranje bez izbacivanja ili upravljanja stranicama 157

Prvi model je bio upotrebljavan u mainframe mašinama i mikroračunarima a danas se više ne upotrebljava. Drugi model se upotrebljava u embedded sistemima, kućnim računarima 80'ih (ZX Spectrum, C64). Treći model je upotrebljavan prije u PC sistemima. Dio sistema u ROM-u se naziva BIOS (Basic Input Output System). U tako struktuisanom sistemu može istovremeno raditi samo jedan proces.

6.5 Multiprogramiranje sa fiksnim particijamMonoprogramiranje se danas može naći još samo u nekim emedded

sistemima. Većina modernih sistema može izvršavati više programa istovremeno. Kada je istovremeno aktivno više procesa, i jedan proces čeka na završetak neka U/I operacije u međuvremenu može neki drugi proces preuzeti CPU. Multiprogramiranje uvećava iskorištenost CPU. Na mrežnim serverima može istovremeno raditi više procesa, a i većina klijent mašina imaju danas tu karaktristiku. Multiprogramiranje znači da istovremeno imamo i više spremnih procesa u internoj memoriji.

6.6 Razlozi za uvođenje multiprogramiranja:-rad sa više korisnika,-bolje iskorištenje procesorskog vremena (dok proces A čeka na podatke sa

diska, procesor bi mogao izvršavati proces B,-jednokorisnički sistemi: dok editujemo tekst, želimo slušati muziku sa CD-a, a

želimo da nam printer isprinta neštoKao što smo vidjeli, drugi način monoprogramiranja je podjela memorija se dijeli

na dva dijela – jedan dio koristi OS, a drugi dio je namenjen korisničim programima. Ovde bismo mogli ostvariti swapping: spremni procesi čekaju na disku, biramo jedan se učitava u memoriju i izvršava 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 mijenjanje procesa.

Proširenje ove ideje je slijedeće: podijelimo memoriju na međusobno nezavisne i odvojene dijelove – particije, ako je moguće različitih veličina. U svaku particiju ćemo učitati proces koji je spreman za izvršavanje, taj proces vidi samo svoju particiju i misli, da je sam u memoriji. Kada nalog dođe, može se


postaviti na kraj reda za čekanje za najmanju particiju koja je za njega dovoljno velika.

Imamo dva pristupa za određivanje veličine particija:1. neka su sve particije iste veličine – nedostak: particija je veličine 1MB, a u

njoj se izvršava proces veličine 100KB, cijela particija je zauzeta, a 90% raspoložive memorije u toj particiji je neiskorišteno

2. neka su particije različith veličina – imamo manje i veće particije, u svaku particiju stavljamo proces koji najbolje iskorištava raspoloživu memoriju

Liste čekanja: imamo dvije mogućnosti:1. svaka particija ima svoju listu čekanja – novi proces se stavlja u listu

najpogodnije particije (gledamo da imamo što manje neiskorištene memorije).-Nedostatak ovog pristupa: može se desiti da na listama čekanja manjih

particija čeka 100procesa 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 slijedeći proces.Izbor procesa može se vršiti na dva osnovna načina:1. biramo proces koji je najbliži u redu čekanja i može da stane u datu particiju.Nedostatak: imamo na raspolaganju veliku particiju, ali je mali proces bliže

nego veliki, pa će mali proces biti učitan u veliku particiju – gubimo mnogo memorije na mali proces.

2. biramo najveći od svih onih procesa koji mogu stati u datu particiju.Nedostatak: mali procesi su diskriminisani, uvijek biramo veće procese.Na slici (a) vidimo kako sistem sa fiksnim particijama i redovima za čekanje

izgleda. Nedostatak ovakvog rasporeda pokazuje se kad je red za jednu veliku particiju prazan a za neku manju pun. Alternativa je prikazana na slici (b) sa jednim redom za čekanje za sve particije. S druge strane, ne treba trošiti veliku particiju na male zadatke. Druga strategija koja bi imala smisla je za svaku oslobođenu particiju pretražiti red, i izabrati najveći odgovarajući zadatak. Ovaj metod obrađuje manje zahtjeve kao da nisu vrijedni čitave particije iako je u normalnim uslovima potrebno manje, interaktivne zahtjeve obrađivati bolje nego velike.

Razlozi za uvođenje multiprogramiranja: 159

Rješenja za izbjegavanje navedenih nedostataka. Potrebno je definisati dovoljan broj dovoljno malih particija (u koje mogu stati samo mali procesi a ne i veliki). Tako se manji zahtjevi mogu zadovoljiti da ne zauzimaju veću particiju.

Može se uvesti slijedeće pravilo: ni jedan zahtjev ne smije biti preskočen više od k puta. Svaki

zahtjev koji se preskoči dobiva jedan poen, i onaj zahtjev koji je skupio k poena ne smije se više preskakati. Ovaj model se zove MFT (multiprogramming with a fixed number of tasks) a danas ga podržava veoma malo sistema.

6.7 Modeliranje multiprogramiranjaMultiprogramiranje poboljšava iskorištenost CPU. Ako posmatramo CPU sa

stanovišta vjerovatnoće i pretpostavimo da jedan proces provodi dio p svog vremena čekajući na završetak U/I operacija, kod n procesa je vjerovatnoća da svi

istovremeno čekaju na U/I p. U ovom slučaju bi CPU bila prazna i njeno iskorištenje je

A = 1 − pn

.Slika prikazuje iskorištenje CPU u zavisnosti od n, pri tome se n zove stepen

multiprogramiranja (engl. degree of multiprogramming).

Modeli zasnovani na vejerovatnoći su samo približni zato što se pretpostavlja su svi procesi nezavisni jedan od drugog. Procesi nisu nezavisni jedan od drugog.

6.8 Analiza kod multiprogramiranjaPredstavljeni model može se upotrjebiti kod analize batch sistema. Zamislimo

jedan računski centar čiji zadaci u prosjeku imaju 80 % U/I vremena čekanja Neka dolaze četri zadataka sa slike (a). Prvi zadatak dolazi u 10 sati i treba 4 minute CPU. Kod 80 % vremena čekanja ovaj zadatak koristi samo 12 sekundi od svake minute koje provede u memoriji. Ostalih 48 sekundi čeka na U/I operacije. Tako ovaj zadatak za četri minute računanja mora provesti u memoriji 20 minuta čak ako i postoji konkurencija za CPU vrijeme.

U intervalu 10 sati i 10:10 je zadatak potpuno sam u memoriji i završava se 2 minute. U 10 i 10 dolazi zadatk 2 i opterećenje raste kroz povišenje stepena multiprogramiranja od 0,20 na 0,36. Sa round-robin metodom, svaki proces dobiva pola od CPU vremena, to znači 0,18 minuta CPU vremena za svaku minutu koju


provede u memoriji. Prisustvo drugog procesa košta prvi proces samo 10% njegovog učinka. On dobiva sad 0,18 umjesto 0,20 CPU minuta po minuti stvarnog vremena.

U 10:15 dolazi treći zadatak. Do ovog trenutka je zadatak 1 imao 2,9 minuta CPU a zadatk 2 0,9 CPU minuta. Sa trostrukim multiprogramiranjem dobiva svaki zadatak 0,16 CPU minuta po stvarnoj minuti. Između 10:15 i 10:20 dobiva svaki od zadataka 0,8 minuta CPU vremena. U 10:20 dolazi 4 zadatak.

6.9 RelokacijaParticionisanjem memorije dolazimo do situacije, da jedan isti proces može biti

učitan i izvršavan u različitim particijama. To dovodi do problema relokacije, naime prilikom prevođenja programa kompajler (prevodilac) generiše objektne fajlove koji sadrže logičke adrese. Zatim dolazi linker (povezilac) i povezuje sve korištene (i prevedene) module u jedan izvršni fajl. Da bi to uradio, potrebno je da zna početnu fizičku adresu gde će program biti učitan i izvršavan. Pošto je to za vrijeme povezivanja nepoznato, i linker će morati da koristi logičke adrese. Znači sada imamo izvršni fajl sa logičkim adresama.

Adresa koju generiše procesorska instrukcija je logička, a adresa same memorijske jedinice je fizička. Logičke i fizičke adrese su iste u fazi prevođenja i u fazi učitavanja programa ali se razlikuju u fazi izvršavanja. Logička adresa se u fazi izvršavanja naziva i virtualnom adresom. Skup svih logičkih adresa koje generiše program naziva se logički ili virtuelni adresni prostor, a skup svih fizičkih adresa koje njima odgovaraju naziva se adresni prostor.

Mapiranje virtualnog adresnog prostora u fizički obavlja hardverski uređaj koji se zove MMU jedinica za upravljanje memorijom (engl. Memory Management Unit).

Najjednostavnija šema mapiranja je šema koja koristi relokacioni registar. Relokacioni registar definiše adresu fizičkog početka programa. Svaka logička adresa koju generiše program sabira se sa vrijednošću relokacionog registra i tako dobijamo fizičke adrese. Korisnički program počinje od nulte adrese.

Ako se ograničimo na programe veličine 64K, Intel 8086 ima ovakvu mogućnost. Četiri segmentna registra CS, DS, SS i ES u suštini predstavljaju relokacione registre podijeljene s 16.

Zaštita 161

6.10 ZaštitaZaštita operativnog sistema od korisničkih procesa i međusobna zaštita

korisničkih procesa po pitanju pristupa memorijskim sekcijama može se realizovati pomoću hardverske podrška. Procesor treba imati dva posebna registra: base register (bazni registar) i limit register (limit (granični) registar). Bazni registar čuva početnu adresu particije gde je proces učitan, a limit registar krajnju adresu te particije (ili veličinu particije). Punilac u ovom slučaju ne mjenja adrese procesa, jednostavno samo učita proces u particiju i postavi vrijednost 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 podrška rješava i problem zaštite: kada se izračunava fizička adresa memorije kojoj program želi pristupiti, jednostavno se upoređuje sa sadržajem limit registra. Korištenje baznog registra za relokaciju pruža još jednu mogućnost: program se može pomjerati po memoriji za vrijeme izvršavanja - 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 izvršavanje se može nastaviti.

6.11 Upravljanje memorijom sa swappingomKod batch sistema je jednostavno i efektivno memoriju podijeliti na fiksne

particije. Svaki zadatak se puni u jednu particiju kada je na redu (u redu za čekanje) i ostaje u memoriji dok ne završi. Sve dok je u memoriji dovoljno zadataka koji CPU mogu držati zaposlenom nema razloga za komplikovanijim sistemom.

Kod time-sharing sistema ili PC-a sa grafičkim interfejsom situacija je drugačija. Nekad nema dovoljno mjesta u memoriji za sve aktivne procese zato se neki od njih moraju snimiti na disk i po potrebi dinamički ponovo pozvati u memoriju.

Za ovakvo upravljanje memorijom postoje u osnovi dva pristupa. Za koje se odlučuje zavisi djelimično i od hardvera. Najjednostavnija strategija je tzv. swapping kod koga se svaki proces kompletno poziva u memoriju, smije tamo biti neko određeno vrijeme i nakon toga se vraća na disk.

Kod druge strategije, koja se zove virtualna memorija programi mogu biti aktivni i kada se samo djelimično nalaze u memoriji.

Tehnika razmjene zahtjeva (swap) zahtjeva postojanje tri komponente:- prostor na disku (engl. swap space),- mehanizam swap-out koji prebacuje procese iz memorije na disk,- mehanizam swap-in koji vraća uspavani proces sa diska u memoriju.Ovaj pristup upravljanja memorije je viđen npr. na Windows 2.0.

6.12 Multiprogramiranje sa promenljivim particijamaDa bismo izbjegli problem unutrašnje fragmentacije (engl. internal

fragmentation) uvodimo promenljive particije: veličina pojedinih particija se određuje na osnovu procesa koji se učita u memoriju. Nemamo unaprijed određen broj particija sa unaprijed određenim veličinama. Kada se proces učita, zauzima


onoliko memorije koliko mu je potrebno (ako imamo dovoljno memorije). Slika prikazuje način rada jednog swapping sistema.

Razlika između fiksnih i promjenljivih particija je slijedeća: kod fiksnih particija, broj, veličina, pa i lokacija svih particija su određeni unaprijed pri pokretanju sistema od strane sistem operatora. Kod promjenljivih particija ne znamo unaprijed ni broj, ni veličinu ni lokaciju particija – ti parametri se određuju dinamički i zavise od procesa koji se izvršavaju. Flekisbilnost poboljšava iskorištenost memorije ali je dodjeljivanje, oslobađanje i upravljanje memorijom komplikovanije.

Interna fragmentacija se javlja ukoliko se procesu dodjeli dio memorije veći od memorije koju proces zahtjeva. Preostali dio memorije ostaje neiskorištena sve dok proces ne oslobodi svu memoriju koju je zauzeo.

Eksterna fragmentacija je karakteristična za sisteme sa kontinualnom dodjelom memorije.

Procesu se ne može dodijeliti određena količina memorije jer na sistemu ne postoji dovoljno velik kontinualni memorijski blok (bez obzira što ukupna količina slobodne memorije premašuje zahtjeve procesa).

Problem spoljašnje fragmentacije (engl. external fragmentation): mogli bismo rješiti tako što ćemo pomjerati sve procese tako da se sve slobodne particije nalaze na jednom mjestu kontinualno (to se zove kompakcija - compaction). Kompakcija memorije zahtjeva dosta CPU vremena pa se u normalnim uslovima ne koristi.

Značajno pitanje je koliko memorije treba rezervisati za proces koji se poziva u memoriju. Kada svaki proces ima fiksnu veličinu koja se nikad ne mjenja to je jednostavno, operativni sistem mu dodjeljuje tačno koliko mu je potrebno.

Drugi problem koji može nastati je kada procesi rastu. Ako postoji praznina u memoriji pored prostora koji okupira proces ta mu se praznina može dodjeliti. Ako proces leži direktno pored nekog drugog procesa, rastući proces se mora prebaciti u neki veći prazan prostor koji je dovoljno velik za njega ili se neki procesi moraju izbaciti da bi se stvorio dovoljno veliki prostor. Kada proces ne može dalje rasti proces mora čekati ili biti prekinut:

1. Procesi su dužni da prilikom učitavanja u memoriju jave maksimalnu veličinu.2. Proces se ubija (prekida) uz poruku o grešci.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, gdje se nalaze zauzete

particije i koje su njihove veličine, odnosno gdje se nalaze prazne particije i koje su njihove veličine.

Ako pođemo od pretpostavke da se većina procesa u periodu dok su aktivni povećava, nije loše rezervisati nešto više prostora u memoriji. Na slici vidimo konfiguraciju memorije kod koje je za dva procesa ostavljen prostor tako da se oni mogu povećavati.

Multiprogramiranje sa promenljivim particijama 163

6.13 Windows API za upravljanje memorijomZa alokaciju i oslobađanje memorije dodijeljene procesu, Windows API pruža

sljedeće funkcije• CopyMemory (pDestination,pSource,iLength ) Kopira blok memorije s jednog

mjesta na drugo• FillMemory(pDestination,iLength,bFill); Puni memoriju istim bajtom• GetProcessHeap() Dobavlja alokacijsko područje za proces• VirtualAlloc(lpAddress,dwSize,dwAllocationType,dwProtect) Alocira dio

virtuelne memorije za proces (zaokruženo na veličinu stranice)• VirtualFree(lpAddress,dwSize,dwFreeType); Oslobađa alociranu virtuelnu

memoriju• HeapAlloc(hHeap,dwFlags,dwBytes) Alocira dio memorije unutar procesa• HeapReAlloc(hHeap,dwFlags,lpMem,dwBytes) Mijenja veličinu memorije za

proces• HeapFree(hHeap,dwFlags,lpMem) Oslobađa memoriju alociranu za proces• HeapSize(hHeap,dwFlags,lpMem) Dobavi veličinu alociranog memorijskog

bloka

6.14 Posix API za upravljanje memorijomSvega dvije Posix funkcije za upravljanje memorijom su sistemski pozivi • int brk(void *end_data_segment); Postavlja kraj područja memorije za proces• void *sbrk(intptr_t increment); Uvećava kraj područja memorije za proces

Aplikacije trebaju koristiti C funkcije calloc(), malloc(), realloc(), valloc(), memalign()

6.15 Strukture podataka za upravljanje memorijomZa vođenje evidencije o zauzetosti memorije (o zauzetim particijama) i o

rupama između particija (slobodna memorija) možemo koristiti slijedeće strukture:1. Bit mape (engl. bit maps),2. Povezane liste (engl. linked lists),3. Sistem udruženih parova - drugova (engl. buddy sistem).


6.16 Upravljanje memorijom sa bit mapamaKod upravljanja memorijom pomoću bit mape, memorija se dijeli na

dijelove iste veličine. Svakom dijelu odgovara jedan bitu u bit mapi pri čemu 0 znači ja je jedinica slobodna a 1 da je zauzeta (ili obrnuto). Tako dolazimo do niza nula i jedinica (bitova) koji se zove bit mapa memorije.

Pitanje: koje veličine treba da budu ovi dijelovi memorije ? Veličina alokacionih jedinica je značajno pitanje dizajna. Što su manje jedinice to je veća mapa bita. Glavni problem ovde je da svaki put kad neki proces treba k jedinica, treba pretražiti bit mapu tražeći niz k 0-bita. Pošto ovo zahtjeva dosta vremena to je ozbiljan argument protiv bit mapa.

6.17 Upravljanje memorijom sa povezanim listama (linked lists)

Memorija je ili zauzeta od strane nekog procesa (P) ili je slobodna (praznina, H – hole). Povezane liste gradimo od slogova slijedeće strukture:

P ili H početna adresa veličina Slijedeć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ži početnu adresu dijela memorije koju opisuje dati slog. Treće polje veličinu opisane memorije, a četvrto polje sadrži pokazivač na slijedeći slog. Upravljanje memorijom se odvija na slijedeći način:

Zauzimanje memorije: imamo proces, tražimo dovoljno veliku rupu u memoriji. Pretražujemo povezanu listu, tražimo slog tipa H (praznina) dovoljne veličine. Ako nađemo, umjesto H upišemo P, i eventualno ubacimo novi čvor tipa H (ako proces ne zauzima cijelu prazninu, ostaje nam neka manja praznina).

Oslobađanje memorije: proces A završi sa radom, oslobodimo zauzetu memoriju. Tada jednostavno stavimo H umjesto P ako se i ispred i iza procesa A nalazi neki drugi proces (a ne slobodna memorija), inače vršimo ažuriranje liste.

Jedan proces uglavnom ima dva susjeda, koji mogu biti ili proces ili praznina (procesi na rubu memorije imaju samo jednog susjeda). Moguće kombinacije koje su predstavljene na slici.

Upravljanje memorijom sa povezanim listama (linked lists) 165

6.18 Sistem drugova (Buddy system)

Čitav dostupni prostor se tretira kao jedan blok veličine 2 U

Ako je veličina zahtjeva s takva da je

2 U −1

< s ≤ 2 U

, čitav blok se zauzima– U suprotnom blok se dijeli na jednake dijelove (buddies).– Postupak se nastavlja sve dok se ne nađe najmanji blok koji je veći ili

jednak zahtjevu s.Upravljač memorije koristi po jednu listu za blokove slobodne memorije veličine1,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 cijela 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že stati jeste ona od 128KB (mora biti stepen od 2). Na žalost, lista koja sadrži particije te velične je prazna. Zato ćemo particiju od 1MB razbiti na dva dijela od 512KB (ovi dijelovi se zovu drugovi – buddy), pa ćemo prvi razbiti na dva dijela od 256KB, i još jednom, prvi dijelimo na dva dijela od 128KB. U prvu particiju stavimo proces:

Sada lista od 128Kb sadrži dva čvora (jedan je zauzet – P, a drugi je slobodan – H), a liste od 256KB i 512KB sadrže po jedan slobodan čvor. Ovde već vidimo nedostatak ovog sistema: za proces od 70KB zauzimamo čitavu particiju od 128KB, tj. gubimo 58KB memorije (unutrašnja fragmentacija).

Neka sada dođe proces B veličine 35KB. Potrebno je zauzeti particiju veličine 64KB. Lista za takve particije je prazna. Zato dijelimo prvu slobodnu particiju od 128KB na dva dijela 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.


Novi proces C od 80KB ubacujemo tako što dijelimo 256KB na dva dijela od 128KB, u prvi ubacimo C a drugi ostaje prazan:

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

Ako neki proces završi sa radom, provjerimo veličinu praznine koja nastaje. Ako u susjedstvu ima druga, formiramo duplo veću prazninu od te dvije praznine. Važno je da veličina novoformirane praznine bude neki stepen od 2 – ako to nije slučaj, odustajemo od spajanja.

6.19 Algoritmi za izbor prazne particijeUzećemo povezane liste za strukturu upravljanja memorijom. Pretpostavka

je da su liste sortirane na osnovu početnih adresa.

Algoritmi za izbor prazne particije 167

1. Prvi uklapanje (FIRST FIT) je najjednostavniji algoritam za rezervaciju memorije. Menadžer memorijom pretražuje povezanu listu od početka do kraja i novi proces stavlja u prvu prazninu koja je dovoljna velika. Ako je rupa iste veličine kao i sam proces, jednostavno mijenjamo tip sloga iz H (praznina) u P (proces), ako je rupa veća, mijenjamo tip iz H na P, postavimo veličinu, zatim iza tog sloga ubacimo još jedan koji će predstavljati prazninu koja preostaje. Ovo je najbolji algoritam.

2. Slijedeće uklapanje (NEXT FIT): radi na isti način kao first fit, samo ne kreće svaki put od početka liste, već od mjesta gdje je poslednji put stao. Pokazuje slične performanse kao first fit. Ovaj algoritam za razliku od prethodnog zapamti poziciju gdje je zadnji put našao odgovarjauću prazninu te svoju sljedeće pretraživanje počinje od te pozicije. Ovaj algoritam se pokazao kao nešto brži nego prvo uklapanje.

3. Najbolje uklapanje (BEST FIT) je slijedeći poznati algoritam svaki put pretražuje cijelu listu i traži najmanju odgovarajuću prazninu u koju može stati dati proces. Sporiji je od prva dva algoritma jer mora svaki put preći cijelu listu. Pored toga dolazi do veće spoljašnje segmentacije (gubimo više memorije nego kod prethodna dva algoritma): pošto uvijek tražimo najmanju moguću praznina – a mala je vjerovatnoća da će ta praznina biti po bajtu iste veličine kao proces, pa dobijamo mnoštvo malih praznina koja se ne mogu ni na šta iskoristiti (bez grupisanja na jedno mjesto – a to je jako spora operacija i izbjegava se).

4. Najveća particija - najgore uklapanje (WORST FIT): radi na isti način kao best fit, samo što uvijek traži najveću moguću prazninu. Pretpostavka je slijedeća: ako proces stavimo u najveću moguću prazninu, imamo veću šansu da ostatak bude dovoljno veliko da u njega stane neki drugi proces. Simulacije su pokazale da je worst fit najlošiji 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 dvije liste – jednu listu za procese i jednu listu za praznine. Dobra strana je brzina (ne treba preći i preko procesa). Loša strana je povećana kompleksnost ažuriranja: ako proces postaje praznina mora se izbaciti iz liste za procese a ubaciti u listu za praznine. Ako praznina postaje proces, mora se prebaciti iz liste za praznine u listu za procese – pošto ćemo vjerovatno dobiti i novu prazninu, moramo zauzeti memoriju za novi slog i ubaciti u listu za praznine.

2. Ako koristimo dvije liste, mogli bismo listu za praznine 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 više lista za praznine. Formiramo liste praznine često korištenih veličina. Npr. 4KB, 8KB, 20KB itd. Neobične (praznine nepredviđene veličine) stavljamo u posebnu listu. Ovaj algoritam se zove quick fit – dobra strana je brzina, loša strana je komplikovanost ažuriranja, naročito kada proces postaje praznina, pa treba vidjeti da li su susjedi praznine radi spajanja u veću praznine.


6.20 Odvojen instrukcijski prostor i prostor podatakaVećina računara imaju zajednički adresni prostor koji sadrži i programe i

podatke. Kada je adresni prostor dovoljno velik ovo funkcioniše odlično (slika (a)). Na žalost ovaj prostor je često premalen.

Jedno moguće rješenje ovog problema su odvojen prostor za instrukcije i prostor za podatke. Slika (b) pokazuje odvojene adresne prostore. Ovdje algoritmi straničenja za odvojene prostore mogu biti nezavisni.

6.21 Segmentacija (segmentation)Do sada smo koristili linearni adresni prostor: počinje od nule i ide do nekog

maksimuma, cio proces se posmatra kao linearna struktura. Program smo razbijali na dijelove učitavali po potrebi da bismo mogli izvršavati programe koji su veći od raspoložive memorije. Sve do sada smo smatrali da je adresni prostor procesa linearan.

Neki nedostaci ovog pristupa: ako bilo koju proceduru izmijenimo, moramo prevoditi cio program jer je adresni prostor linearan, pa ako izmijenimo veličinu te procedure, mijenjaju se sve adrese iza nje, ili može doći do rasta steka za vreme izvršavanja programa tako da se stek napuni, pa se podaci pišu na dio gde se nalazi kod programa.

Virtualna memorija koju smo do sad razmatrali je jednodimenzionalna zato što virtualne adrese rastu linearno od 0 do određenog maksimuma. Za dosta problema bi bilo dobro imati dva ili više odvojenih adresnih prostora.

Segmentacija je metoda upravljanja memorijom koja podržava logički korisnički pogled na memoriju. Logički adresni prostor sastoji se od kolekcije segmenata a svaki segment ima jedinstveno ime i dužinu.

Kako segmenti predstavljaju vlastite prostore, oni mogu nezavisno mijenjati veličine. Kada neki stek u određenom segmentu treba više prostora može ga dobiti. Naravno može se desiti da segment ostane bez prostora ali to se veoma rijetko dešava.

Adresa u ovom segmentiranom, dvodimenzionalnom prostoru sastoji se iz dva dijela: broja segmenta i adrese unutar segmenta.

Segmentacija (segmentation) 169

Slika pokazuje kako segmenti mogu biti izgrađeni. U ovom primjeru program koristi 5 segmenata. Segment gradi logičku cjelinu. Programer mora biti svjestan toga i koristiti ga kao cjelinu.

Između implementacije segmentacije i straničenja postoji velika razlika, stranice imaju fiksnu veličinu, segmenti ne. Slika prikazuje fizičku memoriju koja ima 5 segmenata. Kada se ukloni segement 1 i manji segment 7 dođe na njegovo mjesto nastaje situacija na slici (b). Između segmenta 7 i 2 je nastaje neiskorišteno područje, jedna praznina. Nakon toga se segment 4 zamjenjuje segmentom 5 (c), segment 3 segmentom 6 (d). Nakon izvjesnog vremena rada sistema, memorija je podjeljena na na veliki broj blokova od kojih su neki segmenti a neki praznine. Ovaj fenomen se zobve checkerboarding ili eksterno fragmentiranje.

Ideja segmentacije je da se svakom procesu dodijeli više linearnih adresnih prostora koji počinju od nule i idu do nekog maksimuma. Ti prostori ili dijelovi procesa se nazivaju segmentima. Svaki segment predstavlja linearnu memoriju. Segmenti predstavljaju funkcionalne dijelove programa kao što su: kod programa, stek, heap, ali segment može da sadrži i samo jednu proceduru ili niz ili nešto drugo. Veličina svakog segmenta može se mijenjati za vrijeme izvršavanja od nule do nekog maksimuma. Različiti segmenti mogu biti različitih veličina. Pošto svaki segment ima svoj adresni prostor (linearan), različiti segmenti nemaju uticaja jedan na drugi.

Sa uvođenjem 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:


Ako koristimo segmentaciju, i procedure stavimo u posebne segmente, ne moramo kao kod linearnog pristupa svaki put kad izmjenimo neku proceduru prevoditi cio program. Pošto je svaki segment nezavisan i ima svoj linearni adresni prostor, dovoljno je prevesti samo onu proceduru koju smo izmjenili.

Pošto segmenti uglavnom sadrže samo jedan tip struktura: npr. samo stek, samo kod procedure, samo neki niz, razni segmenti mogu imati razne tipove zaštite. Npr. segment procedure može se samo izvršavati, u stek smijemo i pisati i čitati, elemente niza možemo samo čitati (konstantni niz) itd.

Da bi OS mogao preuzeti brigu o segmentima, potrebno je da ima slijedeće informacije: početna adresa segmenta, veličina (dužina) segmenta, tip segmenta, bezbjednosni podaci. Ove informacije se čuvaju u tabeli segmenata.

Windows 3.1 u standardnom režimu rada koristi pristup segmentacije.

6.22 Dijeljene bibliotekeKako svaki segment ima sopstveni adresni prostor, otvara se mogućnost korištenja

dijeljenih, 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 dijeliti. Tako nema potrebe da te biblioteke učitamo u adresni prostor svakog procesa, već je dovoljna jedna kopija u memoriji – svi će to koristiti.

Dijeljene datoteke se pored implementacije preko segmenata mogu realizovati i pomoću stranica.

6.23 Windows API za dijeljene datotekeFunkcije koje omogućavaju učitavanje dijeljenih datoteka na Windows suLoadLibrary(lpFileName) Učitava dinamičku biblioteku (.dll) u memorijuFreeLibrary(hModule) Oslobađa dinamičku biblioteku iz memorije

Windows API za dijeljene datoteke 171

GetModuleFileName(hModule,lpFilename,nSize) Dobavi puno ime biblioteke s stazom

GetProcAddress(hModule,lpProcName) Traži adresu podprograma s datim imenom u dinamičkoj biblioteci

DllMain (hinstDLL,fdwReason, lpvReserved) Glavna rutina DLL podprograma

6.24 Posix API za dijeljene datotekeFunkcije su• mprotect(pAddr, iLen, iProt) Postavlja prava nad dijelom memorije• mlock(pAddr, iLen) munlock(pAddr, iLen) Zaključava/otključava dio

virtuelnog prostora procesa• mlockall(iFlags) munlockall() Zaključava/otključava cijeli virtuelni prostor

procesa• mincore(pAddr, iLength, pVec) Informiše da li je taj dio adresnog prostora u

RAM-u• madvise(pAddr, iLength, iAdvice) Predlaže jezgru kako da mapira stranice

procesa

172 Virtuelna memorija


Znamo da procesor može izvršavati samo procese koji su u internoj memoriji. Kako je operativna memorija relativno malog kapaciteta, dolazimo do slijedeć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).

Virtualna memorija predstavlja posebnu memoriju i razlikuje se od fizičke memorije. Operativni sistem drži djelove programa koji su upravo potrebni u glavnoj memoriji a ostatak na disku. Virtualna memorija funkcioniše i kod multiprogramiranja, pri tome dijelovi različitih programa mogu istovremeno biti u memoriji.

Osnovna ideja je da programi mogu imati proizvoljnu veličinu a OS treba voditi računa o tome da u memoriji budu samo oni dijelovi procesa (i kod i podaci) koji su u datom trenutku potrebni, a ostatak neka čeka na disku. Znači jedan dio procesa je u internoj memoriji a drugi dio je u eksternoj memoriji, a sam proces ne zna ništa o tome –njemu se čini da ima dovoljno operativne memorije i da se čitav proces nalazi u internoj memoriji. Drugim riječima: ako nema dovoljno memorije, uzećemo malo od diska – procesi neće znati za to, možda korisnik primijeti usporavanje rada programa.

7.1 Straničenje (paging)Većina sistema sa virtualnom memorijom primjenjuju tehniku koja se zove

straničenje. Straničenje se koristi kao tehnika za realizaciju virtuelne memorije. Nemamo dovoljno interne memorije da bismo učitali cijeli proces, pa koristimo virtuelnu memoriju – memoriju koja je veća od fizičke interne memorije. Za realizaciju virtuelne memorije potrebna pomoć 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 prvo do dijela procesora koji se zove jedinica za upravljanje memorijom (MMU – Memory Managment Unit), koja virtuelnu adresu pretvara u fizičku memorijsku adresu:

Za svaki računar postoji veliki broj adresa koje programi mogu kreirati. One adrese koje generišu programi zovu se virtualne adrese i one grade virtualni adresni prostor (engl. virtual address space).

Straničenje (paging) 173

Slika pokazuje jednostavan primjer kako funkcioniše preslikavanje sa virtuelne na fizičku adresu. Virtualni adresni prostor je podjeljen na jedinice, koje se zovu stranice (pages). Isto tako internu memoriju dijelimo na blokove iste veličine. Ova odgovarajuća jedinica u fizičkoj memoriji zove se okvir stranice (page frame). Stranice i okviri stranica imaju uvijek jednaku veličinu. Između memorije i diska se uvijek prenose čitave stranice. 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 mijenja se u toku izvršavanja procesa: ako proces želi pristupiti nekoj adresi koja se nalazi na virtuelnoj stranici koja nije učitana u internu memoriju, moramo izbaciti neki okvir za stranice iz operativne memorije (ako je cijela operativna memorija već zauzeta) na eksternu memoriju a iz eksterne memorije moramo dovući traženu stranicu na mjesto izbačenog okvira za stranice.

Ako jedan program želi pristupiti adresi 0, virtualna adresa 0 se šalje u MMU. MMU ustanovi da ova virtualna adresa pripada stranici 0. što opet odgovara okviru stranice sa brojem 2 (8192 do 12 287). To znači da se virtualna adresa 0 preslikava na fizičku adresu 8192. MMU preslikava sve virtualne adrese od 0 do 4095 na fizičke adrese od 8192 do 12287. Kada tražena virtuelna stranica nije učitana u internu memoriju, MMU ustanovi da se ova stranica ne nalazi u memoriji i


pokreće jedan sistemski poziv. Ovaj sistemski poziv se zove graška stranice (page fault). Operativni sitem traži jedan okvir stranice koji je manje korišten piše njegov sadržaj nazad na disk. Poslije toga puni stranicu koja je prouzrokaovala grešku stranice u upravo oslobođeni okvir stranice, prilagođava tabelu i ponovo izvršava prekinutu komandu.

7.2 Kako radi MMU?Neka CPU šalje adresu 8196 = 0010000000000100. Tu adresu dijelimo na dva

dijela: 4 najznačanija bita označavaju index unutar tabeli stranica, a ostalih 12 bita offset 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 dijelili na

4KB stranice.) Tabela stranica sadrži dakle 16 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 slijedeći način: na osnovu 4 najznačajnija bita adrese dobijene od CPU-a (0010) , uzmemo indeks okvira stranice (110) , pogledamo da li je data stranica učitana u internu memoriju (1 – jeste, ako nije, generišemo 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 offset adresu unutar tog 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.

7.3 Tabele stranicaU najjednostavnijem slučaju preslikavanje iz virtualnih adresa u fizičke

funkcioniše onako kako je upravo opisano. Virtualna adresa se djeli na virtualni broj stranice (biti visoke vrijednosti) i offset (biti niske vrijednosti). Broj virtualne stranice se koristi kao indeks za pretraživanje tabele stranica. Informacija u

Tabele stranica 175

tabeli stranica sadrži broj odgovarajućeg okvira stranice, kada je dostupan. Broj okvira stranice se stavlja na kraj offseta do bita višeg prioriteta i zamijenja broj virtualne stranice. Broj okvira stranice i offset daju fizičku adresu koja se šalje u memoriju. Svrha tabele stranica je preslikavanje virtualnih stranica u okvire stranica.

Postoje dva najvažnija problema:1. tabela stranica može postati ekstremno velika,2. preračunavanje mora biti jako brzo.

7.4 Informacije u tabeli stranicaTačna građa podataka u tabelu stranica zavisi od mašine ali informacije koje su

tu sadržane su kod skoro svih mašina iste. Slika prikazuje primjer unosa u tabelu.

Veličina se razlikuje od računara do računara ali su 32 bita tipična veličina. Najznačajnije polje je broj okvira stranice stranice, čija je vrijednost u suštini i razlog pravljenja tabele. Pored toga imamo present/absent bit koji pokazuje da li stranica trenutno leži u memoriji. Ukoliko je ova vrijednost 0 kod zahtjeva za stranicom nastaje greška stranice. Zaštitini biti upravljaju pristupom stranici, u najjednostavnijem slučaju ovo polje sadrži samo jedan bit 0 za pristup za čitanje i pisanje i 1 za čitanje.

Modified bit (M-bit) i referenced bit (R-bit) protokolišu pristup stranici. Zadnji bit dozvoljava regulisanje keširanja. Ova osobina je značajna za stranice koje se preslikavaju u registre uređaja a ne u memoriju. Ako je operativni sistem poslao U/I instrukciju nekom uređaju i čeka u petlji na odgovor. Tu je značajno da hardver pri svakom prolasku kroz petlju pročita vrijednost registra a ne jednu te istu kopiju keša. Pomoću ovog bita se keširanje može isključiti.

7.5 Spremnik za prevođenje TLB – Translation Lookaside Buffer

U većini sistema sa straničenjem se tabele stranica drže u memoriji zbog njihovog obima. Zbog toga performanse sistema mogu biti oslabljene. Uzmimo kao primjer jednu instrukciju koja kopira jedan registar u drugi. Bez straničenja je ovde potreban samo jedan pristup memoriji da se instrukcija uzme iz memorije. Sa straničenjem su potrebni dodatni pristupi memoriji da se uzme instrukcija iz tabele stranica. Kada je po jednom pristupu potrebno više pristupa tabeli stranica smanjuju se performanse i pod ovim uslovima se tabela stranica nikad ne koristi u memoriji.


Računari imaju jedan mali uređaj, koji virtualne adrese, bez zaobilaska preko tabele stranica, preslikava na fizičke adrese. To je skup povezanih registara građen od brze memorije a zove se zove TLB (engl. translation lookside buffer). TLB se koristi sa tabelama stranica kao keš za najčešće korištene memorijske reference. Ukoliko se referenca pronađe u TLB, adresa okvira se dobija gotovo istovremeno i prelazi se na pravu memorijsku referencu. Ukoliko se dogodi promaršaj tad se par vrijednosti za tekuću referencu mora dovesti u TLB.

On je jedan dio MMU i sastoji se od malog broja unosa. U ovom slučaju je to 8, u stvarnosti rijetko više od 64. Svaka stavka TLB-a sadrži informaciju o jednoj stranici pod tim virtualni broj stranice, bit koji se postavlja kad se stranica modificira, zaštitni bit i fizički okvir stranice. Još jedan bit pokazuje da li je unos važeći. Kada se jedna virtualna adresa pošalje MMU, hardver prvo provjerava da li će odgovarajući unos pronaći u TLB. Kada se odgovarajući unos pronađe i pristup nije u suprotnosti sa bitom zaštite, primjenjuje se broj okvira stranice iz tabele. Kada virtualna stranica ne stoji u TLB MMU zaključuje da nema tog unosa, normalno pristupa tabeli stranica i upisuje u TLB pri čemu prepisuje neki stari unos.

7.6 Invertovana tabela stranicaRješenje za veće sisteme je invertovana tabela stranica (engl. inverted page table).

Kod ovog pristupa se u tabelu stranica snima jedna vrijednost po svakom fizičkom okviru stranice umjesto po svakoj stranici u virtualnom prostoru. Svaki unos u tabelu za odgovarajući okvir stranice unosi sastoji se od informacije o virtualnoj adresi stranice smještene na tu memorijsku lokaciju sa informacijom o procesu koji posjeduje tu stranicu: odgovarajući par (proces, broj stranice). Ivertovana tabela stranica štedi memoriju, bar ond kada je virtualni adresni prostor značajno veći od fizičke memorije ali imaju jedan značajan nedostatak. Sad je značajno komplikovanije virtualnu adresu preslikati na jednu fizičku adresu. Kada proces n želi pristupiti virtualnoj stranici p, hardver ne može jednostavno naći fizički okvir stranice tako što koristi virtualni broj stranice kao indeks nego mora pretražiti čitavu tabelu tražeći unos (p,n). Osim toga je ova pretraga neophodna za svaki pristup memoriji a ne samo kod greške stranice.

Rješenje za ovu dilemu je TLB. Kada sve stranice koje se puno koriste mogu stati u TLB, preračunavanje adresa je jednako brzo kao i preračunavanje sa tabelama stranica. Prilikom TLB greške mora invertovana tabela stranica biti softverski pretražena.

Invertovana tabela stranica (engl. inverted page table (IPT)) kombinuje tabelu stranica i tabelu okvira u jednu strukturu podataka. U suštini je to jedna tabela fiksne veličine sa redovima koji su povezani sa okvirima stranice fizičke memorije. Za svaki red postoji jedno mjesto za broj virtualne stranice (virtual page number (VPN)) broj okvira stranice i još neki podaci.

Jedna praktična metoda je korištenje hash-tabele sa hash vrijednostima. Sve virtualne stranice koje imaju istu hash vrijednost su povezane u listu kao na slici. Kada hash-tabela ima toliko unosa koliko sistem fizičkih stranica, svaki lanac ima

Invertovana tabela stranica 177

jedan unos što ubrzava pretragu. Kada je broj stranice pronađen, novi par koji se sastoji od virtualne stranice i fizičkog okvira stranice se unese u TLB.

7.7 Hijerarhijsko straničenjeVećina savremenih računara podržava širok logički adresni prostor pa su tabele

stranica jako velike. Kod metoda straničenja sa dva nivoa postoji spoljna tabela stranica koja ukazuje na stranice u kojima su smještene prave tabele stranica.

Može se ići i na više nivoa.

7.8 Izbor stranica za učitavanje (fetch-strategy)Imamo dvije osnovne strategije:1. Učitavanje po potrebi (engl. 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. Loša strana je sporost.

2. Učitavanje sa predviđanjem (engl. anticipatory paging): OS pokuša predvidjeti, 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 grešaka (page fault) i izvršavanje procesa dobija na brzinu. Ako ne, od učitavanja nemamo nikakvu korist. Kako cijena interne memorije pada a kapacitet raste, ova strategija postaje sve popularnija.

7.9 Algoritmi za izbor stranice za zamjenjivanje (page replacement algorithms)

Kada dođe do prekida - page fault, koji javlja OS-u da MMU nije našao traženu virtuelnu stranicu među okvirima unutar interne memorije, OS treba da odredi u koji će okvir učitati potrebnu stranicu, odnosno sadržaj kog okvira će izbaciti iz operativne memorije da napravi mjesta za stranicu koja stiže.

Ako je sadržaj izabranog okvira modifikovan, OS ga mora prebaciti na disk s ciljem aktueliziranja kopije koja se nalazi na disku. Međutim ako se stranica nije mijenjala, kopija na disku je aktuelna tako da aktueliziranje nije potrebno a stranica koja se upisuje u operativnu memoriju jednostavno prepiše stranicu koju treba izbaciti.

Iako bi bilo moguće izabrati slučajnu stranicu da se riješi problem greške stranice, performanse sistema su mnogo bolje ako se izabere stranica koja se ne koristi puno. Možemo pretpostaviti da će stranica koja se mnogo koristi vjerovatno vrlo brzo ponovo biti potrebna. Ako se ukloni takva stranica vrlo brzo ćemo u tom slučaju ponovo imati page fault.

Dosta teoretskih i praktičnih istraživanja je urađeno na temu algoritama zamjene stranica.

Algoritmi za izbor stranice za zamjenjivanje (page replacement algorithms)Objasnićemo neke od najvažnijih algoritama:1. Optimalni algoritam2. NRU (Not Recently Used): okvir koji nije skoro korišten3. FIFO (First-In, First-Out algoritam): prvi učitani okvir4. Druga šansa (Second Chance): varijanta FIFO algoritma5. Satni (Clock page) algoritam6. LRU (Least Recently Used): izbaciti onu stranicu koja u prošlosti nije najdulje

upotrebljavana7. NFU (Not Frequently Used): najrjeđe korišten okvir8. NFU sa starenjem9. Algoritam sa radnim skupom (Working Set Algoritam )10. WSClock algoritam zamjene stranica

7.10 Optimalni algoritam (Optimal Page Replacement Algorithm)

Kada dođe do page fault-a, optimalni algoritam će se potruditi 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 slijedeće greške

Optimalni algoritam (Optimal Page Replacement Algorithm) 179

stranice odložiti najduže što možemo. MMU ne voli prekidati svoj rad i javljati OS-u da nije našla neku stranicu, zato se trudimo da odložimo prekide što duže.

Ova je najbolja moguća strategija, ali nažalost ne može se implementirati. Ne postoji način da OS dođe do potrebne informacije o tome, kada će koja stranica biti potrebna. Trebalo bi na neki način predvidjeti rad procesa. Računari kao i ljudi pokušavaju da odgode neprijatne događaje što je moguće dalje u budućnost. Jedini problem sa ovim algoritmom je da ga nije moguće realizovati. U trenutku u kome se pojavljuje greška stranice, operativni sistem ne zna koja je stranica sljedeća. Imali smo sličnu situacija sa algoritmom raspoređivanja: SJF - najkraći posao prvi gdje se postavljalo pitanje kako sistem zna koji je posao najkraći.

Ipak ako pokrenemo program na simulatoru moguće je implementirati optimalnu zamjenu stranica, iz drugog puta, korištenjem informacije koje su prikupljene prvi put.

Na ovaj način je moguće uporediti preformanse algoritma koji je moguće realizovati sa najboljim mogućim algoritmom. Ako operativni sistem postigne performanse samo 1% lošije nego optimalni algoritam napori uloženi za traženje boljeg algoritma će dati u najboljem slučaju 1% bolji rezultat.

Treba naglasiti da se ovo odnosi samo na mjereni program sa specifičnim ulaznim podacima. Iako je ovaj metod koristan za procjenu algoritma zamjene stranica nije od praktičnog značaja u realnim sistemima. Dalje ćemo razmatrati algoritma koji su korisni u realnim sistemima.

7.11 NRU (Not Recently Used): okvir koji nije skoro korišten

Strategija ovog algoritma je slijedeća: izbacujemo onu stranicu kojoj nismo skoro pristupili. Da bi omogućili operativnom sistemu da prikupi korisnu statistiku o tome koje su stranice korištene a koje ne, većina računara sa virtualnom memorijom imaju dva statusna bita koja su povezana sa svakom stranicom. Pretpostavimo da su svakom okviru pridružena dva bita: R (engl. referenced)

– označava da li smo pristupili (čitali ili pisali) tom okviru, odnosno M (engl. modified) – da li smo mijenjali sadržaj tog okvira. Ako hardver računara ne podržava ove bitove, mogu se implementirati na nivou OS-a.

R se postavlja svaki put kad se stranica korist (čita ili piše). M se postavlja kada se na stranicu upisuje (modificira). Biti su sadržani u tabeli stranica.

Značajno je da ovi biti moraju biti aktuelizirani prilikom svakog pristupa memoriji i moraju biti postavljeni od strane hardvera. Kad je bit postavljen na 1 on ostaje 1 sve dok ga operativni sistem ne resetuje na 0.

Pri početku rada procesa svi R-biti i M-biti dobijaju vrednost 0. Zatim pri svakom prekidu hardverskog sata OS briše vrednost R-bita (stavlja R=0) – da bi mogao razlikovati stranice koje su skoro korištene od onih koje nisu. Ako je R=1, to znači da je datom okviru pristupano u zadnjem vremenskom intervalu. Kada učitamo neku stranicu sa eksterne u internu memoriju stavimo M=0 (sadržaj okvira nije modificiran). Ako dođe do mijenjanja sadržaja stranice, stavimo M=1 – to onda


označava da ćemo morati sadržaj tog okvira prebaciti na disk, da bi smo sačuvali promjene, ako za izbacivanje izaberemo baš taj okvir.

R i M biti se koristiti da formiraju jednostavan algoritam straničenja. Ukratko, kada je proces pokrenut, operativni sistem postavlje oba bita za sve njegove stranice na 0. Periodično, na svaki prekida sata, R bit se briše. Tako je R bit postavljen samo kod stranica koje su u zadnje vrijeme korištene.

Kada se pojavi greška stranice operativni sistem pregleda sve stranice i dijeli ih na četiri kategorija na osnovu vrijednosti njihovih R i M bita:

Klasa 0: nije referenciran, nije modifikovana (R=0, M=0).Klasa 1: nije referenciran, modificiran (R=0, M=1). Klasa 2: referenciran, nije

modifikovan (R=1, M=0). Klasa 3: referenciran, modifikovan (R=1, M=1).Iako klasa 1 izgleda nemoguća, ona se pojavljuje kada je kod stranice klase 3 R

bit modificiran na signal sata. Signal sata ne briše M bit jer je ovaj bit potreban da se zna da li se stranica mora aktuelizirati na disku. Brisanje R ali ne i M vodi ka stranicama klase 1.

NRU (Not Recently Used) algoritam uklanja slučajnu stranicu iz najniže klase. Ovde postoji pravilo da je bolje ukloniti modificiranu stranicu koja nije referencirana u bar jednom taktu sata nego čistu stranicu koje se često koristi. Glavna prednost NRU algoritma je da je jednostavan za razumjevanje, srednje efikasan za implementaciju i pruža performanse koje iako nisu optimalne mogu biti odgovarajuće.

7.12 FIFO (First-In, First-Out algoritam): prvi učitani okvirDrugi algoritam sa malim opterećenjem (overhead) je FIFO (First-In, First-Out)

algoritam. Kao ilustraciju razmotrimo supermarket koji ima dovoljno polica da izloži tačno k različitih proizvoda. Ako želimo uvesti novi proizvod koji obećava uspjeh na tržištu a nemamo dovoljno prostora pretpostavimo da će se supermarket oslobodi nekog starog proizvoda da bi imao mjesta za novi.

Jedna mogućnost je pronaći proizvod koji se nalazi u prodaju najduže i rješiti ga se uz pretpostavku da za njega nije više niko zainteresovan. Supermarket vodi listu proizvoda onim redom kojim su uvođeni u prodaju. Novi proizvod dolazi na kraj liste a prvi na listi je izbačen.

Kod algoritma zamjene stranica može se primjeniti ista ideja. Operativni sistem održava listu svih stranica koje su trenutno u memoriji na čelu sa stranicom koja je najstarija i na kraju onom koja je zadnja stigla. Kod greške stranice, stranica sa vrha se uklanja a na kraj se dodaje nova stranica.

Kada ovo primjenimo na supermarket, može se desiti da sa prodajne liste uklnimo neki zaista nepotreban proizvod ali isto tako i neki neophodan proizvod (brašno, so ili puter). Isto važi i za računare te je zato FIFO algoritam rijetko korišten.

Ovaj algoritam pretpostavlja da ako je neka stranica davno učitana, vjerovatno je već odradila svoj dio posla i da će ubudućnosti manje biti potrebna od stranica koja su stigla posle nje. Nedostatak ovog pristupa je to što ćemo izbaciti stranicu

FIFO (First-In, First-Out algoritam): prvi učitani okvir 181

čak i ako je često koristimo – samo zato što je “ostarila”. Zbog ovog nedostatka ovaj algoritam se u ovoj verziji ne koristi.

7.13 Druga šansa (Second Chance): varijanta FIFO algoritma

Jednostavna modifikacija FIFO algoritma koja sprječava odbacivanje stranica koje se često koriste ispituje R bit najstarije stranice. Ovaj algoritam sprječava odbacivanje stranica koje se često koriste tako što ispituje R bit najstarije stranice. Kao pomoć, koristimo vrijednost 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že se izbaciti i učitati nova. Ako je R=1, to znači da je stranica dugo u memoriji, ali smo je nedavno koristili. Tada ćemo staviti R=0 a stranicu prebacimo na početak reda opsluživanja i gledamo slijedeću stranicu. Znači, ako je stranica korištena dobija još jednu šansu.

Ako je R=0 stranica je i stara i nekorištena zato se odmah zamjenjuje. Ako je R bit 1, bit je izbrisan, stranica se stavlja na kraj liste stranica i njeno vrijeme punjenja se aktuelizira tako da izgleda da je upravo stigla u memoriju. Nakon toga se traženje nastavlja. Ako su sve stranice korištene, algoritam će staviti R=0 za svaku, pa će početi ponovo od najstarije stranice. Sada je R=0, pa će najstarija stranica biti izbačena. Algoritam sigurno nalazi okvir za izbacivanje. Ako je R=0 za sve stranice, ovaj se algoritam ponaša isto kao i FIFO verzija.

Rad ovog algoritma koji se zove second chance, je prikazan na slici. Na slici (a) vidimo stranice A do H čuvane vezanoj listi i sortirane prema remenu kad su stigle u memoriju.

Pretpostavimo da se greška stranice pojavi u trenutku 20. Najstarija stranica je A, koja je stigla u trenutku 0 kada je proces počeo sa radom. Ako A ima R=0, stranica se uklanja iz memorije ili pisanjem na disk (M-bit postavljen) ili samo prepisivanjem (M=0).

S druge strane ako je R bit postavljen (R=1), A se stavlja na drugi kraj liste i njeno vrijeme punjenja se postavlja na aktuelno vrijeme (20). R bit je izbrisan. Potraga za odgovarajućom stranicom nastavlja sa B.

To što second chance radi je traženje neke stare stranice koja nije pozivana u zadnjem vremenskom intervalu. Ako je stranica referencirana ovaj algoritam se svodi na prosti FIFO. Zamislimo da sve stranice sa slike (a) imaju R bit postavljen.


Operativni sistem ih jednu po jednu pomjera na kraj liste briše R bit. Na kraju se vraća na stranicu A koja sad ima R obrisan. U ovom trenutku se A uklanja. Tako da se algoritam uvijek može završiti.

7.14 Satni (Clock page) algoritamNepotrebno pomjeranje stranica čini ovaj algoritam druga šansa nedovoljno

efikasnim. Satni algoritam je nadogradnja algoritma druga šansa. Pokazuje se da je bolji pristup je čuvati okvire stranica u kružnoj listi u formi sata kao što je prikazano na slici.

Pokazivač pokazuje na najstariju stranicu, tj. na stranicu koja je najranije učitana. Kada dođe do greške stranice, stranica na koju se pokazuje se pregleda, tj. provjeri se R bit stranice na koju pokazuje pokazivač. Ako je R = 0 stranica se izbacuje a nova se ubacuje na njeno mjesto, pokazivač se pomjera za jedno mjesto. Ako je R =1 ovaj bit je obrisan (stavi se R=0) i kazaljka se pomjera na slijedeću stranicu, nastavljamo traženje. Na ovaj način izbjegavamo stalno pomjeranje opisa stranica sa početka reda opsluživanja na kraj, što se javlja kod algoritma druga šansa, a time poboljšavamo performanse. Ovaj proces se ponavlja dok se stranica za izbacivanje ne pronađe. Ovaj algoritam se od algoritma second chance razlikuje samo u implementaciji.

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.

7.15 Least recently used (LRU) algoritamDobra aproksimacija optimalnog algoritma se zasniva na razmatranju da će

stranice koje su se puno koristile u zadnjih nekoliko instrukcija, biti vjerovatno korištene u nekoliko budućih instrukcija. S druge strane stranice koje nisu dugo korištene vjerovatno se i dalje neće dugo koristiti. Ova ideja predlaže algoritam koji se može realizovati: kada se pojavi greška stranice odbacuje se stranica koja se najduže nije koristila. Strategija se zove LRU (Least Recently Used) straničenje.

Iako je LRU teoretski moguće realizovati, to nije jeftino. Ovaj algoritam radi jako dobro, ali se teško ostvaruje. Implementacija zahtjeva podršku od strane hardvera.

Least recently used (LRU) algoritam 183

Imamo nekoliko realizacija:1. Pomću brojača (hardverska podrška): procesor ima brojač instrukcija. Ovo je

načini implementacije LRU sa specijalnim hardverom. Ovaj metod podrazumjeva opremljenost hardvera jednim 64-bitnim broječem C koji se automatski povećava poslije svake instrukcije. Dalje svaki unos u tabelu stranica treba imati polje koje je dovoljno veliko da sadrži brojač. 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žaj brojača procesora u interni brojač okvira. Kada dođe do page fault prekida, upravljač memorijom pregleda sve interne brojače i bira stranicu čiji je brojač najmanji (to znači da je korištena najdavnije). Nedostatak: pri svakom pristupu memorije moramo izvršiti plus jedan pristup radi prebacivanja sadržaja glavnog brojača u lokalni.

2. Pomoću povezane liste (softversko rješenje): slično kao kod FIFO algoritma, stranice stavljamo u red opsluživanja. Za potpuno implementiran LRU je neophodno urediti povezanu listu svih stranica u memoriji, sa nedavno korištenom stranicom naprijed, i najdavnije korištenom stranicom na kraju. 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. Pronalaženje stranice na listi, brisanje, i pomjeranje naprijed zahtjeva puno vremena, čak i u hardverskoj realizaciji uz pretpostavku da takav hardver može biti napravljen.

3. Pomoću dvodimenzionalnog niza (matrice – hardverska podrška): Pogledajmo sada drugi hardverski algoritam. Imamo matricu formata NxN, gdje N označava broj okvira interne memorije. Matrica se inicijalizuje na nulu (nulamatrica). Prilikom pristupa k-tom okviru, k-ti red matrice ispunimo sa jedinicama a k-tu kolonu sa nulama. Tada red označavaju mladost odgovarajuće stranice u binarnom zapisu (što je broj veći, stranica je korištena u bližoj prošlosti). Biramo stranicu sa najmanjim brojem. U svakom tenutku , red čija binarna vrijednost je najniža je najduže nekorišten.

Rad ovog algoritma je prikazan na slici. sa okvirima stranica i redom pristupanja 0 1 2 3 2 1 0 3 2 3. Nakon prvog pristupa stranici 0 imamo situaciju na slici (a). Nakon pristupa stranici 1 sliku (b) itd.


7.16 NFU (Not Frequently Used): najrjeđe korišten okvirJoš jedna mogućnost je NFU (Not Frequently Used) algoritam. Ovo rješenje za

savaku stranicu ima jedan softverski brojač koji se na početku postavlja na 0. Biramo stranicu koja je najrjeđe (najmanji broj puta) korištena. Kod svakog prekida sata opeartivni sistem prekontroliše sve stranice u memoriji i dodaje svakom brojaču odgovarajuće stranice pripadajući R bit. Ovi brojači su pokušaj da se izbroji koliko se često pristupa jednoj stranici. Kod greške stranice stranica sa najnižom vrijednosti brojača će se odbaciti.

Nedostaci:1. Algoritam sve pamti: stranice koje smo nekada često koristili ostaju u

memoriji i pored toga što više nisu potrebne.2. Nove stranice kreću od nule, stare imaju prednost, pa ćemo izbaciti tek učitanu

stranicu.Problem je da ovaj algoritam nikad ne zaboravlja. Može se desiti da operativni

sistem izbaci one stranice, zbog vrijednosti brojača, koje su nam potrebna. Potreban je mala promjena koja će približiti ovaj aloritam LRU. Promjena se sastoji iz dva dijela. Brojači se pomjeraju desno prije dodavanja R bita, i ovaj bit se dodaje krajnjem lijevo bitu (najznačajnijem bitu). Kako ovaj poboljšani algoritam funkcioniše pokazuje slika.

Ovaj algoritam je poznat pod imenom aging.U prvom intervalu R biti imaju vrijednost 1, 0, 1, 0, 1, 1. Drugim rječima u prvom

intervalu se pristupalo stranicama 0, 2, 4 i 5. Nakon pomjeranja brojača za jedan bit na desno i dodavanja R bita krajnjem lijevom bitu imao situaciju sa slike (a). Ostale stranice pokazuju šta se dešava nakon sljedeća 4 intervala.

Kod greške će se otkloniti stranica sa najnižom vrijednošću brojača. Ako dvije stranice imaju vrijednost brojača 0 možemo samo po slučajnom principu otkloniti jednu od njih. Pošto nemamo više od 8 bita, može se desiti da je jednoj stranici pristupano prije 9 intervala a drugoj prije 1000, nemamo načina da to ustanovimo.

NFU sa starenjem 185

7.17 NFU sa starenjemOvaj algoritam (aging) pokušava izbjeći nedostatak NFU algoritma da ne bi sve

pamtio – uračunava i starost stranice: OS prilikom svakog prekida hardverskog sata pomjera bitove unutrašnji brojača prema desno (najmanje značajni bit se gubi), a vrijednost R bita se postavi na najznačajniju poziciju (prvi bit sa lijeve strane). Izbacujemo stranicu čiji brojač ima najmanju vrednost.

Uporedimo rad čisto NFU algoritma i NFU algoritma sa starenjem na jednom primjeru: Sa NFU algoritmom:

Vidimo da smo nekada treću stranicu često koristili a kako NFU pamti sve, brojač treće stranice ima veću vrijednost nego brojač stranice 4 kojoj smo u bliskoj prošlosti pristupili čak dva puta, a ipak će ta biti izbačena.

Sa NFU algoritmom sa starenjem:

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

7.18 Algoritam sa radnim skupom (working set algoritam)U najčistijoj formi straničenja proces počinje bez i jedne stranice u memoriji. Čim

CPU pokušava pozvati prvu instrukciju dolazi do greške stranice i operativni sistem puni prvu stranicu. Nakon nekog vremena proces ima većinu stranica koje su mu potreben na raspolaganju i radi dalje sa malim brojem grešaka. Stranice koje proces u jednom određenom trenutku koristi zovu se radni skup (engl. working set). Kada je čitav working set u memoriji proces radi bez puno grešaka, do sljedeće faze rada. Kada memorija koja je na raspolaganju nije dovoljna za sve stranice u working setu proces proizvodi mnogo grešaka stranice i radi sporo. Ovakvo ponašanje nativa se thrashing.

Puno sistema zapamti working set procesa i pobrine se da ga napuni prije ponovnog pokretanja procesa. Ovaj pristup se zove working set model, i od njega se očekuje da značajno smanji broj grešaka stranice. Ne smije se zaboraviti da se working set s vremenom mijenja. Strategija koja puni stranice prije nego što su potrebne zove se predstraničenje (engl. prepaging).

Već dugo je poznato da pristupi memoriji jednog programa nisu jednako podjeljeni preko adresnog prostora nego su koncentrisani na nekoliko stranica. Svaki pristup memoriji ili uzima jednu instrukciju, čita podatke iz memorije ili


upisuje podatke u memoriju. U svakom trenutku t postoji veliki broj stranica kojima je pristupano u zadnjih k pristupa memoriji. Ova veličina: w(k,t) je working set. Granična vrijednost w(k,t) je konačna zato što jedan program ne može pristupiti više stranica nego što može stati u njegov adresni prostor. Slika prikazuje working set u zavisnosti od k.

Za implemantaciju working set modela operativni sistem mora u svakom trenutku znati, koje stranice su u working setu jednog procesa. Iz ove informacije slijedi direktno algoritam straničenja: Kada se pojavi greška stranice, nađi stranicu koja ne pripada radnom working setu, i izbaci je. Vrijednost k mora se unaprijed utvrditi.

Osnovna ideja ovog algoritma je kad dođe do greške stranice, izbaciti stranicu koja ne pripada working setu. Slika prikazuje isječak iz jedne tabele stranica.

Svaki unos sadrži najmanje dvije informacije: približno vrijeme zadnjeg pristupa stranici i R bit. Kod svake greške stranice će tabela stranica biti pretražena u potrazi za stranicama koje se mogu izbaciti. Kod svakog unosa se prvo ispituje R bit. Ako je ovaj bit postavljen u polje za vrijeme zadnjeg pristupa se unosi aktuelno vrijeme, to znači da se stranica u vrijeme pojave greške koristila. S obzirom da je stranica korištena u aktuelnom vremenskom intervalu očigledno pripada u working set i ne treba je izbaciti.

Kada je R=0 stranica je mogući kandidat za izbacivanje zato što joj nije pristupano u zadnjem vremenskom intervalu. Da se proračuna da li stranica pripada u working set izračunaće se njena starost, aktuelno vrijeme minus vrijeme zadnjeg pristupa i uporedi sa τ - uzma se da traje nekoliko intervala. Ako je starost veća od τ ova stranica ne spada više u working set. Ako se nađe više stranica sa R=0, izbacuje se ona sa najvećom starošću.

WSClock algoritam zamjene stranica 187

7.19 WSClock algoritam zamjene stranicaJednostavni working set algoritam je kompikovan, zato što kod svake greške

stranice provjerava čitavu tabelu dok ne nađe odgovarajućeg kandidata. Jedan bolji algoritam koji je izgrađen na clock algoritmu zove se WSClock. Zahvaljujući njegovim dobrim karakteristikama i jednostavnoj implementaciji je u realnim sistemima veoma raširen.

Jednako kao i clock algoritam i WSClock algoritam koristi prstenastu listu okvira stranica. (vidi sl.). Kada se prve stranice pozovu, ubacuju se u listu. S vremenom se unosi sve više stranica i lista postaje prsten. Svaki unos u listu sadrži R bit, M bit i polje za zadnji pristup stranici (iz jednostavnog working set algoritma).

Kao i kod clock algoritma prvo će se pregledati stranica na koju pokazuje kazaljka. Ako je R bit postavljen stranica je korištena u zadnjem intervalu. Prema tome ona ne može biti kandidat za izbacivanje. R bit se postavlja na 0, kazaljka se pomjera ka sljedećoj stranici i algoritam se ponavlja za ovu stranicu. Slika (b) pokazuje stanje nakon ovoga.

Šta se dešava kad je R bit 0, kao na slici (c). Ako je starost stranice veća od τ i ako ona nije mjenjana ne pripada u working set i postoji njena važeća kopija na disku. Stranica će onda jednostavno, kako pokazuje slika (d) obrisana i zamjenjena novom stranicom. Ako je sadržaj stranice promjenjen ona ne može jednostavno biti obrisana jer se mora aktuelizirati na disku. Da bi se izbjegla promjena procesa, prelazak na drugi proces, zabilježi se da se sadržaj stranice treba prepisati na disk i radi se sa algoritmom dalje jer se možda dalje na listi nalazi jedna čista stranica koja se bez problema može izbaciti.


U principu nakon jednog kompletnog prolaska listom sve stranice mogu biti označene za aktueliziranje na disk. Da bi se smanjilo operećenje diska može se postaviti limit da se na disk može snimiti maksimalno n stranica. Kada kazaljka prođe čitavu listu i opet dođe na početak moramo razlikovati dva slučaja:

1. Bar jedna stranica je obilježena za pisanje (aktueliziranje) na disk2. Nijedna stranica nije zabilježena.U prvom slučaju kazaljka jednostavno ide dalje i traži čistu stranicu. Prva čista

stranica na koju algoritam naiđe se zamjenjuje.U drugom slučaju sve stranice pripadaju u wokring set, strategija je ovde

izabrati bilo koju stranicu izbaciti je, upisati na disk i ovaj okvir koristiti za novu stranicu.

7.20 Pregled algoritama za zamjenu stranica• Optimalni algoritam zamjenjuje stranice koje će zadnje biti potrebne, na žalost

je nemoguće znati koje su to stranice. Nije ga moguće implementirati ali je dobar za upoređenje i mjerenje performanisi ostalih algoritama.

• NRU dijeli stranice na osnovu R i M bita na četri klase i bira slučajnu stranicu iz najniže klase koja nije prazna. Vrlo jednostavan za primjenu ali i primitivan. Postoje bolji algoritmi.

• FIFO algoritam pamti redosljed kojim stranice pristižu u memoriju, tako što ih unosi u jednu ulančanu listu. Izabrati najstariju stranicu je trivijalno ali ona može još biti potrebna iako je dugo u memoriji. Zbog toga je FIFO loš izbor.

• Second chance je modifikovana verzija FIFO. On provjerava da li će se stranica koristiti prije nego je otkloni iz memorije. Ovaj pristup značajno poboljšava performanse.

• Clock algoritam je drugi način implementacije algoritma secon chance.• LRU je odličan algoritam, za koji nam je potreban specijalni hardver.• NFU je pokušaj približavanja LRU algoritmu i nije naročito dobar

algoritam. Nasuprot tome aging predstavlja značajno bolje rješenje.• Dva zadnja algoritma koriste working set procesa. Working set pruža

pristojne rezultate ali je komplikovan za implementaciju. WSClock je varijanta koja pruža dobre performanse i efikasnu implementaciju.

Sve u svemu dva najbolja algoritma su aging i WSClock. Oba su bazirana na LRU i working setu procesa. Oba imaju dobre rezultate i mogu se efikasno primjeniti. Postoje još neki algoritmi ali ova dva su u praksi najznačajnija.

Pregled algoritama za zamjenu stranica 189

7.21 Beladayeva anomalijaIntuitivno možemo zaključiti da sistem sa više fizičkih okvira stranice proizvodi

manje grešaka stranice. Na žalost to nije uvijek tačno. Belady je (1969) otkrio da FIFO sa četri okvira stranice proizvodi više grešaka nego sa tri okvira stranica. Ova čudna situacija se naziva Beladays anomalija. Slika prikazuje situaciju za jedan program sa 5 virtualnih stranica, koje su numerisane od 0 do 4. Stranicama se pristupa u sljedećem nizu

012301401234Slika (a) pokazuje kako sa tri okvira stranica nastaje ukupno 9 grešaka. Na slici (b)

dobivamo 10 grešaka sa 4 okvira.

7.22 Stack algoritamSvaki proces dok radi proizvodi niz pristupa memoriji. Svaki pristup odgovara

jednoj određenoj virtualnoj stranici. Lista poredani brojeva stranica koja predstavlja ove pristupe memoriji zove se reference string. Ograničićemo se zbog jednostavnosti na sistem sa jednim proscesom.

Sistem zamjene stranica je karakterisan sa tri stvari:1. reference string2. algoritam zamjene stranica


3. broj m fizičkih okvira stranica.Možemo zamisliti jedan apstraktni interpreter koji funkcioniše na slijedeći način:

On dobiva jednu internu tabelu koja predstavlja stanja memorije. Tabela ima n unosa, jedan za svaku virtualnu stranicu procesa. Tabela M ima dva dijela. Gornji dio sa m unosa sadrži stranice koje se nalaze u memoriji, donji dio n-m sadrži stranice kojima se pristupalo ali koje su izbačene iz memorije. Na početku je M prazna jer se nije pristupalo ni jednoj stranici.

U slijedećem koraku proces počinje sa radom. Za svaku stranicu interapter provjerava da li se nalazi u gornjem dijelu ako ne signalizira grešku stranice. Ako postoji slobodan okvir stranice, puni je na to mjesto. Ovu situaciju imamo samo na početku izvršenja. Kada je memorija puna poziva se algoritam zamjene stranica da ukloni jednu stranicu iz memorije. Ovde će jedna stranica iz gornjeg dijela biti premještena u donji dio a stranica iz donje u gornji. Gornji i donji dio mogu biti dvije različite tabele.

Da pojasnimo rad interpretera pogledajmo konkretan primjer koji upotrebljava LRU algoritam. U gornjem dijelu tabele vidimo reference string. Tabela ima 25 kolona i 8 redova. Svaka kolona pokazuje stanje tabele u određenom trenutku tokom rada procesa. U ovom primjeru se nova stranica ubacuje na vrh a ostale stranice se automatki pomjeraju na dole.

Karakteristike modela ukratko:Kada se stranici pristupa ona se pomjera na vrh, ako je već bila u M, svi druge

stranice se pomjeraju preko njene pozicije prema dole. Unosi koji se nalaze ispod stranice kojoj se pristupa ostaju tamo gdje se nalaze. Ovaj algoritam se zove stack algoritam.

7.23 Raspodjela okviraNajprostija strategija dodjeljivanja fizičke memorije koja se može primjeniti je kad

god se pojavi potreba, stranica se učitava u memoriju. Postavlja se slijedeće pitanje. Kako rasporediti m okvira na n procesa? Makismalan broj okvira koje proces može dobiti je ograničen fizičkom veličinom memorije. Prema metodi jednake raspodjele, svakom se procesu dodjeljuje jednaka količina okvira m/n. Prema metodi proporcionalne raspodjele, okviri se dodjeljuju procesima na osnovu osobina procesa.

Raspodjela okvira 191

Pri tome je m ukupan broj okvira fizičke memorije, ai -broj okvira koji pripada svakom procesu, S -ukupna virtualna memorija, Si -veličina procesa pi, a n broj procesa. Osnovni nedostatak ovih metoda jeste to što pri raspodjeli okvira ne uzimaju u obzir prioritet procesa.

7.24 Lokalne i globalne strategije straničenjaJedno značajno pitanje je kako se memorija dijeli među konkurentnim procesima.Pogledjmo sliku (a). Na ovoj slici su tri procesa spremna za rad. Ako proces A

proizvede grešku stranice treba li algoritam zamjene u obzir uzeti samo njegovih 6 područja ili treba pretražiti čitavu memoriju. Slika (b) pokazuje slučaj kad on razmatra samo stranice od procesa A. Ako algoritam nasuprot tome traži najstariju stranicu u memoriji , bira stranicu B3 i imamo situaciju kao na slici (c).

Prva strategija se zove lokalna strategija straničenja a druga je globalna strategija. Generalno, globalna strategija bolje funkcioniše.

1. Lokalni pristup: svaki proces dobija određen broj okvira i taj broj se ne može mijenjati. Ako dođe do page faulta, onda stranicu za bacanje biramo u skupu dodeljenih okvira. Nedostatak: broj virtuelnih stranica procesa je veći od dodeljenog broja okvira u internoj memoriji, dobar dio memorije je slobodna, ali ne možemo učitati nove stranice bez izbacivanja već učitanih zbog fiksnog 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štenim okvirima.

2. Globalni pristup: broj pridruženih okvira nije ograničen. Memoriju dijelimo na okvire, svaki proces uzima koliko može. Ako proces A generiše page fault, tada za razliku od lokalnog pristupa, stranicu koja će biti izbačena nećemo tražiti samo u


skupu okvira prirdruženih za taj proces, već u skupu svih okvira. Znači može se desiti, da OS odluči da izbaci neki okvir procesa B a na to mjesto ubaci traženu stranicu procesa A. Globalni pristup pokazuje bolje rezultate.

7.25 Efekat zasićenjaProces zahtjeva radnu memoriju kao resurs. Ukoliko broj raspoloživih okvira

padne ispod minimalne vrijednosti, proces se mora dovesti u stanje WAIT jer resurs nije slobodan pa proces ne može da se izvršava. Ako je broj okvira raspoloživih za proces veoma mali, proces se može izvršavati ali su veoma česte page fault greške. Pojava čestog zamjenjivanja stranica, koja nastaje kao posljedica visokog stepena multiprogramiranja, naziva se efekat zasićenja (engl. thrashing). To značajno pogoršava performanse sistema. Stepen iskorištenosti procesora raste s povećanjem broja procesa do kritične tačke u kojoj počne naglo da opada zbog učestalih swap-in i swap-out operacija. Zasićenje se može spriječiti smanjenjem stepena multiprogramiranja.

7.26 Kontrola opterećenjaČak i sa najboljim algoritmom zamjene stranica može se desiti da sistem

proizvodi mnogo grešaka stranice. Simptom ove situacije je da PFF algoritam (page fault frequency algoritam za nadgledanje) koji govori da više procesa imaju malo memorije a ni jedan previše.

Rješenje je izbaciti neke procese na disk i osloboditi sve njihove stranice. Takođe treba ponovo razmotriti nivo multiprogramiranja.

7.27 Veličina stranicePostoje faktori koji govore u prilog maloj veličini stranica.Prednosti: manje unutrašnje fragmentacije, bolje se uklapa u različite strukture

podataka manje nekorištenih programa u memoriji. Nedostatci: programi trebaju puno stranica, velike tabele stranica. Na nekim računarima tabelu stranica treba pozvati registra i što su stranice manje to duže traje. Osim toga ove tabele za manje stranice zuzimaju više prostora. Prosječna veličina procesa je s bajta, stranice p bajta, a svaki unos u tabelu stranica e. Svaki poces pokriva onda u prosjeku s/p stranica i time se/p bajta u tabeli. Na internu fragmentaciju se gubi još p/2 , tako da imamo ukupno na fragmentaciju i tabelu:

Prvi dio je velik kad je stranica mala, drugi je velik kad je stranica velika, optimalno rješenje mora biti neki kompromis.Vadeći prvi izvod po p i izjednačavanjem sa 0 dobivamo optimizirano kad je

Veličina stranice 193

7.28 Dijeljene straniceJoš jedna značajna tačka kod sistema straničenja su dijeljene stranice. U

sistemu sa više korisnika često se dešava da više korisnika koriste jedan program. Očigledno je efikasnije stranice zajednički koristiti nego istovremeno imati više kopija iste stranice u memoriji. Problem pri tome je da sve stranice ne mogu istovremeno biti korištene. Stranice koje se samo čitaj (tekst programa) mogu biti korištene zajedno, one koje sadrže podatke ne mogu.

Ako sistem podržava ovdojene adresne prostore za programski tekst i podatke, najjednostavnija metoda je da dva ili više procesa koriste istu tabelu stranica za adresni prostor instrukcija i odvojene tabele stranica za adresni prostor podataka. U sistemu koji zajedničke tabelu podržava na ovaj način, tabele procesa su odvojene od tabela stranica. Svaki proces ima dva pointer u njegovoj tabeli procesa jedan na tabelu stranica za prostor instrukcija i jedan za tabelu stranica za prostor podataka kao što je prikazano na slici.

7.29 Memorijski mapirane datotekePošto virtualna memorija svakako sprema povremeno stranice u neku datoteku,

malim izmjenama se može postići da se sadržaj te stranice smiješta u datoteku koju odabere korisnik. Na ovaj način se pristup podacima datoteke umjesto poziva za čitanje i pisanje dalje obavlja prostim upisom na memorijsku lokaciju. Ovo može znatno povećati brzinu nekih ulazno/izlaznih operacija. Ako dva procesa dijele istu datoteku, ovaj mehanizam se može koristiti za komunikaciju procesa preko dijeljene memorije.

Mnogi programeri osjećaju da je pristup datotekama, kao što je prikazan prije, nepogodan, posebno kada se poredi sa pristupom memoriji. Iz ovih razloga, neki operativni sistemi, počevši od Multics-a, obezbjedili su način da se datoteke mapiraju u adresni prostor izvršnog procesa. Za ove svrhe postoje dva sistemska program kojim se datoteka mapira i mapiranje uklanja, mmap i unmap.

Na primjer, pretpostavimo da je datoteka ”f” velika 64 KB i mapirana je u virtuelni adresni prostor počevši od 512 K. Kada bilo koja mašinska instrukcija čita sadržaj memorijske adrese na 512 K, tada ona dohvata bajt 0 datoteke. Slično, pisanje na adresu 512K + 21000 modifikuje bajt 21000 datoteke. Kada proces


završi izvođenje, modifikovana datoteka će ostati na disku kao da su promjene izvršene sistemskim pozivima seek i write.

Interne sistemske tabele su promjenjene tako da datoteka postane rezervna memorija za region 512K do 576K. Dakle, čitanje sa 512 K uzrokuje grešku stranice dovlačeći u stranicu 0 datoteke sadržaj. Slično, pisanje 512 K + 1100 uzrokuje grešku stranice, dovlačeći u stranicu koja sadrži tu adresu poslije čega se može obaviti pisanje. Ako se stranica ikada izbaci zbog algoritama zamjena stranica, on se zapisuje ponovno na odgovarajuće mjesto u datoteku. Kada proces završi izvođenje, svi mapirane, modifikovane stranice se pišu nazad u njihove odgovarajuće datoteke.

Mapiranje datoteka najbolje radi u sistemu koji podržava segmentaciju. U takvom sistemu, svaka datoteka se može mapirati u svoje sopstvene segmente tako da bajt k u datoteki predstvalja i bajt k u segmentu. Na slici prikazan je proces koji ima dva segmenta, text i data. Pretpostavimo da ovaj proces kopira datoteke. Prvo, proces mapira izvornu datoteku, racimo “abc” u jedan segment. Zatim, kreira jedan prazan segment i mapira ga u odredišnu datoteku, xyz. Ova operacija je prikazana na slici

(a) Segmentirsani proces prije mapiranja datoteka. (b) Proces poslije mapiranja datoteke abc u segment i kreiranja novog segmenta za datoteku xyz.

U tom trenutku, proces može kopirati izvorni segment u odredišni segment koristeći običnu petlju za kopiranje. Nisu potrebni sistemski pozivi read i write. Kada se kopiranje završi, izvrši se sistemski poziv unmap, da bi se uklonile datoteke iz adresnog prostora i onda završi proces. Izlazna datoteka, xyz, će sada postojati kao da je bila kreirana na uobičajen način.

Mada mapiranje datoteka eliminira potrebe za U/I i na taj način čini programiranje lakšim, ono uvodi nove probleme. Prvo, teško je da sistem zna tačno dužinu izlazne datoteke, xyz, u našem primjeru. On može reći broj najviše pisane stranice ali ne može da zna koliko ima bajta u stranici. Pretpostavimo da program koristi samo stranicu 0, i poslije izvršavanja se nalazi još na stranici 0. Možda datoteka xyz sadrži 10 nula, a možda ta datoteka ima 100 nula a možda i 1000. Ko zna? Operativni sistem ne može da zna. Sve što može da uradi je da kreira datoteku čije je dužina jednaka veličini stranice, u ovom primjeru.

Drugi problem može se desiti ako je datoteka mapirana od strane jednog procesa a otvorena za čitanje od drugog procesa. Ako prvi proces modifikuje stranicu, ova promjena se neće vidjeti na datoteci sve dok stranica ne bude zapisana. Sistem treba da preuzme veliku brigu da dva procesa ne vide nekonzistentnu verziju datoteke.

Memorijski mapirane datoteke 195

Treći problem kod mapiranja datoteka je da datoteka može biti veća od segmenta, ili čak veća i od virtuelnog adresnog prostora. Jedini način je da se uredi sistemski poziv mmap da može da mapira dio datoteke umjesto cijele datoteke. Mada ovo funkcioniše, predstavlja ograničenje u odnosu na mapiranje cijele datoteke.

7.30 Pozadinski program za brisanje stranicaPerformanse straničenja se poboljšavaju ako uvijek ima dovoljno slobodnih

stranica. Umjesto da se rjeđe korištena stranica izbaci tek kada dođe zahtjev za alokacijom memorije, može se koristiti pozadinski program koji određuje koje stranice izbaciti, i ranije, a ne kada procesu zatreba stranica. Taj program je uglavnom neaktivan, a onda izbaci stranice kada broj slobodnih stranica padne ispod nekog praga.

7.31 Postupak kod greške straniceKada instrukcija pristupi memorijskoj lokaciji koja je u tabeli stranica označena

kao ne-dodijeljena fizičkom okviru, dešava se sljedeći postupak.1. Hardver upisuje stanje brojača i pokreće skok u kernel2. Snimljeno stanje opštih registara3. OS određuje koja virtualna stranica je potrebna4. OS provjerava validnost adrese, traži okvir stranice5. Ako je izabrani okvir modifikovan, zapiši na disk6. OS puni novu stranicu sa diska7. Aktueliziranje tabele stranica8. Instukcija koja je prouzrokovala grešku vraća se na prethodno stanje9. Raspoređivanje proces koji je prouzrokovao grešku10. Registri snimljeni11. Program nastavlja

7.32 Windows API za upravljanje stranicama i dijeljenom memorijom

Sljedećim funkcijama se može podešavati pristup memorijskim stranicama koristeći Windows.

• GetProcessWorkingSetSize(hProcess,lpMinimumWorkingSetSize,lpMaximumWorkingSetSize) Dobavlja veličinu radnog skupa u stranicama

• SetProcessWorkingSetSize(hProcess,dwMinimumWorkingSetSize,dwMaximumWorkingSetSize) Postavlja veličinu radnog skupa u stranicama

• VirtualLock (lpAddress,dwSize) VirtualUnlock(lpAddress,dwSize) Fiksira virtuelnu stranicu u memoriju ili je oslobađa

• VirtualProtect(lpAddress,dwSize,flNewProtect,lpflOldProtect) Mijenja prava čitanja, pisanja, izvršavanja nad stranicom


• CreateFileMapping(hFile,lpAttributes,flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, lpName) Priprema preslikavanje datoteke u RAM

• MapViewOfFileEx(hFileMappingObject,dwDesiredAccess,dwFileOffsetHigh,dwFileOffsetLow,dwNumberOfBytesToMap) Privi dijeljenu stranicu koristeći preslikavanje datoteke u RAM

7.33 Posix API za upravljanje stranicama i dijeljenom memorijom

Sljedećim funkcijama se može podešavati pristup memorijskim stranicama koristeći Posix kompatibilne operativne sisteme

• mprotect(pAddr, iLen, iProt) Postavlja prava nad dijelom memorije• mlock(pAddr, iLen) munlock(pAddr, iLen) Zaključava/otključava dio

virtuelnog prostora procesa• mlockall(iFlags) munlockall() Zaključava/otključava cijeli virtuelni prostor

procesa• mincore(pAddr, iLength, pVec) Informiše da li je taj dio adresnog prostora u

RAM-u• madvise(pAddr, iLength, iAdvice) Predlaže jezgru kako da mapira stranice

procesa

7.34 Poređenje straničenja i segmentacijeStraničenje i segmentacija su slični, ali imaju i međusobnih razlika. Najveća je da

aplikativni programer nije svjestan straničenja. On piše programe kao da je memorija linearna, a operativni sistem i procesor brinu o njenoj podjeli i pretvaranju u virtualne adrese. Programer na sistemima s segmentacijom međutim, u svojim programima navodi dva dijela adrese, segment i stranicu. Sve stranice su iste veličine, a segmenti su različite. Segmentacija ima više linearnih adresnih prostora, a straničenje samo jedan. Segmenti omogućavaju logičku podjelu i zaštitu dijelova aplikacije, a stranice ne.

7.35 Segmentacija sa straničenjemI straničenje i segmentacija imaju svoje prednosti . Straničenje, što je transparentno

za programera , eliminira vanjske fragmentacije i na taj način osigurava efikasno korištenje glavne memorije. Komadi koji su preselili u i izvan glavne memorije su fiksne jednake veličine , moguće je razviti sofisticirane algoritme upravljanja memorijom koji iskorištavaju ponašanje programa .

Segmentacija je vidljivo za programera i ima sposobnost da upravljaju rastom strukture podataka , modularnost, i podrška za razmjenu i zaštitu . Za kombiniranje prednosti oba pristupa, neki sistemi su opremljeni hardverom procesora i operativnim sistemom.

U kombinovanom sistemu straničenje/segmentacija korisnički adresni prostora je razbijen u niz segmenata po nahođenju programera. Svaki segment je dalje razbijen u

Segmentacija sa straničenjem 197

niz stranica fiksne veličine koje su jednaki dužini okvira glavne memorije. Ako je segment manji od dužine stranice, segment zauzima samo jednu stranicu.

Sa programerove tačke gledišta, logička adresa se još uvijek sastoji od niza segment i offset . Sa sistemske tačke gledišta , adresa se dobija iz segmenta, broja stranice i pozicije unutar stranice. Pristup je korišten u Multics i OS/2.

7.36 i386 memorijska arhitekturaIntelovi procesori su se razvijali evolutivno, nastojeći da nove generacije čuvaju

kompatibilnost s prethodnim, s obzirom na ogromnu bazu softvera. Kroz tu evoluciju, došlo se do 80386 procesora koji je omogućio takav MMU da postaje moguće realizovati operativne sisteme po želji koji koriste linearnu jednoprocesnu memoriju, memoriju organizovanu po segmentima bez zaštite, memoriju organizovanu po segmentima sa zaštitom, memoriju sa razdvojenim adresnim prostorom za program i podatke, straničenje na dva nivoa, razdvojene prostore za program i podatke sa straničenjem, segmentaciju s straničenjem, sve prostom promjenom nekoliko registara i popunjavanjem tabela. Princip je toliko dobar da se vrlo malo kasnije mijenjao, iako je prošlo oko 30 godina.

Srce virtualne memorije sadrži se od dvije tabele, LDT (Local Descriptor Table) i GDT (Global Descriptor Table). Svaki program ima svoju vlastitu LDT, doj postoji samo jedna GDT, koja se dijeli između svih programa na računaru. LDT opisuje segmente koji su lokalni svakom programu, uključujući njegov kod, podatke, stack, itd., dok GDT opisuje sistemske segmente, uključujući sam operativni sistem.

Da bi pristupio segmentu, i386 program prvo učita selektor za taj segment u jedan od 6 registara segmenata mašine. Tokom izvršavanja, CS registar drži selektor za kod segment, a DS registar drži selektor za segment podataka. Ostali registri segmenata su manje važni. Svaki selektor je 16-bitni broj, kako je prikazano na slici


Jedan od bita u selektoru govori da li je segment lokalni ili globalni (tj., da li je u LDT ili u GDT). Ostalih 13 bita specificiraju unosni broj LDT-a ili GDT-a, pa su te tabele ograničene na držanje 8K deskriptora segmenta. Preostala 2 bita odlaze na zaštitu i njih ćemo kasnije opisati. Deskriptor 0 je zabranjen. On se može upisati u registar segmenata da bi pokazao da registar segmenata trenutno nije dostupan. On izaziva prekid (trap) ako biva korišćen.

Kada se selektor učita u registre segmenata, odgovarajući deskriptor se uzima iz LDT ili GDT i pohranjuje u registre mikroprograma, da bi mu se brzo moglo pristupiti. Deskriptor se sastoji od 8 bajtova, uključujući baznu adresu segmenta, veličinu i druge informacije, prikazane na slici.

Format selektora je odabran da bi se olakšalo pronalaženje deskriptora. Prvo se odabire ili LDT ili GDT, na osnovu bita 2 selektora. Tada se selektor kopira u interni scratch registar, i najniža 3 bita se postave na 0. Konačno, adresa ili LDT ili GDT tabele se doda na to, da bi dala direktni pokazivač na deskriptor. Na primjer, selektor 72 upućuje na unos 9 u GDT, koji je lociran na adresi GDT+72.

Ispratimo sada korake po kojima (selektor, ofset) se par konvertuje u fizičku adresu. Čim mikroprogram koji se registri segmenata koriste, on može pronaći čitav deskriptor koji odgovara tom selektoru u njegovim internim registrima. Ako segment ne postoji (selektor 0), ili je trenutno izbačen, dešava se prekid (trap).

On tada provjerava da li je ofset izvan kraja segmenta, u kom slučaju takođe dolazi do prekida (trap). Logično, trebalo bi jednostavno, postojati 32-bitno polje u deskriptoru koje bi davalo veličinu segmenta, ali dostupno je samo 20 bita, pa se koristi drugačija šema. Ako je polje G-bita (Granularity) 0, Limit polje daje tačnu veličinu segmenta , koja ide do 1MB. Ako je 1, Limit poljedaje veličinu segmenata izraženu u stranicama umjesto u bajtovima. Veličina stranice kod i386 je fiksna i

i386 memorijska arhitektura 199

iznosi 4KB, pa su 20 dovoljni za segmente do 232 bajtova. Od procesora Pentium Pro, stranice mogu biti i 4MB velike.

Pretpostavimo da je segment u memoriji i da je ofset u okviru njega, Pentium tada dodaje 32-bitno Base polje u deskriptor ofseta da bi oformio ono što se zove linearna adresa, kako je prikazano na slici. Base polje se dijeli na tri dijela i širi po deskriptoru radi kompatibilnosti sa 286, u kom slučaju je Base samo 24 bita. Odnosno, Base polje omogućava svakom segmentu da počne od proizvoljnog mjesta u okviru 32-bitnog linearnog adresnog prostora.

Slika konverzija para (selektor, ofset) u linearnu adresu.

Ako je straničenje onemogućeno (globalnim registrom kontrole), linearna adresa se interpretira kao fizička i šalje u memoriju za čitanje ili upis. Prema tome, ako je straničenje onemogućeno imamo čistu segmentacionu šemu, gdje je svaka bazna adresa segmenta data u njegovom deskriptoru. Segmentima je dozvoljeno da se preklapaju, slučajno, vjerovatno zbog toga što bi trebalo previše vremena i muke da se provjeri da su svi odvojeni jedan od drugog.

Sa druge strane, ako je straničenje omogućeno, linearna adresa se interpretira kao virtualna i mapira u fizičku adresu korištenjem tabela stranica, skoro kao i u prethodnim primjerima. Jedina prava poteškoća je to što sa 32-bitnom virtualnom adresom i 4-KB stranicom, segment može da sadrži 1 milion stranica, pa se koristi dvo-nivoovsko mapiranje, radi smanjenja veličine tabele stranica za male segmente.

Svaki program koji se izvršava ima direktorij stranica (page directory) koji ima 1024 32-bitna unosa. Lociran je u adresi, a na njega pokazuje globalni registar. Svaki unos u ovaj direktorij pokazuje na tabelu stranica koja takođe ima 1024 32-bitna unosa. Unosi u tabelu stranica pokazuju na okvire stranica. Ova šema prikazana je na slici.


Slika Mapiranje linearne adrese u fizičku adresu.

Na slici (a) vidimo linearnu adresu podijeljenu na tri polja, Dir, Page (stranica) i Offset (ofset). Dir polje se koristi kao indeks u direktoriju stranica da bi se pronašao pokazivač na odgovarajuću tabelu stranica. Page polje se koristi kao indeks u tabeli stranica da bi se pronašla fizička adresa okvira stranice. Konačno, Offset se dodaje na adrese okvira stranice da bi se dobila fizička adresa bajta ili riječi koja je potrebna.

Unosi u tabelu stranica su 32-bitni, 20 bitova sadrži broj okvira stranice. Preostali bitovi sadrže pristupne (access) i “prljave” bitove, koje postavlja hardver, a koje koristi operativni sistem, bitove zaštite i druge korisne bitove.

Svaka tabela stranica ima unose za 1024 4-KB okvira stranica, pa jedna tabela stranica koristi 4 megabajta memorije. Segment koji je manji od 4M imati će direktorij stranica sa samo jednim unosom, pokazivač na njegovu jednu jedinu tabelu stranica. Na ovaj način, za male segmente biti će dodatne samo dvije stranice, umjesto milion stranica koje bi bile potrebne u jedno-nivoovskoj tabeli stranica.

Da bi se izbjeglo ponavljanje memorijskih referenci, i386 ima mali TLB koji direktno mapira većinu nedavno korištenih Dir-Page kombinacija u fizičke adrese okvira stranica. Samo kada trenutna kombinacija nije prisutna u TLB-u, odvija se mehanizam prikazan na slici, a TLB se ažurira. Sve dok su promašaji TLB-a rijetki, performanse su dobre.

Vrijedno je spomenuti da nekim aplikacijama nije potrebno segmentiranje, nego je njihov sadržaj unutar jednog, straničenog adresnog prostora, a takav model je moguć. Svi registri segmenata se mogu postaviti istim selektorom, čiji deskriptor ima Base = 0 i Limit postavljen na maksimum. Ofset instrukcije će tada biti linearna adresa, sa samo jednim korištenim adresnim prostorom – u stvari to je normalno straničenje.

Ulazno-izlazni sistem računara 201

8 Ulazno-izlazni sistem računaraOperativni sistem posjeduje podsistem koji obezbjeđuje komunikaciju sa ulazno-

izlaznim uređajima. Uređaji koji se mogu priključiti na računar svrstavaju se prema nekim opštim kriterijima u različite kategorije. Kategorije se formiraju prema slijedećim kriterijima:

- namjena uređaja,- smjer prenosa,- brzina prenosa podataka na relaciji računar-uređaj,- jedinična količina prenesenih podataka,- način pristupa podacima,- djeljivost uređaja,- mogućnost upisa.Ulazno-izlazni sistem računara obavlja dvije osnovne funkcije: upravljanje

ulazno- izlaznim uređajima i operacijama koje ti uređaji izvršavaju i kontrola uređaja te obezbjeđivanje što jednostavnijeg interfejsa prema korisniku i ostatku sistema. Podrška za uređaje i grupe srodnih uređaja sadržana je u programima za upravljanje ulazno- izlaznim uređajima – tj. drajverima (engl. drivers). Drajveri su jedinstveni interfejs ulazno- izlaznog sistema.

Osnovni ciljevi razvoja ulazno-izlaznog sistema su nezavisnost uređaja, nazavisnost koda, efikasnost i uniforman interfejs ka aplikacijama i korisniku.

Nezavisnost uređaja sastoji se u slijedećem. Različiti modeli uređaja istog tipa moraju se sa aspekta programa jednako posmatrati. Programi moraju biti nezavisni od konkretne vrste uređaja.

Ulazno-izlazni sistem mora preuzeti brigu o poznavanju konkretnog koda i predstavljanju podataka korisniku u standardnom obliku, ne smije se zahtijevati od korisnika da poznaje kod korištenu u konkretnom uređaju.

Ulazno-izlazni uređaji su značajno sporiji od radne memorije i procesora tako da se mora obezbjediti njihova efikasnost tj. ne smije se dozvoliti da postanu usko grlo računarskog sistema.

Za pojednostavljen rad korisnicima poželjno je omogućiti uniformno rukovanje uređajima.

8.1 Klasificiranje uređajaPrema namjeni uređaji se smještaju u slijedeće opšte kategorije:- uređaji za dugotrajno smiještanje podataka (engl. storage devices),- uređaji za prenos podataka (engl. transmission devices),- uređaji koji obezbjeđuju interfejs ka korisniku (engl. human interface devices).Prema smjeru prenosa uređaje dijelimo na ulazne (npr. miš, skener), izlazne

(npr. printer) i ulazno-izlazne (mrežna kartica).Prema jediničnoj količini prenesenih podataka uređaji se dijele na blokovske i

znakovne uređaje. Izdvajamo mrežne uređaja kao specijalnu klasu. Ovakva podjela

202 Ulazno-izlazni sistem računara

je uslovljena razlikama između ove dvije vrste ulaznih i izlaznih uređaja u pogledu: jedinice pristupa, načina pristupa i upravljanja.

Tako je za blokovske uređaje jednica pristupa blok, a za znakovne uređaje jedinica pristupa je znak. Dalje, dok značajan broj blokovskih uređaja dozvoljava direktan pristup, znakovni uređaji podržavaju samo sekvencijalni pristup. Na kraju, za razliku od blokovskih uređaja, znakovni uređaji dozvoljavaju dinamičko podešavanje njihovih pojedinih funkcionalnih karakteristika, kao što je, na primjer, brzina prenosa znakova od računara i ka računaru. Prethodne razlike utiču na oblikovanje drajvera, zaduženih za upravljanje kontrolerima.

Važno je uočiti da klasifikacija uređaja na znakovne i blokovske ne obuhvata sve uređaje. Na primjer, sat ili miš ne spadaju ni u znakovne ni u blokovske uređaje. Zato se drajveri ovakvih uređaja razlikuju od drajvera znakovnih i blokovskih uređaja.

Prema metodi pristupa uređaji se dijele na uređaje sa sekvencijalnim pristupom i uređaje sa direktnim ili slučajnim pristupom. Sekvencijalni uređaji prenose podatke fiksnim redosljedom koje određuje sam uređaj dok kod uređaja sa direktnim pristupom redosljed određuje aplikacija.

Prema djeljivosti uređaji mogu biti djeljivi i nedjeljivi. Djeljive uređaje može koristiti više procesa istovremeno (npr. diskovi). Nedjeljive uređaje u jednom trenutku koristi samo jedan proces (npr. tastatura).

Uređaji se dalje mogu klasificirati prema mogućnosti upisa na one koji služe za čitanje i pisanje, zatim isključivo za čitanje i isključivo za pisanje (npr. grafička kartica).

Grubo gledano, prema brzini prijenosa uređaji se mogu klasifikovati na brze i spore. Ali je ovu podjelu teško izvršiti jer se razlikuju od najsporijeg do najbržeg i milijardama puta.

Sat i tajmer spadaju u specijalnu klasu uređaja. Oni obezbjeđuju tri osnovne funkcije:

Klasificiranje uređaja 203

- prikazivanje tekućeg vremena,- prikazivanje proteklog vremena,– tajmerski okidač za određenu operaciju u određenom trenutku.–

8.2 Hardverska struktura U/I sistemaVidjeli smo da se računarski sistem sastoji iz tri osnovna funkcionalna bloka:CPU, memorije i ulazno/izlaznog sistema (Input/output (I/O)). U/I dio računara se

može rastaviti na dva dijela:- U/I uređaj (periferni uređaj). U/I uređaji imaju dvije komponente: mehaničku

komponenta i elektroničku komponenta. Elektronička komponenta je kontroler uređaja i može upravljati sa više uređaja Zadaci kontrolera na samom uređaju su konverzija serijskog niza bita u blokove bajta, provođenje korekture grešaka, po potrebi i prepisivanje u glavnu memoriju. Svaki kontroler ima jedan ili više registara. Upisom i čitanje vrijednosti ovih registara odvija se komunikacija između procesora i kontrolera. Ako su memorijski i ulazno-izlazni prostor odvojeni, procesor ima posebne instrukcije za pisanje i čitanje podataka sa određene adrese u kontroleru. Ako se ulazno-izlazni prostor može tretirati kao memorija transferi se obavljaju običnim instrukcijama za rad sa memorijom.

- Tipično ulazno-izlazni sistem sadrži četiri vrste registara:- Kontrolni registar – postavljanje režima rada (procesor upisuje),- Statusni registar – opisuje status komande koja se izvršava (procesor čita),- Registar podataka za ulazni režim – za čitanje podataka iz ulaznih uređaja

(procesor čita podatke),- Registar podataka za izlazni režim rada (registar čita iz procesora).- U/I kontroler. Ulazno-izlazni uređaji komuniciraju sa računarskim siatemom

putem sabirnica.Iz više razloga nije moguće jednostavno povezati U/I uređaj na sistemsku sabirnicu. Postoji veliko broj različitih tipova uređaja. svaki sa drugim metodom rada, npr. monitori, diskovi, tastature. Nije praktično za CPU da se bavi radom svakog tipa uređaja posebno što novi uređaj može biti dizajniran nakon što je CPU proizvedena. Brzina prenosa podataka perifernih uređaja je puno sporija u odnosu na brzinu CPU. CPU ne može direktno komunicirati sa takvim uređajima bez usporavanja čitavog sistema. Periferni uređaji često koriste drugu veličinu riječi ili format. Zbog ovoga računarski sistemi moraju koristiti U/I kontrolere, komponente koje su interfejs između CPU i periferijalnih uređaja. Jedan U/I kontoler ima više funkcija:

- kontrolisanje periferija i njegova sinhronizacija sa CPU,- komunikacija sa CPU kroz sistemsku sabirnicu,- komunikacija sa perifernim uređajem kroz U/I interfejs,- funkcija bafera,- detekcija greške.


Jedan U/I modul se sastoji od nekoliko dijelova: konekcija na sistemsku sabirnicu, neka kontrolna logika, bafer za podatke, interfejs prema periferijalu.

Možemo razdvojiti dva glavna područja:- Strategiju po kojoj U/I kontroleri komuniciraju sa CPU.- Interfejs između U/I kontrolera i uređaja konektovanog na njega.

8.3 Memorijski mapirani i izolirani U/IBilo da sistem koristi programirane ili U/I sa prekidima mora periodično slati

instrukcije U/I modulu Dvije metode se koriste za implementaciju: memorijski mapiranih U/I i izolirani U/I.

Sa memorijski mapiranim U/I kontroleri se CPU čini kao obična lokacija u memoriji, Da bi poslao podatke U/I kontroleru CPU piše ili čita podatke iz ove lokaciju u memoriji. Ovo će smanjiti dostupan adresni prostor memorije. Na primjer, na računaru Amiga instrukcijom move.b #252,$BFE001 se postavlja audio filter. Instrukcija move.b se koristi i u normalnom pristupu memoriji

Sa izoliranim U/I čini se da U/I kontroler okupira svoj vlastiti adresni prostor i koriste se specijalne instrukcije za komunikaciju sa njim. Na primjer na PC računarima se izlaz na zvučnik šalje instrukcijom out 42h,al. Ovo daje više adresnog prostora za oboje memoriju U/I ali će povećati ukupni broj instrukcija. Takođe može smanjiti fleksibilnost sa kojim CPU adresira U/I kontrolere.

(a) Odvojen U/I i memorijski prostor(b) Memorijski-mapirani U/I (c) HibridSvaki kontroler posjeduje registar koji je tu za komunikaciju sa procesorom. Kroz

pisanje u taj registar operativni sistem može davati uređaju instrukcije, kao npr. čitanje i pisanje podataka, da se isključi ili uključi itd. Pored ragistra većina uređaja posjeduje bafer za podatke koji operativni sistem može čitati i pisati.

Postavlja se pitanje kako procesor komunicira sa sa baferom podataka i registrom kontrolera. Postoje dvije alternative. Kod prve svakom registru kontrolera se dodjeljuje U/I broj porta, Pomoću specijalne U/I instrukcije procesor može pisati u kontrolor-registar ili čitati iz njega.

U ovom konceptu su memorijski adresni i U/I adresni prostor odvojeni sl. (a).Drugi način je da se kontrolor-registru dodjeli prazan dio memorijsko adresnog

prostora. Ovaj pristup je prikazan na sl. (b) i zove se memorijski mapiran U/I. Slika (c) prikazuje hibridnu šemu.

Memorijski mapirani i izolirani U/I 205

Slijedeća slika prikazuje dvije arhitekture: single-bus arhitekturu i dual bus arhitekturu. Kod prve arhitekture sve adrese idu preko jedine sabirnice. Međutim trend kod personalnih računara je arhitektura prikazana na sl. (b) gdje posjedujemo brzu sabirnicu za pristup CPU-a memoriji. Ovu osobinu posjeduju i mainframe računari. Ova sabirnica je optimizirana na brzinu memorije i nisu pravljeni nikakvi kompromisi za ulazno-izlazne uređaje. Problem kod ovakve arhitekture je da U/I uređaji ne vide adrese na memorijskoj sabirnici i ne mogu na njih reagovati.

8.4 Interfejs između U/I kontrolera i uređaja konektovanog na njega

Interfejs upravlja sinhronizacijom i kontrolom periferijala. Ovaj proces sinhronizacije poznat je pod nazivom handshaking. Interni bafer U/I kontrolera omogućava kompenzaciju razlika u brzini kojom interfejs može komunicirati sa periferijalom i brzini sistemske sabirnice. U/I interfejsi mogu biti podjeljeni u dva tipa.

Paralelni interfejsiU/I kontroler je višežično povezan sa periferijalom, a biti podataka se prenose

simultano. Ovakvi tipovi interfejsa se koriste za periferijale velikih brzina kao što su diskovi.

Serijski interfejsiU/I kontroler je jednožično povezan na periferijal a podaci se prenose bit po bit.

Ovo se koristi za sporije periferijale kao što je tastatura.

8.5 Programirani U/INajjednostavnija metoda za upravljanje komunikacijom između CPU I U/I

modula su programirani U/I. Korištenjem ove strategije CPU je odgovorna za svu komunikaciju sa U/I modulom pomoću postojećih instrukcija koje kontrolišu povezani uređaj ili prenos podataka. Na primjer ako je CPU željela poslati podatke uređaju korištenjem programiranog U/I prvo šalje instrukciju odgovarajućem U/I da očekuje podatke. CPU onda mora čekati dok kontroler ne odgovori prije slanja


podataka. Ako je modul sporiji od CPU onda CPU mora čekati dok se transfer ne završi. Ovo može biti veoma neefikasno.

Postoji i drugi problem ako CPU mora čitati iz uređaja kao što je tastatura. S vremena na vrijeme CPU mora dati instrukciju odgovarajućem U/I kontroleru da vidi da li je neka tipka pritisnuta. Ovo je takođe ekstremno neefikasno. S obzirom na to ova strategija se koristi samo u veoma malim mikroprocesorskim uređajima.

Ovakav način pristupa periferijskom uređaju će se ilustrovati sljedećim primjerom. Neka je potrebno implementirati sistemski poziv koji šalje podatke iz korisničkog prostora na štampač. Operativni sistem bi kopirao podatke iz korisničkog prostora u bafer, i gledajući znak po znak provjeravao da li je printer spreman i slao mu znakove

copy_from_user(buffer, p, count); /* p is the kernel buffer */for (i = 0; i < count; i++) { /* loop on every character */ while (*printer_status_reg != READY) ; /* loop until ready */ *printer_data_register = p[i]; /* output one character */}return_to_user();

U slučaju sporih uređaja, procesor ostaje zauzet čekanjem u krajnje dugačkim petljama, iako bi mogao raditi pametnije stvari. Nedostatak ove tehnike se može otkloniti uvođenjem hardverskog mehanizma koji omogućava uređaju da označi procesoru kad je komanda izvršena. Ovaj mehanizam se naziva prekid (engl. Interrupt).

8.6 U/I vođeni prekidimaOva strategija dozvoljava CPU da nastavi sa operacijama dok modul nije spreman

da prenese podatke. Kada CPU želi da komunicira sa uređajem daje instrukciju odgovarajućem U/I kontroleru i nastavlja sa drugim operacijama. Kada je uređaj spreman on će prekinuti CPU. CPU može nastaviti prenos podataka kao i u prethodnom slučaju.

Ovo otklanja potrebu da CPU kontinualno provjerava ulazne uređaje da vidi ima li spremnih podataka. Kada ulazni uređaj ima podatke odgovarajući U/I modul može prekinuti CPU da zahtjeva prenos podataka.

U/I kontroler šalje signal prekida procesoru preko prekidne linije (engl. interrupt request line, IRQ). Procesor će završiti tekuću instrukciju, poslije čega se prekida sekvencijalno izvršavanje programa, kako bi se obradio prekid. Poslije obrade prekida CPU nastavlja sa izvršavanjem programa.

Sekvenca događaja je kako slijedi:- U/I kontrolor prekida CPU.

U/I vođeni prekidima 207

- CPU završava izvršenje tekuće instrukcije.- CPU potvrđuje prekid.- CPU spašava svoje trenutno stanje- CPU preskoči na sekvencu instrukcija koje se bave prekidom.Situacija je malo komplikovana s obzirom da većina računarskih sistema ima više

perifernih uređaja povezanih na njega. Ovo znači da računar mora biti u mogućnosti da detektuje koji prekid dolazi od kog uređaja i može nastati problem ako se više prekida desi istovremeno. Odluka se donosi na bazi prioriteta prekida. Neki uređaji će zahtijevati odgovor CPU mnogo brže nego drugi, na primjer prekid diska se mora obraditi brže nego prekid tastature.

Mnogi sistemi koriste višestruke prekidne linije. To dozvoljava brzo dodjeljivanje prioriteta, jer svaka linija prekida može imati drugi prioritet. Međutim vjerovatno ćemo imati više uređaja nego lnija prekida tako da se mora koristiti neka druga metoda da se otkrije odakle dolazi koji prekid.

Većina sistema koristi interapt vektor. Kada CPU potvrdi prekid relevantni uređaj postavlja podatke na sabirnicu (vektor). Vektor identifikuje uređaj koji zahtjeva pažnju i koristi se od strane CPU da se potraži adresa odgovarajuće rutine za obradu tog prekida.

Prekidni sistem obično funkcioniše na slijedeći način. Za svaki od uređaja koji mogu postaviti prekidni signal postoji posebna prekidna rutina, koja se nalazi u memoriji. Informacije o adresama svih prekidnih rutina čuvaju se u tabeli prekidnih vektora (engl. interrupt vectro table), gdje svaki ulaz sadrži adresu jedne prekidne rutine. Na ovaj način se smanjuje trajanje određivanja uređaja koji je postavio prekidni signal. Tačno se zna koja je klasa uređaja vezana za koju liniju PIC (engl. priority interrupt controlller) – prioritetni prekidni kontroler. PIC okida procesor i daje mu informaciju u vidu vektora, tj. pokazivača na ulaz u tabelu prekidnih vektora. Na ovaj način izbjegava se prozivanje uređaja a sve informacije obezbjeđuje PIC.

Primjer sa sistemskim pozivom za štampanje niza znakova bi sada izgledao ovako. Program pozivalac bi se blokirao dok se niz ne završi, a svaki put kada je štampač spreman za novi znak, generisao bi se interapt. U rutini za obradu interapta bi se poslao novi znak, a kada je poslan i posljednji, deblokira se korisnički proces. U sistemskom pozivu bi se nalazile naredbe slične ovimcopy_from_user(buffer, p, count);enable_interrupts();i=0;while(*printer_status_reg != READY) ;*printer_data_register = p[i];scheduler();

U interapt rutini bi bio sljedeći kod.


if(count == 0) { unblock_user();} else { *printer_data_register = p[i]; count = count – 1; i = i + 1;}acknowledge_interrupt();return_from_interrupt()

Prekidni sistem primjenjuje prekidne nivoe. Kad naiđe prekid višeg prioriteta, prekida se opsluživanje prekida nižeg prioriteta.

8.7 DMA (Direct Memory Access)Iako su U/I vođeni prekidom efikasniji od programiranih U/I, podaci si u oba

slučaja prenose preko CPU. Ovo će biti neefikasno kod prenosa velike količine podataka između periferijala i memorije. Prenos će biti sporiji nego što je nužno a CPU će biti zauzeta i neće biti u mogućnosti da obavlja bilo koju drugu akciju dok se izvršava ovaj prenos. Mnogo sistema zbog toga koristi dodatnu strategiju poznatu kao direktan pristup memoriji (engl. direct memory access DMA). DMA koristi dodatni hardver – DMA kontroler. DMA kontroler može preuzeti sistemsku sabirnicu i prenijeti podatke između U/I kontrolera i memorije bez mješanja CPU. Kad CPU želi prenijeti podatke kaže DMA kontroleru smjer prenosa, U/I kontroler koji je uključen, lokaciju podataka u memoriji i veličinu bloka podataka koji se treba prenijeti. Nakon toga može nastaviti rad sa drugim instrukcijama a DMA će je prekinuti kada se prenos završi.

CPU i DMA kontroler ne mogu koristiti sistemsku sabirnicu u isto vrijeme tako da mora postojati način dijeljenja sabirnice između njih Koristi se jedan od slijedeća dva metoda:

-Burst mode: DMA kontroler prenosi blokove podataka zaustavljanjem CPU za vrijeme transfera. Brzina transfera zavisi od slijedećeg lanca: U/I modul/sabirnica/memorija. Podaci ne prolaze kroz CPU ali CPU se zaustavlja kod prenosa podataka.

-Krađa ciklusa - cycle stealing: DMA kontroler prenosi podatke rječ po riječ, korištenjem sabirnice kada je CPU ne koristi. Ovo može malo usporiti CPU ali je prilično efikasno

Jednostavan prenos podataka na relaciji disk – memorija preko DMA kontrolera se može objasniti kroz šest koraka:

DMA (Direct Memory Access) 209

(1) Proces nalaže drajveru da prenese podatke sa diska u bafer koji se nalazi na memorijskoj adresi X.

(2) Drajver nalaže kontroleru diska da prenese C bajtova sa diska u bafer na memorijskoj adresi X.

(3) Kontroler diska inicira DMA transfer.(4) Kontroler diska redom šalje bajtove podataka DMA kontroleru.(5) DMA kontroler prenosi podatke u bafer, uvećavajući memorijsku adresu

X i smanjujući broj bajtova C nakon svakog prenesenog bajta.Kad je prenesen posljednji bajt (C=0), DMA šalje signal prekida procesoru obavještavajući ga o završenom transferu

Protokol usaglašavanja između DMA i U/I kontrolera odvija se preko par linija, signalima DMA-request i DMA-acknowledge. Proces mora adresirati kontroler uređaja da bi sa njim razmjenio podatke. Operativni sistem može koristiti direktni pristup memoriji (DMA) kada hardver ima DMA kontroler na raspolaganju. Nekad je ovaj kontroler integrisan u kontroler diska ili u upravljačku jednincu drugog uređaja, ali ovaj dizajn zahtjeva jedan DMA kontroler po uređaju. Nezavisno gdje je fizički smješten, DMA kontroler ima uvijek nezavisno do CPU pristup sistemskoj sabirnici kao što je prikazano na slici.

Prvo procesor programira registre DMA kontrolera, da bi on zna šta gdje treba transportovati (korak 1 na slici). Uz to se daje komanda kontroleru diska, da pročita podatke u svoju internu memoriju i izvrši provjeru greške. Čim ispravni podaci leže u memoriji kontrolora diska, može početi prenos sa DMA. DMA upravlja


prenosom podataka sa jednom instrukcijom za čitanje, preko sabirnice do kontrolora diska (korak 2). Pisanje u memoriju je jedan standardni ciklus sabirnice (korak3). Čim je pisanje završeno, kontroler diska šalje signal DMA kontroleru (korak 4). DMA kontroler, povećava adresu memorije i smanjuje broj znakova koji se još moraju prenijeti. Sve dok je brojač veći od 0, koraci 2 do 4 se ponavljaju. Kada je brojač 0, DMA kontroler stvara prekid i javlja CPU da je prenos završen.

Primjer sistemskog poziva za slanje na štampač, ako se koristi DMA izgleda jednostavnije. DMA radi kao programirani U/I, ali posao prozivanja uređaja obavlja ona sama. Interapt se dešava samo na kraju prijenosa. U sistemskom pozivu se piše nešto poputcopy_from_user(buffer, p, count);set_up_DMA_controller();scheduler();

a u interapt rutiniacknowledge_interrupt();unblock_user();return_from_interrupt();

DMA je obično sporija od procesora. Da li će najbrži pristup biti koristeći programirani ulaz/izlaz, interapt vođeni ili DMA zavisi od slučaja. DMA bi bila u prednosti ako bi interapt pristup generisao veliki broj prekida.

8.8 Ciljevi i funkcije U/I softveraJedan od ciljeva koje treba postići pri projektovanju operativnog sistema je

formiranje uniformnog interfejsa ka aplikacijama i korisniku. Problem uniformnosti se rješava metodama apstrakcije i višeslojnosti softvera u okviru ulazno-izlaznog sistema.

Dio jezgra zadužen za rad sa ulazno-izlaznim uređajima koordinira širok spektar usluga:

- Upravljanje imenima datoteka i uređaja (engl. name space)- Kontrola pristupa datotekama i uređajima,- Kontrola operacija- Dodjela uređaja procesima na korištenje,- Raspoređivanje ulazno-izlaznih operacija,- Baferovanje, keširanje i spuler,- Kontrola statusa uređaja,– Konfiguracija i inicijalizacija drajvera.

8.9 Struktura softvera U/I sistemaSrodni uređaji grupišu se u opšte klase uređaja. Svakoj klasi uređaja pristupa se

preko standardnog skupa funkcija. Razlike koje postoje među uređajima iste klase sakrivene su u specijalnim modulima jezgra operativnog sistema koji se nazivaju upravljački programi ili drajveri (engl. device drivers). Drajveri postoje za

Struktura softvera U/I sistema 211

svaki uređaj, ali se korisniku predstavljaju kao jedan univerzalni interfejs. Iznad svih drajvera nalazi se sloj ulazno-izlaznog sistema jezgra koji je praktično nezavisan od hardvera. Ova slojevita organizacija olakšava posao projektantima operativnog sistema a i projektantima uređaja i kontrolera.

8.10 Obrađivači interaptaKada se desi interapt, operativni sistem obično obavi sljedeće aktivnosti.1. Snimi registre koje hardver već nije snimio2. Postavi kontekst za interapt servisnu proceduru3. Postavi stek za interapt servisnu proceduru4. Potvrdi interapt kontroler, ako nema centralizovanog interapt kontrolera,

ponovo uključi interapte5. Kopiraj registre s mjestra gdje su snimljeni u tabelu procesa6. Izvrši interapt servisnu proceduru7. Odaberi sljedeći proces sa izvršavanje8. Postavi MMU kontekst za sljedeći proces za izvršenje9. Učitaj registre novog procesa10.Pokreni novi proces

8.11 DrajveriZajedničko svojstvo drajvera je da je svaki od njih namjenjen za upravljanje

određenom klasom uređaja. Pri tome, obično, jedan drajver može da opsluži više primjeraka uređaja iste klase. Drajveri se nalaze u tijesnoj saradnji sa kontrolerima ulaznih i izlaznih uređaja i kriju sve detalje i posebnosti funkcionisanja ovih kontrolera. Van drajvera su vidljive samo operacije, kao što su, na primjer, operacije ulaza ili izlaza, koje omogućuju jednoobrazno korištenje ulaznih i izlaznih uređaja.

Korisnički proces

U/I sistem u korisničkom prostoru

Softver nezavisan od uređaja

Drajveri uređaja

Obrađivači interapta

Hardver


Tipične operacije drajvera blokovskih uređaja su:1. operacija inicijalizacije (koja se poziva samo u toku pokretanja operativnog

sistema) i2. operacije ulaza i izlaza blokova (koje koristi sloj za upravljanje datotekama).Tipične operacije drajvera znakovnih uređaja su:1. operacija inicijalizacije (koja se poziva samo u toku pokretanja operativnog

sistema),2. operacije ulaza i izlaza znakova (koje koristi sloj za upravljanje datotekama),

kao i3. upravljačka operacija (koja omogućuje dinamičko podešavanje funkcionalnih

karakteristika znakovnih uređaja, na primjer, njihove brzine prenosa znakova).Tabela drajvera nudi standardan način za povezivanje sloja za upravljanje

datotekama i sloja za upravljanje ulaznim i izlaznim uređajima, radi vezivanja operacija običnih i specijalnih datoteka za operacije drajvera ulaznih i izlaznih uređaja. Zahvaljujući ovoj tabeli, moguće je u operativni sistem dodavati (statički i dinamički) nove drajvere.

Kako drajveri izgledaju jako zavisi od operativnog sistema. Ovdje je dat primjer jednog drajvera za FreeBSD

Drajveri 213

/* * Simple Echo pseudo-device KLD * * Murray Stokely * Søren (Xride) Straarup * Eitan Adler */

#include <sys/types.h>#include <sys/module.h>#include <sys/systm.h> /* uprintf */#include <sys/param.h> /* defines used in kernel.h */#include <sys/kernel.h> /* types used in module initialization */#include <sys/conf.h> /* cdevsw struct */#include <sys/uio.h> /* uio struct */#include <sys/malloc.h>

#define BUFFERSIZE 255

/* Function prototypes */static d_open_t echo_open;static d_close_t echo_close;static d_read_t echo_read;static d_write_t echo_write;

/* Character device entry points */static struct cdevsw echo_cdevsw = { .d_version = D_VERSION, .d_open = echo_open, .d_close = echo_close, .d_read = echo_read, .d_write = echo_write, .d_name = "echo",};


struct s_echo { char msg[BUFFERSIZE + 1]; int len;};

/* vars */static struct cdev *echo_dev;static struct s_echo *echomsg;

MALLOC_DECLARE(M_ECHOBUF);MALLOC_DEFINE(M_ECHOBUF, "echobuffer", "buffer for echo module");

/* * This function is called by the kld[un]load(2) system calls to * determine what actions to take when a module is loaded or unloaded. */

Drajveri 215

static intecho_loader(struct module *m __unused, int what, void *arg __unused){ int error = 0;

switch (what) { case MOD_LOAD: /* kldload */ error = make_dev_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK, &echo_dev, &echo_cdevsw, 0, UID_ROOT,GID_WHEEL, 0600, "echo"); if (error != 0) break;

echomsg = malloc(sizeof(*echomsg), M_ECHOBUF, M_WAITOK | M_ZERO); printf("Echo device loaded.\n"); break; case MOD_UNLOAD: destroy_dev(echo_dev); free(echomsg, M_ECHOBUF); printf("Echo device unloaded.\n"); break; default: error = EOPNOTSUPP; break; } return (error);}

static intecho_open(struct cdev *dev __unused, int oflags __unused, int devtype __unused, struct thread *td __unused){ int error = 0;

uprintf("Opened device \"echo\" successfully.\n"); return (error);


}

static intecho_close(struct cdev *dev __unused, int fflag __unused, int devtype __unused, struct thread *td __unused){

uprintf("Closing device \"echo\".\n"); return (0);}

/* * The read function just takes the buf that was saved via * echo_write() and returns it to userland for accessing. * uio(9) */static intecho_read(struct cdev *dev __unused, struct uio *uio, int ioflag __unused){ size_t amt; int error;

/* * How big is this read operation? Either as big as the user wants, * or as big as the remaining data. Note that the 'len' does not * include the trailing null character. */ amt = MIN(uio->uio_resid, uio->uio_offset >= echomsg->len + 1 ? 0 : echomsg->len + 1 - uio->uio_offset);

if ((error = uiomove(echomsg->msg, amt, uio)) != 0) uprintf("uiomove failed!\n");

return (error);}

/* * echo_write takes in a character string and saves it * to buf for later accessing. */static intecho_write(struct cdev *dev __unused, struct uio *uio, int ioflag __unused){

Drajveri 217

size_t amt; int error;

/* * We either write from the beginning or are appending -- do * not allow random access. */ if (uio->uio_offset != 0 && (uio->uio_offset != echomsg->len)) return (EINVAL);

/* This is a new message, reset length */ if (uio->uio_offset == 0) echomsg->len = 0;

/* Copy the string in from user memory to kernel memory */ amt = MIN(uio->uio_resid, (BUFFERSIZE - echomsg->len));

error = uiomove(echomsg->msg + uio->uio_offset, amt, uio);

/* Now we need to null terminate and record the length */ echomsg->len = uio->uio_offset; echomsg->msg[echomsg->len] = 0;

if (error != 0) uprintf("Write failed: bad address!\n"); return (error);}

DEV_MODULE(echo, echo_loader, NULL);

U sklopu opsluživanja kontrolera, drajveri moraju da reaguju i na prekide, koji stižu od kontrolera. Prekidi, na primjer, objavljuju da je završen prenos podataka ka kontroleru, ili od kontrolera. U ovakvom slučaju, obrada prekida obuhvata ili preuzimanje podatka, pristiglih od kontrolera, ili pripremu prenosa novih podataka ka kontroleru. Za ovakve obrade su zaduženi obrađivači prekida drajvera. Za razliku od operacija drajvera, koje se pozivaju iz slojeva iznad sloja za upravljanje ulaznim i izlaznim uređajima (pa zato predstavljaju gornji dio drajvera), obrađivače prekida poziva mehanizam prekida, znači hardver ispod operativnog sistema (pa zato oni predstavljaju donji dio drajvera).

8.12 Funkcije dijela U/I softvera nezavisnog od uređajaTipični zadaci koje obavlja sloj U/I softver nezavisan od uređaja su1. Uniformni interfejs za drajvere uređaja2. Baferovanje3. Prijava greške


4. Zauzimanje i oslobađanje dodjeljenog uređaja5. Obezbjediti veličinu bloka nezavisnu od uređaja

8.13 Usluge koje obezbjeđuje ulazno-izlazni sistemJezgor operativnog sistema obezbjeđuje više usluga koje se odnose na ulazno-

izlazne operacije:- Raspoređivanje ulazno-izlaznih operacija- Baferovanje- Keširanje- Spuler- Upravljanje greškama- Prevođenje zahtjeva u ulazno-izlazne operacije

8.14 Raspoređivanje ulazno-izlaznih operacijaRaspoređivanje ulazno-izlaznih operacija (engl. I/O scheduling) podrazumjeva

obezbjeđivanje dobrog poretka izvršavanja ulazno-izlaznih operacija. Raspoređivanje operacija se zasniva na redu čekanja koji se definiše za svaki uređaj ponaosob, a na osnovu nekog kriterijuma.

8.15 BaferovanjeBaferovanje je dio memorije a funkcioniše na principu proizvođač-potrošač i

služi za čuvanje privremenih podataka prilikom prenosa podataka između dva uređaja ili između uređaja i aplikacije Razlozi za baferovanje (engl. buffering) su slijedeći:

- usklađivanje različitih brzina između potrošača i proizvođača,- prilagođavanje različitih veličina transfera podataka,- sprečavanje izmjene podataka tokom slanja. Za objašnjenje zašto se koristi

baferovanje posmatrajmo jedan proces koji želi čitati podatke iz modema.(a) Prva mogućnost je da korisnički proces izvodi sistemski poziv read onda

blokira i čeka dok dođe sljedeći znak. Rutina prekida daje znak dalje korisničkom programu i budi ga. Ovaj znak se obrađuje i čita se novi.

(b) Korisnički proces stavlja na raspolaganje bafer. Rutina piše znakove u bafer dok se on ne napuni.

(c) Efikasniji pristup je stavljanje bafera u kernel. Kad je on pun slijedi kopiranje u korisnički prostor.

(d) Šta se dešava sa znakovima koji upravo u tom trenutku dolaze? Rješenje je drugi kernel bafer.

Baferovanje 219

Jednostruki bafer:- Blok orjentisan: korisnički proces može obraditi blok podataka dok se sljedeći

blok učitava a opeartivni sistem prati dodjelu sistemskog bafera korisničkim procesimaNiz orjentisan: korisnički ulaz sa terminala je jedna linija u vremenu sa signalizacijom na kraju linije.Dvostruki bafer koristi dva sistemska bafera umjesto jedan. Proces može prenijeti podatke u ili iz jednog bafera dok operativni sistem prazni ili puni drugi bafer.Kod cirkularnog bafera se koristi više od dva bafera. Svaki samostalni bafer je jedna jedinica u cirkularnom baferu. Koristi se kada U/I mora stizati proces.

8.16 KeširanjeKeš (engl. cache) predstavlja oblast brze sistemske memorije koja čuva

kopiju podataka, najčešće sa diska. Pristup podacima u kešu znatno je brži od pristupa podacima na ulazno izlaznim uređajima. Keširanje je tehnika kopiranje dijelova u keš memoriju čime se značajno poboljšavaju performanse U/I sistema. Bafer sadrži trenutno aktuelne podatke a keš čuva bilo koju kopiju sa diska.

8.17 U/I sistem u korisničkom prostoruI u korisničkom prostoru se obavlja dio U/I operacija. Najvažnije su sistemske

biblioteke za U/I, koje omogućavaju korisničkom procesu da pošalje zahtjeve periferijskom uređaju, poput rutina za pisanje datoteke ili grafički korisnički interfejs.


Druga kategorija su pozadinski procesi kao što je onaj koji održava spuler za štampač. Spuler je bafer koji privremeno čuva podatke namjenjene nekom nedjeljivom uređaju. On omogućava istovremeni pristup nedjeljivim uređajima tako što proces upisuje podatke namjenjene uređaju na disk, a operativni sistem upravlja spulerom tako što opslužuje jedan po jedan zahtjev. Korištenjem spulera proces može brzo postaviti zahtjev u bafer a nakon toga nastaviti sa drugim aktivnostima. Ovo omogućava da se nedjeljivi uređaji koriste kao prividno djeljivi.

8.18 Windows API za pristup periferijskim uređajima• DeviceIoControl( DeviceIoControl(hDevice,dwIoControlCode,lpInBuffer,nInB

ufferSize,lpOutBuffer,nOutBufferSize,lpBytesReturned,lpOverlapped) Šalje kontrolni kod direktno drajveru periferijskog uređaja

• CreateFile(lpFileName,dwDesiredAccess,dwShareMode,lpSecurityAttributes,dwCreationDisposition,dwFlagsAndAttributes,hTemplateFile) Otvara U/I uređaj ili datoteku

• WriteFile(hFile,lpBuffer,nNumberOfBytesToWrite,lpNumberOfBytesWritten,lpOverlapped) Piše podatke na U/I uređaj ili datoteku

• ReadFile(hFile,lpBuffer,nNumberOfBytesToRead,lpNumberOfBytesRead,lpOverlapped) Čita podatke s U/I uređaja ili datoteke

• SetCommTimeouts(hFile,lpCommTimeouts) Postavlja vremena isteka komunikacije

8.19 Posix API za pristup periferijskim uređajima• open(lPathname,iFlags, iMode) Otvara periferijski uređaj• read(iFd, pBuf, iCount)• write(iFd, pBuf, iCount) Čita ili piše na periferijski uređaj• ioctl(iFd,iRequest pBuf) Šalje kod drajveru uređaja

8.20 Drajver sataU nadležnosti sloja za upravljanje kontrolerima se nalazi i praćenje proticanja

vremena. Praćenje proticanja vremena se zasniva na brojanju periodičnih prekida (clock), koje u pravilnim vremenskim intervalima generiše sat (kristalni oscilator sa pravilnom frekvencijom i brojačem, koji se umanjuje u svakoj oscilaciji, a čije anuliranje izaziva prekid).

Drajver sata 221

Obrađivač prekida sata broji prekide sata, a njihov zbir predstavlja sistemsko vrijeme (lokalno vrijeme u računaru). Ovaj obrađivač prekida predstavlja donji dio drajvera sata. Gornji dio ovog drajvera predstavljaju sistemske operacije za preuzimanje ili izmjenu sistemskog vremena i za uspavljivanje procesa (odnosno, za odlaganje njegove aktivnosti, dok ne istekne zadani vremenski interval). Sistemsko vrijeme se može predstaviti kao broj prekida sata ili kao broj sekundi i broj prekida sata u tekućoj sekundi (druga predstava zahtjeva manje prostora). Sistemsko vrijeme može da se računa u odnosu na neki nepromenljivi trenutak u prošlosti, ili u odnosu na trenutak poslednjeg pokretanja operativnog sistema.

Procesorsko vrijeme troši i obrađivač prekida sata, jer se u njegovoj nadležnosti nalazi više poslova, kao sto su:

(1) održavanje sistemskog vremena,(2) praćenje isticanja kvantuma aktivnog procesa,(3) praćenje ukupnog korištenja procesorskog vremena aktivnog procesa,(4) provjera da li je nastupilo vrijeme buđenja uspavanog procesa (čija aktivnost

se nastavlja tek kada istekne zadani vremenski interval), ili(5) skupljanje statistika o aktivnosti procesa (koje se svodi na registrovanje

sadržaja programskog brojača, radi otkrivanja učestanosti izvršavanja pojedinih dijelova programa).

Pored sistemskog sata, mnogi sistemi imaju još jedan koga postavljaju aplikativni programi. Primjeri takvih tajmera su spominjani u poglavlju o signalima. Ako je frekvencija interapta koju program postavi prevelika, dodatna potrošnja usljed obrade interapta zahtijeva više posla od programiranog U/I. Jedno od rješenja ovog problema su meki tajmeri. Kod ovih tajmera, ne okida se interapt i skok u jezgro u tačnim intervalima. Umjesto toga, kad je sistem već u jezgru zbog nekog drugog razloga (greške stranice, sistemski pozivi, drugi U/I događaji), prije povratka u korisnički režim rada provjeri se je li meki tajmer istekao i tada pokreće događaj.

8.21 Upravljanje napajanjemAutonomni računari kao što su laptopi i tableti treba da brinu o potrošnji energije, s

obzirom na ograničeni kapacitet baterija. Neki načini uštede energije su:Gašenje ekrana, kada nije bilo aktivnosti za određen broj minuta. Zaustavljanje motora hard diskova nakon perioda neaktivnostiSoftversko prebacivanje procesora u režim spavanje, smanjujući potrošnju energije

skoro na nulu.Potvrđivanje memorijskog keša, a zatim isključiti . Podaci se uvijek mogu

prebaciti iz glavne memorije bez gubitka informacija Drastičnija opcija je upisati sadržaj glavne memorije na disk , a zatim isključiti

samu glavne memorije . Ovaj pristup se zove hibernacija. Kada je memorija isključena , CPU ili se mora isključiti ili izvršavati program iz ROM-a. Ako je procesor isključen , prekid da probudi mora dovesti ga skočiti na kod u ROM , tako da se memorija može učitati prije nego što se koristi.


Ako je radio prijemnik je uvijek uključen kako bi osluškivao za dolazne e-pošte , baterija može isprazniti vrlo brzo. S druge strane , ako je radio isključen nakon , recimo, 1 minutu biti u stanju mirovanja, dolazne poruke mogu biti izgubljene, što je jasno nepoželjno . Jedan efikasno rješenje za ovaj problem je da mobilni računar pošalje poruku baznoj stanici kada želi da isključi radio . Od tog vremena , bazna stanice baferuje dolazne poruke na disku . Kad mobilni računar opet uključi radio, zovne baznu stanicu koja mu pošalje akumulirane poruke .

A nešto drugačije, ali ipak pitanje u vezi energije, je upravljanje toplotom. Moderni procesori mogu biti izuzetno vrući zbog svoje velike brzine. Desktop strojevi obično imaju interni ventilator koji puše vruć zrak iz kućišta. Budući da smanjenje potrošnje energije je obično nije problem sa desktop računalima, ventilator je obično uključen cijelo vrijeme. Sa laptopom, situacija je drugačija. Operativni sistem mora da prati temperaturu u kontinuitetu. Kada se približi na maksimalno dozvoljenu temperaturu, operativni sistem ima izbor. Može može uključiti ventilator, što čini buku i troši energiju. Alternativno, može smanjiti potrošnju energije smanjivanjem pozadinskog osvjetljenja ekrana, usporava CPU, i tako dalje.

Prijenosna računala koriste sada smart baterije, koje mogu komunicirati sa operativnim sistemom . Po želji se mogu prijaviti na stvari kao što su maksimalni napon, struje , maksimalna punjenja ,struje punjenja, i još mnogo toga . Većina laptop računala imaju programe koji se mogu izvoditi na upit i prikazati sve ove parametre . Smart bateriji može biti naloženo da promijeni azličite operativne parametre pod kontrolom operativnog sistema .

Windows sistem ima razrađen mehanizam za upravljanje potrošnjom energije zove ACPI ( Advanced Configuration and Power Interface ). Operativni sistem može poslati bilo kompatibilnom drajveru komande tražeći da se prijave sposobnosti svojih uređaja i njihovo trenutno stanje, da traži od uređaja da pređe u režim smanjenja potrošnje ili da prati kada su miš ili tastatura bili neaktivni ili prešli u režim aktivnosti.

Uređaji razumljivi korisniku 223

9 Uređaji razumljivi korisnikuU ovom poglavlju će biti riječi o principima rada uređaja koji direktno

komuniciraju sa korisnikom. Ovim uređajima se upravlja u korisničkom prostoru kao i jezgru. Uz ovu temu je vezana oblast korisničkog interfejsa.

9.1 Ulazni softver: tastaturaTastature na PC računarima su uređaji koji imaju dva jednostavna kontrolera, od

kojih je jedan na matičnoj ploči računara, a drugi na samoj tastaturi. Tastatura se može povezati s interapt pozivom koji se dešava na pritisnute ili otpuštene tastere. Tada se može očitati stanje ulaznog porta tastature i očitati koji je taster pritisnut i sačuvati u ulaznom baferu. Tasteri se označavaju sken kodovima koji zavise od pozicije tastera na tastaturi.

Drajver tastature očitava sken kodove za znakove koji su se sakupili u baferu u međuvremenu. Treba ih konvertovati u razumljive znakove. Na primjer, kada se pritisne taster A, scan kod (30) se stavi u registar. Drajver treba da odredi, na bazi ranijeg pritiska ili otpuštanja tastera da li je to a, A, CTRL-A, ALT-A, ... U tu svrhu se koristi ASCII tabela, prilagođena različitim nacionalnim jezicima koja se može eksterno učitati.

Drajveri za tastaturu mogu da vraćaju samo unesene znakove (nekanonski ili sirovi režim) ili da prate razne kombinacije tastera sa specijalnim značenjem (kanonski ili kuhani režim). Na primjer u kanonskom režimu rada kombinacija CTRL-H briše prethodno uneseni znak.

9.2 Ulazni softver: mišVećina PC- ima miša , ili ponekad trackball , što je samo miš leži na leđima .

Najčešći tip miša ima gumenu loptu koja viri kroz rupu na dnu i rotira kada miš ide preko grube površine. Kako lopta rotira, ona trlja gumene valjke stavljena na ortogonalna vratila . Zahtjev u pravcu lijevo-desno uzrokuje rotiranje vratila na y - osi, kretanje u smjeru naprijed-nazad uzrokuje rotiranje vratila na x - osi . Kad god miš pređe određenu minimalnu udaljenost u oba smjera ili je taster je pritisnut ili pušten , poruka se šalje na računar . Minimalna udaljenost je oko 0,1 mm ( iako se može postaviti u softveru ) . Neki ljudi zovu ove jedinice je Mickey . Miš može imati jedan, dva , ili tri tipke. U novije vrijeme se zbog čestog zaprljanja vratila koriste miševi sa svjetlosnom diodom.

Poruka za računar sadrži tri stavke : Δx , Δy , dugmad . Prva stavka je promjena u x poziciji od posljednje poruke. Zatim dolazi promjena u y položaju u odnosu na prethodnu poruku . Konačno, proslijedi se status tipki. Format poruke ovisi o sistemu i broju tipki miša. Obično je potrebno 3 bajta . Većina miševa javi maksimalno 40 puta / sec , tako da je miša možda premješten za više Mickeys od posljednjeg javljanja. Imajte na umu da miš pokazuje samo promjene u položaju , ne direktno apsolutno poziciju . Ako se miš podigne i spusti lagano bez okretanja loptice poruka nće biti poslana .

224 Uređaji razumljivi korisniku

Neki GUI razlikuju između jednostruke klikove i dvostruki klikova na tipku miša . Ako su dva klika su dovoljno blizu u prostoru ( Mickeys ) i dovoljno blizu u vremenu ( milisekundi ) , dvostruki klik sesignalizira. Maksimum za " dovoljno blizu " je do softvera , koji sa parametrima obično bude korisnika podesiv

9.3 Ekranski hardverPrikazni uređaji mogu se podijeliti u dvije kategorije . Vektorski grafičkih uređaja

može prihvatiti i izvršiti naredbe , kao što su crtanje tačaka, linije , geometrijske figure , i tekst . Nasuprot tome, rasterska grafika uređaji predstavljaju izlazno području kao pravougaoni mrežu tačaka koje nazivamo pikselima , od kojih svaki ima neke nijanse sive vrijednosti ili malo boje.

Raster grafika prikazuje se provodi hardverski uređaj koji se zove grafički adapter . A za grafičku karticu sadrži posebnu memoriju naziva video RAM , koji čini dio adresnog prostora računala i obratili CPU na isti način kao i ostatak memorije. Slika ekrana je ovdje pohranjena u bilo karakter modu ili bitnom modu . U modu karaktera , svaki bajt ( ili 2 bajta ) video RAM-a sadrži jedan znak da se prikaže . U bitmap modu , svaki piksel na ekranu se predstavlja posebno u video RAM . sa 1 bit po pikselu za najjednostavnije crno bijeli zaslon na 24 ili više bita po pikselu za visoku kvalitetu prikaza boja .

Također dio grafičkog adapter aje čip zove video kontroler . Ovaj čip vuče znakova ili bitova iz video RAM-a i generira video signal koji se koristi za pogon monitora . A monitor stvara snop elektrona koji skenira horizontalno preko ekrana , slikanje linije na njemu . Tipično ekran ima 480-1024 linije od vrha do dna , s 640-1200 piksela po liniji . Video kontrolerski signal modulira snop elektrona , utvrđivanje da li će dati piksela bude svijetle ili tamne . Kolor monitori imaju tri barijere , za crvenu , zelenu i plavu , koje su samostalno modulirani . Ravni ekran također koristiti piksele u tri boje , koristeći zakretanje kristala koji polarizuju svjetlost..

Video kontroleri imaju dva režima : režim karaktera ( koristi se za jednostavan tekst ) i bit mod ( za sve ostalo ). Na slici se vidi dio video RAM-a za prikaz u režimu karaktera . Svaki znsk na ekranu na slici zauzima dva bajta u RAM. Prvi bajt po redu predstavlja ASCII kod za znak koji će biti prikazani . Naredni bajt je atribut bajt , koji se koristi za odrediti boju , obrnuti video , trepće , i tako dalje .

Rad u bitmap modu koristi isti princip , osim što svaki piksel na ekranu se individualno kontrolirani i pojedinačno zastupa 1 ili više bitova u video RAM . U najjednostavnijem konfiguracije za jednobojni ekran , svakom ekranu piksela ima odgovarajuće malo u video RAM . Na drugu krajnost , svakom ekranu piksela predstavljena je 24 - bitni broj u video RAM-a, sa 8 bita za Red , Green i Blue intenziteta . Ova reprezentacija RGB se koristi jer je crvena , zelene i plave su primarne aditivne boje , iz kojih se sve druge boje mogu se graditi zbrajanjem različitih intenziteta tih boja .

Ekranski hardver 225

Veličine ekrana razlikuju , najčešće su 640 × 480 ( VGA ) , 800 × 600 ( SVGA ) , 1024 × 768 ( XGA ) , 1280 x 1024 , i 1600 × 1200 . Svi ovi , osim 1280 x 1024 su u omjeru 4:3, što se uklapa u odnos aspekt NTSC televizore i na taj način daje kvadratne piksela . Kao primjer , prikaz 768 x 1024 u boji sa 24 bita po pikselu zahtijeva 2,25 MB RAM-a , samo da drži sliku. Ako je puni je osvježen 75 puta / sec , video RAM mora biti sposoban za isporuku podataka kontinuirano na 169 MB / sec .

Da bi se izbjeglo upravljanje velikom ekranskom slikom , neki sistemi imaju sposobnost za trgovinu rezolucije u boji prema veličine slike . U najjednostavnijem šemi , svaki piksel je predstavljena 8 - bitnim brojem . Umjesto da ukazuje na boju , ova vrijednost je indeks u tablici 256 unosa , svaki drži 24 - bitne ( crvena , zelena , plava ) vrijednosti . Ova tabela , koja se zove paleta boja i često čuva u hardveru , omogućava da ekran sadrži proizvoljnih 256 boja u bilo kojem trenutku. Mijenjanje , recimo , unosa 7 u paleti boja , mijenja boju svih piksela na slici sa 7 kao vrijednost .

Također je moguće koristiti paletu boja sa 16 bita po pikselu . U ovom slučaju paleta boja sadrži 65536 unosa , tako da do 65,536 boja se može koristiti odjednom . Međutim , ušteda u prostoru manja jer svaki piksel sada zahtijeva 2 bajta u video RAM .


9.4 Znakovni terminaliRanije su mnogo korišteni RS-232 terminali za komunikaciju s Mainframe

sistemima, bit po bit, preko serijske linije, između kojih se koristi eventualni telefonski modem. Kompjuter i terminal potpuno odvojeni, ali terminal ima sposobnost prikaza teksta koji mu se pošalje. Pojeftinjenje personalnih računara je učinilo da se i oni mogu koristiti kao terminali. To je najprije išlo takođe preko RS-232 interfejsa, a nakon toga su računari opremljeni mrežnim karticama i protokolima, što je komunikaciju učinilo daleko bržom.

Drajveri tekstualnog ekrana, bilo da su realizovani kroz terminal ili kao lokalni ekran PC računara mogu na izlazu da prepoznaju specijalne kombinacije bajtova koji se interpretiraju drugačije. Primjer takvih kombinacija su ANSI escape sekvence. Njih prihvata terminalski drajver, i imaju posebno ponašanje nakon ESC znaka. To je bajt s ASCII kodom 0x1B. Neke od ovih sekvenci mogu imati parametre.

9.5 Windows konzolne funkcijeIako se rjeđe koriste, Windows podržava nekoliko funkcija za ispis tekstualnih

aplikacija, iz komandne linije.

Windows konzolne funkcije 227

• SetConsoleTitle( lpConsoleTitle); Postavlja naslov konzolnog prozora• WriteConsole(hConsoleOutput,lpBuffer,nNumberOfCharsToWrite,lpNumberO

fCharsWritten, lpReserved); Ispisuje tekst na konzolni ekran• GetConsoleWindow() Dobavlja rukovatelj konzolnog prozora• ReadConsole(hConsoleInput,lpBuffer,nNumberOfCharsToRead,pNumberOfC

harsRead, lpReserved); Unosi tekst sa tastature na konzolnom ekranu• WriteConsoleInput( hConsoleInput,lpBuffer,nLength,lpNumberOfEventsWritt

en); Šalje podatke na ulaz konzole

9.6 WINDOWS GDIZa iscrtavanje likova pod Windows u grafici visoke rezolucije na ekranu koristi se

više API grupacija, od kojih se najčešće koriste GDI funkcije. Ima ih oko 200, pa će ovdje biti spomenuto samo nekoliko njih. Skoro sve one koriste kontekst uređaja kao prvi parametar, koji se obično dobije funkcijom BeginPaint ili GetDC. On se najčešće odnosi na korisničko područje prozora, ali se iste funkcije mogu koristiti i za izlaz na štampač, EMF datoteku vektorske grafike, okvire prozora itd.

HDC = GetDC ( hwnd ) ;TextOut ( HDC , x , y , psText , iLength ) ;ReleaseDC ( hwnd , HDC ) ;U prvoj naredbi se dobija rukovatelj na kontekst uređaja , HDC. Druga koristi

kontekstu uređaja da napiše liniju teksta na ekranu , navodeći ( x , y ) koordinate gdje string počinje , pokazivač na sam string, i njegovu dužinu. Na treći poziv se oslobađa kontekst uređaja. bi se pokazalo da je program kroz crtanje za trenutak. Kada se HDC dobije na ovaj način, program može pisati samo na unutrašnjem području klijenta prozora, ne u traci naslova i drugim dijelovima. Međutim , postoji još jedan način da se dobije kontekst uređaja, GetWindowDC, koji omogućava crtanje na cijelom prozoru. Ostali pozivi ograničavaju clipping regiji i na druge načine . S više poziva da rade gotovo istu stvar je još jedan karakteristika Windows .

Evo još jednog primjera. Da se iscrta pravougaonik na ekranu, poziva seRectangle ( HDC , xleft , ytop , xright , ybottom ) ; Na primjer ,Rectangle ( hdc , 2 , 1 , 6 , 4 ) ;

GDI funkcije su primjeri vektorske grafike. Oni se koristi za postavljanje geometrijskih figura i teksta na ekranu. Zbirka poziva GDI procedura se može sastaviti u datoteku koja može opisati složen crtež. Takva datoteka se zove Windows Metafile , i široko se koristi za prijenos crteža iz jednog Windows programa u drugi. Takve datoteke imaju ekstenziju . WMF.

Fotografije i video zapisi, na primjer , ne koristite vektorsku grafike. Pamti se vrijednost crvene , zelene i plave komponente svakog kvadratića slike i sačuvati kao vrijednost jednog piksela. Takva datoteka se zove bitmapa. Jedan načina za korištenje bitmape je kroz funkciju bitblt . To se zove kako slijedi :


bitblt ( dsthdc , dx , dy , wid , HT , srchdc , SX , sy , rasterop ) ;

U svom najjednostavnijem obliku , ona kopira bitmapu iz pravougaonika u jednom prozoru na pravougaonika u drugom prozoru ( ili istom ) . Prva tri parametra odrede prozor i položaj odredišta. Zatim dolaze širina i visina. Sljedeći dolaze prozor i položaj izvora . Imajte na umu da svaki prozor ima svoj koordinatni sistem , sa ( 0 , 0 ) u gornjem lijevom uglu prozora. Posljednji parametar omogućava efekte pri kopiranju slike, obično logičku funkciju.

BitBlt ( hdc2 , 1 , 2 , 5 , 7 , hdc1 , 2 , 2 , SRCCOPY ) ;

Možemo spomenuti još neke zanimljivije GDI funkcije.• AlphaBlend Prikazuje bitmapu s transparentnim ili polutransparentnim

tačkama • BitBlt Kopira bitmapu s mjesta na mjesto.• CreateBitmap Kreira bitmapu.• GetPixel Vraća boju tačke na datoj koordinati.• LoadBitmap Učitava bitmapu iz izvršnog programa.• SetPixel Postavlja boju tačke.• StretchBlt Kopira bitmapu, uz raširenje ili smanjenje.• CreateHatchBrush Kreira četku s šrafiranim uzorkom i bojom.• CreateSolidBrush Kreira četku s punom bojom.• CreatePen Kreira logičko pero s navedenim stilom, bojom i uzorkom• CreatePalette Kreira logičku paletu.• GetWindowExtEx Vraća dimenzije prozora za kontekst uređaja.• GetDC Vraća oznaku konteksta uređaja za klijentski prostor prozora ili cijelog

ekrana.• ReleaseDC Oslobađa kontekst uređaja.• CopyIcon Kopira ikonu iz drugog programa.

WINDOWS GDI 229

• DrawIcon Iscrtava ikonu.• Chord Iscrtava odsječak elipse.• Ellipse Iscrtava elipsu.• FillRect Puni pravougaonik navedenom četkom.• Pie Iscrtava torta isječak.• Polygon Iscrtava poligon.• Rectangle Iscrtava pravougaonik.• RoundRect Iscrtava zaobljeni pravougaonik.• Arc Iscrtava eliptički luk• LineTo Iscrtava liniju od trenutne pozicije do navedene tačke.• PolyBezier Iscrtava Bezierovu krivu.• Polyline Iscrtava izlomljenu liniju.• CreateFont Kreira logički font.• DrawText Iscrtava tekst u pravougaoniku.• EnumFontFamiliesEx Prolazi kroz sve fontove u sistemu.• ExtTextOut Iscrtava niz znakova.• TextOut Piše niz znakova na lokaciji.• BeginPaint Priprema prozor za crtanje.• InvalidateRect Dodaje pravougaonig u region koji se treba ponovo iscrtati.• SetBkColor Postavlja boju pozadine.• UpdateWindow Ažurira klijentsko područje prozora.• CreatePolyPolygonRgn Kreira region od više poligona.• FillRgn Puni region koristeći navedenu četku.

9.7 Posix terminal apiZa tekstualni ispis i očitavanje tastature se koriste standardne read i write funkcije,

pri čemu je datotečni desktriptor STDIN i STDOUT. One se koriste kod PC ekrana i terminala. Za priključenje znakovnih terminala postoji više funkcija za podešavanje parametara terminala: termios, tcgetattr, tcsetattr, tcsendbreak, tcdrain, tcflush, tcflow, cfmakeraw, cfgetospeed, cfgetispeed, cfsetispeed, cfsetospeed, cfsetspeed

9.8 ŠtampačiDvije osnovne vrste štampača su udarni štampači i bezkontaktni štampači. Udarni printeri su najstarija tehnologija štampe još uvijek u aktivnoj proizvodnji.

Udarni printeri su najfunkcionalniji u specijaliziranim okruženjima gdje lje niska cijena štampe od suštinskog značaja. Tri najčešća oblika su matrični, lepezni i linijski štampači.

Tehnologija iza matričnih štampača je vrlo jednostavna . U radu se pritisne bubanj ( gumirani cilindar ) i povremeno povuče prema naprijed kao ispis napreduje . U elektromagnetskom pogonu glava štampača se kreće preko papira i udara iglicama


vrpcu pisača koja se nalazi između papira i glava štampača. Glava štampača na traci tiska tačkice tinte na papiru koje čine ljudski - čitljive znakove .Dot - matrix printeri razlikuju u rezoluciji štampe i ukupne kvalitete bilo sa 9 ili 24 – iglice na glavi štampača. Budući da glava štampača mora udariti površinu papira sa dovoljno snage za prijenos tinte sa trakom na stranici , on je idealan za okruženja koja moraju proizvesti karbon kopije kroz upotrebu posebnih višedijelnih dokumenata.

Štampači s lepezom su slični pisaćim mašinama. Glava štampača sastoji se od metalnog ili plastičnog točka isječenog po laticama. Svaka latica ima određen broj slova ( velikih i malih slova ), brojeva ili interpunkcijskih znakova na njemu. Kada latica je pogodi vrpcu štampača ovo rezultira ispisom tinte na papir. Ovi printeri su glasni i spori . Oni ne mogu ispisati grafiku , a ne mogu promijeniti fontove osim ako je točak štampača fizički zamijenjen. Pojavom laserskih štampača, ovi printeri se obično ne koriste u modernim računarskim okruženjima .

Linijski printeri imaju mehanizam koji omogućava više znakova da se istovremeno štampa na istoj liniji . Mehanizam može koristiti veliki rotirajući bubanj ili papir u lancu petlje. Kao bubanj ili lanac se rotira preko površini papira , elektromehanički čekići iza papira gurnu papir ( zajedno sa trakom ) na površinu bubnja ili lanca, iscrtavajući lik na površini bubanj ili lanca. Zbog prirode mehanizma ovi štampači su vrlo brzi ali vrlo bučni i lošijeg kvaliteta otiska.

Kod bezkontaktnih štampača, s papirom ne dolaze u dodir metalni dijelovi štampača nego samo boja. Ovakvi štampači su znatno tiši od udarnih i omogućuju bolji kvalitet štampe. Njihovi predstavnici su termalni, inkjet, laserski, sa sublimacijom boje, termalnog voska i čvrste tinte.

Termalni štampači koriste specijalni papir osjetljiv na temperaturu ili električni naboj. Glava štampača na pojedinoj tački papira zagrije to mjesto grijačem ili električnom varnicom, nakon čega papir na tom mjestu blago izgori. Danas se najčešće koriste u registar kasama za štampanje računa.

Inkjet pisač koristi jednu od najpopularnijih štampe tehnologije danas. Relativno niske cijene i višenamjenski ispis čine da su inkjet štampači dobar izbor za male biznise i kućne urede. Inkjet printeri koriste boje na bazi vode koje se brzo suše i glavu štampača s nizom malih mlaznica koja rasprskava tintu na površini papira. Inkjet štampači su prvobitno proizveden za crno-bijeli ispis. Međutim, glava štampača od tada je proširena i mlaznice povećane za smještaj cijan, magenta, žuta i crna. Ova kombinacija boja (naziva CMYK) omogućava ispis slika gotovo iste kvalitete kao razvoj u foto laboratoriju (kada se koristi papir određene vrste.)

Laserski pisači su poznati po velikim mogućnostima izlaza i niskim troškovima po stranici. Laserski printeri dijele mnogo istih tehnologija kao fotokopir . Valjci povuku list papira iz ladice za papir i kroz valjak , što daje papiru elektrostatički naboj . U isto vrijeme ispisni bubanj ima suprotno naelektrisanje. Površina bubnja se zatim skenira laserom, isprazni površina bubnja i ostave samo one tačke koje odgovaraju željenom tekstu i slikama. Ovaj naboj se zatim koristi da prisili toner da se zadrži na površini bubnja. Papir i bubanj se zatim dovode u kontakt; njihovo različito

Štampači 231

naelektrisanje uzrokuje da se toner tada zadrži za papir. Konačno, papir putuje između valjaka , koji griju papir i tope toner , spajajući ga na površini papira .

Laserski štampač u boji temelji se na tradicionalnom laserskom monohromatskom štampanju, ali koristi dodatne komponente za stvaranje slike u boji i dokumenata . Umjesto korištenja samo crnog tonera, laserski printeri u boji koriste CMYK toner kombinaciju. Bubanj za ispis ili rotira svake boje i postavlja toner sjednu po jednu boju, ili leži sve četiri boje, a zatim prolazi papir kroz bubanj , prenošenjem kompletne slike na papir . Kolor laserski printeri i dodaju grijač ulja za dodatno vezanje boje na papir što može dati različite stepene sjaja na gotovoj slici.

Za postizanje visokog kvaliteta u boji rjeđe se koriste još neke tehnologije. Štampači termalnog voska imaju pojas za pogon CMYK trake veličine lista papira i specijalno - premazani papir ili folije. Glava štampača sadrži grijne elemente kojim se topi vosak boja na papir , dok on ide kroz štampač. Štampači s sublimacijom boje su slični štampačima termalnog voska, osim što koriste film boje difuzne plastike umjesto obojenog voska . Glava štampača zagrijava film u boji i isparava sliku na posebno premazani papir. Printeri čvrste boje su cijenjeni zbog svoje sposobnosti za ispis na raznim vrstama papira, što se koristi za izradu prototipova ambalaža. Ovi printeri koriste tvrdu tintu koja se istopi i prska kroz male mlaznice na glavama štampača . Papir se zatim šalje prema valjku grijaču što dodatno tjera tintu na papir .

Prije pojave laserske i inkjet tehnologije, udarni printeri su mogli samo ispisati standardni tekst bez razlike u veličini slova ili stilu fonta. Danas, pisači su u mogućnosti da obrađuju složene dokumente sa ugrađenim slikama, grafikonima i formulama na nekoliko jezika, sve na jednoj stranici. Zato su razvijeni jezici za opis stranice ( ili PDL ) - specijalizirani jezik za formatiranje dokumenta specijalno napravljen za komunikaciju računara sa štampačem. Tokom godina , proizvođači pisača su razvili vlastite jezike za opisivanje formata dokumenata . Međutim , takvi jezici su primjenjivi samo na štampače koji su proizvođači stvorili sami . Ako bi, na primjer, poslali datoteku spremnu za štamu pripremljenu u PDL Epson štampača u profesionalnu štampariju, nema garancije da će datoteke biti kompatibilne sa štamparskom mašinom.

U firmi Adobe , je razvijen PDL zvani PostScript, koji koristi jezik za opisivanje i oblikovanje teksta i slika koje može obraditi printer . U isto vrijeme, Hewlett - Packard je razvio Printer Control Language ™ ( ili PCL ) za upotrebu u svojim sveprisutnim laserskim i inkjet štampačima. PostScript i PCL su sada široko prihvaćeni PDL-ovi i podržava ih većina proizvođača pisača. PDL rade na istom principu kao i programski jezici . Kada je dokument spreman za ispis, PC ili radna stanicu uzima slike , tipografske informacije i raspored dokumenta , i koristi ih kao objekte koje šalje štampaču za obradu. Štampač potom prevodi ove predmete u rastere, niz skeniranih linija koje čine sliku dokumenta (tzv. Raster Image Processing ili RIP ) , i ispisuje izlaz na stranicu kao jednu sliku , zajedno sa tekstom i bilo grafike uključene. Sljedeći primjer predstavlja PostScript program koji se šaje štampaču da nacrta trougao na stranici.


%!PS newpath 10 10 moveto 100 10 lineto 50 100 lineto closepath stroke 100 100 10 0 360 arc fill showpage

Sljedeći primjer u PCL crta pravougaonik, gdje <esc> predstavlja bajt s vrijednošću 27.<esc>&u300D<esc>*t300R<esc>*p300x300Y<esc>*r3U<esc>*v2S<esc>*c300a300b5P

U zavisnosti od organizacionih potreba , može biti nepotrebno dodijeliti jedan štampač za svakog člana organizacije. Dok je lokalni pisač priključen preko paralelnog ili USB kabel za svaku radnu stanicu idealno rješenje za korisnika , to je obično nije ekonomski isplativo. Proizvođači printera su za ovo razvili grupne printere. Ove mašine su obično izdržljive, brze, i imaju dug životni vijek potrošnog materijala . Grupni printeri obično su vezani za server štampe , samostalni uređaj koji se bavi poslovima štampe i preusmjerava izlaz na odgovarajući štampač kada je dostupan.

9.9 Štampanje u WindowsNa Windows gotovo sve aplikacije koriste GDI, koji se može koristiti i za

štampače tako da je generisanje izgleda stranice na štampaču jednostavno. Kontekst uređaja štampača se dobije API pozivom StartDoc i koriste se pozivi za crtanje. Slika se ispisuje u metadatoteku ili direktno prema drajveru, koji onda konvertuje to u format štampača. Podaci koji se šalju štampaču se pošalju programu spuleru (spoolsv.exe).

Vrlo često se kompletna konverzija u raster oblik obavlja na računaru, a ne na štampaču. To je omogućilo pojavu jeftinih štampača za Windows, zvanih GDI štampači, pored štampača s standarnim PCL.

API pozivi za generisanje štampe dati su u sljedećoj tabeli.

Štampanje u Windows 233

9.10 Linux/Unix štampanjeUnix arhitektura je starija od grafički orijentisanih štampača. Originalno,Unix nije

imao spool, nego se datoteka direktno slala na uređaj štampača naredbom poput.cat file > /dev/lp1U kasnijim verzijama je uveden lpd printer spuler, ali je imao nekih

nekompatibilnosti. Većina Unix alata za štampu je prilagođena linijskim štampačima, a ne pametnim štampačima. To znači da nema standardnog interfejsa za programski izlaz. Mora se kreirati privremena datoteka i štampati iz linijskog režima

Situacija se promijenila uvođenjem CUPS. CUPS je više od spool programa. To je kompletan sistem za upravljanje štampačima. Poznaje novi Internet Printing Protocol (IPP). Može mu se pristupiti web, GUI i komandnim interfejsima. Opremljen je programima filterima koji prevode različite tekstualne i grafičke formate u PostScript jezik, koji se može direktno slati takvim štampačima. Ako štampač nije PostScript tipa, programima CUPS-raster se konvertuje PostScript u format prilagođen štampaču, a zatim backend programima šalje kroz odgovarajući fizički interfejs ili mrežni protokol prema štampaču ili udaljenom serveru. Kada se koristi CUPS iz komandne linije se pripremljena datoteka zatim štampa programom lpr. Npr, ako se želi poslati datoteka na podrazumijevani štampač, koristi se

lpr test.pdf


9.11 Dodirni ekraniU novije vrijeme, sve popularniji ulazno/izlazni uređaj je dodirni ekran. Dodirni

ekran je računarski monitor koji reaguje na dodir olovkom ili prstom. Koriste se četiri tipa principa rezistivni, kapacitivni, infracrveni i površinski akustični talas (SAW)

Kod rezistivnog dodirnog ekrana, ekran je napravljen od dva sloja provodnog materijala. Jedan sloj ima vertikalne, drugi horizontalne linije. Kada se pritisne gornji sloj on dođe u kontakt s drugim koji dopusti tok struji. Odgovarajuće horizontalne i vertikalne linnije određuju poziciju na ekranu koja je dodirnuta.

Kapacitivni dodirni ekran je napravljen od laminata preko cijelog staklenog ekrana. Laminat provodi struju u svim pravcima, vrlo mala struja ide iz sva četiri ugla. Kada se ekran dodirne, struja teče u prst ili olovku. Lokacija dodira se odredi poređenjem koliko je jak tok elektriciteta iz svakog ugla

Infracrveni dodirni ekran je ekran s unaksrnim horizontalnim i vertikalnim zracima IC svjetla. Senzori suprotnih strana ekrana detektuju zraku. Kada korisnik prekine zraku dodirom ekrana, lokacija prekida se može odrediti

Akustički površinski zvuk (SAW) je ekran s visokofrekventnim zvučnim talasima horizontalno i vertikalno . Kada prst dodirne površinu, senzor prepozna prekid I odredi lokaciju dodira.

Dodirni ekrani 235

Najčešći način programiranja ulaza s ovim uređajem je da se za njih napišu drajveri slični drajveru za miša, pa da se uređaj ponaša kao miš.

Tableti su mali računari bez tastature kojima je dodirni ekran glavni ulazni uređaj. Jedan od načina da se prevaziđe nedostatak tastature su gesture. To su pokreti prstima preko dodirnog ekrana s posebnim značenjem.

9.12 Tekstualni korisnički interfejsObično izvan jezgra se izvršava aplikacija namijenjena korisnicima i to je ono što

većina ljudi vidi kada se govori o operativnom sistemu. Ta aplikacija omogućava korisnicima da unose i pokreću programe.

Prvi kućni računari, kao i današnji programabilni kalkulatori, nisu imali operativne sisteme u smislu u kome se govori u ovom kursu. Umjesto toga koristi se interpreter za programski jezik u ROMu (kao što su BASIC, Forth).


Prednost pristupa je u izuzetno brzom pokretanju računara, i mogućnosti da se odmah piše korisnički program, ali je mana u maloj fleksibilnosti.

Druga varijanta tekstualnog korisničkog interfejsa je primijenjena u operativnim sistemima kao što su CP/M, DOS, Unix ili VMS. Umjesto generalnog programskog jezika, kao što je BASIC, računar je opremljen specijaliziranim jezikom namijenjenim za pokretanje drugih aplikacija i manipulaciju datotekama. Ovakvi jezici se zovu skriptni jezici ili komandni interpreteri. Većina komandnih interpretera radi tako što ispiše kratku poruku koja se zove prompt. Korisnik tada otkuca komandu sljedećeg oblika:Opći obrazac za komandne linije sučelje OS je :

Naredba parametar1 parametar2 param3 ..Naredbe su obično jedna od tri klase :

1. Interna – prepoznaje i obrađuje sam interpreter komandne linije sebe i ne ovisi o bilo kojoj vanjskoj izvršnoj datoteci

2. Uključena - Izdvojena izvršna datoteka koja se općenito smatra dijelom operativnog okruženja i uvijek uključena u OS .

3. Vanjska - Vanjske izvršne datoteke nisu dio osnovnog OS , ali su dodane naknadno od strane korisnika.

Parametri parametar1 ... parametarn se prosljeđuju naredbi, odnosno eksternom programu. Parametri mogu biti argumenti (npr. Imena datoteka koje se obrađuju naredbom) ili opcije (dodatno definišu naredbu). Ispred opcija se stavlja neki standardizovani simbol poput crtice ili kose crte.

9.13 Skriptni jezici u DOS i WindowsVeć od prve verzije MSDOS, pa sve do današnjeg Windows 8, postoji komandni

interpreter koji se zove COMMAND.COM. U MS DOS, koji gotovo da nema upravljanje procesima, COMMAND.COM se naizmjenično učitava s aplikativnim programom. U DOS memoriji, kao i kod Windows 95 se čuva u dva dijela. Tranzijentni dio interpretira komande i briše se iz memorije kada se učita pozvani program. Rezidentni dio ostaje u memoriji i nakon završetka pozvanog programa ponovo učita tranzijentni COMMAND.COM dio s diska. Interne komande su date u tabeli.cd Change Directorychcp Change Code Pagecls Clear Screencopy Copy or Concatenate Filesctty Change Termial Typedate Displays or sets the date.del Delete (Erase) Filesdir Directory Listingexit Quits the COMMAND.COM program (command interpreter).lock Locks a drive, enabling direct disk access for an application.md Make Directorypath Sets program path

Skriptni jezici u DOS i Windows 237

prompt Changes the Windows command prompt.rd Remove (Delete) Directoryren Rename File or Directoryset Displays, sets, or removes Windows environment variables.time Displays or sets the system time.type Displays the contents of text files.unlock Unlocks a drive, disabling direct disk access for an application.ver Displays the Windows version.vol Volume Label/SNbreak Sets or clears extended CTRL+C checking.call Calls one batch program from another.echo Displays messages, or turns command-echoing on or off.for Runs a specified command for each file in a set of files.goto Directs Windows to a labelled line in a batch program.if Performs conditional processing in batch programs.lfnfor Enables/Disables Long file names when processing FOR commands.lh Loads a program into the upper memory area.pause Suspends processing of a batch program and displays the message:rem Records comments (remarks) in a batch file or CONFIG.SYS.shift Changes the position of replaceable parameters in a batch file.verify Tells Windows whether to verify that your files are written correctly to a

Ostale komande kao što su FORMAT, DISKCOPY, EDLIN, XCOPY, MEM, MOVE, START, PING, NET, ... se učitavaju s diska

Naredbe je moguće spajati u programe koji se zovu batch datoteke. Pored naredbi, batch datoteke u COMMAND.COM mogu imati četiri vrste varijabli :

• ERORLEVEL - sadrži povratni kod posljednjeg pokrenutog programa koji postavlja vrijednost ( cijeli broj između 0 i 255 ) . Većina programa imaju određeni konvenciju za njihove povratne kodove

• Varijable okruženja imaju formu %PROMENLJIVA%, a postavljaju se SET naredbom.

• Komandni parametri imaju oblik %0 , %1, ...%9 , u početku sadrže naziv komande i prvih devet parametara komandne linije. Parametri desno od devetog se mogu dosegnuti pomoću SHIFT naredbe

• " for" varijable – se koriste u petljama i imaju format %%a kada se radi u batch datotekama

Postoji mogućnost preusmjerenja ulaza ili izlaza komande u datoteku ili drugu komandu

komanda < datoteka Preusmjeravanje standardnog ulaza iz datoteke ili uređajakomanda > datoteka Preusmjeravanje standardnog izlaza , prebriše ciljnu datoteku

ako postoji .Komanda >> datoteka Preusmjeravanje standardnog izlaza , dodavanjem na ciljnu

datoteku ako ona postoji .


naredba1 | naredba2 Proslijedi standardni izlaz iz naredbe1 standardnom ulazu naredba2

command1 & naredba2 Komande razdvojene i izvršavaju se u sekvenciOd Windows NT, COMMAND.COM je ostavljen za izvršavanje 16 bitnih DOS

aplikacija, a uveden je CMD.COM. On je kompatibilan sa COMMAND.COM, ali ima više memorije na raspolaganju, naredbe SETLOCAL/ENDLOCAL za ograničenje područja varijabli okruženja, interne CALL i GOTO labele, izrazi u SET i IF, poboljšana FOR, historija komandi, dovršavanje komandi uz pomoć TAB, i naredbe za pamćenje direktorija PUSHD, POPD

POWERSHELL se instaira na nekim serverskim verzijama Windows. Puno je moćniji kao jezik. Koristi .NET klase, i aplikacije koje se zovu Cmdleti a koji se pokreću i obavljaju funkcije. Svaki cmdlet ima alias koji liči na DOS ili Unix komande. Npr. aliasi za Remove-Item su ri, del, rmdir, rd, rm

9.14 Unix ShellPod Unix sistemima nastalo je više različitih komandnih jezika. Izvršavaju se u

korisničkom prostoru memorije. Prva grupa je nastala od najranijeg. Oni se mogu podijeliti u dvije kategorije. Odlikuje se jezikom sličnim Algol 68, i ovu grupaciju sačinjavaju Bourne shell (sh – najraniji), Almquist shell (ash - malo zahtjevan ), Bourne-Again shell (bash – najpopularniji ), Debian Almquist shell (dash – verzija ash za distribuciju Debian), Korn shell (ksh čiji je autor David Korn), Z shell (zsh – najkompletniji od svih), Busybox – (u jednom programu su Shell i mali programi)

Drugu kategoriju predstavljaju C shell (csh) i TENEX C shell (tcsh). Njihov skriptni jezik podsjeća na C.

Grafička okruženja su danas dosta napredovala u odnosu na rane Linux dane, ali je komandna linija i dalje popularna na Unix baziranim sistemima. Razlog je u velikoj fleksibilnosti, univerzalnosti i brzini komandnog okruženja. Aktivnosti iz komandne linije se mogu automatizovati, tako da na primjer pripremite skup komandi koje će kopirati veliki broj datoteka i zatim radite nešto drugo, što jeste teže naučiti od kopiranja mišem, ali će vam na duži rok uštedjeti dosta vremena.

Komandna linija se još zove i terminal, konzola, XTerm, shell, školjka, ljuska, naredbena linija, naredbeni redak, komandni prompt (mada svi ovi izrazi nisu potpuni sinonimi). U BHLD je možete najlakše pokrenuti klikom na dugme s prikazanim crnim terminalom. Možete i iz K menija, koristeći opciju Konzola iz menija Sistem. Ako su vam potrebna veća prava, koristite opciju Root terminal.

Možete aktivirati komandnu liniju i u tekstualnom režimu, pritiskom na Alt Ctrl i F1 istovremeno, što ćete koristiti ako imate problema sa grafičkim režimom. Sa Alt Ctrl i F7 se ponovo aktivira grafički režim rada.

Naredbe se kucaju tako što imate jednu aktivnu liniju u koju upisujete naredbe. Naredbu pokrećete pritiskom na taster Enter. Kad se naredba izvrši i ispiše se rezultat (ako naredba daje kakav ispis) pojavi se nova aktivna linija, a stara se pomakla prema gore. Krivo napisana naredba se može korigovati s tasterima Delete i Backspace.

Unix Shell 239

Taster Tab služi za dopunjavanje naredbe. Često je dovoljno otkucati prvih nekoliko slova naredbe ili njenog parametra, a zatim pritisnuti taster Tab.

Osnovne Unix/Linux naredbeZa početak je korisno dobiti informacije gdje smo, ko smo i kada smo na sistemu.

Kao odgovor na prvo pitanje pogledajte kako se zove trenutni direktorij. Otkucajtepwdi pritisnite Enter.Računar će vam javiti kako se zove direktorij u kome se trenutno nalazimo. Naše

korisničko ime pod ovom sesijom saznajemo naredbomwhoamiIme računara se dobija naredbom hostname, a verzija jezgra Linuxa naredbom

unamehostnameuname -aTrenutno vrijeme i datum se saznaju naredbomdateDetaljniji kalendar dobijate naredbomcalAko želite pogledati spisak svih datoteka u tekućem direktoriju, otkucajte

komandulsNaredbe mogu imati i parametre. Tako na primjer ls -lRdaje spisak svih datoteka u tekućem direktoriju i njegovim poddirektorijima sa

detaljima o pravima, veličini, vlasništvu i vremenu kreiranja, dok se spisak svih datoteka uključujući i skrivene dobija sa

ls -aSvaka komanda ima parametar -? ili --help koji daje kratko uputstvo. Tako na

primjer, parametre naredbe ls možete saznati sals --helpDetaljniji opis svake naredbe možete dobiti koristeći komandu man. Ova komanda

kao parametar ima ime komande o kojoj se traži uputstvo. Na primjerman dateće dati sve parametre naredbe date i način njihovog korištenja. Kroz ovaj priručnik

krećete se strelicama gore/dolje ili PageUp/PageDown, a izlazite pritiskom na taster Q.

Za prelazak u drugi direktorij koristite komandu cd, čiji je parametar ime direktorija, na primjer za prelazak u direktorij /etc/apt otkucajte

cd /etc/aptNekoliko direktorija imaju specijalna imena..Trenutni direktorij ..


Direktorij koji se u hijerarhiji nalazi tačno iznad trenutnog~Početni direktorij za trenutnog korisnika/Korijenski direktorij cijelog datotečnog sistemaTako na primjer, sljedeća komanda vas prebacuje direktorij iznad trenutnog.cd ..Specijalni znak kose crte okrenut na lijevo (\) se koristi za unos znakova u

komandnoj liniji koji mogu praviti probleme. Na primjer, razmak normalno razdvaja parametre i ako želite pristupiti direktoriju koji ima razmak u imenu (npr /mnt/sda1/Program Files), ispred razmaka trebate staviti ovu kosu crtu, tj

cd /mnt/sda1/Program\ FilesAko se cd navede bez parametara, prelazi se u polazni direktorijcdNovi direktorij se kreira naredbom mkdir, koja kao parametar ima ime direktorija,

nprmkdir testniUz dodatni parametar -p ovom komandom kreirate i sve poddirektorije u

navedenoj stazi ako ne postoje nprmkdir -p testni/pod1/pod2/pod3Da obrišete datoteku koristite komandu rm, na primjerrm poruka.txtAko uz ovu naredbu dodate parametar -r, njom se mogu brisati i direktorijirm testni -rDatoteku možete iskopirati u drugu datoteku ili direktorij naredbom cp. Ova

naredba ima dva parametra, od kojih je prvi izvor, a drugi odredište. Na primjer, ako želite iskopirati datoteku prva.txt u direktorij /tmp otkucajte

cp prva.txt /tmpIstom naredbom možete napraviti drugu kopiju datoteke, npr.cp prva.txt druga.txtAko želite da pri tome nestane njena originalna kopija, dakle ne da je kopirate nego

da je premjestite (ili preimenujete) koristite komandu mv. mv prva.txt /tmpUnix/Linux poznaje i veze na datoteke koje omogućavaju više kopija iste datoteke,

ali da na disku koristi samo jedan prostor. To se zove simbolička veza. Simboličke veze se kreiraju komandom ln. Sljedećim primjerom će se kreirati datoteka kopirana.txt koja je identična naredbi prva.txt. Primijetite da ako nakon ove naredbe mijenjate sadržaj datoteke prva.txt, da će se promjene odraziti i na datoteku kopirana.txt

ln prva.txt kopirana.txtDa pronađete neku datoteku u dubokom stablu direktorija koristite naredbu find, na

primjer find /home -name naziv.txt

Unix Shell 241

Naredba find pruža širok izbor mogućih načina pretraga. Iza parametra --name se navodi regularni izraz s opisom imena datoteka koje se pretražuju, a iza parametra --exec možete navesti komandu koja se izvrši svaki put kada se pronađe datoteka čije ime zadovoljava dati uslov. Unutar parametra exec, ime nađene datoteke se označava s otvorenom i zatvorenom vitičastom zagradom, a naredba završava znakovima naopake kose crte i tačka-zareza. Sljedeći primjer će iskopirati sve .c i .h datoteke iz svih poddirektorija direktorija /home/student u direktorij /tmp/arhiva

find /home/student -name *.[hc] -exec cp {} /tmp/arhiva \;Naredbom which saznajemo gdje se nalazi pojedina izvršna naredba. Tako, na

primjer da saznamo u kom direktoriju se nalazi program sort, otkucajtewhich sortZa prikaz datoteke na ekranu koristite naredbu cat cat prva.txtOva naredba može da ima više parametara, koji predstavljaju datoteke koje se

redom ispisujucat prva.txt druga.txt treca.txtPošto veće datoteke prebrzo prelete na ekranu, prilikom ispisa, uvedene su

komande more i less. Komandom more se prikazuje datoteka navedena kao njen parametar, praveći pauzu nakon svakog ispunjenog ekrana teksta, i čeka da pritisnete taster za razmak. Tasterom Q možete izaći iz programa more

more prva.txtNaredba less predstavlja unapređenje naredbe more i omogućava kretanje

strelicama unazad kako bi se vidio već pregledani tekst.less prva.txtDa vidite samo prvih deset linija datoteke, koristi se naredba head, na primjerhead prva.txtDa obrišete konzolni prozor koristiteclearDa obnovite ispravno funkcionisanje konzolnog prozora ako počne prikazivati

čudne znakove umjesto slova koristitereset Ako želite izlaz iz neke komande umjesto na ekran proslijediti u datoteku, koristite

znak za redirekciju >, na primjerls > spisak.txtAko se znak za redirekciju udupla, izlaz se nadovezuje na postojeću datoteku, na

primjerls /etc >> spisak.txtA ako želite izlaz iz jedne komande proslijediti kao ulaz u drugu komandu koristi

se znak uspravne crte, na primjer, da se datoteka spisak.txt prikaže sortirano sa pauzom nakon svake strane, koristite:

cat spisak.txt | sort | moreAko komanda prihvata ulaz sa tastature, tada možete čitati podatke iz datoteke,

npr:


fdisk <priprema.txtAko je izlazni tekst takav da staje u jedan red, on može postati argument neke

naredbe. Na primjer, da vidite zauzeće prostora trenutnog direktorija otkucajte: du `pwd`Naredba tar spaja više datoteke u jednu ili raspakuje iz nje. To je korisno za

arhiviranje i prenošenje preko Interneta. Kada se naredba tar koristi s parametrom -c tada se spaja više datoteka u jednu, a s parametrom -x se ovakva datoteka raspakuje. Izlaz iz naredbe tar se često prosljeđuje komandama gzip, compress ili bzip2 koje zbirnu datoteku kompresuju. Sljedeći primjer kompresuje direktorij home u datoteku home.tar.bz2

tar -c /home/ | bzip2 > home.tar.bz2Datoteka kreirana na prethodni način se može dekompresovati i raspakovati

sljedećom naredbombzip2 -dc home.tar.bz2 | tar -xZa pretraživanje podataka unutar tekstualne datoteke možete koristiti komandu

grep. Ovoj komandi prvi glavni parametar predstavlja traženi niz znakova a drugi je datoteka u kojoj se on traži. Na primjer, da nađete pojavu teksta proizvod u datoteci spisak.txt koristite:

grep proizvod spisak.txtNaredba grep je veoma moćna, jer omogućava pretraživanje složenijih izraza.

Specijalni simboli ^ i $ predstavljaju početak i kraj linije. Tako se riječ root, ako je na početku reda u datoteci /etc/passwd traži s

grep ^root /etc/passwd Pretraga za redovima koji završavaju znakom dvotačke u datoteci /etc/passwd se

obavlja sagrep :$ /etc/passwdPosebno je korisna mogućnost složenih izraza. Unutar uglastih zagrada se može

navesti skup znakova koji mogu doći na datom mjestu, dok znak tačke predstavlja bilo koji znak. Sljedeći primjer će prikazati sve redove gdje se javljaju prezimena poput Milić, Mašić, Mišić, Mešić, Molać iz datoteke imenik.txt

grep M.[lš].ć imenik.txtAko iza znaka tačke slijedi zvjezdica, ona se može više puta ponavljati. Tako,

ukoliko pored prezimena navedenih u prethodnom primjeru želite izdvojiti prezimena Milanković, Malenković, Milanović, Mišanović itd iz datoteke imenik.txt koristit ćete

grep M.[lš].*ć imenik.txtIzlaz iz naredbe cat se može proslijediti naredbi sed koja obavlja zamjene, brisanje

i filtriranje linija. Najčešće korišteni parametar ove naredbe je komanda s koja vrši zamjenu. Tako na primjer za prikaz datoteke upute.txt tako da se riječ kompjuter zamijeni riječju računar otkucajte:

cat upute.txt | sed 's/kompjuter/računar/g'Naredbom sed je veoma moćna iako zna biti dosta nepregledna. Sljedeći primjer

koji uklanja komentare i prazne redove iz datoteke s.txt najbolje ilustruje ta svojstva ove naredbe:

Unix Shell 243

cat s.txt | sed '/ *#/d; /^ *$/d'Naredba sort sortira tekstualnu datoteku, dok uniq izbacuje ponovljene redove iz

sortirane datoteke. Sljedeći primjer će napraviti uniju dvije datoteke:cat skup1.txt skup2.txt | sort |uniqDa dobijete informacije o broju linija, riječi i znakova u nekoj datoteci koristi se

naredba wc, kao u sljedećem primjeru:wc skup1.txtKomande koje zahtijevaju veća prava možete pozvati s prefiksom sudo, na primjer

da dodate novog korisnika otkucajtesudo addusernakon čega trebate odgovoriti na pitanja.Nad svakom datotekom su definisani vlasnik, grupa i ostali korisnici, te njihova

prava. Da bi korisnik safet dobio vlasništvo nad datotekom m.txt koristi se komanda chown.

sudo chown safet m.txtPripadnost datoteke grupi određuje se komandom chgrp. Da bi grupa studenti

dobila vlasništvo nad datotekom m.txt koristi se komanda chgrp.sudo chgrp studenti m.txtKomanda chmod dodjeljuje prava vlasniku, članovima grupe i ostalim korisnicima.

Svakom od njih u navedenom redu odgovara jedna oktalna cifra prava. Najčešće se koriste cifre 0 (nikakva prava), 4 (samo za čitanje), 5 (čitanje i izvršenje), 6 (čitanje i pisanje), 7 (puna prava). Tako se vlasniku datoteke m.txt dodjeljuju puna prava (7), grupi prava čitanja i izvršenja (5), a ostalim samo čitanja (4) nad datotekom m.txt sljedećom komandom

sudo chmod 764 m.txtSpisak aktivnih programa možete dobiti komandom:sudo ps -AKomanda ps će vam za svaki od procesa dati njegov identifikacioni broj. Taj broj

možete koristiti da nasilno prekinete zaglavljeni proces, na primjer, da prekinete proces s identifikacionim brojem 2212

sudo kill 2212Ako iza komande slijedi znak &, ta komanda se izvršava bez komunikacije preko

tastature, na primjer: cp velika odrediste &Prelazak na drugog korisnika obavlja se komandom su. Ako ova komanda nema

parametra podrazumijeva se prelazak na korisnika root. Obično je za ovu komandu prethodno potrebno pozvati program sudo, npr.

sudo susudo su mirkoIz promijenjenog korisnika izlazite sa exit. Ponavljanje ove komande napušta

komandnu školjku.exit


Naredbama du i df možete vidjeti zauzeće trenutnog direktorija i svih montiranih particija. Probajte

dudfNaredba dd se koristi za kopiranje koje uključuje i uređaje koji nisu prave

datoteke. Njeni parametri if, of, bs i count redom predstavljaju ulaznu datoteku, izlaznu datoteku, veličinu blokova i broj blokova koji se koristi. Tako na primjer, cijeli sadržaj CD-a u ISO datoteku se kopira sa

sudo dd if=/dev/cdrom of=snimak.isoDa pristupite podacima na disk particijama koje nisu korištene u Linux datotečnom

sistemu. Tako se particija treća particija prvog hard diska (/dev/sda3) povezuje s direktorijem /mnt/disk sljedećom komandom.

sudo mount /dev/sda3 /mnt/diskNaredbom export možete dodijeliti vrijednost promjenjivoj okruženja. Toj

promjenjivoj se kasnije pristupa s znakom dolar ispred njenog imena. Sljedeće dvije naredbe će dodijeliti vrijednost varijabli TESTNI i prikazati je.

export IME=testniecho $IMENaredba wget preuzima datoteku s http sajta. Ona se najčešće koristi s jednim

parametrom, URL koji predstavlja ime datoteke na udaljenom računaru. Uz parametar -c može se nastaviti prekinupto preuzimanje datoteke, a uz parametar -limit-rate može se ograničiti zauzeće mrežnih resursa. Sljedeći primjer koristi ove parametre.

wget -c –limit-rate=20k http://www.primjer.com/velika.isoDa prikažete stanje mrežnih interfejsa koristite komande ethtool (za žičane) i

iwconfig (za bežične uređaje) ili ifconfig (za sve uređaje)ethtool eth0iwconfig eth1ifconfigDa aktivirate, odnosno deaktivirate mrežni interfejs, koristitesudo ip link set dev eth0 upsudo ip link set dev eth0 downSpisak IP adresa se dobija saip addr showDa pristupite dijeljenom direktoriju share na računaru //windows_box koji radi pod

operativnim sistemom Windows otkucajte kao root sljedeću komandu, sudo mount -t smbfs -o fmask=666,guest //windows_box/share /mnt/wGašenje računara iz komandne linije obavlja se komandom shutdown now.shutdown now.U BASH je manji broj komande interni: echo, printf, read, cd, pwd, pushd, popd,

dirs, eval, set, unset, export, declare, typeset, readonly, getopts, source, . , exit, exec, shopt, caller, true, false, type, hash, bind, help, a sve ostale su eksterne.

Unix Shell 245

Shell skripte služe za automatizaciju čestih zadataka koji se inače ne mogu obaviti jednom prostom naredbom iz komandne linije. Uz BHLD se isporučuju dva komandna interpretera Bash i Dash, ali se Bash daleko više koristi.

Da budete upoznatiji s Bash programiranjem unesite sljedeći program u tekstualnu datoteku koji vraća dužinu datoteke u bajtima i snimite ga pod imenom velicina. #!/bin/bash # Declare variable choice and assign value 4choice=4# Print to stdout echo "1. Bash" echo "2. Scripting" echo "3. Tutorial" echo -n "Please choose a word [1,2 or 3]? "# Loop while the variable choice is equal 4# bash while loopwhile [ $choice -eq 4 ]; do # read user inputread choice# bash nested if/elseif [ $choice -eq 1 ] ; then echo "You have chosen word: Bash"else if [ $choice -eq 2 ] ; then echo "You have chosen word: Scripting" else if [ $choice -eq 3 ] ; then echo "You have chosen word: Tutorial" else echo "Please make a choice between 1-3 !" echo "1. Bash" echo "2. Scripting" echo "3. Tutorial" echo -n "Please choose a word [1,2 or 3]? " choice=4 fi fifidone

Kada ste otkucali i snimili datoteku kreiraj, postavićete pravo izvršavanja nad tom datotekom za korisnika koji ju je kreirao

chmod 755 velicinaPrimjer isprobajte sa ./velicina velicinašto će vratiti veličinu datoteke u bajtima.


U prethodnom primjeru se vidi nekoliko karakterističnih jezičkih elemenata koji će vam pomoći kod pravljenja različitih skripti. Da se pročitaju argumenti iz komandne linije, mogu se koristiti sljedeći specijalni skupovi znakova

$0 ime datoteke s skriptom$# ukupan broj argumenata (>=0)$1 1. argument$2 2. argument itd$* svi argumenti s kojim je skripta pozvana$@ slično kao $*, s time da "$@" ima isti efekt kao i "$1" "$2" ...$$ procesni identifikator (PID) shella koji izvršava skriptuNaredba shift pomjera argumente skripte: $1 postaje raniji $2, itd. a $# se smanjuje

za jedan (naravno, ako je bilo argumenata).Bash skriptni jezik poznaje osnovne jezičke strukture. Najvažnija je if, koja

uslovno izvršava dio koda. Njena struktura jeif naredbathen niz naredbi[elif naredbathen niz naredbi]...[else niz naredbi]fipri čemu su opcionalni dijelovi stavljeni u uglaste zagrade. Naredba if izvršava

zadatu naredbu i ako je ona vratila izlazni status 0 (logička vrijednost "tačno") izvršava se niz naredbi iza then. Možete navesti i jednu ili više naredbi elif koje testiraju dodatne uslove ukoliko raniji testovi nisu uspjeli. Na kraju, možete dodati naredbu else koja izvršava niz naredbi koje iza nje slijede ako su sva ispitivanja uslova u if/elif klauzulama bila neuspješna. Kontrolna struktura if se završava ključnom rječju fi.

U Bash skriptama se mogu naredbe razdvajati novim redovima ili znakom tačka/zarez.

Na primjerif [ podjela == 0 ] then echo $telse ((t=$t/1024)) echo $t Kfi

se može pisati i kao

Unix Shell 247

if [ podjela == 0 ] ; then ; echo $t ; else ; ((t=$t/1024)) echo $t K ;fi

Uloga tačka/zareza je drugačija nego u Pascalu ili C-u. Ona znači da želimo još naredbi u istom redu.

Kontrolnom strukturom while možete ponavljati niz naredbi dokle god je neki uslov zadovoljen, dok kontrolna struktura until ponavlja niz naredbi sve dok uslov nije ispunjen. Sintaksa ovih naredbi jewhile naredba; doniz naredbidone

odnosno:until naredba; doniz naredbidone

Kontrolna struktura case omogućuje poređenje neke riječi i obradu pojedinih slučajeva. Opšti format je:case riječ inslucaj1)lista naredbi 1;;slucaj2)lista naredbi 2;;...esac

Naredba for se koristi za ponavljanje akcije nad skupom riječi ili datoteka:for ime_promjenljive [in lista_riječi]doniz naredbidone

Varijablama u shell programima dodjeljuju se vrijednosti tako što se odmah iza njenog imena dopiše bez razmaka između znak "jednako", a sa desne strane znaka jednakosti varijabli se pristupa znakom $ ispred njenog imena.

Shell programi mogu uključivati funkcije koje se pozivaju kao da su skripte u posebnoj datoteci. Definicija shell funkcije ima sljedeći oblik:ime_funkcije () { niz naredbi}

Parametrima funkcije se može pristupati na isti način kao parametrima same skripte, npr. $2 predstavlja drugi parametar funkcije.

Naredba test je interna naredba koja se često koristi za ispitivanje uslova u kontrolnim strukturama. Argumenti naredbe test određuju vrstu testa. Izlazni status je 0 ako je test uspješan, a različit od nule ako je neuspješan.


Naredba test se može i skraćeno zapisati uz pomoć uglastih zagrada. Npr. test $x -gt 2 se može zapisati kao

[ $x -gt 2 ]. Obratite pažnju na razmake kojima su uglaste zagrade odvojene od susjednih riječi. Ovo je lista svih mogućih kombinacija uslova u naredbi test.

-e f da li postoji datoteka/direktorij s imenom f-f f da li je f obična datoteka -d f da li je f direktorij-r f da li skripta može čitati datoteku ili direktorij f-w f da li skripta može pisati datoteku ili direktorij f-x f da li skripta može izvršavati datoteku ili direktorij f-z str da li je string str prazan -n str da li je string str neprazanstr1 = str2 jednakost stringova str1 i str2 |str1 != str2 različitost stringova str1 i str2 |str1 < str2 da li je str1 ispred str2 u abecednom redustr1 > str2 da li je str1 iza str2 u abecednom redu n1 -eq n2 da li su n1 i n2 jednaki n1 -ne n2 da li su n1 i n2 različiti|n1 -lt n2 da li je n1 manji od n2 kao brojn1 -le n2 da li je n1 manji ili jednak n2 kao brojn1 -gt n2 da li je n1 veći n2 kao brojn1 -ge n2 da li je n1 veći ili jednak od n2 kao brojuslov1 -o uslov2 da li je zadovoljen bilo uslov1 bilo uslov2 uslov1 -a uslov2 testira da li je zadovoljen i uslov1 uslov2! uslov logička negacija zadovoljenosti uslova

9.15 GUIVećina operativnih sistema namijenjenim stonim računarima i laptopima danas

koristi grafičko okruženje za rad, GUI. Prvi GUI je nastao u XEROX laboratoriji Palo Alto, a ostali popularni su oni koji su sastavni dio operativnih sistema Apple Lisa i Macintosh, Microsoft Windows i UNIX X. Ovakav korisnički interfejs lakši je za učenje od komandne linije, iako se ne mogu automatizovati određene aktivnosti koje pružaju skriptni jezici. Kao glavni ulazni interfejs koristi se miš uz tastaturu, a kod mobilnih uređaja dodirni ekran.

Na sljedećoj slici dato je više GUI sistema, prvi Macintosh i novija verzija, rani Windows i noviji, te minimalistički TWM Window manager za Unix sisteme i napredni KDE, za Unix sisteme.

GUI 249

9.16 WINDOWS API GUI PROGRAMZa ilustraciju GUI, ovdje će se uzeti Win32 API , koji je podržan od strane svih 32

- bitnih verzijaWindowsa .Osnovni objekt na ekranu je pravougaono područje koje se zove prozor . Položaj i

veličina prozora su jedinstveno određeni davanjem koordinata ( u pikselima ) dva dijagonalno suprotna ugla . Prozor može sadržavati naslov, meni , alatnu traku , vertikalnu kliznu traku i horizontalnu kliznu traku. Windows koordinatni sistem stavlja ishodište u gornjem lijevom uglu i y povećava prema dolje , što se razlikuje od Kartezijevih koordinata koje se koriste u matematici .


Kada se stvara prozor , parametri određuju da li prozor može biti premješten od strane korisnika , mijenjati veličinu od strane korisnika , ili pomicati. Programi moraju biti obaviješteni o promjenama u veličini njihovih prozora i moraju biti spremni na ponovno iscrtavanje sadržaja njihovih prozora u bilo koje vrijeme , čak i kad to najmanje očekuju.

Kao posljedica toga , Windows programi su orijentisani na poruke . Korisničke akcije koje uključuju tastaturu ili miša su zarobljene od strane Windows-a i pretvore u poruke programu koje posjeduje prozor. Svaki program ima red poruka kome se šalju sve poruke koje se odnose na njega. Petlja glavnog programa love narednu poruku i prerade pozivom interni postupak za tu vrstu poruke . U nekim slučajevima, sam Windows može pozvati ove procedure izravno , zaobilazeći red poruka .

Sljedeći primjer pokazuje program u C koristeći Windows API koji prikazuje osnovni prozor na ekranu. On se sastoji od četiri osnovna dijela: registracija prozorske klase, kreiranje i prikaz prozora, petlje koja prosljeđuje poruke i prozorske procedure koja ih obrađuje.

#include <windows.h>const char g_szClassName[] = "myWindowClass";// Step 4: the Window ProcedureLRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch(msg) { case WM_CLOSE: DestroyWindow(hwnd); break; case WM_DESTROY: PostQuitMessage(0); break; default: return DefWindowProc(hwnd, msg, wParam, lParam); } return 0;}

WINDOWS API GUI PROGRAM 251

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { WNDCLASSEX wc; HWND hwnd; MSG Msg; //Step 1: Registering the Window Class wc.cbSize = sizeof(WNDCLASSEX); wc.style = 0; wc.lpfnWndProc = WndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hInstance; wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); wc.lpszMenuName = NULL; wc.lpszClassName = g_szClassName; wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION); if(!RegisterClassEx(&wc)) { MessageBox(NULL, "Window Registration Failed!", "Error!", MB_ICONEXCLAMATION | MB_OK); return 0; }

// Step 2: Creating the Window hwnd = CreateWindowEx( WS_EX_CLIENTEDGE, g_szClassName, "The title of my window", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 240, 120, NULL, NULL, hInstance, NULL); if(hwnd == NULL) { MessageBox(NULL, "Window Creation Failed!", "Error!", MB_ICONEXCLAMATION | MB_OK); return 0; } ShowWindow(hwnd, nCmdShow); UpdateWindow(hwnd);


// Step 3: The Message Loop while(GetMessage(&Msg, NULL, 0, 0) > 0) { TranslateMessage(&Msg); DispatchMessage(&Msg); } return Msg.wParam;}

Glavni program počinje funkcijom WinMain. Prvi parametar je identifikacija programa za ostatak sistema . Drugi parametar je prisutan samo zbog kompatibilnosti i više se ne koristi. Treći parametar, szCmd, je nulom završen niz koji sadrži komandnu liniju kojom je pokrenut program, čak i ako nije počeo od komandne linije. Četvrti parametar , iCmdShow , govori da li početni prozor programa treba zauzimati cijeli ekran, dio ekrana , ili samo traku zadataka.

Svaki prozor mora imati povezani objekt klase koja definira njegova svojstva . Objekat tipa WNDCLASS ima 10 polja. Najvažnije polje je lpfnWndProc , koje je dugi ( tj. , 32 - bitni ) pokazivač na funkciju koja upravlja porukama usmjerenim na ovaj prozor. Polje lpszClassName sadrži tekstualno ime klase prozora. U drugim poljima koja su ovdje inicijalizovana može se reći koje ime i ikonu koristiti u naslovnoj traci , a koji simbol će se koristiti za kursor miša. Nakon što je WNDCLASS inicijaliziran, RegisterClass je pozvan da Windows zna koji podprogram pozvati za smiještanje raznih događaja kroz red poruka.

Drugi glavni dio Windows programa je kreiranje i prikaz prozora. Sljedeći poziv, CreateWindow, alocira memoriju za strukturu podataka prozora i vraća ručku za referenciranje kasnije. Program zatim obavi još dva poziva u nizu, stavi prikaz prozora na ekranu , i na kraju ga popuni u potpunosti .

U ovom trenutku dolazimo do glavne petlje programa, koji se sastoji od dobavljanja poruke, njene konverzije u drugu poruku, a zatim prolazi natrag u Windows da Windows pozove proceduru za obradu. Ova procedura je ranije definisana kao polje u klasi prozora.

Pri slanju poruke se pozove podprogram WNDPROC , koji upravlja raznim porukama koje se mogu poslati do prozora. Prvi parametar je oznaka prozora koji se koristi. Drugi parametar je vrsta poruke. Treći i četvrti parametri mogu se koristiti za pružanje dodatnih informacija kada je to potrebno. Vrste poruka WM_CREATE i WM_DESTROY se šalju na početku i na kraju programa, respektivno. One daju programu priliku , na primjer , da se izdvoji memorije za strukture podataka, a zatim ga vratite. Treći tip poruke, WM_PAINT, je instrukcija programu da popuni prozor . Za razliku od tekst - baziranog sistema, u Windows programu ne može pretpostaviti da sve što se nacrta na ekranu će tamo ostati dok se ne makne. Ostali prozori mogu biti prevučeni preko njega, meniji iscrtavati, pojavljivati iskočni prozori itd. Da Windows obavijesti program da mora ponovo iscrtati, on pošalje WM_PAINT poruku, koja također pruža informacije o tome koji dio prozora je prepisan, u slučaju da je lakše generisati taj dio prozora umjesto cijelog. Postoji mnogo više vrsta poruka . Da biste izbjegli nestabilno ponašanje kada neočekivane poruke stignu , najbolje je

WINDOWS API GUI PROGRAM 253

pozvati DefWindowProc na kraju WNDPROC da se pozove podrazumijevana obrada.

Ukratko , Windows program normalno stvara jedan ili više prozora s klase objekta za svaki . Povezan sa svaki program je red poruka i skup rukovatelja postupaka . Na kraju , ponašanje programa je vođen dolazni događaja , koji se obrađuju procedurama rukovatelj . Ovo je veoma drugačiji model svijeta nego više proceduralnih stav da UNIX uzima .

9.17 X Window sistemU Unix sistemima se za grafiku koristi X terminal , koji vodi System X Window

( često je upravo zvao X ) , razvijen na MIT-u kao dio projekta Athena . Jedan X terminal je računar koje radi na X softveru , a koji stupa u interakciju sa programima koji rade na udaljenom računalu . Program unutar X terminala koji prikuplja unos sa tastature ili miša i prihvata komande sa udaljenog računara naziva se X server . On komunicira preko mreže sa X klijentom koji rade na nekom udaljenom računalom . On im šalje poruke tastature i miša i prihvata komande ekrana od njih. Može izgledati čudno da se X server izvršava unutar terminala a klijenti na udaljenom računaru, ali posao je X servera za prikaz bita , tako da ima smisla da bude u blizini korisnika.

Također je moguće pokrenuti X Window System na vrhu UNIX ili nekog drugog operativnog sistema. U stvari , mnogi UNIX sistemi pokreću X kao svoj standardni sistem prozora, čak i na samostalnoj mašina ili za pristup udaljenih računara preko interneta. Protokol i rad sistema je identična u svim slučajevima .

X je samo sistem prozora . To nije potpuni GUI . Da biste dobili potpuni GUI , drugi sloj softvera drže na vrhu. Jedan sloj je Xlib , što je skup biblioteka procedura za pristup funkcionalnost X .

Ovaj primjer pokazuje kako izgleda osnovni X Windows program


#include <X11/Xutil.h>#include <X11/Xos.h>#include <X11/Xatom.h>#include <X11/keysym.h>Display *dis;Window win;XEvent report;GC zuta_gc;XColor zuta_col;Colormap colormap;char zuta[] = "#FFFF00";void crtaj() {int i;

for ( i=1; i<200 ; i+=30) { XDrawRectangle(dis, win, zuta_gc, i,i, i,i); XFlush(dis);

}}

int main() {dis = XOpenDisplay(NULL);win = XCreateSimpleWindow(dis, RootWindow(dis, 0),

1, 1, 500, 500, 0,BlackPixel (dis, 0), BlackPixel(dis, 0));XMapWindow(dis, win);colormap = DefaultColormap(dis, 0);zuta_gc = XCreateGC(dis, win, 0, 0);XParseColor(dis, colormap, zuta, &zuta_col);XAllocColor(dis, colormap, &zuta_col);XSetForeground(dis, zuta_gc, zuta_col.pixel);

crtaj();XSelectInput(dis, win, ExposureMask | KeyPressMask |

ButtonPressMask);while (1) {XNextEvent(dis, &report);

switch (report.type) { case Expose:

crtaj();break;

case KeyPress:if (XLookupKeysym(&report.xkey, 0) == XK_q) {exit(0);}

break;}

}return 0;}

X Window sistem 255

Pošto Xlib pruža samo osnovne mogućnosti iscrtavanja likova, on se dopunjuje sa još dvije grupe biblioteka. Jedna grupa se zove X-toolkit ili intrisic i pruža podršku da se iscrtaju elementi korisničkog interfejsa koji se zovu widget, (meniji, dugmad) ali ih još ne iscrtava. Druga grupa zaista iscrtava te komponente i zovu se toolkit. Ima više toolkita (GTK, QT, Motif, FLTK, OpenLook ...)

9.18 Window manager, Display manager, Session manager i Desktop

Sam X Sistem u kombinaciji s toolkitima iscrtava elemente grafičkog interfejsa, ali je potreban i softver koji će crtati ukrase oko prozora, omogućiti njihovo pomjeranje, širenje, maksimiziranje uz dodatke elemenata kao što je Start dugme, ikona s značenjem i slično. Taj program se zove Window manager, koji je promjenjiv u toku rada. Postoji više njih, kao što su minimalistički twm, Metacity, Compiz, kwm itd. Razlikuju se u izgledu i memorijskim zahtjevima. Window menadžer je obični pozadinski proces i registruje se s X serverom da se pokrene zajedno s njim.

Da bi korisnici mogli da se prijave na računarski sistem već u startu u grafičkom režimu rada, koristi se Display manager. On može raditi lokalno ili preko mreže. Kada je display manager aktivan, ovi korisnici startuju sesiju navodeći važeću kombinaciju korisničkog imena i lozinke. Display manager također brine o pokretanju X servera pri podizanju ili eventualnom padu.

Session manager čuva stanje aplikacije, tj. položaje i sadržaj svih otvorenih prozora. Korisnik može da se odjavi i ponovo prijavi s sačuvanim položajem prozora. Postoji poseban protokol za komunikaciju između window managera i session manager-a.

Ova tri menadžera se mogu pisati odvojeno. Ali, ako se pišu sa zajedničkim ciljem da čine jedinstvenu cjelinu, dobija se Desktop okruženje. U njemu sve aplikacije imaju isti izgled. Na primjer prozori za izbor datoteke ili štampača su jedinstveni, kao i načini iscrtavanja prozora. Pokretanje pojedinačnih programa (ali samo onih specijalno pisanih za to desktop okruženje ili bar toolkit na kom je njegov window manager zasnovan) je takođe ubrzano.jer su dinamičke biblioteke koje oni koriste već u memoriji dok traje sesija. Primjeri desktopa su KDE, CDE, LXDE, EDE, Gnome itd.


Sekundarna memorija 257

10 Sekundarna memorija

Sadržaj sekundarnih memorija se za razliku od interne radne memorije, ne gubi nakon isključivanja napajanja. Sekundarne memorije služe za smiještanje operativnog sistema, podataka i programa.

Magnetni disk je najznačajnija komponenta eksterne memorije. Da bi se postigle bolje performanse i veća dostupnost za servere i veće sisteme se koristi RAID disk tehnologija. RAID predstavlja familiju tehnika koja koristi višestruke diskove kao paralelni niz za trajno smiještanje podataka sa ugrađenom redundansom a za kompenziranje mogućih grešaka.

Osim sekundarne memorije, značajna komponenta računarskih sistema je eksterna optička memorija. Osim toga koriste i sistemi sa magnetnim trakama u svrhu arhiviranja podataka.

Procesor računara i disk komuniciraju putem kontrolera diska. Kontroleri različitih diskova pružaju isti interfejs ka ostatku računara.

10.1 Magnetni diskoviHard disk (ili tvrdi disk) je uređaj koji piše i čita podatke. Hard disk služi

za trajno smiještanje podataka i nakon gašenja računara.Hard disk se sastoji od elektroničkog i mehaničkog dijela. Tvrdi disk se

sastoji od 5 glavnih dijelova:- Magnetna ploča- Glava za čitanje/pisanje- Pobuđivačka kazaljka- Pobuđivač- Osovina

Većina sistema imaju glavu za čitanje i glavu za pisanje. Tokom operacija čitanja i pisanja glava miruje dok ploča rotira ispod glave. Mehanizam pisanja zasnovan je na principu magnetnog uzorka.

10.2 Organizacija diska


Podaci se zapisuju u trake - koncentrične krugove na disku koji se zovu staze (engl. Tracks). Slika prikazuje raspored podataka. Susjedne staze su odvojene međuprostorom (engl. intertrack gap). Ovo sprečava ili minimizira greške nastale zbog pogrešnog poravnanja glave ili interferenciju magnetnog polja. Staze su podjeljene na sektore (engl. Sectors). Trake sadrže veliki broj sektora a oni mogu biti fiksne ili varijabilne veličine. Uobičajeni su sektori fiksne veličine 512 bajta. Da bi se izbjegli zahtjevi na sistem za nerealnom preciznošću, uvode se međuprostor između sektora (engl. intersector gaps)

Trake su imenovane od vanjske strane diska (sektor 0) prema centru, i mogu se još nazivati i cilindri (s obzirom da se u pojedinom uređaju nalazi više ploča). Ekvidistantne trake na svim diskovima čine jedan cilindar.

10.3 Pojednostavljen prikaz hard diska

Pojedini sektori grupisani i iskorišteni za zapis podataka nazivaju se nakupine (clusters). Operativni sistem se brine o iskorištavanju sektora i njihovom grupisanju u clustere. U idealnom slučaju pojedine datoteke će biti zapisane u jednom kontinuiranom clusteru, u stvarnosti s obzirom da se datoteke s vremenom povećavaju, smanjuju, brišu i dodaju datoteke će biti više manje razbacane u više clustera na disku. Ova pojava se naziva fragmentacija i dovodi do smanjivanja brzine pristupa datotekama. (obično OS ima alat za preslagivanje datoteka u kontinuirane clustere što se naziva defragmentacijom).

Magnetna tehnologija stalno napreduje, pa je gustina staza sve veća, što iskazuje efikasnije korištenje magneta. Unutrašnje staze, odnosno staze bliže centru, imaju manju površinu pa samim tim i manje magneta. Zbog toga se uvodi

Pojednostavljen prikaz hard diska 259

tehnika zona na disku gdje se cilindri grupišu u zone iste gustine (BZR - bite zone recording). Na taj način povećava se i kapacitet diska i brzina čitanja sa medijuma ali kontrolna elektronika ima složeniji zadatak.

Kapacitet diska predstavlja količinu podataka koja stane na disk. Mjeri se u bajtima. Računamo ga kao proizvod broja glava, cilindara (staza po ploči), sektora po stazi i broja bajtova po sektoru. Ova četiri podatka su osnovni podaci za pristup disku.

Najvažnije tehničke karakteristike neizmjenjivih magnetskih diskova kategorisane na slijedeći način. Prema kretanju glave diskove dijelimo na one fiksnom glavom (jedna po stazi) i pokretnom glavom (jedna po površini). Diskovi mogu biti uklonjivi i neuklonjivi, jednostrani ili dvostrani. Prema broju ploča imamo diskove sa jednom ili sa više ploča. Mehanizam glave može biti zasnovan na kontaktu (floppy) i aerodinamičkom međuprostoru (Winchester).

Mehanizam glave dozvoljava klasifikaciju diskova na tri tipa. Glava za čitanj/pisanje je postavljena na fiksnu udaljenost iznad površine diska dozvoljavajući međuprostor ispunjen zrakom. Drugi slučaj je kad mehanizam dolazi u fizički kontakt sa površinom diska tokom operacija čitanja i pisanja. Ovaj posljednji slučaj se koristi kod disketa (floppy disk).

Kod trećeg tipa diska je značajno uočiti odnos gustine podataka i zračnog međuprostora. Što je uža glava za čitanj/pisanje, to njena udaljenost od površine treba biti manja kako bi ispravno čitala i pisala. Uska glava povlači za sobom usku stazu a samim tim veću gustinu podataka a to je poželjno. S druge strane, što je glava bliže površini diska veća je mogućnost greške zbog nečistoća i nesavršenosti. Winchester disk predstavlja napredak u razvoju tehnologije. Winchester glave su hermetički zatvorene i gotovo potpuno bez prisustva nečistoća. Galve za čitanje/pisanje su dizajnirane tako da mogu raditi bliže površini diska nego konvencionalne rigid disk glave, i zato dozvoljavaju veliku gustinu podataka.


Za većinu diskova magnetni omotač se nalazi sa obje strane diska tada je disk dvostrani (engl. double sided). Neki jeftiniji diskovi se koriste single-sided diskove. Diskovi često sadrže više ploča koje se nalaze jedna iznad druge a sadrže i više ručica sa glavama za čitanje odnosno pisanje, kao što je prikazano na slici.

Geometrija diska je u opštem slučaju određena brojem magnetnih površina odnosno glava za čitanje i pisanje, brojem cilindara i sektora, a taj podatak se čuva na posebnoj memorijskoj lokaciji sa baterijskim napajanjem - CMOS RAM. Sa trodimenzionim adresiranjem «glava, cilindar, sektor» (engl. head, cylinder, sector) se može pristupiti svim dijelovima diska.

10.4 Parametri koji određuju performanse diskaKada disk uređaj radi disk rotira konstantnom brzinom. Za čitanje i pisanje

glava mora biti pozicionirana na željenu stazu na početak željenog sektora na toj stazi. Za izbor staze glava se pokreće na pokretnom sistemu dok ne dođe na željeni sektor od ruba diska ka sredini i obrnuto.

Na sistemu sa pokretnom glavom vrijeme potrebno da se glava pozicionira na željenu stazu naziva se vrijeme traženja (engl. seek tima). Nakon toga disk rotira dok se željeni sektor ne nađe ispod glave. Vrijeme potrebno da se početak željenog sektora poravna sa glavom naziva se rotaciono kašenjenje (engl. rotational delay). Vrijeme traženja i rotaciono kašenjenj čine vrijeme pristupa. Kad se glava nalazi na ispravnoj poziciji nastupa prenos podataka i vrijeme koje je za to potrebno naziva se vrijeme prenosa (engl. transfer time).

Pored vremena pristupa i vremena prenosa podataka, postoje nekoliko vremena kašnjenja (queuing delays) povezana sa U/I operacijama. Kada proces pokrene jedan U/I zahtjev, mora prvo čekati u redu na uređaj sve dok taj uređaj ne bude dostupan. U trenutku kada je uređaj dodjeljen počine vrijeme traženja.

Vrijeme traženja je vrijeme potrebno da se ručica diska pomjeri na zahtjevanu stazu. Ovo vrijeme se sastoji od dvije ključne komponente: inicijalno vrijeme uspostavljanja i vrijeme koje je potrebno za prelazak do željen staze. Na žalost, vrijeme prelaska nije linerana funkcija broja staza i uključuje i vrijeme od pozicioniranja ručice iznad željene staze sve dok se ne potvrdi identifikacija staze.

Rotaciono kašnjenje: Diskovi rotiraju brzinom koja se kreće od 3600 rpm (Revolutions Per Minute) do 15,000 rpm. Floppy dsikovi rotiraju sa brzinima tipično između 300 i 600 rpm. U najgorem slučaju, glava se mora pomjeriti od staze 0 do staze najbliže centru, a u prosjeku pola rotacije. Za minifloppy koji rotira sa 300rpm, srednje rotaciono kašnjenje je 100ms, a za hard disk koji rotira sa 3600rpm ono se smanjuje na 8,3ms.

Vrijeme prenosa podataka na disk i sa diska zavisi od rotacione brzine diska na slijedeći način:

Parametri koji određuju performanse diska 261

gdje jeT - vrijeme prenosa,b - broj bajta koji trebaju biti preneseni,N - broj bajta na stazi,r - rotaciona brzina, rpm

Tako da ukupno prosječno vrijeme pristupa može biti izraženo sa:

gdje je T s prosječno vrijeme traženja.

Kod tehnologije zona broj bajta po stazi je varijabilan a to komplikuje računanje. Generalni vremenski dijagram dat je na slici.

10.5 Formatiranje diska i pravljenje particijaFormatiranje diska je proces kod koga se na magnetni medij upisuju oznake koje

predstavljaju granice staza i sektora, a neformatiran disk se ne može koristiti.Prva vrsta formatiranja je formatiranje diska na niskom nivou. Na nekim

diskovima (MFM, raniji SCSI)može ga raditi korisnik, ali se danas uglavnom radi fabrički. Suština ovog formatiranja je da se pripreme se signali za prepoznavanje (Preamble) i korekciju grešaka sektora (ECC).

Druga vrsta formatiranja je tzv. formatiranje visokog nivoa (eng. high level formating) DOS/Windows operativnih sistema što predstavlja formatiranje fajl sistema, ovim se ne formatira disk na niskom nivou.

Za dalje korištenje pod operativnim sistemom, nakon formatiranja disk se priprema u dvije faze. Prva faza predstavlja dijeljenje diska na particije. Na disku se može napraviti samo jedna particija ili se prema potrebi može napraviti nekoliko particija koje se ponašaju kao zasebni diskovi. Više particija je potrebno kad želimo instalirati više operativnih sistema.

Disk se često dijeli na particije i kada je instaliran samo jedan operativni sistem, na ovaj način je lako razdvojiti sistemske fajlove od korisničkih.


Informacije o svim particijama diska su zapisane u nultom logičkom sektoru, nulti sektor, nulte staze na nultoj površini diska. Ovaj sektor se naziva glavni startni zapis (engl. Master Boot Record). BIOS pristupa MBR-u kod svakog pokretanja računara. MBR sadrži program koji očitava particionu tabelu, provjerava koja je particija aktivna i očitava prvi sektor aktivne particije - startni sektor (engl. boot sector). U startnom sektoru se nalazi mali program čijim pokretanjem započinje bootstrap rutina odnosno učitavanje operativnog sistema u memoriju.

10.6 Preplitanja i zakretanja u transformaciji logičkih sektora u fizičke

Radi praktičnijeg računanja, tri koordinate (glava, sektor, cilindar) se transformišu u jednu, logički broj sektora. Moderni diskovi u svojim kontrolerima imaju čak mogućnost da se disku pristupa navodeći direktno taj jedan logički broj, a da se ta konverzija u tri koordinate obavi interno. Sistem se zove LBA (logical block access). Ima više načina da se obavi ova transformacija, na primjer da se poredaju u jedan niz od logičkog sektora 0 svi sektori nulte staze, pa svi sektori prve staze itd. Sve do zadnjeg sektora zadnje staze. No, ponekad se radi poboljšanja performansi ova transformacija obavlja i drugačije.

Na sporijim računarima, može se desiti da je disk rotacijom došao na naredni sektor prije nego je završen prijenos prethodnog sektora. Da bi se to izbjeglo, koristi se preplitanje. Logički sektori se ne redaju sekvencijalno u fizičke, nego se preskače po jedan ili dva sektora. Na primjer, za disk čija staza ima 40 sektora, ako logički sektor broj 80 treba da se nalazi na fizičkom sektoru 0, glave 0, cilindra 2, logički sektor broj 81 će se smjestiti na fizički sektor 2, glave 0, cilindra 2,... logički sektor broj 99 će se smjestiti na fizički sektor 38, glave 0, cilindra 2, nakon čega se popunjavaju preskočeni sektori, pa će se logički sektor 100 smjestiti na fizički sektor 1, glave 0, cilindra 2, logički sektor 101 smjestiti na fizički sektor 3 glave 0, cilindra 2, itd. Moderni diskovi imaju dovoljno veliku brzinu pa preplitanje nije potrebno.

Nekada se koristi i zakretanje (skew). Da bi se ubrzalo sekvencijalno logičkih čitanje sektora koji se nalaze na različitim stazama, brojanje logičkog sektora po završetku staze se ne treba nastaviti od nultog sektora sljedeće staze, jer bi dok glava pređe na narednu stazu zbog rotacije diska potrebni sektor već prošao i morao bi se sačekati cijeli krug. Umjesto toga naredni logički sektor se nastavlja od onog fizičkog sektora koji bi bio na poziciji glave nakon pređenog vremena u njenom pozicioniranju na sljedeću stazu.

Proces podizanja sistema na PC računarima 263

10.7 Proces podizanja sistema na PC računarima

POWER GOOD

TIMER PREKIDA RESET

JMP FFFF:0000

GREŠKE BEEP

TRAŽI BIOS NA ADRESAMAC000:0000 i C780:0000

GREŠKE C000 ROM ERROR

0000:0472=1234

INIT VIDEO KARTICE

WARM=1

PNP BIOS ?

TEST BIOSA

TEST MEMORIJE

WARM BOOT ?

ZA SVE UREĐAJE SMJESTI PODATKE U RAM

ISKLJUČI KONFLIKTE

DODIJELI IRQ ADRESE

OMOGUĆI SVE UREĐAJE

UČITAJ CMOS RAM

DISKETA?

NAĐI MBR SEKTOR, CIL=0, HEAD=0, SECTOR=1, LEN=512

UČITAJ MBR NA 0000:7C00

MBR NEMA 55AA NA KRAJU

SKOČI U LOADER

NAĐI AKTIVNU PARTICIJU I POZICIJU BOOT SEKTORA

UČITAJ BOOT SEKTOR

BASIC ROM

NO ROM BASIC, SYSTEM HALTED

STARTAJ BASIC

NAĐI BOOT SEKTOR, TRACK=0, HEAD=0, SECTOR=1, LEN=512

LOŠA SIGNATURA

DISKETA

DISK BOOT FAILURE

GENERAL FAILURE ERROR

DOS, WIN3.1

WINDOWS 95/98/ME

WINDOWS NT, XP, 2000

LINUX NEBUTABILNA DISKETA

NON SYSTEM DISK OR DISK ERROR

WINDOWS VISTA


Svi IBM PC kompatibilni računari započinju svoj rad tako što se procesor uključi u realnom režimu rada. U ovom režimu, mikroprocesor je kompatibilan sa starim 8086 i koristi šesnaestbitne registre i segmente. Početna adresa je podijeljena u dva dijela, registar CS (Code segment) ima vrijednost 0xFFFF, a registar IP (Instruction pointer) ima vrijednost 0000. U ovoj fazi se greške javljaju zvučnikom. Kada je prepoznat BIOS video kartice (adresa C000:0000) i utvrđeno da je u pitanju puno podizanje procesora, slijedi test BIOS ROMA, test RAM memorije i inicijalizacija nekih periferijskih uređaja. Kada je prepoznato da postoji flopi ili hard disk, sa njega se učita njegov početni sektor na adresu 0000:7C00. BIOS obavi skok na navedenu adresu koja u slučaju hard disk-a sadrži program koji očita aktivnu particiju i učita početni sektor te particije ponovo na istu adresu, i ponovi se skok u program koji započinje učitavanje cijelog operativnog sistema. U slučaju flopi diska, već prvi skok na 0000:7C00 započinje učitavanje operativnog sistema.

10.8 Raspoređivanje zahtjeva za rad sa diskomU višeprocesnom okruženju, u jednom trenutku postoji veliki broj zahtjeva za rad

sa diskom. Pravilnim raspoređivanja ovih zahtjev (engl. disk scheduling) može se skratiti ukupno vrijeme pozicioniranja ili rotaciono kašnjenje. Svaki zahtjev sadrži informacije o tome da li je u pitanju operacija čitanja ili pisanja, adresu bloka na disku, adresu memorijskog bafera i broj bajtova koje treba prenijeti.

Više zahtjeva može stići istovremenao a u jednom trenutku može biti obrađen samo jedan zahtjev. Za raspoređivanje pristiglih zajtjeva za rad sa diskom postoji više algoritama: FCFS, SSTF, SCAN, C-SCAN, LOOK i C-LOOK.

10.9 FCFSFCFS (first come, first served) je najjednostavniji algoritam kod koga se

zahtjevi opslužuju onako kako pristižu. Ovaj algoritam iako ravnopravno tretira sve zahtjeve daje nalošije performanse. Performanse zavise od pokretanja glave za čitanje i pisanje a performanse će slabiti sa većim pomjeranjem.

Razmotriom slijedeći primjer. Pretpostavimo da disk ima 200 staza i da imamo sekvencu zahtjeva: 98,183,37,122,14,124,65,57

Pretpostavimo da je glava za čitanje/pisanje inicijalno pozicionirana na stazi 53.

FCFS 265

U ovom primjeru glava za čitanje/pisanje će preći 640 cilindara.

10.10 SSTFSSTF algoritam (shortest seek time first) kod opsluživanja zahtjeva od pristiglih

zahtjeva bira onaj koji će izazvati najmanje pomjeranje glave. Algoritam ima sličnosti sa SJF algoritmom raspoređivanja procesa i ima optimalno vrijeme pozicioniranja. Korištenje ovog algoritma , međutim, može dovesti do problema izgladnjivanja - zakucavanja (engl. starvation). Glave se mogu zadržati dugo u jednoj zoni opslužujući zahtjeve za koje je potrebno malo pomjeranja tako da se može desiti da udaljeni zahtjevi veoma dugo čekaju. Za isti primjer kao kod FCFS, pređeni put je 236 cilindara.


10.11 SCANSCAN algoritam ili kako se još često naziva lift algoritam naizmjenično pomjera

glave do kraja diska i nazad pri tome opslužuje zahtjeve na koje nailazi na tekućem cilindru. Ovaj algoritam rješava problem izgladnjivanja. Za spomenuti primjer, pređeni put je 208 cilindara.

10.12 C-SCANKružni SCAN algoritam (C-SCAN, circular SCAN), je varijanta algoritma

SCAN i on razrješava problem favorizovanja unutrašnjih cilindara. Razlika u odnosu na SCAN je u tome što se zahtjevi opslužuju samo u jednom smjeru, kad glava dođe do posljednjeg cilindra, pomjera se na početak a pri povratku na početak ne opslužuje zahtjeve. Ako se povratni put ne računa (ima logike, jer se glava u toj fazi može kretati brže), pređeno je 183 cilindra.

LOOK i C-LOOK 267

10.13 LOOK i C-LOOKAlgoritmi LOOK i C-LOOK su modifikacija algoritama SCAN. Glave se

ovde ne pomjeraju od početka do kraja diska nego do psoljednjeg zahtjeva koji se nalazi u tom smjeru. LOOK opslužuje zahtjeve u oba smjera, dok C-LOOK samo u rastućem smjeru do posljednjeg zahtjeva u tom smjeru.

Za navedeni primjer LOOK algoritma, pređeni put je 180 cilindara.

Ako se povratni put ne računa, CLOOK algoritam ima najkraći pređeni put.


10.14 Raspoređivanje diska u multimedijalnim sistemimaDa se izbjegnu trzaji u audio/video datotekama, postoje i posebni algoritmi za

raspoređivanje u multimedijalnim sistemima. Ovi algoritmi su potrebni i kod nemehaničkih diskova

Jedan algoritam je najraniji rok prvo, Earliest-Deadline-First (EDF). Uz blokove, koji predstavljaju dio neke video datoteke se evidentira i u kojem trenutku je potrebno učitati taj blok. Redoslijed očitavanja blokova se određuje prema roku kada je traženi blok potrebno učitati, tj. da se ranije potrebni blokovi ranije učitavaju.

Drugi algoritam je SCAN-EDF, koji je kao EDF, ali se blokovi s jednakim rokom trebaju očitavati po SCAN algoritmu

10.15 Povećanje pouzdanostiNa povećanje pouzdanosti diskova može se uticati na više načina, kao što su

korekcioni kodovi u formatu niskog nivoa, premapiranje loših sektora, uvođenje RAID struktura itd.

Korekcioni kodovi (ECC) omogućavaju da se u slučaju neispravnosti jednog bita i dalje dobijaju ispravni podaci, odgovarajućim računom. Oni su najčešće ugrađeni u sastavni dio sektora formatiranog na niskom nivou i nevidljivi su za operativni sistem.

Veći defekti se prepoznaju razlikovanjem upisane i naknadno pročitane vrijednosti. Ako se uoči takva razlika, sektor se proglašava neispravnim i treba ga izbaciti iz upotrebe. Loše sektore može obraditi disk kontroler ili OS. U slučaju da to radi kontroler, on ima tablicu kojom zamijeni blokove na logičkoj poziciji rezervnim blokovima. To može uraditi i operativni sistem, praveći drugačije tablice, često definisane datotečnim sistemom. Sljedeći primjer na slici pokazuje dva načina premapiranja lošeg sektora, prvi je njegovo smiještanje u odvojeni rezervni sektor, a drugi je jedno preskakanje mjesta.

RAID strukture 269

10.16 RAID struktureRAID strukture se koriste za realizaciju stabilnih sistema i koriste princip

ogledala. Brzina rada sa sekundarnom memorijom je značajno manja od brzine procesora i interne meorije. Zbog ove razlike sistemi sekundarne memorije postaju glavni fokus rada na poboljšanju ukupnih performansi računarskog sistema. Uočeno je da se poboljšanje performansi postiže korištenjem višestrukih paralelnih sistema. To vodi razvoju niza diskova koji rade nezavisno i paralelno. Sa više diskova odvojeni U/I zahtjevi se mogu obraditi paralelno sve dok podaci koji se zahtjevaju leže na odvojenim diskovima. Osim toga jedan U/I zahtjev može biti obrađen paralelno ako podaci kojima se pristupa leže distribuirano na više diskova. Kada se koriste višestruki diskovi postoji različiti načini za organizaciju podataka i postizanje redudanse i pouzdanosti. Postoje industrijski standardi poznati pod nazivom RAID (Redundant Array of Independent Disks).

RAID šema se sastoji od 7 nivoa (od nivoa 0 do nivoa 6). Ovi nivoi ne predstavljaju hijerarhijski odnos nego različite arhitekturalne dizajne koji dijele tri osnovne zajedničke karakteristike.

(1) RAID je skup fizičkih diskova koje operativni sistem vidi kao jedan logički disk. (2) Podaci su raspoređeni preko niza fizičkih diskova.

(3) Redudantni kapacitet se koristi za smiještanje paritetne informacije koja garantuje oporavak u slučaju ispada diska.

Detalji druge i treće karakteristike razlikuju se za različite RAID nivoe. RAID 0 ne podržava treću karakteristiku. Slijedi pregled svih RAID nivoa. Tabela daje podatke za 7 RAID nivoa. Nivo 2 i 4 se rijetko koriste.


10.17 RAID nivo 0RAID nivo 0 nije pravi član RAID familije s obzirom da ne uključuje

redundancu. Međutim, postoji nekoliko područja primjene gdje su performanse i kapacitet te niža cijena prioritet u odnosu na pouzdanost.

RAID nivo 0 271

Kod RAID 0 sistema korisnici i sistemski podaci su distribuirani preko cijelih diskova u nizu. Ovo ima uočljive prednosti u odnosu na korištenje jednog velikog diska. Ako U/I zahtjevi čekaju na dva različita bloka podataka postoji velika šansa da su ti blokovi na različitim diskovima. Zato ti zahtjevi mogu biti obrađeni paralelno. Osim jednostavnog distribuiranja podataka preko niza diskova, podaci su podijeljeni na trake (striped) što se najbolje može shaviti posmatranjem slike. Svi korisnici i podaci se posmatraju kao da su smješteni na jedan veliki logički disk. Disk je podijeljen na trake, koje mogu biti fizički blokovi, sektori ili neke druge jedinice. Ove trake su po round robin metodi mapirane na sve članove niza. Prednost ove šeme je da ako se jedan U/I zahtjev sastoji od zahtjeva ka više traka one mogu biti obrađene u paraleli.

RAID 0 je veoma brza konfiguracija i ima najbolje performanse čitanja i upisa, ali pošto nema nikakvu redundansu, otkaz bilo kog diska znači gubitak svih podataka.

10.18 RAID nivo 1RAID 1 se razlikuje od ostalih RAID nivoa (2 do 6) po načinu na koji je

postignuta redundansa U ovim ostalim RAID šemama neka forma računanja parnosti se uvodi u cilju uvođenja redundanse. Kod RAID 1 nivoa redundansa se postiže prostim dupliciranjem svih podataka. Kao što se može vidjeti na slici, podaci se dijele na trake kao kod RAID 0 nivoa, samo u ovom slučaju svaka logička traka se mapira na dva odvojena fizička diska. Svaki disk ima svoj disk ogledalo (engl. mirror disk). Koji sadrži iste podatke.

Postoji veći broj pozitivnih aspekata RAID 1 organizacije:(1) Zahtjev za čitanje može se uslužiti sa bilo kog od dva diska koji sadrže iste

podatke, a nastoji se da se smanji vrijeme traženja i rotaciono kašnjenje.(2) Zahtjev za pisanje treba da se uradi na oba diska koji sadrže te podatke ali to

se može učiniti paralelno.Osnovna mana RAID 1 nivoa je cijena jer zahtjeva dvostruki prostor logičkog

diska koji podržava.

10.19 RAID nivo 2RAID nivoi 2 i 3 koriste tehnike paralelnog pristupa. Kod paralelnog pristupa svi

diskovi učestvuju u izvršenju svakog U/I zahtjeva. Kao i kod ostalih RAID šema, koristi se dijeljenje podataka na trake. Kod RAID 2 i 3 nivoa, trake su male, često veličine bajta ili riječi. ECC (error-correcting code) se koristi za računanje greške. Bez obzira na broj diskova podataka, potrebna su još 3 diska za ECC koja mogu sačuvati podatke u slučaju otkaza bilo kog diska. RAID 2 nije praktično implementiran.

10.20 RAID nivo 3RAID 3 je organizovan na sličan način kao RAID 2. Razlika je jedino u tome da

RAID 3 zahtjeva jedan redundantni disk, bez obzira koliko ima podatkovnih diskova. Ova konfiguracija organizuje podatke na nivou bit ili bajta, a po pitanju


redundanse prvi put se uvodi parnost diskova (engl. bit-interleaved parity). Kod diskova se tačno zna gdje je nastupila greška. U slučaju greške pristupa se disku parnosti i podaci se rekonstruišu na bazi parnosti. Za sve diskove podataka dovoljan je jedan bit parnosti.

S obzirom da su podaci podijeljeni u male trake RAID 3 može postići velike brzine prenosa podataka. Bilo koji U/I zahtjev uključuje paralelni prenos podataka sa svih podatkovnih diskova. Za veće prenose poboljšanje performansi je uočljivo. S druge strane samo jedan U/I može biti izvršen u jednom trenutku. Ovakav sistem bi imao loše preformanse u sistemu sa velikim brojem transakcija.

10.21 RAID nivo 4RAID nivo 4 konfiguracija ima organizaciju dijeljenja podataka na nivou

bloka, a po pitanju redundanse koristi parnost za diskove na nivou bloka (engl. block-interleaved parity). Za N blokova, sa N diskova, dovoljan je jedan blok parnosti koji je jednak veličini trake diska. U svakom ciklusu upisa učestvuje i diska parnosti a to dovodi do preopterećenja ovog diska koji može postati usko grlo sistema.

10.22 RAID nivo 5RAID 5 je organizovan na sličan način kao RAID 4. Razlika je u tome da

RAID 5 distribuira trake parnosti preko svih diskova. Tipično se koristi round-robin šema alokacije kao što je ilustrovano na slici. Od osnovnih struktura RAID 5 predstavlja najbolju kombinaciju: posjeduje paralelizam, konkurentnost, dobar je za velike upise, a svi diskovi su ravnomjerno opterećeni.

RAID nivo 6 273

10.23 RAID nivo 6RAID 6 predstavlja jedinu RAID šemu koja može razriješiti problem u slučaju

otkaza više od jednog diska (ukoliko se koriste prethodne šeme, osim RAID 1, svi podaci se gube ako istovremeno otkažu dva ili više diskova). Kod RAID 6 šeme koristi se računanje dvije različite parnosti koje se smještaju u blokove na različite diskove. RAID 6 šema koja ima podatke za N diskova zahtjeva ukupno N+2 diska.

10.24 Hibridni RAID 0+1 i 10Padom cijena diskova postaju popularne kombinovane RAID šeme. Najčešće se

kombinuju RAID 0 i RAID 1 sa dva različita redoslijeda ovih šema.RAID 0+1 najprije razdvoji podatke na odsječke na različitim diskovima bez

redundanse, kao što radi RAID 0, u cilju postizanja potrebnog kapaciteta i brzine. Zatim se cijeli skup diskova umnoži u dvije kopije kao što radi RAID 1.

U RAID 1+0 ili RAID 10 radi se obrnutim redoslijedom. Ovdje se najprije naprave kopije diskova, a zatim kopije podijele na odsječke. Sistem se odlikuje velikom pouzdanošću, jer dopušta ispad više diskova pod uslovom da ostane bar jedna kopija.

data disks mirror copies

Stripe 0

Stripe 4

Stripe 3Stripe 1 Stripe 2

Stripe 8

Stripe 7Stripe 6Stripe 5

Stripe 9

Stripe 0

Stripe 4

Stripe 3Stripe 1 Stripe 2

Stripe 8 Stripe 9

Stripe 7Stripe 6Stripe 5

Mirror pair

Stripe 0

Stripe 4

Stripe 8

Stripe 3

Stripe 11

Stripe 7

Stripe 2

Stripe 10

Stripe 6

Stripe 1

Stripe 5

Stripe 9

Stripe 0

Stripe 4

Stripe 8

Stripe 3

Stripe 11

Stripe 7

Stripe 2

Stripe 10

Stripe 6

Stripe 1

Stripe 5

Stripe 9


10.25 SSD diskovi Klasični tvrdi disk se sastoji od jedne ili više magnetnih ploča – diskova, koje

rotiraju oko vertikalne osi, a pomična glava čita i piše podatke koji su zapisani na magnetnom premazu tih ploča. SSD je skraćenica od Solid-State Drive i ti uređaji, za razliku od tvrdog diska, nemaju pokretnih dijelova. Time izostaju vibracije i buka, a odlikuje ih i mala potrošnja struje, a s time i manje zagrijavanje. Pojam solid-state označava upotrebu isključivo elektroničkih elemenata i sklopova, a time je i način zapisa na ovim uređajima potpuno drugačiji od onog na klasičnim tvrdim diskovima.

Za zapis informacija se koriste dvije vrste memorija, NAND flash i DRAM. Princip NAND flash je MOSFET s 2 gate, od kojih je jedan izolovan pa čuva podatke godinama. Algoritmi za optimizaciju kretanja glave kao što su elevator, ili preplitanje su potpuno irelevantni, jer je vrijeme pristupa jednako, bez obzira kojem se sektoru pristupa.

Dok kod hard diskova proces čitanja sektora otprilike jednako traje kao i pisanje, SSD diskovi imaju osjetno sporije pisanje, jer se prije upisa na SSD mora najprije obrisati njegov blok svi biti postavljeni na 1.

Kod hard diskova na vrijeme života utiče uglavnom mehaničko habanje, kod SSD diskova vrijeme života se mjeri se brojem ciklusa brisanja. Stoga drajveri u samom disku ili na operativnom sistemu, treba i da paze da je broj brisanja na svakom bloku uravnotežen da se uređaj ne pokvari prerano. Na primjer, datoteke povremeno prebacivati s jednog diska na drugi, a posebno pažnju obratiti da se ne fiksira datoteka koja realizuje virtuelnu memoriju na isto fizičko mjesto.

Pošto su magnetni diskovi su još uvijek jeftiniji, a SSD diskovi imaju daleko brže vrijeme pristupa, prave se i hibridni diskovi. Hibridni disk koristi mali SSD kao bafer za veći magnetni disk. Izmijenjeni blokovi unutar SSD diska se upisuju na magnetni disk na bazi vremena koliko su dugo na SSD dijelu diska i kada se najavljuje gašenje sistema.

10.26 Upravljanje Swap prostoromVirtualna memorija koristi disk prostor kao proširenje glavne memorije. Ovaj

prostor se naziva Swap-prostor i može se čuvati u datotečnom prostoru ili biti na posebnoj disk particiji.

Prilikom pokretanja procesa treba unutar dattoeke za čuvanje stranica alovirati onoliko prostora koliko zauzima programski segment i segment podataka. Taj prostor treba osloboditi pri završetku procesa. Ako se koriste dijeljene stranice između više procesa, tada kernel koristi swap mape za praćenje upotrebe (koliko korisnika koristi tu stranicu) i samo umanjuje brojače upotrebe kada se proces završava.

Upravljanje Swap prostorom 275

10.27 Priključivanje diskovaDiskovima se pristupa na tri osnovna načina. Prvi način su diskovi priključeni na

računar i pristupa im se koristeći hardversku sabirnicu (npr., IDE, ATA, SATA, FireWire, USB, SCSI, FC– Fiber Channel). Kada operativni sistem želi da čita ili piše podatke na ovako priključenim diskovima, on izvršava uobičajene instrukcije za ulaz/izlaz kao što je out za U/I mapirane periferijske uređaje. Koje vrijednosti slati na koji port u kojem vremenskom trenutku zavisi od vrste diska.

Mrežni priključak omogućava da klijentski računar pristupa disku drugog računara koristeći RPC (poziv udaljene procedure) baziran protokol. Na klijentskom računaru izvršava se program za preusmjeravanje (redirector) koji kada očekuje pristup dijelu datoteke, zapakuje zahtjev u mrežni paket i pošalje ga programu na drugom računaru koji se zove server.

Server pronađe na svom lokalnom disku dio te datoteke i šalje ga nazad ili mijenja. Postoje posebni protokoli za ovu svrhu, kao što su NFS za Unix sisteme ili CIFS (ranije SMB) za Windows sisteme. Mrežno dijeljenje diskova omogućava da više korisnika na različitim računarima pristupa zajedničkim podacima, ali na svakom od njih mora postojati operativni sistem s realizovanim datotečnim sistemom.

Ukoliko je potrebno dijeljenje smještaja između više računara, ali da se podacima na takvim diskovima pristupa na nivou bloka, a ne da se oslanja na postojeći datotečni sistem, koristi se treći pristup, mreže za smještaj (storage networks). Riječ je o posebnim, autonomnim diskovima koji se priključuju na računarsku mrežu, a ne ugrađuju ni u jedan računar. Koristeći posebne adaptere, pristup mrežnom disku je sličan pristupu lokalnom disku. Ovakva konfiguracija se koristi kada se želi smanjiti


obim posla na administriranju pojedinačnih računara i datotečnih sistema na njima. Na primjer, ovako postaje moguće podići operativni sistem sa diska u mreži, pa se on ne mora instalirati na svaku radnu stanicu. Takođe, u slučaju kvara serverskog računara, drugi računar može preuzeti njegovu funkciju bez otvaranja računara i prebacivanja diska u njega.

10.28 Izmjenjivi medijiZa razliku od fiksnih diskova, izmjenjivi mediji zahtijevaju ljudsku intervenciju da

bi se pristupilo podacima. Podaci se nalaze na mediju koji se može izvaditi iz uređaja i tako postići praktično neograničen kapacitet i prebacivost između različitih računara. Mogu biti realizovani na četiri principa materijala: magnetni (trake, diskete, izmjenjivi tvrdi diskovi), papirni (optički prepoznatljiv tekst, bušene kartice i bušene trake), poluprovodnički (stikovi, SD kartice) i optički (CD, DVD)

Kada se ovi mediji koriste za pisanje, operativni sistem treba paziti da korisnik može da ih iskopča iz računara kada to poželi. Većina modernih operativnih sistema ne upisuje podatke odmah na diskove, nego ih čuva u memoriji, a zatim primjenjuje neki od algoritama za pristup disku kada je procesor manje opterećen. Ako se podaci namijenjeni izlazu nisu na vrijeme upisali, nego na primjer čuvali u baferima, podaci će biti izgubljeni kada se medij izvadi. Stoga, operativni sistem treba na izmjenjive medije da piše podatke što prije moguće. Ako to ne može biti slučaj, jer bi to drastično usporilo operativni sistem, treba tražiti od korisnika da najavi vađenje izmjenjivog uređaja (demontiranje ili bezbjedno uklanjanje) .

10.29 Magnetni izmjenjivi mediji Magnetne trake se koriste kao jeftini medij velikog kapaciteta. Dva tipa ovog

medija su koturasti (koji se koristi na mainframe računarima) i kertridž (traka je u kaseti poput standarda QUIC, DAT, VHS). Na današnjim kertridžima postižu se kapaciteti od više terabajta. Pristup podacima je isključivo sekvencijalni, pri čemu neki formati na isto mjesto na magnetnoj traci smiještaju jedan bit ili po devet bita istovremeno.

Magnetni izmjenjivi mediji 277

Drugi izmjenjivi magnetni medij je flopi disk. Sve do oko 1998. godine bili su dominantni izmjenjivi medij na personalnim računarima. Zbog malog kapaciteta (varirao od 75K do 240 M) na današnjim personalnim računarima se rijetko ugrađuju, a jedina preostala namjena im je za podizanje operativnog sistema u situaciji kada to nije moguće uraditi s drugog uređaja zbog nedostatka drajvera. Flopi diskovi su se proizvodili u raznim veličinama, mjerenim u inčima: 2, 2.5, 3, 3.5, 5.25 i 8”. Jedna ili dvije glave diska upisuju podatke koristeći modifikovanu frekventnu modulaciju. Ovo kodiranje se bazira na kombinacijama jačeg (s) i slabijeg (w) magnetnog fluksa. Na taj način, binarno 1 se kodira kao WS , dok se binarno 0 kodira na jedan od dva načina: kao SW (ako je prethodni bit bio 0) ili kao WW (ako je prethodni bit bio 1)


10.30 Optički mediji CD, CDROM, DVDCD je inicijalno dizajnizan za čuvanje

digitalizovane muzike i zamijenio je analognu gramofonsku ploču. Kasnije je upotrijebljen i u računarima za čuvanje podataka koji se ne mijenjaju. Za razliku od tvrdih diskova, on nije podijeljen na staze i sektore, nego se sektori redaju sekvencijalno u jednu spiralu, pri čemu je njihova veličina 2352 bajta. Obični CD se priprema tako što laser buši rupe na master disku pravljenom od specijalnog stakla. Kalup je napravljen sa zaprekama gdje su rupe. Smola izlivena unutra ima isti uzorak rupe kao stakleni disk. Na vrh smole se stavi aluminijum. Rupice (udubljenja) i ravnine (neizgorenog područje) su raspoređeni u spiralama. Laser se koristi za čitanje rupica i ravnina i pretvori ih u bitove (0 i 1).

Pošto je na malu površinu nabijeno puno podataka, potrebno jepoboljšati mogućnost korekcije grešaka na CD. Svaki bajt (8 bita) u se na ovom disku čuva kao 14 bitni simbol sa 6 bita za korekciju greške. 42 simbola čine okvir, a grupa od 98 okvira čini CD-ROM sektor. Na kraju svakog sektora se nalazi dodatni kod za ispravljanje grešaka, a na njegovom početku preambula za prepoznavanje početka sektora.

Početni trošak pravljenja CD-a je visok zbog potrebe za pravljenjem master CD-a, ali su kasniji štampani CD-ovi relativno jeftini. Za pravljenje manjih serija, pogodniji su upisivi CD. Mogu se praviti s jednim ili više upisivanja. Prilikom upisa laser spaljuje tačke na sloju iznad reflektivnog zlatnog ili aluminijskog sloja. Pri kasnijem čitanju laserski zrak se reflektuje samo na nezatamnjenim mjestima i tako se razlikuju 0 i 1.

Optički mediji CD, CDROM, DVD 279

DVD ima isti dizajn kao CD sa poboljšanjima. Inicijalno je namijenjen za čuvanje digitalizovanih filmova. Veći kapacitet u odnosu na CD postignut je manjim rupama, užom spiralom i upotrebom crvenog lasera. Izrađuje se u četiri varijante: jednostrani - jednoslojni (4.7 GB), jednostrani - dvoslojni (8.5 GB), dvostrani – jednoslojni (9.4 GB) i dvostrani - dvoslojni

Prelaskom na još manje rupe, širinu spirale i laser ljubičaste svjetlosti, pojavio se optički uređaj s još većim kapacitetom. To je Blu Ray. Na jedan ovakav disk staje normalno 25 gigabajta, a kada se koriste četiri sloja, kapacitet raste sve do 128 gigabajta.

10.31 USB uređajiUSB je uveden kao standard za priključivanje širokog broja uređaja uz vrlo mali

broj žica. Konkretno koriste se samo četiri žice, napajanje, uzemljenje, napon signala i negirani napon signala. Prijemnik oduzme napon i negirani napon signala čime se eliminišu šumovi u signalu.

Podaci se prenose serijski u paketima, standardizovanim brzinama (Slow speed, 1.5Mbps, Full Speed 12Mbps ili i brže). Podržano mnogo uređaja, svaki sa svojom internom adresom (miševi, tastature, diskovi). Paketi se šalju redoslijedom prvo najmanje značajan bajt i grupišu se u okvire. Mogu se sastojati od sljedećih polja

1. Sync polje: služi za sinhronizaciju brzina između uređaja koji koriste USB protokol. Njegova zadnja dva bita određuju gdje PID polje počinje

2. PID polje određuje vrstu paketa koji se šalje. Vrsta paketa se odnosi na to da li je paket namijenjen uspostavljanju veze, prenosu podataka, početku okvira

3. ADDR polje određuje uređaj za koga je namijenjen paket. Kako je polje 7 bitno, može se imati u USB mreži do 127 uređaja.

4. ENDP polje određuje oznaku veze prema odredišnom uređaju, može ih biti do 16

5. CRC polje sadrži kontrolnu provjeru paketa6. EOP polje predstavlja kraj paketaU okviru ovih paketa se mogu nalaziti podaci namijenjeni bilo kojem uređaju. Za

uređaje masovne memorije koristi se unutar ovih paketa protokol sličan komunikaciji s SCSI diskovima. Tehnološki preko USB se priključuju stikovi (diskovi na bazi Flash memorij) , tvrdi diskovi, flopi ili optički diskovi.


10.32 Windows i Posix API za disk kao fizički uređajKada je potrebno pristupiti fizičkim sektorima diskova pod Windows ili Linux

mogu se također koristiti sistemski pozivi kao što su read pod Linux ili ReadFile pod Windows. Imena uređaja kojima se pristupa u ovim sistemima su na primjer

\\.\PhysicalDrive0 (Fizički disk 0, Windows)/dev/fd0 (Fizički prvi flopi disk, Linux) /dev/cdrom (CD ROM, Linux)/dev/sda1 (Prva particija prvog SCSI diska, Linux)/dev/hda (Cijeli prvi IDE disk, ranije verzije Linux)

Datotečni sistemi 281

11 Datotečni sistemi 11.1 Zadaci i problemi razvoja datotečnog sistema

Gotovo sve računarske aplikacije imaju potrebu da smještaju i izdaju podatke. Dok se proces izvršava, unutar adresnog prostora je moguće smjestiti ograničen skup informacija. To znači da je smještajni kapacitet ograničen na veličinu virtuelnog adressnog prostora. Za neke aplikacije ova veličina je dovoljna dok za neke dati prostor nije dovoljan (kao na primjer, sistem za rezervaciju avionskih karata, bankarske aplikacije kao i vođenje zapisa za velike firme).

Drugi problem, kod čuvanja podataka unutar adresnog prostora, je njihov nestanak ukoliko proces završi izvođenje. Za mnoge aplikacije, recimo za baze podataka, informacije se moraju održavati duži vremenski period. Nestanak podataka nakon završetka procesa je neprihvatljiv pogotovo ako dođe do nasilnog završetka aplikacije.

Treći problem predstavlja potreba da višestruki procesi pristupe dijelovima podataka u isto vrijeme. Ako je, recimo telefonski imenik, smješten unutar adresnog prostora procesa tada samo taj proces može mu pristupiti. Način da se razrješi problem je da se podaci načine nezavisnim od bilo kojeg procesa.

Dakle, postoje tri suštinska zahtjeva za dugoročno čuvanje podataka:1. Mora se biti u stanju smjestiti veliki skup podataka.2. Podaci moraju preživjeti nasilni prekid procesa koji ih koristi.3. Višestruki procesi moraju biti u stanju da pristupe informacijama konkurentnoUobičajeno rješenje svih navedenih problema predstavlja smiještanje podataka

na disk ili druge eksterne medije u organizovane smještajne jedinice koje se zovu datoteke. Tada ih procesi mogu čitati ili pisati u njih. Podaci smješteni u datoteke moraju biti stalni i ne smiju zavisiti od toga da li će se process završiti i kako će se završiti. Datoteka se može pobrisati samo ako je njen vlasnik pobriše.

Datotekama upravlja operativni sistem. Glavne teme u projektovanju operativnog sistema predstavljaju:

1. Organizacija smještajnog prostora,2. Imenovanje datoteka,3. Načini pristupa4. Načini korišćenja5. Zaštita datoteka6. Implementacija.Dio operativnog sistema koji se bavi poslovima vezanim za datotke se

naziva datotečni sistem.Sa korisničke tačke gledišta, najvažnije karakteristike datotečnog

sistema predstavljaju: kako se predstavljaju korisnicima, šta čini datoteku, kako se datoteke imenuju i štite, koje operacije su dozvoljene nad datoteka i sl. Za korisnika su manje važni detalji koji se odnose na povezane liste ili bitmape, koje se koriste za vođenje evidencije o slobodnom smještajnom prostoru, i koliko fizičkih sektora

282 Datotečni sistemi

se nalazi u logičkom sektoru. Međutim, ovi podaci su izezetno važni za projektante operativnih sistema.

11.2 DatotekeU ovom djelu posmatraćemo datoteke sa korisničke tačke gledišta a to su:

kako se koriste i koje karakteristike imaju.

11.3 Imenovanje datotekaDatoteke predstavljaju apstraktne mehanizme koji obezbjeđuju način smještanja

podataka na disk i njihovog kasnijeg čitanja. Ona mora zaštititi korisnika od informacija koje se odnose na detalje gdje su smješteni podaci i kako se to radi.

Vjerovatno najvažnija karakteristika apstraktnih mehanizama je način upravljanja sa tim mehanizmom odnosno njegovo imenovanje. Znači, govorimo o imenovanu datoteka pri čemu ime predstavlja ime objekta nad kojim radimo. Kada proces napravi datoteku on joj daje ime. Kada process završi svoje izvođenje, datoteka ostane pod tim imenom da postoji na disku i može joj pristupiti drugi proces koristeći to ime.

Pravila za imenovanje datoteke su različita od sistema do sistema, ali svi operativni sistemi dozvoljavaju niz od 1 do 8 znakova kao važeće ime datoteke. Često su cifre i specijalni znaci dozvoljeni da se kombinuju da slovima. Mnogi sistemi dozvoljavaju da dužina imena datoteke bude do 255 znakova. Neki sistemi razlikuju mala i velika slova (kao u UNIX-u) dok drugi ne (kao u MS-DOS-u). Mnogi datotečni sistemi podržavaju imena datoteka sa dva dijela međusobno odvojena tačkom, racimo prog.c. Dio koji se nalazi iza tačke se naziva nastavak i obično ukazuje na tip datoteke ( u ovom slučaju kaže da datoteka predstavlja izvorni kod napisan u C jeziku). Nastavak je fiksan u MS-DOS-u i iznosi 3 znaka dok kod Unix-a može postojati više nastavaka (prog.c.bz2, gdje bz2 označava da je datoteka prog.c komprimovana). U tabeli ispod, dati su neki uobičajeni nastavci datoteke.

Neki tipični nastavci datoteke

Nastavak Značenjefile.bak Backup datotekafile.c izvorni program u C-ufile.gif Slika u formatu gif (engl. Graphical Interchange Format)file.html World Wide Web HyperText Markup Language documentfile.iso ISO image CD-ROM-a (za zapis na CD)file.jpg Slika kodirana u skladu sa JPEG standardomfile.mp3 Muzička datoteka kodirana u MPEG layer 3 audio formatufile.mpg Film kodiran sa MPEG standardomfile.o Objektna datoteka (izlaz iz kompajlera)file.pdf Datoteka tipa „Portable Document Formatfile.ps Datoteka tipa „PostScript

Imenovanje datoteka 283

file.tex Datoteka kao ulaz za „TEX formatting program“file.txt Tekst datotekafile.zip Komprimirana arhiva

11.4 Datotečni atributiSvaka datoteka ima ime i svoje podatke predstavljene sadržajem. Kao dodatak

ovome, operativni system dodaje nove informacije svakoj datoteci koje mu služe da bi sa njima kvalitetnije upravljalo datotekom a to su: datum i vrijeme kreiranja datoteke, veličina datoteke i sl. Ove dodatne parametre zvaćemo atr ibu t i m a d a t ot e k e mada ih neki nazivaju i meta podacima. Lista atributa značajno varira od sistema do sistema. U tabeli ispod prikazane su samo neki od atributa ali treba znati da se tu mogu dodati i oni koji su određenim projektantima potrebni.

Atributi ZnačenjeZaštita Ko može pristupati datoteci i na koji načinLozinka Lozinka s kojom se pristupa datoteciKreator ID lica koji je kreirao datotekuVlasnik Tekući vlasnikRead-only flag 0 za read/write; 1 za “read only”Hidden flag 0 za obične; 1 akose ne želi prikazivati u listing-uSystem flag 0 za obične datoteke; 1 za sistemske datotekeArchive flag 0 za backup datoteke; 1 za potrebu da se backup-iraASCII/binary flag 0 za ASCII datoteke; 1 za binarne datotekeRandom access flag 0 samo za seq pristup; 1 za slučajan pristupTemporary flag 0 za obične dat.; 1 za brisanje datoteke kad process završiLock flags 0 za otključavanje; <>0 za zaključavanjeRecord length Broj bajta u sloguKey position Pomjeraj ključa unutar svakog slogaKey length Broj bajta u polju ključaCreation time Datum i vrijeme kreiranja datotekeTime of last access Datum i vrijeme posljednjeg pristupa datotekiTime of last change Datum i vrijeme posljednje promjene datotekeCurrent size Broj bajta u datoteciMaximum size Broj bajta u datoteci može rasti do “Maximum size”


Prva četiri atributa se odnose na zaštitu datoteke i govore ko može pristupiti datoteki. Zastavice predstavljaju bite koji služe za upravljanje ili omogućivanje nekih akcija, Na primjer, datoteke koje su označene kao sakrivene se ne izlistavaju. Zastavica arhiviranja nam govori da li je datoteka backup-irana. Backup program čisti bit a operativni system ga postavlja kod promjene datoteke. Na ovaj način, backup program zna koje datoteke treba backup-irati. Zastavica koja označava privremenu datoteku omogućuju automatsko brisanje datoteke nakon završetka procesa koji ju je kreirao.

Polja dužine sloga, pozicija ključa i dužine ključa, su prisutna samo u onim datotekama u kojima je moguće pretraživanje pomoću ključa. Ona obezbjeđuju informacije potrebne za pronalaženje ključeva.

Različita vremena služe da ukažu na vrijeme kreiranja datoteke, posljednjeg modifikovanja i posljednjeg pristupa datotekama. Ona su korisna za različite svrhe. Na primjer, ako je izvorna datoteka modifikovana poslije kreiranja objektne datoteke daje nam informaciju da je treba ponovno kompajlirati (make program).

Veličina datoteke govori koliko je velika tekuća datoteka. U nekim starijim operativnim sistemima bila je potrebna maksimalna veličina datoteke da se upiše kod kreiranja nove datoteke u cilju da operativni system rezerviše unaprijed maksimalnu iznos smještajnog prostora za datoteku unaprijed. Moderni operativni sistem su dovoljno «pametni» da mogu raditi bez ove vrijednosti.

11.5 Struktura datotekeDatoteke mogu biti struktuirane na jedan od nekoliko načina. Uobičajeni

načini su prikazani na slici. Datoteka, na slici a, predstavljena je sa nestruktuiranim nizom bajta. U ovom slučaju, operativni sistem ne zna ili ne brine o sadržaju unutar datoteke, koji u suštini predstavlja samo niz bajta. Neko značenje ovih bajta se koristi od strane nekih korisničkih programa a ne od operativnog sistema.

Prvi korak u struktuiranju datoteka je prikazan na slici b. U ovom modelu, datoteka predstavlja niz slogova fiksne veličine, od koji svaki ima svoju internu strukturu. Osnovna ideja ovakve strukture podataka je da operacija čitanja vraća jedan slog i da operacija pisanja prepisuje ili dodaje jedan slog (primjer, čitanje programa sa 80 kolonski kartica i štampanje istih na štamač sa širinom od 132

Struktura datoteke 285

znaka). Ovakav pogled na datoteke je primijenjen u operativnim sistemima poput Michigan Terminal System, Pick Operating System.

Treća vrsta struktuiranja datoteke je prikazana na slici .c. U ovoj organizaciji, datoteka se sastoji od slogova organizovanih u drvo pri čemu nisu svi iste dužine i svaki sadrži polje ključa na fiksnoj poziciji u slogu. Primjer je datotečni sistem IBM VSAM na operativnom sistemu z/VSE. Drvo je sortirano po polju ključa da dozvoli brzo pretraživanje po pojedinačnom polju ključa. Osnovna operacija, ovdje prestavlja čitanje “sljedećeg” sloga mada je moguće čitati i slog sa navedenim ključem. Na slici c, može se tražiti od sistema da se pročita slog čiji je ključ “pony”, bez brige o poziciji sloga u datoteci. Pored toga, novi slog može biti dodan u datoteku od strane operativnog sistema a ne korisnika. Operativni sistem odlučuje gdje da stavi slog i kako da ga poveže da bi se mogao pronači sa ključem. Ovi tipovi datoteka su sasvim različiti od nestruktuiranih tipova datoteka korišćenih kod Unix-a i Windows 98 operativnih sistema, i koriste se na mainframe računarima u nekim komercijalnim aplikacijama.

11.6 Tipovi datotekaMnogi operativni sistemi podržavaju nekoliko tipova datoteka. UNIX i Widows,

na primjer, imaju obične datoteke (engl. regular files, u daljem tekstu datoteka) i direktorije. UNIX ima i specijalne datoteke tipa karakter i blok. Widows XP koristi metadata datoteke. Datoteke su one koje sadrže korisničke informacije.

Direktoriji su sistemske datoteke koje služe za održavanje struktura datotečnog sistema. O njima ćemo govoriti kasnije. Specijalne datoteke tipa karater su povezane na ulaz / izlaz i koriste se za seriske U/I uređaje takve kao što su terminali, štampači i mreže. Specijalne datoteke tipa blok se koriste za ulazno izlazne operacije sa blok orijentisanim uređajima ( disk i sl). U ovom dijelu primarno ćemo se baviti običnim datotekama.

Obične datoteke su ili ASCII datoteke ili binarne datoteke. ASCII datoteke se sastoje od linija teksta ( na nekim sistemima terminator je CR dok kod nekih drugi je LF, Windows koristi oba). Linije ne moraju biti iste veličine. Binarne datoteke predstavljaju biz bajta i nisu pogodne za štampanje. Obično su to izvršne datoteke koje služe za formiranje procesa.


Na slici gore može se vidjeti struktura izvršne datoteke definisana još u ranim verzijama UNIX-a. Mada je, tehnički, datoteka niz bajta, operativni system će izvršti samo datoteku koja ima odgovarajući format. Sastoji se od 5 sekcija: zaglavlje datoteke, tekst sekcija – predstavlja „kod“ programa, data sekcija koja predstavlja statičke podatke, relokacioni biti potrebni za izračunavanje fizičke adrese i tabela simbola. Zaglavlje datoteke sadrži magični broj koji identificira izvršnu datoteku (da bi spriječio izvršavanje datoteka koje nisu iz tog sistema). Zatim dolazi veličine raznih djelova datoteke (gore spomenutih sekcija), adresa početka izvršavanja i neki biti koji označavaju zastavice. Iza zaglavlja datoteke se nalaze djelovi datoteke koji se zovu “text” sekcija i “data “ sekcija. Kada se ovi pune u memoriju, relokacioni biti se koriste da bi se formirala fizička adresa. Tabela simbola se koristi za debugg-iranje.

Drugi primjer binarne datoteke predstavlja arhiva. Sastoji se od skupa bibliotetskih procedura (modula) koji su kompilirani ali nisu povezani. Svaki od njih ima zaglavlje u kome se nalazi ime modula, datum kreiranja, vlasnik, zaštitni biti i veličina. Kao i kod izvršnih datoteka, zaglavlje modula predstavljeno je binarnim brijevima.

11.7 Pristup datotekamaRani operativni sistemi su obezbjeđivali samo jednu vrstu pristupa datotekama,

tzv. sekvencijani pristup. U ovim sistemima, proces je mogao pročitati sve bajte ili slogove u redosljedu počinjući od početka. Nije bilo dozvoljeno čitanje od neke pozicije niti preskakanje određenog broja slogova. Jedino se moglo pozicionirati na početak datoteke. Ovaj pristup je bio veoma pogodan za magnetne trake a ne disk.

Pristup datotekama 287

Kod diska se vršio zapis datoteka kod koje su se mogli čitati ili pisati slogovi izvan nekog redosljeda, kažemo mogli smo pristupati slogovima sa ključem a ne njegovom pozicijom. Datoteke, čiji bajti ili slogovi se mogu čitati u bio kojem redosljedu se nazivaju datoteke sa slučajnim pristupom (engl. random access files).

Multimedijalne datoteke, tj. datoteke s filmom i zvukom su u osnovi datoteke s sekvencijalnim pristupom. Filmovi su kodirani na način da se jedan za drugim navode elementi slike trenutnog kadra i zvučni elementi.

Datoteke sa direktnim pristupom su važni za mnoge aplikacije, na primjer sisteme baza podataka. Ako kupac pozove sistem za rezervaciju karata za određeni avion, program mora biti u mogućnosti da pristupi slogovima za taj let bez potrebe da čita podatke od početka za sve druge letove aviona.

Dvije metode se koriste da bi se navelo gdje da se počne sa čitanjem. U prvoj metodi, svaka operacija čitanja daje poziciju u datoteci da bi počeo čitanje. U drugoj metodi, posebna operacija, nazvana “seek”, se koristi da se izvrši postavljanje na tekuću poziciju. Poslije izvršavanje seek operacije, datoteka može biti čitana i sekvencijalno od date tekuće pozicije ( ovo je veoma često u upotrebi kod sortiranih datoteka). U modernim operativnim sistemima ne pravi se razlika između ovih datoteka i sve datoteke se kreiraju kao datoteke sa slučajnim pristupom

Indeksna organizacija datoteka se zasniva na posebnom području (indeks) u kome se čuvaju pokazivači na pojedini dio datoteke prema navedenom ključu. Ovakve datoteke se koriste u bazama podataka jer se odlikuju brzom mogućnosti pretrage.


11.8 Datotečne operacijeDatoteke postoje da bi se u njih trajno smjestili podaci i kasnije koristili. Različiti

datotečni sistemi obezbjeđuju različit skup operacija koje omogućuju smiještanje i izdavanje podataka. U nastavku je prikazana većina sistemskih poziva koji se koriste za rad sa datotekama.

Kreiranje, «Create» : ovim sistemskom pozivom se vrši kreiranje datoteke bez podataka. Svrha sistemskog poziva je da se nova datoteka kreira i da joj se postave određeni atributi.

Brisanje, «Delete»: Kada datoteka nije više potrebna, treba da se pobriše da bi oslobodila diskovni prostor. Sistemski poziv za ove svrhe postoji.

Otvaranje datoteke, «open»: Prije korišćenja datoteke, proces je mora otvoriti. Svrha sistemskog poziva «open» je da dozvoli sistemu da preuzme atribute datoteke kao i listu diskovnih adresa u memoriju radi bržeg pristupa kod kasnijih poziva.

Zatvaranje datoteke, «close»: Kada je završeno sa svim pristupima datoteci, kada atributi datoteke kao i diskovne adrese više nisu potrebne, vrši se zatvaranje datoteke kako bi se oslobodio prostor u memoriji za neke nove datoteke koje mogu trebati. Mnogi sistemi imaju parametar koji se zove maksimalni broj otvorenih datoteka po procesu. Podaci se pišu u blokovima i zatvaranje datoteke forsira operativni sistem da upiše blokove koji se još nalaze u memoriji.

Čitaj, «Read»: Podaci se čitaju iz datoteke. Obično, čitaju se bajti od tekuće pozicije u datoteci. Pozivaoc mora navesti koliko je podataka potrebno pročitati kao i spremnik u koje će ih upisati.

Piši, «Write»: Podaci se pišu u datoteku, obično na tekuću poziciju. Ako je tekuća pozicija kraj datoteke, onda se povećava veličina datoteke. Ako je pozicija u sredini datoteke, postojeći podaci se prepisuju i gube zauvijek.

Dodavanje (operacija “append”): ovaj sistemski poziv predstavlja ograničeni oblik operacija “write”. Sa njim se podaci samo dodaju na kraj datoteke. Datotečni sistemi koji obezbjeđuju minimalan skup sistemskih poziva, nemaju operaciju “append”, dok neki drugi sistemi koji imaju višestruke načine izvršavanja sličnih operacija, imaju operaciju “append”.

Pozicioniranje (operacija seek): kod operacija sa slučajnim pristupom, potreban je sistemski poziv kojim se pozicioniramo na podatke koje treba čitati. Uobičajeni pristup je sistemski poziv “seek” kojim se datotečni pokazivač pozicionira na specifično mjesto u datoteci. Kada se ovaj sistemski poziv završi, onda se podaci mogu čitati sa te pozicije ili pisati na tu poziciju.

Preuzmi atribute: procesi često treba da čitaju datotečne atribute da bi ih koristili u svom poslu. Na primjer, UNIX-ov make program često se koristi za upravljanje razvojem softverskih projekata koji se sastoji od više datoteka. Kada se pokrene make program, on ispituje vremena modifikacije datoteka svih izvornih i objektnih datoteka i dolazi do saznanja koji minimalni skup datoteka je potrebno prevesti da bi se došlo do cilja (da bude sve kako treba ažurirano). Na bi ovo uradilo,

Datotečne operacije 289

potrebno je imati atribute datoteka i koristiti atribut koji se zove vrijeme modifikacije.

Postavi attribute: Neke atribute može postaviti korisnik i mogu se promjeniti poslije kreiranja datoteke. Ovaj sistemski poziv vam omogućava takve intervencije. Jedan upečatljiv primjer predstavlja zaštita datoteke. Većina zastavica, takođe, spada u ovu kategoriju.

Reimenovanje (operacija «rename»): kada korsinik želi da promjeni ime datoteke, koristi se ovaj sistemski poziv. Može se izvesti sa kopiranjem datoteke u novu datoteku sa željenim imenom i brisanje stare datoteke. Međutim, ova operacija nekada može biti veoma duga, čak i neizvodljiva, dok je operacija reimenovanja brza operacija i izvodi se samo nad imenom datoteke.

Zaključavanje, «Lock»: zaključavanje datoteke ili dijela datoteke predstavlja spriječavanje višestrukih procesa da pristupe simultano datoteci ili dijelu datoteke. Kod sistema za rezervaciju karata za avion, zaključavanje baze podataka sprečava rezervaciju karata za dva različita korisnika u isto vrijeme.

•

11.9 Datotečni deskriptorVećina operativnih sistema (Unix, Windows, MS DOS), pa i korisnički programi

pisani u jeziku C bez obzira u kojem operativnom sistemu su pokrenuti se referenciraju na otvorenu datoteku koristeći jedan cjelobrojni ili pointerski identifikator datoteke, koji se zove datotečni deskriptor (fd). On je uveden umjesto stalnog prosljeđivanja sistemskim pozivima imena datoteke iz dva razloga. Jedan razlog je u brzini samog sistemskog poziva, jer je manje zahtjevno proslijediti jedan cijeli broj nego, npr 30 znakova imena. Drugi razlog je što je mnogim programima potrebno otvoriti istu datoteku više puta istovremeno, na primjer prilikom njenog sortiranja j praktično se kretati kroz datoteku s dva različita pokazivača.

Korisnički program prilikom početka rada s datotekon pozove npr. sistemski poziv open(ime_datoteke, način). Način može biti r, rw, w, ..., zavisno od toga da li je u pitanju čitanje, čitanje i pisanje, pisanje itd. Operativni sistem provjerava da li takva datoteka postoji, i ako je sve u redu, rezultat ove funkcije je datotečni deskriptor fd. Korisnički proces treba da korisiti deskriptor za sve buduće operacije nad datotekom, na primjer read(fd, buff,num) ili write(fd, buff,num). Kada proces završi sa tom datotekom, on poziva operaciju close(fd) da izvrši zatvaranje datoteke.

Sa strane operativnog sistema, datotečni sistem održava jednu internu strukturu za svaku otvorenu datoteku, t.j., za svaki važeći datotečni deskriptor. U toj internoj strukturi se čuva trenutna pozicija u datoteci, njeno ime, a ako novokreirani procesi nasljeđuju i otvorene datoteke, čuva se i podatak koliko procesa drži tu datoteku otvorenom na ovoj poziciji. Ova se struktura kreira prilikom otvaranja datoteke i briše se kod zatvaranja close). Datotečni deskriptor, zavisno od implementacije, je pokazivač na ovu strukturu, indeks u tabeli otvorenih datoteka ili totalno nevezani podatak. Više struktura koje predstavljaju otvorene datoteke se spajaju u tabelu


otvorenih datoteka (engl. Open file table) koje predstavljaju sistemsku listu datotečnih deskriptora u upotrebi.

11.10 Operacije nad datotekom -C funkcije

• fopen() Kreiranje datoteke• fwrite() Piši u datoteku – implicitno napreduje datotečni pokazivač• fread() Čitaj datoteku – implicitno napreduje datotečni pokazivač• lseek() Repozicioniranje u datoteci

11.11 Windows API datotečni sistem

• CopyFile(lpExistingFileName,lpNewFileName,FailIfExists) Kopira datoteku• CloseHandle( hObject) Zatvara otvoreni objekt (npr. Datoteku)• CreateDirectory(lpPathName,lpSecurityAttributes) Kreira direktorij• CreateFile(lpFileName,dwDesiredAccess,dwShareMode,lpSecurityAttributes

,dwCreationDisposition,dwFlagsAndAttributes,hTemplateFile) Kreira ili otvara datoteku

• DeleteFile(lpFileName) Briše datoteku• FindClose(hFindFile) Završava pretragu datoteka• FindFirstFile(lpFileName, lpFindFileData) Traži prvu datoteku• FindNextFile(lpFileName, lpFindFileData) Traži sljedeću datoteku• FlushFileBuffers(hfile) Forsira upis bafera• GetDiskFreeSpace(lpRootPathName,lpSectorsPerCluster,lpBytesPerSector,lp

NumberOfFreeClusters,lpTotalNumberOfClusters) Očitava slobodan prostor i druge informacije o strukturi datoteka

• GetFileAttributes(lpFileName) Čita atribute datoteke

Windows API datotečni sistem 291

• GetFileInformationByHandle(hFile,lpFileInformation) Uzima informaciju o datoteci

• GetFileSize( hFile,lpFileSizeHigh) Dobavlja veličinu datoteke• GetTempFileName(lpPathName,lpPrefixString,uUnique,lpTempFileName)

Sastavlja ime privremene datoteke• GetTempPath(nBufferLength,lpBuffer) Vraća ime direktorija za privremene

datoteke• LockFileEx(hFile,dwFlags,dwReserved,nNumberOfBytesToLockLow,nNum

berOfBytesToLockHigh,lpOverlapped) Zaključava dio datoteke od istovremenog pristupa

• MoveFile(lpExistingFileName,lpNewFileName) Premješta datoteku• ReadFile(hFile,lpBuffer,nNumberOfBytesToRead,lpNumberOfBytesRead,lp

Overlapped) Čita datoteku• RemoveDirectory(lpPathName) Briše datoteku• SetEndOfFile(hFile) Postavlja kraj datoteke• SetFileAttributes(lpFileName,dwFileAttributes) Postavlja atribute datoteke• SetFilePointer(hFile,lDistanceToMove,lpDistanceToMoveHigh,dwMoveMet

hod) Postavlja trenutnu poziciju u datoteci• UnlockFileEx(hFile,dwReserved,nNumberOfBytesToUnlockLow,nNumberO

fBytesToUnlockHigh,lpOverlapped) Otključava dio datoteke• WriteFile(hFile,lpBuffer,nNumberOfBytesToWrite,lpNumberOfBytesWritten

,lpOverlapped) Piše podatke u datoteku

11.12 POSIX API DATOTEČNI SISTEM• getcwd(pBuf, iSize); očitaj trenutni direktorij• mkdir(pPathname, iMode); kreira direktori• rmdir(pPathname); briše direktorij• chdir(const char *path); mijenja renutni direktorij• link(pOldpath, pNewpath); još jedno ime datoteke• unlink(const char *pathname); ukloni dodatno ime a možda i datoteku• rename(pOldpath, pNewpath) promijeni ime ili lokaciju datoteke• stat(pFile_name, pBuf); provjeri status datoteke• chmod(pPath, iMode); Promijeni prava datoteke• chown(iPath, owner, group); Promijeni vlasništvo datpteke• utime(pFilename, pBuf); Promijeni vremena datoteke• opendir(pName); otvori direktorij• readdir(DIR *dir); čitaj element datoteke• closedir(DIR *dir); zatvori direktorij• rewinddir(DIR *dir) reset direktorijskog prikaza• access(pPathname, iMode); Provjeri prava nad datotekom• open(pPathname, iFlags);


• creat(pPathname, iMode); otvori i eventualno kreiraj datoteku• close(fd); zatvori datoteku• read(fd, pBuf, iCount); Čitanje datoteke• write(fd, pBuf, iCount);i pisanje• fcntl(fd, iCmd); upravljaj deksriptorom• fstat(fd, pBuf); datotečni status• lseek(fd, iOffset, iWhence); pozicija datoteke• dup( oldfd);• dup2(oldfd, newfd); duplicira deskriptor datoteke• pipe(int filedes[2]); kreira cijev• mkfifo (pPathname, mode ); kreira imenovanu cijev• umask(mask); maske za kreiranje• *fdopen (fd, pMode); povezivanje toka s deskriptorom• fileno( FILE *stream); deskriptor toka

POSIX API DATOTEČNI SISTEM 293

11.13 Primjer pristupa datotekama s Unix sistemskim pozivima/* File copy program. Error checking and reporting is minimal. *//* “myfilecopy oldfile newfile” will copy the contents of “oldfile” to “newfile” *//* The program will read blocks of 4K from the “oldfile” to a buffer, and store them to “newfile” sequentially */

#include <sys/types.h> /* include necessary header files */#include <fcntl.h>#include <stdlib.h>#include <unistd.h>

int main(int argc, char *argv[]); /* ANSI prototype */#define BUF_SIZE 4096 /* use a buffer size of 4096 bytes */#define OUTPUT_MODE 0700 /* protection bits for output file */int main(int argc, char *argv[]){ int in_fd, out_fd, rd_count, wt_count; char buffer[BUF_SIZE]; if (argc != 3) exit(1); /* error if argc is not 3 */

/* Open the input file and create the output file */ in_fd = open(argv[1], O_RDONLY); /* open the source file */ if (in_fd < 0) exit(2); /* if it cannot be opened, exit */ out_fd = creat(argv[2], OUTPUT_MODE); /* create the destination file */ if (out_fd < 0) exit(3); /* if it cannot be created, exit *//* Copy loop */while (TRUE) { rd_count = read(in_fd, buffer, BUF_SIZE); /* read a block of data */ if (rd_count <= 0) break; /* if end of file or error, exit loop */ wt_count = write(out _fd, buffer, rd_count); /* write data */ if (wt_count <= 0) exit(4); /* wt_count <= 0 is an error */}/* Close the files */close(in_fd);close(out_fd);if (rd_count == 0) /* no error on last read */ exit(0);else exit(5); /* error on last read */}


11.14 DirektorijiDa bi vodili evidenciju o datotekama, datotečni sistem ima direktorije (ili foldere,

ili mape) koji u mnogim sistemima sami predstavljaju datoteke. U ovom dijelu, pozabavićemo se direktorijima, njihovom organizacijom, njihovim karakteristikama i operacijama koje se izvršavaju nad njima.

11.15 Jednostavan direktorijDirektorij tipično sadrži jedan broj elemenata, po jedan za svaku datoteku.

Jedna mogućnost je prikazana na slici a ) u kojem svaki element sadrži ime datoteke, datotečne atribute i diskovne adrese smještenih podataka. Druga mogućnost je prikazana na slici b gdje jedan element direktorija sadrži ime datoteke i pokazivač na drugu strukturu podataka gdje se mogu naći atributi datoteke i diskovne adrese. Oba ova sistema se koriste.

(a) atributi u elementu direktorija. (b) atributi izvan elementa direktorija.

Kada se zatraži otvoranje datoteke, operativni sistem pretražuje odgovarajući direktorij sve dok ne nađe njeno ime. On tada vadi atribute datoteka kao i diskovne adrese iz elementa direktorija, kao pod a, ili iz strukture podataka na koju pokazuje polje u elementu direktorija, vidi pod b, i stavlja ih u tabelu u glavnu memoriju. Sve sljedeće reference na datoteku koriste informacije zapisane u glavnoj memoriji.

Broj direktorija varira od sistema do sistema. Najednostavniji oblik direktorija je jedan direktorij koji sadrži sve datoteke za sve korisnike, kao što je to pokazano na slici ispod. Kod ranih personalnih računara to je bila uobičajena praksa, jer je postojao samo jedan korisnik. Ovakva organizacija direktorija je primijenjena npr u Apple DOS.

Jednostavan direktorij 295

Problemi sa jednim direktorijem u sistemu sa više korisnika je da različiti korisnici mogu slučajno dovesti do brisanja datoteka. Na primjer, kada korisnik A kreira datoteku mailbox a kasnije korisnik B kreira istu datoteku, doći će do brisanja datoteke mailbox korisnika A.

11.16 Jedan direktorij po korisnikuDa bi izbjegli ovakva ponašanja, sljedeći korak bio je da se svakom

korisniku da direktorij u okviru koga može kreirati svoje datoteke. Na ovaj način imena izabrana od strane jednog korisnika ne utiču na imena koja je izabrao drugi korisnik. Ovaj pristup je prikazan na slici b. Ovakav pristup bi se mogao koristiti na računaru sa više korisnika ili jednostavnoj mreži personalnih računara koji koriste djeljeni datotečni server kroz lokalnu mrežu. Pristup je korišten na operativnom sistemu CP/M.

Kod projektovanja ovakvog sistema, kada korisnik pokuša da otvori datoteku, operativni sistem zna koji je to korisnik i za njega zna koji direktorij da pretražuje. Kao posljedica ovog, korisnici se trebaju prijaviti na sistem sa imenom i lozinkom i na taj način se pridružuje određeni direktorij kao prostor u kome korisnik može da formira svoje datoteke

11.17 Hijerarhijski sistem direktorijaHijerarhija u dva nivoa eliminiše konflikt između korisnika. Pojavljuje se

drugi problem, kada jedan korisnik ima veliki broj datoteke koje nije moguće lako organizovati unutar jednog (čitaj svog) direktorija. Pojavljuje se potreba grupisanja datoteka u manje grupe, recimo, profesor želi da studentske domaće zadaće grupiše u jedan direktorij a predavanja da čuva u drugom direktoriju. Za ovakav pristup je potrebno imati hijerarhijsku strukturu direktorija, koju nekada nazivamo i strukturom drveta. Kod ovog pristupa, svaki korisnik može imati direktorija koliko mu treba tako da datoteke može grupisati na prirodniji način. Ovaj pristup je prikazan na slici


11.18 Aciklični grafNeki datotečni sistemi dopuštaju da se datoteka istovremeno nalazi u više

direktorija. U Unix sistemima ovo se postiže komandom ln. Ovakav model pruža najviše mogućnosti, ali i stvara određene poteškoće prilikom pravljenja rezervnih kopija sistema., jer se mora evidentirati da li je datoteka već bila kopirana.

11.19 Čuvanje i pretraživanje direktorijaDirektoriji se mogu čuvati u datotečnom sistemu na isti način kao datoteke, samo

imaju specijalne atributima. Alternativno, mogu se nalaziti u potpuno odvojenom području datotečnog sistema (CP/M)

Unix: Smješteni kao obične datoteke ali sa definisanom strukturom. Njihov sadržaj je tipa <broj indeksnog čvora, ime datoteke > Imena se završavaju sa “\0”, indeksni čvorovi se koriste za pretraživanje meta informacija o datotekama, i za lokaciju samog sadržaja datoteke.

Jedna datoteka se može pojaviti u više direktorijaDatoteka koja predstavlja direktorij može svoje elemente (opise datoteka)

organizovati na više načina• Koristeći linearni niz ili listu što omogućava brzo dodavanje, ali spoua pretraga

kod velikih direktorija (FAT)• Koristeći B* stabla čime je brza pretraga uz komplikovano ažuriranje(NTFS,

Mac HFS),• Preko hash tabela gdje se pozicija u tabeli se računa iz imena, što omogućava

brzo nalaženje jedne datoteke, ali ne i datoteka s džoker znakovima (Ext2FS)•

Dijeljene datoteke 297

11.20 Dijeljene datotekeDatotečni sistemi koji imaju strukturu acikličnog grafa direktorija omogućavaju

dijeljene datoteke između direktorija. Na slici prikazan je datotečni sistem sa jednom od C datoteka sada predstavljenih u B direktoriju.

Datotečni sistem koji sadrži djeljene datoteke

Kod Unix-a, korišćenje indeksnih čvorova za smiještanje datotečnih atributa čini djeljenje datoteka jednostavnijim. Bilo koji broj u elementu direktorija može pokazivati na jedan indeskni čvor. Indeksni čvor sadrži polje koje se inkrementira kada se nova veza na istu datoteku dodaje i dekrementira kada se izbriše. Samo kada taj brojač dostigne nulu, tada se označava da je datoteka i njen indeskni čvor pobrisani. Ova veza se ponekad zove i č vrst o m ve z o m . Djeljene datoteke koja koristi čvrste veze nije uvijek moguće. Glavno ograničenje je da su direktoriji i indeksni čvorovi strukture podataka jednog datotečnog sistema (čitaj, u okviru jedne particije), tako da direktorij iz jednog datotečnog sistema ne može pokazivati na indeksni čvor drugog datotečnog sistema. Takođe, datoteka može imati jednog vlasnika i jedan skup prava pristupa. Ako vlasnik djeljene datoteke izbriše svoju sopstveni element direktorija za datoteku, drugi korisnik bi mogao imati problem da pobriše datoteku jer nema prava pristupa.

Alternativni način za djeljenje datoteka predstavlja kreiranje nove vrste datoteke čiji sadržaj predstavlja puno ime datoteke. Ova vrsta datoteke treba da radi kroz datotečne sisteme koji se mogu mount-irati (različiti datotečni sistemi). U stvari ako je ime datoteke takvo da se sa njim može stići na drugi računar, tada to označava takvu vrstu datoteka. Ova vrsta veze na datoteku se naziva s i m b o l ič ka v e z a u Unix-u, shortcut u Windows-u, i alias u Apple's Mac OS. Simboličke veze se mogu koristiti na sistemima gdje su atributi smješteni u elementu direktorija. Mane simboličkih veza su kada se datoteka pobriše ili čak i reimenuje, veza na datoteku postane nevažeća.

Opšti graf direktorija


Neki datotečni sistemi nemaju nikakva ograničenja na pripadnost datoteka direktorijima. Direktorij može pokazivati i na druge direktorije, koji su u hijerarhiji inače iznad njega. Neki Linux datotečni sistemi, npr. UnionFS koriste ovu mogućnost kod operativnih sistema koji se pokreću s CD-a. Ovaj pristup je najfleksibilniji, ali i najopasniji, jer bi postupak brisanja svih datoteka u poddirektoriju mogao potencijalno uništiti sve datoteke u datotečnom sistemu.

11.21 Imena staza datotekaKada je datotečni sistem organizovan kao drvo ili aciklični graf, potrebno je iznaći

način kako da se označe datoteke koje se nalaze u različitim direktorijima. U ove svrhe koriste se dva razrličita pristupa. Kod prvog pristupa, svakoj datoteki se pridružuje ime staze od korjenskog direktorija. Na primjer, staza /usr/ast/mailbox znači da korjenski direktorij sadrži direktorij usr/, a ovaj sadrži direktorij ast/ koji sadrži datoteku mailbox. Ovakva imena staza se nazivaju apsolutnim i ona počinju uvijek od jedinstvenog korjenskog direktorija pa su na taj način i imena staza jedinstvena. U UNIX-u se korjenski direktorij označava sa «/» znakom. U Windows-u separator se označava znakom \. Dakle, ista staza u dva sistema će izgledati ovako:

Windows \usr\ast\mailboxUNIX /usr/ast/mailboxBez obzira koji se karakter koristi, ako je prvi karakter, imena staze, separator,

onda je staza apsolutna. Pored apsolutnog imena staze postoji i relativno ime staze. Ona se koristi u vezi sa radnim direktorijem koji se još zove i tekući direktorij. Na taj način, ako je radni direktorij /usr/ast onda datoteka sa apsolutnim imenom staze je

/usr/ast/mailbox može biti prikazana samo kao mailbox jer se nalazi u radnom direktoriju. Drugim rječima, Unix-ovom komadom

cp /usr/ast/mailbox /usr/ast/mailbox.bak i komandom

Imena staza datoteka 299

cp mailbox mailbox.bakradimo istu operaciju ako je radni direktorij /usr/ast/. Relativna staza je

često pogodnija i radi isto što i apsolutna staza.Većina operativnih sistema koji podržavaju sistem hijerarhijskih direktorija imaju

dva posebna elementa, a to su «.» i «..». Tačka je ime za tekući direktorij dok se .. odnosi na direktorij roditelj. Da vidimo kako se ovo koristi pogledajmo na sliku 5.7. Neki proces ima svoj radni direktorij /usr/ast. On može koristiti .. da prsitupi direktoriju iznad. Na primjer, on može kopirati datoteku /usr/lib/dictionary u svoj direktorij komandom cp ../lib/dictionary .

11.22 Operacija nad direktorijimaSistemski pozivi za rad sa direktorijima prikazuju znatne varijacije od

sistema do sistema. Da bi ih objasnili, uzećemo primjer iz Unix-a.Kreiraj direktorij, «create»: ovim sistemskim programom se kreira

prazan direktorij, mada sadrži dva elementa, ona koji se odnose na pojmove . i .. Kreira se komandom mkdir.

Pobriši direktorij, «delete»: ovim sistemskim pozivom se briše direktorij i samo prazan direktorij može biti obrisan. Direktorij koji sadrži samo . i .. smatra se praznim. Pojedinačno elementi . i .. se ne mogu pobrisati jer služe u sistemske svrhe. Otvori direktorij: Direktorij se može čitati. Na primjer, da bi izlistali sadržaj direktorija, program za listanje direktorija mora otvoriti direktorij za čitanje, analogno otvaranju datoteke.

Zatvori direktorij: Kada se završi pisanje direktorija, on mora biti zatvoren da bi se oslobodio prostor u internim tabelama.

Citaj direktorij: ovaj poziv vraća sljedeći element u otvorenom direktoriju.Reimenuj direktorij: s obzirom da su direktoriji kao datoteke, oni mogu biti

reimenovani.


Link: ovim pozivom dozvoljavamo da se jedna datoteka pojavljuje u više od jednog direktorija. U sistemskom pozivu se navodi postojeća datoteka i staza, i kreira se veza od postojeće datoteke u ime navedeno u stazi. Na ovaj način, ista datoteka se može pojaviti u višestrukim direktorijima. Ovakva veza, koja inkrementira brojač datoteka jednog indeksnog čvora ( a cilj joj je da vodi evidenciju o broju ulaza u datoteku) se ponekad naziva i čvrstom vezom (engl. hard link).

Raskini vezu (engl. unlink). Brisanje elementa direktorija. Ako se ovom komandom briše datoteka koja postoji samo u jednom direktoriju, onda se datoteka uklanja iz datotečnog sistema. Ako se datoteka nalazi u više direktorija onda se uklanja veza na koju pokazuje i smanjuje se referentni brojač na indeksnom čvoru datoteke. Gornji sistemski pozivi predstavljaju skup važnijih poziva, ali postoje i neki drugi, kao na primjer, za upravljanje informacijama zaštite a pridružena su direktoriju.

11.23 Implementacija datotečnog sistemaSada je vrijeme da pre]emo sa korisničkog pogleda na datotečni sistem na

pogled projektananta datotečnih sistema. Korisnici brinu o tome kako da daju imenima datoteka i koje operacije da primjene nad njima i kako da im izgleda struktura direktorija. Oni koji implementiraju datotečni sistem, brinu o načinu smještanja datoteka i direktorija, kako upravljaju diskovnim smještajnim prostorom i kako da naprave da sve radi pouzdani i efikasno. U sljedećem dijelu pozabavićemo se ovim pitanjima.

11.24 Organizacija datotečnog sistemaDatotečni sistemi se obično smještaju na disk. Većina diskova su podjeljena

u particije pri čemu na svakoj particiji može da postoji nezavistan datotečni sistem. Prvi sektor na disku se naziva MBR (engl. master boot record) i koristi se za svrhe operacija punjenja operativnog sistema (engl. booting). Na kraju MBR se nalazi tabela particija. Ova tabela daje početnu i krajnju adresu svake particije. Jedna od particija u tabelu može biti označena kao aktivna. Kod punjenja operativnig sistema, BIOS čita prvi sektor, koji predstavlja MBR, i izvršava kod koji se nalazi u MBR-u. Prva stvar koju program u MBR-u treba da uradi je da pronađe aktivnu particiju, pročita njen prvi blok, koji se naziva boot blok i počne izvršavati program u njemu. Program u boot bloku puni operativni sistem koji je sadržan u toj particiji. Radi uniformnosti, svaka particija počinje sa boot blokom čak i kad nema na sebi operativni sistem. Međutim, možda će particija u budućnosti imati operativni sistem pa nije loša ideja da se taj blok zadrži.

Gornji opis mora biti tačan, bez obzira koji operativni sistem se koristi za bilo koju hardversku platformu na kojoj BIOS može pokrenuti više od jednog operativnog sistema. Može biti razlika u terminologiji kod različitih operativnih sistema, na primjer, MBR se ponekad naziva i IPL (engl. Initial Program Loader), dok Volume Boot Code predstavlja kod u MBR-u.

Organizacija datotečnog sistema 301

Kada je BIOS napunio MBR ili boot sektor akcije mogu biti različite. Na BIOS se može računati samo da napuni jedan blok akutomatski, a onda boot program će obezbjediti punjenje dodatnih blokova ako je potrebno (prisjetimo se projektong zadatke 1 gdje u boot programu punimo 2 bloka po 512Bajta da bi mogao u njih stati naš boot program i c program koji predstavlja neki budući komandni interpreter).

Na PC kompatibilnim računarima ne može biti više od 4 primarne particije jer ne postoji više praznog prostora u tabeli (ona se nalazi između MBR program i kraja bloka veličine 512 bajta). Neki operativni sistemi dozvoljavaju da jedan element particione tabele bude tkz. extended particija koja ukazuje na povezanu listu logičkih particija. Na ovaj način moguće je da imamo bilo koji broj dodatnih particija. BIOS ne može pokrenuti operativni sistem sa logičke particije, tako da se zahtjeva od inicijalnog koda iz primarne particije da napuni kod kojim bi se moglo upravljati logičkim particijama.

Evidencija o particijama se vodi u tabeli particija koja se nalazi u MBR-u na adresi 0x1BE. Svaki element tabele particija ima strukturu prikazanu ispod.

Struct partition { unsigned char boot_ind;/* 0x80 – aktivna unsigned char head;/* početna glava unsigned char sector;/* početni sektor unsigned char cyl;/* početni cilidar unsigned char sys_ind;/* koji tip particije unsigned char end_head;/* zadnje glava unsigned char end_sector;/* zadnji sektor unsigned char end_cyl;/* zadnji cilidar unsigned short start_sectlo;/* početna pozicija sektora od 0 unsigned short start_secthi;/* početni sektor se broji od 0 unsigned short nr_sectslo;/* broj sektora u particiji unsigned short nr_sectshi;/* broj sektora u particiji}

Dodatna extended particija se koristi u MINIX 3, koja dozvoljava particiji da sadrži dodatne tabele za particije. Prednost ovakvog pristupa da kod koji radi sa tabelama primarnih particija može raditi i sa dodatnim tabelama za particije, a koje imaju istu strukturu. Moguća upotreba podparticija je da se imaju različite particije za korjenski direktorij, za swaping, za sistemske biblioteke, za korisničke datoteke.

Nisu svi diskovi podjeljeni na particije. Disketa obično počinje sa boot blokom u prvom sektoru. BIOS čita prvi sektor diska i gleda koji je magični broj. On identificira važeći kod i na taj način spriječava da pokuša izvršiti kod koji nije odgovarajući. MBR i boot blok koriste isti magični broj tako da kod mora biti isti jer je vezan za isti datotečni sistem.

Osim što svi diskovi počinju sa boot blokom, organizacija datotečnog sistema varira značajno od jednog do drugog datotečnog sistema. Unix-ova organizacija datotečnog sistema, koji je smješten u particiju, bi se mogao prikazati kao na slici. Prvi je boot blok. Zatim dolazi super blok. On sadrži sve ključne parametre o


datotečnom sistemu i u cijelosti se drži u memoriji poslije punjenja operativnog sistema ili poslije prvog pristupa datotečnom sistemu.

Mogući raspored datotečnog sistema.

Sljedeće polje predstavlja informacije o slobodnim blokovima u datotečnom sistemu. Iza njega se nalazi skup indeksnih čvorova, niz struktura podataka, od kojih je jedan vezan za jednu datoteku i govori sve o toj datoteci, i gdje je smještena i sve njene atribute. Poslije toga dolazi prostor za korjenski direktorij koji sadrži datoteke i direktorije definisane na najvišem nivou datotečnog sistema. Na kraju se nalazi prazan prostor koji služi za definisanje svih ostalih datoteka i direktorija. Sljedeći primjer čita sadržaj jednog super bloka.struct SUPER{ushort nodesNum; //ukupan br. indexnih cvorova ushort zoneNum; //ukupan br. zonaushort imap; //br. blokova bit mape indexne cvorove ushort zmap; //br. blokova bit mape zonaushort dataZ; //short log2BZ; //Ignorisi ovo poljelong fileSize; //maksimalna velicina int magic; //Magicni broj};void citaj_superblok(){char buf[BLOCK_SIZE];struct SUPER *sp;get_block(1, buf); napuni u bafer blok broj 1 - superblok sp=(struct SUPER *)buf;printf("Inodes:%d\nZona:%d\nImap blok:%d\nZmap blok:%d\n\1. blok podataka:%d\nLog2(vel.bloka/vel.zone):%d\nMax. file: %d\n\ Magic:0x%X\n\n",sp->nodesNum, sp->zoneNum, sp->imap, sp->zmap, sp->dataZ, sp->log2BZ, sp->fileSize, sp->magic);}

11.25 Implementacija datotekaVjerovatno najvažnije pitanje u implementaciji smještajnog prostora za

datoteke je vođenje evidencije o blokovima koji pripadaju datoteci. Različite

Implementacija datoteka 303

metode se koriste u različitim operativnim sistemima. U ovom dijelu razmotrićemo neke od njih.

11.26 Implementacija direktorijaPrije nego što se datoteka pročita, ona mora biti otvorena. Kada se datoteka otvori,

operativni sistem koristi ime staze koju je obezbjedio korisnik da bi pronašao element direktorija koji se odnosi na tu datoteku. Nalaženje direktorija znači da smo pronašli prvo korjenski direktorij. Korjenski direktorij je na fiksnoj poziciji u odnosu napočetak particije, mada se ova pozicija može odrediti i pomoću nekih drugih podataka, recimo superbloka, koji sadrži informaciju o veličini sistemske strukture podataka koja prethodi djelu sa podacima. Iz superbloka lokacija indeksnog čvora može biti nađena. Prvi indeskni čvor će pokazivati na početak korjenskog direktorija koji je kreiran kada je Unix formirao datotečni sistem na disku. Kod Windows XP-a, informacije u boot sektoru (koji je znatno veći od jednog sektora) pokazuje na MFT pomoću koga lociramo ostale dijelove datotetečnog sistema.

Kada se pronađe korjenski direktorij, pretraživanjem drveta direktorija se nalazi željeni element direktorija. Element direktorija sadrži informacije potrebne da se pronađu diskovni blokovi. U zavisnosti od datotečnog sistema, informacije mogu biti diskovna adresa cijele datoteke ( kao kod kontinualne alokacije), broj prvog bloka datoteke ( za sheme ulančanih lista) ili jedan broj koji predstavlja broj indeksnog čvora (za alokaciju sa indeksnim čvorom). U svim slučajevima, osnovna funkcija elementa direktorija je da uspostavi vezu između imena datoteke sa njegovim infomacijama potrebnim da se pronađu podaci datoteka na disku.

Gdje su smješteni atributi datoteke? Svaki datotečni sistem održava atribute datoteke, takve kao što su: vlasnik datoteke, vremena kreiranja, posljednji pristip i modifikacija datoteke. Jedna očigledna mogućnost je da se smjesti u element direktorija. U najednostavnijem slučaju, direktorij se sastoji od elemenata fiksne veličine, po jedan po datoteki, koji sadrže ime datoteke fiksne veličine i strukturu atributa datoteke i jednu ili više diskovnih adresa koje govore gdje su diskovni blokovi datoteke smješteni.

Za sisteme koji koriste indeksne čvorove, druga mogućnost je smiještanje atributa datoteke u indeksni čvor umjesto u element direktorija. U ovom slučaju element direktorija može biti znatno kraći, samo ime datoteke i broj indeksnog čvora.

11.27 Kontinualna alokacija datotekaNajednostavnija alokaciona šema je smiještanje svake datoteke u niz

susjednih diskovnih blokova. Dakle, na disku sa 1 KB blokovima, 50 KB datoteka će alocirati 50 susjednih diskovnih blokova. Alokacija kontinualnog diskovnog prostora ima dvije značajne prednosti. Prva, jednostavna je za implementaciju jer vođenje evidencije o smještenim blokovima se redukuje na zapisivanje samo dva


broja: diskovna adresa prvog bloka datoteke i broj blokova u datoteki. Pomoću broja prvog bloka u datoteci, jednostavnim operacijama se može doći na adresu željenog bloka.

Druga prednost predstavlja performanse kod čitanja koje su izuzetno dobre jer cijela datoteka može biti pročitana u samo jednoj operaciji čitanja. Pri čitanju je potrebna samo jedna seek operacija kojom se pozicioniramo na prvi blok. Poslije toga nema gubljenja vremena ni na rotaciono kašnjenje niti na dodatne operacije pozicioniranja na sektore (čitaj seek operacije), tako da se podaci iz datoteke mogu prenositi maksimalnom propusnošću koja je definisana za neki disk. Dakle ova kontinualna alokacija je jednostavna za implementaciju i ima visoke performanse.

Nažalost, kontinualna alokacija ima i svoje nedostatke: u toku rada disk postane fragmentisan, i sastoji se od datoteka i šupljina na disku. U početku, ova alokaciona tehnika ne predstavlja problem jer se datoteke uvijek pišu na kraju diska ( na početku praznog prostora za disk). Međutim, poslije punjenje diska i brisanja datoteka dolazimo u situaciju kada veliki procenat diska nije iskorišćen a neka veća datoteka se ne može zapisati. U tom slučaju se pribjegava kompakciji diska ali je ta operacija veoma duga i nepoželjna. Na takvom disku, slobodni prostor se održava sa listom šupljina i kada je potrebno dodati novu datoteku, potrebno je proći kroz listu i naći pogodan dio šupljine na disku gdje bi se mogao smjestiti sadržaj datoteke.

Mada ova tehnika ima mana ona se opet aktuelizirala sa pojavom CD i DVD uređaja na kojima se koristi ova alokaciona tehnika, ponajviše zbog njenih performasi jer se sadržaj datoteke veoma brzo čita.

11.28 ISO 9960 FSKao primjer datotečnog sistema s kontinualnom alokacijom opisaće se ovaj

sistem koji se koristi na CD ROM uređajima. CD je svakako uređaj kod koga proširivanje veličine datoteke nije moguće, pa prednosti kontinualne alokacije u brzini pristupa daleko premašuju eventualne mane. CD-ROM se sastoji od više staza (track) od kojih svaka može imati različit datotečni sistem, pa i miješati datotečne sisteme namijenjene za čuvanje datoteka i one za audio zapise.

Zapis u formatu ISO 9960 se sastoji od sektora velikih 2352 bajta, od kojih su 2048 namijenjeni za podatke, a ostatak su zaglavlja i korekcija grešaka. Početni dio od 16 sektora se ne koristi,

ISO 9960 FS 305

kontinualna alokacija. Zatim slijede deskriptori sadržaja, veliki po jedan sektor. Od njih je najvažniji deskriptor primarnog sadržaja (tip 1) koji sadrži podatke o veličini logičkih blokova, autorskim pravima na CD, verziji datotečnog sistema, datumu i vremenu kreiranja CD-a itd. Jedan od deskriptora (tip 0) može sadržati boot program. Posljednji deskriptor koji se navodi je terminator skupa deskriptora (tip 255). U deskriptoru primarnog sadržaja se nalaze i podaci o lokaciji sadržaja direktorija.

Svaki element direktorija ima strukturu kao na slici. Prva dva polja definišu veličinu elementa direktorija i veličinu dodatnih atributa. Zanimljivo je da se podaci o lokaciji datoteke i njenoj veličini na CD-u čuvaju i u Big Endian i u Little Endian formatu. Nakon toga se u odvojenim bajtima čuvaju dan, mjesec, godina, sat, minuta, sekunda i vremenska zona kreiranja datoteke. Zatim slijedi indikator bajt čiji pojedini bitovi govore da li je datoteka skrivena, koristi dodatne atribute ili je zadnja datoteka u direktoriju. Polje preplitanja omogućava da se kontinualna alokacija zamijeni ekstentnom koja se sastoji od više kontinualnih dijelova. Naredno polje omogućava da se navede oznaka CD-a kome pripada data datoteka (ako nije na istom CD-u). Na samom kraju je ime datoteke sa dužinom ispred imena i oznakom verzije iza tačka/zareza.

11.29 Alokacija datoteka ulančanim listamaDruga metoda za smiještanje datoteka se izvodi vođenjem evidencije za

njene diskovne blokove koristeći ulančanu listu, kao što je to prikazano na slici Prva riječ svakog bloka se koristi kao pokazivač na sljedeći blok.

U odnosu na kontinualnu alokaciju, u ovoj alokacionoj tehnici se može koristiti svaki blok na disku i na taj način nema gubitka diskovnog prostora zbog fragmentacije diska izuzev interne fragmentacije koja se javlja u zadnjem bloku


svake datoteke. Dovoljno je da u elementu direktorija smjestite samo diskovnu adresu početnog bloka a da se ostalim blokovima može prići koristeći listu. Pristup datotekama se obavlja sekvencijalno, a u slučaju da pristupamo datoteci random, pristup je izuzetno spor jer je potrebno pročitati sve blokove ispred da bi se došlo na željeni blok.

Kod ove alokacione tehnike, veličina bloka nije više jednaka stepenu broja 2 jer na početku ima pokazivač koji pokazuje na sljedeći blok. Rad sa ovakvim blokovima je manje efikasan jer je potrebno uložiti dodatni, interni, rad kako bi se, recimo, dva bloka koristila a de se eliminišu pokazivači (možda je potrebno izvršiti i kopiranje što utiče na performanse programa koji koristi takve blokove podataka).

Primjer ovakve alokacije je na Commodore 64: Na 18. traci diskete je direktorij s imenima datoteka i početnom trakom i sektorom svakog programa, a na početku svakog sektora je pokazivač na narednu traku i sektor (2 bajta) + 254 bajta bloka

11.30 Alokacija sa ulančanim listama koje koriste memoriju

Obje mane alokacione tehnike sa ulančanim listama mogu se razrješiti uklanjanjem pokazivača iz svakog diskovnog bloka i premještanjem u memoriju. Na slici je prikazan mogući izgled tabele. Imamo dvije datoteke. Datoteka A koristi diskovne blokove u redosljedu 4,7,2,10 i 12, dok datoteka B koristi dsikovne blokove u redosljedu 6,3,11 i 14. Koristeći tabelu, možemo početi sa blokom 4, čiji sadržaj predstavlja index sljedećeg bloka koga treba koristiti, pa sve do kraja datoteke koja je označena specijalnim znakom,

Alokacija sa ulančanim listama koje koriste memoriju 307

recimo –1, kako je prikazano na slici. Ovakva tabela u memoriji se naziva FAT tabela (engl. File Allocation Table).

U ovoj organizaciji, random pristup datoteka je omogućen jer se diskovnom bloku može prići brzo s obzirom da se pretražuje tabela u memoriji, a ne čitanjem diskovnih blokova što uzrokuje sporost u pretraživanju. Kao u prethodnoj alokacionoj tehnici, dovoljno je imati pokazivač na prvi blok datoteke koji se drži u elementu direktorija bez obzira koliko velika datoteka može biti.

Osnovna mana, kod ove alokacione tehnike, je što cijela tabela mora biti u memoriji cijelo vrijeme. Kod 20 GB diskova i 1KB veličine bloka, tabela će imati 20 miliona elemenata za svaki od 20 miliona diskovnih blokova. Svaki element treba da ima minimalno 3 bajta. Radi brzine u izvršavanju ova veličina bi trebala biti jednaka 4 bajta. Dakle, tabela će biti velika 60 MB ili 80 MB glavne memorije cijelo vrijeme, u zavisnosti da li je sistem optimiziran za prostor (60MB) ili vrijeme pretraživanja (80MB). Razumljivo da bi se ovakva tabela mogla staviti u virtuelnu memoriju ali bi i tada zauzimala značajan dio virtuelne memoriji i povećala promet između glavne i virtuelne memorije. MS-DOS i Windows 98 koriste FAT datotečni sistem i kasnije Windows verzije ga podržavaju.

11.31 DOS/Windows FATOS čuva na disku dvije kopije ove tabele pokazivača (File Allocation Table)Elementi mogu biti 12 bitni, 16 bitni ili 32 bitni

FAT element direktorija


BYTE Name[8]; /* Ime datoteke, sa velikim slovima nadopunjen sa praznim znakovima */BYTE Extension[3]; /* Proširenje – velikim slovima. Nadopunjen sa znakom prazno. Ne postoji separator '.' . Separator se dodaje zbog čitljivosti kada se imena datoteka ispisuju */BYTE Attributes; /* Sadrži kod atributa */BYTE Reserved[10]; /* Reservisano za Windows NT. Postavljase na nulu kada se kreirajudatoteke/direktoriji.*/WORD Time; /* Vrijeme poslednjeg pisanja (recimo kreiranje datoteke/direktorija) */WORD Date; /* Datum poslednjeg pisanja */WORD startCluster; /* Pokazivač na prvi klaster datoteke*/DWORD fileSize; /* Veličina datoteke u bajtima. Kod modifikacije datoteke ovo polje treba ažurirati*/

Direktoriji na Windows 98.Datotečni sistem Windows 95 operativnog sistema bio je identičan

datotečnom sistemu MS-DOS-a. Tek poslije verzije 2, dodana je podrška za duga imena datoteka. Ovaj datotečni sistem se pojavio kod Windows 98 sistema mada je postojao u nekim verzijama Windows95 sistema. Postojala su dva tipa elementa direktorija u Windows 98 datotečnom sistemu. Zvaćemo ga osnovnim elementom i prikazan je na slici.

Osnovni element direktorija ima sve informacije koje su postojale u elementu direktorija starijih Windows sistema, i više od toga. Desest bajta koja počinju koristiti kod NT polja su dodana na starije verzije Windows 95 struktura, koje nisu ranije bila korišćena. Najvažnije poboljšanje polja je da povećava broj

diskovnih blokova kojima se može pristupiti sa 216

na 2 32

.Ova struktura obezbjeđuje ime u starom stilu, 8 + 3 znaka koje je povučeno od

DOS- a. Šta ćemo sa dugim imenima datoteka? Odgovor na ovaj problem je da se mora zadržati ova struktura zbog datoteka koje treba podržati dok za duga imena će se koristiti druga struktura elementa direktorija. Slika prikazuje alternativni oblik elementa direktorija koji može sadržati do 13 znakova dugog imena datoteke. Za datoteke sa dugim imenima generisalo se skraćeno ime automatski i smještalo u osnovno ime i polje proširenja kao na slici. Da bi se dobilo dugo ime potrebno je je bilo zapisati ga u strukturu datu na slici ispred osnovnog imena u obrnutom redosljedu. Polje atributa svakog elementa sa dugim imenom je sadržalo vrijednost 0x0f, koja je za prethodne sisteme nečitljiv i biće

DOS/Windows FAT 309

ignorisan ako se čita sa starim sistemima ( na disketi na primjer). Bit u polju sekvenca kaže sistemu koji je posljednji element.

Slika Jedan element (dio od) dugog imena datoteke u Windows 98.

Mada izgleda veoma kompleksno, potrebno je bilo obezbjediti kompatibilnost sa starim sistemima.

Kompromis između veličine klastera (512 bajta do 64 kilobajta) i veličine tabeleVeći kapacitet: veća interna fragmentacija

11.32 Indeksni čvorovi (engl. I-Nodes)Naša naredna tehnika kojom se vodi evidencija o diskovnim blokovima datoteke

se naziva alokacija diskovnog prostora pomoću indeksnih čvorova. Indeksni čvor predstavlja strukturu podataka pridruženu jednoj datoteci na disku. Ova struktura podataka se sastoji od atributa datoteke i pokazivača na blokove datoteke ili blokove sa diskovnim adresama, tkz. indeksne blokove. Velika prednost ove sheme u odnosu na ulančanu listu blokova datoteke u memoriji je da indeksni čvor treba da bude u memoriji samo kada se odgovarajuća datoteka otvori. Za svaki indeksni čvor koji zauzima n bajta i maksimalno je moguće otvoriti k datoteka, ukupan memorijski prostor koji je potrebno imati za odgovarajuće


indeksne čvorove jednak je n*k bajta. Samo ovoliki indeksni prostor treba rezervisati unaprijed. Prisjetite se prethodnog primjera sa 60 ili 80 GB sa 20GB disk.

Ovakav niz indeksnih čvorova je obično znatno manji nego tabela prikazana u prethodnoj alokacionoj tehnici (FAT pristup). Razlog je jednostavan. Tabela iz prethodnog primjera sadrži povezanu listu svih diskovnih blokova i proporcionalna je veličini diska (čitaj svih datoteka, i otvorenih i nekorišćenih). Ako disk ima n blokova, tabela treba n elemenata. Ako veličina diska raste, i broj elemenata u tabeli raste. Nasuprot tome, shema alokacije koja koristi indeksne čvorove treba jedan niz u memoriji čija je veličina proporcionalna maksimalnom broju datoteka koje mogu biti otvorene u jednom tenutku. To znači da nije važno da li je disk veliki 1 GB ili 10 GB ili 100 GB.

11.33 CP/M datotečni sistem Jedan od prvih operativnih sistema za mikroračunare, CP/M koristio je indeksne

čvorove s jednim nivoom. Tablica elemenata direktorija, pored imena datoteka i polja user code (koje predstalja redni broj direktorija) sadrži šesnaest pokazivača na blokove od po 128 bajta do 32K i brojač koji kaže koliko blokova je iskorišteno. Ako je datoteka duža od 16 blokova, ponavlja se isti element u direktorijskoj strukturi sa rednim brojem ekstenta. Ovakav datotečni sistem ima ozbiljna ograničenja na maksimalne veličine datoteka, ali je zadovoljavao za tadašnje kapacitete disketa.

11.34 Indeksni čvorovi s više nivoaJedan od problema kod indeksnih čvorova što ima fiksan broj direktnih

diskovnih adresa blokova. Šta će se desiti ako veličina datoteke zahtjeva dodatne diskovne adrese? Jedno od rješenja je da se rezerviše posljednja diskovna adresa za jedan blok koji sadrži dodatne diskovne adrese i često se zove indirektni blokom ili adresnim blokom. To znači da njegov sadržaj ne predstavlja podatke datoteke već adrese preko kojih se dolazi do blokova podataka. Njegov sadržaj predstavljaju direktne diskovne adrese koje predstavljaju direktne adrese koje se mogu naći u indeksnom čvoru (obično je 10 direktnih pokazivača i 11 pokazivač se nalazi u prvom indirektnom bloku). Ideja se može proširiti da se koriste duplo indirektni blokovi i trostruko indirektnim blokovima, kao što je prikazano na slici.

Indeksni čvorovi s više nivoa 311

11.35 Unix datotečni sistemPristup preko indeksnih čvorova na više nivoa primijenjen je u datotečnim

sistemima kod većine operativnih sistema nastalih od Unix sistema. Jedno područje diska sadrži indeksne čvorove, relarivno male veličine, po jedan za svaku datoteku. Unutar indeksnog čvora se ne čuva ime datoteke, ali se čuvaju podaci o njenoj veličini, vremenima kreiranja i pokazivačima na blokove. Zavisno od podvarijanti datotečnog sistema Zaglavlje datoteke sadrži više pokazivača na blokove podataka (npr 10), te pokazivače na jednostruko, dvostruko indirektne blokove i eventualno trostruko indirektne blokove (na primjer po jedan za svaki od njih). Neka je n broj pokazivača koji se mogu smjestiti u blok podataka. U ovom primjeru, za pristup blokovima između 0 i 9 njihovu poziciju čitamo iz direktnog pokazivača. Za pristup blokovima između 10 i 10+(n-1), njihove pozicije saznajemo iz pokazivača koji su smješteni u bloku na koji pokazuje jednostruko indirektni pokazivač. Za pristup blokovima između 10+n i 10+n+n2-1 najprije preko dvostruko indirektnog bloka pokazivača se nađe pokazivački blok prvog nivoa, u njemu pokazivački blok drugog nivoa, a iz pokazivačkog bloka drugog nivoa dođe do podataka. Za pristup podacima između bloka 10+n+n2 i 10+n+n2+n3-1 se koriste tri nivoa indirekcije.


Prema tome, u ovakvim datotečnim sistemima, gornja granica veličine datoteke je određena s dva faktora, zbog načina alokacije i veličine pokazivača, od kojih se uzima manji od njih. Ako je p veličina pokazivača, b veličina bloka, n=b/p broj pokazivača u bloku, D broj direktnih pokazivača u indeksnom čvoru, I broj indirektnih pokazivača u indeksnom čvoru, V broj dvostruko indirektnih pokazivača u indeksnom čvoru, T broj trostruko indirektnih pokazivača u indeksnom čvoru, maksimalna veličina datoteke zbog načina alokacije je M=b(D+In+Vn2+Tn3). Maksimalna veličina datoteke zbog veličine pokazivača je M=2pb .

Ovakav način alokacije datoteka se odlikuje dobrom skalabilnošću jer je zadovoljavajući i za male i za velike datoteke. Blokovi se alociraju dinamički i indirektni blokovi postoje samo za velike datoteke. Pristup malim datotekama je jako brz. Mana pristupa je što velike datoteke zahtjevaju puno pretraživanje da bi se pristupilo indirektnim blokovima

Jednom kada se nađe indeksni čvor, možete se pristupiti svim blokovima datoteke. Kako naći indeksni čvor? U nekim Unix sistemima indeksni čvor je u rezervisanom dijelu diska, pa se datotekama pristupa interno navodeći poziciju indeksa. Mana ovog pristupa je što indeksni čvor nije blizu podacima (i to zahtijeva kretanje glave diska) i što je broj indeksnih čvorova unaprijed određen u vrijeme formatiranja diska. U kasnijim verzijama kao što su Berkeley fast file system (FFS) ili Ext2 (linux) indeksni čvorovi su raspoređeni po disku na različitim mjestima, ali se njihova pozicija opet može izračunati iz njegovog broja.

Kako nalazimo broj indeksnog čvora za datoteku? On je naveden u strukturi datoteke koja predstavlja direktorij.

Unix datotečni sistem 313

Struktura direktorija u tradicionalnom Unix sistemu je izuzetno jednostavna i prikazana je na slici. Svaki element direktorija sadrži ime datoteke i broj indeksnog čvora vezanog za datu datoteku. Sve dodatne informacije o tipu, veličini, vremenima i vlasništvu kao i diskovnim blokovima sadržaja datoteke su sadržane u indeksnom čvoru. Neki Unix sistemi imaju drugačiji raspored datotečnog sistema, ali element direktorija je obavezno jednostavan i sastoji se samo od dva polja, imena datoteke i njenog broja indeksnog čvora.

Version 7 UNIX - element direktorija

Kada se datoteka otvori, datotečni sistem mora uzeti ime datoteke da bi pronašao njene blokove podataka. Pogledajmo u primjeru ispod, kako se pretražuje datoteka /usr/ast/mbox. Ovdje koristimo Unix kao primjer, ali je algoritam pretraživanje u osnovi isti za sve hijerarhijske datotečne sisteme. Prvo se locira korjenski direktorij. Indeksni čvorovi formiraju jednostavan niz koji se pretražuje na osnovu informacija koje se nalaze u superbloku. Prvi element u ovom nizu predstavlja indeksni čvor korjenskog direktorija.

Datotečni sistem pretražuje unutar bloka podataka korjenskog direktorija ime «usr» da bi našao, pored njega, njegov broj indeksnog čvora u ovom slučaju jednak je 6, vidi sliku . Zatim se pristupa indeksnom čvoru broj 6 (koji može biti u memoriji ili na disku) u okviru koga se na prvom mjestu direktnih pokazivača, nalazi pokazivač koji kaže da se sadržaj direktorija /usr nalazi u diskovnom bloku 132. Čitanje diskovnog bloka broj 132 dobijamo sadržaj direktorija /usr u kome pokušavamo da pronađemo direktorij /ast. Kada pronađemo direktorij ast čitamo njegov indeksni čvor u memoriju koji je jednak 26 i čitamo njegov sadržaj koji se nalazi na bloku broj 406. Na njega pokazuje prvi direktni pokazivač u indeksnom čvoru. Sadržaj bloka broj 406 predstavlja sadržaj direktorija /usr/ast i u njemu pretražujemo ime za datoteku mailbox sa indeksnim čvorom koji je jednak 81. Cijeli proces je prikazan na slici.


Koraci u pretraživanuju datoteke /usr/ast/mboxRelativna imena datoteke se pretražuju na isti način kao i apsolutna samo je

startna tačka pretraživanja radni direktorij umjesto korjenskog direktorija. Svaki direktorij ima . i .. koji se formiraju po kreiranju direktorija. Element . ima indeksni čvor tekućeg direktorija a .. indeksni čvor direktorija roditelja. Dakle procedura pretraživanja datoteke ../etf/prog.c jednostavno pretražuje u radnom direktoriju, nalazi broj indeksnog čvora direktorija roditelj. Zatim čita dati indeksni čvor u memoriju i preko njega stiže do sadržaja tog direktorija u kome pretražuje datoteku prog.c. Ne postoji poseban mehanizam za ovo pretraživanje. Imena su data u ASCII formatu.

Postoje određene konvencije za imena direktorija. /bin/ direktorij sadrži komande i alate koje koriste korisnici iz komandne školjke. /boot/ direktorij sadrži potrebne datoteke za podizanje sistema./dev/ direktorij sadrži virtualne datoteke koje predstavljaju periferijske uređaje

koji su prikopčani na sistem./etc/ direktorij sadrži konfiguracijske datoteke svega što se nalazi na tom

računaru. /home/ direktorij sadrži direktorije za korisničke podatke svakog korisnika na

sistemu pri čemu direktorij dobiva ime prema imenu korisnika, npr. /home/ana/. Sve datoteke koje kreira korisnik, kao i njegove konfiguracijske datoteke, se smještaju u ovaj direktorij.

/lib/ direktorij treba sadržavati samo one statičke i dinamičke biblioteke koji su potrebni za izvršavanje binarnih datoteka u direktorijima /bin/ i /sbin/.

/mnt/ direktorij sadrži privremeno montirane datotečne sisteme kao CD-ROM, Floppy uređaj ili neke druge particije.

/opt/ direktorij obezbjeđuje skladištenje velikih, statičkih aplikacijskih paketa. /proc/ direktorij sadrži specijalne virtuelne datoteke koji ili izvlače informacije ili

ih šalju jezgru./root/ direktorij je privatni direktorij sistemskog administratora./sbin/ direktorij sadrži izvršne datoteke koje koristi samo root korisnik (admin,

superuser)./tmp/ direktorij sadrži privremene (temporary) fajlove./usr/ direktorij sadrži datoteke kojima svatko u sistemu može pristupiti. Njegov

poddirektorij /usr/bin/ sadrži komande koje pokreću različite aplikativne programe, u direktoriju /usr/games se nalaze igre, u /usr/src izvorni kod programa, u /usr/local programi koji se instaliraju na neuobičajen način itd.

/var/ direktorij sadrži promjenjive ili variable datoteke. To su datoteke koje se stalno mijenjaju bez intervencije korisnika kao npr. log datoteke (/var/log/) ili printer spool datoteke (/var/spool/).

Ekstentna alokacija datoteka 315

11.36 Ekstentna alokacija datoteka Porastom kapaciteta diskova i potrebom za većim datotekama zbog predstavljanja

video sadržaja, uočava se nedostatak indeksne u odnosu na kontinualnu alokaciju. Pristup velikoj datoteci koristeći indeksne čvorove s tri nivoa, često zahtijeva čitanje četiri bloka da bi se pročitao jedan, dok se kod kontinualne alokacije tom bloku može direktno pristupiti. Stoga, neki datotečni sistemi kombinuju indeksnu alokaciju na jednom nivou i kontinualnu alokaciju. Umjesto da pokazivači indeksnog čvora pokazuju na blokove fiksne veličine, oni pokazuju na kontinualne blokove promjenjive veličine, koji se zovu ekstenti. Tako se u području indeksa čuva za svaki ekstent početni klaster i koliko klastera on zauzima. Na primjer, u području direktorija se uz datoteku može navesti sljedeća tabela, koja će značiti da ova datoteka zauzima klastere 12,13,100,101,102,103,104,105,1200,1201

Početni klaster Veličina12 2100 51200 2

Postojanje velikih kontinualnih blokova predstavlja malu fragmentaciju u smislu fizičke pozicije klastera. Mana ove alokacije je potencijalna eksterna fragmentacija kada disk postane skoro pun, pa se ne može pronaći dovoljno veliki kontinualni blok.

11.37 NTFSNTFS (engl. New Technology File System) je standardni Microsoft-ov

datotečni sistem. Ovdje će se prikazati kratak opis ovog sistema sa nekim od problema sa kojima se suočava kao i rješenja koja koristi.

NTFS je dizajniran za pouzdanost, sigurnost i podršku velikim uređajima. Skalabilnost je postignuta upotrebom generičnih struktura podataka koje se umotaju oko struktura podataka specifičnog sadržaja. Za razliku od većine datotečnih sistema u NTFS je sve datoteka (i bit mape, indeksi, direktorij) i može biti bilo gdje na disku. Samo boot sektor je na fiksnom mjestu i pokazuje na $MFT datoteku. Druga specifičnost je struktura same datoteke. Za rješenje mnogih problema pristup koji koristi NTFS predstavljen je sa više atributa. U Unixu, datoteka se predstavlja nizom bajta, dok je kod NTFS-, datoteka skup atributa i svaki atribut predstavlja niz bajta.

Najvažnija datoteka u NTFS-a je $MFT (engl. Master File Table) . U n jo j su opi sane os ta le da to teke , pr i čemu opi s svake zauzima po 1 KB u $MTF-u i sastoji se od zaglavlja (42 bajta) i atributa. Struktura zaglavl ja je pr ikazana na sl jedećoj sl ic i .


Šesnaest prvih datoteka u MFT su specijalne datoteke navedene u tabeli.Poz Ime Opis0 $MFT Sama MFT1 $MFTMirr Kopija prvih elemenata MFT2 $LogFile Žurnal koji prati izmjene metapodataka3 $Volume Informacije o disku4 $AttrDef Opisi svih atributa: indentifikatori, imena i veličine5 . Korijenski direktorij6 $Bitmap Alokacijski status svakog klastera7 $Boot Boot sektor8 $BadClus Klasteri s lošim sektorima9 $Secure Informacije o pravima nad datotekama10 $Upcase Verzija velikim slovima svakog Unicode znaka11 $Extend Direktorij s datotekama s opcionim proširenjima

Nakon zaglavlja MFT elementa preostalih 1024-42 bajta popunjavaju njegovi atributi. Svaki atribut ima dalje zaglavlje i sadržaj.

Zaglavlje atributa određuje njegov tip (numerički identifikator), veličinu i ime (Unicode UTF 16), flegove da li je kompresovan i šifrovan. Neki važniji atributi s navedenim identifikatorom su: $FILE_NAME (48) za ime datoteke, $BITMAP (176) za slobodne blokove, $DATA (128) sa sadržajem, $INDEX_ROOT (144) za opis direktorijske strukture, $INDEX_ALLOCATION (160) za elemente direktorijske strukture.

NTFS 317

Ako za opis neke datoteke nije dovoljno 1024 bajta, atribut unutar MFT-a može biti zaglavlje koje ukazuje na dodatnu datoteku čiji je nastavak tipa atributa. Ovakav oblik atributa je poznat pod nazivom nerezidentni atribut.

Tijelo atributa se može smjestiti u samu MFT datoteku ili biti eksterni atribut (pokazuje na klaster). Tijelo atributa može biti i sam sadržaj datoteke. Za kratke datoteke (do 700 bajta) podaci se mogu staviti i u sam MFT. Za duže datoteke, u zaglavlju $DATA (tip 128) atributa polje runlist pokazuje na listu ekstenta.

Kako se u opisu datoteke može nalaziti više $DATA atributa, NTFS datoteka može da ima više od jednog toka podataka. Višestruki tokovi podataka imaju svoju upotrebu, na primjer, velike grafičke slike mogu imati i male grafičke slike

smještene u istoj datoteci (engl. thumbnail). Tok podataka može sadržati do 264

bajta. Kada je $DATA atribut nerezidentni, on pokazuje na seriju kontinualnih blokova

memorije, pa se zato ovaj datotečni sistem ubraja u ekstentne sisteme, pri čemu se ovdje koristi terminologija data-run za svaki kontinualni niz sektora.

To važi i za samu $MFT. S obzirom na velike datoteke, odnosno velik porast datotečnog sistema, inicijalno se rezerviše 12,2% prostora na particiji za rast MFT-a. Dakle, on može rasti bez fragmentiranja sve dok se inicijalno pridružen prostor ne ispuni, poslije čega se rezerviše drugi veliki prostor. Dakle, ako MFT postane fragmentiran on će se satojati od malog broja vrlo velikih fragmenata.

Direktorijumska struktura organizovana je kao balansirano B stablo u atributima $INDEX_ROOT (rezidentni) i $INDEX_ALLOCATION (nerezidentni) koji sadrže $FILE_NAME atribute. Ovakva struktura omogućava brzo nalaženje datoteka i ta lista se automatski sortira pri dodavanju datoteke.

Samo smo pomenuli neke od načina kako NTFS radi sa problemima koji nisu vezani za stare i jednostavne datotečne sisteme. NTFS obezbjeđuje dodatne karakteristike kao što su: složeni sistem zaštite, ekripcija i kompresija podatka. Opisujući sve ove karakteristike i njihovu implementaciju bi zahtjevalo mnogo više prostora nego što ga možemo dati ovdje.


11.38 Upravljanje diskovnim prostorom

S obzirom da se datoteke smještaju na disk, upravljanje diskovnim prostorom predstavlja osnovnu brigu projektantima datotečnog sistema. Za smiještanje n bajta u datoteku, postoje dvije osnovne strategije: alociranjem n susjednih bajta diskovnog prostora i podjelom datoteke u jedan broj diskovnih blokova.

Kao što smo vidjeli, smiještanje datoteke kao kontinualnig niza bajta ima očigledan problem ako datoteka počne da raste, tako da će se vjerovatno morati premjestiti na drugo mjesto na disku. Isti problem postoji za segmente u memoriji, osim što je premještanje segmenata u memoriji relativno brza operacija u poređenju sa premještanjem datoteke sa jednog mjesta na drugo. Zbog ovih razloga, gotovo u svim datotečnim sistemima datoteke se dijele u blokove fiksne veličine kako bih lakše mogli smjestiti na disk bez potrebe da se iznalazi dovoljan prostor za cijelu datoteku.

11.39 Veličina blokaNakon odluke da datoteku treba smjestiti u blokovima iste veličine, trebalo

je odgovoriti na pitanje, kolike veličine bi trebao da bude blok? S obzirom na organizaciju diska sa sektorima, stazama (čitaj, skup sektora) i cilindrima (čitaj, veći skup sektora), izgleda da su oni očigledni kandidati da budu alokaciona jedinica mada su zavisni od uređaja što im predstavlja veliki minus. Na primjer, ako je alokaciona jedinica jednaka veličini cilindra, tada to znači da svaka datoteka, čak i ona koja zauzima samo jedan bajt će zauzeti cijeli cilindar.

S druge strane, korišćenje malih alokacionih jedinica ima za posljedicu da će se svaka datoteka sastojati od mnogo blokova. Čitanje svakog bloka zahtjeva kašnjenje kod pozicioniranja na stazu kao i rotaciono kašnjenje tako da čitanje datoteke, koja se sastoji od mnogo malih blokova, će biti prilično sporo. Na primjer, pogledajmo disk koji ima 131,072 bajta/stazi, rotaciono kašnjenje od 8.33 msec i srednje vrijeme pozicioniranja od 10 msec. Vrijeme da se pročita blok od k bajta se onda izračunava kao suma kašnjenja kod pozicioniranja na stazu, rotacionog kašnjenja i vremena prijenosa podataka: 10 + 4.165 + (k / 131072)x 8.33.

Puuna linija na slici pokazuje intenzitet prenosa podataka sa/na disk kao funkcija veličine bloka.

Veličina bloka 319

Puna linija (skala na lijevoj strani) označava intenzitet prijenosa podataka sa diska. Isprekidana kriva (skala na desnoj strani) daje efikasnonost korišćenja diskovnog prostora. Sve datoteke imaju veličinu od 2 KB.

Da bi izračunali efiksnost korišćenja diskovnog prostora, treba da napravimo pretpostavku o srednjoj veličini datoteke. Rana istraživanja pokazuju da je srednja veličina datoteke u UNIX-u oko 1 KB (Mullender and Tanenbaum, 1 9 84 ). Mjerenja izvršena u 2005 godini, na uzorku od 1000 korisnika i 1 milion datoteka, dala su srednju veličinu datoteke od 2475 bajta, što znači da je polovina datoteka manja od ove veličine a polovina veća. Kao sporedan efekat, medijana predstavlja bolju mjeru nego srednja vrijednost jer jako mali broj datoteka može imati veliki uticaj na srednju vrijednost ali ne i na medijanu. Knjige zapisane na nekoliko stotina MB ili video sadržaji mogu značajno uticati na srednju vrijednost ali imaju mali efekat na medijanu.

Jedan eksperimet je pokazao da je upotreba NT datoteka prilično različita od korišćenja datoteka na UNIX-u. Vogles (1999) je napravio mjerenja na datotekama na Cornel University. Primjetio je da korišćenje NT datoteka složenije nego Unix datoteka. On je napisao: „ Kada odštampate nekoliko znakova u notepad text editoru, i spašavanje tog sadržaja u datoteku će pokrenuti 26 sistemskih poziva, uključujući i 3 neuspješna pokušaja otvaranja datoteke, jedno prepisivanje datoteke i 4 dodatne operacije otvaranja datoteke i operacije zatvaranja. Primjetio je da veličina medijane (ponderisana sa upotrebom) datoteka koje čitaju 1 KB, zapisuje se 2,3 KB i datoteke čitaju i pišu 4.2 KB. Medijana ovakvih datoteka je 2 KB. Zbog jednostavnosti, pretpostavimo da su sve datoteke jednake 2 KB, što vodi do isprekidane krive na slici koja prikazuje efikasnost korišćenja diskovnog prostora.

Ove dvije krive mogu se shvatiti na sljedeći način. Vrijeme pristupa bloku zavisi uglavnom od premena pozicioniranja i rotacionog kašnjenja, stoga potrebno je 14 msec da bi se pristupilo bloku i ako se preuzme više podataka to je bolje. Pošto se intenzitet prenosa podataka povećava sa veličinom bloka ( dok prenos podataka ne bude dovoljno dug da počne da dominira). Kod malih blokova veličine stepena 2 i 2KB datotekama nema gubitaka prostora u bloku.


Mežutim, sa 2 KB datotekama i 4 KB ili većim blokovima, neki diskovni prostor se gubi (slobodan prostor se nalazi samo u posljednjem bloku datoteke).

Šta krive pokazuju, međutim, su performanse i iskorišćenost diskovnog prostora koje su međusobno zavisne. Mali blokovi su loši za performanse ali dobri za iskorišćenost diskovnog prostora. Potrebno je pronaći neku veličinu bloka koja predstavlja kompromis. Za ovakve podatke, veličina bloka od 4 KB predstavlja dobar izbor, ali su neki operativni sistemi napravili ovaj izbor davno prije, kada su diskovni parametri i datoteke bile različite. Kod Unix-a, veličine blokova od 1 KB se najčešće koristio. Kod MS-DOS-a, mogla je biti od 512 do 32 KB, ali je određena sa veličinom diska i razlozima koji nisu povezani sa ovim činjenicama (maksimalan broj diskovnih blokova na diskovnoj particiji je 2 na 16, pa ta činjenica forsira velike blokove za velike diskove).

Pojavom većih diskova i velikih datoteka brzina pristupa je važnija od iskorištenja prostora. Za diskove čije su dimenzije u terabajtima, preporučljiva veličina bloka je 64 kilobajta.

11.40 Vođenje evidencije o slobodnim blokovimaKada smo izabrali veličinu bloka, sljedeće važno pitanje predstvalja

vođenje evidencije o slobodnim blokovima. Pet metoda se koristi, o d k o j i h su dvije prikazane na slici. Prva se sastoji od korišćenja ulančane liste diskovnih blokova, pri čemu svaki blok drži brojeve slobodnih diskovnih blokova. Sa 1 KB blokom i 32 bitnim brojem diskovnog bloka, svaki blok može držati brojeve 255 slobodnih blokova, pri čemu je jedno mjesto potrebno za pokazivač na sljedeći blok. Jedan 256 GB disk treba da listu slobodnih blokova od maksimalno 1,052,689 blokova da bi držao svih 2 na 28 brojeva diskovnih blokova. Često se slobodni blokovi koriste da bi držali listu slobodnih blokova.

Slika (a) smiještanje liste slobodnih blokova u ulančanu listu. (b) bit mapa.

Druga tehnika za upravljanje slobnim prostorom na disku je bit mapa. Jedan disk sa n blokova zahtjeva mapu sa n bita. Slobodni blokovi su predstavljeni sa 1 u

Vođenje evidencije o slobodnim blokovima 321

mapama, a alocirani blokovi sa o (ili obrnuto). Jedan 256 GB disk ima 228

1

KB blokova i zahtjeva 228

bita za mapu, koja zahtjeva 32,768 blokova. Nije iznenađenje da bit mapa zahtjeva manje prostora pošto koristi 1 bit po bloku prema 32 bita kod modela sa ulančanim listama. Samo ako je disk gotovo pun (t.j. ima nekoliko slobodnih blokova) će model sa ulančanim listama zahtjevati manje blokova nego bit mapa. S druge strane, ako ima jako puno slobodnih blokova, neki od njih mogu se koristiti da drže listu slobodnih blokova bez gubitaka diskovnog kapaciteta.

Kada se koristi metoda sa ulančanim listama, samo jedan blok pokazivača se drži u glavnoj memoriji. Kada se datoteka kreira, potrebni blokovi se uzimaju iz liste blokova sa pokazivačima. Kada se završi sa korišćenjem datoteke, čitaju se novi blokovi pokazivača u memoriju da diska. Slično, kada se pobriše datoteka, blokovi se oslobađaju i dodaju u blok pokazivača na slobodne blokove. Kada se ovaj blok popuni, piše se na disk.

Treća metoda je lista slobodnih blokova, koja se stalno održava, ali nije nužno ulančana. Ova metoda nije posebno efikasna jer traži prolaske kroz listu. Primjer gdje je korištena je V R1 sistem, FAT.

Četvrta metoda je uvezana lista indeksnih blokova. Koriste se specijalni indeksni čvorovi koji pokazuju na slobodne blokove. Svaki indeksni blok sadrži adrese slobodnih blokova i pokazivač na sljedeći indeksni blok. Veliki broj slobodnih blokova se može naći veoma brzo.

Peta metoda je vezana za ekstentnu i kontinualnu alokaciju. Neki datočni sistemi, kao što je NTFS rezervišu slobodni prostor za konkretnu datoteku određene veličine (npr 64K za NTFS), čak i ako je ona kraća. Prilikom širenja datoteke, prvo se gleda da li ona ima slobodnog prostora ranije dodijeljenog za nju, a tek ako nema, gledaju se slobodni blokovi predstavljeni bitmapama.

11.41 KvoteMnogi višekorisnički operativni sistemi ograničavaju korisniku broj datoteka i

blokova diska koji mogu zauzeti, u cilju pravilnog upravljanja slobodnim prostorom. Kvote se realizuju tako što se u tabeli otvorenih datoteka postavi pokazivač na tablicu ograničenja blokova i datoteka. Ograničenja se dijele na čvrsta i meka. Kada korisnik pređe meki limit, operativni sistem treba da mu pošalje upozorenje. Prekoračenje čvrstog ograničenja rezultuje zabranom daljnje prijave tog korisnika i on mora tražiti od administratora da mo poveća kvotu ili obriše nepotrebne datoteke.

11.42 Pouzdanost datotečnog sistemaUništenje datotečnog sistema je često teže nego uništenje cijelog računara.

Ako se računar uništi vatrom, kafom koja se izlila na tastaturu i sl., zamjena pojedinih djelova se može obaviti dosta brzo i sa manje ili više novaca. Međutim, ako je datotečni sistem izgubljen na disku, kao rezultat hardverske


pogreške ili rezultat nefuncionisanja softvera, rada virusa i sl., vraćanje informacija će biti izuzetno teško, gotovo nemoguće. Za ljude, čije informacije mogu predstavljati programe, dokumente, korisničke datoteke, baze podataka ili radne planove, gubitak podataka dovešće do katastrofalnih posljedica. Kako datotečni sistem ne može nuditi neku vrstu zaštite od fizičkog uništenja opreme ili medija, on bi mogao pomoći u zaštiti informacija. U ovom djelu pozabavićemo se nekim pitanjima koja uključuju mjere zaštite datotečnog sistema.

Diskete su ispravne kada napuštaju proizvodne fabrike ali mogu proizvesti «loše» blokove u toku upotrebe. Uređaj za diskete koji se manje koristi ima manju vjerovatnoćui da uništi disketni medij. Diskovi često imaju neispravne blokove (engl. bad blocks) i proizvođaču je vrlo teško da ih potpuno elimiše. Sa ovakvim blokovima na disku radi kontrolor diska koji zamjenjuje neispravne blokove sa rezervnim koji su obezbjeđeni za te svrhe. Na ovim diskovima, staze su bar jedan sektor duže nego što je potrebno, tako da bar jedan neispravan blok može biti preskočen i zamjenjujući ga sa praznim prostorom između dva susjedna sektora. Nekoliko rezervnih sektora je obezbjeđeno na svakom cilindru tako da kontrolor može automatski uraditi uređivanje ako primjeti da sektor traži više pokušaja čitanja ili pisanja. Dakle, korisnik nije svjestan neispravnih blokova i upravljanja sa njima. I pored toga, kada se na modernim IDE ili SCSI diskovima desi neispravan blok, to će obično završiti katastrofalno jer se izvršava izvan rezervnih blokova. SCSI obezbjeđuju oporavak od greške poslije uspostavljanja rezevnig bloka umjesto neispravnog bloka. Ako drajver primjeti ovo i prikaže poruku na monitoru, onda korisnik zna da je vrijeme da kupi novi disk kada ova poruka počne da se pojavljuje često.

Jednostavno softversko rješenje postoji za problem neispravnih blokova i pogodno je za korišćenje na starim diskovima. Ovaj pristup zahtjeva od korisnika ili datotečnog sistema da pažljivo konstruiše datoteku koja sadrži sve ove neispravne blokove.Ova tehnika ih uklanja iz liste svih slobodnih blokova, tako da se više nikad neće pojaviti u podacima datoteka. Sve dok se datoteka neispravnih blokova ne čita ili piše, problemi ove vrste neće postojati u ostalim datotekama. Treba paziti kod spašavanje podataka (engl. backup) da se ta datoteka ne čita koja bi prouzrokovala zastoj usljed nemogućnosti da se pročitaju njeni blokovi.

11.43 Spašavanje podataka (engl. Backups)Većina korisnika ne pravi spašavnje svojih datoteka jer misle da nije

vrijedno utrošenog vremena i uloženog truda oko toga. Međim, kada se desi uništenje podataka, oni postanu svjesni potrebe za čuvanjem svojih podataka. U firmama, korisnici su svjesni vrijednosti podataka koji se nalaze na medijima i obično vrše spašavanje podataka jedanput dnevno, obično na trake. Moderne trake mogu čuvati desetine ili čak i stotine GB a koštaju 1 KM/GB. Međutim, spašavanje podataka nije jednostavno kako to izgleda te u tom smislu pozabavimo se nekim pitanjima koja se odnose na spašavanje podataka.

Spašavanje podataka (engl. Backups) 323

Spašavanje podataka na trake se izvodi da bi se radilo sa jednim od dva moguća problema:

o Oporavak od katastrofalnog događajao Oporavak zbog nepažnjeU prvom slučaju, radi se o oporavku računarskog sistema kome se desilo

uništenje diska, požar, poplava ili drugi katasrofalan događaj. U praksi se ove stvari ne dešavaju često, što predstavlja razlog nekim korisnicima da se ne uhvate u koštac sa ovim problemom. Isti ovi korisnici nemaju osiguranje od požara iz istih ili sličnih razloga.

Drugi razlog predstavlja brisanje podataka, uslijed nepažnje, koji će kasnije trebati. Ovakav problem se često dešava. Kod Windows-a, datoteka se ne pobriše nego se premjesti u poseban direktorij, nazvan «recycle bin», i mogu se vratiti na mjesto gdje su potrebne. Spašavanje podataka omogućuje korisnicima da vrate datoteke koje su pobrisane nekoliko dana ili sedmica, prije. Pravljenje ovih datoteka kada se vrši spašavanje podatka, predstavlja proces koji traje i zahtjeva dodatni smještajni prostor. Veoma je važno ovo raditi efikasno jer će nam omogućiti vraćanje podataka kasnije u slučaju gubitka podataka. Ova razmatranja dovode do sljedećih pitanja. Prvo, da li treba cijeli datotečni sistem spasiti ili samo njegov dio? U mnogim instalacijama, izvršni programi se drže u ograničenom djelu datotečnog sistema. Nije potrebno spašavati datoteke koje se mogu ponovno instalirati sa CD-a proizvođača. Takođe, većina sistema ima direktorij za privremene datoteke. I njega ne treba spašavati jer mu ime kaže da služi za privremene operacije. U operativnom sistemu UNIX, specijalne datoteke (U/I uređaji) se čuvaju u direktoriju /dev/. Ne samo da spašavanje datoteka ovog direktorija nije potreban, nego je vrlo opasno jer će program za spašavanje «zaglaviti» ako se pokuša sa čitanjem ovih datoteka. Kratko, obično je poželjno da spašavamo samo određene direktorije i sve u njima nego da spašavamo cijeli datotečni sistem.

Drugo, spašavanje podataka koji se nisu mjenjali od posljednjeg spašavanje podataka predstavlja samo gubitak smještajnog prostora. Ovakav pristup vodi inkrementalnim sigursnosnim kopijama. Najednostavniji oblik inkrementalnog čuvanja sigurnosnih kopija je da se napravi periodično potpuno spašavanje podatka (puni backup), recimo sedmični ili mjesečno, a zatim se pravi dnevno čuvanje podataka samo onih datoteka koje su modifikovane od posljednje promjene u odnosu na puni backup. Još bolje je, ako se naprave sigurnosne kopije samo onih datoteka koje su modifikovane u odnosu na posljednje spašavanje sigurnsnih kopija, a ne punog backup-a. Ovakvim pristupom se smjanjuje vrijeme izrade backup-a ali se usložnjava oporavak od greške, jer je potrebno vratiti posljednji snimljeni puni backup a na njega dodati sve inkrementalne sigurnosne kopije u ispravnom redosljedu, prvo najstarija do najkasnije. Da bi oporavak bio jednostavniji, često se koriste složenije sheme inkrementalnog čuvanja sigurnosnih kopija.


Treće, pošto se enormno veliki iznos podataka spašava, poželjno je komprimovati podatke prije pisanja na trake. Međutim, kod mnogih kompresionih algoritama, samo jedan neispravan blok na traci može dovesti kod algoritma za dekompresiju da cijela datoteka ili čak i cijela traka postanu nečitljivi. Dakle, pitanje komprsije podataka mora se pažljivo razmotriti.

Četvrto, teško je izvršiti spašavanje podataka na aktivnom datotečnom sistemu. Ako se datoteke i direktoriji dodaju, brišu i modifikuju u toku procesa spašavanja podataka, spašeni podaci mogli bi biti nekozistentni. S obzirom da spašavanje datotečnog sistema traje nekoliko sati, potrebno je ovu operaciju raditi u toku noći kada je datotečni sistem neaktivan. Iz ovih razloga, algoritmi su osmišljeni za pravljenje brzog snimka stanja (engl. snapshot) datotečnog sistema kopiranjem kritičnih struktura podataka, a onda zahtjevajući da buduće izmjene datoteka i direktoija budu kopirane u blokovima a ne ažuriranjem datoteka (Hutchinson et al., 1999). Na ovaj način, datotečni sistem je u suštini «zaleđen» na momenat, tako da može biti spašen poslije u slobodnije vrijeme.

Peto, provođenje čuvanja podataka dovodi do mnogih netehničkih problema u radnoj organizaciji. Najbolji sigurnosni sistem na svijetu mogao bi biti nekoristan ako administrator sistema čuva sve backup trake u svojoj kancelariji i ostavlja ih otvorenim i nečuvanim kad god napusti radno mjesto. Špijun treba da uđe u sobu i stavi jednu traku u džep i izađe s pozdravom i smješkom. Doviđenja sigursnosti. Takođe, izvođenje dnevnih backup-a nije korisno ako dođe do požara koji će zapaliti i trake. Iz ovih razloga, trake bi trebale biti držane izvan prostorije ali i to uvodi nove sigurnosne rizike.

Mogu se koristiti dvije strategije za spašavanje diska na trake: fizički prepis i logički prepis. Fizički prepis počinje sa blokom 0 na disku, zatim piše sve blokove na traku u redosljedu i završava kad zapiše posljednji blok na traku. Takav program je veoma jednostavan i može biti vjerovatno bez grešaka, takav da ne treba pričati o drugom takvom programu. Napišimo nekoliko komentara na fizički zapis sigurnosnih kopija.

Ovdje ne postoje vrijednosti koje ukazuju na nekorišćenje diskovne blokove. Ako program za spašavanje može pristupiti strukturi bit mapa diska onda bi mogao i spriječiti zapis nekorišćenih blokova. Međutim, potrebno je usaglasiti takvo pisanje jer nije više blok broj k na traci jednak bloku broj k na disku.

Druga briga predstavlja zapis neispravnih blokova. Ukoliko su svi neispravni blokovi zamjenjeni sa rezervnim blokovima i kontroler ih sakriva od operativnog sistema, fizički zapis sigurnosnih kopija će raditi dobro. S druge strane, ako su vidljivi operativnom sistemu i održavani u jedan ili više «datoteka neispravnih blokova» ili bitmapa, izuzetno je važno da program za fizički zapis pristupi ovim informacijama i spriječi njihov zapis kako bi spriječio beskrajne disk greške koje bi se javljale u toku ovog procesa. Glavna prednost fizičkog zapisa je jednostavnost i velika brzina ( u suštini se može obavljati brzinom diska). Glavna mana je nemogućnost da se ne uključuju neki direktoriji, da se napravi

Spašavanje podataka (engl. Backups) 325

inkrementalni backup i da se izvrši povrat pojedinačnih datoteka na zahtjev. Iz ovih razloga, većina instalacija se izvodi logičkim zapisom sigurnosnih kopija.

Logički zapis sigurnosnih kopija počinje na jednom ili više direktorija i rekurzivno zapisuje sve datoteke koje nađe u njima i koje imaju promjene od nekog datuma, t.j. posljednje inkrementalnog zapisa ili punog backup-a. Dakle, u logičkom zapisu, zapis na traku ima niz pažljivo odabranih direktorija i datoteka koje su jednostavnije za proces vraćanja datoteka ili direktorija na zahtjev. U cilju da se može povratiti čak i jedna datoteka korektno, sve informacije za ponovno kreiranje datoteke su potrebne, uključujuči i stazu datoteke. Dakle, prvi korak u radu sa logičkim zapisom je analiza stabla direktorija. Jasno je da treba da spasimo bilo koju datoteku ili direktorij koji su bili modifikovani. Ali za tačniji oporavak, svi direktoriji, čak i oni koji nisu modifikovani ali možda pokazuju na direktorij ili datoteku koja je modifikovana (prisjetite se komande link). Ovo znači da spašavamo, ne samo podatke (imena datoteka u pokazivače na indeksne čvorova), već i svi atributi direktorija moraju biti spašeni tako da se mogu vratiti sa originalnim dozvolama (engl. permissions). Direktoriji sa njihovim atributima se prvo pišu na trake a onda se spašavaju modifikovane datoteke sa njihovim atributima. Ovi podaci su dovoljni da se povrati datoteka i direktorij u datotečni sistem na različitim računarima. Na ovaj način, operacija spašavanja i vraćanja programa mogu se korsititi za prijenos cijelog datotečnog sistema između računara.

Drugi razlog za spašavanje nemodifikovanih direktorija je da se omogući inkrementalno vraćanje jedne datoteke (moguće je raditi oporavak od nenamjernog brisanja). Pretpostavimo da je izvršen puni backup u nedjelju navečer i da je urađen inkrementalni zapis u ponedeljak naveče. U utorak je pobrisan direktorij

/usr/jhs/proj/nr3/ zajedno sa svim direktorijima i datotekama ispod njega. U sijedu izjutra, korisnik želi da napravi vraćanje datoteke /usr/jhs/proj/nr3/plans/summary. Međutim, nije moguće vratiti datoteku «summary» jer nema mjesta gdje će se staviti. Direktoriji nr3/ i plans/ moraju se prvo vratiti, da bi obezbjedili mjesto za traženu datoteku. Da bi uzeli ispravne njihove vlasnike, načine pristupa, vremena itd., ovi direktoriji moraju biti prisutni na traci čak iako oni nisu modifikovani od posljednjeg punog zapisa.

Vraćanje datotečnog sistema sa zapisanih traka je prilično jasno. Da bi počeli sa ovim, na disku se kreira prazan datotečni sistem. Onda se vrati posljednji zapisani puni zapis. Pošto se direktoriji pojavljuju prvi na traci, oni se prvi i vrate i na taj način daju kostur datotečnog sistema. Zatim se vraćaju pojedine datoteke. Ovaj proces se zatim ponavlja sa prvim inkrementalnim zapisom napravljenim poslije punog zapisa, a zatim sljedeći itd.

Mada je logički zapis prilično jasan, postoje neka interesantna zapažanja. Kao prvo, pošto lista slobodnih blokova nije datoteka, ona se ne zapisuje i ponovno se pravi u toku operacije vraćanja datoteka i direktorija. Skup slobodnih blokova predstavlja samo komplement zauzetih blokova za jedan medij.


Drugačije su veze na datoteke. Ako je datoteka povezana na dva ili više direktorija, važno je da datoteka koja se vraća samo jedanput ažurira pokazivače na direktorije kojima pripada.

Na kraju, specijalne datoteke, imenovani pipe-ovi, i sl. ne bi trebalo nikada da se zapisuju, bez obzira u kom direktoriju se nalaze (ne moraju biti zatvorene u /dev/).

11.44 Konzistentnost datotečnog sistemaKonzistentnost datotečnog sistema predstavlja drugu oblast pouzdanosti

datotečnog sistema. Mnogi datotečni sistemi čitaju blokove, mjenjanju ih i kasnije ih zapisuju. Ako datotečni sistem «padne» prije nego što su svi izmjenjeni blokovi zapisani, datotečni sistem će doći u nekonzistentno stanje. Problem je posebno težak u slučaju da se indeksni blokovi ne zapišu, ili blokovi direktorija ili blokovi koji sadrže listu slobodnih blokova.

Za borbu sa problemem nekonzistentnosti datotečnog sistema, većina računara imaju program koji kontroliše konzistentnost datotečnog sistema. Na primjer, Unix ima fsfck ( file systems check), dok Windows ima chkdsk (check disk), ili scandisk u ranijim verzijama. Ovaj program se može pokrenuti kad god je potrebno, posebno kod pada računara. U nastavku će biti dat opis rada programa fsck. Chkdsk je nešto različitiji jer radi sa različitim datotečnim sistemom, ali je u suštini isti sa predhodnikom jer koristi redundantne informacije. Svi programi kontrolišu svaki datotečni sistem – datotečnu particiju, nezavisno jedan od drugog.

Dvije vrste kontrole konzistentnosti mogu biti: koja koristi blokove i koja koristi datoteke. Za kontrolu konzistentnosti blokova, program pravi dvije tabele, od kojih svaka sadrži brojač za svaki blok, u početku postavljen na 0. Brojač u prvoj tabeli vodi evidenciju koliko puta je svaki blok prisutan u datoteci. Brojač u drugoj tabeli zapisuje koliko često svaki blok je prisutan u listi slobodnih blokova.

Program, zatim, čita sve indeksne čvorove. Počevši od indeksnog čvora, moguće je napraviti listu svih brojeva blokova korišćenenih u odgovarajućoj datoteki. Čim se pročita broj bloka, njegov brojač, u prvoj tabeli se poveća za jedan. Program zatim ispituje listu slobodnih blokova ili bitmapu, da pronađe sve blokove koji nisu u upotrebi. Svaka pojava bloka u listi slobodnih blokova dovodi do povečanja za jedan njegov brojač u drugoj tabeli.

Ako je datotečni sistem konzistentan, svaki blok će imati jednu jedinicu u prvoj ili u drugoj tabeli, kao što je to prikazano na slici a. Međutim, kao rezultat «pada», tabele mogu izgledati kao na slici b, na kojoj se blok broj 2 ne pojavljuje ni u jednoj tabeli. On će biti označen kao nedostajući blok. Dok nedostajući blokovi ne prave štetu, sve je u redu pri čemu takvi blokovi troše diskovni prostor i na taj način redukuju kapacitet diska. Rješenje problema nedostajućih blokova je prilično jasno: program za kontrolu konzistentnosti datotečnog sistema samo ih dodaje u listu slobodnih blokova.

Konzistentnost datotečnog sistema 327

Slika Stanja datotečnog sistema. (a) konsistentno. (b) nedostajući blok. (c) Duplicirani blok u listi slobodnih blokova. (d) duplicirani blok podataka.

Sljedeća situacija, koja se može desiti je prikazana na slici c. Ako pogledamo na blok broj 4, primjetićemo da postoji dva puta u listi slobodnih blokova (dupliciranje se može desiti samo ako je lista slobodnih blokova organizovana kao lista, kod bitmapa to je nemoguće). Rješenje je jednostavno, treba napraviti listu slobodnih blokova ponovo.

Najgori slučaj koji se može desiti je da je jedan te isti blok prisutan u dvije ili više datoteka, kao što je prikazano na slici d sa blokom broj 5. Ako dođe do brisanja ovih datoteka, blok broj 5 se stavlja u listu slobodnih blokova, dovodeći do slučaja da je slobodan i zauzet u isto vrijeme. Ako se pobrišu obje datoteke, slobodan blok će biti smješten u listu slobodnih blokova dva puta.

Odgovarajuća akcija za program za kontrolu konzistentnosti datotečnog sistema je da alocira jedan slobodan diskovni blok, kopira sadržaj diskovnog bloka 5 u njega i ubaci kopiju u jednu od datoteka. Na ovaj način, sadržaj informacija u datotekama je ostao neizmjenjen (mada gotovo sigurno da je jedan uništen), ali je datotečni sistem bar konzistentan. Greška se može prikazati koja će omogućiti korisniku da istraži eventualnu štetu.

Program za kontrolu konzistentnosti kontrolira i sistem direktorija kako bi korektno uradio kontrolu pojedinačnih datoteka. Pri ovome koristi tabele brojača za datoteke a ne za blokove. Počinje od korjenskog direktorija i rekurzivno silazi kroz drvo ispitujući svaki direktorij u datotečnom sistemu. Za svaku datoteku, u svakom direktoriju, povećava brojač za datoteku. Prisjetimo se zbog čvrstih veza, datoteka se može pojaviti u dva ili više direktorija. Simboličke veze se ne računaju i ne povećavaju brojač za datoteke.

Kada se sve završi, postoji lista, indeksirana sa indeksnim čvorovima, koja kaže koliko direktorija sadrži svaka datoteka. Onda se poredi ove brojeve sa brojačem veza koji je smješten u samom indeksnom čvoru. Ovaj brojač počinje sa 1 kod kreiranja datoteke i povećava se za 1 svaki put kada se napravi jedna čvrsta veza na datoteku. U jednom, konzistentnom, datotečnom sistemu, oba brojača će biti isti. Međutim, dvije vrste grešaka se mogu desiti: brojač veza u indeksnom čvoru može biti isuviše veliki ili veoma mali. Ako je broj veza veći od broja elemenata direktorija, onda iako se sve datoteke uklone iz direktorija, brojač može biti različit


od nule i indeksni čvor se ne može pobrisati. Ova greška nije ozbiljna, ali troši diskovni prostor sa datotekama koje nisu ni u jednom direktoriju. Ovo se može srediti postavljajući brojač veza u indeksnom čvoru na korektnu vrijednost.

Druge greške mogu proizvesti katastrofalne rezultate. Ako su dva elementa direktorija povezani u jednu datoteku, ali indeksni čvor kaže da ima samo jedna datoteka, onda je uklonjen element direktorija ili indeksni čvor je dostigao vrijednost 0. Kada brojač u indeksnom čvoru dosegne 0, datotečni sistem označava ga kao nekorišćen i oslobađa sve njegove blokove. Ova akcija može proizvesti da jedan od direktorija sada pokazuje na jedan nekorišćen indeksni čvor, čiji blokovi bi uskoro mogli biti dodjeljeni nekoj drugoj datoteci. Rješenje je da se prisilno postavi brojač veza u indeksnom čvoru na stvarnu vrijednost elemenata direktorija.

Ove dvije operacije, kontrola blokova i kontrola direktorija, su često integrisane zbog efikasnosti (t.j. zahtjeva se samo jedan prolaz kroz sve indeksne čvorove). Moguće su i neke druge kontrole. Na primjer, direktoriji imaju definisan format sa brojevima indeksnih čvorova i ascii imenima datoteka. Ako je broj indeksnog čvora veći od broja indeksnih čvorova na disku, to znači da je direktorij oštećen.

11.45 Žurnalski datotečni sistemiMnoge aktivnosti datotečnih sistema zahtijevaju više izmjena na sistemu. Na

primjer brisanje datoteke tipično uklanja element iz direktorija, oslobađa prostor rezervisan za datoteku i oslobađa njen indeksni čvor. Ako se desi krah između ovih faza sistem ostaje nekonzistentan. Povremeno je potrebno provjeriti konzistentnost sistema, ali kako je to opisano u prethodnom poglavlju to je duga aktivnost.

Da se izbjegne test cijelog sistema na nekonzistentnost, uvodi se poseban dio datotečnog sistema ili specijalna datoteka koji se zove žurnal. Kada se da zahtjev za višefaznom akcijom nad datotečnim sistemom, u žurnal se zabilježe unaprijed sve promjene koje se trebaju uraditi. U slučaju kraha, prilikom novog podizanja operativnog sistema, samo se pročita žurnal i ponove planirane aktivnosti. Promjene su atomske pa ili će se obaviti u cjelosti ili neće biti uopšte započete, jer nisu ni upisane u žurnal. Primjeri ovakvih datotečnih sistema su NTFS i Ext3FS.

11.46 Performanse datotečnog sistemaPristup disku je mnogo sporiji nego pristup memoriji. Čitanje memorijske

riječi se može obaviti za 10 nsec. Čitanje sa diska se obavlja brzinom od 10MB/sec što je 40 puta sporije po 32 bitnoj riječi. Ovome je potrebno dodati i 510 msec vremena pozicioniranje na staze i vrijeme potrebno da dati sektor stigne ispod glave diska. Ako je samo jedna riječ potrebna, onda je pristup memoriji milion puta brži nego pristup disku. Kao posljedicu ovako različitog ponašanja, mnogi datotečni sistemi su projektovani sa raznim optimizacionim tehnikama kako bi poboljšali performanse datotečnog sistema. U ovmo djelu, diskutovaćemo detaljnije o tri takve tehnike.

Keširanje 329

11.47 KeširanjeNajčešća tehnika koja se koristi da redukuje diskovni pristup je keširanje

blokova. (keš dolazi od francuske riječi cache a znači sakriti). U ovom kontekstu, keš predstavlja skup blokova koji logički pripadaju disku ali se drže u memoriji iz razloga povećanja performasi.

Različiti algoritmi se koriste za upravljanje kešom, ali najčešći je onaj kojim se provjeravaju svi zahtjevi za čitanje da bi se vidjelo da li su potrebni blokovi u kešu. Ako jesu, zahtjev za čitanje može se uraditi bez diskovnog pristupa. Ako blok nije u kešu, prvo ga je potrebno pročitati u keš a onda kopirati tamo gdje je potrebno, recimo, u korisnički bafer. Sljedeći zahtjevi koji se obavljaju nad istim blokom mogu se izvršiti iz keša.

Operacije nad kešom su prikazane na slici. Pošto u kešu ima puno blokova, često i hiljadama, potrebno je imati način da se brzo provjeri da li je blok prisutan u kešu. Uobičajen način je da se napravi hash tabela za diskovni uređaj sa diskovnim adresama i da se brzo pretražuje hash tabela. Svi blokovi da istom hash vrijednošću se smještaju u povezanu listu tako da u slučaju kolizije se pretržuje samo pridružena lista.

Kada jedan blok treba da se napuni u keš koji je pun, neke blokove iz keša bi trebalo izvaditi (i zapisati na disk ako je došlo do promjena na bloku od njegovog zadnjeg punjenja). Ovaj postupak je vrlo sličan straničenju i na njega se mogu odnositi svi algoritmi, takvi kao FIFO, druga šansa i LRU. Jedna prijatna razlika između straničenja i keširanja je da se keš koristi prilično rijetko, tako da je moguće održavati sve blokove u LRU redosljedu pomoću povezane liste.

Na slici vidi se da, ako se kolizija desi, postoji bidirekcionalna lista koja vezuje sve blokove u redosljedu njihovog korišćenja, tako da su blokovi koji su nedavno korišćeni na vrhu liste a oni koji su skoro korišćeni na kraju liste. Kada se blok referencira, on se uklanja sa svoje pozicije i smješta na kraj liste. Na ovaj način se održava ispravan LRU redosljed.

Nažalost, ovdje postoji problem. Šta će se desiti kod pada sitema i da li će nam datotečni sistem biti konzistentan? Ako se kritični blok, takav kao blok indeksnih čvorova, čita u keš i modifikuje, a ne zapiše na disk, pad sistema bi mogao dovesti datotečni sistem u nekonzistentno stanje. Ako je blok stavljen na kraj LRU liste, može se ne koristiti jedno vrijeme prije nego što dođe na vrh liste. Dakle, neki blokovi, takvi kao blokovi indeksnih čvorova, se rjetko referenciraju


unutar nekog intervala. Ova razmatranja vode do modifikovane sheme LRU, koja uzima u obzir sljedeća dva faktora:

o Da li će blok biti vjerovatno potreban ponovno, uskoro?o Da li je blok važan za konzistentnos datotečnog sistema?Za oba razloga, blokovi mogu biti podjeljeni u kategorije takve kao blokovi

indeksnih čvorova, indirektni blokovi, blokovi direktorija, puni blokovi podataka i blokovi podataka djelomično popunjeni. Blokovi koji, vjerovatno, neće biti potrebni skoro se stavljaju na vrh liste a ne na kraj liste tako da će njihovi baferi brzo biti korišćeni. Blokovi koji su djelomično popunjeni i u njih se može pisati veoma brzo se stavljaju na kraj liste tako da tamo ostaju duže vrijeme.

Drugo pitanje, koje je nezavisno od prvog se odnosi na blokove koji su važni za konzistentnost datotečnog sistema (u suštini, svi izuzev blokova podataka). Ako se oni modifikuju, trebalo bi ih odmah pisati na disk, bez obzira na kojem se kraju liste nalaze. Brzim pisanjem kritičnih sektora značajno smanjujemo vjerovatnoću da će pad sistema uništiti datotečni sistem. Mada korisnik može biti nezadovoljan ako se neka njegova datoteka pokvari, bio bi nezadovoljniji ako se uništi datotečni sistem.

Postoje dva pristupa u radu sa ovim. Unix ima sistemski poziv, sync, koji prinuđuje operativni sistem da odmah izvrši zapis svih modifikovanih slogova na disk. Windows piše sve modifikovane blokove na disk čim se promjeni njihov sadržaj. Keš u kojima se pišu odmah svi modifikovani blokovi na disk se naziva write-through keš. Razlika u ova dva pristupa se vidi u slučaju kada program piše 1 KB blok pun na disk, pri čemu dolaze znakovi u bafer vremenski raspodjeljeni. Kod Unixa, skupiće sve znakove u bafer i pisati blok svakih 30 sec ili kada se blok ukloni iz keša. Windows će pristupati disku na svaki pisani znak. Naravno, većina programa rade interno baferovanje, tako da Windows ne piše znak na disk nego liniju, ili veću jedinicu kod svakog pisanja na disk.

Kao posljedica ovakvih pristupa u strategiji keširanja je, kod Unixa, ako uklonimo disketu bez izvršavanja sync komande, gotovo uvijek će rezultat biti izgubljeni podaci i često će imati posljedice na datotečni sistem. Kod Windows-a ovih problema nema. Strategije se razlikuju zato što je Unix počeo sa razvojem na fiksnim diskovima a ne izmjenljivim, dok je Widows počeo sa disketom.

11.48 Čitanje blokova unaprijedDruga tehnika za poboljšanje nadgledanje performasi datotečnog sistema je

pokušaj dovlačenja blokova u keš prije nego što su potrebni da bi se povećao intenzitet nalazaka bloka u kešu. Da pojasnimo, mnoge datoteke se čitaju sekvencijalno. Kada se traži od datotečnog sistema da izda blok k neke datoteke, on uradi to čitanje i provjeri da li ima sljedećeg bloka u kešu, k+1. Ako ga nema, on izdaje zahtjev za čitanje bloka broj k+1 u nadi da će trebati brzo, i kada zatreba, nalaziće se u kešu.

Naravno, ova strategija, (engl. read ahead strategy) radi dobro samo za datoteke koje se čitaju sekvencijalno. Ako je pristup datotekama random, ova strategija

Čitanje blokova unaprijed 331

ne daje dobre rezultate. U stvari, ovim se sužava diskovna propusnost čitajući nekorisne blokove i uklanjenjem iz keša možda korisnih blokova. Čak, ako su blokovi koje izbacujemo modifikovani, potrebno ih je zapisati na disk a tim još sužavamo diskovnu propusnost. Da bi se pratilo da li ova tehnika loše radi, datotečni sistem može voditi evidenciju o pristupima svakoj otvorenoj datoteki. Na primjer, po jedan bit se može pridružiti svakoj datoteci da se vodi evidencija da li je datoteka u sekvencijanom načinu rada ili ima slučajan pristup. Sve se datoteke označe u početku kao da su u sekvencionalnom načinu rada. Međutim, kada se izvrši operacija seek, bit se očisti, a ako ponovno počinje sekvencialni način pristupa, bit se postavi. Na ovaj način, datotečni sistem može napraviti realne pretpostavke da li da se koristi ova tehnika ili ne.

11.49 Smanjenje kretanja glave diskaKeširanje i čitanje blokova unaprijed nisu jedine tehnike za povećanje

performansi datotečnog sistema. Jedna od važnih tehnika je smanjenje kretanja glave diska uređenjem zahtjeva za diskovne blokove kojima će se pristupati u redosljedu, blizak jedan drugom, po mogućnosti i u istom cilindru. Kada se piše datoteka, datotečni sistem treba da alocira po jedan blok u jedinici vremena, kada su potrebni. Ako su slobodni blokovi zapisani u bitmapi u glavnoj memoriji, dovoljno je izabrati slobodan blok dovoljno blizak jednom prethodno traženom. Sa listama slobodnih blokova, čiji se dio nalazi na disku, mnogo je teže alocirati blokove da budu jedan pored drugog.

Međutim, čak i kod liste slobodnih blokova može se izvršiti grupisanje blokova. To se evidentira na način da se smještajni prostor na disku vodi u grupama susjednih blokova. Ako sektor sadrži 512 bajta, sistem bi mogao koristiti 1 KB blokove ( po 2 sektora) a alocirati diskovni prostor u jedinicama od 2 bloka ( 4 sektora). Ovo nije isto kao da imamo 2 KB diskovne blokove, pošto će keš koristiti 1 KB blokove i prenos sa diska će biti sa 1KB blokovima, dok će sekvencijano čitanje datoteka redukovati broj pozicioniranja na stazu sa faktorom 2, i na taj način značajno povećati performanse. Varijacija na temu je da se uzme u obzir rotaciono kašnjenje. Kada alociramo blokove, sistem će pokušati da stavi susjedne blokove u datoteku u isti cilindar. Drugo usko grlo za performase u sistemu koji koristi indeksne čvorove ili neki ekvivalent indeksnim čvorovima je da čitanje čak i kratkih datoteka zahtjeva dva diskovna pristupa: jedan za indeksni čvor datoteke i jedan za njen blok podataka. Uobičajeno smiještanje indeksnih čvorova na disk je prikazano na slici a. Ovdje su svi indeksni čvorovi blizu početka diska, tako da će srednje rastojanje između indeksnog čvora i njegovih blokova biti oko ½ broja diskovnih cilindara, što zahtjeva duža vremena pozicioniranja.


Slika a) Indeksni čvorovi smješteni na početku diska. b) disk podjeljen u cilindrične grupe, svaki sa svojim blokovima i indeksnim čvorovima (datotečni sistem, ext 2, na Linuxu).

Jedno blago poboljšanje performansi je stavljanje indeksnih čvorova u sredini diska umjesto na početak diska pri čemu se smanjuje srednje vrijeme pozicioniranja između indeksnih čvorova i njihovih blokova za faktor 2. Druga ideja, prikazana na slici je da se podjeli disk u cilindrične grupe pri čemu svaka grupa ima svoje sopstvene indeksne čvorove, blokove podataka i listu slobodnih blokova (McKusick et al., 1984). Kada se formira nova datoteka, bilo koji indeksni čvor može biti izabran, mada se pokušava da se nađu blokovi i indeksni čvor u istoj cilindričnoj grupi. Ako to nije moguće, onda se koriste blokovi iz susjedne cilindrične grupe (njegova blizina uzrokuje manje vremena za pozicioniranje)

11.50 Log-Structured File SystemsPromjene u tehnologiji vrše pritisak na tekuće datotečne sisteme. Da pomenemo,

procesori postaju sve brži, diskovi postaju sve veći i jeftiniji ( ili ne i puno brži) a veličina memorije raste eksponencijalno. Jedan parametar koji nije značajno poboljšan je vrijeme pozicioniranja na traku (engl. seek time). Ako se pogledaju ova zapažanja može se primjetiti da usko grlo performasi sistema se desiti kod mnogih datotečnih sistema. Istraživanje izvršeno na Berkeley univerzitetu dovelo je do razvoja potpuno nove vrste datotečnog sistema, LFS (Log-structured File System). U ovom dijelu, prikazan je kratak opis funkcionalnosti LFS-a.

Osnovna ideja koja je vodila projektante LFS-a je što procesori postaju brži i RAM memorija postaje sve veća tako da bi se i keš mogao značajno proširiti. Kao posljedica toga, sada je moguće ispuniti značajno veliki broj zahtjeva za čitanje direktno iz keša, bez pristupa disku. Prateći ova razmatranja, budući diskovi će imati većinu diskovnih pristupa za pisanje, tako da mehanizam za dovlačenje blokova unaprijed, jer će skoro trebati, neće doprinijeti mnogo performansama sistema. Da stvar postane gora, u većini datotečnih sistema, pisanje se izvodi na vrlo malim djelovima. Pisanje malih djelova su vrlo neefikasni, pošto je potrebno 50 microsec za pisanje na disk ali je za pisanje potrebno čekati 10 msec za pozicioniranje i 4 msec za rotaciono kašnjenje. Sa ovim parametrima efikasnost pada na 1%.

Log-Structured File Systems 333

Da shvatimo odakle dolaze ova mala kašnjenja, pogledajmo kako se izvodi kreiranje nove datoteke u Unix-u. Da bi zapisali ovu datoteku, potrebno je zapisati sljedeće: indeksni čvor za direktorij, blok podataka za direktorij, indeksni čvor za datoteku i blok podataka za datoteku (ova prva dva zato što je potrebno u tim blokovima popraviti pojedene atribute direktorija, racimo, broj datoteka povećati za jedan, označiti vremena izmjene u indeksnom čvoru direktorija, označiti broj indeksnog čvora nove datoteke u direktoriju, i sl.). Ova pisanja bi mogla biti odložena, ali u slučaju pada sistema, datotečni sistem bi došao u nekonzistentno stanje. Iz ovih razloga, potrebno je indeksne čvorove odmah zapisati.

Iz ovih razloga, projektanti LFS-a odlučili su da izgrade datotečni sistem na takav način da postignu punu propusnost diska suočavajući se sa sistemom sa mnogo pisanja malih djelova na disk. Osnovna ideja je da se cijeli disk struktuira kao log. Periodično, i kada postoji potreba sa pisanjem, svako pisanje na disk koje je čekalo u baferima, se skuplja u jedan segment i piše na disk kao jedan kontinualan segment na kraju loga. Taj jedan segment može sadržati indeksne čvorove, blokove direktorija, blokove podataka i druge vrste blokova, sve pomješane zajedno. Napočetku svakog segmenta se nalaze informacije koje govore šta se može naći u segmentu. Ako je srednje veličina segmenta oko 1 MB, gotovo puna propusnost diska se može koristiti.

Kod ovog pristupa, indeksni čvorovi još postoje i imaju istu strukturu kao u Unix-u, ali su sada razbacani kroz cijeli log, umjesto da budu na jednoj poziciji na disku. Pored toga, kada se pronađe jedan indeksni čvor, pronalaženje njegovih blokova podataka se radi na uobičajen način. Treba primjetiti da je sada nalaženje indeksnih čvorova mnogo teže, pošto se adresa ne može jednostavno izračunati iz broja indeksnog čvora, kao u Unix-u. Da bi bilo moguće da se nađu svi indeksni čvorovi, održava se jedan indeksni čvor za mapu koji se indeksnira sa brojem indeksnog čvora. Element i u ovoj mapi pokazuje na indeksni čvor na disku. Mapa se održava na disku ali se jedan dio može i keširati, tako da će većina intenzivno korišćenih djelova u memoriji većinom vremena, u cilju da poveća performanse.

Da sumiramo, šta smo rekli do sada, sva pisanja na disk se baferuju u memoriju i periodično sva baferovana pisanja se pišu na disk u jednom segmentu, na kraju loga (čitaj na kraju diska, kontinulano). Za otvaranje datoteke koristi se mapa da bi se pronašao indeskni čvor datoteke. Kada se pronađe indeksni čvor, u njemu se nalaze adrese blokova koji se odnose na datoteku (adresni blokovi i blokovi podataka). Svi blokovi će biti u jednom segmentu negdje u logu. Ako su diskovi beskonačne veličine tada gornji opis je dovoljan. Međutim, stvarni diskovi su konačne veličine, tako da log može zauzeti cijeli disk i u tom momentu novi segment se ne može pisati u log. Tako mnogi postojeći segmenti mogu imati blokove koji više ne trebaju, recimo. Ako je jedna datoteka prepisana, njeni indeksni blokovi će sada pokazivati na nove blokove dok će stari blokovi još zauzimati prostor u prethodno napisanom segmentu.


Da bi pomogao kod ovog problema, LFS ima thread čistač, koji provodi vrijeme skenirajući cirkularno log i praveći njegovu kompakciju. Počinje čitanje informacije u prvom segmentu u logu da vidi koje su datoteke i indeskni čvorovi u njemu. Zatim provjerava mapu indeksnih čvorova da vidi da li su indeksni čvorovi i blokovi podataka u upotrebi. Ako nisu, te informacije se odbacuju, progrlašavaju slobodnim. Oni koji su u upotrebi, čitaju se u memoriju da bi ih ponovno zapisali na disk u sljedećem segmentu. Segment koji smo pretraživali se prograšava slobodnim, tako da se može koristiti za sljedeće pisanje segmenta. Kao posljedica ovog, disk je postao veliki cirkularni bafer sa treadom pisač koji dodaje segment na početak bafera i threadom čistac koji uklanja stare segmente sa kraja bafera.

11.51 Zadaci

Zadatak. Data je datoteka koja ima 100 blokova. Pretpostavimo da je kontrolni blok datoteke ( indeksni blok, u slučaju indeksne alokacije) već u memoriji. Izračunati koliko se U/I operacija zahtjeva za sljedeće alokacione strategije: kontinualna, povezana listama i indeksna (samo na prvom nivou, ne koristit indirektne pokazivače) kod čitanja jednog bloka pri čemu važi: u slučaju kontinualne alokacije postoji prostor da datoteka raste samo na kraju datoteke. Pretpostavim da blok informacija koje je potrebno dodati u datoteku je smješten u memoriji. Operacije koje treba uraditi su:

a. Blok se dodaje na početak datoteke b. Blok se dodaje u sredinu datotekec. Blok se dodaje na kraj datoteke d. Blok se uklanja sa početka datoteke

e. Blok se uklanja iz sredine datoteke f. Blok se uklanja s kraja datotekeOdgovor: ( za datoteku sa 100 blokova)Kontinualna Povezane liste Indeksna

a. 201 1 1b. 101 52 1c. 1 3 1d. 198 1 0e. 98 52 0f. 0 100 0

. Zadatak. Nacrtaj datoteku sa 4 bloka podataka koja koristi alokacione tehnike a) Sa indesknim čvorovima b) FAT organizaciju Na crtežu nacrtati element direktorija i pokazivače na sadržaj datoteka kao

i meta podatke. Rješenje:a) sa indeksnim čvorovima

Zadaci 335

b) FAT

Zadatak Pretpostavimo da želimo da otvorimo datoteku /tmp/file1 u datotečnom sistemu UNIX-a. Koliko disk blokova treba pročitati u memoriju i koji su to blokovi? Radi jednostavnosti pretpostavimo da se podaci direktorija uvijek nalaze u jednom bloku i da prije otvaranja, nikakva struktura datotečnog sistema se nije nalazila u memoriji.

Odgovor: 1. Čita se blok gdje se nalazi indeksni čvor korjenskog direktorija i u njemu se

nalazi diskovna adresa ( broj bloka ) bloka podataka korjenskog direktorija. 2. Čita se blok podataka korjenskog direktorija; U njemu se nalazi

indeksni čvor direktorija tmp. 3. Čita se indeksni čvor direktorija tmp, u kome se nalazi diskovn aadresa

bloka podataka direktorija tmp. 4. Čita se blok podataka direktorija tmp, u kome se nalazi indeksni čvor datoteke

file1. 5. Čita se indeksni čvor datoteke file1 u memoriju. Dakle, imamo čitanje 5 diskovnih blokova (ili manje ako se indeksni čvorovi

nalaze u istom bloku).


Zadatak Koliko je potrebno čitati blokova da bi se otvorila datoteka/etf/ri/student/skripta.txt. Nacrtati sliku na kojoj se vide svi blokovi kao i njihov sadržaj (indeksni čvor ili blok podataka).

Primjer slike pretraživanja datoteke /usr/student/

Zadatak. Dat je indeksni čvor veličine 64 bajta koji sadrži 6 direktnih pokazivača na blokove, 2 indirektna pokazivača i 2 duplo indirektna pokazivača. Svaki pokazivač ukazuje na blok od 4kbajta koji sadrži podatke ili listu 4-bajtnih pokazivača.

a1) Nacrtati shematski sistemske i blokove podataka datoteke koja je velika 27K. Datoteka od 27KB koristi 6 direktna pokazivača u indeksnom čvoru (6x4=24KB) i jedan indirektni pokazivač koji ukazuje na blok disk adresa. Prva 4 bajta u bloku diskovnih adresa ukazuju na blok podataka u kome se nalazi preostala 3KB datoteke.

a2) Koliko iznose meta podaci za ovu datoteku?Meta podatke predstavljaju: indeksni čvor datoteke, 1 indirekni blok pokazivača,

što ukupno čini 1k+64bajta

Zadatak Razmotrimo indeksne čvorove kod UNIX-a sa 9 direktnih pokazivača, jednog indirektnog i jednog duplo indirektnog pokazivača. Pretpodatvimo da je velučina bloka jednaka 8 KB i da je veličina pokazivača 4 bajta. Korsteći ovakav datotečni sistem, kolika je maksimalna veličina datoteke u ovom sistemu?

Odgovor: 9(2 13

) + ((2 13

)/4)* 2 13

+ ((2 13

)/4)*((2 13

)/4)* 2 13

bajta.

Zadatak. Operacijom get_block(19, spemnik) se čita 19 blok sa diska u memorijiski bafer “spremnik” koji je veliki 1 KB. Njegov sadržaj predstavlja sadržaj direktorija. Napisati kod u c-u za listanje sadržaja direktorija čije je struktura opisana sa

struct dir {short broj_indeksnog_cvora; /* 2 bajta dug*/char ime_datoteke[14];}Pri listanju sadržaja odštampati za svaku datoteku njen broj indeksnog čvora i

naziv.

Zadaci 337

typedef struct dir{ushort broj_indeksnog_cvora;char ime_datoteke[14];} DIR;

char dirBuf[BLOCK_SIZE];int root_fd, i;DIR *dp = (DIR *) dirBuf;main(){ushort dev;char superbuf[BLOCK_SIZE];char dirBuf[BLOCK_SIZE];root_fd = open("/dev/fd0", 2);dev = root_fd;get_block(dev,19,dirBuf); pročitaj blok broj 19 – korj. direktorij na disketnom uređaju (480i-n)dp = (DIR *)dirBuf;printf("----spisak datoteka u direktoriju----\n");for( i=1; i<64; i++, dp++) { // 64 je BLOCK_SIZE/sizeof(DIR) – 1024 / 16 if (dp->broj_indeksnog_cvora != 0){printf("%i\t %s \n", dp->broj_indeksnog_cvora, dp->ime_datoteke);};};printf("-------------------------------------\n");};

338 Sigurnost računarskih sistema


Datotečni sistemi sadrže informacije koje su izuzetno vrijedne svojim korisnicima. Zaštita ovih informacija od neautorizovanog pristupa je, dakle, osnovna briga svih datotečnih sistema. U sljedećim djelovima pogledajmo na različita pitanja koja se odnose na sigurnost i zaštitu. Ova pitanja se podjednako odnose na timesharing sisteme kao i mrežu personalnih računara koji su spojeni na djeljene servere preko lokalne računarske mreže.

12.1 Sigurnosna okolina

Ludi često koriste termine «sigurnost» i «zaštita». Često je korisno napraviti razliku da se osiguraju datoteke da nisu čitane ili modifikovane od neautorizovanog korisnika, koji uključuje tehnička, administrativna, pravna i politička pitanja s jedne strane i specifičnih mehanizama operativnih sistema korišćenih da se obezbjedi sigurnost, s druge strane. Da bi izbjeglu konfuziju, koristićemo termin sigurnost kada se osnosi na cijelokupan problem, a termin zaštitni mehanizmi kada se odnosi na pojedinačan mehanizam operativnog sistema koji se koristi za čuvanje informacije na računaru. Međutim, granica među njima nije jasno definisana. Prvo ćemo se pozabaviti sa sigurnošću, da bi shvatili šta je priroda problema. Kasnije, pogledajmo na zaštitne mehanizme i raspoložive modele koji nam pomažu da sačuvamo informacije na računaru.

Sigurnost je suočena sa više izazova. Tri važnija predstavljaju: prirodu prijetnji, priroda «uljeza» i slučajni gubitak podataka.

12.2 PrijetnjeSa sigurnosnog stanovišta, računarski sitemi imaju tri opšta cilja sa

odgovarajućim prijetnjama ka njima, kao što je prikazano na slici. Prvi cilj je povjerljivost podataka, pri čemu se mora obezbjediti da tajni podaci ostanu tajni. To znači, da ako vlasnik nekih podataka odluči da dozvoli pristup svojim podacima nekoj grupi korisnika a ne drugim, sistem bi trebao garantovati da neautorizivani korisnici ne mogu pristupiti tim podacima. Vlasnik bi trebao bar da može specificirati ko može pristupiti podacima i sistem bi morao da provodi ovu specifikaciju.

Cilj Prijetnja

Povjerljivost podataka Izlaganje podataka

Integritet podataka Učiniti ih «raskidivim»

Raspoloživost sistema Odbijanje servisa

Prijetnje 339

Drugi cilj, integritet podataka, znači da neautorizovani korisnici ne bi trebali biti u stanju da modifikuju bilo kakve podatke bez vlasničke dozvole. Modifikacija podataka, u ovom značenju, uključuje ne samo promjenu podataka već i brisanje i dodvanje lažnih podatka. Ako sistem ne može garantirati da smješteni podaci ostanu neizmjenjeni dok vlasnik ne odluči da ih izmjeni, onda ovakav pristup nije vrijedan za informacioni sistem. Integritet podataka je obično važniji od povjerljivosti podataka.

Treći cilj, raspoloživost sistema, znači da niko ne može uticati na sistem da dođe u nestabilno stanje. Takav napad na sistem se obično povećava. Na primjer, ako računar predstavlja Internet server, slanje previše zahtjeva ka njemu moglo bi ga onesposobiti uzimanjem njegovom procesorskog vremena i to ako ih samo prihvata, ispituje i odbacuje. Ako ova obrada traje, recimo, 100 µsec, onda onaj koji pošalje 10000 zahtjeva mogao bi dovesti server u nestabilno stanje (kada ne može da izvršava svoje servise onako kako bi trebalo). Modeli i tehnologije za rad sa napadom na povjerljivost i integritet podataka postoje dok je za odbijanje servisa (engl. denial service) borba prilično teška.

12.3 UljeziVećina ljudi se ponaša u skladu sa zakonom i često postavljamo pitanje

zašto se brinemo o sigurnosti. Brinemo se zato što postoji skupina ljudi koji bi željeli da naprave probleme (možda za svoje komenrcijalne svrhe). U literaturi, oni koji pokušavaju provaliti na sistem gdje oni nemaju pravo pristupa se nazivaju uljezima (engl. intruders) ili ponekad i suparnicima (engl. adversary). Uljezi rade na dva različita načina. Pasivni uljezi žele samo da čitaju datoteke za koje nisu autorizovani. Aktivni uljezi su zlonamjerni i žele da naprave izmjene za koje nisu autorizovani. Kada se projektuje operativni sistem, i kada je potrebno da se osiguramo od uljeza, veoma važno je znati o vrsti uljeza koji pokušavaju da pristupe sistemu. Neke kategorije su:

Slučajno radoznao netehnički korisnik: Mnogi ljudi imaju personalne računare na svojim stolovima i spojeni su na djeljene datotečne servere. U prirodi nekih ljudi je da pokušaju čitati datoteke ili elektronsku poštu drugih ljudi ako ne postoji zapreka za njihovo čitanje. Kod većine UNIX sistema, na primjer, svaka novoformirana datoteka je čitljiva za svakog.

Krađa iznutra (engl. Snooping by insiders): Studenti, sistem programeri, operatori i drugo netehničko osoblje često razmatra kao lični izazov da razbije siurnost na lokalnom računarskom sistemu. Oni su, često, vrlo vješti i željni da posvete značajno vrijeme svojim naporima (možda bi određeni pokušaji mogli napraviti novac). Neki programeri u bankama su pokušavali da ukradu novac u svojim bankama. Različite sheme postoje, od izmjene softvera tako da promjeni način zaokruživanja iznosa i da decimalni dio odlaže na svoj račun, do ucjena tipa «plati mi ili ću uništiti sve bankaske slogove».


Komercijalna i vojna špijunaža: Špijunaža se odnosi na ozbiljne i dobro podržane napade od konkurencije ili stranih zemalja da bi ukrali programe, poslovne tajne, patentirane ideje, tehnologije, projekte kola, poslovne planove i sl. Često ovi pokušaji će uključiti ožičavanje ili pravljenje usmjerenih antena ka računaru da bi pokupile njegovo elektromagnetno zračenje.

12.4 Zlonamjerni programiDruga kategoriaja sigurnosne zaraze predstavljaju zlonamjerni programi.

Pisac ovakvih programa je uljez, često sa veoma visokim tehničkim vještinama. Razlika između običnog uljeza od zlonamjernog je što prvi se odnosi na lice koji ličnio pokušava da probije sistem da bi uzrokovao štetu, dok drugi predstavlja program, napisan da bi uzrokovao štetu i navođen je ciljano na sistem.

12.5 VirusVećinu poznatih vrsta zlonamjernih programa predstavljaju virusi. Visrus

predstavlja dio koda koji se može reprodukovati, pišući svoj kod kao dodatak nekoj datoteci (što liči na sličan proces reprodukcije bioloških virusa). Pored vlastite reprodukcije, virusi mogu raditi i druge stvari. Na primjer, može štampati poruke, prikazati sliku na ekran, izvoditi muziku ili nešto, drugo, bezopasno. Nažalost, može i modifikovati datoteke, uništiti ih ili krasti datoteke slanjem elektronskom poštom.

Virus može raditi i druge stvari, recimo, da učini da je računar neupotrebljiv dok on radi. Ovo se naziva DOS napadom (engl. Denial Of Service). Uobičajeni pristup je da se koriste računarski resursi, takvi ka što je procesor, ili da se disk puni datoteke nevrijednog sadržaja. Virusi kao i drugi programi mogu uzrokovati DDOS napad (engl. Distributed Denial Of Service). U ovom slučaju virusi ne rade ništa po instalaciji na na računar. U predefinisano vrijeme i datum, hiljade kopija virusa na računarima širom svijeta počnu otvarati web stranice ili počnu koristiti druge mrežne servise od ciljnog računara, na primjer Web servera političke partije ili neke složene organizacije. Ovo dovodi do preopterećenje ciljnog servera ili mrežnih servisa.

Zlonamjerni programi se često kreiraju zbog zarade. Većina neželjene elektronske pošte («spam») je povezana sa konačnim odredištima preko mreže računara koji su zaraženi sa virusima ili drugim oblicima zlonamjernim programima. Računar zaražen sa ovakvim programom postaje rob i izvještava status svojem gospodaru što je veoma često na Internetu (odnos master slave). Master šalje spam da bude povezan sa svim e-mail adresama na slave računarima. Druga vrsta zlonamjernog programa instalira proces za prijavu korisnika ma zaraženi računar. Ovaj proces zapisuje sve što se zapisuje na tastaturi. Na taj način dolazi do korisničkih imena i lozinki, brijeva kreditnih kartica kao i datuma njihovog nevaženja. Takve informacije se šalju ka master računaru i onda mogu biti korišćene ili prodane za kriminalne radnje.

Crv 341

12.6 CrvDok se virus širi lijepljenjem na drugi program i izvršava se kada se program na

koji je zalijepljen izvršava, crv predstavlja neovisan program. Crvi se šire korišćenjem mreže za prenos sopstvenih kopija na druge računare. Widows sistemi uvijek imaju startup direktorij za svakog korisnika. Bilo koji program koji se nalazi u tom direktoriju će se izvršiti kada se korisnik prijavi. Ono što treba da crvi urade je da stave svoj kod u taj Startup direktorij (ili kraticu na njega) na udaljenom računaru. Efekat crva može biti isti kao kod virusa. I zaista, razlika između crva i virusa često nije jasna. Neki zlonamjerni programi koriste obje metode da se prošire.

12.7 TrojanacDruga kategorija zlonamjernih programa predstavlja trojanac. Ovo je program

koji izgleda da izvršava važeće funkcije neke igre ili «poboljšane» verzije nekog korisničkog programa. Ali kada se trojanac izvršava onda se izvršavaju i neke druge funkcije, možda se pokreće crv ili virus ili izvršava neku od zlonamjenih stvari koje se zahtjeva. Efekati trojanskog konja treba da budu tihi i nečijni. Nasuprot crvima i virusima, trojance skidaju korisnici sa Interneta i čim se prepoznaju, biće izbrisani.

12.8 Logička bombaDruga vrsta zlonamjernih programa predstavlja logička bomba. Ona predstavlja

dio koda napisan od nekog programera iz firme u kojoj je zaposlen, i tajno unesen u operativni sistem. Svaki put kada se programer prijavi na računar on ne radi ništa. Međutim, ako je programer slučajno otpušten iz firme i fizički mu prava pristupa uklonjena bez najave, sljedeći dan, kada se korisnik ne prijavi, aktivira se logička bomba koja može uključivati brisanje diska, brisanje datoteka, enkripcija važnih datoteka. Firma je u situaciji ili da zove policiju ili da zove bivšeg programera kao «konsultanta» dajući mu astronomski iznos da bi rješio problem (u nadi da ne planira instalirati novu logičku bombu).

12.9 SpywereJoš jedan oblik zlonamjernih programa predstavlja spyware. Obično se dobija

posjećivanjem web stranica. U najednostavnojoj formi, spyware može biti cookie. To su male datoteke koje se izmjenjuju između web browser-a i web servera. One sadrže neke informacije koje dozvoljavaju Web stranici da vas identificira. To je nešto kao tiket koji dobijete kada ostavite biciklo da vam se popravi. Kada se vratite u radnju, važeg pola tiketa služi da se pronađe biciklo koje ste ostavili. Web konekcije nisu stalne, tako, na primjer, ako ste zainteresovani da kupovinu knjige pri posjeti nekoj online knjižari, ona traži od vašeg browsera da prihvati cookie. Kada završite sa pregledavanjem i drugi put odlučite da izaberete drugu knjigu, onda se od browsera traži da vrati informacije smještene ranije kako bi generisao listu onoga što je nekad bilo traženo.


Ono što je ružno, je što postoji način da web stranica može biti u stanju da pokupi izvršni program na vašem računaru. Mnogi browseri prihvataju plug-ins da bi dodali neke funkcije takvih kao prikazivanje novih vrsta datoteka. Korisnici često prihvataju nove plug-in-e bez dovoljnog znanja šta oni rade. Jedna greška u browseru može dozvoliti udaljenom računaru da instalira neželjeni program, možda poslije «mamljenja» korisnika na stranicu koja je pažljivo konstruisana i ranjiva. U bilo koje vrijeme ako korisnik prihvati pristup takvoj stranici, dobrovoljno ili ne, postoji rizik da taj pristup sadrži kod koji bi mogao nanijeti štetu.

12.10 Slučajan gubitak podatakaKao dodatak prijetnjama uzrokovanih od nepoželjnih uljeza, vrijedni podaci mogu

se izgubiti i slučajno. Neki od uobičajenih uzroka gubitka podataka predstavljaju: vatra, poplava, zemljotres, ratovi, ili miševi koju su stigli do traka i disketa.

Hardversko softverske greške: procesor ne funkcionira, nečitljivi diskovi ili trake, greške na telekomunikacijama, programske greške.

Vrlo česta grupa softverskih grešaka je prekoračenje bafera. Ona se pored ovoga, može iskoristiti od strane napadača na sistem.U sljedećem primjeru:char A[8] = {};unsigned short B = 1979;strcpy(A, "excessive");

neće biti promijenjena samo varijabla A, nego i varijabla B. Sličnim principom se mogu mijenjati i povratne adrese iz podprograma i tako forsirati izvršenje koda na inače nedostupnom mjestu

Da se ne ostave ovakve sigurnosne rupe, uvijek koristiti sistemske pozive koji provjeravaju dužine nizova, npr strncopy.

Ljudske greške: nekorektan unos podataka, montiranje pogrešne trake ili diska, loše izvođenje programa, izgubljena traka ili disk, ili neka druga greška.

Većina ovih problema se mogu riješiti sa adekvatnim backup-om, koji je dovoljno udaljen od originalnih podataka.

12.11 Uobičajeni sigurnosni napadiNalaženje sigurnosnih šupljina nije jednostavno. Uobičajen način za

testiranje sigurnosti sistema je da se iznajmi grupa eksperata, poznatih kao tim za pronalaženje sigurnosnih rupa (engl. penetration team, ili tigers team), da bi se vidjelo da li su oni u stanju da izvrše proboj u sistem. Hebbard i ostali (1980) su pokušali da sa studentima postdiplomcima. Ovi timovi su otkrili jedan broj oblasti u kojima će sitemi vjerovatno biti slabi. U nastavku su nabrojani neki od uobičajenih napada koji su često uspješni. Kada projektujete sistem, potrebno je da se osigurate da sistem može odoljeti napadima kao što je ovaj. U nastavku su navedeni problemi na koje treba obratiti pažnju:

Uobičajeni sigurnosni napadi 343

1. Zahtjev za čitanjem memorijskih stranica, diskovnog prostora ili traka. Mnogi sistemi ih ne brišu prije alokacije i oni mogu biti interesantni nekome a predstavljaju informacije od prethodnog korisnika.

2. Pokušaj sa ilegalnim sistemskim pozivom, ili legalan sistemski poziv sa nelegalnim parametrima, ili legalan sistemski poziv sa legalnim ali neočekivanim vrijednostima parametara. Mnogi sistemi mogu doći u prilično zbunjujuće stanje.

3. Počni prijavu korisnika i pristisni DEL, RUBOUT ili BREAK u toku sekvence prijave korisnika. U nekim sistemia, program za kontrolu lozinke će biti uništen i prijava će biti uspješna.

4. Pokušaj mjenjati kompleksne strukture operativnog sistema koje se čuvaju u korisničkom adresnom prostoru. U nekim sistemima ( posebno na velikim mašinama, mainframes), kod otvaranja datoteke, program pravi velike strukture podataka koje sadrže ime datoteke i mnoge druge parametre i proslijeđuje ih sistemu. Čim se datoteka pročita, ili piše, sistem sam ažurira strukturu podataka. Promjene ovih polja bi mogle da promjene ponašanje programa u izvođenju i na taj način stvoriti šupljinu u sigurnosti sistema.

5. Ometanje korisnika pisanjem programa koji štampa "login:" na ekranu i slično.

Mnogi korisnici će unijeti ime i lozinku i šalje onom kome treba.6. Pogledaj u manual-e i djelove koji kažu "Nemoj uraditi X." Pokušaj sa

mnogim varijacijama X.7. Ubjedi sistemskog programera da promjeni pristup sistemu kako bi

zaobišao izvjesne ključne sigurnosne prepreke za sve korisnike sa vašim imenom. Ovaj napad je poznat kao «trap door».

8. Ako je sve u redu, onaj koji probija u sistem može naći sekretaricu direktora računarskog centra i ponuditi joj veliki novac. Sekretarice često imaju pristup svim vrstama korisnih informacija i obično su slabo plaćene. Nemojte podcjeniti ovaj problem koji dolazi od osoblja.

12.12 Principi projektovanja sigurnostiSaltzer i Schroeder (1 9 75 ) su identificirali nekoliko opštih principa koji se

mogu koristiti kao vodič za projektovanje sigurnosnih sistema. Kratak sadržaj njihovih ideja baziranih na iskustvu sa MULTICS-om je prikazano u nastavku.

1. Projektovanje sistema bi trebalo biti javno. Pretpostavljajuči da uljez ne zna kako sistem radi služi samo da se zavedu projektanti.

2. Pristup ne bi smio biti definisan unaprijed (kao default). Na taj način, greške koje se pojavljuju kod prijave legalnog korisnika a odbijen je će biti uočene znatno brže nego greške koje se pojave kod prijave neautorizovanih korisnika.

3. Provjera tekuće autorizacije. Sistem ne bi trebao kontrolisati permisije da bi odredio da je pristup dozvoljen, i onda skloni ove informacije za sljedeće upotrebe. Mnogi sistemi kontrolišu permisije kada se otvara datoteka a ne poslije. Ovo znači da korisnik koji je otvorio datoteku i drži je otvorenom sedmicama će imati i dalje stare permisije čak iako je vlasnik davno promjenio permisije datoteke.


4. Dati svakom procesu najmanje moguće privilegija. Ako editor ima samo prava za pristup datoteci koju obrađuje (koja se navodi po pozivu editora), editori sa trojancem neće biti u stanju da naprave mnogo štete. Ovaj princip predstavlja zaštitnu shemu fine granulacije.

5. Zaštitni mehanizmi bi trebali biti jednostavni, uniformni i ugrađeni u najniže nivoe sistema. Pokušavajući da podesimo sigurnost na postojećem nesigurnom sistemu je skoro nemoguće. Sigurnost nije karakteristika koja se postiže dodavanjem zakrpa.

6. Izabrana shema mora biti prihvatljiva. Ako korisnici osjete da zaštita njihovih datoteka predstavlja puno rada, oni je neće ni raditi. Šta više, oni će se glasno žaliti ako se nešto loše desi. Odogovori tipa „To je tvoja greška“ neće biti dobro primljena.

12.13 Autentifikacija korisnikaMnoge zaštitne sheme su bazirane na pretpostavkama da sistem zna identitet

svakog korisnika. Problem identifikacije korisnika kada se prijavljuju na sistem se naziva autentifikacija korisnika. Većina autentifikacionih metoda su bazirane na identifikaciji nečeg što korisnik zna, nečeg što korisnik ima ili nečeg što je korisnik.

12.14 LozinkeVećina, široko korišćenih, oblika autentifikacije zahtjeva od korisnika da

unese lozinku. Zaštita lozinkom je jednostavna za shvatiti a i jednostavna za implementaciju. U unix-u se izvodi ovako: program za prijavu traži od korisnika da unese svoje ime i lozinku. Lozinka se odmah šifrira. Zatim program za prijavu čita datoteku lozinki u kojoj se nalazi niz ascii linija, po jedna za korisnika, dok ne nađe liniju koja sadrži ime korisnika. Ako je šifrirana lozinka ista sa šifriranom lozinkom kod prijave, pristup je dozvoljen inače se odbija. Lozinke se lako probijaju. Često ste čuli priču u kojoj studenti ili čak i srednjoškolci na svojim računarima izvršavaju proboje u neke sisteme sa vrunskim tajnama velikih korporacija ili vladinih agencija. U suštini, proboj se sastoji od pogađanja kombinacije korisničkog imena i lozinke.

Jedan od načina proboja je prikupljanje liste vjerovatnih lozinki: prvo i posljednje ime, imena ulica, imena gradova, fudbalskih klubova, riječi iz rječnika srednje veličine zajedno sa verzijama tih rječi čitanih unazad. Ako se sve lozinke sastoje od 7 znakova izabranih slučajno od 95 ascii znakova, prostor za

pretraživanje postaje 957

što je 7x 1013

. Vršeći 1000 kriptiranja u sekundi, trebaće 2000 godina da se napravi potpuna lista i iskontroliraju sve. Ako se pak zahtjeva od lozinki da sadrže bar jedno malo slovo, bar jedno veliko slovo i jedan specijalan znak i da bude bar 7 znakova duga lozinka će biti osnovno poboljšanje kod davanja loziniki. Danas se koristi sličan kriterij kompleksnosti kod Windows-a, stim da je lozinika valjana ako ima u sebi bar tri vrste znakova od mogućih 4 skupina znakova: brojevi, mala slova, velika slova i specijalni znaci.

Lozinke 345

Čak iako se smatra nemogućim da se zahtjeva od korisnika da uzimaju korektne lozinke, Morris i Tompson su opisali tehniku koja će učiniti njihov sopstveni napad (enkripcijom velikog broja lozinki unaprijed) gotovo nekorisnim. Ideja je da se pridruži slučajan broj dužine n bita svakoj lozinki. Slučajan broj se mjenja kad god se lozinka mjenja. Slučajan broj se smješta u datoteku u nekreptiranom obliku, tako da ga svako može pročitati. Umjesto da se kriptirane lozinke smještaju u datoteku lozinki, prvo se lozinika i slučajan broj spoje i onda kriptiraju zajedno i kao takav se smješta u datoteku lozinki.

Sada razmotrimo posljedicu da uljeze koji bi željeli da naprave listu vjerovatnih lozinki, koje će šifrirati i sačuvati u datoteku f, tako da bilo koja kriptirana lozinka može se brzo naći. Ako uljez sumnja da bi lozinika mogla biti Marilyn, više nije dovoljno da tu lozinku kriptira i stavi je u datoteku f. On treba

da kriptira 2n

lozinkiitakvi kao što su Marilyn0000, Marilyn0001, Marilyn0002 i dalje i sve ih

stavi u datoteku f. Ova tehnika povećava veličinu datoteke f sa 2n

. UNIX koristi metodu sa n=12. Neke verzije Unixa čine da je datoteka lozinki nečitljiva ali obezbjeđuje program da pretraži elemente po zahtjevu, dodavajući malo kašnjenje koje značajno usporava bilo kojeg intruder-a.

Mada ova metoda nudi zaštitu od uljeza koji pokušavaju da dobiju lozinke iz velike liste kriptiranih lozinki, ne radi se ništa da se zaštiti korisnik David čija je lozinka David. Jedan od načina je da ohrabrite ljude da izabiraju bolje lozinke je da imate ponudu od računara unaprijed. Neki računari imaju programe koji generišu slučajno riječi koje se jednostavno izgovaraju koje se mogu koristiti kao lozinke (poželjno bi bilo da imaju i velika slova i neki specijalni znak). Drugi računari zahtjevaju od korisnika da promjene svoje lozinke da bi se zaštitili od prouzorokovane isticanjem važnosti lozinke. Najekstremniji oblik ovog pristupa su jednovremene lozinke. Kada se koriste jednovremene lozinke, tada se koristi lista lozinki. Svaki korisnik koristi sljedću lozinku u listi. Ako uljez ikada otkrije lozinku, neće mu biti od koristi jer se kod sljedeće prijave mora koristiti druga lozinka. Ovdje je opasno da se ne izgubi lista lozinki.

U toku unošenje lozinke ne dolazi do prikazivanja znakova na ekranu, da bi zaštitio od radoznalih koji se nalaze blizu terminala. Lozinke ne bi trebalo nikada smještati u nekriptiranom obliku. Šta više, ni uprava računarskog centra ne bi imala nekriptirane lozinke. Držanje nekriptiranih lozinki je opasno i može prouzročiti nevolje.

Jedna varijacija kod izdvanja lozinki je da svaki korisnik ima dužu listu pitanja i odgovora koji se smještaju u kriptiranom obliku. Pitanja bi bila takva da imaju jasne odgovore. Tipična pitanja su: Kako se zove tvoja sestra? U kojoj ulici se nalazi osnovna škola? Da li je gospodin X.Z profesor? Kod logiranja, računar postavlja pitanja po slučajnom izboru i provjerava odgovore. Jedna varijacija na ova pitanja je postavljanje pitanja koja u sebi imaju formulu, racimo


x2

. Kada se korisnik prijavljuje i računar odštampa, recimo 7, tada korisnik treba da napiše 49. Ovaj algoritam može biti različit prije podne i poslije podne, u različite dane u sedmici, sa različitih terminala i sl.

12.15 Fizička identifikacijaPotpuno različit pristup kod autorizacije je da se provjeri kako bi se vidjelo

da li korisnik ima neki element, plastičnu karticu sa magnetnom trakom na njoj. Kartica se ubaci u terminal koji onda kontroliše čija je kartica. Ova metoda se kombinuje sa lozinkom tako da se korisnik može prijaviti samo a) ako ima karticu i b) zna lozinku. Automatske mašine za izdavanja novca, obićno, rade na ovom principu.

Još jedan pristup je da se mjere fizičke karakteristike koje je teško krivotvoriti. Na primjer, otisak prsta ili čitač zapisa glasa na terminalu bi mogao provjeriti korisnički identitet.

Još jedna tehnika se naziva analiza potpisa. Korisnik se potpisuje sa specijalnim perom spojenim na terminal i računar provjerava sa zapisanim primjerkom potpisa. Čak bolje je da se ne provjerava potpis nego da se provjeravaju kretnje pera koje se prave kod potpisivanja. Dobar falsifikator bi nogao kopirati potpis ali ne bi imao osjećaj o tačnim pokretima koje izvodi.

Analiza dužine prsta je iznenađujuće praktična. Kada se koristi, svaki terminal ima uređaj kao što je prikazan na slici. Korisnik ubaci svoju ruku i tada se mjeri dužina svakog od njegovih prstiju i porede sa onim zapisanim u bazi podataka.

Metode kao analiza krvi i analiza mokraće, nisu prihvatljive za korisnika.

12.16 ProtumjereRačunarske instalacije koje su ozbiljne u vezi sigurnosti preduzimaju korake kako

bi autorizacija korisnika postala složenija. Na primjer, svakom korisniku bi moglo biti dozvoljeno da se prijavi samo sa određenog terminala i samo u toku nekih dana u sedmici i sati u danu.

Protumjere 347

Rad sa telefonskim linijama bi trebao da izgkleda ovako. Ako se neko pokuša prijaviti putem telefonske linije, poslije uspješne prijave, sistem bi trebao odmah prekinuti vezu i pozvati korisnika po dogovoru koristeći njegov broj. Ova mjera znači da uljez ne može pokušavati proboj sa različitih linija, nego samo sa korisničkog telefona bi se moglo prijaviti. U bilo kojem događaju, sa ili bez poziva korisnika koji je zvao, sistem bi trebao bar 10 sec da provjeri neku lozinku i trebao bi povećati ovo vrijeme poslije nekoliko neuspješnih pokušaja u cilju da smanji intenzitet pokušaja uljeza. Poslije tri neuspješna pokušaja, liniju bi treablo prekinuti na 10 minuta i o tome obavjestiti osoblje sigurnosti. Sve prijave bi trebalo zapisivati. Kada se korisnik prijavi, sistem bi trebao ispisati vrijeme i terminal predhodne prijave tako da se može detektovati moguće probijanje sistema.

Sljedeći korak je postavljanje zamke kako bi se uhvatili uljezi. Najednostavnija shema je da se ima posebno ime za prijavu sa jednom jednostavnom lozinkom (t.j. korisničko ima: gost, Lozinka: gost). Kada se neko prijavi koristeći ovaj račun (korisničko ime i lozinka), specijalisti sigurnosnog sistema su odmah obavješteni.

12.17 Zaštitni mehanizmiU sljedećem dijelu koncentrisaćemo se na detaljne tehničke specifikacije

koje se koriste u opercionim sistemima da bi se zaštitile datoteke. Sve ove tehnike prave jasnu razliku između politika (čije podatke treba štititi i od koga) i mehanizama (kako sistem provodi politiku). Odvajanje politike od mehanizama je diskutovano u Sandhu (1 9 93 ). Pristup u ovom djelu biće na mehanizmima a ne na politikama.

U nekim sistemima, zaštita se provodi sa programom nazvanim referentni monitor. Svaki put kada se pokuša pristup ka možda zaštićenom resursu, sistem prvo pita referentni monitor da provjeri legalnost pristupa. Referentni monitor onda pregledava tabele politika i pravi odluke. U nastavku, opišimo okolinu u kojoj referentni monitor funkcioniše.

12.18 Zaštitni domeniRačunarski sistem sadrži mnoge „objekte“ koji treba da budu zaštićeni. Ovi

objekti mogu da budu hardver (t.j. procesori, memorijski segmenti, diskovni uređaji, ili štampači), ili mogu da budu i softver (t.j. procesi, datoteke, baze podataka, ili semafori). Svaki objekt ima jedinstveno ime preko koga mu se pristupa, i konačan skup operacija kojima im proces može pristupati. Operacije read i write su odgovarajuće operacije za datoteke, operacije up() i down() su za semafore. Jasno je da je potreban način da se zabrani pristup procesa objektima za koje nije autorizovan. Šta više, mehanizam mora napraviti mogućnost da se ograniče procesi na skup legalnih operacija kada je potrebno. Na primjer, proces A može biti namjenjen za čitanje datoteke F a ne i za pisanje.


U cilju da diskutujemo o različitim zaštitnim mehanizmima, korisno je da se uvede koncept domena. Domen je skup parova ( objekata, prava). Svaki par specificira objekt i jedan podskup operacija koje se mogu izvršiti na njemu. Pravo u ovom kontekstu, znači dozvolu da se izvrši jedna od operacija. Često jedan domen odgovara jednom korisniku, koji govori šta korisnik može a šta ne može da uradi, mada domen može biti opštiji nego samo za jednog korisnika.

Slika prikazuje tri domena, pokazujući objekte u svakom domenu i prava [Read, Write, eXecute] raspoloživa za svaki objekt. Primjetimo da Printer1 se nalazi u dva domena u isto vrijeme. Mada nije prikazano u ovom primjeru, moguće je da isti objekat bude u više domena, sa različitim pravima u svakom domenu.

Slika Tri zaštitna domena.

U svakom trenutku vremena, svaki proces se izvršava u nekom zaštitnom domenu. Drugim rječima, postoji neki skup objekata kojima može pristupiti, i za svaki objekt ima neki skup prava. Procesi mogu izmjeniti domen u toku izvršavanja. Pravila za izmjenu domena su jako zavisna od sistema.

Da bi napravili ideju zaštitnih domena konkretnijom, pogledajmo što imamo u Unixu. U Unixu, domen procesa je definisan sa njegovim UID i GID. Dajući bilo koju kombinaciju (UID, GID), moguće je napraviti potpunu listu svih objekata (datoteka, uključujući i U/I uređaje predstavljene sa specijalnim datotekama, i sl. ) kojima se može pristupiti, i njima se može pristupiti za pisanje, čitanje ili izvršavanje. Dva procesa sa istom kombinacijom (UID, GID) će imati pristup istom skupu objekata. Procesi sa različitim parom (UID, GID) će imati pristup različitom skupu datoteka, mada se mogu značajano poklapati u večini slučajeva.

Dakle, svaki proces u UNIX-u ima dvije polovine: korisnički dio i sistemski dio. Kada proces izvrši sistemski poziv, on vrši izmjenu domena iz korisničkog u sistemski dio. Sistemski dio ima pristup različitom skupu objekata od korisničkog dijela. Na primjer, sistem može pristupati svim stranicama u sistemskoj memoriji, cijelom disku i svim drugim zaštićenim objektima. Dakle. Sistemski poziv uzrokuje izmjenu domena. Kada jedan proces uradi exec nad datotekom sa SETUID ili SETGID bitom postavljenim, on dobija nove stvarne UID ili GID. Sa različitom kombinacijom (UID,GID), on ima različit skup datoteka i raspoloživih operacija. Izvršavanje programa sa SETUID ili SETGID takođe predstavlja izmjenu domena, pošto se raspoloživa prava mjenjaju.

Važno pitanje je kako sistem održava evidenciju koji objekt pripada kojem domenu. Održava se sa matricom, sa vrstama koje predstavljaju domene i kolonama koje predstavljaju objekte. U svakom elementu matrice se nalaze prava

Zaštitni domeni 349

prirtupa, ako postoje, za dati objekt i domen. Matrica za sliku tri zaštitna domena je prikazana na s l jedećoj slici. Sa ovom matricom i tekućim brojem domena sistem može kazati kakav je pristup dozvoljen navedenom objektu.

Sama izmjena domena može se lako uključiti u model matrice tako što će sam domen predstavljati objekt, sa operacijom ulazak u domen. N a s l j e d e ć o j s l i c i s e v i d i r a n i j e p o me n u t a ma t r i c a , ali sada sa tri domena i samim objektima. Proces u domenu 1 može preći u domen 2, ali poslije toga se ne može vratiti. Ova situacija modelira izvršenje jednog SETUID programa u UNIX-u. Ostale izmjene domena nisu dozvoljene u ovom primjeru.

Zaštitna matrica sa domenima kao objektima

12.19 Liste kontrola pristupaU praksi, smiještanje matrice prava pristupa predstavlja smiještanje rijetke

matrice jer je velika i nepupunjena. Većina domena nema pristupa večini objekata, tako da smiještanje vrlo velike, gotovo prazne matrice predstavlja gubitak smještajnog prostora. Dvije praktične metode se koriste za smiještanje matrice, smiještanje nepraznih elemenata po vrstama i po kolonama.

Prva tehnika se sastoji od pridruživanja svakog objekta jedne uređene liste koja sadrži sve domene koji mogu pristupiti objektu i kako. Ova lista se naziva kontrolnom listom pristupa ili ACL i prikazana je na narednoj slici. Ovdje se vide tri procesa, od kojih svaki pripada različitom domenu, A, B i C i tri datoteke F1, F2 i F3. Radi jednostavnosti, pretpostavimo da svaki domen odgovara po jednom korisniku, u ovom slučaju, korisnicima A, B i C.

Korišćenje liste kontrole pristupa da bi se upravljalo pristupom datoteci


Svaka datoteka ima jednu ACL kojoj joj je pridružena. Datoteka F1 ima dva elementa u svojoj ACL (odvojene sa ;). Prvi element kaže da bilo koji proces čiji je vlasnik A može čitati i pisati datoteku. Drugi element kaže da bilo koji proces korisnika B može čitati datoteku. Svi drugi pristupi od strane ovih korisnika i svi drugi pristupi od drugih korisnika su zabranjeni. Primjetimo da su prava dodjeljena od strane korisnika a ne od procesa. Nije važno da li korisnik ima jedan ili sto procesa, posmatra se vlasnik a ne ID procesa.

Datoteka F2 ima tri elementa u svojoj ACL: A, B i C mogu čitati datoteku pri čemu B je može i pisati. Drugi pristupi nisu dozvoljeni. Datoteka F3 je očigledno jedna izvršna datoteka, pošto B i C mogu i čitati i izvršavati datoteku. Pored toga B je može i pisati.

Ovaj primjer ilustrira većinu osnovnih oblika zaštite koristeći ACL. Složenije sheme se često koriste u praksi. Da bi počeli sa ovim, za sada imamo tri prava pristupa: čitanje, pisanje i izvršavanje. Pored njih mogu postojati i dodatna prava. Neka od njih mogu biti opšta, i koja se primjenjuju na sve objekte, a neka mogu biti specifična objektima. Primjeri opštih prava su uništi objekt i kopiraj objekt. Oni bi se mogli održavati za svaki objekt bez obzira kojeg su tipa. Prava specifična objektima mogu uključivatu dodavanje poruke u mailbox objekt i alfabetsko sortiranje objekta direktorij.

Za sada, naši ACL elementi su predstavljeni za pojedinačnog korisnika. Mnogi sistemi podržavaju koncept grupe korisnika. Grupe korisnika imaju imena i mogu se uključiti u ACL. Moguće su dvije varijacije u značenju grupe. U nekim sistemima, svaki proces ima korisničku identifikaciju, ID (UID) i identifikaciju grupa GID. U takvim sistemima, element ACL sadrži elemente oblika

UID1, GID1: pravo_pristupa1; UID2, GID2: pravo_pristupa2; ...Pod ovim uslovima, kada se napravi zahtjev za pristup objektu, provjera se

vrši koristeći UID i GID pozivaoca. Ako su prisutni u ACL, navedena prava pristupa su na raspolaganju. Ako par (UID, GID) nije u listi, pristup nije dozvoljen. Koristeći grupe na ovaj način, u suštini se uvodi koncept svojstva. Razmotrimo jednu instalaciju u kojoj je Tana administrator sistema i na taj način je u grupi sysadm. Međutim, pretpostavimo da firma ima i neke klubove za zaposlene i da je Tana član i kluba XYZ i ima pristup podacima koji se nalaze u bazi XYZ za klub. Dio ACL bi mogao izgledati kao što je prikazano na narednoj slici.

Liste kontrola pristupa 351

Slika Dvije liste kontrole pristupa

Datoteka Lista kontrole pristupa

Lozinka tana, sysadm: RW

XYZ_data bill, XYZ: RW; tana, XYZ: RW; ...

Ako Tana pokušava da pristupi jednoj od ovih datoteka, rezultat zavisi u kojoj grupi je trenutno prijavljena. Kada se prijavljuje, sistem je može da pita koju grupu će koristiti, pri čemu različite grupe mogu imati razlićite parove (korisničko ime, lozinka). Suština ovakve sheme je da se spriječi Tana da pristupa datoteci lozinki kada se nalazi prijavnjena na klub XYZ. Ona to može raditi samo ako se prijavi kao administrator sistema.

U nekim sistemima, korisnik smije imati pristup nekim datotekama nezavisno kojoj grupi pripada i kako je prijavljen. Ovaj slučaj može se ozčaiti sa *, koja znači sve pristupe. Na primjer

tana, *: RWće za datoteku lozinki dati Tani pristup nez obzira na koju je grupu

trenutno prijavljena.Još jedna mogućnost je da ako korisnik pripada bilo kojoj grupi koje imaju

neka prava, kod prijave korisnika prava su mu dozvoljena. U ovom slučaju, korisnik koji pripada u više grupa ne mora navoditi grupu u kojoj treba da radi pri čemu su njegova sva prava pristupa dozvoljena. Mana ovakvog pristupa je što obezbjeđuje manju zaštitu podataka: Tana bi mogla editovati datoteku lozinki na sastanku kliba XYZ.

Korišćenje grupa i * uvodi mogućnost odabranog blokiranja specifičnih korisnika da pristupi datoteci. N aprimjer, element

virgil, *: (none); *, *: RWdaje svima pristup za čitanje i pisanje, osim Virgil-u. Ovo funkcionira zato

što se elementi liste skeniraju u redosljedu i kada se prvi primjeni postaje važeći i sljedeći se ne ispituju. Čim se pronađe Virgil na prvom elementu liste i njegova prava pristupa, u ovom primjeru nikakva, odmah se primjenjuju. Pretraživanje se obustavlja u ovoj tački. Činjenica da svi ostali imaju pristup nikada se nije tražila.

Drugim rječima pri radu sa grupama nije dovoljno da imamo elemente ACL koji imaju parove (UID, GID), već da imamo da svaki element se nađe u UID ili GID. Na primjer, element XYZ_data mogla bi biti

debbie: RW; phil: RW; pigfan: RWšto znači da Debbie i Phil, i svi članovi XYZ grupe imaju pristupe za čitanje i

pisanje nad datotekom.Ako se nekada desi da korisnk ili grupa ima neke dozvole pristupa s

obzirom na datoteku koje vlasnik datoteke želi da poništi. Sa listom kontole pristupa, relativno je jasno da se ponište prethodno dodjeljenja prava. Sve što treba uraditi je da se naprave izmjene u ACL. Međutim, ako se lista kontrolira samo


kod otvaranja, mnoge promjene će se reflektovati kasnije kod ponovnog otvaranja, čak i u slučajevima kada korisnik više nije autorizovan da pristupi datoteci.

12.20 Liste mogućnostiDrugačiji način pogleda na matricu prava je preko vrsta. Kada se ova metoda

koristi, svakom procesu se pridružuje lista objekata kojima se može pristupiti zajedno sa indikacijom koje operacije su dozvoljene na svakom objektu, drugim rječima u njihovim domenima. Ova lista se naziva listom mogućnosti (engl. capabilities) ili C- lista a pojedini elementi u listi se nazivaju mogućnostima (Dennis and Van Horn, 19 6 6 ; Fabry, 1974). Skup od tri procesa i njihove C-liste su prikazane na narednoj slici.

Svaka C-lista daje vlasniku neka prava na nekom objektu. Proces čiji je vlasnik korisnik A može čitati datoteke F1 i F2. Obično se mogućnosti odnose na identifikator datoteke (kada uopšteno kažemo objekat) i bitmapu koja se odnosi na različita prava pristupa. U Unix sistemima, identifikator datoteke bi vjerovatno mogao biti broj indeksnog čvora. C-liste predstavljaju objekte i na njih se može pokazivati iz drugih C-lista i na taj se način postiže djeljenje poddomena.

Potpuno je jasno da C-liste moraju biti zaštićene od neovlašćenog pristupa korisnika. Poznate su tri metode za zaštitu.

1. zahtjeva se da računar ima označenu arhitekturu (engl. taggedarchitecture), hardver je projektovan na takav način da svaka memorijska riječ

ima jedan dodatni bit koji kaže da li riječ sadrži capability ili ne. Ovaj bit se ne koristi u aritmetičkim operacijama, kao i operacijama poređenja i običnim instrukcijama i može se promjeniti samo sa programima koji se izvršavaju u sistemskom načinu rada (t.j. operativnim sistemom). Računari sa ovakvom arhitekturom su izgrađeni i mogu se napraviti da rade dobro. Popularni primjer ovakve arhitekture predstavlja računar IBM AS/400.

2. drugi način predstavlja držanje C-liste unutar operativnog sistema.Mogućnosti se onda odnose na poziciju u C-listi. Proces može izdati komandu

«Čitaj 1 KB iz datoteke na koju pokazuje mogućnost 2». Ovaj oblik adresiranja je sličan korišćenju datotečnih deskriptora u Unix-u. Hydra radi na ovaj način.

3. Ovaj način podrazumjena držanje C-liste u korisničkom adresnom prostoru, ali se upravlja sa C-listom koja je kriptirana tako da joj korisnik ne može

Liste mogućnosti 353

prići i mjenjati je. Ovakav pristup je posebno pogodan za distribuirane sisteme i radi na sljedeći način. Kada proces klijent pošalje poruku udaljenom serveru, na primjer, datotečnom serveru, da bi kreirao jedan objekt za njega, server kreira traženi objekt i generiše slučajan broj tipa long i kontrolno polje koje ide sa njim. U tabeli datoteka na serveru se vrši rezervacija ovog objekta zajedno sa ovim kontrolnim poljem i adresama diskovnih blokova i sl. Kod Unix-a, ovo kontrolno polje se smješta u indeksni čvor datoteke na serveru. Ono se ne šalje nazad korisniku i nikada se šalje na mrežu. Server zatim generiše mogućnost za tu datoteku ka korisniku kao što je prikazano na narednoj slici.

Slika Capability zaštićena kriptiranjem

Server Objekat Prava_pristupa f(Objekat,Prava_pristupa,kontrolno _polje)

Capability koja se vrati korisniku sadrži identifikator servera, broj objekta (indeks u tabelu datoteka na serveru, u stvari broj indeksnog čvora), njegova prava pristupa smještena kao bipmapa. Za novi objekat, sva prava pristupa će se postaviti. Posljednje polje se sastoji od spajanja objekta, prava pristupa i pomoćnog polja kortisteći jednosmjernu funkciju f nad kriptiranim poljima.

Kada korisnik želi da pristupi objektu, on šalje u svom zahtjevu serveru i njegove mogućnosti pristupa objektu. Server iz poruke izvadi broj objekta koji mu služi da pronađe objekat u tabeli objekata. On onda izvršava funkciju f(Objekat, Prava_pristpa, kontrolno_polje) uzimajući prva dva parametra iz poslane mogućnosti i treći iz svoje sopstvene tabele. Ako se rezultat poklapa sa četvrtim poljem u capabulity-u, zahtjev se odobrava, inače se odbija. Ako korisnik pokuša da pristupi nekom drugom objektu na serveru, s obzirom da ne može da napravi četvrto polje korektno pošto ne zna kontrolno polje, zahtjev će se odbiti.

Korisnik može tražiti od servera da omogući slabiji pristup, na primjer «samo za čitanje». Prvo što radi server je da provjerava da li odgovarajuće pravo pristupa postoji. Ako postoji, on izračunava f(Objekat, Nova_prava_pristpa, kontrolno_polje) i generiše nove mogućnosti za objekt i smješta ih u četvrto polje. Primjetimo da se kontrolno polje koristi jer realizacija dolazećih zahtjeva zavise od njega.

Ova novogenerisana mogućnost pristupa objektu se vraća procesu koji je tražio pristup. Korisnik sada može dati ovu mogućnost drugom korisniku slanjem u poruci. Ako drugi korisnik postavi sve bite koji bi trebali da budu spušteni, server će detektovati jer funkcija f daće rezultat koji nije jednak polju prava pristupa objektu. Ova shema je razvijena za Amoeba distribuirani sistem.

Kao dodatak pravima pristupa specifičnog objekta, takvim kao što su read i execute, capabilities ( i kernel i korisničke) obično imaju definisana prava pristupa koja su primjenljiva za sve objekte. Primjeri ovakvih prava su:

o Kopiraj capability: kreiraj novu capability za isti objekato Kopiraj objekat: kreiraj duplikat objekat sa novim capability


o Uklnoni capability: pobriši element iz C-liste; ne utiče na objekato Uništi objekat: trajno ukloni objekat i njegova prava pristupa objektuUkoliko želimo da ponovno dodjelimo prava pristupa objektu koji smo

izmjenili ili pobrisali, to će biti veoma teško ukoliko se odnosi na kernel pristup. Teško je za sistem da nađe sve capabilities za bilo koji objekat i vrati ih nazad u stanje kakve su bile, jer one mogu biti smještene u C-liste po cijelom disku. Jeda pristup ovom problemu je da postoje pokazivač na indirektni objekat prije nego na sam objekat. Ovaj indirektni objekat predstavlja pokazivaće na stvarne objekte, sistem bi mogao uvijek da prekine vezu ka klijentu, i na taj način da ne dozvoli pristup tom objektu.

U shemi Amoebe, davanje ranijih prava pristupa se izvodi jednostavno. Sve što je potrebo uraditi je promjena kontrolnog polja smještenog sa objektom. Jednim potezom sve capabilities mogu biti nevažeće. Međutim, nijedna shema ne dozvoljava selektivnu revokaciju, takvu kao što bi bilo za vraćanje prava pristupa samo Jonu i nikom više. Ovo je uočeno i predstavlja problem za sve sisteme koji koriste capability.

12.21 Tajni kanali (engl. Covert Channels)Čak i sa listom kontrole pristupa i capability-a, može se desiti da sigurnost nije

dobra. U ovom dijelu pozabavićemo se sa problemom curenja informacija čak i u slučajevima kada je to curenje informacije matematički nemoguće, kao što je pokazao Lampson 1973. god.

Lampsonom model je originialno definisan u smislu jednog timesharing sistema, ali ista ideja se može primjeniti na LAN i druga okruženja sa više korisnika. U najčistijem obliku, to uključuje tri procesa na nekim zaštićenim računarima. Prvi proces nazvan klijent želi nekakav rad koji izvršava drugi proces, nazvan server. Klijent i server ne vjeruju u potpunosti jedan drugom. Na primjer, posao servera je da pomogne klijentu sa popunjavanjem njihovih obrazaca za poreze. Klijenti se brinu da njihove finansijske slogove server ne zapisuje negdje, recimo da održava tajnu listu onih koji zarađuju puno a onda prodaje te podatke. Server brine da klijenti ne ukradu vrijedne programe za obračun poreza.

Treći proces je kolaborator, koji je u dogovoru sa serverom da ukrade klijentove povjerljive podatke. Kolaborator i server se uprvaljaju od strane iste osobe. Ova tri procesa su prikazana na narednoj slici. Cilj ove vježbe je da se projektuje sistem u kome je nemoguće za server proces da daje informacije ka collaborator-u koje su primljene od klijenta. Lampson naziva ovaj problem sa „confinement problem“.

(a) Procesi klijet, server, i collaborator. (b) server šalje podatke preko tajnih kanala ka collaborator-u.

Tajni kanali (engl. Covert Channels) 355

Sa tačke gledišta projektanta sistema, cilj je da se ugnježdi ili «zatvoren» server na takav način da ne može proslijediti informacije ka collaborator-u. Korišćenjem sheme zaštitne matrice može se lako garantovati da server ne može komunicirati sa collaborator-om pišući podatke u datoteku na koju collaborator ima pravo pristupa tipa read. Takođe je moguće obezbjediti da server ne može komunicirati da collaboratorom koristeći mehanizme za međuprocesnu komunikaciju.

Nažalost, suptilniji komunikacioni kanali mogu biti na raspolaganju. Na primjer, server može pokušati da komunicira kroz tok bita na sljedeći način: Da bi poslao 1 bit, on izvršava intenzivna izračunavanja fiksan period vremena. Da bi poslao 0, on se blokira isti vremenski period. Collaborator može pokušati da detektuje tok bita pažljivim posmatranjem njegovih vremena odgovora. Uopšte rečeno, imao bi brži odgovor kada server šalje 0 nego kada server šalje 1. Ovaj komunikacioni kanal je poznat kao tajni kanal i prikazan je na slici b.

Praćenje korišćenja procesora nije jedini tajni kanal. Intenzitet straničenja može se takođe modulirati (puno grešaka stranice za 1, bez grešaka stranice 0). U stvari, gotovo bilo koji način degradiranja performasi na način rada sata postaje kandidat. Ako sistem obezbjeđuje način zaključavanja datoteka, onda server može zaključati neku datoteku da ukaže na 1, i onda otključati je da ukaže na 0. U nekim sistemima, moguće je za proces da se detektuje status zaključavanja čak na datotekama kojima se ne može pristupiti. Ovaj tajni kanal je ilustriran na slici 5-32 sa zaključavanjem i otključavanjem datoteke za isti fiksan vremenski interval poznat serveru i collaborator-u. U ovom primjeru, tok tajnih bita koji se prenose je 11010100.

Tajni kanal koji koristi zaključavanje datoteka.


12.22 Sigurnost u Unix sistemima

Datoteke imaju tri grupe prava: Vlasnik, grupa i ostali

Funkcije za očitavanje i postavljanje prava. UID je identifikator korisnika, GID grupe

12.23 Sigurnost u Windows sistemimaSvaki proces ima pristupni token, koji izgleda kao na slici

API vezan za sigurnost

Arhitektura Microsot-ovih operativnih sistema 357

13 Arhitektura Microsot-ovih operativnih sistemaOgromnu većinu presonalnih računara i laptopa, kao i dobar dio serverskih

računara pogoni neka od verzija Windows operativnog sistema. U ovom poglavlju daće se osvrt na istorijat i arhitekturu Microsoft-ovih operativnih sistema.

13.1 Osmobitni operativni sistemiKada je u januaru 1975. firma MITS objavila projekt prvog kućnog računara, koji

je postigao značajniji uspjeh, Altair 8080. Programirao se na ekstremno težak način: prekidačima u mašinskom jeziku, u binarnom sistemu. Prva verzija ovog računara je mogla samo da prikazuje izlaz na lampicama, ali su se zatim pojavili priključci za jedinicu papirne trake, RS232 veza na teleprinter, dodatni RAM, osmoinčni flopi itd. Za samo mjesec dana od pojave tog računara, Bill Gates i Paul Alen realizuju interpreter za BASIC prvo na papirnoj traci, kasnije u ROMu, te osnivaju firmu Microsoft. Microsoft BASIC interpreter uspješno radi kao neka vrsta jednoprocesnog operativnog sistema. Realizovane su verzije za različite procesore: Intel8080, Zilog Z80, Motorola 6800, Motorola 6809, MOS 6502, Intel 8086. Mnogi računari iz ovog doba nisu morali koristiti diskove kao jedinice spoljnje memorije, nego jeftinije, ali i znatno sporije, kasetofone.

U isto vrijeme Garry Kendall razvija CP/M, za Intel 8080, mali disk bazirani operativni sistem, ali nevezan za programski jezik. Ideje od ovog operativnog sistema će uticati i na nastanak MS DOS za 16 bitne računare. Microsof je napravio i dva osmobitna disk operativna sistema: MIDAS za 8080 i MSX-DOS korišten na japanskim računarima sa Z80 procesorom.

13.2 MS DOS Nakon uspjeha tada manjih kompanija Apple, Microsoft, Commodore, Tandy i

Atari, i IBM je odlučio da napravi svoj prvi personalni računar, IBM PC 5150, koristeći Intel 8088 procesor. Nakon neuspjelog dogovora sa Digital Research (vlasnicima CP/M) za razvoj operativnog sistema, Microsoft preuzima razvoj operativnog sistema. Tim Paterson iz firme Seatle Computers prelazi u Microsoft i dovršava svoj raniji operativni sistem QDOS u MSDOS, odnosno u IBM verziji PC DOS. MSDOS je jedan od najjednostavnijih operativnih sistema koji se i danas ponegdje koristi. Prva verzija MS DOSa je bila veoma primitivna, ali nakon nekoliko promjena omogućila je sve neophodne funkcije koje pruža operativni sistem. MS DOS je prošao kroz više promjena tokom godina da bi omogućio bolju funkcionalnost. MS-DOS je jednozadaćni operativni sistem, što znači da može da izvršava samo jedan program u isto vrijeme, što znači da korisnik mora kucati tekstualne komande i odgovore kada komunicira sa operatvinim sistemom. Kasniije verzije uključuju dodatni program DOSSHELL.

358 Arhitektura Microsot-ovih operativnih sistema

MS DOS smatra svaki odvojeni program i podatke individualnom datotekom. Svaka datoteka ima ime, koje je podijeljeno u dva dijela, ime datoteke i ekstenziju. Ime datoteke može biti do osam karaktera dugačko, a ekstenzija može biti do tri karaktera. DOS je između 1980 i 1993. prošao kroz 13 verzija navedenih u tabeli. Još

narednih sedam godina bio je dio arhitekture Windows sistema, sve do Windows ME. Za MS DOS je napisan ogroman broj programa, pa i nakon što je Microsoft prestao s podrškom za ovaj operativni sistem, njegovi kasniji sistemi su čuvali kompatibilnost s MS DOS sistemom.

DOS cijeli memorijski prostor vidi kao područje od jednog megabajta memorije, pri čemu se na nižim adresama od adrese 0 nalaze interapt vektori, zatim određeni prostor zauzima jezgro sistema, nakon koga slijedi prostor za korisnički program. Od 640-g kilobajta smješteni su video memorija, nakon nje ROM video kartice, mali prostor za proširenje RAM-a i na vrhu memorije ROM BIOS. Adresa Područje00000 Interapt vektori00400 ROM BIOS područje00500 DOS parametarsko područje00700 IBMBIO.COM / IO.SYS promjenjivo IBMDOS.COM / MSDOS.SYS promjenjivo Prostor koji je rezervisao CONFIG.SYS za drajvere i baferepromjenjivo Rezidentni COMMAND.COMpromjenjivo Pokazivač na varijable okruženjapromjenjivo Blok varijabli okruženja rezidentnog programapromjenjivo Rezidentni program promjenjivo Blok varijabli okruženja trenutnog programapromjenjivo Trenutni program promjenjivo Tranzijentni dio COMMAND.COMA0000 Video memorijaC0000 ROM video karticaE0000 Memorijska proširenjaF0000 ROM BIOS

Drivespace disk compressionMS-DOS 6.22

Disk compression removedMS-DOS 6.21

Doublespace disk compression, safer utilities

MS-DOS 6.2

Memmaker addedMS-DOS 6.0

Memory management, improved utilities (Edit, Mem, Dosshell)

MS-DOS 5.0

Patch to 4.0MS-DOS 4.01

504 MB partitions, very buggyMS-DOS 4.0

3.5-inch floppies, multiple partitionsMS-DOS 3.3

1.2 MB floppy supportMS-DOS 3.0

International code supportMS-DOS 2.11

Hard drive and subdirectory supportMS-DOS 2.0

320K floppy drive supportMS-DOS 1.1

First version, very primitveMS-DOS 1.0

CommentMS-DOS Version

TABLE 9.1: MS-DOS Versions

MS DOS 359

Neophodni dio MS DOS, koji se stalno nalazi u memoriji, se sastoji od tri datoteke.

• IO.SYS, koji sadrži osnovne drajvere periferijskih uređaja i učitava u memoriju glavni dio DOS-a MSDOS.SYS. U PC DOS on se zove IBMBIO.COM

• MSDOS.SYS, je jezgro operativnog sistema i sadrži implementaciju sistemskih poziva MSDOS-a, kroz softverske trap-ove između INT 20h i INT 2Fh, od kojih je posebno značajan INT 21h. U PC DOS on se zove IBMDOS.COM

• COMMAND.COM je interpreter komandne linije, koji od korisnika očekuje unos komande s parametrima i izvršava komandu ugrađenu u njega ili eksterni program. Ova datoteka se ne čuva cijelo vrijeme u RAMu u potpunosti, ali je jedan njen dio uvijek prisutan. On ima mali skriptni jezik koji omogućava pokretanje programa s ekstenzijom .BAT. Jedan od njih AUTOEXEC.BAT se pokreće pri svakom podizanju MSDOS.

Ostatak MSDOSa se tipično čuva na disketu ili fisksnom disku, u direktoriju sa imenom C:\DOS. Datoteke smještene u tom direktoriju imaju rutine operativnog sistema kao što je program za formatiranje disketa i hard diskova, ali nisu neophodne za normalni rad operativnog sistema.

Ograničenja DOS-a na jedan program u jednom trenutku i limit na 640 K memorije, dovelo je do nekoliko načina za njihovo ublažavanje. Uvođenje sistemskog poziva INT 27h (Terminate and Stay Resident, TSR) je omogućilo da program ostane u memoriji i nakon njegovog završetka, a za nove aplikativne programe ostaje prostor iza posljednjeg bajta koji je zaustavljeni program iskoristio. Ta se osobina koristila uglavnom za drajvere, a zaustavljenom programu se onda pristupa preusmjeravajući interapte. Nedovoljan memorijski prostor od 640 K tzv. konvencionalne memorije se prevazilazio jednom od sljedećih tehnika:

Overlay: Dijelovi programa se nalaze u eksternoj datoteci na disku, slično mehanizmu swapping, ali bez spašavanja trenutnog stanja. Svaki mogući podprogram se prevede kao kratka rutina od nekoliko bajtova koja preusmjeri poziv podprograma na prebacivanje podprograma iz datoteke u memoriju ili na njegov stvarni programski kod.

Expanded memorija: Neiskorišteni memorijski prostor između apsolutnih adresa E0000 i F0000 se popunjavao RAM memorijom podijeljenom u stranice po 16 K. U jednom trenutku u memoriji mogu biti četiri takve stranice, ali ukupni broj raspoloživih stranica iz kojih se te stranice biraju nije ograničen.

Extended memorija: Dodatnim programima se procesor prebacuje u zaštićeni režim rada, čime mu postaje dostupna memorija i iznad 1M, prebaci dijelove memorije aplikativnom programu koji se nalazi u dijelu memorije dostupnom pod MS DOS i vraća u realni režim rada.


13.3 Xenix i OS 2Bilo je jasno da sa pojavom moćnijih procesora, kao što su 80286 i 80386, jedan jednokorisnički operativni sistem kao što je MS DOS ograničen u području memorije na 1M nije adekvatan. Zato su u Microsoftu krenuli u više projekata moćnijih operativnih sistema, ali nakon uspjeha Windows, napušteni su.

Xenix: Microsoft je uzeo 1979 licencu od AT&T da napravi UNIX kompatibilan operativni sistem, i angažujući druge kompanije Altos, Tandy i SCO napravljene su verzije za PDP-11, Zilog Z8001, 68000 i Intel 8086. 1987, prava potpuno predana firmi SCO.

OS /2: Zamišljen kao multitasking i grafički nasljednik DOSa, pojavio se u doba kada mašine nisu bile dovoljno jeftine. Razvijan zajedno s firmom IBM. Nakon razlaza 1990, nastavljen je razvoj od strane IBM-a, do 2005, kada i ova firma prestaje s razvojem OS/2. Arhitektura je dijelom iskorištena za arhitekturu Windows NT. Dizajner: Michael S. Kogan

13.4 Šesnaestbitne verzije WindowsNakon uspjeha Apple Macintosh, Microsoft-ov odgovor je bio u okruženju

Windows. Prve verzije Microsoft Windows su zapravo samo dodatak grafičkog okruženja u MS DOS. U ranim verzijama, Windows 1.0 i 2.0 bio je moguć samo rad u realnom režimu na 8086 procesoru, ali sa mogućnošću prebacivanja između procesa. To je značilo i dalje ograničenje adresnog prostora na 1M i nikakva zaštita između aplikacija. Ni raspoređivanje nije bilo preemptivno, nego se zasnivalo na uredno pisanim petljama poruka, opisano u poglavlju o Windows GUI. Windows 1.0 nije imao preklapanje prozora a Windows 2.0 jeste. Ove verzije Windowsa su sličnije DOSShellu nego Windowsu 3.1. Budućnost je još uvijek gledana u OS/2, Product manager; Russ Werner Steve Balmer Tandy Trower.

Windows 1.0Windows 2.0

Windows 3.0 Windows 3.1

Šesnaestbitne verzije Windows 361

Prve dvije verzije Windows-a su uglavnom ignorisane, jer je malo aplikacija pisano za njih. Međutim, verzije Windows 3.0, 3.1 i 3.11 for workgroups su preokrenule sofverski svijet mikroračunara. Iako se za 3.x seriju još uvijek može reći da nisu operativni sistem nego samo grafički korisnički interfejs koji ne radi ništa drugo nego translaciju manipulacija ikonama u komande koje može da razumije operativni sistem. Dakle, MS-DOS je primarni operativni sistem, a Windows 3.x omogućava GUI. Kada se podiže kompjuter, MSDOS se mora prvi učitati, a Windows se pokreće komandom WIN. Nakon što je GUI pokrenut, vidi se osnova Windowsa 3.x, Program Manager.

Šesnaestbitni Windows rade u tri režima rada, ali ne podržavaju sve verzije svaki od ovih režima, u tabeli je navedeno koji režim postoji u kojem Windows-u.

1.0 2.0 3.0 3.1 3.11 FWG

Realni • • •

Standardni • •

Prošireni Posebna verzija • • •

• Realni režim: Windows 3.x startovan kao obični GUI za MS-DOS. Ova verzija Windowsa nije imala nikakvo upravljanje memorijom, niti je bila sposobna za multitasking. Samo je jedva sposobna za startanje aplikacija i upravljanje fajlovima. Ova verzija je radila u limitu MS- DOSa od 1 MB.

• Standardni režim, radi u 286 zaštićenom modu, dala je Windowsu mogućnost adresiranja do 16 M RAMa. Ta mogućnost je pravila probleme sa programima koji rade u MSDOS realnom režimu. Windows je omogućio standardizovanu grafiku, fontove, I/O uređaje i memoriju. Programi se dijele na segmente različite veličine.

• 386 prošireni režim, Windows u 386 proširenom - zaštićenom modu adresira do 4 GB memorije, podržava virtuelnu memoriju i pušta više MS DOS programa da se istovremeno izvršavaju.

Pored 3 datoteke potrebne za pokretanje MS-DOS, za pokretanje Windows u 16 bitnom režimu potrebne su datoteke koje sadrže sistemske pozive. Za razliku od MSDOS, sistemski pozivi se ne pozivaju interaptima nego kao obični podprogrami, ali smješteni u dijeljene datoteke.

• KERNEL.EXE ili KRNL386.EXE: Alocira i prati sistemske resurse, koordinira U/I zahtjeve prema hardveru, odgovoran za upravljanje memorijom i pokretanje programa.

• USER.EXE – obrađuje U/I zahtjeve, odgovoran za tastaturu, miša, zvuk, komunikacijski hardver i tajmer.

• GDI.EXE – Graphic Driver Interface, sarađuje s USER. EXE i KERNEL.EXE, odgovoran za grafičko iscrtavanje i štampanje

• SHELL.DLL – API za pristup korisničkoj školjci (od 3.0)• MMSYSTEM.DLL – Funkcije za multimediju (od 3.1)


• COMMDLG.DLL – Standardni dijaloški prozori (od verzije 3.1)• COMMCTRL.DLL – Napredniji elementi korisničkog interfejsa: kartice,

potenciometri, indikatori napretka.. (od 3.11)• PROGMAN.EXE, WINFILE.EXE, MSDOS.EXE – Korisničke školjke

program manager (od 3.0) , file manager (od 3.0) i MSDOS executive (od 2.0)Pored njih bitne su

• *.DRV datoteke sa drajverima za periferijske uređaje• 386spart.par Datoteka za izmjenjivanje (swap file) je virtuelna memorija, što je

napredna funkcija 386 zaštićenog režima koja omogućava da na procesoru dio hard diska radi kao RAM. Mnogo je sporija od RAMa ali dopušta sistemima sa ograničenim RAMom da izvršavju više aplikacija. Virtualna memorija se upravlja iz specijalne skrivene datoteke.

Konfiguracione datoteke Windows 3.x• Control.ini — postavlja boje, pozadinu, printere i instalabilne drajvere.• Mouse.ini — kontroliše hardverske postavke miša.• Program.ini — definiše koje su grupe u Program Manageru i ima puno

postavki da se ograniči pristup korisnicima. Sadrži informacije o lokaciji programskih datoteka sa grupama i veličini

• Protocol.ini — definiše komponente u mrežnom okruženju• System.ini — kontroliše i inicijalizira sve resurse za PC. Kontroliše sistemski

hardver i povezane informacije. Prikazuje drajvere za hardver(kao Config.sys za MS-DOS.)

• Win.ini — definiše korisnički specifične postavke za Windows okruženje - screen savere, boje, fontove, pridruživanja i odnos resursa i aplikacija. (kao Autoexec.bat za MS-DOS.)

13.5 Windows 95, 98, MEVeliki broj programa za MS DOS, i Windows 3.1, kao i mali hardverski zahtjevi

ovih operativnih sistema, naveli su Microsoft da razvije seriju Windows koja se često naziva 9x i uključuje Windows 95, Windows 98, Windows 98SE i Windows ME- One se odlikuju 32 bitnim grafičkim okruženjem, ali velikom kompatibilnošću s starijim aplikacijama, po cijenu manje sigurnosti i prenosivosti. Jezgro je modifikovani MS DOS, ali je upitanju veliko poboljšanje MSDOSa jer se dobijaju dva proizvoda u jednom. Windows 95 ima MS-DOS interfejs za zaštićeni režim DPMI i GUI u zaštićenom režimu. DPMI režim je unapređena verzija MSDOSa koja podržava upotrebu produžene memorije, ali nema multitasking. Windows 95 prvo starta DPMI, a zatim učita GUI. Ne mora se imati GUI za podizanje Windowsa 95. To je važan koncept jer se mnogo funkcija obavlja u C: promptu. Product manager Windows 95 je Yusuf Mehdi.

DPMI zahtijeva iste tri datoteke kao i MS-DOS: Io.sys, Msdos.sys, i Command.com. Ove datoteke su različite u odnosu na istoimene u ranijim verzijama, podržavaju duga imena datoteka, a Msdos.sys je sada tekstualna datoteka koja sadrži

Windows 95, 98, ME 363

konfiguracijske postavke, dok io.sys sadrži pored drajvera uređaja i implementaciju sistemskih poziva.

Kada se pokrene GUI on preklapa DPMI i učitava vlastite drajvere za sve, što znači da Config.sys nije potreban za učitavanje device drajvera. Neki drajveri, kao što je MSCDEX za CD i podrška mišu se učitaju u zaštićenom režimu, te ne zauzimaju konvencionalnu memoriju.

Windows 95 se pojavio u više izdanja, od početnog na 15 disketa, do posljednjeg OSR 2.5 sa podrškom za USB i FAT 32.

Arhitektura Windows 95 zbog kompatibilnosti s MS DOS je dosta miješana. Postoje dvije vrste drajvera. Drajveri u realnom režimu se učitavaju iz Config.sys (linije device=sxss) i Autoexec.bat (TSR programi). Drajveri u zaštićenom režimu se učitavaju iz GUI-a, pri čemu oni najčešći su u datoteci VMM386.VXD, ali se mogu zamijeniti drugom datotekom. Upravljač virtuelnom memorijom VMM podržava upotrebu memorije na nivou DPMI i GUI.VMM može kreirati virtuelne mašine (VM), područja memorije u kojima se aplikacije izvršavaju. Upoteba više virtuelnih mašina omogućava MSDOS programima da se izvršavaju u vlastitom memorijskom prostoru, poboljšavajući perfomanse operativnog sistema. Kada se radi u GUI režimu, DOS interapt pozivi (npr INT 21h) se preusmjeravaju na odgovarajuće drajvere unutar VMM.

Uz VMM je instalabilni datotečni sistem (IFS) koji pruža podršku za hard diskove, CDROM-ove i mrežne diskove. IFS pruža podršku za duga imena datoteka. IFS podržava i DPMI i GUI režim.

U GUI režimu se nalazi srce Windowsa 95: Kernel, GDI i USER. Ove komponente održavaju sve glavne funkcije unutar Windowsa 95. Windows 95 ima preemptivni multitasking (svaki program ima određeno vrijeme procesora) za razliku od Windowsa 3.x koji ima kooperativni multitasking (vrijeme koje program ima bazirano je na načinu kako je aplikacija pisana). Ove tri komponente imaju potpuno


istu funkciju kao kod Windows 3.1 – kernel32.dll je 32 bitna verzija kernel.exe, gdi32.dll je 32 verzija gdi.exe a user32.dll je 32 bitna verzija user.exe.

Na vrhu arhitekture Windowsa 95 je korisnički interfejs sa ikonama, prozorima i alatkama.

Kako su INI datoteke postale mnogobrojne, zamijenjene su Registry bazom. To je centralizovana konfiguraciona baza za softverske postavke i hardverske postavke. Svi konfiguracijski parametri su smješteni u datoteke User.dat i System.dat, pri čemu operativni sistem pravi njihove kopije kao User.da0 i System.da0, uz obezbjeđenje editora regedit.exe za ručno mijenjanje sadržaja registry.

Datotečna struktura za Windows 95 je veoma unapređena u odnosu na Windows 3.x. Windows 95 podržava duga imena fajlova (LFN) prevazilazeći 8.3 limite. Imena Windows 95 datoteka sadrže do 255 znakova uključujući razmeke i tačke. O načinu kako se ona čuvaju u memoriji, pisalo je u poglavlju 11.31. Svako dugačko ime datoteke ima ekvivalentno kratko ime

This is a really really really long file name.txtthisis~1.txt

Microsoft Windows 98 je 32 bitni operativni sistem koji uključuje ugrađenu vezu s Internetom, Plug and Play podršku, visoke perfomance, robustnost i kompatibilnost sa Windowsom 95.

Windows 98 uključuje sofisticiranije upravljanje napajanjem, podršku za više monitora i integrisanu podršku za najnoviji hardver. Takođe je uključena podrška za novi Win32 Driver Model (WDM), koji dopušta WDM uređaju da radi i pod Windowsom 98, kao i budućim verzijama Windowsa NT koristeći isti drajver.

Napravljena i Windows 98 Second edition. Product manager: Nicolas CoudièreArhitektura Windows 98 je očito slična arhitekturu Windows 95, uz novu vrstu

drajvera WDM, koja omogućava upotrebu istih drajvera u 9x i NT seriji.

Windows 95, 98, ME 365

Poput Windows-a 95, Windows 98 je razvijen iz Windows 3.1 platforme i uključuje sljedeće mogućnosti:

• Kompletan 32 bitni kernel sa upravljanjem memorijom i preemptivnim višezadaćnim i višenitnim radom.

• Puni integrisani 32 bitni datotečni sistem u zaštićenom režimu rada koji eliminiše potrebu za posebnom kopijom MSDOSa prilikom podizanja sistema

• 32 bitni instalabilni datotečni sistem koji podržava ..., mrežnu redirekciju i visoke perfomanse. Ovi datotečni drajveri podržavaju dugačka imena datoteka i otvorenu, modularnu arhitekturu za buduća proširenja.

• WDM podrška dopušta uređaju koji podržava WDM da radi pod Windowsom 98 i budućim verzijama Windowsa NT koristeći isti drajver.

• Poboljšana sistemska robustnost i čišćenje nakon pada aplikacije ili drajvera. To omogućuje stabilniji i pouzdaniji operativni sistem

• Dinamička hardverska konfiguracija koja smanjuje potrebu da korisnici podešavaju i restartuju ručno svoje sisteme.

Posljednji Windows iz 9x serije je Windows ME, (Millenium Edition) i on je i posljednja inkarnacija MS DOS, iako je ovog puta DOS dobro sakriven. Windows ME je Windows 4.90 iznad MSDOS-a 8.00. Urađene su sljedeće izmjene:

• Izbačen command prompt iz F8 startnog menija• Ukinuta Exit to DOS opcija u Windows shutdown. Windows ME sprječava

aplikacije koje žele izaći iz Windowsa u DOS• Config.sys se automatski briše da se ne bi učitali DOS drajveri• SYS komanda sprečava SYS bilo čega osim diska C: kada se koristi boot

disketa, Izbačena opcija FORMAT /S• Dodani System Restore, Windows File Protection, Windows Image

Acquisition, Automatic Updates


13.6 Windows NT serijaU toku razvoja OS/2 3.0, kao stabilnog, portabilnog, višeprocesnog operativnog

sistema angažovan je David Neil Cutler kao prvi glavni projektant (ranije projektovao RSX 11 i VMS). Operativni sistem je dizajniran sa razdvojenim API od jezgra operativnog sistema. Nakon uspjeha Windows 3.0, odlučeno je da se umjesto OS/2 API, primarno razvija 32 bitna verzija Windows API. Tako je 1993 nastao Windows NT.

Windows NT 3.51 Windows NT 4.0Nasljednici Windows NT su i danas aktuelne verzije Windows-a i dijele zajednički

osnovni dizajn jezgra, više od 20 godina, i uz manje razlike koje će biti kasnije objašnjene, opis je relevantan za većinu verzija Windows. Sve verzije Windows, koje pripadaju NT seriji su date u sljedećoj tabeli.

Ime Izdanja DatumWindows NT 3.1 Windows NT, Advanced Server 27.7.1993Windows NT 3.5 Workstation, Server 21.9.1994Windows NT 3.51 Workstation, Server 30.5.1995

Windows NT 4.0Workstation, Server, Server Enterprise Edition, Terminal Server, Embedded 29.7.1996

Windows 2000 Professional, Server, Advanced Server, Datacenter Server 17.2.2000,

Windows XP

Home, Professional, Media Center (original, 2003, 2004 & 2005), Tablet PC (original i 2005), Starter, Embedded, Home N, Professional N 25.10.2001

Windows Fundamentals for Legacy PCs 8.7.2006Windows XP 64-bit Edition Version 2003 28.3.2003

Windows Server 2003Standard, Enterprise, Datacenter, Web, Storage, Small Business Server, Compute Cluster 24.4.2003

Windows XP Professional x64 Edition 25.4.2005

Windows Server 2003 R2Standard, Enterprise, Datacenter, Web, Storage, Small Business Server, Compute Cluster 6.12.2005

Windows Home Server 167.2007

Windows VistaStarter, Home Basic, Home Premium, Business, Enterprise, Ultimate, Home Basic N, Business N 30.11.2006

Windows NT serija 367

Windows Server 2008Foundation, Standard, Enterprise, Datacenter, Web Server, HPC Server, Itanium-Based Systems 27.2.2008

Windows 7Starter, Home Basic, Home Premium, Professional, Enterprise, Ultimate 22.10.2009

Windows Server 2008 R2Foundation, Standard, Enterprise, Datacenter, Web Server, HPC Server, Itanium-Based Systems 22.10.2009

Windows Home Server 2011 6.4.2011

Windows 8Windows 8, Windows 8 Pro, Windows 8 Enterprise, Windows RT 26.10.2012

Windows Server 2012 Foundation, Essentials, Standard, Datacenter 4.9.2012

Windows 8.1Windows 8.1, Windows 8.1 Pro, Windows 8.1 Enterprise, Windows RT 8.1 18.10.2013

Windows Server 2012 R2 Foundation, Essentials, Standard, Datacenter 18.10.2013

13.7 Windows NT - KERNEL

NT koristi modifikovani mikrokernel koji je između čistog mikrokernela i monolitnog dizajna. U NT-ovom modifikovanom mikrokernelskom dizajnu, okruženja operativnih sistema se izvršavaju u korisničkom režimu kao diskretni procesi, uključujući DOS, WIN 16, Win32, OS/2, and POSIX.

Osnovni podsistemi operativnog sistema, uključujući Process Manager i Virtual Memory Manager, izvršavaju se u kernel modu i kompajlirani su u jednoj datoteci. NTOSKRNL.EXE Ovi podsistemi u kernel modu nisu odvojeni procesi i međusobno komuniciraju pozivom funkcija radi maksimalnih perfomansi.

Svaki od ovih operativnih sistema ima svoje API-je, ali je nivo implementiranosti različit. DOS aplikacije su ograničene na one koje ne pristupaju direktno hardveru,


POSIX i OS/2 imaju minimalan skup funkcija, dok se WIN32 stalno unapređuje i on je zvanični jezik NT linije.

Okruženja operativnih sistema se baziraju na servisima koje kernel mod eksportuje da izvršava usluge koje oni ne mogu izvršavati u user modu. Te usluge pozvane u kernel modu su poznate kao NT-jev prirodni API. Ovaj API ima oko 250 funkcija koji se pozivaju koristeći softverske izuzetke. Softverski izuzetak je hardverski podpomognuti način da se prelazi između kernel i user moda.

Zahtjeve za prirodnim API-jem izvršavaju funkcije u kernel modu koje se zovu sistemski servisi.

Da bi se podržao rad sistemski servisi pozivaju komponente NT Executive-a:I/O Manager, Object Manager, Security Reference Monitor, Process Manager, Local Procedure Call Facility, i Virtual Memory Manager. Sa I/O managerom blisko saraðuju drajveri ureðaja koji omogućuju pristup ureðajima poput diskova i tastature.

13.8 Komunikacija između jezgra i korisničkog režimaOkruženja operativnih sistema su

implementirana kao klijent/server. Kao dio procesa kompajliranja,aplikacije se u toku linkovanja vežu za API operativnog sistema koji eksportuje okruženje operativnog sistema.

U trenutku linkovanja aplikacija se povezuje sa klijentskim DLL-ovima koji eksportuju API. Na primjer WIN32 program je klijent okruženja operativnog sistema Win32. Stoga se on povezuje sa klijentskim DLL-ovima, Kernel32.dll, gdi32.dll, i user32.dll. POSIX program seveže za psxdll.dll

U nekim slučajevima klijentski DLL može u potpunosti implementirati API bez poziva servera, u drugim slučajevima server mora pomoći. Serverska pomoć je potrebna obično samo kada se trebaju ažurirati globalne informacije o sistemu. Na primjer, za CreateProcess funkciju, mora se pozivati server, jer on poziva prirodnu NT funkciju, dok za čitanje datoteke ne mora se zvati server jer se ta akcija može implementirati unutar DLLa.

Sistemski servisi prirodnog API-ja su napravljeni da ih dijelovi NTa u user modu mogu koristiti. Prirodni API mogu zvati i aplikacije, ali neće dobiti ništa više što ne bi mogle dobiti Win32 API-jem. Imena sistemskih servisa počinju sa Nt. Na primjer Win32 funckija CreateProces poziva ntCreateProces, a ovaj poziva psCreateProcess iz Process Managera. Prirodni API se nalazi u ntdll.dll

U cilju ubrzanja grafičkog korisničkog interfejsa, za razliku od NT 3.51 USER i GDI dio Win32 je prebačen u kernel. Prebacivanje je ubrzalo NT4.0 ali su njegove rane verzije postale nestabilne u slučaju loše napisanog grafičkog drajvera.

NT Executive 369

13.9 NT Executive NT Executive upravlja resursima u operativnom sistemu. Sastoji se od sljedećih

dijelova: Object Manager, Security Reference Monitor, Virtual Memory Manager, I/O Manager, Cache Manager, Local Procedure Call (LPC) Facility, Configuration Manager, Process Manager, Win32 (od NT 4.0), Plug-and-Play Manager (od Windows 2000) i Power Manager (od Windows 2000).

13.10 Object managerOsnovna uloga operativnog sistema je da upravlja logičkim i fizičkim resursima

računara.Svi drugi podsistemi Executivea koriste Object Manager da definišu objekte i

upravljaju objektima koji predstavljaju resurse. Na primjer, kroz Object manager, Process manager definiše objekt "proces" kojim prati aktivne procese

Objekti su Adapter, Callback, Controller, DebugObject, Desktop, Device,,Directory, Driver, Event, EventPair, File, IoCompletion, Job, Key, KeyedEvent, Mutant, Port, Process, Profile, Section, Semaphore, SymbolicLink, Thread, Timer, Token, Type, WaitablePort, WindowsStation, WMIGuid

ULOGE OBJECT MANAGERAObject Manager obavlja zadatke upravljanja objektima koje uključuju

identifikaciju i brojanje referenci. Kada aplikacija otvori resurs, OM locira objekt ili kreira novi.

Objekti se označavaju identifikatorima koji se zovu handle.Oni su jedinstveni na nivou aplikacije, ali ne i između aplikacija. Referencni brojač

prati koliko je procesa pristupilo resursu.Identifikacija objekta se nalazi u NT-jevom prostoru za imena. Svi djeljivi resursi

imaju imena, kao što su imena fajlova, registry ključeva ili semafora.Skoro svi servisi pozivaju Object Manager.

13.11 SECURITY REFERENCE MONITOR

Security Reference Monitor je vezan s Object Managerom. Object Manager poziva Security Reference Monitor koji provjerava prava pristupa prije nego dopusti aplikaciji da otvori objekt. Object manager takođe zove Security Reference Monitor prije nego da aplikaciji da obavlja druge operacije nad objektima, kao što su čitanje i pisanje.

SRM implementira sigurnosni model baziran na sigurnosnim identifikatorima (SID) i Diskrecionim listama za kontrolu pristupa (DACL). Svaki proces u NT-u ima pridruženi token pristupa koji sadrži SID korisnika koji posjeduje proces i SIDove grupa kojima on pripada.

Na slici je DACL koji ne da vlasniku procesa , Mark, da čita objekt, premda dopušta njegovoj grupi (Administrators)


13.12 VIRTUAL MEMORY MANAGERVirtual Memory Manager ima dva zadatka: Da kreira i upravlja adresne mape za

procese i kontroliše alokaciju fizičke memorije NT 4.0 implementira 32 bitni prostor, ali aplikacije mogu pristupiti prva 2G (user mode polovina, koja se mijenja kako se pokreću novi procesi). Druga polovina je (2-4G) je kernel polovina i ona se ne mijenja.

Virtual Memory Manager implementira virtuelnu memoriju preko stranica, velikih 4 K na Intel arhitekturi ili 8K na Alpha arhitekturi. Ako procesi zahtijevaju više memorije nego što je fizički ima, višak se nalazi u zamjenskoj datoteci.

Napredne mogućnosti VMM su memorijsko mapiranje datoteka, dijeljenje memorije i zaštita pri pisanju strane.

13.13 I/O MANAGER

I/O manager integriše dodatne drajvere za uređaje sa NT-om.

Drajver ureðaja prevodi komande koje NT i aplikacije šalju uređaju i prosljeđuju zahtjeve hardveru. Ako Microsoft nije isporučio drajver, proizvođač hardvera jeste.

I/O manager podržava asinhroni paketni I/O prijenos. Npr, ako MS Word čita iz fajla, servis NtReadFile alocira I/O request packet (IRP) koji ima informacije o adresi gdje se smještaju podaci, objektu koji predstavlja datoteku, poziciji u datoteci, količini podataka itd. IRP se zatim proslijedi drajveru fajl sistema.

Kada drajveri prime IRP oni rade svoje a aplikacija nastavlja sa izvršenjem.

I/O MANAGER 371

Pošto to može biti teško za programiranje, standardni Win32 API ubacuje potrebna čekanja, ali je moguće pozivati i napredne funkcije koje koriste ovu asinhronost.

I/O manager podržava 64 bitne pozicije u datotekama i višeslojne drajvere ureðaja. Npr, NTFS drajver je iznad fault tolerant drajvera koji je iznad standardnog drajvera.

13.14 CACHE MANAGER Cache manager sarađuje sa VMM i drajverima za datotečni sistem. Cache

manager održava NT globalni (dijeljen od svih fajl sistema) keš za datoteke. NT keš je datotečno orijentisan (za razliku od 95 koji je blokovno).

Fizičku memoriju kešu dodjeljuje Working-set tuner. Kada on izbacuje memoriju iz prostora predviðenog za keš, fajl sistem snima datoteku na disk.

13.15 POZIV LOKALNE PROCEDURENT-ov Poziv lokalne procedure (LPC) oprimizira komunikaciju između aplikcija

uključujući i okruženja operativnih sistema. LPC funkcija je bazirana na dva tipa port objekata: konekcijski portovi i komunikacioni portovi. Server kreira konekcijski port na koji se klijent kači. Nakon što klijent uspostavi tu komunikaciju, server kreira komunikacioni port kroz koji server i klijent prenose podatke.

Postoje 3 tipa LPC, kopiranje podataka, dijeljena memorija i dijeljena memorija sa parovima dogaðaja (Quick LPC). NT koristi kopiranje podataka za male poruke (do 256 bajtova). Jedna strana ( Klijent ili server) kopira poruku na port

Dijeljena memorija se koristi za poruke preko 256 bajtova. U LPC-u dijeljenom memorijom klijent i server dijele region memorije. Šalje se samo kratka poruka sa informacijom o adresi dijeljene memorije.

Win32 pod NT 3.51 koristi Quick-LPC. Win32 ne šalje poruke kroz portove. Umjesto toga, jedna strana koristi sinhronizacijski objekt Eventpair da informiše drugu. Ovaj metod izbjegava opterećenja zbog komunikacije kroz port ali troši više resursa.

13.16 CONFIGURATION MANAGER Configuration Manager upravlja Registry-jem i Win32 Registry funkcije se

zasnivaju na Configuration manageru. Njegove usluge koristi i IO manager radi dodjeljivanja resursa drajverima uređaja.

13.17 PROCESS MANAGERProcess Manager radi sa kernelom da definiše objekte procesa i tredova. Process

Manager uokviruje kernelov objekt proces i dodaje mu identifikator procesa PID, pristupni token, adresnu mapu i tabelu hendlova. Slično radi i sa threadovima dodajući im TID identifikator i statistiku koja uključuje kada se proces i thread startovali i odreðene brojače virtuelne memorije.


Process Manager izvozi interfejs koji omogućava da ostali podsistemi Executivea i korisničke aplikacije manipulišu procesima i tredovima. Na primjer, aplikacije mogu pristupati funkcijama Process Managera da kreiraju procese, brišu ih i modifikuju njihove karakteristike (kao što su njihovi prioriteti).

13.18 WIN 32 U KERNEL DIJELU

Win32 se sastoji od funkcija za poruke i crtanje Win32 API-ja. U NT 3.51 ti su moduli bili u user režimu kao dio Win32 okruženja.

13.19 KERNEL NTNT kernel radi bliže sa hardverom nego Executive i sadrži kod ovisan od

procesora. NT rasporeðivač thredova , koji se zove dispečer, nalazi se u Kernelu. Dispečer implementira 32 nivoa prioriteta. Prioritet 0 je rezervisan za sistemski thread koji briše memorijske stranice. Programi se izvršavaju u nivoima prioriteta 1 do 15, dok nivoima 16 do 31 mogu pristupiti samo administratori.

NT dispečer je preemptivni rasporeðivač. Procesorsko vrijeme je podijeljeno u dijelove koji se zovu kvantumi. Kada thread doðe do kraja svog kvantuma i dispečer predaje zadatak threadu istog prioriteta koji čeka. Sinhronizaciju omogućavaaju mutexi, semaphori, eventi, and spinlockovi. Objekte kernela mapira Executive kroz Object Manager i Process Manager, i oni su takvi vidljivi aplikacijama.

Kernel upravlja interapt vektorima. NT definiše i implementira IRQ nivoe u Kernelu.

13.20 HARDWARE ABSTRACTION LAYERHAL je NT-ov interfejs prema samom procesoru. NT je portabilan izmeðu

različitih procesora. Stvari specifične za pojedini procesor pišu se u ovom modulu. HAL eksportuje standardni procesor i drajveri se pišu za njega.

Čak i na pločama sa istim procesorom može biti razlika, recimo ako su jedno i višeprocesorske. Postoje tri verzije HAL.DLL-a, jednoprocesorska, višeprocesorska i debug verzija.

WINDOWS 2000 373

13.21 WINDOWS 2000

Kako se vidi na slici, dva nova podsistema u jezgru uvedena s Windows 2000 su PLUG AND PLAY I POWER MANAGER

Plug and play,uveden sa Windows 95,sada je dio Windows 2000. Kompatibilni ureðaje se mogu uvesti i Windows će konfigurisati ureðaj. To će možda zahtijevati rekonfigurisanje drugih uređaja.

Poboljšano je upravljanje napajanjem radi podrške prenosnim računarima.

13.22 Windows XP i Windows .NET server 2003Od Windows 2000 kernela Microsoft je dodao široku podršku za uređaje i plug and

play. Promijenjen je kernel da se ubrza dizanje sistema.


Plavi ekran krahiranja su često izazivali nekompatibilni drajveri za ureðaje. Windows XP provjerava da li je drajver certificiran u Windows Hardware Quality Lab (WHQL).

Necertificirani drajveri mogu i dalje raditi na korisnikov zahtjev, ali postoji i crna lista drajvera koji definitivno krahiraju. Windows XP uključuje System Restore koji vraća sistem u stanje prije instalacije problematičnog drajvera.

Poboljšana podrška DLL-ovima. Dopušteno je da se u memoriji nalazi više različitih verzija DLLova kako bi aplikacije koje su ovisne o specifičnoj verziji DLLa radile.

Slabo upravljanje memorijom je bilo uzrok nestabilnosti.Više se ne dogaða da drajver ureðaja alocira memoriju koja ne postoji. Može se

mapirati duplo više stranica memorije nego sa Win2000.Stabilnost povećana kad je nedovoljno memorije. Operativni sistem tada smanjuje

vlastite zahtjeve.Ubrzano vrijeme podizanja operativnog sistema uz pomoć Simple Boot Flag (SBF)

specifikacije.Registry je optimizovan da što manje bude fragmentiran, i prebačen iz kernelske u

straničenu memoriju. Njegov sadržaj se smješta u memoriju pri dizanju sistema radi boljih perfomansi.

WINDOWS XP VERZIJE: Windows XP Home Edition, Windows XP ProfessionalWindows XP Media Center Edition 2005, Windows XP 64-Bit Edition, Windows

XP Media Center Edition, Windows XP Tablet PC Edition, Windows XP EmbeddedWindows Fundamentals for Legacy Pcs, Windows XP Starter Edition, Windows

XP Edition NWindow Server 2003 je dizajniran kao nastavak Windows 2000 servera. Windows

2003 server uključuje .NET Framework 1.1 i XML Web Services. Jedno vrijeme se zvao i Windows 2003 .NET server. Omogućeno je brže i lakše upraavljanje Aktivnim direktorijem. Domain Controller (DC) Upgrade Wizard omogućava čitanje podaataka o Domain Controleru sa Cda. Uključen Internet Information Server (IIS) 6, 64 bitna

Windows XP i Windows .NET server 2003 375

verzija Windows Server 2003 predviđena je za Intel 64-bit Itanium 2 , ostale verzije su za 32 bitni Pentium.

13.23 WINDOWS VISTA i Windows Server 2008 Microsoft je počeo planirati Vistu ("Longhorn") 2001. godine, odmah nakon

izlaska XPa. Bio je očekivan krajem 2003. kao korak između Windows XPa i "Blackcomba" (sada znanog pod imenom Windows "Vienna"). "Longhorn" je trebao uključiti mnogo novih značajki i tehnologija planiranih za "Blackcomb". Orginalni "Longhorn", zasnovan na XP-ovom izvornom kodu je odbačen i krenulo se otpočetka, izradom na bazi sistema Windows Server 2003. Neki najavljeni noviteti kao što je WinFSsu odbačeni ili odgođeni.

NOVOSTI WINDOWS VISTA: Grafički interfejs Aero sa novom školjkom Prepoznavanje govora Drugačiji boot loader Internet explorer 7 Media player 11 Mail, Calendar, Photo Gallery, DVD maker Direktoriji koriste simboličke linkove, veća sigurnost Problem Reports and Solutions, Windows update Druga arhitektura drajvera, manje drajvera u kernelu Imunija na viruse, manje stabilna od XP, manje kompatibilna s DOS-om Izmjene u algoritmima CPU vrijeme: Koristi Time Stamp Counter (TSC) Interapti se ne računaju u nitima Vrijeme I kvantum precizniji Komunikacije ALPC: Advanced Lightweight Procedure Calls Kernel-mode RPC Novi TCP/IP stek (integrisan IPv4 id IPv6)


Ulaz/izlazUklonjena izmjena konteksta u trenutku završetka ulaza/izlaza na portovimaPoboljšanje otkazivanja ulaza/izlazaUpravljanje memorijomSlučajni adresni prostor (DLL, stekovi) Dinamički konfigurisan adresni prostor jezgra Sigurnost: BitLocker, DRM, UAC, Integrity Levels

WINDOWS SERVER 2008 Bivši Longhorn Server Građen na Vista kodu Active directory roles Komandna linija: PowerShell i SuperCore verzija Hyper V virtualizacija Samopopravljajući NTFS Podrška za dodavanje procesora i memorije u hodu

WINDOWS 7 377

13.24 WINDOWS 7

IZMJENE U JEZGRU I OSNOVNOM MINWINWindows 7 i Windows server 2008 R2 isto jezgro Product manager Steven

SinofskyServer 2008 R2 samo 64 bitni

MinWin, minimum da se Windows 7 pokrene (bez GUI, sa mrežnim servisima, 25 M

DLL-ovi refaktorisani da bi se usaglasili s MinWinKernel32.dll -> Kernelbase.dllAdvapi32.dll -> Kernelbase.dllAPI skupovi – virtualni DLL se mapira u logički

Prepoznavanje rukopisa Virtuelni diskovi Bolje ponašanje na višejezgrenim procesorima i brži boot, do 256 procesora Virtualni folderi u libraries datotekama Vizuelne izmjene u taskbaru itd

Obrada konzole prebačena is csrss u conhost.exe


Memorijske optimizacije: DWM rearhitektura smanjuje zauzeće memorije po prozoru za 50%, Registry učitan u skup strana( prije bio u memoriji) povećane performanse time

Brojač starenja radnog skupa četverobitni (prije trobitni, dijelovi sistema imaju odvojene radne skupove)

UBPM (Unified Background Process Manager) Unificirani način za pokretanje procesa po događajima. Realizovan u Service Control Manager

Servisi se sada mogu pokretati na događajeFault tolerant heap (FTH), kada se primjeti čest pad procesa zbog upotrebe heap

memorije, mijenjaju se algoritmi provjereUvedeni virtuelni korisnički nalozi (potrebni servisima)Uvijek se kreiraju BitLocker, šifrovane skrivene particije, omogućavaju I lozinku

nad pomjerljivim medijemPodržano više od 32(64) procesora, (ranije se svaki predstavljao jednim bitom da li

je aktivan)User mode scheduling (UMS) za realizaciju niti u korisničkom prostoruRanije je raspoređivano ravnomijerno po jezgrama, čak I ako se malo koristiCore Parking pokušava opterećenje na što manje logičkih procesora (manja

potrošnja) I fizičkih soketaNa neaktivne procesore se ne šalje ni tajmer interapt

Windows 8 i Windows Server 2012 379

13.25 Windows 8 i Windows Server 2012

Vizuelno: nema više start menija, File explorer, task barPrilagođen tabletimaNovi API Windows Runtime, intenzivna upotreba HTML 5Windows Store, nova distribucija softvera, zatvorene aplikacijeSecure boot, sa javnim ključemVerzije Windows 8, Windows 8 professional, Windows 8 enterprise i Windows RT

(za ARM)

Manager: Julie Larson-Green


13.26 Windows 8.1Start se vratio!

13.27 Specijalne verzije s Windows NT jezgromWindows Embedded, skraćene i konfigurabilne verzije Windows-a za ugradnju u

različite uređaje (npr POS kase, bankomate...)XBOX i XBOX-360 imaju operativne sisteme sa jezgrom preuzetim od Windows

2000, ali drugačijim ostatkom operativnog sistemaHome server i Home server 2011 (smanjena verzija Windows server 2008)Windows fundamentals for legacy PC (smanjena verzija XP, samo klijent)Windows Thin PC (smanjena verzija Windows 7, samo klijent)

13.28 WINDOWS CE, Windows Phone, Mobile i Pocket PCU Windows CE sistemima cijeli operativni sistem je u ROMu kao i aplikacije koje

dolaze sa sistemom. Ako programski modul nije kompresovan, ROM programi se izvršavaju na licu mjesta. Ako je modul u ROMu kompresovan, dekompresuje se i prebaci u RAM.

Upisivi podaci se smještaju u RAM.Najnovija verzija Windows CE 7.0

WINDOWS CE, Windows Phone, Mobile i Pocket PC 381

Windows CE je operativni sistem dijeljenog izvornog koda, proizvođači uređaja licenciraju izvorni kod. Na raspolaganju je nekoliko arhitektura. Nije kompatibilan s WIN32, a (za razliku od XP embedded koji zahtijeva bar 8 megabajta) CE 5 može se smjesiti u 350 kilobajta

WINDOWS CE VERZIJE1.0 1996 Uređaji "handheld PC" (HPC)2.0 1997. Uređaji "Palm-sized PC". RT raspoređivanje , arhitekture ARM, MIPS,

PowerPC, StrongARM, SuperH i x86, 32-bitekrani,SSL 2.0 and SSL 3.0.3.0 2000 CE real time do mikrosekunde, baza za Pocket PC 2000, Handheld PC

2000, Pocket PC 2002 iSmartphone 2002. Povećano nivoa prioriteta s 8 na 256 Broj objekata povećan s 65,536 na 4.19 miliona Zaštita kritičnih dijelova registry

4.x 2002. Nova struktura drajvera baza za "Pocket PC 2003" Bluetooth podrška, TLS (SSL 3.1), IPsec L2TP VPN, ili Kerberos

5.x 2004. Automatska prijava bagova. Direct3D Mobile DirectDraw za 2D grafiku i DirectShow za kamere i digitalizaciju Remote Desktop Protocol (RDP)

WINDOWS CE VERZIJE6.0 2006. Adresni prostor povećan s 32 MB na 2 GB. Broj procesa povećan s 32 to

32,768.[23] Drajveri u korisničkom i sistemskom režimu 512 MB fizičke memorije Device.exe, filesys.exe, GWES.exe prebačeni u jezgro Povećane mogućnosti sistemskih poziva

7.0 2011. Podrška za više jezgara, Wi-Fi pozicioniranje Bluetooth 3.0 + HS Podrška za DLNA (Digital Living Network Alliance) standarde DRM tehnologija, Media Transfer Protocol,

Windows Phone 7 IE sa Flash 10.1 podrškom, NDIS 6.1 support UX C++ XAML API za Windows Presentation Foundation i Silverlight, Podrška za unos dodirom,Podrška jezgra za 3G RAM

Windows Phone, Mobile i Pocket PCOperativni sistemi za mobilne uređaje, bazirani na CE

kerneluAli nisu tako modularni kao Windows CE

Porodično stablo Windows:


13.29 KLONOVI

PCDOS CPM/86,DRDOS, OpenDOS, NovellDOS FreeDOS, FreeDOS32, GNU DOS PTS DOS IBM OS/2 WABI, WINE

13.30 Budući planovi

Midori (ranije Singularity): Virtuelne mašine, radiće preko Interneta, Cloud Computing

Barellfish, opensource za multicore, hardverske informacije u bazi podataka umjesto drajvera

HomeOS (personal cloud?)

Arhitektura Unix-Linux 383

14 Arhitektura Unix-LinuxDsdadOPERATIVNI SISTEMIUNIX I LINUX

14.1 UNIX historijatMULTICS and UNICS (Thompson)PDP-11 UNIX (B & C, Richie & Tompson)Portable UNIXBerkeley UNIXStandard UNIXLinux (Linus Torvald)Historijat UNIX porodice

14.2 UNIX ciljeviInteraktivni sistem za podršku više procesa I naprednih korisnikaIskusnim korisnicima trebaJednostavnos, elegantnost, konzistentnostSnaga, fleksibilnostManje redundancijeInterfejsi u UNIX sistemima

384 Arhitektura Unix-Linux

UNIX ciljevi 385


14.3 POSIXPOSIX, skraćenica od Portable Operating System Interface je zajedničko ime za

porodicu povezanih standarda koje definiše Institut inžinjera elektrotehnike i elektronike (IEEE).

Cilj standarda je da definiše oblik i ponašanje programskog okruženja (API-ja) operativnog sistema, ljuske i komandi kompatibilnih sa operativnim sistemom Unix

Međunarodno ime za ove standarde je ISO/IEC 9945. Svi standardi ove porodice standarda su dio projekta koji je započet oko 1985. godine. Podijeljeni su u 3 dijela

Standard za jezgro (engl. POSIX Kernel API), koji obuhvata proširenja za POSIX.1) i opisuje: Osnovne servise, Servise za rad u realnom vremenu, Proširenja za rad u realnom vremenu, Interfejs za bezbjednost, Interfejs za korišćenje niti, Pristup datotečnim sistemima preko mreže, Komunikaciju procesa preko mreže

Standard za komande i alatke (engl. POSIX Commands and Utilities), koji opisuje proširenja za prenosivost, ispravke i njihova proširenja i alatke za kontrolu, sigurnost i automatsko održavanje sistema)

Testiranje usklađenosti sa Posix standardom

14.4 UNIX Shell Shell: komandno linijski interfejs != X WindowsBrži i proširivijiPri pokretanju školjke, ona se inicijalizira, prikazuje prompt znak. Korisnik kuca

liniju. Školjka izdvaja prvu riječ, program za izvršenje. Školjka je program takođeKomande mogu imati argumente. cp a1.txt b1.txtTakođer opcije, džokeri. –2 , */?Ulaz, izlaz, redirekcija ( <, >).npr. sort < in > tmp; head –30 < temp; rm tempIzlaz programa kao ulaz u drugi. Pipes (|)

UNIX Shell 387

e.g. sort < in | head –30Shell skripteUNIX osnovni alatiNeki osnovni Unix alati koje zahtijeva POSIX

14.5 Procesi u UNIX sistemimaProcese kreira fork sistemski pozivMemorija roditeljskog i kreiranog procesa je privatna za svaki proces, datoteke se

dijele između procesasKako procesi znaju koji od njih izvršava roditeljski, a koji dijete kod?


Interprocesna komunikacijaProcesi komunciraju međusobno:Prosljeđivanjem poruka (cijevi) i signalimaSignali koje zahtijeva POSIX.

Sistemski pozivi za upravljanje procesima

s kod greškepid ID procesaresidual preostalo vrijeme od prethodnog alarmaPOSIX ShellPrincip rada školjke

Procesi u UNIX sistemima 389

UNIX Procesi:ImplementacijaDvije strukture tabela procesa i korisnička strukturaTabela procesa (informacije o svim procesima):Raspoređivački parametri (prioritet procesa, potrošeno vrijeme, vrijeme

neaktivnosti)Memorijska slika (pointeri na text, data i stack segmente)Signali (maske šta se radi s signalima)Razno (stanje procesa, događaji na koje se čeka, PID, itd.)Korisnička struktura (samo za izvršive procese u memoriji)Mašinski registriStanje sistemskog pozivaTabela datotečnih deskriptora (za lociranje indeksnih čvorova)Proračuni (CPU koliko je korišten)Proces pokretanja ls komandee

Koraci izvršenja jedne komande ls tipa u školjci


14.6 UNIX raspoređivačDizajniran za dobar odziv interaktivnih procesaDvo-nivovski algoritamNiskog nivoa: dobavlja proces između izvršivihVisokog nivoa: premješta procese između memorije I diskaNisko nivovski algoritam:Više redova čekanja različitih prioritetaProcesi u user režimu pozitivne vrijednosti, u kernel režimu negativniProcesi izvršavaju quantum (obično 100msec) ili dok se ne blokira I prebaci na

kraj reda čekanjaSvake sekunde: priority = CPU_usage + nice + base

UNIX Scheduler

UNIX raspoređivač, višenivovski redovi čekanja

14.7 Upravljanje memorijomMapiranje virtuelnog adresnog prostora procesa A i B u fizički memoriju

Sistemski pozivi za upravljanje memorijom

Upravljanje memorijom 391


s oznaka greškeb i addr su memorijske adreselen je dužinaprot kontroliše zaštituflags su razni bitifd datotečni deskriptoroffset je pozicija datoteke

Implementacija straničenja u UNIXNa zahtjevBez predstraničenjaDemon za straničenjeOS, osnovna mapa I stranični okviri


Zamjena strana u UNIXKada se desi greška stranice, a nema dostupne strane, proces se suspenduje, dok

demon za stranice ne oslobodi nekuAlgoritam za zamjenu se dešava u demonu stranice, svakih 250 msec provjerava da

li je broj stranica >= lotsfree paramtra. Ako nije, prebacuje strane na disk.Koristi se modifikovana verzija clock algoritma s globalnom zamjenom.

14.8 UNIX datotečni sistemNajvažniji direktoriji u UNIX sistemima

UNIX datotečni sistem Čvrsti i simbolički linkovi omogućavaju da se datoteka nalazi istovremeno u više direktorija i da ima više imena. Simbolički link pravi malu pomoćnu datoteku, a čvrsti koristi više pokazivača na isti element tabele datoteka


UNIX datotečni sistem

Separate file systemsAfter mountingSistemski pozivi za upravljanje datotekama

s oznaka greškefd datotečni deskriptorposition pozicija datotekeSistemski pozivi za upravljanje direktorijima

s oznaka greškedir direktorijski tokdirent element direktorijaUNIX datotečni sistem

Raspored diska u klasičnim Unix sistemimaUNIX File System

UNIX datotečni sistem 395

Datotečni deskriptori su identifikacijski brojevi kojim programi pristupaju datotekama. Oni pokazuju na tablice otvorenih datoteka, te tablice na indeksne čvorove, a indeksni čvorovi na fizička mjesta na disku


14.9 UNIX U/I sistemSvi I/O uređaji se ponašaju kao datoteke kojima se pristupa istim naredbama za

litanje i pisanjeUNIX integriše I/O uređaje kao specijalne datoteke. Npr. /dev/hd1 (hard disk),

/dev/lp1 (printer), /dev/net.Programi mogu čitati/pisati u specijalne datoteke kao u regularne. Npr. cp

account.txt /dev/lp1Specijalne datoteke:block: sekvenca numerisanih blokova (npr. diskovi)character: ulazno/izlazni tok znakova (npr. tastatura, printer)

14.10 Mreža

Soketi su slični sandučićima. Kreiraju se teko što se vrati datotečni deskriptorSvaki soket podržavaPouzdani konekcijski orijentisan tok bajtovaPouzdani konekcijski orijentisani tok paketaNepouzdani tok paketaPrije korištenja soketa on mora imati adresu

Terminali 397

14.11 TerminaliPOSIX pozivi za upravljanje terminalima

14.12 UNIX I/O drajveriPri kreiranju drajvera popuni se cdevsw tabela sa pointerima na funkcije koje

obavljaju osnovne operacije, i proslijedi kao jedan od parametara make_dev_pstatic struct cdevsw echo_cdevsw = {

.d_version = D_VERSION,

.d_open = echo_open,

.d_close = echo_close,

.d_read = echo_read,

.d_write = echo_write,

.d_name = "echo",};

UNIX I/OPrimjer hijerarhije UNIX I/O drajvera u BSD


14.13 Linux historijatLinux je moderni, besplatni I slobodni OS baziran na UNIX standardimaZapočeo 1991 Linus Torvalds, sa ciljem UNIX kompatibilnosti,Sarađuje puno

učesnika preko InternetGPL licencaEfikasno I pouzdano na PC ali I drugim platformamaJezgro je originalno, ali koristi dosta drugog slobodnog UNIX kodaMnogo kolekcija jezgro+dodatni softver=distribucijaVerzije: 0.1 (samo 386, Minix FS), 1.0 (mreža, dodatni hardver), 1.2 (posljednja

samo za PC) 2.0, 2.2(više arhitektura), 2.4 i 2.6 (simetrično multiprocesiranje)Nakon 2.6.39 prešlo se na seriju 3.0.Trenutna verzija 3.13 (nov. 2013)

14.14 Linux distribucijeStandardni, prekompajlirani skup paketa, ili distribucije, uključuju osnovni Linux

sistem, alate za instalaciju I upravljanje sistemom I osnovne UNIX alate

Linux distribucije 399

Prve distribucije su samo raspakivale datoteke na mjesta, kasnije imaju naprednije rukovanje paketima

Primjeri: Slackware, RedHat, Debian, Ubuntu, Gentoo, Suse, Mandriva ...The RPM i DEB paketni formati kompatibilnost između distribucija

14.15 Komponente Linux sistemaJezgro održava glavne aktivnosti operativnog sistemang system. Izvršava se u

režimu jezgra a njegove strukture i kod su u istom adresnom prostoruSistemske biblioteke definišu standardni skupfunkcija kroz koje aplikacije sarađuju

s jezgrom i funkcionalnost OS koja ne zahtijeva pune privilegije jezgraSistemski alati obavljaju specijalizovane zadatke upravljanja

Dijagram arhitekture jednog Linux sistemaDizajneri Linux distribucije određuju arhitekturu iznad jezgra(Ovo je primjer arhitekture za Nokia Maemo tablete)


Arhitektura jezgra se vidi monolitnost kernela

Ovo nije mikro-kernel arhitektura.Jezgro je jedna datotekaInterfejsi su C pozivi, a ne poruke ili IPCMoguće je kod jezgra razdvojiti u više modula koji su u odvojenim datotekama I

posebno se učitavaju, ali su u istom adresnom prostoriModuli se koriste za drajvere za opcione periferijske uređajeKomponente modula jezgra Sistem za upravljanje modulima: Učitavanje modula u memoriju I komunikacija s kernelomUčitavanje i izbacivanje modula:Alati u korisničkom režimu za učitavanje i izbacivanje modulaSistem registracije drajvera:

Komponente Linux sistema 401

Dopušta modulima da kažu ostatku kernela da postoji novi drajverMehanizam razrješenja konfliktaRezerviše hardverske resurse I štiti ih od drugog drivera.

14.16 Upravljanje procesima u LinuxKoriste se UNIX operacije za procese Poziv fork kreira novi procesNovi proces pozove execvePod Linuxom svojstva procesa spadaju u tri grupe identitet procesa, okruženje i

kontekstProcesov ID (PID). Jedinstveni identifikator procesa, koristi se za navođenje

procesa pri sistemskim pozivimaAkreditivi. Uz proces se prilažu ID procesa I jedan ili više grupnih ID za

određivanje prava procesa na sistemske resurse I datotekePersonalnost. Svaki proces ima identifikator personalnosti za izmjenu značenja

sistemskih pozivaZa emulaciju drugih UNIXOkruženje procesa se nasljeđuje od roditeljha i ima dva vektora koji se završavaju

kodom nula:Argumenti komandne linije (ime programa s parametrima)Parovi “NAME=VALUE” Okruženje se podešava po procesuKontekst procesaStanje aktivnog programaKontekst raspoređivača, informacije potrebne za zaustavljanje I ponovno

pokretanje procesaKernel održava računovodstvene informacije I potrošnju resursaTabela datoteka je niz pointera na datotečne strukture jezgraTabela rukovalaca signala definiše rutine u adresnom prostoru koje se zovu na

dolazak signalaLinux koristi niti u jezgru, iste strukture, nit je novi proces s istim adresnim

prostorom kao roditeljRazlika je u kreiranjufork kreira novi proces s novim kontekstomclone ckreira novi proces s svojim identitetom ali dijeli strukture podataka s

roditeljemRaspoređivanje procesa od 0.1 do 2.6Linux koristi dva raspoređivačka algoritma, koje određuje klasa procesa:Algoritam u dijeljenom vremenu za pravično raspoređivanjeAlgoritam za realno vrijeme gdje je apsolutni prioritet važniji od pravičnostiZa procese u dijeljenom vremenu, Linux koristi prioritizirani algoritam sa

dinamičkim prioritetomPravilo


Za procese u realnom vremenu Linux koristi FIFO i round-robin klase; u oba slučaja još ima i prioritet

Raspoređivač odabere proces najvećeg prioriteta, za jednako prioritetne procese, odabere onaj koji je najduže čekao

FIFO procesi nastavljaju do završetka ili blokiranjaA round-robin procesi se prekidaju i prebace na kraj reda raspoređivanja, pa se

round-robin procesi jednakog prioriteta automatski raspoređuju

Raspoređivanje procesa 2.6-3.12Ranije verzije su prolazile kroz cijelu tabelu procesa O(N)O(1) raspoređivač raspoređuje procese u konstantnom vremenu bez obzira koliko

procesa ima u operativnom sistemu ( Linux kernel 2.6.0 to 2.6.23Trenutno Completely Fair Scheduler, vrijeme O(log N) . Raspoređivač čuva

procese u formi balansiranog red-black stabla, koristeči proteklo vrijeme kao ključ i birajući najdalji lijevi čvor

14.17 Sinhronizacija jezgraZahtjev kernelu iz dva razloga:Aktivni program zahtijeva jezgro sistemskim pozivom ili greškom straniceDrajver izaziva hardverski interaptSinhronizacija jezgra pazi da kritična sekcija jezgra ne bude prekinuta drugom

kritičnom sekcijomLinux koristi dvije tehnike za zaštitu kritične sekcije:1. Normalni kernel kod se nije prekidao (do 2.4)– kad se desi tajmer interapt usred servisne rutine jezgra, postavi se need_resched

fleg, pa se raspoređivač pokrene nakon završetka sistemskog poziva2. Unutar obrade interapta, novi interapti su isključeni

Da se izbjegne veliko čekanje, Linux kernel smanjuje isključenost interapta u kritičnoj sekciji

Interapt obrada se dijeli na gornju polovinu i bdonju polovinu.U gornjoj polovini interapti su isključeniU donjoj polovini su uključeni, a mali raspoređivač sprečava da se donje polovine

međusobno prekidaju

14.18 Simetrično multiprocesiranjeLinux 2.0 je bilo prvo jezgro za višeprocesorski rad. Različiti procesi ili niti se

mogu izvrpiti u paraleli na raznim procesorimaKernel spinlock, određuje da samo jedan procesor može da samo jedan procesor

može izvršavati kod u jezgru

credits :=credits

2+priority


14.19 Upravljanje memorijomUpravljanje fizičkom memorijom u Linux sistemima alocira I dealocira stranice,

grupe stranica I male blokove memorijePodržava virtuelnu memoriju, I memoriju mapiranu u adresni prostor aktivnog

procesaRazdvaja memoriju u 3 zone po hardverskim karakteristikama



Upravljanje fizičkom memorijomAlokator zauzima I oslobađa fizičke straneKoristi Buddy sistem za praćenje slobodne fizičke memorijeSvaki alocirani region se upari sa susjedomKada se dva susjedna regiona oslobode formiraju veći regionAko se mali zahtjev ne može zadovoljiti alokacijom malog regiona, veći se dijeli

na dva partneraKernel drajveri mogu alocirati kontinualni blok statički ili dinamički (preko

stranica)Virtualna memorijaVM sistem kreira strane virtuelne memorije na zahtjev I brine o učitavanju I

zamjeni na diskSvaki proces imalogički I fizički pogledNovi virtualni prostori se kreiraju pri pozivima fork i execLinux kernel za svaki proces ima svoje, mašinski ovisno područje u memoriji,

podijeljeno na pokazivače na sve dostupne stranice i nerezervisani dioMemorijsko područje ELF programa

14.20 Datotečni sistemiDatotečni sistem izgleda kao hijerarhijsko stabloKernel apstrahuje sve sisteme kao jedinstveni virtual file system (VFS) Linux VFS se sastoji od dvije komponente:Skup definicija koje određuju na šta datotečni objekat ličiStrukture inode-object i file-object predstavljaju datoteke


file system object predstavlja datotečni sistemSoftverski sloj za manipulaciju objektimaExt2fs alocira u blokovima od 1K I smiješta logički susjedne blokove datoteke u

fizički susjedne blokove na disku

Proc datotečni sistem.proc datotečni sistem ne čuva podatke, nego se računa na UI zahtjeveproc mora implementirati direktorijsku strukturu sa brojevima indeksnih čvorovaBroj indeksnog čvora određuje vrstu operacije koja se obavi

14.21 Blok uređajiInterfejs prema disk uređajuma

Keš block buffer ima dvije uloge:Skup bafera za aktivni I/OKeš za završeni I/O

request manager čita I piše bafere iz blok uređaja

14.22 Znakovni uređajiDrajver ne pruža slučajni pristupZnakovni uređaj mora registrovati skup funkcija za U/I operacijeKernel ne obrađuje zahtjeve za čitanje I pisanje datoteke, nego proslijedi zahtjev

uređajuIzuzetak su neki terminalski uređaji, za koje kernel održava standardni interfejs

14.23 Interprocesna komunikacijaLinux može da šalje signale, ali one ne nose dodatne informacijeLinux kernel interno ne koristi signale, nego stanja raspoređivanja I wait.queue

struktureSistemom cijevi se komunicira između procesaDijeljena memorija je brži način komunikacijeKoristi isti princip kao memorijski mapirana datoteka

Mrežna struktura 407

14.24 Mrežna strukturaPodržani standardni Internet protokoli (TCP, UDP, IP) kao I neki drugo (Appletalk

I IPX)Interno, umrežavanje u Linux jezgru se sastoji od tri sloja softvera:socket interfaceProtokol drajveriDrajveri mrežnog uređaja

14.25 SigurnostKontrola pristupa određena identifikatorima (uid and gid)Objektima se dodijele zaštitne maske (ko može da čita piše ili izvršava)

408 Mobilni operativni sistemi

15 Mobilni operativni sistemidsdsOPERATIVNI SISTEMIOPERATIVNI SISTEMI ZAMOBILNE UREĐAJEMobilni uređaji u usporedbi s stonimUvijek s korisnikomImaju često Internet pristupObično imaju GPS Imaju kompaseKamere I mikrofoniAplikacije besplatne ili jeftineOgraničen ekranOgraničen život baterijeOgraničena brzina procesoraSpor mrežni pristupNepraktični ulazni uređaji: soft keyboard, phone keypad, touch screen, ili pisaljkaOgraničen web browserPuno platformi

15.1 Google AndroidSoftvarski stek za mobilne uređaje koji uključujeOperativni sistemMeđuslojKljučne aplikacije

Koristi Linux za sistemske uslugeSigurnostUpravljanje memorijomUpravljanje procesimaUpravljanje napajenjemHardverski drajvovi

Google Android 409


Android aplikacijeGrade se koristeći Java I SDK bibliotekeNe koriste se Swing & AWTJava code kompajlirana u Dalvik byte code (.dex)Optimizovano za mobilne uređaje (bolje upravljanje memorijom, upotreba baterije,

itd.)Dalvik VM izvršava .dex datoteke

ADB je client server program koji povezuje klijente na programerskoj mašini sa uređajima I emulatorima

Svaka aplikacija ima svoj Linux procesProces pokrenut kada se kod aplikacije treba izvršitiThreads može obaviti vremenski zahtjevne operacijeSvaki proces ima svoju Dalvik VMSvakoj aplikaciji dodijelje jedistvei Linux IDPrava postavljena da su aplikacijske datoteke vidljive samo njoj

Symbian OS 411

15.2 Symbian OSNastao iz Psion EPOC, korišten u Nokia sistemima do 2012Dizajn: Objektna orijentacija jezgra, svi sistemski pozivi rade preko handle koji je

apstraktna predstava podatakaMicrokernel DizajnPreko poruka

Struktura Symbian OS

Symbian OS NanokernelRaspoređivanje, interapti I sinhroizacijaKernel slojUpravljanje nitima, raspoređivanje, DLL, IPCServeriOtvaranje datoteke poziva file server I šalje mu poruku

U Symbian nit je glavna jedinica za multitaskingNanokerel raspoređuje nanothread. Nanothreads stanja:SuspendovanaČeka na brzi semaforČeka odložen funkcijski pozivUspavanaOstaloProcesiGrupe nitiInterprocesa komunikacijaSoketi i semaforiNema virtuelne memorijeBriga o veličini aplikacijeIzbjeći statičko linkovanjeHeap upravljanjIzvršenje ein-placeProgram je već u FLASH memoriji, pa se ne mora prebaciti u RAMUčitavanje DLLsUpravljanje memorijom prepustiti hardveru


Straničenje s dva nivoaNa tabelu pokazuje TTBR registarSvaki proces ima virtuelni prostor ali se stranice ne zamjenjuju na diskDevice DriverPodijeljen u logički I fizički drajverKernel ExtensionsDrajveri koje Symbian učita pri

podizanjuDMA dosta korišten u drajverimaBlokirajući I/OKoristi se preko aktivnih objekata

(sistemski thread) koji sigalira OS I suspenduje proces

Uklonjivim medijima se upravlja preko softverkih kontrolera

Datotečni sistemiFFS2, FAT16, FAT32Koristi apstrakciju OS Sigurost I zaštitaNisu bitna korisnička prava, nego

zaštita od malicioznih aplikacijaCSY: komunikacijski serverTSY: telefonski sercerPRT: Protokolski modul

(TCPIP.PRT ili BT,PRT)MTM: Slanje poruka

Apple iOS 413

15.3 Apple iOS

iOS je Apple’s mobilni operativni sistem za iPhone proširen na iPAD, iPod Touch and Apple TV.

Inicijalno “iPhone OS”, u Junu 2010 preimenova u “iOS”.iOS je samo na Apple uređajima.Korisnički interfejs iOS bazira na gesturama.iOS je Unix bazira OS. iOS koristi četiri sloja apstrakcije, namely: Core OS , Core Services , Media

layer, i Cocoa Touch layer.

Windows Mobile OSsasaBlackBerry OS


UDIO TRŽIŠTA OS

UDIO TRŽIŠTA OS

Apple iOS 415

18

Kategorija Datum Linux Unix Interni Windows Ostalo

Desktop, laptop, netbook

1.12.2013 1.73% (Ubuntu) 7.43% (OS X)

90.83% (XP, 7, Vista, 8)

Smartphone, tablet

1.12.2013 39.07% (Android) 31.79% (iOS) 1.79% (WP8, RT)

27.35%

Server (web) 1.12.2013 31.86% (Debian, CentOS, RHEL)

34.94% (BSD, HP-UX, Aix, Solaris)

33.20% (W2K3, W2K8)

Superkompjuter 1.11.2013 96.4% (Custom) 2.4% (UNIX) 0.4% 0.8%

Mainframe 1.12.2008 28% (SLES, RHEL) 72% (z/OS)

Igraća konzola 1.6.2013 0% (SteamOS, Android)

29.6% (PS3) 40.9% (Wii)

29.5% (Xbox)

Embedded 1.3.2012 29.44% (Android, Other)

4.29% (QNX) 13.5% 11.65% (WCE 7)

41.1%

Real time 1.11.2011 19.3% (Android) 20.1% 35.8% (XPE, WCE)

24.8%

Documents

Operativni sistemi-Haris Ribić