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 Bátfai Norbert Debreceni Egyetem Informatikai Kar (DE IK), Információ Technológia.

Hasonló előadás


Az előadások a következő témára: "Operációs rendszerek Bátfai Norbert Debreceni Egyetem Informatikai Kar (DE IK), Információ Technológia."— Előadás másolata:

1 Operációs rendszerek Bátfai Norbert Debreceni Egyetem Informatikai Kar (DE IK), Információ Technológia Tanszék egyetemi tanársegéd Dokumentum verzió: 0.0.6, DEIK_MIPPOS_2008tavasz_BN_5.odp Debrecen, április előadás – IPC PROBLÉMÁK, MEGOLDÁSOK Programozó Páternoszter DE IK mérnök informatikus szak előadás

2 Operációs rendszerek előadás Bátfai, Norbert Debreceni Egyetem, Informatikai Kar, Információ Technológia Tanszék Copyright © 2008 Bátfai Norbert E közlemény felhatalmazást ad önnek jelen dokumentum sokszorosítására, terjesztésére és/vagy módosítására a Szabad Szoftver Alapítvány által kiadott GNU Szabad Dokumentációs Licenc 1.2-es, vagy bármely azt követő verziójának feltételei alapján. Nem változtatható szakaszok: A szerzőről. Címlap szövegek: Programozó Páternoszter, Bátfai Norbert, Gép melletti fogyasztásra. Hátlap szövegek: Belépés a gépek mesés birodalmába. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with the Invariant Sections being: A szerzőről, with the Front- Cover Texts being: Programozó Páternoszter, Bátfai Norbert, Gép melletti fogyasztásra, and with the Back-Cover Texts being: Belépés a gépek mesés birodalmába. Felhasználási engedély A GNU Free Documentation License nem hivatalos magyar fordítása:

3 Az ötödik előadás vázlata Elmélet ● Klasszikus IPC problémák és megoldásuk ● Dijkstra-féle szemaforok ● Ebédelő filoszok ● Termelők és fogyasztók ● Olvasók és írók Példák ● Ebédelő filoszok C-ben POSIX szálakkal ● Olvasók és írók C-ben POSIX szálakkal ● Alvó borbély C-ben POSIX szálakkal ● A Java SE java.util.concurrent.Semaphore osztálya Gyakorlat ● A gyakorlat javasolt témája

4 Ebédlőasztal 0. filozófus 1. villa 2. villa 0. villa 3. villa 4. villa Ebédelő filozófusok 1. filozófus 2. filozófus 3. filozófus 4. filozófus

5 ... #define FILOSZOK_SZAMA 5 sem_t villa[FILOSZOK_SZAMA]; void *egy_filosz(void *id) *id=3 { int sorszam = *(int *)id; printf("%d. filosz jelen.\n", sorszam); fflush(stdout); for(;;) { sem_wait(villa+sorszam); sem_wait(villa+((sorszam+1) % FILOSZOK_SZAMA)); printf("%d. filosz ebedel.\n", sorszam); fflush(stdout); sem_post(villa+sorszam); sem_post(villa+((sorszam+1) % FILOSZOK_SZAMA)); } return id; }... Ebédelő filozófusok Ebédlőasztal 0. filozófus villa villa *id=0... *id=1... i *id=2... *id= szál fut 1. szál fut 2. szál fut 4. szál fut 3. szál fut $./filoszok 3. filosz ebedel. 2. filosz ebedel. 1. filosz ebedel. 0. filosz ebedel. 4. filosz ebedel. FAGYÁS!!!!!!!!! pontosabban HOLTPONT PP 70

6 ... #define FILOSZOK_SZAMA 5 sem_t villa[FILOSZOK_SZAMA]; void *egy_filosz(void *id) *id=3 { int sorszam = *(int *)id; printf("%d. filosz jelen.\n", sorszam); fflush(stdout); for(;;) { sem_wait(villa+sorszam); printf("%d. filosz a 2. sem elott.\n", sorszam); fflush(stdout); sem_wait(villa+((sorszam+1) % FILOSZOK_SZAMA)); printf("%d. filosz ebedel.\n", sorszam); fflush(stdout); sem_post(villa+sorszam); sem_post(villa+((sorszam+1) % FILOSZOK_SZAMA)); } return id; }... Ebédelő filozófusok i $./filoszok filosz 2 sem elott. 4. filosz 2 sem elott. 1. filosz 2 sem elott. 3. filosz 2 sem elott. 0. filosz 2 sem elott. PP 72

