Operációs rendszerek

A számítógépek felépítése

-Hardver megközelítés

A számítógépek nagyon sokat változtak az elmúlt négy évtizedben, azonban ez a változás kapacitásukat, sebességüket érintette elsősorban, működési elvükben követték a Neumann János által 1945-ben kidolgozott szabályokat.

Ezek közül a legfontosabbak a következők:

1. Tárolt program: Az utasításokat az adatokkal azonos módon, közös nagy kapacitású memóriában, numerikus kódok formájában kell tárolni.

2. Kettes számrendszer: Az adatok- és program kódok ábrázolására a kettes számrendszert kell alkalmazni.

3. Vezérlőegység: Szükség van egy olyan vezérlőegységre, amely különbséget tud tenni utasítás és adat között, majd önműködően végrehajtatja az utasításokat.

4. Aritmetikai-logikai egység (ALU): A számítógép tartalmazzon olyan egységet, amely az aritmetikai műveletek mellett képes elvégezni az alapvető logikai műveleteket is.

5. Perifériák: Szükség van olyan ki/bemeneti egységekre, amelyek biztosítják a kapcsolatot az ember és a számítógép között.

A perifériákkal történő kommunikáció háromféleképpen történhet:

1. Lekérdezéses átvitel (polling): A processzor folyamatosan kérdezi le a periféria állapotát, és ha érdemleges információt talál, beolvassa azt. A módszer legnagyobb hátránya, hogy a processzor folyamatosan foglalt, a periféria átvitel alatt semmi mást nem képes csinálni.

2. Megszakításos átvitel (Interrupt ReQest - IRQ): A periféria a számára kijelölt megszakítás-kérő vonalon értesíti a megszakítás vezérlőn keresztül a processzort, ha adatátvitelt igényel. A kérés elfogadása esetén a CPU egy időre félreteszi éppen végzett munkáját, kiszolgálja a perifériát, majd folytatja ott, ahol abbahagyta. A processzor ez esetben nincs teljesen kiszolgáltatva a perifériának, viszont a programok közötti átkapcsolás, a visszatéréshez szükséges információk elmentése adminisztrációt, szervezést igényel, időt vesz el.

3. Közvetlen memória átvitel (Direct Memory Access - DMA):

DMA esetén a memória és a periféria közötti átvitel a processzortól függetlenül, önálló vezérlő segítségével történik. A processzor egy pillanatig sem foglalt (ez nem mondható el azonban a buszról), mindössze az átvitel megkezdése előtt a kezdő memóriacímet, és az átadandó blokk méretét kell közölnie az autonóm vezérlővel.

Funkcionális megközelítés:

- Első szint: logikai áramkör, amelyekből felépíthetők a processzorok alapegységei, az ALU, a vezérlőegység és a regiszterek, valamint a mikroprogram tár.

- Második szint: a mikroprogram tár tartalma, azaz a gépi kódú utasítások végrehajtását vezérlő program.

- Harmadik szint: a mikroprocesszor. A mikroprocesszorhoz memóriát és perifériákat illesztve építhető fel a számítógép, a “a lelketlen vas”.

- Negyedik szint: a hardverhez legközelebb álló szoftver réteg, az operációs rendszer, amely többek között a hardver vezérlésének nehézségeit hivatott elfedni.

- Ötödik és hatodik szint: a programozók birodalma, a gépi kódú (assembly), valamint a magas szintű nyelvek tartománya.

- Hetedik szint: itt készülnek el a programozói nyelvek segítségével, az alkalmazások.

A hétszintű logikai modell:

Alkalmazások (Word, Excel)

Magas szintű nyelvek (Pascal, C)

Alacsony szintű nyelvek (Assembly)

Operációs rendszer Operációs rendszer

Hardver (Memória, busz, perifériák)

CPU (mikroprogram, regiszterek)

Logikai áramkörök (kapuk, összeadó)

Operációs rendszer átnyúlása

Az operációs rendszer csápjai a legalacsonyabbtól a legmagasabb szintig nyúlnak.

Az operációs rendszerek fejlődése:

A kezdetek:

Az 1944-ben készített jelfogós Mark I, és az 1946-os elektroncsöves ENIAC már bináris elven működött, de a mai értelemben tulajdonképpen nem is volt igazi számítógép, programozásához huzalok százait kellett átdugdosni. Az első tárolt program elvén működő Neumann-féle számítógép 1949-ben, Angliában készült, és a vezetékek cseréje helyett kapcsolók segítségével bitenként lehetett programozni.

Az 1950-es években a FORTRAN megjelenésével a számítógép által kezelhető feladatok köre is bővült. A felhasználó a számára biztosított gépidőben szemtől szembe került a komputerrel, azt tett vele, amit akart, pontosabban, amit tudott (open shop). A FORTRAN fordítóprogrammal futottak a lyukkártyás rendszerek.

Kötegelt feldolgozás:

A hatékonyság növelése érdekében a kezelők profizmusát növelni kellett, a műveletek közötti átfedéseket, pedig csökkenteni. Mindkét problémára megoldást jelentett egy szakképzett operátor alkalmazása. Az egyes feladatokat leíró kártyakötegek utasításait egymás után, szép sorban hajtotta végre a számítógép, ezért ezt a feldolgozási módot kötegelt (batch) feldolgozásnak nevezzük. A munka hatékonyabb lett, de a számítógépek sebessége tovább nőtt, így újra az ember lett a szűk keresztmetszet. Ezért a számítógép vezérlését egy állandóan a memóriában tartózkodó programra, a monitorra bízták, az operátor csak a perifériákat kezelte. A monitor volt az első operációs rendszer(ecske). Ebben az időben jelentek meg az első mágnes szalagok, melyek szintén meggyorsították a feldolgozást.

A végrehajtani kívánt művelet közlésére speciális utasításokat kellett adni a számítógépnek. A gépi kód szintű ASSEMBLY és a magas szintű FORTRAN mellett új nyelvcsalád jött létre, a parancsnyelvek (command language, command interpreter, job control language) családja. Az 1960-as évekre a programok közvetlen futtatásának folyamatából már kimaradtak a felhasználók, az operátorok és a lassú, mechanikus perifériák. A processzorok gyorsulása azonban további kihívást jelentett. A CPU és a perifériák közötti sebesség különbség áthidalására egy olyan gyors átmeneti tároló szolgálhat. Ez az eszköz a gyors, látszólag tetszőleges elérésű mágneslemez lett. Az ilyen rendszerek a lefordíthatatlan SPOOL rendszer nevet kapták.

A SPOOL előnyei:

1) mágneslemezen egyszerre több munka is volt, így lehetővé tette, hogy a CPU válogathasson a futásra várakozó munkák között,

2) az adatok tárolhatók rajta újbóli felhasználás vagy további feldolgozás céljából.

Multiprogramozás (Többfeladatos rendszerek):

A CPU legteljesebb kihasználásához, több feladatot kellett egyszerre elvégeztetni a számítógéppel. A többféle periféria megjelenése, valamint a több feladat egyidejű kezelésére fejlesztették ki a rendszermagot, vagyis a kernelt. A kezelői felület, a burok (shell) és a mag (kernel) együttese alkotja az operációs rendszert (operating system). Az operációs rendszereknek a hardver, illetve a szoftver oldalról nézve következő feladatokat kellett ellátniuk:

1. Eszközkezelők (Device Driver): a felhasználói programok elől el kell fedniük a perifériák különbözőségét, egységes kezelői felületet kell biztosítani.

2. Megszakításkezelés (Interrupt Handling): alkalmas kell, legyen a perifériák felől érkező kiszolgálási igények fogadására, megfelelő ellátására.

3. Rendszerhívás, válasz (System Call, Reply): az operációs rendszer magjának ki kell szolgálnia a felhasználói alkalmazások (programok) erőforrások iránti igényeit úgy, hogy azok lehetőleg észre se vegyék azt, hogy nem közvetlenül használhatják a perifériákat. Erre szolgálnak a programok által kiadott rendszerhívások, melyekre a rendszermag válaszokat küldhet.

4. Erőforrás kezelés (Resource Management): az egyes eszközök közös használatából származó konfliktusokat meg kell előznie, vagy bekövetkezésük esetén fel kell oldania.

5. Processzorütemezés (CPU Scheduling): az operációs rendszerek ütemező funkciójának a várakozó munkák között valamilyen stratégia alapján el kell osztani a processzor idejét, illetve vezérelnie kell a munkák közötti átkapcsolási folyamatot.

6. Memóriakezelés (Memory Management): gazdálkodnia kell a memóriával, fel kell osztania azt a munkák között úgy, hogy azok egymást se zavarhassák, és az operációs rendszerben se tegyenek kárt.

7. Állomány- és lemezkezelés (File and Disk Management): rendet kell tartania a hosszabb távra megőrzendő állományok között.

8. Felhasználói felület (User Interface): a parancsnyelveket feldolgozó monitor utódja, fejlettebb változata, melynek segítségével a felhasználó közölni tudja a rendszermaggal kívánságait, illetve annak állapotáról információt szerezhet.

Interaktív rendszerek:

Az operációs rendszerek fejlődésének következő lépése az INTERAKTÍV multiprogramozás megjelenése volt. A programfejlesztés hatékonysága ugrásszerűen emelkedett, amikor a lyukkártya és a mágnesszalag helyett az interaktív terminál vált az elsődleges program- és adatbeviteli eszközzé. A számítógépek felhasználási területe is lényegileg változott meg. A számítógépek gigantikus számológépekből az információkezelés eszközeivé váltak.

Az interaktivitás megteremtése természetesen az operációs rendszert sem hagyta érintetlenül:

1. Válaszidő. Az operációs rendszernek emberi mércével is elfogadható válaszidővel kellett reagálnia a felhasználói beavatkozásokra, ez, pedig az eddigi órák, napok helyett másodperceket jelentett.

2. Időosztás. A számítógépnek nemcsak akkor vannak adminisztratív feladatai, ha egy program éppen írni vagy olvasni akar, hanem időről időre foglalkoznia kell a terminálok előtt ülő türelmetlen felhasználókkal is, a perifériák között megjelenik az óra, amely az idő felosztását vezényli (időosztás, time sharing).

3. Felhasználói felület. A kötegelt rendszerekben alkalmazott parancsnyelvet ki kellett váltania egy olyan parancsértelmezőnek (command interpreter) amely lehetővé teszi, hogy a felhasználó közölhesse óhajait a számítógéppel. Nem árt, ha a felhasználó és a gép kommunikációs felülete “felhasználóbarát”.

4. Felhasználói adminisztráció. Az operációs rendszernek a munkafolyamatokon kívül a felhasználókat is könyvelnie kell. Felvetődnek a felhasználói jogosultsággal kapcsolatos biztonsági kérdések. Igényként jelentkezik az egy gép termináljai előtt ülő felhasználók egymás közötti kommunikációja.

Az interaktív rendszerek speciális esetének tekinthető VALÓS IDEJŰ (real time) rendszerek lényegében abban különböznek az interaktív rendszerektől, hogy egy kiszolgálás-kérésre adott válasz egy szigorúan meghatározott időn belül meg kell, érkezzen. Egy felhasználó - szomorúan ugyan - de elvisel néhány másodperces várakozást, de ugyanez nem mondható el egy számítógép által vezérelt mérőrendszerről vagy gyártósorról.

Az interaktív rendszerek a kötegelt rendszerek mellett jelentek meg, nem kiszorítva azokat. A személyi számítógépek esetén ugyan ma dominál az interaktivitás, azonban nagyobbacska gépeknél a kötegelt futtatásnak

(természetesen a többfeladatos kötegelt futtatásnak) mindmáig van létjogosultsága.

Személyi számítógépek

Eddig minden fejlesztés a drága processzoridő jobb kihasználása érdekében történt.

Egy másik iparág, a mikroelektronika fejlődése, tette lehetővé a kicsi, de sokak számára elérhető SZEMÉLYI SZÁMÍTÓGÉPEK (PC) széleskörű elterjedését.

Az Intel által kifejlesztett Alter 8800, 1975-ben, egérrel vezérelt grafikus felülettel rendelkezett, biztosította a WYSIWYG (What You See Is What You Get - Ami a képernyőn, az a nyomtatón) funkciót, valamint az egyes gépek Ethernet hálózaton kommunikálhattak egymással! A könyörtelen versenyben csak két cég maradt talpon, az IBM (1981-től) és az Apple (1982-től). Mindkettő a felhasználói felületnek köszönhette eredményeit. A BASIC programozási nyelv és a DOS operációs rendszer döntő szerepet játszott Microsoft birodalom kialakulásában.

A 90-es évek elejétől, a Windows 3.1 megjelenésével a grafikus kezelői felület általánossá vált, sőt a Windows már több feladatot tudott egy időben kezelni.

Az erőforrások megosztására, személyi számítógépek esetén a Novell adott először megoldást.

Novell - NetWare

1984

Lokális

hálózatok

Apple - Macintosh

1982

Grafikus felhasználói

felület

IBM - PC

1981

Programfejlesztési

támogatás

Apple - Macintosh

1982

Grafikus felhasználói

felület

Különbség a nagy- és a mikroszámítógépek között:

A nagygépes világban a többfeladatos, erőforrásokat megosztó rendszerek a hardver lehető legoptimálisabb kihasználása érdekében jöttek létre, a mikro-gépek világában ugyanerre az eredményre a felhasználók minél jobb kiszolgálásának célja vezetett.

A jelen és a közeljövő tendenciái

A számítástechnika fejlődési iránya tehát a hetvenes évek közepétől kettévált. A személyi számítógépek és a nagygépek fejlődése külön utakat járt, a két ág azonban a nyolcvanas évek végétől újra összefonódni látszik.

A számítógépek hálózatba szervezése is nemrégiben még elképzelhetetlen méreteket öltött, a világhálóra, az Internetre több millió számítógép csatlakozik, méretre, operációs rendszerre, gyártmányra való tekintet nélkül.

Ha a számítógépek felépítése hasonló, ugyanazokat a feladatokat kell ellátniuk, ráadásul együtt is kell tudniuk működni, kézenfekvő, hogy az operációs rendszereiknek is hasonulniuk kell egymáshoz. Kell egy közös nevezőt találni.

A Unix operációs rendszer:

A számítástechnika óriási változásait lényegében változatlanul követte a hatvanas évektől a mai napig, a UNIX operációs rendszer. A két legfontosabb szabvány, a rendszerek összeköthetőségét biztosító OSI modell, illetve az alapvető rendszerspecifikációkat megadó POSIX szintén a UNIX-hoz kötődik.

Egy mondatban: a UNIX volt a közös ős, a szabványteremtő és az alkalmazkodó.

Többprocesszoros rendszerek:

A nagyszámítógépek világában, a legjelentősebb változást, a több processzoros rendszerek, megjelenése okozta. A többprocesszoros rendszerek klasszikus megvalósításában a processzorok ugyanazt a memóriát, ugyanazokat a perifériákat használják, és a rendszerbuszon keresztül kommunikálnak egymással, tehát közöttük igen szoros a kapcsolat (tightly coupled systems).

Előnyei:

1. Megnövekedett átbocsátó képesség.

2. Erőforrás megtakarítás.

3. Megbízhatóság.

Az ilyen rendszereket hibatűrő rendszereknek (fault tolerant systems) nevezzük.

A több processzoros rendszerek lehetnek szimmetrikusak (SMP - Symmetric MultiProcessing), vagy aszimmetrikusak.

Szimmetrikus esetben minden processzor egyenértékű, mindegyiken az operációs rendszer egy másolata fut, minden folyamatot bármelyik processzorra rá lehet bízni.

Aszimmetrikus rendszereknél az egyes processzorok feladata előre rögzített, például az egyik, lehet a főnök, a másik végezheti a lebegőpontos számításokat, a harmadik kezelheti a perifériákat és így tovább.

Elosztott rendszerek:

