Sistemas Operativos

Sincronização de
processos

Hardware de sincronização

! Muitas máquinas fornecem instruções

especiais de hardware que nos permitem:
– Testar e modificar o conteúdo de uma palavra
– Ou trocar o conteúdo de duas palavras
! Sendo essas instruções realizadas de
forma atómica
! Estas instruções especiais podem ser
usadas para resolver o problema da secção
crítica
2 Luísa Jorge Sistemas Operativos

1
 Instrução Test-and-Set

! Vamos usar C para abstrair os principais conceitos por trás

deste tipo de instruções
! A instrução Test-and-Set pode ser definida da seguinte forma
int Test-and-Set (int *destino)
// NB: toda a operação é executada de forma atómica
{ int aux;
aux= *destino;
*destino= 1;
return aux;
}

3 Luísa Jorge Sistemas Operativos

Utilização de Test-and-Set para

garantir exclusão mútua

! Vamos utilizar uma variável partilhada trinco

inicializada a 0
! Estrutura do processo Pi:
do{
while (Test-and-Set(&trinco)) ;
/*secção crítica*/
trinco=0;
/*secção restante*/
}while (1);

4 Luísa Jorge Sistemas Operativos

2
 Instrução Swap

! A instrução Swap pode ser definida da seguinte

forma
void swap (int *a, int *b)
// NB: toda a operação é executada de forma atómica
{ int aux;
aux= *a;
*a= *b;
*b= aux;
}

5 Luísa Jorge Sistemas Operativos

Utilização de Swap para garantir

exclusão mútua

! Vamos utilizar uma variável partilhada trinco inicializada a 0 e

uma variável chave não partilhada
! Estrutura do processo Pi:
do{
chave=1;
do{
Swap(&trinco,&chave)
}while(chave!=0);
/*secção crítica*/
trinco=0;
/*secção restante*/
}while (1);

6 Luísa Jorge Sistemas Operativos

3
 Utilização de Test-and-Set para garantir
exclusão mútua e espera limitada

! Os algoritmos apresentados anteriormente garantem

a exclusão mútua mas não garantem a espera
limitada
! Apresenta-se a seguir um algoritmo, que usa a
função Test-and-Set, e que satisfaz todos os
requisitos
! Consideremos as variáveis partilhadas:
– espera – array que permite armazenar n itens, inicializados
a0
– trinco inicializada a 0
! E as variáveis não partilhadas chave e j

7 Luísa Jorge Sistemas Operativos

Exclusão mútua e espera limitada com

Test-and-Set

! Estrutura do processo Pi:

do{
espera[i]= 1;
chave= 1;
while (espera[i]&&chave)
chave= Test_and_Set(&trinco);
espera[i]= 0;
/*secção crítica*/
j= (i+1)%n;
while((j!=i)&&(!espera[j]))
j= (j+1)%n;
if (j==i) trinco= 0;
else espera[j]= 0;
/*secção restante*/
}while (1);

8 Luísa Jorge Sistemas Operativos