Klasyczne problemy synchronizacji

Transkrypt

1 Klasyczne problemy synchronizacji Systemy Operacyjne 2 laboratorium Mateusz Hołenko 19 grudnia 2011

2 Plan zajęć 1 Synchronizacja 2 Problem producenta / konsumenta 3 Problem pięciu filozofów 4 Problem czytelników i pisarzy Mateusz Hołenko Klasyczne problemy synchronizacji [1/23]

3 Synchronizacja

4 Co to jest synchronizacja? synchronos stgr. równoczesny koordynacja zdarzeń w czasie synchronizacja zegarków aby wskazywały ten sam czas synchronizacja dostępu do danych aby niezależne procesy nie operowały jednocześnie na tym samych danych Mateusz Hołenko Klasyczne problemy synchronizacji [3/23]

8 Cele synchronizacji zapobieganie anomaliom jednoczesnego dostępu utracony zapis odczyt danych pośrednich wyścig w dostępie do zasobów zapewnienie poprawnego przeplotu operacji różnych procesów jednoczesne uruchamianie wielu procesów (np. testy wydajnościowe oprogramowania) Mateusz Hołenko Klasyczne problemy synchronizacji [4/23]

11 Problem producenta / konsumenta

12 Opis problemu magazyn o ograniczonym rozmiarze N bufor cykliczny proces producenta wytwarzającego produkty (P ) wytworzone produkty umieszczane są w magazynie nie można umieszczać w pełnym magazynie proces konsumenta wykorzystującego produkty (C) produkty pobierane są z magazynu nie można pobierać z pustego magazynu Mateusz Hołenko Klasyczne problemy synchronizacji [6/23]

15 Model const int N; Product buffer[n]; Semaphore empty = 0; Semaphore full = N; int next2read = 0; int next2write = 0; N rozmiar bufora (magazynu) buffer bufor cykliczny empty semafor full semafor next2read następna komórka bufora do odczytu next2write następna komórka bufora do zapisu Mateusz Hołenko Klasyczne problemy synchronizacji [7/23]

16 Model const int N; Product buffer[n]; Semaphore empty = 0; Semaphore full = N; int next2read = 0; int next2write = 0; N rozmiar bufora (magazynu) buffer bufor cykliczny empty semafor full semafor next2read następna komórka bufora do odczytu next2write następna komórka bufora do zapisu Mateusz Hołenko Klasyczne problemy synchronizacji [7/23]

17 Producent while(true) { Product elem = CreateProduct(); P(empty); buffer[next2write] = elem; next2write = (next2write + 1) % N; V(full); } Producent tworzy produkt (potencjalnie długotrwała operacja, więc nie powinna być wykonywana w sekcji krytycznej), następnie opuszcza semafor empty. Sygnalizuje on tym samym zmniejszenie ilości dostępnych wolnych miejsc w magazynie o 1. Następnie umieszcza nowoutworzony produkt w magazynie i przesuwa wskaźnik wolnego miejsca na kolejne pole. W końcu podnosi semafor full dając znak konsumentowi, że w magazynie dostępny jest nowy produkt do pobrania. Mateusz Hołenko Klasyczne problemy synchronizacji [8/23]

18 Producent while(true) { Product elem = CreateProduct(); P(empty); buffer[next2write] = elem; next2write = (next2write + 1) % N; V(full); } Producent tworzy produkt (potencjalnie długotrwała operacja, więc nie powinna być wykonywana w sekcji krytycznej), następnie opuszcza semafor empty. Sygnalizuje on tym samym zmniejszenie ilości dostępnych wolnych miejsc w magazynie o 1. Następnie umieszcza nowoutworzony produkt w magazynie i przesuwa wskaźnik wolnego miejsca na kolejne pole. W końcu podnosi semafor full dając znak konsumentowi, że w magazynie dostępny jest nowy produkt do pobrania. Mateusz Hołenko Klasyczne problemy synchronizacji [8/23]

19 Konsument while(true) { P(full); Product elem = buffer[next2read]; next2read = (next2read + 1) % N; V(empty); Consume(elem); } Konsument opuszcza semafor full, sygnalizując producentowi zmniejszenie ilości produktów w magazynie o 1. Następnie pobiera produkt oraz przesuwa wskaźnik na kolejne pole. Podnosi semafor empty dając znak konsumentowi, że w magazynie dostępny jest nowe puste miejsce na produkt. W końcu wykorzystuje produkt (poza sekcją krytyczną). Mateusz Hołenko Klasyczne problemy synchronizacji [9/23]

20 Konsument while(true) { P(full); Product elem = buffer[next2read]; next2read = (next2read + 1) % N; V(empty); Consume(elem); } Konsument opuszcza semafor full, sygnalizując producentowi zmniejszenie ilości produktów w magazynie o 1. Następnie pobiera produkt oraz przesuwa wskaźnik na kolejne pole. Podnosi semafor empty dając znak konsumentowi, że w magazynie dostępny jest nowe puste miejsce na produkt. W końcu wykorzystuje produkt (poza sekcją krytyczną). Mateusz Hołenko Klasyczne problemy synchronizacji [9/23]

21 Problem wielu producentów / konsumentów Jak sądzisz? Czy zaproponowane rozwiązanie skaluje się dla wielu producentów / konsumentów? Mateusz Hołenko Klasyczne problemy synchronizacji [10/23]

