Manual de Sistemas Operativos

MANUAL DO CURSO DE LICENCIATURA EM
Gestão de Sistemas de Informação
SISTEMAS OPERATIVOS
ENSINO ONLINE. ENSINO COM FUTURO 2022

2º ANO Disciplina: Sistemas Operativos
CÓDIGO UNISCED1-GSI05
GSITOTAL HORAS/ 1 125
SEMESTRE
CRÉDITOS (SNATCA) 5
NÚMERO DE TEMAS 7
UNISCED CURSO: Gestão de Sistemas de Informação; 2° Ano Disciplina/Módulo: Sistemas Operativos
Direitos de autor (copyright)

Este manual é propriedade da Universidade Aberta Isced (UNISCED), e contém
reservados todos os direitos. É proibida a duplicação ou reprodução parcial ou total
deste manual, sob quaisquer formas ou por quaisquer meios (eletrónicos, mecânico,
gravação, fotocópia ou outros), sem permissão expressa de entidade editora
(Universidade Aberta Isced (UNISCED).
A não observância do acima estipulado o infractor é passível a aplicação de
processos judiciais em vigor no País.
Universidade Aberta Isced (UNISCED)

Direcção Académica
Rua Dr. Almeida Lacerda, No 212 Ponta - Gêa
Beira - Moçambique
Telefone: +258 23 323501
Cel: +258 82 3055839
Fax: 23323501
E-mail: direcção@unisced.edu.mz
Website: www.unisced.edu.mz
i
Agradecimentos
A Universidade Aberta Isced (UNISCED) agradece a colaboração dos seguintes indivíduos e

instituições na elaboração deste manual:
Autor Harold Chate
Coordenação Direcção Académica do UNISCED
Universidade Aberta Isced (UNISCED)

Design
Instituto Africano de Promoção da Educação a Distancia (IAPED)
Financiamento e Logística
Revisão Científica e XXXXX

Linguística
Ano de Publicação 2018
Local de Publicação UNISCED – BEIRA
ii
Índice
Visão geral 1
Benvindo ao Módulo de Contabilidade Geral........................................................................... 1
Objectivos da Disciolina/Módulo .................................................................................................. 1
Quem deveria estudar este módulo? ........................................................................................... 1
Como está estruturado este módulo? ........................................................................................... 2
Ícones de actividade........................................................................................................................ 3
Habilidades de estudo .................................................................................................................... 3
Precisa de apoio?............................................................................................................................. 5
Tarefas (avaliação e auto-avaliação) ......................................................................................... 6
Avaliação........................................................................................................................................... 6
TEMA I: INTRODUÇÃO AOS SISTEMAS OPERATIVOS 9

Unidade 1.1. Introdução aos SIstemas Operativos. ............................................................................. 9
Unidade 1.2. Histórico dos Sistemas Operativos ................................................................................ 13
Unidade 1.3. Classificação dos Sistemas Operativos ....................................................................... 20
Unidade 1.4. Estrutura dos Sistemas Operativos ............................................................................... 24
Unidade 1.5. EXRECÍCIOS INTEGRADOS das unidades deste tema .............................................. 27
TEMA II: GESTÃO DE PROCESSOS 29

Unidade 2.1. Introdução a Gestão de Processos ............................................................................... 29
Unidade 2.2. Comunicação Interprocessos .......................................................................................... 39
Unidade 2.3. Problemas Clássicos de Comunicação Interprocessos (IPC) ..................................... 48
Unidade 2.4. Escalonamento de Processos .......................................................................................... 51
Unidade 2.5. EXRECÍCIOS INTEGRADOS das unidades deste tema .............................................. 58
TEMA III: GESTÃO DE MEMÓRIA 61

Unidade 3.1. Introdução a Gestão de Memória ................................................................................ 61
Unidade 3.2. Gestão Básico de Memória ........................................................................................... 63
Unidade 3.3. Gestão de Memória para Multiprogramação ........................................................... 65
Unidade 3.4. Memória Virtual ............................................................................................................... 70
Unidade 3.5. EXERCÍCIOS INTEGRADOS das unidades deste tema .............................................. 83
TEMA IV: SISTEMAS DE ARQUIVOS 86

Unidade 4.1 Introdução aos Sistemas de Arquivos............................................................................ 86
Unidade 4.2. Implementação de Arquivos .......................................................................................... 93
Unidade 4.3. Directórios.......................................................................................................................... 95
Unidade 4.5. EXERCÍCIOS INTEGRADOS das unidades deste tema ........................................... 100
TEMA V: SISTEMAS DE ENTRADA/SAÍDAS 102

Unidade 5.1. Introdução aos Sistemas de Entradas/Saídas ......................................................... 102
iii
Unidade 5.2. Princípios de Hardware de Entradas/Saídas ......................................................... 103

Unidade 5.3. Princípios de Software de Entradas/Saídas ........................................................... 108
Unidade 5.4. Deadlocks ....................................................................................................................... 110
Unidade 5.5. EXERCÍCIOS INTEGRADOS das unidades deste tema ........................................... 121
iv
Visão geral
Benvindo à Disciplina/Módulo de Sistemas

Operativos
Objectivos do Módulo
Ao terminar o estudo deste módulo de Sistemas Operativos deverá

ser capaz de: Demonstrar uma perspectiva geral sobre o
funcionamento dum sistema operativo, tipos e técnicas usadas no
seu desenho e implementação, selecionar, instalar e configurar os
sistemas de informação segundo as necessidades de cada
organização tendo em conta as situações reais existentes.
▪ Perceber o princípio de funcionamento dos sistemas operativos.

▪ Ser capaz de instalar, configurar e operar um sistema operativo
na plataforma Windows.
Objectivos
▪ Implementar as filosofias e técnicas usadas no desenho e
Específicos
implementação de sistemas operativos;
Quem deveria estudar este módulo
Este Módulo foi concebido para estudantes do 2º ano do curso de

licenciatura em Gestão de Sistemas de Informação do UNISCED.
Poderá ocorrer, contudo, que haja leitores que queiram se
actualizar e consolidar seus conhecimentos nessa disciplina, esses
serão bem-vindos, não sendo necessário para tal se inscrever. Mas
poderá adquirir o manual.
1
Como está estruturado este módulo
Este módulo de Sistemas Operativos, para estudantes do 2º ano do

curso de licenciatura em Gestão de Sistemas de Informação, à
semelhança dos restantes do UNISCED, está estruturado como se
segue:
Páginas introdutórias
▪
Um índice completo.
▪
Uma visão geral detalhada dos conteúdos do módulo, resumindo
os aspectos-chave que você precisa conhecer para melhor
estudar. Recomendamos vivamente que leia esta secção com
atenção antes de começar o seu estudo, como componente de
habilidades de estudos.
Conteúdo desta Disciplina/módulo
Este módulo está estruturado em Temas. Cada tema, por sua vez
comporta certo número de unidades temáticas ou simplesmente
unidades. Cada unidade temática se caracteriza por conter uma
introdução, objectivos, conteúdos.
No final de cada unidade temática ou do próprio tema, são
incorporados antes o sumário, exercícios de auto-avaliação, só
depois é que aparecem os exercícios de avaliação.
Os exercícios de avaliação têm as seguintes características: Puros
exercícios teóricos/Práticos, Problemas não resolvidos e actividades
práticas, incluído estudo de caso.
Outros recursos
A equipa dos académicos e pedagogos do UNISCED, pensando em

si, num cantinho, recôndito deste nosso vasto Moçambique e cheio
de dúvidas e limitações no seu processo de aprendizagem,
apresenta uma lista de recursos didácticos adicionais ao seu módulo
para você explorar. Para tal o UNISCED disponibiliza na biblioteca
do seu centro de recursos mais material de estudos relacionado com
o seu curso como: Livros e/ou módulos, CD, CD-ROOM, DVD. Para
além deste material físico ou electrónico disponível na biblioteca,
pode ter acesso a Plataforma digital moodle para alargar mais
ainda as possibilidades dos seus estudos.
2
Auto-avaliação e Tarefas de avaliação
Tarefas de auto-avaliação para este módulo encontram-se no final

de cada unidade temática e de cada tema. As tarefas dos
exercícios de auto-avaliação apresentam duas características:
primeiro apresentam exercícios resolvidos com detalhes. Segundo,
exercícios que mostram apenas respostas.
Tarefas de avaliação devem ser semelhantes às de auto-avaliação
mas sem mostrar os passos e devem obedecer o grau crescente de
dificuldades do processo de aprendizagem, umas a seguir a outras.
Parte das terefas de avaliação será objecto dos trabalhos de
campo a serem entregues aos tutores/docentes para efeitos de
correcção e subsequentemente nota. Também constará do exame
do fim do módulo. Pelo que, caro estudante, fazer todos os
exercícios de avaliação é uma grande vantagem.
Comentários e sugestões
Use este espaço para dar sugestões valiosas, sobre determinados

aspectos, quer de natureza científica, quer de natureza didáctico-
Pedagógica, etc, sobre como deveriam ser ou estar apresentadas.
Pode ser que graças as suas observações que, em gozo de confiança,
classificamo-las de úteis, o próximo módulo venha a ser melhorado.
Ícones de actividade
Ao longo deste manual irá encontrar uma série de ícones nas

margens das folhas. Estes ícones servem para identificar diferentes
partes do processo de aprendizagem. Podem indicar uma parcela
específica de texto, uma nova actividade ou tarefa, uma mudança
de actividade, etc.
Habilidades de estudo
O principal objectivo deste campo é o de ensinar aprender a

aprender. Aprender aprende-se.
Durante a formação e desenvolvimento de competências, para

facilitar a aprendizagem e alcançar melhores resultados, implicará
empenho, dedicação e disciplina no estudo. Isto é, os bons resultados
apenas se conseguem com estratégias eficientes e eficazes. Por isso
é importante saber como, onde e quando estudar. Apresentamos
algumas sugestões com as quais esperamos que caro estudante
possa rentabilizar o tempo dedicado aos estudos, procedendo como
se segue:
1º Praticar a leitura. Aprender a Distância exige alto domínio de

leitura.
3
2º Fazer leitura diagonal aos conteúdos (leitura corrida).
3º Voltar a fazer leitura, desta vez para a compreensão e

assimilação crítica dos conteúdos (ESTUDAR).
4º Fazer seminário (debate em grupos), para comprovar se a sua

aprendizagem confere ou não com a dos colegas e com o padrão.
5º Fazer TC (Trabalho de Campo), algumas actividades práticas ou

as de estudo de caso se existirem.
IMPORTANTE: Em observância ao triângulo modo-espaço-tempo,

respectivamente como, onde e quando...estudar, como foi referido
no início deste item, antes de organizar os seus momentos de estudo
reflicta sobre o ambiente de estudo que seria ideal para si: Estudo
melhor em casa/biblioteca/café/outro lugar? Estudo melhor à
noite/de manhã/de tarde/fins-de-semana/ao longo da semana?
Estude melhor com música/num sítio sossegado/num sítio barulhento!?
Preciso de intervalo em cada 30 minutos, em cada hora, etc.
É impossível estudar numa noite tudo o que devia ter sido estudado
durante um determinado período de tempo; Deve estudar cada
ponto da matéria em profundidade e passar só ao seguinte quando
achar que já domina bem o anterior.
Privilegia-se saber bem (com profundidade) o pouco que puder ler

e estudar, que saber tudo superficialmente! Mas a melhor opção é
juntar o útil ao agradável: Saber com profundidade todos conteúdos
de cada tema, no módulo.
Dica importante: não recomendamos estudar seguidamente por

tempo superior a uma hora. Estudar por tempo de uma hora
intercalado por 10 (dez) a 15 (quinze) minutos de descanso (chama-
se descanso à mudança de actividades). Ou seja que durante o
intervalo não se continuar a tratar dos mesmos assuntos das
actividades obrigatórias.
Uma longa exposição aos estudos ou ao trabalho intelectual

obrigatório pode conduzir ao efeito contrário: baixar o rendimento da
aprendizagem. Por que o estudante acumula um elevado volume de
trabalho, em termos de estudos, em pouco tempo, criando interferência
entre os conhecimentos, perde sequência lógica, por fim ao perceber
que estuda tanto mas não aprende, cai em insegurança, depressão e
desespero, por se achar injustamente incapaz!
Não estude na última da hora; quando se trate de fazer alguma

avaliação. Aprenda a ser estudante de facto (aquele que estuda
sistematicamente), não estudar apenas para responder a questões de
4
alguma avaliação, mas sim estude para a vida, sobre tudo, estude
pensando na sua utilidade como futuro profissional, na área em que
está a se formar.
Organize na sua agenda um horário onde define a que horas e que

matérias deve estudar durante a semana; Face ao tempo livre que
resta, deve decidir como o utilizar produtivamente, decidindo
quanto tempo será dedicado ao estudo e a outras actividades.
É importante identificar as ideias principais de um texto, pois será

uma necessidade para o estudo das diversas matérias que
compõem o curso: A colocação de notas nas margens pode ajudar
a estruturar a matéria de modo que seja mais fácil identificar as
partes que está a estudar e Pode escrever conclusões, exemplos,
vantagens, definições, datas, nomes, pode também utilizar a
margem para colocar comentários seus relacionados com o que
está a ler; a melhor altura para sublinhar é imediatamente a seguir
à compreensão do texto e não depois de uma primeira leitura;
Utilizar o dicionário sempre que surja um conceito cujo significado
não conhece ou não lhe é familiar;
Precisa de apoio?
Caro estudante, temos a certeza que por uma ou por outra razão, o
material de estudos impresso, lhe pode suscitar algumas dúvidas
como falta de clareza, alguns erros de concordância, prováveis
erros ortográficos, falta de clareza, fraca visibilidade, página
trocada ou invertidas, etc). Nestes casos, contacte os serviços de
atendimento e apoio ao estudante do seu Centro de Recursos (CR),
via telefone, sms, E-mail, se tiver tempo, escreva mesmo uma carta
participando a preocupação.
Uma das atribuições dos Gestores dos CR e seus assistentes
(Pedagógico e Administrativo), é a de monitorar e garantir a sua
aprendizagem com qualidade e sucesso. Dai a relevância da
comunicação no Ensino a Distância (EAD), onde o recurso as TIC se
torna incontornável: entre estudantes, estudante – Tutor, estudante –
CR, etc.
As sessões presenciais são um momento em que você caro estudante,
tem a oportunidade de interagir fisicamente com staff do seu CR,
com tutores ou com parte da equipa central do UNISCED indigitada
para acompanhar as suas sessões presenciais. Neste período pode
apresentar dúvidas, tratar assuntos de natureza pedagógica e/ou
administrativa.
O estudo em grupo, que está estimado para ocupar cerca de 30% do
tempo de estudos a distância, é muita importância, na medida em que
lhe permite situar, em termos do grau de aprendizagem com relação
aos outros colegas. Desta maneira ficará a saber se precisa de apoio
ou precisa de apoiar aos colegas. Desenvolver hábito de
5
debater assuntos relacionados com os conteúdos programáticos,

constantes nos diferentes temas e unidade temática, no módulo.
Tarefas (avaliação e auto-avaliação)
O estudante deve realizar todas as tarefas (exercícios, actividades

e auto−avaliação), contudo nem todas deverão ser entregues, mas é
importante que sejam realizadas. As tarefas devem ser entregues
duas semanas antes das sessões presenciais seguintes.
Para cada tarefa serão estabelecidos prazos de entrega, e o não
cumprimento dos prazos de entrega, implica a não classificação do
estudante. Tenha sempre presente que a nota dos trabalhos de
campo conta e é decisiva para ser admitido ao exame final da
disciplina/módulo.
Os trabalhos devem ser entregues ao Centro de Recursos (CR) e os
mesmos devem ser dirigidos ao tutor/docente.
Podem ser utilizadas diferentes fontes e materiais de pesquisa,
contudo os mesmos devem ser devidamente referenciados,
respeitando os direitos do autor.
O plágio1 é uma violação do direito intelectual do(s) autor(es). Uma
transcrição à letra de mais de 8 (oito) palavras do testo de um
autor, sem o citar é considerado plágio. A honestidade, humildade
científica e o respeito pelos direitos autorais devem caracterizar a
realização dos trabalhos e seu autor (estudante do UNISCED).
Avaliação
Muitos perguntam: Com é possível avaliar estudantes à distância,

estando eles fisicamente separados e muito distantes do
docente/tutor! Nós dissemos: Sim é muito possível, talvez seja uma
avaliação mais fiável e consistente.
Você será avaliado durante os estudos à distância que contam com
um mínimo de 90% do total de tempo que precisa de estudar os
conteúdos do seu módulo. Quando o tempo de contacto presencial
conta com um máximo de 10%) do total de tempo do módulo. A
avaliação do estudante consta detalhada do regulamentado de
avaliação.
Os trabalhos de campo por si realizados, durante estudos e
aprendizagem no campo, pesam 25% e servem para a nota de
frequência para ir aos exames.
Os exames são realizados no final da cadeira disciplina ou modulo e
decorrem durante as sessões presenciais. Os exames pesam no mínimo
1
Plágio - copiar ou assinar parcial ou totalmente uma obra literária,
propriedade intelectual de outras pessoas, sem prévia autorização.
6
75%, o que adicionado aos 25% da média de frequência,

determinam a nota final com a qual o estudante conclui a cadeira.
A nota de 10 (dez) valores é a nota mínima de conclusão da cadeira.
Nesta cadeira o estudante deverá realizar pelo menos 2 (dois)
trabalhos e 1 (um) (exame).
Algumas actividades práticas, relatórios e reflexões serão utilizados
como ferramentas de avaliação formativa.
Durante a realização das avaliações, os estudantes devem ter em
consideração a apresentação, a coerência textual, o grau de
cientificidade, a forma de conclusão dos assuntos, as
recomendações, a identificação das referências bibliográficas
utilizadas, o respeito pelos direitos do autor, entre outros.
Os objectivos e critérios de avaliação constam do Regulamento de
Avaliação.
7
TEMA – I: INTRODUÇÃO AOS SISTEMAS OPERATIVOS.
UNIDADE Temática 1.1. Introdução, aos Sistemas Operativos.

UNIDADE Temática 1.2. Histórico dos Sistemas Operativos.
UNIDADE Temática 1.3. Classificação dos Sistemas Operativos.
UNIDADE Temática 1.4. Estrutura dos Sistemas Operativos.
UNIDADE Temática 1.5. EXERCÍCIOS deste tema.
▪
Definir o conceito de Sistemas Operativos; descrever os objectivos de sistemas
operativos.
▪
Descrever breve historial sobre a evolução dos sistemas operativos.
Objectivos
específicos ▪
Apresentar a classificação dos sistemas operativos, bem como como os
mesmos estão estruturados.
UNIDADE Temática 1.1. Introdução, aos Sistemas Operativos
Desde sua criação, os computadores sempre foram sistemas de elevada

sofisticação em relação ao estágio tecnológico de suas épocas de
desenvolvimento. Ao longo dos últimos anos evoluíram incrivelmente e,
embora tenham se tornado mais comuns e acessíveis, sua popularização
ainda esconde sua tremenda complexidade interna.
Um Sistema Operativo é um conjunto de rotinas executado pelo

processador (CPU), de forma análoga aos programas de usuários. A
principal função dessas rotinas é controlar o funcionamento do Sistema
Computacional, gerindo de forma optimizada os recursos disponíveis,
como processadores, memória e dispositivos de entrada e saída,
além de, na medida do possível, fazer a interface entre o hardware e
o usuário final, procurando esconder sua complexidade e mostrando
um ambiente agradável e de fácil utilização. É de salientar que os
sistemas operativos estão sempre em constante evolução.
Se não existisse o Sistema Operativo, o usuário, para poder manipular o

computador, deveria conhecer os diversos detalhes de hardware (tarefa
árdua), o que tornaria o seu trabalho mais cansativo, lento e impróprio,
9
sem considerar a grande quantidade de problemas e com uma grande

perspectiva de erros.
De um modo geral os Sistemas Operativos (SO) pode ser visto sobre

duas visões (Andrew Tanenbaum):
▪ A visão de Sistema Operativo como uma máquina estendida; e
▪
O Sistema Operativo como gestor dos recursos.
A definição de Sistemas Operativos do ponto de vista de uma máquina

estendida procura esconder a complexidade do hardware
computacional. Já a definição de Sistemas Operativos do ponto de
vista de gestor de recursos trata de organizar os recursos
computacionais disponíveis, evitando assim possíveis problemas, como
inconsistências e disputas entre os programas.
O Rômulo faz uma abordagem diferente “em torno de um computador,

existem usuários com problemas a serem resolvidos,” problemas esses que
podem se estender de simples entretenimento, até edição de textos,
figuras e actividades mais complexas, como uma análise estatística ou
gestão de uma empresa por completo. O software, de um modo geral,
é utilizado para solucionar os problemas do usuário, enquanto que o
hardware do computador é o dispositivo físico capaz de executar esses
softwares. Esses softwares, responsáveis por realizar as actividades dos
usuários, geralmente são chamados de programas aplicativos.
Tendo como base na abordagem do Rômulo, podemos nós perguntar e

o Sistema Operativo aonde entra? Desta forma podemos caracterizar o
Sistema Operativo como uma camada de software localizado entre
hardware e os programas aplicativos que executam as actividades dos
usuários, a Figura 1 ilustra.
10
usuário
1
usuário
2
usuário
3
... usuário
n
compilador montador editor de texto ... sistema de

banco de
dados
programas de sistema e aplicativos
sistema operacional
hardware do
computador
Figura 1: Visão Abstrata dos componentes de um sistema de

computação
O hardware - a unidade central de processamento (CPU - central
processing unit), a memória e os dispositivos de entrada/saída (I/O -
input/output) - fornece os recursos básicos de computação do sistema.
Os programas aplicativos - como processadores de texto, planilhas,
compiladores e navegadores da web – definem as formas pelas quais
esses recursos são utilizados para resolver os problemas computacionais
dos usuários. O sistema operativo controla o hardware e coordena seu

uso pelos diversos programas aplicativos de vários usuários.
1.1. Definição de Sistemas Operativos

Como visto anteriormente, segundo Tanenbaum os Sistemas Operativos
(SO) podem ser definidos levando em consideração dois pontos de vista:
▪
O Sistema Operativo como uma máquina estendida; e
▪
O Sistema Operativo como gestor dos recursos.
1.1.1. Sistema Operativo como uma Máquina Estendida

O usuário (que pode ser um programador ou um usuário final), geralmente,
não está interessado em saber os detalhes funcionais dos dispositivos.
Como exemplo, o usuário não quer saber o que é preciso, a nível de
hardware, para que seja lido uma determinada informação de uma
disquete ou de um disco rígido (tarefa bem complexa, que exige o
11
conhecimento de registradores, motores, cilindros e outros dispositivos

físicos). O usuário deseja ter uma interface mais palpável e mais simples
de lidar. No caso dos discos, por exemplo, uma abstração típica seria
que o disco contenha um conjunto de nomes de arquivos. A partir desses
nomes, é possível realizar as operações básicas (abrir, ler, escrever e
fechar), sem se importar qual a velocidade e estado actual do motor,
por exemplo. Assim, o Sistema Operativo aparece como o programa
que esconde do usuário a complexidade do hardware e apresenta uma
visão fácil e simples para as operações sobre os dispositivos. Essa visão
é equivalente a uma máquina estendida ou máquina virtual, mais fácil
de lidar.
1.1.2. Sistema Operativo como Gestor de Recusrsos

Por outro lado, o Sistema Computacional é composto de uma série de
recursos, no qual podemos enumerar: processadores, memórias, discos,
mouses, teclados, impressoras, placas de rede e uma infinidade de
dispositivos em geral. Dessa forma, o Sistema Operativo aparece como
sendo o responsável por organizar e alocar de forma ordenada todos
esses recursos disponíveis.
Essa tarefa, em uma primeira vista, pode parecer simples. Porém,

quando se tem vários programas disputando os recursos, que são
limitados, é necessário utilizar técnicas de alocação dos dispositivos, a
fim de se evitar inconsistências e, até mesmo, situações que resultem
numa parada do sistema de uma forma geral.
1.1.3. Objectivos de um Sistema Operativo

