Silberschatz and Galvin 1999 6.1 Operating System Concepts Unidade 6: Sincronização de Processos Contexto O problema da seção crítica Hardware para sincronização.

Apresentação em tema: "Silberschatz and Galvin 1999 6.1 Operating System Concepts Unidade 6: Sincronização de Processos Contexto O problema da seção crítica Hardware para sincronização."— Transcrição da apresentação:

1 Silberschatz and Galvin 1999 6.1 Operating System Concepts Unidade 6: Sincronização de Processos Contexto O problema da seção crítica Hardware para sincronização Semáforos Problemas clássicos de sincronização Regiões críticas Monitores Sincronização no Solaris 2 Transação atômica

2 Silberschatz and Galvin 1999 6.2 Operating System Concepts Contexto Acesso concorrente a dados compartilhados pode levar a inconsistências. Para manter a consistência de dados necessitam-se de mecanismos que garantem a execução de processos cooperativos na ordem certa. A solução do problema do buffer limitado (capítulo 4) permite que tenha no máximo n – 1 itens no buffer no mesmo tempo. Uma solução que usa todos os buffers não é simples. –Suponhamos que modificamos o código de produtor e consumidor colocando uma variável counter, inicializada em 0 e incrementada a cada vez que um item novo é colocado no buffer

3 Silberschatz and Galvin 1999 6.3 Operating System Concepts Bounded-Buffer Shared data type item = … ; var buffer array [0..n-1] of item; in, out: 0..n-1; counter: 0..n; in, out, counter := 0; Producer process repeat … produce an item in nextp … while counter = n do no-op; buffer [in] := nextp; in := in + 1 mod n; counter := counter +1; until false;

4 Silberschatz and Galvin 1999 6.4 Operating System Concepts Bounded-Buffer (Cont.) Consumer process repeat while counter = 0 do no-op; nextc := buffer [out]; out := out + 1 mod n; counter := counter – 1; … consume the item in nextc … until false; As linhas de código: –counter := counter + 1; –counter := counter - 1; devem ser executados atomicamente.

5 Silberschatz and Galvin 1999 6.5 Operating System Concepts O problema da seção crítica n processos concorrem para usar algum dado compartilhado Cada processo tem um trecho de código chamado seção crítica no qual os dados compartilhados estão sendo acessados. O problema: ter certeza que enquanto um processo está executando dentro da sua seção crítica, nenhum outro processo é permitido de executar na sua seção crítica. Estrutura de processo P i repeat seção de entrada seção crítica seção de saída seção restante until false;

6 Silberschatz and Galvin 1999 6.6 Operating System Concepts Solução do problema da seção crítica 1.Exclusão mútua. Se processo P i está executando dentro da sua seção crítica, nenhum outro processo pode executar na sua seção crítica. 2. Progresso. Se nenhum processo está executando na sua seção crítica e existe alguns processos que desejam entrar nas suas respetivas seções críticas, então a seleção do processo que vai entrar na seção crítica não pode ser adiada por causa de um processo que está na sua seção restante. 3. Espera limitada. Deve existir um limite para o número de vezes que outros processos são permitidos de entrar nas suas seções críticas depois que um processo tenha feito uma solicitação para entrar a seção crítica dele e antes que esta solicitação tenha sido atendida. Suponha que todo processo executa na seção crítica em velocidade não-zero. Não faça nenhuma suposição sobre a velocidade relativa dos n processos.

7 Silberschatz and Galvin 1999 6.7 Operating System Concepts Somente dois processos, P 0 e P 1 Estrutura geral do processo P i (outro processo é P j ) repeat seção de entrada seção crítica seção de saída seção restante until false; Processos são permitidos de compartilhar alguns variáveis para poder sincronizar suas ações. Initial Attempts to Solve Problem

8 Silberschatz and Galvin 1999 6.8 Operating System Concepts Variáveis compartilhadas: –var turn: (0..1); inicialmente turn = 0 –turn - i P i pode entrar dentro da sua seção crítica Processo P i repeat while turn i do no-op; seção crítica turn := j; seção restante until false; Satisfaz exclusão mútua, mas não o progresso: Processo P i não pode executar duas vezes em seguida a seção critica sem que P j tenha executado uma vez a seção crítica dele Algoritmo 1

9 Silberschatz and Galvin 1999 6.9 Operating System Concepts Algoritmo 2 Variáveis compartilhadas –var flag: array [0..1] of boolean; inicialmente flag [0] = flag [1] = false. –flag [i] = true P i pode entrar dentro da sua seção crítica Process P i repeat flag[i] := true; while flag[j] do no-op; seção crítica flag [i] := false; seção restante until false; Satisfaz exclusão mutua, mas não a condição de progresso.