22 Problem wielu producentów / konsumentów Zaproponowane wcześniej rozwiązanie synchronizuje dostęp dwóch klas procesów: produkującego, konsumującego. Brak jednak synchronizacji między procesami należącymi do tej samej klasy! Jak sądzisz? Co należy zrobić aby rozwiązać problem wielu producentów / konsumentów? Mateusz Hołenko Klasyczne problemy synchronizacji [11/23]

23 Problem wielu producentów / konsumentów Należy wprowadzić dodatkową synchronizację! Mutex s = 1; while(true) { Product elem = CreateProduct(); P(empty); P(s); buffer[next2write] = elem; next2write = (next2write + 1) % N; V(s); V(full); } while(true) { P(full); P(s); Product elem = buffer[next2read]; next2read = (next2read + 1) % N; V(s); V(empty); Consume(elem); } Mateusz Hołenko Klasyczne problemy synchronizacji [12/23]

24 Problem pięciu filozofów

25 Opis problemu filozofowie mają proste życie myślą i jedzą żywią się makaronem z miski jedzą za pomocą dwóch widelców filozofowie ze sobą nie rozmawiają Mateusz Hołenko Klasyczne problemy synchronizacji [14/23]

29 Ilustracja problemu Mateusz Hołenko Klasyczne problemy synchronizacji [15/23]

30 Rozwiązanie I const int N; Mutex fork[n] = {1}; while(true) { think(); P(fork[i]); P(fork[(i + 1) % N]); eat(); V(fork[i]); V(fork[(i + 1) % N]); } N liczba filozofów fork tablica widelców (semaforów) Mateusz Hołenko Klasyczne problemy synchronizacji [16/23]

31 Rozwiązanie I const int N; Mutex fork[n] = {1}; while(true) { think(); P(fork[i]); P(fork[(i + 1) % N]); eat(); V(fork[i]); V(fork[(i + 1) % N]); } N liczba filozofów fork tablica widelców (semaforów) Mateusz Hołenko Klasyczne problemy synchronizacji [16/23]

32 Rozwiązanie II const int N; Mutex fork[n] = {1}; Semaphore waiter = N - 1; while(true) { think(); P(waiter); P(fork[i]); P(fork[(i + 1) % N]); eat(); V(fork[i]); V(fork[(i + 1) % N]); V(waiter); } N liczba filozofów fork tablica widelców (semaforów) waiter kelner podający widelce (semafor) Mateusz Hołenko Klasyczne problemy synchronizacji [17/23]

33 Rozwiązanie II const int N; Mutex fork[n] = {1}; Semaphore waiter = N - 1; while(true) { think(); P(waiter); P(fork[i]); P(fork[(i + 1) % N]); eat(); V(fork[i]); V(fork[(i + 1) % N]); V(waiter); } N liczba filozofów fork tablica widelców (semaforów) waiter kelner podający widelce (semafor) Mateusz Hołenko Klasyczne problemy synchronizacji [17/23]

34 Rozwiązanie III Rozwiązanie zaproponowane przez Dijkstrę: widelce identyfikowane są za pomocą numerów od 1 do N każdy filozof podnosi wpierw widelec o niższym identyfikatorze, dopiero potem o wyższym sztućce odkładane są w odwrotnej kolejności filozofowie od 1 do 4 biorą najpierw lewy widelec, potem prawy filozof 5 najpierw bierze prawy widelec, potem lewy Mateusz Hołenko Klasyczne problemy synchronizacji [18/23]

35 Problem czytelników i pisarzy

36 Opis problemu biblioteka jako miejsce pracy twórczej pisarzy oraz spotkań czytelników pisarzy jest wielu, jednak każdy z nich tworzy książki tylko w pustej bibliotece czytelnikom nie przeszkadza jednak obecność innych czytelników Mateusz Hołenko Klasyczne problemy synchronizacji [20/23]

40 Model const int N; const int M; Mutex library = 1; Mutex aux = 1; int readers = 0; N liczba czytelników M liczba pisarzy library semafor biblioteki aux semafor aktualnej liczby czytelników readers aktualna liczba czytelników w bibliotece Mateusz Hołenko Klasyczne problemy synchronizacji [21/23]

41 Model const int N; const int M; Mutex library = 1; Mutex aux = 1; int readers = 0; N liczba czytelników M liczba pisarzy library semafor biblioteki aux semafor aktualnej liczby czytelników readers aktualna liczba czytelników w bibliotece Mateusz Hołenko Klasyczne problemy synchronizacji [21/23]

42 Proces pisarza while(true) { P(library); write(); V(library); } Przed przystąpieniem do tworzenia pisarz musi upewnić się, że jest sam w bibliotece. W tym celu opuszcza semafor binarny library. Mateusz Hołenko Klasyczne problemy synchronizacji [22/23]

43 Proces pisarza while(true) { P(library); write(); V(library); } Przed przystąpieniem do tworzenia pisarz musi upewnić się, że jest sam w bibliotece. W tym celu opuszcza semafor binarny library. Mateusz Hołenko Klasyczne problemy synchronizacji [22/23]

44 Proces czytelnika while(true) { P(aux); readers++; if (readers == 1) P(library); V(aux) read(); P(aux); readers--; if (readers == 0) V(library); V(aux); } Mateusz Hołenko Klasyczne problemy synchronizacji [23/23]