SISTEMAS OPERACIONAIS 1

Sistemas Operacionais

Unidade Dois

Prof. Flávio Márcio de Moraes e Silva


Prof. Flávio Márcio 2

Conceito de Processo

Processo – um programa em execução Organizados em vários processos seqüenciais

Um processo inclui: Contador de programa Registradores (pilha) Variáveis (seção de dados)



Estados de Processos

A medida em que o programa executa, seu estado muda:

Novo: O processo está sendo criado Pronto: O processo está esperando para ser atribuído

a um processador Em execução: Instruções estão sendo executadas Em espera: O processo espera por um evento Encerrado: O processo terminou sua execução



Estados de Processos

novo

pronto em execução

em espera

encerrado

1

2

3

4



Transição de Estado

Transição 1 Ocorre quando um processo descobre que não pode

prosseguir

Transições 2 e 3 São causadas pelo escalonador de processo O processo não precisa tomar conhecimento que foi

interrompido Dispatcher = responsável pela reposição de contexto

(voltar valores dos registradores na transição 3)

Transição 4 Ocorre quando acontece um evento externo pelo qual um

processo estava aguardando



Bloco de Controle de Processos

Informação associada com cada processo Contador de Programa Pilha de execução Registradores da CPU

Estado do processo (apto, executando, bloqueado,etc) Informações de escalonamento de CPU (tempo de

processador, prioridade) Informações de gerência de memória Informações de status de I/O Informações de arquivos abertos



Threads

Processos são baseados em dois conceitos independentes: agrupamento de recursos e execução

Threads são úteis quando há a necessidade de separá-los

Um thread (ou processo leve) é uma unidade básica de utilização da CPU. Consiste em:

Contador de programa: para manter o controle da próxima instrução a ser executada

Conjunto de registradores: contêm suas variáveis atuais de trabalho

Pilha: traz o histórico de execução, e uma estrutura para cada processo chamado e não retornado



Threads

Um thread compartilha com outros threads do mesmo processo:

Seção de código Seção de dados Recursos do SO

Um processo tradicional ou pesado é igual a uma tarefa com apenas um thread



Threads

Em uma tarefa com múltiplos threads, enquanto um thread servidor está bloqueado e esperando, um segundo thread na mesma tarefa pode executar

Cooperação entre múltiplos threads na mesma tarefa confere maior produção (throughput) e performance

Aplicações que requerem o compartilhamento de um buffer comum se beneficiam da utilização de threads

Exemplos: Um navegador Web pode ter um thread exibindo uma

imagem enquanto outro recupera dados na rede Um editor de textos pode ter um thread lendo

caracteres do teclado enquanto outro faz a verificação ortográfica



Threads

Vantagens Capacidade de Resposta: tarefas podem ser

executadas enquanto outras esperam por recurso Compartilhamento de Recursos: facilita acesso Economia: alocar memória e recursos para a criação

de um processo novo é caro Utilização de arquiteturas paralelas



Processos com um ou Vários Threads



Escalonamento: Conceitos Básicos

A utilização máxima de CPU é obtida através de multiprogramação. Com um só processador, nunca haverá mais de um processo em execução

Quando dois ou mais processos estão na situação de pronto, o SO deverá fazer a escolha de qual processo será executado

Escalonador é a parte do SO que escolhe processo Utiliza algoritmos de escalonamento A troca de processo é “cara” para a CPU



Comportamento do Processo

Todo processo alternam surtos de uso da CPU com requisições de E/S

Tipos de surtos Orientado a CPU

Passam a maior parte do tempo utilizando a CPU Orientado a E/S

Passam a maior parte do tempo realizando E/S

A medida que a velocidade dos processadores aumentam os processos tendem a ficar orientados a E/S



Critérios de Escalonamento

É fundamental o SO saber o momento certo de escalonar um processo

Decisões de escalonamento de CPU ocorrem quando o processo:1. Muda do estado de execução para espera2. Muda do estado de execução para pronto3. Muda do estado de espera para pronto4. Termina

Escalonamento não-preemptivo um processo só perde a CPU por vontade própria (término ou chamada de sistema 1 e 4).

Escalonamento preemptivo o processo em execução pode perder a CPU para outro e maior prioridade (2 e 3).




Características para comparação de algoritmos: Utilização de CPU: manter a CPU o mais ocupada

possível Throughput: quantidade de processos que completam

sua execução por unidade de tempo Tempo de retorno: quantidade de tempo para

executar um processo Tempo de espera: quantidade de tempo que um

processo gasta na fila de processos prontos Tempo de resposta: quantidade de tempo gasto entre

a requisição e a produção da primeira resposta




Máxima utilização de CPU Máximo throughput Mínimo tempo de retorno Mínimo tempo de espera Mínimo tempo de resposta



Algoritmos de Escalonamento

Primeiro a chegar é servido (FIFO) Exemplo: Processo Duração de Surto

P1 24

P2 3

P3 3

Suponha que os processos chegam na ordem: P1 , P2 , P3

O diagrama para o escalonamento é:

