OPERÁCIÓS RENDSZEREK

Átírás

1 OPERÁCIÓS RENDSZEREK I. Az operációs rendszer fogalma A számítógép (a hardver) önmagában semmit sem ér. A megfelelő szoftvertámogatással azonban képes információt tárolni, feldolgozni és visszakeresni (Neumann-elv). A szoftverek két nagy csoportját különböztetjük meg: a) rendszerprogramok (a számítógép saját működéséért felelnek) b) felhasználói programok (a tényleges munkát végzik) Az egyik legalapvetőbb rendszerprogram az operációs rendszer, amely a számítógép erőforrásait kezeli, valamint kezelő felületet biztosít felhasználó számára. Kialakulásának egyik legfőbb oka: meg kell védeni a programozókat a hardver bonyolultságától. A fokozatos fejlesztés eredménye a nyers hardver fölé helyezett szoftverréteg, amely a teljes rendszert kezeli és a felhasználó számára olyan kapcsolódási felületet biztosít, amelyet könnyebb megismerni és programozni. I.1. Mi az operációs rendszer? A kérdést nem egyszerű megválaszolni, mivel az operációs rendszer két, teljesen különböző feladatot hajt végre. Ezek a következők: I.1.1.Az operációs rendszer kiterjesztett gép (virtual machine) A legtöbb számítógép architektúrája a gépi nyelv szintjén primitív, programozása (különösen az I/O műveletek) kényelmetlen. A részletek mellőzésével is belátható, hogy egy átlagos programozó nem kíván mélyen belemerülni egy-egy hardvereszköz programozásába. Ehelyett a programozó egy egyszerű, átlátható, magas szintű absztrakcióval szeretne foglalkozni (nem pedig a pontos technikai megvalósítással). Az a program, amely eltakarja a hardvert a programozó elől, nem más mint az operációs rendszer. Ilyen szempontból az operációs rendszer tulajdonképpen olyan kiterjesztett gépként vagy virtuális gépként funkcionál, amelyet egyszerűbb programozni, mint a mögötte lévő hardvert. I.1.2.Az operációs rendszer erőforráskezelő

2 Az előzőekben felülről lefelé vizsgáltuk az operációs rendszer működését. Ha alulról felfelé vesszük szemügyre, akkor azt mondhatjuk, hogy az operációs rendszer az összetett számítógép minden egyes részét kezeli. Az utóbbi nézőpont szerint az operációs rendszer feladata az, hogy a processzor(okért), a memóriáért és az I/O eszközökért versengő programok számára szabályos és felügyelt módon biztosítsa a szükséges erőforrást. Többfelhasználós rendszerekben ennek különösen nagy jelentősége van! Ehhez a következő dolgokat kell megvalósítania: nyilván kell tartania, hogy ki melyik erőforrást használja, mérnie kell a használatot, valamint egyeztetnie kell a programok és felhasználók ellentmondásos kéréseit. I.2.Az operációs rendszerek története Volt már szó róla, hogy az operációs rendszerek évek hosszú során alakultak ki. Az operációs rendszerek szorosan kapcsolódnak azokhoz a számítógép-architekúrákhoz, amelyeken futottak, így az egymást követő számítógép-generációk jól mutatják, milyenek is voltak. Az első valóban digitális számítógép Charles Babbage nevéhez fűződik. "Analitikai gépe" sohasem működött ugyan, mivel korának technológiája nem tudta előállítani a szükséges alkatrészeket, de Babbage rájött, hogy szükség van a géphez szoftverre. Ada Lovelace-t (Lord Byron nővérét) kérte fel, hogy készítse el a megfelelő programot. Az Ada programozási nyelvet róla nevezték el. I.2.1.Az első generáció ( ); vákuumcsöek és kapcsolótáblák A 40-es évek közepén többek között Neumann János ért el sikert a vákuumcsöves számológépek építésében. Ezek óriási méretűek voltak. Minden gépet külön csapat tervezett, épített és kezelt. A programozás kizárólag gépi nyelven folyt. Főként numerikus számítások (sin és cos táblák) mgoldására használták. I.2.2.A második generáció ( ); tranzisztorok és kötegelt rendszerek Az 50-es években a lyukkártyák és a tranzisztorok óriási előrelépést jelentettek. A számítógépek gyárthatókká és eladhatókká váltak, és elég hosszú ideig működőképesek maradtak. Ezek a gépek lékondicionált termekbe voltak zárva, és szakképzett kezelőszemélyzet működtette őket. Egy feladat megoldásához először a programozó papírra írta a programot (FORTRAN vagy assembly nyelven), majd ezt kártyára lyukasztották. Megjegyzés: a számítógép idejének java része azzal telt, hogy a kezelő menetelt a gépteremben. Az

3 elvesztegetett idő csökkentésére dolgozták ki az ún. kötegelt rendszereket. A második generációs számítógépeket többnyire tudományos és mérnöki számításokra használták. Tipikus operációs rendszerek voltak az FMS (Fortran Monitor System) és az IBSYS, az IBM operációs rendszere a 7094-en. I.2.3A harmadik generáció ( ); integrált áramkörök és multiprogramozás Az IBM 360-as gépe volt az első olyan nagyobb sorozat, amelyben (kisméretű) integrált áramköröket (IC) alkalmaztak, ezzl óriási ár/teljesítmény előnyhöz jutottak a második generációs gépekkel szemben. A kompatibilitás mint igény is megfogalmazódott: lőny és hátrány volt egyszerre. Megjelent a multiprogramozás módszere (a CPU üresjárati idejének csökkentésére). A kialakult megoldás a memória szeletekre particionáláa volt. Ez viszont megkívánta, hogy a feladatokat megvédjük egymástól, ezt hardverrel oldották meg. A háttértárolás (spool, Simultaneous Peripheral Operation On Line) megjelenése is ebbe az időszakba esik. A harmadik generációs számítógépeken a feladat leadása és az eredmények visszakapása között több óra is eltelhetett. A gyors válaszidő iránti igény az időosztáshoz vezetett. Az első igazi időosztásos rendszer az M.I.T. által kifejlesztett CTSS rendszer volt. Ennek sikerén felbuzdulva az akkoriban jelentős gyártók (Bell Labs és a General Electric) megalkották a MULTICS (MULTiplexed Information and Computing Service) nevű renszert, ami több száz időosztásos felhasználót szolgált volna ki. A megépítése azonban nem úgy sikerült, ahogy gondolták. Ken Thompson, a MULTICS projekt egyik munkatársa fejlesztései (a MULTICS egyszerűsítése, egyfelhasználós változata) a UNIX operációs rendszerhez vezettek. Megjegyzés: POSIX szabvány. I.2.4.A negyedik generáció (1980-napjainkig); személyi számítógépek Az integrált áramkörök megjelenésével a számítógép tömegcikké vált. A kitűnő grafikai képességű számítógépek a felhasználóbarát szoftverek megjelenését vonták maguk után, ami jelentősen fellendítette az iparágat (szoftvergyártás). Kezdetben két operációs rendszer dominált a személyi számítógépek piacán: a Microsoft-féle MS-DOS és a UNIX. Az MS-DOS-t széles körben használták az IBM PC és más Intel processzorra (8088, 80286, 80386, 80486). A WINDOWS, az MS-DOS utódja eredetileg az MS-DOS felett futott (azaz inkább parancsértelmező, semmint operációs rendszer volt), de 1995-től önálló operációs rendszerként jelent meg (WINDOWS'95). Ugyanekkor egy másik vonalat is elindítottak, amely a WINDOWS NT fejlesztésévé vált. A UNIX az uralkodó a munkaállomásokon és a nagy számítógépeken, mint például a hálózati szerverek.

4 I.2.5.Hálózati operációs rendszerke és osztott operációs rendszerek Egy hálózati operációs rendszeren a felhasználók számára több számítógép áll rendelkezésre, bejelentkezhetnek távoli gépekre, stb. De ezek lényegében nem különböznek az egyprocesszoros operációs rendszerektől. Az osztott operációs rendszer a felhasználó felé egy hagyományos egyprocesszoros rendszernek mutatkozik, valójában azonban egy alkalmazás egy időben több processzoron futhat. Ehhez pedig bonyolult feladatütemező algoritmus szükséges. I.3.Az operációs rendszerek fogalmai Az operációs rendszer és a felhasználói programok közötti kapcsolatot az operációs rendszer által biztosított "kiterjesztett utasítás" készlet adja, amelyet hagyományosan rendszerhívásoknak nevezünk. Minden operációs rendszerben kulcsfontosságú a processzus fogalma, amely lényegében egy végrehajtás alatt lévő programot jelöl. Minden processzus rendelkezik saját címtartománnyal a memória egy szeletével amelyen belül olvashat ill. írhat. Minden procsszushoz tartozik még egy regiszterkészlet, beleértve az utasításszámlálót, veremmutatót, egyéb hardver regisztereket, valamint a program futásához szükséges egyéb információt. Fontos még a processzustáblázat (a processzushoz tartozó, de annak címtartományán kívüli információt tárol vektor vagy lánc formában) és a memóriatérkép (a címtartományának tartalmát jelenti). I.4.Rendszerhívások Többféle rendszerhívásról beszélhetünk: a) Processzuskezelő rendszerhívások b) Szignálkezelő rendszerhívások (váratlan események fellépésekor kapcsolatba lép a processzussal) c) Fájlkezelő rendszerhívások d) A védelem rendszerhívásai (A tulajdonos, a csoport és a többiek jogosultságaival foglalkozik) e) Az időkezelés rendszerhívásai (1970. január 1. 00:00)