Apesar do tipo, sofisticação ou capacidades do computador, para o
desenvolvimento de um Sistema Operativo devemos então atender aos
seguintes princípios ou objetivos:
▪
Oferecer os recursos do sistema de forma simples e transparente.
▪
Tornar a utilização do computador eficiente e conveniente, a fim
de ter um ganho de produtividade e, dessa forma, utilizar o
Sistema Computacional para agilizar as atividades do dia-a-dia;
▪
Garantir a integridade e segurança dos dados armazenados e
processados pelos programas e também dos recursos físicos
12
disponíveis.
Além destes objetivos, um sistema operativo também deve proporcionar

uma interface adequada para que ele possa ser utilizado pelos seus
usuários. Historicamente as primeiras interfaces dos sistemas operativos
eram baseadas em um conjunto de palavras-chave comandos e
mensagens de diálogo que permitiam a execução de tarefas e a
comunicação entre homem (o operador) e máquina. Estes comandos e
mensagens definiam a Interface Humano-Computador (IHC) daquele
sistema. Actualmente as interfaces baseadas em modo texto estão em
desuso, sendo substituídas por interfaces gráficas mais modernas e
simples que buscam facilitar a utilização do computador através de sua
aparência atraente e uso intuitivo.
UNIDADE Temática 1.2. Histórias dos Sistemas Operativos.
Para melhor compreendermos a evolução dos Sistemas Operativos,

traremos um breve histórico que vem junto da evolução dos Sistemas
Computacionais.
Os Sistemas Operativos, ao longo dos anos, vêm se desenvolvendo e

ganhando novas características, sendo necessário partimos ao seu
histórico para que possamos compreender como se deu essa evolução.
Partindo do pressuposto que a história dos Sistemas Operativos sempre
esteve estreitamente relacionado à história das arquiteturas de
computadores. No breve resumo que se segue pretende-se enfocar os
principais eventos e movimentos relacionados ao desenvolvimento
destas máquinas.
O primeiro computador digital, de facto, foi projectado por volta da

década de 1820 pelo matemático Charles Babbage e intitulada como
motor analítico. Esta máquina, por se tratar de um equipamento
puramente mecânico e a tecnologia da época não permitir a construção
de engrenagens de alta precisão o qual Babbage necessitava, nunca
funcionou adequadamente. Assim, o motor analítico de Babbage não
possuía Sistema Operativo. Um dado interessante está no facto de que
13
Babbage sabia que era preciso de um software para o seu motor

analítico e, assim, contratou uma jovem chamada Ada Lovelace como
primeira programadora do mundo. O nome da linguagem de
programação Ada foi criado em homenagem a esta jovem.
1.2.1. Primeira Geração (1945-1955)

Impulsionado pela Segunda Guerra Mundial, surgiram os grandes
computadores digitais, formados por milhares de válvulas e que ocupavam
salas inteiras. Estes computadores, desenvolvidos por Howard Aiken e
John Von Neumann, eram extremamente lentos. Para trabalhar nesta
máquina era necessário o conhecimento do funcionamento do seu
hardware, onde a programação era feita através de linguagem de
máquina, frequentemente ligando painéis de conectores com fios para o
controle das funções básicas. Nessa época, ainda não existia o conceito de
Sistema Operativo. Por esse facto, esta geração ficou conhecida como a
geração das válvulas e painéis de conectores.
Figura 1.1: Computador de Primeira Geração.

1.2.2. Segunda Geração (1956-1965)
Com o desenvolvimento dos transístores, os computadores sofreram um
enorme avanço, tornando-se mais confiáveis a fim de serem
comercializados.
14
Nesta época, com o surgimento das primeiras linguagens de

programação, os programas deixaram de ser feitos directamente no
hardware, facilitando assim o processo de desenvolvimento de
programas.
As máquinas de transístores eram armazenadas em salas e operadas

por equipes especiais. Para executar uma actividade, o programador
escrevia o seu programa, inicialmente, em um papel (em FORTRAN ou
ASSEMBLY), e transformava este em cartões perfurados. O seu conjunto
de cartões era levado para a sala onde se encontrava a máquina e
era entregue diretamente aos operadores.
Os cartões eram carregados em fitas magnéticas, que eram lidas pelo

computador, que executava um programa de cada vez, gravando o
resultado do processamento em uma fita de saída. Esse tipo de
processamento, onde um lote de programas era submetido ao
computador, deu-se o nome de processamento em lotes ou
processamento em batch. A Figura 1.2 visualiza este procedimento.
Figura 1.2: Sistema de processamento em lote.

(a) Programadores levavam cartões para o 1401.
(b) O 1401 lia o lote de tarefas em uma fita.
(c) O operador levava a fita de entrada para o 7094.
(d) O 7094 executava o processamento.
(e) O operador levava a fita de saída para o 1401.
(f) O 1401 imprimia as saídas.
15
1.2.3. Terceira Geração (1966-1980)

A terceira geração é conhecida como a geração dos circuitos
integrados (CI’s) e da multiprogramação, diminuindo consideravelmente
o preço do computador, possibilitando assim sua aquisição por
empresas. Esta época se caracteriza pelo grande aumento do poder de
processamento e, também, a diminuição dos equipamentos.
Nesta época, a IBM lançou o System/360, que era uma série de

computadores pequenos, poderosos e, sobre tudo, compatível. O 360
foi projectado para manipular cálculos tanto científicos como comerciais,
ou seja, em uma única família de máquinas era possível satisfazer as
necessidades de praticamente todos os clientes.
Porém, para atender todas as aplicações e periféricos disponíveis por

essa família de máquinas, a IBM teve que desenvolver um Sistema
Operativo (OS/360) extremamente grande e complexo, posto que as
aplicações disponíveis, comumente, eram contraditórias. Este Sistema
Operativo consistia de milhões de linhas de linguagem assembler escrita
por milhares de programadores e muitos bugs, que exigiam versões e
mais versões a fim de corrigi-los.
Apesar de todos os problemas, o OS/360 e os Sistemas Operativos

semelhantes atenderam a maioria dos seus clientes razoavelmente bem.
Além disso, eles lançaram várias técnicas utilizadas até hoje, como
exemplo a multiprogramação. A multiprogramação consistia em dividir
a memória em várias partições a fim de permitir que várias tarefas
sejam carregadas em cada partição. Enquanto uma tarefa esperava
alguma operação de Entrada ou Saída, outra tarefa poderia usar o
processador (CPU).
Outro recurso disponível nos Sistemas Operativos da terceira geração

era a capacidade de ler jobs (tarefas) de cartões para o disco. Assim,
sempre que uma tarefa acabava sua execução, o Sistema Operativo
podia carregar uma nova tarefa do disco para a partição e executa-
lo. Esta técnica é conhecida como spooling.
Entretanto, os Sistemas Operativos ainda eram basicamente sistemas

em lote e que não exigiam comunicação com o usuário.
16
Assim, muitos programadores sentiam falta das máquinas de primeira

geração, que eram disponibilizadas por completo para eles e, assim,
podiam depurar seus programas.
Assim, a multiprogramação evoluiu preocupada em oferecer aos usuários

tempos de respostas razoáveis e uma interface cada vez mais amigável.
Para tal, cada programa na memória utilizaria o processador em
pequenos intervalos de tempo. Esse sistema de divisão de tempo ficou
conhecido como compartilhamento de Tempo (time-sharing).
A terceira geração também é marcada pelo surgimento do Sistema

Operativo UNIX, escrito em linguagem de programação de alto nível,
que se tornou popular no mundo acadêmico e entre muitas empresas.
1.2.4. Quarta Geração (1980)

A década de 1980 é caracterizada pelo surgimento dos computadores
pessoais. Os computadores pessoais se tornaram possíveis devido ao
aparecimento de novas tecnologias, impulsionados pelo avanço da
indústria de hardware, com a introdução de novos circuitos integrados.
Os computadores pessoais permitiram que as pessoas pudessem ter seu
próprio computador.
Os equipamentos desta geração se tornaram cada vez menores, mais

velozes e, principalmente, mais baratos. Esses novos equipamentos, com
alta disponibilidade de poder de computação, especialmente a
computação altamente interativa, normalmente com excelentes gráficos,
levaram ao crescimento de uma importante indústria, a indústria de
softwares para computadores pessoais. Dois Sistemas Operativos
inicialmente dominaram o cenário dos computadores pessoais: o MS-
DOS (Microsoft) e o UNIX. O MS-DOS foi amplamente utilizado no IBM
PC e em computadores com a tecnologia Intel. Esse Sistema Operativo
evolui para o sistema conhecido como Windows.
Outra evolução que surgiu nesta geração foi o crescimento de redes de

computadores pessoais executando Sistemas Operativos de rede e
Sistemas Operativos distribuídos. Em um Sistema Operativo de rede, os
usuários podem conectar-se a máquinas remotas e copiar arquivos de
uma máquina para a outra.
17
Em um Sistema Operativo distribuído os programas dos usuários podem

ser executados em vários computadores, porém, estes veem o sistema
como único.
Alguns autores ainda apontam uma quinta geração, que engloba o

desenvolvimento cada vez maior da indústria do hardware e do
software, além do desenvolvimento das telecomunicações, permitindo o
funcionamento de sistemas e aplicações distribuídas, que figuram nossa
realidade.
Figura 1.3: Computador Pessoal Moderno

1.2.4. Quinta Geração (1990 - Presente)
A década de 1990 é caracterizada pelo surgimento dos computadores
pessoal portátil e pela interoperabilidade. Dispõe-se de
microcomputadores cujo poder de processamento é maior do que os
mainframes da década de 1970.
Os notebooks e PDAs (personal digital assistents) representam o máximo

em portabilidade e flexibilidade, e estão grandemente incorporados no
cotidiano de executivos, profissionais de design, vendedores e outros
profissionais liberais, mesmo aqueles cuja actividade final não é a
informática. Mesmo estes pequenos aparelhos possuem versões
simplificadas de sistemas operativos, permitindo que uma gama maior de
serviços e funcionalidades sejam oferecidos. Além disso a eletrónica
embarcada começa a ser tornar presente em automóveis e utensílios
domésticos, além das tradicionais aplicações industriais. Sistemas de
correio eletrónico, grupos de discussão, educação á distância, multimídia,
18
ATM, Java, sistemas distribuídos, processamento vectorial,

processamento paralelo etc. Inúmeras tecnologias de projecto,
desenvolvimento, aplicação, integração e interoperabilidade,
adicionando diversidade, novas necessidades e maior complexidade
aos sistemas operativos contemporâneos.
Com tudo isto, houve necessidade de se pensar na criação de um sistema

operativo que atende-se em parte tais necessidades, sendo necessário
adaptá-los aos mais diversos tipos de aplicação e usuário. E para dar
suporte a tremenda complexidade destes programas, a indústria de
hardware vem continuamente desenvolvendo novos processadores também
com velocidade cada vez maior, circuitos de memória de maior
capacidade e velocidade bem como dispositivos periféricos cada vez mais
sofisticados, tudo através das novas tecnologias.
O desenvolvimento da computação não parou por aqui, na década

2000 a supercomputação se torna superlativa graças à pesquisa e a
evolução dos sistemas distribuídos, tal como as técnicas de Grid
Computing (Grid computer são executadas em um gigantesco
computador virtual, com uma forte integração de servidores, discos e
outros recursos capazes de compartilhar recursos de forma rápida e de
fácil gereciamento) o emprego de clusters (agrupamentos) de
computadores geograficamente dispersos e interligados através da
Internet ou conectados através de redes locais de alto desempenho
também vem se tornando mais comum, como alternativa mais económica
e de desempenho semelhante aos supercomputadores.
O desenvolvimento e miniaturização de novos componentes eletrónicos

em adição e a utilização de novos processos de fabricação associados
à grande expansão das redes digitais de telefonia móvel permitem
que muitos milhões de usuários se beneficiem de equipamentos que
somam as características de telefones portáteis com PDAs cada vez
mais sofisticados.
Os computadores dedicados e os de uso genérico estão se tornando cada

vez mais populares em contraste com as necessidades e exigências mais
sofisticadas de seus usuários. O número de usuários de computador
19
também cresce vertiginosamente, impulsionando os fabricantes a

criarem novos produtos, serviços e soluções.
Com tudo isso a computação é, sem dúvida alguma, imprescindível como

ferramenta para o homem moderno, tornando o desenvolvimento
contínuo dos sistemas operativos uma tarefa essencial.
Figura 1.4: Servidor, Workstation e notebook
UNIDADE Temática 1.3. Classificação dos Sistemas Operativos
Os Sistemas Operativos evoluíram juntamente com a evolução do

hardware e das aplicações por ele suportada. Muitos termos
inicialmente introduzidos para definir conceitos e técnicas foram
substituídos por outros. Abordaremos neste tópico, os diversos tipos de
Sistemas Operacionais classificados quanto ao seu tipo de
processamento (Figura 1.5), apontando suas principais características.
Tipos de Sistemas
Operacionais
Sistemas Sistemas
Sistemas
Multiprogramáveis ou Monoprogramáveis
Mutiprocessadores
Mutitarefas ou Monotarefas
Figura 1.5: Tipos de Sistemas Operacionais.

1.3.1. Sistemas Monoprogramáveis ou Monotarefas
Os Sistemas monoprogramáveis ou monotarefas são caracterizados por
alocar o Sistema Computacional disponível exclusivamente para um único
20
programa, ou seja, um programa tem todos os dispositivos, incluindo

periféricos, memória e processador disponível durante todo o tempo em
que ele está activo, mesmo se não estiver usando.
Nesse caso, se o programa estivesse executando uma operação de

entrada e saída, o processador continuaria disponível e alocado a ele,
mesmo que ele não esteja a ser utilizado (o processador ficaria ocioso).
Os primeiros sistemas operativos eram tipicamente voltados para a

execução de um único programa. Os sistemas monoprogramáveis estão
tipicamente relacionados ao surgimento dos primeiros computadores na
década de 1960 e se caracterizam por permitir que todos os recursos
do sistema fiquem exclusivamente dedicados a uma única tarefa, como
ilustrado na Figura 1.6.
Programa
ou Tarefa
Processador
Memória
Dispositivo
de E/S
Figura 1.6: Sistemas Monoprogramáveis.
Os Sistemas monoprogramáveis são de simples implementação,

comparado com sistemas multiprogramáveis e multiprocessadores, posto
que não necessita de muita preocupação com compartilhamento e
concorrência.
1.3.2. Sistemas Multiprogramáveis ou Multitarefas

Os Sistemas multiprogramáveis já são bem mais complexos que os
Sistemas monoprogramáveis. Neste tipo de sistema, os diversos recursos
do Sistema Computacional são divididos pelas várias tarefas ou
programas que necessitam utiliza-los, como visualizado na Figura 1.7.
21
Programa Programa
ou Tarefa ou Tarefa
Processador
Memória
Programa Dispositivo Programa

ou Tarefa de E/S ou Tarefa
Figura 1.7: Sistemas Multiprogramáveis.
A grande vantagem dos Sistemas multiprogramáveis está no facto dos

recursos poderem ser divididos entre os vários programas, ganhando
tempo e, naturalmente, aumentando a produtividade do usuário. Assim,
por exemplo, em um caso onde um programa necessite fazer uma
operação de E/S e não esteja utilizando a CPU, esta poderá ser
disponibilizada para outro programa.
Os Sistemas multiprogramáveis podem ser classificados pelo número de

usuários que interagem com o sistema e pela forma com que suas
aplicações são geridas.
Os Sistemas multiprogramáveis, quanto ao número de usuários que

interagem com o Sistema, podem ser classificados a seguir como:
▪
Sistemas monousuários: sistemas multiprogramáveis onde
apenas um usuário interage com o sistema, podendo realizar
várias actividades ao mesmo tempo, como edição de texto,
impressão e acesso a Internet, por exemplo.
▪
Sistemas multiusuários: sistemas multiprogramáveis onde vários
usuários podem estar conectados e interagindo com o sistema.
Os Sistemas multiprogramáveis, quanto à forma que suas aplicações

são geridas, podem ser classificados como: sistemas batch, de tempo
compartilhado ou de tempo real.
22
1.3.2.1. Sistemas Sistemas Batch

Os sistemas batch foram os primeiros Sistemas Operativos
multiprogramáveis. Este tipo de sistema não necessitava da interação do
usuário, o qual o programa era carregado no computador a partir de
algum tipo de memória secundária e eram executados sequencialmente.
1.3.2.1.1. Sistemas de Tempo Compartilhado

Os Sistemas de tempo compartilhado (time-sharing) permitem que
diversos programas sejam executados a partir da divisão do tempo do
processador. Cada programa utiliza o processador por uma fatia de
tempo e pode ser interrompido caso o seu tempo termine. O sistema
cria um ambiente de trabalho próprio, dando a impressão para o
usuário que o sistema está todo disponível a ele.
1.3.2.1.2. Sistemas de tempo Real

Os sistemas de tempo real têm características semelhantes aos sistemas
de tempo compartilhado, porém, suas aplicações possuem requisitos
temporais, ou seja, possuem um tempo máximo para serem executados.
Em sistemas de tempo real, uma tarefa utiliza o processador o tempo que

for necessário ou até que uma outra tarefa mais prioritária apareça.
1.3.3. Sistemas Mutiprocessadores

Os sistemas multiprocessadores são caracterizados por possuir dois ou
mais processadores interligados e trabalhando em conjunto. Esta
característica traz como principal vantagem a possibilidade de vários
programas serem executados ao mesmo tempo.
Os conceitos aplicados ao projecto de sistemas com múltiplos

processadores incorporam os mesmos princípios básicos e benefícios
apresentados na multiprogramação, além de outras características e
vantagens específicas como escalabilidade, disponibilidade e
balanceamento de carga.
▪
Escalabilidade é a capacidade de ampliar o poder
computacional do sistema apenas adicionando novos
processadores.
▪
Disponibilidade é a capacidade de manter o sistema em
operação mesmo em casos de falhas.
23
▪
Balanceamento de carga é a possibilidade de distribuir o
processamento entre os diversos processadores da configuração
a partir da carga de trabalho de cada processador,
melhorando, assim, o desempenho do sistema como um todo.
Processador Processador
Memória Memória
Dispositivo Dispositivo
de E/S de E/S
Figura 1.8: Sistemas Multiprocessadores.
UNIDADE Temática 1.4. Estrutura do Sistema Operativo
O Sistema Operativo proporciona o ambiente pelo qual os programas

são executados e é composto por um conjunto de rotinas, conhecido
como o núcleo, que são disponibilizadas para as aplicações dos
usuários e para o próprio sistema. A interface entre o Sistema
Operativo e os programas dos usuários são definidos por um conjunto
de instruções que o SO proporciona. Esse conjunto de instruções é
tradicionalmente chamado de chamadas de sistema (system calls).
O Sistema Operativo não funciona como aplicações comuns, formados

de início, meio e fim. Os procedimentos do sistema são executados
concorrentemente sem seguir uma ordem, com base em eventos
assíncronos.
Projectar um Sistema Operativo é uma tarefa árdua e altamente

importante, onde, em fase de projecto, devem-se definir todos os
objectivos do sistema como um todo. As principais funções de um
Sistema Operativo, presentes praticamente em todos os SO, podem ser
mencionados como:
24
▪
Gestão de Processos - Um programa nada faz, a menos que
suas instruções sejam executadas por uma CPU. Um programa
em execução, como mencionado, é um processo. Um programa
de processamento de texto, sendo executado por um usuário
individual em um PC, é um processo. Uma tarefa do sistema,
como o envio de saída para uma impressora, também pode ser
um processo (ou pelo menos parte de um processo). Por
enquanto, você pode considerar um processo como uma tarefa
ou um programa de tempo compartilhado.
▪
Gestão da Memória - A memória é um repositório de dados
rapidamente acessáveis compartilhado pela CPU e dispositivos
de entrada/ saída (E/S). O processador central lê instruções na
memória, durante o ciclo de busca de instruções, e lê e grava
dados a partir da memória, durante o ciclo de busca de dados
(em uma arquitetura Von Neumann). A memória costuma ser o
único grande dispositivo de armazenamento que a CPU
consegue endereçar e acessar directamente. Por exemplo, para
a CPU processar dados do disco, primeiro esses dados devem
ser transferidos para a memória por chamadas de E/S geradas
pela CPU. Da mesma forma, as instruções devem estar na
memória para a CPU executá-las.
▪
Gestão de Arquivos – A gestão de arquivos é um dos
componentes mais visíveis de um sistema operativo. Os
computadores podem armazenar informações em vários tipos
diferentes de mídia física. Disco magnético, disco óptico e fita
magnética são os mais comuns. Todas essas mídias têm suas
próprias características e organização física. Cada mídia é
controlada por um dispositivo, tal como um drive de disco ou de
fita, que também tem características próprias. Essas propriedades
incluem velocidade de acesso, capacidade, taxa de transferência
de dados e método de acesso (sequencial ou randômico). Um
arquivo é um conjunto de informações relacionadas definido por
seu criador. Normalmente, os arquivos representam programas (em
ambas as formas, fonte e objecto) e
25
dados. Arquivos de dados podem ser numéricos, alfabéticos,

alfanuméricos ou binários. Os arquivos podem ter formato livre
(por exemplo, arquivos de texto) ou podem ser formatados
rigidamente (no caso de campos fixos).
▪
Gestão dos dispositivos de entrada e saída - As duas tarefas
principais de um computador têm haver com os dispositivos E/S e
processamento. Por exemplo, quando navegamos em uma página
da web ou editamos um arquivo, nosso interesse imediato é ler ou
dar entrada em alguma informação, e não computar uma resposta.
O papel do sistema operativo no E/S do computador é gerir e
controlar operações e dispositivos de E/S.
Cada parte citada pode ser uma porção bem delineada do sistema,
com entradas, saídas e funções bem definidas, o que facilita o seu
estudo e detalhamento. Ao longo deste Modulo, iremos abordar cada
uma das funções que compõe o Sistema Operativo, referenciado acima.
1.5.1. Chamadas de Sistemas

As chamadas de sistemas (system calls) constituem a interface entre um
programa do usuário e o Sistema Operativo. Elas podem ser entendidas
como uma porta de entrada para acesso ao núcleo do sistema, que contém
suas funções. Sempre que o usuário necessitar de algum serviço, o solicita
através de uma chamada de sistema definida e específica.
Cada serviço disponível por um determinado Sistema Operativo possui

uma chamada de sistema associada e cada SO possui seu próprio
conjunto de chamadas (nomes, parâmetros e formas de ativação
específica). As chamadas de sistemas, de facto, servem também para
proteger o núcleo do Sistema Operativo, tentando impedir que um
determinado programa realize alguma operação que altere a
integridade do sistema.
Sumário
Na Unidade temática 1. Abordarmos o conceito de um Sistema Operativo

partindo da visão de uma máquina estendida, que procura esconder a
complexidade de hardware para o usuário e da visão de um
26
gestor de recursos, que procura gerir todos os recursos disponíveis pelo

Sistema Computacional. Também abordamos o histórico dos Sistemas
Operacionais, mostrando sua evolução durante os anos, sempre
acompanhado da evolução dos Sistemas Computacionais. Onde tratamos
de classificar os Sistemas Operacionais bem como são estruturados.
Exercícios de AUTO-AVALIAÇÃO
Perguntas
1. Defina o Sistema Operativo sob o ponto de vista duma Máquina
Estendida.
2. Por quem e quando foi projectado o primeiro computador digital.
3. Classifica os Sistemas Operativos.
4. Quanto a forma como se classificam os sistemas
multiprogamáveis.
5. Quais são as principais funções de um Sistema
Operativo. Respostas:
1. Rever página 10 á 11.
3. Rever página 20.
Exercícios para AVALIAÇÃO
Perguntas
1. Quais os objectivos de um sistema Operativo.
2. Sobre a história dos Sistemas Operativos, qual foi o ponto mais
alto da evolução, justifique a sua resposta.
3. Como se classificam os sistemas multiprogramáveis quanto ao
número de usuários que interagem com o sistema.
4. Fale do sistema de tempo compartilhado.
Bibliografia
▪
DEITELL, H. M. & DEITEL, P. J. & CHOFFNES, D. R. Sistemas Operacionais.
São Paulo, Ed. Prentice Hall, 2005.
▪
OLIVEIRA, R. S. e CARISSIMI, A. S. e TOSCANI, S. S. istemas Operacionais.
3ª ed, volume 11, Ed. Bookman, 2008.
▪
SILBERSCHATZ, A. & GALVIN, P. B. & GAGNE, G. Fundamentos de
Sistemas Operacionais. 6ª Edição, Ed. LTC.
27
▪
SILBERSCHATZ, A. & GALVIN, P. B. & GAGNE, G. Sistemas
Operacionais com Java. 7ª Edição, Rio de Janeiro, Ed.
Elsevier,2008.
▪
TANENBAUM, A. S. & WOODHULL, A. S. Sistemas Operacionais:
Projeto e Implementação. 3ª Edição, Porto Alegre, Ed. Bookman,
2008
▪
Abraham, S.&Peter B. G., & Greg, G. Operating system concepts ninth
edition, 2013
▪
TANENBAUM, A. & Herbert, B., Modern Operating Systems, Fourth
Edition, 2015
▪
Jandl, Peter, Jr. Notas sobre Sistemas Operacionais, 2004
28
TEMA – 2: GESTÃO DE PROCESSOS.
UNIDADE Temática 2.1. Introdução a Gestão de Processos.

