Előadás_#11. Előadás_11-1 -

Átírás

1 Előadás_# Az NT belső mechanizmusai: A Windows NT kernel módú komponensei (Executive illetve Device driver) által használt legfontosabb rendszer mechanizmusok: megszakítás- és kivételkezelés objektumkezelés szinkronizáció lokális eljárás hívás (Local Procedure Calls / LPC s) Megszakítás- és kivételkezelés A megszakítások (interrupt) és a kivételek (exception) olyan műveletsorozatok, melyek hatására az éppen feldolgozás alatt lévő folyamat futásának félbehagyása történik, mivel egy magasabb prioritású igény végrehajtása válik indokolttá. A megszakítások és kivételek egyaránt lehetnek hardver vagy szoftver alapúak. A kivételek kezelését egy erre a célra szolgáló kernelmodul, a kivételkezelő (exception dispatcher) végzi. A kivételkezelő feladata a bekövetkezett kivétel beazonosítása (pl. hibás memóriacímzés, nullával való osztás, túlcsordulás, a nyomkövető programok töréspontjai), a szükséges adminisztráció elvégzése, a probléma megoldása, majd a felfüggesztett folyamat futásának folytatása. Az előbb felsorolt példák szoftveres események, melyek nyilván függetlenek az architektúra kialakításától. Az NT alapú rendszerekben létezik az úgynevezett csapda (trap) fogalma is. Ez esetben a azonban nem egy folyamat, hanem egy szál futásának a félbehagyásáról van szó. A mechanizmus végrehajtásához a CPU-t user módból kernel módba át kell váltani, majd meg kell hívni a trapkezelőt (trap dispatcher), amely azt hivatott eldönteni, hogy szoftveres úton kezelhető-e az adott probléma. Azért, hogy a szál végrehajtása az adott probléma lekezelése után folytatható legyen, a trapkezelő elvégzi a megfelelő adminisztrációt, eltárolja az operációs rendszer számára a folytatáshoz szükséges adatokat. Előadás_11-1 -

2 Objektumkezelés Az NT alapú rendszerekben az objektumok kezelését az executive egyik komponense az objektumkezelő (object manager) végzi. Feladata az objektumok előállítása, kezelése, törlése, és védelme. Az előbb felsorolt feladatokból következik, hogy az objektumkezelő tartalmazza az erőforrás kezelő műveleteket, melyek így jól definiáltan, egy helyen találhatók meg az operációs rendszeren belül. Az objektumkezelő felé támasztott igények: Biztosítson egységes mechanizmust a rendszer erőforrásainak elérésére, illetve használatára. Az objektumok kezelését, és védelmét biztosító kód egy helyen legyen. A rendszer erőforrásainak használatát optimálisan korlátozva, folyamatosan kövesse nyomon a folyamatok objektumhasználatát. Megfelelő névtérrel biztosítsa az objektumok és objektum csoportok egyértelmű azonosítását. Az NT alrendszerek által támasztott követelmények kielégítése. o A Win32 és a POSIX alrendszer esetében szempont az, hogy egy folyamat legyen képes erőforrásokat örökölni a szülő folyamattól. o Legyen lehetőség kis- és nagybetűt megkülönböztető fájlnevek használatára. Biztosítani kell az objektumok életben tartását, ami azt jelenti, hogy egy objektumnak mindaddig rendelkezésre kell hogy állnia, amíg az összes vonatkozó folyamat be nem fejezte az objektum használatát. Az NT alapú rendszerekben a következő két objektumtípust különböztetünk meg: executive objektum típus kernel objektum típus Az executive objektumok az összetettebb szerkezetűek, ezeket az executive réteg különböző komponensei hozzák létre. (a folyamatkezelő, a biztonsági alrendszer, a virtuálismemória-kezelő, az I/O-alrendszer) A kernel objektumok egyszerűbb szerkezetűek, mégis alapvető funkciókat valósítanak meg. Ilyen például a szinkronizáció, amelyet az executive objektumok is igénybe vesznek. Az executive objektumok jellemzően több kernel objektumból épülnek fel. A folyamatok az objektumokhoz egy úgynevezett handle (szószerinti jelentése fogantyú, nyél, - igazi magyar elnevezése nem használatos) igénybe vételével férhetnek hozzá. A handle tehát az objektumhoz való hozzáférési információkat tartalmazza. Tartalmilag egy összetett elérési címről van szó, ami gyakorlatilag egy Előadás_11-2 -