5 I.5.Az operációs rendszer struktúrája A következőkben négy, már kitapasztalt struktúrát vizsgálunk, ezzel némi áttekintést nyerünk a lehetőségekről. I.5.1.Monolitikus rendszerek Ez a legelterjedtebb szervezés; struktúrája a strukturálatlanság. Az operációs rendszer eljárások gyűjteménye, bármelyik hívhatja a másikat korlátozás nélkül. Az információtakarás fogalma teljesen ismeretlen, minden eljárás látja a többit. Ennek ellenére, a monolitikus rendszereket is lehet valamelyest strukturálni. Ehhez tudni kell, hogy a legtöbb CPU két módban dolgozhat: kernel módban az operációs rendszernek dolgozik és ekkor minden utasítás megengedett; felhasználói módban a felhasználói programoknak dolgozik és az I/O ill. néhány más utasítás le van tiltva. Az operációs rendszer szolgáltatásait úgy kérjük, hogy a paramétereket először egyezményes helyeken (pl. regiszterekben) helyezzük el, ezután pedig egy ún. kernel hívást hajtunk végre, amely felhasználói módról kernel módra kapcsolja a gépet. Ha a rendszerhívás befejeződött, a felhasználói program visszakapja a vezérlést. Ez a szervezés utal az operációs rendszer alapstruktúrájára: 1. Főprogram, ez hívja a kívánt szolgáltató eljárásokat. 2. Szolgáltató eljárások készlete, ezek hajtják végre a rendszerhívásokat. 3. Segédeljárások a szolgáltató eljárások támogatására. I.5.2.Rétegelt rendszerek Az operációs rendszer rétegekől álló hierarchia is lehet, amelyben minden réteg az alatta lévőre épül.az első ilyen jellegű rendszer a Dijkstra által tervezett THE kötegelt rendszer volt. Ennek a rendszernek 6 rétege volt. A 0. réteg végezte a processzorhozzárendelést, a processzusok közötti átkapcsolált, valamint biztosította a CPU multiprogramozhatóságát. Az 1. réteg a memóriakezelést végezte. Lefoglalta a processzusok számára a belső memóriát. A 2. réteg kezelte a processzusok közötti kommunikációt és a gépkezelő kopnzolját. A 3. réteg felügyelte az I/O eszközöket és a bejövő vagy kimenő adatfolyamok átmeneti tárolását. A 4. réteg felhasználói programoké volt. A rendszer kezelőjének processzusa került az 5. rétegbe. A MULTICS rendszer tovább általánosította a rétegelt koncepciót. Rétegek helyett a MULTICS

6 koncentrikus gyűrűkbe szerveződött, a belsők több, a külsők kevesebb privilégiumot kaptak. I.5.3.Virtuális gépek Az eredetileg CP/CMS nevű, majd VM/370-re átkereztelt rendszer két jó ötletre épült: az időosztásos rendszerek egyrész a multiprogramozást, másrészt a nyers hardvernél jóval kényelmesebb kapcsolatot nyújtó kiterjesztett gépet biztosítanak. Ma a virtuális gép fogalmát másra is használják, mégpedig az MS-DOS futtatására Pentium vagy más 32 bites Intel processzoron. I.5.4.Kliens-szerver modell A korszerű operációs rendszerek egyre több és több programot tolnak magasabb rétegekbe, ezek kikerülnek az operációs rendszerből, végül egy minimális kernel marad. A módszer általában az, hogy az operációs rendszer több funkcióját felhasználói processzusokra bízzák. Ha egy szolgáltatást kérünk, például egy fájlblokk olvasását, akkor a felhasználói processzus (a kliensprocessus) egy kérést küld a szerverprocesszusnak, amelyik ezután elvégzi a munkát és visszaküldi a választ. Ebben a modellben a kernelnek csak a kliens és a szerver közötti kommunikácót kell kezelnie. II.Processzusok Minden modern számítógép több dolgot képes egy időben elvégezni. Mialatt egy felhasználói program fut, a számítógép olvasni tud egy lemezről és szöveget tud írni egy nyomtatóra. Ilyenkor a CPU programról programra kapcsol, futtatva azokat néhány tíz vagy száz milisec-ig. Ezt a gyors oda-vissza kapcsolást multiprogramozásnak nevezzük. Bár szigorúan véve a CPU minden pillanatban csak egy programot futtat, a felhasználóban a párhuzamosság illúzióját kelti. Ez az ún. látszatpárhuzamosság, amelyet meg kell különböztetnünk a többprocesszoros rendszerek (két vagy több CPU megosztva használja ugyanazt a fizikai memóriát) valódi párhuzamosságától. II.1.A processzus modell Ebben a modellben minden, a számítógépen futtatható szoftver (gyakran magát az operációs rendszert is beleértve) szekvenciális processzusok, vagy röviden processzusokk sorozatává szerveződik. A processzus egyszerűen egy végrehajtás alatt álló program, beleértve az utasításszámláló, a regiszterek és a változók aktuális értékét is.

