SISTEMAS OPERACIONAIS.pdf

Prévia do material em texto

MATÉRIA: SISTEMAS OPERACIONAIS
AULA 1: INTRODUÇAO A SISTEMAS OPERACIONAIS
Nesta aula, conheceremos as características de um sistema operacional
e a importância desse sistema em um ambiente computacional. Para isso, 
trataremos de dois conceitos muito importantes para o entendimento dos 
sistemas modernos: interrupções e chamadas do sistema
CONCEITOS FUNDAMENTAIS DE SISTEMAS OPERACIONAIS
O QUE É UM SISTEMA OPERACIONAL?
É um software.
É um conjunto de programas responsável por: fazer a interface com os 
usuários, gerenciar recursos e fazer a interface com o hardware.
Funções adicionais: contabilização de uso, segurança de acesso, 
auditoria.
O sistema operacional é o intermediário entre o usuário e o hardware.
Cada parte (módulo ou fração) de um sistema operacional é responsável
pelo gerenciamento de um recurso específico.
Que recursos são esses?
Tempo de CPU, espaço de memória, espaço de disco, acesso aos 
dispositivos de comunicaç oa e bibliotecas de software.ῶ
Gerenciar recursos é garantir a utilizaç ao compartilhada do recurso ῶ
sem que ocorram erros que possam gerar instabilidade ou falha no sistema.
Na visão do usuário, o sistema operacional fornece: acesso ao 
sistema, possibilidade de criar e gerir arquivos e diretórios, ambiente 
para execução de programas, acesso aos dispositivos de E/S, acessoa só 
conteúdo de arquivos e detecção de erros.
CLASSIFICAÇÃO DE SISTEMAS OPERACIONAIS
A classificação é utilizada como uma forma sintética de apresentar, 
em poucas palavras, as características de um sistema operacional.
SISTEMA MONOTAREFA X SISTEMAS FUNCIONAIS
SISTEMAS MONOUSUÁRIO X SISTEMAS MULTIUSUÁRIO
SISTEMAS MONOPROCESSADOS X SISTEMAS MULTIPROCESSADOS
ATENÇÃO: Conhecer os conceitos envolvidos em uma classificação evita 
o uso incorreto da nomenclatura técnica e sintetiza de forma unívoca as 
características de um sistema.
ESTRUTURAS DOS SISTEMAS OPERACIONAIS
Um velho conhecido pelos usuários de microcomputadores é a famosa 
“tela azul”. Quem já utilizou sistemas operacionais antigos, como o 
Windows 95, certamente já se deparou com este problema. A “tela azul” era 
de fato uma violação de acesso que tornava o sistema instável.
A partir do 80386, esse problema foi solucionado em termos de 
hardware através da possibilidade de 2 modos de execução: o modo protegdo 
e o modo real. Ficava a cargo do sistema operacional a comutação entre 
esses dois modos por questões de compatibilidade.
A instabilidade evidenciaada pela “tela azul” tem razões históricas. 
Os primeiros processadores da linha x86 possuíam um único modo de 
operação: o modo real. Dessa forma, todas as operações poderiam ser 
executadas diretamente pelas aplicações que, ao produzir erros, geravam 
pane no sistema.
MATÉRIA: SISTEMAS OPERACIONAIS
ESTRUTURA DOS SITEMAS OPERACIONAIS MODERNOS
MODO USUÁRIO X MODO KERNEL
As aplicações são executadas em modo usuário, ou seja, modo que não 
possui privilégios para operaçoes que coloqem o sistema em risco tais como
escreer no disco, criar novas tarefas etc.
Quando essas aplicaç oes precisam executar tarefas críticas, é ῶ
necessário que haja uma mudança para modo Kernel. Essa mudança ocorre 
através de uma “system call” ou chamada ao sistema.
CHAMADAS AO SISTEMA (SYSTEM CALL): Mecanismo responsável pela mudança
de modo usuário para modo kernel. Ao invés de executar diretamente funções
do kernel a aplicação executa uma função intermediária que verifica se o 
acesso ao kernel é seguro e, só então, completa a operação.
Votando à “tela azul”: As aplicações podiam executar diretamente as 
funções do kernel sem a proteção da mudança de modo, ou seja, o erro 
acontecia após a execução de uma função do kernel. Com a mudança de modo, 
se a execução  não for segura, a aplicação será immpedida de continuar a 
execuç ao e o sistema permanecerá estável.ῶ
­ Tipos de Estruturas
Os sistemas são classificados em relação as atribuições do kernel e a
relação entre seus módulos em monolíticos, camadas e microkernel.
Os sistemas modernos são divididos em dois grandes grupos: 
arquitetura monolítica e microkernel. A diferença entre elas está nas 
atribuições do núclo do sistema operacional, denominado KERNEL.
Essa característica é muito importante no projeto de um Sistema 
Operacional e foi alvo de discussão entre dois grandes nomes da 
computação: Andrew Tanenbaum e Linus Torvalds.
INTERRUPÇÕES
São sinais de hardware fundamentais para a existência de sistemas 
multitarefas, pois provocam a suspensão da tarefa em execução pela 
ocorrÊncia de um evento externo permitindo que  outras tarefas 
compartilhem o tempo de uso do processador.
ATENÇÃO: Neste caso, o que está sendo compartilhado é o tempo de uso 
do processador e não o processador em si. Cada tarefa utiliza 100% do 
processador.
Parte do mecanismo é executada pelo hardware (identificação do 
dispositivo, empilhamento dos registradores do sistema) e parte é feita 
por software através da rotina de tratamento da interrupção (interrupt 
handeler).
          HARDWARE SOFTWARE
