Monitores, Comunicação entres Processos - IPC

[pic 1]

Universidade Federal de Goiás - UFG

Bacharelado em Engenharia de Software

Sistemas Operacionais – INF 310

Prof.(a): Iwens Gervásio Sene Junior

Monitores, Comunicação entres Processos - IPC

Elaborado por:

André Lopes, 201703739

__________________________________________

Goiânia, 10 de junho de 2018.

Introdução

Em um sistema multitarefa, seja com um único processador ou com mais de um processador ou ainda com vários núcleos por processador, os processos alternam sua execução segundo critérios de escalonamento estabelecidos pelo sistema operacional. Processos de aplicações concorrentes compartilham diversos recursos do sistema, dispositivos de Entrada/Saída e áreas da memória, arquivos e outros.

O compartilhamento de recursos entre processos pode ocasionar situações indesejáveis, com isso existe vários métodos capazes de reverter essas situações que podem comprometer a execução das aplicações ou até mesmo do sistema como um todo. Um desses métodos são os monitores. Eles são métodos de exclusão mútua e mecanismos de sincronização de alto nível. O conceito de monitores foi proposto por Brinch Hansen em 1972, e desenvolvido por C.A.R. Hoare em 1974, como um mecanismo de sincronização estruturado, ao contrário dos semáforos, que são considerados não estruturados. Monitores são implementados no compilador. Inicialmente, algumas poucas linguagens de programação, como o Concurrent Pascal, Modula-2 e Modula-3, ofereciam suporte ao uso de monitores. Atualmente, a maioria das linguagens de programação disponibiliza rotinas para uso de monitores.

Desenvolvimento

Os monitores apresentam uma propriedade importante que os torna úteis para realizar exclusão mútua: somente um processo pode estar ativo em um monitor em um dado momento. O monitor é uma construção da linguagem de programação e, portanto, os compiladores sabem que eles são especiais e, por isso, tratam as chamadas a rotinas do monitor de modo diferente de outras chamadas de procedimento. Em geral, quando um processo chama uma rotina do monitor, algumas das primeiras instruções da rotina verificarão se qualquer outro processo está atualmente ativo dentro do monitor. Se estiver, o processo que chamou será suspenso até que o outro processo deixe o monitor. Se nenhum outro processo estiver usando o monitor, o processo que chamou poderá entrar. Através de variáveis especiais de condição, é possível associar a execução de um procedimento que faz parte do monitor a uma determinada condição, garantindo a sincronização condicional. As variáveis especiais de condição são manipuladas por intermédio de duas instruções, conhecidas como WAIT e SIGNAL. A instrução WAIT faz com que o processo seja colocado no estado de espera, até que algum outro processo sinalize com a instrução SIGNAL que a condição de espera foi satisfeita. Caso a instrução SIGNAL seja executada e não haja processo aguardando a condição, nenhum efeito surtirá. Vários processos podem estar em estado de espera esperando por várias condições. O monitor organiza os processos em espera utilizando filas associadas às condições de sincronização. A execução da instrução SIGNAL libera apenas um único processo da fila de espera da condição associada.

[pic 2]

Figura 1. Estrutura do monitor com variáveis de condição

Monitores possui algumas desvantagens na sua utilização, como por exemplo:

• É uma boa solução somente para CPUs com memória compartilhada;
• Não é uma boa solução para sistema distribuídos;
• Nenhuma das soluções provê troca de informações entre processo que estão em diferentes máquinas;
• Monitores dependem de uma linguagem de programação;
• Falta de flexibilidade.
• Reduzem o paralelismo.

Uma grande vantagem na utilização de monitores, são que eles tendem a ser mais simples para o programador.

Exemplo: Emule um semáforo S usando a construção de um monitor, considerando as operações Semaforo-Wait e Semaforo_Signal. Use pseudo-linguagem.

Monitor Emulação_Semaforo

S:  integer  := S0;

Not_Zero: Condition;

Operation Semaforo_Wait

    If  S = 0  then   Wait (Not_Zero);  end if;

...