Val´ os idej˝ u oper´ aci´ os rendszerek

Az RT rendszerek alapjai napjainkban sz´am´ıt´og´epen fut´o val´os idej˝u oper´aci´os rendsze-rek (real-time operating system, RTOS). Az RTOS kulcseleme, hogy az alkalmaz´asok feladatait (task) el˝ore defini´alt, ismert id˝on bel¨ul fogadja ´es elv´egzi. A feladatok elv´ eg-z´es´enek ideje ugyan sz´orhat valamelyest (jitter), de hard RT rendszerekn´el a kis sz´or´as k¨ovetelm´eny. A fentieknek megfelel˝oen RTOS-ek eset´eben is megk¨ul¨onb¨oztet¨unk hard

´

es soft rendszert: soft RTOS-ekn´el a folyamatoknak t¨obbnyire van hat´aridej¨uk, m´ıg egy hard RTOS eset´eben minden folyamat determinisztikus hat´arid˝ovel hajt´odik v´egre.

Az oper´aci´os rendszerek (OS), ezeken bel¨ul pedig k¨ul¨on¨osk´eppen az RTOS-ek egyik kulcsfontoss´ag´u tulajdons´aga a feladat-eloszt´as. Az egyes feladatok h´aromf´ele ´allapotban lehetnek: fut´o folyamat az, amit a processzor ´eppen v´egrehajt; a feladat k´eszenl´etben van, ha v´egrehajt´asra v´ar; a folyamat blokkolt, ha adat ki- vagy bevitelre v´ar. Mivel a legt¨obb processzor egy folyamatot k´epes csak futtatni, ez´ert a rendszerben l´ev˝o folyama-tok d¨ont˝o t¨obbs´ege blokkolt vagy k´eszenl´etben van. Azt, hogy melyik folyamat futhat egy processzoron, az oper´aci´os rendszer a folyamatokhoz rendelt priorit´asok alapj´an ha-t´arozza meg. A k´eszenl´eti list´an a priorit´asok szerint ´allnak sorba az egyes folyamatok.

Uj folyamat megjelen´´ esekor a jelenleg fut´o folyamatot egy interrupt megszak´ıtja, az OS besorolja az ´uj folyamatot a list´aba, majd visszat´er a megszak´ıtott folyamathoz. Az ehhez sz¨uks´eges id˝o az ´un. ”flyback time”, ´es egy j´ol fel´ep´ıtett RTOS-nek ezt er˝osen korl´atozott sz´am˝u m˝uvelettel kell v´egrehajtania. Az ´uj folyamat beiktat´asa max. 5-20 paranccsal, a megszak´ıtott folyamat folytat´asa pedig max. 5-30 paranccsal kell hogy

le-´ırhat´o legyen. Amennyiben t¨obb feladatot k´ıv´anunk ”egyszerre” futtatni (multitasking) - ami manaps´ag teljesen term´eszetes -, az oper´aci´os rendszernek v´altogatnia kell a folya-matokat a processzoron, hogy minden folyamat haladhasson. Alapvet˝oen k´etf´ele design l´etezik a folyamatok v´altogat´as´ara.

Az esem´enyvez´erelt design eset´eben az OS csak akkor v´alt ´at m´asik feladatra, ha meg-jelenik a feladatlist´an egy magasabb priorit´as´u folyamat. Ez az ´un. preemptive priority, vagy priorit´as-eloszt´as. A m´odszer el˝onye, hogy a folyamatokat csak magasabb rend˝u folyamatok szak´ıthatj´ak meg. H´atr´anya, hogy az alacsony priorit´as´u folyamatok hossz´u ideig szenvedhetnek er˝oforr´as-hi´anyban (starvation). Az id˝oben megosztott design ezzel ellent´etben nem csak esem´enyekre, hanem hagyom´anyos ´orajeles interruptokra is v´alt a feladatok k¨oz¨ott. Gyakori v´altozata ennek az eloszt´asi rendszernek az ´un. ”round robin”

