szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[: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