Több processzor szolgálatait úgy is igénybe lehet venni, ha azok egymással csak laza kapcsolatban vannak (loosely coupled systems). Minden processzornak saját memóriája van, saját perifériáikkal rendelkezhet, tehát egy önálló számítógép. Az elosztott rendszerek tipikus példái a számítógép-hálózatok.

Előnyei:

1. Rugalmasság (hardver, szoftver).

2. Erőforrás megosztás.

3. Sebességnövekedés.

4. Megbízhatóság.

5. Kommunikáció.

Operációs rendszer mindenhol:

Miért ne lehetne a háztartási és irodai gépeknek is operációs rendszere? A próbálkozások egyik példája a Microsoft At Work operációs rendszer, melyet intelligens irodai kommunikációs rendszerek (számítógép + telefon + fax + fénymásoló + szkenner + nyomtató) számára fejlesztettek ki.

Alapfogalmak:

A program egy algoritmust megvalósító utasítások sorozata, függetlenül attól, hogy azok magas szintű nyelven, vagy akár bináris gépi kódban vannak ábrázolva és tárolva.

A folyamat (task, process) egy éppen végrehajtás alatt lévő program. Egy program végrehajtása több folyamatot is létrehozhat, ugyanaz a program több folyamat formájában is megjelenhet.

A folyamat tehát egy “életre kelt” program.

A folyamatleíró blokk (Process Control Block-PCB, Task State Segment-TSS) azonosítja egyértelműen a folyamatot, tartalmazza a folytatáshoz szükséges adatokat, mint pl.: a folyamat azonosítóját; a programszámláló állását; a folyamat állapotát; a regiszterek tartalmát; a használt perifériák és állományok jellemzőit és a folyamathoz tartozó memóriaterületek adatait.

A Folyamatok, olyan programok, melyeknek van folyamatleíró blokkja.

A szálak (thread) a folyamatokhoz nagyon hasonlítanak, de nyilvántartásukhoz sokkal kevesebb adat elegendő, gyakran csak az utasításszámláló és a regiszterek tartalma szükséges.

Erőforrások:

Erőforrásnak nevezünk minden olyan dolgot, amely egy folyamat futásához szükséges: (a memóriaterület és a processzoridő, a ki- és bemeneti eszközök, egy állomány vagy egy postafiók). Két csoportja: elvehető erőforrások (megszakítható, preemptive): (processzor és a memória), nem elvehető erőforrások (nem megszakítható, non-preemptive): (állományok, nyomtatók, mágnesszalagos egységek).

Megszakítható (preemptív) erőforrás: a folyamatoktól az erőforrás, a folyamat vagy erőforrás károsodása nélkül elvehető.

Nem megszakítható (non-preemptív) erőforrás: az erőforrás használat félbeszakítása esetén a folyamat vagy erőforrás sérülhet!

Operációs rendszer - Erőforrás szemlélet: a folyamatok egy olyan csoportja, amely a felhasználói folyamatok között elosztja az erőforrásokat.

Operációs rendszer - Felhasználói szemlélet: a folyamatok egy olyan csoportja, amely megkíméli a felhasználókat a hardverkezelés nehézségeitől és kellemesebb alkalmazói környezetet, biztosít.

Az operációs rendszer rétegei:

Felhasználói programok
Programok készítési támogatás
Felhasználói folyamatok kiszolgálása
Rendszerhívások Válaszok Rendszermag (KERNEL) Processzorkezelés, Memóriakezelés, Állománykezelés Eszközkezelők Megszakításkezelés
Eszközvezérlő	Megszakítás vezérlő
Perifériák

A rendszermag folyamatok sokasága, melyek a rendszer bekapcsolásakor jönnek létre, és futásuk a rendszer leállításáig tart. A kernel hozza létre a felhasználói folyamatokat, elkészíti a folyamatleíró blokkot, memóriaterületet biztosít a végrehajtandó kódnak, gondoskodik a processzor idő elosztásáról, a folyamatok sorrendjének meghatározásáról.

Rendszerhívások segítségével történik a felhasználói folyamatok és az operációs rendszer magja között a kommunikáció.

A processzorok üzemmódjai:

Felhasználói üzemmód (user mode), melyet a felhasználói programok használnak.

Rendszer üzemmód (kernel mode, privilegized mode, system mode, supervisor mode), melyet csak az operációs rendszer használhat.

A rendszerhívások kiszolgálása a következőképpen történik:

1. A felhasználói folyamat legfontosabb paraméterei elmentődnek.

2. A kernel megfelelő folyamatára kerül a vezérlés.

3. A paraméterek átadásra kerülnek a vermen (stack), a regisztereken vagy valamely közösen használt memóriaterületen keresztül.

4. A processzor rendszermódba kapcsolódik át. (Ezt gyakran már a rendszerhívó utasítás maga megteszi).

5. Elindul a megfelelő rendszerfolyamat, végrehajtja a kívánt feladatot.

6. A válaszok vagy hibakódok valamely paraméter-átadásra szolgáló területre kerülnek.

7. A processzor visszatér felhasználói módba.

8. A megszakított folyamat visszakapja a vezérlést.

A perifériák felől az operációs rendszer magját az eszközkezelőkön (device

driver), illetve a megszakítás (interrupt) rendszeren keresztül lehet megközelíteni.

A külön eszközkezelők létjogosultságát az indokolja, hogy a folyamatok kezelése a kernelre olyan feladatokat ró, hogy annak nincs ideje a különböző perifériák speciális tulajdonságaira figyelni, azokat egységes felületen keresztül szeretné kezelni.

A perifériák az operációs rendszer figyelmét megszakítás kéréssel (interrupt request), hívják fel magukra. Ilyen kérésre kerülhet sor például egy hardver elem meghibásodásakor, egy adatátvitel megkezdésekor, vagy befejezésekor.

Megszakítások típusai:

- Megszakítás (Interrupt): egy periféria jelezheti így egy régen várt adat megérkezését, de megszakítást okoz a rendszer órája is.

- Kivétel (Exception): a kivételeket maga a processzor generálja, ha valamilyen hibát, például nullával való osztást, kellene végeznie, vagy a címszámításnál tapasztal valamilyen komoly hibát.

- Nem maszkolható megszakítás (Non Maskable Interrupt): súlyos hardver hiba, például a memória hibája, vagy a tápfeszültség kimaradás esetén keletkezik.

- Csapda (Trap): olyan szoftver eredetű megszakítás, amely akkor keletkezik, ha egy felhasználói folyamat közvetlenül az operációs rendszerhez fordul (rendszerhívás), vagy olyan utasítást próbál végrehajtani, amihez nem lenne joga (önálló hardverkezelés).

A megszakításkezelés forgatókönyve:

1. Megszakításkérés érkezik.

2. A processzor befejezi az éppen végzett műveletet.

3. A processzor elmenti a futó folyamat állapotvektorát.

4. A CPU privilegizált (kernel) üzemmódba kerül, és letiltódik az összes olyan

megszakítás, melynek prioritása kisebb vagy egyenlő az érkezett

megszakításéval.

5. A központi egység megállapítja a megszakításkérés helyét, és a megszakítási

vektortáblából kikeresi a megfelelő kiszolgáló rutin címét.

6. A kiszolgáló rutin fut.

7. A CPU visszatér felhasználói (user) üzemmódba, és engedélyezi a letiltott

megszakítási szinteket.

8. A processzor visszaállítja a megszakított folyamat állapotvektorát, ezzel

visszaadva a vezérlést.

Virtuális gépek:

Az operációs rendszer, amely a hardver kezelését magára vállalja, egy olyan felületet biztosít, amely úgy viselkedik, mintha egy látszólagos (virtuális) számítógépen futnának programjaink. A virtuális gépen futó folyamatok egymástól gyakorlatilag teljesen függetlenek, mindössze kissé lassabban futnak, mintha valóban egyedül lennének. A virtualizáló kernel előnye, hogy egyszerre futhat rajta több “igazi” operációs rendszer!

I. Alkalmazás	II. Alkalmazás	III. Alkalmazás
I. Operációs Rendszer	II. Operációs rendszer	III. Operációs rendszer
Virtualizáló kernel
Hardver

A Sun JAVA rendszere:

A Java magas szintű, objektum orientált programozási nyelv, könnyedén hozhatunk általa létre grafikus objektumokat, ablakokat, képeket. A magas szintű utasítások bonyolult, összetett operációs rendszer igényelnek.

Az ilyen rendszerek természetesen lassabbak, mint például egy C-ben, vagy

Assembly-ben írt program, viszont a szabványos felületnek köszönhetően ma már szinte minden processzoron, minden operációs rendszer rendelkezik ezzel

az interfésszel.

Úgy működik, mintha önálló operációs rendszer lenne. Saját „homokozóval” rendelkezik, ez által azt a látszatot kelti, mint ha ott sem lenne. Tehát a feltelepített operációs rendszer nem is látja.	Jáva alkalmazás
	Jáva virtuális gép
	Hardware

A felhasználói felület

A legelső dolog, amivel a felhasználó találkozik, az, az operációs rendszerek

felhasználói felülete.

A mai rendszerek túlnyomó többsége interaktív, tehát a felhasználó is igényli, hogy befolyásolhassa a rendszer működését.

Felhasználói felületre szükség van, mert az operációs rendszer nem tudja kitalálni, hogy egy felhasználó mit akar.

A felhasználói felület részei:

- programindítás, kapcsolat a folyamatokkal,

- a rendszermag szolgáltatásainak közvetlen felhasználói elérése,

- a rendszermag programozói felülete,

- alapvető segédprogramok.

A felhasználó és a rendszermag:

A számítógép bekapcsolásakor a hardver ellenőrzés után az első esemény az operációs rendszer betöltése. Az operációs rendszer beállítása lehet kézi beállítású, vagy automatikus un. Plug and play (PnP).

A programozói felület:

Az operációs rendszerek egyik feladata a hardver elrejtése a felhasználók elől.

A forráskód elkészítése: a forráskód elkészítésére szinte minden rendszer biztosít egy szövegszerkesztőt (editor), amely a konzolról begépelt szöveget egy

állományba menti. A programozási nyelv megválasztása erősen függ az

elvégzendő feladattól.

Fordítás: A forráskód alapján azt a gépi kódú programot, amely az adott processzor által ismert utasításokat, valamint a rendszerhívásokat megvalósító szoftver megszakításokat tartalmazza, a fordítóprogram (compiler) készíti el. Így keletkezik a tárgykódú (könyvtár) (object - OBJ) modul. Az operációs rendszer is tartalmazhat előre elkészített, rendszerkönyvtárakba (library - LIB, Dynamic Linked Library - DLL) rendezett, elsősorban perifériakezelő, vagy a felhasználói felület kialakítását segítő programokat. A modern operációs rendszereknek csak a hardver közeli részei íródnak gépi kódban, nagy részüket a kifejezetten e célra kifejlesztett C nyelven készítik.

A kernel programozói szempontból egy függvény-, vagy eljárás könyvtárnak

tekinthető, a programok készítéséhez szükséges információ leírás és

segédprogramok összefoglaló neve a legtöbb esetben API (Application

Programming Interface).

A szerkesztő (linker) feladata a tárgykódú modulok címeinek összehangolása, a kereszthivatkozások feloldása, a betölthető program (executable - EXE) előállítása.

A betöltő (loader) program már az operációs rendszer magjához tartozik,

feladata a végrehajtható program elhelyezése a memóriában, a bázis cím kitöltése a megfelelő értékkel, a folyamat leíró blokk elkészítése. A betöltéssel

válik egy program folyamattá.

Az így elkészített, illetve betöltött program hátrányai:

- minden részlete egyszerre kerül a memóriába,

- annyiszor kerülnek betöltésre, ahány program használni kívánja őket.

Az eddigi statikus szemlélettel szemben a problémát a dinamikusan szerkeszthető könyvtárak (Dynamic Link Library - DLL) segítségével lehet megoldani. A dinamikus könyvtárak csak akkor kerülnek a memóriába, ha azokra hivatkozás történik, bekerülésük után viszont több program is használhatja egyszerre őket.

Karakteres felhasználói felület

A parancsértelmezők, a parancsnyelvek továbbfejlesztése.

Feladatuk az operációs rendszer szolgáltatásainak biztosítása az interaktív felhasználó számára.

Elnevezései lehetnek:

- shell (burok, héj) (Unix, DOS),

- command interpreter (parancsértelmező) (parancsok kiszolgálásánál),

- monitor (felügyelő) (folyamatok kezelésénél).

A shell alapvető feladatai:

- programindítás, programkezelés,

- egyéb, operációs rendszer funkciók felhasználói szintű biztosítása (általános értelemben vett fájlkezelés).

Programkezelés:

Indíthatnak futó folyamatok is további folyamatokat, de a közös ősnek valamikor emberi beavatkozással kellett megszületnie.

Program műveletek:

1. A betöltendő állomány kiválasztása.

2. A program számára a megfelelő környezet biztosítása.

3. A folyamat futásának megfigyelése, szabályozása.

4. Vezérlési szerkezetek megvalósítása.

Program indítása:

A programok indítása általában nem más, mint a gépi utasítássorozatot tartalmazó állomány nevének megadása. Egyes rendszerekben, illetve speciális betöltési mód esetén a program nevét meg kell előznie a run (fut) vagy a load (betölt) utasításoknak. Bonyolult fájlrendszer esetén egyszerűsítő lehetőségeket vehetünk igénybe.

Közvetett fájl elérés: lényege, hogy ugyanazon állományhoz több helyről is hivatkozhatunk. A hivatkozás maga is egy fájl, azonban egy elég kicsi fájl, melynek tartalma mindössze a betöltendő állomány neve, esetleg paraméterei. (BAT illetve NCF kiterjesztéssel).

Keresési útvonalat is megadhatunk a legtöbb esetben. Ilyenkor az operációs rendszer, ha a hivatkozott programot nem találja meg az aktuális katalógusban egy előre adott rendszerint veszi sorba a megjelölt katalógusokat addig, amíg a keresett állományra nem bukkan. (PATH - ösvény).

Láncolt programfuttatás: lehetséges, ha az említett parancsfájl több sort is tartalmaz. Hasonlít a kötegelt feldolgozásra, utasításokat úgy hajtja végre, mintha egyenként gépeltük volna be őket. (DOS kötegelt (batch), a NetWare a parancs (command) illetve a Unix (script)).

Automatikus programbetöltésre: akkor van szükség, ha néhány program indítását minden bekapcsoláskor vagy belépéskor amúgy is elvégeznénk.

(DOS esetén a gyökérkönyvtárba elhelyezett AUTOEXEC.BAT állomány, a Windows esetén a WIN.INI fájl LOAD, illetve RUN).

Program környezet beállítása:

A programok futását befolyásoló, módosító paraméterek összességét nevezzük a program környezetének.

paraméterek, azaz például azon állományok nevei, amelyeken a programnak műveleteket kell végeznie.

kapcsolók (switch, flag, option), melyek a működést pontosítják vagy akár alapvetően megváltoztatják.

átirányítási adatok (redirection), melyek azt jelzik, hogy a program a bemeneti paramétereit az alapértelmezett forrás – általában a billentyűzet – helyett honnan kérje, illetve kimenetét a legtöbbször használt monitor helyett melyik fájlba irányítsa.

környezeti változók (environment variables), az operációs rendszer beállításait jelző paraméterek. Míg az előző adattípusok a parancssorban adhatók meg, az operációsrendszer környezeti változóinak beállítására külön utasítások szolgálnak (pl. SET), melyek gyakran az automatikusan lefutó parancsállományban kapnak helyet.

A folyamat futásának ellenőrzése:

Lehetőség van a futó folyamatok megszüntetésére vagy szüneteltetésére is (pl. Unix Kill, illetve Windows task manager).

Vezérlési szerkezetek:

A parancsnyelv általában nem csak programindításra, illetve paraméterezésre alkalmas, hanem összetett, feltételhez kötött és ciklusutasítások is megadhatók vele.

A parancsértelmező egyéb funkciói:

