1.

OPERATIVNI SISTEMI
JEZGRO

Srž OS-a, upravlja hardverskm i softverskim resursima na najnižem nivou. Sadrži funkcije
za najosnovnije usluge OS-a. Ulazi u radnu memoriju po pokretanju sistema i ostaje tu
tokom čitavog rada

SISTEMSKI POZIVI

Preko njih korisnički programi interaguju s jezgrom i mogu da izvršavaju osetljive

funkcije. Sistem većinom vremena radi u korisničkom režimu sa manje dozvoljenih funkcija,
zarad stabilnosti sistema pošto su samo sigurne operacije dozvoljene.
Ako program bude tražio osetljivu funkciju, on:
1. Signalira jezgru za konkretnu funkciju i stavlja potrebne podatke u poseban deo
memorije, namenjen za to.
2. Jezgro prebacuje sistem u Režim jezgra, sa svim dozvoljenim funkcijama, preuzima
podatke i obrađuje ih.
3. Jezgro vraća sistem u korisnički režim i daje rezultat programu.

TIP OS-A OD JEZGRA

1. Monolit
Sve usluge OS-a, zajedno s drajverima, su u jezgru, integrisani u jedan program
Maksimalna efikasnost
Greška lako dovodi do pada sistema
2. Slojevit
OS se sastoji od više slojeva, najniži je jezgro, najviši su aplikacije. Podaci se
prebacuju od sloja do sloja
Daleko stabilniji od monolita, jer greška ostaje u sloju
Ne-efikasan zbog višestrukog prevođenja i prebacivanja
3. Mikrojezgro
Jezgro sadrži samo najosnovnije funkcije. Drajveri i ostale usluge koje bi inače bile tu
se prebacuju u korisnički deo, u poseban deo memorije s većim privilegijama, grupisani u
servere
Stabilan pošto je jezgro jednostavno, s malo funkcija
Manjak efikasnosti u odnosu na monolit zbog obraćanja serverima pa jezgru
4. Hibrid
Kompromis između Monolita i Mikrojezgra. Neke usluge se vraćaju u jezgro zarad veće
efikasnosti. Cilj je odlučiti šta vratiti u jezgro
5. Egzojezgro
Jezgro služi samo da donese resurse programima. Programi interaguju direktno s hardverom,
putem biblioteka koje korisnik može da unapređuje po volji.
Može biti izuzetno efikasan u zavisnosti od naših biblioteka
Kod je najčešće nekonzistentan zbog korisničkog editovanja

PAKETNA OBRADA

Programi se nadovezuju jedan na drugi. Računari specijalizovani za U-I bi se koristili za

prenos podataka na magnetne trake. Magnetna traka bi se prenosila na računar
specijalizovan za obradu podataka. Računar bi rešio program sa ulazne trake i ispisivao
rezultat na izlaznu magnetnu traku. Postupak se ponavlja dok se ne izvrše svi programi sa
ulazne magnetne trake. Izlazna traka se na kraju prenosi na U-I računar za štampu. U ovo
vreme su brzine periferijskih uređaja i procesora bile uporedive.

MULTIPROOGRAMIRANJE

Ubaciti više programa u memoriju tako da se poveća iskorišćenost procesora. Jedan proces
se izvršava dok ne završi ili mu ne zatreba I/O operacija, ostali u međuvremenu rade I/O
operacije,i tako se smenjuju.
Treba naći kompromis između najveće moguće iskorišćenosti procesora i što manjeg vremena
izvršavanja programa

BAZIRANO NA MULTIPROG

MULTITASKING

Naprednija verzija Multiprog, programi se dele na task-ove, koji ne moraju nužno da se

završavaju I/O operacijama. Funkcioniše isto kao multiprog, samo ide task po task
 TIMESHARING

Jedan procesor, više korisnika. Svaki korisnik dobija procesor na kratko vreme(kvantum),
potom sledeći i tako u krug. Mali kvantum daje iluziju da procesor radi svo vreme za
korisnika.

MULTIPROCESIRANJE

U računaru postoji više procesora koji paralelno izvršavaju programe. Doživljava procvat u
najnovijoj genraciji računara

2. UPRAVLJANJE PROCESIMA
STANJA PROCESA

Većina OS-ova podržava

Nov - tek je ušao u radnu memoriju
Spreman - ima sve potrebne resurse, čeka na procesor da bi se izvršavao
Izvršavanje – proces se izvršava na procesoru
Čeka - čeka neki resurs bez kog ne može da se izvršava
Gotov - završio s radom, treba izbaciti iz memorije

Spreman -> Izvršavanje

Oslobodio se procesor i OS po nekom kriterijumu odabrao proces i dodelio mu procesor
Izvršavanje -> Čeka
Procesu za dalje izvršavanje potrebni resursi koji trenutno nisu dostupni
Izvršavanje -> Spreman
Kada procesu istekne vreme koje mu dodelio OS
Čeka -> Spreman
Kada proces dobije potrebne resurse i spreman je za rad

Suspendovan
Suspendovan proces otpušta sve resurse koje drži i prestaje da konkuriše za resurse
Spreman proces se suspenduje ako ima previše spremnih procesa, da bi se olakšalo biranje
za izvršavanje, a ponekad ti oslobođeni resursi mogu sprečiti zaglavljivanje
Proces koji čeka se suspenduje najčešće da bi se sprečilo zaglavljivanje korišćenjem
oslobođenih resursa

KONTROLNI BLOK

Čuva evidenciju o procesu zarad efikasnijeg rada. Sadrži

Process ID - jedinstven
Brojač instrukcija - pokazuje na sledeću instrukciju
Adresa procesa - pokazivači na stranice/segmente procesa
Adrese resursa - to uključuje fajlove s kojima radi
Stanje procesa - Spreman, čeka itd
Prioritet itd.
OS ima mehanizme za stvaranje, brisanje KB, menjanje prioriteta, biranje procesa za
izvršavanje, menjanje stanja itd.

PREBACIVANJE KONTEKSTA

Jedan proces se izvršava na procesoru, oćemo da ubacimo drugi da se izvrši. Redom:

1. Proces koji se izvršava staje s radom
2. Njegovo stanje se čuva u njegovom Kontrolnom Bloku i vraća se u memoriju
3. Učitamo drugi proces i njegov KB
4. Brojač instrukcije++ i krećemo s radom
Za ovo je zadužen Dispečer

NITI

Delovi jednog procesa, slični procesima, od matičnog procesa nasleđuju segmente koda i
podataka, a heap,stack i brojač imaju sopstveni. Dve prednosti pri korišćenju
1. Memorija
Pošto se od matičnog procesa nasleđuju 2 segmenta, ti segmenti se ne moraju praviti novi,
nego pokazujemo na ta dva iz matičnog procesa. Time mnogo uštedimo u odnosu na posebne
procese
2. Vreme
Zbog istih podataka niti se brže prave u odnosu na procese, plus je prebacivanje konteksta
između niti istog procesa brže
Primer serverske aplikacije:
Aplikacija počinje s jednom niti koja osluškuje ako ima neki klijent. Ako naiđe, onda se
za njega pravi nit koja ga usluži. Pošto imamo niti umesto procesa, možemo više korisnika
opslužiti za isto vreme i memoriju

PLANERI

Imamo red poslova koje treba uraditi. Dugoročni planer bira procese koji će preći u red
spremnih procesa(stanje Spreman). Poželjno je da algoritam ovog planera daje što bolje
rezultate
Imamo red spremnih procesa za izvršiti. Kratkoročni planer bira proces koji će se
izvršavati. Poželjna je što veća brzina algoritma zbog čestog pozivanja
Neki sistemi imaju ugrađen srednjeročni planer. Ponekad se procesi ometaju/zaglavljuju.
Ovaj planer nalazi te slučajeve i razrešava problem suspendovanjem 1 ili više procesa i
naknadnim ponovnim pokretanjem, kad se poboljšaju uslovi. Ta šema se zove prebacivanje

