Você está na página 1de 7

– Por que os Algorítmos de espera ocupada são, grande parte das vezes, ineficientes? RESPOSTA: Os algorítmos de espera ocupada são ineficientes por que eles tomam a CPU para fazer verificações de sua variável.

1

2 – Os semáforos são implementados para garantir quais propriedades necessárias? RESPOSTA: Os semáforos, quando implementados, garantem EXCLUSÃO MÚTUA e SINCRONIZAÇÃO CONDICIONAL.

3 – Como funciona o semáforo e como é implementado ?

RESPOSTA: O semáforo é uma variável compartilhada por todos os processos, acessível a

todos eles, composta por duas instruções atômicas P(s) e V(s).

P(s)

V(s)

→ < await (s > 0) →

<

s

=

s +

1 >

s =

s

– 1; >

4 – Quais são os tipos de semáforo e explique cada um.

RESPOSTA: | 1 – Semáforo Genérico | 2 – Semáforo Binário | → Esses são os dois tipos de

semáforos, o primeiro contém qualquer variável NÃO NULA e o segundo pode conter apenas Zeros (0) e Uns (1).

5 – Implemente EXCLUSÃO MÚTUA com locks e com semáforos. RESPOSTA:

COM LOCK 1. bool lock false;

2.

process_1 {

3.

while(true){

4.

<await (!lock) lock = true;>

5.

seção crítica;

6.

lock = false;

7.

}

8.

}

9.

process_2 {

10.

while(true){

11.

<await(!lock) lock = true;>

12.

seção crítica

13.

lock = false;

14.

}

15.

}

COM SEMÁFORO

1. sem mutex = 1;

2.

process [i=1 to M]{

3.

while(true){

4.

P(mutex);

5.

seção crítica;

6.

V(mutex);

7.

}

8.

}

– Implemente a sinalização de eventos com semáforos RESPOSTA:

6

1. sem arrive_1 = 0, arrive_2 = 0;

2.

process worker_1 {

3.

while(true){

4.

V(arrive_1);

5.

P(arrive_2);

6.

}

7.

}

8.

process worker_2 {

9.

while (true){

10.

V(arrive_2);

11.

P(arrive_1);

12.

}

13.

}

7 – Como se dá a comunicação no PRODUTOR – CONSUMIDOR

RESPOSTA: Dá-se por DEPOSIT E FETCH sendo obrigatoriamente alternada, pois mensagens não podem ser sobrescritas ou lidas por mais de uma vez.

8 – Implemente, com semáforos, o PRODUTOR – CONSUMIDOR RESPOSTA:

1. typeT buf; sem empty = 1, full = 0;

2.

process Produtor [i = 0 to M]{

3.

while(true){

4.

P(empty);

5.

buf = data;

6.

V(full);

7.

}

8.

}

9.

process Consumidor [i = 0 to N]{

10.

while(true){

11.

P(full);

12.

result = buf;

13.

V(empty);

14.

}

15.

}

9 – O que são SEMÁFOROS BINÁRIOS DIVIDIDOS?

RESPOSTA: Um semáforo binário dividido são semáforos FULL E EMPTY dividos em

dois, porém utilizados como um só e NO MÁXIMO TEM O VALOR 1 POR VEZ

10 – Qual a vantagem, para o PRODUTOR – CONSUMIDOR, de se trabalhar com

rajada? RESPOSTA: Ao trabalhar com Rajada o nosso programa terá a performance aumentada

11 – Um Buffer pode ser representado por

RESPOSTA: Um Array ou qualquer estrutura de dados

12 – Como funciona o Buffer do DEPOSIT E FETCH RESPOSTA:

buf[rear] = data; rear = (rear + 1) % n; result = buf[front]; front = (front + 1) % n;

buffer:

←PRODUTOR(deposit)

←CONSUMIDOR(fetch)

rear front
rear front

rear

rear front
rear front
rear front
rear front
front
front
rear front
rear front

13 – Qual é a solução, com semáforos, para Buffers limitados?

RESPOSTA:

1. typeT buf[n]

2.

sem empty = n, full = 0;

3.

int front = 0, rear = 0;

4.

process Producer {

5.

while(true){

6.

P(empty);

7.

buf[rear] = data; rear = (rear + 1) % n;

8.

V(full);

9.

}

10.

}

11.

process Consumer {

12.

while(true){

13.

P(full);

14.

result = buf[front];

15.

front = (front + 1) % n;

16.

V(empty);

17.

}

18.

}

14 – Semáforos que funcionam como contadores de recursos ( semáforos contadores)

são uteis quando ? RESPOSTA: São úteis quando vários processos competem por múltiplas utilidades de um único recurso.

15 – Como são implementados os buffers limitados para vários processos?

RESPOSTA:

1. typeT buf[n]

2.

sem empty = n, full = 0;

3.

sem mutex_A = 1, mutex_B = 1;

4.

int front = 0, rear = 0;

5.

process Producer [i=0 to M]{

6.

while(true){

7.

P(empty);

8.

P(mutex_A);

9.

buf[rear] = data; rear = (rear + 1) %

n;

10.

V(mutex_A);

11.

V(full);

12.

}

13.

}

14.

process Consumer [i=0 to N] {

15.

while(true){

16.

P(full);

17.

P(mutex_B);

18.

result = buf[front];

19.

front = (front + 1) % n;

20.

V(mutex_B);

21.

V(empty);

22.

}

23.

}