UNIDADE Temática 2.2. Comunicação Interprocessos.
UNIDADE Temática 2.3. Problemas Clássicos de IPC
UNIDADE Temática 2.4. Escalonamento de Processos
UNIDADE Temática 2.5. EXERCÍCIOS deste tema
▪
Definir o conceito de processo; Descrever as diversas características de
processos como a criação e manutenção; Descrever o conceito e os benefícios
de threads.
Objectivos
específicos ▪
Descrever o objectivo da Comunicação Interprocessos; Mostrar como essa
comunicação é feita.
▪
Apresentar problemas que servem como ambiente de aplicação de novos
métodos de Comunicação Interprocessos.
▪ Descrever como alocar a CPU vários processos para serem executados.
UNIDADE Temática 2.1. Introdução a Gestão de Processos
Os primeiros sistemas operativos eram caracterizados por apenas um

programa poder ser executado de cada vez. Com a evolução dos
computadores os sistemas operativos passaram a ter capacidade de
executar várias tarefas ao mesmo tempo. De facto, o processador pode
ser alternado de um programa para o outro, executando cada um por
um determinado tempo (geralmente em milissegundos). Isto significa
que, para um determinado intervalo de tempo, vários programas
utilizam uma fatia desse tempo para realizar suas actividades,
passando para o usuário a falsa ideia de que todos os programas
estão sendo executados ao mesmo tempo. Essa falsa ideia passada ao
usuário de que vários programas estão sendo executados ao mesmo
tempo é geralmente conhecido por pseudoparalelismo.
Segundo Abraham, essa evolução exigiu controle mais firme e maior

compartimentalização dos diversos programas, e essas necessidades
resultaram no conceito de processo que é um programa em execução.
Quanto mais complexo é o sistema operativo, mais se espera que ele
funcione em benefício de seus usuários. Embora sua principal
29
preocupação seja a execução de programas de usuário, ele também

precisa se encarregar de várias tarefas do sistema, que ficam melhor
fora do próprio kernel. Consequentemente, um sistema é composto por
um conjunto de processos: processos do sistema operativo executando
código de sistema e processos de usuário executando código de
usuário. Possivelmente, todos esses processos podem ser executados
simultaneamente, com a unidade central de processamento (CPU ou
CPUs) multiplexada entre eles. Alternando a CPU entre os processos, o
sistema operativo pode tornar o computador mais produtivo. Nesta
unidade temática, falaremos sobre o que são processos e o seu
funcionamento.
2.1.1. Conceito de Processo
Um processo pode ser entendido como uma actividade que ocorre em

meio computacional, usualmente possuindo um objectivo definido, tendo
duração finita e utilizando uma quantidade limitada de recursos
computacionais.
Esta definição traz algumas implicações: apenas as actividades que

acontecem num sistema computacional são compreendidas como sendo
processos computacionais. Outro ponto importante é a duração finita, pois
isto implica que um processo computacional, por mais rápido ou curto que
possa ser tem sempre uma duração maior que zero, ou seja, não existem
processos instantâneos. Além disso, um processo utiliza ao menos um dos
recursos computacionais existentes para caracterizar seu estado.
Simplificando, podemos entender que um processo é mais do que o

código do programa, que também é conhecido como secção de texto.
Ele também inclui a atividade corrente, conforme representada pelo
valor do contador do programa e o conteúdo dos registradores do
processador. Geralmente, um processo também inclui a pilha do
processo que contém dados temporários (como parâmetros de funções,
endereços de retorno e variáveis locais), e uma secção de dados, que
contém variáveis globais. Um processo também pode incluir um heap,
que é a memória dinamicamente alocada durante o tempo de
execução do processo. A estrutura de um processo na memória é
mostrada na Figura 2.1.
30
máx
Pilha
heap
dados
texto
0
Figura 2.1: Processo na memória
É de salientar que um programa por si só não é um processo. Um

programa é uma entidade passiva, como um arquivo contendo uma lista
de instruções armazenadas em disco (geralmente chamado de arquivo
executável). Por outro lado, um processo é uma entidade activa, com um
contador de programa especificando a próxima instrução a ser executada
e um conjunto de recursos associados. Um programa torna-se um processo
quando um arquivo executável é carregado na memória. Duas técnicas
comuns para o carregamento de arquivos executáveis são clicar duas
vezes em um ícone representando o arquivo executável ou dar entrada no
nome do arquivo executável na linha de comando (como em prog.exe ou
a.out). Embora dois processos possam estar associados ao mesmo
programa, ainda assim eles são considerados duas sequências de
execução separadas. Por exemplo, vários usuários podem estar
executando diferentes cópias do programa de e-mail ou o mesmo usuário
pode invocar muitas cópias do programa de navegação na web. Cada
uma delas é um processo separado e, embora as seções de texto sejam
equivalentes, os dados, o heap e as seções de pilha variam. Também é
comum haver um processo que gera muitos processos ao ser executado.
2.1.2. Criação de Processos

Os processos, na maioria dos sistemas, podem ser executados
concorrentemente e podem ser criados e excluídos dinamicamente.
Portanto, esses sistemas devem fornecer um mecanismo para a criação
e o encerramento de processos. Durante o progresso de execução, um
31
processo pode criar vários processos novos. O processo criador é

chamado processo-pai, e os novos processos são chamados filhos desse
processo. Por sua vez, cada um desses novos processos pode criar
outros processos, formando uma árvore de processos. A maioria dos
sistemas operacionais (incluindo o UNIX, o Linux e o Windows) identifica
os processos de acordo com um identificador de processo (PID)
exclusivo que, normalmente, é um número inteiro.
Pai
Pid =1
Filho Filho Filho

Pid =2 Pid =3 Pid =4
Filho Filho Filho

Pid =121 Pid =43 Pid =543
Figura 2.2: Árvore de um Processo

2.1.3. Estado do Processo
Quando um processo é executado, ele muda de estado durante sua
execução. O estado de um processo é definido, em parte pela
actividade corrente do processo. Dessa forma, um processo pode estar
no Sistema Operativo (SO) em um dos seguintes estados:
▪
Novo: o processo esta sendo criado.
▪
Em execução: instruções estão sendo executados. Um processo
está em execução quando ele, de facto, está sendo processado
pela CPU. Em sistemas monos processados (único processador),
somente um processo de cada vez pode estar na posse da CPU
em um dado instante. Os processos se alternam na utilização do
processador.
▪
Em espera: um processo está em espera quando ele aguarda por
algum evento externo ou por algum recurso do sistema indisponível
no momento. Por exemplo, se um processo necessita de uma
informação de algum dispositivo de entrada/saída (E/S)
32
(como a conclusão de E/S ou recebimento de um sinal), enquanto

essa informação não se torna disponível, o processo entra em
espera.
▪
Pronto: um processo está pronto quando ele possui todas as
condições necessárias para a sua execução, porém, não está na
posse do processador. Em geral, existem vários processos no
sistema prontos para serem executados e o Sistema Operativo é
responsável por essa lista de processos, selecionar qual o
processador a utilizar em um determinado instante de tempo.
▪
Encerrado: o processo terminou sua execução.
Esses nomes são arbitrários e variam entre os sistemas operativos. No

entanto, os estados que eles representam são encontrados em todos os
sistemas. Certos sistemas operacionais também descrevem, mais
apuradamente, os estados do processo. É importante saber que apenas
um processo pode estar em execução em algum processador a cada
instante. Mas muitos processos podem estar prontos e em espera.
Durante o ciclo de vida de um processo, isto é, desde seu início até seu
encerramento, podem ocorrer diversas transições entre os estados
relacionados, como ilustra a Figura 2.3.
novo admitido saída encerrado

interrupção
pronto em execução
conclusão de E/S despacho do espera por E/S

ou evento programa ou evento
Em espera
Figura 2.3: Diagrama de estado de um processo
Quando solicitamos a execução de um programa, o sistema operativo

cria um novo processo atribuindo a este um número de identificação ou
seu PID (Process Identifier), um valor inteiro que servirá para distinguir
33
este processo dos demais. Após a criação, o processo é colocado no final

de uma fila onde existem apenas processos prontos, ou seja, o estado
inicial de um processo é definido como sendo o estado Pronto. Quando
todos os processos existentes nesta fila, ou seja, criados anteriormente, já
tiverem utilizado seu quantum (fração de tempo do processador), o sistema
operativo acionará uma rotina especial para despachar o processo, ou
seja, para efectivamente colocar o processo em execução. Nesta situação
ocorrerá uma transição do estado do processo de Pronto para Execução.
Quando a fração de tempo destinada ao processo se esgotar, ocorrerá
uma interrupção que devolverá o controle para o sistema operativo, para
retirar o processo do processador e recolocá-lo na fila de processos
prontos. Esta é transição do estado Execução para o estado Pronto. Nos
casos em que o processo deseje utilizar algum dispositivo de E/S, ou seja,
efetuar uma operação de E/S, na solicitação deste recurso o próprio
processo sairá do estado de Execução entrando voluntariamente no
estado Espera pela disponibilidade do recurso solicitado. Ao finalizar o
uso do recurso, o sistema operativo recolocará o processo na lista de
processos prontos, o que faz com que o processo passe do estado Espera
para Pronto. Devemos destacar que a transição do estado Execução para
Espera é a única causada pelo próprio processo, isto é, voluntária,
enquanto as demais são causadas por agentes externos (entidades do
sistema operativo). Outro ponto importante é que os estados Pronto e
Execução são estados considerados activos enquanto que o estado Espera
é tido como inactivo.
2.1.4. Tabelas de Processos

Quando o modelo de administração de processos é adoptado em um
sistema operativo, para que este possa efectivamente controlar os
processos existentes em um sistema, é comum a criação e manutenção de
uma tabela para a organização das informações relativas aos processos
chamada de tabela de processos. Esta tabela é usualmente implementada
sob a forma de um vector de estruturas ou uma lista ligada de estruturas.
Para cada processo existente existe uma entrada correspondente nesta
tabela, ou seja, um elemento da estrutura destinado a armazenar os dados
relativos ao respectivo processo. Tal estrutura, projetada para armazenar
as informações, recebe o nome de
34
BLOCO DE CONTROLE DE PROCESSO (PCB). O PCB contém todas as

informações necessárias para a execução do mesmo possa ser iniciada,
interrompida e retornada conforme determinação do sistema operativo,
sem prejuízo para o processo. Apesar de ser dependente do projecto e
implementação particulares do sistema operativo, geralmente o PCB
contém as seguintes informações:
▪
Estado do processo: o estado pode ser novo, pronto, em
execução, em espera, parado, e assim por diante.
▪
Contador do programa: o contador indica o endereço da
próxima instrução a ser executada para esse processo.
▪
Registradores da CPU: os registradores variam em número e
tipo, dependendo da arquitetura do computador. Eles incluem
acumuladores, registrador índice, ponteiros de pilhas e
registradores de uso geral, além de qualquer informação do
código de condição. Junto com o contador do programa, essas
informações de estado devem ser salvas quando ocorre uma
interrupção, para permitir que o processo seja retomado
corretamente mais tarde.
▪
Informações de scheduling da CPU: essas informações incluem
a prioridade de um processo, ponteiros para filas de scheduling
e quaisquer outros parâmetros de scheduling.
▪
Informações de gerenciamento da memória: essas informações
podem incluir itens como o valor dos registradores base e limite
e as tabelas de páginas, ou as tabelas de segmentos,
dependendo do sistema de memória usado pelo sistema
operativo.
▪
Informações de contabilização: essas informações incluem o
montante de tempo real e de CPU usados, limites de tempo,
números de conta, números de jobs ou processos, e assim por
diante.
▪
Informações de status de E/S: essas informações incluem a lista
de dispositivos de E/S alocados ao processo, uma lista de
arquivos abertos, e assim por diante.
35
estado do processo
número do processo
contador do programa
registadores
limites da memória
lista de arquivos abertos
...
Figura 2.4: Diagrama de estado de um processo
Resumindo, o PCB serve, simplesmente, como o repositório de quaisquer

informações que possam variar de um processo para outro.
2.1.4. Threads
Um thread é uma unidade básica de utilização da CPU; é composto por
um ID de thread, um contador de programa, um conjunto de registradores
e uma pilha. Um thread compartilha, com outros threads pertencentes ao
mesmo processo, sua seção de código, a seção de dados e outros recursos
do sistema operativo, como arquivos abertos e sinais. Um processo
tradicional (ou processo pesado) tem um único thread de controle. Se um
processo tem múltiplos threads de controle, ele pode executar mais de uma
tarefa ao mesmo tempo. A Figura 2.5 ilustra a diferença entre um processo
tradicional com um único thread e um processo multithreads. A maioria das
aplicações de software executadas em computadores modernos é
multithreads. Uma aplicação é implementada, tipicamente, como um
processo separado com diversos threads de controle. Por exemplo um
navegador web pode ter um thread para exibir imagens ou texto,
enquanto outro thread recupera dados da rede. Um processador de textos
pode ter um thread para exibir elementos gráficos, outro para responder
ao uso do teclado pelo usuário, e um terceiro para executar a verificação
ortográfica e gramatical em background.
Em certas situações, uma única aplicação pode ser chamada a executar

várias tarefas semelhantes. Por exemplo, um servidor web aceita
solicitações de clientes de páginas web, imagens, som, e assim por diante.
36
Um servidor web ocupado pode ter diversos (talvez milhares de)

clientes que o acessem concorrentemente. Se o servidor web operasse
como um processo tradicional com um único thread, ele seria capaz de
atender a apenas um cliente de cada vez, e um cliente poderia precisar
esperar por muito tempo para ter sua solicitação atendida. É de
salientar que a maioria dos kernels dos sistemas operativos são, agora,
multithreaded. Múltiplos threads operam no kernel e cada thread
executa uma tarefa específica, como a gestão de dispositivos, a gestão
da memória ou a manipulação de interrupções. Por exemplo, o Solaris
tem um conjunto de threads no kernel especificamente para a
manipulação de interrupções; o Linux usa um thread do kernel para
gerir o montante de memória livre no sistema.
Processo com único thread Processo com múltiplos threads

Figura 2.5: Processos com único e múltiplos threads
(2) cria novo thread

(1) solicitação para atender a
solicitação
cliente servidor thread
(3) volta a escutar

solicitações adicionais
de cliente
Figura 2.6: Servidor com múltiplos threads
37
2.1.4.1. Benefícios
Os benefícios da programação com múltiplos threads podem ser
divididos em quatro categorias principais:
1. Capacidade de resposta: tornar uma aplicação interativa

multithreaded pode permitir que um programa continue a ser
executado, mesmo que parte dele esteja bloqueada ou
executando uma operação demorada, o que aumenta a
capacidade de resposta para o usuário. Essa qualidade é
particularmente útil no projecto de interfaces de usuário. Por
exemplo, considere o que ocorre quando um usuário clica em um
botão que causa a execução de uma operação demorada. Uma
aplicação com um único thread deixaria de responder ao
usuário até que a operação fosse concluída. Por outro lado, se a
operação demorada for executada em um thread separado, a
aplicação continuará respondendo ao usuário.
2. Compartilhamento de recursos: os processos só podem

compartilhar recursos por meio de técnicas como memória
compartilhada e transmissão de mensagens. Essas técnicas
devem ser organizadas explicitamente pelo programador. No
entanto, por default, os threads compartilham a memória e os
recursos do processo ao qual pertencem. O benefício de
compartilhar código e dados é que isso permite que uma
aplicação tenha múltiplos threads de atividade diferentes
dentro do mesmo espaço de endereçamento.
3. Economia: a alocação de memória e recursos para a criação

de processos é dispendiosa. Já que os threads compartilham os
recursos do processo ao qual pertencem, é mais econômico criar
threads e permutar seus contextos. Pode ser difícil avaliar
empiricamente a diferença de overhead, mas, em geral, é
significantemente mais demorado criar e gerir processos do que
threads.
4. Escalabilidade: os benefícios da criação de múltiplos threads

podem ser ainda maiores em uma arquitetura multiprocessadores,
em que os threads possam ser executados em paralelo em
38
diferentes núcleos de processamento. Um processo com um único

thread só pode ser executado em um processador,
independentemente de quantos estiverem disponíveis.
UNIDADE Temática 2.2. Comunicação Interprocessos
Em um Sistema Operativo geralmente os processos podem precisar

trocar informações entre si ou podem solicitar a utilização de um mesmo
recurso simultaneamente como, arquivos, registros, dispositivos de E/S e
memória. O compartilhamento de recursos entre vários processos pode
causar situações indesejáveis e, dependendo do caso, gerar o
comprometimento da aplicação. O Sistema Operativo tem a função de
gerir e sincronizar processos concorrentes, com o objetivo de manter o
bom funcionamento do sistema.
2.2.1. Condições Corrida

Uma condição de Corrida pode ser definida quando dois ou mais
processos podem compartilhar algum espaço de memória
compartilhado no qual, o resultado da informação deste espaço de
armazenamento depende de quem executa e precisamente quando. Um
exemplo típico de condição de corrida, apontado por vários autores, é
o spool de impressão.
Quando um processo deseja imprimir alguma informação, ele insere o

nome de arquivo em um espaço denominado diretório de spooler. Existe
outro processo, o servidor de impressão, que verifica periodicamente se há
qualquer arquivo a ser impresso e, caso haja, ele os imprime e remove a
informação do diretório. Consideremos a seguinte situação: o diretório de
spooler contém um número de entradas numeradas e um processo, quando
deseja imprimir alguma informação, consulta uma variável (entrada) a fim
de saber em qual posição inserir o nome de arquivo no diretório. A Figura
2.7, ilustra o diretório de impressão.
39
Diretório de impressão
Entrada 0
1
2
3
4
..
.
Figura 2.7: Diretório de spooler (impressão)
Podemos imaginar agora a seguinte situação: um processo A lê a variável

entrada e armazena o valor dela (valor 0) em uma variável local. Porém,
o tempo de execução do processo A termina e o Sistema Operativo o
retira do processador, disponibilizando-o a um outro processo B.
O processo B, por sua vez, também deseja imprimir um arquivo, acessa

a área do diretório de impressão, verifica o valor da variável entrada
(valor 0), armazena este valor em uma variável local e, por fim, insere
o nome de seu arquivo a ser impresso na posição 0 do diretório de
impressão, mudando o valor da variável entrada para 1. A Figura 2.8
visualiza esta situação actual.
0 Arquivo B
Entrada 1
4
..
.
Figura 2.8: Situação do diretório de impressão após inserção do nome

do
arquivo do processo B
Por fim, o processo A retoma o processador, iniciando novamente de onde

parou. Ao examinar em sua variável local o valor da variável entrada
(esta informação ele guardou em sua tabela, momento em que ele parou a
execução), o processo observa o valor 0 e escreve seu nome
40
de arquivo nessa posição, apagando o nome de arquivo do processo B.

Em seguida, incrementa o valor da variável entrada para 1. A Figura
2.9 mostra a nova situação do servidor de impressão.
0 Arquivo A
Entrada 1
4
..
.
Figura 2.9: Situação do diretório de impressão após inserção do nome

do
arquivo do processo A
Internamente, o servidor de impressão continua consistente, porém o

arquivo do processo B jamais será impresso. Caracterizamos este tipo
de situação como uma condição de corrida.
2.2.2. Seções Críticas

Para se evitar uma condição de corrida é preciso definir métodos que
proíba que mais de um processo acesse uma determinada área de
memória compartilhada ao mesmo tempo. Esses métodos são conhecidos
como exclusão mútua. Um processo, durante seu tempo de execução,
pode realizar uma série de computações internas que não geram
condições de corrida ou pode estar acessando memória compartilhada,
que levam à condição de corrida. A parte do programa no qual o
processo acessa memória compartilhada é chamada seção crítica ou
região crítica. Dessa forma, a solução para se evitar uma condição de
corrida seria organizar os problemas de tal forma que nenhum de dois
ou mais processos estivessem em suas regiões críticas ao mesmo tempo.
Para se ter uma boa solução de exclusão mútua, precisamos evitar
algumas situações indesejáveis, como:
▪
Dois processos jamais podem estar simultaneamente dentro de
suas regiões críticas.
▪
Nenhuma suposição pode ser feita a respeito de velocidades ou
41
do número de CPUs.
▪
Nenhum processo que esteja fora de sua região crítica pode
bloquear a execução de outro processo.
▪
Nenhum processo deve esperar indefinidamente para poder
entrar em sua região crítica.
2.2.3. Exclusão Mútua com Espera Ativa

Mostraremos várias propostas para realizar a exclusão mútua, de
maneira que enquanto um processo está ocupado actualizando a
memória compartilhada em sua região crítica, nenhum outro entrará na
sua região crítica para causar problemas.
2.2.3.1. Desativando Interrupções

Uma simples solução de exclusão mútua seria desativar todas as
interrupções do sistema quando um processo fosse acessar sua região
crítica, activando-as imediatamente após sair dela. Com as interrupções
desativas, nenhuma interrupção de relógio pode ocorrer e, naturalmente, o
processador não poderá alternar entre processos, garantindo que nenhum
outro processo irá executar sua região crítica. Esta abordagem
é funcional, porém, pouco atraente, pois compromete o nível de
segurança do sistema. Caso as interrupções, por algum motivo, não
sejam novamente activadas, todo o sistema estará comprometido. Outro
problema deste método está em torno de sistemas com mais de um
processador, pois, desativar as interrupções irá afectar apenas um
processador. Com outros processadores livres, outros processos poderão
executar e, ocasionalmente, acessar suas regiões críticas, tornando este
método ineficaz.
2.2.3.2. Variáveis de Bloqueio

Outra solução de exclusão mútua seria utilizar variáveis de bloqueio
(solução de software). A solução de variável de bloqueio consiste de uma
única variável compartilhada (bloqueio). Quando um processo desejar
acessar sua região crítica, ele inspeciona a variável de bloqueio. Caso a
variável esteja definida com valor 0 (bloqueio livre), o processo define seu
valor para 1 e acessa livremente sua região crítica. Se a variável estiver
definida com valor 1, o processo deve esperar até ela se tornar
42
0. Essa ideia gera o mesmo problema visto no directório de impressão.

Suponha que o processo A testa o bloqueio e verifica que ele tem o valor
0. Porém, antes de definir o seu valor para 1, outro processo é
selecionado para utilizar o processador. Este novo processo testará o
bloqueio, verifica que o seu valor é 0, modifica para 1 e acessa sua
região crítica. O processo. A, quando retomar o processador, ele
também definirá a variável de bloqueio para 1 (no momento que ele
parou, ele já tinha verificado o seu valor, no momento, definido como 0)
e acessa sua região crítica. Sendo assim, teremos dois processos
acessando suas regiões críticas simultaneamente.
2.3.3. Alternância Estrita

Uma outra abordagem de exclusão mútua é a alternância estrita. Esta
abordagem utiliza uma variável de bloqueio, que serve para indicar qual
processo irá entrar em sua região crítica. Vamos analisar este método
através do trecho em pseudo-linguagem apresentado a seguir:
Processo A Processo B
Enquanto(VERDADEIRO){ Enquanto(VERDADEIRO){
Enquanto(bloqueio ≠0); Enquanto(bloqueio≠1);
//espera //espera
Região_crítica_A; Região_crítica_B;
Bloqueio = 1; Bloqueio = 0;
Região_não_crítica_A; Região_não_crítica_B;
} }
Como podemos eerificar através dos algoritmos, que quando o processo A

desejar entrar em sua região crítica, primeiramente, ele testa o bloqueio.
Caso o bloqueio esteja com valor 0, o processo A passa o loop (enquanto),
acessando sua região crítica. Caso o processo B desejar entrar em sua
região crítica e testar o bloqueio, irá verificar que o valor consta como 0 e
ficará preso no laço enquanto, não podendo entrar em sua região crítica.
O processo. A, ao sair da sua região crítica, irá definir o valor 1 para a
variável de bloqueio, passando a executar sua região
43
não crítica. Nesse ponto, o processo B terá caminho livre para acessar
sua região crítica.
Agora vamos supor a seguinte situação: o processo A deseja acessar sua