7 Ebédelő filozófusok Ebédlőasztal 0. filozófus 1. villa 2. villa 0. villa 3. villa 4. villa $./filoszok filosz 2 sem elott. 4. filosz 2 sem elott. 1. filosz 2 sem elott. 3. filosz 2 sem elott. 0. filosz 2 sem elott.

8 Ebédelő filozófusok i Kiemelt otthoni feladat: készítsd el a Tanenbaum könyv 95. oldalán szereplő Ebédelő filoszok megoldásának futtatható változatát. Használj POSIX szemaforokat és mutex zárat! Térj ki arra kérdésre is, hogy egyszerre eszik-e két filosz! „Bizonyítékul” a munkádat bemutató, azt részletesen leíró, pillanatfelvételekel bővített DocBook dokumentumot (és egy abból generált html lapot) (vagy esetleg egy OpenOffice dokumentumot) küldj el nekem az címemre, az „OS-KIEMELTOTTHONI-OR95” tárggyal. OR 95

9 Ebédelő filozófusok i Kiemelt otthoni feladat: készítsd el a Tanenbaum könyv 95. oldalán szereplő Ebédelő filoszok megoldásának futtatható változatát. Használj POSIX szemaforokat és mutex zárat! Térj ki arra kérdésre is, hogy egyszerre eszik-e két filosz! „Bizonyítékul” a munkádat bemutató, azt részletesen leíró, pillanatfelvételekel bővített DocBook dokumentumot (és egy abból generált html lapot) (vagy esetleg egy OpenOffice dokumentumot) küldj el nekem az címemre, az „OS-KIEMELTOTTHONI-OR95” tárggyal. OR 95