7 Egy processzus három állapotban lehet: 1. Futó (az adott pillanatban éppen használja a CPU-t). 2. Futáskész (készen áll a futásra; ideiglenesen leállították, hogy egy másik processzus futhasson). 3. Blokkolt (bizonyos külső esemény bekövetkezéséig nem képes futni). Két oka lehet annak, hogy egy processzus blokkolódik: egyrészről teheti ezt azért, mert logikailag nem tudja folytatni (vagyis olyan bemenetre vár, amelyik még nem elérhető), másrészről az is lehetséges, hogy az operációs rendszer (egy kis időre) leállítja. A processzus modell megvalósításához az operációs rendszer egy táblázatot kezel, amit processzustáblázatnak nevezünk, processzusonként egy bejegyzéssel. Ez a bejegyzés minden információt tartalmaz a processzusra vonatkozóan (utasításszámláló, veremmutató, stb.), amit azért kell elmenteni, amikor a processzust futóról futáskész állapotba kapcsoljuk, hogy később úgy indulhasson újra a processzus, mintha soha nem állítottuk volna le. II.2.Processzusok kommunikációja A processzusoknak gyakra szükségük van az egymással való kommunikációra (InterProcess Communication, IPC). II.2.1.Versenyhelyzetek Azokat az eseteket, ahol kettő vagy több processzus olvas vagy ír megosztott adatokat, és a végeredmény attól függ, hogy ki és pontosan mikor fut, versenyhelyzeteknek nevezzük. Hogyan kerüljük el a versenyhelyzeteket? Amire szükség van, az a kölcsönös kizárás valamilyen módszer, amely biztosítja, hogy ha egy processzus megosztott fájlt vagy változót használ, a többi processzus tartózkodjon ettől a tevékenységtől. A programnak azt a részét, amelyben a megosztott memóriát használjuk, kritikus területnek vagy kritikus szekciónak nevezzük. Ha meg tudnánk oldani, hogy soha ne legyen két processzus a saját kritikus szekciójában, akkor elkerülhetnénk a versenyhelyzeteket. De ez még nem elegendő a korrekt és hatékony működéshez!

8 A jó megoldás négy feltétele: 1. Ne legyen két processzus egyszerre a saját kritikus szekciójában. 2. Semmilyen előfeltétel ne legyen a sebességekre vagy a CPU-k számára nézve. 3. Ne legyen olyan processzus, amelyik a kritikus szekcióján kívül futva blokkolhat más processzusokat. 4. Egy processzusnak se kelljen örökké várnia, hogy beléphessen a kritikus szekciójába. A legegyszerűbb megoldás az, hogy minden processzus letiltja az összes megszakítást, mihelyt belép saját kritikus szekciójába, és újra engedélyezi, mielőtt elhagyja azt. Probléma: egy processzus kikapcsolja a megszakításokat, és soha nem kapcsolja vissza. Ez a rendszer végét jelentheti. A többprocesszoros rendszereknél szintén probléma jelentkezne, ugyanis a megszakítások tiltás csak arra a CPU-ra vonatkozik, amelyik a tiltó utasítást végrehajtotta. Más részről a megszakítások tiltása gyakran nagyon hasznos (és főleg kényelmes) technika magán az operációs rendszeren belül, de nem megfelelő a felhasználói processzusok számára. A második kísérletben keressünk egy szoftver megoldást. Ehhez egy ún. zárolásváltozóra van szükségünk, melynek értéke 0 vagy 1, de kezdetben 0. Amikor egy processzus be akar lépni a saját kritikus szekciójába, először ezt vizsgálja meg. Probléma: egy processzus elolvassa a zárolásváltozót és látja, hogy értéke 0. Mielőtt be tudná állítani 1-re, egy másik processzus kerül ütemezésre, és beállítja a változót 1-re. Amikor az első processzus ismét futni kezd, ismételten beállítja 1-re a változót, így két processzus lesz egy időben a saját kritikus szekciójában. A harmadik megközelítés a szigorú váltogatás elvét veszi alapul. Ebben egy turn nevű változó nyomon követi, hogy ki lesz a következő, aki a kritikus szekcióba. A 0. processzus 0-nak találja az értékét, és belép a kritikus szekcióba. Az 1. processzus addig egy ciklusban várakozik, amíg a turn értéke 1 nem lesz (tevékeny várakozás). Általában tartózkodni kell ettől, mert pazarolja a CPU időt. Bár ez az algoritmus megóv minket a versenytől, mégsem számít komoly jelöltnek a 3. feltétel megsértése miatt. Kombinálva az egymás váltogatásának ötletét a zárolásváltozók és a figyelmeztető változók ötletével, Dekker holland matematikus volt az első, aki olyan szoftver megoldást talált ki a kölcsönös kizárás problémájára, amelyik nem igényelte a szigorú váltogatást.

9 1981-ben Peterson talált egy egyszerűbb módot a kölcsönös kizárás megvalósítására, így Dekker megoldása elavulttá vált. Lényege: enter-region, leave-region (a saját processzussám beállításával). Létezik olyan megoldás is, amely némi hardver segítséget igényel. Sok számítógép (főleg azok, amelyeket többprocesszorosra terveztek) rendelkezik egy TSL (Test and Set Lock) utasítással, amely lényegében a művelet befejezéséig megtiltja más CPU-knak a memória elérését. Probléma mindkettőnél: tevékeny várakozást igényel, valamint a magas ill. alacsony prioritású processzusokkal előidézhető az ún. fordított prioritás probléma. Illusztrálva a helyzetet, tegyük fel, hogy egy L alacsony prioritású processzus a kritikus szekciójában van, míg egy H magas prioritású processzus futáskész állapotba kerül. H tevékeny várakozásba kezd, de L-re (alacsony prioritása miatt) soha nem kerül sor, amíg H fut. Így L soha nem tudja elhagyni a kritikus szekcióját. Most pedig nézzünk néhány olyan megoldást, amelyek nem pazarolják a CPU időt. Az egyik legegyszerűbb a SLEEP (alvás) és WAKEUP (ébredés) pár. A SLEEP egy rendszerhívás, ami a hívót blokkolja, amíg egy másik processzus fel nem ébreszti. A WAKEUP hívásnak a felébreszteni kívánt processzus a paramétere. A gyártó-fogyasztó probléma Lásd Tanenbaum oldal. Feladat: Tegyük fel, hogy van egy üzenetküldéses, postaládákat használó rendszerünk. A processzusok nem blokkolódnak, ha egy tele ládába küldenek, vagy egy üresből akarnak üzenetet kivenni. E helyett egy hibakódot kapnak vissza. A processzusok a hibakódra úgy reagálnak, hogy újra és újra próbálkoznak, amíg a művelet sikeres nem lesz. Vezethet-e ez a séma versenyhelyzetekhez? II.3.Klasszikus IPC problémák A következőkben három érdekes, sokat elemzett problémát vizsgálunk meg. II.3.1.Az étkező filozófusok problémája