região crítica, testa o bloqueio e verifica que tem permissão (valor 0). O
processo, assim, acessa sua região crítica, executa sua actividade, sai da
região crítica, define o valor do bloqueio para 1 e começa a acessar sua
região não-crítica. Nesse momento, o processo B testa o bloqueio, verifica
que tem permissão, acessa sua região crítica, executa suas actividades
críticas, sai da região crítica, define o bloqueio para 1 e começa a acessar
sua região não-crítica. Porém, o processo B executa em sua região não
crítica rapidamente e, novamente, precisa entrar em sua região não crítica.
Porém, ele não terá acesso, pois a variável de bloqueio está com valor 0,
mesmo o processo A não estando executando em sua região crítica. Essa
situação viola uma das condições para se ter uma boa solução de exclusão
mútua, que define que nenhum processo que não esteja em sua região
crítica pode bloquear outro processo. No caso apresentado, o processo A,
mesmo não executando em sua região crítica, bloqueia o processo B, que
deseja entrar em sua região crítica.
2.2.3.4. A Solução de Peterson

Ao combinar a ideia de alternar a vez com a ideia das variáveis de
trava e de advertência, um matemático holandês, Dekker, foi o
primeiro a desenvolver uma solução de software para o problema da
exclusão mútua que não exige uma alternância explícita. Em 1981,
Peterson descobriu uma maneira muito mais simples de realizar a
exclusão mútua, tornando assim a solução de Peterson. Este algoritmo
apresenta uma solução para dois processos que pode ser facilmente
generalizada para o caso de N processos. Este algoritmo se baseia na
definição de duas primitivas, utilizadas pelos processos que desejam
utilizar sua região crítica. Essas primitivas, como podem ser visualizadas
no trecho de código a seguir (linguagem de programação C), são as
funções entrar_regiao() e sair_regiao(), que são utilizadas pelos
processos para, respectivamente, entrarem em sua região crítica e sair
de sua região crítica.
44
#define FALSO 0
#define VERDADE 1
#define N 2
int bloqueio;
int interesse[N];
void entrar_regiao(int processo){

int outro = 1 – processo;
interesse[processo] = VERDADE;
bloqueio = processo;
while(bloqueio == processo && interesse[outro] == VERDADE);
//espera
void sair_regiao(int processo){
interesse[processo] = FALSO;
Podemos verificar através do código apresentado, que quando o

processo A desejar entrar em sua região crítica, ele chamará a função
entrar_regiao() passando seu identificador (int processo, com valor 0)
para a função. Nesta função, a variável outro será definido com valor
1, o vetor de interesse, posição 0 (do processo), terá valor VERDADE e
a variável bloqueio será definido para o valor do identificador do
processo, no caso, valor 0. Ao chegar no loop while (enquanto), será
testado se o bloqueio (valor 0) é igual ao identificador do processo e
se o vetor de interesse, na posição do outro, tem valor VERDADE. No
caso apresentado, o valor do vetor interesse, posição outro, não será
valor VERDADE e o processo 0 não ficará preso ao loop, saindo da
função e, naturalmente, podendo entrar em sua região crítica.
Suponhamos que o processo B também tem interesse de entrar em sua

região crítica, chamando a função entrar_regiao() e passando seu
identificador para a função (int processo, com valor 1).
45
Nesse caso, ele definirá que a sua variável outro terá valor 0, que o
vetor interesse, posição 1, terá valor VERDADE e a variável bloqueio
será definido com o valor 1. Ao chegar no laço while, o processo 1 irá
verificar que o vetor de interesse, na posição outro (valor 0), será
VERDADE (processo 0), ficando, assim, preso no laço. Dessa forma, o
processo 1 não poderá acessar sua região crítica. O processo 0,
quando sair de sua seção crítica irá chamar a função sair_regiao(),
passando seu identificador como parâmetro para a função (int
processo, com valor 0). Nesta função, o vetor de interesse, na posição
do processo, receberá valor FALSO. Assim, o processo 1, que estava
preso no loop pois o valor do vetor interesse, posição 0, tinha valor
VERDADEIRO, agora poderá sair do laço e acessar sua região crítica.
2.2.4. Problema dos Produtores e Consumidores

O problema dos produtores e consumidores é muito comum em programas
concorrentes, no qual exista um processo que produz continuamente
informações que serão usadas por outro processo. Esta informação
produzida e consumida pode ser um número, string, registro ou qualquer
outro tipo. Entre o processo que produz a informação (produtor) e o
processo que consome a informação (consumidor) existe um espaço de
memória (buffer) que serve para armazenar temporariamente as
informações que ainda não foram consumidas. O problema surge quando
o productor deseja inserir um novo item, porém o buffer está cheio. De
forma análoga, caso o consumidor deseje consumir alguma informação e o
buffer estiver vazio. A solução para este problema pode ser através de
duas primitivas, conhecidas como sleep (dormir) e wakeup (acordar). Para
o problema dos produtores e consumidores, caso o buffer esteja vazio, o
consumidor pode ser colocado para dormir, através da primitiva sleep e,
de forma análoga, o produtor pode ser colocado para dormir, caso o
buffer esteja cheio. Quando uma informação for produzida, o consumidor
poderá ser acordado pelo produtor através da primitiva wakeup. De
forma análoga, o produtor pode ser acordado pelo consumidor caso uma
informação seja retirada do buffer cheio. Esta situação conduz à condição
de corrida do servidor de impressão vista anteriormente. Supondo que é
utilizada uma variável N para poder monitorar a quantidade de
informações no buffer. Assim,
46
quando o valor de N for a quantidade máxima do buffer, o produtor é

colocado para dormir. Da mesma forma, quando o valor de N for zero,
o consumidor é colocado para dormir. Agora imaginemos a seguinte
situação: o buffer encontra-se vazio e o consumidor acabou de ler a
variável N para ver se ele é zero. Nesse momento, o processador é
tomado do consumidor e passado para o produtor. O produtor realiza
sua actividade, produzindo uma informação e incrementa o valor de N
para 1. Considerando que o valor de N era zero, o produtor chama a
primitiva wakeup para acordar o consumidor (presumindo que ele
estava dormindo). Contudo, o consumidor não estava dormindo e o sinal
de wakeup é perdido. Quando o consumidor volta a utilizar a CPU, ele
testará o valor de N anteriormente lido, verificando que se trata de
valor zero e, por fim, passa a dormir. O produtor, cedo ou tarde, irá
encher o buffer com informações produzidas e também irá dormir.
Ambos dormirão para sempre.
2.2.5. Semáforos
O problema dos produtores e consumidores, além dos vários problemas de
sincronização entre processos, pode ser resolvido através de uma solução
conhecida por semáforos. Ele foi proposto por Dijkstra em 1965. O
semáforo é um tipo abstrato de dado composto por um valor inteiro e uma
fila de processos. Dijkstra propôs existir duas operações básicas sobre
semáforos: operação de testar e a operação de incrementar. Vários
autores utilizam nomenclaturas diferentes para representar essas
operações: DOWN e UP (Tanenbaum), wait e signal (Silberschatz) e P e V,
originalmente designadas, que vem do holandês Proberen (testar) e
Verhogen (incrementar). Quando um processo executa a operação P sobre
um semáforo, o seu valor inteiro é decrementado. Se o valor do semáforo
for negativo, o processo é bloqueado e inserido no fim da fila desse
semáforo. Quando um processo executa a operação V sobre um semáforo,
o seu valor inteiro é incrementado. Caso exista algum processo bloqueado
na fila, o primeiro processo é liberado. Para que a solução através de
semáforos funcione corretamente suas operações são feitas como uma
única e indivisível acção atômica, ou seja, uma vez que uma operação
sobre semáforos comece, ela não pode ser interrompida no meio e
nenhuma outra operação sobre o semáforo deve ser começada.
47
Dessa forma, para utilizar a solução em uma aplicação que gere uma
condição de corrida basta que, para cada estrutura de dados
compartilhada, seja utilizado um semáforo. Todo processo antes de
acessar essa estrutura deve realizar uma operação de teste do semáforo
(P). Ao sair da seção crítica, o processo deve realizar uma operação V
sobre o semáforo.
UNIDADE Temática 2.3. Problemas Clássicos de Comunicação Interprocessos (IPC)
A literatura de Sistemas Operativos está repleta de problemas que servem

como ambiente de aplicação de novos métodos de comunicação
interprocessos (IPC). Segundo Tanenbaum, todo mundo que resolvia
inventar algum método para solucionar problemas de sincronização entre
processos sentia-se obrigado a demonstrar o quão maravilhoso o seu
método era, aplicando sobre um desses problemas clássicos e mostrando o
quão elegantemente seu método resolvia. Mostraremos dois problemas
clássicos de comunicação interprocessos conhecidos como: Problema do
jantar dos filósofos e o problema do barbeiro adormecido.
2.3.1. Problema do Jantar dos Filósofos

O problema do Jantar dos Filósofos foi proposto e resolvido por
Dijkstra em 1965. O problema foi modelado da seguinte forma:
▪
Cinco filósofos sentados ao redor de uma mesa circular, que
contém cinco pratos de espaguete e cinco garfos.
▪
Entre cada prato de espaguete encontra-se um garfo.
▪
Para comer, um filósofo precisa de dois garfos.
O problema do jantar dos filósofos pode ser ilustrado através da

Figura 2.10.
48
Figura 2.10: O problema do Jantar dos Filósofos
Segundo o problema, cada filósofo alterna períodos de comer e pensar.

Assim, quando um filósofo fica com fome, ele tentara pegar os garfos da
sua esquerda e direita, um de cada vez, para poder comer o espaguete.
Se conseguir pegar os dois garfos, ele come por um tempo, liberando os
garfos ao final e voltando à sua actividade de pensar. O problema
consiste em modelar uma situação que não gere o bloqueio dos filósofos.
Vamos imaginar, por exemplo, a seguinte situação: suponha que todos os
filósofos resolvem comer ao mesmo tempo e pegam seus garfos da direita.
Nessa situação, nenhum terá condições de pegar o garfo da esquerda
(indisponível) e entraram em uma situação de impasse. Uma outra situação
que poderíamos imaginar para resolver o problema seria fazer com que o
filósofo depois que pegasse o garfo da direita, verificar se o garfo da
esquerda está disponível. Se estiver disponível, o filósofo poderia pegar e
comer. Caso não estivesse disponível, o filósofo colocaria o garfo da
direita e esperaria algum tempo para, então, tentar comer novamente.
Esta proposta também geraria uma situação de impasse entre os filósofos.
Imagine se todos resolvessem comer ao mesmo tempo, pegassem seus
garfos da direita e, após verificar que os garfos da esquerda não
estavam disponíveis, baixar o garfo da direita, esperar um tempo
qualquer e todos, mais uma vez, resolvessem comer novamente.
Poderíamos pensar em uma solução onde o tempo que o filósofo esperaria
para comer novamente fosse aleatório. Em geral, poderia funcionar, mas
teríamos, ainda, uma probabilidade de que o tempo
49
aleatório de cada um fosse o mesmo, gerando, assim, a situação de

impasse. Uma provável solução para este problema pode ser pensada
utilizando semáforos.
2.3.2. Problema do Barbeiro Adormecido

Outro problema clássico de IPC é conhecido como o problema do
barbeiro adormecido. Trata-se de uma barbearia que contém um
barbeiro, uma cadeira de barbeiro e n cadeiras de espera. O
problema pode ser visualizado através da Figura 2.11.
Figura 2.11: O problema do Barbeiro Adormecido
Para este problema, se não houver nenhum cliente na barbearia, o

barbeiro senta-se e começa a dormir (o barbeiro, provavelmente, não
dormiu direito durante a noite). Quando um cliente chega à barbearia, ele
acorda o barbeiro para poder cortar seu cabelo. Se outros clientes
chegarem enquanto o barbeiro estiver cortando o cabelo de alguém, o
novo cliente observa se existe cadeira de espera livre. Caso exista, ele se
senta e aguarda sua vez. Caso contrário, ele é obrigado a ir embora.
Note que neste problema temos várias áreas compartilhadas e qualquer
método que tente resolver este problema deverá considerar esses pontos.
50
UNIDADE Temática 2.4. Escalonamento de Processos
Um ponto crucial no desenvolvimento de um Sistema Operativo é como

alocar de forma eficiente o processador (CPU) para os vários processos
prontos para serem executados. O escalonamento de processos é a
forma com que os processadores disponíveis (um ou vários) no Sistema
Computacional são distribuídos ou alocados para os vários processos
prontos.
Segundo Silberschatz, o objectivo da multiprogramação é contar

sempre com algum processo em execução para maximizar a utilização
da CPU. Em um sistema com um único processador somente um processo
pode ser executado de cada vez quaisquer outros processos devem
esperar até que a CPU esteja livre e possa ser redistribuída.
Quando um computador é multiprogramado, ele frequentemente tem

múltiplos processos ou threads competindo pela CPU ao mesmo tempo.
Essa situação ocorre sempre que dois ou mais deles estão
simultaneamente no estado pronto. Se apenas uma CPU está disponível,
uma escolha precisa ser feita sobre qual processo será executado em
seguida. A parte do sistema operativo que faz a escolha é chamada de
escalonador, e o algoritmo que ele usa é chamado de algoritmo de
escalonamento.
O projecto de um algoritmo de escalonamento deve levar em conta

uma série de necessidades, no qual alguns são apontados a seguir:
▪
Utilização da CPU: o intuito é manter a CPU ocupada o máximo
de tempo possível.
▪
Maximizar a produtividade (throughput): se a CPU estiver
ocupada executando processos, então o trabalho estará sendo
realizado. Deve-se procurar maximizar o número de processos
processados por unidade de tempo.
▪
Justiça: o algoritmo de escalonamento deve ser justo com todos
os processos, onde cada um deve ter uma chance de usar o
processador.
51
▪
Minimizar o tempo de resposta: intervalo de tempo entre a
submissão de uma solicitação e o momento em que a primeira
resposta é produzida.
Outras necessidades podem ser apontadas, como tempo de espera,

balanceamento do uso dos recursos, previsibilidade, dentre outros. Se
observarmos, alguns desses objectivos de um algoritmo de escalonamento
de processos são conflitantes. Além disso, os processos são únicos e
imprevisíveis. Dessa forma, o grande desafio de se desenvolver algum
algoritmo de escalonamento é conseguir balancear todos esses objectivos
conflitantes. Porém, segundo pesquisadores da área, qualquer algoritmo
de escalonamento que tenta favorecer alguma classe de trabalho (sistemas
interativos, por exemplo) acaba prejudicando outra classe de trabalho, ou
seja, para dar mais a um usuário, você tem que dar menos a outro,
segundo Tanenbaum. Os algoritmos de escalonamentos podem ser
classificados em preemptíveis e não-preemptíveis. O algoritmo de
escalonamento é não-preemptível quando o processador alocado para um
determinado processo não pode ser retirado deste até que o processo seja
finalizado. Já o algoritmo de escalonamento é dito preemptível quando o
processador alocado para um determinado processo pode ser retirado
deste em favor de um outro processo. Este procedimento de tirar o
processador de um processo e atribuí-lo a outro é chamado por vários
autores da área por troca de contexto. A seguir, veremos com detalhes
alguns algoritmos de escalonamento de processos.
2.4.1 Algoritmo de Escalonamento FIFO (First in First out)

Trata-se do algoritmo de escalonamento de implementação mais simples.
Com este algoritmo de escalonamento, o primeiro processo que solicita a
CPU é o primeiro a ser alocado. Dessa forma, os processos que estão
prontos para serem executados pela CPU são organizados numa fila, que
funciona baseado na política FIFO (First in First out – Primeiro a entrar é o
primeiro a sair). Considere o seguinte conjunto de processos:
52
Processo Duração de Execução
A 12
B 8
C 15
D 5
Supondo que a ordem de chegada dos processos seja: A – B

– C – D. Dessa forma, baseado na política FIFO, a ordem de execução
dos processos é mostrado através da Figura 2.12 (diagrama de
tempo).
C
B
A
0 12 20 35 40
Figura 2.12: Diagrama de tempo usando a política FIFO
Para este conjunto de tarefas o tempo de espera do processo A é de 0

(zero) unidades de tempo; para o processo B de 12 unidades de
tempo; para o processo C de 20 unidades de tempo; e para o
processo D de 35 unidades de tempo. O tempo médio de espera na
fila de prontos é de (0+12+20+35)/4, que equivale a 16,75 unidades
de tempo. Nesta política de escalonamento o tempo médio de espera
é, com frequência, um tanto longo. Outro ponto é que processos
importantes podem ser obrigados a esperar devido à execução de
outros processos menos importantes dado que o escalonamento FIFO
não considera qualquer mecanismo de distinção entre processos.
2.4.2. Algoritmo de Escalonamento Menor Tarefa Primeiro

Outra política de escalonamento de tarefas é conhecida como
algoritmo de escalonamento de Menor Tarefa Primeiro (SJF – shortest
job first), no qual o processo que tem o menor ciclo de processamento
(tempo de execução) será selecionado para usar o processador.
Considerando o mesmo conjunto de tarefas apresentados, teríamos o
diagrama de tempo apresentado na Figura 2.13.
53
D
C
B
0 5 13 25 40
Figura 2.13: Diagrama de tempo usando a política Menor Tarefa

Primeiro
Nesta política de escalonamento, o tempo de espera do processo A é de

13 unidades de tempo; para o processo B de 5 unidades de tempo; para
o processo C de 25 unidades de tempo; e para o processo D de 0
unidades de tempo. O tempo médio de espera na fila de prontos é de
(13+5+25+0)/4, que equivale a 10,75 unidades de tempo. Em média,
nessa política de escalonamento, os processos tiveram que esperar menos
para serem executados pelo processador. Segundo Silberschatz, a
dificuldade real com o algoritmo de Menor Tarefa Primeiro é saber o
tempo de duração da próxima solicitação de CPU. Assim, trata-se de um
algoritmo óptimo, porém, não pode ser implementado, pois não há modo
de saber o tempo de duração do próximo pico de CPU. Uma abordagem
possível é tentar aproximar-se do algoritmo de Menor Tarefa Primeiro.
2.4.3. Algoritmo de Escalonamento Round Robin

O algoritmo Round Robin, conhecido também como algoritmo de
escalonamento circular, também organiza a lista de processos prontos
como uma fila simples, semelhante ao algoritmo FIFO. No entanto, cada
processo recebe uma fatia de tempo do processador, geralmente
chamado de quantum. Assim, um processo executa durante um quantum
específico. Se o quantum for suficiente para este processo finalizar, outro
processo do início da fila é selecionado para executar. Se durante sua
execução o processo se bloquear (antes do término do quantum), outro
processo da fila de prontos também é selecionado. Se terminar a fatia de
tempo do processo em execução, ele é retirado do processador, que
é disponível para outro processo. Note então, que trata-se de um
algoritmo de escalonamento preemptível. Vamos considerar o mesmo
conjunto de tarefas apresentado anteriormente quando abordamos o
algoritmo de escalonamento FIFO. Para escalonar este conjunto de
54
tarefas utilizando o algoritmo de escalonamento Round Robin, com

quantum de 4 unidades de tempo, teríamos o diagrama de tempo
representado na Figura 2.14.
D D
C C C C
B B
A A A
0 4 8 12 16 20 24 2829 33 37 40
Figura 2.14: Diagrama de tempo usando a política Round Robin

(quantum 4 unidades de tempo)
Uma grande questão relacionada à política de escalonamento Round

Robin é a definição do quantum. A troca de contexto (alternar entre um
processo e outro) requer certa quantidade de tempo para ser
realizada. Sendo assim, se o quantum definido for muito pequeno,
ocasiona uma grande quantidade de trocas de processos e a eficiência
da CPU é reduzida; de forma análoga, a definição do quantum muito
grande pode tornar a política Round Robin num FIFO comum.
2.4.4. Algoritmo de Escalonamento por Prioridades

Outra política de escalonamento bem interessante é a política por
prioridades. Nesta política, os processos são organizados na fila de
prontos baseado em prioridades. Quem tiver maior prioridade vai
para o início da fila. Quem tiver menor prioridade vai se encaixando
no final da fila. Esta prioridade pode ser uma atribuição externa ao
sistema. Considere o seguinte conjunto de processos:
Processo Prioridade Duração de Execução
A 2 10
B 4 8
C 3 6
D 1 4
Dessa forma, baseado na política de escalonamento por prioridades

(quanto menor o número, maior a prioridade), a ordem de execução dos
55
processos é mostrado através da Figura 2.15 (diagrama de tempo).
D
C
B
A
0 4 14 20 28
Figura 2.15: Diagrama de tempo usando a política Menor Tarefa

Primeiro
Alguns aspectos devem ser considerados na política de escalonamento

por prioridades. Primeiro, se no sistema existir uma quantidade grande
e interativa de processos de alta prioridade, podemos chegar a uma
situação onde processos de baixa prioridade nunca executarão. Uma
possível solução para este problema é a utilização de prioridades
dinâmicas. Dessa forma, os processos de baixa prioridade podem ter
suas prioridades lentamente aumentadas, tendo, assim, chances de
utilizar o processador. Segundo Oliveira, tipicamente, soluções
baseadas em prioridades utilizam preempção, pois o mecanismo de
preempção permite implementar o conceito de prioridades de uma
maneira mais completa no sistema, posto que não faz sentido fazer
todo um esforço para executar antes processos com prioridades alta e,
ao mesmo tempo, permitir que um processo de baixa prioridade ocupe
o processador indefinidamente (caso não haja preempção).
2.4.5. Algoritmo de Escalonamento Múltiplas Filas

Geralmente, em um Sistema Operativo, existem vários processos de
mesmo tipo (mesma categoria, baseado na prioridade e consumo de
recursos). Dessa forma, ao invés de termos apenas uma única fila de
prontos, poderíamos construir várias filas de prontos e agrupar os
processos de mesma categoria nessas filas. Para cada fila poderíamos
definir prioridades diferentes e políticas de escalonamentos específicas.
Este tipo de algoritmo de escalonamento é conhecido como algoritmo
de Múltiplas Filas.
Um exemplo deste algoritmo seria considerar duas filas de prontos, uma

com maior prioridade e outra de menor prioridade, as duas funcionando
segunda a política Round Robin. Dessa forma, se a fila mais prioritária
56
tiver processos, estes terão prioridade sobre o processador. Caso a fila

mais prioritária estiver vazia, os processos prontos da fila menos
prioritária irão concorrer ao processador.
Sumário
Na Unidade temática 2 estudamos sobre processos que é um programa

em execução. Mais também podemos saber, quando que um processo é
executado a tendência é mudar de estado, que é definido por sua
actividade corrente. Podemos abordar sobre thread que é um fluxo de
controle dentro de um processo. Onde vimos que um processo
multithreaded contém vários fluxos de controle diferentes dentro do
mesmo espaço de endereçamento. A Comunicação Interprocessos num
sistema operativo fazem com que os processos necessitem de trocar
informações frequentemente entre si ou podem solicitar a utilização de
um mesmo recurso simultaneamente, como como arquivos, registros,
dispositivos de E/S e memória. Abordamos sobre alguns pontos
pertinentes tais como Condições de Corrida, Secções Críticas, bem como
algumas formas de se evitar uma condição de corrida que é usando
métodos capazes de minimizar chamados de Exclusão Mútua.
Verificamos que o problema dos productores e consumidores
apresentam problemas de sincronização entre processos, como forma
de resolver esse problema abordamos a solução de Semáforos, que foi
proposto por Dijikstra em 1965. O semáforo é um tipo abstrato de
dado composto por um valor inteiro e uma fila de processos.
Apresentamos problemas que são usados nos Sistemas operacionais que
servem como ambiente de aplicação de novos métodos de comunicação
interprocessos. O problema do jantar dos filósofos e o problema do
barbeiro adormecido. O Escalonamento de Processos, que é a forma
com que os processadores disponíveis no sistema computacional são
distribuídos ou alocados para vários processos prontos. Também vimos
que na projeção de um algoritmo de escalonamento devemos ter em
conta uma série de necessidades de modo a permitir com que possamos
projectar algoritmos eficientes. Vimos com detalhes alguns algoritmos
de escalonamento de processos.
57
Perguntas
1. Defina Processo.
2. Quais são as actividades que incluem no processo, mencione-os.
3. Porquê que um programa por si não pode ser considerado um
processo?
4. Um programa é uma entidade activa. Marque a alternativa
correcta.
a) V
b) F
5. Descreva como é feita a criação de processos, usando como
base a árvore de processos.
6. Descreve como é que ocorre a transição do estado de processo
de Pronto para Execuçào.
7. Defina Threads e como é composto.
8. Defina condição de corrida.
9. Que exemplo típico de condição de corrida é apontado por
vários autores.
10. Para se evitar a condição de corrida é preciso definir alguns
métodos, como são conhecidos esses métodos.
11. O problema do Jantar dos Filósofos por quem foi proposto e
como foi modelado.
12. Como é conhecido o outro problema e do que se trata.
13. Defina Escalonamento de Processos.
14. Segundo “Silberschatz”, qual o objectivo da multiprogramação.
15. Quando é que consideramos que um algoritmo é Preemptível ou
não-preemptível.
Respostas:
1. Rever Página 30.
6. Rever página 33 e 34.
58
Perguntas
1. Por que a definição de processo pode trazer algumas
implicações?
2. Um processo pode ser considerado uma entidade activa.
Marque a alternativa correcta.
a) V
b) F
3. A transição do estado Execução para Espera é a única causada
pelo próprio processo, isto é, voluntáriamente, enquanto as
demais são causadas por agentes externos (entidades do
sistema operativo). Marque a alternativa correcta.
a) V
b) F
4. Os benefícios da programação com múltiplos threads podem ser
divididos em quatro categorias principais, mencione-os.
5. Como é chamada a parte do programa no qual o processo
acessa a memória compartilhada.
6. Para se ter uma boa solução de exclusão mútua, precisamos
evitar algumas situações indesejáveis, mencione-os.
7. Qual das soluções propostas para se evitar condições de
corrida apresenta uma melhor solução, e justifique o porquê da
sua escolha.
8. Como pode ser resolvido o problema de productores e
consumidores.
9. Através da resposta da pergunta anterior (4.), defina.
10. O que propôs Dijkstra.
11. Qual a provável solução para o problema do Jantar dos
Filósofos.
12. Ao tentar-nos resolver o problema do Barbeiro adormecido que
pontos deve-se ter em conta.
13. Como é chamado a parte responsável por selecionar qual será
o processo a ser executado no processador.
14. Como são classificados os algoritmos de escalonamento.
15. Dos algoritmos de escalonamento de processos abordados qual
deles que achou ser o mais eficiente, justifica a sua escolha.
Bibliografia
▪
BACON, J. e HARRIS, T. Operating Systems: Concurrent and
Distributed Software Design. Addison Wesley, 2003.
▪
DEITELL, H. M. & DEITEL, P. J. & CHOFFNES, D. R. Sistemas
Operacionais. São Paulo, Ed. Prentice Hall, 2005.
▪
OLIVEIRA, R. S. e CARISSIMI, A. S. e TOSCANI, S. S. istemas
Operacionais. 3ª ed, volume 11, Ed. Bookman, 2008.
▪
59
▪
Elsevier,2008.
▪
2008
▪
Abraham, S.&Peter B. G., & Greg, G. Operating system
concepts ninth edition, 2013
▪
Edition, 2015
▪
60
TEMA – 3: GESTÃO DE MEMÓRIA.
UNIDADE Temática 3.1. Introdução à Gestão de Memória.

