LabSO Retrospectiva da aula

Gerência de Processos passada...

AULA 4
Flávia Maristela (flavia@flaviamaristela.com)
Romildo Martins (romildo@romildo.net)

Na aula passada... Na aula passada...

Processos Threads
– Estados do processo – Motivação
– Transições de processos – Conceito
– O que motiva a criação de um processo? – Multithreading
– Como um processo pode ser executado?
– Estados
– O que motiva a finalização de um processo?
– Transições
– Como visualizar processos no Windows
– Como visualizar processos no Linux – Gerenciamento de threads
– Hierarquia de processos – Operações
 Na aula passada... Na aula passada...
Gerência de processos Gerência de processos
– Trata do compartilhamento de recursos entre – Problemas associados a comunicação de
os processos processos:
– Processos cooperantes precisam trocar • Condição de corrida (race condition)
informações • Produtor vs. Consumidor
– Como os processos se comunicam?
• Troca de mensagens (sincronização ou
bufferização)
• Compartilhamento de memória
– Informações são trocadas numa área compartilhada
– Operação não é gerenciada pelo sistema operacional

Comunicação entre processos

Na aula de hoje...
(-- Race condition --)
Race condition
Região Crítica
Exclusão Mútua
Problemas Clássicos
Escalonamento
Dois processos podem tentar ler ou escrever
dados num espaço compartilhado, e o resultado
final depende de quem está executando
naquele momento.
 Comunicação entre processos Comunicação entre processos
(-- Race condition e região crítica --) (-- Race condition e região crítica --)
O que causa condição de corrida? Como evitar condições de corrida?
– QUALQUER TIPO DE COMPARTILHAMENTO!!
– Sincronizando os processos
O trecho de código em que a memória
compartilhada é acessada é chamado de região ou seja
crítica.

P1: P2:
Considerando x = 2 – Proibindo que mais de um processo possa ler
x := x + 1 x := x * 2
y := 5 + 2 a := 2 * 5
P1
P2 : x = 6 ou escrever numa área compartilhada ao
P2
P1 : x = 5
z := y + t c := a - 7 mesmo tempo.

Comunicação entre processos

Para pensar...
(-- Exclusão Mútua --)
Definição: Pense no problema do PRODUTOR vs.
– Mecanismo que garante que cada processo CONSUMIDOR.
que usa uma área compartilhada terá acesso
exclusivo a mesma.
O que acontece se quando o produtor
estiver armazenando um item, o
consumidor não puder consumir nada?

Qual é o problema da exclusão mútua??

 Comunicação de Processos Comunicação de Processos
(-- Exclusão mútua e região crítica --) (-- Exclusão mútua e região crítica --)
Dois processos não podem estar simultaneamente em
suas regiões críticas

Nada pode ser assumido com relação a velocidade dos

processos ou quantidade de processadores disponível

Nenhum processo fora de sua região crítica pode

bloquear um processo que esteja na região crítica

Nenhum processo deve esperar indefinidamente para

entrar na região crítica.

Tanenbaum, Capítulo 2

Comunicação de Processos Comunicação de Processos

(-- Como implementar exclusão mútua --) (-- Exclusão mútua + espera ocupada --)
Espera ocupada Premissa da espera ocupada:
Sleep and wakeup – Enquanto um processo executa na região
crítica, o outro apenas espera.
Semáforos
Mutex
Formas de implementar:
Monitores
– Interrupção:
• Problema: não é ideal que processos tenham
controle sobre as interrupções
 Comunicação de Processos
(-- Exclusão mútua + espera ocupada --)
Formas de implementar:
– Alternância Obrigatória
Comunicação de Processos
(-- Sleep e Wakeup --)
Comunicação de Processos
(-- Sleep e Wakeup --)
Primitivas (chamadas de sistemas)
sleep()
– Bloqueia um processo enquanto aguarda um recurso
wakeup()
– Ativa o processo quando o recurso foi liberado
Comunicação de Processos
(-- Semáforo --)
Proposto por E. Dijkstra em 1965
Apesar de ser um mecanismo antigo, ainda é bastante
utilizado em programação concorrente.
Na prática, é uma variável que deve ser executada de
forma atômica*
– A variável possui um contador e uma fila de tarefas;
Duas primitivas podem ser executadas sobre a variável:
– Up()
V()
– Down()
P()
 Comunicação de Processos Comunicação de Processos
