Processzuskezelés

1. Processzuskezelés • Processzusok, alapfogalmak • Processzusok kommunikációja • Klasszikus IPC problémák • Processzusok ütemezése

2. Alapfogalmak (1) • A processzus vagy folyamat (process, job, task) egy végrahajtás alatt levő program. • A címtartomány memoriaregiszterek azon sorozata, amelybe egy adott processzus írhat vagy amelyből olvashat. • A processzustáblázat olyan, az adott processzushoz kapcsolt vektor vagy láncolat, amely a címtartomány által nem tartalamazott, de a processzussal kapcsolatos egyébb információkat foglalja magában. • Egy időosztásos rendszer processzusát tehát annak • címtartománya (memóriatérképe) és • processzustáblázatbeli tartalma alkotja.

3. Alapfogalmak (2) • A parancsértelemző (shell) a számítógép operációs rendszerének kulcsfontosságú processzusa. • Egy processzus (a szülőprocesszus) létrehozhat egy vagy több új processzust (gyermekprocesszusokat). • Ez a hierarchikus processzusrendszer fastruktúraként ábrázolható. • Az elengedhetetlen processzusok közötti kommunikációt például egy pszeudofájl vagy a csőrendszer (pipe) biztosítja. • Egy többfelhasználós rendszerben a felhasználó által indított processzus azonosítójához mindenképpen kapcsolódik az őt indító felhasználó azonosítója (user id).

4. Alapfogalmak (3)Rendszerhívások és szignálok • A processzusok és az operációs rendszer közötti kapcsolatot a szignálok és a rendszerhívások biztosítják. • A szignál a hardver-megszakítások szoftvermegfelelője. • Az operációs rendszer és a felhasználói programok közös érintkezési területe (inbterface) egy kiterjesztett parancsokból álló halmaz, a rendszerhívások (system calls) halmaza. • A többfeladatos operációs rendszer által kezelt rendszerhívásoknak mindenképpen szüksége van az időszerű processzek azonosítójára (process id vagy pid).

5. Alapfogalmak (4)Rendszerhivások és szignálok • A rendszerhívások általában a következő osztályokba sorolhatók • processzuskezelő rendszerhívások • szignálkezelő rendszerhívások • fájlkezelő rendszerhívások • katalóguskezelő rendszerhívások • a védelem rendszerhívásai • az időkezelés rendszerhívásai. • A rendszerhívások végrehajtása erősen gépfüggő, és áltlában assembly nyelben fogalmazódik meg. • A renszerhívásokat tartalmazó eljáráskönyvtár általában lehetővé teszi, hogy C nyelvű programokból rendszerhívásokat hívjunk meg.

6. Alapfogalmak (4)Processzuskezelő rendszerhívások a UNIX alapú rendszerekben

7. AlapfogalamakPárhuzamosságok a modern számitógépes rendszerekben • A harmadik generációs számítógépek jelentős technikai újítási voltak* • a multiprogramozás (a memóriát szeletekre particionáljuk, és minden particióhoz egy-egy feladatot rendelünk) • a háttértárolás (spooling - simultaneous peripheral operation on line) • az időosztás (timesharing), a multiprogramozás olyan változata, amikor minden felhasználónak saját on-line terminálja van. • A számítógépek negyedik generációjával bevezetett újítások* • munkaállomások kialakítása és hálózatba kötése • felhasználóbarát szoftverek • hálózati operációs rendszerek és osztott operációs rendszerek kilalkulása. *természetesen az operácós rendszerek tekintetében.

8. AlapfogalamakPárhuzamosságok a modern számítógépes rendszerekben • Egy multiprogramozású rendszerben a központi egység egyik programról a másikra ugrik, ezeket a másodperc törtrészére indítja, majd megszakítja azokat. Annak ellenére, hogy minden időpillanatban a központi egység csak egy processzussal foglalkozik, egy másodpercen belül több folyamattal is előrehaladhat, és a felhasználó úgy érezi, ezek a folyamatok párhuzamosan hajtódnak végre. Ám ez, mint láttuk, csak egy látszólagos párhuzamosság. • A valódi párhuzamosság azt jelenti, hogy egy többprocesszoros rendszerben több központi egység osztja ugyanazt a memóriaterületet. • Az operációs rendszerek fejlesztői kidolgozták a szekvenciális processzusok modelljét, amely megkönnyíti a párhuzamosságok kezelését.