A programindításon kívül leginkább állományokkal, katalógusokkal kapcsolatos műveleteket végez.

Grafikus felhasználói felületek

Felhasználói felület jellemzői:

- Könnyű legyen megtanulni;

- Méretezhető legyen;

- Lehessen visszavonni;

- Törölni lehessen a műveleteket;

- Többszintű súgó rendszer;

- Hasonlítson az élő nyelvhez;

- Minden parancsra legyen válasz;

- Hasonló funkciók hasonló módon.

Többfeladatos, karakteres felületet használó rendszerekben (multitask, pl. Unix) ugyan futhatnak folyamatok a háttérben, azonban ezek működését csak meglehetősen nehézkesen lehet nyomon követni.

Az ablakozó technikák tehát a többfeladatos rendszerekhez kötődnek, fejlődésük kezdete a 80-as évek elejére tehető.

Az ablakozó rendszer működése:

Egy szép színes grafikus képernyő kezelése meglehetősen bonyolult feladat, ezért az ilyen eszközt alkalmazó operációs rendszerben ezt a funkciót egy speciális folyamat csoport, egy alrendszer látja el, a GUI (Graphical User Interface - Grafikus Felhasználói Felület). A GUI feladata, hogy az őt “használó” folyamat számára biztosítsa a grafikus bevitel, illetve megjelenés lehetőségét. A grafikus interfész tehát egy szolgáltatást (szerver, server) nyújt a hozzá forduló ügyfelek (kliens, client), a folyamatok számára.

Üzenetvezérlési ciklus:

1. Minden futó programhoz tartozik egy ablak vagy az ablakot reprezentáló ikon.

2. A grafikus terminál előtt ülő felhasználó tevékenykedik, azaz mozgatja az egeret, nyomkodja a gombjait, vagy olykor leüt egy billentyűt, azaz események (event) történnek.

3. Az ablakozó rendszer, (az X szerver), az egér pozíciójából megállapítja, hogy melyik alkalmazással kíván kommunikálni a felhasználó, és az üzenetet a megfelelő folyamatnak küldi el.

4. Az alkalmazás feldolgozza az üzenetet, és felkéri a szolgáltatót, hogy hajtson végre bizonyos változtatásokat.

Ez az üzenet feldolgozási ciklus folytatódik folyton folyvást.

Ablakok rendszere:

A grafikus felhasználói felületen minden alkalmazásnak megfelel egy ablak, azok a területek, amelyek az ablak szélein kívülre esnének, levágódnak. Az ablakok egymást részben vagy egészben eltakarhatják.

Az alkalmazások ablakainak lehetnek gyermekei, azaz olyan ablakok, amelyeket a szülő alkalmazás hozott létre. Ezek az ablakok csak a szülő ablakon belül mozoghatnak, azt nem hagyhatják el.

Az események címzettjének felismerése

Események akkor következnek be, ha az egér, billentyűzet vagy egyéb beviteli eszköz állapotában változás áll be.

- egér: aktuális koordinátáiból megállapítható, hogy mely ablak felett jár.

- billentyűzet: mindig van egy kitüntetett (jól láthatóan megkülönböztetett) ablak, amelyikhez a rendszer a billentyű leütéseket rendeli, erre az ablakra irányul a figyelem (input focus).

Eszközfüggetlen működés

Az ügyfelek eszközfüggetlen üzeneteket küldenek, amelyeket az ablakozó rendszer a maga legjobb tudásának megfelelően végrehajt.

– A megjelenítő szerver az alkalmazás szabványos, eszközfüggetlen üzenetei alapján állítja össze a megjelenítendő képet.

– Az alkalmazásnak nem kell ismernie a munkaállomás perifériáit, a megjelenítésről a helyi szerver gondoskodik (GUI).

– A GUI az alapvető objektumokat maga állítja elő az alkalmazástól kapott paraméterek alapján.

Az adatforgalom csökkentése

Különösen abban az esetben, amikor a szolgáltató és az ügyfél a világ két ellentétes pontján található, nagyon fontos, hogy a lassú és túlterhelt csatornán (például az interneten) a lehető legkevesebb adatnak kelljen átmennie. Ennek érdekében az ügyfél nem minden apró kívánságát küldi el az ablakozó rendszernek, hanem több utasítást csokorba fogva.

– Nem mozognak az átviteli csatornán nagyméretű képernyőtartalmak, csak az ezek összeállítására vonatkozó utasítások.

– A GUI az alapvető objektumokat maga állítja elő az alkalmazástól kapott paraméterek alapján.

– Az ideiglenesen nem használt felületek tartalma tárolódik az X-szerveren.

– Lehetőség szerint csak a változásokra vonatkozó utasítások mozogjanak.

Segédprogramok, alrendszerek:

A parancsnyelv – shell (héj, burok) nem más, mint a rendszerhívások, illetve rendszerhívások sorozatának kiadására szolgáló magas szintű eszköz, ezért vitathatatlanul az operációs rendszerhez tartozik.

A gyakran használt operációs rendszer szintű feladatok megoldására szolgáló segédprogramok – alrendszerek (lemezformázás stb.) szintén közel állnak az operációs rendszerhez.

Alrendszerek működési területei:

- Állományok kezelése.

- Programfejlesztés.

- Adatbázis kezelés.

- Kommunikáció.

Állományok, Katalógusok

Fájl = Állomány:

1) Az adatok egy olyan csoportja, melyre együttesen, egy névvel hivatkozhatunk.

2) Logikailag összetartozó adatok halmaza névvel ellátva.

A fájl fogalma alatt általában tárolt adatokat értünk, de léteznek olyan operációs rendszerek (például a UNIX), ahol ezt a szemléletet minden külső adatfolyamra, így a képernyő tartalomra és a billentyűzetre is általánosították.

Fájltípusok:

- Ideiglenes rendszerállományok (pl. virtuális memória).

- Adminisztratív állományok (pl. katalógusok).

- Felhasználói állományok.

A mágneses háttértárak feladata a operatív tár kiegészítése, méretének látszólagos megnövelése, illetve a felhasználók által létrehozott állományok megőrzése.

A lemezeken tárolt adatok három csoportja:

I.

1. Ideiglenes állományok,

2. Felhasználói állományok,

3. Adminisztratív állományok

II.

1. Adatfájlok köre,

2. Könyvtárfájlok köre.

A rendszermag azon részét, amely a fájlokkal kapcsolatos műveleteket végzi, fájlkezelőnek nevezzük. A fájlkezelő az a folyamat, mely a nevekből a logikai blokkszámokat kialakítva a felhasználói folyamatok kéréseit az eszközvezérlőnek továbbítja.

Fájlnevek:

A felhasználói-folyamatok fájlnevek segítségével hivatkoznak a kívánt adatcsoportokra.

A fájlneveket alkotó karakterek lehetséges halmaza, a név lehetséges hossza, valamint szerkezete az aktuális operációs rendszer függvénye. A nevek több összetevőből állhatnak, melyeket valamilyen speciális karakter választ el egymástól. A leggyakoribb a két összetevőből álló név, ahol az első az egyedi, a fájl tartalmára utaló rész, a második rész a fájl jellegére.

MS-DOS: két komponensből áll, az első rész, a név, minimum 1, maximum 8 karakterből állhat, az elválasztó pont után következő kiterjesztés legfeljebb 3 karakterből állhat.

UNIX: hossza maximum 255 karakter lehet, és tetszőleges számú, a DOS-hoz hasonlóan ponttal elválasztott összetevőből állhatnak.

Windows 95: legfeljebb 250 karakter hosszúságú, tetszőleges karakterekből álló név és, ugyancsak maximum három karakteres kiterjesztéssel.

Fájlok jellemzői:

A fájlokhoz a nevükön kívül egyéb információk is tartoznak, melyeket részben az operációs rendszer ad, részben a felhasználó:

- fájlnév,

- utolsó módosítás időpontja,

- fájl mérete,

- a fájl tulajdonosa,

- fizikai elhelyezkedés,

- hozzáférési jogok,

- attribútumok.

A fájl állapotára utaló jelzőbiteket összefoglaló néven attribútumoknak nevezzük.

Közvetlen hivatkozások esetén a teljes elérési útvonal meg van adva, ez alapján juthatunk el a keresett fájlhoz.

Közvetett hivatkozások:

Közvetett hivatkozásokról (láncolás, link, alias) akkor beszélünk, ha egy fájlhoz nem csak egy elnevezés segítségével juthatunk el, tehát például egy programot a különböző felhasználók, különböző neveken érhetnek el.

A merev láncolás (hard link) esetén tulajdonképpen két vagy több független, egyenértékű fájlról beszélhetünk, melyek kizárólag a fájl fizikai elhelyezkedésére vonatkozó információkban kell, megegyezzenek. Az operációs rendszer nyilván kell tartania, hogy egy-egy fájl fizikai megvalósulására hány hivatkozás mutat, és csak akkor szabad a fájlt törölni, már egy sem mutat rá.

A lágy láncolás (soft link) a fizikai cím helyett a hivatkozott fájl nevét tartalmazza, lehetővé téve azt, hogy a fájl akárhol is előfordulhasson. A lágy láncolás további előnye, hogy az adatállományok tömörítése, vagy alapvető, fizikai címeket is, érintő átstrukturálása esetén is működőképes marad.

Katalógus (könyvtár, directory)

A katalógus olyan speciális állomány, melynek tartalma a fájlok nevét és jellemzőit tartalmazó rekordok listája.

Ha egy folyamat egy fájlra hivatkozik, az operációs rendszer először a katalógust vizsgálja meg, hogy létezik-e egyáltalán ilyen fájl. Pozitív válasz esetén jön a következő ellenőrzés, hogy a felhasználónak, illetve az általa indított folyamatnak van-e joga a kívánt művelethez. Amennyiben a fájl is létezik, és a jogosultságok is rendben vannak, akkor kezdődhet meg a katalógusban lévő, a fizikai elhelyezkedésre utaló információ alapján a művelet végrehajtása.

Katalógus nélkül:

Soros hozzáférésű média, például mágnesszalag esetén, ahol a blokkok mérete sem állandó, nehéz elképzelni könnyen kezelhető, a fájlok alapvető adatait tartalmazó katalógus állományt.

Egyszintű katalógus:

Ha egy rendszer csak egyetlen, rendszerszintű katalógust kezel (manapság ez már kuriózum), egyszintű katalógusról beszélünk.

Kétszintű katalógus:

Egy második szint bevezetése sokkal áttekinthetőbb rendszert eredményez, a legtöbb feladat így már megoldható. Minden felhasználó kaphat egy saját katalógust, míg a közösen használt fájlok külön katalógusba kerülhetnek. Az egyes katalógusokat, a katalógusok katalógusa, a fő (master) vagy más néven gyökér (root) katalógus fogja össze. Mivel ebből eszközönként csak egyetlen egy van, nem is szükséges neki nevet adni.

A névtelen gyökér katalógust követi az első törtvonal, következik a katalógus neve, majd újabb törtvonal után a fájl neve.

Többszintű (hierarchikus) fájl rendszer:

A kétszintű rendszerről nem nehéz átállni a többszintű, többnyire fa struktúrát alkalmazó rendszerekre. A hierarchikus rendszer kiindulópontja a gyökérkönyvtár, mely tartalmazhat fájlokat és alkatalógusokat (subdirectory), ez utóbbiak szintén tartalmazhatnak fájlokat és alkatalógusokat és így tovább.

Abszolút hivatkozás: fájl megadásának az a módszere, ahol a gyökér katalógustól kezdődően az összes közbülső katalógus nevének felsorolása után jutunk el a fájlhoz.

Relatív hivatkozás: A fájl megadásának az a módszere, ahol a gyökér katalógus (vagy szülő könyvtár) helyett az aktuális katalógus a kiinduló pont.

Hozzáférési jogok:

Az egyes fájlok tartalma lehet bizalmas, vagy fontos, nem módosítható.

Jogosultságok típusai:

Olvasás (Read - R)

Írás (Write - W)

Létrehozás (Create - C)

Végrehajtás (eXecute - X)

Törlés (Erase - E)

Jellemzők módosítása (Modify - M)

Hozzáférés módosítása (Access control - A)

Jogok nyilvántartása:

A felhasználókat és a fájlokat tehát a jogosultságok kapcsolják össze. A nyilvántartásnak lehetőség szerint olyannak kell lennie, mely nagyon gyors keresést tesz lehetővé, hiszen erre minden egyes fájlhivatkozásnál szükség van.

Fájlok elhelyezése:

A fájlok adatai között szerepelt egy paraméter, ami arra utalt, hogy hol található maga a fájl a lemezen.

A blokkok állapotát a foglaltsági tábla mutatja. Egy blokk 512 KB.

Szabad helyek nyilvántartása:

- Folytonos: first, worst, best

- Láncolt: FAT

- Indexelt: INODE

Folytonos kiosztás: (nagygépes környezetben) a fájl blokkjai folytonosan helyezkednek el.

1 legelső alkalmas (First Fit) – leggyorsabb, de pazarló.

2 legjobban illeszkedik (Best Fit) – lassú, de gazdaságos hely kiosztás.

3 legrosszabbul illeszkedik (Worst Fit) – egyszerű nyilvántartás.

Ha ragaszkodunk a folytonos elhelyezéshez, óhatatlanul szétdarabolódik a rendelkezésre álló hely. Túl precíz illeszkedés esetén a fájl méretének minimális növekedése is csak az egész állomány átmásolásával lehetséges, valamint ha a fájl belsejéből ki akarunk törölni egy blokkot, az azzal jár, hogy az összes maradék blokkot egy blokkal előre kell mozgatni.

1 2 3

Láncolt elhelyezés: (Főként régi Windows)

A katalógusban itt is csak a fájl kezdő blokkjának címét kell megadni, az összes többi adatot a fájl elhelyezési tábla (File Allocation Table - FAT) tartalmazza. A táblázatnak ugyanannyi eleme van, mint ahány blokk a lemezen és minden rekesz tartalma a fájl következő blokkjára mutató sorszám - ha van következő blokk, 0 - ha ez volt az utolsó blokk.

Előnye a teljes kihasználhatóság, hátránya, hogy végig kell lapozni az összes blokkot, ha valamit keresünk.

Indextábla alkalmazása: (Linux)

Rugalmas elhelyezési lehetőségekhez jutunk, ha egy óriási táblázat helyett sok kicsit használunk, minden állományhoz külön. A katalógus tartalmazza a fájlhoz tartozó kicsi táblázat címét, a kicsi táblázat pedig a fájl blokkjainak a címét.

A módszer előnye, hogy az elhelyezési információ gyorsan elérhető, kevésbé sérülékeny a tárolás is, hátránya, hogy valamiféle becslésre van szükség, hogy mekkorák lesznek fájlok.

Előnye, hogy lehetővé teszi a közvetlen elérést és hibatűrő, kevésbé sérülékeny.

Műveletek állományokkal

1) Létrehozás

2) Keresés katalógusban

3) Írás, olvasás

– megnyitás

– pozicionálás

– írás-olvasás

– lezárás

4) Törlés

Állomány, katalógus létrehozása:

Állomány létrehozása: a katalógusba új bejegyzés kerül, az új állomány számára az operációs rendszer megfelelő mennyiségű szabad blokkot keres.

Katalógus létrehozása: különleges státuszát mutató attribútumán kívül semmiben sem különbözik a fájlok készítésétől.

Írás, olvasás állományokba:

Keresés a katalógusban a fájl neve alapján az állomány jellemzőinek, fizikai elhelyezkedésének adatait keressük, ez a leggyakoribb katalógus művelet.

Hatékony és gyors végrehajtása érdekében célszerű a katalógust rendezett állapotban tartani.

Állomány megnyitása, ha a folyamat egy állományhoz fordul, a megnyitás során az operációs rendszer ellenőrzi a kívánt művelethez szükséges jogosultság meglétét. Majd, létrehozza a fájl leíró táblázatát (file control block - FCB).