(k¨orhinta), ahol a folyamatok azonos m´eret˝u id˝oablakokat kapnak, minden folyamat sorra ker¨ul, majd a k¨or kezd˝odik el˝or˝ol (teh´at a folyamatok azonos priorit´as´uak). A design el˝ o-nye, hogy egy folyamat sem marad er˝oforr´as n´elk¨ul (starvation-free design), ´es a gyakori v´alt´as miatt a multitasking nagyon finom, azt az ill´uzi´ot kelti, hogy az ¨osszes er˝oforr´as a folyamat´e/felhaszn´al´o´e. Ugyanakkor h´atr´any, hogy az OS l´enyegesen t¨obbsz¨or v´alt a folyamatok k¨oz¨ott, ami a teljes rendszer lassul´as´ahoz vezet. A hardvergy´art´ok azonban optimaliz´altak erre a probl´em´ara, ´es m´ıg egy r´egebbi processzoron a feladatv´alt´as ak´ar 20 ms id˝ot is ig´enyelt, a korszer˝ubb processzoroknak m´ar kevesebb mint 3 ms-ra van sz¨uks´eg¨uk ugyanehhez.

A folyamatokat azonban nem csak rangsorolni kell, hanem meg kell osztani k¨oz¨ott¨uk a sz´am´ıt´og´ep ¨osszes er˝oforr´as´at is, hiszen ha t¨obb folyamat haszn´aln´a egyszerre ugyan-azt az er˝oforr´ast, az megj´osolhatatlan eredm´ennyel j´arna. P´eldak´ent gondoljunk arra, hogy mi t¨ort´enne, ha az egyik folyamat olyan mem´oriater¨uletet olvasna ki, amit egy m´asik folyamat m´ar (r´eszben) fel¨ul´ırt. Sz¨uks´eges teh´at annak biztos´ıt´asa, hogy az egyes folyamatok egym´ast´ol elk¨ul¨on¨ulve m˝uk¨odhessenek. Ezt nevezik forr´asmegoszt´asnak.

A forr´asmegoszt´as egyik nagyon egyszer˝u, ´am sok bonyodalmat is el˝oid´ezni k´epes m´odja az interruptok tilt´asa. Ha egy folyamat fut´asa k¨ozben letiltjuk az interruptokat, akkor processzor (´es minden m´as er˝oforr´as is) a fut´o folyamat´e marad, mert a rendszer nem k´epes k¨ozbel´epni semmilyen m´odon. Ez azonban igen vesz´elyes is lehet, ha p´eld´aul a fut´o folyamat nagyon hossz´u, esetleg valami hiba folyt´an v´egtelen ciklusba ker¨ul - ekkor a multitasking megsz˝unik, sz´els˝os´eges esetben a rendszer lefagy. Ezek miatt a potenci´alis vesz´elyek miatt a hagyom´anyos oper´aci´os rendszerek felhaszn´al´oi szint˝u folyamatok sz´ a-m´ara nem enged´elyezik az interrupt-tilt´ast. Az RTOS-ek eset´eben azonban van lehet˝os´eg kernel m´odban is folyamatokat futtatni, ez´altal a folyamat sokkal hat´ekonyabb rendszer-h´ıv´asokra is k´epes, kevesebb k¨ozrem˝uk¨od´est ig´enyel az oper´aci´os rendszert˝ol. F˝oleg az egy CPU-val rendelkez˝o rendszerek eset´eben ´erdekes, hogy az ilyen folyamatok sz´am´ara enged´elyezett az interruptok tilt´asa, azaz egyetlen folyamat haszn´alja a teljes CPU-t, ´ıgy gyorsan v´egre tud hajt´odni. Azonban a programoknak csak egy kis, ´un. kritikus r´esze futhat ebben a v´edett m´odban: ennek felt´etele, hogy a kritikus r´esz fut´asi ideje r¨ovidebb legyen, mint a leghosszabb interrupt k´esleltet´esi id˝o az OS-ben. Ez a gyakorlatban azt jelenti, hogy a kritikus r´esz n´eh´any utas´ıt´asra korl´atoz´odik, ´es ciklusok nem enged´ elyezet-tek. Ha az RT alkalmaz´asban siker¨ul ilyen r¨ovid feladatokat defini´alni, akkor az interrupt tilt´as egy el´erhet˝o opci´o, ´es ´altala biztos´ıtani lehet, hogy a feladatot ismert id˝on bel¨ul elv´egzi a rendszer.

