Todo SO

Sistemas operacionais.
Conceitos básicos
Prof. Diovani Milhorim

SO – Conceitos básicos
O sistema operacional é uma camada de software
que opera entre o hardware e os programas
aplicativos voltados ao usuário final.
O sistema operacional é uma estrutura de

software ampla, que incorpora aspectos de
baixo nível (como drivers de dispositivos e
gerência de memória física) e de alto nível
(como programas utilitários e a própria interface
gráfica).
Arquitetura geral de um sistema computacional típico.

Os objetivos básicos de um sistema
operacional podem ser sintetizados em
duas palavras-chave:
“abstração” e “gerência”
Abstração:
O sistema operacional deve definir

interfaces abstratas para os recursos do
hardware.
Abstração: Objetivos.
 Prover interfaces de acesso aos dispositivos,

mais simples de usar que as interface de
baixo nível, para simplificar a construção de
programas aplicativos.
 Tornar os aplicativos independentes do
hardware.
 Definir interfaces de acesso homogêneas para
dispositivos com tecnologias distintas.
Abstração: Exemplo: leitura de um arquivo em disquete.
1. verificar se os parâmetros informados estão corretos (nome do arquivo,

identificador do leitor de disquete, buffer de leitura, etc);
2. verificar se o leitor de disquetes está disponível;
3. verificar se o leitor contém um disquete;
4. ligar o motor do leitor e aguardar atingir a velocidade de rotação correta;
5. posicionar a cabeça de leitura sobre a trilha onde está a tabela de diretório;
6. ler a tabela de diretório e localizar o arquivo ou subdiretório desejado;
7. mover a cabeça de leitura para a posição do bloco inicial do arquivo;
8. ler o bloco inicial do arquivo e depositá-lo em um buffer de memória.

Gerência de recursos:
O sistema operacional deve definir políticas

para gerenciar o uso dos recursos de
hardware pelos aplicativos, e resolver
eventuais disputas e conflitos.
Gerência de recursos:
Situações onde se faz necessária a gerência de recursos:
 O uso desse processador deve ser distribuído entre os

aplicativos presentes no sistema, de forma que cada um
deles possa executar na velocidade adequada para cumprir
suas funções sem prejudicar os outros.
 A memória RAM, que deve ser distribuída de forma justa
entre as aplicações.
 A impressora é um recurso cujo acesso deve ser efetuado de