UNIDADE Temática 3.2. Gestão Básica de Memória.
UNIDADE Temática 3.3. Gestão de Memória para Multiprogramação.
UNIDADE Temática 3.4. Memória Virtual.
▪
Definir o conceito de Memória;
▪
Descrever como é feita a Gestão Básica de Memória bem como a Gestão de
Memória para Multiprogramação.
Objectivos
▪
específicos Abordar sobre Memória Virtual, bem como as estratégias para sua
implementação.
UNIDADE Temática 3.1. Introdução à Gestão de Memória.
A memória é um recurso fundamental e de extrema importância para a

operação de qualquer Sistema Computacional, seja os mais antigos até
aos mais modernos.
A memória principal (RAM) é um recurso importante que deve ser

cuidadosamente gerenciado. Apesar de o computador pessoal médio
hoje em dia ter 10.000 vezes mais memória do que o IBM 7094, o
maior computador no mundo no início da década de 1960, os
programas estão ficando maiores mais rápido do que as memórias.
Ao longo dos anos, as pessoas descobriram o conceito de hierarquia de

memórias, em que os computadores têm alguns megabytes de memória
cache volátil alguns gigabytes de memória principal volátil de
velocidade e custo médios, e alguns terabytes de armazenamento em
disco em estado sólido ou magnético não volátil, barato e lento, sem
mencionar o armazenamento removível, com DVDs e dispositivos USB.
Os Sistemas Computacionais mais antigos possuíam uma quantidade

muito escassa de memória. Actualmente, a memória já é um recurso bem
mais acessível e muito mais disponível que antigamente. Porém, mesmo
com o ambiente actual sendo muito mais favorável que antigamente, a
61
gestão da memória é um dos factores mais importantes e complexos de

qualquer projecto de Sistemas Operativos, pois influência directamente
no bom ou mau desempenho de um Sistema Computacional. A maioria
dos computadores tem uma hierarquia de memória, que se trata de
uma pirâmide, no qual em direção ao topo estão as memórias mais
rápidas, porém, mais caras. A Figura 3.1 esboça essa pirâmide.
Figura 3.1: Hierarquia de Memória
O Sistema Operativo tem como principal função gerir a hierarquia de

memória. A parte do SO responsável por essa função é chamada de
Gestão de Memória. Entre as funções da gestão da memória está em
controlar as partes de memória utilizada e as partes não utilizadas,
alocar (disponibilizar) memória para os processos, desalocar (retirar)
memória de processos e gerir a troca entre memória principal
(primária) e memória secundária.
Segundo Tanenbaum, basicamente, os métodos de gestão são divididos

em duas grandes classes: os métodos que fazem troca ou paginação e
os que não fazem. Adiante abordaremos esses métodos.
62
UNIDADE Temática 3.2. Gestão Básica de Memória.
Os primeiros computadores de grande porte (antes de 1960), os

primeiros minicomputadores (antes de 1970) e os primeiros
computadores pessoais (antes de 1980) não tinham abstração de
memória. Cada programa apenas via a memória física. Quando um
programa executava uma instrução como
MOV REGISTER1,1000
o computador apenas movia o conteúdo da memória física da posição
1000 para REGISTER1. Assim, o modelo de memória apresentado ao
programador era apenas a memória física, um conjunto de endereços
de 0 a algum máximo, cada endereço correspondendo a uma célula
contendo algum número de bits, normalmente oito. Nessas condições,
não era possível ter dois programas em execução na memória ao
mesmo tempo. Se o primeiro programa escrevesse um novo valor para,
digamos, a posição 2000, esse valor apagaria qualquer valor que o
segundo programa estivesse armazenando ali. Nada funcionaria e
ambos os programas entrariam em colapso quase que imediatamente.
Mesmo com o modelo de memória sendo apenas da memória física,

várias opções são possíveis. Três variações são mostradas na Figura
3.2. O sistema operativo pode estar na parte inferior da memória em
RAM (Random Access Memory — memória de acesso aleatório), como
mostrado na Figura 3.2(a), ou pode estar em ROM (Read-Only Memory
— memória apenas para leitura) no topo da memória, como mostrado
na Figura 3.2(b), ou os drivers do dispositivo talvez estejam no topo da
memória em um ROM e o resto do sistema em RAM bem abaixo, como
mostrado na Figura 3.2(c). O primeiro modelo foi usado antes em
computadores de grande porte e minicomputadores, mas raramente é
usado. O segundo modelo é usado em alguns computadores portáteis e
sistemas embarcados. O terceiro modelo foi usado pelos primeiros
computadores pessoais (por exemplo, executando o MS-DOS), onde a
porção do sistema no ROM é chamada de BIOS (Basic Input Output
System — sistema básico de E/S). Os modelos (a) e (c) têm a
63
desvantagem de que um erro no programa do usuário pode apagar por

completo o sistema operativo, possivelmente com resultados desastrosos.
Quando o sistema está organizado dessa maneira, geralmente apenas um

processo de cada vez pode estar executando. Tão logo o usuário digita
um comando, o sistema operativo copia o programa solicitado do disco
para a memória e o executa. Quando o processo termina, o sistema
operativo exibe um prompt de comando e espera por um novo comando
do usuário. Quando o sistema operativo recebe o comando, ele carrega
um programa novo para a memória, sobrescrevendo o primeiro.
Uma maneira de se conseguir algum paralelismo em um sistema sem

abstração de memória é programá-lo com múltiplos threads. Como
todos os threads em um processo devem ver a mesma imagem da
memória, o facto de eles serem forçados a fazê-lo não é um problema.
Embora essa ideia funcione, ela é de uso limitado, pois o que muitas
vezes as pessoas querem é que programas não relacionados estejam
executando ao mesmo tempo, algo que a abstração de threads não
realiza. Além disso, qualquer sistema que seja tão primitivo a ponto de
não proporcionar qualquer abstração de memória é improvável que
proporcione uma abstração de threads.
Figura 3.2: Organização de Memória com um sistema operativo e um

processo de usuário.
64
UNIDADE Temática 3.3. Gestão de Memória Multiprogramação.
Actualmente, os sistemas multiprogramáveis são amplamente mais

utilizados do que os sistemas monoprogramáveis, devido a maior
eficiência do uso do processador, pois permitem que múltiplos processos
executem simultaneamente.
A forma mais simples de gerir memória em sistemas multiprogramáveis

é dividindo a memória principal em partições estáticas e com tamanhos
definidos, estabelecidas na fase de inicialização do sistema. Esse tipo
de gerenciamento é chamado por alguns autores por alocação
particionada estática ou alocação fixa.
Quando um processo chega, ele é colocado em uma fila de entrada da

partição menor capaz de armazená-lo. Como o esquema prevê que a
partição é fixa, se o processo não ocupar o espaço total da sua
partição, o resto de espaço é desperdiçado. A Figura 3.3 ilustra o
esquema de gestão de memória.
Partição 4
900k
Partição 3
Mútliplas 500k
Filas
Partição 2
200k
Partição 1
100k
Sistema
Operacional
0
Figura 3.3: Esquema de Gestão de Memória para Multiprogramação

com
Partições fixas.
65
Assim, os programas eram carregados em uma partição específica. Em

algumas situações, é possível que uma determinada fila exista uma
quantidade grande de processos esperando pela partição enquanto
que em outras filas de partição não exista nenhum processo. Isso era
uma grande desvantagem para o sistema. Por exemplo, na Figura 3.3
podemos verificar que a partição 4 possui três processos em espera,
enquanto que na partição 2 não existe nenhum processo. Essa partição
poderia, assim, ser utilizado por um desses processos na fila.
Dessa forma, uma solução para tentar contornar esse problema é

implementar este método com uma única fila. Assim, quando uma
determinada partição estivesse livre, o processo mais próximo do início
da fila que melhor se ajusta à essa partição poderia ser carregado
nela. Este método é ilustrado na Figura 3.4.
Partição 4
900k
Fila Única
Partição 3
500k
Partição 2
200k
Partição 1
100k
Sistema
Operacional
0
Figura 3.4: Método de Partições Fixas com única fila
O método de gestão de memória baseado em partições fixas, de uma

forma ou de outra, gera um grande desperdício de memória, posto que,
um processo ao ser carregado em uma partição, se ele não ocupa todo o
seu espaço, o restante não poderá ser utilizado por nenhum outro
processo. Uma forma de se evitar todo esse desperdício, foi desenvolvido
um esquema de Gestão e alocação de memória dinamicamente,
66
dependendo da necessidade do processo. Este esquema é conhecido

como alocação com partições variáveis.
3.3.1. Alocação com Partições Variáveis

O método de alocação de partições variáveis é utilizado quando o
tamanho das partições de memória é ajustado dinamicamente à
medida que os processos vão chegando. Nesse tipo de esquema, o
processo utilizará um espaço de memória necessário, tornando esse
espaço sua partição. Poderá se resolver o problema da fragmentação,
pois as partições passarão a ser definidas a partir da alocação dos
processos na memória.
O método é bem simples. Observe através da Figura 3.5, que um

processo A ao chegar, é carregado na memória e o seu tamanho define
o tamanho da sua partição. O processo B e C, de forma análoga, são
carregados no espaço livre, ainda disponível. Ao chegar o processo D,
não existe espaço livre contínuo suficiente para ele ser carregado.
Processo C Processo C
Processo B Processo B Processo B
Processo A Processo A Processo A

Processo D
Sistema Sistema Sistema Sistema

Operacional Operacional Operacional Operacional
Figura 3.5: Esquema de Alocação com Partições Variáveis
Como podemos verificar, para inserir o novo processo D na memória foi

preciso retirar o processo A, a fim de o espaço de memória suficiente seja
disponibilizado para o novo processo. Assim, o processo A é actualizado
em disco e o processo D é carregado em memória principal, podendo
executar suas actividades. Este processo de retirar um processo de
memória, actualizar em disco e colocar outro no lugar é chamado,
67
segundo Tanenbaum, por método de Troca. A troca consiste em trazer um

processo inteiro, executa-lo temporariamente e, então, devolve-lo ao disco.
Isto acontece quando a memória principal disponível é insuficiente para
manter todos os processos carregados (situação que seria óptima).
Podemos verificar através da Figura 3.5, que após alocar e desalocar
vários processos, a memória pode ser particionada (espaço entre os
processos D e B, por exemplo). A isso chamamos de fragmentação externa.
Veja que essa fragmentação é diferente da gerada na alocação estática.
Na alocação estática, a fragmentação é gerada pelo não uso total da
partição pelo processo (fragmentação interna).
Assim, quando a troca cria várias lacunas na memória, é possível juntar

todas essas lacunas em um grande espaço, movimentando todos os
processos para baixo o máximo possível. Essa técnica é conhecida como
compactação de memória e exige muito tempo de CPU.
O método de alocação dinâmica da partição é bem mais flexível que o

método de alocação estática. Porém, essa flexibilidade também
complica mais a tarefa de alocar e desalocar a memória, assim como a
monitoração da memória utilizada. O Sistema Operativo tem a função
de gerir essa memória. De modo geral, há duas maneiras de monitorar
o uso da memória: através do mapa de bits e listas encadeadas.
3.3.2. Gestão de Memória com Mapas de Bits

Com o mapa de bits, a memória é dividida em unidades de alocação e
para cada unidade é associado um bit no mapa. Se este bit estiver com
valor 0 implica que esta unidade de alocação está vazia. Se este bit
estiver com valor 1 implica que esta unidade de alocação está
preenchida por algum processo. Através da Figura 3.6 é mais fácil
compreender como essa estratégia de gestão funciona. Considere a
memória, particionada em XX unidades de alocação, com processos e
espaços vazios (lacunas). O mapa de bits dessa memória será
configurado como mostrado na figura.
68
A B C D E
0 5 14 18 20 26 29
1 1 1 1 1 0 0 0
1 1 1 1 1 0 0 0
1 1 1 1 1 0 0 0
1 1 1 1 1 0 0 0
Figura 3.6: Memória dividida em unidade de alocação e o

correspondente
Mapa de Bits
O ponto crucial do mapa de bits é a definição do tamanho da unidade

de alocação. Se ele for muito pequeno, o mapa de bits poderá ser
muito grande. Se a unidade for muito grande, o mapa de bits será
menor, mas uma quantia de memória poderá ser desperdiçada na
última unidade se o tamanho do processo não for um múltiplo exacto da
unidade de alocação.
3.3.3. Gestão de Memória com Listas Encadeadas

Outra maneira de controlar o uso da memória é manter uma lista
encadeada dos segmentos de memória alocados e livres, onde um
segmento pode ser um processo ou lacuna entre dois processos. Assim,
cada nó da lista seria formado por uma entrada especificando se é um
processo (P) ou uma lacuna (L), o endereço de onde se inicia, a
quantidade de unidades de alocação e um ponteiro para a próxima
entrada. A Figura 3.7 ilustra a mesma gestão de memória através de
listas encadeadas.
A B C D E
0 5 14 18 20 26 29
P 0 5 L 5 3 P 8 6 P 14 4
L182 P206 P263 L293X
Comprimento 2
Espaço Processo
Livre
Começa
em 18
Figura 3.7: Memória dividida em unidade de alocação, monitorada

através de Lista Encadeada
69
UNIDADE Temática 3.4. Memória Virtual.
Os programas estão limitados ao tamanho de memória principal

disponível. É possível utilizar a técnica overlay, que permite que um
programa seja dividido em módulos, de forma que seja possível a
execução independente de cada módulo, utilizando uma mesma área
de memória. Trabalhar com overlays joga a responsabilidade para o
programador de dividir o seu programa, o que se trata de uma tarefa
complexa e que exigia tempo do programador. Dividir programas
grandes em módulos pequenos era uma tarefa cansativa, chata e
propensa a erros. Poucos programadores eram bons nisso. O ideal
seria que a divisão do programa fosse feito pelo sistema. Não levou
muito tempo para alguém pensar em passar todo o trabalho para o
computador. O método encontrado (FOTHERINGHAM, 1961) ficou
conhecido como memória virtual. O principal objectivo desta técnica é
estender a memória principal através de memória secundária, dando
impressão ao usuário que ele tem a disposição uma quantidade de
memória maior do que a memória real disponível. Em outras palavras,
para facilitar o entendimento, a técnica de memória virtual
disponibiliza para o usuário uma memória de trabalho maior do que a
memória principal (RAM). Esse espaço de memória adicional
implementado em disco é conhecido como memória de swap.
Memória Memória
Principal Swap
Memória disponível
Figura 3.8: Memória Virtual
70
Assim, o Sistema Operativo deve manter parte do programa que está em

uso na memória principal e parte dele na memória swap. Na
multiprogramação, parte de vários processos podem ser mantidas em
memória principal e partes em memória swap. Existem algumas estratégias
para implementar o método de memória virtual. A estratégia mais
conhecida é chamada de paginação, abordaremos adiante.
3.3.4. Swapping
Um programa para ser executado deverá se encontrar na memória. Em
sistemas de multiprogramação, um programa em execução pode ser
retirado (swapp out) temporariamente para o disco sem que este tenha
terminado para depois ter que se trazer de novo para a memória
(Swapp in) para continuar com a execução. Este mecanismo visa
permitir que, mesmo em situações de limitação de memória, se possa ter
no sistema vários processos em execução.
Em ambientes de multiprogramação o método de swapping pode ser

usado com o algoritmo de escalonamento da CPU round-robin, visto
anteriormente. Quando o quantum (fatia de tempo alocado ao processo)
expira a unidade de gestão de memória poderá retirar o processo que
acaba de deixar a CPU para o disco e trazer um outro processo para o
espaço de memória deixado livre pelo processo que acaba de ser levado
para o disco. Este método é ilustrado na Figura 3.9.
Sistema
Operacional
Processo
1 remoção P1
Processo
2 inserção P2
Espaço do
usuário
Memória retaguarda
Memória principal
Figura 3.9: Processo de Swapping
71
O processo de Swapping envolve a transferência de processos entre a

memória principal e uma memória de retaguarda. A memória de
retaguarda geralmente é um disco veloz. Ela deve ser suficientemente
grande para acomodar cópias de todas as imagens da memória para
todos os usuários, e deve fornecer acesso directo a essas imagens da
memória.
Teoricamente a unidade de gestão de memória deverá proceder o

swapping em tempo muito curto de modo que haja sempre processos na
memória prontos para o escalonamento. Por outro lado, o quantum
atribuído a cada processo deverá ser suficientemente grande para
permitir que, no intervalo entre dois swappings, o processo que ganha a
CPU possa ter tempo de computação significativo. Uma outra variante
de swapping é usada com o algoritmo de escalonamento por
prioridades.
Com este algoritmo, se um processo de alta prioridade tiver que ser

executado a unidade de gestão de memória pode fazer o swap out de
um processo de menor prioridade para depois carregar e pôr em
execução o processo de alta prioridade. Quando o processo de alta
prioridade termina então o que havia sido retirado para o disco
poderá retornar para a memória e ser alocado a CPU para continuar
com a execução.
3.3.5. Paginação
Segundo Silberstchaz, a paginação é um esquema de gestão de
memória em que o espaço de endereçamento físico (endereços de
memória principal) de um processo não é contíguo. A paginação, assim,
evita o problema da fragmentação externa gerado pela alocação de
memória dinâmica. Os programas são capazes de gerar endereços,
chamados de endereços virtuais. Esse conjunto de endereços forma o
que chamamos de espaço de endereçamento virtual. Em sistemas que
não utilizam a técnica de memória virtual, o endereço virtual equivale
ao endereço físico, especificando exactamente onde o programa será
armazenado na memória principal.
Em computadores que utilizam a técnica de memória virtual, os endereços

virtuais não vão directamente para o barramento de memória.
72
Primeiramente, ele passa por uma unidade chamada de Unidade de

Gestão de Memória (MMU – Memory Management Unit). A MMU tem
como função mapear um endereço virtual para um endereço lógico.
Adiante, o espaço de endereçamento virtual é dividido em unidade

chamadas de páginas. A memória principal também é dividida em
unidades, do mesmo tamanho das páginas, chamadas de molduras de
página (quadro). Assim, num sistema que contém páginas de 4k, as
molduras também serão de 4k. Considere a Figura 3.10, com o espaço
de endereço virtual formado de 64k e o a memória física de 32k, com
páginas de molduras de 4k.
Na figura temos 16 páginas virtuais e 8 molduras de páginas. Quando

um programa tenta acessar um endereço virtual, este é passado para a
MMU, que vai analisar o mapeamento deste endereço e descobrir a
qual moldura pertence. A MMU mapeia este endereço virtual para o
endereço físico, que, por fim, é colocado no barramento de memória.
Espaço endereço
Virtual
60k-64k
56k-60k Página
52k-56k
48k-52k
44k-48k
40k-44k
36k-40k Espaço de
endereço Físico
32k-36k Moldura de
Página
28k-32k 28k-32k
24k-28k 24k-28k
20k-24k 20k-24k
16k-20k 16k-20k
12k-16k 12k-16k
8k-12k 8k-12k
4k-8k 4k-8k
0k-4k 0k-4k
Figura 3.10: Técnica de Paginação
Vejamos um outro exemplo. Consideremos o mapeamento apresentado

na Figura 3.11.
73
Espaço endereço
Virtual
60k-64k X
56k-60k X
52k-56k X
48k-52k X
44k-48k 7
40k-44k X
36k-40k 5 Espaço de
32k-36k X endereço Físico
28k-32k X 28k-32k
24k-28k X 24k-28k
20k-24k 3 20k-24k
16k-20k 4 16k-20k
12k-16k 0 12k-16k
8k-12k 6 8k-12k
4k-8k 1 4k-8k
0k-4k 2 0k-4k
Figura 3.11: Mapeamento da memória virtual
Com esse mapeamento, o endereço virtual 0, se encontra na página 0 (0k-

4k) é mapeado pela MMU para a moldura 2 (8k-12k). De forma análoga,
o endereço virtual 8195, pertencente à página 2 (8k-12k, correspondente
a 8192-12287) é mapeado para a moldura 6 (24576 até 28671), e seu
endereço físico será 24576 (endereço inicial da moldura) adicionado do
deslocamento dele na página (página começa com endereço 8192, como
seu endereço é 8195, ele está deslocado de 3). Assim, o endereço físico
será 24576 + 3, que equivale a 24579 através desse exemplo podemos
verificar como a MMU faz esse mapeamento. O endereço virtual 8195
corresponde, em codificação binária, a 0010000000000011. Este
endereço virtual é formado de 16 bits, no qual os quatros primeiros bits
(0010) são utilizados para representar o número da página (0010
corresponde à página 2) e o restante (12 bits) é utilizado para
representar o deslocamento na página. Como temos 4 bits para
representar o número de páginas, com essa combinação, podemos gerar
números de 0 a 15, ou seja, as 16 páginas no espaço de endereçamento
virtual. Com os 12 bits de deslocamento podemos ter endereços de 0 a 4k,
ou seja, o tamanho das páginas.
74
Já no espaço de endereçamento físico, como temos 8 molduras no