A megnyitás lehet:

- írás: a fájl eredeti tartalma törlődik, az új adatok a régiek helyére kerülnek

- olvasás: a fájl a művelet után változatlan marad

- hozzáfűzés: az állomány eredeti tartalma nem sérül, az újabb adatok a meglévők után kerülnek

- írás/olvasás

Az adatok értelmezése szerint:

- bináris a beolvasott bájtok pontosan megfelelnek a fájlban tároltaknak,

- szöveg az olvasás a fájl vége karakternél leáll.

Az elérés módja szerint:

- sorrendi (szekvenciális): az aktuális pozíciót tartalmazó mutató az adatok írásával/olvasásával automatikusan növekszik,

- tetszőleges (random): az írás vagy olvasás helyét meghatározó mutatót a program állítja.

Az aktuális pozíciót az operációs rendszer az FCB-ben tárolja.

Pozícionálás állományokban a mutató helyének beállítása. Speciális, gyakran használt pozícionáló utasítás a fájl elejére állítás (rewind). Hozzáfűzés esetén a mutató automatikusan a fájl végére ugrik, onnan indul.

- Írás/olvasás: adatátvitel a memória és az állomány között a fájlmutató által meghatározott pozíciótól.

- Állomány kezelése: hatására az átmeneti tárolóban lévő adatok rögzítésre kerülnek, az FCB megszűnik.

- Állomány, katalógus törlése: a szülő katalógus megfelelő bejegyzésének ellátása a törölt állapotot mutató jelzővel (NEM fizikai törlés!)

Katalógusokon végzett, de tulajdonképpen állományokra vonatkozó művelet a fájlok jellemzőinek, hozzáférési jogainak módosítása, illetve (szerencsés esetben) a véletlenül törölt fájl visszaállítása.

Fájlrendszerek jövője (vízió!)

Jelen:

– Katalógus (leíró információ) → Fájl (tartalom).

– A katalógus célja a kereshetőség, rendszerezés.

– Kereshetőségi szempontok: Név, Idő, Méret.

KEVÉS, többszempontú kereshetőség kell.

A katalógus elemeinek a bővítése operációs rendszer szinten csak időleges megoldás.

Egyéni bővíthetőség esetén elveszik a hordozhatóság.

Jövő (megoldás)

– ÖNLEÍRÓ állományok, azaz a rendszer a struktúráját SZABVÁNYOS módon hordozza (XML).

– Ez nem más, mint az ADATBÁZIS (relációs, OO)!

– A fájlrendszerek ELTŰNNEK, vagy legalábbis az adatbázis koncepció felé tartanak.

PCB és FCB kapcsolata

PCB (Process Control Block)

– A folyamat folytatásához szükséges adatok

FCB (File Control Block)

– A fájl művelet folytatásához szükséges adatok

Tartalma:

• Logikai azonosító,

• Aktuális pozíció (hol tartok az olvasással?),

• Megnyitási mód (írás, olvasás, bináris, szöveg),

• Zárolási adatok (ne piszkáljon bele senki!),

• Változásjelző stb. (el kell menteni, mert megváltozott a tartalom!).

A PCB tartalmazza a folyamat által használt fájlok FCB-ire mutató pointereket is!

Lemezkezelés

A processzor és a memória mellett a számítógépek nélkülözhetetlen építőelemei a ki- és bemeneti (input/output) egységek, melyek alapvető feladata egyrészt a külvilággal való kapcsolattartás, másrészt az adatok, programok tartós, állandó tárolása későbbi felhasználás céljából.

Háttértárak

Lemezkezelés

• Háttértárolók felépítése:

– Szalag, Lemez, CD

• Fizikai lemezkezelés:

– Ütemezés, Címszámítás, Adatátvitel

• Az adattárolás optimalizálása:

–Blokkméret

– Tömörítés, redundancia

Mágnesszalagok:

Adattároló képességük a lemezes tárolókét jóval meghaladja, 2 -16 GB (adattömörítés esetén még több), nem is beszélve arról, hogy mágnesszalagok esetén a lejátszó/felvevő eszköz ugyan drága, de az adathordozó ára töredéke a hasonló kapacitású merevlemezek árának.

Mágnesszalagok jellemzői:

• Nagy mennyiségű, összefüggő adat:

– Archiválás, adatmentés

– Nagy tömegű adat átvitele

– Sok adat átmeneti tárolása

• Képviselői:

– sztrímer (100 Mb kapacitású, személyi számítógépek archiváló eszközei)

– DAT (Digital Audio Tape) (hálózatok és munkaállomások nagy biztonságú háttértára).

Mágnesszalagos egységeket alkalmazása:

Archív tárolóként adatmentés (backup) céljára,

Adatok átvitelére számítógépek között,

Nagy adatmennyiség átmeneti tárolására.

A mágnesszalagokra történő adatrögzítés a szalag szélessége mentén sávokban, 9 bites keretekben (frame) történik. A keret 8 bitje adattárolásra, 1 bitje paritás ellenőrzésre szolgál.

Mágneslemezek:

A mágneslemezek (winchester, Hard Disk Drive - HDD) a leggyakrabban alkalmazott, leguniverzálisabban használható háttértároló eszközök. Segítségükkel nagy adatátviteli sebesség (2-10 Mbit/s) érhető el, igen nagy kapacitásúak (1-20 GB) és viszonylag olcsók.

A lemez gyorsan forog (60 s-1), a koncentrikus körök, a sávok (track) mentén tárolt adatokat sugárirányban mozgatható olvasó/író fejek olvassák, illetve rögzítik. Az egymás alatt elhelyezkedő sávokat együttesen cilindernek nevezzük.

Alkalmazása:

– Virtuális memória

– Programok tárolása

– Adatok tárolása

Mágneslemezek jellemzői

Technikai jellemzői:

– Kapacitás: 40GB-1TB

– Elérési idő: 10 ms

– Adatátviteli sebesség: 2-10 Mb/s

A beolvasott adatok továbbítása

Beolvasási sebesség

– A mágnesesen rögzített jelek megtalálása

– Mechanikai korlátok (aláfordulási idő, fejmozgás)

Átviteli sebesség

– Az adatok átvitele a memória felé

– Elektronikus (interfész, buszrendszer) korlátok

Sebességkülönbség esetén

– Beolvasási > Átviteli Æ Közbeékelő (interleave) technika

– Átviteli > Beolvasási Æ Szalag (stripping) technika

– Beolvasási ≠ Átviteli Æ Buffer (csak „burst” jelleggel)

Tömörítési eljárások:

Kisebb helyfoglalás Nagyobb számításigény

Gyorsabb adatátvitel Kisebb adatbiztonság

Futás hossz kódolás: sok azonos karakter esetén;

Különbségi kódolás: lassan változó minta esetén;

Huffmann-kódolás: erősen eltérő gyakoriságú karakterek esetén.

Gyakorlatban: Microsoft Drive Space / Double Space

Novell NetWare Compressed Volume

Adattömörítés

Az adattömörítés mind a tároló kapacitás növelésére, mind az adatátviteli sebesség növelésére megoldást kínál.

- veszteséges tömörítők,

- veszteségmentes tömörítés.

1. Futási hossz-kódolás (Run Length Encoding), olyan esetekben alkalmazható a legjobban, ahol egy adatmezőben nagyon sok egyforma elem van.

2. Különbségi kódolás (Difference Encoding) segítségével lassan, fokozatosan változó adatok esetén érhető el jó eredmény. A módszer lényege, hogy nem magát az adatot, hanem csak a változást tárolja.

3. A Huffmann-kódolás: a módszer egy kód összerendelés, mely a tömörítetlen adatok között gyakrabban előfordulókhoz rövidebb, a ritkábbakhoz hosszabb kódot rendel.

Eszközszintű védelem

– lemeztükrözés - lemez megkettőzése

– RAID - adatok redundáns elosztása

Adatbiztonságot javító módszerek:

Adatszintű védelem

– paritásbit - egyetlen bithiba

– hibajavító kód - független hibák

– CRC - összefüggő hibák

Az adatátvitelhez szükséges adatok:

Eszköz típusa

Eszköz sorszáma

Adat kezdőcíme az eszközön

Adat kezdőcíme a memóriában

Adat mennyisége

Átvitel iránya: Írás vagy olvasás

Visszatérési folyamat

A RAID napjaink egyik fontos technológiája, amelynek segítségével sérülés-biztos merevlemez-rendszereket hozhatunk létre kritikus alkalmazásokhoz és hálózatokhoz.

A RAID szintek

A RAID-ben eredetileg 5 szintet határoztak meg: RAID 1-5-ig. Az egyes szintek nem tükröznek minőségi vagy fejlődési sorrendet, egyszerűen különböző megoldásokat javasolnak. Később természetesen újabb szintek is létrejöttek: a 0-ás és 6-os RAID, illetve a különböző ajánlások összekapcsolásával és kombinálásával kapott RAID10 (RAID 0 + RAID 1) és a RAID50 (RAID 0 + RAID 5).

Nagyon fontos, hogy a létrejövő logikai lemez mögött álló technológia teljesen láthatatlan az operációs rendszer számára, a RAID ugyanúgy lekezeli az olvasási, írási és egyéb lemezkezelési műveleteket. A RAID alapötlete a fizikai lemezek csíkokra (stripes) bontása. Ezek a csíkok minden lemezen egyforma méretűek, mely 512 byte-tól néhány megabyte-ig terjedhet. Az adatok nem folytonosan kerülnek egy-egy lemezre, hanem az egymást követő csíkokra round-robin (körbeforgásos) módon.

A RAID 0 mindenféle redundancia vagy paritás nélkül csíkozza az adatokat a meghajtókon. Ez a szint nyújtja a legnagyobb adatátviteli sebességet és kapacitást, mind az írási, mind az olvasási műveletek párhuzamosan történnek. Hátránya, hogy nem biztosít hibatűrést, ezért egyetlen fizikai lemez meghibásodása az egész rendszert használhatatlanná teszi. Nem használnak tartalék-meghajtókat.

Az RAID 1-es szint tükrözi (mirror) az adatokat, azaz az adatok duplikálva vannak. Az írás és olvasáspárhuzamosan történik, ebből következik, hogy az olvasás jóval gyorsabb (kb. 2x) az írásnál. Amennyiben az egyik meghajtó kiesik, az adatok továbbra is rendelkezésre állnak a másikon, emiatt ez a szint elég jó hibavédelmet biztosít.

A védelem ára a kétszeres fizikai lemez-szükséglet. A RAID 1 nem használja a csíkozást, azonban igen elterjedt az 1-es és 0-ás szint összekapcsolásával kapott RAID 10-es rendszer. Nem használnak tartalék-meghajtókat.

A RAID 2 ajánlás már használja a csíkozást, emellett külön meghajtókat használnak paritás információk tárolására Hamming-kód segítségével. A Hamming-kód képes hibadetektálásra és annak javítására. A gyakorlatban nem használják ezt a RAID szintet.

A RAID 3-4 szintén csíkozza a meghajtókat, és egyetlen kitüntetett lemezre írja a paritásadatokat. A két szint közti különbség, hogy a 3-asnál kisméretű csíkokat használnak, míg a 4-es szint nagyméretű blokkokkal dolgozik.

Ha az egyik meghajtó meghibásodik, az adatok rekonstruálhatók a paritást tartalmazó lemez segítségével. Mivel a paritás információt íráskor kell generálni, ezért ez a számításigény kihat a rendszer teljesítményére. A RAID 3 és 4 a legjobban ott állja meg a helyét, ahol sokszor nagy fájlokat, adatokat mozgatnak, és fontos a redundancia. Tartalék-meghajtók hiba esetén átvehetik a sérült lemez szerepét.

A RAID 5 már nem csak az adatokat, hanem a paritás információkat is csíkozva helyezi el a lemezeken. A paritás sorban a következő meghajtóra kerül íráskor, ezzel az egyenletes elosztással kiküszöbölték a kitüntetett paritás meghajtó szűk keresztmetszetét. Az olvasási és írási műveletek párhuzamosan végezhetőek. Szintén írás közben számolja a paritást, de kizáró-vagy (XOR) algoritmust használ, mely kisebb adatmozgatások számára kiváló. Tartalék-meghajtók hiba esetén átvehetik a sérült lemez szerepét.

A RAID 6 csupán az 5-ös szint kibővítése: nem csak soronként, hanem oszloponként is kiszámítja a paritást, így kétszeres meghajtó meghibásodás sem jelent problémát a rendszer egészére nézve. A megnövelt biztonságért cserébe azonban kevesebb hasznosítható terület áll a rendelkezésre.

A felsorolt technikák közül a gyakorlatban főleg a RAID 0-át, RAID 1-et, a RAID 5-öt, és az ezek együttes használatával megvalósított RAID 10-et és 50-et használják elterjedten. A RAID 3 és 4 a paritás meghajtó miatti szűk keresztmetszet miatt nem terjedt el, míg a RAID 6 túl nagy többletköltséggel jár.

Optikai tárolók:

A hangtechnikából átvett CD (Compact Disk) felületén az egyes biteket (a hagyományos hanglemezhez hasonlóan) spirális vonalban elhelyezkedő, 0,5 ?m átmérőjű kiemelkedések (pit) és a köztük lévő sík területek (land) reprezentálják.

Az adattárolás alapvetően más formáját valósítják meg az optikai lemezek. A 8 vagy 12 cm átmérőjű műanyag korongokon 650-1300 MB, sőt a legfrissebb technológia a DVD (Digital Versatile Disk) alkalmazásával 17 GB adat is tárolható.

A holografikus lemez ugyanakkora, mint a DVD, nagy kapacitású, egy bélyegnyi helyen 2-10GB adat tárolható. A MILLIPEDE 2 dimenzióban tárolja az adatokat, úgy működik, mint a lyukkártya, 20-szor nagyobb a kapacitása, mint a mágneses lemezeknek. MODS, 250GB adat tárolására képes oldalanként.

• Technikai jellemzői:

– Kapacitás: 650MB-14GB

– Elérési idő: 300 ms-tól

– Adatátviteli sebesség: 150 kb/s-tól

• Alkalmazása:

– Archiválás

– Program kereskedelem

– Nagy adatbázisok, lexikonok

Eszközmeghajtók

Az eszközmeghajtók az operációs rendszer magjának a részei, és mint ilyenek, feladatuk egyrészt a hardver hatékony kihasználása, másrészt a felhasználó, illetve felhasználói folyamat kiszolgálása úgy, hogy a hardver részletei minél inkább a háttérben maradjanak.

A felhasználói folyamatok, ha valamilyen perifériára van szükségük, egy rendszerhívást adnak, melyet a kernel egy folyamata fogad, és ad tovább az eszközvezérlőnek.

Az átvitelhez szükséges adatok:

A lemezegység egy számhármast vár, mely megadja, hogy a kívánt blokk melyik lemezoldal melyik szektorának melyik sávjába található.

Fej sorszáma [H]	Melyik lemez, melyik oldalán található a keresett blokk?
Szektor sorszáma [S]	Melyik szektorban van az adat?
Cilinder sorszáma [C]	Melyik cilinderen van a blokk?
Írás vagy Olvasás	Az adatáramlás irányának meghatározása

A lemez eszközmeghajtójának felépítése:

A réteges felépítési elvnek megfelelően az eszközmeghajtó további funkcionális egységekre bontható. Legegyszerűbb, ha különválasztjuk a folyamatokkal kapcsolatot tartó részt, és az eszközzel kommunikáló részt.

Szinkron átvitelnek nevezzük a műveletet akkor, ha a kérő folyamat a művelet befejezéséig a várakozási sorban tartózkodik. Ekkor a folyamat nem érzékeli az adatátvitel sebességét, hiszen mikor újra futhat, már minden kért adat rendelkezésére áll.

Szinkron:

A kérés (rendszerhívás) átadása után

– A folyamat felfüggesztődik,

– Elveszti erőforrásait (átvitel az OS területére)