3 összetett pointer, aminek igénybe vételével lényegesen gyorsabban érhető el egy objektum annál, mintha az objektum nevével hivatkoznánk rá. Szinkronizáció A folyamatok szinkronizálásának alapvető eszköze a kölcsönös kizárás, különös tekintettel a nem osztott elérésű erőforrások elérésének szabályozására. A kölcsönös kizárás különösen fontos az NT alapú operációs rendszerek esetében, mivel a több CPU-s (és ezen belül is több magos CPU-k) architektúrák használatakor ez elengedhetetlen. A kernel, hogy elláthassa a több szál által is használt adatstruktúrák kezelését, a kölcsönös kizárást megvalósító alapmodulokat (a korábban már említett primitíveket) veszi igénybe. Ebben az esetben is elengedhetetlen a szinkronizáció, melyet az executive réteg biztosít, szintén a primitívek használatával. A kernel kódok végrehajtásakor a végrehajtás minden fázisában a kernelnek biztosítania kell, hogy egy kritikus szakaszt csakis egyetlen CPU (CPU mag) hajt végre. Mivel megszakítások gyakorlatilag bármikor bekövetkezhetnek, kezelésük a szinkronizáció során nem mindig oldható meg zökkenőmentesen. Amennyiben a kernel éppen egy globális adatstruktúrát módosít, előfordulhat, hogy pont egy olyan megszakítás történik, aminek a kezelő rutinja pontosan ugyanazt a globális struktúrát módosítaná. Az ilyen helyzetekben az NT alapú operációs rendszerek más megoldást alkalmaznak egy CPU mag esetén, illetve több CPU vagy CPU mag esetén. Egy CPU mag esetén az NT mozgástere kicsi. Az operációs rendszer mindössze annyit tehet, hogy a globális erőforrások használata előtt ideiglenesen letiltja azokat a megszakításokat, amelyek megszakítás kezelő programja ugyanazt a globális erőforrást venné használatba. Technikailag ez úgy történik, hogy a CPU futási szintjét a szóban forgó megszakítások közül a legmagasabb szintre emeli az operációs rendszer. Több CPU mag esetében ez nyilván nem elegendő, hiszen hiába emeli meg az operációs rendszer az egyik CPU mag prioritását, egy másik CPU mag ettől még készen állhat a megszakítás elfogadására. A kölcsönös kizárás ilyen esetben az úgynevezett lezárással (locking) garantálható, ami úgy valósítható meg, hogy a szóban forgó globális erőforráshoz tartozó spin-lock (szószerinti jelentése forgózár, - igazi magyar elnevezése nem használatos) segítségével a kernel zárolja az erőforrást. A spin-lock megszerzése után az operációs rendszer már priorizálhatja a globális erőforrás használatára jelentkező igények végrehajtási sorrendjét. Multiprocesszoros környezetben a globális adatstruktúrákhoz való hozzáférést az executive réteg komponenseinek is szinkronizálnia kell. A kernel funkciók hívásakor Előadás_11-3 -

