INTERNACIONALNI UNIVERZITET U NOVOM PAZARUFAKULTET INFORMATIKE I INFORMACIONIH TEHNOLOGIJA

SMER ZA INFORMATIKU

SEMINARSKI RAD

MRTVE PETLJE

Novi Pazar,2010

Sadržaj:

1

UVOD.........................................................................................................................................- 3 -

MRTVE PETLJE........................................................................................................................- 4 -

Uvod u mrtve petlje.................................................................................................................- 5 -

Uslovi za mrtvu petlju.........................................................................................................- 5 -

Modelovanje mrtve petlje...................................................................................................- 6 -

RESURSI....................................................................................................................................- 9 -

Resursi koji se mogu oduzeti procesu (preemptable) i koji se ne mogu oduzeti procesu (nepreemptable)......................................................................................................................- 9 -

Akvizicija resursa..................................................................................................................- 10 -

NOJEV ALGORITAM.........................................................................................................- 10 -

Detekcija mrtve petlje i oporavak.........................................................................................- 11 -

Detekcija mrtve petlje sa jednim resursom svakog tipa....................................................- 11 -

Detekcija mrtve petlje sa više resursa svakog tipa............................................................- 13 -

Oporavak od mrtve petlje..................................................................................................- 16 -

Oporavak preko oduzmanja resursa (preemption)............................................................- 17 -

Oporavak putem vraćanja stanja procesa unazad (Rollback)...........................................- 17 -

Oporavak preko ubijanja procesa (killing processes).......................................................- 18 -

IZBEGAVANJE MRTVE PETLJE......................................................................................- 18 -

Sigurna i nesigurna stanja.................................................................................................- 18 -

Bankarov algoritam za jedan resurs..................................................................................- 20 -

SPREČAVANJE MRTVE PETLJE.....................................................................................- 21 -

Napad na uslov uzajamnog isključivanja..........................................................................- 22 -

Napad na uslov zadrži i čekaj...........................................................................................- 22 -

Napad na uslov nemogućnosti oduzimanja resursa bez posledica....................................- 23 -

DRUGA PITANJA O MRTVIM PETLJAMA........................................................................- 23 -

Dvo-fazno zaključavanje.......................................................................................................- 23 -

Mrtve petlje bez resursa........................................................................................................- 24 -

Izgladnjivanje........................................................................................................................- 25 -

ISTRAŽIVANJA MRTVIH PETLJI........................................................................................- 25 -

ZAKLJUČAK...........................................................................................................................- 27 -

Literatura...................................................................................................................................- 28 -

2

UVOD

U višeprocesnom okruženju, više procesa se mogu međusobno takmičiti za konačan broj resursa.

Kada proces zahteva resurs, a resurs nije raspoloživ, proces može zauvek ostati u stanje čekanja

na resurs blokira se. Blokirani proces može zauvek ostati u tom stanju ukoliko potrebni resurs

ostane neraspoloživ. Ova situacija je moguća ukoliko je resurs prethodno dodeljen na korišćenje

drugom procesu koji tokom vremena takođe prelazi u stanje čekanja na drugi neraspoloživ

resurs. Takva situacija naziva se zastoj, tj.blokada(mrtva petlja). pojava je sasvim moguća,

naročito pri radu sa savremenim višenitnim procesima, i treba je izbeći. Sistem koji je doveden u

stanje stoja mora se oporaviti.

U ovom poglavlju razmatrati ćemo mrtve petlje bliže, videti kako nastaju i sagledati neke načine

njihovog prevazilaženja ili njihovog izbegavanja. Iako se ovaj materijal bavi mrtvim petljama u

okviru operativnih sistema, one takođe nastaju u sistemima baza podataka i mnogim drugim

područjima računarskih nauka, pa je ovaj materijal u stvari primenjiv za mnoge višeprocesne

sisteme.

3

MRTVE PETLJE

Računarski sistemi imaju dosta resursa koji istovremeno ne mogu biti korišteni od strane više

procesa. Prost primer su štampači, magnetne trake i zapisi u unutrašnjim sistemskim tabelama.

Ako dva procesa istovremeno pristupaju štampaču dolazi do zabune, takođe ako dva procesa

koriste isti zapis sistemske tabele dolazi do greške sistema fajliranja. Usled toga svaki

operatvivni sistem ima mogućnost trenutnog dodeljivanja ekskluzivnog prava procesu za pristup

određenim resursima.

Kod mnogih aplikacija proces mora imati ekskluzivni pristup ne samo jednom već nekoliko

resursa. Pretpostavimo, na primer, dva procesa koji imaju isti zadatak: da snime skeniran

dokument na CD. Proces A traži dozvolu za upotrebu skenera i dobija je. Proces B, koji je

programiran na drugi način, traži prvo dozvolu za upotrebu CD snimača i takođe je dobija. Sada

A traži dozvolu za upotrebu CD pisača, ali zahtev se odbija sve dok B ne oslobodi CD pisač.

Međutim, B umesto da oslobodi CD pisač, traži dozvolu za upotrebu skenera. U ovom trenutku

procesi su blokirani i tako će ostati u nedogled. Ova situacija naziva se mrtva petlja (deadlock).

Mrtve petlje se takođe dešavaju i između više mašina. Mnoge kancelarije imaju lokalnu mrežu

(LAN) instaliranu na većem broju računara. Često su uređaji (kao što su skeneri, CD pisači,

štampači i magnetni čitači) povezani u mrežu kao deljeni resursi (shared) koji su dostupni

svakom korisniku na svakom računaru u mreži. Ako se ovi uređaji mogu rezervisati “na daljinu"

(tj. sa korisnikovog računara) može se pojaviti ista vrsta mrtvih petlji kao one koje su prethodno

opisane. Komplikovanija situacija može izazvati mrtve petlje koje uključuju tri, četiri ili više

uređaja i korisnika.

Mrtve petlje se mogu pojaviti u raznim situacijama, a ne samo u onim koje uključuju zahtjeve za

upotrebu određenih ulazno/izlaznih (I/O) uređaja. U sistemu baze podataka, na primjer, program

nekad mora da zaključa nekoliko slogova podataka koje koristi, da bi izbjegao takmičenje nad

dozvolom za rad sa tim slogovima. Ako proces A zaključa slog R1, a proces B zaključa slog R2,

i zatim svaki proces pokušava da zaključa slog onog drugog, tada takođe imamo mrtvu petlju.

Znači mrtva petlja se može pojaviti kako na hardverskim resursima tako i na softverskim.

4

Uvod u mrtve petlje

Mrtva petlja se formalno može ovako definisati:

Niz procesa je u mrtvoj petlji ako svaki proces u nizu čeka na događaj koji samo drugi proces u

