FATEC OURINHOS

ANÁLISE E DESENVOLVIMENTO DE SISTEMAS

3º SEMESTRE - NOTURNO
SISTEMAS OPERACIONAIS

COMUNICAÇÃO ENTRE PROCESSOS

OURINHOS (SP)
2020
 I

COMUNICAÇÃO ENTRE PROCESSOS

Projeto de pesquisa apresentado a

Faculdade de Tecnologia de Ourinhos
para a primeira avaliação da disciplina
de Sistemas Operacionais no curso
de Análise e Desenvolvimento de
Sistema. Orientador: Prof. Sérgio
Roberto Delfino.

OURINHOS (SP)
2020
 SUMÁRIO

1. REFERENCIAL TEÓRICO...................................................................................... 4

2. INTRODUÇÃO ........................................................................................................ 5

3. CONDIÇÕES DE CORRIDA ................................................................................... 6

4. REGIÕES CRÍTICAS .............................................................................................. 7

5. EXCLUSÃO MÚTUA............................................................................................... 9

5.1 Espera Ocupada .............................................................................................. 9

5.2 Primitiva Sleep/Wake-Up ................................................................................. 9

5.3 Semáforos ...................................................................................................... 10

5.4 Monitores........................................................................................................ 11

5.5 Troca de mensagem ...................................................................................... 11

REFERÊNCIAS......................................................................................................... 12
1. REFERENCIAL TEÓRICO

A comunicação entre processos é um tópico que recebe atenção a décadas,

com vários autores propondo soluções para seus conflitos como Edsger Dijkstra,
Theodorus Dekker, Gary L. Peterson.
Um dos papeis de refencia sobre o asunto é o de G. L. Peterson: "Myths About
the Mutual Exclusion Problem" publicado em 1981.
 5

2. INTRODUÇÃO

O tema comunicação entre processos (Interprocess communication – IPC) é

um conteúdo de extrema importância no âmbito de estudos de sistemas operacionais.
No decorrer deste trabalho haverá a apresentação de alguns tópicos sobre o
tema, baseando-se majoritariamente na 4ª (quarta) edição do livro Sistemas
Operacionais Modernos de Andrew S. Tanenbaum e Herbert Bos.
 6

3. CONDIÇÕES DE CORRIDA

Uma condição de corrida é a situação em que dois ou mais processos tentam

acessar os mesmos arquivos de forma simultânea ou um dado processo sofre uma
interrupção de relógio antes de completar suas alterações na memoria compartilhada
e outro processo começa a editar a mesma região. Isso ocorre em sistema onde se
utiliza paralelismo no processamento das tarefas e pode ter resultados catastróficos,
incluindo corrupção de dados ou má execução.
Uma condição de corrida pode ser exemplificada por um spool de impressão,
onde há uma fila para impressão que variam de um a N e duas variáveis in e out, que
apontam, respectivamente para o próximo arquivo a ser impresso e o próximo lugar
vazio. Se um programa A executar e decidir imprimir um arquivo ele irá olhar para a
variável out, ver que possui um valor de, digamos, oito, e referenciar esse valor para
uma variável interna NextFreeSlot e ira escrever o nome do seu arquivo no slot oito
da fila. Digamos que por uma interrupção de relógio a CPU decida que o processo A
já executou por tempo suficiente e começa a executar o processo B que
coincidentemente quer imprimir um arquivo, o processo B ira ler a variável out receber
o valor oito e escrever esse valor na sua variável interna NextFreeSlot, após isso irá
sobrescrever o nome de arquivo do processo A e mudar a variável out para nove.
Após certo período o processo A voltara a ser executado, sua próxima ação será
alterar a variável out para nove. Nesse exemplo, o spool estará consistente e será
executado, porem o arquivo do processo A não será impresso, somente o do processo
B.
No exemplo acima, podemos observar que ocorreu uma perda permanente de
informações devido a condição de corrida no qual os dois processos se depararam.
Isso se torna mais comum quanto mais denso for o paralelismo em dado sistema,
porem há algumas formas de remediar esse problema e manter o paralelismo de
execução sem ocasionar erros de condição de corrida, como veremos nos próximos
capítulos.
 7

4. REGIÕES CRÍTICAS

Região crítica é um estado onde um processo se encontra modificando dados

compartilhados onde há o risco de uma condição de corrida, isso é importante pois
um dado processo não necessariamente está processando dados compartilhados
todo o seu tempo de execução, portanto está seguro de uma condição de corrida.
Porem há instancias onde um conflito pode ocorrer e o programa pode se identificar
como acessando sua região crítica, que se implementado um sistema de exclusão
mútua, pode se mitigar a ocorrência de uma condição de corrida.

Figura - Exclusão Mútua usando regiões críticas

Fonte: Sistemas Operacionais Modernos – Tanenbaum - 4ª Edição

Como vemos na figura acima, o processo A entra na região crítica e logo após
o processo B também tenta entrar em sua região crítica, porem é bloqueado e fica
aguardando, após certo período o processo A deixa sua região crítica dando liberdade
para que o processo B entre na sua respectiva região crítica. No caso acima seria
impossível haver uma condição de corrida pois nunca mais de um processo acessará
sua região crítica simultaneamente.
Para o esquema acima funcionar corretamente deveremos, segundo
Tanenbaum, obedecer a quatro axiomas:
I. Dois processos jamais podem estar simultaneamente dentro de suas regiões críticas.
II. Nenhuma suposição pode ser feita a respeito de velocidades ou do número de
CPUs.
III. Nenhum processo executando fora de sua região crítica pode bloquear qualquer
processo.
 8