4 is célszerű a lezárás használata. Természetesen nem szabad megfeledkezni arról sem, hogy ez szükségképpen időveszteséggel jár, hiszen a prioritási sorban elfoglalt helyének megfelelően minden folyamat több-kevesebb ideig várakozni kényszerül, sőt az összes érintett CPU mag is várakozni kényszerül. Ezért a módszer nem alkalmazható korlátozásmentesen: A lezárással védett erőforrásnak gyorsan elérhetőnek kell lennie, azaz nem lehetnek szerteágazó logikai kapcsolatai. A kritikus szakaszok nem lapozhatók ki a memóriából, nem hívhatnak külső eljárásokat (rendszerszolgáltatásokat sem), valamint nem okozhatnak se megszakítást, se kivételt. Ezek a korlátozások különösen annak figyelembe vételével, hogy az executive objektumok a kölcsönös kizárás mellett igényt tarthatnak az előidejűségre, illetve az egyidejűségre is, valamint a user folyamatokkal is megkövetelt szinkronizáció miatt nem minden esetben érvényesíthetők pusztán a spin-lock igénybevételével. Szükség van további szinkronizációs objektum kezelőkre (dispatcher object) is, melyek megfelelő függvényhívások segítségével képesek dinamikusan kezelni, azaz főleg várakoztatni a hozzáférést igénylő objektumokat (WaitForSingleObject, WaitForMultiplyObject). Az operációs rendszer a várakoztatott objektum felszabadulásakor annak típusától függően, egy vagy több várakozó folyamatot is futásra kész állapotba tehet. Lokális eljárás hívás (LPC) A lokális eljáráshívás (LPC / Local Procedure Call) a folyamatok közötti kommunikációt biztosítja gyors üzenet továbbítással. NT alapú operációs rendszerek esetében az LPC kizárólag a rendszer komponensek számára használható, így például a Win32 API-n keresztül nem érhető el. Az LPC tipikus esete az NT alapú operációs rendszerek szolgáltatásait realizáló szerver folyamatok és a kliens folyamatok közötti kapcsolattartás. LPC-kapcsolat létrehozható két felhasználói módú folyamat között, vagy egy kernel módú komponens és egy felhasználói módú folyamat között. 2. Az NT folyamatok Alapfogalmak: A program maga a végrehajtható kód. A folyamat egy végrehajtás alatt lévő program. A folyamat egy szála az, ami éppen fut egy CPU-n, és nem maga a folyamat. Minden folyamathoz tartozik legalább egy szál, ami elinduláskor elkezdi futni. Előadás_11-4 -

5 A folyamatok az NT-ben egy adott program kódját végrehajtó (egy vagy több) szálból, valamint a szálak által birtokolt erőforrásokból állnak. Az NT folyamat modellje a következő dolgokat foglalja magába: A végrehajtandó program kódját és adatait. Saját virtuális memória címteret, amit a folyamat használhat. Rendszererőforrásokat (szemaforokat, fájlokat stb.) amiket az operációs rendszer foglal a folyamat számára, amikor a folyamathoz tartozó szálak azokat megnyitják. A folyamat egyedi azonosítóját (process ID, PID). Legalább egy végrehajtható szálat. A szál az az egység (entitás) az NT-ben, amit az ütemező kezel és végrehajtásra ütemez a CPU-hoz. A szálak a következő komponensekből állnak: A szálat végrehajtó CPU regiszterei, melyek a processzor állapotát írják le. Két veremtárat (stack). Egyet a kernel módban történő programvégrehajtáshoz, egyet a felhasználói módban történő programvégrehajtáshoz. Kizárólagosan használható tárterületet a DLL-ek, run-time könyvtárak számára. A szál egyedi azonosítóját (thread ID). (Megjegyzendő, hogy a thread ID és a process ID ugyanabból a névtérből kerül ki, így egy rendszerben sohasem lehet két egyező.) A felsorolás első három elemét együttesen hívjuk a szál környezetének (thread context). Az egy folyamathoz tartozó szálak közös virtuális címtartományt használnak. Az egyes folyamatok viszont külön címtartományban futnak, csak osztott elérésű memória használata esetén lehet átfedés két folyamat által használt memóriaterület között. A folyamatok illetve egészen pontosan a folyamatokat alkotó szálak által használni kívánt memóriaterületeket természetesen a rendszertől kérni kell, le kell foglalni azokat. A memóriához hasonlóan a folyamatnak le kell foglalni a folyamat által használni kívánt erőforrásokat, amelyeket az NT objektumokként reprezentál. Minden ilyen objektumhoz a megnyitása után a folyamat a gyorsabb elérés érdekében egy ún. handle-t kap. Előadás_11-5 -

