Mir l lesz szó? Operációs rendszerek. A sorbaállási modell. A sorbaállási modell. Er forrás csoportosítás 1. Er forrás csoportosítás 2

Átírás

1 Mir l lesz szó? Operációs rendszerek Kölcsönös kizárás - szemaforok 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 Operációs rendszerek 1 Operációs rendszerek 2 A sorbaállási modell 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 Belép Hosszú-távú ütemezés M Futásra kész I/O Középtávú ütemezés Felfüggesztett I/O ütemezés Rövid-távú ütemezés Várakozó CPU Id szelete letelt Memória kérés I/O kérés Kilép Operációs rendszerek 3 Operációs rendszerek 4 Er forrás csoportosítás 1 Er forrás csoportosítás 2 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) 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 Az igénylés kérés és a lemondás felszabadítás absztrakt instrukciók Operációs rendszerek 5 Operációs rendszerek 6

2 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érhaszná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 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 Operációs rendszerek 7 Operációs rendszerek 8 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. Operációs rendszerek 9 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. Operációs rendszerek 10 Az alap séma Precedencia Alapfogalmak 1 Kölcsönös kizárás processz() { kérelem(); használat(); felszabadítás(); processz() { // kérelmez processz kérelem(); használat(); nem-kritikus-szakasz2() processz() { // engedélyez if (van-kérelmez ) engedélyezés();. 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. Operációs rendszerek 11 Operációs rendszerek 12

3 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. 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. Operációs rendszerek 13 Operációs rendszerek 14 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). 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. Operációs rendszerek 15 Operációs rendszerek 16 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. Operációs rendszerek 17 Blokkolni kell Szignáloz Blokkolni? Ne jusson a CPU-hoz Busy waiting Állapotváltással A mutex alap séma Kölcsönös kizárás processz() { kérelem(); használat(); felszabadítás(); Operációs rendszerek 18

4 Alapalgoritmusok, épít kövek 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! Megoldás #1: váltogatás Az osztott turn változó nyomonköveti, ki lesz a következ. shared turn=i; processz-i() { while(turn!=i) nop(); turn = j; processz-j() { while(turn!=j) nop(); turn = i; Operációs rendszerek 19 Sérül a 2. követelmény: nem követi, hogy egy processz érdekelt-e vagy sem (4. köv: csak 2 processzre). Operációs rendszerek 20 Megoldás #1: turn & erd Egymás váltogatása az érdekeltség figyelembevételével Shared turn, erd[n] = {false, false, ; processz-i() { processz-j() { erd[i] = true; turn = j; erd[j] = true; turn = i; while (erd[j] && turn == j) while (erd[i] && turn == i) nop(); nop(); erd[i] = false; erd[j] = false; Csak a 4. köv. sérül: 2 processzre jó. De kiterjeszthet! Operációs rendszerek 21 Zárolásváltozó használat #2 Az osztott lock változó tesztelhet és beállítható. shared lock = false; processz-i() { while (tsl(&lock)) nop(); lock= false; int tsl(*lock) { register int temp; temp = *lock; *lock = true; return temp; // ez megszakithatatlan // instrukcio kell legyen 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. Operációs rendszerek 22 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. 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 Operációs rendszerek 23 Operációs rendszerek 24

5 Használata Egy termel -fogyasztó probléma Esettanulmány Kritikus szakasz védelme shared semaphore s = 1; processz-i() { DOWN(s); UP(s); Szinkronizáció shared semaphore s = 0; processz-i() { // ui elozze uj-t ui(); UP(s); processz-j() { DOWN(s); uj(); 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; Kizárás probléma Üresség jelzésére; Szinkronizáció teliség jelzésére. Operációs rendszerek 25 Operációs rendszerek 26 A termel A fogyasztó #define N 32 semaphore mutex = 1; semaphore ures = N; semaphore teli = 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 Operációs rendszerek 27 #define N 32 semaphore mutex = 1; semaphore ures = N; semaphore teli = 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 Operációs rendszerek 28 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? 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 <sys/ipcs.h> #include <sys/sem.h> Operációs rendszerek 29 Operációs rendszerek 30

6 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. A rendszerhívások: semget( ) int semget(key_t key, int nsems, int flg); Ahol key (hexa) kulcs a küls azonosításhoz, nsems az elemi szemaforok száma a szemaforban flg ké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. Operációs rendszerek 31 Operációs rendszerek 32 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 ushort sem_nsems; // az elemi szem.ok száma Ebb l egy elemi szemafor adatai: struct sem { ushort semval; // pillanatnyi érték ushort semzcnt; // nullára váró processzek száma ushort semncnt; // növelésre várók száma pid_t sempid; // utolsó operáló processz A rendszerhívások: semctl( ) int semctl( int sid, int semnum, int cmd[, union semunion arg]); Ahol sid a bels leíró, semnum az elemi szemafor indexe, cmd IPC_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. arg a felhasználói címtartományhoz tartozó union változó vagy konstans, lekérdezésnél eredmény, beállításkor forrás. Operációs rendszerek 33 Operációs rendszerek 34 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 Operációs rendszerek 35 Rendszerhívások: semop( ) int semop(int sid, struct sembuf *sops, unsigned nsops); Ahol: sid a szemfor leírója, sops pointer 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ó short sem_flg; // operációt módosító jelz Operációs rendszerek 36

7 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); 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ó.) Operációs rendszerek 37 Operációs rendszerek 38 A sem_flg módosító Egy példa: nsems=3, nops=4 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( ); Kiindulás sid semval num op flag Eredmény sid Operációs rendszerek 39 Operációs rendszerek 40 Példaprogramok Nézzük a szokásos helyet! GEIAL302B/Peldaprogramok/ipc/sem Az ebédel filozófusok Nézzék meg Tanenbaum megoldást (D szemaforral egész bonyolult. Elegáns megoldás U szemaforral Operációs rendszerek 41 Operációs rendszerek 42

8 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 */ 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 */ Operációs rendszerek 43 Operációs rendszerek 44 Operációs rendszerek Kölcsönös kizárás - szemaforok Operációs rendszerek 45