Relatório final so

ÍndiceÍndice...........................................................................................................................................................1

Índice de figuras..........................................................................................................................................3

Introdução...................................................................................................................................................3

Objectivos....................................................................................................................................................4

Objectivo Geral........................................................................................................................................4

Objetivos específicos...............................................................................................................................4

Metodologia................................................................................................................................................5

Conceitos básicos........................................................................................................................................5

Processo..................................................................................................................................................5

Programa.................................................................................................................................................5

Sincronização e comunicação entre Processos............................................................................................6

Sicronização.............................................................................................................................................6

Comunicação ..........................................................................................................................................6

Memória compartilhada..........................................................................................................................6

Troca de Mensagens....................................................................................................................................7

.................................................................................................................................................................8

Comunicação indirecta............................................................................................................................8

Secção crítica...........................................................................................................................................9

Principais problemas a resolver com a sincronização..............................................................................9

Inanição.................................................................................................................................................10

Deadlock(Interblocagem)..........................................................................................................................10

Prevenção de Deadlocks........................................................................................................................11

Exclusão mútua......................................................................................................................................11

Espera por recurso (Hold and Wait) .....................................................................................................11

Não-preempção.....................................................................................................................................12

Espera circular.......................................................................................................................................12

Detecção e Recuperação...........................................................................................................................12

10.Gerenciamento Manual do deadlock....................................................................................................12

Mecanismo de sicronização e comunicação de processos

Semáforos..................................................................................................................................................13

Sincronização Condicional.........................................................................................................................13

Sicronização Condicional utilizando semáforos.....................................................................................13

Níveis de planeamento do sistema operativo............................................................................................14

Monitores..................................................................................................................................................14

Exemplos classicos de sincronização de processos....................................................................................16

Problema do programa Conta_Corrente...............................................................................................16

10.1.Jantar dos Filósofos.......................................................................................................................16

Conclusão..................................................................................................................................................18

Bibliografia.................................................................................................................................................19

2


Índice de figurasfig. 1 Estrutura do monitor........................................................................................................................15

IntroduçãoDesde a origem do Homem foi sempre preocupação se comunicar, recorrendo a diferentes meios para o

efeito. Seria extremamente difícil a vida dos seres vivos sem a comunicação. De modo similar, acontence

com os processos dentro do sistema operativo.

3


Desde a década 1960, com o surgimento dos sistemas multiprogramáveis, tornou-se possível estruturar as

aplicações de modo que partes delas fossem executadas em concorrência.

Processos de aplicações concorrentes compartilham diversos recursos do sistema, tais como arquivos,

registos, dispositivos de entrada e saida de dados e área de memória. O tal compartilhamento de recursos

entre processos pode ocasionar situações indesejáveis, capazes até de comprometer a execução das

aplicações ou até mesmo do sistema como um todo caso a sincronização e comunicação entre processos

não estiver implementada pelo sistema operacional.

Objectivos

Objectivo GeralDescrever os mecanismos de comunicação e sincronização de processos nos Sistemas operativos.

Objetivos específicosAnalisar como os processos se comunicam;

Analisar as formas de sincronização dos processos;

4


Descrever alguns problemas relacionados com a sincronização e comunicação entre processos;

Analisar a resolução de problemas de sincronização e comunicação.

MetodologiaConsulta bibliográficas e sites de internet, livros e trabalhos de licenciatura;

Supervisão feita pelo docente da cadeira;

Consultas aos estudantes que já fizeram a cadeira;

Discução das matérias no grupo.

Conceitos básicos

ProcessoUm processo é um conjunto de dados estruturados, interno ao sistema operativo, onde se inclui todas as informações sobre o estádo, ambiente de execução sobre os recursos utilizados e a respectiva contabilização. Um processo é a abstracção de execução de uma instância dum programa. Um programa ao ser executado

pode correr mais de um processo.

ProgramaPrograma é um conjunto de algoritmos que tem como objectivo resolver um problema com o auxílio de

computador.

5


Sincronização e comunicação entre Processos

SicronizaçãoSeria impossível falar da sicronização sem falar da concorrência de processos, dado que a sincronização acontece quando há concorrência entre processos em aceder o processador e outros recursos escaços .

Com o surgimento dos sistemas multiprogramáveis, onde múltiplos processos poderiam permanecer na memória e disputar o uso de um único processador surgiu a grande necessidade do sistema operativo fazer a gerência do processador e de todos os processos em curso.