6 A rendszer erőforrásainak védelme, illetve az erőforrás használat szabályozása érdekében minden folyamat rendelkezik egy ún. elérési tokennel, mely tartalmazza a folyamat biztonsági azonosítóját, illetve a folyamat jogosultságainak leírását. Folyamatok és szálak adatstruktúrája A Windows NT executive rétege a folyamatokhoz tartozó adatokat egy ún. folyamatblokkban (EPROCESS) tárolja. Minden folyamathoz hozzárendel az NT egy ilyen adatstruktúrát a folyamat indulásakor. A blokk a folyamat kísérő adatait tartalmazza, valamint egy sereg mutatót a kapcsolódó adatstruktúrákra. Például minden folyamaton belül van egy vagy több szál, ahol a szálakat ún. executive szálblokk (ETHREAD) ír le. Az EPROCESS blokk és a hozzá tartozó adatstruktúrák a rendszer címterében helyezkednek el. Kivétel ez alól a folyamat futási környezetét leíró ún. folyamatkörnyezeti blokk (PEB / Process Environment Block), amely a folyamat címterében található. Ennek oka, hogy ez az adatstruktúra olyan információt tartalmaz, amit a felhasználói módban futó kód is megváltoztathat. Az EPROCESS blokkon felül a Win32 alrendszer folyamata is kezel egy folyamatleíró adatstruktúrát (W32PROCESS). Minden Win32 kódot végrehajtó folyamathoz tartozik egy-egy ilyen adatstruktúra. Előadás_11-6 -

7 Folyamat létrehozása Egy Win32 folyamat akkor jön létre, amikor egy alkalmazás meghívja a Win32 CreateProcess függvényét. A létrehozás több fázisból áll, amelyeket az operációs rendszer három részlete valósít meg: a Win32 kliensoldali könyvtárából a KERNEL32.DLL, a Windows NT executive, valamint a Win32 alrendszer folyamat (CSRSS). Mivel a Windows NT több környezeti alrendszert kezel, emiatt egy Windows NT executive réteg processz objektumának kezelése (amit más alrendszerek is tudnak használni) szét van választva attól a tevékenységtől, ami a Win32 folyamat létrehozásával jár. A következő felsorolás összefoglalja a Win32 CreateProcess hívásának főbb lépéseit: 1. A processzen belül végrehajtandó image-fájl (.EXE) megnyitása. 2. A Windows NT executive processz objektumának létrehozása. 3. A kezdeti szál létrehozása. 4. A Win32 értesítése az új processzről, azzal a céllal, hogy az felkészüljön az új processzre és szálra. 5. A kezdeti szál végrehajtásának elindítása. 6. Az újonan létrehozott processz és szál környezetben a címtér inicializálása (például a szükséges DLL-ek betöltése), majd a program végrehajtásának elkezdése. Előadás_11-7 -

8 A fenti lépések mindegyikére vonatkozóan az alábbi megjegyzések érvényesek: Egyetlen CreateProcess híváshoz egynél több prioritási osztály specifikálható. Ha nincs prioritási osztály specifikálva az új folyamathoz, a prioritási osztály a Normal besorolást kapja. Minden ablakot egy desktophoz rendel a rendszer. (Desktopnak nevezi az NT a felhasználó által használható grafikus környezetet. Egy munkahelyen több desktopot is képes kezelni a rendszer.) Ha a Create Processben nincs megadva, melyik desktopot használja a folyamat, akkor a folyamat automatikusan a hívó aktuális desktopjához rendelődik. Szálak kezelése Az operációs rendszer szintjén egy Windows NT szálat egy ún. executive szál blokk (ETHREAD) reprezentál. Az ETHREAD blokk és azok az adatstruktúrák, melyekre az ETHREAD blokkban tárolt pointerek mutatnak, a rendszer címtartományában találhatók, a szál környezeti blokkjának kivételével, ami a folyamat címtartományában van. (lásd előző ábra) Az ETHREAD blokkon kívül, a Win32 alrendszer folyamata is kezel egy szálleíró adatstruktúrát minden egyes szálhoz, ami egy Win32-es folyamatban jött létre. Az ábrán ez executive szálblokk felépítése látható. Az első mező a kernel szálblokk (KTHREAD). Ezt követi a szálazonosítási információ, a processzazonosítási információ, a saját processz hez tartozó pointerrel, biztonsági információ az elérési tokenre mutató pointer formájában, a megszemélyesítési információ, és végül az LPC-üzenetekre, illetve a függőben levő I/O-kérésekre vonatkozó mezők. Előadás_11-8 -