– A felelősség a biztonságért az operációs rendszeré

Az aszinkron átvitel a másik alternatíva. Ez esetben a folyamat nem várakozik, viszont a folyamatnak is, az operációs rendszernek is komoly gondot okoz, hogy az éppen feltöltés alatt álló területek, és a források sem változhatnak az átvitel alatt. Külön gond, hogy egy folyamat az átvitel alatt akár be is fejeződhet, és nincs, aki felszabadítsa a foglalt memóriarészt.

Aszinkron

A kérés (rendszerhívás) átadása után

– A folyamat tovább fut,

– Megtartja erőforrásait (átvitel az FOLYAMAT területére történik),

– A biztonságért a folyamat a felelős.

Lemezütemezési algoritmusok:

Algoritmus	Várakozási idő	Várakozási idő szórása
Sorrendi: FCFS	nagy	kicsi
Legrövidebb idejű: SSTF	kicsi	nagy
Pásztázó: SCAN	közepes	közepes
Egyirányú pásztázó: C-SCAN	közepes	kicsi

Sorrendi kiszolgálás (First Come First Served - FCFS)

Legkisebb elérési idő módszere: (Shortest Seek Time First - SSTF)

Pásztázó (Scan, Look)

Egyirányú pásztázás (Circular Scan, C-Scan)

A DMA vezérlő természetesen csak valóságos, fizikai címekkel tud valamit kezdeni, hardver eszköz lévén számára értékelhetetlenek a virtuális memória lehetőségei. Szinkron átvitel esetén az operációs rendszernek kell átmenetileg területet biztosítania a várakozó folyamat adatainak, majd a művelet befejezése után át kell azokat másolnia a folyamat területére.

Lemezgyorsító (Disk cache)

Körkörös átmeneti tár (Buffer pool)

Átmeneti tárak (Buffer pool)

A felhasználói folyamat szintjén kínál megoldást az átmeneti tárak tömbjének

(buffer pool) kialakítása a felhasználói folyamat memóriaterületén. Bufferek segítségével úgy valósítható meg aszinkron adatátvitel, hogy sem a folyamat, sem a rendszermag számára nem jelent sok többlet terhet. A másik előny, hogy a folyamat maga tudja eldönteni, hogy mennyi területre van szüksége, és nem kell versenyeznie az operációs rendszer buffereiért. Általában külön bufferek kialakítása célszerű az írási és az olvasási műveletek megvalósítására. A nyilvántartást tovább egyszerűsíti, ha az egy blokknyi méretű tároló helyeket körkörösen alakítjuk ki.

Lemezgyorsítás (Disc caching)

Szinkron átvitelnél tehát feltétlenül szükség van az operációs rendszer támogatására, azonban ebből kis ráfordítással még előny is kovácsolható. Ha az operációs rendszer adatterületén hozunk létre buffereket, és azokba nemcsak a kívánt blokkot, hanem az azt követő néhány blokkot is beolvassuk, a lokalitási elv értelmében “előre dolgozunk”, mivel feltehetően a folyamat legközelebb a következő blokkokat szeretné olvasni. Írás esetén a folyamatnak elegendő csak az operációs rendszer bufferébe tölteni adatait, és kiadni a megfelelő címet, és utána nyugodtan rábízhatja magát a kernel folyamataira. A módszer rokonságot mutat mind a hardver-gyorsítótár (cache), mind a virtuális memória lapcsere algoritmusával.

A rendszerszintű buffer (Disk Cache) alkalmazásakor a háttértárhoz forduló folyamat először a kernelhez küld rendszerhívást, az azonban nem továbbítja ezt azonnal az eszközvezérlőnek, hanem megnézi, hátha a saját buffereiben

megvan a kívánt adat. Ha igen, elvégezhetők a módosítások minden lemezművelet nélkül, azonban a változtatás csak a memóriabeli másolatot érinti! Az operációs rendszernek számon kell tartania a változtatásokat, és időről időre, vagy legalábbis a folyamat megszűnésekor szinkronizálni kell a memóriaképet a valóságos háttértár tartalommal. Egyes megvalósításokban az olvasási és írási bufferelés külön-külön engedélyezhető. A lemezgyorsító, bufferelő algoritmust néha külön program valósítja meg (MS-DOS, Smartdrive), de gyakran az operációs rendszer szerves része (NetWare, Windows 95).

Blokkméret optimalizálása:

Az adatállományok mérete általában nem egyezik meg pontosan egy blokk méretével. Vagy kisebb, vagy nagyobb. A lemezegység azonban blokkokat tud kezelni, annál kisebb adategység számára nem létezik. Az adatcsoportok a lemezen annyi blokkot foglalnak le, amennyi még éppen szükséges, azaz a lefoglalt blokkok együttes mérete éppen egyenlő az adatcsoport méretével, vagy nagyobb annál. A blokkméret helyes megválasztása tehát nem más, mint optimumkeresés a lemez férőhely, és az operatív memória pazarlása között.

Tárolórendszer követelményei:

Hagyományos szempontok:

Kapacitás (tera/peta bájt nagyságrendű),

Adatátviteli sebesség (>100 Mbyte/sec),

Elérési idő (minimális, de nagyon változó).

Hagyományos, de egyre fontosabb szempontok:

Megbízhatóság, rendelkezésre állás,

Rugalmas konfigurálhatóság, bővíthetőség.

Összefoglalás:

• Fizikai lemezkezelés:

– Ütemezés: FCFS, SSTF, Scan változatok

– Logikai-fizikai cím konverzió

– Blokkméret optimalizálás

• Tömörítés:

– RLE, DE, Huffmann

• Adatvédelem:

– Szoftver: paritás, CRC

– Hardver: tükrözés, RAID

Korszerű tároló architektúrák:

Tárolórendszer követelményei:

Hagyományos szempontok:

Kapacitás (tera/peta bájt nagyságrendű),

Adatátviteli sebesség (>100 Mbyte/sec),

Elérési idő (minimális, de nagyon változó).

Hagyományos, de egyre fontosabb szempontok:

Megbízhatóság, rendelkezésre állás,

Rugalmas konfigurálhatóság, bővíthetőség.

Hagyományos rendszerek korlátai:

Korlátozott kapacitás,

Rögzített konfiguráció, nem rugalmas,

Mentés helyi hálózaton (LAN),

Meghatározott szállítók (nem nyílt rendszer),

Platformfüggőség.

Erőforráskezelés

Erőforrások csoportosítása:

1). -Hardver erőforrások,

-Szoftver erőforrások.

2). -Hagyományos,

-Operációs rendszer által létrehozott erőforrások.

3). -Megosztható (sharable) és megszakítható, elvehető (preemptive).

-Nem megoszthatók (non-sharable) és nem megszakíthatók, nem elvehetők (non-preemptive).

Az erőforrás kezelő (resource manager) a rendszermag azon része, amely az erőforrások elosztásáért és lefoglalásáért felelős.

Összefoglalásul megállapíthatjuk, hogy az erőforrás kezelő gondoskodik a számítógép (rendszer) erőforrásainak (a futó folyamatok igényei alapján történő) hatékony, gazdaságos elosztásáról, illetve az erőforrások használatáért vívott versenyhelyzetek kezeléséről.

Erőforrások:

– Erőforrás foglalási gráf

– Holtpont, Kiéheztetés

Holtpontkezelő stratégiák

– Megelőzés

– Felszámolás

– Közösen használt erőforrások problémái

Erőforráskezelés alapfogalmai:

• Feladat

• a számítógéprendszer erőforrásainak elosztása (a futó folyamatok igényei alapján)

• illetve az erőforrások használatáért vívott versenyhelyzetek kezeléséről

• Céljai:

–a rendszer működését gazdaságossá tenni

–elkerülni a holtponthelyzetek kialakulását és/vagy felszámolni a kialakult holtponthelyzeteket

HOLTPONT – Deadlock: Több folyamat egy olyan erőforrás felszabadulására vár, amit csak egy ugyancsak várakozó folyamat tudna előidézni.

KIÉHEZTETÉS – Starvation:

Egy folyamat - az erőforrás-kezelő stratégiája miatt - beláthatatlan ideig nem jut erőforráshoz.

Erőforrások csoportosítása:

Hardver erőforrások (processzor, memóriák, I/O csatornák, perifériák)

Szoftver erőforrások (programok, adatállományok - egyre fontosabbak)

“hagyományos” erőforrások (nyomtatók, szövegszerkesztők)

Az operációs rendszer által létrehozott erőforrások (lapok, pufferek, floppy blokkok, adatállományok, tartalomjegyzékek)

Elvehető erőforrások (processzor, memória)

Nem elvehető erőforrások (index állomány, nyomtató)

Gazdaságosság:

Valamilyen költségfüggvény minimalizálása:

– kihasználtság

– válaszidő

Egyéb szempontok (ellentmondóak):

– átlagos átfutási idő minimalizálása

– a lassú válaszok számának minimalizálása

– a (hardver) kihasználtság maximalizálása

– maximális kihasználtság adott válaszidő-korlát mellett

Tendencia: a kihasználtság háttérbe szorul (HW ára csökken!) a válaszidővel szemben.

Az erőforrások lefoglalása:

Statikus lefoglalás

– a folyamat indulása előtt lefoglalja az összes szükséges erőforrást

• Pazarló,

• Kiéheztetés,

• Ha egyszer elindult, erőforrás korlát miatt nem áll le.

Dinamikus lefoglalás

– a folyamat csak akkor igényel erőforrást, amikor éppen szüksége van rá

• Hamar elindulhat egy folyamat, de versenyzés miatt lassabban fut(hat),

• Teljesítőképesség, átbocsátóképesség nő,

• Nagy probléma: holtpont.

Holtpont kialkulás lehetőségének feltételei:

1. Kölcsönös kizárás van

2. Várakozás közben lekötés történik

3. Rablás nincs

4. Ciklikus várakozás van

A feltételeknek EGYSZERRE kell teljesülniük a holtpont kialakulásához, vagyis HA LEGALÁBB AZ EGYIK FELTÉTEL NEM TELJESÜL, NEM

ALAKULHAT KI HOLTPONT!

Holtpont kialkulás lehetőségének feltételei:

Holtpont-kezelési stratégiák:

• A holtpont megelőzése:

– A négy feltétel (legalább) egyikét nem engedjük teljesülni

– NEM MINDIG LEHETSÉGES (a korlátozó feltételek miatt)

• A kialakult holtpont felismerése és megszüntetése:

A megelőzés “olcsóbb”

A holtpont megelőzése:

→Kölcsönös kizárás:

Ezzel a feltétellel nem tudunk mit kezdeni, vannak olyan erőforrások, melyeket egyszerre csak egy folyamat használhat (pl. nyomtató).

→Várakozás közbeni lekötés:

Egy folyamat csak akkor igényelhet újabb erőforrást, ha nincs más lekötött erőforrása.

Megoldások:

– Statikus erőforrás-kezelés,

– Ha egy folyamat erőforrást igényel, el kell, engedje az összes korábban lefoglalt erőforrását.

Hátrányok:

– rossz az erőforrások kihasználtsága,

– kiéheztetés.

→Erőforrásrablás:

1. Ha egy folyamat egy olyan erőforrást igényel, amit nem tud megkapni azonnal (vagyis várakoznia kell), akkor elvesszük tőle az ÖSSZES lefoglalva tartott erőforrását, akkor folytatódhat, ha visszaszerezte az összes régit és megszerezte az újat is.

2. Ha egy folyamat olyan erőforrást igényel, amit más VÁRAKOZÓ folyamat foglal, ezt attól elveszi; ha az igényelt erőforrást egy nem várakozó folyamat használja, akkor az IGÉNYLŐ folyamat kerül várakozó állapotba, és TŐLE rabolhatnak a többiek.

E módszerek CSAK az elvehető erőforrásokra alkalmazhatók.

→Ciklikus várakozás:

1. módszer

Minden erőforráshoz egy (a többitől különböző) sorszámot rendelünk.

A folyamatok az erőforrásokat csak azok sorszámaik szerint növekvő sorrendjében igényelhetik (ezért célszerű, ha a sorszámokat az erőforrások természetes felhasználási sorrendje szerint osztjuk ki).

Másképp fogalmazva: ha egy folyamat egy bizonyos sorszámú erőforrást igényel, fel kell szabadítania az összes általa lefoglalt, az igényeltnél NAGYOBB sorszámú erőforrást.

Hátrány: csökken a rendszer áteresztőképessége.

2. módszer

Az operációs rendszer csak akkor engedi meg egy új erőforrás lefoglalását, ha ennek teljesítése után a rendszer ún. BIZTONSÁGOS állapotban marad.

Biztonságos állapot: az összes folyamat erőforrás igénye valamilyen sorrendben kielégíthető.

Nem biztonságos állapot: holtpont kialakulhat (nem biztos, hogy kialakul!)

Hátrányok: Olyan pluszinformáció szükséges (a maximális igény), amely sokszor nem tudható előre. Bonyolult algoritmus.

Holtpont megelőző stratégiák:

→ Egyetlen foglalási lehetőség:

• Csak az a folyamat foglalhat erőforrást, amelyik egyetlen egy fölött sem rendelkezik.

Előny: – nincs holtpont.

Hátrány: – Rossz erőforrás kihasználás, kiéheztetés veszélye.

→ Rangsor szerinti foglalás:

• Egy folyamat csak olyan osztályból igényelhet erőforrást, melynek sorszáma magasabb, mint a már birtokolt erőforrások sorszáma.

Előny: – Nincs holtpont.

Hátrány: – Pazarló, önkényes

→Bankár algoritmus:

A bankár algoritmus úgy kerüli el a holtpont kialakulásának lehetőségét, hogy a rendszert mindig biztonságos állapotban tartja.

Előny:– nincs holtpont

– az előzőeknél hatékonyabb

Hátrány:– sok számolást igényel,

– előzetes feltevéseken alapul.

Sohase elégítsünk ki egy igényt, ha az, bizonytalan állapotot eredményez. Egy állapotot akkor tekintünk biztonságosnak, ha létezik legalább egy olyan sorozat, amely szerint az összes folyamat erőforrás igénye kielégíthető.

Bankár algoritmus: 1. példa

Aktuális állapot:

Összesen 12 db erőforrás

A és B folyamatok

	Foglal	Maximális igény	Várható igény
A	4	6	2
B	4	11	7
Szabad	4

Várakozó C folyamat: BEENGEDHETŐ?

C

2

8

6

Próba:

	Foglal	Maximális igény	Várható igény
A	4	6	2
B	4	11	7
C	2	8	6
Szabad	2

A lefut:

	Foglal	Maximális igény	Várható igény
B	4	11	7
C	2	8	6
Szabad	6

C lefut:

	Foglal	Maximális igény	Várható igény
B	4	11	7
Szabad	8

B is le tud futni!

Példa 2.

	Foglal	Maximális igény	Várható igény
A	4	6	2
B	4	11	7
Szabad	4

C folyamat: BEENGEDHETŐ?

C

2

9

7

	Foglal	Maximális igény	Várható igény
A	4	6	2
B	4	11	7
C	2	9	7
Szabad	2

A lefut:

	Foglal	Maximális igény	Várható igény
B	4	11	7
C	2	9	7
Szabad	6

C igényeit nem tudja kielégíteni az operációs rendszer!

Bankár algoritmus:

1. - Felírjuk a folyamatok által maximálisan igényelt erőforrások számait, tartalmazó mátrixot (MAX. IGÉNY).

2. - Felírjuk a folyamatok által lefoglalva tartott erőforrások számait, tartalmazó mátrixot (FOGLAL).

3. - A MAX. IGÉNY-ből FOGLAL-t kivonva kapjuk a még kielégítetlen igényeket, leíró mátrixot (IGÉNY).

4. - Erőforrás fajtánként összeadjuk a lefoglalva tartott erőforrások számait, majd ezeket kivonva az egyes erőforrások összes darabszámából kapjuk a pillanatnyilag rendelkezésre álló erőforrás készletet (KÉSZLET).

