1. Operációs rendszerek helye

1. 1. Operációs rendszerek helye • számítógépes rendszer (hardver, szoftver, hálózat) + felhasználók = Egységes Tervezési Egység (a felhasználók is fontos részei a tervezésnek)- szoftver: rendszerprogramok (alapszoftver) és felhasználóiprogramok- az OS a legalapvetőbb rendszerprogram, kernel módban fut- egyéb rendszerprogramok: nem az OS részei, lehetnek hardver közeliek, hálózat közeliek, segédprogramok (pl.: fordítók, szövegszerkesztők), felhasználói módban futnak- felhasználói programok - általános applikációk (web böngészők, táblázatkezelők, stb.) - célrendszerek (banki alkalmazások, ETR, stb.)

2. 2. OS alapvető feladatai 1. kiterjesztett, virtuális gép – „felülről lefelé nézőpont” - megvédi a felhasználót a hardver kezelésétől - állományorientált kapcsolatot biztosít - elrejt sok alacsony szintű tulajdonságot, pl. megszakítások, időzítések, memóriaszervezés, stb. ► a felhasználónak egy egyenértékű, egyszerűbben kezelhető virtuális gépet nyújt2. erőforrás-kezelő – „alulról felfelé nézőpont” - nyilvántartja az erőforrásokat (hardver és szoftver erőforrások) - kielégíti az erőforrás-kéréseket - maximalizálja a rendszer hatékonyságát, teljesítményét► az OS az a hely, ahol az összetett rendszer minden egyes részét kezelik

3. 3. OS alapvető tulajdonságai 1. processzusok (folyamatok) az alapvető aktív alkotóelemek - processzus: egy végrehajtás alatt lévő program, ami létrejön (programbetöltés vagy végrehajtás indítása során), létezik (fut), majd megszűnik2. egyidejűleg több processzus létezik - a CPU-t fel kell osztani az aktuális futó processzusok között, ezt nevezzük time sharing-nek3. erőforrások centralizált kezelése - a processzusok kérés esetén kapják meg az erőforrásokat az operációs rendszertől4. eseményvezérelt - eseménymegszakításesemény feldolgozásaesemény kiszolgálásavisszatérés a megszakítás helyére

4. 4. OS generációi – 1-2. generáció 1. generáció (1945-55) - nem léteztek operációs rendszerek - hatalmas, vákuumcsöves, 1 felhasználós gépek - gépi nyelvű programozás - gépek vezérlése kapcsolótáblával, később lyukkártyákkal - külön csapat tervezte, programozta, kezelte, stb. a gépeket2. generáció (1955-65) - tranzisztorok megjelenése → megbízhatóbb gépek → gyárthatóak, eladhatóak (több millió dolláros ár) - fortran és assembly programozás - az OS állandó a memóriában (pl. FMS, IBSYS) - elkülönültek a tervezők, gyártók, kezelők, programozók, karbantartók - kötegelt rendszerek → az elvesztegetett idő csökken - megjelent az eszközvezérlők, a verem-memória, a hívható OS eljárások, a relatív címezhetőség

5. 5. OS generációi – 3. generáció - kis méretű integrált áramkörök (IC-k) alkalmazása, csökken az ár/teljesítmény hányados- IBM bevezeti a System/360 rendszert, egymással kompatibilis gépek családja → megszűnik a két független gyártósor- a sorozat minden gépén OS/360 operációs rendszer- multiprogramozás: CPU és I/O átfedően képes dolgozni, az OS a CPU üresjárati idejét tölti ki több belső memóriában tárolt processzus egyidejű futtatásával- memória szeletelés: az OS a memóriát szeletekre particionálja, minden partícióban egy-egy független job fut, ezeket speciális hardver védi meg más feladatok beavatkozásától- háttértárolás: az OS a feladatokat közvetlenül lemezről tudta olvasni, egy futó program befejezésekor egy új feladatot töltött a lemezről az immár üres partícióba, és elindította azt → a szalagok alkalmazásainak többsége megszűnt- COBOL, ADA, PASCAL nyelvű programozás

6. 6. Időosztás – time slicing - a multiprogramozás egy variációja- minden felhasználónak saját on-line terminálja van- a felhasználó processzusai egy adott maximális időtartamig birtokolhatták a CPU-t → a processzus-ütemező alrendszer átadta a CPU használatának jogát egy másik processzusnak- így a kiszolgálást igénylő feladatokhoz rendelhető a CPU → nagyszámú felhasználót képes gyorsan, interaktív módon kiszolgálni a számítógép- az első időosztásos rendszer a CTSS volt, az M.I.T. fejlesztette ki egy speciálisan átalakított IBM 7094-esen