(ROTINA DE SERVIÇO)
Dispositivos   de
controle   ou   outro
sistema   de   hardware
que   permita   ativar
uma interrupção
Salva   informações
remanescentes sobre
o   estado   do
processo
Processador   termina
a   execução   da
Processa   a
interrupção
MATÉRIA: SISTEMAS OPERACIONAIS
instrução corrente
Processador
reconhece   sinal   de
interrupção
Restaura   a
informação   do
estado do processo
Processador   coloco
PSW e PC na pilha de
controle
Restaura   o   velho
PSW PC
Processador   carrega
novo   valor   do   PC,
baseado   na
interrupção
CONCEITO DE CONCORRENCIA
Compartilhar recursos significa que diferentes usuários ou programa 
usam os recursos de forma concorrente. Como administrar recursos 
compartilhadors?
Os recursos são limitados e, assim, o uso dos mesmos pelos diferentes
programas ou usuários precisa ser controlado e administrado de forma a 
evitar possíveis conflitos ou uma alocação por tempo indeterminado de 
algum recurso.
­ Concorrência
É a capacidade de execução concorrente de tarefas permitindo um 
melhor aproveitamento de recursos.
Uma tarefa pode deixar a CPU por vontade própria, quando precisa 
aguardar por um recurso, ou por uma interrupção.
Em particular, uma interrupção de temporizador provoca a substituição
de tarefa em execução criando uma alterância entre as tarefas.
ATENÇAO: A alterancia entre as tarefas pode dar  a impressão de 
execução simultânea de tarefas, mas não é o que ocorre.
O estudo das funções do sistema operacional para gerenciamento 
concorrente de recursos será alvo de estudo das próximas aulas.
AULA 2: PROCESSOS
­ CONCEITO
Processo é a instância de um programa em execução. É a unidade de 
carga e alocação de uma tarefa.
Em sistemas mais antigos, também é considerado a unidade de unidade 
de execução, mas veremos, na próxima aula, que isso não é verdade nos 
sistemas.
­ PROCESSO
Cada processo é único em um sistema.
O processo é criado quando o programa é carregado para a memória 
principal para ser executado.
Um programa é carregado para a memória onde aloca uma determinada 
área para código e dados.
MATÉRIA: SISTEMAS OPERACIONAIS
­ COMPONENTES
Um processo é dividido em partes que são armazenadas na memória em 
uma estrutura denominada PCB (process control block).
IDENTIFICAÇÃO PROGRAMA
REGISTRADOR SP
REGISTRADOR PC
REGISTRADORES DE USO GERAL
INFORMAÇÕES DE ESCALONAMENTO
RELAÇÃO DE ARQUIVOS ABERTOS
PRIVILÉGIOS
ESPAÇO DE ARMAZENAMENTO DE
PROGRAMA: Código executável.
CONTEXTO DE HARDWARE: Características da execução. Armazena o conteúdo dos
registradores responsáveis pelo controle de execução do programa.
CONTEXTO DE SOFTWARE: Características e limites do ambiente onde o 
programa será executado. Fazem parte do contexto de software:Identificação, quotas, privilégios, identificação do usuário dono do 
processo.
ESPAÇO DE ENDEREÇAMENTO DE MEMÓRIA: Área da memória alocada para a 
execução do programa.
­ ESTADOS
No que diz respeito aos estados de um processo, o diagrama mais comum
possui cinco estados e é suficiente para o entendimento dos demais estados
intermediários. Observe abaixo:
A substituição do processo em execução é denominada troca de 
contexto. Quando o processo é interrompido seu contexto é armazenado. 
Quando o processo retorna para o estado de execução seu contexto é 
recuperado.
O sistema operacional não pode provocar troca de contexto, uma vez 
que é um software e para gerar uma ação precisaria estar em execução.
­ TIPOS
Os processos podem ser classificados em função de características de 
execução:
PROCESSO CPU­BOUND: São processos que passam a maior parte do tempo em 
estado de execução ou pronto. Realiza poucas operações de E/S.
PROCESSO I/O­BOUND:  São processos que passam a maior parte do tempo em 
estado de espera, pois realizam um elevado número de operações de E/S.
PROCESSOS EM FOREGROUND: Permite a comunicação direta do processo com o 
usuário durante sua execução. Em geral, o canal de entrada está associado 
ao teclado/mouse e de saída a um  monitor.
PROCESSO BACKGROUND: Prcoessos em que não existe interação direta com o 
usuário.
MATÉRIA: SISTEMAS OPERACIONAIS
A extratégia utilizada para ordenar a execução de processos pode 
variar em função dos tipos de processos de um sistema.
AULA 3: THREADS
­ CONCEITO DE THREADS
Threads são fluxos de execução dentro de um processo, um executável.
Atualmente um thread é considerada a unidade de execução de um 
sistema ao invés do processo como um todo.
Um processo pode ter uma ou mais threads. Por exemplo: um processo – 
um threads, um processo – múltiplos threads, múltiplos processos – um 
thread por processo, múltiplos processos – múltiplos threads por 
processos.
­ ESTRUTURA
Um processo que contenha threads é composto pelo seu PCB (Process 
Control Block) e pelos blocos específicos para cada thread que contém uma 
estrutura de contexto de software e uma estrutura de contexto de hardware.
Cada Threads possui contextos próprios de hardware e software, porém 
compartilham o mesmo espaço de endereçamento alocado ao processo.
Vamos entender melhor.
Pense em funções do mesmo processo onde todas as funções são capazes,
por exemplo, de ver e alterar o conteúdo de variáveis globais.
Int x = 10;
int main () {
int y;
x = x + 1;
y = soma();
cout << “x = ” << x << “\n”;
{
int soma() {
x = x + 1;
return x;
}
Vamos exemplificar o seguinte trecho do programa : Como a variável x é 
visível por todas as funções o valor final da variável x será 12.
As funções enxergam a mesma àrea de memória.
Agora pense um pouco e responda. Toda função é uma thread? NÃO. Quando 
utilizamos funções, o módulo que fez a chamada deve aguardar o término da 
função para continuar. No exemplo, o resultado será exibido após o retorno
da função cout << “x = ” << x << “\n”; Se fosse uma thread a exibição 
poderia ocorrer antes que a função terminasse.
Podemos gerar erros? A exibição poderia mostrar o resultado antes da 
função terminar. Esse tipo de problema antes da função terminar.
Esse tipo de problema será tratado em comunicação entre processos e é
conhecido como condição de corrida.
MATÉRIA: SISTEMAS OPERACIONAIS
O que podemos concluir? Uma thread pode ser imaginada então como uma 
função de um programa que tem “vida própria” para a execução, mas não pode
ser criada isoladamente.
­ TIPOS DE THREADS
As threads podem ser classificadas em:
THREADS DE KERNEL: As threads de kernel são criadas e gerenciadas pelo 
kernel do sistema operacional, mas não podem ser diretamente utilizadas 
pelo usuários.
O suporte a múltiplas threads é uma característica do sistema 
operacional.
THREADS DE USUÁRIO: As threads de usuário facilitam aspectos de 
portabilidade são criadas e gerenciadas  por uma biblioteca no nível do 
usuário.
O Kernel não enxerga essas threads e por esse motivo, não podem ser 
gerenciadas individualmente.
Exemplo: Biblioteca de threads: POSIX, Pthreads, Win32 threads,  java
threads.
Processo leve ou LWP – A combinação entre os dois tipos de threads promove
uma associação entre  threads de usuarios e de kernel, porém a forma de 
associação depende do sistema operacional.
O uso combinado de threads de usuários e de kernel permite melhor 
aproveitamento do tempo de CPU, possibilidade de paralelismo e facilidade 
de programação.
Vamos agora conhecer os modelos de associação entre threads de 
usuários e de kernel.
Muitos para um: Gerenciamento de thread é feito no espaço do usuário; 
Usadas em sistemas que não suportam threads; Um thread bloqueada bloqueia 
todo o processo.
Um para um: Cada thread de usuário é mapeada para uma kernel thread; Criar
uma user thread requer a criação de uma thread de Kernel; Algumas 
implementações restrigem o número de threads suportada pelo sistema; É 
utilizada pelo windows e pelo linux.
Muitos para muitos: Permite que várias threads de usuários sejam mapeadas 
para um número menor  ou  maior de threads de Kernel dinamicamente; 
Permite que o SO crie umm número suficiente de threads de kernel.
AULA 4: COMUNICAÇÃO ENTRE PROCESSOS
­ MOTIVAÇÃO
Processos e threads em sistemas multitarefas compartilham recursos.
Aprendemos nas aulas anteriores que processos e threads não executam 
direto, ou seja, desde o início até o fim. Durante um tempo de execução 
sofrem interrupções e ficam bloqueados aguardando recursos.
Suponha que um processo P1  está executando quando é interrompido 
pelo final da fatio de tempo. Outro processo P2 será selecionado para 
MATÉRIA: SISTEMAS OPERACIONAIS
execução e poderá querer utilizar o mesmo recurso que estava sendo 
utilizado por P1. E agora?
Vamos entender o exemplo:
Considere as variáveis  A e B, ambas iniciadas com valor 1 , são 
compartilhadas por duas threads de um mesmo processo e cada uma delas 
deverá executar:
THREAD 1 THREAD 2
LINHA 1 A := A* 2 B := B+1
LINHA 2 B := B * 2 A := A +1
Quais serão as formas possíveis de execução?
CASO 1: Thread 1 executa linha 1 e linha 2, thread 2 executa linha 1 e 
linha 2.
Resultado final: A = 3 e B = 3
CASO 2: Thread 2 executa linha 1 e linha 2, thread 1 executa linha 1 e 
linha 2.
Resultado final: A = 4 e B = 4
CASO 3: Thread 1 executa linha 1, thread 2 executa linha 1 e linha 2, 
thread 1 executa linha 2.
Resultado final: A = 3 e B =4
Podemos perceber neste exemplo muito simples que  obtivemos 3 
resultados diferentes em função da ordem em que os processos ocorrem. Esse
efeito é denominado CONDIÇÃO CORRIDA.
CASO 1: Resultado final: A = 3 B = 3
CASO 2: Resultado final: A = 4 B = 4
CASO 3: Resultado final: A = 3 B = 4
Há condição de corrida quando existem recursos compartilhados entre 
duas ou mais threads ou entre dois ou mais processos sem as devidas 
precauções.
­ ENTENDENDO A CONDIÇÃO DE CORRIDA
O trecho de código que trata recursos compartilhados é denominado  
REGIÃO CRÍTICA.
No exemplo, ambas as threads utilizavam as variáveis A e B 
compartilhadas, então as duas linhas apresentadas formam uma região 
critica.
Reflexão: Repare que, no exemplo, a ordem de execução de threads, 
mesmo sem interrupção, já é suficiente para permtir resultados diferentes.
Mais uma informação: Sabe aqueles problemas de erro intermitente do 
sistema operacional? Não existe erro intermitente de software, já que não 
existe “mau contato” dentro de um programa.
Erros intermitentes são mesmos erros de programação que ocorrem em 
determinadas situações.
Essas situações podem se repetir ou não com frequencia. Com a 
repetição do contexto é impraticável, torna­se muito mais difícil 
localizar um erro de execução do programa.
­ VAMOSCONHECER AGORA UM EXEMPLO MAIS PRÁTICO
Esse problema aconteceu realmente em um sistema operacional bem 
conhecido que utiliza uma fila para armazenar temporariamente os 
MATÉRIA: SISTEMAS OPERACIONAIS
documentos que seriam impressos. Essa fila é implementada em uma área de 
memória do sistema operacional compartilhada com todos os processos.
Quando um processo deseja imprimir, deverá executar a seguinte rotina
(fornecida como uma API do sistema operacional).
1) Ler posição livre da fila   2) Incluir o arquivo na posição indicada   → →
3) Atualizar próxima posição livre
CASO 1) POSIÇÃO ATUAL: Considere a seguinte posição inicial. Processo 0 
está sendo impresso e, em um determinado momento, o processo 1 também irá 
imprimir.
1° Passo – API irá ler a primeira posição livre da fila (será 1).
2° Passo – API irá incluir o arquivo na posição 1 da fila.
3° Passo – API irá atualizar a posição livre para 2.
CASO 2) Voltamos para a situação inicial, só que agora utilizaremos dois 
processos concorrentes. Processo 0 está sendo impresso e, em um 
determinado momento, o processo 1 também irá imprimir.
1° Passo – API irá ler a primeira posição livre da fila (será 1).
2° Passo – API irá incluir o arquivo na posição 1 da fila.
3° Passo – A fatia de tempo expira e ocorre uma troca de contexto, 
deixando a situação acima.
COMO EVITAR A OCORRÊNCIA DE UMA CONDIÇÃO DE CORRIDA?
Para garantir o acesso exclusivo a uma região, será necessário 
utilizarmos mecanismos que garantam a EXCLUSÃO MÚTUA entre processo e/ou 
threads.
Para implementação de um mecanismo de exclusão mútua, utilizaremos um
protocolo de acesso e um protocolo de saída de uma região crítica. Esse 
protocolo poderá ser baseado em soluções algorítmicas, em características 
do processador ou em primitivas do sistema operacional.
O CÓDIGO DA ESTRUTURA FICARIA:
ENTRAR_RC()
Código da região critica
SAIR_RC()
DE ACORDO COM O EXEMPLO ANTERIOR:
ENTRAR_RC()
Ler posição livre da fila
Incluir o arquivo na posição indicada
Atualizar próxima posição livre
SAIR_RC()
ATENÇÃO: Os mecanismos que implementam a exclusão mútua podem colocar o 
processo que não deve ter acesso ao recurso em “espera ocupada” (busy 
wait) ou bloqueá­lo ao executar a função     ENTRAR_RC e deverá permitir o
acesso ou desbloqueá­lo ao executar a função SAIR_RC.
PARA QUE UM MECANISMO DE EXCLUSÃO MÚTUA SEJA EFETIVO, DEVE GARANTIR QUE:
Somente um processo por vez possa executar uma região critica.
Um processo interrompido fora de uma região crítica não possa impedir
que outro processo tenha acesso a essa região crítica.
MATÉRIA: SISTEMAS OPERACIONAIS
Não possa haver nem deadlock nem starvation.
Quando não houver processo executando uma região crítica, qualquer 
processo que solicitar acesso deverá obtê­lo imediatamente.
Um processo deve permanecer executando uma região crítica por tempo 
finito.
Nada possa ser assumido sobre a velocidade relativa e dos processos 
nem o número de processadores.
CONDIÇÃO DE OCORRÊNCIA DE DEADLOCK
Condição necessárias  (não suficiente): Exclusão mútua, Posse e 
espera (hold & wait) e não preempção.
Condição suficiente: Espera circular: Os processos P1 e P2 precisam 
de recursos R1 e R2 para executar, P1 está de posse de R1 e aguardando  
R2. P1 não executará enquanto não obtiver R2; logo, não liverará R1. P2 
está de posse de R2 e aguardando R1, P2 não executará enquanto não obtiver
R1; logo, não liberará R2.
AULA 5: SINCRONIZAÇÃO ENTRE PROCESSOS
A utilização de mecanismo de exclusão mútua é necessária para impedir
o acesso a uma região crítica por mais de um processo evitando, assim, 
condição de corrida.
Os mecanismos estão divididos em três categorias baseadas em: 
Algoritmos, Características de hardware, Primitivas do sistema 
operacional.
A implementação de um mecanismo de exclusão mútua implica a 
utilização de um protocolo  de acesso à região crítica e um protocolo de 
saída da região crítica.
ENTRAR_RC()
Acesso ao recurso compartilhado
SAIR_RC()
Considerando: 
ENTRAR_RC()
A:=A*2
B:=B*2
SAIR_RC()
MECANISMOS BASEADOS EM ALGORITMOS
A primeira abordagem baseadas em algoritmos possui uma estrutura 
muito mais simples onde uma variável compartilhada determina se a região 
crítica está ou não livre. Essa solução possui   diversas limitações, como
veremos a seguir:
Considere a variável global vez e os processos P0 e P1 disputando uma 
região crítica:
Processo 0 Processo 1
while turn=0 do {} while turn = 1 do {}  ENTRAR_RC→
<RC> <RC>
vez = 1 vez = 0  SAIR_RC→
MATÉRIA: SISTEMAS OPERACIONAIS
Um dos processos permanece em espera ocupada até que o outro saía da 
região crítica executando, altere o valor da variável vez permitindo que o
outro processo saia do loop e execute a região crítica.
Diversos algoritmos foram propostos, porém até a quarta versão, esses 
algortimos apresentavam problemas que feriam os principios de exclusão 
mútua.
A primeira solução garantiu a exclusão mútua entre dois processos foi
proposta por Dekker e possui uma lógica bastante complexa. Esse algoritmo 
foi simplificado posteriormente por Peterson generalizando o código para n
processos.
Algoritmo de Peterson
Apresenta uma solução para dois processos que pode ser generalizada 
de N processos.
1) Antes de acessar a região crítica, o processo sinaliza esse desejo 
através de uma variável booleana flag.
2) Porém o processo cede o uso de recurso ao outro processo indicado pela 
variável vez.
3) Em seguida, o processo executa um loop até a obtenção da variável vez.
Processo 0  Processo 1
flag[0] = true flag[1] = true
vez = 1 vez = 0
while flag[1] and vez = 1 {} while flag[0] and vez = 0 {}
 ENTRAR_RC→