exemplo apresentado, precisamos de 3 bits para representá-las. Com
os 3 bits podemos representar as molduras 0 a 7. Como o tamanho de
cada moldura corresponde também à 4k, precisamos, assim, de 12 bits
para representar endereços de 0 a 4k.
Assim, o endereço físico é representado por 15 bits. Todo mapeamento

realizado pela MMU é feito através de uma tabela conhecida como
tabela de páginas. Cada processo possui sua tabela própria e cada
página possui uma entrada nesta tabela. Cada entrada, ou seja, cada
página na tabela possui um bit (bit de validade) que informa se a
página está ou não mapeada na memória principal.
A Figura 3.12 mostra o exemplo do mapeamento do endereço virtual

8195 (0010000000000011) para o endereço físico 24579
(110000000000011).
Quando um programa tenta utilizar um endereço virtual e a MMU

percebe que a página no qual o endereço pertence não possui
mapeamento na memória principal, ela gera uma interrupção no
Sistema Operativo, conhecido como falha de página (page fault). O
Sistema Operativo, por sua vez, toma conta do processador e seleciona
uma das molduras, atualizando seu valor em disco. Então, ele busca a
página não mapeada, carrega ela na moldura, altera a tabela e
reinicia o processo interrompido. A moldura a ser retirada é escolhida
baseada em algoritmos de escalonamento, chamados de algoritmos de
substituição de páginas, abordaremos mais adiante.
75
000 0 15
000 0 14
000 0 13
000 0 12
111 1 11
000 0 10 Endereço Físico 24579
101 1 9 110 000000000011
000 0 8
000 0 7
000 0 6
011 1 5 Referência à
100 1 4 Página
000 0 3 0010 000000000011
110 1 2 Endereço Virtual 8195
001 1 1 Bit de Válidade
010 1 0
Figura 3.12: Mapeamento de endereço virtual para endereço físico

3.3.6. Translation Lookside Buffers (TLB)
As tabelas de páginas, geralmente, são mantidas em memória, o que
influência directamente no desempenho, já que as tabelas são bastante
grandes. Segundo Tanenbaum, um comportamento que foi verificado é
que programas tendem a fazer um grande número de referências a um
pequeno número de páginas. Assim, somente uma pequena fração de
entradas da tabela de páginas é intensamente lida. Com isso, foi
desenvolvido um dispositivo de hardware capaz de mapear endereços
virtuais em endereços físicos sem passar pela tabela de páginas. Esse
dispositivo é conhecido como memória associativa ou Translation
Lookside Buffers (TLB). Geralmente, ele é encontrado dentro da MMU.
3.3.7. Algoritmos de Substitutição de Páginas

Quando ocorre uma falha de página, o Sistema Operativo deve
selecionar uma das molduras para disponibilizar para a página não
mapeada. Se a página a ser retirada da moldura tiver sido modificada,
ela deve ser actualizada em disco. Caso contrário, a página pode ser
retirada da moldura, ou seja, da memória principal, sem necessitar de
actualização em memória. A página escolhida geralmente é chamada de
76
página vítima. A escolha aleatória de uma página vítima pode

influênciar directamente o desempenho do sistema. O ideal seria retirar
uma página que não é utilizada constantemente. Por exemplo, se for
retirado uma página que é muito utilizada, provavelmente ela seja
logo referenciada e necessite voltar para a memória principal,
gerando novamente uma falha de página. Para a escolha de qual
página será retirado da memória, temos vários algoritmos de
substituição de páginas, que abordaremos a seguir.
3.3.7.1. Algoritmos de Substitutição de Página Óptimo

O algoritmo de substituição de página óptimo pode ser considerado
como sendo o melhor algoritmo possível. A ideia básica deste algoritmo
é que, quando ocorrer uma falha de página, a página a ser substituído
na memória física será a que for referenciada mais tardiamente. Em
outras palavras, se tivermos uma quantidade x de páginas carregadas
na memória físicas (nas molduras), algumas páginas poderão ser
utilizadas logo em seguida, porém, algumas páginas só irão ser
referenciadas depois de muito tempo.
Dessa forma, se a página escolhida for a página que será referenciada

mais tardiamente, o algoritmo estará adiando o máximo possível uma
nova falha de página. Um exemplo mais prático para que possamos
entender este algoritmo, seria supor que temos 10 páginas na memória.
Dessas 10 páginas, a página 5, por exemplo, será a primeira a ser
referenciada, ou seja, a próxima. Da mesma forma, a página 0, por
exemplo, será a última a ser referenciada, ou seja, do conjunto de páginas
carregadas, ela será a última. Então, baseado no algoritmo de substituição
de página óptima, a página 0 será a melhor escolha, pois estamos
adiando o máximo possível uma falha de página. É visível que este
algoritmo não é realizável na prática, pois seria necessário, quem sabe,
uma bola de cristal para podermos adivinhar qual seria a última página a
ser referenciada. O facto de não termos como “prever o futuro”, esse
algoritmo se torna não praticável. Porém, este algoritmo é muito utilizado
para ser comparado com algoritmos realizáveis.
77
3.3.7.2. Algoritmos de Substitutição de Página Não Recentemente

Utilizada
Alguns bits são utilizados na tabela de páginas e são utilizados com o
objectivo de facilitar a implementação de algoritmos de substituição de
páginas. O primeiro bit é conhecido como o bit sujeira (dirty bit) e
indica se uma página foi alterada ou não durante a execução do
processo. Toda vez que uma determinada página é gravada na
memória secundária, o Sistema Operativo apaga este bit.
O segundo bit é conhecido como o bit de referência (reference bit) e

serve para indicar se uma página foi referenciada (acessada) por um
processo. Quando uma página é carregada na memória, este bit é
apagado. Dessa forma, o algoritmo de substituição de página não
recentemente define que, quando ocorre uma falha de página, o
Sistema Operativo inspeciona todas as páginas e agrupa em quatros
conjuntos, como segue:
▪
Conjunto 1: páginas não-referenciadas (bit de referência com
valor zero) e não-modificadas (bit sujeira com valor zero).
▪
Conjunto 2: páginas não-referenciadas (bit de referência com
valor zero) e modificadas (bit sujeira com valor 1).
▪
Conjunto 3: páginas referenciadas (bit de referência com valor
1) e não-modificadas (bit sujeira com valor zero).
▪
Conjunto 4: páginas referenciadas (bit de referência com valor
1) e modificadas (bit sujeira com valor 1).
O conjunto 4, visivelmente, contém as páginas que são menos

aconselhadas de serem retiradas. O conjunto que contém páginas
modificadas que não foi referenciada é uma escolha melhor do que
páginas não-modificadas, mas que são constantemente referenciadas.
3.3.7.3. Algoritmos de Substitutição de Página FIFO

O algoritmo de substituição de páginas FIFO (first in first out) define que a
página que será retirada é a página que está mais tempo na memória. Em
suma, trata-se de uma fila, onde o primeiro que entra é sempre o primeiro
que sai. Para exemplificar este algoritmo, consideremos a sequência de
páginas solicitadas apresentada na Figura 3.13. Considere
78
também que existe apenas 3 molduras (m1, m2 e m3). Dessa forma,

através do algoritmo de substituição de página FIFO temos a
configuração de seleção de páginas a serem retiradas apresentadas.
Podemos verificar na Figura 3.13, que as primeiras páginas, pelo facto
de não estarem carregadas nas molduras, também geram uma falha
de página e precisam, assim, serem mapeadas. Vejamos também que a
quarta página quando é referenciada (página 3) não está mapeada.
Como a página 0 foi a última a ser referenciada (mapeada), ela é a
página escolhida pelo algoritmo.
Podemos verificar facilmente, que o algoritmo de substituição de

página FIFO não leva em consideração se uma determinada página é
muito referenciada, ou seja, caso ela seja a escolhida para sair, ela
será substituída. Veja ainda na Figura 3.13, que a página 7 foi
escolhida para sair e, logo após ela foi novamente referenciada.
FIFO
m m m
Página 1 2 3 Falha
0 0 x
2 0 2 x
1 0 2 1 x
3 3 2 1 x
5 3 5 1 x
4 3 5 4 x
6 6 5 4 x
3 6 3 4 x
7 6 3 7 x
4 4 3 7 x
7 4 3 7
3 4 3 7
3 4 3 7
5 4 5 7 x
5 4 5 7
3 4 5 3 x
1 1 5 3 x
1 1 5 3
1 1 5 3
7 1 7 3 x
Figura 3.13: Algoritmo de Substituição de Página FIFO
79
3.3.7.4. Algoritmos de Substitutição de Página de Segunda Chance

No algoritmo de substituição de página FIFO podemos verificar que o
mesmo não leva em consideração se uma página é muito utilizada.
Assim, a fim de se tentar evitar que uma página muito utilizada seja
selecionada, podemos inspecionar o bit de referência antes de
selecionar a página em questão.
Este algoritmo geralmente é chamado de algoritmo de substituição de

página de segunda chance. De facto, antes de se retirar uma página, é
verificado se seu bit de referência tem valor 1. Caso ele tenha valor 1,
seu valor é mudado para 0 e esta página não é retirada. Note que
este algoritmo é uma pequena modificação do algoritmo FIFO.
3.3.7.5. Algoritmos de Substitutição de Página de Relógio

O algoritmo de substituição de página de relógio utiliza os bits de
referência para selecionar a próxima página a ser retirada. A
principal diferença para o algoritmo apresentado anteriormente está
na implementação. O algoritmo de segunda chance é implementado
através de uma fila FIFO, utilizando os bits de referência. Já o
algoritmo do relógio é implementado a partir de uma fila circular.
Assim, a próxima página a ser retirada será a primeira página
apontada pelo ponteiro do relógio que contiver o bit de referência 0.
A Figura 3.14 ilustra esse algoritmo.
Observemos neste algoritmo, que a próxima página que será retirada

não será nem as páginas 15, 16, 1 e 2, pois seus bits de referência têm
valores 1. Assim, a próxima vítima será a página 3. A Figura 3.15
mostra essa configuração.
80
Página p1
p16 p2
1 1 1 p3
p15
0 Página
1
Vítima
p14 p4
1 0
Bit de
referência p13 0 1 p5
p12 0 1 p6
1 0
p11 p7
1 0 1
p10 p8
p9
Figura 3.14: Algoritmo de Substituição de Página do relógio
Observemos na Figura 3.15, que os bits das páginas 15, 16, 1 e 2

foram zeradas e a página 17 entrou no lugar da página 3.
p1
p16 p2
1 1 1
p15 p17
1 0
p14 p4
1 0
p13 0 1 p5
p12 0 1 p6
1 0
p11 p7
1 0 1
p10 p8
p9
Figura 3.15: Seleção de página segundo o algoritmo de Substituição de

Página do relógio
3.3.7.6. Algoritmos de Substitutição de Página Menos Recentemente

Utilizada
O algoritmo de substituição de página menos recentemente utilizada
(LRU – Least Recently Used) trata-se do algoritmo que tem uma boa
aproximação do algoritmo óptimo. O seu funcionamento é bem simples:
como é impossível olhar para o futuro, ou seja, não é possível saber das
páginas carregadas, qual será a última que será referenciada, olhemos
para o passado. Assim, quando acontecer uma falha de página, o
81
algoritmo selecionará para ser retirada a página que foi a mais tempo
referenciada.
A implementação do algoritmo LRU é muito custoso, segundo

Tanenbaum, pois é preciso manter uma lista encadeada de todas as
páginas na memória, com as páginas mais recentemente utilizadas na
frente as menos recentemente utilizadas no fundo. Essa lista deve ser
atualizada a cada referência de página, o que pode gerar uma
grande modificação na lista. Imaginemos que, uma página do fim da
lista (pouco referenciada) seja referenciada. É preciso, então deslocar
esta página para o início da fila. Para exemplificar este algoritmo,
consideremos a mesma sequência de páginas solicitadas apresentada
no algoritmo FIFO. A Figura 3.16 ilustra essa situação.
LRU
Página m1 m2 m3 Falha
0 0 x
2 0 2 x
1 0 2 1 x
3 3 2 1 x
5 3 5 1 x
4 3 5 4 x
6 6 5 4 x
3 6 3 4 x
7 6 3 7 x
4 4 3 7 x
7 4 3 7
3 4 3 7
3 4 3 7
5 5 3 7 x
5 5 3 7
3 5 3 7 x
1 5 3 1 x
1 5 3 1
1 5 3 1
7 7 3 1 x
Figura 3.16: Algoritmo de Substituição de Página Menos Recentemente

Utilizada
Observemos, que de forma análoga ao algoritmo FIFO, as primeiras

páginas, pelo facto de não estarem carregadas nas molduras, também
geram uma falha de página e precisam, assim, serem mapeadas. Veja
82
que a página 3, que no algoritmo FIFO seria a página retirada para

ser substituída pela página 5, pelo facto dela ter sido referenciada, o
algoritmo LRU já escolheu outra página para ser retirada, no caso a
página 4, que no momento era a menos referenciada.
Sumário
Nesta Unidade temática 3 introduzimos a Gestão de Memória, onde

podemos constatar que é um recurso de grande importância para
qualquer sistema. Abordando sobre a Gestão de Memória para
Multiprogramação, vimos qual seria a forma mais simples de gerir
memória em sistema multiprogramáveis. Mais também estendemos a
nossa abordagem falando sobre memória Virtual, onde vimos que na
multiprogramação, partes de vários processos podem ser mantidas em
memória principal e partes em memória swap. Mais vimos algumas
estratégias para implementar o método de memória virtual. A
estratégia mais conhecida é chamada de paginação, onde estudamos
sobre algoritmos de substituição de páginas.
Perguntas
1. Qual é a principal função do Sistema Operativo.
2. Como é chamada a parte do Sistema Operativo responsável
por essa função.
3. O que aconteceria quando um programa executava uma
instrução como: MOV REGISTER1,1000
4. Baseando-se no exercício (3.), o que aconteceria se o primeiro
programa escreve um novo valor para a posição 2000.
5. Relacione os exercícios (3. e 4.), diga se os programas
continuariam a funcionar. Justifique.
6. Porquê que os sistemas multiprogramáveis são mais utilizados
do que os sistemas monoprogramáveis.
7. Qual seria a forma mais simples de gerir memória em sistemas
multiprogramáveis.
8. Com base no exercício (7.), diga como é chamado por alguns
autores esse tipo de gestão.
9. Por quem e em que ano foi desenvolvido a memória virtual.
10. Qual era o principal objectivo ao desenvolvedor dessa técnica.
11. Para implementação de memória virtual existem várias
estratégias, diga como é chamada a estratégia mais conhecida.
83
12. Porque a escolha aleatória de uma página vítima pode

influenciar o desempenho do sistema.
Respostas:
5. Rever página 63e 64.
Perguntas
1. Qual a função da Gestão de Memória.
2. Segundo Tanenbaum os métodos de gestão são divididos em
duas classes, mencione-os.
3. Baseando-se na Figura 3.2, diga qual das Figuras 3.2 (a); 3.2
(b) e 3.2 (c) foi usado em computadores de grande porte e
minicomputadores.
4. Na gestão de memória para multiprogramação com partições
fixas e o método de partições fixas com única fila qual dos dois
é mais vantajoso. Justifique.
5. Segundo Silberstchaz defina Paginação.
6. Em computadores que utilizam a técnica de memória virtual, os
endereços virtuais não vão diectamente para o barramento de
memória. Passando por uma unidade chamada Unidade de
Gestão de Memória (MMU). Qual a principal função dessa
unidade.
7. Qual dos algoritmos de substituição de páginas é o mais
eficiente, justifica a sua resposta.
Bibliografia
▪
▪
▪
▪
▪
Elsevier,2008.
84
▪
2008
▪
▪
Edition, 2015
▪
85
TEMA – 4: SISTEMAS DE ARQUIVOS.
UNIDADE Temática 4.1. Introdução aos Sistemas de

Arquivos. UNIDADE Temática 4.2. Implementação de
Arquivos. UNIDADE Temática 4.3. Directórios
▪
Explicar a função dos Sistemas de Arquivos
▪
Mostrar os vários métodos utilizados para implementar arquivos.
▪
Descrever métodos usados na organização de Sistemas de Directórios.
Objectivos
específicos
UNIDADE Temática 4.1. Introdução, aos Sistemas de Arquivos
Todas as aplicações de computadores precisam armazenar e recuperar

informações. Enquanto um processo está sendo executado, ele pode
armazenar uma quantidade limitada de informações dentro do seu
próprio espaço de endereçamento. No entanto, a capacidade de
armazenamento está restrita ao tamanho do espaço do endereçamento
virtual. Para algumas aplicações esse tamanho é adequado, mas, para
outras, como reservas de passagens aéreas, bancos ou sistemas
corporativos, ele é pequeno demais.
Manter informações dentro do espaço de endereçamento de um processo

constitui um problema visto que, quando o processo é concluído, as
informações são perdidas. Para muitas aplicações (por exemplo, bancos
de dados), as informações precisam ser retidas por semanas, meses, ou
mesmo para sempre. Perdê-las quando o processo que as está utilizando
é concluído é algo inaceitável. Além disso, elas não devem desaparecer
quando uma falha no computador mata um processo.
Mais também é necessário que múltiplos processos acessem (partes de)

uma informação ao mesmo tempo. Se temos um diretório telefônico on-
line armazenado dentro do espaço de um único processo, apenas
aquele processo pode acessá-lo.
86
Segundo Tanenbaum a maneira para solucionar esse problema é tornar

a informação em si independente de qualquer processo. Tanenbaum
aponta três requisitos essenciais para o armazenamento de informações
por longo prazo que devesse ter em conta:
1. Deve ser possível armazenar uma quantidade muito grande de

informações.
2. As informações devem sobreviver ao término do processo que

as está utilizando.
3. Múltiplos processos têm de ser capazes de acessá-las ao mesmo

tempo.
A solução encontrada usualmente para o armazenamento de informações

é utilizar mídias externas e distintas da memória principal (volátil) em
unidades chamadas arquivos, de modo que essas informações devem ser
armazenadas de forma persistente, ou seja, não pode ser afetada pela
criação e término de um processo. Assim, um arquivo só irá ser destruído
quando seu proprietário o remover explicitamente. Discos magnéticos
foram usados por anos para esse armazenamento de longo prazo. Em
anos recentes, unidades de estado sólido tornaram-se cada vez mais
populares, à medida que elas não têm partes móveis que possam quebrar.
Elas também oferecem um rápido acesso aleatório. Fitas e discos ópticos
também foram amplamente usados, mas são dispositivos com um
desempenho muito pior e costumam ser usados como backups.
Arquivos são unidades lógicas de informação criadas por processos ou por

outras palavras são recipientes de dados, identificados por um nome e por
uma série de atributos, mantidos e geridos pelo sistema operativo.
Enquanto que, Directórios são arquivos do sistema para manter a estrutura
do sistema de arquivos ou são conjuntos de referências a arquivos. Os
directórios permitem agrupar arquivos, facilitando manuseamento e
localização. Do ponto de vista do usuário, o aspecto mais importante do
Sistema de Arquivos é como aparece para ele, ou seja, como o Sistema de
Arquivos é implementado e quais estruturas são utilizadas não é a questão
primordial. O usuário está mais interessado no que o arquivo é constituído,
nomeados e protegidos.
87
Nesta unidade temática veremos os arquivos do ponto de vista do

usuário, abordando suas principais propriedades. Apresentaremos as
características gerais de Sistema de Arquivos, é de salientar que cada
Sistema de Arquivo específico contém características próprias.
4.1.1. Nomeação de Arquivos

Segundo Tanenbaum, o arquivo é um mecanismo de abstração, no qual
oferece meios de armazenar informações no disco e lê-las posteriormente.
A característica mais importante de qualquer mecanismo de abstração é o
modo como os objectos são geridos e nomeados, isto é, a nomeação de
arquivos. Um processo ao criar um arquivo, atribui um nome a ele e
quando o processo termina, este arquivo continua existindo, possibilitando
que outros processos possam ter acesso a ele simplesmente buscando por
seu nome. As regras de nomeação de arquivos variam de sistema para
sistema, porém, como característica comum, todos os Sistemas Operativos
actuais permitem cadeias de caracteres de um até oito letras como nomes
válidos de arquivos.
Alguns Sistemas de Arquivos permite a utilização de caracteres especiais,

outros não; alguns Sistemas de Arquivos permitem nomes com tamanhos até
255 caracteres; alguns Sistemas de Arquivos fazem distinção entre letras
maiúsculas e minúsculas (case sensitive), como exemplo o Sistema de
Arquivo do Unix, enquanto que outros não diferenciam, como exemplo o
Sistema de Arquivo do MS-DOS e do Windows.
O Windows 95 e o Windows 98 usavam o mesmo sistema de arquivos do

MS-DOS, chamado FAT-16, e, portanto, herdaram muitas de suas
propriedades, como a maneira de se formarem os nomes dos arquivos. O
Windows 98 introduziu algumas extensões ao FAT-16, levando ao FAT-32,
mas esses dois são bastante parecidos. Além disso, o Windows NT,
Windows 2000, Windows XP, Windows Vista, Windows 7 e Windows 8
ainda dão suporte a ambos os sistemas de arquivos FAT, que estão
realmente obsoletos agora. No entanto, esses sistemas operacionais novos
também têm um sistema de arquivos nativo muito mais avançado (NTFS —
native file system) que tem propriedades diferentes (como nomes de
arquivos em Unicode). Na realidade, há um segundo sistema de arquivos
para o Windows 8, conhecido como ReFS (ou
88
Resilient File System — sistema de arquivos resiliente), mas ele é

voltado para a versão de servidor do Windows 8.
A maioria dos Sistemas Operativos (na verdade, o Sistema de Arquivo do

SO) suporta nomes de arquivos de duas partes, separados por um ponto.
A parte que segue o ponto é chamada de extensão do arquivo e indica o
tipo do arquivo. Essa extensão, em alguns Sistemas Operativos,
é utilizada para atribuir qual programa deve abrir aquele arquivo em
específico. A tabela abaixo apresenta algumas extensões comuns de
arquivos.
Extensão Significado
.bak Cópia de segurança
.c Código-fonte de programa em C
.gif Imagem no formato Graphical Interchange Format
.hlp Arquivo de ajuda
.html Documento em HTML
.jpg Imagem codificada segundo padròes JPEG
.mp3 Música codificada no formato MPEG (camada 3)
.mpg Filme codificado no padrão MPEG
.o Arquivo objecto (gerado por compilador, ainda não

ligado)
.pdf Arquivo no formato PDF (Portable Document File)
.ps Arquivo PostScript
.tex Entrada para o programa de formatação TEX
.txt Arquivo de texto
.zip Arquivo compactado
4.1.2. Estruturas de Arquivos

Os arquivos podem ser estruturados de várias maneiras. Segundo
Tanenbaum, os arquivos podem ser estruturados basicamente através
de três maneiras, ilustradas na Figura 4.1.
89
1 Byte
1 Registro
Info 1 Info 2 Info 3
Info 1 Info 2 Info 3 Info 1 Info 2 Info 3 Info 1 Info 2 Info 3
Info 1 Info 2 Info 3
(c)
(a) (b)
Figura 4.1: Estruturas de Arquivos
(a) Sequência de bytes não-estruturada: nessa estrutura o SO não

sabe o que o arquivo contém e tudo que ele enxerga é uma
sequência de bytes. Tal estratégia apresenta uma máxima
flexibilidade, uma vez que os programas dos usuários podem
pôr qualquer coisa que queiram em seus arquivos e chamá-los
do nome que lhes convier.
(b) Sequência de registro de comprimento fixo: Um arquivo é uma

sequência de registros de tamanho fixo, cada um com alguma
estrutura interna. A ideia central é que a operação de leitura
retorna um registro e a operação de escrita sobrepõe ou anexa
um registro.
(c) Árvore de Registros: um arquivo é constituído de uma árvore

de registros (não necessariamente do mesmo tamanho), cada um
contendo um campo-chave em uma posição fixa no registro, na
qual a árvore é ordenada pelo campo-chave para que se
busque mais rapidamente por uma chave específica. Além disso,
novos registros podem ser adicionados ao arquivo, decidindo o
sistema operativo onde colocá-los. Este tipo de arquivo é
amplamente aplicado em computadores de grande porte
usados ainda para alguns processamentos de dados comerciais.
4.1.3. Tipos de Arquivos

