online kép - Fájl  tube fájl feltöltés file feltöltés - adja hozzá a fájlokat online fedezze fel a legújabb online dokumentumok Kapcsolat
   
 

Letöltheto dokumentumok, programok, törvények, tervezetek, javaslatok, egyéb hasznos információk, receptek - Fájl kiterjesztések - fajltube.com

 

Online dokumentumok - kep
   
kategória
 

Biológia állatok Fizikai Földrajz Kémia Matematika Növénytan Számítógépes
Filozófia
Gazdaság
Gyógyszer
Irodalom
Menedzsment
Receptek
Vegyes

 
 
 
 













































 
 

Processzusok

számítógépes

Fájl küldése e-mail Esszé Projekt


egyéb tételek

 
Az ACCESS adattípusai
A szöveg specialis objektumainak kezelése
A személyi szamítógépek felépítése (részegységek, jellemzöik). Processzorok jellemzöi, fajtai. Memória jellemzöi, típusai.
Programozasi eszközök, vezérlési szerkezetek
INTERNET ÉS KOMMUNIKÁCIÓ
A WORD eszközei II
Processzus ütemezése
A Paint Shop Pro grafikai program hasznalata
Az informatika története
NOVELL NETWARE jellemzői
 
 

Processzusok

Processzus:

Végrehajtás alatt lévő program (ennek egy absztrakciója)

Látszatpárhuzamosság:

A CPU gyors működésének köszönhetően több program is futhat egyszerre a számítógépen, de egy program csak ezredmásodpercekre kapja meg a CPU-t, ami kapcsolgat közöttük.

Valódi hardverpárhuzamosság:

Több processzor használja ugyanazt a memóriát.

A párhuzamosság kezelésére az op. rendszerek tervezői egy modellt fejlesztettek ki.

Processzus modell:

A processzus egy végrehajtás alatt lévő program. Minden processzusnak saját CPU-ja, virtuális CPU-ja van.

Valójában a processzor oda-vissza kapcsolgat a programok között, ezt multiprogramozásnak nevezzük.



Multiprogramozást kezelő számítógépmodell:

Egy processzus egy bizonyos fajta tevékenység, van programja, bemenő és kimenő adatai és állapota. Egy processzort bizonyos ütemezési algoritmussal megoszthatunk több processzus között, és ez az algoritmus eldönti, hogy mikor szakít meg egy processzust és vesz át egy másikat.

A processzus három állapotban lehet:

-         Futó (egy adott pillanatban éppen használja a CPU-t)

-         Futáskész (készen áll a futásra, ,ideiglenesen leállították, hogy egy másik processzus              futhasson.)

-         Blokkolt (bizonyos külső eredmények bekövetkezéséig nem képes futni)

Ezen állapotok közötti átmenet:

1.      A processzus input végett blokkolt.

2.      Az ütemező másik processzusra vált.

3.      Az ütemező erre a processzusra vált.

4.      A bemenet elérhető.

1.      A processzus ráébredt, hogy nem tudja folytatni.

            Op. rendszer lehetséges teendői:

-         Egyes rendszerek a BLOCK rendszerhívást hajtják végre

-         Mások a processzus pájpból olvas és ha nincs elérhető bemenet, akkor automatikusan blokkolódik.

A 2. és 3. átmenetet a processzusütemező váltja ki, anélkül, hogy erről a processzus tudomást szerezne.

Arra, hogy a processzusütemező logon működjön, sok algoritmust találtak ki.

Szem előtt tartandó követelmény:

-         A rendszer hatékonysága.

-         Processzusok pártatlan kezelése.

A 4. átmenet esetén, ha nincs futó processzus, akkor azonnal futni kezd, míg ellenkező esetben a processzus vár az ütemezőre.

Az ütemező nemcsak processzus ütemezéssel foglalkozik, hanem megszakításkezeléssel és a processzusok közötti kommunikációval is.

Processzusok megvalósítása:

A processzustáblázat tartalmazza a processzusokkal kapcsolatos adatokat:

-         Utasításszámlálója

-         Veremmutatója

-         Lefoglalt memória

-         Megnyitott fájljainak állapota

-         Ütemezési információ

-         Minden olyan információt a processzorról, amelyek ahhoz kellenek, hogy a processzus úgy indulhasson újra, mintha soha nem állítottuk volna le.

Egy CPU és több B/K számítógép működése

Minden B/K osztály (hajlékonylemez-egységek, merevlemez egységek) kapcsolatban van egy megszakításvektorral. Ez a megszakítást kiszolgáló eljárás címét tartalmazza.

Ha egy B/K eszköz megszakítást kér, akkor a megszakításhardver az utasításszámlálót és egy vagy több regisztert a verembe helyez, ezután a megszakítás kezelése szoftver feladata.

Megszakítás kiszolgáló eljárás:

Processzustáblába helyezi az összes regiszter tartalmát, majd a veremmutatót átállítja egy másik veremre és kiveszi a megszakítás által lerakott információkat. Ha nincs ennél nagyobb prioritású processzus, akkor ez fog futni.

Megszakítás kezelésének lépései:

-         A hardver verembe teszi az utasításszámlálót, regisztereket.

-         A hardver a megszakításvektorból betölti az új utasításszámlálót.

-         Az assembly nyelvű eljárás elmenti a regisztereket.

-         Az assembly nyelvű eljárás beállítja az új vermet.

-         A „C” megszakításkezelő fut.

-         Az ütemező bejelöli a várakozó folyamatra, hogy futáskész.

-         Az ütemező eldönti, hogy melyik legyen a következő futtatandó processzus.

-         A „C” eljárás visszatér az assembly kódba.



-         Az assembly nyelvű eljárás elindítja az új aktuális processzust.

Szálak

Az op. rendszerek támogatják a processzuson belüli szálakat. Ezeket vezérlési szálaknak, vagy könnyűsúlyú processzusoknak nevezzük.

A szálak kezelése hasonlóan történik, mint a processzusok kezelése.

Néhány op. rendszer azonban tudomást sem vesz a szálakról.

-         A szálak közötti kapcsolgatás felhasználó szinten sokkal gyorsabb, mint rendszerhívással.

      (a szálak kezelését felhasználói szinten kell végezni)

-         Ha egy szál blokkolódik felhasználói szintű szálkezelésnél, akkor az egész processzus blokkolódik.

      (érvényes a szál op. rendszer szintű kezelésére)

Ha a szál fogalmát nem ismeri az op. rendszer és egy új verziónál bevezetésre kerül, akkor alapjaiban kell átírni az op. rendszert.

Processzusok kommunikációja

Olyankor, ha pl. az egyik processzus adatait át kell adni egy másiknak.

A processzus kommunikáció (InterProcess Communication) IPC

Versenyhelyzet:

Ha kettő vagy több processzus olvas vagy ír megosztott adatokat, és a végeredmény attól függ, hogy ki és mikor fut.

Pl.: Nyomtatási versenyhelyzet

Az A pakolni akar a háttértárba, de mikor kiolvassa az IN értéket, mielőtt pakolna bele, az időzítő B-nek adja a vezérlést, aki bepakol, és legközelebb A is a 7-esbe pakol, majd növeli az IN értékét.

Kritikus terület szekció:

A programnak az a része, amelyben a megosztott memóriát használja.

Versenyhelyzet kikerülésének feltételei:

-         Ne legyen két processzus egyszerre a saját kritikus szekciójában.

-         Semmilyen feltétel ne legyen a sebességekről, vagy a CPU-k számáról.

-         Ne legyen olyan processzus, amely a kritikus szekcióján kívül futva blokkolhat más processzusokat.

-         Egy processzusnak se kelljen örökké arra várni, hogy belépjen a kritikus szekciójába

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

Ha egy processzus használ megosztott változót vagy fájlt, a többi processzus tartózkodjon ettől.

  1. Megszakítások tiltása:

      Ha egy processzus belép a saját kritikus szekciójába az összes megszakítást letiltja,       és újraengedélyezné, mihelyt kilépne belőle. (óramegszakítás sem fordul elő).

      Hátránya: Felhasználói processzusnak olyan hatalmat ad, amivel ki tudja kapcsolni a      megszakításokat.

      Az op. rendszeren belüli megszakítástiltás hasznos lehet.

  1. Zárolásváltozók:

      Megosztott zárolásváltozón keresztül ha értéke 0, akkor 1-re állítja, majd belép a          kritikus szekcióba.

      Hátránya: Ha egy processzus kiolvassa az értéket ami 0, majd más processzushoz         kerül a vezérlés, amely kiolvassa a 0-át miután belép! Visszakerül a vezérlés az       előzőhöz aki állítja az értéket és belép! 1-nek ellenkezőre.

  1. Szigorú váltogatás:

      A TURN változóban tárolják a következő szekcióba léphető processzust.

      A processzusok várnak, amíg be nem léphetnek a saját kritikus szekciójukba.

      Op. rendszer:                                                                1. proc:

                  While(TRUE)                                                                                  }

      Probléma akkor van, ha az egyik processzus lényegesen hosszabb a másiknál, amely     ilyenkor sokat várakozik.

      Ez ellentmond a 3. feltételnek, miszerint az egyik processzus blokkol  egy olyan processzust, amely nem a kritikus szekciójában van.

  1. Peterson megoldása:

      1981-ben Peterson talált megoldást a kölcsönös kizárás megvalósítására.

      Mielőtt megosztott változókat használna a processzus, meghív egy Enter_region             függvényt, átadva a saját processzusának a számát.

      Ha kell várakozik a biztos belépésig.

      Kilépéskor meghívja a Leave_region függvényt.

      Int turn;                                                //ki következik

      Int interested[i];                                    //minden érték 0 (FALSE)


      Void enter_region (int process) //0 vagy 1 a processzus sorszáma

     

      Void leave_region (int process)

     

      A 0. processzus meghívja az enter_region-t

                  Process=0

                  Other=1

                  Interested[0]=TRUE

                  Turn=0

      Ha az 1. nem érdekelt azonnal visszatér.

      Egyébként várakozik, amíg interested[1]=FALSE nem lesz.

      Ha az 1. most meghívja az enter_region-t, akkor vár míg az interested[0] FALSE-ra      nem vált. Ez akkor következik be, ha a 0. processzus meghívja a leave_region-t.

      Turn globális változó!

      Ha mindkét processzus egyszerre hívja meg az enter_region-t, akkor csak az utolsó       írás számít, mert az globális.

      Ha az 1. ír be utoljára, akkor turn=1 lesz.

      A while ciklushoz érve mindkettő vizsgál.

      A 0. nem hajt végre ciklusmagot így belép a kritikus szekcióba.

      Az 1. ismételget, nem lép be a szekciójába.

  1. TSL utasítás: (TEST AND SET LOCK)

      Hardversegítséget igényel. Sok processzor ismeri a TSL utasítást.

      Beolvassa a memóriaszó tartalmát egy regiszterbe, és ezután egy (a szó beolvasása és    tárolása nem választható szét) nemnulla értéket ír erre a memóriacímre.

      A memória elérése az utasítás végrehajtása során minden CPU számára tilos.

      A LOCK változót, ha az 0, minden processzus beállíthatja 1-re a TSL utasítással.

      Enter_region;

                  Tsl register,lock                        //átmásolja a lock-ot a regiszterbe és 1-re állítja

                  Cmp regiszter,#0                      //a lock 0 volt?

                  Jne enter_region #0                  //ha nem volt 0, akkor be van állítva így ciklus

                  Ret                                           //vissza és belépünk a kritikus szekcióba

      Leave_region;

                  Move lock,#0                           //lock legyen 0

                  Ret                                           //visszatérés