Miel˝ott folytatn´ank, ´es belemenn´enk a r´eszletekbe, tekints¨uk ´at azt a n´eh´any alap-vet˝o dolgot, amelyeket a folyamatokr´ol felt´etelez¨unk. ´Altal´anoss´agban elmondhat´o, hogy

”megb´ızunk” a folyamatokban, azaz felt´etelezz¨uk, hogy az al´abbiakat nem teszik:

• Er˝oforr´ast ig´enyelnek, de azt k´es˝obb nem szabad´ıtj´ak fel.

• Olyan er˝oforr´ast szabad´ıtanak fel, amit kor´abban nem ig´enyeltek.

• Egy er˝oforr´ast sok´aig birtokolnak, de nem haszn´alj´ak.

• Olyan er˝oforr´ast haszn´alnak, amit nem ig´enyeltek.

Ezek ut´an n´ezz¨uk meg, mit lehet tenni, ha a kritikus szakasz hosszabb, mint az eml´ı-tett n´eh´any parancs. Ekkor a val´os idej˝u algoritmusoknak is hasonl´oan kell m˝uk¨odni¨uk, mint a t¨obbi programnak, ´es a v´edetts´eg biztos´ıt´asa ´un. bin´aris szemaforral lehets´ e-ges, ami nem m´as, mint egy v´edett v´altoz´o. Az OS pedig ezeken a v´edett v´altoz´okon kereszt¨ul vez´erli az er˝oforr´asokhoz val´o hozz´af´er´est. Ha a szemafor bin´aris, ´ert´eke 1-et vagy 0-´at vehet f¨ol. Ha egy folyamat megkap egy er˝oforr´ast, annak szemaforj´at null´aba

´

all´ıtja, ´es az ¨osszes t¨obbi folyamatnak v´arnia kell, ha ugyanezt az er˝oforr´ast akarja hasz-n´alni, mindaddig, am´ıg a szemafor ism´et 1-re nem ´all. A sziszt´ema j´ol ´erz´ekeltethet˝o a k¨onyvt´ar-anal´ogi´aval: az er˝oforr´asok egyszem´elyes olvas´otermek, ´es tegy¨uk fel, hogy van t´ız egyforma olvas´oterem. Olvas´otermet a k¨onyvt´arost´ol (oper´aci´os rendszer) lehet ig´enyelni, tetsz˝oleges id˝ore, viszont el˝ore foglal´as nincs! Emiatt mindig csak a szabad

termek sz´ama sz´am´ıt, az egyes konkr´et termek foglalts´aga nem. Amennyiben nincs sza-bad terem, az olvas´ok sorban ´allnak, vagy (bizonyos esetekben) versenghetnek is (pl.

priorit´as alapj´an). ´Altal´anoss´agban elmondhat´o, hogy az egyes folyamatok csak bizo-nyos id˝okorl´aton bel¨ul v´arnak egy szemaforra. Ez a rendszer azonban sz´amos probl´ema forr´asa lehet. Gyakori az ´un. priorit´as-megfordul´as, amikor egy magas priorit´as´u folya-matnak v´arnia kell, mert egy alacsony priorit´as´u folyamatnak van szemaforja. Ennek egy lehets´eges megold´asa az ´un. priorit´as-¨or¨okl´es, azaz a szemaforos folyamat priorit´as´at egyenl˝ov´e tessz¨uk a legmagasabb priorit´as´u v´arakoz´o folyamat´eval. Egy m´asik gyakori probl´ema, ami akkor jelentkezhet, ha a folyamatoknak t¨obb er˝oforr´asra is sz¨uks´eg¨uk van, az ´un. deadlock, vagy holtpont. Ekkor k´et vagy t¨obb folyamat rendelkezik 1-1 szemaforral, id˝okorl´at n´elk¨ul, ´es k¨ozben egym´as szemaforjaira v´arnak (anal´ogia: k´et em-bernek m˝uszaki rajzot kell k´esz´ıtenie, de csak egy vonalz´o ´es egy ceruza van, a vonalz´o az egyikn´el, a ceruza a m´asikn´al). Ez a patthelyzet gyakorlatilag a v´egtelens´egig tart, ´es k´epes teljesen megb´en´ıtani a rendszert. Kialakul´as´anak n´egy felt´etele van, ezek az ´un.