nizu može izazvati.

Zbog toga što svi procesi čekaju, nijedan od njih neće nikad izazvati događaj koji može probuditi

drugog člana niza, pa svi procesi nastavljaju čekanje u beskonačnost. Za ovaj model,

pretpostavljamo da procesi imaju samo jednu nit (thread) i da nisu mogući interapti za buđenje

blokiranog procesa. Uslov da nema interapta je neophodan da bi se spriječilo buđenje procesa

koji je inače u mrtvoj petlji, pomoću npr. alarma, i na taj način oslobađanja ostalih procesa u

nizu.

U većini slučajeva, događaj koji svaki proces čeka je oslobađanje nekih resursa koje trenutno

koristi drugi član niza. Drugim riječima, svaki član niza procesa u mrtvoj petlji čeka na resurs

koji posjeduje proces u mrtvoj petlji. Nijedan od procesa ne može da radi, nijedan od njih ne

može da oslobodi resurse koje drži i ni jedan od njih ne može da se probudi. Broj procesa i broj i

vrsta resursa koji su u posjedu i koji su zatraženi nisu važni. Ovakav rezultat se dobija za svaku

vrstu resursa, dakle i za hardverske i za softverske.

Uslovi za mrtvu petlju

1. Uslov uzajamnog izuzeća. Svaki resurs je ili trenutno dodjeljen tačno jednom procesu ili

je slobodan.

2. Uslov drži i čekaj. Procesi koji trenutno drže resurse koji su ranije dozvoljeni mogu

tražiti nove resurse.

3. Uslov nemogućnosti oduzimanja resursa bez posljedica Resursi koji su prethodno

odobreni ne mogu se silom oduzeti od procesa koji ih trenutno posjeduju. Moraju se osloboditi

eksplicitno od strane procesa koji ih drži (nonpreemption).

4. Uslov cirkularnog čekanja. Mora postojati cirkularni lanac od dva ili više procesa, gdje

svaki čeka na resurs kojeg drži idući član lanca.

Sva četiri uslova moraju da postoje da bi nastala mrtva petlja. Ako samo jedan od njih

nedostaje, mrtva petlja nije moguća.

5

Ništa ne vrijedi to što se svaki uslov odnosi na ono što sistem može da ima ili nema. Može li se

određeni resurs dodijeliti istovremeno na više od jednog procesa? Može li proces držati resurs i

tražiti drugi? Mogu li resursi biti oduzeti bez posljedica? Da li mogu postojati cirkularna

čekanja? Kasnije ćemo vidjeti kako mrtve petlje mogu da se razriješe pokušavanjem negiranja

nekih od datih uslova.

Modelovanje mrtve petlje

Holt (1972) pokazao je kako se mogu modelovati ova četiri uslova korištenjem direktnih

grafova. Grafovi imaju dvije vrste čvorova: procese prikazane kao kružiće, i resurse prikazane

kao kvadratiće. Linija od čvora resursa do čvora procesa znači da je resurs prethodno bio tražen,

dozvoljen i trenutno u posedu tog procesa. Na slici 1. (a), resurs R je trenutno dodeljen procesu

A.

Linija od procesa do resursa znači da je proces trenutno blokiran čekanjem na resurs. Na slici 1.

(b) proces B čeka na resurs S. Na slici 1.(c) vidimo mrtvu petlju: proces C čeka na resurs T, koji

je trenutno u posedu procesa D. Proces D neće skoro da oslobodi resurs T jer čeka na resurs U,

kojeg drži proces C. Oba procesa će čekati beskonačno dugo. Krug na grafu znači da su procesi i

resursi u mrtvoj petlji (pretpostavljamo da postoji resurs svake vrste). U ovom primeru krug je C-

T-D-U-C.

Pogledajmo sada primer kako se mogu upotrebiti grafovi resursa. Zamislimo da imamo

tri procesa A, B i C, i tri resursa R, S i T.

Slika 1. Grafovi alokacije resursa. (a)držanje resursa. (b) zahtevanje resursa. (c) mrtva petlja

6

Posle koraka (q), procesu B se može dozvoliti S, jer je A završio, a C ima sve što mu je

potrebno. Čak iako bi se B mogao eventualno blokirati kada bude tražio T, ne može se desiti

mrtva petlja. B će jednostavno čekati dok C ne završi.

Pretpostavimo sada, da proces i proračunava i daje ulaz/izlaz, pa je kružni tok razuman

algoritam rasporeda. Zahtev za resursima može da se pojavi po redosledu datom na slici 2.(d).

Ako se tih šest zahteva sprovede po tom redosledu, šest rezultujućih grafova prikazani su na

slici 2.(e)-(j). Posle zahteva 4, A je blokiran čekajući na S, kako je prikazano na slici 2.(h). U iduća

dva koraka B i C se takođe blokiraju, što dovodi do mrtve petlje date na slici 2.(j).

Međutim, kao što smo već naveli, od operativnih sistema se ne zahteva da izvršavaju

procese po nekom određenom redosledu. Praktično, ako dozvola određenog zahteva može

dovesti do mrtve petlje, operativni sistem može jednostavno suspendovati proces bez

odobravanja zahteva (tj. samo rasporediti proces) dok ne bude sigurno da se neće desiti mrtva

petlja. Na slici 2. vidimo, da je operativni sistem mogao suspendovati proces B, da je znao da će

doći do mrtve petlje, umesto da mu dozvoli resurs S. Kada bi samo proces A i C radili, dobili bi

zahteve i oslobađanje resursa prikazane na slici 2.(k) umesto onih na slici 2.(d). Ova sekvenca

vodi ka grafovima resursa datim na slikama 2.(l)-(q), koji ne dovode do mrtve petlje.

Posle koraka (q), procesu B se može dozvoliti S, jer je A završio, a C ima sve što mu je

potrebno. Čak iako bi se B mogao eventualno blokirati kada bude tražio T, ne može se desiti

mrtva petlja. B će jednostavno čekati dok C ne završi.

7

Slika 2. Primer kako dolazi do mrtve petlje i kako ona može da se izbegne

Uopšteno, koriste se četiri strategije prilikom rada sa mrtvim petljama.

1. Ignorisanje celokupnog problema. Ako ga ignorišemo možda će on (problem) ignorisati

nas.

2. Detekcija i ozdravljenje. Neka se dese mrtve petlje, detektujte ih i pokrenite akciju.

3. Dinamičko izbegavanje pažljivom alokacijom resursa.

8

4. Prevencija (sprečavanje), pomoću strukturalnog negiranja jednog od četiri uslova koji su

potrebni za stvaranje mrtve petlje.

RESURSI

Mrtve petlje mogu nastati kada je procesu dozvoljen ekskluzivan pristup uređaju, fajlu, itd. Da bi