7. 7. Átmeneti tárolás – spooling • a 3. generációs operációs rendszereknél jelent meg- SPOOL = Simultaneous Peripheral Operation On Line - az OS a feladatokat a számítógépteremben való megjelenésükkor lemezre (disk-spool terület) tudta olvasni, valahányszor egy futó program befejeződött, az OS egy új feladatot tudott a lemezről az immár üres partícióba tölteni és elindítani, a processzus is innen kapja és ide írja adatait- ezt a technikát háttértárolásnak is hívják, és a kimentre is alkalmazták- segítségével a szalagok alkalmazásainak többsége megszűnt

8. 8. Memória-partíciók • az OS a memóriát szeletekre particionálta, és minden partícióhoz egy-egy független job rendelődött- a multiprogramozást tette lehetővé- partíciók fajtái: - statikus: az operációs rendszer indulásakor fix darabszámú és fix méretű partíció képződött, egy feladat végrehajtásához az OS keresett egy szabad és elegendő méretű partíciót, amelyben a programnak megkezdhette a végrehajtását - dinamikus: az OS egy program végrehajtásához a szabad memóriaterületből készített egy elegendő méretű partíciót, így a partíciók száma változó

9. 9. OS generációi – 4+ generáció • LSI (Large Scale Integration) áramkörök megjelenése → PC-k, munkaállomások (üzleti életben, hivatalokban használt nagy teljesítményű, hálózatba kötött nagyobb PC-k)- PC, Workstation operációs rendszerek: - egy felhasználós, több feladatos operációs rendszerek - felhasználóbarátok - pl.: MS-DOS, Windows verziók, stb.- hálózati operációs rendszerek: - több felhasználós, több feladatos operációs rendszerek - lényegében nem különböznek az egyprocesszoros OS-ektől - pl.: UNIX, Linux, Windows NT, stb.- osztott operációs rendszerek: - egy feladatot egy időben több processzor is végezhet - az állományok tárolását automatikusan az OS végzi - a párhuzamosításhoz bonyolult processzorütemező algoritmus szükséges

10. 10. OS felületei • az OS-nek lehet felhasználói felülete és program felülete- felhasználói felület: - felhasználó – OS kapcsolati alrendszer - ezek egy parancsértelmezőn (command interface, shell), vagy egy grafikus felületen keresztül kommunikálnak egymással - a felhasználó parancsait értelmezi- program felület: - processzus – OS kapcsolati alrendszer - ezek rendszerhívások, könyvtári eljárások, ill. egyéb OS szolgáltatások útján kommunikálnak egymással

11. 11. Rendszerhívások – system calls - rendszerhívások (kiterjesztett utasítások) készlete: - OS – felhasználói programok közötti kapcsolatot alkotják - meghatározzák az OS tényleges tevékenységét - interpretáció kérdése, mi alkot rendszerhívást, pl. a POSIX szabvány csak a biztosítandó eljárásokat sorolja fel- a MINIX 53 rendszerhívásának 6 kategóriája: - processzusok létrehozása és megszüntetése - szignálok kezelése - fájlok írása és olvasása - katalóguskezelés - adatvédelem - időkezelés- ezeken kívül létezhetnek további kategóriák: - eseménykezelés - memóriakezelés - üzenetkezelés

12. 12. OS szerkezete – rétegelt 1. • az operációs rendszer rétegek hierarchiája, minden réteg az alatta lévőre épül,- minden réteg egy „virtuális gép”, a rétegbeli függvények által nyújtott funkciók összessége- az első ilyen rendszer a E. W. Dijkstra által tervezett THE volt, az alábbi 6 réteggel rendelkezett: 5. rendszert kezelő processzus 4. felhasználói programok 3. bemenet/kimenet 2. processzus kommunikáció, gépkezelő konzol 1. memóriakezelés 0. processzor-hozzárendelés, multiprogramozás- eljárások, függvények rétegekbe csoportosulnak → felügyelt eljáráshívások valósíthatóak meg- bármely n. rétegbeli eljárás csak a közvetlenül alatta lévő n-1. réteg eljárásait hívhatja → áttekinthető eljárásrendszer

13. 12. OS szerkezete – rétegelt 2. - minden réteg saját adatterülettel rendelkezhet → áttekinthető adatáramlás- program-végrehajtási szinteket különböztetünk meg: - normál mód: - felhasználói programok - OS eljárásainak meghatározott részhalmaza - kitüntetett mód: - speciális OS eljárások ill. rendszerprogramok is- a rétegelt szerkezet könnyen konfigurálható, például az eszközvezérlők egy rétegbe csoportosíthatóak