9. BevezetésProcesszus modell - egyprocesszoros rendszer • Minden futtatható szoftver a számítógépen, általában maga az operációs rendszer is, szekvenciális processzusok sorozata. • A processzus, mint egy program futó példánya, a következő összetevőkből áll: • utasításszámláló • regisztrek • változóinak értékei. • Minden processzusnak saját virtuális központi egysége (CPU) van. A valóságban a CPU processzusról processzusra kapcsol - tehát multiprogramozásról van szó.

10. Bevezetésprocesszus modell (2) Négy független, szekvenciális processzus elméleti modellje, processzusonkénti utasitásszámlálóval

11. Bevezetésprocesszus modell (3) Négy program multiprogramozása, egy utasításszámlálóval

12. BevezetésProcesszus modell (4) • A processzusok nem állandó sebességgel haladnak előre a végrehajtásban, ezért egy esetleges újraindításkor nem ismételhető meg az időosztás. • A processzusokba nem szabad belső időzítéseket beépiteni, de • szükség van egy időosztásos (scheduling) algoritmusra, amely a megfelelő időpillanatban felfüggeszti a futó processzust és egy másikat indít, vagy intít újra. • A processzus tehát egy tevékenység, amelynek van • programja • bemenő és kimenő adatai • állapota.

13. BevezetésProcesszus modell Példa A számítógépes szakember anyuka (CPU) süteményt készít (főprocesszus) a születésnapi ünnepségre. Rendelkezésére áll a recept (program), a hozzávalók (bemenetek), és hozzákezd a sütéshez (a főprocesszus futó állapotba kerül). Ebben a pillanatban a fia belép, és közli, hogy elesett. Az anyuka abbahagyja a sütést, és a fia segítségére siet (magasabb prioritású processzus adódott) folytatása következik...

14. BevezetésProcesszus modell az anyuka abbahagyja a sütést (a főprocesszust felfüggeszti) feljegyzi, hol áll a recept lépéseiben (a pillanatnyilag futó processzus állapotát elmenti) ellátja a fia sebeit az elsősegélynyújtás szabályai alapján (a magasabb prioritású processzt hajtja végre annak programja alapján). Amikor a sebet ellátta (befejeződütt a magasabb proiritású processz) az anyuka (CPU) visszatér a sütéshez (főprocesszus), és folytatja azt ott ahol abbamarad (az elmenetett állapot alapján folytatódik a főprocesszus). A kész sütemény lesz a processzus kimenete.

15. Processzushieararchiák • A fölöttébb egyszerű rendszerekben, illetve az egy alkalmazás futtatásásra alkalmas rendszerekben nincs szükség processzushierarchiák létrehozására. • Öszzetettebb rendszerek esetében a processzusok létrehozásának és megszüntetésének módszereit ki kell dolgozni, • ezért az operációs rendszerek általában tartalmazzák a következő rendszerhívásokat • processzuslétrehozás • memóriába történő betöltés • indítás. • Meg kell határozni az új processzusok létrehozásának módját is, algoritmusok segitségével. • A UNIX alapú rendszerekben általában a fork nevű rendszerhívás szolgál a processzek létrehozására.

16. Processzushieararchiák

17. Processzusállapotok • Egy processzus egy adott pillanatban a következő három állapot egyikében lehet • futó - az adott pillanatban éppen használja a CPU-t (running) • futáskész - készen áll a futásra, mert időlegesen leállították, hogy egy másik processzus futhasson (ready) • blokkolt - bizonyos külső esemény bekövetkezéséig nem képes futni (blocked). • A futó és futáskész állapot csak abban különbözik, hogy a másodikban pillanatnyilag nem áll a processzus rendelkezésére szabad CPU kapacitás. • A blokkolt állapot csak akkor szűnik meg, ha a külső, a blokkolást előidéző körülmény ezt újra megengedi. • A processzusállapotok között négy különböző átmenet lehtséges:

18. Processzusállapotok közötti átmenetek 1. A processzus input miatt blokkoolt 2. Az ütemező másik processzust választott 3. Az ütemező ezt a processzust választotta 4. A bemenet elérhető lett

19. Processzusállapotok - ütemezés • Hogyan kezelhetők a processzus állapotváltásai, a megszakítások, a processz indítás és megszüntetés? • A UNIX alapú renszerek alsó szintje, az ütemező, (scheduler) kezeli a megszakitásokat és az ütemezést. Az operációs rendszeren belül a további processzusszervezés szekvenciális jellegű. • Az ütemező egyúttal a megszakításokat és a processzusok közötti kommunikációt is felügyeli.

20. Processzusállapotok - példák 1. Példa a UNIX rendszerekből cat file1 file2 | grep fontos A cat parancs összekapcsolja a file1 és a file2 fájlok tartalmát. A grep parancs a kapott fájlból kiválaszt minden olyan sort, amely tartalmazza a fontos szót. A processzusok végrehajtásának relatív sebességétől függően előfordulhat, hogy a grep parancsot végrehajtó processzus már futásra készen áll, de az összekapcsoló processzus még nem biztosította számára a bemenetet. Igy a grep blokkolt állapotba kerül. 2. Bármely processzussal előfordulhat, hogy futása közben az operációs rendszer más processzusnak osztja ki a CPU-t, es ezáltal futáskész állapotba kerül.

21. Processzusok megvalósitása • A processzusmodell lényege, hogy az opeációs rendszer processzusonként egy processzustáblázatot hoz létre és a processzus élettartama alatt azt kezeli. • A processzustáblázat tartalma általában utal a processzus • állapotára • utasitásszámlálójára • veremmutatójára • memóriatérképére • megnyitott fájljainak állapotára • elszámolási és ütemezési információira • egyéb olyan információkra, amelyeket a processzus esetleges felfüggesztésekor tárolunk azzal a céllal, hogy a processzust újraindíthassuk.

22. Processzusok megvalósitásaProcesszuskezelő mezők a processzustáblázatban A legtöbb operációs rendszer a processzusokat, memóriát és fájlokat elkülönítve kezeli, ezért a processzustáblázat mezői is e három csoportba tagolódnak. A processzustáblázat memóriakezelő mezői általában a következő információkat tartalmazzák * regiszterek *utasitásszámláló * programállapot szó *veremmutató * processzusállapot *processzus inditási ideje *felhasznált CPU idő *gyermek CPU ideje * következő ébresztés ideje *mutató az üzenetsorra * függö jelző bitek *processzusazonosító * különböző jelző bitek

23. Processzusok megvalósitásaMegszakítások Hogyan működik egy, egy központi egységgel és több ki- és bemeneti egységgel rendelkező rendszer ütemezője? Minden egyes B/K eszközosztály kapcsolatban áll a memória alsó részében elhelyezkedő megszakításvektorral. Ez a vektor tartalmazza a megszakítást kiszolgáló eljárás címét. A következő sorrend mutatja hogyan cselekszik az operációs rendszer alsó szinje (az ütemező általábnan), amikor megszakítás következik be. Megjegyzés: Az 1. és 2. lépést általában hardvermegszakítások kezelik. A 3., 4. és 9. lépést assembly utasitások kezelik. Az 5-8. lépéseket általában C eljárások hajtják végre.

24. Processzusok megvalósitásaMegszakítások vázlatos leirása 1. A hardver verembe teszi az utasításszámlálót és más információkat 2. A hardver a megszakításvektorból betölti az új utasításszámlálót 3. Az assembly eljárás elmenti a regiszterek tartalmát 4. Az assembly eljárás beállítja az új vermet 5. A C megszakitáskezelő bemenő adatokat olvas és tárol 6. Az ütemező a várakozó processzust futáskész állapotba helyezi 7. Az ütemező a futáskész várakozók közül kijelöl egyet futásra 8. A C eljárás visszatér assembly kódba és elindítja az új aktuális processzust