diskutovali o mrvim petljama što je uopštenije moguće, objekte kojima je dozvoljen pristup

zvaćemo resursi. Resurs može biti hardverski uređaj (CD snimač) ili dio informacije (zaključan

slog u bazi podataka). Računar ima mnogo različitih resursa koje može koristiti. Za neke resurse

može biti dostupno nekoliko jednakih primeraka, kao što su tri CD snimača. Kada su nekoliko

kopija resursa slobodne, bilo koja od njih može biti upotrebljena da zadovolji zahtev za tim

resursom. Ukratko, resurs je sve što se može koristiti od strane jednog procesa u svakom deliću

vremena.

Resursi koji se mogu oduzeti procesu (preemptable) i koji se ne mogu oduzeti procesu (nepreemptable)

Postoje dva tipa resursa: preemptable i nepreemptable. Preemptable resurs je onaj koji može da

se oduzme procesu koji ga koristi bez nekih loših posledica. Memorija je primer jednog takvog

resursa. Razmatrajmo, na primer, sistem sa 32MB memorije, jednim štampačem i dva 32-MB

procesa koji oba treba da štampaju nešto. Proces A traži i dobija štampač, te počinje da

proračunava vrednosti za štampanje. Pre nego što završi proračunavanje, vreme koje mu je

dodeljeno biva prekoračeno i on biva zamenjen.

Sada startuje proces B i pokušava dobiti štampač ali neuspešno. Imamo moguću situaciju mrtve

petlje jer A ima štampač a B ima memoriju, a ni jedan ne može da nastavi bez resursa koji je u

posedu drugog procesa. Na sreću moguće je oduzeti memoriju od B izbacujući ga, a ubacujući

proces A na njegovo mesto. Sad A može da radi, da obavi štampanje, a zatim i da oslobodi

štampač. Dakle ne dolazi do pojave mrtve petlje.

Neptreemptable resurs, za razliku od prethodnog, ne može biti oduzet od procesa koji ga trenutno

koristi bez posledica. Ako je proces počeo da upisuje podatke na CD-ROM, iznenadno

9

oduzimanje CD pisača od procesa i njegovo dodeljivanje drugom procesu rezultovaće u

oštećenom CD-u. CD pisači nisu resursi koji se mogu oduzeti procesu.

Uopšteno, mrtve petlje se sreću kod resursa koji se ne mogu oduzeti procesu bez posledica.

Potencijalne mrtve petlje koje se sreću kod resursa koji se mogu oduzeti procesu mogu se često

razrešiti putem realokacije resursa sa jednog procesa na drugi. Stoga ćemo se fokusirati na

resurse koji se ne mogu oduzeti procesu bez posledica.

Akvizicija resursa

Za neke vrste resursa, kao što su slogovi u sistemu baze podataka, do korisnika procesa je kako

će da rasporedi upotrebu samih resursa. Jedan od mogućih načina da se dozvoli korisniku

raspodela resursa je da se veže semafor za svaki resurs. Svi semafori su inicijalno postavljeni na

Promene se mogu koristiti jednako dobro. Tri koraka navedena iznad se implementiraju kao

dolje na semaforu za akviziciju resursa, korištenje resursa i na kraju gore za oslobađanje resursa.

Nekad procesi potražuju dva ili više resursa. Ako je potrebno više od dva resursa, oni se mogu

dobiti jedan za drugim. Do sada nema mnogo problema. Dok je samo jedan proces uključen u

razmatranje sve fino radi. Naravno, sa samo jednim procesom i nema potrebe za formalnim

potraživanjem resursa, jer ne postoji konkurencija nad njima.

Zbog mogućnosti tako lakog pojavljivanja mrtve petlje, mnogo istraživanja je upravo sprovedeno

da bi se lakše izlazilo na kraj sa njima. Ovo poglavlje diskutuje o mrtvim petljama do detalja i o

tome što se može učiniti u vezi sa njima.

NOJEV ALGORITAM

Najjednostavniji pristup je nojev algoritam: “Stavi glavu u pesak i pretvaraj se da nema

problema”. Različiti ljudi na ovu strategiju reaguju na različite načine. Matematičari nalaze da je

ona totalno neprihvatljiva i da se mrtve petlje moraju sprečiti po svaku cenu. Inženjeri pitaju

koliko često se problem može očekivati, koliko često sistem pada zbog drugih razloga, i koliko

su mrtve petlje, u stvari, ozbiljne. Ako se mrtve petlje dešavaju u proseku jednom u pet godina, a

sistem pada zbog grešaka hardvera, grešaka u kompajliranju i bagova operativnog sistema

jednom nedeljno, većina inžinjera neće biti voljna da radi na eliminisanju mrtvih petlji.

10

Maksimalan broj otvorenih fajlova je ograničen veličinom i-čvora tabele, pa se dešava sličan

problem kada se tabela napuni. Prostor na disku je drugi ograničen resurs. U stvari, skoro svaka

tabela operativnog sistema predstavlja ograničen resurs. Treba li da poništimo sve ovo jer je

moguće da u kolekciji od n procesa svaki potražuje 1/n od ukupnog broja, i zatim da svaki proces

traži po još jedan.

Većina operativnih sistema, uključujući UNIX i Windows, samo ignorišu problem pod

pretpostavkom da će većina korisnika radije prihvatiti povremenu mrtvu petlju nego pravila koja

bi ograničavala sve korisnike na korištenje jednog procesa, jednog otvorenog fajla, itd. Ako se

mrtve petlje mogu eliminisati besplatno, ne bi bilo puno diskusije o tome. Problem je u tome što

je cena eliminisanja mrtvih petlji vrlo visoka, najviše u smislu postavljanja nepraktičnih

ograničenja na procese, što ćemo videti uskoro. Znači, susreli smo se sa neugodnom trgovinom

između praktičnosti i tačnosti i velikim brojem diskusija o tome što je od toga važnije, i kome.

Pod ovakvim uslovima teško je uopšteno naći rešenja za mrtvu petlju.

Detekcija mrtve petlje i oporavak

Druga tehnika je detekcija i oporavak. Kada se koristi ova tehnika sistem ne pokušava

sprečiti pojavu mrtvih petlji. Umesto toga sistem dopušta da se one dese, pokušavajući ih

detektovati, i onda preuzima neku akciju u cilju saniranja posledica koje su izazvale. U ovom

poglavlju videćemo neke načine detekcije mrtve petlje, i saniranja posledica njihovog dejstva.

Detekcija mrtve petlje sa jednim resursom svakog tipa

Počnimo sa najjednostavnijim slučajem: neka postoji po jedan resurs svakog tipa. Takav