(-- Semáforo --) (-- Semáforo --)
Tipo de dado abstrato: Down()
– Contador: inteiro – Decrementa o contador
– Fila de processos – solicita acesso à região crítica
• Livre: processo pode continuar sua execução;
Contador: inteiro • Ocupada: processo solicitante é suspenso e
Semáforo

Fila de processos adicionado ao final da fila do semáforo;

Down(s):
s.counter--
if (s.counter < 0) contador = contador - 1
{
s.enqueue (processo_atual) P1
suspend(processo_atual)
}

Comunicação de Processos Comunicação de Processos

(-- Semáforo --) (-- Semáforos --)
Up ()
– Incrementa o contador
– Liberar a seção crítica
• Tem processo suspenso: acordar o processo
Como resolver o problema do
(volta a fila de pronto)
– Chamada é não bloqueante
o processo
Produtor vs. Consumidor
não precisa ser suspenso para executá-la. usando semáforos?
Up(s):
s.counter++
if (s.counter ≤ 0) contador = contador + 1
{
s.dequeue (processo_atual) P1
acorda (processo_atual)
} Sai da fila de bloqueado
 Comunicação de Processos Comunicação entre processos
(-- Problemas clássicos --) (-- O jantar dos filósofos --)
Jantar dos filósofos
Escritores e Leitores
Barbeiro dorminhoco

Comunicação entre processos Comunicação entre processos

(-- O jantar dos filósofos --) (-- O jantar dos filósofos --)
Formulado por E. Dijkstra para Descrição
caracterizar o problema da sincronização – Cada filósofo pode “comer” ou “pensar”
e concorrência – Cada filósofo usa dois garfos para comer
– Cada filósofo pega um garfo por vez
Descrição
– 5 filósofos numa mesa de jantar circular
– 5 pratos de espaguete
– 1 garfo entre cada par de pratos
 Jantar dos filósofos Jantar dos filósofos
(-- 1ª solução --) (-- 2ª solução --)
#define N 5 #define N 5 O que acontece se todos os
filósofos pegam o garfo da
void philosopher (int i) esquerda simultaneamente?
void philosopher (int i) {
{ while (TRUE)
{ – INANIÇ
INANIÇÃO (starvation
(starvation))
while (TRUE) O que acontece se todos os think();
{ filósofos pegam o garfo da take_fork (i);
think(); esquerda simultaneamente? if (fork((i+1) % N) is available)
– Nenhum filósofo consegue {
take_fork (i); pegar o garfo da direita take_fork ((i+1) % N);
take_fork ((i+1) % N); – DEADLOCK eat();
eat(); put_fork (i);
put_fork ((i+1) % N);
put_fork (i); }
put_fork ((i+1) % N); else
} put_fork (i);
}
} }

Jantar dos filósofos Jantar dos filósofos

(-- 3ª solução --) (-- 3ª solução --)
#define N 5 O que acontece nesta solução? Atribui 3 possíveis estados aos filósofos
– Apenas um filósofo come por – PENSANDO
void philosopher (int i) vez
{ – Afeta o PARALELISMO
– COMENDO
while (TRUE) – FAMINTO
{
think();
down(mutex);
Idéia:
take_fork (i); – Um filósofo no estado “faminto” só pode pegar os
take_fork ((i+1) % N); garfos se os seus vizinhos (esquerda e direita) não
eat();
estiverem “comendo”.
put_fork (i);
put_fork ((i+1) % N); Estudar a solução para o problema dos
up(mutex); filósofos!
}
}
Comunicação entre processos Comunicação entre processos
(-- Os leitores e escritores --) (-- Barbeiro dorminhoco --)

Database

DEADLOCK Deadlock
Problema de programação concorrente

“Um conjunto de n processos está em

deadlock quando cada um dos n
processos está bloqueado a espera de um
evento que somente pode ser causado
por cada um dos n processos.”
 Porque é necessário escalonar?
Processos precisam ser executados

Escalonamento de Processos concorrem a CPU

Processos Escalonador:
– Componente (implementação) do sistema
operacional

– Determina a ordem de execução dos processos

baseado num algoritmo de escalonamento

– Lê a fila que contém os processos no estado “pronto”

e os ordena para execução

O que provoca o escalonamento? Tipos de algoritmo de escalonamento

