video capítulo 7: sincronização de processos. silberschatz, galvin and gagne 2002 3.2 video...

Capítulo 7: Sincronização de

Processos

Silberschatz, Galvin and Gagne 20023.2Operating System Concepts

Assuntos

Cenário O problema da secção crítica Hardware de sincronização Semáfaro Problemas clássicos de sincronização Regiões críticas Monitores

Cenário

Acesso concorrente a dadosInconsistência

Manutenção da consistênciaMecanismos para ordenar execução de

processos concorrentes Exemplo: produtor/consumidor

Usando todo o bufferAdiciona-se uma variável “counter” que

dá o número de elementos no buffer

Armazenamento Limitado

Dados compartilhados:#define BUFFER_SIZE 10typedef struct {. . .

} item;item buffer[BUFFER_SIZE];int in = 0;int out = 0;int counter = 0;

Processo Produtor:item nextProduced;

while (1) {while (counter == BUFFER_SIZE); /* do nothing */buffer[in] = nextProduced;in = (in + 1) % BUFFER_SIZE;counter++;}

Processo Consumidor:item nextConsumed;

while (1) {while (counter == 0); /* do nothing */nextConsumed = buffer[out];out = (out + 1) % BUFFER_SIZE;counter--;}

As seguintes operações tem de ser atômicascounter++;counter--;

Uma operação é atômica se ela é executada inteiramente sem ser interrompida

Em linguagem de máquina, as operações são implementadas da seguinte forma

counter--;

reg2 = counterreg2 = reg2 – 1counter = reg2

counter++;

reg1 = counterreg1 = reg1 + 1counter = reg1

Se ambos produtor e consumidor acessarem o contador simulaneamente, as instruções em linguagem de máquina podem se misturar

A ordem da mistura depende do escalonamento dos processos produtor e consumidor

Assuma que counter = 5Counter pode ser 4 ou 6Valor correto: 5

produtor: reg1 = counter (reg1 = 5)produtor: reg1 = reg1 +1 (reg1 = 6)consumidor:reg2 = counter (reg2 = 5)consumidor:reg2 = reg2 –1 (reg2 = 4)produtor: counter = reg1 (counter = 6)consumidor:counter = reg2 (counter = 4)

Condições de Corrida

Resultado da operação depende da ordem de execução dos processos

Pare prevení-las, processos concorrentes tem de ser sincronizados

O Problema da Secção Crítica

Processos competindo pelo uso dos mesmos dados

Em cada processo uma parte do código faz o acesso aos dados compartilhadosSecção crítica

Problema:Apenas um processo pode executar sua

secção crítica por vez

Características da Solução

Exclusão mútua Progresso Espera limitada

Exclusão Mútua

Se um processo está executando sua secção crítica, nenhum outro pode estar também dentro de sua secção crítica (mesmo se nas filas de espera ou prontos)

Progresso

Se não há nenhum processo na secção crítica, um processo que deseje entrar em sua secção crítica não pode esperar indefinidamente

Espera Limitada

Se um processo pediu para entrar em sua secção crítica, existe um limite do número de vezes que outros processos entrem em sua (própria) região crítica antes que este consiga fazê-lo

Tentando Resolver...

Dois processos P0 e P1 Estrutura dos processosdo {entry sectioncritical sectionexit sectionreminder section} while (1);

Processos compartilham variáveis para sincronização

Algoritmo 1 Variáveis compartilhadas

int turn;inicialmente turn = 0

turn - i Pi entra na secção crítica Processo Pi

do {while (turn != i) ;critical sectionturn = j;reminder section} while (1);

Satisfaz exclusão mútua, mas não progresso

Algoritmo 2

Variáveis compartilhadasboolean flag[2];

inicialmente flag [0] = flag [1] = false.

flag [i] = true Pi pronto para entrar na região crítica

Algoritmo 2

Processo Pi

do {flag[i] := true;while (flag[j]) ;critical sectionflag [i] = false;remainder section} while (1);

Satisfaz exclusão mútua, mas não progresso

Algorítmo 3

Combinação de 1 e 2 Processo Pido {flag [i]:= true;turn = j;while (flag [j] and turn = j) ;critical sectionflag [i] = false;remainder section} while (1);