<RC> <RC>
flag[0] = false flag[1] = false
 SAIR_RC→
MECANISMOS BASEADOS EM CARACTERÍSTICAS DE HARDWARE
São mecanismos que utilizam instruções do processador para a 
implementação de exclusão mútua. Iremos estudar duas soluções:
INIBIR INTERRUPÇÕES
Essa solução mais simples para o processamento de exclusão mútua, 
pois permite que um processso desligue o recebimento de interrupções antes
da execução de uma região crítica, impedindo a troca de contexto. As 
interrupções são novamente habilitadas após o término da região crítica. 
Nesse exemplo, serão utilizadas as instruções da família de processadores 
x86 para desligar (cli) e ligar (sti) as interrupções.
CLI   ENTRA_RC→        
RC
STI  SAIR_RC→
Essa solução apresenta alguns 
problemas:
Não habilitar as interrupções por 
erro de programação (só desligando o
computador).
Como somente as interrupções do 
processador que executou a instrução
são desabilitadas, não garante 
exclusão mútua em sistemas 
multiprocessados.
Uma aplicação de usuário não deve 
ter privilegios para executar essa 
MATÉRIA: SISTEMAS OPERACIONAIS
operação.
INSTRUÇÕES TSL (TEST AND SET LOCK)
São instruções atômicas que executam a leitura de uma variável 
utilizada para lock, armazenando temporariamente seu valor em um 
registrador. Sem sofrer interrupção, essa instrução valida o conteúdo da 
variável e faz a alteração se necessário.
Veja a implementação dessa instrução:
ENTRAR_RC
    TSL RX, LOCK
    CMP RX, #0
    JNE ENTRA_RC
    RET