sistem može imati jedan skener, jedan CD pisač, jedan štampač i jedan magnetni čitač. Drugim

rečima, isključujemo sisteme sa dva štampača za sada. Njih ćemo razmatrati kasnije, koristeći

drugu metodu. Za takav sistem možemo konstruisati graf resursa za sliku 3. Ako ovaj graf sadrži

jedan ili više krugova, znači da postoji mrtva petlja. Svaki proces koji je deo kruga nalazi se u

mrtvoj petlji. Ako ne postoji ni jedan krug znači da sistem nije u mrtvoj petlji.

11

Kao primer kompleksnijeg sistema od onih koje smo do sada razmatrali, posmatrajmo

sistem sa sedam procesa. Neka su to procesi od A do G. Neka postoji i šest resursa od R do W.

Stanja resursa, odnosno, kome su trenutno dodeljeni i koji proces ih zahteva, data su kako sledi:

1. Proces A poseduje R i zahteva S.

2. Proces B ne poseduje ni jedan resurs ali zahteva T.

3. Proces C ne poseduje ni jedan resurs ali zahteva S.

4. Proces D poseduje U i zahteva S i T.

5. Proces E poseduje T i zahteva V.

6. Proces F poseduje W i zahteva S.

7. Proces G poseduje V i zahteva U.

Pitanje je sledeće: “Da li je ovaj sistem u mrtvoj petlji, i ako jeste koji su procesi uključeni u

nju?”. Da bi dali odgovor na ovo pitanje konstruišimo graf resursa kakav je dat na slici 3.(a). Kao

što vidimo, ovaj graf sadrži jedan krug. Krug je prikazan na slici 3.(b). Vidimo da su procesi D, E i

G u mrtvoj petlji. Procesi A, C i F nisu u mrtvoj petlji jer se S može dodeliti svakom tom procesu,

koji ga oslobađa kada završi svoj posao. Tada preostala dva procesa mogu da ga redom koriste i

oslobode.

Slika 3. (a) Graf resursa. (b) Krug izdvojen iz grafa.

Iako je relativno lako odrediti koji je proces u mrtvoj petlji (jednostavnim pogledom na

graf resursa), za prave sisteme koristi se formalni algoritam za detekciju mrtve petlje. Poznati su

12

mnogi algoritmi koji se koriste u tu svrhu. Mi ćemo razmotriti jednostavan algoritam koji

pretražuje graf i određuje da li postoji u njemu krug ili ne. Ovaj algoritam koristi jednu strukturu

podataka, L - lista čvorova. U toku rada algoritma, markirati će se linije koje su već pregledane

da bi se sprečilo ponavljanje pretraživanja.

Algoritam pretražuje graf sledećim koracima:

1. Za svaki čvor, N na grafu izvode se sledećih 5 koraka sa N kao početnim čvorom.

2. Inicijalizira se L kao prazna lista, i označe se sve linije kao nemarkirane.

3. Doda se trenutni čvor na kraj L i provjeri se da li se čvor pojavljuje u L dva puta. Ako

se pojavljuje, graf ima krug i algoritam završava.

4. Od datog čvora, pogledamo postoje li nemarkirane izlazne linije. Ako postoje

odrađuje se korak 5, a ako ne postoje korak 6.

5. Odabere se jedna nemarkirana izlazna linija i označi. Zatim je pratimo do idućeg

čvora (trenutni čvor) i prelazi se na korak 3.

6. Došli smo do slepog puta. Odstranimo ga i vratimo se na prethodni čvor (onaj koji je

bio trenutni čvor pre ovoga). Sada on postaje opet trenutni čvor i vraćamo se na

korak 3. Ako je čvor početni, graf ne sadrži ni jedan krug i algoritam ovde završava.

Detekcija mrtve petlje sa više resursa svakog tipa

Kada postoje višestruke kopije nekih resursa, potreban je drugi pristup radi

detektovanja mrtvih petlji. Predstavićemo algoritam za pronalaženje mrtvih petlji baziran na

matricama od n procesa: P1 do Pn. Neka je m broj klasa resursa, sa E1 resursa klase 1, E2

resursa klase 2 i uopšteno Ei resursa klase i (1 i m). E je postojeći vektor resursa. On daje

ukupan broj postojećih primeraka svakog resursa. Na primer, ako su klasa 1 magnetni čitači,

tada E1=2 znači da sistem ima dva magnetna čitača. U nekom trenutku neki od resursa su

zauzeti ili dodeljeni. Neka je A vektor dostupnih resursa, gde je Ai broj primeraka resursa i koji

su trenutno dostupni (tj. nedodeljeni). Ako su oba od naša dva magnetna čitača dodeljena, A1

je 0.

13

Potrebna su nam dva niza: C - matrica trenutne alokacije, i R- matrica zahteva. i – ti red

matrice C govori o tome koliko primeraka svakog resursa trenutno ima proces Pi. Tako je Cij

broj primeraka j – tog resursa koje ima i – ti proces. Slično Rij je broj primeraka j – tog resursa

koje proces Pi zahteva. Ove četiri strukture podataka prikazane su na slici 4.

Slika 4. Četiri strukture podataka potrebne za algoritam detekcije mrtve petlje.

Veoma važno je reći da resurs može biti ili alociran ili slobodan. Ovo se može napisati i

ovako:

∑i=1

n

Cij+ Aj=Ej

Drugim riječima, ako svim primercima j – tog resursa koji su alocirani dodamo sve primerke koji

su slobodni, dobijamo koliko primeraka te klase resursa u stvari postoji. Algoritam detekcije

mrtve petlje zasnovan je na upoređivanju vektora. Definišimo relaciju A B nad dva vektora A i

B kao: svaki elemenat A je manji ili jednak od odgovarajućeg elementa B. Matematički A B

stoji ako i samo ako je: Ai Bi, za 1 i m. Svaki proces je inicijalno postavljen kao

nemarkiran. Kako algoritam napreduje, procesi će biti markirani, što znači da su u stanju da

izvrše započeti posao i da nisu u mrtvoj petlji. Kada algoritam završi, za svaki nemarkiran proces

se zna da je u mrtvoj petlji. Algoritam detekcije mrtve petlje se sada može dati kako sledi:

1. Traženje nemarkiranog procesa Pi, za koje je i –ti red R-a manji ili jednak A

2. Ako je tako, dodaje se i -ti red od C na A, markira proces i vraća na korak1

14

3. Ako takav proces ne postoji, algoritam završava.

Kad algoritam završi, svi nemarkirani procesi, ako ih ima, su u mrtvoj petlji. U koraku 1

algoritam traži proces koji može da se izvrši do kraja. Takav proces se karakteriše kao proces