Coffman-felt´etelek:

• K¨olcs¨on¨os kiz´ar´as: adott er˝oforr´ast csak egy folyamat haszn´alhat.

• ”Fogd ´es k´erj” sziszt´ema, azaz er˝oforr´ast birtokl´o folyamatok ig´enyelhetnek ´uj er˝ o-forr´asokat.

• Nincs el˝ojogosults´ag (preemption), azaz nem lehet er˝oforr´ast elvenni folyamatt´ol.

• K¨ork¨or¨os v´arakoz´as: k´et vagy t¨obb folyamat (k¨ork¨or¨os l´ancban) v´ar egym´asra.

Egy kialakult holtpontot nagyon neh´ez feloldani, ez´ert ´altal´aban legink´abb a megel˝ o-z´es´ere koncentr´alnak. ´Erdekess´eg, hogy bizonyos rendszerek az strucc-algoritmust hasz-n´alj´ak, azaz nem vesznek tudom´ast a probl´ema l´etez´es´er˝ol. Eset¨unkben ez azt jelenti, hogy az oper´aci´os rendszer felt´etelezi, hogy egy holtpont kialakul´as´anak az es´elye igen csek´ely, ez´altal a holtpontok miatti adatveszt´es val´osz´ın˝us´ege olyan kicsi, amit v´allalni lehet. Ezt a m´odszert kezdetben p´eld´aul a UNIX rendszerek is haszn´alt´ak. Azonban ha ehelyett t´enylegesen meg k´ıv´anjuk el˝ozni (vagy feloldani a kialakult) holtpontot, ez a fenti felt´etelek valamelyik´enek kiz´ar´as´aval t¨ort´enhet, azonban b´armelyik szab´alyt is pr´ob´aljuk kiiktatni, az mindig okozhat valamilyen m´asik probl´em´at:

• K¨olcs¨on¨os kiz´ar´as tilt´asa. A legf˝obb probl´ema itt, hogy processzorok eset´en nem al-kalmazhat´o. Ugyanakkor bufferelhet˝o (spooling) er˝oforr´asokra kiv´al´o, ilyen p´eld´aul az adatolvas´as.

• A ”fogd ´es k´erj” kiiktat´asa. Ekkor a folyamatoknak az ¨osszes ´uj er˝oforr´ast egyszerre kell ig´enyelni¨uk. Ez a gyakorlatban legt¨obbsz¨or lehetetlen, ´es emiatt az er˝oforr´asok kihaszn´alts´aga nagyon alacsony lesz. Egy m´asik m´odszer, az ´un. all-or-none szisz-t´ema szerint a folyamatoknak minden er˝oforr´asukat fel kell szabad´ıtaniuk, miel˝ott

´

ujakat ig´enyelnek. Azonban ez is hasonl´o probl´em´akat okoz, ez´ert alkalmaz´asa nem praktikus.

• El˝ojogosults´agok haszn´alata, azaz a folyamatokt´ol el lehet venni az er˝oforr´asokat.

Ez nagyon probl´em´as, m´ar-m´ar szinte etikai k´erd´es, hiszen az oper´aci´os rendszernek feladata, c´elja, hogy minden folyamat sz´am´ara, legal´abb bizonyos ideig, biztos´ıta-nia kell az er˝oforr´asokat. Mindezeken t´ul, az el˝ojogosults´agok haszn´alata k¨onnyen eredm´enytelens´eghez (trashing) vezethet, azaz a rendszerid˝o az er˝oforr´asok el´er´ e-s´ere ford´ıt´odik, ´es nem a haszn´alatukra.