Muitos sistemas operativos aceitam vários tipos de arquivos. Os
principais tipos de arquivos são:
▪
Arquivos comuns: arquivos que contêm informações do usuário.
90
▪
Diretórios: arquivos do sistema que mantêm a estrutura do
sistema de arquivos.
▪
Arquivos especiais de caracteres: arquivos relacionados à
entrada e saída e usados para modelar dispositivos de E/S.
▪
Arquivos especiais de blocos: arquivos usados para modelar
discos.
Os arquivos comuns (informações do usuário), em geral, são arquivos

ASCII ou arquivos binários. Os arquivos ASCII são constituídos de linhas
de texto, possuindo como grande vantagem o facto de que eles podem
ser mostrados e impressos como são e poder ser editados com qualquer
editor de textos. Além disso, facilita a conexão entre a saída de um
programa e a entrada de um outro. Já os arquivos binários, em geral,
possuem alguma estrutura interna, conhecida pelos programas que os
usam. Todo Sistema Operativo deve reconhecer pelo menos um tipo de
arquivo: seu próprio arquivo executável.
4.1.4. Acesso aos Arquivos

O acesso a arquivos pode ser realizado, basicamente, através de duas
maneiras.
▪
Acesso sequencial: nesse tipo de acesso os arquivos são lidos
em ordem sequencialmente, partindo do início, mas nunca
saltando e lendo fora de ordem. Esse tipo de acesso é muito
utilizado, como exemplo, leitura de mídias do tipo fita
magnética, além de leitura sequencial de programas fontes,
realizada por vários compiladores.
▪
Acesso Aleatório: em alguns tipos de mídias é possível ler bytes
ou registros de um arquivo fora da ordem. Esses arquivos são
chamados de arquivos de acesso aleatório.
Segundo Tanenbaum, em alguns Sistemas Operativos antigos, os

arquivos eram classificados por acesso sequencial ou por acesso
aleatório no momento em que estavam sendo criados. Entretanto, os
Sistemas Operativos modernos não fazem distinção, ou seja, todos os
seus arquivos são, automaticamente, de acesso aleatório.
91
4.1.5. Atributos de Arquivos

A maioria dos Sistemas Operativos associa várias informações extras a
um determinado arquivo. Essas informações geralmente são chamadas
de atributos de um arquivo. Os tipos de atributos variam de sistema
para sistema e nenhum sistema dispõe de todos os tipos de atributos
possíveis. Podemos enumerar uma série de atributos, como: pessoas que
podem acessar, senhas, criador, proprietário, comprimento do arquivo,
tempo de criação, tempo do último acesso, tempo da última
atualização, tamanho máximo, dentre outros.
4.1.6. Operações com Arquivos

A finalidade dos arquivos é armazenar informação e permitir que ela
seja recuperada posteriormente. Assim, os Sistemas de Arquivos
oferecem diferentes operações para armazenar e recuperar
informações. Dentre as várias operações possíveis sobre arquivos,
podemos destacar:
▪
Criar: operação utilizada para criar o arquivo.
▪
Apagar: operação utilizada para excluir um determinado
arquivo, liberando espaço de memória.
▪
Abrir: operação utilizada para abrir um arquivo e permitir
escrita ou leitura de informações.
▪
Fechar: operação utilizada para fechar um arquivo e manter
sua consistência.
▪
Ler: operação disponibilizada para ler informações do arquivo,
para poderem ser utilizadas.
▪
Escrever: operação para incluir alguma informação no arquivo.
92
UNIDADE Temática 4.2. Implementação de Arquivos.
Vários métodos são utilizados para implementar arquivos dentre eles se

destacam:
4.2.1. Alocação Contígua

Trata-se do exemplo mais simples de implementar, no qual é utilizado
um bloco de dados contíguo (sequencial) no disco para armazenar um
arquivo. Por exemplo, considerando um disco com blocos de 1k, um
arquivo com 20k ocuparia 20 blocos consecutivos. Este tipo de alocação
traz como principal vantagem a simplicidade de implementação e o
facto de ter um bom desempenho no acesso a um arquivo, pois um
arquivo inteiro pode ser lido com apenas uma operação.
Porém, a alocação contígua possui grandes desvantagens. A primeira

está no facto de que este tipo de alocação só é praticável caso seja
conhecido o tamanho do arquivo no momento de sua criação. Outra
desvantagem é que este tipo de alocação gera uma fragmentação no
disco.
Disco
Bloco
0
1 Bloco
Físico
2 Bloco 0
3 Bloco 1
Arquivo
4 Bloco 2
5 Bloco 3
6 Bloco 4
7
8
Figura 4.2: Arquivos por Alocação Contígua

4.2.2. Alocação por Lista Encadeada
Outro método para armazenar um arquivo é utilizando listas encadeadas
de blocos de disco. Cada bloco conterá, dessa forma, o seu
93
dado armazenado e um ponteiro para o bloco seguinte. A principal

vantagem de se utilizar a alocação por lista encadeada está no facto de
evitar o grande desperdício em disco comum na alocação contígua. Além
disso, para acessar todo o arquivo é suficiente armazenar apenas o
endereço de disco do primeiro bloco. Porém, a principal desvantagem da
utilização desse método é que o acesso aleatório é extremamente lento.
Além disso, considerando que cada bloco terá que guardar o endereço do
bloco seguinte, existe um gasto de memória adiciona.
Arquivo
Bloco 0 Bloco 1 Bloco 2 Bloco 3 Bloco 4
6 4 8 15 2
Bloco
Físico
Figura 4.3: Arquivos por Alocação por Lista Encadeada

4.2.3. Alocação por Lista Encadeada usando Índice
Uma maneira de tentar driblar as duas desvantagens de se utilizar
alocação por lista encadeada seria utilizar a palavra ponteiro de cada
bloco de disco de um arquivo e colocar em uma tabela ou em um índice
na memória.
Dessa forma, o bloco inteiro no disco estará disponível para

armazenamento de dados (não é necessário armazenar mais o ponteiro
para o próximo bloco). Além disso, o acesso aleatório é muito mais
fácil, pois a cadeia de blocos está toda em memória, não sendo
necessário qualquer referência ao disco. A Figura 4.4 ilustra a tabela
utilizada neste método de alocação para armazenar a sequência dos
blocos do arquivo representado pela lista encadeada da Figura 4.3.
94
Bloco
0
Físico
2 0
3
4 8
5
O Arquivo
6 4 começa aqui
7
8 15
9
10
11
12
13
14
15 2
16
Figura 4.4: Arquivos por Alocação por Lista Encadeada Utilizando Índice
UNIDADE Temática 4.3. Directórios
Os sistemas de arquivos têm, em geral, diretórios ou pastas para

controlar os arquivos, que, em muitos sistemas, também são
considerados arquivos.
4.3.1. Organização de Sistemas de Directórios

A maneira mais simples de se projectar um Sistema de Arquivos é ter
um diretório contendo todos os arquivos geralmente chamado de
diretório-raiz.
Esse sistema era muito comum, em parte, nos primeiros computadores

pessoais, pois havia somente um usuário. Porém, em um sistema com vários
usuários o problema de haver somente um diretório é que diferentes
usuários podem usar acidentalmente os mesmos nomes para seus
95
arquivos. Em consequência disso, esse esquema não é mais empregado

em sistemas multiusuário geralmente empregado em sistemas
embarcados (embedded Systems).
Directório-Raiz
A B c D
Figura 4.5: Sistemas de arquivos com um nível
Com a finalidade de evitar conflitos causados por diferentes usuários

escolhendo o mesmo nome para seus arquivos, a solução é oferecer um
diretório privado para cada usuário. Dessa forma, os nomes escolhidos
por um usuário não interfeririam nos nomes escolhidos por outro usuário,
podendo ocorrer de arquivos com o mesmo nome em dois ou mais
diretórios sem causar nenhum problema. Este esquema está ilustrado na
Figura 4.6.
Directório-Raiz
Directórios de
usuário
Arquivos
A B c D E
Figura 4.6: Sistemas de arquivos com dois níveis
96
Os conflitos de nomes entre os usuários são eliminados na hierarquia em

dois níveis, mas tal hierarquia não é satisfatória para os usuários com
um número muito grande de arquivos ou que desejam agrupar seus
arquivos de maneira lógica. Dessa forma, podemos utilizar uma
hierarquia geral, ou seja, uma árvore de diretórios, no qual cada
usuário pode ter tantos diretórios quanto necessários para agrupar os
seus arquivos de uma maneira natural.
Assim, essa capacidade de os usuários criarem um número arbitrário de

subdiretórios constitui uma poderosa ferramenta de estruturação para
organizar seus trabalhos. Por esse motivo, quase todos os modernos
sistemas de arquivos são organizados dessa forma.
Directório-Raiz
Directórios de
usuário
Arquivos
A c D
Sub-directórios
de usuário
c D E
Figura 4.7: Sistemas de arquivos hierárquico

4.3.2. Nomes de Caminhos
Quando organizamos um Sistema de arquivos baseado em uma árvore
de diretórios, torna-se necessário uma forma de especificar o nome dos
arquivos, e para isso, geralmente são usados dois métodos: nome de
caminho absoluto e nome de caminho relativo.
97
Um nome de caminho absoluto é formado pelo caminho entre o

diretório-raiz e o arquivo específico. Os nomes de caminhos absolutos
sempre iniciam no diretório-raiz e são únicos. Em Sistemas de Arquivos
do Windows os componentes do caminho são separados por \. Já em
Sistemas de Arquivos do Unix são separados por /.
Já o nome de caminho relativo é utilizado em conjunto com o conceito

de diretório de trabalho (também chamado diretório actual). Assim, um
usuário pode designar um diretório de trabalho específico e quaisquer
nomes de caminhos que não comecem a partir do diretório-raiz são
interpretados em relação ao diretório do trabalho. Como exemplo,
imagine que o diretório de trabalho de um usuário UNIX seja
/home/usuário, então o arquivo, cujo nome de caminho absoluto seja
/home/usuário/arquivo.txt pode, simplesmente, ser interpretado como
arquivo.txt.
Cada processo possui seu próprio directório de trabalho. Dessa forma,

quando um processo altera seu directório de trabalho e depois sai,
nenhum outro processo é afectado e nenhum vestígio da mudança é
deixado no sistema de arquivos. Por outro lado, procedimentos de
bibliotecas raramente alteram o directório de trabalho e, quando
precisam fazê-lo, eles sempre voltam para onde estavam, se não o
resto do programa poderá não funcionar.
A maioria dos Sistemas Operativos que suportam um sistema de

diretório hierárquico tem duas entradas especiais em cada diretório:
ponto (.) e o ponto-ponto (..). O ponto refere-se ao diretório actual,
enquanto que o ponto-ponto se refere ao diretório pai (diretório
anterior). Como exemplo, se um usuário tiver trabalhando no directório
/home/usuário, caso utilize o ponto-ponto, ele estará subindo na árvore
de diretórios, ou seja, referenciando o diretório /home. Se ele utilizar o
ponto, estará referenciando o próprio diretório (/home/usuário).
4.3.3. Operações com Directórios

Como os arquivos, existem diversas chamadas ao sistema para gerir
diretórios, que, também, variam de sistema para sistema. As operações
mais importantes são:
98
▪
Criar: utilizado para criar um determinado diretório.
Inicialmente é criado um diretório vazio, contendo apenas o
ponto e o ponto-ponto.
▪
Apagar: operação utilizada para apagar um determinado
diretório. Normalmente, só é possível excluir um diretório vazio.
▪
Abrir diretório: a partir desta operação é possível abrir um
diretório. Antes de ler um diretório é preciso, inicialmente, abri-
lo.
▪
Fechar diretório: operação utilizada para fechar um diretório.
▪
Ler: esta chamada é utilizada para ler o conteúdo de um
diretório.
▪
Renomear: fornece a possibilidade de alterar o nome do
diretório.
4.3.4. Implementação de Directórios

O Sistema Operativo utiliza o nome de caminho fornecido pelo usuário
para poder localizar a entrada de diretório. A entrada de diretório
contém informações necessárias para a localização dos blocos de disco.
Essas informações podem ser o endereço do arquivo inteiro ou o número
do primeiro bloco, por exemplo. Assim, a principal função do sistema
de directório é mapear o nome ASCII do arquivo para as informações
necessárias para localizar os dados em disco (Tanenbaum).
Sumário
Nesta Unidade temática 4 fizemos uma breve introdução sobre Sistema de

Arquivos. Abordamos os arquivos do ponto de vista do usuário, falamos
sobre as regras de nomeação de arquivos, como os arquivos são
estruturados, vimos que os Sistemas Operacionais suportam vários tipos de
arquivos e como podem ser acessados, bem como os seus atributos e as
operações com arquivos. Vimos as vantagens e desvantagens de cada um
dos métodos. Estendemos a nossa abordagem falando sobre Directórios,
abordando sobre a organização de Sistemas de Directórios onde vimos
que a forma mais simples de se projectar um Sistema de
99
Arquivos é ter um directório contendo todos os arquivos geralmente

chamados de Directório-raiz.
Perguntas
1. Defina Arquivos.
2. Segundo Tanenbaum como são estruturados os arquivos.
3. Mencione os tipos de Arquivos.
4. Como pode ser realizado o acesso aos arquivos.
5. Mencione os métodos utilizados na implementação de arquivos.
6. Qual dos métodos é eficiente na implementação de arquivos.
7. Qual a maneira mais simples de se projectar um Sistema
de Arquivos.
8. Qual o problema de haver somente um directório em
sistema com vários usuários.
Respostas:
1. Rever Página 87.
4. Rever página 91e 92.
6. Rever página 93 e 94
Pergunta
Tema1
1. Aonde é aplicado a estrutura de Árvore de Registo.
2. Qual a vantagem que os arquivos ACSII apresentam.
3. A leitura de mídias do tipo fita magnética, que tipo de acesso
aos arquivos é.
4. Mencione as vantagens e desvantagens de cada um dos
métodos utilizados na implementação de arquivos.
5. Qual a finalidade de uso de Sistemas de Arquivos com dois níveis.
6. Como podemos eliminar os conflitos de nomes entre os usuários.
7. Porquê a hierarquia em dois níveis não é satisfatória para os
usuários.
100
Bibliografia
▪
▪
▪
▪
▪
Elsevier,2008.
▪
2008
▪
▪
Edition, 2015
▪
101
TEMA – 5: SISTEMAS DE ENTRADA/SAÍDAS.
UNIDADE Temática 5.1. Introdução, aos Sistemas de Entradas/Saídas

UNIDADE Temática 5.2. Princípios de Hardware de E/S
UNIDADE Temática 5.3. Princípios de Software de
E/S UNIDADE Temática 5.4. Deadlocks
▪
Explicar os princípios de Hardware e do Software de E/S.
▪
Trataremos da concorrência entre os processos para alocar os dispositivos em
geral e como esse acesso poder gerar uma situação de Deadlocks ou Impasse.
Objectivos
específicos
UNIDADE Temática 5.1. Introdução, aos Sistemas de Entradas/Saídas
Uma das principais funções de um Sistema Operativo é controlar e gerir

todos os dispositivos de entrada e saída disponíveis no Sistema de
Computação. Os dispositivos de entrada e saída são responsáveis por
fazer a comunicação do sistema em si com o usuário ou meio externo. O
Sistema Operativo deve ser responsável por fazer a interface entre os
dispositivos em si e o resto do Sistema Computacional, enviando
comandos para os dispositivos, capturando interrupções e tratando
possíveis erros. Além disso, o Sistema Operativo deve apresentar uma
interface amigável para o usuário, escondendo toda complexidade de
hardware, típico dos dispositivos de entrada e saída. Por sua vez o
computador se tornaria em um equipamento inútil se não existisse
alguma forma do meio externo em comunicar com ele. Sendo que esses
dispositivos de entrada e saída (E/S) são responsáveis por fazer essa
comunicação entre o sistema, de um modo geral, e o meio externo.
Nessa unidade temática abordaremos sobre os princípios de hardware

e de software de E/S, ou seja, como o software que controla e faz a
comunicação com um dispositivo é organizado. Esta organização é
ilustrada na Figura 5.1.
102
Software de E/S no
espaço do usuário
Software de E/S
Independente de dispositivo Princípios de
Software
Drives
Manipulador de Interrupções
Controladores
Princípios de
Hardware
Dispositivos de E/S
Figura 5.1: Princípios de hardware e de software de E/S
UNIDADE Temática 5.2. Princípios de Hardware de Entradas/Saídas
Diferentes pessoas veem o hardware de E/S de maneiras diferentes.

Segundo Tanenbaum, o hardware de entrada e saída pode ser visto
sob dois pontos de vista:
▪
Engenheiros elétricos veem em termos de chips, cabos, motores,
suprimento de energia e todos os outros componentes físicos que
compreendem o hardware.
▪
Programadores olham para a interface apresentada ao
software — os comandos que o hardware aceita, as funções
que ele realiza e os erros que podem ser reportados de volta.
103
Neste modulo, estamos interessados na programação de dispositivos de

E/S, e não em seu projecto, construção ou manutenção; portanto, nosso
interesse é saber como o hardware é programado, não como ele funciona
por dentro. Não obstante isso, a programação de muitos dispositivos de
E/S está muitas vezes intimamente ligada à sua operação interna (assunto
de maior interesse dos engenheiros eléctricos).
5.2.1. Dispositivos de Entrada/Saídas

O dispositivo de entrada/saída é o mecanismo utilizado para fazer a
interface entre o mundo exterior e o sistema e sem ele o computador não
teria muita funcionalidade. É possível encontrar uma grande diversidade
de dispositivos de entrada e saída, como: teclados, mouses, monitor de
vídeo, impressora, scanners, dentre outros. A Figura 5.2 ilustra.
Figura 5.2: Dispositivos de E/S
Os dispositivos de entrada e saída, dependendo do sentido do fluxo de

informações entre o sistema e o dispositivo, podem ser divididos, em grosso
modo, em dispositivos de entrada, dispositivos de saída ou dispositivos de
entrada e saída. Os dispositivos de entrada são caracterizados por conter
um fluxo de informações do dispositivo para o sistema, ou seja, são
responsáveis por inserir no sistema informação do mundo externo. Já os
dispositivos de saída são caracterizados pelo fluxo de informações do
sistema para o mundo externo, ou seja, responsáveis por disponibilizar
respostas ao mundo externo. Já os dispositivos e
104
entrada e saída contemplam os dois fluxos. A tabela 5.1 abaixo ilustra

como os dispositivos são caracterizados.
Entrada Saída Entrada/Sáida
Teclado Monitores (e placas Drives de discos de

Rato, touchpad, pointing gráficas) disquetes, disco
Device Projectores de vídeo rígido,gravador CD/DVD,
Scanner e de imagem Pen Disk, etc.
Câmaras digitais Impressoras Impressora multifunções
(fotográficas e de video) Placas de som
Caneta öptica Placas de captura e exibição
Leitor código de barras de vídeo, placa de televisão
Joystick Placas de rede
Sistemas de identificação Modem, routers, pontos de
acesso
Tabela 5.1: Caracterização dos dispositivos de E/S
Segundo Tanenbaum, os dispositivos também podem ser divididos de

um modo geral em duas categorias: dispositivos de bloco e
dispositivos de caractere. Os dispositivos de bloco são caracterizados
por armazenar informações em blocos de tamanhos fixos, cada um com
seu endereço próprio. A propriedade essencial desse tipo de
dispositivos é que é possível ler ou gravar blocos independentemente
um do outro. Discos rígidos, discos Blu-ray e pen drives são dispositivos
de bloco comuns. O disco é um bom exemplo deste tipo de dispositivo.
Já o dispositivo de caractere envia ou aceita um fluxo de caracteres,

desconsiderando qualquer estrutura de bloco. Ele não é endereçável e
não tem qualquer operação de busca. Impressoras, interfaces de rede,
mouses (para apontar), ratos (para experimentos de psicologia em
laboratórios) e a maioria dos outros dispositivos que não são parecidos
com discos podem ser vistos como dispositivos de caracteres.
Embora esta classificação seja, de forma geral, muito utilizada,

segundo Tanenbaum, existem dispositivos que não são classificáveis em
nenhum desses tipos. Como exemplo, tomemos por base os relógios. Os
relógios são dispositivos que geram interrupções em intervalos definidos
de tempo. Este dispositivo não se encaixa nos dispositivos de bloco, pois
não possuem estrutura de blocos e, também, não se encaixam como
dispositivos de caractere, pois não gera nenhum fluxo de caracteres.
105
5.2.2. Controladores de Dispositivos

Para que os dispositivos se comuniquem com o sistema, eles são ligados
ao computador através de um componente de hardware chamado de
interface. Assim, os dispositivos não estão ligados directamente aos
barramentos do computador. Devido a diversidade de tipos de
dispositivos, que abstrai diferentes formas de operações e
complexidade, as interfaces empregam no seu projecto um outro
componente de hardware conhecido como controlador de dispositivo.
Unidades de E/S consistem, em geral, de um componente mecânico e
um componente eletrônico.
O controlador de dispositivo (chamada também de adaptador de

dispositivo) trata-se de um componente eletrônico geralmente na forma
de uma placa de circuito impresso, que pode ser inserido na placa mãe
do computador. Trata-se de um componente mecânico. Um controlador
pode manipular mais de um dispositivo e, quando padronizadas,
podem ser fabricados por diversas empresas. Como exemplo de
controladores, temos os controladores de disco IDE ou SCSI.
Cada controlador deve saber especificamente como o dispositivo a ele

relacionado funciona, a fim de que possa enviar comandos a serem
realizados. Basicamente, um controlador tem a função de converter um
fluxo serial de bits em um bloco de bytes e executar uma correção de
erros. Este bloco de bytes, montado em um buffer interno do
controlador, após verificado erros, pode ser copiado para a memória
principal. A maioria dos Sistemas Operativos quase sempre lidam com
o controlador, não com o dispositivo.
Os controladores são formados de um conjunto de registradores que são

enxergados pelo processador. Esses registradores recebem ordens do
processador, fornecem o estado de uma operação ou permitem a leitura
ou escrita de dados do dispositivo. O Sistema Operativo quando deseja
dar algum comando ao controlador acessam esses registradores (cada
registrador possui um endereço). Os endereços dos registradores podem
fazer parte do espaço normal de endereçamento de memória. Esse sistema
é conhecido como mapeamento de entrada e saída em memória.
106
Figura 5.3: Exemplo de um disco com interface IDE e SCSI.

5.2.2.1. Controladores que suportam Acesso Direto à Memória (DMA)
Os controladores comuns (sem acesso directo à memória) recebem um
fluxo de caracteres, converte para um bloco, armazenado em seu
buffer, depois verifica possíveis erros. Por seguinte, o controlador gera
uma interrupção no Sistema Operativo, que por sua vez, começa a ler o
bloco do buffer do controlador, cada byte por vez, e armazena-os na
memória principal. Esta operação, naturalmente, exige desperdício de
CPU. O Acesso Direto à Memória (DMA – Direct Memory Access) é um
mecanismo criado para liberar a CPU do trabalho de cópia dos dados
do controlador para a memória. O controlador DMA é conectado
directamente ao barramento de dados e de endereços do computador,
para ter a capacidade de acessar directamente endereços de
memória. Com o controlador DMA, após o bloco ter sido lido do
dispositivo completamente e verificado possíveis erros, ele copia o
primeiro byte para o endereço de memória principal especificado pelo
endereço de memória DMA. Após terminar a transferências dos dados
para a memória principal, o controlador DMA gera uma interrupção
para o Sistema Operativo, que ao ser iniciado já encontra o dado em
memória principal.
Segundo Oliveira, a técnica de DMA é mais eficiente quando a

operação de entrada e saída envolve a leitura ou escrita de muitos
dados, como exemplo, uma leitura de disco.
107
Nem todos os computadores utilizam a técnica de DMA. A justificativa

disso é o facto de que a CPU, geralmente é bem mais rápida que o
controlador DMA e pode fazer o trabalho de cópia de dados para a
memória muito mais rápida.
UNIDADE Temática 5.3. Princípios de Software de Entradas/Saídas
O software de entrada e saída, geralmente é organizado em uma