25. Pocesszusok megvalósitásaSzálak • A hagyomámányos processzusszervezésben egy vezérlési szál és egy uatsításszámláló volt. • A modern operációs rendszerek támogatják a processzuson belüli töbszörös vezérlési szálak kiszolgálását. Ezekt a szálakat nevezzük könnyűsúlyú processzusoknak vagy egyszerűen szálaknak.

26. Pocesszusok megvalósitásaSzálak -példák • Fájlszerver processzus. A szerver az aktuális fájlba történő íráskor/olvasáskor hatékonyságnövelés céljából gyorsírótárat (cache) használ. Ha az OR blokkolja is processzust, több szálon fogadhat továbbra is kéréseket a fájllal kapcsolatban. Egyszálas rendszernél ez nem lehetséges, mert különböző processzek különálló szálai nem osztozhatnak ugyanazon a gyorsírótár-tartományon. • A WEB oldalak több kis összetett képből állnak. Ezek letöltése különálló kapcsolatteremtést jelent, és különálló szálakon futó kapcsolatként lényegesen növelhető a letöltés teljesítménye.

27. Pocesszusok megvalósitásaSzálak magvalósitása • Ha ugyanazon címtartományt több szál használja, akkor néhány processzkezelő mező szálanként értendő, és a különálló száltáblázat tartalmaz önálló • utasításszámlálót (mert a szálak felfüggeszthetők és újraindíthatók), • regisztereket (amelyeket szál-felfüggesztéskor ugyancsak elmentünk), • állapotjelzőt (mert a szálak is lehetnek fuót, futáskész és blokkolt állapotban).

28. Pocesszusok megvalósitásaSzálak kezelése • Ha az OR nem vesz tudomást a szálak létezéséről, akkor azok felhasználói hatáskörben vannak (azaz például egy blokkolásra készülő szál maga jelöli ki az utódját). Ilyen feléhasználói szintű szálkezelő csomag például a POSIX P-szálak csomagja. • Ha az OR kezeli a szálakat, akkor a kezelés a kernel feladata, amely a szálak ütemezését a processzustáblázathoz hasonló, minden futó szálra vonatkozó száltáblázat segítségével végzi. • A szálak közötti átkapcsolás a felhasználói szintű szálkezelésnél gyorsabb, viszont egy szál blokkolása ennél a módszernél a teljes processzus blokkolásához vezet. Ezért mindkét módszert (a felhasználói- és a kernel-kezelést is) alkalmazzák, illetve azok hibrid változataival kisérleteznek.

29. Pocesszusok megvalósitásaSzálak kezelése - nyitott kérdések A szálak alkalmazásakor felmerülő nyitott kérdések közül néhány: • Milyen hatása van a többszálas szülőprocesszusban kiadott, gyermekprocesszust létrehozó rendszerhivásnak? A gyermekpocesszus megörökli a szálakat is? • Ha a szülő- ás a gyermekprocesszus is többszálas, és egy B/K rendszerhívás blokkolja a szálat, csak a szülő-szál blokkolodik? Csak a gyermekszál, vagy mindkettő? • Ha több szál osztozik ugyanazon adatsruktúrán, természetesen ugyanazon a processzuson belül, akkor előfordulhat hogy egyik szál lezár egy fájlt, egy másik szál pedig még olvas belőle? • Ha egyazon processzus két különböző szála majdnem egyidőben igényel újabb memóriaterületet, mindkettő külön-külön kap új területeket? (Nem többszálas rendszereknél gyakran összeomlik az operációs rendszer, ha még kielégítetlen igénylés alatt újabb érkezik. )