10 1965-ben Dijkstra felvetett és megoldott egy szinkronizációs problémát, amelyet étkező filozófusok problémának nevezett el. A probléma a következő: öt filozófus ül egy kerek asztal körül. Mindegyik filozófusnak van egy tányér spagettije. A spagetti olyan csúszós, hogy egy filozófusnak két villára van szüksége, hogy megegye. Minden egymás melletti tányér között van egy villa. A filozófusok élete egymást váltogató evésből és gondolkodásból áll. Amikor egy filozófus éhes lesz, megpróbálja megszerezni a bal és jobb oldalán lévő villát, egyszerre csak egyet, tetszőleges sorrendben. Ha sikerül mindkét villát megszereznie, akkor eszik egy ideig, majd lerakja az evőeszközöket és gondolkodik. Kulcskérdés: tudunk-e olyan programot készíteni mindegyik filozófus számára, amelyik azt csinálja, amit elvárunk és soha nem akad el? A nyilvánvaló megoldás (próbálja megszerezni a bal oldalon lévő villát, majd ha ez megvan, szerezze meg a job oldalon lévőt) sajnos hibás. Ha ugyanakkor szerzi meg mind az öt filozófus a bal oldali villát, akkor nem lesz villa a jobb oldalon és holtpont alakul ki. Az sem segít, ha várakozunk. Véletlen ideig történő várakozás nem hoz garantált sikert. A korrekt megoldás bináris szemaforokat használ. II.3.2.Az olvasók és írók probléma Másik híres probléma az olvasók és írók probléma, amelyik egy adatbázis elérését modellezi. Képzeljünk el egy olyan helyfoglalási rendszert sok versengő processzussal, amelyek mind olvasni és írni szeretnének. Az elfogadható, hogy több processzus egyidejűleg olvasson az adatbázisból, de ha egy processzus írja az adatbázist, akkor más processzusoknak (még az olvasóknak sem) szabad elérniük az adatbázist. A kérdés: hogyan programozzuk az olvsókat és írókat. Egyik megoldás: számláljuk az olvsókat, majd ha végeztek, csökkentjük a számláló értékét. Ha eléri a 0-át, akkor jön az író. Probléma: mi van, ha folyamatosan jönnek az olvasók? Amíg egy is van, nem lehet írni az adatbázisba... Ha felfüggesztjük az olvasókat az érkező író mögött, akkor kisebb hatékonysággal, de megbízhatóan működik a dolog. II.3.3.Az alvó borbély probléma Megint egy másik klasszikus IPC probléma a borbélynál fordul elő. A fodrászüzletben egy borbély van, egy fodrászszék, és n szék a várakozó vendégeknek. Ha éppen nincs vendég, akkor a orbély leül a fodrászszékbe és elalszik. Ha egy vendég érkezik, fel kell ébresztenie. Ha további vendégek érkeznek, míg a borbély egy vendég haját vágja, akkor vagy leülnek (ha van üres szék) vagy elmennek (ha minden szék foglalt). Megoldásunk három szemafort használ: customers (a várakozó vendégeket számolja, a

11 fodrászszéken ülő kivételével), barbers (az unatkozó borbélyok száma, értéke 0 vagy 1 lehet) és mutex (a kölcsönös kizárásra használunk. II.4. Processzus ütemezése Amikor egynél több processzus képes futni, akkor az operációs rendszernek el kell döntenie, hogy melyik fusson először. Az operációs rendszer eme döntéshozó részét, ütemezőnek nevezzük, az erre a célra használt algoritmust pedig ütemezési algoritmusnak.

12 Amikor átgondoljuk, hogy mit is próbál elérni az ütemező, különböző feltételek juthatnak eszünkbe. A lehetőségek közül néhány: 1. Pártatlanság biztosítani, hogy minden processzus megkapja az őt megillető CPU-részt. 2. Hatékonyság a CPU-t 100 százalékig kihasználni. 3. Válaszidő minimalizálni az interaktív felhasználók válaszidejét. 4. Áthaladási idő minimalizálni azt az időt, amíg a kötegelt felhasználók eredményre várnak. 5. Áteresztőképesség maximalizálni az óránként végrehajtott feladatok számát. Egy kis gondolkodással láthatjuk, hogy ezen célok ellentmondásosak.bármely ütemezési algoritmus, amelyik előnyben részesít egy feladatosztályt, megsért egy másikat. A rendelkezésre álló CPU idő is véges. Ahhoz, hogy egyik felhasználónak többet adjunk, a másiknak kevesebb jut. II.4.1.Round robin ütemezés Az egyik legrégebbi, legkorrektebb és legszélesebb körben használt algoritmus a round robin. Minden processzus kap egy időintervallumot, amit időszeletnek nevezünk (amely alatt futhat). Ha az időszelet végén a processzus még fut, akkor a következő kapja meg a vezérlést. Amikor a processzus felhasználja az időszeletét, a lista végére kerül. Probléma: az időszelet hossza. Az időszelet túl kicsire állítása túl sok processzusátkapcsolást okoz, és csökken a CPU hatékonysága, de túl nagyra állítása gyors interaktív kérdésekre lassú válaszadást okozhat. (Az időszelet 100 ezredmásodperc körüli értéke gyakran ésszerű kompromisszum.) II.4.2.Prioritásos ütemezés Még egy egyfelhasználós PC-n is lehet egyik processzus fontosab, mint a másik. A kézenfekvő módszer lehet az, hogy minden processzushoz egy prioritást rendelünk. Ilyenkor azonban arról is gondoskjodni kell, nehogy a magas prioritású processzusok végtelen ideig fussanak. A megoldás: az ütemező minden óramegszakításnál csökkenti az éppen futó processzus prioritását. Egy mási kegyszerű algoritmus, amely jó szolgálatot tehet az I/O igényes processzusnak: a processzus prioritását 1/f-re állítja, ahol f az utolsó időszeletből felhasznált idő. Gyakran kényelmes processzusok csoportjait prioritási osztályokba sorolni. És prioritásos ütemezést használni az osztályok között, de round robin ütemezést ey osztályon belül. II.4.3.Többszörös sorok

13 A legmagasabb osztályan lévő processzusok egy időszeletig futnak. A következő osztályban lévők két időszeletig, az ezután követkeő processzusok pedig négy időszeletig futnak. Valahányszor egy processzus elhasználja a számára biztosított időszeletet egy osztállyal lejjebb kerül. Pl. Egy 100 időszelet számolási időt igénylő processzus először 1, mjad 2, 4, 8, , végül 64 (de ebből csak 37-et használ fel) időszeletet kap. Ily módon 7 cserével kiváltható a round robin 100 (!) cseréje. II.4.4.A legrövidebb feladatot először A fenti algoritmusok többségét interaktív rendszerekbe tervezték. Most nézzünk egy rendszert, amely előre ismert futási idővel rendelkező kötegelt feladatok feldolgozására alkalmas.amikor sok egyformán fontos feladat van a bemenő sorban kezdésre várva, akkor az ütemezőnek a legrövidebb feladatot elvet kell használnia. Pl. A, B, C és D futásideje rendre 8, 4, 4 és 4 perc. A megadott sorrendben futtatva az áthaladási idő 8, 12, 16 és 20 perc. Az átlag: 14 perc. A legrövidebb feladatot először elvet használva az áthaladási idő 4, 8, 12, 20 perc. Az átlag: 11 perc. II.4.5.Garantált ütemezés Az ütemezés egy teljesen más megközelítése az, ha n felhasználó van bejelentkezve, akkor a CPU erejének kb. 1/n részét fogja megkapni. Ehhez a rendszernek nyomon kell követnie, hogy egy processzus mennyi CPU-t kapott létrehozása óta. Ezután mindegyikhez kiszámítja a járó CPU mennyiségét (a létrehozása óta eltelt időt osztja n-nel). Mivel minden processzusnak ismerjük az eddig elhasznált CPU idejét, könnyen kiszámíthó az aktuálisan felhasznált és a processzusnak járó CPU arányát. Az algoritmus ezután a legkisebb arányszámmal rendelkező processzust fogja futtatni. II.4.6.Sorsjáték -ütemezés Az alapötlet az, hogy minden processzusnak sorsjegyet adunk a különböző rendszererőforrásokhoz Ha egy ütemezési döntést kell hozni, egy sorsjegyet véletlenszerűen kiválasztunk, és az a processzus kapja meg az erőforrást, amelyiknél a sorsjegy van. Amikor ezt CPU ütemezésre használjuk, akkor a rendszer másodpercenként tart sorsolást, vagyis minden nyertes 20 ezredmásodperc CPU időt kap nyereményként. A fontosabb processzusok több sorsjegyet kaphatnak, hogy növeljék a nyerési esélyeiket. A szabály világos: ha egy processzus a sorsjegyek f-ed részét birtokolja, akkor a kérdéses erőforrás kb. f-ed részét meg fogja kapni.

14 II.4.7.Valós idejű ütemezés Egy valós idejű rendszerben az idő alapvető szerepet játszik. A valós idejű rendszereket két kategóriába sorolhatjuk: szigorú valós idejű (abszolút határidők vannak, amelyeket kötelező betartani) és lágy valós idejű rendszerek (egy határidő esetleges elmulasztása tolerálható). Egy külső esemény észlelésekor az ütemező feladata a processzusok olyan ütemezése, hogy minden határidő teljesüljön. Az események, melyekre egy valós idejű rendszernek válaszolnia kell, tovább bonthatók: periodikusak (rendszeres intervallumonként) és aperiodikusak (megjósolhatatlanok). A valós idejű ütemező algoritmusok dinamikusak vagy statikusak lehetnek. Tekintsünk át röviden néhány dinamikus algoritmust. A klasszikus megoldást állandó arány algoritmusnak nevezzük. Előzetesen, a kiváltó esemény előfordulási gyakoriságának arányában minden processzushoz hozzárendel egy prioritást. Például, a 20 ezredmásodpercenként futó 50-et, a 100 ezredmásopercenként futó 10-et kap. Az ütemező mindig a legmagasabb prioritású futáskész processzust futtatja. Másik népszerű algoritmus a legkorábi határidő először. Egy harmadik megoldás először kiszámítja minden processzus felesleges időmennyiségét, ezt lazaságnak nevezzük. A legkisebb lazaság algoritmus azt a processzust választja, amelyik a legkisebb felesleges időmennyiséggel rendelkezik. II.4.8.Kétszintű ütemezés Lásd Tanenbaum oldal! Feladat: Öt kötegelt program (A-tól E-ig) érkezik a számítóközpontba szinte teljesen egy időben. Becsült futásidejük 10, 6, 2, 4 és 8 perc. Az előre megállapított prioritásaik sorrendben 3, 5, 2, 1 és 4. A legnagyobb prioritás az 5. Ak alábbi ütemezési algoritmusok mindegyikére állapítsa meg az átlagos áthaladási időt. (a) round robin (b) prioritásos (c) érkezési sorrendben (d) legrövidebb először II.5.Az operációs rendszer elindulása (A boot-folyamat)

15 A betöltés általában egy másneslemezről (hajlékonylemez vagy merevlemez) történik, de manapság a BIOS-ok jelentős része támogatja a CD-ről ill. DVD-ről való indítást. Amikor a rendszer elindul, a hardver (pontosabban egy ROM-ban lévő program) beolvassa az indítólemez első szektorát és végrehajtja az ott talát programot. Egy partíciók nélküli hajlékonylemezen az első szektor az indíóblokk, amely betölti az indítóprogramot (boot). A merevlemezek particionáltak, és az első szektorban lévő program beolvassa a szintén az első szektorban elhelyezett partíciós táblát, majd betölti és végrehajtja az aktív partíció első szektorát. Egy partíciónak általában ugyanolyan a szerkezete, mint egy particionálás nélküli hajlékonylemeznek, azaz van egy indítóblokkja, amely betölti az indítóprogramot. A valódi helyzet egy kicsit bonyolultabb is lehet, mert egy partíció alpartíciókat is tartalmazhat. Ebben az esetben a partíció első szektora az alpartíciók partíciós tábláját tartalmazó elsődleges indítórekord (master boot record) lesz. A boot az operációs rendszer betöltésénél kicsit többet tud, mert ez egy felügyelő program is egyben, melynek segítségével a felhasználó megváltoztathat, beállíthat és elmenthet különféle paramétereket. A boot a partíciója második szektorában keresi az érvényben lévő paramétereket. A boot nem az operációs rendszer része, de elég okos ahhoz, hogy a fájlrendszer adatszerkezeteit használja és megtalálja az operációs rendszert a lemezen. II.6.Megszakításkezelés Amikor egy CPU egy processzus futása alatt megszakítást érzékel, akkor egy vermet hoz létre, amit a megszakítás kiszolgálása közben használ. A CPU automatikusan betesz néhány kulcsfontosságú regisztert az új verembe, ezek között azokat is, amelyek a megszakított processzus vermének és utasításmutatójának visszaállításához szükségesek. A megszakításkezelő programrész futása kezdetén ezt a processzus táblában elhelyezkedő területet használja veremnek, eddigre a megszakított processzushoz való visszatéréshez szükséges információk nagy része már elmentésre került. Tehát egy megszakítás megállítja a futó processzust, a megszakítás kiszolgálásának befejeződése pedig úrjaindít egy processzust, ez esetleg különbözhet a legutoljára megállítottól. A CPU megszakítás érzékelése esetén letiltja a megszakításokat. Ez biztosítja, hogy semmi nem történhet, ami a processzus táblában lévő verem túlcsordulását okozhatná. A szoftver megszakításokat ugyanúgy kezeljük, mint a hardver megszakításokat, természetesen ekkor a megszakításleíró tábla (Interrupt Descriptor Table) indexe az utasításban található nnn paraméter, és nem egy megszakításvezérlő áramkör szolgáltatja.

16 Összefoglalás: Amikor megszakítás történik, akkor a kernel létrehoz és elküld egy üzenetet annak a taszknak, amelyik a megszakítást okozó eszközt kezeli. Például a lemez taszk hívja a receive eljárást és blokkolódik, miután a lemezvezérlő hardvernek átadott egy adatblokk beolvasását kezdeményező parancsot. A vezérlő megszakítást generál, amikor az adat készen áll. Az alacsony szintű szoftver ekkor összeállít egy üzenetet a lemeztaszk számára és futtathatóvá teszi. Amikor az ütemező a lemeztaszkot választja ki futásra, akkor megkapja és feldolgozza az üzenetet. A megszakításkezelő maga is végezhet munkát közvetlenül, mint ahogy az időzítő kezelője megszakítás után frissíti az időt. Megszakítás után processzusváltás következhet be. Ha egy processzus futása megszakad, akkor egy verem jön létre a hozzátartozó processzustábla bejegyzésben és a folytatáshoz szükséges minden információ ebbe a verembe kerül. Bármelyik processzust újra futtatható állapotba lehet hozni, ha a veremmutatót a processzustábla bejegyzésére állítjuk, ebből újratöltjük a regisztereket és végrehajtunk egy iretd utasítást. Az ütemező dönti el, hogy melyik processzus tábla bejegyzés címe kerül a veremmutatóba. A kernel futása közben is történnek megszakítások. A CPU ezt felismeri és ekkor a kernel vermét használja a processzustábla verem helyett. Így egymásba ágyazott megszakítások is lehetségesek, amikor a későbbi kiszolgálása befejeződőtt, folytatódhat az egy szinttel alatta lévő végrehajtása. Az összes megszakítás kiszolgálása után folytatódhat valamelyik processzus végrehajtása.

17 3. Bevitel/Kivitel Az operációs rendszer egyik fő feladata az I/O (beviteli/kiviteli) eszközök vezérlése. Az eszközök felé parancsokat kell kiadnia, kezelnie kell a megszakítási kéréseket és a hibákat. Továbbá gondoskodnia kell az eszközök és a rendszer többi része közötti kapcsolódási felületről, aminek egyszerűnek és könnyen használhatónak kell lennie. A bővítések érdekében az eszközök közötti kapcsolatok megvalósítására egységes módszert kell biztosítania (eszközfüggetlen kapcsolat). A teljes operációs rendszer egy jelentős hányadát a Bevitel/Kivitel kódja teszi ki. Először tekintsük át röviden az I/O hardver bizonyos alapelveit I/O eszközök Az I/O eszközöket durván két csoportba sorolhatjuk: blokkos eszközök és karakteres eszközök. Blokkos eszközön olyan eszközt értünk, amely az információt adott méretű blokkokban tárolja, mindegyiket saját címmel. A szokásos blokkméret tartománya 512 bájt és bájt között van. Az ilyen eszközök lényeges tulajdonsága, hogy az egyes blokkok írhatóak és olvashatóak a többi blokktól függetlenül. A leggyakrabban használt blokkos eszköz a lemez. Az I/O eszközök másik típusát a karakteres eszközök alkotják. Egy karakteres eszköz kibocsátja vagy fogadja a karakterek sorozatát anélkül, hogy bármilyen blokkszerkezetet figyelembe venne. Az ilyen eszköz nem címezhető, és a keresési műveletet sem tudja végrehajtani. Nyomtatók, egerek és a legtöbb eszköz, ami nem lemez jellegű, karakteres eszköznek tekinthető. Bizonyos eszközök nem illeszkednek egyik osztályhoz sem: órák (nem címezhetők blokkonként, de nem generálnak és fogadnak karaktersorozatot sem) és a memórialeképzésű képernyők (terminálok) Eszközvezérlők Az I/O egységek mechanikus és elektromos összetevőkből állnak. Az elektromos komponenst, eszközvezérlőnek vagy adapternek nevezik. A PC-knél ez leggyakrabban egy nyomtatott áramköri lap alakjában jelenik meg, ami a számítógép alaplapjához kapcsolt. A mechanikus komponens maga az eszköz. A vezérlőkártyán rendszerint van egy csatlakozó, amely kábellel hozzákapcsolható az eszközhöz. A legkisebb számítógépek a CPU és a vezérlők közötti kapcsolat megvalósítására egysínű (vagy busz) modellt alkalmaznak. A vezérlő és az eszköz közötti kapcsolódási felület gyakran nagyon alacsony szintű. Egy lemezt például lehet olyan formátumúra hozni, amelyben az 512 bájtos pálya 16 szektorra bontott. Amit a meghajtó valójában létrehoz, az egy bitsorozat, amely egy előszóval kezdődik, utána egy 4096 bites szektor van és végül egy ellenőrző összeg, amit hibajavító kódnak (Error-Correcting Code, röviden

18 ECC) neveznek. Az I/O kapuknál sok vezérlő megszakítással jelez a CPU felé, amikor a regisztereinek olvasása vagy írása már megtörtént. Egy megszakítás, első megközelítésben, egy elektromos jelenségként fogható fel. Egy hardver megszakításkérés (Interrupt ReQuest, IRQ) valójában egy fizikai bemenet a megszakítást vezérlő lapka számára. Ezeknek a bemeneteknek a száma korlátozott; a Pentium-os PC-knél csak 15 áll az I/O eszközök rendelkezésére. Néhány vezérlő a rendszer alaptestében mereven behuzalozott, mint például a billentyűzetvezérlő. Egy olyan vezérlő esetében, ami be van dugva a hátlapon levő csatlakozóblokkba, az eszközvezérlőn levő váltókapcsolók (jumperek) vagy hardverkapcsolók révén az eszköz néha kiválaszthatja, hogy melyik IRQ bemenetet használja, és így az ütközések elkerülhetők (a PnP eszközöknél ellenben az IRQ szoftveres beállítása lehetséges). A megszakítást vezérlő lapka minden egyes IRQ bemenetet egy megszakítási vektorba képez le, amely meghatározza a megfelelő megszakítást kiszolgáló szoftvert. Egy parancs elfogadása esetén a CPU magára hagyhatja a vezérlőt és foglalkozhat más feladat végrehajtásával. A parancs végrehajtása után a vezérlő egy megszakítást hoz létre abból a célból, hogy az operációs rendszer szerezze meg (vissza) a CPU irányítását és ellenőrizze a művelet eredményét Közvetlen memória-elérés (DMA) Sok vezérlő, különösen a blokkos eszközöké, támogatja a közvetlen memória-elérést vagy DMAt (Direct Memory Access). A DMA működésének megértéséhez nézzük meg, hogyan zajlanak a lemezes olvasások, ha nincs DMA. A vezérlő először beolvassa a meghajtóból a blokkot (egy vagy több szektort), amit úgy tesz, hogy bitenként folytatólagosan olvas a meghajtóból a saját belső pufferébe, amíg egy teljes blokk kialakul. Ezután kiszámolja a hibajavító kódot, amivel igazolja, hogy nem fordult elő olvasási hiba. Ezután egy megszakítást idéz elő. Amikor az operációs rendszer beindítja a futtatást, akkor a lemez egy blokkját a vezérlő pufferéből olvassa be egy ciklus végrehajtásával, amelyben minden egyes iterációs lépésben egy bájtot vagy szót olvas a vezérlő regiszteréből, és azt a memóriában tárolja. Ez a módszer pazarolja a CPU-időt! A DMA-val az volt a szándék, hogy a CPU megszabaduljon ettől az alacsony szintű munkától. Előfordulhat, hogy a vezérlő csak minden második blokkot tud beolvasni. Egy teljes pályavonal beolvasásához ekkor a lemez két teljes fordulata szükséges, egy a páratlan blokkok és egy a páros blokkok számára. Blokkok átugrását, mellyel a vezérlő időhöz jut, hogy adatot mozgasson át a memóriába, közéillesztési (interleaving) módszernek nevezik. Amikor a lemez formázása történik, akkor a blokkokhoz a közéillesztési metódusnak megfelelő szám van rendelve. A blokkok ilyen sorszámozása lehetővé teszi, hogy az operációs rendszer az egymást követő sorszámú blokkokat

19 olvassa és elérje a hardver melletti maximális gyorsaságot Az I/O szoftver alapelvei Az I/O szoftver alapgondolata, hogy a szoftver rétegek sorozatából épüljön fel úgy, hogy az alacsonyabb rétegek által a magasabb szintű rétegek elől el legyenek rejtve a hardver sajátosságai. A magasabb rétegek feladata az is, hogy a felhasználó felé egy kellemes, standard kapcsolódási felületet biztosítson. A kulcsfogalom az I/O szoftver tervezésénél az eszközfüggetlenség. Ez azt jelenti, hogy legyen lehetőség olyan program írására, amely olvashat lemezen lévő állományokat anélkül, hogy a programot módosítani kellene különböző típusú eszközök esetén. Az eszközök használata lehet megosztott (pl. lemezek) vagy monopol (szalagmeghajtók). A célok megvalósítása érdekében az I/O szoftver négy rétegre tagolódik: III.Megszakításkezelők (alsó) IV.Eszközmeghajtók. V. Eszközfüggetlen operációs rendszer szoftver. VI.Felhasználó szintű szoftver (felső).

20 4. Memóriagazdálkodás A memória egy fontos erőforrás, így gondosan kell vele bánni. Ideális esetben a memória végtelenül nagy és gyors, valamint nem felejtő (azaz áramkimaradás esetén is megőrzi tartalmát). Ezen kívül az sem ártana, ha olcsó lenne. Sajnos a technika (egyelőre) nem képes ilyen memória előállítására, ezért a legtöbb számítógépben a memória hierarchikus szerveződésű. Létezik egy kicsi, nagyon gyors, drága és felejtő cache memória (gyorsítótár); néhány vagy néhány szám MB közepes sebességű és árú, felejtő központi memória (RAM); valamint néhány GB lassú, olcsó és nem felejtő lemezes tároló. Az operációs rendszer azon részét, amely a hierarchikus memória kezelését végzi, memóriakezelőnek nevezzük. A feladata az, hogy nyilvántartsa a szabad és foglalt memóriarészeket, memóriát foglaljon a programoknak, illetve memóriát szabadítson fel, amikor már nincs szükség rá, valamint vezérelje a cserét a központi memória és a lemez között, ha a központi tár már túl kicsi a programok befogadásához. A következőkben megvizsgáljuk a különböző memóriakezelési algoritmusokat a legegyszerűbbtől a bonyolultabbak felé haladva Alapvető memóriakezelés A memóriakezelő algoritmusokat két csoportra oszthatjuk: amelyek végrehajtás közben mozgatják a programrészeket a központi tár és a lemez között (lapozás, szegmentálás) és azok amelyek nem Egy program futtatása A legegyszerűbb memóriakezelési módszer, hogy egy időben csak egy programot futtatunk a memóriát megosztva az operációs rendszer és a program között. Itt is (legalább) háromféle változat létezik: az operációs rendszer a memória alacsony címein található a felső címeken a ROM-ban az eszközmeghajtók a memória magas címein a ROM-ban, az operációs rendszer maradék része az alacsony címeken a RAM-ban (MS-DOS). Ha egy rendszer ilyen, akkor egy időben csak egy program futhat. Amikor a felhasználó begépeli a parancsot, az operációs rendszer beölti az igényelt programot a lemezről és végrehajtja. Miután a

21 program befejeződik, az operációs rendszer újabb parancsra vár. Amikor megkapja a parancsot, betölti az új programot, felülírva az előzőt Multiprogramozás rögzített méretű partíciókkal Az időosztásos rendszerekben egyszerre több program tartózkodik a memóriában; amíg az egyik egy I/O művelet befejezésére vár, addig egy másik használhatja a központi egységet. Így a multiprogramozás növeli a CPU kihasználtságát. A multiprogramozás megvalósításának legegyszerűbb módja, hogy felosztjuk a memóriát n (lehetőleg nem egyenlő méretű) szeletre. Amikor egy végrehajtandó program érkezik, a rendszer berakja annak a partíciónak a várakozási sorába, amelyik a legkisebb azok közül, amelyekbe belefér a program. Mivel a partíciók mérete rögzített, elvész a partíciónak az a része, amelyet a program nem használ fel. Ennek a módszernek az a hátránya (az előzőn túl), hogy előfordulhat olyan eset, hogy a nagy partíció várakozási sora üres, de a kisebb partícióra sok program várakozik. A módszer két változata: több várakozási sor van a különböző partíciókhoz. csak egyetlen várakozási sor van. Amikor egy partíció kiürül, az a program töltődik be, amelyik belefér és a sorban a legelső. Ezt a rögzített partíciókkal bíró rendszert éveken keresztül használták az OS/360-ban az IBM nagygépeken. Napjainkban kevés operációs rendszer támogatja ezt a modellt Csere Az időosztásos vagy grafikus felületű rendszereknél gyakran nincs elég memória az összes aktív program befogadásához, így a felesleges programokat a lemezen kell tartani, és dinamikusan kell betölteni futtatásra. A memóriakezelésnek két általános, (részben) az adott hardvertől függő megközelítése van: Csere: a programokat teljes egészükben mozgatja a memória és a lemez között. Virtuális memória: akkor is engedi a programokat futni, ha csak egy részük van a központi memóriában. A rögzített partíciójú rendszerekhez képest az a fő különbség, hogy itt a partíciók száma, helye és mérete dinamikusan változik, ahogy a programokat mozgatjuk a központi tár és a lemez között. A csere esetében jobb a memória kihasználtsága, de bonyolultabb a lefoglalás és felszabadítás.

22 Amikor a csere sok lyukat hoz létre a memóriában, a programok mozgatásával egy nagy lyukká lehetne összeolvasztani ezeket a lyukakat (memóriatömörítés). Nagy processzorigénye miatt általában nem használják. Amikor az operációs rendszer létrehoz vagy behoz egy folyamatot, döntést kell hoznia, hogy mennyi memóriát foglaljon le a program számára. Ha a programot egy rögzített mérettel hozza létre, és ez a méret nem változik, akkor egyszerű a dolog, pontosan ennyi memóriát kell lefoglalni. Ha program mellett egy lyuk van a memóriában, akkor ezt lefoglalhatja és hozzáadhatja a program memóriaterületéhez. Ha a program mellett egy másik program van a memóriában, akkor az operációs rendszer elmozgathatja a növekvő programot egy nagyobb lyukba, esetleg egy vagy több programot kirakhat a lemezre, hogy elegendő helyet csináljon. Ha a program már nem tud tovább nőni a memóriában, és a lemezen kijelölt rész is tele van, akkor a programnak várni vagy abortálni kell. Ha várható, hogy a legtöbb program növekszik futás közben, akkor érdemes egy külön memóriarészt foglalni (a növekvő résznek). Ha a programnak két növekvő szegmense (adatszegmens (heap) és veremszegmens (stack)), a két szegmens között levő memória egyszerre mindkettőhöz tartozik. A veremszegmens felülről lefelé, az adatszegmens alulról felfelé terjeszkedik. Memóriakezelés bittérképpel Amikor dinamikusan foglalunk memóriát, akkor azt az operációs rendszernek kezelnie kell. Két módszer van a memóriahasználat nyilvántartására: A bittérképes módszernél a memória néhány kilobájtnyi allokációs egységekre van osztva. Minden ilyen egységhez tarozik egy bit, ami 0, ha az egység szabad és 1, ha az egység foglalt. Az allokációs egység mérete fontos: ha az egység kicsi, akkor a bittérkép nagy. Ha az allokációs egység nagy, akkor a bittérkép kicsi, de jelentős mennyiségű memória megy veszendőbe a programok utolsó egységéből. Probléma: ha egy k méretű programot akarunk a memóriába rakni, akkor a memóriakezelőnek k darab egybefüggő 0 bitet kell keresnie a térképen. Ez lassú művelet. Memóriakezelés láncolt listákkal A memóriakezelés másik módja, hogy láncolt listába fűzzük a szabad és a foglalt szegmenseket (a

23 programokat és a lyukakat egyaránt). A listának minden eleme a hozzá tartozó lyuk vagy programszegmens kezdőcímét, hosszát és a következő listaelem címét tartalmazza. Kezdőcím szerint rendezett listában számos algoritmus használatos a memória lefoglalására az új vagy a lemezről éppen behozott programok számára (feltesszük, hogy a memóriakezelő tudja, hogy mennyi memóriát kell elfoglalnia): First Fit: a legegyszerűbb algoritmus. A memóriakezelő addig keres a szegmensek listájában, amíg meg nem találja az első megfelelő méretű lyukat. Ezt a lyukat két részre vágja: az egyik a programé lesz, a másik megmarad szabadnak. A First Fit a leggyorsabb algoritmus, mert olyan keveset keres, amennyit csak lehet. Next Fit: a First Fithez hasonlóan működik, kivéve azt, hogy megjegyzi, hol találta az előző megfelelő lyukat. Innen indul a következő keresés. A Next Fit kicsit rosszabb teljesítményű, mint a First Fit. Best Fit: az egész listát végigkeresi, és a legkisebb alkalmas lyukat adja meg. A Best Fit lassabb, mint a First Fit, mert minden alkalommal átnézi az egész listát. Meglepetésre a First Fitnél és a Next Fitnél több memóriát veszteget el, mert hajlamos arra, hogy kicsi, használhatatlan lyukakat formáljon a memóriában. Worst Fit: a legnagyobb lyukat választja ki, így a szabadon maradt lyukdarab elég nagy ahhoz, hogy használható legyen. Szimulációkkal igazolták, hogy a Worst Fit nem olyan jó, mint a többi eljárás. Quick Fit: a leggyakrabban kért méretekhez külön lyuklistákat épít. Pl. egy lista a 4KB-os, egy másik a 8KB-os, egy harmadik pedig a 12KB-os lyukaknak. A Quick Fit nagyon gyorsan megtalálja a megfelelő méretű lyukat, de megvan ugyanaz a hátránya, mint a többi méret szerint rendezett listának.

24 4. 3. Virtuális memória Sok éve már, hogy az emberek először szembekerültek azzal a problémával, hogy a programok túl nagyok voltak, és nem fértek bele a rendelkezésre álló memóriába. Gyakran alkalmazott módszer volt a programok rétegekre darabolása (overlays). Az operációs rendszer a rétegeket a lemezen tartotta, és akkor hozta be, ha szükségesek voltak. Bár a program futása alatt a rétegek mozgatása a lemez és a memória között az operációs rendszer feladata, a programozónak kellett rétegekre darabolni a programot. Mivel ez időrabló és unalmas munka, kitalálták, hogyan lehet az egészet az operációs rendszerre bízni. Az erre kifejlesztett módszert virtuális memóriának nevezik. A virtuális memória mögött álló ötlet az, hogy a program, az adat és a verem együttes mérete meghaladhatja a fizikai memória mennyiségét. Az operációs rendszer csak a program éppen használt részét tartja a memóriában, a többi lemezen van. A virtuális memória a több programot futtató rendszereknél is működik, ekkor több program darabjai vannak a memóriában. Lapozás A virtuális memóriát használó rendszerekben leggyakrabban a lapozás technikáját alkalmazzák. Utasítás: MOV REG, 1000 Jelentése: a REG regiszterbe másolódik az 1000-es memóriarekesz tartalma. Ezeket a program által generált virtuális címeknek, az egészet pedig virtuális címtérnek nevezik. A virtuális címek nem kerülnek közvetlenül a memóriabuszra, ehelyett a memóriakezelő egységbe (MMU, Memory Management Unit) kerülnek, ami a virtuális címeket képezi le fizikai címekre. A következő ábra erre a leképezésre mutat egy egyszerű példát. A virtuális címek 16 bitesek, 0-tól 64 KB-ig tudnak címezni. A gépnek azonban csak 32 KB memóriája van. A program teljes egészében a lemezen van, és csak azok a részek töltődnek be, amelyekre szükség van. A virtuális címteret lap (page) nevű egységekre osztják, ennek megfelelő egység a fizikai memóriában a lapkeret. A lapok és a lapkeretek mindig pontosan egyforma méretűek. Ebben a példában ez 4 KB, a létező rendszerekben a lapméret 512 bájt és 64 KB közé esik (ami 16 virtuális lapot és 8 lapkeretet eredményez). A jelenlegi rendszerekben egy Jelenlét/hiány bit jelzi, hogy a lap leképezhető-e vagy sem. Mi történik, ha a program egy olyan lapra hivatkozik, ami nincs a fizikai memóriában? Az MMU észleli, hogy a lap nincs a memóriában, és egy laphiba nevű megszakítást okoz. Az operációs rendszer vesz egy lapkeretet, a tartalmát kiírja a lemezre, behozza a hivatkozott lapot a lemezről, módosítja a laptérképet, majd a megszakítást okozó utasítástól folytatja a program végrehajtását. A lapszámot a laptábla indexeként használjuk, az adott virtuális laphoz tartozó bejegyzést mutatja

25 meg. Laptáblák A laptábla célja az, hogy a virtuális lapokat lapkeretekre képezzük le. Két probléma: a laptábla nagyon nagy lehet a leképezésnek gyorsnak kell lennie Az első pont abból következik, hogy a modern számítógépek legalább 32 bites virtuális címeket használnak. 4 KB-os lapméretnél a címtér több mint egymillió lapból áll. A gyorsaság azért szükséges, mert a leképezést minden memóriahivatkozásnál végre kell hajtani (különben fellép az üvegnyakhatás). A következőkben néhány nagyobb teljesítményű változatot tanulmányozunk. Többszintű laptáblák A helyett, hogy egy nagy laptábla állandóan a memóriában legyen, sok rendszerben többszintű laptáblát alkalmaznak. A többszintű laptáblás módszer titka az, hogy nem tart bent minden laptáblát egyszerre a memóriában, főként azokat nem, amelyekre nincs szükség. TLB Címfordítási gyorsítótár A megoldás azon az észrevételen alapszik, hogy a programok legtöbb hivatkozása a lapok egy kis részhalmazára történik, így az ezekhez tartozó laptábla-bejegyzéseket gyakran, a többit ritkábban használjuk. A megoldás az, hogy egy kis hardvereszközzel szerelték fel a gépeket, ami a laptábla megkerülésével képezi le a logikai címeket a fizikai címekre. A TLB-nek (Translation Lookaside Buffer, címfordítási gyorsítótár) vagy asszociatív memóriának hívják. A TLB az MMU-ban található és néhány bejegyzést tartalmaz. Mindegyik bejegyzés egy lap adatait tartalmazza: a virtuális lapszám, a módosítási bit, a védelmi kód és a lapkeret száma, ahol a lap van. Egy további bit jelzi, hogy a bejegyzés érvényes (azaz használt) vagy nem. Vizsgáljuk meg, hogyan működik a TLB. Amikor az MMU egy virtuális címet kap, akkor először megvizsgálja, hogy a lap száma benne van-e a TLB-ben. A vizsgálat minden bejegyzésre egyidejűleg (párhuzamosan) zajlik. Ha megtalálta a lapot, és az elérés nem sérti a védelmi kódot, akkor a lapkeret számát közvetlenül a TLB-ből veszi, nem kell a laptábla. Ha a lap száma benne van a TLB-ben, de csak olvasható, akkor ugyanúgy védelmi hiba generálódik.