9 A KTHREAD blokk tartalmazza mindazokat az adatokat, amelyekre a kernelnek van szüksége a szálütemezés és a szinkronizáció végrehajtása érdekében. Szál létrehozása (CreateThread) Egy szál életciklusa akkor veszi kezdetét, amikor egy program új szálat hoz létre. Az erre irányuló kérés eljut a Windows NT executive-hoz, ahol a processzkezelő (elnevezése: process dispatcher) helyet jelöl ki egy szálobjektum számára, majd a kernelt hívja, a kernel szálblokk kezdeti értékeinek beállítása végett. Melyek tehát azok a lépések, amelyek a Win32 CreateThread függvénye szerint történnek a KERNEL32.DLL-ben, azzal a céllal, hogy egy Win32 szál jöjjön létre: 1. A folyamat kéréssel fordul az executive-hoz. 2. A processzkezelő elvégzi a helyfoglalást a szálobjektum számára 3. A processzkezelő meghívja a kernelt a KTHREAD kezdeti értékeinek beállítása végett. 4. A CreateThread egy felhasználói módú stacket hoz létre a szál részére, a folyamat címterében. 5. A CreateThread beállítja a kezdeti értékeket a szál hardverkapcsolataihoz. 6. Az NtCreateThread függvény hívására kerül sor, ami az executive szál objektumát hozza létre. Az ide tartozó lépések sorozata kernel módban hajtódik végre, a Windows NT executive-ján és kernelén belül. 7. A CreateThread értesíti a Win32 alrendszert az új szálról, amire az alrendszer különböző beállításokat eszközöl az új szál részére. 8. A szál összetett elérési címe (handle) és azonosítója (amik a 6. lépésben lettek generálva) visszaadódik a hívónak. 9. A szál olyan állapotba került, hogy ütemezni lehet a végre hajtását. 3. Az NT ütemezése: Alapfogalmak ismétlése, összefoglalása: Windows NT estén az ütemezés szál alapú, prioritásvezérelt, és preemptív. Folyamat (process): Egy program futásának számára biztosított, fenntartott rendszererőforrások egysége, mely nagy vonalakban a következőket tartalmazza. A program kódja, és adatai, saját virtuális címterület, operációs rendszer által hozzárendelt rendszererőforrások (szemaforok, kommunikációs portok, fájlok, stb.), egyedi azonosító, legalább egy szál. Szál (thread): Egy folyamathoz tartozó entitás, amin a program futása történik. Egy szálhoz a következő dolgok tartoznak: A processzor állapotát reprezentálandóan a regiszterek tartalma, két veremtár (kernel illetve user Előadás_11-9 -

10 módbeli futáshoz), egyedi azonosító, saját tárolóterület, ahol a szálhoz kapcsolódó információk tárolhatók. (A két vermet, a saját tárterületet és a tárolt regisztereket nevezzük a szál context-jének. Ez az egyetlen olyan publikusan elérhető adatstruktúra a Windows NT-ben, ami számítógépfüggő.) A Windows NT-ben két processzor-hozzáférési mód létezik. Az egyik a user mód, ahol a felhasználói programok futnak. Az itt futó két alkalmazás nem tudja sem egymás, sem az operációs rendszer fontos adatait módosítani, elérni. A másik a kernel mód, ahol az operációs rendszer fut. Egy kernel módban futó kód eléri a teljes memóriát, és minden processzorutasítást használhat. Megszakítási szintek (IRQL): A különböző típusú processzoroknak más a megszakítási rendszere, ezért a kernelben definiáltak egységes, hordozható megszakítási szinteket. Egy bizonyos szintű megszakítás után már nem fogadható el az aktuálisnál alacsonyabb szintű megszakítás, az aktuálisnál magasabb szintű megszakítás viszont félbeszakíthatja az aktuális megszakítás feldolgozásának menetét. Az ütemezés során az első három szinttel találkozhatunk (IRQL 0-2), melyek szoftver megszakítások (nem egy hardver eszköz váltja ki őket). (IRQL 0: a CPU egy normál kernel vagy user módú process-t futtat IRQL 1: a CPU egy asszinkron programhívást (APC) vagy laphibát futtat IRQL 2: a CPU egy halasztott eljáráshívást (DPC) és szálütemezést végez.) Mivel az ütemezés szál alapú, ezért ha egy processzben több szál fut, mint egy másik processzben, és a szálak prioritása azonos, akkor az első processznek több idő fog jutni (ha első megközelítésben úgy tekintjük, hogy minden szál azonos ideig fut). Azt, hogy egy szálnak mennyi idő áll rendelkezésre a futáshoz, egy quantum (időszelet) nevű mennyiség határozza meg. A megadott idő után a szál abbahagyja futását, majd ezután választás történik, hogy melyik szál fog futni következőnek. Az ütemezés prioritásvezérelt, vagyis az, hogy melyik szál fog futni, alapvetően a szálak prioritásától fog függeni. Egy ilyen rendszerben mindig a legnagyobb prioritású, futásra kész szál fut (eltekintve egy különleges esettől, ami többprocesszoros rendszerek esetén léphet fel.) Az ütemezés preemptív, vagyis egy szál futását az ütemező bármikor megszakíthatja, ha például egy magasabb prioritású szál lesz futásra kész. Előadás_

