Trabalho Final SO - fala de semaforos em sistemas operativos

Indice

1. Lista de abreviaturas.......................................................................................................3

1 Indice............................................................................................................................. 1

1.1 Lista de ﬁguras............................................................................................................... 3

2 Lista de Algoritmos......................................................................................................... 3

2.1 Vocabulário.................................................................................................................... 4

2.2 .......................................................................................................................................

2.3 CAPITULO....................................................................................................................... 6

2.4 Agradecimento .............................................................................................................. 6

2.5 Introdução...................................................................................................................... 6

2.6 Resumo.......................................................................................................................... 8

2.7 CAPITULO....................................................................................................................... 9

2.8 Objec�vos...................................................................................................................... 9

2.9 Objec�vos Gerais:.......................................................................................................... 9

2.10 Objec�vos Especíﬁcos:................................................................................................... 9

2.11 CAPITULO....................................................................................................................... 10

2.12 Semáforos...................................................................................................................... 10

3 Algoritmo 2: Vagas de carros num estacionamento....................................................... 14

3.1 Semáforos como um mecanismo de sincronização geral............................................... 15

3.2 Semáforo Contador ....................................................................................................... 15

3.3 Valor inteiro posi�vo pode variar sem limites................................................................ 15

3.4 Semáforos genéricos ou Semáforo Binário .................................................................... 15

3.5 Algoritmo de codiﬁcação de um mutexes...................................................................... 16

4Algori�mo 5: Decodiﬁcacao de um mutex..................................................................... 17

4.1 Variáveis de condição..................................................................................................... 17

Pré-visualização parcial do texto

Baixe Trabalho Final SO e outras Trabalhos em PDF para Informática, somente na Docsity!

Indice

5 Algoritmo 6: Implementecao Hipote�ca das operações wait, no�fy e broadcast.......... 18 6 Algoritmo 7: Espera sequencial de processos................................................................ 19 6.1 Monitores...................................................................................................................... 20 7 Algoritmo 8: Monitor...................................................................................................... 21 8 Algoritmo 9: Monitor (em Java)..................................................................................... 23 8.1 Deadlock e starva�on..................................................................................................... 24 8.2 Tenta�va de evitar Deadlocks/Impasses........................................................................ 24 9 Figura 2. Gráfico de espera............................................................................................. 26 9.1 CAPITULO....................................................................................................................... 28 9.2 Conclusão....................................................................................................................... 28 9.3 CAPITULO....................................................................................................................... 29 9.4 Referências bibliográficas............................................................................................... 29

1. Lista de abreviaturas

API -

POSIX -

FIFO – First In First Out (Primeiro a entrar, primeiro a sair).

TSL –

3.3 Valor inteiro posi�vo pode variar sem limites................................................................ 15 3.4 Semáforos genéricos ou Semáforo Binário .................................................................... 15 3.5 Algoritmo de codificação de um mutexes...................................................................... 16 4 Algori�mo 5: Decodificacao de um mutex..................................................................... 17 4.1 Variáveis de condição..................................................................................................... 17 5 Algoritmo 6: Implementecao Hipote�ca das operações wait, no�fy e broadcast.......... 18 6 Algoritmo 7: Espera sequencial de processos................................................................ 19 6.1 Monitores...................................................................................................................... 20 7 Algoritmo 8: Monitor...................................................................................................... 21 8 Algoritmo 9: Monitor (em Java)..................................................................................... 23 8.1 Deadlock e starva�on..................................................................................................... 24 8.2 Tenta�va de evitar Deadlocks/Impasses........................................................................ 24 9 Figura 2. Gráfico de espera............................................................................................. 26 9.1 CAPITULO....................................................................................................................... 28 9.2 Conclusão....................................................................................................................... 28 9.3 CAPITULO....................................................................................................................... 29 9.4 Referências bibliográficas............................................................................................... 29

4. Vocabulário

1. Awake – Acordado, Apto.

2. Broadcast

3. Counter – Contador.

4. Deadlock

5. Down- Baixo, Em Baixo, Por

Baixo.