5. - Megnézzük, hogy a KÉSZLET-ből kielégíthető-e valamelyik folyamat igénye

6a. - Ha nincs ilyen folyamat, a rendszer NEM BIZTONSÁGOS állapotban van

6b. - Ha van ilyen folyamat, kielégítjük igényét

7. - A kiválasztott folyamat a lefutása után felszabadítja az összes általa használt erőforrást, azaz KÉSZLET új értékét megkapjuk, ha előző értékéhez hozzáadjuk a folyamat által eredetileg lefoglalva tartott erőforrások számát (FOGLAL megfelelő sorát)

8. - Visszamegyünk az 5. lépésre

A holtpont felismerése:

Folyamatos adatgyűjtés az erőforrások szétosztásáról és a ki nem elégített igényekről.

Ezen adatokból a holtponthelyzetet detektálni képes algoritmus ismételt futtatása.

– ha egy igényt nem lehet azonnal kielégíteni:

• gyakran kell futtatni, sok plusz idő

– előre megbecsült időnként: – ezalatt, holtpont (akár több is) kialakulhat

• nagy felélesztési veszteség.

Holtpontból való felélesztés:

Megszüntetjük a holtponti helyzetben lévő folyamatokat - nagy veszteség.

Finomítás: EGYENKÉNT szüntetünk meg holtponti helyzetben lévő folyamatokat, amíg a holtpont fennáll - kisebb veszteség.

Sokszor elég, ha a folyamatot nem szüntetjük meg teljesen, hanem egy előző állapotából folytatjuk -ellenőrző pontok (check point).

– nagy tárigény,

– sok plusz időt igényel a folyamatok állapotának periodikus mentése.

Ugyanaz a folyamat nem választható akárhányszor áldozatul (kiéheztetés).

→ Áldozatkijelölési szempontok:

Melyikkel hány erőforrást nyerek?

Hány további erőforrást igényel még?

Mennyi már elhasznált CPU időt ill. I/O munkát vesztek?

Mennyi van még hátra a futásából?

Ismételhető / nem ismételhető folyamat-e?

A folyamat prioritása!

Megszüntetése hány további folyamatot érint?

→ Erőforrásrablás:

A holtponti helyzetben lévő folyamatoktól erőforrásokat rablok el.

Veszteség, ha nem elvehető erőforrást kell elvenni.

Áldozatkijelölés az előzőhöz hasonló szempontok szerint.

A holtpontkezelés két legnagyobb veszélye:

1) Az egyik az ún. alulszabályozás, vagyis az, ha olyan túlbiztosításra törekszünk, hogy ezáltal ugyan holtpont nem fog kialakulni, de a rendszer lehetőségeit nem tudjuk kihasználni.

2) A másik probléma az ún. túlszabályozás, azaz az, ha olyan bonyolult, számítás- és/vagy memóriaigényes algoritmust választunk, hogy maga az algoritmus futtatása lassítja le katasztrofálisan a rendszert.

Erőforrás-kezelő stratégiák összehasonlítása:

Holtpontkezelési módszerek:

Közös erőforrások:

Kölcsönös kizárás:

A közös adatterületet egyszerre csak egy folyamat használhatja!

Közösen használt erőforrások: Termelő / fogyasztó probléma

A közös adatterületet (KÖZÖS ERŐFORRÁS) egyszerre csak egy folyamat használhatja (KÖLCSÖNÖS KIZÁRÁS).

Vezérlés: szemafor

1. a szemafor olvasása

2. a beolvasott érték vizsgálata

3. ha szabad a szemafor: 5. és foglaltra állítás.

4. ha foglalt: vissza 1-re

5. az erőforrás használata

(írás a közös memóriába)

6. a szemafor szabadra állítása

1. a szemafor olvasása

2. a beolvasott érték vizsgálata

3. ha szabad a szemafor: 5. és foglaltra állítás.

4. ha foglalt: vissza 1-re

5. az erőforrás használata

(írás a közös memóriába)

6. a szemafor szabadra állítása

P és V primitívek:

Primitív: megszakíthatatlan (oszthatatlan) művelet

P primitív: FOGLALTTÁ ÁLLÍTÁS

– 1. a szemafor olvasása

– 2. a beolvasott érték vizsgálata

– 3. ha szabad: a szemafor foglaltra állítása

– 4. ha foglalt: vissza 1-re

V primitív: SZABADDÁ ÁLLÍTÁS

– A szemafor szabadra állítása

Bináris szemaforról beszélünk, akkor, ha a vezérlés folyamatosan megy le.

Osztatlan művelet esetén az első négy lépést egyben végzi az operációs rendszer, mert így egy másik (majdnem ugyanabban az időben érkező) folyamat már a termelő által beállított tilos jelzést találja.

Torlódásvezérlő szemafor. Postaláda: olyan közös adatterület, ahová EGYNÉL TÖBB (pl. N db.) üzenet írható nem zavarhatja meg, a már futó folyamatot.

Folyamat- és processzorkezelés

• Folyamatok létrehozása,

• Műveletek folyamatokkal,

• Speciális állapotok,

• Processzorütemezés.

Az idővel való gazdálkodást ütemezésnek (scheduling) nevezzük. Az ütemezés során a folyamatok állapota változik meg. Attól függően, hogy milyen állapotok között történik váltás, az ütemezők több szintjét definiálhatjuk.

A főütemező (high-level scheduler) vagy magas szintű ütemező választja ki a háttértárolón lévő programok közül azt, amelyik az operációs rendszer közvetlenebb felügyelete alá kerülhet, elkezdődhet a végrehajtása, azaz folyamattá válhat.

Operációs rendszer (Erőforrás szemlélet): A folyamatok egy olyan csoportja, amely a felhasználói folyamatok között elosztja az erőforrásokat.

Folyamatok: 1. „Életre kelt” programok.

2. Olyan programok, amelyeknek van folyamatleíró táblája.

Az operációs rendszernek azonban mindenképpen rendelkeznie kell egy olyan komponenssel, amely a futni készülő programokhoz, avagy folyamat csírákhoz Folyamatleíró blokkot (PCB - Process Control Block) rendel, és a betölti azt a memóriába.

Folyamatleíró/vezérlő blokk (Process Control Block - PCB):

Egyértelműen azonosítja a folyamatot, minden információ megtalálható benne, ami az operációs rendszer számára szükséges:

– Folyamat azonosítója, szülő, gyerekek;

– Folyamat állapota (új, futásra kész, aktív, várakozó stb.);

– PC + regiszterek tartalma (a következő utasítás címe);

– Erőforrások állapota (ki nem elégített I/O igények, a folyamathoz rendelt I/O eszközök, megnyitott állományok);

– CPU ütemezési információ (prioritás, CPU igény);

– Elszámolási adatok, statisztikák (rendszerben eltöltött idő);

– Memóriaterület adatai, címtranszformációs táblák.

A PCB minden információt tartalmaz, ami a folyamat futásához szükséges. Az operációs rendszer szempontjából a PCB maga a folyamat, a folyamat állapota kizárólag attól függ, hogy az operációs rendszer éppen mit kezd a folyamatleíró blokk adataival. Ha az adatok a processzor regiszteribe kerülnek, akkor a folyamat fut, egyébként a PCB feltehetően valamelyik várakozási sor egyik elemét alkotja.

Várakozási sor (queue):

A folyamatok közül egyidejűleg csak egy futhat, tehát a többinek valamire várnia kell (I/O eszköz, CPU, memória stb.), tehát egy várakozási sorba kell állnia.

Funkció: A folyamatok (PCB-k) egy olyan sora, melyben minden elem utal az őt követő elemre.

Megvalósítás: láncolt adatstruktúra (lista).

Tipikus: FIFO (First In First Out), (ami először bemegy, az jön ki először).

Műveletek: hozzáfűzés, beékelés.

Verem – verem kezelés (LIFO): A folyamat elmentődik, amíg újra nem futhatnak.(Linux-nál: folyamatos ürítés – így folyamatok veszhetnek el – ellenben Windows- nál ha a verem megtelik, akkor a veremben lévő folyamatok végződnek el először.)

A várakozási sor egy olyan lista, melynek minden eleme egy adatból és egy mutatóból áll.

Folyamatok állapotai:

A várakozási sorok megfelelnek a folyamatok állapotainak.

• FUTÁSRA KÉSZ (már csak a CPU hiányzik)

– Megszakított (pl. kivétel, I/O művelet)

• FUT

• VÁRAKOZIK (további erőforrásra)

– Holtponti (ha reménytelenül vár valamire)

• FELFÜGGESZTETT (erőforrás nélkül, csak PCB)

Környezet váltás:

A PCB-k, és a benne foglalt adatok képezik az operációs rendszer folyamatainak környezetét, kontextusát (context). Ha a rendszerfolyamat egy másik felhasználói folyamattal akar foglalkozni, a környezetét kell átkapcsolni.

Ez a művelet a környezetváltás (context switching).

A folyamatok alapállapotai:

Mikor a főütemező elvégezte feladatát, és létrehozta az új folyamatot, az a futásra kész programok sorába kerül. Innen az operációs rendszer egy folyamata, az alacsony szintű ütemező, kiveszi, és átadja futtatás céljából a processzornak, azaz elindul.

Az állapot átmenetek:

1. Elindul (dispatch): A központi egység felszabadulása esetén az alacsonyszintű ütemező a KÉSZ állapotban lévő folyamatok közül választja ki azt, amelyik a FUT állapotba kerülhet.

2. Megszakad (timer runout): Ha a futó folyamat számára biztosított idő lejár, visszakerül a FUTÁSRA KÉSZ állapotba. (Nem mindegyik operációs rendszer teszi lehetővé, hogy egy folyamatot megszakítsunk, ehhez a rendszernek, illetve a folyamatnak megszakíthatónak (preemptív) kell lennie).

3. Vár (wait, block) Amennyiben olyan erőforrásra van szüksége, amely éppen foglalt, a FUT állapotból, a VÁRAKOZIK állapotba jut.

4. Feléled (awake) a várt esemény bekövetkezése esetén a folyamat,

FUTÁSRA KÉSZ állapotba kerül, újra beáll a processzorra várakozó folyamatok sorába.

Ha túlságosan sok folyamat került futásra kész állapotba, előfordulhat, hogy egyiknek sem jut megfelelő mennyiségű erőforrás, és a processzor idejének javát rendszeradminisztrációval, például környezetváltásokkal tölti.

A középtávú, vagy más néven közbenső szintű ütemező (medium-term scheduler) ilyenkor beavatkozik, és egyes folyamatok felfüggesztésével, vagy a prioritási szintek időszakos változtatásával helyreállítja a hatékony működés feltételeit.

A felfüggesztett (suspended) folyamatok időlegesen kiszállnak az erőforrásokért folyó versenyből, de folyamatok maradnak, és futásuk a helyzet jobbra fordulása után bármikor folytatható.

Processzorütemezés:

Az operációs rendszerek talán legaktívabb komponense, az alacsony szintű ütemező. Az alacsony szintű ütemezővel szemben támasztott legfőbb követelmény a gyorsaság.

Ütemezési szintek:

1. Várakozási idő (waiting time, missed time): megadja, hogy a folyamat mennyi időt töltött tétlen várakozással.

2. Átfutási idő (penalty ratio): a folyamat érkezésétől annak befejezéséig eltelt idő.

3. Válaszidő (response time) azaz idő, ami a folyamat rendszerbe állításától az első futás kezdetéig telik el. Interaktív rendszereknél nagyon fontos, hogy a felhasználók megnyugodjanak, programjuk elindult, nincs nagyobb baj.

A fenti paramétereken kívül mindhárom esetben nagyon tanulságos a szórás, illetve a folyamat igényére vonatkoztatott arányszám is.

Előbb jött, előbb fut (First Come First Served - FCFS):

A folyamatok érkezési sorrendben futhatnak.

Előny: egyszerű, biztos.

Hátrány: a folyamatok érkezési sorrendjétől nagymértékben függő várakozási idő.

Legrövidebb előnyben (Shortest Job First - SJF):

A folyamatok közül először a legrövidebb fut.

Előny: a legrövidebb várakozási időt adja.

Hátrány: a hosszú folyamatokkal mostohán bánik.

Körben járó algoritmus (Round Robin - RR):

Minden folyamat egy adott időszeletig futhat, majd újra sorba kell állnia.

Előny: demokratikus, a legrövidebb a válaszideje.

Hátrány: jelentős adminisztrációt igényel.

Prioritásos módszerek:

A folyamatokat fontosság szerint rangsorba állíthatjuk, ez persze felborít minden egyszerű algoritmust. A prioritás az FCFS és SJF technikáknál azt jelenti, hogy a magasabb rendű folyamat a várakozási sor elejére kerül. Az RR algoritmus az elsőbbséget nagyobb időszelet biztosításával is el lehet érni. A prioritásos rendszereknél fennáll a veszélye annak, hogy a kevesebb joggal rendelkező folyamatok háttérbe szorulnak, nem futhatnak.

A prioritás azonban a gyengék javát is szolgálhatja. Ha a várakozási sorban lévő folyamatok prioritását idővel automatikusan növeljük, előbb-utóbb az alacsony jogú, hátrányos helyzetű folyamatok is futhatnak.

Processzorütemezés

Egy rendszer az alábbi erőforrásokkal gazdálkodik:

E1: 240 példány

E2: 36 példány

E3: 8 példány

A rendszerben levő processzek: P1, P2, P3, P4.

Biztonságos-e holtpontmentesség szempontjából a következő állapot?

	FOGLALT			MAXIMÁLIS IGÉNY			IGÉNY
	E1	E2	E3	E1	E2	E3	E1	E2	E3
P1	53	14	4	67	15	5	14	1	1
P2	0	5	1	13	5	3	13	0	2
P3	46	17	0	107	27	5	61	10	5
P4	127	0	1	132	25	4	5	25	3

A pillanatnyilag lefoglalt erőforrásokat tartalmazó mátrix oszlopait összeadva és az eredményt az összerőforrás-számból kivonva megkapjuk a pillanatnyilag szabad erőforrások számát:

E1=240-(53+0+46+127)=240-226=14

E2=36-(14+5+17+0)=36-36=0

E3=8-(4+1+0+1)=8-6=2

Ebből látszik, hogy a szabad erőforrásokból (14,0,2) kielégíthetjük P2 (13,0,2) igényét. P2 lefutása után felszabadítja az általa lefoglalt erőforrásokat (0,5,1) is. Ezt hozzáadva az eredetileg szabad erőforrások számához (14,0,2), kapjuk a szabad erőforrások új számát: (14,5,3). Ebből kielégíthető P1 igénye, amely lefutása után a szabad erőforrások új száma (14,5,3)+(53,14,4)=(67,19,7) lesz. Ebből kielégíthető P3 igénye, amely lefutása után a szabad erőforrások új száma

(67,19,7)+(46,17,0)=(113,36,7) lesz, amelyből kielégíthető P4 igénye. Vagyis a folyamatok erőforrás igénye P2, P1, P3, P4 sorrendben kielégíthető, tehát a rendszer holtpontmentesség szempontjából BIZTONSÁGOS!

Várakozási időérték számítás

Határozza meg az alábbi terhelés esetén az átlagos várakozási időértékét a következő CPU ütemezési algoritmusok mellett:

a. FCFS (előbb jött - előbb fut);

b. SJF (legrövidebb először);

c. Round-Robin (időszelet 10 egység).

Process	Érkezési idő (futásra kész sorba)	CPU igény
P1	0	15
P2	8	7
P3	12	26
P4	20	10

a. FCFS:

Ennél a módszernél a folyamatok érkezési sorrendben kapják meg a processzor használati jogát. A várakozási idő értelemszerűen a kezdési időpont és az érkezési időpont különbsége.

Processz	Érkezési idő	CPU igény	Kezdési időpont	Befejezési időpont	Várakozás (kezd.- érk.)
P1	0	15	0	15	0
P2	8	7	15	22	7
P3	12	26	22	48	10
P4	20	10	48	58	28
					45