Concorrência é o princípio básico para projeto e implementação dos sistemas operacionais

multiprogramáveis onde é possível o processador executar instruções aparentemente em simultaneo com

operações de entrada (E) e saida (S).

Quando um conjunto de processos colabora entre si para a execução de um algoritmo comum, é

indispensável que haja mecanismos de sincronização que permitam controlar essa colaboração.

A concorrência pela CPU por diversos programas é implementada de maneira que, quando um processo

perde o uso do processador, outro processo é admitido pelo processador. O novo processo admitido pelo

processador pode por sua vez passar o uso do processador para um novo processo ou retomar ao primeiro

processo, O programa deverá continuar sua execução exatamente na instrução seguinte àquela em que

havia parado, aparentando ao usuário que nada aconteceu. A este conjunto de acções chamamos

comutação de contexto.

Comunicação Muitas vezes, em uma aplicação concorrente, é necessário que os processos comuniquem entre si. A

comunicação entre processos pode ser implementada como uso de diversos mecanismos, como variáveis

compartilhadas ou troca de mensagens. Nesta situação, é necessário que os processos tenham a sua

execução sicronizada pelo sistema operacional.

Memória compartilhadaNeste caso dois ou mais processos podem incluir a mesma memória no seu espaço de endereçamento, permitindo a comunicação entre eles. É o mecanismo mais rápido de comunicação entre processos pois não existem trocas de dados entre os processos, os dados mesmos dados são acessados pelos diversos processos catalizando assim a comunicação e evitando cópias redundantes.

6


.

Fonte: Facol

Na figura-1 podemos ver o exemplo de dois processos concorrentes compartilhando um buffer para trocar

informações através de operações de gravação e leitura, onde ambos necessitam aguardar que o buffer

esteja pronto para realizar as respectivas operações.

Mecanismos de Sincronização garantem a comunicação entre os processos concorrentes e o acesso aos

recursos melhorando a eficiencia ao acesso ao dados e evitando problemas como a inanição que veremos

algumas secções a seguir.

Troca de MensagensTambém é um mecanismo de comunicação e sicronização entre processos, o sistema operacional possui um subsistema de mensagens que suporta esse mecanismo sem que haja a necessidade do uso de variáveis compartilhadas. Para que ocorra a comunicação entre os processos, deve existir um canal de comunicação, podendo ainda esse meio ser um buffer ou um link de uma de uma rede decomputadores.

Os processos cooperativos podem fazer uso de um buffer para trocar mensagens através de duas rotinas: SEND (transmissor, mensagem) e RECEIVE (receptor, mensagem). A rotina SEND permite o envio de uma mensagem para um processo receptor, enquanto que a rotina RECEIVE permite o recebimento de mensagem enviada por um processo transmissor.

7


A troca de mensagens pode ser feita de duas maneiras a saber:

Comunicação direta e a comunicação indireta.

Comunicação directa entre dois processos exige que ao enviar ou receber uma mensagem , o processo

enderece de uma forma explicita o nome do processo receptor ou transmissor. De salientar que este tipo

de comunicação é só permitida a troca de mensagens entre dois processos.

Fonte: UNIBAN

Comunicação indirectaA comunicação indireta entre processos utiliza uma área compartilhada, onde as mensagens podem ser

colocadas pelo transmissor e retiradas pelo receptor.

Esse tipo de buffer é conhecido com mailbox ou port e as suas características, como identificar e

capacidade de armazenamento de mensagens, são definidas no momento da criação.

8


Na comunicação indireta, vários processos podem estar associados a mailbox, e os parametros dos

procedimentos SEND e RECEIVE passam a ser nomes de mailbox e não mais nomes de processos.

Fonte: UNIBAN

Independentemente do mecanismo de comunicação adoptado, processos que estão trocando mensagens

devem ter suas execuções sicronizadas em funcão do fluxo de mensagens; um processo não pode tratar

uma mensagem até que esta tenha sido enviada por outro processo, ou então receber uma mesma

mensagem mais de uma vez.

Secção críticaÉ uma área de código de um algoritmo que acessa um recurso compartilhado que não pode ser acedido concorrentemente por mais de uma linha de execução. Seu objetivo é tornar a operação sobre o recurso compartilhado atômica.