• A k¨ork¨or¨os v´arakoz´as kialakul´as´anak megakad´alyoz´asa. E c´el el´erhet˝o p´eld´aul az er˝oforr´asok u.n. r´eszleges rendez´es´evel (partial ordering), amikor is az er˝oforr´asokat sorrendbe ´all´ıtjuk, ´es a folyamatok csak olyan tov´abbi er˝oforr´asokat vehetnek f¨ol, amelyek sorsz´ama nagyobb, mint amiket jelenleg birtokolnak; tov´abb´a a legkisebb sorsz´am´ut kell el˝osz¨or felvenni, majd a legnagyobb sorsz´am´ut els˝ok´ent letenni. Saj-nos ez a m´odszer sem t¨ok´eletes, itt is sok id˝o ford´ıt´odik az er˝oforr´asok adogat´as´ara:

p´eld´aul, ha egy folyamat haszn´alja az 5-¨os ´es 3-as er˝oforr´asokat, de sz¨uks´ege lenne a 2-esre is, akkor el˝osz¨or le kell tennie 5,3-at, felvenni a 2-est, majd ´ujra k´erni a m´asik kett˝ot.

A fenti probl´em´ak f´eny´eben ´erthet˝o, hogy tov´abbi m´odszerek is vannak a holtpont kialakul´as´anak megakad´alyoz´as´ara. Az alap¨otlet az, hogy az oper´aci´os rendszer ismerheti (bek´erheti a folyamatt´ol), hogy a folyamat milyen er˝oforr´asokat fog haszn´alni, ig´enyelni fut´asa sor´an. Amikor egy folyamat futni k´ıv´an, az oper´aci´os rendszer a beszolg´altatott ig´enyei alapj´an ´ert´ekeli, hogy a folyamat fut´asa milyen es´ellyel vezethet holtponthoz (azaz, hogy a rendszer k¨ovetkez˝o ´allapota vesz´elyes-e), ´es az eredm´eny f¨uggv´eny´eben d¨ont a folyamat enged´elyez´es´er˝ol. Ahhoz, hogy a rendszer meg tudja ´allap´ıtani, hogy a k¨ovetkez˝o ´allapota biztons´agos lesz-e, a k¨ovetkez˝oket kell ismernie, el˝ore, b´armely id˝opillanatban:

• a jelenleg el´erhet˝o er˝oforr´asok,

• minden, az egyes folyamatok ´altal allok´alt er˝oforr´asok,

• a folyamatok ´altal a j¨ov˝oben ig´enyelni ´es felszabad´ıtani k´ıv´ant er˝oforr´asok.

Egy ilyen algoritmust ezek ut´an ´ugy haszn´alunk, hogy ha egy folyamat bejelenti, hogy egy er˝oforr´asra ig´enyt tart, akkor ´ugy tesz¨unk mintha odaadn´ank neki az ig´enyelt er˝ ofor-r´ast, ´es az ´ıgy l´etrej¨ott ´allapotr´ol eld¨ontj¨uk, hogy biztons´agos-e. Ha igen, akkor val´oban odaadjuk a processznek a megfelel˝o er˝oforr´ast, ha nem, akkor nem adjuk oda neki az er˝oforr´ast, hanem v´arakoztatjuk egy darabig (am´ıg esetleg v´altozik a helyzet). Ez az ´un.

bank´ar-algoritmus. Azonban mivel egy val´odi, ´eletszag´u folyamat a legritk´abb esetben

tudja el˝ore megmondani, milyen er˝oforr´asokat fog ig´enyelni, egy val´odi rendszerben a legritk´abb esetben haszn´alhat´o a bank´ar algoritmus.

Egy m´asik m´odszer a szimmetria-t¨or´es, azaz a k¨ork¨or¨os v´arakoz´as valamilyen m´odon t¨ort´en˝o felold´asa. Erre k´et ´altal´anosan haszn´alt algoritmus a Wait/Die (v´ar/t¨or¨ol) ´es a Wound/Wait (s´ert/t¨or¨ol). Mindk´et algoritmus megk¨ul¨onb¨ozteti a folyamatok ”kor´at”