estrutura de camadas, no qual as camadas mais baixas têm como
principal função esconder das camadas mais altas as peculiaridades do
hardware. Já as camadas mais altas têm como principal função
apresentar uma interface amigável e simples para o usuário final.
Algumas metas de software de entrada e saída podem ser apontadas:
▪
Independência de dispositivo: deve ser possível escrever
programas que podem, por exemplo, lêr arquivos de qualquer
dispositivo.
▪
Atribuição uniforme de nomes: o nome de um arquivo ou de
um dispositivo não pode depender do dispositivo.
▪
Tratamento de erros: os erros devem ser tratados o mais perto
possível do hardware.
▪
Transferências síncronas ou assíncronas: a maior parte dos
dispositivos de E/S são assíncronos e os programas dos usuários
são mais fáceis de implementar através de bloqueios. Assim o
Sistema Operativo deve fazer com que as operações pareçam,
de facto, com bloqueios para os programas do usuário.
▪
Dispositivos compartilháveis ou dedicados: O Sistema Operativo
deve ser capaz de tratar dispositivos tanto dedicados como
compartilhados de uma maneira que não gere problemas.
5.3.1. Manipuladores de Interrupções

As interrupções devem ser escondidas do sistema. O ideal é bloquear um
processo que inicia uma operação de E/S e mantê-lo bloqueado até que
108
a operação de E/S complete e a interrupção tenha ocorrido. O

importante a se saber é que quando uma interrupção é gerada, o
processo é desbloqueado, passando para um estado capaz de ser
executado.
5.3.2. Drives de Dispositivos

O driver de dispositivo (device driver) é composto de um conjunto de
módulos de software cada um implementado para fornecer mecanismos de
acesso a um dispositivo de entrada e saída específico. Assim, cada driver
de dispositivo trata de um tipo de dispositivo ou de uma classe de
dispositivos correlacionados. De modo geral, um driver é responsável por
aceitar uma solicitação abstrata (por exemplo, ler alguma informação) e
cuidar para que esta solicitação seja atendida. Assim o driver de um
dispositivo tem o conhecimento de como funciona o controlador.
5.3.3. Software de E/S Independente de Dispositivos

A principal função do software de E/S independente de dispositivo é
executar funções que são comuns para vários dispositivos e oferecer
uma interface uniforme para o software de nível de usuário.
Segundo Oliveira, podemos enumerar alguns serviços sob

responsabilidade dessa camada:
▪
Nomeação de Dispositivo: cada dispositivo deve receber um
nome lógico e ser identificado a partir dele.
▪
Buferização: buffer é uma zona de memória temporária
utilizada para armazenar dados enquanto eles estão sendo
transferidos entre as diferentes camadas do software de E/S.
▪
Cache de Dados: armazenar na memória um conjunto de dados
que estão sendo frequentemente utilizados.
▪
Alocação e Liberação: devido a alguns dispositivos admitirem,
no máximo, um usuário por vez, o software de E/S deve gerir a
alocação, liberação e uso destes dispositivos.
▪
Tratamento de Erros: o software de E/S deve fornecer
mecanismos de manipulação de erros, informando à camada
superior o sucesso ou fracasso de uma operação.
109
5.3.4. Software de E/S de Nível de Usuário

A visão dos dispositivos de E/S para o usuário consiste de bibliotecas
vinculadas em programas de usuários. Essas bibliotecas são fornecidas
pelas linguagens de programação e podem ser utilizadas pelos usuários e
ligadas com seus programas para compor o arquivo executável.
As funções de entrada e saída são dependentes e específicas de cada

linguagem de programação. Por exemplo, na linguagem C as funções
printf e scanf são utilizadas para impressão formatada e leitura,
respectivamente. As bibliotecas de entrada e saída não fazem parte
do núcleo do Sistema Operativo. Elas são associadas às várias
linguagens de programação.
UNIDADE Temática 5.4. Deadlocks
O Sistema Computacional está repleto de recursos, que podem ser

utilizados pelos processos. Geralmente, a quantidade de recursos
disponíveis é muito menor que a quantidade de processos solicitando
esse recurso. Dependendo do recurso, este facto pode gerar uma
situação de bloqueio eterno do processo, o que é muito ruim para os
sistemas. Podemos, assim, definir que um conjunto de processos está em
deadlock ou impasse quando cada um desses processos está bloqueado
esperando um evento que só pode ser gerado por um outro processo
desse conjunto. Como todos os processos estão bloqueados, nenhum
deles poderá gerar um evento e, naturalmente, todos continuarão nessa
situação. Um bom exemplo apontado por Tanenbaum trata-se de dois
processos querendo ler dados de um CD e imprimindo em uma
impressora. Suponha que o processo A solicite a impressora, que é
disponibilizada. De forma análoga, o processo B solicita o CD-ROM,
que lhe é disponibilizado. Agora o processo A solicita o CD-ROM,
enquanto que o processo B solicita a impressora. Como ambos os
recursos já estão alocados, o processo A e B serão bloqueados.
110
Nessa situação eles continuarão indefinidamente, pois nenhum processo

terá como se finalizar e, por fim, liberar o recurso já alocado. Esses
processos geram um deadlock. Uma ilustração de deadlock bem
interessante, trazida no livro de Silberschatz, seria a seguinte: “Quando
dois trens se aproximarem um do outro em um cruzamento, ambos
deverão parar completamente e nenhum deles partirá novamente até
que o outro o tenha feito”.
É importante destacar, que os impasses podem ser gerados tanto por

recursos de hardware quanto por recursos de software. Um recurso de
software seria um impasse gerado no acesso a registros de um banco de
dados. Sendo assim, trataremos o termo recurso de uma forma geral.
Os recursos podem ser divididos em dois tipos:
▪
Recursos preemptíveis: trata-se de recursos que podem ser
retirados de um determinado processo sem gerar problema
algum. Por exemplo, a memória.
▪
Recursos não-preemptíveis: trata-se de recursos que não
podem ser retirados de um determinado processo sem causar
problemas. Por exemplo, é inviável retirar a impressora de um
determinado processo que começou a imprimir sua saída.
5.4.1. Condições para um Deadlocks

Coffman demonstrou em 1971 que existe quatro condições para que
haja um deadlock ou impasse:
▪
Condição de exclusão mútua: somente um processo de cada
vez pode acessar um recurso. Caso contrário, o recurso estará
disponível.
▪
Condição de posse e espera: um processo deve estar de posse
de um recurso e solicitando novos recursos.
▪
Condição de não preempção: os recursos concedidos aos
processos não podem ser retirados deles.
▪
Condição de espera circular: deve haver uma cadeia circular de
dois ou mais processos, cada um dos quais está esperando um
recurso já segurado pelo próximo membro da cadeia e, assim
111
por diante.
5.4.2. Modelagem de Deadlocks através de Grafos

Os deadlocks ou impasses podem ser modelados através de grafos
dirigidos ou grafos de alocação de recursos. Esses grafos podem ter
dois tipos de nós: processos e recursos. Os nós de processos são
representados através de círculos e os nós de recursos através de
quadrados, como mostrado na Figura 5.4.
Processo 1 Recurso 1
P1 R1
Figura 5.4: Nós de Processos e Recursos na Modelagem de Deadlocks
Adiante, um arco de um processo apontando para um recurso significa

que o processo está bloqueado esperando esse recurso. Já um arco de
um recurso para um processo significa que este recurso está alocado
para o processo. A Figura 5.5 ilustra estes dois arcos, respectivamente.
P1 R1
R1 P1
Figura 5.5: Arco de Processo par Recurso e de Recurso para Processo
Definido a modelagem do grafo, podemos mostrar que se o gráfico

não contiver um ciclo fechado, nenhum processo estará em uma situação
de deadlock. Porém, se o ciclo fechado for formado, poderemos ter um
deadlock. A Figura 5.6(a) mostra um grafo sem deadlock e a Figura
5.6(b) mostra uma situação de deadlock.
112
P1 P1
R1 R1 R1 R1
P1 P1
(a) (b)
Figura 5.6: Modelagem através de Grafos. (a) Situação onde não está
caracterizado deadlock. (b) situação onde se caracteriza um deadlock.
5.4.3. Métodos de Lidar com Deadlocks

Existem várias formas de lidar com deadlocks. Em geral, temos quatro
métodos:
▪ Ignorar completamente o problema.
▪
Detectar e recuperar uma situação de deadlock.
▪
Prevenir um deadlock através da negação das quatros
condições de Coffman.
▪
Impedimento de um deadlock através de uma alocação
dinâmica cuidadosa de recursos.
5.4.3.1. Algoritmo do Avestruz

A forma mais simples de lidar com deadlock é chamada de Algoritmo
do Avestruz. Reza a lenda, que o avestruz, em um problema qualquer,
enfia sua cabeça na areia e nem se preocupa com o que está
acontecendo, ou seja, finge que não há nenhum problema.
Esta solução é utilizada em muitos Sistemas Operacionais, inclusivo

UNIX. Assim, quando acontece uma situação de impasse, o SO
simplesmente ignora o problema, passando a responsabilidade do
usuário para tomada de decisões.
5.4.3.2. Detecção e Recuperação

Uma outra técnica para lidar com uma situação de impasse é a técnica
de detecção e recuperação. Nessa técnica, o Sistema Operativo não se
preocupa em prevenir um deadlock. Ao invés disso, o sistema fica
113
monitorando as solicitações e liberações de recursos.
Caso um recurso seja solicitado e a nova situação gere um impasse, o

Sistema Operativo tentará eliminar um processo do ciclo. Se o ciclo ainda
existir, outro processo será eliminado até que o ciclo seja quebrado.
5.4.3.3. Prevenção de Deadlocks

Outra estratégia é impor situações para os processos de tal forma que
um impasse seja impossível de acontecer. Essas situações seria negar
pelo menos uma das condições para que ocorra um deadlock,
modeladas por Coffman.
▪
Condição de exclusão mútua - Caso nenhum recurso fosse
atribuído de forma exclusiva a um único processo, negaríamos
essa condição e não teríamos um impasse. Só que existe recursos
impossíveis de serem atribuídos a mais de um processo, como a
impressora.
Uma solução seria utilizar técnicas de spool, onde os processos,

ao invés de acessar o recurso directamente, acessariam um
espaço de memória e gravariam suas informações. A partir
desse espaço de memória, um único processo iria ler as
informações e enviar para o recurso específico. Porém, nem todo
recurso é possível se utilizar técnicas de spool.
▪
Condição de posse e espera - Na segunda condição, se for
possível fazer que um processo, segure algum recurso, não
solicite outros recursos, eliminaríamos esta condição e,
naturalmente, uma possível situação de impasse.
Uma solução seria fazer que, um processo solicite todos os seus

recursos antes de iniciar a execução. Caso os recursos estejam
disponíveis, ele executa. Caso contrário, ele precisa esperar. O
problema para esta alternativa é que, na maioria dos casos, os
processos não sabem a priori quais recursos irá precisar.
▪
Condição de não preempção - Atacar a terceira condição de
Coffman, sem sombra de dúvidas, é uma das soluções menos
promissora, pois certos recursos são, intimamente, não
preemptíveis. Mais uma vez, tomemos como exemplo a
114
impressora. Tomar a impressora de um processo no meio da

impressão é uma atitude um tanto sem lógica.
▪
Condição de espera circular - A última condição diz que, para
se ter um deadlock, é formado uma cadeia circular de dois ou
mais processos, cada um dos quais está esperando um recurso já
segurado pelo próximo membro da cadeia e, assim por diante.
Consideraremos uma possibilidade: enumerar globalmente todos

os recursos disponíveis. Assim, a regra seria que processos
podem solicitar recursos sempre que desejarem, mas todas as
solicitações devem ser feitas em ordem numérica.
Com essa regra, nunca seria formado uma situação circular.

Considere a situação de um processo 1, com um recurso 1
alocado e um processo 2 com um recurso 2 alocado. Se o
processo 1 solicitar o recurso 2 e o processo 2 solicitar o recurso
1 formaríamos um ciclo e teríamos uma situação de impasse.
Porém, com essa regra, o processo 2 (com recurso 2 alocado)
não tem permissão para solicitar o recurso 1. Assim, o impasse é
impossível. A Figura 5.7 ilustra essa solução.
P1 P2
R1 R2
Figura 5.7: Recursos ordenados numericamente

5.4.3.4. Impedimento de Deadlocks
O sistema pode evitar que um impasse ocorra mediante a alocação
cuidadosa dos recursos disponíveis. Para que isso ocorra, o sistema
precisará de informações adicionais a priori de quais recursos um
processo irá requisitar e usar durante sua execução.
115
Analisaremos o algoritmo do banqueiro para um recurso e para

múltiplos recursos, que são utilizados para avaliar se uma alocação de
recursos é considerada segura ou não.
▪
Algoritmo do Banqueiro para um Único Recurso - O algoritmo
do banqueiro foi proposto por Dijkstra (1965). Este algoritmo é
baseado na mesma ideia de um banqueiro de uma pequena
cidade para garantir ou não crédito a seus clientes. A ideia é
que um banco jamais possa alocar todo seu dinheiro disponível
em caixa de tal modo que não possa mais atender às
necessidades de todos os seus clientes.
Esta analogia pode ser utilizada pelo Sistema Operativo,

considerando que os clientes são os processos, os recursos são as
linhas de crédito e o banqueiro trata-se do Sistema Operativo
em si. Um processo ao entrar no sistema, declara a quantidade
máxima de recursos que ele necessitará para executar. Esta
quantidade não pode extrapolar a quantidade deste recurso
disponível no sistema.
A Figura 5.8 ilustra quatro processos no sistema, com a

quantidade de recursos alocados e a quantidade máxima que
cada um necessita para poder executar, além da
disponibilidade desse recurso no sistema. Essa listagem
apresentada na Figura 5.8 é chamada de um estado.
Recurso
Processo Alocado Máximo
A 0 6
B 0 5
C 0 4
D 0 7
Disponíveis: 10
Figura 5.8: Estado inicial contendo quatro processos e a quantidade
máxima de recursos necessários.
116
Quando um determinado processo solicitar uma quantidade dos

recursos disponíveis, o sistema deverá determinar se esta
alocação deixará o sistema em um estado seguro. Assim,
considera-se um estado seguro se existir uma sequência de
outros estados que leva todos os processos a solicitarem seus
recursos máximos.
Nesse caso, o estado representado pela Figura 5.9 é

considerado um estado seguro, pois o processo C ainda terá
condição de alocar a sua quantidade de recursos máxima e,
naturalmente, executar suas atividades, finalizar e liberar os
recursos para serem utilizados pelos outros processos. Dessa
forma, com esse estado não teremos uma situação de deadlock.
Recurso
A 1 6
B 1 5
C 2 4
D 4 7
Disponíveis: 2
Figura 5.9: Estado considerado seguro no Algoritmo do Banqueiro
para
Único Recurso.
Porém, se o sistema, ao invés de disponibilizar os dois recursos

livres no sistema para o processo C, disponibilizasse um recurso
para o processo B, o estado gerado seria um estado não
seguro, pois com apenas um recurso disponível, nenhum dos
processos do conjunto iria conseguir finalizar e,
consequentemente, teríamos uma situação de impasse. A Figura
5.10 representa este estado não seguro.
117
Recurso
A 1 6
B 2 5
C 2 4
D 4 7
Disponíveis: 1
Figura 5.10: Estado considerado não seguro no Algoritmo doBanqueiro
para Único Recurso.
▪
Algoritmo do Banqueiro para Múltiplos Recursos - O
algoritmo do banqueiro pode ser generalizado para vários
processos e várias classes de recursos, cada um com uma
quantidade diversificada.
A modelagem desse algoritmo é feito através de duas matrizes:

a primeira contendo os recursos alocados aos processos e a
segunda contendo a quantidade ainda necessária de cada
recurso por processo. Temos, também, três vectores: um vector E
que mostra a quantidade de recursos existentes no sistema, um
vector A que mostra a quantidade de recursos já alocados e um
vector L que mostra a quantidade de recursos livres. A Figura
5.11 mostra esta modelagem.
118
Processo R1 R2 R3 R4 Processo R1 R2 R3 R4
A 0 0 0 0 A 4 1 1 1
B 0 0 0 0 B 0 2 1 2
C 0 0 0 0 C 4 2 1 0
D 0 0 0 0 D 1 1 1 0
E 0 0 0 0 E 2 1 1 0
Recurso Alocados Recurso ainda necessários

Vector E = (6 3 4 2)
Vector A = (0 0 0 0)
Vector L = (6 3 4 2)
Figura 5.11: Modelagem do Algoritmo do Banqueiro para Múltiplos
Recursos.
Verifique a partir da Figura 5.11, que, por exemplo, o processo

A necessita de 4 recursos R1, 1 recurso R2, 1 recurso R3 e 1
recurso R4 para executar. Verifique também que o sistema
contém 6 recursos R1, 3 recursos R2, 4 recursos R3 e 2 recursos
R4. O algoritmo do banqueiro para Múltiplos recursos funciona
da seguinte forma:
▪
Procurar uma linha da matriz de recursos ainda
necessários, no qual todas as posições sejam menores ou
iguais ao vector de recursos livres. Se não existir essa
linha, nenhum recurso conseguirá finalizar e teremos,
enfim, um impasse.
▪
Caso um processo execute e se finalize, os recursos por
ele alocados serão disponibilizados e poderão ser
utilizados por outro processo.
No caso de vários processos (linhas da matriz) tiverem condições

de se finalizarem, independente de qual será escolhido, o
algoritmo resultará em um estado seguro.
A Figura 5.12 representa um estado seguro. Verifique, por

exemplo, que o processo D, que já possui alocado um recurso R1,
um recurso R2 e um recurso R4, precisa apenas de um recurso R3.
Se verificarmos o vector de recursos livres, podemos verificar que
119
ainda existem dois recursos R3 livres, ou seja, a linha (0 0 1 0) é

menor que o vetor (1 0 2 0). Assim, este estado pode ser
considerado seguro.
A 3 0 1 1 A 1 1 0 0
B 0 1 0 0 B 0 1 1 2
C 1 1 1 0 C 3 1 0 0
D 1 1 0 1 D 0 0 1 0
E 0 0 0 0 E 2 1 1 0

Vector E = (6 3 4 2)
Vector A = (5 3 2 2)
Vector L = (1 0 2 0)
Figura 5.12: Estado considerado seguro no algoritmo do Banqueiro para
Múltiplos Recursos.
Entretanto, se fosse atribuído um recurso R3 para os processos B

e E, o novo estado gerado não seria seguro, pois não existiria
uma linha menor que o vetor de recursos livre. Analise através
da Figura 5.13 esta situação impasse.
A 3 0 1 1 A 1 1 0 0
B 0 1 1 0 B 0 1 0 2
C 1 1 1 0 C 3 1 0 0
D 1 1 0 1 D 0 0 1 0
E 0 0 1 0 E 2 1 0 0

Vector E = (6 3 4 2)
Vector A = (5 3 4 2)
Vector L = (1 0 0 0)
Figura 5.13: Estado considerado não seguro no algoritmo do Banqueiro
para Múltiplos Recursos.
120
Sumário
Na Unidade temática 5 estudamos sobre a Gestão de Entrada/Saída.

Vimos que é através dos dispositivos de entrada/ saída que é feito a
ligação entre o sistema e o mundo exterior. Onde abordamos os
princípios de Hardware e Software de E/S. Podemos ver como o
Software que controla e faz a comunicação com um dispositivo e a sua
organização. Mais também abordamos sobre concorrência entre os
processos para alocar os dispositivos e como esse acesso pode gerar
situações de deadlock ou impasse.
Perguntas
1. Nos dispositivos de E/S qual a principal função do
Sistema Operativo.
2. Como pode ser visto o hardware de E/S segundo Tanenbaum.
3. Como podem ser vistos os dispositivos de E/S, dependendo do
sentido do fluxo da informação entre o sistema e o dispositivo.
4. Segundo Tanenbaum, os dispositivos podem ser divididos
em duas categorias. Mencione-os.
5. Como é organizado o software de E/S.
6. Qual a função da camada mais alta.
7. Qual a função do software de E/S independente de dispositivo.
8. Quando que um processo se encontra em deadlock ou impasse.
9. Diga como os deadlocks ou impasses podem ser modelados.
Respostas:
8. Rever página 110
Perguntas
1. Qual a responsabilidade que os dispositivos de E/S têm.
2. O engenheiro Eléctrico no princípio de hardware de E/S têm
uma visão diferente do programador. Fale da visão que o
engenheiro tem.
3. Como se caracterizam os dispositivos de Entrada.
121
4. Como são caracterizados os dispositivos de bloco e de caractere.

5. Mencione as metas de software de E/S.
6. Mencione as condições para que haja um impasse.
7. Como são representados os nós de processos nos grafos.
8. Quando podemos dizer que um processo se encontra ou não em
situação de deadlock ou impasse. Justifiquei apresentado a
figura da modelagem através de grafos.
9. Mencione os métodos de lidar com deadlocks.
Bibliografia
▪
▪
▪
▪
▪
Elsevier,2008.
▪
2008
▪
▪
Edition, 2015
▪
122

Manual de Sistemas Operativos

Enviado por

Direitos autorais:

Formatos disponíveis

Manual de Sistemas Operativos

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

Manual de Sistemas Operativos

Enviado por

Direitos autorais:

Formatos disponíveis

MANUAL DO CURSO DE LICENCIATURA EM

Gestão de Sistemas de Informação

ENSINO ONLINE. ENSINO COM FUTURO 2022

Direitos de autor (copyright)

Universidade Aberta Isced (UNISCED)

A Universidade Aberta Isced (UNISCED) agradece a colaboração dos seguintes indivíduos e

Autor Harold Chate

Coordenação Direcção Académica do UNISCED

Universidade Aberta Isced (UNISCED)

Revisão Científica e XXXXX

Ano de Publicação 2018

Local de Publicação UNISCED – BEIRA

TEMA I: INTRODUÇÃO AOS SISTEMAS OPERATIVOS 9

TEMA II: GESTÃO DE PROCESSOS 29

TEMA III: GESTÃO DE MEMÓRIA 61

TEMA IV: SISTEMAS DE ARQUIVOS 86

TEMA V: SISTEMAS DE ENTRADA/SAÍDAS 102

Unidade 5.2. Princípios de Hardware de Entradas/Saídas ......................................................... 103

Benvindo à Disciplina/Módulo de Sistemas

Ao terminar o estudo deste módulo de Sistemas Operativos deverá

▪ Perceber o princípio de funcionamento dos sistemas operativos.

Quem deveria estudar este módulo

Este Módulo foi concebido para estudantes do 2º ano do curso de

Como está estruturado este módulo

Este módulo de Sistemas Operativos, para estudantes do 2º ano do

A equipa dos académicos e pedagogos do UNISCED, pensando em

Auto-avaliação e Tarefas de avaliação

Tarefas de auto-avaliação para este módulo encontram-se no final

Use este espaço para dar sugestões valiosas, sobre determinados

Ao longo deste manual irá encontrar uma série de ícones nas

O principal objectivo deste campo é o de ensinar aprender a

Durante a formação e desenvolvimento de competências, para

1º Praticar a leitura. Aprender a Distância exige alto domínio de

2º Fazer leitura diagonal aos conteúdos (leitura corrida).

3º Voltar a fazer leitura, desta vez para a compreensão e

4º Fazer seminário (debate em grupos), para comprovar se a sua

5º Fazer TC (Trabalho de Campo), algumas actividades práticas ou

IMPORTANTE: Em observância ao triângulo modo-espaço-tempo,

Privilegia-se saber bem (com profundidade) o pouco que puder ler

Dica importante: não recomendamos estudar seguidamente por

Uma longa exposição aos estudos ou ao trabalho intelectual

Não estude na última da hora; quando se trate de fazer alguma

Organize na sua agenda um horário onde define a que horas e que

É importante identificar as ideias principais de um texto, pois será

debater assuntos relacionados com os conteúdos programáticos,

Tarefas (avaliação e auto-avaliação)

O estudante deve realizar todas as tarefas (exercícios, actividades

Muitos perguntam: Com é possível avaliar estudantes à distância,

75%, o que adicionado aos 25% da média de frequência,

TEMA – I: INTRODUÇÃO AOS SISTEMAS OPERATIVOS.

UNIDADE Temática 1.1. Introdução, aos Sistemas Operativos.

UNIDADE Temática 1.1. Introdução, aos Sistemas Operativos

Desde sua criação, os computadores sempre foram sistemas de elevada

Um Sistema Operativo é um conjunto de rotinas executado pelo

Se não existisse o Sistema Operativo, o usuário, para poder manipular o

sem considerar a grande quantidade de problemas e com uma grande

De um modo geral os Sistemas Operativos (SO) pode ser visto sobre

A definição de Sistemas Operativos do ponto de vista de uma máquina

O Rômulo faz uma abordagem diferente “em torno de um computador,

Tendo como base na abordagem do Rômulo, podemos nós perguntar e