14. 13. OS szerkezete – kliens/szerver 1. - A korszerű operációs rendszerek egyre több programot helyeznek magasabb rétegekbe, azok kikerülnek az OS-ből → egy minimális kernel marad- egymással kommunikáló processzusok rendszere – üzenetek adása ill. vétele értendő kommunikáció alatt- az OS feladata az üzenetek közvetítése a processzusok között- szolgáltatást kérünk az OS-től → a kliensprocesszus kérést küld a szerverprocesszusnak → ez elvégzi a munkát és választ küld- az üzenet felépítése: - fejléc (header), az üzenet továbbításához szükséges információkat tartalmazza (pl. címzett, feladó, hossz, kódolás...) - tartalom (body), a címzett állítja össze, a feladó értelmezi, szerkezete a kommunikációs protokoll által definiált- a kliens- és szerverprocesszus felhasználói módban fut- a kernel felügyelt módban fut, a kliens és a szerver közötti kommunikációt kell kezelnie

15. 13. OS szerkezete – kliens/szerver 2. - az operációs rendszer felhasználói módban nem végrehajtható funkcióinak kezelése: - speciális, kernel módban futó szerverprocesszusokkal - a kernelbe beépített minimális kezelőkészlettel- a kliens/szerver struktúra előnyei: - újabb szerverprocesszusokkal az operációs rendszerszolgáltatásai bármikor bővíthetők - a szerverprocesszusok egymástól teljesen függetlenül programozhatóak - hálózatok esetén is alkalmazható, ekkor a szerver- és kliensprocesszus külön OS-en fut, és ezek a hálózaton keresztül cserélnek üzeneteket

16. 14. Kliens/szerver programozás - két ill. három rétegű alkalmazás-szerkezeten alapul- a kliens számítógépen futó kliens processzus a szükséges szolgáltatásokat a hálózaton üzenetek formájában kéri a szerver gépen futó szerver alkalmazástól- a kliens gép feladatai: - a képernyő kezelése - a felhasználó akcióinak megfelelő kérések összegyűjtése és továbbítása - a válaszok fogadása

17. 15. OS alrendszerek • az operációs rendszerekben egy-egy összetartozó funkció- csoport egy alrendszert alkothat, ilyen alrendszerek lehetnek: - processzuskezelő – process handling pl. gondoskodik a CPU időosztásáról - erőforrás-kezelő – resource handling pl. kölcsönös kizárás, szinkronizáció, stb. - memóriakezelő – memory management - bevitel/kiviteli – input/output - fájlkezelő – file, directory and file system management - időkezelő – time management pl. maximális végrehajtási idő meghatározása - védelmi, biztonsági – protection, security - jelkezelő – signal handling - eseménykezelő – event handling - felhasználói felületet kezelő pl. a parancsértelmező (shell)

18. 16. Processzusok, fonalak 1. - processzus: - végrehajtás alatt lévő program - tartozik hozzá egy saját címtartomány, a memória egy szelete, amelyen belül az olvashat és írhat - címtartományának tartalmát memóriatérképnek nevezik, ez a program szövegéből, adataiból és verméből áll - a memóriatérképen kívüli információit az OS processzus- táblázata tárolja (regiszterkészlet: utasításszámláló, verem- mutató, egyéb hardver regiszterek, futáshoz szükséges egyéb információk) - állapota lehet futó, futáskész vagy blokkolt- egy processzus létrehozhat egy vagy több gyermekprocesszust, ezek újra sajátjaikat → fastruktúra jön létre- közös feladat végrehajtásában együttműködő processzusok kommunikálhatnak is egymással- erőforrásokat kizárólagosan ill. osztottan használhatnak

19. 16. Processzusok, fonalak 2. - több processzus között is megoszthatjuk a processzort egyprocesszusütemezési algoritmussal, mellyel meghatározzuk, hogy mikor fejezzük be a munkát az egyik processzuson és szolgáljunk ki egy másikat- fonal: - szekvenciálisan végrehajtódó program - a processzus hozza létre - osztozik a létrehozó erőforrásain, címtartományán, jogosultságain - saját állapota és verme van - kezelése jelentős részben a programozó felelőssége