O tempo de espera para P1 = 0; P2 = 24; P3 = 27 O tempo de espera médio: (0 + 24 + 27)/3 = 17

P1 P2 P3

0 24 27 30




Primeiro a chegar é servido (FIFO) Suponha que os processos cheguem na ordem: P2 , P3 , P1

O diagrama para o escalonamento é:

O tempo de espera para P1 = 6; P2 = 0; P3 = 3

O tempo de espera médio : (6 + 0 + 3)/3 = 3 Muito melhor que o anterior Efeito Comboio: pequenos processos atrás de longos

processos

P1P2 P3

0 3 6 30




Escalonamento job mais curto primeiro (SJF)

Associa a cada processos o tamanho do seu próximo surto de CPU. Usa estes valores para escalonar o processo com o menor tempo

Dois esquemas: Não-preemptivo – uma vez que a CPU é dada ao

processo, não pode ser retirada até completar seu surto Preemptiva – se um novo processo chegar com um

tempo de surto de CPU menor que o tempo restante do processo sendo executado, é feita a troca. Este esquema é conhecido como Menor-tempo-restante-primeiro (SRTF)

SJF é ótimo – sempre dá o mínimo tempo médio de espera para o conjunto de processos




Escalonamento job mais curto primeiro (SJF) Exemplo Processo Chegada Tempo Surto

P1 0.0 7

P2 2.0 4

P3 4.0 1

P4 5.0 4

SJF (não-preemptivo)

Tempo médio de espera = (0 + 7 + 8 + 12)/4

0 87 12 16

P1 P2P3P4




Escalonamento job mais curto primeiro (SJF) Exemplo Processo Chegada Tempo Surto

P1 0.0 7

P2 2.0 4

P3 4.0 1

P4 5.0 4

SJF (preemptivo)

Tempo médio de espera = (0 + 2 + 4 + 7)/4

0 2 4 5 7 11 16

P1 P2 P3 P2 P4P1




Escalonamento por prioridade Um número de prioridade (inteiro) é associado

com cada processo A CPU é alocada para o processo com maior

prioridade (menor valor maior prioridade) SJF é um escalonamento por prioridade, onde

a prioridade é dada pelo tempo de surto Problema: Starvation – processos com baixa

prioridade podem nunca serem executados Solução: Envelhecimento (Aging) – a

prioridade aumenta com o tempo




Round Robin (RR) Cada processo recebe uma pequena unidade de tempo

de CPU (quantum), geralmente 10-100 ms. Após este tempo, o processo é retirado e inserido no fim da fila de prontos

Se existirem n processos na fila de prontos e o quantum for q, cada processo terá 1/n de tempo de CPU em parcelas de no máximo q unidades de tempo por vez. Nenhum processo esperará mais que (n-1)q unidades de tempo

Não precisa esperar até o final do quantum Quando um processo termina outro processo utiliza a

CPU imediatamente




Round Robin (RR) Desempenho

q grande FIFO

q pequeno q deve ser grande em relação ao tempo

de troca de contexto, ou o overhead será muito alto Se q possui 4ms e o tempo de chaveamento é 1ms, o

resultado será péssimo




Round Robin (RR) -> q = 20 Exemplo Processo Tempo de Surto

P1 53

P2 17

P3 68

P4 24

O diagrama é:

Tipicamente, maior média de retorno que SJF, mas melhor resposta

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 37 57 77 97 117 121 134 154 162




Fila Multiplas A fila de prontos é particionada em filas separadas:

primeiro plano (interativo) segundo plano (batch)

Cada fila tem seu próprio algoritmo de escalonamento, por exemplo:

primeiro plano – RR segundo plano – FIFO

Deve haver escalonamento entre as filas Escalonamento de prioridade fixa: primeiro plano pode

ter prioridade sobre o segundo plano. Possibilidade de starvation

Fatia de tempo: cada fila recebe uma certa quantidade de tempo de CPU que pode ser escalonada entre seus processos. Por exemplo, 80% para primeiro plano em RR e 20% para o segundo plano em FIFO




Fila Multiplas com Realimentação Um processo pode passar de uma fila para outra. O

envelhecimento pode ser implementado desta maneira

O escalonador de Filas Múltiplas com realimentação é definido pelos seguintes parâmetros:

número de filas algoritmos de escalonamento para cada fila método usado para determinar a promoção de um

processo a uma fila de maior prioridade método usado para determinar quando rebaixar um

processo método usado para determinar em qual fila o processo

deve entrar quando precisar de serviço




Fila Multiplas com Realimentação Três filas:

Q0 – quantum 8 ms Q1 – quantum 16 ms Q2 – FCFS

Escalonador Um novo job entra na fila Q0 servido por FCFS. Quando

recebe CPU, o job tem 8 ms. Se não terminar em 8 ms, o job é removido para Q1.

Em Q1 o job é servido por FCFS e recebe 16 ms adicionais. Se ainda não terminar, é transferido para Q2.



Sincronização de Processos

Processos podem compartilhar armazenamentos em comum, onde cada um pode ler e escrever

Problema Imagine que um spool tenha um vetor quem contém