10 Silberschatz and Galvin 1999 6.10 Operating System Concepts Algoritmo 3 Combinação das variáveis compartilhadas de algoritmo 1 e 2. Processo P i repeat flag [i] := true; turn := j; while (flag [j] and turn = j) do no-op; seção crítica flag [i] := false; seção restante until false; preenche todas as condições e resolve o problema da seção crítica para dois processos.

11 Silberschatz and Galvin 1999 6.11 Operating System Concepts Algoritmo do Banco Antes de entrara na sua seção crítica o processos recebe um número (ficha). Quem está com número menor entra na seção crítica. Se procesos P i e P j recebem o mesmo número, se i < j, então P i é servido primeiro; senão P j é servido primeiro. O esquema de enumeração sempre gera números em ordem crescente, ou seja, 1,2,3,3,3,3,4,5... Seção crítica para n processos

12 Silberschatz and Galvin 1999 6.12 Operating System Concepts Algoritmo do Banco (Cont.) Notação < significa ordem numérica da seqüência (ficha #, processo #) –(a,b) < (c,d) if a < c or if a = c and b < d –max (a 0,…, a n-1 ) é um elemento k, tal que k a i for i = 0, …, n – 1 Dados compartilhados var choosing: array [0..n – 1] of boolean; number: array [0..n – 1] of integer, inicializados para false e 0 respectivamente

13 Silberschatz and Galvin 1999 6.13 Operating System Concepts Algoritmo de Banco(Cont.) repeat choosing[i] := true; number[i] := max(number[0], number[1], …, number [n – 1])+1; choosing[i] := false; for j := 0 to n – 1 do begin while choosing[j] do no-op; while number[j] 0 and (number[j],j) < (number[i], i) do no-op; end; seção crítica number[i] := 0; seção restante until false;

14 Silberschatz and Galvin 1999 6.14 Operating System Concepts Hardware de Sincronização Testa e modifica o conteúdo de uma palavra atomicamente function Test-and-Set (var target: boolean): boolean; begin Test-and-Set := target; target := true; end;

15 Silberschatz and Galvin 1999 6.15 Operating System Concepts Exclusão mútua com Test-and-Set Dado compartilhado: var lock: boolean (initially false) Processo P i repeat while Test-and-Set (lock) do no-op; seção crítica lock := false; seção restante until false;

16 Silberschatz and Galvin 1999 6.16 Operating System Concepts Semáforo Um mecanismo de sincronização que nao implica em espera ocupada (busy waiting). Semáforo S – variável inteira pode ser acessado somente através de duas operações indivisíveis (atômicas) wait (S): while S 0 do no-op; S := S – 1; signal (S): S := S + 1;

17 Silberschatz and Galvin 1999 6.17 Operating System Concepts Exemplo: Seção crítica de n processos Variáveis compartilhadas –var mutex : semaphore –inicialmente mutex = 1 Processo P i repeat wait(mutex); seção crítica signal(mutex); seção restante until false;

18 Silberschatz and Galvin 1999 6.18 Operating System Concepts Implementação de semáforo Define um semáforo como estrutura (record) type semaphore = record value: integer L: list of process; end; Suponha duas operações simples: –block suspende o processo que a executa –wakeup(P) recomeça a execução do processo P.

19 Silberschatz and Galvin 1999 6.19 Operating System Concepts Implementação de semáforos (Cont.) Operações em cima de semáforos agora são definidas assim: wait(S):S.value := S.value – 1; if S.value < 0 then begin add this process to S.L; block; end; signal(S): S.value := S.value + 1; if S.value 0 then begin remove a process P from S.L; wakeup(P); end;

20 Silberschatz and Galvin 1999 6.20 Operating System Concepts O semáforo como mecanismo geral de sincronização Execute B in P j only after A executed in P i Use semaphore flag initialized to 0 Code: P i P j Await(flag) signal(flag)B

21 Silberschatz and Galvin 1999 6.21 Operating System Concepts Deadlock and Starvation Deadlock – dois ou mais processos esperam indefinitamente por um evento que pode ser causado somente por um dos processos em espera. S e Q sejam dois semáforos inicializados em 1 P 0 P 1 wait(S);wait(Q); wait(Q);wait(S); signal(S);signal(Q); signal(Q)signal(S); Starvation – bloqueio sem fim. Um processo nunca é removido da fila de semáforo na qual ele fica bloqueado.

22 Silberschatz and Galvin 1999 6.22 Operating System Concepts Dois Tipos de Semáforos Semáforo contábil – valor inteiro que se pode estender até o infinito. Semáforo binário – valor pode ser somente 0 ou 1; mais facil de implementar. É possível implementar semáforo contábil a partir de semáforos binários.

23 Silberschatz and Galvin 1999 6.23 Operating System Concepts Implementando S com semáforos binários Estruturas de dados: varS1: binary-semaphore; S2: binary-semaphore; S3: binary-semaphore; C: integer; Initialização: S1 = S3 = 1 S2 = 0 C = valor inicial do semáforo S

24 Silberschatz and Galvin 1999 6.24 Operating System Concepts Implementando S (Cont.) wait operation wait(S3); wait(S1); C := C – 1; if C < 0 then begin signal(S1); wait(S2); end else signal(S1); signal(S3); signal operation wait(S1); C := C + 1; if C 0 then signal(S2); signal(S1);

25 Silberschatz and Galvin 1999 6.25 Operating System Concepts Problemas clássicos de Sincronização Problema do buffer limitado Problema de Escritores e Leitores Problema dos filósofos jantando

26 Silberschatz and Galvin 1999 6.26 Operating System Concepts Problema do Buffer limitado Dados compartilhados type item = … var buffer = … full, empty, mutex: semaphore; nextp, nextc: item; full :=0; empty := n; mutex :=1;

27 Silberschatz and Galvin 1999 6.27 Operating System Concepts Bounded-Buffer Problem (Cont.) Processo produtor repeat … produza um item em nextp … wait(empty); wait(mutex); … coloque o item em nextp no buffer … signal(mutex); signal(full); until false;

28 Silberschatz and Galvin 1999 6.28 Operating System Concepts Bounded-Buffer Problem (Cont.) Processo consumidor repeat wait(full) wait(mutex); … remove um item do buffer para nextc … signal(mutex); signal(empty); … consume o item em nextc … until false;

29 Silberschatz and Galvin 1999 6.29 Operating System Concepts Readers-Writers Problem Dados compartilhados var mutex, wrt: semaphore (=1); readcount : integer (=0); processo escritor wait(wrt); … escrevendo … signal(wrt);

30 Silberschatz and Galvin 1999 6.30 Operating System Concepts Readers-Writers Problem (Cont.) Process leitor wait(mutex); readcount := readcount +1; if readcount = 1 then wait(wrt); signal(mutex); … reading is performed … wait(mutex); readcount := readcount – 1; if readcount = 0 then signal(wrt); signal(mutex):

31 Silberschatz and Galvin 1999 6.31 Operating System Concepts Problema dos filósofos jantando Dados compartilhados var chopstick: array [0..4] of semaphore; (=1 initially)

32 Silberschatz and Galvin 1999 6.32 Operating System Concepts Dining-Philosophers Problem (Cont.) Filósofo i: repeat wait(chopstick[i]) wait(chopstick[i+1 mod 5]) … come … signal(chopstick[i]); signal(chopstick[i+1 mod 5]); … pensa … until false;

33 Silberschatz and Galvin 1999 6.33 Operating System Concepts Regiões críticas Uma construção de alto nível Uma variável v do tipo T é declarada assim: var v: shared T a variável v é acessado somente dentro de uma construção do tipo region v when B do S na qual B é uma expressão booleana. Enquanto a instrução (o bloco de instruções) S é executado, nenhum outro processo pode acessar a variável v.

34 Silberschatz and Galvin 1999 6.34 Operating System Concepts Regiões críticas (Cont.) Regiões que se referem aos mesmos variáveis excluem uma à outra no tempo. Quando um processo executa uma construção region, a expressão booleana B é avaliada. Se B é verdade, a instrução S é executada. Se é falso, o processo fica bloqueado até que B passa a ser verdade e nenhum outro processo está na região associada com v.

35 Silberschatz and Galvin 1999 6.35 Operating System Concepts Exemplo – Buffer limitado Variáveis compartilhadas: var buffer: shared record pool: array [0..n–1] of item; count,in,out: integer end; Processo produtor region buffer when count < n do begin pool[in] := nextp; in:= in+1 mod n; count := count + 1; end;

36 Silberschatz and Galvin 1999 6.36 Operating System Concepts Exemplo – Buffer limitado (Cont.) Processo consumidor region buffer when count > 0 do begin nextc := pool[out]; out := out+1 mod n; count := count – 1; end;

37 Silberschatz and Galvin 1999 6.37 Operating System Concepts Implementação: region x when B do S Associate with the shared variable x, the following variables: var mutex, first-delay, second-delay: semaphore; first-count, second-count: integer, Mutually exclusive access to the critical section is provided by mutex. If a process cannot enter the critical section because the Boolean expression B is false, it initially waits on the first-delay semaphore; moved to the second-delay semaphore before it is allowed to reevaluate B.

38 Silberschatz and Galvin 1999 6.38 Operating System Concepts Implementation (Cont.) Keep track of the number of processes waiting on first-delay and second-delay, with first-count and second-count respectively. The algorithm assumes a FIFO ordering in the queuing of processes for a semaphore. For an arbitrary queuing discipline, a more complicated implementation is required.

39 Silberschatz and Galvin 1999 6.39 Operating System Concepts wait(mutex); while not B do begin first-count := first-count + 1; if second-count > 0 then signal(second-delay) else signal(mutex); wait(first-delay): first-count := first-count – 1; if first-count > 0 then signal(first-delay) else signal(second-delay); wait(second-delay); second-count := second-count – 1; end; S; if first-count >0 then signal(first-delay); else if second-count >0 then signal(second-delay); else signal(mutex);

40 Silberschatz and Galvin 1999 6.40 Operating System Concepts High-level synchronization construct that allows the safe sharing of an abstract data type among concurrent processes. type monitor-name = monitor variable declarations procedure entry P1 :(…); begin … end; procedure entry P2(…); begin … end; procedure entry Pn (…); begin…end; begin initialization code end Monitors

41 Silberschatz and Galvin 1999 6.41 Operating System Concepts To allow a process to wait within the monitor, a condition variable must be declared, as var x, y: condition Condition variable can only be used with the operations wait and signal. –The operation x.wait; means that the process invoking this opeation is suspended until another process invokes x.signal; –The x.signal operation resumes exactly one suspended process. If no process is suspended, then the signal operation has no effect. Monitors (Cont.)

42 Silberschatz and Galvin 1999 6.42 Operating System Concepts Schematic view of a monitor

43 Silberschatz and Galvin 1999 6.43 Operating System Concepts Monitor with condition variables

44 Silberschatz and Galvin 1999 6.44 Operating System Concepts type dining-philosophers = monitor var state : array [0..4] of :(thinking, hungry, eating); var self : array [0..4] of condition; procedure entry pickup (i: 0..4); begin state[i] := hungry, test (i); if state[i] eating then self[i], wait, end; procedure entry putdown (i: 0..4); begin state[i] := thinking; test (i+4 mod 5); test (i+1 mod 5); end; Dining Philosophers Example

45 Silberschatz and Galvin 1999 6.45 Operating System Concepts procedure test(k: 0..4); begin if state[k+4 mod 5] eating and state[k] = hungry and state[k+1 mod 5] ] eating then begin state[k] := eating; self[k].signal; end; begin for i := 0 to 4 do state[i] := thinking; end. Dining Philosophers (Cont.)