20. 17. Kontextus csere - egy modern számítógép több dolgot képes egy időben elvégezni- multiprogramozható rendszerben a CPU váltakozva hajtja végre a processzusok programjait, futtatva azokat néhány 10 vagy 100 ezredmásodpercig- a processzor minden időpillanatban csak egy programot futtat, de a párhuzamosság illúzióját kelti → látszatpárhuzamosság ↨ többprocesszoros rendszerekben hardver-párhuzamosság- kontextus csere – context switching: - a CPU át akar váltani a P1 processzusról a P2 processzusra - a P1 állapotát kimenti a CPU a hardver regisztereiből az erre a célra fenntartott memóriaterületre - a P2 korábban memóriába mentett állapotát helyreállítja a CPU a regisztereiben

21. 18. Memóriatérkép - minden processzushoz tartozik egy saját címtartomány, azaz a memória egy minimális és maximális című helye közötti szelet, amelyen belül az olvashat és írhat- a címtartomány tartalmát memóriatérképnek nevezzük, amely a következőkből áll: - szövegszegmens – a program kódja - adatszegmens – konstansokat és változókat tartalmazhat - veremszegmens – adatot (pl. lokális változók), információkat (pl. Last-In-First-Out kezelés, Push/Pop utasítások, stb.) tartalmazhat - dinamikus változók (pl. heap)

22. 19. Processzus állapotai, állapotátmenetek 1. • bár minden processzus önálló egység saját utasításszámlálóval és belső állapottal, gyakran szükségük van arra, hogy más processzusokkal kölcsönhatásba lépjenek ↓ ha az egyik processzus végrehajt egy kommunikációs lépést, akkor megváltozhat a másik processzus állapota- egy processzus egy adott pillanatban 3-féle állapotban lehet: - futó – az adott pillanatban használja a CPU-t - futáskész – készen áll a futásra, de ideiglenesen leállította a processzorütemező, és átadta a CPU használati jogát egy másik processzusnak, hogy az futhasson - blokkolt – bizonyos külső esemény bekövetkezéséig logikailag nem képes futni, tipikusan azért, mert olyan bemenetre vár, mely még nem elérhető - segédállapotok – iniciális, terminális

23. 19. Processzus állapotai, állapotátmenetek 2. • léteznek átmenetek is az állapotok között: - futó→blokkolt: - automatikus - futó→futáskész: - a processzusütemező feladata - futáskész→futó: - a processzusütemező feladata - blokkolt→futáskész: - akkor fordul elő, ha a processzus által várt külső esemény bekövetkezik - ha egy processzus sem fut az adott pillanatban, akkor a processzus egyből futó állapotba megy át, ellenkező esetben várakoznia kell, míg a CPU elérhető nem lesz.

24. 20. Processzus leírása 1. - a processzusok nyilvántartására, tulajdonságainak leírására szolgáló memóriaterület a Process Table, illetve a Process Control Block (PCB)- minden processzus leírása a következőket tartalmazza: - processzus azonosító – process ID: egyértelmű hivatkozási sorszám, a processzus létrejöttekor kapja meg - létrehozó processzus azonosító: a szülő processzus azonosítója - memóriatérkép: a processzus címtartományának tartalma, idővel változik - processzus állapota: futó, futáskész, blokkolt - jogosultságok: read, write, execute – létrehozó állítja be - birtokolt erőforrások: kizárólagosan ill. osztottan használt erőforrások nyilvántartása - meg nem kapott erőforrások: a processzus által kért, de meg nem kapott erőforrások

25. 20. Processzus leírása 2. - CPU-állapot mentési terület: kontextus cseréhez; utasítás- számláló, verempointerek, regiszterek tárolására - egyéb számlázási, statisztikai információk- egyidejűleg létező processzusok leírásai láncra vannak fűzve- processzus létrejön → leírására szolgáló memóriaterület (PCB) hozzá csatolódik a lánchoz- processzus megszűnik → a PCB láncszem törlődik a láncról- a processzusleírások láncán műveleteket is végre lehet hajtani, ilyenek lehetnek például a következők: - processzus gyermekeinek keresése – pl. szülőprocesszus megszűnésekor, - futáskész processzusok keresése – pl. CPU kiosztásakor, - erőforrást igénylő processzusok keresése – pl. erőforrás odaítélésekor, stb.

26. 21. Processzus létrehozása - egy processzus létrehozásának lépései az alábbiak: 1. memóriaterület foglalása a processzus PCB számára 2. a PCB feltöltése iniciális adatokkal: - memóriatérkép kezdeti adatai - kizárólagosan birtokolt erőforrások - a processzor állapota - indítási cím ► utasításszámláló - létrehozó jogosultságai ► jogosultságok 3. memória foglalása a program szövege, adatai és verme számára, és ezek betöltése, a legtöbb OS-ben ez a létrehozó feladata 4. a processzus PCB hozzáfűzése a processzusleírások láncára 5. a processzus állapotának futáskészre állítása