Algum mecanismo de sincronização é necessário para implementar a entrada e a saída duma região crítica para assegurar o uso exclusivo, como por exemplo um semáforo.

Uma região crítica é geralmente usada quando um programa multitarefa deve atualizar diversas variáveis relacionadas sem que outra linha de execução faça modificações conflitantes nos dados.

Principais problemas a resolver com a sincronização1. Cooperação entre processos

É necessária quando um processo espera que outro lhe assinale a conclusão da execução de uma

determinada operação;

9


2. Competição por recursos

Como os sistemas dispõem de recursos que têm de ser utilizados em exclusividade ou cujo número é

limitado, a sincronização deve garantir que a gestão dos recursos seja correcta;

InaniçãoInanição é a situação em que um processo nunca é executado, como por exemplo, no escalonamento por prioridade, os processos com prioridade maior vão sempre ser executados, e quando um processo acaba outro entra com maior prioridade, sendo assim os processos com menor prioridade não vão ter nenhum progresso na execução de sua tarefa.

Nota: Uma solução para esta situação é a delegação de um tempo máximo de espera

Deadlock(Interblocagem)Deadlock é a situação em que um processo aguarda por um recurso que nunca estará disponível ou um

evento que não ocorrerá. Esta situação é originada na maioria das vezes, do compartilhamento de

recursos, como dispositivos, arquivos e registos, entre processos concorrentes onde a exclusão mútua é

exigida.

Fonte: UNIBAN

Para que ocorra uma situação de Deadlock, existem quatro (4) condições necessárias a saber:

Exclusão mútua: cada recurso só pode estar alocado a um único processo em um determinado instante.Espera por recurso: um processo, além dos recursos já alocados, pode estar esperando por outros recursos.

10


Não-preempção: um recurso não pode ser liberado de um processo só porque outros processos desejam o

mesmo recurso.

Espera circular: um processo pode ter de esperar por um recurso alocado a outro processo e vice-versa.

Os problemas de deadlock existem em qualquer sistema multiprogramável, no entanto as soluções a

implementar devem considerar o tipo de sistema e o impacto em seu desempenho.

Prevenção de DeadlocksPelo que vimos das quatro (4) condições para a ocorrencia de Deadlock, estas devem ocorrer

simultaneamente. Isto quer dizer que se garantirmos que somente uma delas não possa ocorrer, estaremos

prevenindo que não ocorra Deadlock em um determinado sistema.

Em seguida analisemos as quatro condições separadamente.

Exclusão mútua.A condição de exclusão mútua não deve ser negada, pois dois processos acessando um recurso

simultaneamente poderiam levar o sistema a uma sitação de caos.

Podemos tomar como exemplo para esta situação dois processos acessando uma mesma impressora ao

mesmo tempo, aqui a solução é utilizar o sistema de spool, onde um único processo de spool acessa

directamente a impressora e daí não acessa um outro recurso, dado que os processos não impremem

directamente e o processo de spool acessa somente o recurso impressora.

No entanto o problema é que nem todos os recursos podem ser alocados via spoolng.

Espera por recurso (Hold and Wait) A primeira estratégia Havender requer que todos os recursos que um processo precisa devem ser

requesitados de uma única vez. Sistema deve liberar os recursos segundo uma política “tudo ou nada”. Se

todos os recursos que o processo requisitou estão disponíveis, então o sistema pode alocá-los todos de

uma vez ao processo, se acontecer ao contrário o processo deve esperar até que todos eles estejam

disponíveis. No entanto enquanto o processo espera ele não deve deter nenhum recurso, assim a condição

“hold and wait” é negada e deadlocks não podem ocorrer.

Esta solução parece ser boa, mas pode levar a um sério despedício de recursos. E outro grande problema é

a possibilidade de um processo requisitando todos os seus recursos de uma só vez ficar indefinidamente

esperando, se outros processos estiverem usando os recursos que ele deseja com muita frequência mas de

qualque forma, esta abordagem evita deadlocks

11


Não-preempção.Negar a condição de “Não-preempção” é uma estratégia ainda pior do que a anterior. Para vários recursos

como uma impressora, não é interessante que um processo os perca durante seu uso.

Espera circularA condição Espera circular “Circular Wait” pode ser eliminada de várias formas. Uma maneira é

estabelecer uma regra que diga que um processo só pode alocar um único recurso em um dado momento.

Se ele precisar de um segundo recurso deve liberar primeiro.