30. Pocesszusok megvalósitásaSzálak kezelése • Az olyan hibajelzéseket, amelyeket a processzus egyik szála globális változóba ír (pl. UNIX-ban), felülírhatja ugyanazon processzus másik szála. • A szignálok között vannak szálspecifikusak. Ha például a többszálas rendszer kernelje a processzus valamely száljától ALARM hivást kap, tudnia kell az eredményszignált a megfelelő szálon átadni. A felhasználói szintű szálkezelésnél viszont az a probléma áll elő, hogy a rendszer processzusonként csak egy riasztást képes kezelni, ugyanakkor a processzus több száljának akár egyidőben is szüsége lehet a riasztásra. • Többszálas processzus szálankénti vermelést igényel. Verem-túlcsordulásnál a kernelnek érzkelnie kellene melyik szál verméről van szó, és csak azt autómatikusan növelnie. Ez nehezen oldható meg.

31. Processzusok kommunikációja • A többfeladatos rendszerek alapkövetelménye, hogy egy megszakítások nélküli, jól struktúrált módszert biztosítson a processzusok közötti kommunikációhoz, azaz az IPC (Interprocess Communication) feladatkörhöz. • Az operációs rendszereket építő szakembereknek a következő feladatokat kell megoldaniuk • hogyan továbbíthat egyik processzus információt egy másiknak • biztosítani kell hogy két vagy több processzus ne keresztezze egymás útját ha kritikus tevékenységbe kezdenek • ha a processzusok munkája között függőség áll fenn, akkor a sorrendiséget meg kell oldani.

32. Processzusok kommunikációjaVersenyhelyzetek • Ha kettő vagy több processzus olvas vagy ír megosztott adatokat és a végeredmény attól függ, hogy ki és pontosan mikor fut, versenyhelyzet áll elő. • A megosztott adatterület lehet a memóriaterület vagy közösen használt fájl. • A versenyhelyzeteket tartalmazó programok nyomonkövetése (debugging) bonyolult feladat, és előfordulhatnak időnként furcsa és megmagyarázhatlan dolgok programfuttatás közben. • Tanácsos elkerülni a versenyhelyzeteket. Kerüljük el a megosztott memória, megosztott fájlok, és egyéb megosztott erőforrások egyidejű elérését több processzus irányából.

33. Processzusok kommunikációjaVersenyhelyzetek. Kritikus szekciók • A versenyhelyzetek megelőzésére szükségünk van a kölcsönös kizárásra, azaz arra, hogy más processzusokat távol tratsunk a közös erőforrásoktól, amig azokat egy futó processzus használja. • Az operációs rendszerek tervezésének fontos szempontja, hogy jól megszerkesztett primitiv műveleteket alkalmazzanak a kölcsönös kizárás eléréséhez. • A programnak azt a részét, amelyben megosztott memóriát használ, kritikus területnek, illetve kritikus szekciónak nevezzük. Ha megszervezhető, hogy két vagy több processzus ne legyen egyidejűleg kritikus szekcióban, akkor ezzel elkerülhető lesz a versenyhelyzet is.

34. Processzusok kommunikációjaKritikus szekciók Párhuzamosan futó processzusok akkor oszthatják korrekten és hatékonyan a közös adatterületeket, ha: 1. két processzus nem lehet egyidejűleg a saját kritikus szekciójában, 2. nem szabunk előfeltételeket a sebeségekkel és a CPU-k számával kapcsolatban, 3. egy, a saját kritikus szekcióján kivül futó processzus sem blokkolhat más processusokat, 4. egy processusnak sem kell örökké várnia, hogy belépjen a saját kritikus szekciójába.. Lássunk néhány megközelítést, a problámafelvetéstől, a megoldás modján keresztül a felmerülő nyitott kérdésekig.

35. Processzusok kommunikációjaKölcsönös kizárás A kölcsönös kizárás fogalma azt jelenti, hogy mialatt egy processzus a saját kritikus szekciójában a megosztott erőforrást aktualizálja, ne legyen más olyan processzus, amely saját kritikus szekciójába lép, agyanazt az erőforrást használná, és bajt okozhatna.

36. Processzusok kommunikációjaKölcsönös kizárás Magszakítások tiltása A megoldás Minden processzus letiltja az összes megszakítást (az óramegszakitásokat is), mihelyt belép saját kritikus szekciójába, és újraengedélyezi, mielőtt elhagyja azt. (A CPU csak órajelre vagy megszakításra kapcsol processzusról processzusra.)