27. 22. Processzus megszüntetése - egy processzus megszüntetésének lépései az alábbiak: 1. gyermekprocesszusok megszüntetése rekurzívan, vagy más szülőprocesszushoz csatolása 2. processzus állapotának terminálisra történő állítása 3. processzus PCB lecsatolása a processzusleírások láncáról, a processzus ezután már nem osztozik a CPU-n 4. a processzus birtokában lévő erőforrások felszabadítása 5. a memóriatérképnek megfelelő memóriaterületek felszabadítása 6. processzus PCB memóriaterületének felszabadítása- egy processzus a következő módokon szűnhet meg: - önmagát megszüntetheti az exit() paranccsal → jelet küld a létrehozó processzusnak a megszüntetés sikerességéről - a létrehozója vagy annak ősei megszüntethetik - a „kill” szignál megszüntetheti, ha az nincsen lekezelve

28. 23. Processzus ütemezés feladata, céljai - amikor egyidejűleg több futáskész állapotú processzus létezik, az OS-nek el kell döntenie, hogy melyik fusson először → ütemezője hozza meg ezt a döntést, ütemezési algoritmus- az ütemező által elérni próbált célok: - pártatlanság – egy adott processzus indokolatlanul a többi processzus kárára ne részesüljön előnyben - hatékonyság – a CPU kihasználtsága 100% legyen - válaszidő – csökkenteni az interaktív felhasználók válaszidejét - átfutási idő – egy processzus létrejöttétől a megszűnéséig tartó időtartam minél rövidebb legyen - áteresztőképesség – egy egységnyi idő alatt végrehajtott processzusok száma minél nagyobb legyen - erőforrás-kihasználtság minél jobb legyen - költség alacsony legyen, az algoritmus nem lehet túl bonyolult - megbízhatóság – az átfutási idő nem függhet az egyidejűleg létező processzusoktól

29. 24. Processzus ütemezés paraméterei 1. Az ütemezési algoritmus ezek alapján dolgozik; a processzusokazon tulajdonságai, melyeket figyelembe vesz az ütemező: - processzus létrejöttekor besorolódhat processzus osztályokba: - batch – a processzus futtatása „ráér” - interaktív – a shell-ben kiadott parancs hatására jön létre a processzus, mely a felhasználókkal is kommunikálhat - real-time – időre érzékeny processzusok, ezek eseményeket szolgálnak ki - processzus rendelkezhet prioritással, mely lehet: - rögzített – létrehozás után nem változik - változó – az ütemező változtatja az algoritmusától függően - processzusnak lehet típusa is: - CPU-intenzív - erőforrás-igényes

30. 24. Processzus ütemezés paraméterei 2. - real-time (eseményeket kiszolgáló) rendszerekben feltételek tartozhatnak egy processzushoz - dinamikus információk, ezeket az ütemező gyűjti: - eddig használt összes CPU idő, - maximális memória, - erőforráskérések gyakorisága, - adott processzus „elhanyagoltsága”, stb.

31. 25. Processzus ütemező algoritmusok –round robin, tiszta prioritásos 1. - round robin ütemezés: - egyik legrégebbi, legegyszerűbb, legszélesebb körben használt - minden processzusnak ki van osztva egy időszelet, amely alatt engedélyezett a futása - időszelet végen a processzus fut → előjegyzett processzus kapja meg a CPU használati jogát - időszelet vége előtt véget ér a processzus → a CPU- átkapcsolás a processzus blokkolásakor megtörténik - az ütemező egy listát tart nyilván a futtatandó processzusokról, ha a processzus felhasználta a saját időszeletét, a végére kerül - az átkapcsolás folyamata bizonyos adminisztrációs időt igényel, ezt a folyamatot nevezik processzusátkapcsolásnak ↓ - ha az időszelet túl kicsi, az csökkenti a CPU hatékonyságát, ha túl nagy, akkor az interaktív kérdésekre lassú a válaszadás

32. 25. Processzus ütemező algoritmusok –round robin, tiszta prioritásos 2. - tiszta prioritásos ütemezés: - minden processzushoz rendelünk egy prioritást és csak a legmagasabb prioritású, futásra kész processzusnak engedjük meg, hogy fusson - a magas prioritású processzusok végtelen ideig tartó futásának megelőzésére a következő módszerek alkalmazhatók: - minden óraütemben csökkentjük a futó processzus prioritását - minden processzushoz hozzárendelünk egy max. időszeletet - a prioritások hozzárendelése lehet statikus vagy dinamikus - a processzusokat sorolhatjuk prioritási osztályokba, ekkor az osztályok között prioritásos algoritmus érvényesül, az osztályon belül viszont más szempont alapján születik döntés (pl. round robin ütemezés)