Detecção e RecuperaçãoAlguns sistemas estão desenhados para permitir que a alocação de recursos prossiga sem grandes

intervenções, em vez disso, o sistema verifica periodicamente se existe a possibilidade de surgir um

deadlock, quer periodicamente, quer sempre que certos eventos ocorram. Um aspecto negativo desta

abordagem reside em determinar quando o algoritmo de detecção deve ser executado. Isto deve-se ao

facto de que se é esecutado muitas vezes, simplesmente torna o sistema demasiado lento, mas se não é

executado vezes suficientes os processos em Deadlock e os recursos do sistema ficam entrelaçados de

uma maneira não produtiva até que o sistema seja recuperado. Este problema é devido à presença de um

Deadlock resultar da não ocorrência de eventos em vez de executar algum evento excepcional que possa

disparar a execução do algoritmo de detecção.

Na estratégia do algoritmo de detecção surgem duas fases, a detecção, que verifica se ocorre uma situação

de Deadlock, e a segunda fase, recuperação, que surge após o Deadlock se ter verificado e que resulta no

desbloqueio dos recursos, por destruição dos processos que bloqueavam. Esta é a estratégia mais utilizada

para tratar uma situação de Deadlock.

10. Gerenciamento Manual do deadlockMuitos dos sistemas actuais deixam para o usuário a função de detectar um Deadlock, que através da

utilização rotineira o usuário apercebe-se devido ao tempo que se acha necessário, para que o processo

seja executado, já ter sido largamente ultrapassdo, ficando a descrição do usuário achar se os processos

que entraram em Deadlock, e tentar resolver a situação recorrendo a ferramentas dos sistemas ou que a

máquina fornecem, como por exemplo, e utilizando em última instância, a reinicialização do sistema.

O padrão em que os recursos são requisitados, adquiridos e ficam em Deadlock determina quando o

sistema entra em Deadlock. Um processo bloqueado é incapaz de mudar o estado de um sistema, pois ele

não consegue causar qualquer transição para além do estado corrente.

12


SemáforosSegundo Dijkstra (1965), semáforo é um mecanismo de sicronização que permite implementar de forma

simples, a exclusão mútua e a sicronização condicional entre processos. Hoje em dia, a maioria das

linguagens de programação disponibiliza rotinas para o uso de semáforos.

Os semáforos são classificados em dois tipos:

Semáforos binários- que só assumem os números binários 0 e 1

Semáforos Contadores- que podem assumir qualquer valor inteiro positivo além do zero.

Sincronização CondicionalSincronização Condicional é uma situação onde o acesso ao recurso compartilhado exige a sicronização

de processos vinculadas a uma condição de acesso dado que um recurso pode não se encontrar pronto

para o uso, devido a uma condição específica. Nesse caso, o processo que deseja acessá-lo deverá

continuar a espera até que o recurso esteja disponível.

Sicronização Condicional utilizando semáforosAlém de permitir a implementação da exclusão mútua, os semáfros podem ser utilizados nos casos onde a

sicronização condicional é exigida. Geralmente esse tipo de sicronização ocorre quando um processo

solicita uma operação de Entrada/Saida, o pedido faz com que o processo execute uma instrução DOWN

no semáfro associado ao evento e fique no estado de espera, até que a operação seja completada. E

quando a operação termina, a rotina de tratamento da interrupção executa um UP no semáfro, libertando

o processo do estado de espera.

Os semáforos são uma solução eficiente para assegurar a exclusão mútua no acesso a recursos. Um semáforo é constituído por uma variável de controlo inteira e por uma lista de processos. O conteúdo da variável reflecte a quantidade de recursos disponíveis no sistema. A primitiva Esperabloqueia um processo quando a variável do semáforo tem, à partida, o valor zero. O contexto do processo é colocado na fila de processos do semáforo e o seu estado passa a bloqueado. A primitiva Assinalarincrementa a variável de controlo, se não existirem processos bloqueados, ou torna executável um processo.

13


Fonte: UNIBAN

Níveis de planeamento do sistema operativoExistem três níveis de planeamento do sistema operativo a saber:

Nível alto: decide que trabalhos são candidatos a converter-se em processos que competem pelos recursos

do sistema.

Nível médio: decide quais são os processos suspensos ou reativos.

Nível baixo: decide qual dos processos (que foram listados pelos outros dois níveis de planeamento) é