koji ima zahteve za resursima koji su trenutno slobodni i koji se stoga mogu odobriti. Takav

proces tada odrađuje svoj posao, zatim oslobađa resurse koji tada ponovo postaju dostupni

(slobodni) resursi. On se markira kao izvršen proces. Ako se svi procesi mogu izvršiti, tada ni

jedan nije u mrtvoj petlji. Ako neki od njih ne mogu nikada da se izvrše – oni su u mrtvoj petlji.

Iako algoritam nije deterministički, rezultat je uvek isti.

Kao primer rada algoritma za detekciju mrtve petlje, razmotrimo sliku 5. Imamo tri

procesa i četiri klase resursa: magnetni čitači, ploteri, skeneri i CD-ROM – ovi. Proces 1 ima

jedan skener. Proces 2 ima dva magnetna čitača i CD-ROM. Proces 3 ima ploter i dva skenera.

Svaki proces zahteva dodatne resurse, kako je prikazano matricom R. Da bi pokrenuli algoritam

detekcije mrtve petlje, tražimo proces čiji zahtevi za resursima mogu biti zadovoljeni. Prvi ne

može biti zadovoljen jer nema ni jedan slobodan CD ROM. Drugi ne može biti zadovoljen jer

nema slobodnog skenera. Srećom treći može biti zadovoljen, pa se pokreće i kada završi vraća

sve resurse koje je držao dajući:

A=(2 2 2 0)

Sada proces 2 može da se pokrene, i nakon toga vraća svoje resurse dajući:

A=(4 2 2 1)

Sada i preostali proces može da se izvrši. Dakle, u sistemu nema mrtve petlje.

15

Slika 5. Primer za algoritam detekcije mrtve petlje.

Sada zamislimo malu promenu situacije date na slici 5. Pretpostavimo da proces 2

zahteva CD-ROM kao i dva magnetna čitača i ploter. Nijedan od zahteva ne može biti

zadovoljen, pa je sistem u mrtvoj petlji. Sada kada znamo kako detektovati mrtve petlje,

postavlja se pitanje kada ih tražiti. Jedna mogućnost je da se proverava njihovo postojanje svaki

put kada se postavi zahtev za resursom. Tako je sigurno da će biti detektovane najranije moguće,

ali ovo troši mnogo procesorskog vremena. Alternativno, može se mrtva petlja tražiti svakih k

minuta ili samo onda kada upotreba procesora pala ispod nekog praga. Razlog razmatranja

upotrebe procesora je taj što ako je mnogo procesa u mrtvoj petlji, biti će nekoliko procesa koji

se mogu izvršiti, i procesor će često biti slobodan.

Oporavak od mrtve petlje

Pretpostavimo da je naš algoritam za detekciju mrtve petlje uspio i da je detektovao

mrtvu petlju. Šta sada? Potreban je neki način oporavka i ponovnog pokretanja sistema. U ovom

poglavlju diskutovati ćemo razne načine oporavka od mrtve petlje. Ni jedan od njih, međutim,

nije naročito atraktivan.

16

Oporavak preko oduzmanja resursa (preemption)

U nekim slučajevima moguće je da se privremeno oduzme resurs od njegovog trenutnog

korisnika i dodeli drugom procesu. U mnogo slučajeva, potrebna je intervencija samog korisnika.

Na primer, da bi se laserski štampač oduzeo od trenutnog njegovog korisnika, operator

može da skupi sve već odštampane stranice na hrpu. Tada proces može biti suspendovan. Sada

štampač može biti dodeljen drugom procesu. Kada on završi, hrpa odštampanih stranica se može

opet vratiti na štampač i restartovati originalni proces.

Sposobnost oduzimanja resursa od procesa, davanje drugom procesu na korištenje tog

resursa, vraćanje resursa prvobitnom procesu a da on to ne primeti veoma zavisi od prirode tog

resursa. Oporavak u ovom slučaju često je teško ili čak nemoguće izvesi. Odabiranje procesa koji

će se suspendovati zavisi od prirode resursa, dakle koji će se resurs najlakše vratiti prvobitnom

procesu.

Oporavak putem vraćanja stanja procesa unazad (Rollback)

Kako dizajneri sistema i korisnici mašina znaju da su mrtve petlje moguće, moguće je

napraviti da se procesi periodično čekiraju. Čekiranje procesa je zapisivanje trenutnog stanja

procesa u fajl tako da bi se kasnije moglo to stanje restartovati. Čekiranje ne sadrži samo

memorijsku sliku već i stanje resursa, odnosno koji resursi su u tom trenutku bili dodeljeni

procesu. Da bi bila efektivnija, nova čekiranja ne bi trebala izbrisati stara nego se upisati u nove

fajlove. Tako bi se stvarali novi fajlovi stanja procesa sve dok god se on izvršava.

Kada se detektuje mrtva petlja, lako je videti koji su resursi zahtevani. Da bi se sproveo

oporavak, proces koji drži zahtevani resurs se vraća na stanje koje je imao pre zahtevanja tog

resursa tako što se restartuje neki od prošlih fajlova stanja procesa. Sav posao odrađen od tog

stanja na dalje propada (npr. ako su odštampane neke stranice a u međuvremenu se stanje vratilo

na prethodno, bacaju se jer će biti ponovo odštampane). Proces se resetuje na prethodno stanje

kada nije imao resurse koje sada drži proces koji je bio u mrtvoj petlji. Kada se restartuje, proces

ponovo zahteva resurs, ali sada on čeka da resurs postane slobodan.

17

Oporavak preko ubijanja procesa (killing processes)

Najgrublji i najjednostavniji način prekidanja mrtve petlje je ubijanje jednog ili više

procesa. Jedna mogućnost je ubijanje procesa iz kruga. Uz malo sreće, drugi procesi će nastaviti

svoj posao. Ako ovo ne pomogne, jednostavno se nastavi sa ubijanjem procesa iz kruga, sve dok

se krug sasvim ne prekine.

Alternativno, proces koji nije u krugu se takođe može izabrati kao žrtva da bi oslobodili

resurse koje on drži. U ovom slučaju, proces koji treba da se ubije je pažljivo odabran jer drži

resurse koji su zahtevani od nekog procesa iz kruga. Na primer, jedan proces može da drži

štampač, a da zahteva ploter, dok drugi proces drži ploter i zahteva štampač. Ova dva procesa su

u mrtvoj petlji. Treći proces drži identičan štampač i identičan ploter i normalno radi. Ubijanjem

trećeg procesa oslobađaju se njegovi resursi i prekida se mrtva petlja prva dva procesa. Gde je

moguće, najbolje je ubiti proces koji se može restartovati od samog početka bez loših posledica.

Na primer, kompajliranje se uvek može restartovati jer kompajler u stvari samo čita izvorni fajl i