33. 26. Processzus ütemező algoritmusok –aging, feedback 1. - aging – növekvő prioritásos – ütemezés: - minden processzushoz rendelünk egy prioritást és csak a legmagasabb prioritású, futásra kész processzusnak engedjük meg, hogy fusson - a magas prioritású processzusok végtelen ideig tartó futásának megelőzésére minden óraütemben csökkentjük a futó processzus prioritását - ha egy processzus nem választódik ki, akkor nő a prioritása - a prioritások hozzárendelése lehet statikus vagy dinamikus - a processzusokat sorolhatjuk prioritási osztályokba, ekkor az osztályok között prioritásos algoritmus érvényesül, az osztályon belül viszont más szempont alapján születik döntés (pl. round robin ütemezés)

34. 26. Processzus ütemező algoritmusok –aging, feedback 2. - feedback – visszacsatolási prioritásos – ütemezés: - minden processzushoz rendelünk egy prioritást és csak a legmagasabb prioritású, futásra kész processzus futhat - a magas prioritású processzusok végtelen ideig tartó futásának megelőzésére minden processzushoz hozzárendelünk egy maximális időszeletet - ha a processzus időszeletének lejárta miatt veszti el a CPU használati jogát, akkor csökken a prioritása, ha erőforráskérés miatt, akkor marad → a CPU-intenzív és erőforrás-igényesprocesszusok kiegyenlítődnek - a prioritások hozzárendelése lehet statikus vagy dinamikus - a processzusokat sorolhatjuk prioritási osztályokba, ekkor az osztályok között prioritásos algoritmus érvényesül, az osztályon belül viszont más szempont alapján születik döntés (pl. round robin ütemezés)

35. 27. Processzus ütemező algoritmusok –fair share - a CPU-t a processzusok között „igazságosan elosztó” ütemezés- a processzusok osztályokba sorolódnak- az osztályok meghatározott arányban részesülnek az összes CPU-időből- az ütemező mériaz egyes osztályokbeli processzusokra fordított összes CPU-időt- ha egy osztály elmarad az őt megillető aránytól, akkor abból az osztályból választ az ütemező processzust- osztályon belül a választás más szempont alapján történik

36. 28. Processzus ütemező algoritmusok –előrelátó algoritmusok - a „legrövidebb feladatot először” algoritmus - olyan rendszerekben alkalmazzák, melyek speciálisan kötegelt feladatok feldolgozására alkalmasak, és ezen feladatok futási ideje előre ismert - mindig a legkisebb összes CPU-időt igénylő processzus kapja meg a processzor használati jogát - az algoritmus bizonyíthatóan optimális, legyen 4 feladatunk: a, b, c és d futásidőkkel, ekkor az első befejezi a időpontban, a második a+b időpontban, stb. → az átlagos áthaladási idő: (4a+3b+2c+d)/4, tehát a többszörösen járult hozzá az átlaghoz → neki kell a legrövidebb feladatnak lennie

37. 29. Processzus ütemezés elmélete • az ütemezéshez létezik egy szelekciós függvény: int f (p,w,e,s), ahol - p: a processzus prioritása - w: a processzus eddig rendszerben eltöltött összideje - e: a processzus által eddig használt összes CPU-idő - s: a processzus által igényelt összes CPU-idő- a függvény által visszaadott f értékét minden aktív processzusra kiszámoljuk, és az érték szerint döntünk - f ~ max(w) → FIFO algoritmus - f ~ állandó → round robin, prioritásos, stb. - f ~ min(s) → „legrövidebb feladatot először” algoritmus- normalizált átfutási időnek a w/s hányadost nevezzük, 1 ≤ w/s = 1/(1-r), ahol 0≤r<1► az ütemezési algoritmus hatékonyságát r jellemzi, minél ez az érték, annál jobb az algoritmus

38. 30. Processzus ütemezés szimulációja - a processzus ütemező algoritmust mesterséges körülmények között szimulálhatjuk, hogy elemezni tudjuk a hatékonyságát- a szimulációhoz szükséges paraméterek: - l: egységnyi (1) idő alatt átlagosan létrejövő processzusok száma - s: egy processzus átlagos össz CPU időszükséglete (s•l ≤ 1)- minden létrehozott processzushoz hozzárendelődnek a szimulálandó ütemezési algoritmusban használt paraméterek (pl. prioritás)- futtatjuk a szimulált algoritmust a fenti paraméterekkelvéletlenszerűen létrehozott processzusokra, mérjük a normalizált átfutási időket- hisztogramot rajzolunk az s szerint csoportosított átlagos normalizált átfutási időknek megfelelő r értékekből, és ezt értelmezzük