10 1965, Dijkstra-féle szemaforok Az S szemafor egyfajta egész értékű változó két primitivvel (azaz oszthatatlan, „atomi” művelettel). 01 FOGLALT SZABAD P(S) { S = S – 1; if(S < 0) // Várakozás S-en wait(); } V(S) { S = S + 1; if(S <= 0) // Egy S-en várakozó // ébresztése wakeup(); } DOWN, Probeer (try), wait, pend, acquire UP, Verhoog (inc), signal, post, release Vagy kevésbé szemléletesen: P(S) { while(S <= 0) // Várakozás S-en ; S = S - 1; } V(S) { S = S + 1; // Ezzel S-en egy várakozó // ébresztése }

11 Ismétlés: pthreads könyvtár, mutex zárak, pthreads_ PTHREAD_MUTEX_LOCK(P) POSIX Programmer's Manual PTHREAD_MUTEX_LOCK(P) NAME pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock - lock and unlock a mutex SYNOPSIS #include int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex); DESCRIPTION The mutex object referenced by mutex shall be locked by calling pthread_mutex_lock(). If the mutex is already locked, the calling thread shall block until the mutex becomes available. This operation shall return with the mutex object referenced by mutex in the locked state with the calling thread as its owner. i... #define SZALAK_SZAMA 100 int szamlalo = 0;... int main(void) { pthread_t sz[SZALAK_SZAMA];... void * novel_szal(void *id) { int i; for(i=0; i<100; ++i) { printf("Szal: %d, %d\n", *(int *)id, pthread_self()); fflush(stdout); var(); szamlalo = szamlalo + 1; } return id; } void * csokkent_szal(void *id) { int i; for(i=0; i<100; ++i) { printf("Szal: %d, %d\n", *(int *)id, pthread_self()); fflush(stdout); var(); szamlalo = szamlalo - 1; } return id; }. Szal: 98, Szal: 96, Szal: 98, Szal: 96, A szamlalo vegul: -2 PP 67

12 i... #define SZALAK_SZAMA 100 int szamlalo = 0; pthread_mutex_t szamlalo_zar = PTHREAD_MUTEX_INITIALIZER;... int main(void) { pthread_t sz[SZALAK_SZAMA];... void * novel_szal(void *id) { int i; for(i=0; i<100; ++i) { printf("Szal: %d, %d\n", *(int *)id, pthread_self()); fflush(stdout); var(); pthread_mutex_lock(&szamlalo_zar); szamlalo = szamlalo + 1; pthread_mutex_unlock(&szamlalo_zar); } return id; } void * csokkent_szal(void *id) { int i; for(i=0; i<100; ++i) { printf("Szal: %d, %d\n", *(int *)id, pthread_self()); fflush(stdout); var(); pthread_mutex_lock(&szamlalo_zar); szamlalo = szamlalo - 1; pthread_mutex_unlock(&szamlalo_zar); } return id; }. Szal: 40, Szal: 55, Szal: 97, Szal: 40, Szal: 55, A szamlalo vegul: 0 PP 69 Kölcsönös kizárás

13 Kölcsönös kizárás bináris szemaforral DOWN(S mutex ); // kritikus szekció UP(S mutex ); szamlal o 1 0 DOWN(S mutex ) ; P(S) { S = S – 1; if(S < 0) // Várakozás S-en wait(); } V(S) { S = S + 1; if(S <= 0) // Egy S- en // várakozó // ébresztése wakeup(); } idő UP(S mutex ) ; szamlal o 1 Kritikus tartomány

14 Kölcsönös kizárás bináris szemaforral DOWN(S mutex ); // kritikus szekció UP(S mutex ); szamlal o 1 0 DOWN(S mutex ) ; P(S) { S = S – 1; if(S < 0) // Várakozás S-en wait(); } V(S) { S = S + 1; if(S <= 0) // Egy S- en // várakozó // ébresztése wakeup(); } VÁRAKOZÁS idő DOWN(S mutex ) ; VÁRAKOZÁS UP(S mutex ) ; X X

15 Termelők és fogyasztók probléma T1 T2 T3 T1 T2 T3 T1 T2 T3 F1 F2 F3 T2 T3 F4 F5 Betenni akkor lehet, ha van hova. Kivenni akkor lehet, ha van mit.

16 Termelők és fogyasztók probléma OR 85 Legyen N=3 a rekeszek száma! S teli_helyek = 0 S üres_helyek = N S tömb_mutex = 1 N = 3; Semaphore S tömb_mutex = 1; Semaphore S teli_helyek = 0; Semaphore S üres_helyek = N; OR 85, 2.12 ábra Termelő() { for(;;) { // termel DOWN(S üres_helyek ); DOWN(S tömb_mutex ); // berak UP(S tömb_mutex ); UP(S teli_helyek ); } Fogyasztó() { for(;;) { DOWN(S teli_helyek ) ; DOWN(S tömb_mutex ); // kivesz UP(S tömb_mutex ); UP(S üres_helyek ); // feldolgoz }

17 S teli_helyek = 0 S üres_helyek = 3 Termelő // termel P(S üres_ helyek ); P(S tömb _mutex ); // berak V(S tömb _mutex ); V(S teli_h elyek ); Fogyasztó P(S teli_h elyek ); P(S tömb _mutex ); // kivesz V(S tömb _mutex ); V(S üres_ helyek ); // feldolgoz Mennyit tudunk kivenni? betenni? T1 termel 42 P(S üres_helyek ); P(S) S = S – 1; if(S < 0) wait(); V(S) S = S + 1; if(S <= 0) wakeup() ; S teli_helyek = 0 S üres_helyek = 2 F1 P(S teli_helyek ); S teli_helyek = - 1 S üres_helyek = 2 VÁRAKOZIK... idő Futtatás

18 S teli_hely ek S üres_hely ek Termelő // termel P(S üres_ helyek ); P(S tömb _mutex ); // berak V(S tömb _mutex ); V(S teli_h elyek ); Fogyasztó P(S teli_h elyek ); P(S tömb _mutex ); // kivesz V(S tömb _mutex ); V(S üres_ helyek ); // feldolgoz P(S) S = S – 1; if(S < 0) wait(); V(S) S = S + 1; if(S <= 0) wakeup() ; F2 P(S teli_helyek ); S teli_helyek = - 2 S üres_helyek = 2 VÁRAKOZIK S teli_helyek = - 2 S üres_helyek = 2 V(S teli_helyek ); 42 S teli_helyek = - 1 S üres_helyek = 2 Mennyit tudunk kivenni? betenni? Futtatás

19 S teli_hely ek S üres_hely ek Termelő // termel P(S üres_ helyek ); P(S tömb _mutex ); // berak V(S tömb _mutex ); V(S teli_h elyek ); Fogyasztó P(S teli_h elyek ); P(S tömb _mutex ); // kivesz V(S tömb _mutex ); V(S üres_ helyek ); // feldolgoz P(S) S = S – 1; if(S < 0) wait(); V(S) S = S + 1; if(S <= 0) wakeup() ; FELÉBRE D 42 S teli_helyek = - 1 S üres_helyek = 2 S teli_helyek = - 1 S üres_helyek = 3 V(S üres_ helyek ); Mennyit tudunk kivenni? betenni? termel 42 P(S üres_helyek ); 7 S teli_helyek = - 1 S üres_helyek = 2 V(S teli_helyek ); 7 S teli_helyek = 0 S üres_helyek = 2 Futtatás

20 S teli_hely ek S üres_hely ek Termelő // termel P(S üres_ helyek ); P(S tömb _mutex ); // berak V(S tömb _mutex ); V(S teli_h elyek ); Fogyasztó P(S teli_h elyek ); P(S tömb _mutex ); // kivesz V(S tömb _mutex ); V(S üres_ helyek ); // feldolgoz P(S) S = S – 1; if(S < 0) wait(); V(S) S = S + 1; if(S <= 0) wakeup() ; FELÉBRE D 7 S teli_helyek = 0 S üres_helyek = 2 S teli_helyek = 0 S üres_helyek = 3 V(S üres_ helyek ); Mennyit tudunk kivenni? betenni? Futtatás

21 Ebédelő filozófusok FILOSZOK_SZAMA = 5; int filosz_allapota[FILOSZOK_SZAMA]; Semaphore S kritikus_szekcio_zar = 1; Semaphore S filosz_szemafor [FILOSZOK_SZAMA]; OR 95, 2.18 ábra egy_filosz // a sorszam. filosz szála { for (;;) { felveszi_villakat (sorszam); printf ("%d. filosz ebedel.\n", sorszam); fflush (stdout); leteszi_villakat (sorszam); } felveszi_villakat (int sorszam) { DOWN (S kritikus_szekcio_zar ); filosz_allapota[sorszam] = FEL_AKARJA_VENNI; probal_villakat_felvenni (sorszam); UP (S kritikus_szekcio_zar ); DOWN(S filosz_szemafor [sorszam]); } probal_villakat_felvenni (int sorszam) { if (filosz_allapota[sorszam] == FEL_AKARJA_VENNI && filosz_allapota[(sorszam - 1) % FILOSZOK_SZAMA] != ESZIK && filosz_allapota[(sorszam + 1) % FILOSZOK_SZAMA] != ESZIK) { filosz_allapota[sorszam] = ESZIK; UP(S filosz_szemafor [sorszam]); }

22 Ebédelő filozófusok OR 95, 2.18 ábra egy_filosz // a sorszam. filosz szála { for (;;) { felveszi_villakat (sorszam); printf ("%d. filosz ebedel.\n", sorszam); fflush (stdout); leteszi_villakat (sorszam); } leteszi_villakat (int sorszam) { DOWN (S kritikus_szekcio_zar ); filosz_allapota[sorszam] = GONDOLKOZIK; probal_villakat_felvenni ((sorszam - 1) % FILOSZOK_SZAMA); probal_villakat_felvenni ((sorszam + 1) % FILOSZOK_SZAMA); UP (S kritikus_szekcio_zar ); }

23 felveszi_villakat (int sorszam) { DOWN (S kritikus_szekcio_zar ); filosz_allapota[sorszam] = FEL_AKARJA_VENNI; probal_villakat_felvenni (sorszam); UP (S kritikus_szekcio_zar ); DOWN(S filosz_szemafor [sorszam]); } probal_villakat_felvenni (int sorszam) { if (filosz_allapota[sorszam] == FEL_AKARJA_VENNI && filosz_allapota[(sorszam - 1) % FILOSZOK_SZAMA] != ESZIK && filosz_allapota[(sorszam + 1) % FILOSZOK_SZAMA] != ESZIK) { filosz_allapota[sorszam] = ESZIK; UP(S filosz_szemafor [sorszam]); } G0G0 G0G0 G0G0 G0G0 G0G0 G0G0 E1E1 G0G0 G0G0 G0G0 G0G0 E0E0 G0G0 G0G0 G0G0 G0G0 E0E0 G0G0 E1E1 G0G0 G0G0 E0E0 G0G0 E0E0 G0G0

24 felveszi_villakat (int sorszam) { DOWN (S kritikus_szekcio_zar ); filosz_allapota[sorszam] = FEL_AKARJA_VENNI; probal_villakat_felvenni (sorszam); UP (S kritikus_szekcio_zar ); DOWN(S filosz_szemafor [sorszam]); } probal_villakat_felvenni (int sorszam) { if (filosz_allapota[sorszam] == FEL_AKARJA_VENNI && filosz_allapota[(sorszam - 1) % FILOSZOK_SZAMA] != ESZIK && filosz_allapota[(sorszam + 1) % FILOSZOK_SZAMA] != ESZIK) { filosz_allapota[sorszam] = ESZIK; UP(S filosz_szemafor [sorszam]); } G0G0 E0E0 G0G0 E0E0 G0G0 G0G0 E0E0 G0G0 E0E0 F-1F-1

25 egy_filosz // a sorszam. filosz szála { for (;;) { felveszi_villakat (sorszam); printf ("%d. filosz ebedel.\n", sorszam); fflush (stdout); leteszi_villakat (sorszam); } leteszi_villakat (int sorszam) { DOWN (S kritikus_szekcio_zar ); filosz_allapota[sorszam] = GONDOLKOZIK; probal_villakat_felvenni ((sorszam - 1) % FILOSZOK_SZAMA); probal_villakat_felvenni ((sorszam + 1) % FILOSZOK_SZAMA); UP (S kritikus_szekcio_zar ); } G0G0 E0E0 G0G0 G0G0 F-1F-1 G0G0 E0E0 G0G0 G0G0 E0E0 probal_villakat_felvenni (int sorszam) { if (filosz_allapota[sorszam] == FEL_AKARJA_VENNI && filosz_allapota[(sorszam - 1) % FILOSZOK_SZAMA] != ESZIK && filosz_allapota[(sorszam + 1) % FILOSZOK_SZAMA] != ESZIK) { filosz_allapota[sorszam] = ESZIK; UP(S filosz_szemafor [sorszam]); } G0G0 E0E0 G0G0 E0E0 F-1F-1

26 Ebédelő filozófusok i Kiemelt otthoni feladat: készítsd el a Tanenbaum könyv 95. oldalán szereplő Ebédelő filoszok megoldásának futtatható változatát. Használj POSIX szemaforokat és mutex zárat! Térj ki arra kérdésre is, hogy egyszerre eszik-e két filosz! „Bizonyítékul” a munkádat bemutató, azt részletesen leíró, pillanatfelvételekel bővített DocBook dokumentumot (és egy abból generált html lapot) (vagy esetleg egy OpenOffice dokumentumot) küldj el nekem az címemre, az „OS-KIEMELTOTTHONI-OR95” tárggyal. OR 95

27 Ebédelő filozófusok i Kiemelt otthoni feladat: készítsd el a Tanenbaum könyv 95. oldalán szereplő Ebédelő filoszok megoldásának futtatható változatát. Használj POSIX szemaforokat és mutex zárat! Térj ki arra kérdésre is, hogy egyszerre eszik-e két filosz! „Bizonyítékul” a munkádat bemutató, azt részletesen leíró, pillanatfelvételekel bővített DocBook dokumentumot (és egy abból generált html lapot) (vagy esetleg egy OpenOffice dokumentumot) küldj el nekem az címemre, az „OS-KIEMELTOTTHONI-OR95” tárggyal. OR 95

28 Olvasók és írók adatbázis T1 T2 T3 I1 I2 I3 T1 T2 T3 O1 O2 O3 T2 T3 O4 O5 Az írók írni, az olvasók olvasni szeretnék. OR 96

29 Olvasók és írók adatbázis T1 T2 T3 I1 I2 I3 T1 T2 T3 O1 O2 O3 T2 T3 O4 O5 Vagy egy írhatja.

30 Olvasók és írók adatbázis T1 T2 T3 I1 I2 I3 T1 T2 T3 O1 O2 O3 T2 T3 O4 O5 Vagy bármennyi olvashatja.

31 Olvasók és írók int olvaso_szamlalo = 0; Semaphore S mutex = 1; Semaphore S adatb = 1; OR 97, 2.19 ábra Író() { for(;;) { DOWN(S adatb ); // ír UP(S adatb ); } Olvasó() { for(;;) { DOWN(S mutex ); ++olvaso_szamlalo; if(olvaso_szamlalo == 1) DOWN(S adatb ); UP(S mutex ); // olvas DOWN(S mutex ); -- olvaso_szamlalo; if(olvaso_szamlalo == 0) UP(S adatb ); UP(S mutex ); }

32 Olvasók és írók i Kiemelt otthoni feladat: készítsd el a Tanenbaum könyv 97. oldalán szereplő Olvasók és írók megoldásának futtatható változatát. Használj POSIX szemaforokat és mutex zárat! Térj ki arra kérdésre is, hogy mi történik, ha „2 másodpercenként jön új olvasó és minden olvasónak 5 másodperces munkája van” „Bizonyítékul” a munkádat bemutató, azt részletesen leíró, pillanatfelvételekel bővített DocBook dokumentumot (és egy abból generált html lapot) (vagy esetleg egy OpenOffice dokumentumot) küldj el nekem az címemre, az „OS-KIEMELTOTTHONI-OR97” tárggyal. OR 97

33 Olvasók és írók i Kiemelt otthoni feladat: készítsd el a Tanenbaum könyv 97. oldalán szereplő Olvasók és írók megoldásának futtatható változatát. Használj POSIX szemaforokat és mutex zárat! Térj ki arra kérdésre is, hogy mi történik, ha „2 másodpercenként jön új olvasó és minden olvasónak 5 másodperces munkája van” „Bizonyítékul” a munkádat bemutató, azt részletesen leíró, pillanatfelvételekel bővített DocBook dokumentumot (és egy abból generált html lapot) (vagy esetleg egy OpenOffice dokumentumot) küldj el nekem az címemre, az „OS-KIEMELTOTTHONI-OR97” tárggyal. OR 97

34 Nem könnyű velük programozni! int olvaso_szamlalo = 0; Semaphore S mutex = 1; Semaphore S adatb = 1; Író() { for(;;) { DOWN(S adatb ); DOWN(S mutex ); // „tesztelésként” kiíratjuk // az olvasók számát, // mert ennek itt nullának // kell(ene) lennie! UP(S mutex ); // ír UP(); } Olvasó() { for(;;) { DOWN(S mutex ); ++olvaso_szamlalo; if(olvaso_szamlalo == 1) DOWN(S adatb ); UP(S mutex ); // olvas DOWN(S mutex ); -- olvaso_szamlalo; if(olvaso_szamlalo == 0) UP(S adatb ); UP(S mutex ); } Tervünk, hogy mutex-el védve férünk hozzá a kritikus olvaso_szamlalo-hoz... Mi fog történni, ha a fent pirossal szedett módon ezt meg is tesszük???

35 Holtpont! int olvaso_szamlalo = 0; Semaphore S mutex = 1; Semaphore S adatb = 1; Író() { for(;;) { DOWN(S adatb ); DOWN(S mutex ); // „tesztelésként” kiíratjuk // az olvasók számát, // mert ennek itt nullának // kell(ene) lennie! UP(S mutex ); // ír UP(); } Olvasó() { for(;;) { DOWN(S mutex ); ++olvaso_szamlalo; if(olvaso_szamlalo == 1) DOWN(S adatb ); UP(S mutex ); // olvas DOWN(S mutex ); -- olvaso_szamlalo; if(olvaso_szamlalo == 0) UP(S adatb ); UP(S mutex ); } 3. VÁR 2. miatt, 4. VÁR 1. miatt! HOLTPONT! 3.

36 Alvó borbély OR 99

37 Alvó borbély #define SZEKEK_SZAMA int varakozok_szama = 0; Semaphore S mutex = 1; Semaphore S borbély = 0; Semaphore S vendég = 0; OR 99, 2.21 ábra Borbély() { for(;;) { DOWN(S vendég ); DOWN(S mutex ); -- varakozok_szama; UP(S borbély ); UP(S mutex ); // hajat vág } Vendég() { for(;;) { DOWN(S mutex ); if(varakozok_szama < SZEKEK_SZAMA) { ++varakozok_szama; UP(S vendég ); UP(S mutex ); DOWN(S borbély ); // haját vágják } else { UP(S mutex ); }

38 Alvó borbély

39

40 A Java SE java.util.concurrent.Semaphore osztálya

41 Java monitorok

42 Holt holtpont modellje Process z Erőforrá s P E OR 186 P processz az E erőforrást sorrendben: elkérte, megkapta, birtokolja. P processz blokkolt és várakozik az E erőforrásra. P E EF P Q

43 Holt holtpont modellje OR 186 E F PQR PQR Igényli E Igényli F Elengedi E Elengedi F Igényli E Igényli F Elengedi E Elengedi F Igényli F Igényli E Elengedi F Elengedi E E F PQR B B B Ütemező: P, Q, R, P, R

44 A strucc algoritmus OR 189

45 1965, Dijkstra; elkerülés: a bankár algoritmus OR 192 Egy erőforrástípusra.

46 1965, Dijkstra; elkerülés: a bankár algoritmus OR 195 Több erőforrástípusra.

47 A B/K rendszer Felhasználói programok szintje Eszközföggetlen réteg Eszközmeghajtó program Megszakításkezelő Hardver eszköz B/K kérésB/K válasz

48 A MINIX B/K

49 void driver_task(dp) struct driver *dp; /* Device dependent entry points. */ { /* Main program of any device driver task. */... message mess;... /* Here is the main loop of the disk task. It waits for a message, carries * it out, and sends a reply. */ while (TRUE) { /* Wait for a request to read or write a disk block. */ if (receive(ANY, &mess) != OK) continue; device_caller = mess.m_source;... /* Now carry out the work. */ switch(mess.m_type) { case DEV_OPEN: r = (*dp->dr_open)(dp, &mess); break; case DEV_CLOSE: r = (*dp->dr_close)(dp, &mess); break;... case DEV_READ: case DEV_WRITE: r = do_rdwt(dp, &mess); break;... }... /* Finally, prepare and send the reply message. */ if (r != EDONTREPLY) { mess.m_type = TASK_REPLY; mess.REP_ENDPT = proc_nr; /* Status is # of bytes transferred or error code. */ mess.REP_STATUS = r; send(device_caller, &mess); } } A blokkos meghajtók közös főciklusa a MINIX3-ban: drivers/libdriver/driver.c OR 205

50 RAM lemezek OR

51 Se nem blokkos, se nem karakteres, mégis B/K eszköz, mi az? OR 240

52 kernel/clock.c... void clock_task() {/* Main program of clock task. If the call is not HARD_INT it is an error. */ message m; /* message buffer for both input and output */ int result; /* result returned by the handler */ init_clock(); /* initialize clock task */ /* Main loop of the clock task. Get work, process it. Never reply. */ while (TRUE) { /* Go get a message. */ receive(ANY, &m); /* Handle the request. Only clock ticks are expected. */ switch (m.m_type) { case HARD_INT: result = do_clocktick(&m); /* handle clock tick */ break;... }...

53

54

55 kernel/clock.c... void clock_task() {/* Main program of clock task. If the call is not HARD_INT it is an error. */ message m; /* message buffer for both input and output */ int result; /* result returned by the handler */ init_clock(); /* initialize clock task */ /* Main loop of the clock task. Get work, process it. Never reply. */ while (TRUE) { /* Go get a message. */ receive(ANY, &m); /* Handle the request. Only clock ticks are expected. */ switch (m.m_type) { case HARD_INT: result = do_clocktick(&m); /* handle clock tick */ break;... }...

56

57 Tippek a gyakorlatra Végezzünk feladatokat a labor jegyzet Programozzunk az ebédelő filozófusokkal fejezete szerint! PP 70

58 Köszönöm a figyelmet Az előadások és a gyakorlatok kölcsönösen, oda-vissza építenek egymásra. Skype: batfai.norbert MSN: Az óra fóruma:


Letölteni ppt "Operációs rendszerek Bátfai Norbert Debreceni Egyetem Informatikai Kar (DE IK), Információ Technológia."

Hasonló előadás


Google Hirdetések