RASPOREĐIVANJE PROCESA
Naći redosled kojim će se izvršavati procesi tako da sistem radi što efikasnije
Kriterijumi:
1. Iskorišćenost procesora. Što veće moguće
2. Vreme obrade procesa. Što manje moguće
3. Vreme čekanja procesa. Što manje moguće
4. Broj obrađenih procesa u jedinici vremena. Što više moguće

ALGORITMI RASPOREĐIVANJA PROCESA:

FCFS
Implementira se sa FIFO, izvršava se proces koji je najranije došao u red.
Jednostavan za implementaciju.Ako se neki proces dugo izvršava, lako dođe do velikog broja
procesa koji čekaju procesor(efekat konvoja)

SPF
Za svaki proces se proceni vreme izvršavanja, izvršava se onaj s najmanjim vremenom.
Varijante sa i bez prekidanja.
Sa:Ako naiđe proces koji je kraći od onog koji se izvršava, prebacuje se kontekst da se on
izvrši prvo.
Bez: Čeka na red kao i ostali
Dugi procesi dugo čekaju na izvršavanje
Kako proceniti vreme izvršavanja?
Jedna varijanta: tau(n+1)=a*tau(n)+(1-a)*t(n)
tau(n)-procenjeno vreme za n-tu aktivnost
t(n)-stvarno vreme -------||-------
a - const između 0 i 1

PRIORITETI
Svakom procesu se daje broj koji određuje prioritet. Izvršava se proces najvećeg
prioriteta.
Kako odrediti prioritet?
Mogu biti interni, za računar merljivi faktori. Vreme izvršavanja, vreme dolaska,
memorijski zahtevi itd.
Ili eksterni,spoljašnji faktori. Važnost klijenta, rok izvršavanja, političke prirode itd.
Procesi niskog prioriteta dugo čekaju
Može se rešiti taj problem postepenim povećavanjem priorieta procesa što duže čeka

KRUŽNO
Bazirano na timesharingu. Svaki proces dobija procesor na kvantum vremena q. Ako završi s
radom ili prođe q, prebacuje se konkekst na sledeći proces i tako u krug.
Garantuje se da će svaki proces čekati maksimalno q(n-1) vremena da se izvršava.
Ako je q premali gubimo previše vremena na prebacivanje
Ako je preveliki onda se svodi na FCFS

REDOVI
Imamo više redova različitog prioriteta. Bira se proces iz reda najvećeg prioriteta. Ako
nema u njemu, onda sledeći najveći red itd.
Svaki od tih redova ima svoj algoritam raspoređivanja kojim nudi proces
Problem je što procesi u redovima nižeg prioriteta dugo čekaju

REDOVI S POVRATNOM SPREGOM

Procesi se mogu prebacivati između redova, npr ako dugo čeka proces na rad. Tako se
smanjuje izgladnivanje
Primer: 3 reda
R1: Q=8mikrosekundi svi prvo idu ovde
R2: Q=16mikrosekundi ako ne završi za Q=8 onda ide ovde
R3: FCFS ako ni za Q=16 ne završi

3. KONKURENTNOST I SINHRONIZACIJA PROCESA

KRITIČNA SEKCIJA

Deo programa gde se interaguje s deljenim resursima. Važno je da se ovaj deo pravilno
obradi zarad konzistentnosti podataka i stabilnosti sistema
Rešenje ovog problema treba da
1.Garantuje da je samo jedan od procesa u sekciji u jednom trenutku - Uzajamna
isključivost
2.Proces koji ne želi sekciju ne sprečava ostale da uđu u nju - Uslov progresa
3.Garantuje se da će svaki proces dobiti sekciju eventualno - Konačno čekanje

AKTIVNO ČEKANJE

Procesi koji žele sekciju a ne mogu da uđu bivaju zaglavljeni u beskonačnoj petlji dok im
ne bude dopušteno da uđu. Ovo često dovodi do vremena potrošenog na nepotrebno loop-ovanje

STRIKTNA ALTERNACIJA
P1:
while(naredu==2);
//sekcija
naredu=2;

isto za P2 samo zameni 2 sa 1 i obrnuto gde treba

naizmenično 2 procesa idu u sekciju

Ispunjava samo prvi uslov.
Proces koji ne želi sekciju neće omogućiti drugom da uđe. Takođe ne garantuje konačno
čekanje zbog toga
Može biti koristan kad hoćemo da 2 procesa naizmenično rade sa sekcijom, pošto je
jednostavan
Radi samo za 2 procesa

DEKER
P1:
zeli1=1;
while(zeli2==1){
if(naredu==2){
zeli1=0;
while(naredu==2);
zeli1=1;
}
}
//sekcija
naredu=2;

Ako proces ne može u sekciju da uđe on će dati drugom procesu da preskoči while petlju i
odmah u sekciju.
UZ.ISK i U.P. ispunjava. KON.ČEK ne možemo garantovati jer ako proces opet hoće sekciju
nakon što završi on može da preleti opet u nju bez while petlje ako drugi proces ne dobije
da se izvrši u međuvremenu
Radi samo za dva procesa

PITERSON
P1:
zeli1=1;
naredu=2;
while(naredu==2 && zeli2==1);
//sekcija
zeli1=0;

Proces džentlmentski ustupa drugom procesu sekciju. Ako je ne želi onda drugi proces
preskače petlju
Ispunjava sva tri uslova
Važi samo za dva procesa
Pekarski je njegovo unapređenje

PEKARSKI
Pi:
ceka[i]=1;
broj[i]=max(broj)+1; //uzmi sebi broj
ceka[i]=0;
for(j=0;j<n;j++){
while(ceka[j]); //sačekaj da svi dobiju broj
while(broj[j]!=0&&(broj[j],j)<(broj[i],i));//čekaj u redu
}
//sekcija
broj[i]=0; //gotov, ostali nastavljaju kroz for

Unapređenje Pitersona
Kao u pekari, svaki proces dobija broj. Radi se proces najmanjeg broja
Ispunjava sva tri uslova i radi za više procesa

HARDVESRKI ALGORITMI
U procesoru postoji atomična operacija kojom se može proveriti stanje i nakon toga loop-
ovati proces ako nije na redu i time zaštititi sekciju. Zahteva da procesor ima ugrađenu
tu operaciju
TAS,FAA,SWAP

A=TAS(B) A=B B=1

PI:
NEMOZE=1;//prvo mu se ne da
WHILE(NEMOZE==1)NEMOZE=TAS(ZAUZETO);//ako je ZAUZETO 0 onda se pusti
//sekcija
ZAUZETO=0;//sekcija je slobodna sad

problem je što ne možemo garantovati konačno čekanje jer nemamo reda oko toga ko ide u
sekciju

TAS UNAPREĐENJE
Pi:
ceka[i]=1;
while(ceka[i]==1 && TAS(zauzeto)==1);
ceka[i]=0;
//sekcija
j=(i+1)%n;
while(ceka[i]==0 && j!=i){
j=(j+1)%n
}
if(j==i) zauzeto=0;
else ceka[j]=0;

kad proces završi sa sekcijom onda se redom gledaju sledeći procesi. Ako neki čeka pusti
ga da prođe, inače oslobodi sekciju

FAA(A,B) A,B -> B,A+B

MOZE=0;
WHILE(MOZE==0) FAA(MOZE,SLOBODNO);
//sekcija
SLOBODNO=1;

SWAP(A,B) A,B -> B,A

MOZE=0;
WHILE(MOZE==0) SWAP(MOZE,SLOBODNO)
//sekcija
SLOBODNO=1;

REŠENJA BEZ AKTIVNOG ČEKANJA

Umesto da se gubi vreme s loop-ovanjem, mogu se implementirati mehanizmi koji bi blokirali
proces koji ne može u kritičnu sekciju i potom odblokirali kad dođe na red za nju
Semafori, Kritični Regioni,Monitori

SEMAFORI
Imamo ceo broj S i operacije P i V.
P(S): S--. Ako je S<0 blokiraj ovaj proces
V(S): S++. Ako je S<1 odblokiraj neki drugi proces koji čeka
Ovo je jedna implementacija. Semafori mogu takođe biti binarni(samo 0 i 1, gde se prvo
proverava pa onda -- ili ++ ako je slobodna sekcija)
Implementiraju se kao servis OS-a, sa listom koja beleži blokirane procese. Mogu se
koristiti i van zaštite sekcije.
Treba biti pažljiv pri radu s njima jer mala greška će ili blokirati sve procese ili
narušiti ekskluzivnost sekcije