39. 31. Kölcsönös kizárás - az együtt dolgozó processzusok közös tárolóterületen (memória, fájl) osztozhatnak, amelyből mindegyik olvashat és írhat- versenyhelyzet: kettő vagy több processzus olvas vagy ír megosztott adatokat, és a végeredmény attól függ, hogy ki és pontosan mikor fut- a kölcsönös kizárás valamilyen módszer, mely biztosítja, hogy ha egy processzus használ megosztott változót, fájlt, stb., akkor a többi processzus tartózkodjon ettől a tevékenységtől- kritikus szekció: a processzus programjának az a része, mely megosztott memóriához vagy fájlokhoz nyúl, vagy más kritikus tevékenységet végez, mely versenyhelyzetekhez vezethet- a megfelelő kölcsönös kizárás szabályai: - legfeljebb egy processzus lehet a kritikus szekciójában - véges időn belül bármely proc. beléphessen a krit. szekciójába - krit. sz. kívüli proc. nem befolyásolhatja más krit. sz.-ba lépését - nem lehet feltétel a CPU-k száma vagy a proc.-ok lefutási ideje

40. 32. Entry – Exit módszerek struktúrájaa kölcsönös kizárásra - a kölcsönös kizárás szabályainak megfelelő Entry-Exit módszerek struktúrája a következő: - a processzus az entry eljárással belép a kritikus szekciójába - itt már használhatja a processzus a megosztott fájlokat, memóriát, stb. - a processzus az exit eljárással kilép a kritikus szekciójából - ezután a következő processzus beléphet saját kritikus szekciójába

41. 33. Entry – Exit módszerek – hardver módszerek 1. - megszakítások tiltása: - a legegyszerűbb megoldás, mihelyt egy processzus belép saját kritikus szekciójába letiltja az összes megszakítást, és újraengedélyezi, mielőtt elhagyja azt - problémák ezzel a módszerrel: - ütemező-, esemény-kiszolgáló processzusok nem jutnak CPU-hoz → veszélyes - többprocesszoros rendszerben a tiltás csak egy adott CPU-ra vonatkozik - nem megfelelő a felhasználói processzusok számára- a TSL (Test and Set Lock) utasítás - beolvassa a memóriaszó tartalmát egy regiszterbe, és ezután egy nemnulla értéket ír erre a memóriacímre - az utasítás végrehajtásával a CPU zárolja a memóriabuszt, a művelet befejezéséig megtiltva ezzel más CPU-knak a memória elérését

42. 33. Entry – Exit módszerek – hardver módszerek 2. - ha a lock megosztott változó értéke 0, bármelyik processzus beállíthatja 1-re a TSL használatával, és ezután olvashatja, írhatja a megosztott memóriát - miután ezt megtette, visszaállítja lock értékét 0-ra - tevékeny várakozást követel megenter_region; TSL register, lock CMP register, #0 JNE enter_region RETleave_region; MOVE lock, #0 RET

43. 34. Entry – Exit módszerek –Peterson „udvariassági” módszer 1. #define FALSE 0#define TRUE 1#define N 2int turn;int interested[N];void enter_region (int process) { int other; other = 1 - process; interested[process] = TRUE; turn = process; while (turn == process && interested[other] == TRUE { }}

44. 34. Entry – Exit módszerek –Peterson „udvariassági” módszer 2. void leave_region (int process) { interested[process] = FALSE;}- csak két processzusra működik- mielőtt a kritikus szekcióba lép, minden processzus meghívja azenter_region-t, paraméterként átadva a saját processzus sorszámát, 0-t vagy 1-et- ha szükséges várakozik a biztonságos belépésig- miután végzett meghívja a leave_region-t, hogy ezt jelezze, és megengedje egy másik processzusnak a belépést- tevékeny várakozást követel meg

45. 35. Entry – Exit módszerek –Lamport „sorszám” módszer int N; // sorszám-tömbint MyNoi = 0; // saját sorszám-változóEntryi: MyNoi = N++; //pi egyedi belépési sorszámot kap wait while(MyNoi != minj(MyNoj, MyNoj != 0)); ki: …Exiti: MyNoi = 0; // pi kilépett- ez a módszer akárhány processzusra működik- mindegyik processzus olvassaa többi processzus sorszám- változóját- tevékeny várakozást követel meg → elpazarolt CPU-idő