Átlagos várakozási idő: 45/4=11,25.

A kezdési időpont az előző processz befejezési időpontja, a befejezési időpont a kezdési időpont és a CPU igény összege.

b. SJF:

Ennél a módszernél meg kell vizsgálni, hogy egy folyamat befejezésekor a várakozó folyamatok közül melyik a legrövidebb, és az kapja meg a processzor használati jogát. Tehát itt az érkezési és a végrehajtási sorrend, különböző lehet!

Processz	Érkezési idő	CPU igény	Kezdési időpont	Befejezési időpont	Várakozá-si idő	Befejezés-kor váró proc-k	Következő Legrövi-debb
P1	0	15	0	15	0	P2 (7), P3 (26)	P2
P2	8	7	15	22	7	P3 (26), P4 (10)	P4
P3	12	26	32	58	20	- , -	-
P4	20	10	22	32	2	P3 (26)	P3
					29

Átlagos várakozási idő: 29/4=7,25.

c. Round Robin:

Ennél a módszernél egy folyamatot az időszelet letelte után felfüggesztünk, és a várakozási sor végére rakjuk be. A táblázatban csillaggal jelöltük meg a korábban felfüggesztett folyamatok ismételt futását és ilyenkor az érkezési időpont oszlopában, zárójelben a felfüggesztés idejét adtuk meg.

Processz	Érkezési idő	CPU igény	Kezdési időpont	Befejezési időpont	Maradék igény	Várakozá-si idő	Befejezéskor váró proc-k
P1	0	15	0	10	5	0	P2, P1
P2	8	7	10	17	0	2	P1, P3
P1*	(10)	5	17	22	0	7	P3, P4
P3	12	26	22	32	16	10	P4, P3
P4	20	10	32	42	0	12	P3
P3*	(42)	16	42	52	6	10	P3
P3*	(52)	6	52	58	0	0	-
						41

Átlagos várakozási idő: 41/4=10,25.

(Megjegyzés: az átlagos várakozási idő mindig a folyamatok összes várakozási ideje osztva a folyamatok darabszámával.)

Memóriakezelés

A valóságos és a virtuális tárkezelés között a különbség az, hogy a valós tárkezelés esetében az éppen végrehajtott folyamathoz tartozó programutasításoknak és adatoknak teljes egészében az operatív memóriában kell tartózkodniuk, míg virtuális tárkezelés esetén csak az éppen végrehajtás alatt álló rész van az operatív tárban, a program és az adatok többi része a háttértáron található.

Rögzített címzés:

Az operációs rendszer állandó területen, például a memória legelső, legkisebb című rekeszein helyezkedett el, a felhasználói program használhatta az operációs rendszer végétől egészen a legnagyobb címig az egész memóriát. A program változóinak, illetve vezérlésátadásainak címe így már fordítás közben meghatározható volt.

A tárvédelem is elég egyszerű ebben az esetben, mindössze azt kell figyelni, hogy a határregiszterben tárolt címnél kisebbet a felhasználói program ne érhessen el, mert az már az operációs rendszer fennhatósága.

Áthelyezhető címzés:

A programok fordításakor a fordítóprogram már nem közvetlen fizikai címeket generált, hanem a program elejéhez képesti relatív címeket. A bázisregiszter tartalmazza a program kezdő- vagy más néven báziscímét. A processzor minden memória műveletnél automatikusan hozzáadja a bázisregiszter tartalmát az utasításban szereplő címhez és az így kapott összeg lesz az a fizikai memóriacím, amihez fordul.

Átlapoló (overlay) módszer:

Lényege: hogy a memóriában állandóan csak a programrészek közötti átkapcsolást végző modulnak kelljen tartózkodnia, a többiek közül hol az egyik, hol a másik rész került a memóriába, a többi a háttértáron várakozott. Így a program mérete meghaladhatja a memória méretét, és a háttértár, nem csak a programok tárolására szolgál, hanem a program futtatásában is részt vesz.

Tárcsere (swapping):

Több felhasználó estén a legegyszerűbb és legősibb mód, ha minden felhasználó kap egy bizonyos időszeletet, majd ha az lejár, az általa használt egész memóriaterületet az operációs rendszer a háttértárra másolja, és onnan betölti a következő felhasználóhoz tartozó memóriatartalmat. A memóriatartomány ki-be másolását tárcserének (swapping) hívjuk, a másolás eredményeképpen keletkező állományt cserefájlnak (swap file). A módszer nagy hátránya, hogy lassú, hiszen az időszelet lejártakor a teljes memóriaterületet a háttértárra kell másolni, illetve onnan betölteni, ami nagyon sokáig tart!

Tárcsere

Állandó partíciók:

Ha a felhasználói folyamatok számára rendelkezésre álló memóriaterületet egymástól független részekre, partíciókra osztjuk, több program memóriában tartására is lehetőség nyílik. Egy-egy partíció úgy viselkedik az őt birtokló folyamat számára, mintha teljesen önálló memória lenne, a partíción belül lehetőség van az átlapoló vagy a tárcsere technika alkalmazására is. Ha túl kicsi a partíció esetleg nem fér bele folyamat. Ha túl nagy, esetleg sok kihasználatlan üres hely marad a partíció területén belül. Ezt a jelenséget nevezzük belső elaprózódásnak (internal fragmentation). Ennek kivédésére, több különböző partíciót alakítottak ki.

Az operációs rendszereknek ismerniük kell a partíciók méretét és annyi bázisregiszter-határregiszter párt, kell számon tartaniuk és folyamatosan vizsgálniuk, ahány partíció van. A másik feladat a partíciók kijelölése a folyamatok számára.

Rugalmas partíciók:

Az állandó partíció mérethátrányait jórészt kiküszöböli, ha a partíciók számát és nagyságát nem rögzítjük szigorúan, azok rugalmasan alkalmazkodhatnak az aktuális feltételekhez. Az operációs rendszer ebben az esetben nyilvántartja a partíciók foglaltságát, és az érkező folyamatoknak a befejezett folyamatok után fennmaradó lyukakból választ helyet, persze, csak ha van olyan szabad terület, ahová az befér. Ez a módszer kiküszöböli a belső elaprózódást, mivel a partíciók mérete 2048 B, vagy többszöröse, a legnagyobb kihasználatlan terület is maximum 2048 B. Külső elaprózódásról (external fragmentation), akkor beszélünk, ha egy befejezett folyamat után egy másikat tölt be az operációs rendszer, nyilván ez kisebb lesz (nagyobb nem lehet, mert nem fér bele), így lyukak maradnak. Tömörítő algoritmussal kivédhető, de lassú.

Lapozás (paging):

Ha a rendelkezésre álló operatív memória területet egyforma és viszonylag kisméretű egységekre osztjuk, úgynevezett lapokra, akkor egy folyamat memóriában való elhelyezésekor most már nem szükséges az, hogy akkora összefüggő szabad memóriaterület álljon rendelkezésre, amennyit a folyamat igényel, hanem elég az, hogy összességében legyen ennyi hely. Az operációs rendszer minden egyes folyamat betöltésekor létrehoz a folyamat számára egy laptáblát, mely a logikai lapokhoz hozzárendeli a fizikai lapot.

A processzor által kiadott logikai címet formálisan két részre osztjuk. A cím első része adja meg a lapszámot, míg a második része a lapon belüli eltolást. Ezek után megnézzük a laptábla "lapszám"-adik sorát, és az ott található számérték megmutatja a lap fizikai kezdőcímét az operatív memóriában. Ehhez a számértékhez kell hozzáilleszteni a lapon belüli eltolás értékét.

Előzmények

Áthelyezhető: nem mindig ugyanoda töltődik

Átlapoló (overlay): nem minden rész kell egyszerre

Tárcsere (swapping): memóriakép a háttértáron

Lapozás: nem folytonos elhelyezés

Virtuális tárkezelés

A valóságos memóriakezelésnek három fontosabb problémája van:

· Az egyszerűbb mikroprocesszorok címzési kapacitása is olyan nagy, amekkorát nem akarunk kiépíteni, mert a fizikai memória sokkal kisebb.

· Egy multiprogramozott rendszer hatékonysága nő, ha minél több folyamat fut párhuzamosan, de itt is túl nagy memóriára volna szükség.

· A valóságos tárkezelés esetén egy folyamat betöltése, valamilyen okból történő felfüggesztése esetén háttértárra mentése, majd újra betöltése rendkívül hosszú időt vesz igénybe.

Megoldás a virtuális tárkezelés: a lapoknak egyszerre csak egy részhalmaza van bent az operatív memóriában, még a többi része a merevlemez egy külön kialakított részén, a virtuális memóriában tárolódik.

Virtuális címszámítás: Osszuk fel az operatív memóriát és a virtuális memóriát is egyforma méretű, viszonylag kis egységekre, lapokra. Az operatív memóriában hozzunk létre minden folyamathoz egy laptáblát, amely minden sorában a lap operatív tárbeli kezdőcíme mellett tartalmazzon még egy olyan vezérlés jellegű bitet is, amely azt mutatja, hogy az adott lap bent van-e (present) az operatív tárban vagy nincs.

Ha a present bit azt mutatja, hogy az adott lap az operatív memóriában van, akkor hasonlóan járunk el, mint a lapozásnál. Ha a present bit azt mutatja, hogy az adott lap nincs az operatív memóriában, akkor be kell tölteni azt a háttértárról. Ilyenkor beszélünk laphibáról (page fault), amely azt jelenti, hogy a hivatkozott lap nincs bent az operatív memóriában, azt be kell tölteni a háttértárról.

Laphiba (page fault)

Ha a folyamat olyan memóriacímre hivatkozik, ami olyan lapon található, amely nincs betöltve az operatív memóriába.

Nem igazi hiba! Virtuális tárkezelésnél természetes!

Szükséges lépések:

– Ellenőrizzük, hogy az adott folyamat használhatja-e az adott címet.

– A lapot behozzuk a háttértárról az operatív tárba (természetesen előtte egy lapot lehet, hogy ki kell menteni) és módosítjuk a laptáblát.

– Meg kell ismételni annak az utasításnak a végrehajtását, ahol a laphiba fellépett.

Lapkiosztási elvek:

1. egyenletes lapkiosztás: minden folyamat ugyanannyi kerettel gazdálkodhat.

2. arányos lapkiosztás: egy folyamat minél nagyobb virtuálismemória-területet használ, annál több keretet kap.

3. prioritásos elosztás: magasabb prioritású folyamatok több lapot kapnak.

Lokális elosztás: a rendelkezésre álló lapok száma egy folyamat számára a futás során állandó.

Globális lapkiosztás: Az operációs rendszer csak a minimálisan szükséges lapokat osztja ki, a fennmaradó szabad lapokból a folyamatok dinamikus igényeit elégíti ki.

Vergődésnek (trashing) nevezzük azt a jelenséget, ha egy folyamat olyan kevés laphoz jut, hogy csaknem mindig laphibát okoz. Fut ugyan, de nagyon lassan.

Lényeg, előnyök: a folyamat lapjai közül nem mindegyik van a memóriában, a többi a háttértáron várakozik. Csak a folyamat által igényeltek kerülnek be a memóriába (igény szerinti lapozás).

Előny:

– a valós memóriánál nagyobb program is le tud futni;

– több folyamat futhat egyszerre;

– gyorsabb a betöltődés is.

Virtuális tárkezelés

Lapcsere stratégiák: laphibák csökkentésére algoritmusokat használnak.

1. OPT (Optimal) - Optimális stratégia: azt a lapot kell lecserélni, amelyre a legkésőbb lesz szükség.

Előny: ez adja a minimális laphiba számot;

Hátrány: a gyakorlatban megvalósíthatatlan, mert nem tudhatjuk előre a hivatkozások sorrendjét.

Igényelt lap	6 8 3 8 6 0 3 6 3 5 3 6
1.lap 2.lap 3.lap	6 6 6 6 6 8 8 0 5 3 3 3
Laphiba	* * * * *

2. FIFO (First In First Out) - Előbb jött, előbb megy: azt a lapot kell lecserélni, amely legrégebben van bent a memóriában.

Előny: egyszerű;

Hátrány: sok laphibát okoz.

Igényelt lap	6 8 3 8 6 0 3 6 3 5 3 6
1.lap 2.lap 3.lap	6 6 6 0 0 0 3 8 8 8 6 6 6 3 3 3 5 5
Laphiba	* * * * * * *

3. LRU (Last Recently Used) - Legrégebben használt: azt a lapot kell lecserélni, amelyre legrégebben hivatkozott a folyamat.

Előny: viszonylag jól közelíti az optimálist;

Hátrány: lassú.

Igényelt lap	6 8 3 8 6 0 3 6 3 5 3 6
1.lap 2.lap 3.lap	6 6 6 6 6 6 8 8 8 3 3 3 0 0 5
Laphiba	* * * * * *

Ezeknél vannak jobbak, mert ezek túl bonyolultak, vagy sok laphibát okoznak.

1. SC (Second Chance) - Második esély: az eljárás a FIFO elven alapul, egy kis kiegészítéssel. A laptáblába egy paritásbitet helyeznek el, mely jelzi, hogy a lap éppen használatban van-e. Így elkerülhetjük, hogy olyan lap kerüljön kilapozásra, melyre még a folyamatnak szüksége volna.

Igényelt lap	6 8 3 8 6 0 8 6
1.lap 2.lap 3.lap	6,1 6,1 6,1 6,0 6,0 6,0 0,1 0,1 0,1 0,1 8,1 8,1 8,1 8,0 8,0 8,0 8,1 8,0 8,0 3,1 3,1 3,1 3,0 3,0 3,0 3,0 6,1
Laphiba	* * * * ! !! *

2. Mostanában nem használt - Not Used Recently (NUR): LRU alapú, jelző bittel kiegészítve, mely jelzi, hogy a lap használatban van-e. A mostanában kifejezés tehát azt takarja, hogy az előző lapcsere óta használták, vagy nem használták a kérdéses lapot.

Igényelt lap	6 8 3 8 6 0 3 6 3 5 3 6
1.lap 2.lap 3.lap	6,1 6,0 6,0 6,0 6,1 6,0 3,1 3,0 3,1 3,0 3,1 3,0 8,1 8,0 8,1 8,1 8,0 8,0 6,1 6,0 6,0 6,0 6,1 3,1 3,1 3,1 0,1 0,0 0,0 0,0 5,1 5,0 5,0
Laphiba	* * * ! ! * * ! ! * ! !
1) használt 2) nem használt	- laphibánál - bentlévő: 0 - aktív: 1	- nincs laphiba: - aktív: 1

Laphibák: 3+3

A címszámítás gyorsítása asszociatív tárral:

A virtuális tárkezelés legnagyobb hátránya az volt, hogy lassú. A sebesség növelése érdekében egyrészt igyekeztünk csökkenteni a laphibák számát megfelelően hatékony lapcsere algoritmus használatával.

A hagyományos memóriák úgy működnek, hogy bemenetükre egy címet kell adnunk, ennek hatására pedig a kimenetükön megjelenik egy adat.

Az úgynevezett tartalom címezhető memóriák (content addressable memory) ezzel ellentétben úgy működnek, hogy a bemenetükre egy adatot kell adnunk, a kimenetükön pedig megjelenik, hogy ez az adat benne van-e a memóriában vagy nincs, és mindez egy memória ciklusidő alatt.

Az ilyen memóriák meglehetősen drágák és elég kisméretűek.

Egy ilyen memóriamodulhoz hozzárakhatunk egy hagyományos tárolóelemet, és ilyenkor a kimeneten nem csak az jelenik meg, hogy a bemenetre adott adat (az ún. kulcsinformáció) bent van-e a memóriában, hanem ha bent van, akkor egy másik kimeneten megjelenik az adott kulcshoz társított, a hagyományos modulban lévő adat is. Ezért hívjuk ezt a típusú memóriát asszociatív memóriának.

