Baixe Trabalho de so e outras Trabalhos em PDF para Informática, somente na Docsity!
ÍNDICE
- INTRODUÇÃO
- SEMÁFOROS
- 2.1. Definição..............................................................................................................................
- 2.2. Monitores
- 2.3. Principais operações de semáforos........................................................................................
- 2.3.1. Inicialização
- 2.3.2. Operação P(S)
- 2.3.3. Operação V(S)
- 2.4. Tipos de semáforos...............................................................................................................
- 2.4.1. Semáforos Binários (valor inicial é 1)
- 2.4.2. Semáforos de Contagem (valor inicial é normalmente maior do que 1)
- 2.5. Sincronização de Processos
- DEADLOCK (INTERBLOQUEIO, BLOCAGEM, IMPASSE)
- 3.1. Definição..............................................................................................................................
- 3.2. Condições para que possa ter uma ocorrência de deadlock
- 3.2.1. Exclusão Mútua (Mutual Exclusion)
- 3.2.2. Manter e Esperar (Hold and Wait)
- 3.2.3. Não preempção (No Preemption)
- 3.2.4. Espera Circular (Circular Wait)
- 3.3. Estratégias para Tratar o Deadlock
- 3.3.1. Prevenção
- 3.3.2. Detecção..........................................................................................................................
- 3.3.2.1. Detecção de deadlocks com um recurso de cada tipo
- 3.3.2.2. Detecção de deadlocks com múltiplos recursos de cada tipo
- 3.3.3. Correção do deadlock
- STARVATION
- CONCLUSÃO
- BIBLIOGRAFIA
2. SEMÁFOROS
O conceito de semáforos foi proposto em 1965, sendo apresentado como um mecanismo de sincronização que permitia implementar, de forma simples, a exclusão mútua sincronização condicional entre processos.
2.1. Definição
Um semáforo é uma estrutura de dados que consiste em um número inteiro e em uma fila que armazena descritores de tarefas.
O conceito de semáforos consiste na colocação de protecções em torno do código que acessa esta estrutura para oferecer acesso limitado aos dados. Em geral, a estrutura de dados é uma fila, funcionando em regime de primeiro a entrar, primeiro a sair. O semáforo tem uma variável especial protegida (ou tipo abstracto de dados) que tem como função o controle de acesso a recursos compartilhados (por exemplo, um espaço de armazenamento) num ambiente multitarefa. A invenção desse tipo de variável é atribuída a Edsger Dijkstra, em 1965 e foi utilizado inicialmente no sistema operacional THEOS.
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).
Dijkstra introduziu a noção de semáforo para impor a exclusão mútua entre processos. É uma construção de alto nível também usada para sincronizar processos. Um semáforo S é uma variável inteira positiva sobre a qual os processos podem fazer duas operações (P(S) e V(S)) primitivas indivisíveis, ou seja, enquanto um processo estiver executando uma dessas duas operações, nenhum outro processo pode executar outra operação sob o mesmo semáforo, devendo esperar que o primeiro processo encerre sua operação sob o semáforo. Essa obrigação evita condições de disputa entre vários processos. As operações P e V têm sua origem das palavras parsen (passar) e vrygeren (liberar). Uma vez iniciada uma das operações ela irá até o fim sem interrupções.
Cada semáforo tem uma fila associada a ele, onde processos bloqueados nele esperam. O uso de semáforos exige do programador muito cuidado, pois qualquer engano pode gerar bugs em seu programa que o levem a falhas de sincronização ocasionando quedas e travamento geral do sistema.
Utilização do semáforo binário na exclusão mútua
2.2. Monitores
Monitores são mecanismos de sincronização de alto nível que tornam mais simples o desenvolvimento de aplicações concorrentes. Este conceito foi proposto em 1972.
Ou por outra, são mecanismos de sincronização compostos de um conjunto de procedimentos, variáveis e estrutura de dados definidos dentro de um módulo cuja finalidade é a implementação automática da exclusão mútua entre seus procedimentos. Somente um processo pode estar executando um dos procedimentos do monitor em um determinado instante. Toda vez que um processo chamar um destes procedimentos, o monitor verifica se já existe outro processo executando algum procedimento do monitor. Caso exista, o processo fica aguardando a sua vez ate que tenha permissão para executá-lo.
Processo acessaa região crítica Fila de esperade processos
Processo deseja entrarna região crítica
DOWN (S= 0)
DOWN (S> 0) UP (S) - processo saida região crítica
da fila de esperaLibera processo
2.3. Principais operações de semáforos
As principais operações sobre semáforos são:
2.3.1. Inicialização
Recebe um valor inteiro indicando a quantidade de processos que podem acessar um determinado recurso.
2.3.2. Operação P(S)
Decrementa o valor do semáforo. Se o semáforo está com valor igual a zero, o processo é posto para dormir.
2.3.3. Operação V(S)
Se o semáforo estiver com o valor igual a zero e existir algum processo adormecido, um processo será acordado. Caso contrário, o valor do semáforo é incrementado.
Quando uma operação V(S) é executada, um processo bloqueado é retirado da fila para execução. A disciplina de empilhamento da fila do semáforo depende da implementação.
Dependendo dos valores que o semáforo pode ter, há dois tipos de semáforos
2.4. Tipos de semáforos
2.4.1. Semáforos Binários (valor inicial é 1)
São inicializados pelo sistema e usados para criar exclusão mútua no acesso a recursos com uma unidade apenas, porque apenas um processo pode passar pela operação P a cada vez.
2.4.2. Semáforos de Contagem (valor inicial é normalmente maior do que 1)
São utilizados para sincronização e controle de alocação de recursos com mais de uma unidade. O valor inicial do semáforo é igual ao número de unidades do recurso. Este semáforo também notifica os processos sobre o uso dos recursos. Sempre que um processo usa um recurso qualquer, este semáforo é incrementado sempre que um processo liberar um recurso ele será decrementado. Este semáforo é útil para evitar que um processo na região crítica sem que haja recursos disponíveis no sistema.
O semáforo pode ser usado também para implementar sincronizações condicionais. Isto consiste em um processo que necessita ser notificado sobre a ocorrência de um evento. Pode-se usar o semáforo para notificar este processo sobre a ocorrência deste evento.
Outro tipo de semáforo usado é semáforo consumidor onde ele pode informar ao processo se o buffer está cheio ou está vazio.
2.5. Sincronização de Processos
Processos não foram projectados para trabalhar em conjunto. Seus resultados independem das acções de outros processos. Mas para gerar seus resultados eles necessitam de recursos do sistema operacional, como todos os outros processos.
Em programação concorrente, não é possível determinar quando e em que ordem os eventos irão ocorrer. Com isso torna-se difícil compartilhar recursos globais e alocar recursos. Portanto é necessário um mecanismo para manter a consistência dos dados.
Corrupção dos dados: ocorre quando dois processos têm acesso a uma mesma estrutura de dados. Precisa-se de um processo de sincronização para que sempre o dado escritos/lidos sejam os correctos.
Dijkstra explica a situação de deadlock através da seguinte ilustração:
Processo 1 reserva para si o Recurso 1, por sua vez o Processo 2 e o Processo 3 reservam respectivamente para si o Recurso 2 e o Recurso 3. Por exemplo se um dos outros processos necessitar de um dos recursos anteriormente reservados por outros processos, como acontece no diagrama da figura anterior entramos numa situação de Deadlock. Nenhum dos processos pode continuar, porque para isso acontecer, os mesmos necessitariam que os recursos reservados fossem disponibilizados. A não ser que um dos processos detecte a situação e abandonando o pedido do recurso anteriormente reservado por outro processo, e liberte ao mesmo tempo o recurso por si reservado. Com isso, há a possibilidade de pelo menos um processo correr.
Um deadlock, em computação, ocorre normalmente com recursos como dispositivos, arquivos, memória, entre outros.
3.2. Condições para que possa ter uma ocorrência de deadlock
3.2.1. Exclusão Mútua (Mutual Exclusion)
Existência de recursos que precisam ser acessados de forma exclusiva. Cada recurso só pode estar alocado a um único processo em um determinado instante.
3.2.2. Manter e Esperar (Hold and Wait)
Possibilidade de processos manterem os recursos alocados enquanto esperam por recursos adicionais. Um processo, além dos recursos já alocados, pode ficar na espera por outros;
3.2.3. Não preempção (No Preemption)
Necessidade de recursos serem liberados pelos próprios processos que os estão utilizando. Um recurso não pode ser retirado de um processo porque outros processos o estão desejando
3.2.4. Espera Circular (Circular Wait)
Possibilidade da formação de uma espera circular. Um processo pode aguardar por um recurso que esteja alocado a outro processo e vice versa.
Todas estas condições devem estar presentes para que ocorra um deadlock. Se alguma delas falhar, então não ocorrerá um deadlock.
Recurso 2 Recurso 1
Processo A
Processo B
Processo Asolicita o Recurso 2 alocado aoRecurso 1 Processo A
alocado aoRecurso 2 Processo B
Processo Bsolicita o Recurso 1
3.3.2. Detecção
O sistema permite que ocorra o deadlock e depois executa o procedimento de recuperação, que se resume na detecção da ocorrência e na recuperação posterior do sistema.
Para detecção do deadlock, deve-se implementar no sistema uma estrutura de dados que armazene as informações sobre os processos e os recursos alocados a eles e essas reflictam a situação de cada processo/recurso no sistema. Porém, é importante ressaltar que o simples procedimento de actualização dessas estruturas gera sobrecarga no sistema, pois toda vez que o processo aloca, libera ou requisita um recurso, elas precisam ser actualizadas.
Algumas das técnicas de detecção utilizadas são:
3.3.2.1. Detecção de deadlocks com um recurso de cada tipo
Se tem apenas um recurso de cada tipo (somente uma impressora, ou um CD). Existe um algoritmo para detectar se existem ciclos no grafo dos processos e recursos.
3.3.2.2. Detecção de deadlocks com múltiplos recursos de cada tipo
Algoritmo baseia-se em um ambiente que possui vários recursos do mesmo tipo e os processos solicitam apenas pelo tipo de recursos, não especificando qual recurso desejam utilizar.
Uma vez que o algoritmo de detecção de deadlocks é bem-sucedido, o que se fará em seguida é a recuperação do sistema da situação de deadlock e colocá-lo novamente em condição de funcionamento normal.
3.3.3. Correção do deadlock
A correção pode ser feita: eliminando um ou mais processos envolvidos no deadlock, desalocar os recursos já garantidos por eles (quebrando assim a espera circular).
4. STARVATION
A primeira situação indesejada é conhecida como starvation (ou espera indefinida).
Ocorre quando um processo espera por um recurso e é bloqueado porque o recurso está sempre alocado a outro processo ou seja, bloqueio indefinido. Um processo pode nunca ser removido da fila de semáforos na qual ele está bloqueado “Injustiça”.
Um processo pode esperar indefinidamente, porque os outros processo continuam chegando e recebendo os recursos solicitados antes deste processo ser executado. Note-se que recurso está sendo activamente utilizado e da discussão vai parar de esperar, se outros processos pararem de chegar dentro.
Quem determina as prioridades dos processos é o sistema operacional. Neste caso existem duas formas do sistema operacional determinar qual será a vez de quem. Ou por escolha aleatória ou por prioridades. Quando a escolha é aleatória, existirá a probabilidade de um processo nunca ser escolhido. Quando for uma escolha por prioridades, um processo de menor prioridade nunca receberá o acesso ao recurso, e ai este processo nunca executará sua rotina.
Uma solução bastante simples é a criação de filas de pedidos de alocação para cada recurso, utilizando o esquema FIFO (First In First Out). Sempre que um processo solicita um recurso, o pedido é colocado no final da fila associada ao recurso. Quando o recurso é liberado, o sistema seleciona o primeiro processo da fila.
6. BIBLIOGRAFIA
TANENBAUM, Andrew S.. (2003) "Sistemass Operacionais Modernos", Editora Prentice Hall – 2 ed. – São Paulo. SILBERSCHATZ, Abraham; Galin, Peter; Gagne, Grag. (2000). "Sistemas Operacionais: conceitos e aplicações", Editora Elsvier – 8 reimpressão – Rio de Janeiro. N. RIBEIRO (2007). "Sistemas Operativos", http://ltodi.est.ips.pt/nribeiro/Lecturing/SO_02- 03/A06.pdf., Novembro. SILBERSCHATZ, Abraham; Karth, Henry F.; Sudarshan, S. (1999). "Sistema de Banco de Dados", Editora Makron Books – 3 ed. – São Paulo. VALADOR, Nelson. (2007). "Sistemas Operativos", http://alumni.ipt.pt/~nvalador/trab1/cap10.html, Novembro. E.W. Dijkstra. (1968). "Go To Statement Considered Harmful, Communications of the ACM". Vol. 11