SAIR_RC
    MOV_LOCK, #0
    RET
O valor 0 significa que a região 
critica está livre, o valor é 
configurado para 1 e o acesso é 
obtido.
Se, ao tentar o acesso, o valor está
em 1, o processo permanece em espera
ocupada até que o valor da variável 
seja configurado para 0 pela 
execução de SAIR_RC.
Essa implementação apresenta as seguintes características: Utiliza 
espera ocupada, Possibilidade de starvation, Seleção arbitrária, Deve 
garantir exclusividade no uso do barramento para multiprocessadores.
MECANISMOS BASEADOS EM PRIMITIVAS DO SISTEMA OPERACIONAL
Nessa catégoria são implementados três implementações:
SEMÁFOROS: Um processo é suspensoenquanto não obtém acesso a região 
crítica; O processo bloqueado é acordado através de um sinal
MONITORES: O monitor é composto de várias rotinas cujas variáveis somente 
são acessadas dentro do monitor; Um processo entra no monitor chamando uma
das suas rotinas; e Somente um processo entra no monitor de cada vez.
TROCA DE MENSAGENS: Utilizado também em sistemas distribuídos; Utiliza 
primitivas send e receive para o envio e recebimenteo de mensagens; As 
primitivas podem ou não bloquear o processo; Considere um receive 
bloqueante e um send não bloqueante. O processo deve aguardar um send para
liberar o processo bloqueado na instrução receive.
Receive (caixa_postal)
<RC>
send (caixa_postal)
DETALHAMENTO DOS SEMÁFOROS
O conceito de semáforo foi proposto por Dijktra para implementação de
exclusão mútua e sincronização condicional entre processos.
Um processo é suspenso enquanto não obtém permissão para executar uma RC e
é automaticamente  “acordado” através de um sinal >> Para liberar um 
semáforo “s” o processo deve executar uma primitiva signal(s) para obter 
acesso a RC, via o semáforo “s”, o processo deve executar uma primitiva 
wait(s).
MATÉRIA: SISTEMAS OPERACIONAIS
!!!!! Um semáforo é uma estrutura de dados composta por um contador e uma 
fila que registra os processos pendentes em ordem de solicitação. O 
semáforo possui regras de acesso.
Vamos ver um exemplo: Considere P0, P1 e P2 três processos que desejam 
acesso a uma região crítica e s o semáforo que controla esse acesso, 
inicializado com 1. O acesso á região critica é dado por: 
Wait (s)
    Região Critica