Ezt az asszociatív tárat gyakran címszámítást kikerülő tárnak (Translation

Lookaside Buffer - TLB) nevezik.

Ezek után három különböző szituáció lehet.

1.A keresett lap címe bent van a TLB-ben (ez a leggyakoribb), onnan gyorsan megkaphatjuk és leállítjuk a hagyományos, laptáblán keresztüli címszámítást.

2.A keresett lap címe nincs bent a TLB-ben, de maga a lap bent van az operatív tárban. (Azaz a lapot régóta nem használtuk, de még nem lapozódott ki. Ilyen eset azért lehet, mert a TLB mérete - mint már említettük - meglehetősen kicsi, tipikusan 32, 64 vagy 128 soros, és ezért nem fér bele az összes, operatív tárbeli lap adata.) Ilyenkor végrehajtjuk a címszámítást a laptáblán keresztül és beírjuk a kiszámított címet a TLB-be is.

3.A keresett lap nincs bent az operatív memóriában (laphiba). Ekkor a lapot be kell hozni a háttértárról, megfelelően módosítani kell a laptáblát, a módosított laptábla segítségével el kell végezni a címszámítást és a kiszámított címet be kell írni a TLB-be is.

Végül azt a kérdést kell megvizsgálni, hogy hogyan tudjuk könnyen biztosítani, hogy a TLB-ben mindig a legutoljára használt néhány lap adata legyen bent?

Az új lap adatai a shift regiszter tetejére kerülnek, a bent lévő adatok pedig eggyel lejjebb lépnek, alul pedig elveszik az eddigi utolsó sor. Ha egy lapra hivatkozunk, akkor a lap adatait tartalmazó sor kerül a shift regiszter tetejére és az összes eddig felette lévő sor eggyel lejjebb csúszik. (Ilyenkor tehát nincs adatvesztés.) Könnyen belátható, hogy ezzel a módszerrel a TLB tetején mindig a legutoljára használt lap adatai lesznek, míg legalul a legrégebben nem használt lap adatai találhatók meg.

Tárvédelem, Szegmentálás:

Multiprogramozott környezetben meg kell teremtenünk annak a feltételeit, hogy az egyes folyamatok egymás memóriaterületeit ne zavarják, még olyankor sem, ha például programhibát tartalmaznak. Vagyis ki kell alakítani egy jól működő védelmi rendszert. Azonban a folyamatok közötti szeparálás nem szabad, hogy

"tökéletes" legyen, hiszen vannak olyan esetek, amikor több folyamat együtt akar működni, például egy közös adatterületen keresztül. Tehát a védelmi rendszernek meg kell akadályozni a "rosszakaratú" hozzáféréseket, de ellenőrzött keretek között biztosítani kell a folyamat közötti kommunikációt.

1. Védeni kell egy folyamat különböző logikai egységeit egymástól.

2. Védeni kell a felhasználói folyamatokat egymástól, de biztosítani kell közöttük az igényelt kommunikáció lehetőségét.

3. Védeni kell az operációs rendszert a felhasználói folyamatoktól.

A szegmensleíró tábla segítségével védekezhetünk a verem túlcsordulás (memória túlcsordulás), vagy a véletlen program felülírás ellen.

A folyamatok védelme egymástól:

A folyamatok memóriaterületeit meg kell, védjük egymástól, de biztosítanunk kell, a folyamatközti kommunikáció lehetőségét. A megoldás: ne egy darab szegmensleíró táblánk legyen, amely az összes folyamat összes szegmensét leírja, hanem rendeljünk egy-egy szegmensleíró táblát minden folyamathoz.

Ha két folyamat egy közös adatterületet szeretne használni, akkor erre a közös területre definiáljunk egy adatszegmenst, és ennek adatait tegyük be mindkét folyamat leírótáblájába. Ezáltal ehhez mindkét folyamat hozzá tud férni, de rajtuk kívül senki más.

Az olyan segédprogramokhoz, melyet minden folyamat használ, létrehoznak egy közös, mindenki által használható, úgynevezett globális leírótáblát (global descriptor table - GDT) a már említett, minden folyamathoz rendelt saját, lokális leírótáblán (local descriptor table - LDT) felül.

Az operációs rendszer védelme – prioritások:

Ahhoz, hogy egy folyamat ne írhassa felül egy másik folyamat leírótábláját, az egyes folyamatokhoz jogokat rendelünk – prioritási szint – és meghatározzuk, hogy legalább milyen prioritási szinttel kell rendelkeznie egy folyamatnak ahhoz, hogy az adott szegmenst használja.

A szegmensleíró táblát kiegészítjük:

Kezdőcím

Hossz

Típus

Prioritás

Vergődés

Egy folyamat több időt tölt lapozással, mint hasznos tevékenységgel (kevés lapja van)

Elkerülése:

Lokális lapkiosztási algoritmus: Minden folyamatnak rögzített darabszámú lapja van. Így, ha egy folyamat vergődik, a többi (majdnem) szabadon futhat.

Munkahalmaz: viszonylag lassan változik; az op. r. olyan lapozási stratégiát követ, hogy minden folyamatnak igyekszik bent tartani a munkahalmazát; bonyolult SW és HW igény.

Laphiba-gyakoriság figyelése: kevés laphibánál a folyamatnak túl sok kerete van, ezért elveszünk tőle egyet, ill. sok laphibánál kevés kerete van, tehát adunk neki még egyet.

Védelem

Szegmentálás: bontsuk a programjainkat LOGIKAI egységekre (lapozás: fizikai egységekre tördelés)

Ezzel megoldható:

1. Egy folyamaton belül a logikai egységek védelme egymástól.

2. A folyamatok védelme egymástól (DE biztosítva az esetleges együttműködés lehetőségét).

3. Az operációs rendszer védelme a felhasználóktól.

Logikai egységek védelme

Különítsük el a folyamat LOGIKAI egységeit!

– kód-, adat-, veremszegmens

Minden utasításnak legyen alapértelmezett szegmense!

– JUMP kódszegmens;

– MOVE adatszegmens;

– PUSH stack szegmens,

Az utasítás végrehajtásakor a HW ellenőrizze, hogy tényleg adott típusú szegmensben van-e az operandus. Tárolni kell a szegmens típusát, kezdőcímét és HOSSZÁT (Az univerzalitás ellen hat: “prefix utasítások”).

Folyamatok védelme egymástól

Lokális leíró tábla (LDT):

Legyen minden egyes folyamatnak SAJÁT szegmens leíró táblája, amelyben CSAK az általa elérhető szegmensek vannak feltüntetve, így a memória MÁS területeit egyáltalán nem használhatja az adott folyamat!

Globális/Interrupt leíró tábla (GDT, IDT):

A közösen használt szegmensek leíróit helyezzük el az összes együttműködni szándékozó folyamat leíró táblájában, DE esetleg különböző jogokkal!

Az operációs rendszer védelme

Prioritási szintek bevezetése:

Egy adott szegmenst csak az a folyamat használhat, melynek prioritása minimum megegyezik a szegmens prioritásával

–szegmensek prioritási szintje: a vezérlés mezőben

–folyamat prioritási szintje: a KÓDSZEGMENSÉHEZ rendelt prioritás érték.

(Természetesen az operációs rendszer folyamatai kerülnek a magas prioritású szintekre, míg a felhasználói folyamatok az alacsonyakra).

Tárvédelem

Folyamatok logikai egységeinek védelme egymástól	Szegmensleíró tábla, szegmenshossz mező
Folyamatok védelme egymástól	Szegmensleíró tábla létezése
Operációs rendszer védelme	Szegmensleíró tábla védelmi (prioritás) mezői

Lapozás vs. Szegmentálás

Lapozás:

– Fizikai darabolás eredménye,

– Egyforma méretű lapok,

– Gyors, hardver által végezhető lapcsere,

– A védelemnek nem sok értelme van.

Szegmentálás:

– Logikai darabolás eredménye,

– Különböző méretű szegmensek,

– Lassabb betöltés/mentés,

– Védelemhez jól használható.

A címszámítás gyorsítása szegmentálásnál:

A szegmens leírótábla használatával a memória hozzáférés ideje legalább kétszeresére nő. Megoldás: szegmentálás és lapozás együtt.

Lapozott szegmentálás - példa

JMP valahova (szegmens: CS, offset: valahova)

• A folyamat által adott cím a LOGIKAI cím

• A szegmensleíró tábla CS-hez tartozó sorában ellenőrizzük, hogy a folyamat jogosult-e használni a szegmenst, illetve, hogy a valahova cím benne van-e a tartományban.

• Kiszámítjuk a szegmens: offset alapján a LINEÁRIS címet (pl. szegmens kezdőcím+offset)

• A lineáris cím a lapozó egység bemenete, felosztódik laptábla címre (pl. 6 bit -> 4kB) és lapon belüli offset-re, majd a laptábla által tartalmazott fizikai lapcímet összeillesztve az eltolással, megkapjuk a FIZIKAI címet.

Gyorsítótár (cache) – elv: A leggyakrabban használt adatok legyenek a leghamarabb elérhető helyen.

Összefoglalás

Valóságos tárkezelés:

– Overlay, swapping, particionálás, lapozás

Virtuális tárkezelés

– Laphiba, lapkezelés, címszámítás

– Lapcsere stratégiák: FIFO, OPT, LRU, SC, NUR

– A címszámítás gyorsítása

Tárvédelem:

– A logikai egységek védelme

– A folyamatok védelme egymástól

– Az operációs rendszer védelme

9. A párhuzamos programozás

Alapjai

Multiprogramozott környezetben szükség van a konkurencia leírására és a folyamatok közötti szinkronizáció megoldására.

A folyamatok közötti szinkronizáció három fő fajtája:

· kölcsönös kizárás, azaz az, hogy két folyamat közül egy időben csak az egyik - de mindegy, hogy melyik - futhat.

· randevú: az "előbb érkező" folyamatnak meg kell várnia a másikat, majd végrehajtásuk - többnyire paraméter-átadás után - újra szétválik.

· precedencia, vagyis a sorrend biztosítása. A precedencia itt azt jelenti, hogy egy bizonyos folyamat adott utasításcsoportjának végrehajtása meg kell, hogy előzze egy másik folyamat másik adott utasításcsoportjának végrehajtását. (Például egy üzenetet előbb be kell tenni egy postaládába, és csak ezután lehet kiolvasni onnan.)

A precedenciagráf megmutatja, hogy a folyamatokat hol kell párhuzamosítni, szinkronizálni és hol kell utasításokat egymás után végrehajtani.

A precedenciagráf csomópontjaiban folyamatok vannak, és egy csomóponttól nyíl mutat egy másik csomópontig akkor, ha az első csomópont által reprezentált folyamat végrehajtása meg kell, hogy előzze a másik csomópont által reprezentált folyamatét. Tehát a nyilak két folyamat végrehajtási sorrendjét határozzák meg.

(ha több él találkozik egy csomópontban: szinkronizálás!)

A precedenciagráf tehát egy irányított, körbejárható hurkot (ún. ciklust) nem tartalmazó gráf.

A precedenciagráfból ránézésre megállapítható, hogy mely utasítás kell, megelőzzön mely más utasítást/utasításokat (ezt mutatják a nyilak), hol van szükség szinkronizációra (u5 és u7 előtt), és végül, hogy hol lehetséges a párhuzamosítás (azok az utasítások hajthatók végre párhuzamosan, amelyekre igaz, hogy egyikből se tudunk eljutni a másikba a nyilak mentén; a példában az

u6-tal párhuzamosítható az u2, u3, u4 és u5-bol álló utasításnégyes bármelyike, azon belül pedig az u3 az u4-gyel).

A precedenciagráfnak megvan még az a kellemes tulajdonsága, hogy vele bármilyen szituáció leírható, emellett szemléletes is, viszont hátránya, hogy egy számítógép nem ért belőle semmit, tehát programozásra nem alkalmas.

A fork és join utasítások a számítógép számára érthetően írják le a párhuzamosítási lehetőségeket. A fork jelentése szétágazni, míg a join-é egyesülni.

A fork utasítás segítségével a végrehajtás pontosan két, egymással párhuzamosan végrehajtható ágra osztható szét. Ezek közül az első ág utasításai közvetlenül a fork utasítás után kerülnek felsorolásra, míg a másik ág a fork utasítás paraméteréül megadott címkénél kezdődik.

A fenti gráf programja fork utasítás használatával

Egymással párhuzamosan futó ágakat a join utasítás segítségével egyesíthetünk.

A join utasítás tetszőleges számú ágat egyesíthet, az egyesítendő ágak számát az utasítás paraméteréül megadandó számláló értéke mutatja meg. A join utasítás a szinkronizálást is megoldja: ha az itt találkozó ágak egyike befejeződik, azaz az ág programjának a végrehajtása után elérjük a join utasítást, akkor a join utasítás számlálójának értékét eggyel csökkentjük, majd az ágat felfüggesztjük. Ezt megtesszük mindaddig, míg az utolsó ág is be nem fejeződött - azaz amikor a számláló értéke 0 lesz - és ekkor elkezdődik az egyesített ág futása.

Az egyesítendő ágak tehát "bevárják" egymást. A leíráshoz a goto (azaz ugorj a paraméterül megadott címkére) utasítás használata nélkülözhetetlen.

Az előző példában megszerkesztett precedenciagráf leírása fork-join utasítások segítségével!

A parbegin - parend (bizonyos programozási környezetekben cobegin -

coend) utasítások strukturált programozási lehetőséget nyújtanak a konkurencia leírásához. A parbegin - parend utasításpár tulajdonképpen konkurensen végrehajtható folyamatok (példáinkban utasítások) zárójelezését jelentik. Az utasításpár használata:

parbegin u1; u2; ... parend;

Ez azt jelenti, hogy a parbegin és a parend között felsorolt u1, u2, ... utasítások egymással párhuzamosan végrehajthatók.

Az első utasítás az u1, majd utána két részre szakad a gráf, tehát a párhuzamosan végrehajtható ágak programjait parbegin és parend közé kell tenni. Begin - end közé kell leírni azt, ami az u6-tal párhuzamosítható. Ez a rész az u2-vel kezdődik, majd a gráf ismét kétfelé ágazik. De ez a két ág már csak egy-egy utasítást tartalmaz, ezért most egy parbegin - parend között egyszerűen felsorolhatjuk az u3 és u4 utasításokat, majd következik az u5 utasítás és itt ér véget az u6-tal párhuzamosítható utasításcsoport, azaz ide kell az end utasítás. Az első parbegint lezáró parend után pedig már csak az utolsó, az u7-es utasítást kell leírni ahhoz, hogy kész legyünk.

Látható, hogy ezzel a megoldással áttekinthetőbb, ide-oda ugrálásoktól mentes kódot kapunk.

A parbegin - parend utasításokkal szemléletes, áttekinthető kódot kapunk, de sajnos nem minden precedenciagráf leírásához alkalmasak, vagyis "erejük" kisebb, mint a precedenciagráfok vagy a fork - join ereje.

A parbegin - parend utasítások kiegészítése primitívekkel (V - P)

Tételezzük fel, hogy az összes utasításunk párhuzamosan végrehajtható, de tegyünk - az első kivételével - minden egyes utasítás elé egy őt engedélyező szemafort, amelyet induláskor TILOS-ra állítunk. Ezt a szemafort majd akkor engedélyezzük - a V primitív segítségével -, ha az adott utasítást megelőző utasítást végrehajtottuk. Azt pedig, hogy egy utasítás végrehajtását elkezdhetjük-e, a P primitív segítségével tudhatjuk meg, pontosabban, az utasítás végrehajtása előtt a P primitív segítségével addig várakozunk, míg az őt vezérlő szemafort valaki szabadra nem állította, majd a szemafort "lefoglaljuk", azaz újra tilosra állítjuk, végrehajtjuk az utasítást, végül engedélyezzük a következő utasítás(oka)t.