pravi objektni fajl. Sa druge strane, procesi koji popunjavaju baze podataka, ne mogu se uvek

dobro restartovati po drugi put. Ako proces doda 1 nekom slogu u bazi, puštajući je u rad, pa je

ubijajući, ponovo puštanje u rad dodati će 2 u slog, što nije tačno.

IZBEGAVANJE MRTVE PETLJE

U diskusiji o mrtvim petljama, prećutno smo pretpostavili da kada proces zahteva

resurse, da ih zahteva sve od jednom (matrica R sa slike 5.). Kod većine sistema, međutim,

resursi se zahtevaju jedan po jedan. Sistem treba da zna odlučiti kada je odobravanje

zahtevanih resursa sigurno a kada nije, i dozvoliti resurse samo u prvom slučaju. Postavlja se

pitanje: Postoji li algoritam koji može uvek izbeći mrtve petlje pravilnim odlučivanjem? Odgovor

je: da – mogu se izbeći mrtve petlje ali samo kada je određena informacija dostupna unapred

Sigurna i nesigurna stanja

U bilo kom trenutku vremena, trenutno stanje sastoji se od E, A, C i R. Za stanje kažemo

da je sigurno kada nije u mrtvoj petlji i postoji neki raspored po kojem se svaki proces odvija

18

dok se ne završi, čak i ako svi procesi odjednom zahtevaju maksimalni broj resursa koji im može

biti dodeljen. Ovaj koncept najlakše je ilustrovati primjerom sa jednim resursom. Na slici 7.

imamo stanje procesa A koji ima 3 primerka resursa ali možda će zahtevati ukupno 9 primeraka.

B trenutno drži 2, a možda će zahtevati ukupno 4 primerka, kasnije. Slično, C drži 2, a možda će

zahtevati još 5 primeraka resursa. Ukupan broj primeraka resursa je 10, znači pošto je 7 već

alocirano, ostala su još 3 slobodna.

Slika 7. Demonstracija da je stanje (a) sigurno

Stanje na slici 7. (a) je sigurno jer sekvence alokacija omogućavaju izvršenje čitavog

procesa. Naime, raspored može jednostavno pokrenuti isključivo proces B, sve dok ne zatraži i

dobije dva nova primerka resursa. Ovo stanje prikazano je na slici 7.(b). Kada B završi, dolazimo

do stanja datog slikom 7.(c). Sada raspored može da pokrene C, što dovodi do slike 7.(d). Kada C

završi dobijamo 7.(e). Sada A može da dobije šest primeraka resursa koje traži i takođe može da

završi. Tako da je stanje 7.(a) sigurno jer pažljivim rasporedom procesa, sistem izbegava mrtvu

petlju.

Sada pretpostavimo da imamo početno stanje dato na slici 8.(a), ali ovog puta A zahteva

i dobija druge resurse, što je dato slikom 8.(b). Da li možemo pronaći sekvencu koja bi

garantovala uspešan rad? Da pokušamo. Raspored može da pokrene B dok ne zatraži sve svoje

resurse, što je dato na slici 8.(c).

19

Slika 8. Demonstracija da stanje (b) nije sigurno

Nakon nekog vremena B završava i dobijamo stanje na slici 8.(d). Došli smo do

zaglavljivanja. Postoje samo 4 slobodna primerka resursa, a svaki od aktivnih procesa zahteva 5.

Ne postoji sekvenca koja garantuje završetak. Tako je odluka o alokaciji koja je promenila stanje

sistema od onog sa slike 8.(a) na stanje na slici 8.(b), u stvari promenila sigurno stanje sistema u

nesigurno. Ništa ne znači što nesigurno stanje nije mrtva petlja. Počevši od slike 8.(b), sistem

može da radi neko vreme. u stvari, proces se čak može i završiti. Nadalje, moguće je da A

oslobodi resurse prije nego što traži nove, tako omogućavajući da C završi i izbegavajući na taj

način mrtvu petlju. Tako je razlika između sigurnog i nesigurnog stanja u tome što sistem u

sigurnom stanju može garantovati da će se svi procesi završiti, dok proces u nesigurnom stanju

ne može dati nikakvu garanciju o završavanju procesa.

Bankarov algoritam za jedan resurs

Algoritam rasporeda koji može izbeći mrtve petlje je nastao zahvaljujući Dijkstra (1965) i

poznat je kao bankarev algoritam a koristi se kao dodatak algoritma za detekciju mrtvih petlji.

Modelovan je tako da bi bankar malog grada mogao raditi sa grupom korisnika kojima je

odobrio kredit. Algoritam proverava da li odobravanje zahteva za kredit dovodi do nesigurnog

stanja. Ako dovodi, tada se zahtev za kreditom odbija. Ako odobravanje dovodi do sigurnog

stanja, ono se odobrava. Na slici 9.(a) vidimo 4 korisnika A, B, C, D, svaki od njih ima odobren

određeni kredit (1 jedinica =1K$). Bankar zna da svi korisnici neće odmah trebati sav kredit, pa

je odvojio 10 jedinica umjesto 22 da bi ih uslužio (U ovoj analogiji korisnici su procesi ,a jedinice

su resurs dok je banka operativni sistem).

20

Slika 9. Stanja alokacije resursa: (a) sigurno, (b) sigurno, (c) nesigurno.

Korisnici, s obzirom na posao kojim se bave, traže kredite s vremena na vreme

(zahtevaju resurse). U određenom trenutku, situacija je kao na slici 9.(b). Ovo stanje je sigurno

jer su ostale još dve jedinice, pa bankar može da odloži sve zahteve osim C, tako mu

omogućavajući da završi i oslobodi 4 njegova resursa. Sa 4 jedinice, bankar može sada da ih

prepusti D ili B koji ih traže, itd..

Razmotrimo što bi se desilo da je zahtev B za jednom ili više jedinica odobren što je dato

na slici 9.(b). Doći ćemo u stanje na slici 9.(c) koje je nesigurno. Ako svi korisnici odjednom

zatraže maksimalan kredit, bankar ne može da zadovolji ni jednog od njih pa iz toga sledi da je

će sistem ući u mrtvu petlju. Nesigurno stanje ne mora da dovede do mrtve petlje, pošto

korisnik možda neće imati potrebu za svim kreditom ali bankar ne može da računa na takvo

stanje.

SPREČAVANJE MRTVE PETLJE

Videli smo da se mrtva petlja ne može izbeći, jer su sistemu potrebne informacije o

budućim zahtevima za resurse, koje nisu poznate. Kako onda sistemi izbegavaju pojavu mrtve

petlje? Odgovor leži u ona četiri uslova za postojanje mrtve petlje (Coffman et al. 1971). Ako