6. End – Fim.

7. Exclusion – Exclusão.

8. If – Se.

9. Livelock

10. Lock – Fechar, Trancar.

11. Mutex

12. Notify – Notificar.

13. Queue – Fila.

14. Semaphore – Semáforo.

15. Starvation – Fome.

16. Synchronized – Sincronizado.

17. Then – Logo, Deles.

18. Try – Tentar.

19. Unlock – Destrancar, Liberar.

20. Up – Cima, Em Cima.

21. Wait – Esperar.

Nota: Alguns termos foram traduzidos directamente e outros por serem de linguagem

técnica, o grupo optou por não fazer uma tradução directa visto que não perece conveniente

ou fazem parecer o termo não se relacionar com o procedimento ou linguagem em estudo.

utilizados criam situações propícias a acidentes. Assim sendo, é necessário verificar primeiro

se o semáforo é realmente necessário para o local em que se é instalado, isso em questões de

transito; mas para o presente trabalho a que apenas destacar o seu funcionamento electrônico

e programático. Os Dedlock e Starvation são geralmente elementos de sincronização de

semáforos, os quais também serão detalhados e especificados no trabalho em estudo.

I.3.. Resumo

Semáforos são dispositivos utilizados com o objectivo de ordenar o tráfego, subdivididos em

dois tipos: Semáforo Contador – valor inteiro positivo pode variar sem limites e Semáforos

genéricos ou Semáforo Binário também conhecido como mutex locks são os semáforos nos

quais o contador inteiro pode assumir qualquer valor e constituem um mecanismo de

coordenação muito poderoso. Ambos possuem seus algoritmos e seus processos de

programação organizados de acordo com suas funcionalidades mas com mesma finalidade

de “ordenar o tráfego”. Os semáforos possuem um sistema de funcionamento usando

mecanismos Deadlock (quando dois ou mais processos ficam esperando indefinidamente por

um evento que pode ser causado apenas por um dos processos bloqueados), Starvation

( quando um segmento pode esperar indefinidamente, porque os outros segmentos continuam

chegando e recebendo os recursos solicitados antes deste segmento ser executado) ou ainda

Livelock ( quando um processo pode nunca terminar a sua execução).

III.CAPITULO

I.5.. Semáforos

Em 1965, o matemático holandês E. Dijkstra propôs um mecanismo de coordenação eficiente

e flexível para o controle da exclusão mútua entre n tarefas: o semáforo [Raynal, 1986].

Apesar de antigo, o semáforo continua sendo o mecanismo de sincronização mais utilizado

na construção de aplicações concorrentes, sendo usado de forma explícita ou implícita (na

construção de mecanismos de coordenação mais abstratos, como os monitores).

Um semáforo pode ser visto como uma variável S, que representa uma seção crítica e cujo

conteúdo não é diretamente acessível ao programador. Internamente, cada semáforo contém

um contador inteiro S:counter e uma fila de tarefas S:queue, inicialmente vazia.

Figura 1: Exemplo de um Semáforo comum.

Down(s): usado para solicitar acesso à seção crítica associada a s. Caso a seção esteja livre, a

operação retorna imediatamente e a tarefa pode continuar sua execução; caso contrário, a

tarefa solicitante é suspensa e adicionada à fila do semáforo; o contador associado ao

semáforo é decrementado3. Dijkstra denominou essa operação P(s) (do holandês probeer, que

significa tentar).

P(s) (Down) - checa o valor do semáforo. Se o valor é maior que 0 (zero), decrementa e

continua. Se for igual a 0, o processo é posto para dormir _ Ação atômica: é garantido que,

uma vez iniciada a operação, nenhum outro processo tem acesso ao semáforo (essencial para

resolver problemas de sincronização e evitar condições de corrida)

1. P(s) equivale a:

2. Se s > 0 então

3. s := s - 1

4. senão

5. bloqueia o processo até s > 0 (= wait(s))

Down(s): // a executar de forma atômica

1. s:counter s:counter + 1

2. if s:counter < 0 then põe a tarefa corrente no final de s:queue suspende a tarefa