que deve ter a oportunidade de executar na unidade central de processamento.

MonitoresMonitores são mecanismos de sicronização de alto nível que tornam mais simples o desenvolvimento de

aplicações concorrentes. Estes mecanismos são estruturados em função de serem implementados pelo

compilador, possibilitando que o desnvolvimento de programas concorrentes fique mais fácil e menores

chances de erros.

O monitor é formado por procedimentos e variáveis encapsulados dentro de um módulo, implementando

de forma automática a exclusão mútua entre os procedimentos declarados.

14


Tadavia , toda vez que algum processo faz uma chamada a um procedimento, o monitor verifica se já

existe outro processo executando algum procedimento do monitor, caso exista o processo ficará

aguardando a sua vez em uma fila de entrada.

A implementação da exclusão mútua via monitores não é implementada directamente pelo programador,

assim como no caso do uso dos semáfros, o próprio sistemas operacionais compilador é que se

encarrega de garantir a exclusão mútua entre procedimentos previamente definidos.

fig. 1 Estrutura do monitor

Fonte: UNIBAN

Os processos cooperativos podem fazer uso de um buffer para trocar mensagens através de duas rotinas: SEND (receptor, mensagem) e RECEIVE (transmissor, mensagem). A rotina SEND permite o envio de uma mensagem para um processo receptor, enquanto que a rotina RECEIVE permite o recebimento de mensagem enviada por um processo transmissor.

15


Exemplos classicos de sincronização de processos

Problema do programa Conta_CorrenteQue atualiza o saldo bancário de um cliente após um lançamento de débito ou crédito no arquivo de

contas correntes.

Neste arquivo são armazenados os saldos de todos os correntistas do banco. O programa lê o registro do

cliente no arquivo, lê o valor a ser depositado ou retirado e, em seguida, atualiza o saldo no arquivo de

contas.

Ex:

PROGRAM Conta_Corrente;

.

.

READ (Arq_Contas, Reg_Cliente);

READLN (Valor_Dep_Ret);

Reg_Cliente.Saldo := Reg_Cliente.Saldo + Valor_Dep_Ret;

WRITE (Arq_Contas, Reg_Cliente);

.

END.

10.1. Jantar dos Filósofos

fig. 8 Mesa dos filósofos

16


O problema dos filósofos é um exemplo clássico de sincronização de processos. Nesse problema, há uma

mesa com cinco pratos e cinco garfos fig.7, onde os filósofos podem sentar, comer e pensar. Toda vez que

um filósofo para de pensar e deseja comer, é necessário que ele utilize dois garfos, posicionados à sua

direita e à sua esquerda.

Existem várias soluções para resolver o problema dos filósofos, entre elas:

• Limitar o acesso à “sala” a N-1 filósofos (fica sempre pelo menos1 garfo livre).semaforo_t garfo[5] = {1, 1, 1, 1, 1};semaforo_t sala = 4;filosofo(int id){while (TRUE) {pensar();esperar(sala);esperar(garfo[id]);esperar(garfo[(id+1)%5]);comer();assinalar(garfo[id]);assinalar(garfo[(id+1)%5]);assinalar(sala);}}

17


ConclusãoProblemas relacionados com sincronização e comunicação entre processos, podem ser resolvidos com soluções implementandas a nível do Hardware ou a nível do Software. No presente trabalho foram descritas várias soluções quer do hardware quer de software.

A ausencia de mecanismos de sincronização e comunicação nos SO pode pode ocasionar situações indesejáveis, capazes até de comprometer a execução das aplicações ou até mesmo do sistema como um todo.

Soluções para problemas de sincronização e comunicação entre processos vem sendo aprimorados ao longo dos anos com objectivo principal que e de executar as aplicações de forma concorrente partilhando recursos que os sistemas computacionais mas sem comprometer a performance dos sistemas computacionais.

18


Bibliografiahttp://www.anylogic.pl/fileadmin/Modele/Traffic/filozof/Dining%20Philosophers%20-%20Hybrid%20Applet.html

http://www.doc.ic.ac.uk/~jnm/concurrency/classes/Diners/Diners.html

http://journals.ecs.soton.ac.uk/java/tutorial/java/threads/deadlock.html

http://users.erols.com/ziring/diningAppletDemo.html

UNIBAN, Sincronização e Comunicação entre Processos

19

Documents

Relatório final so