možemo osigurati da se bar jedan uslov nikada ne ispuni, mrtva petlja ne može nikada nastati.

21

Napad na uslov uzajamnog isključivanja

Ako se ekskluzivno ne dodele resursi jednom procesu, mrtva petlja se neće nikada desiti.

Međutim, jasno je da će doći do haosa ako dozvolimo da dva procesa istovremeno koriste

štampač. Ako je izlaz štampača u spoolingu*, tj. poslat je u memoriju ili na disk odakle će mu se

kasnije pristupiti, nekoliko procesa mogu da u isto vreme generišu izlaz. Po ovom modelu, jedini

proces koji stvarno fizički zahteva štampač je njegov serverski program (daemon). Pošto

serverski program nikad ne zahteva druge resurse, možemo eliminisati mrtvu petlju kod

štampača.

Na nesreću, ne mogu svi uređaji da budu u spoolingu (tabela procesa se tada ne ponaša

baš najbolje). Nadalje, nadmetanje nad prostorom na disku za spooling samo po sebi vodi u

mrtvu petlju. Što bi se desilo da postoje dva procesa koji popune, svaki po pola, slobodan

prostor za spooling izlaznim podacima, a da ni jedan ne završi sa pravljenjem tih izlaznih

podataka. Ako je serverski program štampača programiran tako da počne štampanje pre nego

što se sav izlaz nađe u spoolingu štampač može da čeka sa štampanjem ako je izlazni proces

odlučio da sačeka nekoliko sati prije nego što počne sa štampanjem. Zbog toga serverski

programi su programirani da štampaju tek kada je dostupan čitav fajl. U ovom slučaju imamo

dva procesa koji su odradili dio, ali ne i sve, izlazne podatke, i stoga ne mogu da nastave dalje.

Nijedan od procesa neće nikada da završi, što bi značilo da na disku imamo mrtvu petlju. Ovde

leži začetak ideje koja može biti često primenjivana. Izbegavanje dodeljivanja resursa osim u

slučajevima kada je to apsolutno neophodno, i osiguravanje da što manji broj procesa može

zatražiti dati resurs.

Napad na uslov zadrži i čekaj

Drugi od uslova koji su dati u Coffman et al. izgleda malo više obećavajući. Ako možemo

da sprečimo da procesi koji drže rersurse čekaju na nove resurse, možemo eliminisati mrtvu

petlju. Jedan način da se ovo postigne je da tražimo da svi procesi zahtevaju sve svoje resurse

pre nego što počnu sa izvršavanjem. Ako je sve slobodno, procesu će biti dodeljeni resursi koje

zahteva i on može da odradi svoj posao do kraja. Ako su jedan ili više resursa zauzeti, ni jedan

22

resurs mu se neće dodeliti, i on mora čekati. Neposredan problem ovog pristupa je da mnogi

procesi ne znaju koliko će resursa trebati sve dok ne počnu da rade. U stvari, da znaju, bankarov

algoritam bi bio primjenjiv. Drugi problem je što se sa ovakvim pristupom resursi neće

optimalno koristiti. Uzmimo, kao primjer, proces koji čita podatke sa jedne magnetne vrpce,

analizira ih jedan sat, zatim rezultate upisuje na drugu magnetnu vrpcu i daje rezultate na

ploteru. Ako se svi resursi moraju zahtjevati unaprijed, proces će držati izlaznu magnetnu vrpcu

i ploter čitav sat. Ipak, neki višekorisnički sistemi traže od korisnika da navede sve resurse

potrebne za svaki posao. Sistem tada drži te resurse sve dok se posao ne odradi do kraja. Iako

ovaj način opterećuje programera i neoptimalno koristi resurse, on sprečava pojavu mrtve

petlje. Malo drugačiji način ugrožavanja uslova zadrži i čekaj je da sistem zatraži od procesa koji

zahtjeva resurs da prvo privremeno oslobodi sve resurse koje trenutno drži. Tada da pokuša

odjednom dobiti sve što mu je potrebno.

Napad na uslov nemogućnosti oduzimanja resursa bez posledica

Napad na treći uslov je još manje obećavajući od napada na drugi. Ako je procesu

dodijeljen štampač i proces ga trenutno koristi (štampa), nasilno oduzimanje štampača je u

najboljem slučaju teško, a u najgorem nemoguće.

DRUGA PITANJA O MRTVIM PETLJAMA

U ovom poglavlju razmotrićemo nekoliko različitih pitanja koja se odnose na mrtvu

petlju, i to : dvo-fazno zaključavanje, mrtve petlje bez resursa i izgladnjivanje.

Dvo-fazno zaključavanje

Iako ni izbjegavanje ni prevencija, uopšteno gledajući, nisu naročito obećavajući načini,

postoje mnogi dobri algoritmi koji se koriste za specijalne namjene. Na primjer, u mnogim

sistemima baza podataka, operacija koja se često dešava je zahtjev za zaključavanje nekoliko

slogova, a zatim i ažuriranje tih slogova. Kada nekoliko procesa radi u isto vrijeme, postoji

23

realna opasnost od pojave mrtvih petlji. Pristup koji se često koristi je dvo-fazno zaključavanje.

U prvoj fazi proces pokušava da zaključa istovremeno sve slogove koji su mu potrebni. Ako

uspije u tome, počinje druga faza – ažuriranje slogova i njihovo oslobađanje. U stvari i nije

urađen nikakav posao u prvoj fazi.

Ako u prvoj fazi postoji neki slog koji je već prethodno zaključan (od strane drugog

procesa), proces oslobađa sve zaključane slogove i ponovo počinje prvu fazu. Na određen način,

ovaj pristup je sličan zahtjevu za svim potrebnim resursima unaprijed ili bar prije nego što se

odradi nešto poslije čega nema povratka u staro stanje. Kod nekih varijacija dvo-faznog

zaključavanja ne postoji oslobađanje i restartovanje ako se naiđe na određeni slog koji već

zaključan u prvoj fazi. Kod njih je moguća pojava mrtve petlje. Međutim, ova strategija,

uopšteno, nije primjenjiva. U sistemima u realnom vremenu i sistemima kontrole procesa, npr.

nije prihvatljivo, usljed nedostupnosti resursa, proces samo djelomično okončati i početi sve

ponovo. Nije prihvatljivo ni početi ispočetka ako je proces pročitao ili poslao poruke mreži,

ažurirao fajlove, ili bilo što drugo što se ne može ponoviti na zadovoljavajući način. Algoritam

radi samo u onim slučajevima kada je programer vrlo pažljivo napravio raspored, tako da se

program može zaustaviti u bilo kojem trenutku tokom prve faze i zatim restartovati. Mnoge

