Az előadás letöltése folymat van. Kérjük, várjon

Az előadás letöltése folymat van. Kérjük, várjon

Operációs rendszerek Kölcsönös kizárás - szemaforok.

Hasonló előadás


Az előadások a következő témára: "Operációs rendszerek Kölcsönös kizárás - szemaforok."— Előadás másolata:

1 Operációs rendszerek Kölcsönös kizárás - szemaforok

2 Vadász2 Miről lesz szó? A probléma: vetélkedés erőforrásokért Alapfogalmak, kívánalmak Megoldások –Váltogatás és ki érdekelt, zároló-változó stb. (primitívek, alapalgoritmusok) –szemaforok Problémák megoldásai, esettanulmányok

3 Vadász3 A sorbaállási modell Erőforrásokért versengő processzek rendszerének analizálására Várakozási sorok (queue) képezhetők (téglalapok) Vannak erőforrások (körök) Ütemezések (függőleges vonal) –CPU ütemezésnél Hosszú-távú Középtávú Rövid-távú –Egyéb erőforrás ütemezések is lehetnek

4 Vadász4 A sorbaállási modell Hosszú-távú ütemezés CPU I/O Futásra kész Várakozó Felfüggesztett Belép Kilép I/O ütemezés Középtávú ütemezés Rövid-távú ütemezés Időszelete letelt Memória kérés M I/O kérés

5 Vadász5 Erőforrás csoportosítás 1 A típus száma szerint –Egy példányos erőforrások –Többpéldányos erőforrások: használati értékükben azonosak a példányok) Használati mód szerint –Megosztottan használhatók, melyek Állapota lementhető és visszaállítható, emiatt esetleg „elvehetők” a használótól (preemption lehetséges) –Csak kizárólagosan használhatók, melyek Nem vehetők el a használótól csak „zökkenőkkel” (pl. vissza kell küldeni a használót egy korábbi állapotába, terminálni kell a használót)

6 Vadász6 Erőforrás csoportosítás 2 „Létük” szerinti csoportosítás –Előállítandó és fogyasztható (consumable) erőforrás Itt: előállítás – igénylés|kérés – használat forgatókönyv –Újrahasználható erőforrás Itt: igénylés|kérés – használat – lemondás|felszabadítás forgatókönyv … A forgatókönyvekhez –Igénylés, kérés: esetleg várakozással Általánosan: egy kéréssel több erőforrásból, több példányt is igényelünk … –A felszabadítás|lemondás (szignálozás is) 2 típusa (legalább) Adott típusból valamennyit felszabadítom Adott foglaltakból adott példányokat szabadítok fel

7 Vadász7 A CPU erőforrás különleges … A (független) processz modellnél a CPU erőforrás használathoz preemptív ütemezésnél nincs kér- használ-lemond „instrukciókészlet” –A CPU ütemezésben nem lesz holtpont probléma … –Legfeljebb a „kooperatív” ütemezésnél van lemondás … A „User-level” szálakat a taszk saját maga ütemezi … –Itt már lehet holtpont probléma …

8 Vadász8 Erőforrás-használat - holtpont Az (egy) egyszerű példa: –P1 és P2 processzek; X és Y erőforrások … –P1-ben kér(X); kér(Y) absztrakt insrukció-sor –P2-ben kér(Y); kér(X) absztrakt insrukció-sor A kérés-kielégítés modelljei –A kér-en egy processz „blokkolódhat” (vár kielégítésre) –A kielégités modellje: kielégítésre váró szignált vár (eseményt vár), végül megkapja a szignált; valami kell adja a szignált

9 Vadász9 Együttműködő processzek egy absztrakt problémája Termelő-fogyasztó (Producer-Consumer) probléma –Vannak termelő folyamatok, melyek saját ritmusukban terméket (item, message) állítanak elő és behelyezik egy raktárba. –Vannak fogyasztó folyamatok, melyek saját ritmusukban a terméket kiveszik a raktárból és felhasználják, fogyasztják –Van korlátozott termék-raktár.