Algorítmo da Padaria

Cada processo recebe um número

O menor número dá acesso à secção crítica

Variáveis compartilhadas

boolean choosing[n];int number[n];

Algorítmo da Padaria

do { choosing[i] = true;number[i] = max(number[0],number[1], …, number [n – 1])+1;choosing[i] = false;for (j = 0; j < n; j++) {

while (choosing[j]) ; while ((number[j] != 0) && (number[j,j] <

number[i,i])) ;}

critical sectionnumber[i] = 0;

remainder section} while (1);

Hardware de Sincronização

Testar e modificar atômico

boolean TestAndSet(boolean &target) {boolean rv = target;tqrget = true;

return rv;}

Exclusão mútua com TestAndSet

Variáveis compartilhadasboolean lock = false;

Processo Pi

do {while (TestAndSet(lock)) ;critical sectionlock = false;remainder section}

Hardware de Sincronização

Troca atômica de duas variáveis

void Swap(boolean &a, boolean &b) {boolean temp = a;a = b;b = temp;}

Exclusão mútua com SWAP Variáveis compartilhadasboolean lock;boolean waiting[n];

Processo Pi

do {key = true;while (key == true) Swap(lock,key);critical sectionlock = false;remainder section}

Construções para Sincronização

Semáfaros Regiões Críticas Monitores

Semáfaros

Não requer busy-waiting Semáfaro S é uma variável inteira Duas operações atômicas wait (S):

while S 0 do no-op;S--;

signal (S): S++;

Usando Semáfaros Para Região Crítica de Vários

Processos Variáveis compartilhadassemaphore mutex; //mutex = 1

Processo Pi:

do { wait(mutex); critical section

signal(mutex); remainder section} while (1);

Deadlock & Starvation

Deadlock – dois ou mais processos esperam indefinidamente por um evento que seria gerado por um deles

Starvation – bloqueio indefinido de um processo por outros

Problemas Clássicos

Produtor-Consumidor com área limitada

Escritor-Leitor Filósofos “Jantantes”

Todos podem ser resolvidos por qualquer um dos métodos de sincronia

Região Crítica

Variáveis compartilhadasv: shared T Variável acessível dentro da

expressãoregion v when B do S Enquanto S está sendo executado,

nenhum outro processo pode acessar a variável v

Região Crítica

Regiões com a mesma variável são excludentes no tempo

Ao executar o “region”, se a variável B é falsa o processo espera até que seja verdadeiro Nenhum outro processo está dentro da

região crítica

Monitores

Permitem o compartilhamento seguro de tipos abstratos

monitor monitor-name{shared variable declarationsprocedure body P1 (…) {. . .}procedure body P2 (…) {. . .} procedure body Pn (…) { . . .} {initialization code}}

Monitores

São definidas variáveis de condição

condition x, y; Estas só podem ser usadas nas

operações wait e signal

Visão Esquemática de um Monitor

video capítulo 7: sincronização de processos. silberschatz, galvin and gagne 2002 3.2 video...

Documents

clipping assuntos de interesse sistema fieam 27 10

clipping assuntos de interesse sistema fieam 02 02

clipping assuntos de interesse sistema fieam 10 09

instalando o cliente de sincronização do onedrive for

clipping assuntos de interesse sistema fieam 12 03

clipping assuntos de interesse sistema fieam 28 03

clipping assuntos de interesse sistema fieam 14 08

clipping assuntos de interesse sistema fieam 01 02

clipping assuntos de interesse sistema fieam 04 02

clipping assuntos de interesse sistema fieam 04 10

cobertura noticiosa, assessoria mediática e assuntos

clipping assuntos de interesse sistema fieam 11 01

clipping assuntos de interesse sistema fieam 23 01

clipping assuntos de interesse sistema fieam 16 02

clipping assuntos de interesse sistema fieam 11 03

modulo i - sincronização programação concorrente ·...

clipping assuntos de interesse sistema fieam 03 05

clipping assuntos de interesse sistema fieam 19 01

clipping assuntos de interesse sistema fieam 02 04

clipping assuntos de interesse sistema fieam 22 08