Fordított prioritás probléma:

Mind a Peterson, mind a TSL megoldás tevékeny várakozást igényel a processzusok részéről.

Legyen H magas, L alacsony prioritású folyamat. Tegyük fel, hogy az ütemezés olyan, hogy ha H futáskész állapotban van, akkor futni is fog.

Ha L a kritikus tartományába kerül, és mielőtt kilépne onnan a H futáskész állapotba kerül, és aktív várakozásba kezd.

Mivel L-re soha nem fog sor kerülni, a H sem fog belépni a kritikus szekciójába. (Végtelen ciklus).

A blokkolás miatt az előző megoldások pazarolják a processzusidőt.

Új megoldások elve, hogy a processzusok SLEEP és WAKEUP rendszerhívásokkal altatják és ébresztik a rájuk váró processzusokat.

1.      Gyártó-fogyasztó probléma:

Két processzus osztozik egy közös tárterületen.

Egyikük a gyártó, adatokat helyez el benne, a másik a fogyasztó, adatokat vesz ki onnan.

(A probléma általánosítható n gyártóra, és m fogyasztóra is.)

Nehézség a gyártó adatot pakolna, de már tele van a tárolóterület.

A megoldás, hogy a gyártó elmegy aludni, és felébresztik, ha kell.

Másik nehézség, amikor a fogyasztó venne a tárból, de nincs adat.

Ez egyszerűnek látszik, de ugyanolyan versenyhelyzeteket szül, mint a háttérkatalógusos nyomtatási probléma.

#define N 100                                            //A tároló rekeszeinek a száma

int count=0;                                                //az elemek száma a tárolóban

Void producer (void)                                  //gyártó

}

Void consumer (void)

}

      While (TRUE){

                  If (count = = 0) sleep();            //üres tárolónál aludni megyünk

                  Remove_item();                        //elem kivétele a tárolóból

                  Count = count-1;                      //elemek számának csökkentése

                  If (count = = N-1) wakeup (producer); //termelő ébresztése

                  Consume_item();                      //felhasználjuk az elemet

Versenyhelyzetek itt (count globális, közös tárban van)

A tároló üres és a fogyasztó count-ot olvassa, ami 0, az ütemező elindítja a gyártót, aki berak egy elemet és növeli a count-ot. Mivel a count=1, ezért a gyártó hívja a wakeup-ébresztőt. Ha a fogyasztó ismét fut a count értékét 0-nak találja és elmegy aludni.

A gyártó telerakja a tárat és elmegy aludni.

Mindketten örökre aludni fognak.

A probléma az ébresztőjel elvesztése miatt történik.

Egy ébresztőt váró bit bevezetésével megoldható.

Ha olyan processzusnak küldünk ébresztőt, amelyik még ébren van, akkor ez a bit beállítódik. Később amikor aludni menne, és az ébresztőt váró bit be van kapcsolva kikapcsolja, és nem megy el aludni. Ez azonban nem szolgáltat teljes megoldást.


: 1335