os nomes de arquivos a serem impressos Esse vetor possui duas variáveis: out – aponta para o

próximo arquivo a ser impresso e in – aponta para a próxima posição vaga no vetor

Um processo A ler a próxima posição livre (in) e é escalonado pela CPU

Um processo B ler a próxima posição livre, armazena o arquivo e incrementa in

O processo A armazena o arquivo a ser impresso e incrementa in

O arquivo de impressão do processo B é perdido



Regiões Críticas

O que fazer para evitar condições de disputa? Exclusão mútua: assegurar que processos sejam

impedidos de usar uma variável ou arquivo compartilhado que já estiver em uso por outro processo

Região crítica Parte do código em que há acesso à memória

compartilhada



Regiões Críticas

Uma boa solução deve satisfazer:1. Nunca dois processos podem estar

simultaneamente em suas regiões críticas

2. Nada pode ser afirmado sobre velocidade ou sobre o número de CPUs

3. Nenhum processo executado fora da sua região crítica pode ser bloqueado por outros processos

4. Nenhum processo deve esperar eternamente para entrar em sua região crítica



Exclusão Mútua com Espera Ociosa

Desabilitando interrupções O processo desabilita todas as interrupções logo

após entrar em sua região crítica e reabilita-as antes de sair

Problema dessa abordagem Processos de usuário podem desabilitar interrupções

e nunca reabilitá-las

Há casos que é necessários que o núcleo do SO desabilite alguma interrupção

Enquanto estiver alterado variáveis ou listas




Variáveis de impedimento Exemplo:

Se uma variável lock estiver marcada como 0 o processo entra na região crítica e a altera para 1

Se a variável lock estiver marcada como 1 o processo espera

Essa idéia não funciona Antes de alterar a variável para um o processo a lê

como 0 e é escalonado pela CPU. Assim outro processo pode ler a variável como 0, alterá-la para 1 e entrar na região crítica




Alternância Obrigatória Baseada na seqüência lógica antecessor/sucessor Alterna o acesso à região crítica entre dois processos

Desvantagem Teste continuo do valor da variável compartilhada Se um processo falha o outro jamais entra na região

crítica Viola a regra 2 se a parte não critica de um processo

for muito maior que a do outroProcesso Awhile (TRUE){ while (turn!=0); // lock() região_critica turn=1; // unlock()}

Processo Bwhile (TRUE){ while (turn!=1); // lock() região_critica turn=0; // unlock()}




Solução de Paterson Antes de usar as variáveis compartilhadas, cada

processo chama enter_region com seu próprio número de processo (0 ou 1)

Essa chamada fará com que ele fique esperando até que seja seguro entrar

Após usar as variáveis compartilhadas, o processo chama leave_region




Solução de Paterson#define FALSE 0#define TRUE 1#define N 2 //número de processosint turn; //de quem a vezint interested[N]; //todos os valores iniciados com 0void enter_region(int process) { //processo é 1 ou 0

int other; //número do outro processoother = 1 – process; //o outro processointerested[process] = TRUE; //mostra quem você está interessadoturn = process; //altera o valor de turnwhile (turn==process && interested[other]==TRUE); //comando nullo

}void leave_region(int process) { //processo: quem está saindo

interested[process] = FALSE; //indica a saída da região crítica}




A instrução TSL (Test and Set Lock) Proposta que requer auxílio de hardware

TSL RX, LOCK Copia o conteúdo da variável de memória LOCK no

registrador RX e então armazena um valor diferente de zero no endereço de memória LOCK

Se LOCK = 0, seção crítica livre Se LOCK > 0, seção crítica ocupada

enter_region: TSL reg, lock CMP reg, #0 JNE enter_region RET

leave_region: MOVE lock, #0 RET



Semáforos

Utiliza uma variável inteira (o semáforo) para controla o acesso ao recurso compartilhado

O valor zero indica que nenhum sinal de acordar está pendente

Um valor positivo N indica o número de sinais pendentes

Primitivas do semáforo Down – Chamada quando o processo deseja acessar

o recurso compartilhado Up – Chamada quando o processo deseja liberar o

recurso compartilhado

As operações Down e Up são executadas de forma atômica sobre o semáforo



Semáforos

Problema do produtor-consumidor Necessita 3 semáforos

1 para garantir a exclusão mútua mutex – regição crítica: Usados para implementar

exclusão mútua. Também chamados de binários (assumem apenas 0 e 1)

1 para bloquear os produtores o quando a fila estiver cheia (sem slots disponíveis)

full – buffer cheio

1 para bloquear os consumidores o quando a fila estiver vazia (sem itens na fila)

empty – buffer vazio



Semáforos

define N 100semaphore mutex=1;semaphore full=0;semaphore empty=N;

void producer(void) { int item; while(1) { item=produz_item(); down(&empty); down(&mutex); insere_item(item); up(&mutex); up(&full); }}

void consumer(void) { int item; while(1) { down(&full); down(&mutex); item=remove_item(); up(&mutex); up(&empty); consome_item(item); }}

SISTEMAS OPERACIONAIS 1

Documents

Transcript of SISTEMAS OPERACIONAIS 1