aplikacije se ne mogu napraviti da rade na ovaj način.

Mrtve petlje bez resursa

Do sada smo govorili o mrtvim petljama nad resursima. Jedan proces zahtjeva resurs

kojeg drugi proces drži i mora da čeka dok se taj resurs ne oslobodi. Mrtve petlje mogu da se

dešavaju i u drugim slučajevima kao što su oni u koje nisu uključeni resursi.

Na primer, može se desiti da se dva procesa nađu u mrtvoj petlji, tako što svaki čeka da

ovaj drugi odradi nešto. Ovo se često dešava kod semafora. U poglavlju 2 vidjeli smo neke

primjere toga. Ako se izvršavanje procesa odvija po pogrešnom poretku, može doći do pojave

mrtve petlje.

24

Izgladnjivanje

Problem koji je usko povezan sa mrtvom petljom je izgladnjivanje. U dinamičkom

sistemu stalno se dešavaju zahtjevi za resursima. Potrebna je neka politika odlučivanja o tome

ko kada dobija koji resurs. Ova politika, iako naizgled razumna, može dovesti do toga da neki

procesi nikada ne budu opsluženi iako se ne nalaze u mrtvoj petlji.

Kao primer, posmatrajmo alokaciju štampača. Zamislimo da sistem koristi neku vrstu

algoritma da bi osigurao da alokacija štampača ne dovede do mrtve petlje. Sada pretpostavimo

da nekoliko procesa zahtjeva štampač istovremeno. Koji proces će ga dobiti?

Jedan mogući algoritam alokacije je da se štampač dodjeli procesu koji ima najmanji fajl

koji treba odštampati (pretpostavljamo da je ova informacija dostupna). Ovaj pristup

maksimizira broj zadovoljnih korisnika i čini se da je dobar. Sada razmotrimo šta se dešava kod

veoma zaposlenog sistema kada jedan proces treba da štampa jedan veoma velik fajl. Svaki put

kada je štampač slobodan, sistem će potražiti i izabrati proces sa najmanjim fajlom. Ako postoji

stalan protok procesa sa malim fajlovima, proces sa velikim fajlom neće nikad dobiti štampač.

On će jednostavno izgladnjeti do smrti ( vječno će se odlagati, iako nije blokiran). Izgladnjivanje

može da se izbjegne korištenjem drugačije politike alokacije resursa: prvi-dođe, prvi-uslužen.

Ovim pristupom, proces koji je najduže čekao biva slijedeći uslužen. Svaki dati proces će biti u

jednom trenutku najstariji i time dobiti resurs koji mu je potreban.

ISTRAŽIVANJA MRTVIH PETLJI

Mrtve petlje su su istraživane i opisivane od najranijih dana operativnih sistema. Razlog

tome je što je detekcija mrtve petlje jedan lijepi, mali problem teorije grafova s kojim se jedan

matematički obdaren postdiplomac može uhvatiti u koštac i “žvakati ga” jedno 3-4 godine.

Izmišljeni su razni algoritmi, svaki egzotičniji i manje praktičan od prošlog. Kao posljedica toga,

sva ova istraživanja su izumrla i veoma je malo novih radova (Karacali et al.,2000.). Kada

25

operativni sistem želi da izvrši detekciju ili prevenciju mrtve petlje (nekoliko ih to i radi), koristi

onda jedan od načina datih u prethodnim poglavljima.

Još uvijek postoje određena istraživanja na polju detekcije mrtve petlje. Međutim, ovdje

se time nećemo baviti jer je (1) to izvan interesovanja ove knjige, i (2) ni jedan od njih nije čak ni

približno primjenjiv na realne sisteme. Njihova glavna upotreba izgleda da je u tome što drži van

ulice inače nezaposlene teoretičare grafova.

26

ZAKLJUČAK

Mrtva petlja predstavlja potencijalan problem svakog operativnog sistema. Ona se

dešava kada svakom procesu iz grupe procesa biva ekskluzivno dodeljen resurs, a pri tom svaki

od procesa zahteva drugi resurs kojeg poseduje drugi proces iz grupe. Svi procesi su blokirani i

ni jedan neće više nikad da se pokrene. Mrtva petlja može da se izbegne vođenjem evidencije o

tome koja stanja su sigurna a koja to nisu. Sigurno stanje je ono kod kojeg postoji sekvenca

događaja koja garantuje završetak procesa. Nesigurno stanje nema takvih garancija. Bankarov

algoritam izbegava mrtve petlje ne odobravajući zahtev koji bi odveo sistem u nesigurno stanje.

Mrtva petlja se može strukturno sprečiti izgradnjom sistema na taj način da se ona nikad

ne može pojaviti u tako dizajniranom sistemu. Na primer, dozvoljavanjem procesu da drži samo

jedan resurs istovremeno krši se uslov cirkularnog čekanja koji je neophodan da bi se pojavila

mrtva petlja. Mrtva petlja se takođe može spriječiti numerisanjem svih resursa i njihovim

zahtjevanjem od strane procesa po striktno rastućem redosledu. Izgladnjivanje može da se

prevaziđe politikom alokacije: prvi-dođe, prvi-uslužen.

27

Literatura

1. http://www.croportal.net/forum/tutoriali-i-trikovi/petlje-8031/

2. http://www.link-elearning.com/lekcija-Osnovi-multitasking-a._50

3. http://search.conduit.com/Results.aspx? q=mrtve+petlje&SearchSourceOrigin=1&hl=en&SelfSearch=1&ctid=CT2269050&start=10

4. http://www.pc-press.com/arhiva/tekst.asp?broj=127&tekstID=6960

5. http://webcache.googleusercontent.com/search? q=cache:LXdF367nWXsJ:www.os.ac.me/os/materijal/Deadlocks1/Deadlocks1.doc+mrtve+petlje&cd=1&hl=en&ct=clnk

6. http://docs.google.com/viewer?a=v&q=cache:mq_zOP4m0GYJ:www.os.ac.me/os/ OS7.pdf+mrtve+petlje&hl=en&pid=bl&srcid=ADGEESiVZx_ECbXd-VRGPAyl9IkTOGy4IMbtYLPYlg5bLzoI7YK89VHZFBcQlsvitN9eLkjJCIpiRhbFxdLc5D-dIxXsjmSvEKnrBW--Nzw8bAOuL-m3qvr727WcZswLpoKwfT6oxmau&sig=AHIEtbTehvWfR2swPNmBKYvdgZwGsF2Hng

7. http://webcache.googleusercontent.com/search? q=cache:mZXPgfWHvB8J:www.os.ac.me/os/semi2002_03/Deadlocks.ppt+mrtve+petlje&cd=3&hl=en&ct=clnk

28

29

*