IV. Nenhum processo deve ser obrigado a esperar eternamente para entrar em sua
região crítica. (Tanembaum,Andrew S., Sistemas Operacionais Modernos 4ª Edição,
pagina 83)
 9

5. EXCLUSÃO MÚTUA

Segundo Tanenbaum(2008), a exclusão mútua é a forma de se certificar que

caso um processo esteja acessando um arquivo ou variável compartilhados os demais
processos serão impedidos de realizar a mesma coisa, evitando assim possíveis
problemas.
Há diversas técnicas de exclusão mútua, e algumas delas são: Espera
Ocupada; Primitiva Sleep/Wake-Up; Semáforos; Monitores e Passadores de
mensagem.

5.1 Espera Ocupada

De acordo com Tanenbaum, a espera ocupada consiste na checagem
constante por algum valor. É uma consulta constante para checar se um determinado
processo permanece em sua região crítica, gerando assim a ação(Entrar em região
crítica ou permanecer aguardando) de outro processo .
Em geral, o método deve ser evitado, pois há o desperdício de tempo da CPU.
Essa técnica só é utilizada quando há uma expectativa que a espera será curta.

Existem 5 mecanismos para se realizar a espera ocupada, são eles:

1 - Desabilitar interrupções;
2 - Variáveis de travamento;
3- Estrita Alternância (Alternância Explícita);
4 - Solução de Peterson;
5 - Instrução TSL;
Este último mecanismo, Instrução TSL, diferentemente dos outros citados acima,
utiliza de uma instrução de hardware (TSL – Test and Set Lock). A CPU utilizando
dessa instrução impede o acesso ao barramento de memória, proibindo que outras
CPUs utilizem dessa memória até ela terminar.

5.2 Primitiva Sleep/Wake-Up

Essa técnica baseia-se na utilização das chamadas de sistema Sleep e Wake-Up. A
chamada Sleep tem como função fazer o processo que a chamou ser suspenso até
 10

que um outro processo o desperte. A chamada Wake-Up por sua vez, tem como
parâmetro o processo a ser despertado.
O exemplo utilizado por Tanenbaum para mostrar como essa técnica pode ser
usada é no problema do produtor-consumidor.
Dois processos compartilham de um buffer de tamanho fixo comum. Um deles, o
produtor, insere informações no buffer, e o outro, o consumidor, as retira
dele. O problema surge quando o produtor quer colocar um item novo no buffer, mas
ele já está cheio. A solução é o produtor ir dormir, para ser desperto quando o
consumidor tiver removido um ou mais itens. De modo similar, se o consumidor quer
remover um item do buffer e vê que este está vazio, ele vai dormir até o produtor
colocar algo no buffer e despertá-lo.

Figura – Estrutura Produtor-Consumidor

Fonte: Elaborado pelos Autores

5.3 Semáforos
De maneira resumida, consiste em uma variável utilizada para controlar o acesso a
recursos compartilhados. Tem a função de sincronizar o uso de recursos em grande
quantidade. Possui também a funcionalidade de contar o número de recursos ainda
disponíveis no sistema. Essa técnica foi concebida como uma proposta para
contabilizar o número de Wake-ups armazenados para um uso posterior. Existem dois
tipos de semáforos. O semáforo geral, também conhecido como Counting Semaphore,
é utilizado para controlar acessos a um determinado recurso com número finito de
instâncias. Este pode possuir qualquer valor inteiro não negativo. Diferentemente do
semáforo geral, o semáforo binário, ou mutex, é utilizado exclusivamente para a
realização da exclusão mútua. Este por sua vez, só pode possuir os valores 0 e 1.
 11

5.4 Monitores
Monitores são uma versão de nível alto dos semáforos, tirando a
responsabilidade do programador e a entregando para o compilador. Os monitores
funcionam de uma maneira similar, porém diferente dos semáforos

5.5 Troca de mensagem

Na troca de mensagem não há uma memoria compartilhada, dois processos se
comunicam trocando mensagens entre si, no problema do produtor-consumidor, o
consumidor envia N mensagens vazias para o produtor, que enfim retorna a
mensagem cheia de devido espaço, se o produtor for mais rápido que o consumidor
todas as mensagens retornaram cheias, bloqueando o produtor ate que o consumidor
retorne uma mensagem vazia.
Esse sistema porem sofre de falhas, como problemas na transmissão, que é
parcialmente resolvido com o transmissor enviando uma mensagem, o receptor após
receber reenvia uma confirmação, caso após dado período o transmissor não receba
a resposta a mensagem será reenviada com o mesmo identificador.
 12

REFERÊNCIAS

● TANENBAUM, A. S.; BOS, H. Sistemas Operacionais Modernos: 4. ed.

Amsterdã: Editora Pearson, 2016.
● Normas ABNT para apresentação de trabalhos científicos. Wikimedia.
Disponível em:
<http://pt.wikipedia.org/wiki/Normas ABNT para apresentação de trabalhos
científicos>. Acesso em 04 de abr. de 2012.
● Regras e Normas da ABNT 2012 para formatação de trabalhos
acadêmicos. Trabalhos ABNT. Disponível em:
<http://www.trabalhosabnt.com/regras-normas-abnt-formatacao>. Acesso em
04 de abr. de 2012.
● Trabalhos acadêmicos: Normas da ABNT. Firb. Disponível em:
<http://www.firb.br/abntmonograf.htm>. Acesso em 04 de abr. de 2012.