(azaz hogy melyik folyamatot ind´ıtott´ak el el˝osz¨or), ´es ennek alapj´an d¨ont a folyamatok sors´ar´ol. Az al´abbi t´abl´azatban l´athat´o, hogy a k´et algoritmus milyen m´odon t¨ori meg a v´arakoz´as szimmetri´aj´at annak alapj´an, hogy a kor´abban ind´ıtott, id˝osebb folyamat (”O”) vagy a fiatalabb folyamat (”Y”) k´eri-e az ´uj er˝oforr´ast.

method Wait/Die Wound/Wait

O k´er ´uj er˝oforr´ast Y-t´ol O v´ar Y t¨orl˝odik Y k´er ´uj er˝oforr´ast O-t´ol Y t¨orl˝odik Y v´ar

10.1. t´abl´azat. K´et, ´altal´anosan haszn´alt szimmetriat¨or´esi m´odszer a holtpontok kiala-kul´as´anak megel˝oz´es´ere.

Szint´en ´erdemes megjegyezni, hogy a holtpontok felold´asa sem mindig probl´ emamen-tes, ´es a helytelen felold´as k¨onnyen eredm´enyezhet ´un. livelock-ot. A livelock sor´an a folyamatok nem ´allnak, hanem folyamatosan dolgoznak, v´altoznak, m´egsem haladnak el˝ore. Egy val´os ´eletbeli p´eld´aja a livelock-nak az utc´an szembetal´alkoz´o k´et udvarias ember esete: szerencs´etlen esetben mindk´et f´el ugyanabba az ir´anyba t´er ki, majd ezt

´

eszlelve megpr´ob´alnak a m´asik ir´anyba kit´erni, szint´en egyszerre... az eredm´eny k¨onnyen az a komikus eset, amikor a k´et ember jobbra-balra ”t´ancol”, ´es egyik¨uk sem tud tov´abb haladni. Livelock akkor alakulhat ki, ha a folyamatok k´epesek ´eszlelni, hogy holtpontba ker¨ultek, ´es megpr´ob´alj´ak azt feloldani (pl. ´ujraind´ıtj´ak magukat). Azonban ha t¨obb folyamat is hasonl´o l´ep´eseket tesz, akkor k¨onnyen kialakulhat ugyanaz a holtpont, ´es a holtpont-´eszlel˝o algoritmus ´ujra ´es ´ujra beindul. Ezt ´ugy lehet elker¨ulni, hogy biztos´ıt-juk, hogy csak egy folyamat tesz l´ep´eseket a holtpont felold´as´ara - ezt a folyamatot ak´ar v´eletlenszer˝uen vagy pl. priorit´as alapj´an v´alaszthatjuk ki.

A forr´aseloszt´as egy m´asik m´odja az ¨uzenetk¨uld´es (message passing), amikor is a fo-lyamatok egy szervezett ¨uzenetk¨uld´esi- rendszer ´altal tudnak egym´assal kommunik´alni.

Ebben a sziszt´em´aban egy er˝oforr´ast k¨ozvetlen¨ul csak egy folyamat birtokolhat, ´es ha egy m´asik folyamatnak van r´a sz¨uks´ege, ¨uzenetet k¨uld az er˝oforr´ast birtokl´onak. B´ar ennek a sziszt´em´anak az RT viselked´ese nem annyira hat´arozott, mint a bin´aris szemafo-ros sziszt´em´a´e, az egyszer˝ubb ¨uzen˝os rendszerek sokkal kev´esb´e vannak kit´eve holtpont-vesz´elynek, ´es ´altal´anoss´agban v´eve jobban is viselkednek. Azonban hasonl´o probl´em´ak itt is el˝ofordulhatnak, pl. priorit´as megfordul´as el˝o´allhat, ha egy folyamat ´eppen egy alacsony priorit´as´u ¨uzenetet dolgoz fel, mik¨ozben egy magasabb priorit´as´u ¨uzenet v´ a-rakozik; protokoll´aris holtpont alakulhat ki, ha k´et folyamat egym´as v´alasz¨uzeneteire v´ar.