11 A Windows NT ütemezője a kernel kódjában szétszórva található (nincs egy kitüntetett ütemező modul). Az ütemezés jellemzői: Preemtivitás Időszelet alapú ütemezés Többprocesszoros ütemezés Többprocesszoros ütemezés esetén a cél a szálak (azaz a terhelés) egyenletes elosztása, három paraméter segítségével: processzor affinitás (a szál azon paramétere, hogy melyik processzoron fusson) ideális processzor (azaz az előnyben részesített processzor. Ha a szál külön nem kéri, akkor véletlenszerűen választódik ki a tétlen processzorok közül az, amelyiken a szál futni fog. Ha nincs tétlen processzor akkor a prioritás dönt a processzor használatról.) következő processzor (azaz a másodlagosan preferált processzor, jellemzően az, amin a szál legutóbb futott) Az ütemezéssel kapcsolatos rutinok (összefoglaló néven: diszpécser) IRQL2 esetén futnak, és a következő események válthatják ki a működésüket: egy szál futásra késszé válik (új szál, vagy wait állapotból kikerülő szál) egy szál abbahagyja a futást (terminálódik, wait állapotba kerül, lejár az időszelete) egy szálnak változik a prioritása (rendszerhívás változtatja meg, vagy az operációs rendszer módosítja) egy szálnak változik a processzor affinitása A quantum Minden szálnak van egy időszelete (quantum), melynek lejárta után mindenképpen abba kell hagynia a futást. Ezután újbóli döntés születik, hogy melyik szál legyen a következő, amely futni fog. Egy kvantum tehát az az időtartam, amennyit egy szál futhat, mielőtt a Windows NT megszakítja a szálat azért, hogy kiderítse, nem vár-e futásra egy másik szál ugyanakkora prioritással, vagy pedig nincs-e szükség a megszakított szál prioritásának csökkentésére. Az is lehetséges, hogy egy szál el sem jut a kvantumja végéig, a preemptív ütemezés következtében. Azaz ha egy másik szál, nagyobb prioritással, futásra kész állapotba kerül, a futásban levő szál ki lesz szorítva a saját időszelete lejárta előtt. Ezen felül még az is előfordulhat, hogy Előadás_

12 egy szál futásra lesz kiválasztva, és még azelőtt leállítódik, hogy elkezdené a kvantumját. Minden szálhoz nyilvántart a rendszer egy quantum-érték -et, mely nem időegység, hanem inkább egy darabszám. Ez a quantum-érték alapállapotban Windows NT Workstation esetén 6, Windows NT Server esetén 36. Server esetében azért nagyobb ez az érték, mert az a feltételezés, hogy ennyi idő alatt legtöbbször befejezhető egy kliens kiszolgálása, és a szerver program visszatérhet a várakozó állapotába. Minden óra megszakítás esetén a futó szálnak 3-mal csökken a quantum-értéke. Ha eléri a 0-t, akkor lejárt az időszelet. (Az óra megszakítások közti idő rendszerenként változhat, ezzel együtt az időszelet hossza is.) Windows NT Workstation esetén az előtérben futó alkalmazás szálainak quantumértéke nagyobb lehet a többi szálénál. Processzor Óraciklus ms NT Workstation Quantum Időszelet ms NT Server Quantum Időszelet ms Pentium és feljebb DEC AXP 7, , ,75 Prioritási szintek Amikor prioritási szintekről beszélünk, két dolgot különböztethetünk meg. Az egyik az a prioritás, mely a Windows alatt a programozó által elérhető, és a Windows API-n keresztül állítható be. A másik, mely a kernel belső ábrázolásában használatos, ehhez csak a kernel folyamatai férnek hozzá közvetlenül. Az API-ból beállított érték végül is egy ilyen értékké képeződik le. A Windows API-ból a következőképpen állíthatjuk a prioritást. Egy processznek adhatunk egy prioritási osztályt, amivel a processzünk fontosságát fejezhetjük ki. Ezen kívül a processzhez tartozó minden szálnak megadhatunk egy prioritást, mely a processzen belüli, szálak közötti fontosságot jelképezi. Előadás_