46. 36. Entry – Exit módszerek –Dijkstra féle bináris szemafor int S = N; // globális szemafor változó (itt nem bináris)Entry: // i-től független! DOWN(S): wait while (S == 0); S = S - 1; ki: …Exit: // i-től független! UP(S): S = S + 1; // pi kilépett- E. W. Dijkstra javasolta, hogy egy új, globális, egész változótípus létrehozását, melyet minden processzus lát → szemafor- két művelet van, a DOWN és az UP, ezek rendszerhívásokként vannak megvalósítva → az OS tilt bennük minden megszakítást- a DOWN művelet megvizsgálja, hogy a szemafor értéke nagyobb-e, mint nulla, ha igen, akkor csökkenti az értékét- az UP a megadott szemafor értékét növeli, végrehajtását semmilyen processzus nem blokkolhatja

47. 37. Hoare monitor a kölcsönös kizárásra 1. - Hoare és Brinch Hansen egy magasabb szintű szinkronizációs primitívet javasoltak, amit monitornak neveztek el- a monitor több processzusból hívható, közös állapot- és globális változókkal rendelkező eljárások, változók és adatszerkezetek együttese, és mindezek egy speciális csomagba vannak összegyűjtve- a processzusok bármikor hívhatják monitorban lévő eljárásokat, de nem érhetik el közvetlenül a monitor belső adatszerkezeteit a monitoron kívül deklarált eljárásokból- minden időpillanatban csak egy processzus lehet aktív egy monitorban- processzus meghív egy monitoreljárást → az eljárás ellenőrzi, hogy más aktív-e a monitoron belül, ha igen, akkor a hívó felfüggesztődik, ha nem, akkor a hívó processzus beléphet- minden kritikus szekciót monitoreljárássá alakítva soha lesz két processzus egy időben a saját kritikus szekciójában

48. 37. Hoare monitor a kölcsönös kizárásra 2. • szükség van egy módszerre, mellyel blokkolhatunk egy processzust, ha az nem tud tovább haladni → állapotváltozók, és műveleteik (WAIT, SIGNAL) bevezetése • monitor exampleint i; // globális minden eljárásracondition c; // állapot-változó • procedure producer(x) { . . . WAIT(c); … // a monitoreljárás nem tudja folytatni, blokkolja a } // hívót, más processzus beléphet a monitorba • procedure consumer(x) {. . . SIGNAL(c); // a processzus felébreszti alvó „partnerét” azon} // az állapotváltozón, amelyre az éppen vár end monitor;

49. 38. Szinkronizáció alapproblémái - legyenek p1, p2, … ,pn processzusok és a1, a2, … ,am akciók- ha a pi processzus csak feltételhez szabva hajthatja végre az aj akciót (pl. az a feltétel, hogy egyetlen másik processzus sem hajthatja végre az adott akciót = kölcsönös kizárás), akkor a feltétel bekövetkeztéig a pi processzus blokkolt állapotban lesz- a szinkronizációs probléma tulajdonképpen általánosítása a kölcsönös kizárásproblémájának (pl. legyen v globális változó, amíg p1 ír v-be, p2 nem írhatja/olvashatja v-t)- holtpont (deadlock) : processzusok egy csoportja blokkolt és egyetlen csoportbeli processzus sem képes futáskésszé válni, „örökre” blokkoltak maradnak- éheztetés (starvation): olyan helyzet, melyben minden program korlátlan ideig folytatja a futást, de nem tesz semmit a fejlődés érdekében

50. 39. Étkező filozófusok szinkronizációs probléma 1. - E. W. Dijkstra vetette fel és oldotta meg- 5 filozófus ül egy kerek asztal körül, mindegyik előtt van egy tányér spagetti, és az egymás melletti tányérok között van 1 villa- a filozófusok élete evésből és gondolkodásból áll- a filozófusoknak két villára van szükségük, hogy ehessenek- ha egyikük éhes lesz, megpróbálja megszerezni a bal és jobb oldalán lévő villát – egyszerre egyet – tetszőleges sorrendben- ha ez sikerült, akkor eszik egy ideig, majd leteszi a villákat és gondolkodással folytatja- a feladat az, hogy úgy szinkronizáljuk a filozófusokat, hogyvéges időn belül mindegyikük kapjon 2 villát és ne haljon éhenegyikük sem- a megoldás lépései a következők: 1. a filozófusok gondolkodnak egy ideig, majd megpróbálják megszerezni mindkét villát egyszerre. 2. mindegyikük az állapotát éhesre állítja