16 – Como se dá a Solução para o JANTAR DOS FILÓSOFOS

RESPOSTA:

1. sem fork[5] = {1,1,1,1,1}

2.

process Philosopher [i=0 to 3] {

3.

while(true){

4.

P(fork[i]); P(fork[i+1]);

5.

eat;

6.

V(fork[i]); V(fork[i+1]);

7.

think;

8.

}

9.

}

10.

process Philosopher [4] {

11.

while(true){

12.

P(fork[0]); P(fork[4]);

13.

eat;

14.

V(fork[0]); V(fork[4]);

15.

think

16.

}

17.

}

17 – Quais são as duas abordagens para o problema dos Leitores e Escritores?

RESPOSTA: Pode ser usada uma abordagem que trabalha com EXCLUSÃO MÚTUA como também pode ser usada a abordagem de SINCRONIZAÇÃO CONDICIONAL através do uso da tecnica de PASSAGEM DE BASTÃO.

18 – Como resolver o problema dos Leitores e Escritores com uso de EXCLUSÃO

MÚTUA, e quais são os PROS e CONTRAS?

RESPOSTA:

1. var = 0;

2.

sem mutex_A = 1;

3.

sem rw = 1;

4.

process Reader [i = 0 to M]{

5.

while(true){

6.

P(mutex_A);

7.

var = var + 1;

8.

if(var == 1) P(rw);

9.

V(mutex_A);

10.

Escreve na Base de Dados;

11.

P(mutex_A);

12.

var = var -1;

13.

if (var == 0) V(rw);

14.

V(mutex_A);

15.

}

16.

}

17.

process Writer [i = 0 to N]{

18.

while(true){

19.

P(rw);

20.

Lê da Base de Dados;

21.

V(rw);

22.

}

23.

}

- Essa solução dá prioridade aos leitores em detrimento aos escritores.

- Um fluxo contínuo de leitores pode levar a impossibilidade de um escritor acessar a base de dados

- A solução é NÃO JUSTA

19 – Qual vantagem temos ao usar a solução por SINCRONIZAÇÃO CONDICIONAL RESPOSTA: Podemos, com a solução por sincronização condicional garantir que os processos escritores NÃO entrem em estado de STARVATION utilizando registradores através de contadores, esses registram a quantidade de leitores e escritores acessando a base de dados

20 – A tecnica da passagem de bastão é parte essencial na SINCRONIZAÇÃO

CONDICIONAL, portanto, qual a justificativa para usa-lo? RESPOSTA: A técnica da Passagem de Bastão surge para podermos implementar comandos <await> através de semáforos, pois a implementação por semáforos diretamente é IMPOSSIVEL.

21 – Descreva o algorítmo da passagem de Bastão

RESPOSTA:

1º PASSO: Substitua o “<” por “P(e);” que agora controlará o acesso nos protocolos de entrada 2º PASSO: Verifica as condições para um processo dormir através do uso de “ifs” e implementando os passos para chegar a tal finalidade 3º PASSO: Implementamos os incrementos para os processos que não satisfazem as condições para dormir 4º PASSO: Liberar um dos processos vinculados a um dos semáforos utilizados (PASSAR O BASTÃO)

22 – Implemente o algorítmo da passagem de Bastão

RESPOSTA:

1. int nr = 0, nw = 0; // RW: (nr == 0
2. // e nw <= 1

3. sem e = 1, r = 0, w = 0;

4. int dr = 0, dw = 0;

5. //atrasados (dw) e leitores atrasados (dr)

ou nw == 0)

// Numero de escritores

6.

process Leitor [i = 0 to M] {

 

7.

while(true) {

 

8.

// <await (nw == 0)

nr = nr + 1; >

9.

P(e);

 

10.

if ( nw > 0)

 

11.

{dr = dr + 1; V(e); P(r); }

12.

nr = nr + 1;

 

13.

// SIGNAL;

14.

if (dr > 0) { dr = dr – 1/ V(r);}

15.

else V(e);

 

16.

read the database; //SC

17.

//

< nr = nr – 1; >

18.

P(e);

 

19.

nr = nr – 1;

 

20.

// SIGNAL;

21.

if (nr = = 0 and dw > 0)

22.

{ dw = dw – 1; V(w); }

23.

else V(e);

 

24.

}

25.

}

26.

process Escritor [i = 0 to N] {

27.

while(true){

 

28.

// < await (nr == 0 and nw == 0)

29.

// nw = nw + 1;

 

30.

P(e);

 

31.

if

(

nr > 0 e nw

> 0)

32.

{ dw = dw +1; V(e); P(w); }

33.

nw = nw + 1

 

34.

// SIGNAL;

35.

V(e);

 

36.

write the database; //SC

37.

//SIGNAL;

 

38.

P(e);

 

39.

nw = nw +1;

 

40.

if (dr > 0) { dr = dr – 1; v(r);}

41.

else if ( dw > 0)

 

42.

{dw = dw – 1; V(w); }

43.

else V(e);

 

44.

}

}

23 – Implemente o SIGNAL

RESPOSTA:

1.

if (nw == 0 e

dr

>

0

)

{

2. // ACORDA LEITOR

3. } else if (nr == 0 and nw == 0 and dw > 0 ) {

4. // ACORDA ESCRITOR

5. dw = dw – 1; V(w);

6. } else {

7. // LIBERA LOCK DE ENTRADA

8. V(e);

9. }