[[:oktatas:operációs_rendszerek:elmélet|< Operációs rendszerek elmélet]] ====== Operációs rendszerek elmélet tananyag ====== * **Szerző:** Sallai András * Copyright (c) Sallai András, 2009, 2010, 2011, 2012, 2014 * Licenc: GNU Free Documentation License 1.3 * Web: http://szit.hu ===== Bevezetés ===== Kevés jó könyv található a magyar irodalomban az operációs rendszerek témakörében. Galambos Gábor, Operációs rendszerek című könyve azon kevesek közzé tartozik, amely szakmailag megalapozott és kiváló. Ez a leírás az ő könyvének követi a tematikáját, nagyon nagy segítség volt az elkészítésben. ===== Alapfogalmak ===== Egy számítógépes rendszer a következő elemekből épülhet fel * hardver * felhasználó * folyamatok * a hálózat gépei Az operációs rendszerek határait nehéz meghatározni. Egy számítógép hardverből és szoftverből épül fel. Az operációs rendszer leginkább szoftver, de vannak a hardvernek olyan részei, amelyek közel állnak az operációs rendszerhez. Ilyenek lehet a BIOS. Az operációs rendszer felfogható a hardver kiterjesztéseként is. ==== Erőforrások ==== A számítógép egyes komponenseit erőforrásnak nevezzük, akár a hardver, akár a szoftver része. ==== Erőforrások csoportosítása ==== ^ fizikai ^ logikai ^ | operatív memória, CPU, háttértárolók, időzítők, órák | adatok, programok | ==== Rendszerprogramok ==== * fordítók * szerkesztők * ellenőrzőprogramok ==== Mit tekintünk operációs rendszernek? ==== Három féle megközelítés ismert: * teljes szoftveres környezet * fordítók, szerkesztők, segédeszközök * kernel * ami a végig a memóriában van * középút * egyfajta hardver és felhasználó interfész ==== A hardver és a szoftver ==== A hardver és a szoftver közötti határvonalat nehéz meghúzni. A szorzás művelet például nem huzalozott, szoftveresen van megvalósítva. De szoftveres funkciókat is hardver szokott ellátni. Például memóriakiosztás vagy közvetlen művelet az adatstruktúrákon. ==== Az operációs rendszer helye ==== | Felhasználói környezet | | Operációs rendszer | | Hardver | ==== Az operációs rendszerek feladatai ==== * kezdetben * nem volt rá szükség, a felhasználó maga írta, betöltötte, futtatta a programokat * ma * kényelem, időmegtakarítás, munkánk megkönnyítése a feladatunk ==== Operációs rendszerek feladatai ==== * felület biztosítása * memóriakezelés * folyamatok szervezése * perifériakezelés * állománykezelés * hibakezelés és védelem * könyvelés === Felület biztosítása === * parancs interfész * felület biztosítása a felhasználók számára * program interfész * állomány hozzáférés * IO műveletek * eljáráshívások === Memóriakezelés === Az operációs rendszer elfoglalja a memória egy részét, a többi a programé. Kezdetben az operációs rendszernek csak magát kell védenie. Ma egyszerre több program is fut az operációs rendszer mellett, így az operációs rendszernek nem csak önmagát kell megvédenie, hanem a futó programokat is. === Folyamatok szervezése === A folyamat egy elindított, vagyis a memóriába töltött program. Néha futó programként hivatkozunk rá, bár a valóságban az elindított programok nem futnak folyamatosan. Angolosan processz. Egy processzoros rendszerben minden program kap egy időszeletet, majd a következő program jön. Ha minden program elég gyorsan kap egy-egy időszeletet a felhasználó észre sem veszi, hogy a program valójában nem folyamatosan fut. === Perifériakezelés === Háttértárak, nyomtatók, szkennerek, stb. kezelése. === Állománykezelés === * létrehozás * törlés * olvasás * írás * hozzáférés === Hibakezelés, védelem === Kezelni kell a hardver és a szoftver problémákat. === Rendszerkönyvelés === Naplózzuk az igénybe vett erőforrásokat, az előforduló hibákat és a költségeket. ===== Történet ===== ==== Kezdet ==== Kezdetben nem is volt operációs rendszer. A felhasználó egy vezérlőpulton keresztül órákon keresztül binárisan adta meg az adatokat. A beviteli felület kapcsolókból, a kiviteli felület felvillanó lámpákból állt. A sok futtatandó program, és nagy mennyiségű adat egy idő után maga után vonta egy operátor alkalmazását. Később megjelennek a következő eszközök: * I/O eszközök * Assembly * lyukszalag * több program ==== Felügyelő programok ==== Megjelenik a supervisor program, amely helyettesíti az operátor munkáját. * Input/Output System * SHARE Operating System (SOS) * FORTRAN Monitor System (FMS) Ezek még nem voltak valódi operációs rendszerek. Ezek az egyszerű szupervisor programok, ha egy hibához értek a számítógép megállt. Nem volt hibakezelés. ==== Szalagos operációs rendszer ==== Megjelennek az szalagos rendszerek. * Tape Operating System (TOS) * TOS/360 OS * IBM-360 A szalagos egységek eredményeként nagyon sok program vár a végrehajtásra, így válogatni kell a fontos és nem fontos programok között. ==== Mágnesdob ==== Egy hengeren egy mágneses palást van. Az író-olvasó fej ezen a paláston mozog. Egy körülfordulással az összes információ elérhető. A mágnesdobozok csak rövid ideig vannak jelen a számítógépeken, mivel nagyon hamar megjelennek a lemezes adattárolók. ==== Mágneslemezek ==== * DISK Operation System (DOS) A jóval nagyobb gyorsaság egész más kezelési technikát igényel. Megjelennek a LOADER-ek, amelyek folyamatosan (rezidensek) a memóriában várják a betöltendő újabb programot. ==== JCL vezérlő nyelv ==== A hatékonyabb használathoz egy új vezérlő nyelvet találnak ki, ez a JCL (Job Control Language). ==== I/O ellenőrző részek javítása ==== Az egyre növekvő igények miatt javítják az I/O eszközöket kezelő részeket: Input Output Control System (IOCS) ==== Rezidens, tranziens ==== Megjelenek a rezidens és a tranziens részei az operációs rendszernek. Az operációs rendszer egy része állandóan a tárban marad, a másik része csak akkor ha arra szükség van. * rezidens * folyamatosan a memóriában van * tranziens * csak akkor töltődik be, ha arra szükség van rá ==== Operációs rendszerek jellemzői ==== Ebben az időben senki nem gondol az operációs rendszerek hordozhatóságára. A hardvergyártók maguk készítik az operációs rendszert. A cél a hardver hatékony kihasználása. ==== DOS operációs rendszerek ==== ^ Hardver ^ Operációs rendszer ^ | Honeywell 800/1800 | ADMIRAL | | UNIVAC 1107 | EXEC 1 | | CDC 6000 | SCOPE | | Burroghs 5000 | Master Control | | IBM 7090 | IBSYS | ==== Megjelenik a BATCH programozás ==== * A futtatandó programok egy csomagban vannak összegyűjtve * Egy időben egy ilyen csomag van a memóriában * Ez az ún. soros kötegelt feldolgozási rendszer * Serial Batch Processing System ==== Jelenségek ==== * Gyorsabb CPU -> I/O lassú * A CPU gyakran vár * Ötlet * egyidejűleg legyen több program a tárban ha egy program vár az I/O műveletre, akkor a másik program fut ==== Több programos kötegelt rendszer ==== Batch Multiprogramming System Az első ilyen OS * Master Control Program (MCP) * Burroughs 5000-ben ==== MCP ==== * Virtuális memória * Prioritások alkalmazása ==== Virtuális memória ==== * Kihasználjuk a CPU által nyújtott memória címzési lehetőséget. * Amikor egy program betöltődik nem biztos, hogy van elég memória számára amit megcímezhetünk. * A program, így olyan címet tartalmaz amely fizikailag nem létezik. * Az OS úgy viselkedik mintha lenne elég hely. ==== Prioritások alkalmazása ==== A programhoz hozzárendelünk egy prioritást a sürgősség alapján * pozitív egész szám ==== OS/360 ==== * A legismertebb többprogramos batch * IBM 360 gépén futott * A hardver moduláris * A szoftver visszafele kompatibilis ==== OS/360 két változata ==== * OS/MFT * OS/MVT === OS/MFT === * Multiprogramming with Fix Tasks * A memória szegmentált (partíciók) * ahány partíció annyi program tud futni * I/O készülék lassúak * spool (átmeneti tároló) === OS/MVT === * Multiprogramming with Variable Tasks * Akkor osztott a memória ha szükséges * A kiosztott terület a Task ==== Interaktív feldolgozás ==== * A programozó nem látja mit csinál a program, mert az operátortól sok függ * Az operátornak leadni a csomagot -> holt idő * Gyors mágneslemezek miatt * Spool technika elterjed * a rendszerprogram a mágneslemezen * Terminál ill. interaktív I/O eszköz a javításhoz ==== Batch programok újra ==== * egy időben több program is van a memóriában * de vezérlés átadás csak akkor történik, ha egy program megállási ponthoz ér * Egy program percekig, vagy akár órákig is futhat * Ezen változtat az interaktív technika ==== Időosztás ==== * time slice, time sharing * óra (timer) * méri az utolsó vezérlésátadás óta eltelt időt * Ezen rendszerek fénykora '60-'70-es évek ==== Első időosztásos OS-ek ==== * Compatible Timesharing System (CTSS) * DEC PDP-1 gépen * Kemény és Kurtz készíti Darthmondthban a General Electric számára * Darthmonth Timesharing System (DTSS) * IBM TSS/360 ==== Az interaktivitás következményei ==== * Nagy sikere van * Gyengeségek * az OS ide-oda kapcsol a programok között és adminisztrál; ezzel tölti az idejét * Az állandó beavatkozás veszélyt rejt * az egyik program hibája tönkreteheti a másikat is * Gondosabb szupervizor program kell ==== MULTICS ==== Kutatások kezdődtek a szupervizorok terültén az újabb problémák megoldására három intézményben: * Massachusets Institute of Technology * AT&T/Bell Laboratories * General Electric Munkájuk eredményeképpen létrejött a MULTICS. === Jellemzői === * PL/1-ben íródott * könnyen fejleszthető * hatékony felhasználói interfész * barátságos === Technikai jellemzők === * szegmentált virtuális memória * „gyűrűs” erőforrásvédelem * hierarchikus fájlrendszer * készülékfüggetlen * I/O átirányítás más készülékre ==== UNIX ==== * 1970-ben a MULTICS két kutatója * Ken Thompson * Dennis Ritchie másik szoftvercsoportba kerül * Egyfelhasználós OS-t fejlesztenek PDP-re * A Bell Laboratóriumban népszerű === Jellemzői === * egyszerű, hatékony hierarchikus fájlrendszer * shell jól kezelhető * I/O készülék egy speciális állomány -> átirányítás * több programos === Első UNIX === * Assembly-ben írodott * Akarták PL/1-ben * De a PL/1 PDP-re nem honosítható * C nyelv (B kísérleti nyelvből) * C fordító PDP-11 * A UNIX-ot átírják teljesen C-re === Szokatlan lépések === * Az egyetemeken forráskóddal együtt adják * Így nagyon népszerű lesz a kutatók és a hallgatók között === Jelentősége === Az első OS amely hardvertől függetlenül terjedhet, azaz hordozható ==== Absztrakt és virtuális gépek ==== * Vissza megyünk a '60-as évek végéhez – Európa * Eindhovenni Egyetem – Edger Dijsktra * új több felhasználós rendszer T.H.E * T.H.E – Technische Hogesschool Eindhoven * nagy hatással van a későbbi OS-re ==== T.H.E Multiprogramming System ==== === Újdonságok === * interaktív folyamatok kezelése * holtpontkezelés * szikronizáció * hierarchikus struktúra * a rendszer komponenseit szintekre osztjuk * időzítő, … felhasználói programok * Az alsó két szint absztrakt gép ==== TENEX ==== * Minden felhasználó több folyamatot és virtuális memóriát használhat -> Virtuális gép * A megközelítés az IBM-től van: CP/CMS * Miden felhasználó úgy látja, hogy saját CPU-ja és memóriája van * DEC PDP-10 gépen * 1960 ==== Kis számítógépek ==== Eddig a hardver és szoftver egységesen fejlődött A hardver árak rohamos csökkenése: különböző kategóriák jöttek létre. Létrejött kategóriák * mini * pl. IBM System/3, System/34, System/36, System/38, AS/400, iSeries * mikro * p.: Commondore 64 * személyi-számítógép (PC = Personal ComputerÖ ===== Szerkezet ===== Az operációs rendszer programok gyűjteménye. Ezek a programok speciális szerepet töltenek be más programokkal szemben. Az operációs rendszerek tervezése során a következőket kell figyelembe venni: * hardver * felhasználók száma * I/O készülékek Kezdetben élt az a tévhit, hogy egy operációs rendszert csak Assembly nyelven lehet készíteni. Hogyan változhatott akkor ez meg? A változásban a következő események jártak közre: * újabb hardvereszközök * nagyobb memóriaterület * gyorsabb számítógépek * magas szintű programozási nyelvek * kifejezetten OS készítésre * a magas szintű nyelvek hordozhatóak ==== Társzervezés ==== * rezidens * tranziens === Rezidens === * állandóan a főtárban van * felelősek olyan szolgáltatásokért amire egy futó programnak szüksége van * hibakeresés * folyamatvezérlés * végrehajtás ellenőrzés * a legkritikusabb rész * nevek: nukleus vagy kernel === Tranziens === * akkor töltődik be, ha szükség van rá * parancsinterfész * fájlkezelő rendszer * oda töltjük a memóriába ahol hely van Több folyamat használhatja váltakozva. A tranziens rész dinamikus könyvtárakba van szervezve: DLL, SHL ===== Felületei ===== Az operációs rendszeren belül kétfajta kapcsolat lehetsége: * közvetlen * interaktív terminálon parancsok begépelése * közvetett * programokból adjuk ki a parancsot ==== Felhasználói interfész ==== * parancs interfész * A felhasználó kommunikál az OS-el * program interész * A program és az erőforrások kommunikálnak az OS-el ==== Parancs interfész ==== * parancsnyelv * A felhasználó parancsai * válasznyelv * A felhasználónak adott visszajelzések === Parancsnyelv === * Job-control * Batch feldolgozás * Interaktív * parancssor * menüvezérelt * ikonvezérelt ==== Parancsállományok ==== === Parancsállományok csoportosítása === * CP/M submit fájl * MS-DOS parancsállomány (batch fájl) * UNIX shell script === Parancsállományok jellemzői === * paraméterezhető * egymásbaágyazható * megjegyzés lehet benne * van hibakezelés ===== Memóriakezelés ===== A memóriakezelés három részproblémára osztható fel: * memória-allokáció * memóriaterület és a program összerendelése * áthelyezés * az allokált területre illesztjük a programot * memóriavédelem ==== Allokáció ==== * egyfelhasználós rendszerben * többfelhasználós rendszerben * statikus memóriadefiníció * allokálható blokkok száma és mérete OS generálásakor rögzítjük * dinamikus memóriadefiníció * a blokkok számát és méretét igényléskor határozza meg ==== Memória foglaltság nyilvántartás módjai ==== * bit-térkép (bit map) * egyenlő méretű blokkok esetén használható * memória ellenőrző blokk (Memory Control Block = MCB) * memória blokk hossza nincs rögzítve ==== Allokációs stratégiák ==== * Következő illesztés (Next Fit) * Első illesztés (First Fit) * Legjobb illesztés (Best Fit) * Legrosszabb illesztés (Worst Fit) === Következő illesztés (Next Fit) === Az első szabad blokktól megvizsgálunk minden szabad blokkot. Az első (méretnek) megfelelőt választjuk. Új keresést ott folytatjuk, ahol az előzőt abba hagyjuk. === Első illesztés (First Fit) === Mindig az első FMCB-ből kiindulva keressük az első alkalmas blokkot. A kiválasztott FMCB rész két részre oszlik. Egyikben elhelyezzük programot, maradék rész FMCB lesz. === Legjobb illesztés (Best Fit) === Bejárjuk az összes blokkot, méretüket megvizsgáljuk. Megjegyzi a hozzá legközelebb állót === Legrosszabb illesztés (Worst Fit) === Ahhoz a szabad helyhez allokáljuk a programot, ahol legtöbb szabad hely marad. Azt reméljük a nagyobb szabad blokkok később használhatóbbak. ==== MEMÓRIAVÉDELEM ==== * Egyfelhasználós rendszer * határcím * határregiszterek * Többfelhasználós rendszer * határregiszterek használata * alsó és felső korlát megadása * alsó és blokkszélesség megadása ===== Virtuálismemória ===== Virtuális memóriát akkor használjuk, ha egy újabb programot szeretnénk futtatni és már nincs számára elég szabad memória terület. ==== Memóriaáthelyezési technikák ==== * áthelyezési táblázat * leképezési regiszterek * laprabontás ==== Laphiba ==== Az elérni kívánt lap, nincs a fizikai memóriában. **Normális működés, nem valódi hiba!** ==== Kettős laphiba ==== A laphibát kezelő rutin is laphibát okoz. ==== Négy alap probléma ==== * Betöltés * Mikor kell egy lapot betölteni? * Elhelyezés * Hova kell a lap képét betölteni? * Helyettesítés * Melyik lapot kell eltávolítani a főtárból, ha nincs hely * Módosított lapok kezelése * eltávolított lapot mikor kell visszaírni a másodlagos tárolóra? ==== Lokalitás elve ==== Az aktuális - és az ezek közvetlen közelében elhelyezkedő – címekre a közeljövőben nagy valószínűséggel ismét hivatkozunk. Bélády László - 1966 ==== Betöltési probléma ==== Egyszerű: Akkor kell lapot betölteni, ha nincs a főtárban Finomíthatjuk, ha megvizsgáljuk mikor van szükség az adott lapra Lokalitás elve: Néhány szomszédos lapot is betöltünk ==== Elhelyezési probléma ==== Mivel ugyan olyan méretű lapokkal dolgozunk, ezért nincs a memóriának kitüntetett része. Ha van valahol szabad hely, akkor oda betöltjük a kívánt lapot. ==== Helyettesítési probléma ==== Cél: olyan lapot távolítsunk el, amelyet nem kell visszatölteni (feltehetőleg) stratégiák: * legrégebben használt * legritkábban használt * legrégebben memóriában lévő (FIFO) * kombinált módszerek ==== Módosított lapok kezelése ==== * nem módosított lapok * módosított lapok * Időigényesebb a lap cseréje! Ezért csak akkor választunk ebből a halmazból, ha a másik üres ==== Szegmentált virtuális memória ==== A lapokrabontás mellett a programokat logikai egységek szerint feldaraboljuk, és szegmensekre osztjuk. Egy szegmensre, egységes egészként hivatkozunk. Minden folyamathoz szegmenstáblát készítünk a főtárban, vagy a a hardveren szegmenstábla regiszterek használata. ==== OS-ek virt. mem. szokásai ==== === Linux === Csak akkor ír a swapra, ha már betelt a memória === Windows === Akkor helyezi a programot a memóriába, ha használjuk (a tálcáról előtérbe hozzuk) ===== Folyamatok ===== Azokat a tevékenységeket , amelyeket egy program végrehajt, folyamatnak (processznek) nevezzük. Végrehajtás alatt lévő program. A folyamatok váltakozva hajtódnak végre. Egy időpontban a CPU-t csak egyetlen folyamat használja! Folyamatszervezés módjai * Szekvenciálisan szervezett folyamatok * Minden folyamat egy időszeletet kap (kb. 20 millisecundum) * Közbeékelt folyamatszervezés * Multiprogramozás: az erőforrások egyidejűleg több folyamat között is felosztásra kerülnek ==== PCB ==== Precess Control Block Folyamatellenőrző blokk === PCB – folyamat információk === Amit eltárolunk egy folyamatról: * folyamat neve * felhasznált memória * állapot * környezet * prioritás * szükséges erőforrások * összefüggések * elszámolási információk === Folyamat neve === * Külső név * karakter sorozat * felhasználók számára * Belső név * egész szám * operációs rendszer számára === Folyamat állapot === * direkt kód az állapot leírására * pointer (mutató) az állapot leírására === Környezet === Környezet alatt a regiszterek tartalmát és egyéb információkat értünk. === Prioritás === Prioritás alatt a folyamat relatív fontosságát értjük a többihez viszonyítva. Akkor használjuk, ha több folyamat vár egy erőforrásra. === Szükséges erőforrások === * mit használunk éppen * mire lesz szükség a jövőben === Összefüggések === * A folyamatok közötti viszony leírása. * A szülő-gyermek kapcsolatok leírása === Elszámolási információk === * időparaméterek * felhasznált erőforrások * folyamat tulajdonos neve * stb. ==== Folyamatok és erőforrások kapcsolata ==== Az erőforrás lehet: * fizikai * központi tár * háttértár * I/O készülék * állomány (mert hosszú ideig állnak rendelkezésre) * logikai * állományban vagy központi tárban helyezkednek el ==== Erőforrás másként ==== Erőforrás (más szempont szerint) * ismételten felhasználható * a felhasználói folyamat nem rombolja le * megszűnő erőforrás * általában egy folyamat létrehozza, egy másik használja, az OS lerombolja * pl.: üzenet amit egyik prg. küld a másiknak ==== Speciális erőforrás ==== * CPU * Memória Azért speciális, mert közvetlenül, rendszerhívások nélkül érjük el őket. Olyan két erőforrás, amit nem kell igényelnünk meg mindig szükség van rá. ==== Egyéb erőforrások ==== * Más erőforrásokhoz rendszerhívásokon keresztül jut a folyamat * igénybejelentést előzi meg a használatot * pl. állományok, I/O készülékek ==== Erőforrások használata ==== * néhány folyamat -> ütemezés egyszerű * sok folyamat -> ütemezés bonyolult * szélsőséges esetben holtpont léphet fel * Holtpont (deadlock): egy erőforrás – amelyre néhány folyamat várakozik – nem szabadítható fel, mert egy másik folyamat, amely azt használja, nem fejezhető be, mivel másik erőforrásra várakozik, amely szintén nem szabadítható fel. * várakozás sor (queue) * sorban tárolás esetén ütemezés: FIFO * first in first out ==== Környezetváltás ==== Multitaskos rendszerben a folyamatnak mindig más folyamatnak engedi át a CPU-t. Folyamathoz tartozó információ megőrzése történhet: * regiszterekben * státusz-flagekben * státusz szavakban * vermekben * címterületeken ==== Környezet ==== A megőrzött információ adja a környezetet Ennek cseréje a környezetátállás * van ahol több regisztert alkalmaznak a gyorsításhoz * van ahol az OS számára külön regisztert tartanak fent ==== Folyamatvezérlő műveletek ==== * statikusan kezelt folyamatok * az egyszer aktív folyamat sosem szakad meg * új folyamatot sosem generálnak * dinamikusan kezelt folyamatok * folyamatokat állítunk elő, indítunk * subprocess * szülő-gyermek kapcsolat Folyamatvezérlő műveletek: * Létrehozás * Megszüntetés * Attribútumok olvasása, megváltoztatása * Felfüggesztés, újraindítás === Folyamatok létrehozása === Ha a rendszerben dinamikus folyamatkezelés van! * Rendszerhívással végezhető művelet * indíthatja rendszerprogram * indíthatja felhasználó === Folyamat előállítás műveletei === * PCB előállítása * Memória allokálása * Program betöltése * Kezdeti paraméterek megadása, forráskorlátok folyamathoz rendelése === PCB előállítása === * rögzített terület tartunk fent * meghatározott számú PCB * külön kulcsolási területet (system queue area) tartunk fent * vagy keverjük az előző két technikát * Pl.: UNIX * PCB-ét két részre osztjuk * legfontosabb adatok -> folyamat táblában * pointer mutat a maradék részre -> felhaszn. ter. === Memória terület allokálása === * megvizsgáljuk van-e elég hely a memóriában az PCB-hez tartozó program számára * ha van allokáljuk * ha nincs felfüggesztjük a folyamat előállítását === Betöltés === betöltő végzi (relocating loader) * végrehajtható formában tárolt állományokat olvas be * bonyolult lehet mert a kezdő címek csak akkor válnak ismerté, ha betöltjük az ugró utasítások címeit Kezdeti paraméterek * kezdeti paraméterek beállítása * erőforráskorlátok beállítása UNIX alatt a létrehozott gyermek folyamatok mindig öröklik a szülő által már allokált erőforrásokat === UNIX – új folyamat előállítása === * elágaztatás (fork) * új folyamat előállítása * de kezdetben nincs új program betöltve * helyette a szülőhöz tartozó programot futtatja * végrehajtás (exec) {rendszerhívás} * betölt egy új programot * megkezdődik a végrehajtása === Folyamatok megszüntetése === Okok * önmaga igényli * szülő folyamat ért véget * normálisan * abnormálisan * kitüntetett folyamat kényszeríti * operátori parancs * „nem azonosítható” hiba === Folyamat megszüntetése === Destroy process rendszerhívással * kötések feloldása * gyermek folyamatok megszüntetése * allokált memória felszabadítása * PCB felszabadítása === Megszüntetendő folyamat gyermekei === Lehet olyan gyermek folyamat amelyet kifejezetten azért hoztunk létre, hogy túlélje a szülő folyamatot (pl. nyomtatás) vagy hozzárendeljük őket egy másikhoz vagy árvának tekintjük UNIX-ban az árva folyamatot a init folyamathoz rendeljük === Attribútumok olvasása, változtatása === * adatok olvasása a PCB-ből * értékek megváltoztatása a PCB-ben === Felfüggesztés és újraindítás === * felfüggesztés (suspend) * a folyamat más folyamatok eredményére vár * megszakítás következett be * időpontra vár * újraindítás (waku up) * az alvó folyamat felébresztése, újraindítása ===== Ütemezés ===== Az a művelet amely meghatározza a sorrendet az újrafelhasználható erőforrások igénybevételére. ==== Kiemelt erőforrások ==== * Memória * Kicsi * CPU * Csak egy van belőle * Így kiélezett verseny folyik értük * nehézség, hogy a folyamatok sosem fordulnak ezekért az erőforrásokért mégegyszer ==== Folyamatok osztályozása ==== * Batch folyamatok * jobban elhelyezett munkák, felhasználó nem kommunikál folyamattokkal * Interaktív folyamatok * interaktív terminálról küldött felhasználói beavatkozások * Real-time folyamatok * rendszeren kívül zajló műveletet figyelünk, ellenőrzünk, irányítunk ==== Ütemezési stratégiák ==== * hosszú távú * folyamatok sorbajutásának ellenőrzése * Középtávú * folyamatok közül kiválasztják melyek lehetnek CPU használatra jelöltek * rövid távú * hogyan rendeljünk a CPU-hoz futáskész folyamatokat * kiválasztás (scheduler) * előkészítés (dispatcher) ==== Ütemezési célok 1 ==== * áteresztés * a lehető legtöbb munka elvégzése * konzisztencia * kiszámítható foly. kezelés * válasz * legrövidebb időn belül szolgáljunk ki * korrektség * azonos jellemzőkkel bíró foly. azonos módon kezelése * átfutás * leggyorsabb befejezés * források kezelése * kerüljük a várakozást, a forrásokat folyamatosan használjuk ==== A célokról ==== A célok részben ellentmondanak egymásnak. Ezért kompromisszum szükséges. Megoldásként kategóriákba soroljuk a folyamatokat. Kategóriába soroláshoz alapadatok: * prioritás * kategória * becsült futási idő és a szükséges erőforrások * I/O igények és azok gyakorisága * kapcsolat egy interaktív terminállal * kiszolgálásra mennyi ideje vár ==== Stratégia alkalmasságának megítélése ==== * legrosszabb eset vizsgálat * milyen távol kerülünk az elméleti optimumtól * átlagos eltérés vizsgálata * a mért értékek statisztikai jellemzői mennyire térnek el az optimumtól ==== Fontos jellemzők ==== * Prioritás * mérőszám, többiekhez viszonyított relatív fontosság * csökkenő prioritás (pl.: MVT 0..15) * növekvő prioritás (pl.: VMS 0..31) * Unixban lehet negatív és pozitív * A prioritást PCB-ben tároljuk vagy külön prioritási sort hozunk létre ==== Prioritás osztályozása ==== * statikus * a folyamat élettartalma alatt a prioritás nem voltozik * dinamikus * a folyamat élettartalma alatt a prioritás változhat ==== Önköltség ==== A folyamat kicserélésre használt idő * rövid távú ütemezés esetén * OS döntést előkészítő eljárása fut * környezetváltás * közép távú ütemezés esetén * memória tartalom csere (swaping) ==== Megszakíthatóság ==== * nem megengedett * non-preemtív * addig foglalja a CPU-t amíg le nem mond róla * órákon át futhat * megengedett * preemtív * ha a magasabb prioritású job ready állapotba kerül, akkor megkapja a CPU-t ==== Batch folyamatok ütemezése ==== * Jobokkal dolgozunk * programcsomag * a programok „stepek”-ben hajtódnak végre * Fontos paraméter a becsült futási idő * felhasználó adja meg * felső korlát lesz === Hosszú távú ütemezés === * A jobok közbülső tárolási területen * spool terület * Input sorokba rendezve * input queue * Az initator nevű program vizsgálja az input sorokat * Ha az első step számára minden erőforrás szabad akkor kiválasztja * Kezdéskor időzítőt állítunk be * valós időt mérhetünk vagy * CPU időt mérhetünk === Középtávú ütemezés === Batch esetén nem külön feladat Mivel a jobokat akkor engedjük futni, amikor minden erőforrás rendelkezésre áll. === Rövid távú ütemezés === * ha az operatív memória felszabadul, akkor a készenlétben levő folyamatok közül választunk * egy folyamat fut amíg: * véget nem ér * önként felfüggeszti magát * I/O utasításra van szüksége vagy olyan szolgáltatást kér, amely várakozást igényel * magasabb prioritású folyamat megszakad ==== Rövid távú ütemezési stratégiák ==== * SJN * FIFO * Dinamikus prioritású * SRTN === Shortest Job Next (SJN) === * előnyben részesíti azokat a jobokat, amelyeknek rövidebb a becsült végrehajtási ideje * hátránya * ha mindig van rövid becsült idejű, akkor a hosszú sosem fut * éhenhalási vagy * kiéheztetési jelenség === First-In First-Out – FIFO === * leggyakrabban alkalmazott technika * abban a sorrendben lesznek végrehajtva, ahogy érkeztek * azonos prioritás === Dinamikus prioritású === * job öregedik, így változik a prioritása * néha megszakításos rendszerekben használjuk === Shortest Remaining Time Next – SRTN === * legkevesebb megmaradt idejű job lesz kiválasztva * megszakításos rendszerekben legsűrűbben használt ==== Interaktív folyamatok ütemezése ==== * interaktív terminál <-> felhasználó * tevékenységek hosszúak lehetnek * indításkor semmit nem tudunk az igényelt erőforrásokról * azonos módon kezelt folyamatok * múltbeli viselkedésből következtetünk jövőben viselkedésére * felhasználónak gyors válasz kell === Hosszú távú ütemezés === * nincs jelentősége * az elindított folyamat azonnal fut * kivéve: * túlterhelt rendszer * a rendszerbelépéssel túllépnénk a rendszerkorlátokat * minden folyamat kap egy időszeletet === Középtávú ütemezés === * a központi tár időszeletének kiosztása * számlálót állítunk be a PCB-ben * a rendelkezésre álló CPU időt adjuk meg * ha fut a folyamat a felhasznált idővel csökkentjük * ha I/O tev. van akkor is csökkentünk * ha nincs több CPU idő kikerül az aktív halmazból * Swapolunk ha szükség van az elfog. területre === Rövid távú ütemezés === * CPU időszeletének kiosztása * ha lejár a rendelkezésre álló idő -> környezetváltás * A CPU általában 100 millisecundum és néhány másodpercig használható * Prioritás alapján választunk vagy sorbarendezünk * Nincs teljes futásiidő túllépés (batchnál van) * Alacsonyabb prioritású foly. néha megszakítható === Stratégiák rövid távú ütemezés esetén === * prioritásos ütemezés * prioritás alapján választunk * csoporton belül körkörösen ütemezünk * különböző prioritáshoz, különböző időszelet * alacsony prioritás -> nagyobb időszelet * körkörös ütemezés * sorba rendezünk * rögzített időszelet * sor elejéről választunk * nincs CPU idő -> sorvége * újak a sorvégére ==== Prioritás-kezelés ==== * öregítési technika * visszacsatolás * Kleinrock – önző ütemezés * „tisztességes kiosztás” === Öregítési technika === * időnként felülvizsgáljuk a folyamatokat * ha nem került a folyamatra vezérlés, akkor növeljük a prioritást === Visszacsatolás === * Az éppen befejezett folyamat alacsonyabb prioritást kap === Kleinrock === Kleinrock – önző ütemezési technika * készenléti állapotban lévő folyamat -> külön speciális prioritás * független a normál prioritástól * az új és a készenlétben levő folyamatokat valamilyen technikával növeljük * pl. öregítés === „tisztességes kiosztás” === * a folyamatok különálló csoportokba azaz halmazokba szervezettek * a CPU időt a csoportokhoz rendeljük * kevés CPU idővel bíró csoport magas prioritást kap ==== Hardver támogatás ==== * nem szükséges * szoftveresen minden megoldható * de ha van nagyban növeli a hatékonyságot * regiszterek többszörözése * huzalozott utasítások * speciális CPU utasítások ===== Folyamatok interakciói ===== A folyamatok között a következő két esetben szokott interakció létrejönni: * ha egy erőforrásra várnak * jelzést kíván egyik küldeni a másiknak ==== Interakciók típusai ==== * Erőforrások osztott használata * erőforrásért versenyeznek * konkurensek * akaratlan * Kommunikációból eredő interakció * információt osztanak meg egymással * kooperatívak * akaratlagos Lehetséges probléma: holtpont ==== Holtpont ==== * Folyamat leköt egy erőforrást, egyúttal várakozik egy másik lekötött erőforrásra. A másik erőforrást másik folyamat lefoglalta. * Folyamatok kommunikálnak. Egymás információira várnak. === Holpont létrejöttének feltételei === * Kölcsönös kizárás * egy erőforrás egyidejűleg csak egy folyamat használhat * Erőforrások lefoglalása * erőforrást kell birtokolni, miközben újat igényel * Megszakítás nincs megengedve * erőforrás hozzárendelés nem szüntethető meg * Ciklikusan láncolható igények * a folyamat olyan erőforrásra vár, amelyet a láncban következő folyamat tart lefoglalva A feltételeiknek egyszerre kell megfelelni! === Holtpontmegelőzés === A cél, hogy úgy ütemezzünk az erőforrásokat, hogy a holtpont bekövetkezésének feltételei közül legalább egy ne teljesüljön. ==== Kölcsönös kizárás ==== * néhány forrás esetén elkerülhetetlen * CPU * egyes I/O készülékek * könnyen elkerülhető pl.: csak olvasásra megnyitott fájloknál * I/O készülékeknél spoolingolunk * átmeneti tárolóban helyezzük el a tevékenységet * batch folyamattal használjuk ==== Erőforrások lefoglalása ==== Folyamatot úgy programozzuk, hogy egy időben csak egy erőforrást használjon. ==== Megszakíthatóság ==== * néhány erőforrás esetén azonnal eldönthető, hogy nem követelhető meg * nyomtatás, olvasásra szánt fájl * T.H.E rendszerben mégis megszakítható a nyomtatás ==== Ciklikusan láncolható igények ==== Havendar által fejlesztett hierarchikus rendezés * A forrásokat kategóriákba osztjuk * A kategóriákhoz prioritást rendelünk * Egy adott prioritási szinten levő forrást csak akkor kaphat meg a folyamat, ha vele azonos vagy nála magasabb szinten nem használ forrást. ==== Holtpontelkerülés ==== * dinamikus módszer, amely megkísérli elérni, hogy sohase allokáljunk a forrásokat oly módon, hogy a rendszer „bizonytalan” állapotba kerüljön * Bizonytalan az állapot, ha megnő a holtpont bekövetkezésének a veszélye * Általános stratégiát erre javasolni nagyon nehéz! Az interakcióba került folyamatok erőforrásigényeit ellenőrizni kell Egy módszer lehet, ha a nagyobb igényű erőforrásokat külön ellenőrizzük. * nem javasolt * növeli az önköltséget === Habermann bankár algoritmus === * bankár zárt csoportnak biztosít hitelt * feltételezi egyszerre nem veszik igénybe az egész hitelkeretet * így a teljes hitelkeretnek csak egy részét tartalékolja * hitel = erőforrás használat * Ha egyszerre több igény van, fokozatosan elégíti ki * újabb hitelezés előtt, az előző lépésben kifizetett, teljesen kielégített hitelkeretet mindig felszabadítja * Adott hitelezési állapot rendszerállapot * R1 rendszerállapot biztonságos, ha ebből létrehozható az állapotoknak egy olyan sorozata, amely a maximális igények egymás utáni kielégítésével eljuthat az összes maximális hitelkérelem kifizetéséhez. A = aktuálisan igénybe vett hitel M = Maximálisan igénybe vehető hitel ^ Név ^ A ^ M ^ ^ Név ^ A ^ M ^ ^ Név ^ A ^ M ^ | Nagy | 0 | 9 | | Nagy | 2 | 9 | | Nagy | 1 | 9 | | Kovács | 0 | 5 | | Kovács | 1 | 5 | | Kovács | 3 | 5 | | Szabó | 0 | 4 | | Szabó | 2 | 4 | | Szabó | 2 | 4 | | Takács | 0 | 7 | | Takács | 4 | 7 | | Takács | 4 | 7 | | Szabad keret | 11 | | | Szabad keret | 2 | | | Szabad keret | 1 | | | Biztonságos ||| | Biztonságos ||| | Bizonytalan ||| ==== Holtpont érzékelés ==== * nehéz mert sok folyamat vehet részt * nehéz mert más tevékenység „normálisan” halad === Lehetséges stratégia === - Futó folyamatok közül erőforrást igénylők kiválasztása - ezek vesznek részt a holtpont kialakításában - Keressünk egy olyan folyamatot amely erőforrásigénye kielégíthető. Jelöljük meg - Minden olyan forrást, amelyet most kijelölt tevékenységünk használ, tekintsünk szabadnak - Ismételjük meg az eljárást a 2. ponttól mindaddig, amíg nem jutunk el egy olyan állapotba, amikor már nincs kiszolgálható tevékenység === Következtetés === * Ha az eljárás végén marad nem kiszolgálható folyamat, akkor létezik a rendszerben holtpont * A megmarad folyamatok éppen azok, amelyek a holtpont kialakításában részt vesznek ==== Holtpont megszüntetése ==== * Feladat: várakozási kör lebontása * Drasztikus: * a kör kialakításában résztvevő összes folyamat megölése * néha elég néhány tevékenységet kiemelni és azt megszakítani * néha elég az előbb kiemelt tevékenységeket egy korábbi állapotba visszaállítani ===== Megszakítások, IO kezelés ===== ==== Megszakítás típusok ==== * I/O művelet befejezés miatt * timer-megszakítás * riadó megszakítás * programhiba-megszakítás * rendszermegszakítás * készülék-hibamegszakítás ===== Irodalom ===== * Dr. Galambos Gábor: Operációs rendszerek * http://en.wikipedia.org/wiki/Operating_system