Signal (s)
P0
Executa wait(s) então
s=0
Região critica
P1
Executa wait(s) então
s=1
BLOQUEIO
P2
Executa wait(s) então
s=2
BLOQUEIO
Executa wait(s) então
s=­1
Desbloqueia P1
Região Critica
Executa wait(s) então
s=0
Desbloqueia P2
Regiao Critica
Executa wait(s) então
s=1
SINCRONIZAÇÃO CONDICIONAL UTILIZANDO SEMÁFOROS
Além de permitirem a implementação de exclusão mútua, os semáforos 
também podem ser utilizadas para sincronização condicional entre 
processos.
Um problema clássico que exemplifica essa função é o Problema do 
produtor / consumidor.
O problema do produtor/consumidor pode ser dividido em duas etapas:
1° ­ O processo produtor pode produzir incondicionalmente colocando itens 
em um buffer área de armazenamento, mas o consumidor só pode consumir se 
existirem itens produzidos e armazenados no buffer.
2° ­ Ambos os processos sofrem restrições. Existe uma capacidade máxima 
para produção, limitada ao tamanho da estrutura de armazenamento (buffer).
Vamos ver agora dois casos.
Em ambos os casos, o acesso ao buffer deve ser exclusivo somente pode
ser acessado por um processo de cada vez.
CASO 1: Problema do produtor/consumidor com buffer de armazenamento 
infinito.
Neste problema, serão utilizados dois semáforos: s  exclusão mútua / →
n   controle de consumo.→
Inicialmente s=1 e n = 0 (região crítica liberada e não há itens para
consumo).
Produtor (i) {
while (T) {
produz_item()
wait(s)
adiciona_item()
signal(s)
signal(n)
MATÉRIA: SISTEMAS OPERACIONAIS
}
}
Consumidor(i) {
while (T) {
wait(n)
wait(s)
remove_item()
signal(s)
consome_item()
}
}
AULA 6: GERÊNCIA DE TEMPO DE CPU
ESCALONAMENTO
É uma função do Sistema Operacional que consiste em escolher 
(determinar) detre os processos candidatos aquele que:
Ganhará acesso ao ambiente de processamento, Será retirado do 
ambiente de processamento, Ganhará a posse da CPU.
!!! Esta tarefa do sistema oepracional é de fundamental importância 
em sistemas multitarefas.
ESTRATÉGIA DE ESCALONAMENTO
A estratégia de escalonamento adotada deverá:
Manter o processador ocupado o maior parte de tempo possível, Balancear o 
tempo de CPU entre as tarefas, Oferecer tempos de resposta razoáveis, 
Maximizar a taxa de atendimento (vazão) do sistema (throughput)   →
Importante: É importante lembrar que o escalonador só pode executar quando
o processo que estiver utilizando o processador for interrompido ou 
bloqueado.
Dispatcher: Processo do sistema operacional responsável pela troca de
contexto.
!!! Pode haver conflito de interesses: Usuários quer que seu processo
termine logo (tempo de resposta baixo) e sistema quer que vários processos
sejam atendidos. (throughput alto).
TIPOS DE ESTRATÉGIA
As políticas de escalonamento podem ser classificadas segundo a 
possibilidade do Sistema Operacional permitir ou não a interrupção de um 
processo em execução e substituí­lo por outro.
ESCALONAMENTO PREEMPTIVO: O escalonamento preemptivo permite que um evento
possa interromper o processo em execução e colocá­lo no estado de pronto 
para que outro processo possa ter direito a execução.
ESCALONAMENTO NÃO PREEMPTIVO: O escalonamento não preemptivo é utilizado 
tipicamente me processamento em batch. Quando um processo está em execução
nenhum evento externo poderá interrompe­lo. O processo só deixa o estado 
de execução se terminar ou se executar alguma instrução que o coloque em 
bloqueio.
MATÉRIA: SISTEMAS OPERACIONAIS
CRITÉRIOS DE ESCALONAMENTO
Existem 5 critérios de escalonamento:
FCFS: Sem preempção; Processos são executados na ordem de chegada; 
Processos curtos podem esperar em demasia; Favorece processo CPU­bound.
Processos I/O­bound esperam processo CPU­bound terminar ou ficar 
bloqueado   Quando este fica bloqueado, a CPU fica ociosa.→
PRIORIDADE: Cada processo recebe uma prioridade ao ser iniciado   O →
escalonador seleciona o processo pronto de maior prioridade   Existem →
várias filas “pronto” uma para cada nível de prioriadade   Processos de →
baixa prioridade podem sofrer Starvation   Uma solução possível é mudar →
dinamicamente a prioridade de acordo com a “idade” ou o histórico de 
execução do processo.
SIF: Politica sem preempção; Baseado em estimativa de tempo de execução; 
Processo com o tempo esperado de execução menor é selecionado primeiro; 
Favorece processos curtos em deterimento dos longos; Utilizado em sistema 
batch.
ROUND ROBIN (CIRCULAR): Usa preempção baseado num “Quantum* (time slice, 
fatia de tempo; Busca democratizar a distribuição do tempo da CPU.
* Quantum: tempo máximo que um processo pode executar sem interrupção: 
Muito curto: maior o overhead de escalonamento. Muito longo: degenera em 
FCFS.
MÚLTIPLAS FILAS COM REALIMENTAÇÃO: Penaliza os processos executados há 
mais tempo, Utiliza múltiplas filas com prioridades dinâmicas**; favorece 
processos curtos e I/O bounded.
**Prioridades Dinâmicas: São duas: 1°) A cada ciclo de execução a 
prioridade diminui. 2°) Starvation: prioridade menor implica em quantum 
maior ou muita espera aumenta a prioridade.
AULA 7: GERÊNCIA DE ALOCAÇÃO DE MEMÓRIA
Alocar memória consiste em subdividir e alocar espaços para acomodar 
os processos em execução. É necessário que haja uma estratégia definida 
para esta tarefa porque:
Espaços são solicitados e liberados em função de execução de cada 
tarefa, Cada processo precisar ter seu espaço protegido; Pode ser 
necessário compartilhar informações com outros processos.
ESTRATÉGIAS DE ORGANIZAÇÃO LÓGICA DO ESPAÇO DE MEMÓRIA
Existe cinco estratégias de organização lógica do espaço de: 
CONTÍGUO SIMPLES: Somente uma particiação da memória é criada para apenas 
um único processo. Parte da memória é ocupada pelo sistema operacional a 
outra parte para o processo em execução.
Este modelo somente pode ser utilizado em sistema monotarefa que não 
são utilizados.
MATÉRIA: SISTEMAS OPERACIONAIS
ESTÁTICO: Implementação simples em que cada processo recebe um endereço 
fixo de uma partição para executar denominado endereço absoluto.
Apresenta baixo desempenho e fragmentação interna.
ESTÁTICO RELOCÁVEL: Semelhante ao particionamento estático, porém os 
processos podem ser alocados em qualquer partição.DINÂMICO: A estratégia de alocação dinâmica permite o particionamento sob 
demanda, ou seja, a partição é criada durante a alocação do processo 
exatamente do tamanho que será utilizada.
Essa estratégia evita a fragmentação interna, mas permite a 
ocorrência de fragmentação externa, ou seja, fragmentação entre as 
partições.
PAGINADO: A memória é particionada em pedaços de tamanho igual, assim como
os processos.
Os pedaços que compõem os processos são   Páginas→
Os pedaços que compõem a memória são chamados  Molduras de Páginas(Frames)→
!!! Quando um processo é carregado, suas páginas são alocadas em 
quaisquer molduras disponíveis, não necessáriamente contíguas.
SEGMENTADO: Cada programa é suvdividido em blocos de diferentes tamanhos 
chamados segmentos. 
Quando um processo é carregado para a memória principal, cada 
segmento diferente pode ocupar qualquer lugar.
 O SO mantém  uma tabela de segmentos de cada processo. Cada entrada 
contém: O início do endereço físico daquele segmento; O tamanho do 
segmento (por proteção).
Apresenta fragmentação externa.