Gerncia de Processos

Viso Geral

O conceito de processo um dos conceitos

mais importantes para qualquer sistema
operacional

Um processo um programa em
execuo. Alm do cdigo executvel, ns
temos uma pila de execu!o, um
apontador para esta pila, um contador de
programa, valores dos registradores da
mquina, outras in"orma!#es.

$ada processo tem um identi"icador %nico,

conecido como pid &process id'.

As in"orma!#es so(re um processo esto

arma)enadas na ta(ela de processos,
acessada pelo pid.

*urante a execu!o, o processo

compartila o processador com outros
processos em execu!o &escalonamento
de processador'.

+m processo interage com outros

processos atravs de mecanismos de
comunica!o.

Modelo de Processo

,n"orma!#es que "a)em parte de um processo-

Classificao dos modelos de processos quanto

ao custo de troca de contexto e de manuteno

heavyweight (processo tradicional

lightweight (threads
espao de endereamento
segmento de dados inic
arquivos abertos
processos filho
sinais
estatsticas de uso
contador de programa (PC)
apontador de pilha (SP)
conjunto de registradores
estado de execuo
AMBIENTE
EXECUO

Modelos de Processo

!odelo de processos tradicional (heavyweight

"este caso# o processo $ composto tanto pelo

am%iente como pela execuo& 'rocesso tradicional(
am%iente ) execuo& Cada processo possui um *nico
fluxo de controle (contador de programa e roda de
forma independente dos demais&
+,-. /0# (1
2"C /0
34,/ /0#(1
5, 0678
09.-
0678
+,-. /:#(;
+,-. /0# (1
2"C /0
34,/ /0#(1
5, 0678
09.-
0678
+,-. /:#(;
+,-. /0# (1
2"C /0
34,/ /0#(1
5, 0678
09.-
0678
+,-. /:#(;
t0 t< t:
PC
PC
PC

Modelos de Processo

Como# em um dado instante# pode haver v=rios

processos ativos ao mesmo tempo# o processador $
chaveado entre os diversos processos& 'or esta ra>o#
fica praticamente imposs?vel prever o tempo de
execuo de um processo# pois este depender= da
carga do sistema&

.iferena entre um processo e um programa (por

analogia(

programa( receita de %olo (passivo

processo( ato de fa>er o %olo (ativo

- noo de processo envolve sempre uma noo de

atividade&

@ierarquia de 'rocessos

4odo sistema operacional deve possuir mecanismos

que permitam a criao de processos& 5eralmente# um
processo somente $ criado por outro processo# o que
nos leva a uma hierarquia em =rvore&

Am processo $ criado a partir de um programa (!3B

.,3 ou a partir de outro processo (clonagem
(Anix&
init
gett. gett. sell
cmd/ cmd0 cmdn
...

Estados dos Processos

-pesar dos processos serem relativamente autoB

suficientes# muitas ve>es eles necessitam de
acessar outros recursos (discos# terminais ou
mesmo se comunicar com outros processos&
Cuando um processo est= ocioso esperando que
um evento acontea# nDs di>emos que ele est=
%loqueado& 8m algumas situaEes# o processo
pode ser %loqueado a revelia pelo sistema
operacional&

,s estados %=sicos de um processo so( rodando

(running# %loqueado (%locFed e pronto (ready&
8m um sistema monoprocessado# sD temos um
*nico processo rodando a cada instante&

Estados dos Processos

"a representao acima# as elipses so os estados

e as flechas so as transiEes entre os estados&
(0 , processo %loqueiaBse G espera de um evento
(< , evento esperado pelo processo ocorreu& 8le
pode agora se executar& 'assa ento ao estado
pronto
(: , processo $ escolhido para execuo pelo
processador
(H , tempo de posse do processador pelo processo
(time slice esgotouBse& , sistema operacional
retira o processador do processo
Rodando
Bloqueado
Pronto
(1)
(2)
(4) (3)

Implementao de Processos

4odas as informaEes so%re um processo so mantidas

na ta%ela de processos& - ta%ela de processos contem
campos que di>em respeito G gerIncia do processo# G
gerIncia da memDria e G gerIncia de arquivos - ta%ela
de processos possui uma entrada por processo e os
campos nela contidos variam de sistema operacional
para sistema operacional&

-lguns dados referentes ao processo na ta%ela de

processos(

identificador do processo (pid# valor dos

registradores# valor do contador de programa
('C# valor da palavra de estado ('3J# valor do
apontador de pilha (3'# estado do processo#
instante do in?cio do processo# tempo de
processador utili>ado# etc

-lguns dados referentes G memDria na ta%ela de

processos(

endereo do segmento de texto# dados e pilha#

estado da sa?da# informaEes so%re proteo# etc

-lguns dados referentes G gerIncia de arquivos na

ta%ela de processos(

diretDrio rai># diretDrio de tra%alho# descritores de

arquivos a%ertos# parKmetros de chamadas em
andamento# etc

Implementao de Processos

$om o conceito de processo, como

implementar a multiprograma!o1
'
Am processo p0 solicita uma operao de 8L3&
8le $ %loqueado pelo sistema operacional G
espera da concluso da operao& -s
informaEes de p0 so atuali>adas na sua ta%ela
de processos&
Z
, sistema operacional escolhe um dos processos
na fila dos prontos (processo p< e o coloca para
rodar&

, resultado da operao solicitada por p0 chega&

J
, hardware interrompe p<# salvando o seu
estado de execuo (registradores# descritores#
etc na pilha&

, hardware acessa um endereo de memDria

f?sica espec?fico que contem o vetor de
interrupEes& , vetor de interrupEes contem o
endereo da rotina de tratamento de
interrupEes geradas por cada classe de
dispositivo (disco# floppy# terminal# clocF# etc&

Implementao de Processos

-tualmente# toda m=quina possui um vetor

de interrupEes&
endereo
vetor
interrupes
#005F
#00!1B
#00!3F
#00!51
#00!1B
""#R$% F&'$C%
#00023F
(etor de
$nterrupes
in)*io da rotina
de trata+ento de
interrup,o do
dispositivo 1

Implementao de Processos
- rotina de tratamento de interrupo $ executada pelo
3,& - primeira coisa a ser feita $ salvar os
registradores que foram empilhados pelo hardware na
ta%ela de processos do processo p<& - interrupo $
tratada& , processo p0# que solicitou o servio# $
colocado na fila de prontos&
1 , sistema operacional escolhe um processo da fila de
prontos para se executar# atrav$s de uma pol?tica de
escalonamento&
*
, 3, acessa a entrada da ta%ela de processos do
processo escolhido e carrega o conte*do da ta%ela nos
registradores de m=quina (restaurao&
* , processo escolhido reinicia a execuo&

4roca de contexto( a operao de salvamento dos

registradores de um processo e posterior restaurao
de registradores de outro processo $ chamada de troca
de contexto& - troca de contexto permite a troca de
processador entre processos&
CP-
p1
p2
'.
(1)
(2)
(1)/restaura,o
(2)/salva+ento
p1
p2

Escalonamento de Processos

, algoritmo de escalonamento de processos $ o

respons=vel pela determinao de que processo (dentre
os prontos vai rodar e por quanto tempo& , algoritmo
de escalonamento define# assim# a pol?tica de utili>ao
do processador pelos processos&

Cuando um processo solicita operaEes %locantes (8L3#

por exemplo# sua execuo fica suspensa at$ que o
evento solicitado ocorra&

8xecuo de < processos sem concorrIncia(

8xecuo de < processos com concorrIncia(

8xecutando v=rios processos concorrentemente#

o%temos uma melhor utili>ao da C'A
exec idle exec idle exec
idle exec idle exec
P!
P"
exec idle exec idle exec
idle exec idle exec
P!
P"

Escalonamento de Processos

-o se proMetar um escalonador# devemos o%servar

v=rios crit$rios que devem estar presentes em um
%om algoritmo de escalonamento(

Nustia (fairness( garantir que todos os processos do

sistema tero chances Mustas de uso do processador
(chances iguais $ muito forteOO

8ficiIncia( quando houver tra%alho a fa>er# o

processador deve estar ocupado

4empo de resposta( minimi>ar o tempo de resposta

dos usu=rios interativos&

4urnaround( , tempo de turnaround $ o tempo que

vai desde o lanamento do processo at$ o seu
t$rmino& P a soma dos seguintes componentes(
tempo de espera por memDria# tempo de espera pelo
processador# tempo de espera por 2L, e tempo de
utili>ao da C'A& 8ste crit$rio visa minimi>ar a
espera de resultados& !ais utili>ado em
processamento %atch&

Jaiting time( 8ste crit$rio visa minimi>ar o tempo

de espera pela C'A&

4hroughput( maximi>ar o n*mero de Mo%s executados

em uma unidade de tempo

Escalonamento de Processos

2nfeli>mente# a maioria destes crit$rios $

contraditDrio(

minimi>ar o turnaround x minimi>ar o tempo de

resposta( para que os usu=rios interativos o%tenham
um tempo de resposta pequeno# geralmente os
usu=rios %atch so penali>ados com um tempo de
execuo maior e viceBversa&

Am algoritmo que maximi>a o throughput

geralmente no $ Musto com os processos de
execuo demorada&

etc#

-o se proMetar um algoritmo de scheduling# deveBse

ter em mente que o comportamento de um processo
$ imprevis?vel na maior parte dos casos& -ssim#
quase nunca se sa%e quando um processo ir= se
%loquear ou terminar a execuo# uma ve> a
execuo iniciada&

Escalonamento de Processos

Classificao dos escalonadores quanto G preempo

de processos(

Preempo( suspenso tempor=ria da execuo

de um processo

Escalonador no-preemptivo:Cuando um
processo o%tem o processador# ele roda at$ o fim
ou at$ que ele pea uma operao que ocasione o
seu %loqueio&

Escalonador preemptivo: Cada processo possui

um tempo m=ximo de permanIncia de posse do
processador& Cuando este tempo se esgota# o 3,
retira o processador deste processo e permite que
outro processo se execute&

Como controlar o tempo de execuo do

processoQ 4odo processador moderno possui um
clocF que gera interrupEes em uma frequIncia
determinada& Cada uma destas interrupEes $
chamada clock tick& , 3, mantem um contador
que $ decrementado a cada clocF ticF& 3e o
contador chegar a 9# o tempo de permanIncia do
processo aca%ou& , valor inicial deste contador
corresponde ao tempo m=ximo de permanIncia do
processo com a C'A e denominaBse time slice&

Escalonamento de Processos

Consideraes sobre escalonadores preemptivos e

escalonadores no-preemptivos

,s escalonadores noBpreemptivos so de
proMeto extremamente simples# por$m permitem
que um processo detenha a C'A por um tempo
ar%itr=rio& "este caso# um processo que fa>
somente c=lculo durante 0 hora o%teria o
monopDlio do processador# impedindo os outros
processos de rodarem& 2sso viola v=rios dos
crit$rios de um %om escalonador (Mustia# tempo
m?nimo de resposta# etc&

,s escalonadores preemptivos asseguram um

uso mais %alanceado da C'A e so utili>ados na
maioria dos 3, modernos& 'or$m# o proMeto de
tais escalonadores# al$m de ser complexo#
introdu> complicaEes na programao de
processos concorrentes& Como agora os
processos podem ser interrompidos em um
tempo ar%itrario# eles devem proteger suas
estruturas de dados contra a interferIncia de
outros processos (regiEes cr?ticas&

Al#oritmos de Escalonamento

, pro%lema a ser resolvido pelos algoritmos de

escalonamento $ o seguinte( dado um conMunto de
processos que devem ser executados# como dividir a
utili>ao do processador entre estes processosQ

%l0orit+os de es*alona+ento(
0
8scalonamento 7irstBComeB7irstB3erved (7C73

, processo o%tem a C'A de acordo com a ordem de

chegada das solicitaEes& , processo que pede a
C'A primeiro o%tem a C'A em primeiro lugar&

2mplementao( ,s processos que solicitam a C'A

so colocados em uma fila de prontos# que $
gerenciada segundo a pol?tica 727,&

, escalonamento 7C73 $ noBpreemptivo& -ssim#

um processo C'AL%ound pode fa>er com que v=rios
processos esperem por um tempo indeterminado&
CPU
2 $ * 3
A

Al#oritmos de Escalonamento
O
8scalonamento roundBro%in

Cada processo tem o direito de usar o

processador por um intervalo de tempo pr$B
definido& 8ste intervalo de tempo $ denominado
quantum& Cuando o quantum se esgota# o
processador $ dado a outro processo&

-lgoritmo Musto

7uncionamento(

Am dos maiores pro%lemas do algoritmo de

escalonamento roundBro%in di> respeito G
determinao do valor a ser atri%u?do ao
quantum& 'ara a determinao deste valor#
devemos levar em considerao o tempo m$dio
da troca de contexto e o tempo de resposta
deseMado&

normalmente# o quantum fica em torno de

099 ms&
CPU
2 $ * 3
A
t1
CPU
$ * 3 A
2
t2

Al#oritmos de Escalonamento
O
8scalonamento com prioridades

RaseiaBse no fato de que alguns processos so

priorit=rios e# assim# devem ser executados
antes dos outros&

- cada processo $ atri%u?da uma prioridade&

'rocessos com prioridade maior rodam
primeiro&

'ro%lema( Como impedir que processos com

prioridade mais alta monopoli>em o
processadorQ

- prioridade do processo que est= rodando

$ decrementada periodicamente pelo
escalonador&

Al#oritmos de Escalonamento
O
8scalonamento com prioridades (cont

Como atri%uir as prioridadesQ

de forma esttica: os processos so

divididos em classes e a cada classe $
atri%u?da uma prioridade& - cada
prioridade existe uma fila de prontos
associada
45
05
/5
2 $ * 3
6 G
7 ,
CPU
A
t1
45
05
/5
$ * 3 A
6 G
7 ,
CPU
2
t2

Al#oritmos de Escalonamento

de forma dinmica: o sistema analisa o

comportamento dos processos e atri%ui
prioridades favorecendo um certo tipo de
comportamento&

8xemplo( processos 2L, %ound devem

prossuir prioridade alta& 'rioridade
dinKmica( 1f# onde f $ a frao do
quantum de tempo usada na *ltima
rodada do processo&
O
3hortest No% 7irst (3N7

-lgoritmo proMetado para sistemas %atch

,%Metivo( redu>ir o tempo de turnaround

/equer que o tempo total de execuo do Mo%

seMa conhecido antes do in?cio da execuo

-lgoritmo( .ado um conMunto de Mo%s

prontos# execute os Mo%s com menor tempo de
execuo antes&
2 $ * 3
$ % $ $
ta! ta"# ta$" ta%
3 $ * 2
% $ $ $
ta% ta"# ta$& ta$"

Al#oritmos de Escalonamento
O
3hortest No% 7irst (3N7 (cont

-plicao para sistemas interativos(

processo interativo(
espera comando
executa comando

3e considerarmos cada executa comando

como um Mo%# podemos aplicar o 3N7 para
processos interativos&

'ro%lema( Como determinar o tempo de

execuo do comandoQ

Asar a t$cnica conhecida como a!in!#

que estima um valor %aseandoBse e
lem%randoBse dos valores passados&
Cuando um valor fica muito antigo# ele
praticamente no influencia mais na
estimativa&

8xemplo( 49( tempo m$dio de

execuo de um comando# 40( tempo
medido na *ltima rodada
4empo estimado S 4
4 S a49 ) (0Ba 40
, que acontece se aS0L<Q

Al#oritmos de Escalonamento
O
8scalonamento em dois n?veis

Am caso t?pico de escalonamento em dois

n?veis $ o algoritmo que considera tanto os
processos que esto em memDria como os
processos que esto em disco&

'rimeiro n?vel( manipula os processos

que esto carregados em memDria& 'ode
ser usada uma das H classes de
algoritmos descritas anteriormente

3egundo n?vel( examina periodicamente

o tempo de execuo dos processos e os
tira ou os carrega em memDria
(operaEes de swap inL swap out&

Cuando o modelo de processos inclui

threads# podemos ter tam%$m um algoritmo
de < n?veis& , primeiro n?vel determina que
processo ir= rodar e o segundo n?vel
determina qual thread do processo
selecionado ir= executar&

Com&nicao entre Processos

-o longo de sua execuo# um processo necessita

frequentemente interagir com outros processos&

- interao entre os processos pode ser de <

maneiras(

competio

cooperao

Competio

"este caso# os processos entram em conflito

pela utili>ao de recursos&

, processo que utili>a um recurso deve sempre

deix=Blo em estado consistente# pois o mesmo
poder= ser utili>ado por v=rios outros processos
que se desconhecem mutuamente&

-s relaEes de competio afetam todos os

processos que executam em um mesmo
computador&

3o ditas relaes m"nimas entre os processos&

Com&nicao entre Processos

Cooperao

"este caso# os processos que interagem entre si

possuem conhecimento da existIncia de outros
processos&

Cooperao por compartil#amento: os

processos no se conhecem explicitamente#
interagindo entre si atrav$s de vari=veis
compartilhadas& - cooperao por
compartilhamento pode levar a relaEes de
competio onde as vari=veis
compartilhadas so consideradas recursos&

Cooperao por comunicao( "este caso#

os processos enviam explicitamente valores
a outros processos& -s primitivas de
comunicao existentes so enviar e
re*e1er& - comunicao sD se completa
quando o par de primitivas enviar/re*e1er
$ executado&

- cooperao entre processos $ descrita

frequentemente na literatura como 2'C (interB
process communication&

Com&nicao entre Processos

Como o sistema operacional determina# atrav$s da

pol?tica de escalonamento# o processo que vai
rodar e por quanto tempo# no sa%emos a priori
em que ordem dois processos ativos iro se
executar&

CondiEes de corrida( -contecem frequentemente

quando dois ou mais processos acessam
concorrentemente as mesmas posiEes de
memDria& 3e o valor final contido nestas posiEes
depende da ordem na qual os processos foram
executados# estamos diante de uma condio de
corrida (race condition&

- existIncia de condiEes de corrida em um

sistema pode levar a resultados inesperados#
devido ao noBdeterminismo inerente a estas
condiEes&

Com&nicao entre Processos
Condi'es de corrida

'rimeiro exemplo de condiEes de corrida(

Considere dois processos - e R com o seguinte

cDdigo(

Considere que# inicialmente# o valor de xS9&

Cue valores de x podemos o%ter quando os
processos - e R se executam simultaneamenteQ
(3uponha um escalonador preemptivo&

Caso 0( 'rocesso - BT 'rocesso R

Processo A Processo B
x=x+1; x=x+1;
Processo A
LOAD x,R1 (x=0)
INC R1
STOR x,R1 (x=1)
Processo B
LOAD x,R1 (x=1)
INC R1
STOR x,R1 (x=2)
t
e
m
p
o

Com&nicao entre Processos
Condi'es de corrida

Caso <( 'rocesso- BT 'rocessoR BT 'rocesso-

8sta situao pode ocorrerQ 3e sim# em

que condiEesQ

Uoce considera que o programador

admitia# ao fa>er o seu programa# que a
variavel x pudesse assumir o valor 0 ao
final da execuoQ
Processo A
LOAD x,R1 (x=0)
INC R1
Processo B
LOAD x,R1 (x=0)
INC R1
STOR x,R1 (x=1)
t
e
m
p
o
STOR x,R1 (x=1)

Com&nicao entre Processos
Condi'es de corrida

3egundo exemplo de condiEes de corrida(

'ara que um arquivo seMa impresso# deveBse

colocar o seu nome em uma fila em memDria&
8sta fila $ controlada por duas vari=veis( out# que
indica a posio onde o nome do arquivo deve
ser escrito e in# que indica o arquivo que deve
ser impresso no momento&

, processo que deseMa imprimir arquivos

recupera a vari=vel out$ coloca o nome do
arquivo na posio indicada por out e incrementa
out de uma posio&
teste(c
cria(c
%
)
!*
processo spool+ imprime
processo A+ escre,e ar-&i,o
ar-(a na .ila de impresso
in/% o&t/!*
processo B+ escre,e ar-&i,o
ar-(0 na .ila de impresso
Processo A Processo B
escreve
(arqa,!o"#);
o"#=o"#+1;
escreve
(arq$,!o"#);
o"#=o"#+1;

Com&nicao entre Processos
Condi'es de corrida

Caso 0( 'rocesso - BT 'rocesso R

Processo A
LOAD o"#,R1 o"#(=10)
(co%oca arqa &a '(%a
&a )os(*+o 10)
INC R1
STOR o"#,R1 (o"#=11)
Processo B
t
e
m
p
o
LOAD (&,R1 (o"#=11)
(co%oca arq$ &a '(%a
&a )os(*+o 11)
INC R1
STOR o"#,R1 (o"#=12)
teste(c
cria(c
%
)
!* ar-(a
!! ar-(0
in/% o&t/!"

Com&nicao entre Processos
Condi'es de corrida

Caso <( 'rocesso- BT 'rocessoR BT 'rocesso-

Processo A
LOAD o"#,R1 (o"#=10)
(co%oca arqa &a
'(%a &a )os(*+o 10)
Processo B
t
e
m
p
o
LOAD (&,R1 (o"#=10)
(co%oca arq$ &a '(%a
&a )os(*+o 10)
INC R1
STOR o"#,R1 (o"#=11)
INC R1
STOR o"#,R1 (o"#=11)
teste(c
cria(c
%
)
!* ar-(0
in/% o&t/!!

Com&nicao entre Processos
Condi'es de corrida

-s condiEes de corrida levam geralmente a

resultados inesperados e# por isso# devem ser evitadas&

, que nDs precisamos $ de um meio de garantir que

uma poro de cDdigo seMa executada somente por um
processo de cada ve>& 7a>emos# assim# uma
seriali>ao da execuo&

8sta exclusividade na execuo de partes de cDdigo $

garantida por mecanismos que implementam a
excluso m*tua&

- parte do cDdigo protegida pelos mecanismos de

excluso m*tua $ denominada seo cr?tica&

"o exemplo 0# a seo cr?tica $ simplesmente a

instruo xSx)0& 8 no exemplo <Q

Com&nicao entre Processos
E1cl&so m2t&a

,s mecanismos de excluso m*tua devem garantir que

Mamais dois ou mais processos esteMam dentro da mesma
seo cr?tica simultaneamente&

$+ple+enta,o da e2*lus,o +3tua

'ode ser feita de duas maneiras(

8spera ocupada (%usy waiting( , processo

espera a permisso de entrada na seo cr?tica
em um loop de teste de permisso(
while (vez != minha) ;

- espera ocupada desperdia C'AOO

3D $ interessante utili>=Bla quando se sa%e

que a espera ser= pequena&

Rloqueio de processos( , processo que espera a

permisso de entrada na seo cr?tica executa
uma primitiva que causa o seu %loqueio at$ que
a seo cr?tica seMa li%erada&
if (vez != minha)
sleep();

, %loqueio ocasiona troca de contexto

entre processos BT esperas longas

Com&nicao entre Processos
E1cl&so m2t&a

Ama %oa soluo para o pro%lema da excluso

m*tua deve garantir os seguintes requerimentos(
0
excluso m*tua( 3e o processo '0 est=
executando na seo cr?tica# nenhum outro
processo pode estar executando nesta seo
cr?tica simultKneamente&
O
progresso( 3e no h= processo executando na
seo cr?tica x e existem processos querendo
entrar nela# somente os processos que deseMam
executar a seo cr?tica devem participar na
deciso de que processo pode acess=Bla& Caso
contr=rio# podemos retardar a execuo de
processos indefinidamente&
O
espera limitada (%ounded waiting( deve existir
um limite no n*mero de ve>es que outros
processos acessam a seo cr?tica quando 0
processo est= esperando para entrar nela&

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a
0
2ni%io de interrupEes( , processo que deseMa
acessar a seo cr?tica simplesmente desa%ilita
as interrupEes# acessa a seo cr?tica e a%ilita
novamante as interrupEes ao final da execuo
da seo cr?tica& .esa%ilitando as interrupEes#
o processo no pode ser interrompido pelo
escalonador pois este retira a C'A dos
processos atrav$s de interrupEes de tempo&

Caracter?sticas do algoritmo ( excluso

m*tua# progresso e espera limitada

'ro%lemas( por ser uma funo cr?tica# a

ini%io de interrupEes geralmente sD pode
ser executada em modo Fernel& , usu=rio
comum no tem acesso a esse tipo de
instruo&
,esa$(%(#a-(&#err")*.es();
/0exec"#a a se*+o cr(#(ca 0/
x=x+1;
a$(%(#a-(&#err")*.es();

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a
O
8strita -lternKncia( "este caso# cada processo tem
a sua ve> de entrar na seo cr?tica& - ve> de
entrar na seo cr?tica $ controlada pela vari=vel
vez.

ConsideraEes(

Caracter?sticas do algoritmo ( excluso

m*tua&

, algoritmo permite somente a entrada

alternada de dois processos na seo
cr?tica&

3e os dois processos possuem

velocidades diferentes de execuo do
loop# a execuo $ no otimi>ada
while (TRUE)

while (vez != !) ;
re"iao#critica();
vez = $;
re"iao#n%o#critica();
&
while (TRUE)

while (vez != $) ;
re"iao#critica();
vez = !;
re"iao#n%o#critica();
&
'$ '(

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a
O
-lgoritmo de .eFFer( 'rimeiro algoritmo que
permite que dois processos acessem
corretamente uma seo cr?tica sem a alternKncia
estrita& -l$m da vari=vel vez# serveBse de um
vetor que indica a inteno de um processo de
entrar na seo cr?tica&
while (TRUE)

fla")i* = TRUE;
while (fla")+*)

if (vez == +)

fla")i* = ,-./E;
while (vez == +) ;
fla")i* = TRUE;
&
&
secao#critica();
turn = +;
fla")i* = ,-./E;
&
'i S processo
M S 0 B i

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a
O
3oluo de 'eterson( 'eterson# em 0VW0#
propXs uma verso melhorada do algoritmo de
.eFFer&
int vez;
int interessados)(*;
entra0re"i%o(int processo)

int outro;
outro = $ 0 processo;
interessado)processo* = TRUE;
vez = processo;
while (vez==processo 11
interessado)outro* == TRUE) ;
&
sai#re"iao(int processo)

interessado)processo* = ,-./E;
&

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a
O
3oluo de 'eterson (cont( 4odo processo p
que deseMa executar uma seo cr?tica deve
fa>er(
entra#re"iao(p);
23 se4%o cr5tica 32
sai#re"iao(p);

Caracter?sticas do algoritmo(

preserva a excluso m*tuaY

permite o progressoY

satisfa> a espera limitadaY

8ste algoritmo resolve o pro%lema da

seo cr?tica somente para <
processos OO

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a
O
3oluEes que utili>am hardware adicional( "a
maioria das m=quinas comerciais# existem
algumas instruEes de hardware que auxiliam a
implementao da excluso m*tua(

2nstruEes da fam?lia 4estZ3et( testam e

setam um valor de maneira indivis?vel&

2mplementao da excluso m*tua(

test1set(l)6 temp=l; l=$;
return(temp);
reset(l)6 l=!;
while (test1set(v) != !);
23 se4%o cr5tica 32
reset(v);

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a
O
3oluEes que utili>am hardware adicional (cont(

2nstruEes da fam?lia CompareZ3wap(

instruEes desta fam?lia possuem : parKmetros( o
valor deseMado# o novo valor e uma posio de
memDria& 3e o valor da posio de memDria for
igual ao valor deseMado# atri%uiBse o novo valor G
posio de memDria# de maneira atXmica& Caso
contr=rio# $ retornado falso&

2mplementao da seo cr?tica(

7omp1/wap(v$8v(8w)6
temp=w;
if (temp == v$)
w=r(; z=$;
else
r$=temp; z=!;
return(z);
while (7omp1/wap(!8$8v) != $;
23 secao critica 32
7omp1/wap($8!8v);

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a

-t$ agora# foram apresentadas soluEes que utili>am

a espera ocupada para implementar a excluso
m*tua&

-rgumentos em favor do %loqueio de processos(

8vitar o disperd?cio de C'A

8vitar o pro%lema da prioridade invertida(

3e o algoritmo de escalonamento utili>ado $

um algoritmo de escalonamento por
prioridades est=ticas# e se os processos que
acessam a seo cr?tica possuem classes de
prioridades diferentes# podemos chegar G
seguinte situao(

processo '0 (prioridade %aixa entra na

seo cr?tica

processo '< (prioridade alta entra no

loop de teste de acesso G seo cr?tica

como a execuo do loop no causa o

%loqueio de '<# ele sD sai pelo quantum
mas nesse caso# um processo com a
mesma prioridade que a de '< ou maior
ser= escolhido

'0 no $ executado nunca mais

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a 4 Blo-&eio de processos

'rimitivas usadas para implementar o %loqueio de

processos G espera da seo cr?tica( 3empre temos
pares de primitivas( 0 primitiva para %loquear o
processo e outra primitiva para des%loquear os
processos G espera da permisso de acesso G seo
cr?tica&

8xemplo( 3leep e JaFeup

sleep(v( %loqueia o processo que a chamou

waFeup(v( des%loqueia os processos que esto

esperando pela seo cr?tica controlada pela
vari=vel v&

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a 4 5em6.oros

3em=foros( foram definidos por .iMFstra em 0V[6&

Am sem=foro $ uma vari=vel inteira que admite
somente valores no negativos& .uas operaEes
indivis?veis podem ser executadas so%re um
sem=foro(

%o&n'sem( ou P'sem(:.ecrementa o valor do

sem=foro se este for maior que 9& 3e o valor do
sem=foro for 9# o processo que executou a
operao $ %loqueado&

)p'sem( ou *'sem(( 2ncrmenta o valor do

sem=foro e acorda os processos que estiverem
%loqueados no sem=foro&
'(sem)6 if (sem 9 !)
sem = sem 0$;
else
:lo;ueia(sem);
<(sem)6 if (processos#espera())
acorda#processo();
sem = sem =$;

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a 4 5em6.oros

+emforos binrios( sD podem assumir os

valores 9 ou 0&

+emforos !enerali,ados( podem assumir

tam%$m valores negativos

+emforos com bus- &aitin!: ,s sem=foros

tam%$m podem ser implementados de maneira
mais simples# com as operaEes a%aixo& 8ste
tipo de implementao no $ muito utili>ado
atualmente&
'(sem)6 while (sem >= !);
sem = sem 0 $;
<(sem)6 sem = sem = $;

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a 4 7oc8s

,s locFs so estruturas de dados compatilhadas que

garantem a excluso m*tua por software&

8m geral# o locF $ condedido a um processo de cada

ve>&

,peraEes so%re locFs(

acquire(l ( o%tem a propriedade do locF lY

release(l( li%era o locF lY

-s primitivas de acesso aos locFs so chamadas de

sistema e podem ser implementadas tanto como
espera ocupada (spin locFs ou com o %loqueio do
processo (locFs mutex&
ac;uire(x);
23 secao critica 32
release(x);

Com&nicao entre Processos
T3cnicas de controle de condi'es de corrida
4 Contadores de E,entos

Contadores de evento( 8ste mecanismo resolve o

pro%lema das condiEes de corrida sem utili>ar a
excluso m*tua entre processos& 4rIs operaEes so
executadas em um contador de eventos(

/ead(ev( lI o valor corrente de evY

-dvance(ev( incrementa ev de 0#

-wait(ev# v( espera at$ que ev TS v&

,s contadores de eventos so monotXnicos

crescentes&

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a 4 Monitores

-t$ agora# ao programador $ dado um conMunto de

primitivas e ele deve garantir que estas primitivas
so utili>adas corretamente (ex( todo '(s deve ter
um U(s associado& - programao da
concorrIncia $ dita# neste caso# programao de
%aixo n?vel&

8m 0V\H# @oare propXs um mecanismo de alto

n?vel para a sincroni>ao de processos# chamado
monitor&

!onitor( conMunto de procedures e dados

agrupados por mDdulo& Cada mDdulo $ um
monitor& ,s processos sD podem chamar os
procedimentos# nunca acessando diretamente os
dados&

8xemplo de monitor(
1o&(#or nome
23 declaracao de variaveis 32
)roce,"re p!;
....
e&, )0;
e&, 1o&(#or;

Com&nicao entre Processos
T3cnicas de implementao de e1cl&so
m2t&a 4 Monitores

Caracter?stica importante do monitor( no pode

haver dois processos ativos dentro do monitor
simultaneamente&

, monitor normalmente $ uma construo de

linguagem de programao&

-ssim# o compilador desta linguagem# ao

reconhecer que $ uma chamada a monitor e no uma
chamada a procedure comum# deve garantir que o
processo sD executa esta procedure se no houver
mais ninguem executando& Cuem se preocupa em
garantir a excluso m*tua $ o compilador e no o
programador&

- *nica tarefa do programador $ identificar as

seEes cr?ticas e coloc=Blas dentro do monitor&

'ara implementar a excluso m*tua dentro de um

monitor# o compilador usa geralmente estruturas de
%aixo n?vel# como por exemplo# sem=foros&

'ro%lema( o conceito de monitor deve estar contido

na linguagem de programao e a maioria das
linguagens atuais no suporta este conceito&

Com&nicao entre Processos
T3cnicas de ordenamento de processos 4
9ari6,eis de condio

-t$ agora# os mecanismosapresentados concedem a

posse da seo cr?tica a um processo 'i quando no
existe nenhum outro processo utili>ando a mesma
seo&

8xistem# por$m# casos onde um processo sD deseMa

acessar uma seo cr?tica se uma determinada
condio ocorrer&

Uari=veis de condio so utili>adas para ordenar a

execuo de diferentes processos& 8las permitem
que um processo se %loqueie esperando uma ao
de outro processo&

8xistem duas operaEes poss?veis so%re as

vari=veis de condio(

wait(var( %loqueia o processo em var

signal(var( acorda o(s processo(s %loqueados

em var&

Com&nicao entre Processos
T3cnicas de ordenamento de processos 4
9ari6,eis de condio

-s vari=veis de condio so oferecidas atualmente

no pacote pthreads (',321 threads para sistemas
Anix&

7uncionamento das vari=veis de condiEes no

pacote pthreads(

Cada vari=vel de condio possui um locF

associado&

, processo o%tem o locF (mutex]locF&

, processo li%era o locF e espera na vari=vel de

condio (cond]wait

Cuando a condio deseMada ocorre# o processo

sinali>a (cond]signal

, processo em wait $ acordado e quando ele

volta a executar est= de posse do locF&

Com&nicao entre Processos
E1emplo de &tili:ao de mecanismos de
e1cl&so m2t&a

'ro%lema( 'rodutorBConsumidor

"este pro%lema# dois processos p9 e p0

compartilham um %uffer de tamanho fixo& ,
processo p9 escreve dados no %uffer e o processo
p0 retira dados do %uffer&

Como o %uffer tem tamanho fixo# devemos ter uma

vari=vel que controle o n*mero de mensagens no
%uffer# para que o processo produtor no escreva no
%uffer cheio e o processo consumidor no retire
dados do %uffer va>io& , n*mero de mensagens no
%uffer $ uma vari=vel compartilhada e o acesso a
ela pode levar a condiEes de corrida
p! p$

Com&nicao entre Processos
5ol&o do Prod&tor;Cons&midor
5leep4<a8e&p
void produtor()

int item;
while (TRUE)

produz#item (1item);
if (cont == ?) sleep(v$);
insere#item(item);
cont==;
if (cont == $) wa@eup(v();
&
&
void consumidor()

int item;
while (TRUE)

if (cont == !) sleep(v();
remove#item(1item);
cont00;
if (cont == ?0$) wa@eup(v$);
consome#item(item);
&
&

Com&nicao entre Processos
5ol&o do Prod&tor;Cons&midor
5em6.oros
semaphore mutex = $;
semaphore vazio = ?; 23 vazias 32
semaphore cheio = !; 23 ocupadas 32
void produtor()

int item;
while (TRUE)

produz#item(1item);
'(1vazio);
'(1mutex);
insere#item(1item);
<(1mutex);
<(1cheio);
&
&
void consumidor()

int item;
while (TRUE)

'(1cheio);
'(1mutex);
remove#item(1item);
<(1mutex);
<(1vazio);
consome#item(item);
&
&
semAforo mutex6 controla a se4%o cr5tica
semAforos cheio e vazio6 semAforos de
sincroniza4%o

Com&nicao entre Processos
5ol&o do Prod&tor;Cons&midor
Monitores
monitor produtor0consumidor
condicao cheio8 vazio;
int cont;

cont = !;
procedure insere

if (cont == ?) wait(cheio);
insere#item();
cont==;
if (cont == $) si"nal(vazio);
&

procedure remove

if (cont == !) wait(vazio);
remove#item();
cont00;
if (cont == ?0$) si"nal(cheio);
&
end monitor;

Com&nicao entre Processos
5ol&o do Prod&tor;Cons&midor
Monitores
produtor()

while(TRUE)

produz#item(1item);
produtor0consumidor.insere();
&
&
consumidor()

while(TRUE)

produtor0consumidor.remove();
consome#item(item);
&
&

Com&nicao entre Processos
Troca de mensa#ens

-t$ agora admitimos que os processos cooperantes

possuem um meio de compartilhar vari=veis& 8m
sistemas onde a memDria f?sica $ *nica ou
compartilhada entre v=rios processadores# os
mecanismos descritos at$ ento podem ser
utili>ados& 8m am%ientes distri%u?dos# onde no
existe uma memDria f?sica compartilhada# devemos
utili>ar outro tipo de mecanismo& 7oram# ento#
propostos sistemas %aseados em troca de
mensagens&

- troca de mensagens pode ser utili>ada tanto em

sistemas com memDria compartilhada como em
sistema com memDria distri%u?da&

- troca de mensagens $ expl?cita& Am processo

envia uma mensagem e outro processo a rece%e& 3D
neste momento# a comunicao $ esta%elecida&

'rimitivas %=sicas de troca de mensagens(

send( envia uma mensagem

receive( rece%e uma mensagem

Caracter=sticas da Com&nicao por
Troca de Mensa#ens

Cuando proMetamos a comunicao por troca de

mensagens devemos nos preocupar com os seguintes
aspectos no proMeto das primitivas(

tipo das primitivas( %loqueadasLnoB%loqueadas

tipo da comunicao( 0 a 0# n a 0# n a n

'rimitivas %loqueadas x primitivas noB%loqueadas

- comunicao por troca de mensagem $ composta

por duas partes( uma que quer enviar mensagens e
outra que deseMa rece%IBlas& , momento onde a troca
de mensagens realmente ocorre $ denominado rende>B
vous&

"o proMeto das primitivas de comunicao# devemos

determinar o comportamento delas no caso da outra
parte no estar em ponto de rende>Bvous quando
executamos a nossa primitiva&
P! P"
en,ia>ms#?@
rece0e>ms#?@
rendez-vous
tempo

Caracter=sticas da Com&nicao por Troca de
Mensa#ens
Tipo da com&nicao

'ara este caso# podemos tomar %asicamente duas

atitudes( esperamos que a outra parte chegue ao ponto de
rende>Bvous# %loqueando o processo que executou a
primeira primitiva at$ que isso acontea (primitivas
%loqueadas ou permitimos que o processo que executou
a primeira primitiva continue a sua execuo#
transmitindo a mensagem somente quando a primitiva
correspondente for executada (primitivas noB
%loqueadas&

Pri+itivas 1loqueadas

Comportamento (send antes do receive

P! P"
en,ia>ms#?@
rece0e>ms#?@
rendez-vous bloqueio
recomea a
execuo
recomea a
execuo
tempo

Tipo da com&nicao
Primiti,as 0lo-&eadas

Comportamento (receive antes do send

- comunicao que utili>a primitivas %loqueadas $

dita comunicao s?ncrona porque# no momento da
troca de mensagens# cada processo envolvido na
comunicao sa%e exatamente em que estado da
execuo se encontra o outro processo (ele est=
executando a primitiva de comunicao& -ssim#
al$m de comunicar dados# os processos trocam
implicitamente informaEes so%re o seu estado de
execuo
P! P"
rece0e>ms#?@
en,ia>ms#?@
rendez-vous bloqueio
recomea a
execuo
recomea a
execuo

Tipo da com&nicao
Primiti,as no40lo-&eadas

Pri+itivas n,o/1loqueadas

Comportamento (send antes do receive

Comportamento (receive antes do send

P! P"
en,ia>ms#?@
rece0e>ms#?@
transfere msg
recomea a
execuo
recomea a
execuo
P! P"
rece0e>ms#?@
en,ia>ms#?@
transfere_msg
recomea a
execuo
recomea a
execuo
rece0e>ms#?@
recomea a
execuo

Processos en,ol,idos na Com&nicao
'rocessos envolvidos na comunicao(
1 a 1( , processo . envia uma mensagem ao processo
-& , processo - rece%e somente a mensagem do
processo .&
8xemplo(
send(x# ZmsgY
receive(y# ZmsgY
n a 1( , processo . envia uma mensagem ao processo
-& , processo - rece%e mensagem de qualquer
processo&
8xemplo(
send(estrutra]x# ZmsgY
receive(estrutura]x# ZmsgY
!ecanismos que implementam a comunicao n
a 0( portas# caixasBpostais restritas&
P!
P1
P"
Pn
msg
msg
msg
estrutura8x

Processos en,ol,idos na Com&nicao

n a n( , processo . envia uma mensagem a qualquer

processo& , processo - rece%e mensagem de qualquer
processo&

8xemplo(
estrutura]y S aloca]caixa]postal(Y
send(estrutra]y# ZmsgY
receive(estrutura]y# ZmsgY

!ecanismos que implementam a comunicao n

a n( caixasBpostais gen$ricas&
P!
P1
P"
Pn
msg
msg
msg
estrutura8.
msg

Com&nicao entre Processos
5ol&o do Prod&tor;Cons&midor
Troca de mensa#ens

"este exemplo# vamos utili>ar primitivas s?ncronas

0 a 0&
produtor()

while(TRUE)

produz#item(1item);
send(p(8 1item);
&
&
consumidor()

while(TRUE)

receive(p$8 1item);
consome#item(item);
&
&

Com&nicao entre Processos
Os .ilAso.os #l&t'es

8xistem v=rios pro%lemas que foram propostos na

=rea de comunicao entre processos e servem para
ilustrar o que pode ocorrer se a concorrIncia no for
corretamente tratada& .entre estes pro%lemas# vamos
analisar(

,s filDsofos glutEes

, pro%lema dos leitoresLescritores

, %ar%eiro dorminhoco

.s 4il5so4os 0lutes (t6e dinin0 p6ilosop6ers)

'roposto por .iMFstra em 0V[6&

7ormulao(

8xistem 6 filDsofos sentados em torno de

uma mesa redonda&

8xiste um prato em frente de cada filDsofo e

um garfo entre cada < pratos&

Cada filDsofo necessita de < garfos para

comer&

,s filDsofos sD tomam < aEes( pensar e

comer&

- deciso de comer implica em pegar 0

garfo# pegar o outro garfo e comer&

Com&nicao entre Processos
Os .ilAso.os #l&t'es

Cuesto( /esolver algoritmicamente este pro%lema

de maneira que no haMa deadlocF nem starvation e
que seMa permitida a m=xima concorrIncia poss?vel&

'rimeira soluo (imediata(

Bdefine ? C
void filosofo (int i)

while ($)
pensa();
pe"a#"arfo(i);
pe"a#"arfo((i=$) D ?);
come();
li:era#"arfo(i);
li:era#"arfo((i=$) D ?); &
&
$
$
(
(
E
E
F
F
C
C

Com&nicao entre Processos
Os .ilAso.os #l&t'es

-n=lise da primeira soluo(

'
'ode levar a deadlocF se todos os filDsofos
pegarem o garfo ao mesmo tempo&

3egunda soluo

-n=lise da segunda soluo(

'
'ode levar a starvation
void filosofo (int i)

while ($)
pensa();
pe"a#"arfo(i);
if (ocupado#"arfo((i=$)D?);
li:era#"arfo(i);
else
pe"a#"arfo((i=$) D ?);
come();
li:era#"arfo(i);
li:era#"arfo((i=$) D ?); & &
&

Com&nicao entre Processos
Os .ilAso.os #l&t'es

4erceira soluo (correta(

RaseiaBse na introduo de estados dos

filDsofos (pensando# com fome# comendo& Am
filDsofo sD pode estar comendo se os seus
vi>inhos no estiverem comendo&

8xistem in*meras soluEes para este pro%lema

que seguem estas constataEes& - soluo
apresentada a seguir usa monitores e vari=veis
de condio
monitor filosofos#"lutoes
var estado6 arraG)!..F* of
(pensando8 comfome8 comendo)
var meu#estado6 arraG)!..F* of condicao;
procedure pe"a(i)
:e"in
estado)i* 6= comfome;
testa(i);
if (estado)i* != comendo)
then condition#wait(meu#estado)i*);
end

Com&nicao entre Processos
Os .ilAso.os #l&t'es

4erceira soluo (continuao(

procedure lar"a(i)
:e"in
estado)i* 6= pensando;
testa ((i0$) D C);
testa ((i=$) D C);
end
procedure testa(i)
:e"in
if ((estado)(i0$) D C* != comendo) 2
(estado)i* = comfome) 2
(estado)(i=$) D C* != comendo))
then
:e"in
estado)i* 6= comendo;
cond#si"nal(meu#estado)i*);
end;
end
:e"in
for i6=! to F
do estado)i* 6= pensando;
end

Com&nicao entre Processos
Os .ilAso.os #l&t'es

4erceira soluo (continuao(

Cada filDsofo deve executar o seguinte

cDdigo(

8sta soluo $ livre de deadlocF e garante a

excluso m*tua (nunca dois vi>inhos vo
estar comendo ao mesmo tempo e a
concorrIncia m=xima (at$ dois filDsofos
podem comer ao mesmo tempo# por$m um
filDsofo pode ficar esperando indefinidamente
(starvation&
filosofos#"lutoes.pe"a(i);
23 come 32
filosofos#"lutoes.lar"a(i);

Com&nicao entre Processos
Os leitores;escritores

'roposto por Courtois et al& em 0V\0&

4am%$m conhecido como protocolo !ultiple /eaders

L 3ingle Jriter&

!odela pro%lemas onde v=rios leitores podem

acessar um dado simultaneamente por$m o escritor
deve ter acesso exclusivo& 8x( %ases de dados&

3oluo com sem=foros e duas seEes cr?ticas( uma

para os leitores e outra para os escritores(
semaphore mutex = $8 d: =$;
int num#leitores;
void reader()

while ($)
'(1mutex);
num#leitores = num#leitores = $;
if (num#leitores == $)
'(1d:);
<(1mutex);
le#dados();
'(1mutex);
num#leitores = num#leitores 0$;
if (num#leitores == !) <(1d:);
<(1mutex);
23 fora da secao critica 32
&

Com&nicao entre Processos
Os leitores;escritores

3oluo com sem=foros e duas seEes cr?ticas

(cont(

8sta soluo favorece os leitores( o escritor deve

esperar at$ que no haMa mais nenhum leitor&

-ltere esta soluo para que os escritores seMam

favorecidos&
void writer()

while ($)

23 secao n%o critica 32
'(1d:);
escreve#dados();
<(1d:);
&
&

Com&nicao entre Processos
O 0ar0eiro dorminBoco

'roposto por .iMFstra em 0V[6&

"uma %ar%earia# existem um %ar%eiro# uma cadeira

de %ar%eiro e v=rias cadeiras de clientes& 3e no h=
nenhum cliente na %ar%earia# o %ar%eiro dorme& 3e
chegarem clientes e o %ar%eiro estiver cortando o
ca%elo de algu$m# os clientes esperam nas cadeiras&
3e no houver cadeiras# os clientes vo em%ora&

3oluo com : sem=foros(

semaphore clientes = !;
semaphore :ar:eiro = !;
semaphore mutex = $;
int esperando = !;
void Har:eiro()

while ($)
'(clientes);
'(mutex);
esperando = esperando 0 $;
<(:ar:eiro);
<(mutex);
23 corta ca:elo 32 &
&

Com&nicao entre Processos
O 0ar0eiro dorminBoco

3oluo com : sem=foros(

void cliente()

'(mutex);
if (esperando > 7-IEJR-/)
esperando = esperando =$;
<(clientes);
<(mutex);
'(:ar:eiro);
23tem o ca:elo cortado 32
&
else
<(mutex);