IMPLEMENTACIJA SEMAFORA
P(S):
S.vrednost--;
if(S.vrednost<0){
stavi proces u listu;
blokiraj proces;
}

V(S):
S.vrednost++;
if(S.vrednost<=0){
izbaci i odblokiraj proces iz liste;
}

BROJAČKI SEMAFORI POMOĆU BINARNIH:

P(C):
P(mutex); //ekskluzivan pristup semaforu
C--; //smanji celi broj
if(C<0){ //ako je neko u sekciji daj pristup sem i blokiraj se
V(mutex);
P(sekcija);
}
else V(mutex);

V(C):
P(mutex);
C++;
if(C<=0){ //ako je neko blokiran daj mu da uđe u sekciju
V(sekcija);
V(mutex);
}
else V(mutex);

PROIZVOĐAČ POTROŠAČ SEMAFORI

magacin je deljena struktura podataka nad kojom vršimo ubaci i uzmi

mutex=1; //ekskluzivan pristup magacinu
pun=0; //broj proizvoda u magacinu
prazan=velicinamagacina; //koliko ima mesta

proizvodjac:
P(prazan); //ako nema mesta sačekaj
P(mutex);
ubaci();
V(mutex);
V(pun); //ako neko čeka da uzme signaliraj

potrosac;
P(pun); //ako nema proizvoda sačekaj
P(mutex);
uzmi();
V(mutex);
V(prazan); //ako neko čeka da ubaci pusti

FILOZOFI SEMAFORI

filozofi[5];
S[5]={0,0,0,0,0}; //niz semafora koji blokiraju jedenje
filozof[i]{
uzmi[i];
vrati[i];
jede[i];
test[i];
}
uzmi[i]{
P(mutex); //ekskluzivan pristup stanjima
stanje[i]=gladan; //i je gladan
test(i); //da li može
V(mutex); //daj pristup
P(S[i]); //ako može ješće, inače čeka
}
vrati[i]{
P(mutex); //ekskluzivan pristup
stanje[i]=razmislja; //i ne jede vise
test(levi);
test(desni); //vidi da li susedi hoće
V(mutex); //ekskluzivan pristup
}
test[i]{
if(stanje[i]==gladan && stanje[levi]!=jede && stanje[desni]!=jede){//da li može da
jede
stanje[i]=jede; //daj mu da jede
V(S[i]); //daje se prolaz kroz f-ju
}
}

ČITAČI PISAČI SEMAFORI

pisaci=0; //broj pisača koji čeka

citaci=0; //broj čitača koji čeka
mutex1=1;
mutex2=1;
mozedapise=1;

citac{
while(pisaci>0) blokiraj nove čitače;
P(mutex1);
citaci++; //čitač čeka
if(citaci==1) P(mozedapise); //ako neko piše sačekaj
V(mutex1);
citaj();
P(mutex1);
citaci--;
if(citaci==0) V(mozedapise); //ako nema više čitača koji čekaju daj pisačima
V(mutex1);
}

pisac{
P(mutex2);
pisaci++; //pisač čeka
V(mutex2);
P(mozedapise); //čekaj dok ne dođeš na red da pišeš
P(mutex2);
pisaci--; //došao na red
V(mutex2);
pisi();
V(mozedapise); //gotov s pisanjem
}

KRITIČNI REGIONI

Zaštita kritične sekcije na višem nivou programskog jezika u odnosu na semafore.

Definišemo promenljivu kojoj se može pristupiti isključivo u okviru regiona koji garantuje
ekskluzivan pristup njoj

REGION v{
//operacije sa v
}

Praktičniji za koristiti od semafora ali je sinhronizacija slaba strana ovog pristupa.

Unapređenje:
Uslovni regioni
REGION v WHILE x{
//Ako je x ispunjeno i nije zauzet region on može da prođe u sekciju. Inače se blokira
...
AWAIT y//program izlazi iz regiona odmah i biva blokiran, ako y nije ispunjeno
...
}
I dalje može biti problem definisati sekciju koja će se ograničiti s REGION

PROIZVOĐAČ POTROŠAČ REGIONI

bafer:deljeno{
int magacin=0;
niz koji beleži proizvode u magacinu
}
proizvodjac{
region bafer while(bafer.magacin<velicinamagacina){//ima li mesta za još?
ubaciproizvod(niz);
bafer.magacin++; //ubaci i pribeleži
}
}
potrosac{
region bafer while(bafer.magacin>0){//ima li proizvoda?
uzmiproizvod(niz);
bafer.magacin--; //uzmi i pribeleži
}
}
region štiti ekskluzivan pristup tako da nam ne treba mutex ili slično

ČITAČI PISAČI REGIONI

v:deljeno{
int citaci=0;pisaci=0;
bool zauzeto=false; //za pisače namenjeno da može samo 1 da piše
}
citac{
region v{
await(v.pisaci==0); //ne mogu i č i p u isto vreme
v.citaci++; //pribeleži da ima
}
citaj();
region v{
v.citaci--; //gotov
}
}
pisac{
region v{
await(v.citaci==0 && !v.zauzeto);//nema čitača koji čekaju i pisača koji
rade
v.pisači++;
v.zauzeto=true; //blokiraj ostale pisače
}
pisi();
region v{
v.pisaci--;
v.zauzeto=false; //gotovo
}
}

MONITORI
Najviši nivo apstrakcije rešenja problema krit.sekc. Slični klasama u OOP sa promenljivama
i procedurama. Definišu se sa uslovnom promenljivom i funkcijama wait i signal.
x.wait() - čekaj
x.signal() - signaliraj procesu koji čeka zbog x.wait() da prođe. Ništa ne radi ako niko
ne čeka
U okviru njih su definisani mehanizmi za sinhronizaciju i zaštitu.
Laki za koristiti i mogu se koristiti van sekcija ako zatreba, za razliku od regiona
Definisani u okviru samih Programskih jezika
Debata: Nek P signalira Q. Da li će P odmah izaći iz sekcije u korist Q ili će Q sačekati
da P izađe pa tek onda ući?
Ako P odmah izlazi onda bi signal trebao da bude poslednja operacija u sekciji
Ako Q čeka, to omogućava P da radi još neke operacije ili da signalira više puta
Obično koriste FCFS za raspoređivanje čekača, naprednije može prioritetno čekanje(raste
prioritet čekača s vremenom)

MONITORI PUTEM SEMAFORA

x:struct{
sem_t sem;
int brojac;
}

x.wait(){
x.brojac++;//još jedan proces čeka
if(brojacprocesa>0)V(proces);//ako je neko blokiran s proces
else V(mutex); //ekskluzivan pristup monitoru
P(x.sem); //blokiranje procesa na semaforu
x.brojac--; //više ne čeka proces
}
x.signal(){
if(x.brojac>0){
brojacprocesa++;
V(x.sem);//propusti proces koji čeka
P(proces);//suspenduj proces pošto je poslao signal
brojacprocesa--;
}
}

PROIZVOĐAČ POTROŠAČ MONITORI

pun,prazan - uslovne promenljive;
int bp=0,n-velicina magacina;
maagacin je u okviru monitora;
proizvodjac(){
if(bp==n) pun.wait(); //čekaj ako nema mesta
staviproizvod;
bp++; //pribeleži
if(bp>0) prazan.signal(); //ako potrošač čeka
}
potrosac(){
if(bp==0) prazan.wait(); //čekaj ako je prazno
uzmiproizvod;
bp--; //pribeleži
if(bp<n) pun.signal(); //ako proizođač čeka
}

monitor čuva ekskluzivan pristup samom magacinu!