10 Vadász10 A termelő-fogyasztó probléma A termék ugyan lehet elfogyó erőforrás, de az előállítására várakozás a raktár üresség kezeléssel eliminálódhat A raktárra való korlátozás vonatkozhat: –a raktár méretére (teli raktárba termelő nem rakodhat, üresből fogyasztó nem fogyaszthat); Ez megelőzési (precedencia) probléma. –a raktár használatára (egy időben több termelő nem használhatja a raktárt, egy időben több fogyasztó nem használhatja a raktárt, egy időben csak egy folyamat, akár termelő, akár fogyasztó, használhatja a raktárt.) Ez kölcsönös kizárási probléma.

11 Vadász11 Az alap séma processz() { while (true) { nem-kritikus-szakasz1(); kérelem(); használat(); felszabadítás(); nem-kritikus-szakasz2(); } Kölcsönös kizárás processz() { // kérelmező processz while (true) { nem-kritikus-szakasz1(); kérelem(); használat(); nem-kritikus-szakasz2() } processz() { // engedélyező... if (van-kérelmező) engedélyezés();.... } Precedencia

12 Vadász12 Alapfogalmak 1 Kölcsönös kizárás (Mutual Exclusion): Csak kizárólagosan használható, egypéldányos erőforrásokért vetélkedő processzek közül egy és csakis egy, több példányos erőforrásokért vetélkedő processzek közül kötött számú processz kapja meg a jogot egy erőforráspéldány használatára. A kölcsönös kizárásnak legyenek módszerei, eszközei, technikái.

13 Vadász13 Alapfogalmak 2 Kritikus szakasz (Critical Section): a folyamaton belüli kódrész (valójában annak futási időszakasza), melyen belül a kölcsönös kizárást meg kell valósítani. Egy erőforráspéldány kizárólagos használatának (idő)szakasza.

14 Vadász14 Alapfogalmak 3-5 Belépési szakasz (Entry Section) a folyamaton belül az a kódrész, ahol kéri az engedélyt a kritikus szakaszba való belépésre. A kérelem szakasza. Kilépési szakasz (Leave Section) az a kódrész, ahol elhagyja a processz a kritikus szakaszt. Az erőforráspéldány felszabadítása: jelzés más processzeknek az erőforrás felszabadulásáról. A folyamatoknak természetesen lehetnek nem kritikus szakaszaik is.

15 Vadász15 Kívánalmak 1 Biztonsági (safety) kívánalom: Valósuljon meg a kölcsönös kizárás: ha processz kritikus szakaszában fut, más processz csak akkor léphessen be kritikus szakaszába, ha van még szabad erőforráspéldány. (Ugyanazon időben csakis korlátozott számú kritikus szakasz futhat.). Természetesen, ezalatt további processzek a belépési szakaszukban lehetnek (éppen az a fontos, hogy azon ne jussanak túl).

16 Vadász16 Kívánalmak 2 Előrehaladási (progress) kívánalom: általában nem kritikus szakaszban és nem belépési szakaszban futó processz ne befolyásolja mások belépését. Ha egyetlen folyamat sincs kritikus szakaszában és vannak processzek a belépési szakaszukban, akkor csakis ezek vegyenek részt abban a döntésben, hogy melyik fog végül belépni. Ráadásul ez a döntés nem halasztható végtelenségig.

17 Vadász17 Kívánalmak 3-4 Korlátozott várakozási (bounded waiting) kívánalom: ha egy processz bejelentette igényét a belépésre, de még nem léphet be, korlátozzuk ésszerűen azt, hogy egy másik processz hányszor léphet be. Egy processz se várakozzon a végtelenségig belépésre azért, mert egy másik újból bejelentve az igényét megint megelőzi. Ne legyen kiéhezés. Hardver és platform kívánalom: ne legyenek előfeltételeink a hardverre (sem a CPU-k típusára, számára, sem a sebességükre), a processzek számára, relatív sebességükre, az operációs rendszer ütemezésére stb.

18 Vadász18 A mutex alap séma „Blokkolni” kell „Szignáloz” Blokkolni? –Ne jusson a CPU-hoz –Busy waiting –Állapotváltással processz() { while (true) { nem-kritikus-szakasz1(); kérelem(); használat(); felszabadítás(); nem-kritikus-szakasz2(); } Kölcsönös kizárás

19 Vadász19 0-ik megoldás: Megszakítás letiltás Kritikus szakasz elején IT letiltás, végén engedélyezés Csak egy CPU-ra jó (4. követelmény!) Veszélyes: hiba esetén deadlock! Csak nagyon letesztelt kernel kódokban! Alapalgoritmusok, építőkövek

20 Vadász20 Megoldás #1: váltogatás Az osztott turn változó nyomonköveti, ki lesz a következő. processz-i() { while (true) { nem-kritikus-szakasz1(); while(turn!=i) nop(); kritikus-szakasz(); turn = j; nem-kritikus-szakasz2(); } processz-j() { while (true) { nem-kritikus-szakasz1(); while(turn!=j) nop(); kritikus-szakasz(); turn = i; nem-kritikus-szakasz2(); } shared turn=i; Sérül a 2. követelmény: nem követi, hogy egy processz érdekelt-e vagy sem (4. köv: csak 2 processzre).

21 Vadász21 Megoldás #1: turn & erd Egymás váltogatása az érdekeltség figyelembevételével processz-i() { while (true) { nem-kritikus-szakasz1(); erd[i] = true; turn = j; while (erd[j] && turn == j) nop(); kritikus-szakasz(); erd[i] = false; nem-kritikus-szakasz2(); } processz-j() { while (true) { nem-kritikus-szakasz1(); erd[j] = true; turn = i; while (erd[i] && turn == i) nop(); kritikus-szakasz(); erd[j] = false; nem-kritikus-szakasz2(); } Shared turn, erd[N] = {false, false, …}; Csak a 4. köv. sérül: 2 processzre jó. De kiterjeszthető!

22 Vadász22 Zárolásváltozó használat #2 Az osztott lock változó tesztelhető és beállítható. processz-i() { while (true) { nem-kritikus-szakasz1(); while (tsl(&lock)) nop(); kritikus-szakasz(); lock= false; nem-kritikus-szakasz2(); } int tsl(*lock) { register int temp; temp = *lock; *lock = true; return temp; } // ez megszakithatatlan // instrukcio kell legyen shared lock = false; Sérül a 4. követelmény: nem minden hardveren van ilyen instrukció. IT letiltás többprocesszoros rendszeren nem segít. A 3. követelmény is sérülhet: egy processz kisajátíthatja az erőforrást.

23 Vadász23 Szemaforok Dijkstra (1965) szemafor: pozitív egész számot tartalmazó közös változó és egy várakozási sor. Szemaforon két atomi operáció. Atomi: –Egy időben csak egy processz operálhat egy szemaforon. –Blokkolódásból “felébredő“ processz végrehajtja azt az operációt, amin előzőleg blokkolódott. DOWN (P: Passeren) - ezen blokkolódhat. UP (V: Vrijgeven [vrejhéfen]) - ez szignáloz.

24 Vadász24 Operációk szemaforon DOWN(semaphore S) { if (S >= 1) S=S - 1; else { a hivo helyezze magat az S varakozo sorara és PC-t állítsd az if elé} } UP(semaphore S) { S= S + 1; if (S varakozo sora nem ures) {egy processzt vegy le rola} }

25 Vadász25 Használata Kritikus szakasz védelme processz-i() { while (true) { nem-kritikus-szakasz1(); DOWN(s); kritikus-szakasz(); UP(s); nem-kritikus-szakasz2(); } shared semaphore s = 1; Szinkronizáció shared semaphore s = 0; processz-i() { // ui elozze uj-t... ui(); UP(s);... } processz-j() {... DOWN(s); uj();... }

26 Vadász26 Egy termelő-fogyasztó probléma Több termelő folyamat van. Több fogyasztó folyamat van. Korlátozott a raktár mérete: N számú hely. Korlátozott a raktárhoz való hozzáférés: csak egy ki-berakó gép van (egy időben csakis egy termelő vagy fogyasztó használhatja a raktárt). Raktár “teliség“ és “üresség“ kezelendő. Belátható, legalább 3 szemafor kell: –Ki-berakó gép védelmére; –Üresség jelzésére; –teliség jelzésére. Esettanulmány Szinkronizáció Kizárás probléma

27 Vadász27 A termelő #define N 32 semaphoremutex = 1; semaphoreures = N; semaphoreteli = 0; void producer ( ) { termek_ttermek; while (1) { termek=gyart( ); // nem kritikus szakasz DOWN(ures); // üres rekeszre vár DOWN(mutex);// raktárba lép termeket_raktarba_tesz(termek); UP(mutex);// raktárból kilép UP(teli);// teli jelzést növeli } }

28 Vadász28 A fogyasztó #define N 32 semaphoremutex = 1; semaphoreures = N; semaphoreteli = 0; void cosumer ( ) { termek_ttermek; while (1) { DOWN(teli);// teli rekeszre vár DOWN(mutex);// raktárba lép termek=termeket_raktarbol_vesz( ); UP(mutex);// raktárból kilép UP(ures);// üresek száma nő } }

29 Vadász29 Egy kérdés Mi történne, ha a DOWN(teli); // teli rekeszre vár, vagy csökkenti DOWN(mutex); // belép a raktárba sorokat felcserélnénk?

30 Vadász30 A Unix szemafor mechanizmusa Gyors, kis átvihető információmennyiség Indirekt, OS kötődésű, többirányú A kapcsolódó rendszerhívások: –semget( ) // készítés, azonosítás –semctl( ) // kontroll, jellemzők lekérdezése, törlés –semop( ) // operációkészlet végrehajtás A szükséges „beleértett” fájlok: –#include

31 Vadász31 Dijkstra szemafor – Unix szemafor D nem definiálta a blokkolás implementációját A Usem: –Blokkolásos jellegű, –elemi szemaforok készlete van egyetlen szemaforban, –elemi operációk készletének végrehajtása történik egyetlen (atomi) operációban, –az elemi operációk nemcsak egységgel csökkenthetnek, növelhetnek (non-unitary), –van nulla ellenőrzés is, –kérésre az elemi operációk „visszavonódnak” (undo) –kérésre nincs blokkolódás, bár kellene.

32 Vadász32 A rendszerhívások: semget( ) int semget(key_t key, int nsems, int flg); Aholkey(hexa) kulcs a külső azonosításhoz, nsemsaz elemi szemaforok száma a szemaforban flgkészítéskor védelem, hozzáférés beállítás, azonosításkor létezés ellenőrzés, hozzáférés ellenőrzés Készít nsems elemi szemaforból álló szemafort az adott kulccsal és hozzáférésekkel, vagy azonosít létező szemafort. Visszatér a szemafor belső leírójával, vagy hibaértékkel. Készítés során az elemi szemaforok 0 értéket vesznek fel.

33 Vadász33 Az elkészült szemafor belső adatstruktúrái Az alap adatszerkezet: struct semid_ds{ struct ipc_perm sem_perm;// hozzáférések struct sem*sem_base;// a 0. elemi szem. Pointere ushortsem_nsems;// az elemi szem.ok száma … } Ebből egy elemi szemafor adatai: struct sem { ushortsemval;// pillanatnyi érték ushortsemzcnt;// nullára váró processzek száma ushortsemncnt;// növelésre várók száma pid_tsempid;// utolsó operáló processz }

34 Vadász34 A rendszerhívások: semctl( ) int semctl( int sid, int semnum, int cmd[, union semunion arg]); Aholsida belső leíró, semnumaz elemi szemafor indexe, cmdIPC_STATállapot lekérdező, IPC_SETállapot beállító, IPC_RMID törlő parancs. A GETVAL, GETALL, GETPID, GETNCNT, GETZCNT szintén lekérdező, a SETVAL, SETALL beállító parancsok. arga felhasználói címtartományhoz tartozó union változó vagy konstans, lekérdezésnél eredmény, beállításkor forrás.

35 Vadász35 A semctl( ) híváshoz Az elemi szemaforok 0 és nsems-1 közötti indexűek. Az i-edik elemi szemafor inicializálása: semctl(sid, i, SETVAL, init_value) Az i-edik elemi szemafor pillanatnyi értékének lekérdezése: value=semctl(sid, i, GETVAL); Az arg típusa: union semun { int val; // elemi szemafor érték ushort *array; // elemi értékek tömbjének ptr-e struct semid_ds *buf; // adatstruktúrák mutatója } arg; // egyes rendszerekben ez a sem.h fájlban …

36 Vadász36 Rendszerhívások: semop( ) int semop(int sid, struct sembuf *sops, unsigned nsops); Ahol:sida szemfor leírója, sopspointer az elemi operációk tömbjéhez, nsops az elemi operációk száma. Egy elemi operációt a következő struktúra határoz meg: struct sembuf { ushort sem_num;// az elemi szemafor indexe short sem_op;// az elemi operáció shortsem_flg;// operációt módosító jelző }

37 Vadász37 Az operációkészlet Egy operációkészletre példa: struct sembuf opkeszlet[4] = { 0, -2, 0, 1, 1, 0, 2, 2, 0, 0, 0, 0 }; És az operáció: semop(sid, &opkeszlet[0], 4);

38 Vadász38 A sem_op értéke Ha a sem_op < 0, akkor vár, amíg a semval ≥ |sem_op|, és semval+=sem_op; (Negatív sem_op → dekrementáció, down operáció.) Ha sem_op == 0 akkor vár, amíg semval == 0 lesz. (Null ellenőrzés.) Ha sem_op > 0, akkor semval+= sem_op; (Pozitív sem_op → inkrementráció, up operáció.)

39 Vadász39 A sem_flg módosító Lehet 0, vagy vagy kapcsolatban a következő makrók IPC_SEMUNDO –A processz terminálódására az elemi opráció „visszaáll”. IPC_NOWAIT –Ha nem sikerülne a dekrementáció (down), akkor abortál a semop( ) és a processz fut tovább. Mire jó ez? … while( 1) { if ( semop( ) ) { kritikus_szakasz( ); break} else valami_mas_hasznos( ); } …

40 Vadász40 Egy példa: nsems=3, nops=4 numopflag sid Eredmény sid Kiindulás semval

41 Vadász41 Példaprogramok Nézzük a „szokásos” helyet! GEIAL202/Peldaprogramok/ipc/sem

42 Vadász42 Az ebédelő filozófusok … Nézzék meg Tanenbaum megoldást (D szemaforral egész bonyolult. Tanulmányozható a GEIAL202 Ea6- ban is!)GEIAL202 Ea6- ban Elegáns megoldás U szemaforral

43 Vadász43 Ebédelő filozófusok „Megterítünk” (inicializálás) #define N 5 … sid = semget(key, N, 0666); … for(i=0; i < N; i++) semctl(sid, i, SETVAL,1); /* inicializáljuk a tömböt 1-ekre */ …

44 Vadász44 Ebédelő filozófusok Az i-edik filozófus programja … #define N #define i i #define BAL (i – 1) % N /* bal szomszéd */ #define JOBB (i + 1) % N /* jobb szomszéd */ static struct sembuf villakat[2] = { BAL, 0, 0, JOBB, 0, 0}; … while(1) { gondolkodom( ); villakat[0].semop = -1; villakat[1].semop = -1; semop(sid, villakat, 2); /* 2 villa fel */ nyam_nyam_spagetti( ); villakat[0].semop = 1; villakat[1].semop = 1; semop(sid, villakat, 2); /* 2 villa le */ }

45 Operációs rendszerek Kölcsönös kizárás - szemaforok


Letölteni ppt "Operációs rendszerek Kölcsönös kizárás - szemaforok."

Hasonló előadás


Google Hirdetések