46 Silberschatz and Galvin 1999 6.46 Operating System Concepts Variables var mutex: semaphore (init = 1) next: semaphore (init = 0) next-count: integer (init = 0) Each external procedure F will be replaced by wait(mutex); … body of F; … if next-count > 0 then signal(next) else signal(mutex); Mutual exclusion within a monitor is ensured. Monitor Implementation Using Semaphores

47 Silberschatz and Galvin 1999 6.47 Operating System Concepts For each condition variable x, we have: var x-sem: semaphore (init = 0) x-count: integer (init = 0) The operation x.wait can be implemented as: x-count := x-count + 1; if next-count >0 then signal(next) else signal(mutex); wait(x-sem); x-count := x-count – 1; Monitor Implementation (Cont.)

48 Silberschatz and Galvin 1999 6.48 Operating System Concepts The operation x.signal can be implemented as: if x-count > 0 then begin next-count := next-count + 1; signal(x-sem); wait(next); next-count := next-count – 1; end; Monitor Implementation (Cont.)

49 Silberschatz and Galvin 1999 6.49 Operating System Concepts Conditional-wait construct: x.wait(c); –c – integer expression evaluated when the wait opertion is executed. –value of c (priority number) stored with the name of the process that is suspended. –when x.signal is executed, process with smallest associated priority number is resumed next. Check tow conditions to establish correctness of system: –User processes must always make their calls on the monitor in a correct sequence. –Must ensure that an uncooperative process does not ignore the mutual-exclusion gateway provided by the monitor, and try to access the shared resource directly, without using the access protocols. Monitor Implementation (Cont.)

50 Silberschatz and Galvin 1999 6.50 Operating System Concepts Implements a variety of locks to support multitasking, multithreading (including real-time threads), and multiprocessing. Uses adaptive mutexes for efficiency when protecting data from short code segments. Uses condition variables and readers-writers locks when longer sections of code need access to data. Solaris 2 Operating System