13 Az API-ból beállított prioritásból végül is minden szálra képződik egy 0 és 31 közötti érték, mely a processz és a szál megadott prioritásának kombinációjaként jön létre a következő, fentebb említett leképezés alapján: Processz prioritási osztályok Real-time High Normal Idle Time critical Highest Above normal Szál prioritási szintek Normal Below normal Lowest Idle A prioritási szintek három csoportra oszthatók valós idejű szintek változó szintek 0 zero szint (a táblázatban nem szerepel) Az első a real-time processz prioritási csoportban használatos értékek, vagyis 16-tól 31-ig terjedő prioritásértékek. Ha egy szálnak ilyen a prioritása, akkor azt az operációs rendszer nem módosítja. A real-time, azaz a valós idő a gyakorlatban nem feltétlenül garantálható. A másik csoport az 1-től 15-ig lévő tartomány, ahol is az operációs rendszer ezen a tartományon belül módosíthatja a szál aktuális prioritásának értéket egy időre, a megadott érték csak egy alapérték. A módosítás csak ebben a tartományban történhet, vagyis egy szál sohasem kerülhet fel ilyen módosítás során a lévő csoportba. A módosítás lehet emelés (éheztetés vagy I/O folyamat vége után) illetve csökkentés (a szál futásának megszakítása után). A harmadik csoport valójában nem is csoport, csak egy különálló érték, a 0 prioritás. Ez igazából egy szálhoz sem tartozhat, nem is szerepel a fenti táblázatban, hanem processzoronként egy darab látszólagos szálat rendel hozzá a rendszer, melyet a Task Manager-ben System Idle Process néven találhatunk meg. Alapvetően minden szál normál prioritással kezdi a futását. Előadás_

14 A szálak állapotai Egy szálnak a következő állapotai lehetnek az ütemezés során: Initialized Egy újonnan létrejött szál objektum inicializálása, vagy egy már terminálódott szál objektumának újrainicializálása során kerül a szál ebbe az állapotba. Innen a megfelelő ready sorba helyeződik el, és ready állapotba kerül. Ready Azok a szálak, melyek futásra készek, csak arra várnak, hogy sorra kerüljenek. A terminated állapot kivételével bármelyik másik állapotból ide kerülhet a szál, de innen csak a standby állapotba kerülhet. Standby Minden processzorhoz egy ilyen szál tartozhat, amely már ki van választva futásra, de még nem fut, mert pl. maga az ütemező ezen a proceszoron kerül végrehajtásra. Közvetlenül a ready állapotból kerülhet ide egy szál, és vagy a running állapotba, vagy egy magasabb prioritású szál megjelenése esetén a ready állapotba kerülhet innen a szál. Running A szál éppen végrehajtás alatt van. Vagy standby állapotból kerülhet ide a szál, vagy egy várakozás befejeztével. Az állapotból vagy terminálódik, vagy wait állapotba kerül, vagy ready állapotba kerül a szál (preemptálódás vagy időszelet lejárta esetén). Waiting A szál wait állapotba kerül, ha valamilyen szinkronizációs objektumra, vagy I/O műveletre vár. A várakozás véget értével a szál a prioritásától függően visszakerülhet running állapotba, vagy ready állapotba vagy transition állapotba. Transition Ebbe az állapotba csak akkor kerülhet egy szál, ha a szál kernel verme kilapozódott a memóriából a várakozás közben; a verem visszalapozása után a szál ready állapotba kerül. Terminated A szál befejezte a futását. Ezután vagy törölhető a szál objektum, vagy újrainicializálható Előadás_