forma mutuamente exclusiva (apenas um aplicativo por vez (
solução:print jobs – fila FIFO).
 Impedir que todos os recursos do sistema sejam
monopolizados por um só usuário (quota de uso por
usuário).
Resumindo:
Um sistema operacional visa abstrair o hardware

gerenciando seus recursos e provendo aos
aplicativos um ambiente de execução abstrato,
no qual o acesso aos recursos de hardware se
dá através de interfaces simples, independentes
das características de baixo nível do hardware,
e no qual os conflitos no uso do hardware são
minimizados.
SO – Tipos de sistemas.
Os sistemas operacionais podem ser
classificados de acordo com diversos
parâmetros e perspectivas, como
tamanho, velocidade, suporte a
recursos específicos, acesso à rede,
etc.
Batch (de lote) : os sistemas operacionais
mais antigos trabalhavam “por lote´´ , ou
seja, todos os programas a executar eram
colocados em uma fila, com seus dados e
demais informações para a execução. O
processador recebia um programa após o
outro, processando-os em seqüência, o que
permitia um alto grau de utilização do
sistema.
De rede : um sistema operacional de rede
deve possuir suporte à operação em rede,
ou seja, a capacidade de oferecer às
aplicações locais recursos que estejam
localizados em outros computadores da
rede, como arquivos e impressoras. Ele
também deve disponibilizar seus recursos
locais aos demais computadores, de forma
controlada. A maioria dos sistemas atuais
oferece esse tipo de funcionalidade.
Distribuído : em um sistema operacional distribuído,
os recursos de cada máquina estão disponíveis
globalmente, de forma transparente aos usuários.
Ao lançar uma aplicação, o uuário interage com
sua janela, mas não sabe onde ela está
executando ou armazenando seus arquivos: o
sistema é quem decide, de forma transparente.
Os sistemas operacionais distribuídos já existem há
tempos ( Amoeba [TKvRB91] e Clouds
[DRJLAR91], por exemplo), mas ainda não são
uma realidade de mercado.
Multi-usuário : Um sistema operacional multi-usuário
deve suportar a identificação do “dono” de cada
recurso dentro do sistema (arquivos, processos,
áreas de memória, conexões de rede) e impor
regras de controle de acesso para impedir o uso
desses recursos por usuários não autorizados.
Essa funcionalidade é fundamental para a
segurança dos sistemas operacionais de rede e
distribuídos.
Grande parte dos sistemas atuais são multi-usuários.
Desktop : um sistema operacional “de mesa”
é voltado ao atendimento do usuário
doméstico e corporativo para a realização
de atividades corriqueiras, como edição de
textos e gráficos, navegação na Internet e
reprodução de mídias simples. Sua
principais características são a interface
gráfica, o suporte à interatividade e a
operação em rede. Exemplos de sistemas
desktop são o Windows XP, MacOS X e
Linux.
Servidor : um sistema operacional servidor
deve permitir a gestão eficiente de grandes
quantidades de recursos (disco, memória,
processadores), impondo prioridades e
limites sobre o uso dos recursos pelos
usuários e seus aplicativos. Normalmente
um sistema operacional servidor também
tem suporte a rede e multi-usuários.
Embutido : um sistema operacional é dito
embutido (embedded) quando é construído
para operar sobre um hardware com poucos
recursos de processamento, armazena-
mento e energia. Aplicações típicas desse
tipo de sistema aparecem em telefones
celulares, controladores industriais e
automotivos
Ex. µC/OS, Xylinx, LynxOS e VxWorks.
Tempo real : ao contrário da concepção usual, um
sistema operacional de tempo real não precisa ser
necessariamente ultra-rápido; sua característica
essencial é ter um comportamento temporal
previsível (ou seja, seu tempo de resposta deve ser
conhecido no melhor e pior caso de operação). A
estrutura interna de um sistema operacional de
tempo real deve ser construída de forma a
minimizar esperas e latências imprevisíveis, como
tempos de acesso a disco e sincronizações
excessivas.
Tempo real :
 soft real-time systems, nos quais a perda de prazos
implica na degradação do serviço prestado. Um
exemplo seria o suporte à gravação de CDs ou à
reprodução de músicas.
 hard real-time systems a perda de prazos pelo
sistema pode perturbar o objeto controlado, com
graves conseqüências humanas, econômicas ou
ambientais. Exemplos: controle de funcionamento
de uma turbina de avião a jato ou de uma caldeira
industrial. QNX, RT-Linux e VxWorks.
Sistemas operacionais
Funcionalidades.

SO - Funcionalidades
 Para cumprir seus objetivos de abstração e
gerência, o sistema operacional deve atuar em
várias frentes. Cada um dos recursos do
sistema possui suas particularidades, o que
impõe exigências específicas para gerenciar e
abstrair os mesmos. As principais funções
implementadas por um sistema operacional
típico são:
 Gerência do processador : também conhecida
como gerência de processos ou de atividades,
esta funcionalidade visa distribuir a capacidade
de processamento de forma justa entre as
aplicações, evitando que uma aplicação
monopolize esse recurso e respeitando as
prioridades dos usuários. Busca-se criar a
abstração de “um processador para cada
tarefa”.
 Gerência de memória : tem como objetivo fornecer a
cada aplicação um espaço de memória próprio,
independente e isolado dos demais, inclusive do núcleo
do sistema. Caso a memória RAM não seja suficiente, o
sistema deve prover armazenamento secundário
(espaço em disco) como complemento de memória, de
forma transparente às aplicações.
 A principal abstração construída pela gerência de
memória é a noção de memória virtual, que desvincula
o espaço de endereços visto por cada aplicação do
espaço físico.
 Gerência de dispositivos : A função da gerência de

dispositivos (também conhecida como gerência de
entrada/saída) é implementar a interação com cada
dispositivo por meio de drivers e criar modelos
abstratos que permitam agrupar vários dispositivos
distintos sob a mesma interface de acesso.
 Gerência de arquivos : esta funcionalidade é construída
sobre a gerência de dispositivos e visa criar as
abstrações de arquivo e diretório, definindo também sua
interface de acesso e as regras para seu uso.
É importante observar que essas abstrações são tão

importantes e difundidas que muitos sistemas
operacionais as usam para permitir o acesso a recursos
que nada tem a ver com armazenamento
 Gerência de proteção : com computadores conectados

em rede e compartilha dos por vários usuários,
é importante definir claramente os recursos que cada
usuário pode acessar, as formas de acesso permitidas
(leitura, escrita, etc) e garantir que essas definições
serão cumpridas.
Além dessas funcionalidades básicas, oferecidas pela

maioria dos sistemas operacionais, várias outras vêm se
agregar os sistemas modernos, para cobrir aspectos
complementares, como a interface gráfica, suporte de
rede, fluxos multimídia, gerência de energia, etc.
Política X mecanismo
Como política consideram-se os aspectos de decisão mais

abstratos, que podem ser resolvidos por algoritmos de
nível mais alto, como por exemplo decidir a quantidade
de memória que cada aplicação ativa deve receber, ou
qual o próximo pacote de rede a enviar para satisfazer
determinadas especificações de qualidade de serviço.
Como mecanismo consideram-se os procedimentos de
baixo nível usados para implementar as políticas.
Os mecanismos devem ser suficientemente genéricos

para suportar mudanças de política sem necessidade de
modificações.
Essa separação entre os conceitos de política e

mecanismo traz uma grande flexibilidade aos sistemas
operacionais, permitindo alterar sua personalidade sem
ter de mexer no código que interage diretamente com o
hardware.
Sistemas Operacionais
Estrutura de um Sistema Operacional

S.O. – Estrutura do sistema
Um sistema operacional não é um bloco

único e fechado de software executando
sobre o hardware. Na verdade, ele é
composto de diversos componentes que
têm objetivos e funcionalidades
complementares.
Alguns dos componentes mais relevantes
de um sistema operacional típico são:
Núcleo : é o coração do sistema

operacional, responsável pela gerência
dos recursos do hardware usados pelas
aplicações. Ele também implementa as
principais abstrações utilizadas pelos
programas aplicativos.
Drivers : módulos de código específicos para

acessar os dispositivos físicos. Existe um driver
para cada tipo de dispositivo, como discos
rígidos IDE, SCSI, portas USB, placas de vídeo,
etc. Muitas vezes o driver é construído pelo
próprio fabricante do hardware e fornecido em
forma binária para ser acoplado ao restante do
sistema operacional.
Código de inicialização : a inicialização do

hardware requer uma série de tarefas
complexas, como reconhecer os
dispositivos instalados, testá-los e
configurá-los adequadamente para seu
uso posterior. Outra tarefa importante é
carregar o núcleo do sistema operacional
em memória e iniciar sua execução.
Programas utilitários : são programas que

facilitam o uso do sistema computacional,
fornecendo funcionalidades complementares ao
núcleo, como formatação de discos e mídias,
configuração de dispositivos, manipulação de
arquivos (mover, copiar, apagar), interpretador
de comandos, terminal, interface gráfica,
gerência de janelas, etc.
A maioria dos computadores mono-processados

atuais segue uma arquitetura básica definida
nos anos 40 por János (John) Von Neumann,
conhecida por “arquitetura Von Neumann”. A
principal característica desse modelo é a idéia
de “programa armazenado”, ou seja, o
programa a ser executado reside na memória
junto com os dados.
Arquitetura física
Os principais elementos constituintes do

computador (processador, memória e
controladores de periféricos) estão
interligados por um ou mais barramentos
(para a transferência de dados,
endereços e sinais de controle).
Todas as transferência de dados entre

processador, memória e periféricos são feitas
através dos barramentos:
 barramento de endereços indica a posição de
memória (ou o dispositivo) a acessar,
 barramento de controle indica a operação a
efetuar (leitura ou escrita).
 barramento de dados transporta a informação
indicada entre o processador e a memória ou
um controlador de dispositivo.
O processador :O núcleo do sistema de computação é o

processador. Ele é responsável por continuamente ler
instruções e dados da memória ou de periféricos,
processá-los e enviar os resultados de volta à memória
ou a outros periféricos. Um processador convencional
é normalmente constituído de uma
 Unidade lógica e aritmética (ULA), que realiza os
cálculos e operações lógicas,
 Um conjunto de registradores para armazenar dados de
trabalho
 Alguns registradores para funções especiais (contador
de programa, ponteiro de pilha, flags de status, etc).
MMU : O acesso à memória é geralmente

mediado por um controlador específico (que
pode estar fisicamente dentro do próprio
processador): a Unidade de Gerência de
Memória (MMU - Memory Management Unit).
Ela é responsável por analisar cada endereço
solicitado pelo processador, validá-los, efetuar
as conversões de endereçamento necessárias
e executar a operação solicitada pelo
processador (leitura ou escrita de uma posição
de memória).
Memórias
Os periféricos do computador (discos, teclado,

monitor, etc) são acessados através de
circuitos específicos genericamente
denominados controladores. Para o
processador, cada dispositivo é representado
por sua controladora, que pode ser acessada
em uma determinada faixa de endereços de
entrada/saída
Dispositivo Endereços de acesso IRQ
teclado 0060h-006Fh 1
barramento IDE primário 0170h-0177h 14
barramento IDE secundário 01F0h-01F7Fh 15
porta serial COM1 02F8h-02FFh 3
porta serial COM2 03F8h-03FFh 5
Interrupções e exceções
Um mecanismo muito utilizado na interação

entre o processador e os controladores
de periféricos (incluindo a MMU) é de
importância fundamental para a
construção de sistema operacionais: as
interrupções
Quando um controlador de periférico possui uma

informação importante a fornecer ao processador, ele
tem duas alternativas de comunicação:
• Aguardar até que o processador o consulte, o que

poderá ser demorado caso o processador esteja
ocupado com outras tarefas (o que geralmente ocorre);
• Notificar o processador através do barramento de
controle, enviando a ele uma requisição de interrupção
(IRQ – Interrupt ReQuest).
Ao receber a requisição de interrupção, os circuitos do

processador suspendem seu fluxo de execução
corrente e desviam para um endereço pré-definido onde
se encontra uma rotina de tratamento de interrupção
(interrupt handler). Essa rotina é responsável por tratar
a interrupção, ou seja, executar as ações necessárias
para atender o dispositivo que a gerou. Ao final da
rotina de tratamento da interrupção, o processador
retoma o código que estava executando quando
recebeu a requisição.
Interrupções e exceções
 O processador está executando um programa qualquer
(em outras palavras, um fluxo de execução);
 Um pacote vindo da rede é recebido pela placa
Ethernet;
 A placa envia uma solicitação de interrupção (IRQ) ao
processador;
 O processamento é desviado do programa em
execução para a rotina de tratamento da interrupção;
 A rotina de tratamento é executada para receber as
informações da placa de rede (via barramentos de
dados e de endereços) e atualizar as estruturas de
dados do sistema operacional;
 A rotina de tratamento da interrupção é finalizada
e o processador retorna à execução do programa
que havia sido interrompido.
Esse roteiro de ações ocorre a cada requisição de
interrupção recebida pelo processador.
Cada interrupção geralmente corresponde a um
evento ocorrido em um dispositivo periférico: a
chegada de um pacote de rede, um click no
mouse, uma operação concluída pelo controlador
de disco, etc.
Isso representa centenas ou mesmo milhares de
interrupções recebidas por segundo, dependendo
da carga e da configuração do sistema (número e
natureza dos periféricos). Por isso, as rotinas de
tratamento de interrupção devem ser curtas e
realizar suas tarefas rapidamente (para não
prejudicar o desempenho do sistema).
Para distinguir interrupções geradas por dispositivos

distintos, cada interrupção é identificada por um
inteiro, normalmente com 8 bits. Como cada
interrupção pode exigir um tipo de tratamento
diferente (pois os dispositivos são diferentes),
cada IRQ deve disparar sua própria rotina de
tratamento de interrupção.
A maioria das arquiteturas atuais define um vetor de
endereços de funções denominado Vetor de
Interrupções (IV - Interrupt Vector); cada
entrada desse vetor aponta para a rotina de
tratamento da interrupção correspondente.
Por exemplo, se a entrada 5 do vetor contém o valor
3C20h, então a rotina de tratamento da IRQ 5
iniciará na posição 3C20h da memória RAM.
O vetor de interrupções reside em uma posição fixa da
memória RAM, definida pelo fabricante do
processador, ou tem sua posição indicada pelo
conteúdo de um registrador da CPU específico
para esse fim.
As interrupções recebidas pelo processador têm como
origem eventos externos a ele, ocorridos nos
dispositivos periféricos e reportados por seus
controladores. Entretanto, alguns eventos gerados
pelo próprio processador podem ocasionar o desvio
da execução usando o mesmo mecanismo das
interrupções: são as exceções, ou traps.
Eventos como instruções ilegais (inexistentes ou com
operandos inválidos), tentativa de divisão por zero ou
outros erros de software disparam exceções no
processador, que resultam na ativação de uma rotina
de tratamento de exceção, usando o mesmo
mecanismo das interrupções (e o mesmo vetor de
endereços de funções).
IRQ Descrição
0 divide error
1 debug exception
2 null interrupt
3 breakpoint
4 INTO-detected overflow
5 bound range exception
6 invalid opcode
7 device not available
8 double fault
9 coprocessor segment overrun
10 invalid task state segment
11 segment not present
12 stack fault
13 general protection
14 page fault
15 Intel reserved
16 floating point error
17 alignment check
18 machine check
19-31 Intel reserved
32-255 maskable interrupts (devices & exceptions)
Estrutura de um sistema operacional

Proteção do núcleo
Chamadas de sistema

S.O. – Proteção do núcleo
Um sistema operacional deve gerenciar os
recursos do hardware, fornecendo-os às
aplicações conforme suas necessidades. Para
assegurar a integridade dessa gerência, é
essencial garantir que as aplicações não
consigam acessar o hardware diretamente,
mas sempre através de pedidos ao sistema
operacional, que avalia e intermedia todos os
acessos ao hardware.
Para permitir a diferenciação de privilégio de acesso entre
os diferentes tipos de software, os processadores
modernos contam com dois ou mais níveis de privilégio
de execução. Esses níveis são controlados por flags
especiais nos processadores, e a mudança de um nível
de execução para outro é controlada por condições
específicas.
O processador Pentium, por exemplo, conta com 4 níveis
de privilégio (sendo 0 o nível mais privilegiado).
Na forma mais simples desse esquema, podemos
considerar dois níveis básicos de privilégio:
Nível núcleo : também denominado nível supervisor,

sistema, monitor ou ainda kernel space. Para um
código executando nesse nível, todo o processador está
acessível: todos os registradores, portas de
entrada/saída e áreas de memória podem ser
acessados em leitura e escrita. Além disso, todas as
instruções do processador podem ser executadas.
Nível usuário (ou userspace): neste nível,
somente um sub-conjunto das instruções do
processador, registradores e portas de
entrada/saída estão disponíveis. Instruções
“perigosas” como HALT (parar o processador) e
RESET (reiniciar o processador) são proibidas
para todo código executando neste nível. Além
disso, o hardware restringe o uso da memória,
permitindo o acesso somente a áreas
previamente definidas.
Caso o código em execução tente executar
uma instrução proibida ou acessar uma área
de memória inacessível, o hardware irá gerar
uma exceção, desviando a execução para uma
rotina de tratamento dentro do núcleo, que
provavelmente irá abortar o programa em
execução.
“Este programa executou uma instrução ilegal e

será finalizado”
É fácil perceber que, em um sistema
operacional convencional, o núcleo e os
drivers operam no nível núcleo, enquanto
os utilitários e as aplicações operam no
nível usuário, confinados em áreas de
memória distintas. Existem situações mais
complexas que serão vistas
posteriormente.
S.O. – Chamadas do sistema
Pergunta : Como chamar, a partir de uma
aplicação, as rotinas oferecidas pelo núcleo
para o acesso ao hardware e suas abstrações?
Exemplo: como uma aplicação pode acessar a

placa de rede para enviar/receber dados, se não
tem privilégio para acessar as portas de
entrada/saída nem pode invocar o código do
núcleo que implementa esse acesso (pois esse
código reside em outra área de memória)?
Resposta: Os processadores implementam uma
instrução especial que permite acionar o
mecanismo de interrupção de forma intencional,
sem depender de eventos externos ou internos.
Ao ser executada, essa instrução (int no
Pentium, syscall no MIPS) comuta o
processador para o nível privilegiado e procede
de forma similar ao tratamento de uma
interrupção. Por essa razão, esse mecanismo
é denominado interrupção de software.
H
a
r
Aplicação System Call Núcleo d
w
a
r
e
A ativação de procedimentos do núcleo usando
interrupções de software é denominada chamada de
sistema (system call ou syscall). Os sistemas
operacionais definem chamadas de sistema para todas
as operações envolvendo o acesso a recursos de baixo
nível (periféricos, arquivos, etc) ou abstrações lógicas
(criação e finalização de tarefas, operadores de
sincronização e comunicação, etc). Geralmente as
chamadas de sistema são oferecidas para as aplicações
em modo usuário através de uma biblioteca do sistema
(system library), que prepara os parâmetros, invoca a
interrupção de software e retorna à aplicação os
resultados obtidos.
1. No nível usuário, a aplicação invoca a função read(fd, &buffer,
bytes) da biblioteca de sistema (no Linux é a biblioteca GNU C
Library, ou glibc; no Windows, essas funções são implementadas
pela API Win32).
2. A função read preenche uma área de memória com os parâmetros

recebidos e escreve o endereço dessa área em um registrador da
CPU. Em outro registrador, ela escreve o código da chamada de
sistema desejada (no caso do Linux, seria 03h para a syscall read).
3. A função read invoca uma interrupção de software (no caso do

Linux, sempre é invocada a interrupção 80h).
4. O processador comuta para o nível privilegiado (kernel level) e

transfere o controle para a rotina apontada pela entrada 80h do
vetor de interrupções.
5. A rotina obtém o endereço dos parâmetros, verifica a validade de
cada um deles e realiza (ou agenda para execução posterior) a
operação desejada pela aplicação.
6. Ao final da execução da rotina, eventuais valores de retorno são

escritos na área de memória da aplicação e o processamento
retorna à função read, em modo usuário.
7. A função read finaliza sua execução e retorna o controle à

aplicação.
8. Alternativamente, a rotina de tratamento da interrupção de software

pode passar o controle para a gerência de atividades ao invés
de retornar diretamente da interrupção de software.
9. Na seqüência, a gerência de atividades pode devolver o controle a

outra aplicação que também esteja aguardando o retorno de uma
interrupção de software.
A maioria dos sistemas operacionais implementa
centenas ou mesmo milhares de chamadas de
sistema, para as mais diversas finalidades. O
conjunto de chamadas de sistema oferecidas
por um núcleo define a API (Application
Programming Interface) desse sistema
operacional. Exemplos de APIs bem
conhecidas são a Win32, oferecida pelos
sistemas Microsoft derivados do Windows NT, e
a API POSIX [Gal94], que define um padrão de
interface de núcleo para sistemas UNIX.
S.O. – Unix – estrutura do sistema
S.O. – Unix – estrutura do sistema
S.O. – Windows nt – estrutura do sistema
Arquiteturas de sistemas operacionais.

S.O. - Arquiteturas
As múltiplas partes que compõem o
sistema podem ser organizadas de
diversas formas, separando suas
funcionalidades e modularizando seu
projeto. Nesta seção serão
apresentadas as arquiteturas mais
populares para a organização de
sistemas operacionais.
S.O. - Arquiteturas
Sistemas monolíticos
Em um sistema monolítico, todos os

componentes do núcleo operam em modo
núcleo e se inter-relacionam conforme suas
necessidades, sem restrições de acesso entre si
(pois o código no nível núcleo tem acesso
pleno a todos os recursos e áreas de memória).
S.O. - Arquiteturas
 Não há estruturação visível;

 SO é escrito como uma coleção de processos 
cada processo podendo fazer chamadas a qualquer
outro;
 Os serviços (system calls) são requisitados através
da colocação dos parâmetros em lugares definidos
(pilhas e registradores) e da execução de uma
chamada de sistema especial (TRAP) ao kernel ;
S.O. - Arquiteturas
S.O. - Arquiteturas
Vantagem : dessa arquitetura é seu desempenho:

qualquer componente do núcleo pode acessar
os demais componentes, toda a memória ou
mesmo dispositivos periféricos diretamente, pois
não há barreiras impedindo esse acesso. A
interação direta entre componentes também
leva a sistemas mais compactos.
S.O. - Arquiteturas
Desvantagens:
 O mal funcionamento de uma aplicação do
kernel pode se alastrar e levar o sistema ao
colapso (travamento ou instabilidade)
 Manutenção mais complexa.
 Evolução mais complexa.
S.O. - Arquiteturas
A arquitetura monolítica foi a primeira forma de

organizar os sistemas operacionais; sistemas UNIX
antigos e o MS-DOS seguiam esse modelo.
Atualmente, apenas sistemas operacionais embutidos
usam essa arquitetura, devido às limitações do
hardware sobre o qual executam. O núcleo do Linux
nasceu monolítico, mas vem sendo paulatinamente
estruturado e modularizado desde a versão 2.0
S.O. - Arquiteturas
Sistemas em camadas
a camada mais baixa realiza a interface com o

hardware, enquanto as camadas intermediárias
provêem níveis de abstração e gerência cada
vez mais sofisticados. Por fim, a camada
superior define a interface do núcleo para as
aplicações (as chamadas de sistema).
S.O. - Arquiteturas
Sistemas em camadas
Essa abordagem de estruturação de software

fez muito sucesso no domínio das redes de
computadores, através do modelo de referência
OSI (Open Systems Inter- connection) [Day83],
e também seria de se esperar sua adoção no
domínio dos sistemas operacionais. No entanto,
alguns inconvenientes limitam sua aceitação
nesse contexto.
S.O. - Arquiteturas
Sistemas em camadas
 Camadas sobrepostas;
 Cada módulo oferece um conjunto de funções que podem ser utilizadas
por outros módulos.
Administrar
Camada 4 Programas de Usuário
dispositivos de
Gerência dos Dispositivos de E/S
Camada 3 Entrada/Saída
Comunicação operador-
Administra
Camada 2 processo comunicação
entre cada
Camada 1 Gerência de memória processo
Alocação do processador e Responsável

Camada 0 implementação da poralocaçãode
multiprogramação
espaço
S.O. - Arquiteturas
Sistemas em camadas
Sistema visto como camadas de anéis concêntricos.
 anéis mais internos são mais privilegiados que os

externos;
 prodedimentos de anéis externos executavam
chamadas de sistema TRAP para utilizar os serviços
dos anéis internos;
 proteção dos segmentos de memória.
S.O. - Arquiteturas
usuário
MULTICS
VMS supervisor
Executivo
kernel
S.O. - Arquiteturas
Sistemas em camadas
Inconvenientes:
 O empilhamento de várias camadas de software faz com

que cada pedido de uma aplicação demore mais tempo
para chegar até o dispositivo periférico ou recurso a ser
acessado, prejudicando o desempenho do sistema.
 Não é óbvio como dividir as funcionalidades de um

núcleo de sistema operacional em camadas horizontais
de abstração crescente, pois essas funcionalidades são
inter-dependentes, embora tratem muitas vezes de
recursos distintos.
S.O. - Arquiteturas
Sistemas em camadas
A estruturação em camadas é apenas parcialmente

adotada hoje em dia. Muitos sistemas implementam
uma camada inferior de abstração do hardware para
interagir com os dispositivos (a camada HAL – Hardware
Abstraction Layer, implementada no Windows NT e seus
sucessores), e também organizam em camadas alguns
sub-sistemas como a gerência de arquivos e o suporte
de rede (seguindo o modelo OSI).
Como exemplos de sistemas fortemente estruturados

em camadas podem ser citados o IBM OS/2 e o
MULTICS [CV65].
S.O. - Arquiteturas
Sistemas micro-núcleo (cliente/sevidor)
Uma outra possibilidade de estruturação

consiste em retirar do núcleo todo o código de
alto nível (normalmente associado às políticas
de gerência de recursos), deixando no núcleo
somente o código de baixo nível necessário
para interagir com o hardware e criar as
abstrações fundamentais (como a noção de
atividade).
S.O. - Arquiteturas
Sistemas micro-núcleo
Por fazer os núcleos de sistema ficarem menores, essa

abordagem foi denominada micro-núcleo (ou µ-kernel).
Um micro-núcleo normalmente implementa somente a
noção de atividade, de espaços de memória protegidos
e de comunicação entre atividades. Todos os aspectos
de alto nível, como políticas de uso do processador e da
memória, o sistema de arquivos e o controle de acesso
aos recursos são implementados fora do núcleo, em
processos que se comunicam usando as primitivas do
núcleo.
S.O. - Arquiteturas
S.O. - Arquiteturas
Exemplo : usando essa abordagem o

código de acesso aos blocos de um disco
rígido seria mantido no núcleo, enquanto
as abstrações de arquivo e diretório
seriam criadas e mantidas por um código
fora do núcleo, executando da mesma
forma que uma aplicação do usuário.
S.O. - Arquiteturas
Em um sistema micro-núcleo, as interações

entre componentes e aplicações são feitas
através de trocas de mensagens. Assim, se
uma aplicação deseja abrir um arquivo no disco
rígido, envia uma mensagem para o gerente de
arquivos, que por sua vez se comunica com o
gerente de dispositivos para obter os blocos de
dados relativos ao arquivo desejado.
S.O. - Arquiteturas
Todas as mensagens são transmitidas

através de serviços do micro-núcleo.
Como os processos têm de solicitar
“serviços” uns dos outros (para poder
realizar suas incumbências), essa
abordagem também foi denominada
cliente-servidor.
S.O. - Arquiteturas
Vantagens:
Robustez e flexibilidade. Caso um sub-sistema

tenha problemas, os mecanismos de proteção de
memória e níveis de privilégio irão confiná-lo,
impedindo que a instabilidade se alastre ao restante do
sistema. Além disso, é possível customizar o sistema
operacional, iniciando somente os componentes
necessários ou escolhendo os componentes mais
adequados às aplicações que serão executadas.
S.O. - Arquiteturas
Desvantagens:
o custo associado às trocas de

mensagens entre componentes pode ser
bastante elevado, o que prejudica seu
desempenho e diminui a aceitação desta
abordagem.
S.O. - Arquiteturas
Vários sistemas operacionais atuais adotam

parcialmente essa estruturação; por exemplo,
o MacOS X da Apple tem suas raízes no
sistema Mach, ocorrendo o mesmo com o
Digital UNIX.
O QNX é um dos poucos exemplos de micro-
núcleo amplamente utilizado, sobretudo em
sistemas embutidos e de tempo-real.
S.O. - Arquiteturas
Na prática a implementação de estruturas cliente-servidor é muito

difícil devido a certas funções do sistema operacional exigirem acesso
direto ao hardware;
 » exemplo: operações de e/s.
Na realidade é implementada uma combinação do modelo de camadas

com o modelo cliente-servidor;
Núcleo do sistema:
 » realizar a comunicação entre cliente e servidor;
 » executar funções críticas do sistema;
 » executar funções dos device drivers.
S.O. - Arquiteturas
Máquinas virtuais
Uma máquina virtual é definida como

“uma duplicata eficiente e isolada de
uma máquina real”.
S.O. - Arquiteturas
Máquinas virtuais
Em uma máquina real, uma camada de software

de baixo nível (por exemplo, a BIOS dos
sistemas PC) fornece acesso aos vários
recursos do hardware para o sistema
operacional, que os disponibiliza de forma
abstrata às aplicações. Em uma máquina real,
quando o sistema operacional acessa os
dispositivos de hardware, ele faz uso dos
drivers respectivos, que interagem diretamente
com a memória e os dispositivos da máquina.
S.O. - Arquiteturas
Máquinas virtuais
Um emulador é o oposto da máquina real.

O emulador implementa todas as ins-
truções realizadas pela máquina real em
um ambiente abstrato, possibilitando
executar um aplicativo de uma plataforma
em outra, por exemplo, um aplicativo do
Windows executando no Linux.
S.O. - Arquiteturas
Máquinas virtuais
Um emulador perde muito em eficiência

ao traduzir cada instrução da máquina
real. Além disso, emuladores são
bastante complexos, pois geralmente
necessitam simular a quase totalidade das
instruções do processador e demais
características do hardware que os
circundam
S.O. - Arquiteturas
Máquinas virtuais
A funcionalidade e o nível de abstração de

uma máquina virtual encontra-se entre
uma máquina real e um emulador, na
medida em que abstrai somente os
recursos de hardware e de controle
usados pelas aplicações.
S.O. - Arquiteturas
Máquinas virtuais
Uma máquina virtual é um ambiente

criado por um monitor de máquinas
virtuais, também denominado “sistema
operacional para sistemas
operacionais”. O monitor pode criar
uma ou mais máquinas virtuais sobre
uma única máquina real.
S.O. - Arquiteturas
Máquinas virtuais
Enquanto um emulador fornece uma camada

de abstração completa entre o sistema em
execução e o hardware, um monitor abstrai o
hardware subjacente e controla uma ou mais
máquinas virtuais. Cada máquina virtual
fornece facilidades para uma aplicação ou um
“sistema convidado” que acredita estar
executando sobre um ambiente normal com
acesso físico ao hardware.
S.O. - Arquiteturas
Máquinas virtuais
Existem basicamente duas abordagens para a

construção de sistemas de máquinas virtuais:
 O tipo I, onde o monitor de máquinas virtuais é
implementado entre o hard-ware e os sistemas
convidados.
 O tipo II, onde o monitor é implementado como
um processo de um sistema operacional real
subjacente, denominado sistema anfitrião ou
sistema hospedeiro.
S.O. - Arquiteturas
Máquinas virtuais
Tipo I Tipo II
S.O. - Arquiteturas
Máquinas virtuais
Como exemplos de sistemas de tipo I

podem ser citados o VMWare ESX Server
e o Xen; para o tipo II podem ser citados
o VMWare Workstation, o MS Virtual PC e
o User-Mode Linux.
S.O. - Arquiteturas
Máquinas virtuais
Vantagens:
• Aperfeiçoamento e testes de novos sistemas operacionais;

• Ensino prático de sistemas operacionais e programação de baixo nível;
• Executar diferentes sistemas operacionais sobre o mesmo hardware,
simultaneamente;
• Simular configurações e situações diferentes do mundo real, como por
exemplo, mais memória disponível, outros dispositivos de E/S;
• Simular alterações e falhas no hardware para testes ou reconfiguração
de um sistema operacional, provendo confiabilidade e escalabilidade para as
aplicações;
• Garantir a portabilidade das aplicações legadas (que executariam sobre uma
VM simulando o sistema operacional original);
• Desenvolvimento de novas aplicações para diversas plataformas, garantindo a
portabilidade destas aplicações;
• Diminuir custos com hardware.
S.O. - Arquiteturas
Máquinas virtuais
Desvantagens:
A principal desvantagem do uso de máquinas virtuais é o custo
adicional de execu- ção dos processos na máquina virtual em
comparação com a máquina real. Esse custo é muito variável,
podendo passar de 50% em plataformas sem suporte de hardware
à virtualização, como os PCs de plataforma Intel. Todavia,
pesquisas recentes têm obtido a redução desse custo a patamares
abaixo de 20%, graças sobretudo a ajustes no código do sistema
hospedeiro. Esse problema não existe em ambientes cujo
hardware suporta o conceito de virtualização, como é o caso dos
mainframes.
Noções de processos
S.O. – Noções de processos.
O conceito de processo
Um programa é:
 Uma seqüência finita de instruções;

 Uma entidade passiva (que não se altera com o
passar do tempo).
 Armazenado em disco.
Um processo é:
 Uma abstração que representa um programa em

execução;
 Uma entidade dinâmica: seu estado se altera conforme
for executando.
 Armazenado na memória.
 Pode-se encontrar mais de um processo instanciando
um programa único
O processo do ponto de vista do S.O.
Imagem de um programa
 Segmento de código
 Conjunto de recursos de HW alocados pelo Sis. Operacional.
 Registradores (PC, Stack Pointer…);
 Espaço de endereçamento (memória);
 Espaço no disco (arquivos de E/S).
 Unidade de escalonamento
 Estado;
O processo do ponto de vista do S.O.
Processo (ativo) X Programa(passivo)
Vários processos podem estar associados a um único

programa.
Bloco de controle de processo:
Representa o processo no sistema operacional, mantendo a

informação associada com cada um.
Constitui-se de uma área de memória reservada ao processo e que
mantêm suas informações, tais como:
 PID (número identificador do processo)
 Estado do processo (rodando, bloqueado, etc...)
 PC (endereço da próxima instrução)
 Registradores da CPU
 Informações de gerenciamento de memória (limite, utilizado, etc...)
 Etc...
Bloco de controle de processo:
Representação da imagem do processo
O processo é representado por uma “imagem”:
 Seu segmento de código (o que ele vai fazer)

 Seu espaço de endereçamento (onde, na memória, ele vai fazer
alguma coisa)
 Seu contexto (o que ele precisa para fazer alguma coisa)
 Parte da imagem está sob a responsabilidade do usuário; parte
dele só é gerenciada em modo protegido (pelo Sis. Operacional)
Comunicação entre processos (IPC)
 A comunicação entre processos, em inglês Inter-Process

Communication (IPC), é o grupo de mecanismos que permite aos
processos transferirem informação entre si.
 A execução de um processo pressupõe por parte do sistema
operacional, entre outras coisas, a criação de um contexto de
execução próprio que, de certa forma, abstrai o processo dos
componentes reais do sistema.
 Devido a esta virtualização dos recursos, o processo não tem
conhecimento acerca dos outros processos e, como tal, não
consegue trocar informação.
 O sistema operacional provê recursos para a troca de informações.
Comunicação entre processos (IPC)
Classificação:
 Mecanismos locais
 Pipes nomeados (FIFO)
 Pipes unidireccionais
 Filas de mensagens
 Memória Compartilhada
 Mecanismos cliente/servidor
 Sockets
 Remote Procedure Calls
Relacionamento entre processos
Sem relacionamento (Caso mais simples): os processos são

independentes.
Grupo de processos
Compartilhamento de recursos
 Baseados em hierarquia de processos:
 Um processo pai cria processos filhos;

 Os filhos podem executar o mesmo código, ou trocá-lo;
 Obtem-se uma árvore de processos.
 Implica na definição da semântica de termino de um processo:
 Só o processo morre;
 Toda sua descendência morre.
Na vida, os processos se separam em duas categorias:
Enquanto executam, os processos apresentam dois tipos de

comportamento:
 Ou usam a CPU - Cálculo, operações sobre a memória e/ou

registradores
 Ou fazem Entrada/saída (liberam a CPU) Escrita na tela, entrada
teclado, som, vídeo, rede, disco…
Fala-se de processos CPU-bound e processos I/O- bound
Na vida real: difícil definir qual processo é CPU/IO – bound!

Ciclo de vida – troca de estado
Os processos evoluem: Criado -> “em vida” -> morto
Durante a vida, passam de “uso de CPU” e a “uso de E/S” (e

reciprocamente), via chamada de sistema, interrupção, ou por
causa de um evento.
Ao ser criado, um processo estará pronto para usar a CPU.
 O que acontece se a CPU não está disponível?

 O que acontece se processos estão sendo criados
simultaneamente ?
 Precisa-se manter uma lista de processos prontos!
Ao executar, o processo pode querer fazer E/S:
O que acontece se o recurso de E/S está sendo ocupado?
É preciso de uma fila de processos bloqueados

Após ter executado, o processo passa a ser encerrado.
Em resumo:
Cinco estados (criado, pronto, executando, bloqueado, encerrado)

Estados de processo
 Criado: processo novo, sem utilizar a cpu ainda.

 Pronto: Contexto carregado e esperando o uso de cpu
 Executando: Instrução em uso da cpu pertence ao
processo em execução.s
 Bloqueado: aguardando evento (E/S, sinal, etc...)
 Encerrado: processo terminado.
O que causa uma transição?
Pronto -> executando - Algoritmo de escalonamento
Executando -> pronto

Interrupção de tempo
Interrupção devida ao escalonador
Decisão espontânea (yield)
Executando -> bloqueado

E/S – sincronização
O que causa uma transição?
Bloqueado -> pronto

Interrupção
Executando -> encerrado

Interrupção (CTRL-C)
Término normal
Bloqueado, pronto -> encerrado

interrupção
Mais um estado : Suspenso
Dois problemas principais para gerar os recursos:
 A CPU é muito mais rápida do que a memória;

 A memória é de tamanho finito.
Precisa-se, então, poupar a memória.
 Processos bloqueados que estão na memória podem ser

transferidos para o disco (swap) até sua E/S ser acabada.
 Processos prontos podem também ser descarregados para o disco.
Mais um estado : Suspenso
Chega-se a mais dois estados:
 Bloqueado > suspenso.
 Pronto > suspenso.

Exercício – diagrama de estados
Desenhar o novo diagrama de estados incluindo os estados pronto,

suspenso e bloqueado, suspenso.
Sistemas
Operacionais
Aula 07
Escalonamento de processos
Conceito de Escalonamento
 Para cada estado, existe uma fila que contém os PCB's
executando pcb3
prontos pcb1 pcb5 pcb2
e/s disco pcb4 pcb6
bloqueados e/s terminal pcb9
e/s impressão pcb8 pcb7 pcb10
 nas transições entre estados, o PCB do processo é

movido entre as filas apropriadas
Razões para Suspender Processos
 Do SO
 Swapping: para liberar espaço na memória principal

para trazer outro processo da memória secundária
 SO pode suspender um processo
 em background
 utilitário
 suspeito de estar causando problemas
 Solicitação de usuário interativo
 Temporização: determinados processos são executados
periodicamente
 Solicitação do processo pai
 Escalonamento consiste em determinar, dentre

os processos prontos, qual o próximo processo a
ser executado
 Realizado por um componente do sistema
operacional denominado escalonador
 Dois tipos de escalonadores
 longo prazo
 curto prazo
 Escalonador longo prazo
memória secundária  memória principal
 Escalonador curto prazo
memória principal  processador
 Principais objetivos
 maximizar a utilização do processador
 maximizar o número de processos completados
por unidade de tempo
 garantir que todos os processos recebam o
processador
 minimizar o tempo de resposta para o usuário
 Uma visão dos escalonadores do sistema operacional
Longo-Prazo Curto-Prazo
FIM
Fila de Prontos CPU
Fila
I/O
Espera
 Dispatcher: responsável por passar o controle da CPU

para o processo selecionado pelo escalonador de curto
prazo, envolve:
 mudança de contexto
 mudança para o modo usuário
 salto para a posição adequada dentro do processo
selecionado para reiniciar sua execução
 Latência de despacho  Tempo gasto pelo
dispatcher para interromper um processo e começar a
execução de um outro
Representação do Escalonamento
CPU
fila de processos prontos
requisição de
I/O fila de dispositivo
I/O
término de fatia
de tempo
filho em criação de um
execução processo filho
interrupção em espera por

ocorre uma interrupção
Adição de Escalonador Intermediário
carregar processos em execução remover

parcialmente removidos
da memória
terminar
fila de processos
CPU
prontos
fila de espera por

I/O
I/O
 Mudança de contexto
 CPU é chaveada para outro processo  SO deve
salvar o estado do processo antigo e carregar o
estado do novo processo
 Implica overhead  SO não realiza nenhum
trabalho útil durante os chaveamentos
 Tempo consumido é dependente do suporte de
hardware fornecido
Chaveamento da CPU
interrupção ou chamada ao sistema
exec.
SO
ocioso
armazenar estado no PCB0
.
.
.
recarregar estado no PCB1
executando
ocioso
interrupção ou chamada ao sistema
armazenar estado no PCB1
Processo P1
Processo P0
.
.
.
ocioso
recarregar estado no PCB0
exec.
Características dos Escalonadores
 Escalonador da CPU é invocado muito

freqüentemente (milissegundos)
  precisa ser rápido
 Escalonador de processos é invocado com muito
pouca freqüência (segundos, minutos)
  pode ser lento
 O escalonador de processos controla o grau de
multiprogramação do sistema
 Os escalonadores são implementados por

algoritmos dentro do sistema operacional
 Critérios para comparar a eficiência dos algoritmos
 utilização da CPU (1)
 taxa de saída (throughput) (2)
 turnaround time (3)
 tempo de espera (4)
 tempo de resposta (5)
 Objetivos maximizar (1) e (2)
minimizar (3), (4) e (5)
 Considerações
 Tipo de processamento
 batch
 interativo
 CPU bound
 I/O bound
 Tipo de sistema
política de escalonamento
 monoprogramado (?)
(scheduling policies)
 multiprogramado
 time-sharing
 tempo-real
 multiprocessado
Critérios de Escalonamento
 Orientados ao Usuário e Desempenho
 Uso do processador  mede a porcentagem de
tempo em que a CPU está ocupada
 importante em tempo compartilhado
 não muito importante em sistemas monousuário e
tempo-real
 Tempo de resposta
processos interativos
tempo entre uma requisição e o início da resposta
do ponto de vista do usuário
qual seria o tempo de resposta ideal ?
 Orientados ao Usuário e Desempenho

 Deadlines (prazos)  quando o prazo de término
pode ser especificado
 o sistema deveria fazer o melhor esforço para
atender todos os prazos
 Previsibilidade  um dado processo deveria
executar sempre em um tempo médio previsível
 a carga do sistema não deveria impor
variações
 Orientados ao Sistema e Desempenho
 Throughput (vazão)  número de processos
completados por unidade de tempo, depende:
 do tamanho dos processos
 das políticas de escalonamento
 Turnaround  intervalo de tempo entre a
submissão de um processo e o seu término
 inclui o tempo de execução, espera por
recursos
 medida para sistemas batch
 Waiting time  quantidade total de tempo que um
processo esteve esperando na fila de prontos
 Orientados ao Sistema
 Justiça  processos devem ser tratados igualmente,
a menos que especificado o contrário
processos não deveriam sofrer starvation
 Prioridades  processos mais prioritários devem
efetivamente ser favorecidos
problema da inversão de prioridade
 Balanceamento de recursos  recursos devem ficar
ocupados o máximo possível
processos que não vão utilizar recursos
sobrecarregados devem ser favorecidos
Escalonamento de Processos
 Longa duração  decisão de se adicionar um

processo ao pool de processos para serem
executados
admissão ao sistema
 Duração média  decisão de se adicionar ao
número de processos que está completamente ou
parcialmente na memória
swapping, memória virtual
 Curta duração  decisão de qual processo

disponível será executado
interrupção de clock e I/O, chamadas ao
sistema, signals
 I/O  decisão de qual processo que está na fila
de espera por uma requisição de I/O será tratado
 Tipos
 não-preemptivo: processo executando não pode
ser interrompido
 preemptivo: processo pode ser retirado do
processador
 Políticas mais comuns:
 First-Come-First-Served (FCFS)
 Shortest Job First (SJF)
 Prioridade
 Múltiplas Filas
 Round-Robin
First-Come-First-Served (FIFO)
 Não preemptivo por definição
 Primeiro processo da fila é o primeiro a ser
executado
 Processos usam a CPU até terminar todo
processamento
 Mesmo com alguma intercalação, processos
com menor prioridade podem prejudicar
processos com maior prioridade
 inversão de prioridade
 starvation
First-Come-First-Served
PROCS. TE TT
p1 0 ut 6 ut
p2 6 ut 8 ut
p3 14 ut 7 ut
p4 21 ut 3 ut
t=6 t=8 t=7 t=3

p1 p2 p3 p4
p1 p2 p3 p4
0 6 14 21 24 t
 Exemplo: Processo Tempo de execução

P1 24
P2 3
P3 3
 Suponha que os processos chegaram na seguinte
ordem: P1 , P2 , P3
1. Qual seria o diagrama de Gannt, o waiting time para

cada um dos processos e o waiting time médio?
 Diagrama de Gantt para o escalonamento:
P1 P2 P3
0 24 27 30
 Waiting time para P1 = 0; P2 = 24; P3 = 27

 Waiting time médio: (0 + 24 + 27)/3 = 17
Shortest-Job-First
 Pode ser preemptiva ou não-preemptiva
 Cada processo é associado ao seu tempo de uso do
processador
 Escalonado o processo com o menor tempo de CPU
 privilegiam processos menores
 reduzem o tempo médio de espera na fila de
prontos
 Problema:
 Como determinar quanto tempo de CPU será
necessário?
Shortest-Job-First
 Tanto o escalonamento FIFO quanto o SJF não são
utilizados em sistemas de time-sharing (por quê ?)
t=6 t=8 t=7 t=3

p1 p2 p3 p4
p4 p1 p3 p2
0 3 9 16 24 t
Shortest-Job-First
A política SJF é ótima, minimizando o tempo

médio de espera de um conjunto de processos
 Dificuldade: determinar antecipadamente o
tempo de processador de cada processo
 Na prática, o tempo é estimado, é utilizada
uma aproximação
Shortest-Job-First: não preemptivo
 Processo Tempo de chegada Duração da rajada
P1 0.0 7
P2 2.0 1
P3 4.0 4
P4 5.0 4
 SJF (não preemptivo)
 waiting time médio = (0 + 5 + 4 + 7)/4 = 4
P1 P2 P3 P4
0 3 7 8 12 16
Shortest-Job-First: preemptivo
 Processo Tempo de chegada Duração da rajada

P1 0.0 7 terminado
P2 2.0 4 terminado
P3 4.0 1 terminado
terminado
P4 5.0 4
SJF (preemptivo)
P1 P2 P3 P2 P4 P1
0 2 4 5 7 11 16
waiting time médio = (9 + 1 + 0 +2)/4 = 3

Shortest-Job-First: preemptivo
 Processo Tempo de chegada Duração da

rajada terminado
tempo restante: 5
 P2 P1 2.0 0.0 4 tempo restante: 2
terminado
P3 7 4.0 1 terminado
P4 5.0 4 terminado
SJF (preemptivo)
P1 P2 P3 P2 P4 P1
0 2 ?
4 5 7 11 16
?
waiting time médio = (9 + 1 + 0 +2)/4 = 3

Shortest-Job-First
 Determinação do tempo de CPU, pode:

somente estimar a próxima duração
ser feita usando a duração de tempo de CPU
anteriores, usando-se média exponencial
1. t n  tamanho real da n α rajada de CPU
2.  n 1  valor estimado para a próxima rajada de CPU
3.  , 0    1
4. Define :
 n 1   t n  1    n
Shortest-Job-First
  =0
 n+1 = n  História recente não conta
  =1
 n+1 = tn  Somente o último tempo de CPU (rajada) é
condiserado
 Se expandirmos a fórmula teremos
 n+1 =  tn+(1 - )  tn-1 + …
 +(1 -  ) j  tn-1 + …
 +(1 -  )n+1 tn 0
 Uma vez que tanto  como (1 - ) são menores ou iguais a 1,
cada termo tem peso menor do que o seu predecessor
Shortest-Job-First Preemptivo
 Permite que se dê atenção mais rapidamente a processos

mais prioritários
 Melhores respostas em sistemas time-sharing
 Compartilhamento do processador tende a ser mais
uniforme
 Troca de processos na CPU gera overhead
 Estabelecer de forma otimizada os critérios para a
preempção
 Procurar utilizar processos leves quando possível
Prioridade
 A cada processo é atribuída uma prioridade
 O processo com maior prioridade é atribuído ao
processador
 Pode ser não-preemptiva ou preemptiva
 não-preemptiva: o processo libera
espontaneamente o processador
 preemptiva : o processo executando é
interrompido caso chegue à fila de prontos um
processo com maior prioridade
Prioridade
 Atribuição de prioridades
 estática: o processo tem uma prioridade
fixa durante o seu tempo de vida
 dinâmica: prioridade muda ao longo do
tempo de vida do processo, de acordo com
o seu comportamento
Prioridade
 Dinâmica
pode ser ajustada
 Atribuição de acordo com
de prioridades
 tipo de processamento realizado
 normalmente é feita pelo SO
 a carga do SO
 pode ser configurada pelo superusuário
 quando o processo passa do estado de
 Estáticade usuário recebem uma prioridade
 processos
espera para o estado executando ele é
máxima de usuário
é atribuída
penalizado quando o processo é
e sua prioridade é reduzida,
 usuário pode diminuir a prioridade de seus
iniciado
processos
processos
 Observação
  nãoCPU
 ex.:
 SO
épode
alterada
comando
durante
boundrenice
terão suas
associar àdo
aprioridades
Unix
alta
existência do
prioridade um
processo
reduzidas
númeroaescalar
cada passagem
pequeno para o estado
executando
 pode oferecer tempos de resposta
  0 significa a maior prioridade
  I/O bound ficam em estado de espera
aceitáveis
com freqüência, processos CPU bound não
serão prejudicados
Prioridade
Processo A 4 u.t. 3 u.t. 5 u.t. 1u.t.
Processo B 4 u.t. 2 u.t. 2 u.t. 3 u.t.
4 8 10 13 16 18 23 26 27 tempo
B solicita A solicita B solicita B solicita
preempção preempção
I/O I/O I/O I/O
por B por B
B solicita
I/O
Tempo de CPU (u.t.) Característica do Processo Prioridade
Processo A 13 CPU bound 1 menor
Processo B 11 I/O bound 0 maior

Prioridade
 Vantagens
 é possível fazer diferenciação entre processos
 adaptabilidade (prioridades dinâmicas)
 Desvantagem
 starvation: um processo com baixa prioridade
pode nunca ser atribuído ao processador
 solução: aumentando, em intervalos regulares, a
prioridade dos processos que estão há muito tempo
esperando
Round-Robin
 Escalonamento do tipo preemptivo

 Cada processo executa durante uma fatia de
tempo (time-slice ou quantum)
 Ao final da fatia de tempo, o processo
executando é inserido no final da fila de
prontos
 Processo na frente da fila de prontos recebe o
processador
Round-Robin
bcp1 bcp2 bcp3 bcp4
processo 1 executando
fatia de tempo
esgotada
bcp2 bcp3 bcp4 bcp1
processo 2 executando
Round-Robin
 Bom para tempo compartilhado

 Similar a FIFO + tempo limite para
execução (time-slice ou quantum)
 terminado o quantum, o processo é
devolvido (preempção) para o final da
fila de prontos
 processos não monopolizam a CPU
 quantum entre 100 a 300 ms
Round-Robin
Processo A 5 u.t. 2 u.t. 5 u.t. 3 u.t.
Processo B 4 u.t. 2 u.t. 2 u.t.
5 9 11 13 16 21 23 26 27 tempo
termina termina
B solicita B solicita A solicita
quantum quantum
I/O I/O I/O
de A de A
B solicita
A solicita
I/O
I/O
Tempo de CPU (u.t.) Característica do Processo
Processo A 15 CPU bound
Processo B 8 I/O bound

Round-Robin
 Vantagem do escalonamento Robin Round

  simplicidade
 Tamanho da fatia de tempo é crucial no
escalonamento circular
 pequena: tempo de troca de contexto
torna-se significativo
 grande: aumenta o tempo de resposta
dos processos no final da fila de prontos
Round-Robin
 Se existem n processos na fila de prontos

 Se quantum = q
  cada processo tem 1/n do tempo de
CPU em fatias de no máximo q unidades
de tempo cada
 Nenhum processo espera por mais de
(n-1) q unidades de tempo para ser
atendido
Round-Robin
 Desempenho
quantum = muito grande
  FIFO
quantum = muito pequeno
  q deve ser grande comparado a
mudança de contexto, caso contrário, o
overhead é muito elevado
Round-Robin
Processo Tempo de execução
P1 53
P2 17
P3 68
P4 24
 Diagrama de Gantt (quantum = 20 u.t.)
P1 P2 P3 P4 P1 P3 P4 P1 P3 P3
0 20 37 57 77 97 117 121 134 154 162
 Tipicamente, temos turnaround time médio maior que

na SJF, mais em compensação melhor resposta
Como um pequeno quantum de tempo aumenta as mudanças de
contexto
quantum mudanças
tamanho do processo: 10 u.t. de contexto
12 0
0 10
6 1
0 6 10
1 9
0 1 2 3 4 5 6 7 8 9 10
Múltiplas Filas
 Política do tipo preemptiva

 Prioridades são atribuídas às classes de processos
 Processos das classes de maior prioridade recebem o
processador
 Processos podem migrar entre classes de acordo com
seu comportamento
 Vantagem: adaptabilidade de acordo com o
comportamento do processo
Múltiplas Filas
 Processos são classificados em função do

tipo de processamento
 Cada grupo formado  fila associada
 Fila de prontos associada a cada grupo
permite
aplicação de tipos de escalonamento
diferentes
Múltiplas Filas
 Cada fila possui uma prioridade

 SO só vai escalonar processos em uma fila
se todos os processos das filas de maior
prioridade estiverem vazias
Múltiplas Filas
p=3
processos interativos
p=2
p=1
processos em batch
p=0
 sistema Exemplo
 mais prioritário
 algoritmo de escalonamento por prioridades
 interativo
 prioridade intermediária
 escalonamento Round-Robin
 batch
 menor prioridade
 usa Round-Robin ou FCFS
Maior Prioridade
Fila de Processos do Sistema
Fila de Processos Interativos
Fila de Processos Batch
Menor Prioridade
Múltiplas Filas com Realimentação
 Escalonamento anterior a classificação dos processos

era estática
 Se processo alterar seu comportamento, o esquema
pode falhar (não existe reclassificação)
 Seria interessante que o SO
 reconhecesse a alteração de comportamento de um
processo
ajustasse dinamicamente o seu tipo de
escalonamento
Múltiplas Filas com Realimentação
 No escalonamento por múltiplas filas com

realimentação (multi-level feed-bak queues)
 é permitido que os processos sejam movimentados
entre as filas
 ajuste dinâmico (mecanismo adaptativo)
 processo é direcionado para uma das filas em
função de seu comportamento
Múltiplas Filas com Realimentação:
Funcionamento
 Criação do processo
  prioridade mais alta e quantum mais baixo
 Cada fila pode implementar uma política de
escalonamento diferente para chegar a CPU:
 FIFO com quantum
 SJF
 RR
Funcionamento
 Processo é reescalonado dentro da mesma fila

quando
 processo volta ao estado de pronto
sofrepreempção por outro processo de uma fila
mais prioritária
 Processo é direcionado para fila de menor
prioridade e maior quantum quando
 processo esgota o seu quantum (sofrendo
preempção)
Funcionamento
 Quanto maior a prioridade menor o quantum

 Escalonamento de uma fila só acontece depois
que todas as outras filas de prioridade mais alta
estão vazias
 Fila de menor prioridade  Round-Robin
Características
 Atende as necessidades de escalonamento de
diversos tipos de processos
 Processos I/O bound
 bom tempo de resposta: maior prioridade

 permanecem a maior parte do tempo nas
filas de alta prioridade
 usa pouco a CPU
Características
 Processos CPU bound

com o transcorrer do processamento sua
prioridade vai sendo reduzida
É um mecanismo complexo e gera
overhead, mas os resultados são
satisfatórios
Exemplo 1
Maior Prioridade Menor quantum
Fila 1 (escalonamento FIFO)

preempção por término de quantum


...
Fila m (Round-Robin)
Menor Prioridade Maior quantum
Exemplo 2
quantum = 8
quantum = 16
FCFS

Escalonamento preemptivo

Escalonamento Preemptivo
Lembrando…
 O Sis. Op. escalona os processos na CPU de forma a otimizar seu uso.
Várias métricas possíveis.
 O despachante efetua a troca de contexto entre os processos.
Copia os registradores, ponteiros para o espaço de endereçamento,

descritores de arquivos…
 O escalonador pode ser preemptivo ou não.
Exemplos de não-preemptivos: FIFO, SJF, Prioridades.

Os diagramas de Gantt são usados para visualizar um escalonamento.
Algoritmos de escalonamento pre-emptivos
 Round-Robin;
 Por prioridades;
 Múltiplas filas.
 Estudos de caso de escalonadores:

Windows
Linux
Minix
O escalonamento Round Robin
 O escalonador define um quantum (fatia de tempo) para cada processo.
 Após se encerrar a fatia, o processo escalonado deve ceder o lugar na

CPU a um outro.
Também se perde a CPU se terminar antes do fim do quantum, ou faz um

pedido de E/S.
 Mantém-se uma lista circular de processos prontos.
 Deve-se usar um mecanismo de interrupção regular, ocorrendo a cada

fatia de tempo.
 Usa o clock.
Diagrama de Gant – Escalonamento Round Robin
Ex. Quantum de duas unidades de tempo.

Round-Robin: observações
 Deve-se ter um algoritmo de desempate entre os processos prontos

quando há uma interrupção…
FIFO, SJF, prioridades…
 Se o quantum aumenta muito, se obtém novamente um FIFO.
 Espera média:
A: 7
B: 6
C: 5
(7+6+5)/3 = 6.
Round-Robin: limitações e problemas
 O grande interesse do R.R. é sua “equidade”
 Todos os processos acabam tendo uma chance regular de executar.
 Como definir o quantum?
Muito grande: = FIFO!
Muito pequeno: só se faz troca de contexto…
 Processos I/O bound são prejudicados!
Esperam tanto como os outros, mas não chegam a usar seu quantum todo!
Solução: juntar Round Robin e prioridades com preempção

Prioridades com preempção
 Define-se prioridades para os processos.
 Logo que surgir um processo com maior prioridade que o que está executando, ele preempta o
mesmo que volta para a fila dos “prontos”.
 Caso haja mais de um processo com uma dada prioridade, se aplica um segundo algoritmo de
desempate.
Tipicamente Round-Robin;
Também pode ser um FIFO ou SJF.
 Neste caso, obtém-se uma lista por nível de prioridades.
Quando uma fila está vazia, considera-se a lista de prioridade inferior.
Múltiplas filas, com realimentação.
Pode ter um algoritmo distinto de desempate em cada fila.

R.R. com prioridades e Prioridades com R.R.
O Round-Robin com prioridades usa-as para desempatar processos prontos
no início de uma fatia de tempo.
R.R. com prioridades e Prioridades com R.R.
O algoritmo de prioridades com Round-Robin usa-o para desempatar os
processos que têm uma prioridade idêntica.
Definição de prioridades
 Estática: a prioridade é dada na criação do processo
Pelo Sis. Op., pelo usuário…
Problema: há risco de postergação indefinida (starvation) para um

processo com baixa prioridade.
 Dinâmica: a prioridade evolui durante o ciclo de vida do processo.
Começa com um valor estático . Evolui depois:
Aumenta a medida que o processo usa a CPU;

Aumenta proporcionalmente à fração do quantum que não usou. Assim,
os processos I/O bound voltam na fila de espera com alta prioridade!
Estudo de caso: windows 2000
Escalonador preemptivo com prioridades, com R.R.
O quantum varia conforme a prioridade. Default (XP): 2 “clock intervalos” (10

ms em x86).
Duas classes com 16 prioridades:

Maior o valor, maior a prioridade.
Prioridades estáticas (para tempo real) Níveis 16-31
Prioridades dinâmicas Níveis 0-15 (0 é reservado)
Categorias: high (13)
above normal (10)
normal (8)
below normal (6)
idle (4)
Cada nível tem uma fila usando um Round_Robin para desempatar.

Detalhes: Variação das prioridades e do quantum no Windows
 O processo recebe uma prioridade de base (herdada do processo pai. )
 Pode ser alterada com o explorador de processos.
 O quantum varia conforme o ciclo de vida
 A prioridade varia conforme o ciclo de vida:
 Se há preempção, o processo preemptado entra no início da fila.
 Se termina uma E/S o processo sofre aumento de prioridade

O aumento depende do driver de E/S.
O aumento baixa com o tempo.
Nunca desce em baixo da base (0 ou 16), nem aumenta acima do teto (15
ou 32).
Estudo de caso: LINUX 2.4
 Duas classes de processos:
Regulares: interativos & batches

Tempo real.
 Quanto maior o valor, maior a prioridade.

Regulares: de 0 até 999
Tempo real: de 1000 a 1099.
 A prioridade se chama “goodness”
 No caso tempo real, usa-se um mecanismo de prioridades estáticas

Fixadas pelo usuário entre 1 e 99 (+ 1000).
Com RR para desempatar (SCHED_RR);
Com FIFO para desempatar (SCHED_FIFO);
 Define-se “epochs” (duração fixa de tempo).
 No início de uma “época”, os processos recebem um quantum de

base Qi.
 Quando todos zeram seu quantum, começa uma nova época.
 Ao ser criado, um processo i recebe uma prioridade inicial (p)
 O usuário pode diminuir o default através da chamada de sistema

nice()/setpriority()
Sua prioridade definitiva = p + tempo de sobra em seu quantum.
Enquanto o processo executa, seu quantum é decrementado.
Quando zera, o processo é bloqueado.
Se é preemptado antes do fim de seu quantum, prioridade = p + sobra
Ou seja, obtém uma prioridade maior do que um recém-criado “normal”.
Quando não tem mais nenhum processo pronto, começa um novo

epoch.
Prioridade(i) = p + (quantum restante)/2
Todos processos ganham novos créditos, mas quem ainda tinha tem
mais!
Threads

Threads
Lembrando…
 Escalonamentos preemptivos
Um processo pode ter sua execução interrompida e voltar para a fila

dos prontos.
 Exemplos:
Round-Robin (fatia de tempo/quantum).
Com prioridades para desempatar…
Prioridades / múltiplas filas com realimentação.
Com Round-Robin para desempatar.
Threads
Lembrando…
 Um processo = uma imagem dinâmica de um processo

em execução.
 Um processo = um conjunto de recursos de HW

alocados pelo Sis. Op. = uma unidade a escalonar.
 A imagem do processo na memória é constituída de

vários segmentos.
Threads
Bloco Descritor de Processo
A estrutura de dados que representa o processo no Sis. Op. É chamada

“Process Control Block” (PCB)
Contém as informações necessárias:

Registradores, memória, disco (arquivos)
Prioridade
Estado
Histórico (contabilidade)
Ponteiro para um outro PCB (lista encadeada)
O Sis. Op. deve manter listas de processos
Listas encadeadas;
A estrutura PCB é usada para tal;
Mantém-se um ponteiro sobre o primeiro e/ou o último PCB.
Threads
Imagem do processo
Threads
A imagem do processo
 Texto: contém as instruções binárias do código

executável do processo (imagem).
 Dados: espaço para as variáveis do processo,
declaradas como globais no programa.
 Heap: memória para alocação sob-demanda durante a
execução Alocação dinâmica
 Pilha: memória para alocação:
De variáveis locais a sub-rotinas
Do endereço de retorno de uma sub-rotina.
 Área do usuário vs. área do sistema.
Threads
O processo é…
 Um programa em execução
 Uma unidade de escalonamento
 Um fluxo de execução
 Um conjunto de recursos (contexto) gerenciados pelo Sis. Op.
 Registradores
 Memória
 Descritores de arquivos
 Etc…
A troca de contexto é uma operação pesada
Deve acontecer cada vez que há decisão de escalonamento

Threads
Threads é uma forma de um processo dividir a si
mesmo em duas ou mais tarefas que podem ser
executadas simultaneamente.
Idéia simples: associar mais de um fluxo de

execução a um processo:
Compartilhamento de recursos do PCB

O PCB deve incluir uma lista de threads!
Threads
Em uma máquina multiprocessada ou em um cluster de
computadores, podemos ter vários processos (inclusive
de uma mesma aplicação) rodando ao mesmo tempo
(vale salientar que em máquinas monoprocessadas o
que ocorre é um pseudoparalelismo).
Entretanto, na prática, precisamos de uma granularidade

ainda menor, isto é, precisamos de paralelismo dentro
de um mesmo processo.
Esse paralelismo interno ao processo é obtido com o uso

de Threads.
Threads
Threads
Na realidade, uma thread é análoga a um
processo tendo em vista que ambos são
uma execução seqüencial de um conjunto
de instruções.
Contudo, uma thread é considerada leve
pelo fato de rodar dentro do contexto do
processo, aproveitando-se do
compartilhamento dos recursos alocados
para o ambiente do programa.
Threads
Portanto, uma thread é um subconjunto das informações pertinentes a
um processo e as threads de um mesmo processo compartilham
recursos entre si:
Itens por processo Itens por threads
Espaço de endereçamento Contador de Programa

Variáveis globais Registradores
Arquivos abertos Pilha
Processos filhos Estado
Alarmes pendentes
Sinais e tratadores de sinais
Uso de recursos
Threads
Cada thread tem sua própria pilha de execução.
Threads são bem mais fáceis de criar e destruir, o que
implica em um ganho de performance considerável.
Threads
Há dois tipos de threads: de usuário e de sistema (núcleo).
Threads de usuário:
 O sistema (núcleo) não sabe da existência de threads

 Núcleo gerencia processos monothread
 Cada processo tem sua própria tabela de threads
 Um sistema supervisor, dentro do processo, gerencia os threads
 Salva estado
 Faz escalonamento
 Melhor desempenho
 Threads devem se comportar educadamente -> Ceder a vez
quando não puderem continuar.
Threads
Threads de usuário:
Threads
Threads de sistema:
O núcleo conhece as threads e as gerencia
 Núcleo tem tabela de threads e tabela de

processos
 Bloqueio de threads = chamadas ao sistema
 Núcleo escolhe outro thread do mesmo
processo ou um thread de outro processo
Threads
Threads de sistema:
Threads
Grande parte das aplicações existentes usam o
conceito de multitarefa (multithread).
Por exemplo, quando estamos usando um
navegador WEB (Internet Explorer, Netscape,
...), ao mesmo tempo em que estamos lendo um
texto, também podemos estar efetuando o
download de arquivos e ouvindo música. Para
cada uma dessas atividades, o navegador cria
threads que executarão em
(pseudo)paralelamente.
Threads
Grande parte das aplicações existentes usam o
conceito de multitarefa (multithread).
Por exemplo, quando estamos usando um
navegador WEB (Internet Explorer, Netscape,
...), ao mesmo tempo em que estamos lendo um
texto, também podemos estar efetuando o
download de arquivos e ouvindo música. Para
cada uma dessas atividades, o navegador cria
threads que executarão em
(pseudo)paralelamente.
Aula 10
Comunicação e sincronização de
processos.
Prof Diovani Milhorim

2
Condições de Corrida
 Exemplo: Fila de impressão.

◦ Qualquer processo que queira imprimir precisa colocar o seu documento na fila
de impressão (compartilhada).
◦ O processo de impressão retira os documentos na ordem em que chegaram na
fila
◦ Se a fila é compartilhada, isto significa que seus dados, assim como os
indicadores de frente e fim da fila também o são
3
1. fim++ (incrementa o indicador do fim da fila)

2. coloca documento na posição do novo fim da fila
 dois processos resolvem simultaneamente imprimir um documento

 o primeiro processo foi interrompido (por ter acabado o seu quantum) entre os comandos 1 e 2
 o segundo processo insere seu documento na fila antes que o primeiro processo tenha acabado : qual é o erro
????
 Há uma condição de corrida quando dois ou mais processos estão acessando dados compartilhados e o
resultado depende de quem roda quando
4
 Condições de corrida são situações onde dois ou mais processos
acessam dados compartilhados e o resultado final depende da
ordem em que os processos são executados
 Ordem de execução é ditada pelo mecanismo de escalonamento
do S.O.
 Torna a depuração difícil.
 Condições de corrida são evitadas através da introdução de
mecanismos de exclusão mútua:
 A exclusão mútua garante que somente um processo estará
usando os dados compartilhados num dado momento.
 Região Crítica: parte do programa (trecho de código) em que os
dados compartilhados são acessados
 Objetivo da Exclusão Mútua:
 Proibir que mais de um processo entre em sua Região Crítica
5
Exemplo 1
Procedure echo();
var out, in: character;
begin
input (in, keyboard);
out := in;
output (out, display)
end.
 P1 invoca echo() e é interrompido imediatamente após a conclusão

da função input(). Suponha que x tenha sido o caractere digitado,
que agora está armazenado na variável in.
 P2 é despachado e também invoca echo(). Suponha que y seja
digitado (in recebe y), sendo então exibido no dispositivo de saída.
 P1 retoma a posse do processador. O caractere exibido não é o que
foi digitado (x), pois ele foi sobreposto por y na execução do
processo P2. Conclusão: o caractere y é exibido duas vezes.
 Essência do problema: o compartilhamento da variável global in.
6
Exemplo 2 (1)
 Diretório de spooler com n

entradas, cada uma capaz de
armazenar um nome de
arquivo.
 Servidor de impressão verifica
se existem arquivos a serem
impressos. Caso afirmativo, ele
os imprime e remove os
nomes do diretório.
 Variáveis compartilhadas: out,
que aponta para o próximo
arquivo a ser impresso; e in,
que aponta para a próxima
entrada livre no diretório.
7
Exemplo 2 (2)
 PA e PB decidem colocar um arquivo no spool de

impressão quase ao mesmo tempo.
 PA lê in, armazena o seu valor (7) na variável local next-
free-slot e é interrompido.
 PB é escalonado, lê in e coloca o nome do seu arquivo no
slot 7, atualizando in para 8.
 PA retorna e escreve o nome do seu arquivo na entrada 7
(valor de next-free-slot), apagando o nome colocado por
PB. A variável next-free-slot passa a valer 8.
 O servidor não notará nada de errado (o diretório está
consistente) e PB nunca realizará qualquer saída.
8
Concorrência
 Dificuldades:
 Compartilhamento de recursos globais.
 Gerência de alocação de recursos.
 Localização de erros de programação (depuração de
programas).
 Ação necessária:
 Proteger os dados compartilhados (variáveis, arquivos
e outros recursos globais).
 Promover o acesso ordenado (controle de acesso) aos
recursos compartilhados  sincronização de
processos.
9
Abordagens para Exclusão Mútua
 Requisitos para uma boa solução:

 A apenas um processo é permitido estar dentro de sua
R.C. num dado instante.
 Nenhum processo que executa fora de sua região
crítica pode bloquear outro processo (ex: processo
pára fora da sua R.C.).
 Nenhuma suposição pode ser feita sobre as
velocidades relativas dos processos ou sobre o número
de CPUs no sistema.
 Nenhum processo pode ter que esperar eternamente
para entrar em sua R.C. ou lá ficar eternamente.
10
Tipos de Soluções
 Soluções de Hardware
 Inibição de interrupções
 Instrução TSL (apresenta busy wait)
 Soluções de software com busy wait
 Variável de bloqueio
 Alternância estrita
 Algoritmo de Decker
 Algoritmo de Peterson
 Soluções de software com bloqueio
 Sleep / Wakeup, Semáforos, Monitores
11
Inibição de Interrupções
 Usa um par de instruções do tipo DI / EI.
 DI = disable interrupt EI = enable interrupt
 O processo desativa todas as interrupções
imediatamente antes de entrar na sua R.C.,
reativando-as imediatamente depois de sair dela.
 Com as interrupções desativadas, nenhum
processo que está na sua R.C. pode ser
interrompido, o que garante o acesso exclusivo
aos dados compartilhados.
12
Exemplo - Problema do produtor-

consumidor
13
Exemplo - Problema do produtor-

consumidor
 variável N indica quantos itens ainda podem ser
colocados no buffer.
Produtor Consumidor
DI DI
LDA N LDA N
DCR A INC A
STA N STA N
EI EI
14
Problemas da Solução DI/EI
 É desaconselhável dar aos processos de usuário

o poder de desabilitar interrupções.
 Não funciona com vários processadores.
 Inibir interrupções por um longo período de
tempo pode ter conseqüências danosas. Por
exemplo, perde-se a sincronização com os
dispositivos periféricos.
 OBS: inibir interrupções pelo tempo de algumas
poucas instruções pode ser conveniente para o kernel
(p.ex., para atualizar uma estrutura de controle).
15
Tipos de Soluções
 Algoritmo de Decker
16
Soluções com Busy Wait
 Busy wait = espera ativa ou espera ocupada.

 Basicamente o que essas soluções fazem é:
 Quando um processo quer entrar na sua R.C. ele verifica se a
entrada é permitida. Se não for, ele espera em um laço
(improdutivo) até que o acesso seja liberado.
 Ex: While (vez == OUTRO) do {nothing};
 Conseqüência: desperdício de tempo de CPU.
 Problema da inversão de prioridade:
 Processo LowPriority está na sua R.C. e é interrompido. Processo
HighPriority é selecionado mas entra em espera ativa. Nesta
situação, o processo LowPriority nunca vai ter a chance de sair da
sua R.C.
17
1a. Tentativa - Variável de Bloqueio

 Variável de bloqueio, compartilhada, indica se a
R.C. está ou não em uso.
 turn = 0  R.C. livre turn = 1  R.C. em uso
 Tentativa para n processos:
var turn: 0..1
turn := 0
Process Pi:
...
while turn = 1 do {nothing};
turn := 1;
< critical section >
turn := 0;
...
18
Problemas da 1a. Tentativa
 A proposta não é correta pois os processos

podem concluir “simultaneamente” que a R.C.
está livre, isto é, os dois processos podem
testar o valor de turn antes que essa variável
seja feita igual a true por um deles.
19
Tipos de Soluções (cont.)
 Algoritmo de Dekker
20
2a. Tentativa – Alternância Estrita
 Variável global indica de quem é a vez na hora de

entrar na R.C.
 Tentativa para 2 processos:
var turn: 0..1;
P0: P1:
. .
. .
while turn ≠ 0 do {nothing}; while turn ≠ 1 do {nothing};
< critical section > < critical section >
turn := 1; turn := 0;
. .
21

 O algoritmo garante a exclusão mútua, mas
obriga a alternância na execução das R.C.
 Não é possível a um mesmo processo entrar duas
vezes consecutivamente na sua R.C.
 Logo, a “velocidade” de entrada na R.C. é ditada pelo
processo mais lento.
 Se um processo falhar ou terminar, o outro não
poderá mais entrar na sua R.C., ficando
bloqueado permanentemente.
22
3a. Tentativa
 O problema da tentativa anterior é que ela guarda a
identificação do processo que pode entrar na R.C.
 Entretanto, o que se precisa, de fato, é de informação
de estado dos processos (i.e., se eles querem entrar

na R.C.)
 Cada processo deve então ter a sua própria “chave de
intenção”. Assim, se falhar, ainda será possível a um outro
entrar na sua R.C.
 A solução se baseia no uso de uma variável array para
indicar a intenção de entrada na R.C.
23
3a. Tentativa
 Antes de entrar na sua R.C, o processo examina a
variável de tipo array. Se ninguém mais tiver
manifestado interesse, o processo indica a sua intenção
de ingresso ligando o bit correspondente na variável de
tipo array e prossegue em direção a sua R.C.
var flag: array[0..1] of boolean;
flag[0]:= false; flag[1]:= false;
Process P0: Process P1:

... ...
while flag[1] do {nothing}; while flag[0] do {nothing};
flag[0] := true; flag[1] := true;
flag[0] := false; flag[1] := false;
... ...
24

 Agora, se um processo falha fora da sua R.C. não haverá
nenhum problema, nenhum processo ficará eternamente
bloqueado devido a isso. Entretanto, se o processo falhar
dentro da R.C., o problema ocorre.
 Não assegura exclusão mútua, pois cada processo pode
chegar à conclusão de que o outro não quer entrar e,
assim, entrarem simultaneamente nas R.C.
 Isso acontece porque existe a possibilidade de cada processo
testar se o outro não quer entrar (comando while) antes de um
deles marcar a sua intenção de entrar.
25
4a. Tentativa
 A idéia agora é que cada processo marque a sua intenção
de entrar antes de testar a intenção do outro, o que
elimina o problema anterior.
 É o mesmo algoritmo anterior, porém com uma troca de
linha.

... ...
while flag[1] do while flag[0] do
{nothing}; {nothing};
... ...
26

 Garante a exclusão mútua mas se um processo falha
dentro da sua R.C. (ou mesmo após setar o seu flag) o
outro processo ficará eternamente bloqueado.
 Uma falha fora da R.C. não ocasiona nenhum problema
para os outros processos.
 Problemão:
 Todos os processos ligam os seus flags para true (marcando o
seu desejo de entrar na sua R.C.). Nesta situação todos os
processos ficarão presos no while em um loop eterno (situação
de deadlock).
27
5a. Tentativa
 Na tentativa anterior o processo assinalava a sua
intenção de entrar na R.C. sem saber da intenção do
outro, não havendo oportunidade dele mudar de idéia
depois (i.e., mudar o seu estado para “false”).
 A 5a. tentativa corrige este problema:
 Após testar no loop, se o outro processo também quer entrar na
sua R.C, em caso afirmativo, o processo com a posse da UCP
declina da sua intenção, dando a vez ao parceiro.
28
5a. Tentativa (cont.)

... ...
while flag[1] do while flag[0] do
begin begin
<delay for a short time> <delay for a short time>
flag[0] := true flag[1] := true
end; end;
... ...
29
5a. Tentativa (cont.)

 Esta solução é quase correta. Entretanto, existe um
pequeno problema: a possibilidade dos processos ficarem
cedendo a vez um para o outro “indefinidamente”
(problema da “mútua cortesia”)
 Livelock
 Na verdade, essa é uma situação muito difícil de se
sustentar durante um longo tempo na prática, devido às
velocidades relativas dos processos. Entretanto, ela é uma
possibilidade teórica, o que invalida a proposta como
solução geral do problema.
30
5a. Tentativa – Exemplo

P0 seta flag[0] para true.
P0 testa flag[1].
P1 testa flag[0].
P0 seta flag[0] para false.
P1 seta flag[1] para false.
31
Solução de Dekker
 Trata-se da primeira solução correta para o problema da
exclusão mútua de dois processos (proposta na década
de 60).
 O algoritmo combina as idéias de variável de bloqueio e
array de intenção.
 É similar ao algoritmo anterior mas usa uma variável
adicional (vez/turn) para realizar o desempate, no caso
dos dois processos entrarem no loop de mútua cortesia.
32
Algoritmo de Dekker
var flag: array[0..1] of boolean;
turn: 0..1; //who has the priority
flag[0] := false
flag[1] := false
turn := 0 // or 1
Process p0: Process p1:

while flag[1] { while flag[0] {
if turn ≠ 0 { if turn ≠ 1 {
flag[0] := false flag[1] := false
while turn ≠ 0 {} while turn ≠ 1 {}
} }
} }
// critical section // critical section

... ...
// end of critical section // end of section
turn := 1 turn := 0
33
Algoritmo de Dekker (cont.)
 Quando P0 quer entrar na sua R.C. ele coloca seu flag em true. Ele
então vai checar o flag de P1.
 Se o flag de P1 for false, então P0 pode entrar imediatamente na
sua R.C.; do contrário, ele consulta a variável turn.
 Se turn = 0 então P0 sabe que é a sua vez de insistir e, deste modo,
fica em busy wait testando o estado de P1.
 Em certo ponto, P1 notará que é a sua vez de declinar. Isso permite
ao processo P0 prosseguir.
 Após P0 usar a sua R.C. ele coloca o seu flag em false para liberá-la,
e faz turn = 1 para transferir o direito para P1.
34
Algoritmo de Dekker (cont.)

 Algoritmo de Dekker resolve o problema da exclusão mútua
 Uma solução deste tipo só é aceitável se houver um número de CPUs
igual (ou superior) ao número de processos que se devam executar no
sistema. Porquê?
 Poderíamos nos dar 'ao luxo' de consumir ciclos de CPU,
 Situação rara na prática (em geral, há mais processos do que CPUs)
 Isto significa que a solução de Dekker é pouco usada.
 Contudo, a solução de Dekker mostrou que é possível resolver o
problema inteiramente por software, isto é, sem exigir instruções
máquina especiais.
 Devemos fazer uma modificação significativa do programa se
quisermos estender a solução de 2 para N processos:
 flag[] com N posições; variável turn passa a assumir valores de 1..N;
alteração das condições de teste em todos os processos
35
Solução de Peterson
 Proposto em 1981, é uma solução simples e elegante
para o problema da exclusão mútua, sendo facilmente
generalizado para o caso de n processos.
 O truque do algoritmo consiste no seguinte:
 Ao marcar a sua intenção de entrar, o processo já indica (para o
caso de empate) que a vez é do outro.
 Mais simples de ser verificado
36
Algoritmo de Peterson
flag[0] := false
flag[1] := false
turn := 0

turn := 1 turn := 0
while ( flag[1] && turn == 1 ){ while ( flag[0] && turn == 0 ){
// do nothing // do nothing
} }
// critical section // critical section
... ...
// end of critical section // end of critical section
37
Solução de Peterson (cont.)

 Exclusão mútua é atingida.
 Uma vez que P0 tenha feito flag[0] = true, P1 não pode entrar
na sua R.C.
 Se P1 já estiver na sua R.C., então flag[1] = true e P0 está
impedido de entrar.
 Bloqueio mútuo (deadlock) é evitado.
 Supondo P0 bloqueado no seu while, isso significa que flag[1] =
true e que turn = 1
 se flag[1] = true e que turn = 1, então P1 por sua vez entrará
na sua seção crítica
 Assim, P0 só pode entrar quando ou flag[1] tornar-se false ou
turn passar a ser 0.
38
 Variável de bloqueio A alteração do valor p/ “trancado” APÓS o
 Alternância estrita teste permite que dois processos executem
a R.C. ao mesmo tempo!
 Algoritmo de Dekker O TESTE e a ALTERAÇÃO necessitam ser
 Algoritmo de Peterson feitos de forma indivisível...
39
A Instrução TSL (1)

 TSL = “Test and Set Lock”
 Solução de hardware para o problema da exclusão
mútua em ambiente com vários processadores.
 O processador que executa a TSL bloqueia o barramento de
memória, impedindo que outras CPUs acessem a MP até que a
instrução tenha terminado.
 A instrução TSL faz o seguinte:
 Lê o conteúdo de um endereço de memória (variável
compartilhada “lock”, usada para proteger a R.C.) para um
registrador e armazena um valor diferente de zero
(normalmente 1) nesse endereço.
40

 Se lock = 0  R.C. livre;
Se lock = 1  R.C. ocupada.
(Lock é iniciada com o valor 0).
 A instrução TSL é executada de forma atômica.
 As operações de leitura e armazenamento da variável lock são
garantidamente indivisíveis, sem interrupção.
 Nenhuma outra CPU pode acessar lock enquanto a instrução não
tiver terminado.
41

 Em ling. de alto nível, seria o mesmo que fazer o seguinte
de forma atômica:
boolean testset (int lock) {

if (lock == 0) {
lock = 1;
return true;
}
else {
return false;
}
}
42

43

 Vantagens da TSL:
 Simplicidade de uso (embora sua implementação em hardware
não seja trivial).
 Não dá aos processos de usuário o poder de desabilitar
interrupções.
 Presente em quase todos os processadores atuais.
 Funciona em máquinas com vários processadores.
 Desvantagens:
 Espera ocupada (busy wait).
 Possibilidade de postergação infinita (starvation)
 “processo azarado” sempre pega a variável lock com o valor 1
44
LPRM/DI/UFES Sistemas
Operacionais
Referências
• Silberschatz A. G.; Galvin P. B.; Gagne G.; ''Fundamentos
de Sistemas Operacionais'', 6a. Edição, Editora LTC,
2004.
▫ Capítulo 7 (até seção 7.3 inclusa)
• A. S. Tanenbaum, ''Sistemas Operacionais Modernos'',
2a. Edição, Editora Prentice-Hall, 2003.
▫ Seção 2.3 (até 2.3.3 inclusa)
• Deitel H. M.; Deitel P. J.; Choffnes D. R.; “Sistemas
Operacionais”, 3ª. Edição, Editora Prentice-Hall, 2005
 Capítulo 5 (até seção 5.4.2 inclusa)
Aula 11
Comunicação e sincronização de
processos.
Prof Diovani Milhorim

3
As Primitivas Sleep e Wakeup

 A idéia desta abordagem é bloquear a execução dos
processos quando a eles não é permitido entrar em suas
regiões críticas
 Isto evita o desperdício de tempo de CPU, como nas
soluções com busy wait.
 Sleep()
 Bloqueia o processo e espera por uma sinalização, isto é,
suspende a execução do processo que fez a chamada até que
um outro o acorde.
 Wakeup()
 Sinaliza (acorda) o processo anteriormente bloqueado por
Sleep().
4
O Problema do Produtor e Consumidor c/ Buffer Limitado
 Processo produtor gera dados e os coloca em um buffer de

tamanho N.
 Processo consumidor retira os dados do buffer, na mesma ordem
em que foram colocados, um de cada vez.
 Se o buffer está cheio, o produtor deve ser bloqueado
 Se o buffer está vazio, o consumidor é quem deve ser bloqueado.
 Apenas um único processo, produtor ou consumidor, pode acessar o
buffer num certo instante.
 Uso de Sleep e Wakeup para o Problema do Produtor e
Consumidor
dado dado dado ...
1 2 3 N
5
#define N 100 /* number of slots in the buffer */

int count = 0; /* number of items in the buffer */
void producer(void) {
while (true){
produce_item(); /* generate next item */
if (count == N) sleep(); /* if buffer is full, go to sleep */
enter_item(); /* put item in buffer */
count = count + 1; /* increment count of items in buffer*/
if (count == 1) wakeup(consumer); /* was buffer empty? */
}
}
void consumer(void){
while (true){
if (count == 0) sleep(); /* if buffer is empty, got to sleep */
remove_item(); /* take item out of buffer */
count = count - 1; /* decrement count of items in buffer*/
if (count == N-1) wakeup(producer); /* was buffer full? */
consume_item(); /* print item */
}
}
6
Uma Condição de Corrida ...

 Buffer está vazio. Consumidor testa o valor de count,
que é zero, mas não tem tempo de executar sleep, pois
o escalonador selecionou agora produtor. Este produz
um item, insere-o no buffer e incrementa count. Como
count = 1, produtor chama wakeup para acordar
consumidor. O sinal não tem efeito (é perdido), pois o
consumidor ainda não está logicamente adormecido.
Consumidor ganha a CPU, executa sleep e vai dormir.
Produtor ganha a CPU e, cedo ou tarde, encherá o
buffer, indo também dormir. Ambos dormirão
eternamente.
7
8
Semáforos (1)
 Mecanismo criado pelo matemático holandês E.W. Dijkstra, em

1965.
 O semáforo é uma variável inteira que pode ser mudada por
apenas duas operações primitivas (atômicas): P e V.
 P = proberen (testar)
 V = verhogen (incrementar).
 Quando um processo executa uma operação P, o valor do semáforo
é decrementado (se o semáforo for maior que 0). O processo
pode ser eventualmente bloqueado (semáforo for igual a 0) e
inserido na fila de espera do semáforo.
 Numa operação V, o semáforo é incrementado e, eventualmente,
um processo que aguarda na fila de espera deste semáforo é
acordado.
9
Semáforos (2)
 A operação P também é comumente referenciada

como:
 down ou wait
 V também é comumente referenciada
 up ou signal
 Semáforos que assumem somente os valores 0 e 1 são

denominados semáforos binários ou mutex. Neste caso,
P e V são também chamadas de LOCK e UNLOCK,
respectivamente.
10
Semáforos (3)
P(S):
If S > 0
Then S := S – 1
Else bloqueia processo (coloca-o na fila de S)
V(S):
If algum processo dorme na fila de S
Then acorda processo
Else S := S + 1
11
Uso de Semáforos (1)
 Exclusão mútua (semáforos binários):
...
Semaphore mutex = 1; /*var.semáforo,
iniciado com 1*/
Processo P1 Processo P2 ... Processo Pn

... ... ...
P(mutex) P(mutex) P(mutex)
// R.C. // R.C. // R.C.
V(mutex) V(mutex) V(mutex)
... ... ...
12
#define N 100 /* number of slots inLPRM/DI/U

the bufferSistem
*/
typedef int semaphore; /* FES
semaphores are a special kindasof int */
semaphore mutex = 1; /* controls access to critical region
Operaci */
semaphore empty = N; /* counts empty buffer slots */ onais
semaphore full = 0; /* counts full buffer slots */
void producer(void){
Exemplo: Produtor - Consumidor c/ Buffer Limitado
int item;
produce_item(&item); /* generate something to put in buffer */
P(&empty); /* decrement empty count */
P(&mutex); /* enter critical region */
enter_item(item); /* put new item in buffer */
V(&mutex); /* leave critical region */
V(&full); /* increment count of full slots */
}
void consumer(void){
int item;
P(&full); /* decrement full count */
P(&mutex); /* enter critical region */
remove_item(&item); /* take item from buffer */
V(&mutex); /* leave critical region */
V(&empty); /* increment count of empty slots */
consume_item(item); /* do something with the item */
}
13
Semáforo em C/C++ LPRM/DI/U Sistem

FES as
Incluir o header da biblioteca semaphore. Operaci
onais
#include <semaphore.h>
Criar o semáforo, neste exemplo chamado de teste;

sem_t teste;
Inicialização do semáforo
sem_init(&teste, 0, 0);
Função para (decrementar/aguardar)

sem_wait(&teste);
Função para (incrementar/liberar)

sem_post(&teste);
função para apagar o semáforo após a utilização

sem_destroy(&teste);
14
Semáforo em c++ Sistem

Exemplo: as
Operaci
onais
void thread1()
{
sem_wait(&teste);
regiao_critica;
sem_post(&teste);
}
void thread2()
{
sem_wait(&teste);
regiao_critica;
sem_post(&teste);
}
15
Deficiência dos Semáforos (1)
 Exemplo: suponha que os dois down do código do

produtor estivessem invertidos. Neste caso, mutex seria
diminuído antes de empty. Se o buffer estivesse
completamente cheio, o produtor bloquearia com mutex
= 0. Portanto, da próxima vez que o consumidor tentasse
acessar o buffer ele faria um down em mutex, agora
zero, e também bloquearia. Os dois processos ficariam
bloqueados eternamente.
 Conclusão: erros de programação com semáforos podem
levar a resultados imprevisíveis.
16
Deficiência dos Semáforos (2)
 Embora semáforos forneçam uma abstração flexível o bastante para

tratar diferentes tipos de problemas de sincronização, ele é
inadequado em algumas situações.
 Semáforos são uma abstração de alto nível baseada em primitivas de
baixo nível, que provêem atomicidade e mecanismo de bloqueio,
com manipulação de filas de espera e de escalonamento. Tudo isso
contribui para que a operação seja lenta.
 Para alguns recursos, isso pode ser tolerado; para outros esse tempo
mais longo é inaceitável.
 Ex: (Unix) Se o bloco desejado é achado no buffer cache, getblk() tenta
reservá-lo com P(). Se o buffer já estiver reservado, não há nenhuma
garantia que ele conterá o mesmo bloco que ele tinha originalmente.
17
Referências
• A. S. Tanenbaum, ''Sistemas Operacionais Modernos'',
2a. Edição, Editora Prentice-Hall, 2003.
▫ Seções 2.3.4 a 2.3.6
• Silberschatz A. G.; Galvin P. B.; Gagne G.; ''Fundamentos
de Sistemas Operacionais'', 6a. Edição, Editora LTC,
2004.
▫ Seção 7.4
• Deitel H. M.; Deitel P. J.; Choffnes D. R.; “Sistemas
Operacionais”, 3ª. Edição, Editora Prentice-Hall, 2005
 Seção 5.6
- Sincronização de processos
- Monitores e semáforos.
- Prof. Esp. Diovani Milhorim

Solução - Instrução TSL
 Instruções especiais de hardware que permitem testar e
modificar uma palavra de memória atomicamente (sem
interrupções)
 Instrução Test and Set Lock (TSL)
P
while (lock);
x P
while TSL(lock);
lock = true;
Região Crítica;
Região Crítica;
lock = false;
lock = false;
Monitores
 Os monitores são construções de linguagens de programação que
fornecem uma funcionalidade equivalente aos semáforos
 Mais fácil de controlar
 O monitor é um conjunto de procedimentos, variáveis e inicialização

definidos dentro de um módulo
 A característica mais importante do monitor é a exclusão mútua

automática entre os seus procedimentos
 Basta codificar as regiões críticas como procedimentos do monitor e o

compilador irá garantir a exclusão mútua
 Desenvolvimento é mais fácil
 Existem linguagens que não possuem monitores. Os monitores são um

conceito de linguagem de programação
Monitores
monitor monitor-name
{
declaração de variáveis compartilhadas
procedure P1 (…) {
...
}
procedure P2 (…) {
...
}
procedure Pn (…) {
...
}
{
código de inicialização
}
}
Monitores
 Para implementar a sincronização é necessário utilizar variáveis de
condição
 Variáveis de condição
 são tipos de dados especiais dos monitores
 são operadas por duas instruções Wait e Signal
 Wait(C): suspende a execução do processo, colocando-o em estado

de espera associado a condição C
 Signal(C): permite que um processo bloqueado por wait(C) continue

a sua execução.
Se existir mais de um processo bloqueado, apenas um é liberado
Se não existir nenhum processo bloqueado, não faz nada
Monitores
Monitores: Implementação
A linguagem Java suporta nativamente o uso de

monitores. O uso da palavra Synchronized na
chamada de métodos ou blocos garante o controle
do monitor.
Veja a seguir exemplo de código para uma fila com

duas threads, sendo uma consumidora e outra
produtora.
Monitores
class FilaCirc { public int getElement() throws Exception {
private final int TAM = 10;
synchronized(this) {
private int vetInt[];
if (total == 0 ) throw new Exception(
private int inicio, total; "Fila vazia!");
int temp = vetInt[inicio];
public FilaCirc() {
inicio = (++inicio)%TAM;
total--;
vetInt=new int[TAM];
}
inicio=0; return temp;
total =0; }
}
}
public void addElement(int v) throws Exception {
synchronized(this) {
if (total == TAM) throw new Exception("Fila cheia!");
vetInt[(inicio+total)%TAM]=v; Palavra chave = Synchronized

total++;
}
Troca de Mensagens
 Quando é necessário trocar informações entre processos que não
compartilham memória
 Usado para comunicação e sincronização
 Basicamente usa duas primitivas
 send(destino, mensagem)
 receive(origem, mensagem)
 Estas duas primitivas podem ser facilmente colocadas em

bibliotecas
 Uma biblioteca de comunicação que se tornou padrão é MPI

Troca de Mensagens
 Sincronização
 Um processo receptor não pode receber uma mensagem até que esta
tenha sido enviada
 Deve se determinar o que acontece com um processo após executar

um send ou receive
 Send – quando um send é executado existe a possibilidade de bloquear

ou não o processo até que a mensagem seja recebida no destino
 Receive – quando o processo executa um receive existem duas

possibilidades:
 se a mensagem já foi enviada o processo a recebe e continua a sua
execução
 se a mensagem ainda não foi enviada:

 o processo é bloqueado até que a mensagem chegue ou
 o processo continua a executar e abandona a tentativa de recebimento
Troca de Mensagens
 Send e Receive podem ser bloqueantes ou não
bloqueantes
 O mais comum é send não bloqueante e receive bloqueante
 Endereçamento Direto
 O processo que envia ou recebe uma mensagem deve
especificar a origem e o destino
 Endereçamento Indireto
 As mensagens não são endereçadas diretamente entre
processos origem e destino
 As mensagens são enviadas para caixas postais (mailboxes)

Problemas Clássicos de Sincronização
 Produtor/Consumidor
 Jantar dos Filósofos
 Leitores e Escritores
 Barbeiro Dorminhoco
Produtor/Consumidor
 Um processo produz informações que são gravadas em
um buffer limitado
 As informações são consumidas por um processo

consumidor
 O produtor pode produzir um item enquanto o

consumidor consome outro
 O produtor e o consumidor devem estar sincronizados

 O produtor não pode escrever no buffer cheio
 O consumidor não pode consumir informações de um buffer

vazio
Produtor/Consumidor
 Semáforo binário mutex para exclusão mútua
 Semáforos full e empty
 Full conta os espaços cheios no buffer
 Se full igual a zero, então o consumidor deve ser bloqueado
 Empty conta os espaços vazios no buffer
 Se empty igual a zero, então o produtor deve ser bloqueado

Produtor/Consumidor
Jantar dos Filósofos
 Cada filósofo possui um prato
de espaguete
 Para comer o espaguete o filósofo

precisa de dois garfos
 Existe um garfo entre cada par de pratos
 Um filósofo come ou medita
 Quando medita não interage com seus colegas
 Quando está com fome ele tenta pegar dois garfos um de cada vez. Ele
não pode pegar um garfo que já esteja com outro filósofo
 Os garfos são os recursos compartilhados

Solução 1:
Solução 2:
Atividade em sala:
Examine as duas soluções acima e identifique os

problemas da primeira.
Por que a segunda solução se mostra melhor do que

a primeira?
Gerenciamento de memória

 A multiprogramação implica em manter-se vários processos

em memória.
 A memória necessita ser alocada de forma eficiente para

permitir o máximo possível de processos
 Existem diferentes técnicas para gerência de memória,

que dependem do hardware do processador.
Um sistema de memória possui pelo menos
dois níveis:
o Memória principal: acessada pela CPU

o Memória secundária: discos
• Programas são armazenados em disco
o Executar um programa se traduz em

transferi-lo da memória secundária à
memória primária
• Qualquer sistema operacional tem gerência de
memória
 Monotarefa: gerência é simples
 Multitarefa: complexa
• Algoritmos de gerência de memória

dependem de facilidades disponíveis pelo
hardware da máquina
Memória lógica e memória física
Memória lógica
o É aquela que o processo “enxerga”
o Endereços lógicos são aqueles manipulados por

um processo
Memória lógica e memória física
Memória física
 Implementada pelos circuitos integrados de memória.

 Endereços físicos são aqueles que correspondem a
uma posição real de memória.
Endereço lógico versus endereço físico
Espaço lógico de um processo é diferente do espaço físico.
 Endereço lógico: gerado pela CPU (endereço virtual)

 Endereço físico: endereços enviados para a memória RAM
Programas de usuários “vêem” apenas endereços lógicos.
Endereços lógicos são transformados em endereços físicos no

momento de execução dos processos.
Unidade de gerência de memória
• Memory Management Unit (MMU)
• Hardware que faz o mapeamento entre

endereço lógico e endereço físico
Unidade de gerência de memória
Um programa deve ser transformado em um processo para poder ser
executado.
 Alocação de um descritor de processos

 Alocação de áreas de memória para código, dados e pilha
Transformação é feita através de uma série de passos, alguns com a

ajuda do próprio programados.
 Compilação, diretivas de compilação e/ou montagem,

ligação, etc...
 Amarração de endereços (binding)
Amarração de endereços (binding)
Atribuição de endereços (posições de memória) para código e

dados pode ser feita em três momentos diferentes.
 Em tempo de compilação
 Em tempo de carga
 Em tempo de execução .
Atribuição de endereços para instruções e dados pode ser feita

em três momentos diferentes:
 Em tempo de compilação: se a localização da memória

é conhecida a priori, código absoluto pode ser gerado; tem
que recompilar o código se a alocação inicial mudar
 Em tempo de carga: deve gerar código relocável se a
localização da memória não é conhecida em tempo de
compilação
 Em tempo de execução: a atribuição é adiada até o tempo
de execução se o processo puder ser movido durante
sua execução de um segmento de memória para outro.
Precisa de suporte de hardware para mapear
endereços (ex.: registradores base e limite)
Registradores de Base e de Limite.
Um par de registradores de base e de limite

definem o espaço de endereço lógico
Carregador absoluto versus carregador relocador
• Programador não tem conhecimento de onde o programa será

carregado na memória
• O endereço só é conhecido no momento da carga
Durante a execução do programa sua localização física pode ser alterada.

Ex.: procedimento de swapping
• Necessidade de traduzir endereços lógicos a endereços físicos

• Relocação é a técnica que realiza esta tradução
o Via software: carregador relocador

o Via hardware: carregador absoluto
Carregador relocador
• Correção de todas as referências à memória de forma a corresponder

ao endereço de carga do programa
• Necessidade de identificar quais endereços devem ser corrigidos
o Código relocável
o Mapeamento das posições a serem corrigidas é mantida através de
tabelas
• Código executável mantém informações de relocação na forma de

tabelas.
• No momento da carga o programa executável é interpretado e os
endereços corrigidos.
Carregador relocador
Código absoluto - Carregador absoluto
• Não realiza correção de endereços no momento da carga do

programa em memória
• Código executável absoluto não necessita manter tabelas de

endereços a serem corrigidos
• Endereço de carga
Fixo pelo programa (programador)

Qualquer: Correção pode ser feita automaticamente, de forma
transparente, a partir de registradores de base
Mecanismos básicos de gerência de memória
Um programa (processo) para ser executado deve estar na memória
 Onde deve ser carregado? Problema de alocação de memória
A alocação de memória depende de:

 Código absoluto versus código relocável
 Necessidade de espaço contínuo ou não
Necessidade de gerenciamento da memória

 Determinação de áreas livres e ocupadas
 Racionalizar a ocupação da memória
Alocação contígua simples
• Sistema mais simples
• Memória principal é dividida em duas partições: o

Sistema operacional (parte baixa de memória) o
Processo de usuário (restante da memória)
• Usuário tem controle total da memória podendo

inclusive acessar a área do sistema operacional.
Ex.: DOS (não confiável)
 Evolução: inserir proteção através de
mecanismos de hardware + software
 Registradores de base e de limite o

Memory Management Unit (MMU)
Alocação contígua particionada
• Existência de múltiplas partições
• Imposta pela multiprogramação
• Filosofia:
o Dividir a memória em blocos (partições)
o Cada partição pode receber um processo (programa)
o Grau de multiprogramação é fornecido pelo número de partições

* * Importante: não considerando a existência
de swapping
• Duas formas básicas:
 Alocação contígua com partições fixas

(estática)
 Alocação contígua com partições variáveis
(dinâmica)
• O sistema operacional é responsável pelo controle

das partições mantendo informações como:
o Partições alocadas
o Partições livres
o Tamanho das partições
Alocação contígua particionada dinâmica
Alocação contígua particionada fixa
• Memória disponível é dividida em partições

de tamanho fixo que podem ser do mesmo
tamanho ou não
Questões:
o Processos podem ser carregados em qualquer partição?

Depende se o código é absoluto ou relocável
o Número de processos que podem estar em execução ao
mesmo tempo?
Sem swapping – igual ao número de partições (máximo)
Com swapping – maior que o número de partições
o Se o programa é maior que o tamanho da partição?

Não executa a menos que se empregue um esquema de
overlay
Técnica de Overlay
● Enquanto na alocação contígua simples os

programas estão limitados ao tamanho da
área disponível na memória principal para o
usuário, na técnica de Overlay os
programas são divididos em módulos,
deforma que seja possível a execução
independente de cada módulo,utilizando
uma mesma área da memória
Técnica de Overlay
Exemplo de Overlay: Um programa que consista em

um módulo principal e outros dois módulos
independentes, um correspondente ao cadastro e
outro, à impressão. Quando o programa é
carregado, apenas o módulo principal é introduzido
na memória, os demais aguardam em memória
secundária. Quando um dos outros módulos for
referenciado pelo módulo principal, aquele será
carregado na memória principal, na área de overlay
Técnica de Overlay
A definição das áreas de overlay é feita pelo próprio programador,

através de comandos específicos da linguagem de
programação.
● O tamanho da área de overlay deve ser igual ou maior ao

tamanho do maior módulo.
● Como vantagem, a técnica de overlay possibilita um melhor
aproveitamento da memória principal.
● Sua utilização exige cuidado, pois pode trazer implicações tanto
na manutenção como no desempenho das aplicações, devido
à possibilidade de transferências excessivas dos módulos
entre a memória principal e a memória secundária.
Gerenciamento de partições fixas
Com código absoluto
o Um processo só pode ser carregado na área de memória

(partição) para a qual foi compilado
o Pode haver disputa por uma partição mesmo que tendo outras
livres
Processo é mantido no escalonador de longo prazo (termo)

Empregar swapping
Gerenciamento com código relocável
 Um processo de tamanho menor ou igual ao tamanho da

partição pode ser carregado em qualquer partição disponível
 Se todas as partições estão ocupadas, duas soluções:
- Processo é mantido no escalonador de longo prazo (termo)

- Empregar swapping (escalonador a médio prazo)
Swapping
 Processo necessita estar na memória para ser executado
 Se não há mais espaço em memória é necessário fazer um

rodízio de processos em memória
 Um processo pode ser temporariamente movido para

fora da memória (backing store) e então trazido de volta
para a memória para continuar a execução
Swapping
 Backing store – memória secundária suficientemente grande

para armazenar cópias de todos os processos de usuários
 A maior parte do tempo de swap é tempo de transferência; tempo de

swap é proporcional ao tamanho do processo
 Existem variantes do sistema de swapping utilizados em

sistemas como UNIX, Linux e Windows
 Roll out, roll in – swapping variante usado para algoritmos

de escalonamento baseados em prioridade; processo de
baixa prioridade é movido da memória para que processos
de alta prioridade possam ser carregados e executados
Swapping
sistema operacional mantém uma fila de processos que estão
prontos para executar, que possuem imagens da memória em disco
Fragmentação Interna
• Problema da alocação fixa é uso ineficiente da memória

principal
• Um processo, não importando quão pequeno seja, ocupa

uma partição inteira
Fragmentação Interna
Paliativo para reduzir fragmentação interna
 Partições de tamanho diferentes

Algoritmos para alocação de partições fixas
 Se código é absoluto a alocação é determinada na fase de montagem,

compilação ou ligação.
 Se código é relocável:
- Partições de igual tamanho
* Não importa qual partição é utilizada
- Partições de diferentes tamanhos
* Atribui ao processo a menor partição livre capaz de armazena

o processo
* Processo são atribuídos a partições de forma a minimizar o
desperdício de memória (fragmentação interna)
Algoritmos para alocação de partições fixas
Alocação particionada dinâmica
• Objetivo é eliminar a fragmentação interna
• Processos alocam memória de acordo com

suas necessidades
• Partições são em número e tamanho

variáveis
Fragmentação externa
• A execução de processos pode criar

pedaços livres de memória
• Pode haver memória disponível, mas não

contígua
Soluções possíveis fragmentação externa
 Reunir espaços adjacentes de memória

 Empregar compactação
 Relocar as partições de forma a eliminar os espaços entre elas e
criando uma área contígua
Desvantagem:
Consumo do processador
Acesso a disco
 Acionado somente quando ocorre fragmentação

 Necessidade de código relocável
Gerenciamento de partições dinâmicas
• Determinar qual área de memória livre será alocada a um

processo
• Sistema operacional mantém uma lista de lacunas o Pedaços

de espaços livres em memória
• Necessidade de percorrer a lista de lacunas sempre que um

processo é criado
Algoritmos para alocação contígua dinâmica
 Best fit
Minimizar tam_processo - tam_bloco o Deixar espaços livres os
menores possíveis
 Worst fit
Maximizar tam_processo - tam_bloco o Deixar espaços livres os
maiores possíveis
 First fit
tam_bloco > tam_processo
 Circular fit
Variação do first-fit
Algoritmo alocação particionada dinâmica
Desvantagem de partições variáveis
 Tende a criar lacunas de memória livres que

individualmente podem não ser suficientes para
acomodar um processo
 Pode haver memória livre, mas não contígua

Desvantagem de partições variáveis

Soluções possíveis para fragmentação externa
 Reunir espaços adjacentes de memória

 Empregar compactação
 Relocar as partições de forma a eliminar os espaços entre elas
e criando uma área contígua
o Desvantagem:
Consumo do processador Acesso a disco
Acionado somente quando ocorre fragmentação
 Necessidade de código relocável
Problemas com alocação particionada
o Necessidade de uma área contígua de memória

(tamanho do processo)
o Fragmentação interna (partições fixas) ou externa

(partições variáveis)
 Nova abordagem é considerar a existência
de um espaço de endereçamento lógico e de
um espaço de endereçamento físico
 O espaço de endereçamento físico não precisa ser
contíguo o Necessita “mapear” o espaço lógico no
espaço físico
Dois métodos básicos:

• Paginação
• Segmentação
Paginação de memória

• O Espaço de Endereçamento lógico de um processo pode ser

não contínuo; aloca-se memória física ao processo sempre
que esta é disponível.
• A memória física (sistema) e a memória lógica (processo)

são divididos em blocos de tamanho fixo e idênticos:
o Memória física dividida em blocos de tamanho fixo

denominados de frames
o Memória lógica divide em blocos de tamanho fixo denominados de

páginas
• Sistema mantém o registro de todos os frames livres.
• Para executar um processo do tamanho de n páginas,

basta encontrar n frames livres na memória
o Páginas são carregadas em qualquer frame livre
• Necessidade de traduzir endereços lógicos (páginas) em endereços

físicos (frames)
o Define-se uma tabela de página (page table) para traduzir

o endereço lógico em físico.
• Elimina a fragmentação externa e reduz a fragmentação interna

Características da paginação
• Paginação é um tipo de relocação (via

hardware)
• Não gera fragmentação externa
• Fragmentação interna é restrita apenas a última

página
• Importante:
o Visão do usuário: espaço de endereçamento contíguo
o Visão do sistema: processo é “esparramado” na memória física
• n páginas são alocadas a n frames implicando na criação

de uma tabela de correspondência
o Tabela de páginas
Facilita implementação de proteção e compartilhamento

Tamanho da página
Páginas grandes significam:
o Processos compostos por menos páginas (tabela de páginas

menores)
o Aumento da fragmentação interna na última página
Páginas pequenas significam:
o Processos compostos por mais páginas (tabela de página

maiores)
o Diminuição da fragmentação interna na última página.
• Objetivos conflitantes
Tamanho da página é imposto pelo

hardware (MMU)
Valores típicos variam entre 1 kbyte e 8

kbytes
Questões relacionadas com a gerência de páginas
• A gerência de memória deve manter controle de áreas livres e

ocupadas
Inclusão de mecanismos de proteção
 Evitar que um processo acesse área (páginas) de outros

processos
 Garantir que um processo acesse apenas endereços válidos
 Garantir acessos autorizados a uma posição de memória
e.g.: páginas read-only, read-write, etc.
Inclusão de mecanismos de compartilhamento

 Permitir que dois ou mais processos dividam uma área comum
e.g.: páginas de código de um aplicativo do tipo editor de texto
Proteção
• Proteção de acesso é garantida por definição:
 Processos acessam somente suas páginas (end. válidos)
 Endereço inválido apenas na última página (Se houver fragmentação

interna)
 Inclusão de bits de controle na tabela de página (por entrada).
 Indicação se a página é de leitura, escrita ou executável
 Proteção de memória é implementada associando-se um bit

de proteção a cada frame.
Bit Válido - Inválido anexado a cada entrada na tabela de página:
• “válido” indica que a página associada está no espaço de

endereçamento lógico do processo, assim, é a uma página legal.
• “inválido” indica que a página não está no espaço de

endereçamento lógico do processo.
Exemplo de proteção
Compartilhamento de páginas
Código compartilhado
o Uma cópia do código (read-only, re-entrante) pode ser

compartilhada entre vários processos (e.g.; editores de texto,
compiladores, etc...)
o O código compartilhado pertence ao espaço lógico de todos os

processos
Dados e código próprios
o Cada processo possui sua própria área de código e seus dados

Exemplo de compartilhamento:
Segmentação de memória
 Segmentação
 Técnica de gerência de memória, onde os programas são

divididos logicamente e em sub-rotinas e estruturas de
dados e colocados em blocos de informações na memória
 Segmentos – blocos de tamanhos diferentes com seu

próprio espaço de endereçamento.
 Respeita a visão do programador.

 Segmentação
 Segmentação X Paginação
 Paginação com partes de tamanho fixo e
segmentos com blocos de tamanhos variados
 permite uma relação entre a lógica do
programa e sua divisão na memória.
 Segmentação
 Cada entrada na tabela de segmentos possuí o endereço

do segmento na memória física, informações sobre o
tamanho do segmento, sua proteção e se ele está na
memória ou não.
 O Sistema Operacional mantém uma tabela com as áreas

livres e ocupadas da memória.
 Segmentação
 A escolha da área livre a ser ocupada por um processo a

ser carregado na memória pode ser a mesma utilizada no
item Alocação Particionada Dinâmica (best-fit, worst-fit ou
first-fit).
 Apenas os segmentos referenciados são transferidos para

a memória real.
 Os programas devem ser bem modularizados para uma
maior eficiência.
 Segmentação com Paginação
 Permite a divisão lógica dos programas e segmentos e,

cada segmento é dividido fisicamente em páginas.
 Um endereço é formado pelo número do segmento, pelo

número de página, contida nesse segmento, e pelo
deslocamento dentro dessa página.
 O endereço físico é obtido somando-se a posição inicial

do frame e o deslocamento.
Implementação da tabela de páginas
• Sistema operacional deve manter:
o Frames livres/alocados
o Número de frames e de páginas de um processo o Uma entrada para

cada frame e para cada processo
• Como implementar a tabela de páginas?
o Registradores e Memória
Implementação da tabela de páginas via registradores
Tabela de páginas é mantida por um conjunto de

registradores
o Cada página um registrador
o No descritor de processo devem ser mantidas cópias dos

registradores
Troca de contexto: atualização dos registradores
Desvantagem é o número de registradores

Implementação da tabela de páginas em memória
Tabela de páginas é mantida em memória
o Page-table Base Register (PTBR): início da tabela de páginas

o Page-table Length Register (PTLR): tamanho em número de
entradas.
Cada acesso necessita, no mínimo, dois acessos a memória

Cada acesso necessita, no mínimo, dois acessos a memória
Translation look-aside buffers (TLBs)
• Uma espécie de meio termo entre implementação via registradores e

via memória
• Baseada em uma memória cache especial (TLB) composta por

um banco de registradores (memória associativa)
• Idéia é manter a tabela de páginas em memória com uma

cópia parcial da tabela em um banco de registradores (TLB)
o Página acessada está na TLB (hit): similar a solução de

registradores
o Página acessada não está na TLB (miss): similar a solução via

memória
Implementação da tabela de páginas via TBL
Aspectos relacionados com o uso de TLB
• Melhora o desempenho no acesso a tabela de páginas o Tempo de

acesso 10 vezes menor que uma memória RAM
• Desvantagem é o seu custo
o Tamanho limitado (de 8 a 2048 entradas)
o Uma única TLB (pertence a MMU) que é compartilhada entre

todos processos
TBL - Um acesso é feito em duas partes:
o Se página está presente na TLB (hit) a tradução é feita
o Se página não está presente na TLB (miss), consulta a tabela

em memória e atualiza entrada na TLB
Tabelas multinível
 Cada processo tem associado ao seu espaço de endereçamento uma

tabela de páginas
 A tabela de páginas de cada processo tem que estar carregada em
memória
 Para minimizar o espaço em memória ocupado pelas tabelas de
páginas, utilizam-se habitualmente tabelas multí-nivel
 Guardam-se na memória uma tabela principal, e as tabelas dos
restantes níveis, que contém os descritores das páginas que estão a
ser utilizadas pelo processo
 Estas tabelas têm uma dimensão muito mais pequena do que se
fosse utilizado um esquema com um só nível
Tabelas multi-nível : exemplo
Page-faults:
 Quando é pedida uma página que não se encontra na memória

principal, ocorre uma page fault
 Uma page fault é uma exceção que causa bloqueio ao processo em
questão
 Inicia-se o de carregamento da página em falta, da memória
secundária para a memória principal
 Efetuam-se as alterações necessárias na page table, de modo a esta
continuar consistente
 Pode ser necessário transferir uma outra página para a memória
secundária, de modo a libertar-se uma page frame – nesse caso
corre-se o algoritmo de substituição de páginas
Algoritmos de substituição de páginas
O algoritmo ideal:
 Sempre que for necessária uma substituição de páginas, a que

deveria sair será aquela que só será utilizada daqui a mais tempo
 Este algoritmo não é realizável, pois os S.O.s não conseguem prever
o futuro...
 A aproximação é tentar descartar as páginas que são pouco
utilizadas, ou que já não são utilizadas há muito tempo, na esperança
de que não venham a ser utilizadas brevemente
Not recently used – NRU
Quando ocorre uma page fault, este algoritmo classifica as páginas

carregadas em memória. Para tal utiliza dois bits:
R (Referenced) – indica que a página foi acedida desde a última interrupção
do relógio
M (Modified) – indica que a página foi modificada desde que foi carregada
na memória principal
Estabelecem-se 4 classes diferentes, de acordo com R e M
Classe 0: R=0 e M=0
Classe 1: R=0 e M=1
Classe 2: R=1 e M=0
Classe 3: R=1 e M=1
A página a substituir será uma pertencente à classe mais baixa encontrada
FIFO (First-in, first-out)
 A página a substituir é a que se encontra carregada há mais tempo

na memória principal
 Algoritmo de fácil implementação, bastando ter uma lista com índices
de páginas, com a mais antiga no topo e a mais recente no fim
 À medida que as páginas vão sendo carregadas na memória, os seus
índices vão também sendo acrescentados ao fim da lista mantida
pelo algoritmo
Problema: a página que foi carregada há mais tempo pode estar a ser
utilizada...
Bit de referência
 A cada frame e associado um bit “R” com valor inicial 0.

 Quando uma página é referenciada o Bit “R” é alterado para 1.
 Ao fim de algum tempo todas as páginas tem bit “R” igual a 1. Neste
momento deve entrar em ação um algoritmo de “esquecimento” que
torna todos os bits 1 em 0.
 O frame escolhido para a substituição é aquele primeiro que ao ser
verificado tiver o bit “R” igual a 0.
Segunda chance
 Algoritmo baseado no FIFO, mas que utiliza o bit de referência (R)

 Antes de uma página ser descartada, analisa-se o bit R e, caso este
se encontre a “1”, então é posto a “0”, mas a página não é
descartada, analisando-se a próxima.
 A página a descartar será a primeira que for encontrada com R=0
LRU (Least recently used)
 A página a substituir será a que não é acedida à mais tempo

 Para tal, guarda-se para cada página uma marca temporal com o
tempo do último acesso
 Teoricamente este algoritmo é o que efetua a melhor escolha na
página a substituir
 Bom desempenho a um custo elevado:
 Na prática, este algoritmo obriga à existência de um temporizador
extra (pois as interrupções do relógio são demasiado “lentas”)
 Para além disso, exige bastante espaço para guardar as marcas
temporais (e.g. 64 bits) sempre que uma página é acedida
NFU (Not frequently used)
 Algoritmo que tenta efectuar uma aproximação ao algoritmo LRU

 Associado um contador a cada página carregada em memória,
inicializado a zero quando a página é carregada
 Sempre que ocorre uma interrupção do relógio, e para cada página,
soma-se o valor do bit R ao contador
Problema: uma página muito acedida no início, mas que depois deixe de
ser acedida fica com um valor elevado no contador, pelo que poderá
persistir na memória
Aging
 Variante do algoritmo NFU, que tenta resolver o problema descrito

anteriormente
 Em vez de somar o bit R ao valor do contador, desloca-se o seu
conteúdo para a direita com entrada série do bit R
 Deste modo consegue-se que uma página muito acedida no passado,
mas que já não está a ser utilizada, fique com o valor do contador a
zero após algumas interrupções do relógio
Algoritmo com melhor relação custo/desempenho

Thrashing
Um CPU atual executa cada instrução em menos de 1 nano-segundo
 Quando ocorre uma page fault, o carregamento de uma página para a

memória principal poderá demorar um tempo na ordem mili-segundos
 O carregamento de uma página é cerca de 1.000.000 de vezes mais
lento que a execução de uma instrução...
 Quando um grupo de processos começa a gerar page faults a um
ritmo muito elevado diz-se que se entrou numa fase de thrashing –
esta situação deve ser evitada a todo o custo
Working Set
 O Working Set é o conjunto de páginas que estão a ser utilizadas por

um processo
 Se todo o Working Set de um processo está carregado em memória,
então não ocorrem page faults
 Tirando partido deste facto, existem algoritmos de substituição de
páginas que funcionam tendo em conta o working set de um processo
 A ideia será substituir páginas que não se encontrem dentro do
working set de um processo
Política de carregamento de páginas
Paginação a pedido (Demand paging)
As páginas de um processo vão sendo carregadas à medida que

ocorrem page faults – esta abordagem faz com que ocorram page
faults inicialmente, até ser estabelecido o working set do processo
Paginação por antecipação (Prepaging)
Antes do processo correr, o SO carrega para a memória um conjunto de

páginas – a sua previsão do working Set
Gestão de memória
1
Memória Virtual – Segmentação
 Outro método de gestão de memória virtual é a

segmentação
 A segmentação providencia diferentes espaços de
endereçamento linear designados segmentos
 Um segmento é um conjunto de endereços lineares
desde 0 até um máximo
 Segmentos diferentes podem ter dimensões diferentes
 Um processo pode possuir diferentes segmentos
2
• Esquema de administração de memória que suporta a visão do
usuário da memória, leva em consideração a visão de programadores e
compiladores
Um programa é uma coleção de segmentos. Um segmento é uma

unidade lógica, tal como:
• programa principal
• procedimento / função
• método
• objeto
• variáveis locais, variáveis globais
• pilha
• tabela de símbolos, arrays
Um segmento pode ser uma únidade lógica. ex: procedimentos (funções),

bibliotecas
• Gerência de memória pode dar suporte diretamente ao conceito de

segmentos
3
4
5
 Com o tempo, o swapping e a libertação

de segmentos origina fragmentação...
S e g m e n to 4 S e g m e n to 4 S e g m e n to 4
(1 0 K ) (1 0 K ) (1 0 K )
(6 K ) (6 K ) (4 K )
(6 K ) (6 K ) (6 K )
S e g m e n to 1
Fragmentação
S e g m e n to 5 S e g m e n to 5
(8 K )
(6 K ) (6 K )
te m p o
6
 A gestão de memória segmentada é feita

com recurso a tabelas de descritores de
segmentos
S e le c to r D e s lo c a m e n to E n d e r e ç o v ir tu a l
T a b e la d e d e s c r ito r e s
0 D e s c rito r 0
1 D e s c rito r 1 Base
2 D e s c rito r 2
3 D e s c rito r 3
E n d e r e ç o F ís ic o
Estrutura de um descritor
P Base Limite Protecção Controlo
Bit de presença 7
 Vantagens:
 Fácil implementação de partilha de dados
 Divisão de um processo em segmentos diferentes
(e.g., código, heap, stack)
 Múltiplos espaços de endereçamento linear por
processo
 Desvantagens:
 Maior fragmentação da memória
 Impossibilidade de se definirem segmentos maiores
do que a memória física (a não ser que se utilize
também paginação ou overlays)
8
Memória Virtual – Misto
Segmentação com paginação.
 De forma a tirar partido da paginação e da

segmentação pode-se utilizar um esquema
misto
 A um esquema misto também se costuma dar o
nome segmentação com paginação
 Um esquema misto era utilizado no sistema
operativo Multics
 O processador Pentium também contém suporte
para este tipo de esquema.
9
O endereçamento é feito em duas etapas

 O endereço é traduzido em segmentos por
uma tabela de segmentos.
 Depois, cada entrada na tabela de
segmentos e traduzida em endereços físicos
por uma tabela de página.
Duas tabelas são envolvidas (segmentos e

páginas).
10
11
 Vantagem:
 Eliminaas desvantagens de um esquema
puro de segmentação, mas mantém as suas
vantagens
 Desvantagens:
 Maior complexidade das MMUs
 Mais acessos à memória para conversão de
endereços virtuais em físicos
12
Gestão de Memória – UNIX
 As primeiras versões do UNIX utilizavam gestão de

memória baseadas em partições variáveis e swapping
 Atualmente, praticamente todas as versões do UNIX
utilizam memória virtual paginada
 Processos responsáveis pela gestão de memória
 page daemon – gere as page tables e o core map, e
executa algoritmo de substituição de páginas
 swapper – efectua as transferências de páginas
entre a memória principal e secundária
13
 Espaço de endereçamento dos processos

 Dividido em 3 partes:
 Segmento de texto – contém o código do programa, e
nunca é alterado ao longo do tempo
 Segmento de dados – pode crescer através da reserva
dinâmica de memória
 Segmento do stack – cresce e decresce ao longo do
tempo, à medida que vão havendo chamadas a funções
NOTA: não é utilizada segmentação, por isso estes
segmentos correspondem a um conjunto de páginas
 Dois processos diferentes podem partilhar o mesmo segmento
de texto (se o programa executado for o mesmo)
14
 Espaço de endereçamento dos processos

M em ória
Processo A Processo B
Stack Stack
Espaço virtual Dados Dados Espaço virtual

do processo A do processo B
Texto Texto
frames
SO
15
 Core Map
 Estrutura com informações acerca das page frames
 Contém uma entrada por frame
 Tipicamente cada entrada do Core Map tem as seguintes
informações
 Índices do próximo frame livre e do anterior
 Nº de bloco em disco correspondente à página carregada
 Índice para a process table do processo ao qual pertence a

página carregada no frame
 Bit que indica se o framese encontra livre
 Bit que indica se está ocorrendo uma transferência de

página do frame para o disco (e vice-versa)
 Bit que indica se a página carregada deve permanecer
sempre na memória RAM
16
 Tantoo Core Map como o núcleo (kernel) do

sistema operativo permanecem sempre
carregados na memória principal
M e m ó r ia
P r in c ip a l
...
M o ld u ra 2
Sempre carregados
em memória principal M o ld u ra 1
M o ld u ra 0
C o re
M ap
K e rn e l d o S O
17
 Algoritmo de substituição de páginas

 Originalmente era utilizado o algoritmo do relógio sobre o core
map
 À medida que as memórias foram crescendo em dimensão,
verificou-se que este algoritmo perdia eficiência
 O algoritmo foi modificado de modo a ter dois ponteiros (Two-
handed clock)
 O sistema tenta sempre manter um conjunto de frames livres na
memória principal (tipicamente ¼ dos frames) – o page daemon
acorda quando não há frames livres suficientes
18
Gestão de Memória – Linux
 Esquema de paginação por demanda sem conceito de Working Set
 Algoritmo de substituição de páginas
 Processo kswapd (daemon) – acorda de 1 em 1 segundo para
ver se há suficientes frames livres
 O algoritmo de substituição procura diferentes tipos de páginas
a substituir:
 Páginas em cache – semelhante ao relógio
 Páginas partilhadas – descarta as que não estão a ser

utilizadas por nenhum utilizador
 Restantes páginas – analisadas por ordem crescente de
endereço virtual, com um funcionamento semelhante ao
algoritmo do relógio
 Processo bdflush (daemon) – efetua cópias de páginas
modificadas para o disco
19
Dispositivos de entrada e saída

Periféricos:
Um periférico pode ser visto como qualquer

dispositivo conectado a um computador
de forma a possibilitar sua interação com
o mundo externo.
Periféricos:
De acordo com o sentido do fluxo de

dados entre o computador e o dispositivo,
esses podem ser divididos em periféricos
de entrada, periféricos de saída, ou ainda
periféricos de entrada e saída.
Periféricos:
Os periféricos são conectados ao
computador através de um componente
de hardware denominado interface.
As interfaces constituem um elemento
chave para coordenação da transferência
de dados entre periférico e o processador,
ou entre periférico e memória.
Periféricos:
As interfaces empregam no seu projeto um

outro componente de hardware: o controlador.
Um controlador nada mais é que um
processador projetado especificamente para
realizar uma função, como, por exemplo,
controlar um disco rígido.
Periféricos:
Os dispositivos de I/O, dependendo de

sua interconexão física às interfaces,
podem ser do tipo serial ou paralelo.
Essa característica está relacionada à
maneira pela qual os dados são
transferidos entre os dispositivos de I/O e
as interfaces
Periféricos:
Uma interface serial é aquela que existem

apenas uma linha para os dados. Os
dados podem trafegar em dois sentidos,
mas em apenas um sentido por vez!
Periféricos:
Uma interface paralela possui várias

linhas para os dados, permitindo assim
que vários bits sejam transferidos
simultaneamente (em paralelo) entre os
dispositivos de I/O e a interface.
Periféricos:
Dispositivos de E/S são dispositivos de

hardware bastante variados:
 Orientados a caracteres ou a blocos
 Síncronos ou não
 Compartilhados ou não
 Velocidades diferentes
O Sistema Operacional deve gerenciar os
dispositivos de I/O e ainda abstrair o
acesso a todos esses periféricos de E/S
para o usuário final.
 Independência de dispositivos
São dispositivos lentos

O Sis. Op. deve ser eficiente ao usá-los.
Organização da gerência de I/O
 Cada driver encapsula as características do dispositivo de
Hardware.
 Conversa com o controlador do dispositivo;

 É a parte mais específica do Sis. Op.
 Acompanha o hardware quando da sua aquisição ou vem

nativamente no sistema operacional.
 Em geral existe uma versão de driver para cada sistema

operacional específico.
 Poder seguir um padrão (e.g. SCSI, USB...)

Tipos de drivers/dispositivos.
Orientados a blocos
 Acessa-se blocos de bytes de uma vez;

 Cada bloco deve ter um endereço;
Exemplos: disco, discos removíveis

Dispositivos orientados à rede
 O tempo de acesso à rede é ainda diferente do

tempo de uso de outros devices usuais.
 Por isso, costuma-se definir uma interface
específica para devices orientados a rede.
 A interface típica é o socket
 Pode-se criar um socket, abri-lo e fechá- lo;

 Quando aberto, pode-se:
 Se conectar no socket (connect);
 Ouvir no socket até alguma coisa chegar (listen);
 Escrever no socket (write)
 Pode-se ouvir vários sockets e selecionar (select) uma
ação apropriada ao socket de onde veio a informação.
Existem vários protocolos de rede suportados

pelos sockets:
 Fluxo confiável de bytes (pipe);
 Fluxo confiável de pacotes;
 Fluxo não confiável;
Outras formas de classificar:
 Compartilháveis ou não: possibilidade de ser acesso por vários

processos no mesmo tempo.
 Tela vs. Impressora.
 Seqüencial ou randômico
 Mouse vs. disco
 Acessível em leitura só, ou em escrita só, ou em escrita/leitura.
 Mapeado na memória / usa registradores

O subsistema de E/S
Basicamente, ele define interfaces padronizadas em cima dos

drivers, para serem usadas pelo núcleo.
Possibilita o acesso a vários dispositivos, independente de suas
peculiaridades.
Exemplos:
interface Ethernet para a rede:
 Define um endereço IP, um endereço de roteamento (gateway), um
prazo máximo de atendimento...
 Independente da placa de rede específica!
Interface do Mouse:
 Vai tratar eventos tais como ‘clic’ ou movimentação.
 Independente do tipo de mouse!
Funções típicas e genéricas da interface
 Buffer e Caches
 Tratamento de erros
 Escalonamento de dispositivo
 Compartilhamento e controle de acesso
(Semáforos!)
 Mais funções “backdoor”
Tratamento de erros
O Sistema Operacional deve identificar:
 O tipo de erro
 Transiente/permanente
 SW / HW
 Qual dispositivo é à origem do erro

 Deve retornar o identificador do erro para o usuário.
 Deve logar o erro.
Bufferização
Buffer não é cache!

Buffer = área de armazenamento temporário de dados.
Útil para:
 Ajustar tamanho de dados - Byte vs. Pacotes
 Ajustar velocidades entre dispositivos
 Possibilitar o assincronismo
Mas cache é um buffer orientado ao desempenho!

Bufferização
Problemas básicos:
 Manutenção da coerência entre o buffer e os dados
originais.
 tamanho do buffer;
 O que fazer quando estoura o buffer?
 Aumentar o buffer...
 Usar um outro buffer...
 Usar vários outros buffers
 Sistema de buffers circulares.
Organização de disco

Organização de discos
Introdução
Disco magnético talvez seja o mais importante dispositivo de E/S

 Gerência de memória (área de swap)
 Sistema de arquivos (arquivos + diretórios)
Prós e contras:
 Meio barato de armazenamento permanente
 Se comparado com processador e memória apresenta uma
velocidade de acesso muito lenta
Necessidade:
 Otimizar o desempenho do disco visando aumentar a sua largura
de banda, tempo de resposta e variância
 ex: Bufferização, caches, configurações RAID
Disco Magnético:
Acesso aos dados:
Menor unidade de transferência é um bloco lógico (n setores)
Acessar dado implica em localizar trilha, superfície e setor

Dois métodos:
Método CHS (Cylinder, Head, Sector)

Método LBA (Linear Block Addressage)
Tradução do L-CHS (Logical) para P-CHS (Physical)
Discos modernos endereçam blocos lógicos sequencialmente

Conversão de um bloco lógico para sua localização física
Não é um mapeamento direto por haver setores fisicamente
defeituosos e pelo número de setores por trilha não ser
constante
Fatores de desempenho do disco
 Largura de banda (MB/sec)

 Para ler/escrever dados é necessário que o cabeçote de
leitura/escrita esteja posicionado na trilha e no ínício do setor
desejados
Três tempos envolvidos:
 Tempo de busca (seek time)

Tempo necessário para posicionar o cabeçote na trilha desejada
 Tempo de latência rotacional
Tempo necessário para atingir o início do setor a ser lido/escrito
 Tempo de transferência
Tempo para escrita/leitura efetiva dos dados
Tempo de acesso ao disco:
Tempo de busca (seek)
Influenciado pelo tempo de acionamento, aceleração e deslocamento do

cabeçote até a trilha desejada
Não é linear em função do número do trilhas

Tempo de identificação da trilha (confirmação)
Na realidade existem três tempos de seek
 seek time: tempo de deslocamento até uma determinada trilha

 head switch time: tempo para acionar o cabeçote de leitura/escrita
 cylinder time: tempo de deslocamento da trilha i para a trilha i+1
Tempo médio de seek

Dado fornecido pelo fabricante - 5 a 10 ms (tecnologia anos 2000)
Tempo de latência rotacional
Definido pela velocidade de rotação do motor
e.x.:
discos rígidos (5400 rpm a 10000 rpm);
unidades de floppy (300 rpm a 600 rpm)
Considera-se o tempo médio
Não se sabe a posição relativa do cabeçote com a do setor a ser lido

Metade do tempo de uma rotação
e.x.; 3 ms para um disco de 10000 rpm (6 ms uma rotação )
Tempo de transferência de dados de/para disco depende da velocidade
de rotação
Desempenho de acesso a dados no disco
Depende de três fatores:

 Tempo de seek
 Latência rotacional
Blocos a serem acessados sequencialmente devem estar próximos
Problema da alocação de dados no disco (estudaremos mais adiante)
Objetivo é minimizar a distância a ser percorrida pelo cabeçote de leitura

e escrita do disco
Escalonamento do disco
Problema:
Requisições provêem de diferentes processos e são geradas mais
rapidamente do que são atendidas
→ fila de requisições
Atendimento pode “quebrar” a ordem de acesso a um arquivo mesmo

com um bom mapeamento físico
Solução: reordenar as requisições para otimizar o tempo de busca (seek)

e latência rotacional
Objetivos:
Aumentar a taxa de transferência (rendimento)
Reduzir o tempo médio de resposta
Ser justo no atender a requisições dos processos (variância)
Políticas de escalonamento do disco
Otimização de busca
FIFO ou FCFS
SSTF (Shortest Seek Time First)
Scan (elevador) e suas variações
Otimização rotacional
SLTF (Shortest Latency Time First)

SPTF (Shortest Positioning Time First)
FCFS - First Come First Served
Acessa na ordem em que as requisições são solicitadas
Prós:
 Simples de executar
 Justo: requisições são atendidas na ordem
Contras:
 Padrão de busca aleatório (movimentação mecânica)

 Comportamento ruim sob carga altas (fila de requisição grande)
SSTF - Shortest Seek Time First
Seleciona a requisição com o menor tempo de seek em relação a

posição atual do cabeçote de leitura/escrita
Prós:
 Redução do tempo de busca (maior rendimento)
 Tempo médio tende a ser mais baixo
Contra:
 Não garante justiça (”fura” a fila )
 Postergação indefinida (starvation)
 Variância alta (ruim para sistema interativos, aceitável para sistemas
batch)
SCAN (algoritmo do elevador)
 Atende requisições em uma direção preferencial

 Muda de direção ao atingir os cilindros mais interno ou mais externo
 Definição da direção preferencial (fixa ou em base na fila → critério
SSTF)
Prós
 Oferece bons tempos médios de resposta
 Bom rendimento
 Variância menor que o SSTF
Contra
 Não justo
 Trilhas das extremidades são “visitadas” menos frequentemente que
as trilhas internas
SCAN (algoritmo do elevador)
C-SCAN (1)
Variação do algoritmo de SCAN
 Procedimento é idêntico ao do algoritmo SCAN porém as requisições

são atendidas apenas em um sentido da varredura
 Compensar o fato que, se a leitura ocorresse nos dois sentidos da
varredura, os setores próximo ao centro seriam acessados em um
tempo médio menor
 Ao final da varredura o cabeçote é reposicionado no início do disco
 Fornece uma visão lógica onde o disco é tratado como uma fila
circular
 Oferece um tempo médio de acesso mais uniforme que o algoritmo
SCAN
C-SCAN (1)
Otimização rotacional: estratégias combinadas
Discos mais novos o tempo de seek está na ordem de grandeza da

latência rotacional
SLTF – Shortest Latency Time First
Reordena o atendimento de requisições de um mesmo cilindro em

função do atraso rotacional mais curto.
SPTF – Shortest Positioning Time First
Reordena requisições considerando a soma do tempo de seek com a

latência
Otimização rotacional: estratégias combinadas
Variação: Shortest Access Time First (SATF)

Reordena as requisições considerando a soma do tempo de
seek e de transferência
Sistemas de arquivos

Lembrando…
O disco rígido é organizado em cilindros, trilhas, e setores.
Para acessar dados, distingue-se 3 tempos caraterísticos:

 Tempo de busca (seek)
Procura da trilha certa
 Tempo de latência rotacional
Espera a giração do disco
Leitura do(s) setor(es)
T(b bytes) = Tseek + 1/(2r) + b / (rN)

Onde : B bytes, r rotações por segundo, N bytes por trilha.
Escalonamento de disco
É preciso levar em consideração essa organização para escalonar as

requisições.
Otimiza busca e/ou latência rotacional

Políticas FIFO, SSTF, Scan (elevador)
 SSTF: menor tempo de seek em relação à posição corrente

do cabeçote. Postergação infinita
 Elevador: muito bom, porém injusto.
 Melhor: o C-SCAN
Escalonamento de disco
Políticas de otimização da latência rotacional:
 Shortest Latency Time First

 Shortest Positionning Time First
 Seek + latência.
Definição do sistema de arquivos
É a parte do Sis. Op. que organiza de forma lógica os dados

armazenados no disco.
Organização típica:
 Arquivos
Unidade básica de dados enxergada pelo usuário
 Diretórios
Sistema de classificação dos arquivos.
Funções básicas
 Visão lógica (abstrata) do disco

 Uso eficiente dos discos
Escalonamento das requisições
 Possibilidades de organização dos dados
Compartilhamento
Procura/classificação
nomeação
Do ponto de vista do Sis. Op.:
 Descrição do arquivos
 Gerenciamento do espaço físico
Gerenciar blocos livres/ocupados
Funções básicas
Do ponto de vista do usuário:
 Nomear um arquivo
 Criar, apagar, mover, ler, escrever arquivos
 Controlar seus direitos de acesso
 Organizar seus arquivos
 Efetuar backups
Organização de arquivos
Gerência de dispositivos
Função básica: alocar/liberar “blocos”.
Blocos são mapeados em setores

Conforme for preciso, é preciso:
 Obter mais blocos (quando um arquivo está sendo
criado/acrescentado)
 Liberar blocos (quando um arquivo está sendo destruído)
Problemas a resolver:
 Fragmentação
 Desempenho
 Bom uso do disco.
Núcleo básico
Gerenciamento dos arquivos abertos.
 Armazena os descritores de arquivos em estruturas de dados

(tabelas).
Cada processo tem uma tabela de arquivos abertos;
Mais indicações sobre o tipo de operações (Escrita, leitura...)
 Os descritores são associados a um identificador (ponteiro) para

poupar acessos à estrutura.
FILE* meu_arquivo
meu_arquivo = fopen(“arquivo.txt”,”r”);
Gerência de diretórios
 Basicamente, sua função é “achar” o arquivo:
 A partir de um ponto de entrada (raiz), vai identificar um caminho até o

arquivo;
 Associa ao nome do arquivo um identificador (cf. FILE*)
 Abre o arquivo para o usuário.

Interface com o usuário
Chamadas de sistema:
 Manipulação de arquivos: open, close, read, write...

 Manipulação de diretórios: cd, mkdir, ls
O Sis. Op. efetua o vínculo entre nome simbólico e lugar de

armazenamento no disco.
Em nível do usuário, o arquivo é caracterizado:

 Por um nome (com ou sem extensão)
 Por atributos
 Por uma organização lógica
Atributos de um arquivo
Informações de accounting:
 Data de criação,
 Tamanho,
 Dono
 Grupo
 ...
Informações de segurança
 Direitos de acesso R, w, x
Tipo:
 Arquivo, diretório, link
Tipos de arquivo
 Um sistema operacional suporta vários tipos de arquivos.
 O tipo condiciona as operações que podem ser efetuadas com o

arquivo
 Executá-lo ; lê-lo ; escrever alguma coisa nele...
 Exemplos:
 Executável (binário)
 Arquivo de dispositivo (device) no Linux
 Diretório
 Um arquivo de um dado tipo pode ter seu acesso restrito:

 Leitura só/escrita só/...
Organização de arquivos: registros
 O arquivo é organizado em registros
 Registro = menor unidade de dados acessível.
 Os registros podem ter tamanho fixo ou adaptável

 Caso adaptável, cada registro deve ter seu tamanho informado.
 A medida que o arquivo tem seu tamanho alterado, o número de

registros deve evoluir
 Lista encadeada de registros.
 Arquivos seqüenciais e randômicos
 Arquivos em acesso seqüencial

 Implementação fácil com todos os tipos
 Arquivos randômicos
 Fácil quando se usam registros de tamanho fixo
 Vide acessos em uma tabela (vetor)
 Quando se usam registros de tamanho variável, complica!

 É preciso de um “índice”
 Dificilmente suportado pelo Sis. Op.
Prática de laboratório
 Acesse seu sistema linux atráves da máquina virtual.

 Veja como o sistema classifica o arquivo quanto ao seus donos.
 Veja como o sistema classifica os arquivos quanto ao
permissionamento
 Altere o permissionamento de arquivos.
Comandos: ls, chown ,chmod

Implementação de arquivos

Lembrando…
 Os dados no disco são organizados em arquivos e

diretórios
 Facilidades de accounting, de organização, de procura...
 O Sistema Operacional mantém, para cada processo,

uma tabela de arquivos abertos (TDAA).
 Ponteiros para descritores de arquivos.
 Disponibiliza ao usuário chamadas de sistema para

escrever/ler o arquivo
 Read, write, ...
Alocação de arquivo:
 Problema principal: saber quais blocos do disco

estão sendo usados por um dado arquivo.
É preciso de mecanismos de armazenamento dos
blocos.
 Também é preciso manter as informações de

cada arquivo de uma forma consistente no
sistema todo.
 Organização do sistema de arquivos.
Alocação contínua.
 Um arquivo que usa K blocos vai ser implementado com K blocos

contíguos no disco.
 Vantagens: simplicidade e desempenho.
 Basta armazenar o tamanho do arquivo e um ponteiro sobre o 1o

bloco.
 Simples de carregar de uma vez vários blocos do arquivo.
 Problemas:
 Fragmentação externa;
 Necessidade de conhecer o tamanho (máximo) do arquivo.
Alocação encadeada
 Os blocos formam uma lista encadeada.

 Sem fragmentação externa;
 Basta armazenar um ponteiro sobre o 1o bloco;
 O tamanho do arquivo pode crescer a vontade.
 Problema: acesso randômico complicado!
 E o ponteiro ocupa espaço no bloco.
Alocação encadeada
Lista com índice
Pode-se usar um índice: uma tabela de endereços, que ficará na

memória.
 Vantagens:
 Sem perda de espaço (não tem ponteiros);
 Busca rápida, pois tudo está na memória (acesso randômico simples!).
 Desvantagem:
 Toda a tabela deve caber na memória...
 Exemplo: 500 MBytes, bloco de 1 KB

500.000 entradas de 4 bytes, 2 MBytes de tabela!
Lista com índice
 É este esquema que foi usado em MS-DOS.

 Chamado FAT (File Allocation Table).
 Cada entrada na FAT aponta para a próxima entrada.
 FAT-xxx usa xxx bits para endereçar os blocos
 FAT-12, FAT-16
 FAT-32 a partir de Windows-95+
 Tamanho proporcional à capacidade do disco.
 Para aliviar a memória, os blocos podem ser
aumentados (e.g. 32 KB) em discos grandes.
O sistema de arquivos FAT
• Setor de boot: o setor que contém a primeira imagem a ser

carregada ao boot.
• FAT (1) e FAT (2): tabela de alocação dos arquivos, espelhada.
(obs: a estrutura de diretório contem os ponteiros para os blocos
iniciais dos arquivos)
• Diretório raiz : ponto de entrada
• Resto: espaço para outros diretórios e arquivos
Sistema de arquivos NTFS (Windows 2000+)
Objetivos principais:
 Confiabilidade e tolerância a falhas.
 Garante a manutenção dos metadados.
 logging
 Eficiência
 Links, compressão, arquivos esparsos...
 Organiza os discos em volumes (partição lógica);
 O cluster (bloco) varia ao formatar o volume
 de 1 até 2n setores do disco
 512 Bytes, ... Alguns Kbytes.
NTFS, MFT e metadados
MFT = Master File Table

 É um arquivo especial
 Tabela de registros de 1 KB
 Um registro por arquivo no volume
 Incluí também registro para o arquivo que implementa a própria
MFT.
Além da MFT, NTFS define uma série de arquivos de metadados.

Exemplo: meta-arquivo de log.
O primeiro registro da MFT contém o setor de boot, usado para

carregar o sistema de arquivos na memória.
Espelhado no meio da MFT, caso haja um problema.
Registros de metadados:
 Diretório raiz (\)
 Este registro contém a lista dos arquivos / diretórios encontrados
na raiz;
 Alocação dos blocos do volume
 Bitmap
 Blocos danificados
Registro de arquivo:
 Seqüência de pares (nome atributo, valor)
 Alguns atributos: nome arquivo, informações de acesso, dados...)
 Registro residente: para pequenos arquivos, todos os atributos
cabem no registro da MFT (1 KB)
 Registro extendido: blocos fora da MFT são usados para armazenar
parte dos “grandes” atributos (e.g. dados).
I-node
Solução para diminuir o tamanho da tabela: passar a usar uma tabela

multi-nível.
 O i-node é a solução empregada no Unix/Linux.
 I-node = Index Node
O i-node aponta para:

 atributos
 Blocos (usados para pequenos arquivos) – por exemplo, 10.
 Tabelas de blocos (indireção simples)
 Tabelas de tabelas de blocos
 Tabelas de .... De tabelas de blocos (indireção tríplice)
Muito eficiente para pequenos arquivos, flexível para grandes

arquivos.
I-node
Quantos blocos são acessíveis por um i-node?
 10 blocos diretamente acessados no i-nodo;

 11a entrada aponta para um bloco que contém endereços de
blocos
 Se um bloco contiver 1 KB e
 se um endereço de bloco usar 4 Bytes,
 então são 256 blocos acessíveis através de um bloco.
 12a entrada aponta para um bloco de bloco:

 São 256 x 256 (65536) blocos acessíveis pela 12a entrada.
 13a entrada:
 São 256x256x256 blocos acessíveis pela 13a entrada (16 Milhões).
Atributos do I-node
O i-node inclui vários atributos:
 Tipo de arquivo
 Diretório, link, E/S, ...
 Direitos de acesso
 Leitura, escrita, execução
 Tamanho do arquivo em bytes
 Não em blocos!
 Hora de acesso / criação
Arquitetura do sistema de arquivos Unix-like
Existe um superblock que mantém os metadados.

 Lido ao carregar o sistema de arquivos
 Guardado na memória
 Contém basicamente o tamanho das estruturas de dados.
Conteúdo:
 Tamanho (em blocos) do sistema de arquivos

 Tamanho (em blocos) da lista de i-nodos
 Número de blocos disponíveis e de i-nodos.
 Lista de blocos e i-nodos disponíveis.
Mantém listas parciais na RAM, para não sobrecarregar o superbloco.

Arquitetura do sistema de arquivos Unix-like
Implementação de diretórios

Lembrando: implementação de arquivos & sistemas de
arquivos…
 Arquivos são constituídos de seqüências de blocos

 Bloco mapeado em setores físicos do disco;
 Alocação contígua de blocos
 Fragmentação vs. Bom desempenho
 Uso de listas
 Listas com índice
 FAT
 Inode (Unix/Linux)
Sistemas de arquivos incluem
 meta-dados
 Setor de boot
 Endereço do diretório raiz
 Cópia espelhada da FAT (no caso do DOS/NTFS).
Diretório & Arquivos
 O arquivo é a unidade básica de dados (do ponto de

vista do usuário)
 O diretório é a unidade básica para organizar os
arquivos.
 Em geral, implementado como sendo um arquivo
“especial”.
 Chamado “pasta” em alguns sistemas...
 O diretório deve associar, para cada arquivo/diretório
nele contido:
 Um nome definido pelo usuário;
 Informações de accounting;
 Um ponteiro sobre o arquivo.
Operações com diretórios
Criação
 Deve-se acrescentar uma entrada na estrutura de dados “diretório” para
incluir o novo diretório/arquivo.
 Possivelmente, deve-se re-organizar as entradas.
Remoção
 Deve-se tirar uma entrada;
 Obs: problema potencial ao remover um diretório inteiro! Fazer o que se não
está vazio?
 Possivelmente, deve-se re-organizar as entradas.
Acesso/listagem
 Deve retornar a lista das entradas;
 Para tanto, precisa ser “aberto”.
Diretório de um nível
 Todos os arquivo estão em um diretório só, no sistema

todo.
 Ausência total de controle de acesso...
 Por exemplo, arquivos executáveis e/ou de sistema estão
misturado com os dados dos usuários.
 Falta de eficiência para procurar os arquivos.
 Conflito entre os nomes dos arquivos
 Todos os usuários devem evitar usar nomes parecidos!
 Usado em sistemas de arquivos básicos & antigos
 Floppies.
Diretório de 2 níveis
 Um primeiro nível distingue (por exemplo) contas de

usuários;
 Serve também para isolar diretórios do sistema.
 Cada usuário tem todos seus arquivos em um único
diretório, pessoal.
 Pode-se compartilhar arquivos
 É preciso prefixar o nome do arquivo pelo diretório onde se
encontra.
 Pode-se compartilhar um diretório inteiro
 Bin/ com os executáveis do sistema.
Árvore de diretórios
Generalização do mecanismo com dois níveis.
Caminho (path)
 O caminho é a seqüência de diretórios a serem percorridos até

chegar a um arquivo.
 Caminho absoluto: a partir da raiz

 Começa com ‘/’ (ou ‘\’ em MS-DOS/Windows)
 /home/usuario/bin/gcc
 Caminho relativo:
 Diretório corrente (‘.’) = diretório onde o usuário está trabalhando
quando dispara o processo.
 O caminho relativo começa a partir do diretório corrente
 bin/gcc
 ../bea/bin/gcc
Caminho (path)
 Os diretórios ‘.’ e ‘..’ designam o diretório corrente e pai.
 Existe uma variável de ambiente PATH que indica os

caminhos default onde procurar um arquivo executável.
 Um processo mantém uma variável para seu diretório

corrente
diretórios & Links (atalhos)
O link (atalho) possibilita o compartilhamento de um

arquivo e/ou diretório.
 Não há cópia física dos dados!

 Possibilita a manutenção simples da coerência
 Problema: pode criar laços!! (looping)
 Problema para a procura.
 Problema potencial na hora de deletar arquivos.
diretórios & Links (atalhos)
Soft link:
 Implementado através de um ponteiro sobre uma entrada física
 Possibilita detectar ciclos, por isso lícito com diretórios (looping)
Hard link
 Implementado através de uma cópia física de uma entrada.

 Impossibilita deteção de ciclos, proibido com diretórios. (llooping)
Implementação de diretório
 O diretório provê o acesso aos arquivos e outros

diretórios nele contidos.
 Deve mapear o nome simbólico com a estrutura de dados que
implementa o arquivo
 Arquivo todo, endereço do 1o bloco, inode...
 Também pode haver mapeamento para um outro diretório.
 O diretório será implementado como uma seqüência de
entradas, cada qual descrevendo um dos
diretórios/arquivos nele contido.
 Várias soluções para implementar a seqüência
Possibilidades de implementação
Lista linear de entradas
Pesquisa linear...
 Cada inserção necessita uma procura para evitar nomes repetidos!
 Simples
 Uma forma de otimizar ordenar a lista
 Sobrecusto à inserção
Tabela de Hash
 Lista linear + índice
 Deve-se gerenciar as colisões!
Exemplo de implementação de entrada
Implementa poucas informações
Exemplo simples:
 Nome + tipo (extensão): foo.txt

 Identificador do usuário dono do diretório
 diretório/arquivo
Exemplo de implementação de entrada
Exemplo simples: CP/M (1986)

 Um diretório único
 Endereços dos Blocos dos arquivos armazenados também na
estrutura do diretório
 Uma entrada do diretório é da forma seguinte (32 Bytes):
Implementação no MS-DOS
 Árvore de diretórios!
 Cada entrada tem comprimento 32 Bytes
 Nome, extensão...
 Ponteiro para o primeiro bloco na FAT.
 Os outros blocos do arquivo se encontram graças à
FAT.
 Se o bloco apontado na FAT contiver a mesma
estrutura, aninham-se os diretórios. A tabela fica
distribuída no disco e não em um mesmo local.
Implementação no MS-DOS
Implementação no Unix
Muito simples, devido ao uso de inodes.

 As informações sobre o arquivo/diretório estão armazenadas no
inode (atributos):
 Nome, extensão, data/hora de criação...
Procura por um arquivo
 Procura-se o arquivo /alguma/coisa/foo.txt

 Localiza a raiz / (vide entrada no sistema de arquivos!)
 É um diretório (inode, por exemplo).
 Vai ser consultado para achar o que tem dentro.
 Procura-se o diretório ‘alguma’
 Vai achar o inode correspondendo
 Vai carregar o 1o bloco do disco, que implementa o diretório.
 É um diretório... Se repete o procedimento
 Acha o inode associado a ‘coisa’
 Carrega-o do disco
 Afinal, chega-se a procurar ‘foo.txt’
 Obtém-se o inode apropriado... E os blocos de dados.
Gerenciamento de espaço livre em disco

Gerenciamento de espaço livre
Lembrando: diretórios
 Estrutura de dados para organizar os arquivos
 Criação, remoção, listagem, link.
 Árvore / DAG / Grafo (ciclos!)
 Implementados como arquivos especiais que
contém uma seqüência de entradas
 Tabela de entradas
 Lista seqüencial, tabela de Hash, Árvore B...
 Cada entrada descreve um arquivo/diretório contido

no diretório
 Exemplos: MS-DOS, NTFS, inode/Unix
Qual espaço livre gerenciar?
 O disco é organizado em setores;

 O arquivo é organizado em registros (NTFS)...
 O registro contém (endereços de) blocos.
 Há uma tradução registros / blocos
 Blocos são um múltiplo de setores
 Escolha nem sempre fácil!
 Um bloco pode ter um tamanho fixo ou variável.
 Gerenciamento de espaço livre envolve 2 problemas:
 Decidir do tamanho de um bloco;
 Administrar/recuperar os blocos livres/ocupados no disco.
Influência do tamanho do bloco
 No mínimo, 1 bloco = 1 setor

 Se for menor, perde-se (muito) tempo ao ler os dados
no disco.
 No máximo 1 cilindro
 Desperdiço de espaço!
 Cf. [Mullender & Tannenbaum, 1984]: tamanho médio
de arquivos no Unix é 1 KB.
 Entre os dois:
 deve-seescolher um tamanho que não perca muito
tempo em seek/atraso rotacional, nem muito espaço.
Quanto maior o bloco maior a taxa de
transferência.
 Seja um HD com 32 KBytes/trilha, 16,67 msec
de tempo de rotação
 Seek médio de 30 msec.
 Tempo de transferência de um bloco de k Bytes
(msec) será:
T(k) = 30 + 8,33 + (k / 32768)*16,67
 Taxa de transferência = k / T(k)

Tamanho do bloco x taxa de transferência

Tamanho do bloco x taxa de uso de HD
 E a taxa de uso do HD?

 Supondo que só se tenha arquivos de 1 KB:
 Com blocos k < 1 KB, usa-se 100% dos blocos;
 Com blocos k > 1 KB, usa-se 1 KB / k Bytes,
 (1000/k)*100 % dos blocos. k = 1 KB => 100%
de uso ;
 k = 8 KB => 1/8 = 12 %
Tamanho do bloco x taxa de uso de HD

Tamanho dos blocos:
 Altamente dependendo:
 Das características do HD
 Da distribuição do tamanho dos arquivos...
 Por exemplo:
 o surgimento dos vídeos / arquivos de som alterou recentemente

o tamanho médio dos arquivos em um HD!
 O tamanho do bloco deve acompanhar desenvolvimento dos HD

e dos Sis. Operacional.
Tamanho dos blocos:

Tamanho dos blocos:

Tamanho dos blocos:

Vetor de bits (bitmap)
 Cada bloco é representado por um bit 1 se estiver livre,

0 se estiver usado.
 Implementação eficiente
 Instrução de HW específica para retornar o 1o bit valendo 1.
 Problema:utiliza tantos bits como blocos

 Bitmap armazenado na RAM!
 HD de 80 GB, blocos de 1 KB => 80 Mbits = 10 MBytes...
 Obs: com partições/clusters, reduz-se o bitmap.
Alocação agrupada com bitmap (ext2fs)
 Dois problemas com a escolha do 1o bit livre:
 Achar rapidamente um bit 1
 Procura byte por byte!
 Há fragmentação com essa solução.
 Solução:
 Procura-se um byte livre;
 Vai-se para trás até o último bit ocupado.
 Pre-alocação dos 8 blocos pela frente

Interesse deste esquema
 A procura Byte por Byte é rápida.

 Mais do que se fosse bit por bit.
 A procura para trás minimiza a fragmentação
 A pre-alocação reduz a fragmentação quando se
escreve em vários arquivos intercalados
 Agiliza a alocação dos blocos.
 Blocos pré-alocados que não forem usados são
devolvidos quando se fecha o arquivo.
Lista encadeada
 Mantém-se um ponteiro (endereço) do bloco

inicial na lista de endereços de blocos
disponíveis;
 Os blocos são encadeados numa lista
 Cada elemento da lista é um bloco
 Obs: mantém numa cache parte da lista
 E.g. o 1o bloco, frequentemente suficiente.
Lista encadeada
Exemplo: ext2fs
 Sistema de arquivos “clássico” do Linux
 Inspirado pelo UNIX BSD (FFS)
 Decompõe uma partição ext2fs em grupos
 Dessa forma, agrupa blocos.
Descrição dos grupos no ext2fs
Super-bloco:
 Contém dados relevantes a toda a partição (duplicado
 em cada grupo)
 Número mágico da partição,
 número de mounts,
 tamanho do bloco,
 tamanho do grupo (m),
 ponteiro para o 1o inode do sistema de arquivos (/),
 Número de inodes, de inodes livres, de blocos livres...
Descritor do grupo:
 1 entrada por grupo
 Cada entrada fornece:
 o endereço do bloco onde está o bitmap dos
blocos livres;
 o endereço do bloco onde está o 1o inode na
tabela.
 o endereço do bloco do bitmap dos inodes
 o endereço do bloco do bitmap dos blocos
 O ext2fs usa bitmaps para gerenciar os blocos e

inodes livres;
 Cópias parciais através de caches!
 A tabela de inodes contém os endereços das
cópias na memória dos inodes disponíveis
(livres ou ocupados) no grupo;
O bitmap indica quais usar num dado momento.
 Por fim, a tabela dos blocos aponta para os
blocos disponíveis.
Sistemas distribuídos

Há diversas definições para o que é um sistema
distribuído. Para o nosso contexto, a definição dada por
Tanenbaum é satisfatória:
“UM SISTEMA DISTRIBUÍDO É UMA

COLEÇÃO DE COMPUTADORES
INDEPENDENTES, QUE APARECEM PARA O
USUÁRIO DO SISTEMA COMO UM ÚNICO
COMPUTADOR”.
Sistemas Distribuídos – Definição mais ampla.
“UM SISTEMA DISTRIBUÍDO É AQUELE NO QUAL OS

COMPONENTES DE HARDWARE OU SOFTWARE,
LOCALIZADOS EM COMPUTADORES
INTERLIGADOS EM REDE, COMUNICAM-SE E
COORDENAM SUAS AÇÕES APENAS TROCANDO
MENSAGENS”
Esta nova definição permite que sejam mais
claramente percebidas as seguintes
conseqüências importantes:
 Concorrência
 Inexistência de relógio global.
 Falhas independentes.
Exemplo de sistema distribuído:
A Internet:
A Internet é um conjunto de redes de computadores, de muitos

tipos diferentes, interligadas.
Os programas interagem enviando mensagens através de um
meio de comunicação comum.
Os protocolos Internet permitem que um programa em
execução em qualquer lugar envie mensagens para programas
em qualquer outro lugar .
A Internet é um sistema distribuído muito grande , e permite

que os usuários, onde quer que estejam, façam uso de serviços
como a World Wide Web, e-mail, e transferência de arquivos.
Muitos acreditam que a web é a internet.
A Internet:
Intranets:
Uma Intranet é uma parte da Internet administrada separadamente ,

cujo limite pode ser configurado para impor planos de
segurança locais.
A configuração de uma intranet em particular pod e variar muito ,

desde uma LAN até um conjunto de LANs.
A conexão com a internet é feita por intermédio de um

roteador.
Intranets:
Computação móvel o ubíqua:
Com a miniaturização dos dispositivos, e as redes sem fio,

equipamentos de computação pequenos e portátei estão
sendo integrados com sistemas distribuídos
Dentre esses equipamentos, podem-se citar :
 Notebooks .
 Aparelhos portáteis , como PDA´s , telefones móvei s , pagers
câmeras de vídeo e digitais .
 Aparelhos acoplados ao corpo, como relógios de pulso
inteligentes, com funcionalidades semelhante à de um PDA .
 Dispositivos incorporados em aparelhos, como máquinas de
lavar, aparelho s de som , carros , etc...
 A computação móvel (ou nômade ) é a execução de

tarefas computacionais enquanto o usuário está se
deslocando de um lugar a outro , ou visitando
lugares diferentes de seu ambiente usual .
 A computação ubíqua (ou pervasiva) é a utilização
d e vários dispositivos computacionais pequenos e
baratos ,que estão presentes nos ambientes físicos
dos usuários ,incluindo suas casas , escritórios e até
na rua .
Exemplo de sistemas distribuido: Cluster
Exemplo de sistema distribuído
Cluster é um conjunto de máquinas (no caso de

cluster Linux, especificamente, PC's) interligadas via
rede que trabalham em conjunto trocando informações
entre si.
Sistemas operacionais realmente distribuídos.
Sistemas que se utilizam de mais de uma

plataforma de hardware, distribuindo a carga de
processamento, memória e serviços de i/O.
Sistemas distribuídos devem ser capazes de
prover as mesmas classes de serviços que
sistemas usuais.
Classes comuns de serviços providos pelo sistema
operacional (distribuído ou não)
 Execução de programas
 Operações de entrada/saída (I/O)
 Manipulação do sistema de arquivos.
 Comunicação entre processos.
 Detecção de erros.
 Alocação de recursos.
 Registro (accounting)
 Proteção.
Vantagens de Sistemas Distribuídos em relação a Sistemas
Centralizados:
 Preço: Hardware de baixo valor agregados.

 Velocidade: é possível construir sistemas com valor agregado
muito maior
 Distribuição física: algumas aplicações são essencialmente
distribuídas (e.g., correio eletrônico)
 Confiabilidade: se uma máquina quebra, outras podem
guardar backup
 Disponibilidade: se uma máquina sai do ar, pode-se usar
outra
 Crescimento incremental: podemos acrescentar (ou retirar)
recursos aos poucos
Desvantagens de Sistemas Distribuídos em
relação a Sistemas Centralizados:
 Software: ainda não está tão maduro quanto

o software para sistemas centralizados
 Rede: ela pode cair, pode ficar saturada,
congestionar
 Segurança: roubo de dados, ataques de
negação de serviço
Questões de projeto:
Desempenho
 Normalmente é sinônimo de velocidade

 tempo de resposta
 velocidade de processamento (throughput)
 utilização dos processadores
 parcela da rede utilizada
Transparência
 de localização : os usuários não sabem onde está o

recurso.
 de migração : os recursos podem se movimentar.
 de replicação : os usuários não sabem quantas
copias de um recurso existe.
 de concorrência (compartilhamento simultâneo de
recursos)
 de paralelismo (atividades executadas em paralelo)
Confiabilidade / Tolerância a Falhas:
 Disponibilidade
 Evita perda de dados em caso de falha de
uma máquina
 Mecanismo mais comum: replicação

Todo SO

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Todo SO

Enviado por

Direitos autorais:

Formatos disponíveis

Sistemas operacionais.

Prof. Diovani Milhorim

O sistema operacional é uma estrutura de

Arquitetura geral de um sistema computacional típico.

O sistema operacional deve definir

 Prover interfaces de acesso aos dispositivos,

1. verificar se os parâmetros informados estão corretos (nome do arquivo,

2. verificar se o leitor de disquetes está disponível;

3. verificar se o leitor contém um disquete;

4. ligar o motor do leitor e aguardar atingir a velocidade de rotação correta;

5. posicionar a cabeça de leitura sobre a trilha onde está a tabela de diretório;

6. ler a tabela de diretório e localizar o arquivo ou subdiretório desejado;

7. mover a cabeça de leitura para a posição do bloco inicial do arquivo;

8. ler o bloco inicial do arquivo e depositá-lo em um buffer de memória.

O sistema operacional deve definir políticas

 O uso desse processador deve ser distribuído entre os

Um sistema operacional visa abstrair o hardware

Prof. Diovani Milhorim

 Gerência de dispositivos : A função da gerência de

É importante observar que essas abstrações são tão

 Gerência de proteção : com computadores conectados

Além dessas funcionalidades básicas, oferecidas pela

Como política consideram-se os aspectos de decisão mais

Os mecanismos devem ser suficientemente genéricos

Essa separação entre os conceitos de política e

Estrutura de um Sistema Operacional

Prof. Diovani Milhorim

Um sistema operacional não é um bloco

Núcleo : é o coração do sistema

Drivers : módulos de código específicos para

Código de inicialização : a inicialização do

Programas utilitários : são programas que

A maioria dos computadores mono-processados

Os principais elementos constituintes do

Todas as transferência de dados entre

O processador :O núcleo do sistema de computação é o

MMU : O acesso à memória é geralmente

Os periféricos do computador (discos, teclado,

Dispositivo Endereços de acesso IRQ

Um mecanismo muito utilizado na interação

Quando um controlador de periférico possui uma

• Aguardar até que o processador o consulte, o que

Ao receber a requisição de interrupção, os circuitos do

Para distinguir interrupções geradas por dispositivos

Estrutura de um sistema operacional

Prof. Diovani Milhorim

Nível núcleo : também denominado nível supervisor,

“Este programa executou uma instrução ilegal e

Exemplo: como uma aplicação pode acessar a

2. A função read preenche uma área de memória com os parâmetros

3. A função read invoca uma interrupção de software (no caso do

4. O processador comuta para o nível privilegiado (kernel level) e

6. Ao final da execução da rotina, eventuais valores de retorno são

7. A função read finaliza sua execução e retorna o controle à

8. Alternativamente, a rotina de tratamento da interrupção de software

9. Na seqüência, a gerência de atividades pode devolver o controle a

Arquiteturas de sistemas operacionais.

Prof. Diovani Milhorim

Em um sistema monolítico, todos os

 Não há estruturação visível;

Vantagem : dessa arquitetura é seu desempenho:

A arquitetura monolítica foi a primeira forma de

a camada mais baixa realiza a interface com o

Essa abordagem de estruturação de software