corrente

3. end if

Up(s): invocado para liberar a seção crítica associada a s; o contador associado ao semáforo

é incrementado. Caso a fila do semáforo não esteja vazia, a primeira tarefa da fila é acordada,

sai da fila do semáforo e volta à fila de tarefas prontas para retomar sua execução. Essa

operação foi inicialmente denominada V(s) (do holandês verhoog, que significa incrementar).

V(s) (Up) - se um ou mais processos estão dormindo no semáforo, um deles é escolhido

aleatoriamente pelo SO e continua sua operação Down (o valor zero continua). Se não há

ninguém “dormindo” no semáforo, incrementa o valor dele, operação também é indivisível.

V(s) equivale a:

Verifica se existe uma lista com processos bloqueados por causa de s , se existe escolhe um e

o “acorda”, deixando-o pronto para seguir sua execução de P(s) (= signal(s))

1. Senão

3. int saldo ; // saldo atual da conta

4. sem_t s = 1; // semáforo associado à conta, valor inicial 1

5. ... // outras informações da conta

6. } conta_t ;

8. void depositar (conta_t * conta, int valor)

10. down (conta->s) ; // solicita acesso à conta

11. conta->saldo += valor ; // seção crítica

12. up (conta->s) ; // libera o acesso à conta

A suspensão das tarefas que aguardam o acesso à seção crítica elimina a espera ocupada, o

que torna esse mecanismo mais eficiente no uso do processador que os anteriores. A fila de

tarefas associada ao semáforo contém todas as tarefas que foram suspensas ao solicitar acesso

à seção crítica usando a chamada Down(s). Como a fila obedece uma política FIFO, garante-

se a também a justiça no acesso à seção crítica, pois todos os processos que aguardam no

semáforo serão atendidos em sequência. Por sua vez, o valor inteiro associado ao semáforo

funciona como um contador de recursos: caso seja positivo, indica quantas instâncias daquele

recurso estão disponíveis. Caso seja negativo, indica quantas tarefas estão aguardando para

usar aquele recurso.

A listagem a seguir apresenta um exemplo hipotético de uso de um semáforo para controlar

o acesso a um estacionamento. O valor inicial do semáforo vagas representa o número de

vagas inicialmente livres no estacionamento (500). Quando um carro deseja entrar no

estacionamento ele solicita uma vaga; enquanto o semáforo for positivo não haverão

bloqueios, pois há vagas livres. Caso não existam mais vagas livres, a chamada carro_entra()

ficará bloqueada até que alguma vaga seja liberada, o que ocorre quando outro carro acionar

a chamada carro_sai(). Esta solução pode ser aplicada a um estacionamento com várias

entradas e várias saídas simultâneas.

Algumas implementações de semáforos acordam uma tarefa aleatória da fila, não

necessariamente a primeira tarefa. Essas implementações são chamadas de semáforos fracos,

por não garantirem a justiça no acesso à seção crítica nem a ausência de inanição (starvation)

de tarefas.

Algoritmo 2: Vagas de carros num estacionamento

1. sem_t vagas = 500 ;

3. void carro_entra ()

5. down (vagas) ; // solicita uma vaga de estacionamento

6. ... // demais ações específicas da aplicação

9. void carro_sai ()

11. up (vagas) ; // libera uma vaga de estacionamento

12. ... // demais ações específicas da aplicação

A API POSIX define várias chamadas para a criação e manipulação de semáforos.

valores possíveis: livre (1) ou ocupado (0). Esses semáforos simplificados são chamados de

mutexes (uma abreviação de mutual exclusion) ou semáforos binários. Por exemplo, algumas

das funções definidas pelo padrão POSIX [Gallmeister, 1994, Barney, 2005] para criar e usar

mutexes são as chamadas. Chamadas mais frequentemente utilizadas em API POSIX estão

indicadas a seguir:

Algoritmo 4: Mutex Locks e API POSIX.

1. #include <semaphore.h>

3. // inicializa um semáforo apontado por "sem", com valor inicial "value"