FILOZOFI MONITORI:
filozof[5]- uslovne promenljive;
uzmi(i){
stanje[i]=gladan;
test(i);
if(stanje[i]!=jede) filozof[i].wait();//blokiraj ako ne može da jede
}
vrati(i){
stanje[i]=razmislja;
test(levi);
test(desni); //vidi da li su susedi gladni
}
test(i){
if(stanje[levi]!=jede && stanje[i]==gladan && stanje[desni]!=jede){
stanje[i]=jede;//neće biti blokiran s wait ako već nije
filozof[i].signal();// ako fil čeka na wait-u
}
}

4. ZAGLAVLJIVANJE
To je situacija kada 2 ili više međusobno zavisnih procesa blokirani čekaju na resurse
koje nikada neće dobiti.
Slični zaglavljivanju su:
Živo blokiranje, gde imamo više procesa koji nisu blokirani ali ne mogu napredovati(npr
automobili na raskrsnici koji ustupaju prolaz pa niko ne može)
Izgladnjivanje, gde neki proces predugo čeka da se izvrši

KOFMANOVI USLOVI:

Da bi došlo do zaglavljivanja moraju važiti sledeća 4 uslova

1. Uzajamno isključenje - resursu može samo jedan proces da pristupa u jednom trenutku
2. Čekanje i držanje - proces koji se izvršava ima pravo da traži još resursa i da drži
resurse koje već ima dok čeka
3. Nemogućnost prekidanja - OS nema pravo da prekine program usred rada zarad regulacije,
program može jedino samog sebe zaustaviti
4. Kružno čekanje - imamo lanac procesa, P1 čeka resurs koji drži P2, P2 čeka P3...PN čeka
P1.
Ovo ne garantuje da će doći do zaglavljivanja, ali postoji mogućnost

NAČINI REGULACIJE ZAGLAVLJIVANJA

1. Sprečavanje - sistemske mere/pravila koje se uvode pri početku rada i koje

onemogućavaju jedan od Kofmanovih uslova po cenu efikasnosti sistema, time onemogućavajući
zaglavljivanje
2. Izbegavanje - Dinamičke mere pri čemu se sistem provodi kroz bezbedna stanja gde je
nemoguće doći do zaglavljivanja
3. Detekcija i oporavak - u sistemu postoje mehanizmi koji detektuju zaglavljivanje i
regulišu ga
4. Nepreduzimanje bilo čega - ako procesi nisu važni ili se retko zaglavljuje sistem,
bolje je ne gubiti vreme na regulaciju i jednostavno restartovati zaglavljene procese

SPREČAVANJE

Ideja je da se sistemskim pravilima unapred onemogući jedan od Kofmanovih uslova, time

onemogućavajući zaglavljivanje
1. Ne može se onemogućiti, inače narušavamo podatke i stabilnost sistema
2. Postoje dva pristupa
2.1. Proces ne može početi s radom dok ne dobije sve resurse koji će mu potencijalno
trebati i tokom čitavog rada ih drži. Ti procesi rade do kraja i ne mogu se zaglaviti jer
imaju sve što im treba, ali ovo narušava multiprogramiranje i time efikasnost sistema,
plus što ne znamo uvek šta će sve procesu trebati
2.2. Proces koji se izvršava traži 1 po 1 resurs da obavi svoje poslove. Kad iskoristi
resurse otpušta ih. Ovo često dovodi do prečestog otpuštanja i vremena potrošenog na
odlučivanje i moguće je izgladnjivanje procesa jer se resursi dele svuda oko njih a njima
ne
3. Proces koji se izvršava i traži još resursa koje ne može odmah dobiti se odmah prekida
i otpušta sve što drži. Isto kao sa 2.2., s time da se otpušta samo ako ne može odmah
zadovoljiti. Zahtevni procesi dugo čekaju
4. Svakom resursu dajemo broj. Proces ne može tražiti resurse manjeg broja od najvećeg
broja koji već drži, tj on mora prvo otpustiti resurse većeg broja od traženog. Problem je
sama enumeracija, em kako ćemo, em što moramo opet numerisati kad dođe novi resurs

IZBEGAVANJE

Dinamički se sistem provodi kroz stanja gde je nemoguće zaglavljivanje

BANKAREV ALGORITAM

Za svaki proces znamo njegove maksimalne zahteve. Dinamički ispitujemo dodele resursa da
bismo našli bezbednu sekvencu dodele, tj takav raspored da se neće zaglaviti. Time
garantujemo da je sistem u bezbednom stanju

Provera stanja:
n procesa;
potrebno[n]; //znamo njihove maksimalne zahteve
dodeljeno[n]; //znamo šta sve već drže
radni=raspolozivo; //radni nam kaže s čime raspolažemo garant
gotov[i]=0 za svako 0<=i<n;
sledeci:
if(za svako i gotov[i]==1 && potrebno[i]<=radni)idi na kraj;//da li su svi zadovoljeni
nadji prvi i tako da gotov[i]=0 i potrebno[i]<=radni;
ako nema idi na kraj;
radni+=dodeljeno[i]; //moći će se zadovoljiti, smatrati da će resursi biti dostupni
gotov[i]=1; //zadovoljen
idi na sledeci;
kraj:
if(gotov[i]==1 za svako i) return true; //bezbedno stanje
else return false; //nebezbedno

Kako to izgleda u praksi...

P[i] hoće da se izvrši.
Dodela resursa:
if(potrebno[i]<zahtev[i])greska posto proces prevazilazi maksimalne zahteve;
if(raspolozivo<zahtev[i])proces ce cekati jer nema dostupnih resursa;
raspolozivo-=zahtev[i];
dodeljeno[i]+=zahtev[i];
potrebno[i]-=zahtev[i];
if(Provera stanja) nastavi s radom;
else P[i] ce morati da saceka a sistem se vraca na bezbedno stanje;

DETEKCIJA I OPORAVAK

DETEKCIJA
U sistemu postoje mehanizmi koji detektuju zaglavljivanje i regulišu.
Ta detekcija može biti aktivna(redovno se proverava) ili pasivna(gledaj ako neki procesi
ne napreduju dugo ili nešto nije u redu)
Može se detektovati pomoću grafova. Zamislimo dva tipa čvora, jedan za resurse a drugi za
procese.
Grana od resursa do procesa - proces drži resurs
od procesa do resursa - proces čeka resurs
Ako svaki resurs ima 1 instancu, pretraga se svodi na traženje ciklusa, složenost O(n)
Ako imaju više instanci