Preemptivo:
Novo – Execução de um processo dura um tempo pré-
determinado
– Quando o tempo acaba, o processo é interrompido.
Pronto Executando

Não-preemptivo:
– Processo fica em execução até que:
Bloqueado
Terminado • Termine
• Libere a CPU VOLUNTARIAMENTE
• Seja bloqueado por falta de recurso
 O que afeta a performance de um
Ilustração da troca de contexto
algoritmo de escalonamento?
Cada processo possui informações que
permitem definir precisamente seu estado. preempção
• Tais informações definem o contexto do processo

Troca de Contexto Processo 1

Dispatcher
Escalonador
Dispatcher
Processo 3
(P1) (P3)
– Mecanismo que permite ao escalonador interromper tempo
uma tarefa, e executá-la posteriormente, sem
corromper seu estado. Verificar
Salvar o contexto de P1 qual o próximo
Restaura o contexto de
processo a ser executado
P3

– Separação do escalonamento
• Escalonamento = Política + Mecanismo

Qual o objetivo do escalonamento? Qual o objetivo do escalonamento?

DEPENDE do tipo de sistema operacional
– Lote:
• Não possui usuários aguardando
pode ser
preemptivo ou não
• Não possui muita troca de contexto
– Propósito Geral:
• Possuem usuários interagindo
• Precisam ser preemptivos
• OBJETIVOS
– melhorar o tempo médio de resposta
– atender as expectativas dos usuários

• OBJETIVOS:
– melhorar o throughput (vazão) – Tempo real:
– melhorar o turnaround (tempo entre submissão e • Em geral são preemptivos
finalização) • OBJETIVO:
– manter a CPU ocupada – cumprir requisitos lógicos
– cumprir requisitos temporais
Qual o objetivo do escalonamento? Escalonamento para sistemas em lote

Independente do tipo de sistema operacional, FCFS (ou FIFO)

TODOS os algoritmos de escalonamento – Primeiro processo da fila de pronto é o
precisam atender a alguns critérios: escolhido para executar.
– Não-preemptivo
– Justiça (fairness) – Fácil de entender
– Aplicação da política de escalonamento – Fácil de programar
– Equilíbrio (balance) entre as partes do sistema – “Justo”
– Processos de baixo custo de execução
podem esperar muito tempo para ser
executado

Escalonamento para sistemas em lote Escalonamento para sistemas em lote

FCFS (ou FIFO) Menor Job Primeiro

– Fazer o escalonamento para os seguintes processos: – O job de menor custo de execução executa
primeiro.
– Não-preemptivo
Processo Custo de
execução
– Fácil de entender
A 12 – Fácil de programar
B 8 – “Justo”
C 15 – Para ser adequado requer que todos os jobs
estejam disponíveis simultaneamente
D 5
 Escalonamento em sistemas de
Escalonamento para sistemas em lote
propósito geral
Menor Job Primeiro Alternância circular (round-robin)
– Fazer o escalonamento para os seguintes
processos – Processos executam dentro de uma fatia de
tempo predefinida (quantum)
quantum
– Preemptivo
Processo Custo de
execução
– Simples
A 12 – Justo
B 8 – Amplamente utilizado
C 15 – Tamanho do quantum pode ser um problema
D 5

Escalonamento em sistemas de Escalonamento em sistemas de

propósito geral propósito geral
Round-Robin Prioridade
– Fazer o escalonamento para os seguintes
processos considerando um quantum = 3 – Processos tem diferentes prioridade de
execução
– Preemptivo
Processo Custo de Prioridade – Baseado nos ciclos da CPU ou quantum
execução – Prioridade pode ser atribuída estaticamente
A 12 3 ou dinamicamente
B 8 4 – Pode ser implementado considerando filas de
prioridades
C 15 2
– Pode ocasionar starvation
D 5 1
 Escalonamento em sistemas de
Para a próxima aula
propósito geral
Prioridade Trazer todos os exercícios dos slides
– Fazer o escalonamento para os seguintes
processos respondidos.
Verificar as implementações de semáforo
para o problema do produtor consumidor.
Processo Custo de Prioridade
execução Escalonamento com múltiplas filas.
A 12 3 Descrever a diferença entre processos
B 8 4 I/O- Bound e CPU-Bound.
C 15 2
D 5 1