4. int sem_init(sem_t *sem, int pshared, unsigned int value);

6. // Operação Up(s)

7. int sem_post(sem_t *sem);

9. // Operação Down(s)

10. int sem_wait(sem_t *sem);

11. // Operação TryDown(s), retorna erro se o semáforo estiver ocupado

12. int sem_trywait(sem_t *sem);

Algoritmo de codificação de um mutexes

Semaphore S; // initialized to 1

P(S);

criticalSection();

V(S);

Algoritimo 5: Decodificacao de um mutex.

1. #include <pthread.h>

3. // inicializa uma variável do tipo mutex, usando um struct de atributos

4. int pthread_mutex_init (pthread_mutex_t *restrict mutex,

5. const pthread_mutexattr_t *restrict attr);

7. // destrói uma variável do tipo mutex

8. int pthread_mutex_destroy (pthread_mutex_t *mutex);

10. // solicita acesso à seção crítica protegida pelo mutex;

11. // se a seção estiver ocupada, bloqueia a tarefa

12. int pthread_mutex_lock (pthread_mutex_t *mutex);

14. // solicita acesso à seção crítica protegida pelo mutex;

15. // se a seção estiver ocupada, retorna com status de erro

16. int pthread_mutex_trylock (pthread_mutex_t *mutex);

18. // libera o acesso à seção crítica protegida pelo mutex

19. nt pthread_mutex_unlock (pthread_mutex_t *mutex);

3... Variáveis de condição

10. broadcast (c):

11. awake (c:queue) // acorda todas as tarefas da fila c.queue

No exemplo a seguir, a tarefa A espera por uma condição que será sinalizada pela tarefa B. A

condição de espera pode ser qualquer: um novo dado em um bu_er de entrada, a conclusão de

um procedimento externo, a liberação de espaço em disco, etc.

Algoritmo 7: Espera sequencial de processos.

1. Task A ()

4. lock (c:mutex)

5. while (not condition)

6. wait (c);

8. unlock (c:mutex)

12. Task B ()

15. lock (c:mutex)

16. condition = true

17. notify (c)

18. unlock (c:mutex)

É importante observar que na definição original de variáveis de condição (conhecida como

semântica de Hoare), a operação notify(c) fazia com que a tarefa notificadora perdesse

imediatamente o semáforo e o controle do processador, que eram devolvidos à primeira tarefa

da fila de c. Como essa semântica é complexa de implementar ou programar e interfere

directamente no escalonador de processos, as implementações modernas de variáveis de

condição normalmente adoptam a semântica Mesa [Lampson and Redell, 1980], proposta na

linguagem de mesmo nome. Nessa semântica, a operação notify(c) apenas “acorda” as tarefas

que esperam pela condição, sem suspender a execução da tarefa corrente.

Cabe ao programador garantir que a tarefa corrente vai liberar o mutex e não vai alterar o

estado associado à variável de condição.

As variáveis de condição estão presentes no padrão POSIX, através de operadores como

pthread_cond_wait, pthread_cond_signal e pthread_cond_broadcast. O padrão POSIX adota

a semântica Mesa.

4... Monitores

Em 1972, os cientistas Per Brinch Hansen e Charles Hoare definiram o conceito de monitor

[Lampson and Redell, 1980]. Um monitor é uma estrutura de sincronização que requisita e

libera a seção crítica associada a um recurso de forma transparente, sem que o programador

tenha de se preocupar com isso. Um monitor consiste de:

(^) um recurso compartilhado, visto como um conjunto de variáveis internas ao monitor.
um conjunto de procedimentos que permitem o acesso a essas variáveis;

Trabalho Final SO, Trabalhos de Informática

Documentos relacionados

Pré-visualização parcial do texto

Baixe Trabalho Final SO e outras Trabalhos em PDF para Informática, somente na Docsity!

Indice

1. Lista de abreviaturas

API -

POSIX -

FIFO – First In First Out (Primeiro a entrar, primeiro a sair).

TSL –

4. Vocabulário

1. Awake – Acordado, Apto.

2. Broadcast