radni=raspolozivo;
for(i=0;i<n;i++){
if(zahtev[i]!=0) gotov[i]=0;
else{gotov[i]=1; radni+=dodeljeno[i];
}
sledeci zadovoljiv proces:
if(za svako i gotov[i]==1 && zahtev[i]<radni) idi na kraj;
nadji prvo i tako da gotov[i]==0 i zahtev[i]<radni;
radni=radni+dodeljeno[i];
gotov[i]=1;
idi na sledeci zadovoljiv proces;
kraj:
if(gotov[i]==0 za neko i) sistem se zaglavio, procesi sa gotov[i]=0 su zaglavljeni;

Složenost O(m*n^2) m-broj različitih resursa, n-broj procesa

OPORAVAK
Postoje dva načina
1. Suspenduj procese
1.1. Suspenduj sve zaglavljene procese. Ekstreman potez koji škodi efikasnosti zbog
gubitka napretka
1.2. Suspenduj jedan po jedan proces u nadi da će se razrešiti zaglavljivanje
Kako izabrati procese za suspendovati? Neki kriterijumi:
Prioritet - suspenduj proces niskog prioriteta
Progres - bolje ne diraj proces koji je skoro gotov, nađi neki koji je skora počeo
Zahtevi - gledaj da suspenduješ proces koji drži mnogo resursa koji su drugima
potrebni
2. Oduzmi resurse
Nekim procesima se oduzmu resursi da bi drugi nastavili s radom i razrešio problem. Gleda
se da program ostane u stanju gde može nastaviti s radom ili da mora se malo vratiti kroz
korake programa, umesto da krene ispočetka.
Ponekad može pomoći oduzimanje resursa nezaglavljenim procesima

5. UPRAVLJANJE MEMORIJOM
MEMORIJA
Deo računarskog sistema zadužen za čuvanje procesa i podataka. Može čuvati privremeno(gubi
se po gubitku napajanja) ili trajno.

TIPOVI MEMORIJE:

1. Registri, najbrža memorija, u procesoru, čuva podatke s kojima procesor trenutno radi.
Privremeno čuva
2. Keš, čuva informacije o podacima, ili same podatke, da bi im se brže pristupelo umesto
silaženja u sporu radnu memoriju. Privremeno
3. Primarna/Radna memorija, čuva programe s kojima procesor trenutno operiše.
RAM - Random Access Memory, računar može pristupiti bilo kojem delu ove memorije i
vreme pristupa ne zavisi od lokacije u memoriji. Bez ove memorije, koja privremeno čuva,
računar ne može da funkcioniše. Na ovo se misli kad se kaže memorija
ROM - Read Only Memory. Trajno čuva podatke. Obično računar ima malo ove memorije
iz koje čita važne podatke pri paljenju OS-a
4. Sekundarna memorija, služi za trajno čuvanje podataka. S njima se može raditi tek kad
se učitaju u radnu memoriju. Poprilično spora. HDD,SSD,CD,DVD,USB itd.

SIMBOLIČKE/FIZIČKE ADRESE

Kad se program piše ne zna se gde se nalaze promenljive u memoriji. U tom slučaju imena
tih promenljivih se tretiraju kao simboličke adrese, a kad se učita program generiše se
prava, fizička adresa.

RELATIVNE ADRESE

Pri kompilaciji memorija za podatke se generiše relativno od početka dela memorije vezane
za taj program. To je relativna adresa. Kad se učita program za red generisaće se fizička
adresa od strane Linkera

LOGIČKE ADRESE
Procesor ne radi sa fizičkim adresama podataka, nego generiše sopstvene logičke adrese.
Ako se prevođenje tih adresa vrši tokom kompilacije/punjenja programa, one odgovaraju
fizičkim adresama, al ako se povezuje tokom izvršavanja, onda nisu. MMU preslikava logičke
u fizičke, najčešće dodavanjem vrednosti baznog registra na logičku adresu.

USLOVI PRI UPRAVLJANJU MEMORIJOM

1. Svaki proces mora imati dovoljno memorije za izvršavanje i ne sme pristupati memorijama
drugih procesa.
2. Memorije moraju biti korišćene tako da se svaki proces izvršava najefikasnije moguće

MONOPROGRAMIRANJE:

Radna memorija se deli na dva dela

Jedan za OS, drugi za proces koji se izvršava.
Može takođe da bude deo za OS, deo za proces, deo za drajvere
Zaštita od lošeg pristupa pri ovom sistemu se može implementirati hardverski, putem
zaštitnog registra. Ako je tražena adresa manja od njega onda je to greška.
Problem je kad se promeni adresa tog registra, jer se onda mora opet prevoditi program.
Alternativa je relokatibilni kod, gde se povezivanje odlaže do punjenja, i time promena
registra samo zahteva ponovno punjenje programa
Mana ovoga jeste što se i do 80% vremena gubi na I/O operacije. To vreme se može
iskoristiti bolje

MULTIPROGRAMIRANJE
Umesto da procesor gubi vreme čekajući da proces završi I/O, on može raditi neki drugi
proces. Postoji više načina obrađivanja toga

PREBACIVANJE
Proces koji radi I/O ne mora biti u memoriji. On se može prebaciti nazad u disk i učitati
drugi program koji će se izvršavati.
Efikasnost zavisi od brzine sekundarne memorije, što je loše zbog sporosti nje.
Potrebno je dovoljno mesta u sek.memoriji za ove procese, plus direktan pristup njima.
Napredniji pristup bi bio da se radna memorija procesa podeli na dva bafera, po jedan za
proces. Izvršava se proces dok ne zatreba I/O, potom se prebaci na sek. memoriju, potom se
učita program iz drugog bafera i učita se program u prazno mesto, time omogućavajući veću
iskorišćenost

PARTICIJE
Memorija se deli na n particija, po jedna za proces. To nam omogućava n-ti stepen
multiprogramiranja. Ako nema mesta u particijama formira se red spremnih procesa koji čeka
slobodnu particiju.
Particije se štite od lošeg pristupa definisanjem početne i krajnje adrese adrese u
registrima. Time se ne da pristup adresama izvan tog skupa
Dva načina particionisanja

STATIČKA
Veličina particija se ne menja u toku rada, tj particije su fiksne veličine, a svi procesi
se prvo smeštaju u red spremnih poslova, pa se onda odlučuje gde će ići procesi
Dve strategije:
1. Svaka particija ima svoj red poslova gde idu procesi koji mogu stati u nju
2. Svi procesi idu u jedan red pa potom planer odlučuje gde će ići koji proces.
Unapređenje ovog pristupa nam omogućava da se procesi koji nisu na redu ali mogu da stanu
u neku particiju ubace. Npr prvi proces ne može da stane trenutno, pa gledamo sledeći itd.

DINAMIČKA
Veličine particija nisu fiksirane.
Pri početku rada, memorija se deli na deo za OS i slobodan prostor. Kad uđe program u
memoriju on se smešta u slobodan deo, a ostatak obrazuje slobodnu particiju itd. Kad
proces završi oslobađa particiju
Kako evidentirati slobodan prostor u dinamičkim particijama?
1. Bit-mape. Niz 1 i 0 predstavlja memoriju gde je 0 slobodan niz bitova a 1 zauzet. Kad
tražimo slobodnu particiju tražimo dovoljno velik niz 0.
Jednostavna implementacija, pretraga može biti izuzetno zahtevna.
2. Povezane liste. Napredniji pristup, imamo niz čvorova. Oni sadrže:
Bit - da li je slobodna particija?
Početna adresa
Dužina particije
Pokazivač na sledeću particiju
Neke implementacije imaju dve liste, jedna za slobodne, druga za zauzete.
Teža implementacija, znatno brža pretraga
FRAGMENTACIJA
Kad imamo delove memorije koji su slobodni ali se ne mogu iskoristiti.
INTERNA FRAGMENTACIJA
Ako se proces smesti u particiju veću od njega ostatak prostora se ne koristi. Ovo je
problem kod statičkih particija
EKSTERNA FRAGMENTACIJA
Imamo slobodne delove memorije koji su premali za proces. Time su neupotrebljivi. Dešava
se često kod dinamičkih particija. Jedno rešenje kod din. particija jeste kompakcija.
Nabij sve particije u jednu stranu, ostatak biva slobodan prostor. Veoma zahtevna
operacija pa se ne koristi često. Eks.Frag se dešava i kod statičkih particija, kad
nijedna slobodna particija nije dovoljno velika

ALGORITMI ZA DODELU MEMORIJE

FIRST-FIT
proces ide u prvu slobodnu, dovoljno veliku particiju. Jednostavan algoritam, ali se često
fragmentira
NEXT-FIT
Kao FF ali počinjemo gde smo prošli put stali s algoritmom. Malo manje efikasan
RANDOM
Slučajno biramo od slobodnih i dovoljno velikih particija jednu za proces. IZUZETNO ne-
efikasan zbog random generatora i traženja particija
BEST-FIT
Najbolji u praksi. Biramo najmanju slobodnu dovoljno veliku particiju za proces. Malo
zahtevniji algoritam ali dobre rezultate daje
WORST-FIT
Uđi u najveću slobodnu particiju. Ostatak se može iskoristiti za drugi proces

STRANIČENJE

Način dodele memorije gde ne mora proces biti čitav u memoriji. Program delimo na stranice
fiksne veličine, iste kao okviri u memoriji. Procesor pri ovome radi sa logičkim adresama
od dva dela
p - broj stranice
d - pozicija u stranici
Tabela stranica služi za prebacivanje logičkih u fizičke adrese. Ona pamti adrese svih
stranica jednog procesa, tj svaki proces ima svoju tabelu. p -> adresa stranice, d->
odstupanje od te adrese. BUM, to je fiz.adresa podatka.
Ako je veličina okvira stepen dvojke, to nam omogućava da em izračunamo logičku adresu od
relativne sa R/vel.okv i R%vel.okv, em relativna i logička adresa mogu biti jednaki, gde
viši bitovi daju redni broj stranice a niži odstupanje. Plus se logičke preslikavaju u
fizičke jednostavnim nadovezivanjem odstupanja na adresu stranice.
Proces se pri straničenju pokreće tako što se učitaju stranice koje su isprva potrebne i
smenjuju se po potrebi, mogu i više da budu.
Nema eksterne fragmentacije zbog fiksne veličine, ali postoji interna ako uđe zadnja
stranica programa koja je najčešće manja od okvira. Plus možemo deliti stranicu između
procesa ako se ona ne samomodifikuje, npr kod koda i niti
PTBR- pokazivač na adresu stranice u radnoj memoriji. Pošto je tabela često prevelika da
bi se praktično čuvala u registrima.
Problem ovde je 2 pristupanja sporoj radnoj memoriji za jednu stranicu

ASOCIJATIVNA MEMORIJA

Asoc memorija = keš memorija za potrebe straničenja. Za tabelu stranica. Malo sporija od
registara, ali većeg kapaciteta.
Čuva podatke u parovima ključ - vrednost, tj broj stranice - adresa nje.
Ako procesor traži stranicu prvo gleda u asoc.memoriji znajući broj nje. Ako nađe tu on
direktno ide na tu adresu i nalazi podatak. Inače je promašaj i procesor gleda tabelu u
radnoj memoriji
Gleda se da se u njoj pamte često korišćene stranice zarad maksimalnog hit ratio i time
efikasnosti

SEGMENTACIJA

Logički delimo program. Jedan deo za glavni program, jedan za stack itd.
Svakom segmentu dajemo poseban memorijski prostor sa posebnim pravima. NPR kod se samo
može čitati i slično. Korisno kod niti.
Kao i kod stranica, logičke adrese seg imaju broj seg, odstupanje i tabelu segmenata kojom
se prevodi u fizičku adresu. Plus možemo koristiti asoc. memoriju
Ovako možemo i praktično deliti segmente između procesa ili još bolje niti.
Zbog ne-fiksne veličine poželjne su dinamičke particije, ali zbog manjih veličina
segmenata manje ima fragmentisanja
Može se unaprediti putem segmentacije sa straničenjem, gde se segmenti dele na stranice.
Time se segmenti lakše smeštaju u memoriju jer ne zahtevaju jedan veliki blok

6. VIRTUELNA MEMORIJA
Metod kojim se omogućava da program radi s više memorije nego što je dobio u radnoj
memoriji. U savremenim sistemima to najčešće znači da program može da radi iako nije ceo u
radnoj memoriji. Ovo omogućava veći stepen multiprog. Tri najpoznatija pristupa su:
PREKRIVAČI
Identifikujmo nezavisne module u memoriji programa. Odvojimo ih od glavnog dela programa i
smeštamo u sekundarnu memoriju, a u radnoj rezervišemo memoriju za najveći od njih. Potom
pri radu smenjujemo prekrivače po potrebi. Naprednije, možemo imati više prekrivača u
memoriji za veću efikasnost.
Mana je kako računar može automatski odrediti prekrivače. Do danas nije bilo uspeha u tome
DINAMIČKO PUNJENJE
Slično prekrivačima, izdvajamo funkcije i procedure i ne smeštamo u radnu memoriju dok ne
budu pozvane. Najveća prednost je ako imamo gomilu funkcija za retke situacije, pri čemu
one neće zauzimati mesta u radnoj memoriji nepotrebno
STRANIČENJE NA ZAHTEV
Delimo program na stranice fiksne veličine i učitavamo stranice u radnu memoriju po
potrebi. Za razliku od izvornog straničenja ne zahteva se da sve stranice programa budu u
radnoj memoriji, nego samo one koje su u tom trenutku potrebne, a pejdžer prebacuje te
stranice. I ovde koristimo tabelu stranica, sa dodatnim bitom validnosti koji pamti ako je
stranica u radnoj memoriji, da ne tražimo nju bezveze ako je nema.

PROMAŠAJ STRANICE
Kad se traži stranica, prvo se gleda tabela stranica, tj bit validnosti te stranice. Ako
je taj bit 0, to je promašaj. Procedura je tada:
1. Nađi slobodan okvir ili ako nema izbaci jednu stranicu iz radne memorije da se napravi
mesta.
2. Učitaj traženu stranicu u taj okvir
3. Ažuriraj tabelu stranica za novo stanje
ZAMENA STRANICE
Kako učitati željenu stranicu u memoriju kad nema slobodnih okvira?
Najčešće to se radi putem zamene stranica:
1. Naći željenu stranicu na disku
2. Naći slobodan okvir
ako postoji koristi njega
ako ne izaberi okvir žrtve
prebaciti žrtvu na disk i ažuriraj tabelu stranica
3. Učitaj željenu stranicu u okvir i ažuriraj tabelu stranica

ALGORITMI ZA IZBACIVANJE STRANICE

RANDOM
Slučajno biramo stranicu koja će se izbaciti. Izuzetno ne-efikasan algoritam, em što je
random generator zahtevna operacija, em što lako možemo izbaciti važnu stranicu koju ćemo
ubrzo morati opet da ubacimo, i opet da vrtimo
BELADI
Zamislimo da znamo sekvencu u budućnosti potrebnih stranica. Izbacujemo onu koja je
najkasnije potrebna. Izuzetno dobar algoritam, ali u praksi neizvodljiv. Kako predvideti
potrebne stranice?
FIFO
First in first out. Imamo listu koja beleži stranice po redosledu kojim su ušle,
izbacujemo najranije ubačenu stranicu. Jednostavno, ali ne-efikasno u situacijama gde
često koristimo neke stranice koje smo rano ubacili. Plus postoji FIFO anomalija, gde ako
se poveća broj slobodnih okvira poveća se i broj promašaja, ali to je retko
DRUGA ŠANSA
Svakoj stranici pridružujemo bit referisanosti. On postaje 1 kad se referiše ili prvi put
učita. Kad tražimo žrtvu redom gledamo bitove
Ako je 1, prebaci na 0, sledeći okvir
Ako je 0, to je žrtva
Ako se stranica često koristi ona će ubrzo preći na 1
Problem nastaje kad su svi bitovi 1, onda moramo da izbacimo prvu stranicu
ALGORTAM SATA
Druga šansa koja se pokazala bolje u praksi. Imamo kružnu listu i svakoj stranici
pridružen bit referisanosti. 1 ako uđe ili se referiše. Kad tražimo žrtvu gledamo gde smo
zadnji put stali i tu počinjemo s pretragom umesto od početka.
Opet imamo problem kad su svi bitovi 1
LRU (Least Recently Used)
Za svaku stranicu beležimo kad je zadnji put referisana. Izbacujemo onu koja je najdalje u
prošlosti korišćena.
Memorijski zahtevno jer nam treba brojač za svaki okvir gde će se pamtiti vreme
referisanja, plus ako hoćemo da sortiramo vremena za instant nalaženje to je dodatan
zahtev.
Takođe ne možemo garantovati da nam žrtva neće ubrzo trebati
NRU (Not Recently Used)
Aproksimacija LRU. Svakoj stranici je pridružen bit referisanosti, s time da se periodično
resetuju svi na nulu. Tražimo nulu. Problem je nakon resetovanja su svi kandidati za
žrtvu. Problem određivanja vremenskog intervala t za koji će se periodilno resetovati
bitovi.
NRU+
Dodajmo im bit modifikacije. Postaje 1 nakon što se promeni sadržaj i ne resetuje se.
Ovako imamo 4 stanja
00 – najbolji kandidati za žrtvu
01 – referisan, nemodifikovan
10 – modifikovan,nereferisan – može se desiti nakon resetovanje
11 – modifikovan,referisan – bolje ne izbacivati
LFU (Least Frequently Used)
Least frequently used. Svakoj stranici se pridružuje brojač za broj korišćenja. Izbacujemo
najmanje korišćenu stranicu, smatramo da nam neće trebati više. Treba povremeno resetovati
da nam ne ostane gomila stranica s velikim brojevima koji ne mrdaju a ni ne koriste se.
Nefer se tretiraju novopridošle stranice koje lako postaju kandidati
MFU (Most Frequently Used)
LFU ali obrnuto, izbacujemo najčešće korišćenu stranicu.
//Već smo je puno koristili, verovatno nam više ne treba

7. FAJL SISTEM
OPERACIJE NAD FAJLOVIMA

KREIRANJE - upisivanje novog fajla

BRISANJE - uklanjanje postojeceg fajla
CITANJE - citanje informacije iz fajla
PISANJE - azuriranje fajla, menjanjem vec postojećih podataka ili dodavanjem novih
REPOZICIONIRANJE - pomeranje pokazivača na određeni deo fajla koko bi se taj deo ažurirao
SKRACIVANJE - brisanje krajnjeg dela fajla

STRUKTURA FAJLOVA

NIZ BAJTOVA
Sva kontrola prepuštena programu koji sa njime manipuliše. OS vidi samo niz bajtova i ne
razume unutrašnju strukturu. Fleksibilan pristup.
SLOGOVI FIKSIRANE VELIČINE
Fajl postaje niz slogova, pa se čitanje i pisanje obavljaju na nivou sloga.
STABLO
Brza pretraga, komplikovana implementacija

TIPOVI FAJLOVA

Često se određuje klasično preko ekstenzija. Neki sistemi određuju vrstu fajla na osnovu
niza bitova koji se nalazi na početku fajla (magičan broj).

REGULARNI FAJLOVI
Čuvaju infromacije korisnika. Mogu biti ASCII ili binarni.
ASCII
Ne moraju se posebno interpretirati. Univerzalnost ASCII-ja omogućava da se mogu
obrađivati u većini editora.
BINARNI
Ne mogu se interpretirati bajt po bajt i imaju strukturu poznatu programu koji
njima rukuje. Sastoji se od zaglavlja, kod segmenta, segmeta podataka, bitova za
relokaciju i tabele simbola (za debagovanje). Magični broj je prvi podatak u
zaglavlju i govori OS-u da se radi o izvršnom fajlu.
DIREKTORIJUMI
Sistemski fajlovi koji predstavljaju strukturu fajl sistema.
SPECIJALNI FAJLOVI
Na nekim sistemima postoje interfejsi drajvera uređaja koje operativni sistem vidi kao
obične fajlove radi lakšeg rukovanja. Programi tada manipulišu uređajem koristeći iste
sistemske pozive kao da se radi o fajlu.

ORGANIZACIJA DIREKTORIJUMA

Direktorijum je zapravo fajl koji ima strukturu definisanu fajl sistemom – svaki fajl npr.
može imati jedan bit na početku na osnovu kojeg OS zna da li je u pitanju direktorijum ili
obični fajl.

JEDAN NIVO
Jedan koreni direktorjium u kojem se nalaze svi fajlovi. Lak za implementaciju ali
ogranićen jer dva fajla ne mogu imati isto ime.
DVA NIVOA
Slično prethodnom, samo što sada svaki korisnik ima svoj nivo. Nasleđuje probleme
prethodne organizacije.
STABLO
Svaki direktorijum može sadržati fajlove ali i druge direktorijume, bez ograničenja
dubine. Svaki fajl ima jedinstvenu putanju od korenog direktorijuma i mora da ima
jedinstveno ime samo u poslednjem direktorijumu kojem pripada. Većina fajl sistema danas
je ovako organizovana.

PRAVA PRISTUPA

DOZVOLA ZA ČITANJE
Kod fajla podrazumeva da može da se pristupi podacima fajla i da oni mogu da se pročitaju.
Kod direktorijuma omogućava izlistavanje stavki koje se u njemu nalaze.
DOZVOLA ZA PISANJE
Kod fajla označava mogućnost dodavanja novih podataka, dok se kod direktorijuma radi o
dozvoli za dodavanje i brisanje fajlova i poddirektrojiuma u njemu.
DOZVOLA ZA IZVRŠAVANJE
Kod fajla omogućava korisniku da ga izvrši. Kod direktorijuma se koristi za primenjivanje
nekih drugih dozvola.

IMPLEMENTACIJA FAJLOVA

NEPREKIDNA ALOKACIJA
Svaki fajl se čuva kao neprekidni niz blokova. Fajl veličine n blokova koji počinje na
lokaciji b zauzeće blokove od b do b+n-1. Sledeći fajl se smešta odmah iza posednjeg bloka
prethodnog fajla. Sekvencijalno čitanje i direktan pristup fajlu su efikasni ali brisanje
je neefikasno jer dolazi do fragmentacije. Kad se fajl obriše na njegovom mestu ostaje
„rupa“. Te rupe se popunjavaju novim fajlovima ali može se desiti da ima dovoljno
slobodnog prostora ali da ne postoji neprekidni niz slobodnih blokova dovoljan za
smestanje novog fajla. Ovo je eksterna fragmentacija. Postoji i interna – fajl mora
zauzeti ceo broj blokova pa se veoma retko dešava da je fajl baš veličine bloka (fajl
veličine 1100 bajtova popuniće tri bloka od 512 bajtova gde će treći imati 436
neiskorišćenih bajtova). Prealokacija je jako neefikasna i nemoguće je predvideti koliko
će fajl porasti u budućnosti.
POVEZANE LISTE
Svaki fajl je predstavljen kao povezana lista blokova. Blok sadrži (osim informacije) i
pokazivać na sledeći blok. Direktorijum za svaki fajl zna adresu samo prvog bloka dok
poslednji blok sadrži null. Novi fajl se kreira tako što se u direktorijum doda novi
pokazivač na prvi blok tog fajla. Taj pokazivač u početku može sadržati null čime se
pokazuje da je fajl prazan. Upis u fajl se vrši tako sto sistem nađe neki slobodni blok i
njegovu adresu upiše u pokazivač direktorijuma. Prednost je to što se novi blok može
nadovezati bilo gde da je fizički smešten i time se rešava problem eksterne fragmentacije.
Fajl može rasti sve dok ima slobodnih blokova, pa se veličina fajla ne mora deklarisati na
početku. Direktan pristup fajlu je ovde neefikasan zbog same konstrukcije liste. U svakom
bloku se, osim informacija, mora smestiti i pokazivač koji dodatno zauzima prostor.
Problem pouzdanosti – može se desiti neka greška pri upisu i onda pokazivač sadrži
pogrešnu vrednost adrese. Tada bi fajl mogao da se nadovezuje na slobodan prostor ili na
neki drugi fajl.
INDEKSIRANA ALOKACIJA
Rešava problem prethodne implementacije što se tiče pokazivača. Ova implementacija sve
pokazivače smešta na jedno mesto koje se naziva blok indeksa. Direktorijum za svaki fajl
čuva adresu bloka indeksa. Ovom implementacijom se takođe obezbeđuje i efikasan direktan
pristup jer se i-tom bloku pristupa preko i-te adrese u nizu adresa bloka indeksa. Kod
novog fajla se sve adrese inicijalizuju na null. Nema eksterne fragmentacije ali se opet
prostor troši na pokazivače. Mora se efikasno odrediti veličina koja je najpogodnija za
blok indeksa. Ako se izabere preveliki blok – prostor se neefikasno troši; ako se izabere
premali – neće biti dovoljno mesta da se sačuvaju svi pokazivači velikih fajlova. Rešenja:
Povezana lista blokova indeksa – veći fajlovi imaju više blokova indeksa
Indeksi sa više nivoa – indeks na dva nivoa je indeks koji sadrži adrese blokova indeksa
Hibridni pristup – na početku prvo rešenje a posle nekog određenog broja drugo rešenje

IMPLEMENTACIJA DIREKTORIJUMA

LISTA
Direktorijum predstavljen kao lista fajlova. Pri kreiranju novog fajla lista imena se
pretražuje da bi se utvrdilo da ne postoji fajl sa istim imenom. Unos za novi fajl se na
kraju dodaje na kraj liste. Pri brisanju se traži fajl sa datim imenom pa se oslobađaju
alocirani blokovi. Nakon toga će unos u listi fajlova biti nevažeći i treba ga obeležiti
npr. bitom (1 – fajl postoji, 0 – obrisan). Mana je da pronalazenje nije efikasno, što je
veliki problem s obzirom na to da je to jako česta operacija. Moguće je sortirati fajlove
prema imenima i primeniti binarnu pretragu al to samo komplikuje dodavanje novih
elemanata.
HEŠ TABELA
Tabela sadrži imena fajlova koja su poređana u indeksirani niz. Kada je zadat ključ (ime
fajla koji tražimo), on se dostavlja heš funkciji koja računa indeks. Na osnovu indeksa
ime fajla se nalazi direktno bez pretrage što doprinosi efikasnosti. Najjednostavnija heš
funkcija se može implementirati kao ostatak pri deljenju nekim brojem. Problem heš tabela
predstavlja kolizija i fiksna dužina tabele (koja zavisi od heš funkcije).
Oba problema se rešavaju ulančavanjem - svaki unos u tabeli predstavlja povezanu listu.
Novi unos se tada nadovezuje na stare sa istim indeksom. U najgorem slučaju (svaki ključ
daje isti indeks) dobijamo listu koja bi morala linearno da se pretraži, mada se ovo u
praksi jako retko dešava.

MANIPULISANJE SLOBODNIM PROSTOROM

BIT MAPE
Svaki blok se predstavlja nulom ili jedinicom. Ako je disk veliki bit-mapa takođe mora
biti jako velika.
POVEZANE LISTE
Nizaju se svi slobodni blokovi. Nije potreban direktan pristup.
Postoji i unapređenje koje se oslanja na činjenicu da se više slobodnih blokova alocira i
oslobađa odjednom. Tada je moguće čuvati adresu samo prvog slobodnog bloka koji će dodatno
sadržati broj koji oznaćava koliko ima slobodnih blokova do njega.

8. UPRAVLJANJE ULAZNO-IZLAZNIM UREĐAJIMA

Komunikacija sa u-i uređajima se odvija u posebnom sistemskom režimu OS-a za koji je
odgovorno jezgro. Sistemski pozivi su jedini način na koji korisnik ima mogućnost da
pristupi hardveru.
Na najnižem nivou je hardver pa zatim sledi interfejs kojim se on vezuje za računarski
sistem.
Negde se koriste rutine za obradu prekida, a onda na sledećem nivou su drajveri koji
omogućavaju korišćenje uređaja. Dalje, na sledećem nivou je softver koji ne zavisi od
uređaja i na kraju interfejs ka korisničkim procesima uz pomoć kojeg se obezbeđuju usluge.

HARDVER
Na osnovu načina na koji se prenose podaci, u-i uređaji se dele na:

Blok uređaje – obrađuju podatke u blokovima fiksne dužine, adresibilni, moguć direktni
pristup a transfer podataka se obavlja prebacivanjem odgovarajućeg broja blokova; diskovi,
DVD-ROM i USB
Karakter uređaje – manipulišu podacima koji su u formi niza karaktera, nema direktnog
pristupanja memoriji i nisu adresibilni; štampači, mrežni interfejsi, miševi

Postoje uređaji koji se ne mogu svrstati ni u jednu od ove dve grupe – sistemski časovnik
koji proizvodi impulse koji određuju mašinski ciklus (ne generiše niz karaktera a ne može
se ni adresirati.

INTERFEJS UREĐAJA

Način povezivanja uređaja određuje brzina uređaja, ali se svi povezuju preko priključaka,
a veza ne mora nužno biti preko kabla već moze biti i bežična. Dalje na magistrale koje
povezuju priključke sa ostatkom sistema. Magistrale imaju striktno određene protokole za
komunikaciju.

Sistemska magistrala veza između procesora i brzim u-i uređajima.

Magistrala za proširenje namenjena za sporije uređaje kao što su tastatura, miš, štampaći.

Kontroleri su deo hardvera koji opslužuju portove, magistrale ili uređaje. Registri
kontrolera:
Registar primljenih podataka – podaci preuzeti s uređaja
Registar poslatih podataka – podaci koje treba uskladištiti na uređaj
Statusni registar – sadrži podatke o trenutnom statusu uređaja, signalizira se
procesoru da li je neki proces učitan, da li je izvršena zadata komanda ili došlo
do neke greške
Kontrolni registar – u procesor upisuje komande koje treba izvršiti ili sadrži
informacije vezane za način rada uređaja

Procesor komunicira sa uređajem korišćenjem registara na dva načina:

1. Uvođenje posebnih instrukcija za upis ili čitanje iz registara. Aktiviraju se posebne

linije magistrale da bi se razlikovalo pisanje u memoriju i na registar kontrolera.
Registri se koriste za prenos podataka od procesora ka uređaju i obrnuto.
2. Kontroleri podržavaju memorijski mapirane u-i operacije. Registrima se pristupa
direktno preko memorijske adrese kao da su deo glavne memorije. Procesor mora imati
mogućnost da adresira registre kao ostale delove memorije.

Kod memorijskog mapiranja se zbegava se upotreba asemblera koji je obavezan pri radu sa
registrima. To može dovesti do problema da se upis podataka izvrši greškom na registru jer
se njemu pristupa kao i svakom drugom delu memorije. Zato se određuju posebne instrukcije
kojima bi se lako razlikovalo da li se upis vrši u memoriju ili u registar uređaja.
Zaštita se takođe može realizovati isključivanjem adresa ovih registara iz adresibilnog
prostora.

TEHNIKA PROZIVANJA (POLLING)

Najjednostavniji pristup. Procesor odradi sav posao. Sve vreme se proverava statusni
registar uređaja a uređaj u tom registru signalizira sistemu da je pročitao ili da je
pripremio neki podatak. Neefikasno jer se procesorsko vreme troši na učestalo proveravanje
statusnog registra.

PREKIDI

Ovaj metod se zasniva na hardverskom mehanizmu koji daje mogućnost uređajima da

signaliziraju stanje, dajući vreme procesoru da obavi drugi posao sve dok uređaj ne
signalizira da je spreman.
1. Proces inicira operaciju na uređaju obraćajući se drajveru
2. Drajver prosledi uređaju operaciju preko kontrolera
3. Uređaj završava sa radom i kontroler procesoru šalje signal
4. Procesor prekida izvršavanje trenutnog procesa i obrađuje prekid
5. Rutina za obradu prekida obradi prekid
6. Nakon oprade procesor nastavlja izvršavanje ako planer dozvoli
Obično se se doda još poneka funkcija i omogućava se procesoru da odloži prekid ako se
izvršava neki jako bitan proces. I treba efikasno odrediti koji uređaj je prosledio prekid
i prekidima dodeliti prioritete. Poslednju rečenicu obaviće PIC (Priority Interrupt
Controller). Većina procesora ima dve posebne linije za signale prekida:
Nemaskirajuća linija
Uvek može da prekine izvršenje tekućeg procesa. Koristi se za kritične hardverske greške.
Maskirajuća linija
Ova linija se može isključiti (zamaskirati) tokom izvršavanja važnih delova procesa koji
ne smeju biti prekinuti (krit sekcija). Koristi se za signale prekida od uobičajenih
operacija.
Kada dođe do prekida, tabela prekida odmah pruža rutinu koju treba izvršiti. Sistem
prekida obično primenjuje i prekidne prioritetne nivoe, gde se odlaže opsluživanje prekida
niskih nivoa da bi se opslužili prekidi visokih prioriteta (bez maskiranja).

DMA

Prekidi su problematični ako se previše često događaju jer se tada često vrši prebacivanje
konteksta. Rešenje je DMA. Zahteva postojanje DMA kontrolera koji imaju pristup sistemskoj
magistrali nezavisno od procesora. Suština je da se prenosi karakter po karakter bez
opterećivanja glavnog procesora. DMA vrši aktivno čekanje na uređaju dok je procesor
slobodan da radi druge stvari. Prekidi se dešavaju samo kada se bafer isprazni i DMA
pristupa memoriji.