37. Processzusok kommunikációjaKölcsönös kizárás Magszakítások tiltása Nyitott kérdések -Problémák • Felhasználói processzusoknak nem helyes olyan felhatalmazást adni, hogy kikapcsolhassák a megszakításokat. • Többprocesszoros rendszereknél ez a tiltás csak egyik (a tiltást végrehajtó) CPU-ra vonatkozik. • Gyakran a kernelnek is szüksége van letiltásokra (pl. a futáskész processzusok listájának változtatásakor). Ezt az állapotot egy másik processzustól érkező letiltás megzavarhatja, és versenyhelyzet alakulhat ki.

38. Processzusok kommunikációjaKölcsönös kizárás Magszakítások tiltása Tanulság A megszakítások tiltása hasznos lehet az operációs rendszereken belül, de mint kölcsönös kizárási mechanizmus nem ajánlható a felhasználói processzusok esetében.

39. Processzusok kommunikációjaKölcsönös kizárás Zárolásváltozók Megoldás • A zárolásváltozók alkalmazása egy szoftvermegoldás. Mielőtt egy processzus belép a saját kritikus szekciójába, először ellenőriz egy zárolásváltozót (lock variable), amely eredetileg 0 értéket vesz fel (például). Ha a zárolásváltozó értéke 0, akkor 1-re állitja azt, és belép a kritikus szekcióba. Ha zárolásváltozó értéke 1, akkor a processzus várakozik (futáskész állapotba kerül), amig a 0 értéket nem regisztrál. • Tehát a fenti példában, • a zárolásváltozó értéke 0, ha egy processzus sincs a saját kritikus szekciójában, és • 1, ha valamely processzus kritikus szekcióban van.

40. Processzusok kommunikációjaKölcsönös kizárás Zárolásváltozók Nyitott kérdések • Mi történik, ha az egyik processzus 0 zárolásváltozót olvas, kritikus szekcióba lép, de még mielőtt a zárolásváltozót 1-re állitja, megteszi ezt egy másik processzus is? (A már korábban emlitett háttérkatalógus példa). Tanulság • A fenti probléma akkor sem kerülhető el, ha először a processzus kiolvassa a zárolásváltozó értékét, és azt ellenőrzi az 1-re történő áírás előtt. Még ekkor is előfordulhat versenyhelyzet.

41. Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozással Szigorú váltogatás • Bevezetünk egy 0 kezdőértékű turn egész változót, amely nyomon követi, mely processzus lép legközelebb a kritikus szekciójába, és vizsgálja vagy aktualizálja a megosztott memóriát.Azt a módszert, amikor folyamatosan tesztelünk egy változót egy bizonyos értékének bekövetkeztéig, tevékeny várakozásnak nevezzük.

42. Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozással Szigorú váltogatás Megoldás Egy javasolt, C nyelben iródott megoldás a turn változó használatára: while (TRUE) { while (turn!=0) /*várakozás*/; critical_region(); turn=1; noncritical_region(); } while (TRUE) { while (turn!=1) /* várakozás */; critical_region(); turn=0; noncritical_region(); }

43. Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozással Szigorú váltogatás Nyitott kérdések • A tevékeny várakozás általában pazarolja a CPU időt, ezért csak akkor ajánlott, ha a várakozás várhatóan rövid lesz. • Ha az egyik processzus lassúbb mint a másik, a szigorú váltogatás nem hatékony (egy processzus 1 értéken hagyhatja a turn értéket, pedig már befejezte a kritikus szekcióban a munkát, de még nem váltott) • Ez a helyzet sérti a kritikus helyzetek elkerülésére szabott 3. feltételt (a lassúbb processzus blokkolt egy olyat, amely nincs kritikus szekcióban). • A háttértaroló példa: a gyorsabb processzus nem tud nyomtatni, mert a lassúbb mással van elfoglalva.

44. Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozással Szigorú váltogatás Tanulság • Ez a megoldás megköveteli, hogy két processus szigorúan váltakozva lépjen a saját kritikus szekciójába (például így adhatnak át egymásnak processzusok fájlokat a háttevékenységekhez, de ezt kétszer egyik processzus sem ismételheti közvezlen egymásutánban.) • A módszer elkerüli a versenyhelyzeteket, egyszerű, de az említett 3. követelmény miatt nem komoly jelölt az alkalmzásokban.

45. Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozással Peterson megoldása A megoldás • A váltogatás ötletét ötvözve a zárolás- és figyelmeztető-változók alkalmazásával T. Dekker szoftvermegoldást adott a kölcsönös kizárás problémájára, és eközben nem alkalmazott szigoró váltogatást (1965.). • G.L. Peterson 1981-ben egy egyszerűbb algoritmussal oldotta meg azt a problémát. A következő algoritmus ANSI C-ben irodott. A definiált és használt függvényeket függvényprototipusokkal helyettesítjük.

46. #define FALSE 0 #define TRUE 1 #define N 2 int turn; int interested[N]; void enter_region(int process); { int other; other=1-process; interested[process]=TRUE; turn=process; while (turn = = process && interested[other]= = TRUE) } void leave_region(int process); { interested[process]=FALSE; } /*a processzusok szuáma*/ /*ki következik?*/ /*kezdetben minden érték 0 (FALSE)*/ /*a process vagy 0 vagy 1*/ /*a másik processzus sorszáma*/ /*a process ellenkezője*/ /*mutatja, hopgy érdekeltek vagyunk*/ /*’áll’ a zászló*/ /*üres utasitás*/ /*process: ki hagyja el*/ /*mutatja a kritikus szekció elhagyását*/ Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozással Peterson megoldása

47. Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozással Peterson megoldása Nyitott kérdések • Ha két processzus majdnem egyszerre hívja meg az enter_region-t, és mindkettő beírja a processzusszámát a turn-be, az leső elvész, a második megmarad. • Ha az 1. processzus ír be utoljára, akkor a turn érétke 1. Amikor mindkét processzus elér a while utasitáshoz, a 0. processzus a várakozó ciklust nullászor hajtja végre és a kritikus szekciójába lép, az 1. processzus ismételget de nem lép a kritikus szekciójába.

48. Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozássalA TSL utasítás A megoldás • Az algoritmus hardversegítséggel működik. • A legtöbb többprocesszoros rendszer rendelkezik egy TEST AND LOCK (TSL) utasítással. • A TSL beolvassa a memóriaszó tartalmát egy regiszterbe, és egy nemnulla értéket ír erre a memóriacímre. • A szó kiolvasása és a tárolási művelet nem választható szét, az akció befejezéséig ezt a memóriaszót más processzor nem érheti el. • A CPU a TSL paranccsal zárolja a memóriabuszt és a művelet befejezéséig megtíltja, hogy más CPU hozzzáférjen a memóriaterülethez.

49. Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozássalA TSL utasítás • A TSL egy megosztott lock változót használ. Ha a lock értéke 0, bármely processzus 1-re állíthatja azt, és ezután olvashatja, vagy felülírhatja a megosztott memóriát. Ha végzett, a processzus a lock változót újra 1-re állítja (egy egyszerű MOVE utasítással) • A következő két programmodul egy fiktív assembly nyelvben íródott. Az első beállítja a TSL segitségével a lock értéket (enter_region:), a másik ‘üriti’ azt, és visszaadja a vezérlést a hívónak (leave_region:).

50. enter_region: tsl register,lock cmp register,#0 jne enter_region ret leave_region: move lock,#0 ret | /átmásolja a lock-t a regiszterbe és a lock legyen 1/ | /a lock nulla volt?/ | /ha nem volt nulla, akkor be van állitva, igy ciklus legyen/ | /vissza a hivóhoz, beléptünk a kritikus szekcióba/ | /a lock legyen 0/ | /visszatérés a hivóhoz / Processzusok kommunikációjaKölcsönös kizárás tevékeny várakozássalA TSL utasíitás