3. Counter – Contador.

4. Deadlock

5. Down- Baixo, Em Baixo, Por

Baixo.

6. End – Fim.

7. Exclusion – Exclusão.

8. If – Se.

9. Livelock

10. Lock – Fechar, Trancar.

11. Mutex

12. Notify – Notificar.

13. Queue – Fila.

14. Semaphore – Semáforo.

15. Starvation – Fome.

16. Synchronized – Sincronizado.

17. Then – Logo, Deles.

18. Try – Tentar.

19. Unlock – Destrancar, Liberar.

20. Up – Cima, Em Cima.

21. Wait – Esperar.

Nota: Alguns termos foram traduzidos directamente e outros por serem de linguagem

técnica, o grupo optou por não fazer uma tradução directa visto que não perece conveniente

ou fazem parecer o termo não se relacionar com o procedimento ou linguagem em estudo.

utilizados criam situações propícias a acidentes. Assim sendo, é necessário verificar primeiro

se o semáforo é realmente necessário para o local em que se é instalado, isso em questões de

transito; mas para o presente trabalho a que apenas destacar o seu funcionamento electrônico

e programático. Os Dedlock e Starvation são geralmente elementos de sincronização de

semáforos, os quais também serão detalhados e especificados no trabalho em estudo.

I.3.. Resumo

Semáforos são dispositivos utilizados com o objectivo de ordenar o tráfego, subdivididos em

dois tipos: Semáforo Contador – valor inteiro positivo pode variar sem limites e Semáforos

genéricos ou Semáforo Binário também conhecido como mutex locks são os semáforos nos

quais o contador inteiro pode assumir qualquer valor e constituem um mecanismo de

coordenação muito poderoso. Ambos possuem seus algoritmos e seus processos de

programação organizados de acordo com suas funcionalidades mas com mesma finalidade

de “ordenar o tráfego”. Os semáforos possuem um sistema de funcionamento usando

mecanismos Deadlock (quando dois ou mais processos ficam esperando indefinidamente por

um evento que pode ser causado apenas por um dos processos bloqueados), Starvation

( quando um segmento pode esperar indefinidamente, porque os outros segmentos continuam

chegando e recebendo os recursos solicitados antes deste segmento ser executado) ou ainda

Livelock ( quando um processo pode nunca terminar a sua execução).

III.CAPITULO

I.5.. Semáforos

Em 1965, o matemático holandês E. Dijkstra propôs um mecanismo de coordenação eficiente

e flexível para o controle da exclusão mútua entre n tarefas: o semáforo [Raynal, 1986].

Apesar de antigo, o semáforo continua sendo o mecanismo de sincronização mais utilizado

na construção de aplicações concorrentes, sendo usado de forma explícita ou implícita (na

construção de mecanismos de coordenação mais abstratos, como os monitores).

Um semáforo pode ser visto como uma variável S, que representa uma seção crítica e cujo

conteúdo não é diretamente acessível ao programador. Internamente, cada semáforo contém

um contador inteiro S:counter e uma fila de tarefas S:queue, inicialmente vazia.

Figura 1: Exemplo de um Semáforo comum.

Down(s): usado para solicitar acesso à seção crítica associada a s. Caso a seção esteja livre, a

operação retorna imediatamente e a tarefa pode continuar sua execução; caso contrário, a

tarefa solicitante é suspensa e adicionada à fila do semáforo; o contador associado ao

semáforo é decrementado3. Dijkstra denominou essa operação P(s) (do holandês probeer, que

significa tentar).

P(s) (Down) - checa o valor do semáforo. Se o valor é maior que 0 (zero), decrementa e

continua. Se for igual a 0, o processo é posto para dormir _ Ação atômica: é garantido que,

uma vez iniciada a operação, nenhum outro processo tem acesso ao semáforo (essencial para

resolver problemas de sincronização e evitar condições de corrida)

1. P(s) equivale a:

2. Se s > 0 então

3. s := s - 1

4. senão

5. bloqueia o processo até s > 0 (= wait(s))

Down(s): // a executar de forma atômica