Sop Apostila

Faculdade Cenecista de Varginha - MG
FACECA
Bacharelado em Sistemas de Informação
Prof. José Eduardo S. Gomes
Fevereiro / 2005
SUMÁRIO
Página
1. Sistemas Operacionais ......................................................................... 1

1.1. Conceitos Básicos de Sistema Operacional ..................................... 1
1.2. Máquina de Níveis ...................................................................... 2
1.3. Histórico .................................................................................... 3
1.3.1. Primeira Fase (1945-1955) ................................................. 3
1.3.2. Segunda Fase (1956-1965) ................................................. 3
1.3.3. Terceira Fase (1966-1980) ................................................. 3
1.3.4. Quarta Fase (1981-1990) ................................................... 4
1.3.5. Quinta Fase (1991-2000) ................................................... 4
1.4. Conceitos de Hardware e Software ................................................ 4
1.4.1. Conceitos de Hardware ....................................................... 5
1.4.1.1. Unidade Central de Processamento .............................. 5
1.4.1.2. Clock ....................................................................... 5
1.4.1.3. Registradores ........................................................... 5
1.4.1.4. Memória Principal ...................................................... 6
1.4.1.5. Memória Cachê ......................................................... 6
1.4.1.6. Memória Secundária .................................................. 6
1.4.1.7. Dispositivos de Entrada e Saída .................................. 6
1.4.1.8. Barramento .............................................................. 6
1.4.1.9. Pipeline ................................................................... 7
1.4.1.10. Ativação e Desativação do Sistema ............................ 7
1.4.1.11. Arquitetura RISC e CISC .......................................... 7
1.4.2. Conceitos de Software ........................................................ 7
1.4.2.1. Tradutor .................................................................. 8
1.4.2.2. Interpretador ............................................................ 8
1.4.2.3. Linker ...................................................................... 9
1.4.2.4. Loader ..................................................................... 9
1.4.2.5. Depurador ................................................................ 9
1.4.2.6. Linguagem de Controle .............................................. 9
1.4.2.7. Linguagem de Máquina .............................................. 9
1.4.2.8. Microprogramação ..................................................... 9
1.5. Tipos de Sistemas Operacionais .................................................... 10
1.5.1. Sistemas Monoprogramáveis/Monotarefa .............................. 10
1.5.2. Sistemas Multiprogramáveis/Multitarefa ............................... 10
1.5.2.1. Sistemas Batch ......................................................... 11
1.5.2.2. Sistemas de Tempo Compartilhado .............................. 11
1.5.2.3. Sistemas de Tempo Real ............................................ 11
1.5.3. Sistemas com Multiprocessadores ........................................ 11
1.5.3.1. Sistemas Fortemente Acoplados .................................. 12
1.5.3.2. Conceitos e Organização dos Sist. Fort. Acopl. ............. 12
1.5.3.3. Sistemas Fracamente Acoplados ................................. 13
1.5.3.4. Organização dos Sist. Fracamente Acoplados ................ 13
1.6. Sistemas Multiprogramáveis ......................................................... 14
1.6.1. Interrupção e Exceção ........................................................ 15
1.6.2. Operações de Entrada ........................................................ 16
1.6.3. Buffering .......................................................................... 17
1.6.4. Spooling ........................................................................... 18
1.6.5. Reentrância ...................................................................... 18
1.6.6. Proteção do Sistema .......................................................... 18
1.7. Estrutura do Sistema Operacional ................................................. 19
1.7.1. Núcleo do Sistema ou Kernel (cérebro) ................................. 19
1.7.2. System Calls ..................................................................... 19
1.7.3. Modos de Acesso ............................................................... 20
1.7.4. Estruturas de Sistemas Operacionais .................................... 21
1.7.4.1. Sistemas Monolíticos ................................................. 21
1.7.4.2. Sistemas em Camadas ............................................... 21
1.7.4.3. Sistemas Cliente/Servidor .......................................... 22
2. Processos ........................................................................................... 24
2.1. Introdução ................................................................................. 24
2.2. Modelo de Processo .................................................................... 24
2.2.1. Contexto de Hardware ........................................................ 25
2.2.2. Contexto de Software ......................................................... 25
2.2.3. Espaço de Endereçamento .................................................. 26
2.3. Estados do Processo ................................................................... 26
2.4. Mudanças de Estado do Processo .................................................. 27
2.5. Subprocesso e Thread ................................................................. 28
2.6. Processos do Sistema .................................................................. 28
2.7. Tipos de Processos ...................................................................... 29
3. Comunicação entre Processos ............................................................... 30

3.1. Introdução ................................................................................. 30
3.2. Especificação de Concorrência em Programas ................................. 30
3.3. Problemas de Compartilhamento de Recursos ................................. 32
3.4. Solução para Problemas de Compartilhamento ............................... 32
3.5. Problemas de Sincronização ......................................................... 33
3.5.1. Velocidade de Execução dos Processos ................................. 33
3.5.2. Starvation ........................................................................ 33
3.5.3. Sincronização Condicional ................................................... 33
3.6. Soluções de Hardware para o Problemas de Exclusão Mútua ............. 34
3.6.1. Desabilitação de Interrupções ............................................. 34
3.6.2. Instrução Test-and-Set ...................................................... 34
3.7. Soluções de Software para o Problemas de Exclusão Mútua .............. 35
3.7.1. Semáforos ........................................................................ 35
3.7.2. Monitores ......................................................................... 37
3.7.3. Troca de Mensagens .......................................................... 38
3.8. Deadlock ................................................................................... 38
4. Gerência do Processador ...................................................................... 39

4.1. Introdução ................................................................................. 39
4.2. Critérios de Escalonamento .......................................................... 39
4.3. Escalonamento Não-preemptivo ................................................... 40
4.3.1. Escalonamento First-In-First-Out (FIFO) ............................... 40
4.3.2. Escalonamento Shortest-Job-First (SJF) ................................ 40
4.3.3. Escalonamento Cooperativo ................................................ 40
4.4. Escalonamento Preemptivo .......................................................... 41
4.4.1. Escalonamento Circular ...................................................... 41
4.4.2. Escalonamento por Prioridades ............................................ 41
4.4.3. Escalonamento por Múltiplas Filas ........................................ 41
4.4.4. Escalonamento por Múltiplas Filas com Realimentação ............ 42
4.4.5. Escalonamento de Sistemas de Tempo Real .......................... 42
4.5. Escalonamento com Múltiplos Processadores .................................. 42
8. Bibliografia ..............................................................................
Livros ...................................................................................
Endereços Eletrônicos .............................................................
FACECA – Faculdade Cenecista de Varginha Sistemas de Informação
SOP – Sistemas Operacionais Prof. José Eduardo S. Gomes
1. Sistemas Operacionais
1.1. Conceitos Básicos de Sistema Operacional
Em torno de um computador, existem usuários com problemas para serem

resolvidos. Por exemplo, um usuário precisa editar texto, enquanto outro precisa
fazer a contabilidade da empresa. O problema de cada usuário será resolvido por
um programa específico. No exemplo, um editor de textos e um sistema de
contabilidade. O dispositivo físico capaz de executar esses programas é o hardware
do computador.
Os programas possuem muito em comum. Por exemplo, tanto o editor de
texto quanto a contabilidade precisam acessar o disco. A forma de acesso aos
periféricos é a mesma para todos os programas. Para um melhor aproveitamento
do hardware, vários usuários compartilham simultaneamente o computador.
Entretanto, os programas podem apresentar necessidades conflitantes, pois
disputam os recursos do equipamento. Por exemplo, o editor de texto e a
contabilidade podem querer utilizar, ao mesmo tempo, a única impressora
disponível.
O sistema operacional é uma camada de software colocada entre o
hardware e os programas que executam tarefas para os usuários. Essa visão de um
sistema computacional é ilustrada na figura abaixo. O sistema operacional é
responsável pelo acesso aos periféricos. Sempre que um programa necessita de
algum tipo de operação de entrada e saída, ele a solicita ao sistema operacional.
Dessa forma, o programador não precisa conhecer os detalhes do hardware.
Informações do tipo “como enviar um caractere para a impressora” ficam
escondidas dentro do sistema operacional. Ao mesmo tempo, como todos os
acessos aos periféricos são feitos através do sistema operacional, ele pode
controlar qual programa está acessando qual recurso. É possível, então, obter uma
distribuição justa e eficiente dos recursos. Por exemplo, a divisão do espaço em
disco entre os usuários é feita pelo sistema operacional. Ela pode ser feita,
considerando-se dois aspectos: a eficiência no acesso ao disco e a ocupação
equilibrada do disco pelos usuários.
1
O sistema operacional não resolve os problemas do usuário final. Ele não

serve para editar texto, nem faz a contabilidade da empresa. Entretanto, através
dele, podemos obter uma maior eficiência e conveniência no uso do computador. A
eficiência é obtida através do compartilhamento dos recursos. A conveniência é
obtida através de uma interface mais confortável para a utilização dos recursos
computacionais.
Normalmente, o processador está executando programas de usuário. Para
isso que o computador foi comprado. Somente quando ocorre algum evento
especial, o sistema operacional é ativado. Dois tipos de eventos ativam o sistema
operacional: uma chamada de sistema ou uma interrupção de periférico.
Uma chamada de sistema corresponde a uma solicitação de serviço por
parte do programa em execução. Primeiramente, deve ser verificada a legalidade
da solicitação. Por exemplo, um pedido para que arquivos de outros usuários sejam
destruídos deverá ser recusado. No caso de uma solicitação legal, ela é realizada, e
a resposta é devolvida ao programa.
Em função das chamadas de sistema, o sistema operacional envia comandos
para os controladores dos periféricos. O controlador deve informar ao sistema
operacional quando a operação estiver concluída. Isso é feito através de uma
interrupção. Quando a interrupção acontece, o processador pára o que está fazendo
e passa a executar uma rotina específica do sistema operacional. Como a
interrupção do periférico avisa o término de alguma operação de entrada e saída,
possivelmente uma chamada de sistema foi concluída. Nesse caso, um programa à
espera de resposta poderá ser liberado.
Um sistema operacional (SO) é um conjunto de rotinas executadas pelo
processador, da mesma forma que qualquer outro programa. Sua função principal é
controlar o funcionamento do computador, como um gerente dos diversos recursos
disponíveis no sistema.
Funções principais do SO:

ª Facilidade de acesso aos recursos do sistema
ª Compartilhamento de recursos de forma organizada e protegida
1.2. Máquina de Níveis
Usuário
Sistema Operacional
Hardware
Aplicativos
Utilitários
Sistema Operacional
Linguagem de Máquina
Microprogramação Hardware
Dispositivos Físicos
2
1.3. Histórico
A evolução dos SO está relacionada ao desenvolvimento dos equipamentos.
1.3.1. Primeira Fase (1945-1955)

ª Durante a Segunda Guerra.
ª ENIAC – 18mil válvulas, 70 mil resistores, 30 toneladas. Consumia 140 KWatts,
5.000 adições por segundo.
ª Para trabalhar nessas máquinas, era necessário conhecer profundamente o
funcionamento do hardware, pois a programação era feita em painéis, através
de fios, utilizando linguagem de máquina.
ª UNIVAC I – criado para o senso americano de 1950.
ª Nesta fase, ainda não existia o conceito de Sistema Operacional.
1.3.2. Segunda Fase (1956-1965)

ª Criação do transistor e das memórias magnéticas.
ª Surgimento das primeiras linguagens de programação: Assembly e Fortran.
ª SO com seu próprio conjunto de rotinas para operações de E/S.
ª Processamento batch.
Cartões Perfurados Processamento

Fita de Entrada
Processamento
Fita de Entrada Fita de Saída
Processamento
Fita de Saída Relatórios
Inicialmente, os programas passaram a ser perfurados em cartões, que,

submetidos a uma leitora, eram gravados em uma fita de entrada. A fita, então,
era lida pelo computador, que executava um programa de cada vez, gravando o
resultado do processamento em uma fita de saída. Ao término de todos
programas, a fita de saída era lida e impressa. A esse tipo de processamento,
onde um lote (batch) de programas era submetido ao computador, deu-se o
nome de processamento batch.
1.3.3. Terceira Fase (1966-1980)

ª Circuitos Integrados (CIs) e microprocessadores.
ª Computadores de porte menor e baixo custo (minicomputadores).
ª Conceitos de multiprogramação: compartilhamento de memória principal e
processador. Permite que, enquanto um programa espera por uma operação de
leitura/gravação, o processador executa um outro programa.
3
ª Substituição das fitas por discos magnéticos, permitindo a alteração na ordem

de execução das tarefas que antes era puramente seqüencial: spooling.
ª Foram adicionados terminais de vídeo e teclado para interação on-line do
usuário.
ª Multiprogramação (divisão da memória em partições, onde cada programa
espera sua vez para ser executado e compartilhamento do processador) usando
time-sharing (tempo compartilhado).
ª Criação do UNIX (1969), escrito em linguagem C.
1.3.4. Quarta Fase (1981-1990)

ª Integração em larga escala (LSI) e muito larga escala (VLSI).
ª Surgimento dos microcomputadores PC (Personal Computer), dos sistemas DOS
(Disk Operation System) e VMS (Virtual Memory System).
ª Surgem as estações de trabalho (workstations) que, apesar de monousuárias,
permitem que se executem diversas tarefas concorrentes, criando o conceito de
multitarefa.
ª Máquinas com mais de um processador, exigindo dos SO mecanismos de
controle e sincronismo e possibilitando o multiprocessamento.
ª Difusão das redes WAN, MAN e LAN com o desenvolvimento de protocolos de
rede e sistemas operacionais para rede.
1.3.5. Quinta Fase (1991-2000)

ª Grandes avanços em termos de hardware, software e telecomunicações.
ª Evolução das aplicações, que necessitam cada vez mais de capacidade de
processamento e armazenamento de dados. Sistemas especialistas, sistemas
multimídia, banco de dados distribuídos, inteligência artificial são alguns
exemplos da necessidade cada vez maior.
ª Evolução da microeletrônica, ULSI (Ultra Large Scale Integration).
ª Arquiteturas paralelas, baseadas na organização de multiprocessadores não
convencionais.
ª Processamento distribuído de forma que as funções do sistema operacional
estejam espalhadas por vários processadores através de redes de
computadores.
ª Arquitetura cliente-servidor, aplicada basicamente a redes locais, passa a ser
oferecida em redes distribuídas, permitindo que qualquer pessoa tenha acesso a
todo tipo de informação, independente de onde ela esteja armazenada.
ª Desenvolvimento de interfaces gráficas para os SO: Windows, Linux, etc.
1.4. Conceitos de Hardware e Software
Serão apresentados alguns conceitos básicos sobre hardware e software

relacionados à organização de computadores, necessários para a compreensão dos
demais tópicos sobre fundamentos do sistema operacional.
4
1.4.1. Conceitos de Hardware

Todos os componentes de um computador são agrupados em três
subsistemas básicos: unidade central de processamento, memória principal e
dispositivo de entrada e saída.
Unidade Central de Processamento (UCP)
Unidade Lógica Unidade de

e Aritmética Controle
(ULA) (UC)
Dispositivos de
Registradores Entrada e Saída
Memória Principal
1.4.1.1. Unidade Central de Processamento

A Unidade Central de Processamento (UCP), ou processador, tem como
função principal unificar todo o sistema, controlando as funções realizadas por cada
unidade funcional. A UCP também é responsável pela execução de todos os
programas do sistema, que obrigatoriamente deverão estar armazenados na
memória principal.
1.4.1.2. Clock
O clock é um dispositivo, localizado na UCP, que gera pulsos elétricos
síncronos em um determinado intervalo de tempo (sinal de clock).
1.4.1.3. Registradores
Os registradores são dispositivos de alta velocidade, localizados na UCP,
para armazenamento temporário de dados. Alguns registradores de uso específico:
• Contador de instrução – é o registrador responsável pelo armazenamento do

endereço da próxima instrução que a UCP deverá executar.
• Apontador de pilha – é o registrador que contém o endereço de memória do

topo da pilha, que é a estrutura de dados onde o sistema mantém
informações sobre as tarefas que estão sendo processadas e tiveram que ser
interrompidas por algum motivo.
• Registrador de estado – é responsável por armazenar informações sobre a

execução do programa. A cada instrução executada, o registrador de estado
é alterado conforme o resultado gerado pela instrução.
5
1.4.1.4. Memória Principal

A memória principal, também conhecida como memória primária ou real, é a
parte do computador onde são armazenados instruções e dados.
1.4.1.5. Memória Cache

A memória cache é uma memória volátil de alta velocidade. O tempo de
acesso a um dado nela contido é muito menor que se o mesmo estivesse na
memória principal.
Toda vez que o processador faz referência a um dado armazenado na
memória principal, ele “olha” antes na memória cache. Se o processador encontrar
o dado na cache, não há necessidade do acesso à memória principal; do contrário,
o acesso é obrigatório.
1.4.1.6. Memória Secundária

A memória secundária é um meio permanente (não volátil) de
armazenamento de programas e dados. Enquanto a memória principal precisa estar
sempre energizada para manter suas informações, a memória secundária não
precisa de alimentação.
O acesso à memória secundária é lento, se comparado com o acesso à
memória cache ou à principal, porém seu custo é baixo e sua capacidade de
armazenamento é bem superior à da memória principal.
Registradores
Maior Maior custo e

capacidade de Memória Cache maior velocidade
armazenamento de acesso
Memória Principal
Memória Secundária
1.4.1.7. Dispositivos de Entrada e Saída

Os dispositivos de entrada e saída (E/S) são utilizados para permitir a
comunicação entre o computador e mundo externo. Através desses dispositivos, a
UCP e a memória principal podem se comunicar, tanto com usuários quanto com
memórias secundárias, a fim de realizar qualquer tipo de processamento.
1.4.1.8. Barramento
A UCP, a memória principal e os dispositivos de E/S são interligados através
de linhas de comunicação denominadas barramentos, barras ou vias. Um
barramento (bus) é um conjunto de fios paralelos (linhas de transmissão), onde
trafegam informações, como dados, endereços ou sinais de controle.
6
1.4.1.9. Pipelining
O conceito de processamento pipeline se assemelha muito a uma linha de
montagem, onde uma tarefa é dividida em subtarefas, executadas em diferentes
estágios dentro da linha de produção.
Da mesma forma que em uma linha de montagem, a execução de uma
instrução pode ser dividida em subtarefas, como as fases de busca da instrução e
dos operandos, execução e armazenamento dos resultados. O processador, através
de suas várias unidades funcionais pipeline, funciona de forma a permitir que,
enquanto uma instrução se encontra na fase de execução, uma outra instrução
possa estar na fase de busca simultaneamente.
1.4.1.10. Ativação e Desativação do Sistema

Toda vez que um computador é ligado, é necessário que o sistema
operacional seja carregado da memória secundária para a memória principal. Esse
processo, denominado ativação do sistema (boot), é realizado por um programa
localizado em uma posição específica do disco (boot block), geralmente o primeiro
bloco.
Na maioria dos sistemas, também existe o processo de desativação
(shutdown). Este procedimento permite que as aplicações e componentes do
sistema sejam desativados de forma ordenada, garantindo a integridade do
sistema.
1.4.1.11. Arquiteturas RISC e CISC

Um processador com arquitetura RISC (Reduced Instruction Set Computer)
se caracteriza por possuir poucas instruções de máquina, em geral bastante
simples, que são executadas diretamente pelo hardware. Na sua maioria, estas
instruções não acessam a memória principal, trabalhando principalmente com
registradores que, neste tipo de processador, se apresentam em grande número.
Estas características, além de ajudarem as instruções serem executadas em alta
velocidade, facilitam a implementação do pipeline. Como exemplos de
processadores RISC podemos citar o Sparc (SUN), RS-6000 (IBM), PA-RISC (HP),
Alpha AXP (DEC) e Rx000 (MIPS).
Os processadores CISC (Complex Instruction Set Computers) já possuem
instruções complexas que são interpretadas por microprogramas. O número de
registradores é pequeno e qualquer instrução pode referenciar a memória principal.
Neste tipo de arquitetura, a implementação do pipeline é mais difícil. São exemplos
de processadores CISC o VAX (DEC), 80x86 e o Pentium (Intel), e o 68xxx
(Motorola).
1.4.2. Conceitos de Software

O hardware, por si só, não tem a menor utilidade. Para torná-lo útil, existe
um conjunto de programas, utilizado como interface entre as necessidades dos
usuários e as capacidades do hardware.
7
No decorrer do texto, utilizaremos o termo utilitário, sempre que desejarmos

fazer referência a softwares relacionados mais diretamente com serviços do sistema
operacional, como compiladores, linkers e depuradores. Os softwares desenvolvidos
pelos usuários serão denominados softwares aplicativos, ou apenas aplicações.
1.4.2.1. Tradutor
Nos sistemas operacionais antigos, o ato de programar era bastante
complicado, já que os programas eram desenvolvidos em linguagem de máquina e
carregados diretamente na memória principal para execução.
Com o surgimento das primeiras linguagens de montagem (assembly
languages) e das linguagens de alto nível, o programador deixou de se preocupar
com muitos aspectos pertinentes ao hardware, como em qual região da memória o
programa deveria ser carregado ou quais endereços de memória seriam reservados
para as variáveis.
Apesar das inúmeras vantagens proporcionadas pelas linguagens de
montagem e alto nível, os programas escritos nessas linguagens (programas –
fonte) não estão prontos para serem diretamente executados pela UCP. Para isso,
eles têm de passar por uma etapa de conversão, onde toda representação
simbólica dos programas é traduzida para código de máquina. Esta conversão é
realizada por um software denominado tradutor.
O tradutor, pelo tipo de linguagem de programação utilizada, pode ser
chamado de montador ou compilador.
• O montador (assembler) é o utilitário responsável por gerar, a partir de um
programa escrito em linguagem de montagem, um programa em linguagem
de máquina não executável (módulo-objeto).
A linguagem de montagem está diretamente ligada às características da
arquitetura do processador. Em função disto, este tipo de linguagem é
diferente para cada computador, pois a linguagem de máquina e,
conseqüentemente, a linguagem de montagem são características
específicas do processador.
• O compilador é o utilitário responsável por gerar, a partir de um programa
escrito em uma linguagem de alto nível, um programa em linguagem de
máquina não executável (módulo-objeto).
As linguagens de alto nível, como Pascal, Fortran, Cobol, não têm nenhuma
relação direta com a máquina, ficando essa preocupação exclusivamente
com o compilador. Assim, os programas-fonte podem ser transportados
entre computadores de diversos fabricantes, desde que existam regras de
definição para a linguagem. Isso permite o desenvolvimento de aplicações
independentes do equipamento.
1.4.2.2. Interpretador
O interpretador é considerado um tradutor que não gera código-objeto. A
partir de um programa-fonte, escrito em linguagem de alto nível, o interpretador,
no momento da execução do programa, traduz cada instrução e a executa em
seguida.
8
1.4.2.3. Linker
O linker (ligador) é o utilitário responsável por gerar, a partir de um ou mais

módulos objetos, um único programa executável. Suas funções básicas são resolver
todas as referências simbólicas existentes entre os módulos objetos e reservar
memória para a execução do programa.
Módulo
Objeto
Programa
Linker
Executável
Módulo
Objeto
1.4.2.4. Loader
O loader (carregador) é o utilitário responsável por colocar fisicamente na
memória um programa para execução.
1.4.2.5. Depurador
O depurador (debugger) é o utilitário que permite ao usuário controlar toda
a execução de um programa a fim de detectar erros na sua estrutura.
1.4.2.6. Linguagem de Controle

A linguagem de controle (linguagem de comando) é a forma mais direta de
um usuário se comunicar com o sistema operacional.
Esses comandos, quando digitados pelos usuários, são interpretados por um
programa denominado interpretador de comandos ou shell. O interpretador
reconhece a linha de comando, verifica sua sintaxe, envia mensagens de erro e faz
chamadas a rotinas do sistema. Dessa forma, o usuário dispõe de uma interface
interativa com o sistema operacional, para realizar tarefas como acessar um
arquivo em disco ou consultar um diretório.
1.4.2.7. Linguagem de Máquina

A linguagem de máquina de um computador é a linguagem de programação
que o processador realmente pode entender. Cada processador possui um conjunto
único de instruções de máquina, definido pelo próprio fabricante.
Um programa em linguagem de máquina é totalmente codificado em
formato binário, o que torna o entendimento confuso para o usuário.
1.4.2.8. Microprogramação
Os microprogramas definem a linguagem de máquina de cada computador.
9
1.5. Tipos de Sistemas Operacionais

Os tipos de Sistemas Operacionais e sua evolução estão intimamente
relacionados com a evolução do hardware e das aplicações por ele suportadas.
Abordaremos aqui os diversos tipos de sistemas operacionais, suas
características, vantagens e desvantagens:
Tipos de SO:
1. Sistemas Monoprogramáveis / Monotarefa
2. Sistemas Multiprogramáveis / Multitarefa
3. Sistemas com Múltiplos Processadores
1.5.1. Sistemas Monoprogramáveis / Monotarefa

Os primeiros sistemas operacionais eram voltados para a execução de um
único programa (job). Qualquer outro programa, para ser executado, deveria
aguardar o término do programa concorrente.
Os sistemas monoprogramáveis se caracterizam por permitir que o
processador, a memória e os periféricos permaneçam exclusivamente dedicados à
execução de um único programa.
Os sistemas monotarefa, como também são chamados, se caracterizam por
permitir que todos os recursos do sistema fiquem exclusivamente dedicados a uma
única tarefa.
Vantagem: são simples de implementação, não exigindo preocupação com

sistemas de proteção.
Desvantagem: a memória e o processador são subutilizados.
1.5.2. Sistemas Multiprogramáveis / Multitarefa

Os sistemas multiprogramáveis são mais complexos e eficientes que os
sistemas monoprogramáveis. Vários programas dividem os mesmos recursos de
processador, memória e periféricos.
A partir do número de usuários que interagem com o sistema, podemos
classificar os sistemas multiprogramáveis como monousuário e multiusuário.
Vantagem: aumento da produtividade dos seus usuários e a redução de custo, a

partir do compartilhamento dos diversos recursos do sistema.
Desvantagem: sistemas mais complexos, o sistema se preocupa em gerenciar o

acesso concorrente aos seus recursos.
O conceito de sistema multiprogramável está tipicamente associado aos

mainframes e minicomputadores, onde existe a idéia do sistema sendo utilizado por
vários usuários (multiusuário).
Os sistemas multitarefa, como também são chamados, se caracterizam por
permitir que o usuário edite um texto, imprima um arquivo, copie um arquivo pela
rede e calcule uma planilha.
10
Os sistemas multiprogramáveis/multitarefas podem ser classificados pela

forma com que suas aplicações são gerenciadas, podendo ser divididos em
sistemas batch, de tempo compartilhado ou de tempo real.
1.5.2.1. Sistemas Batch

Os sistemas batch (lote) foram os primeiros sistemas multiprogramáveis a
serem implementados e caracterizam-se por terem seus programas armazenados
em disco ou fita, onde esperam para ser executados sequencialmente. Não
permitem a interação com o usuário durante a sua execução.
1.5.2.2. Sistemas de Tempo Compartilhado

Os sistemas de tempo compartilhado (time-sharing) permitem a interação
dos usuários com o sistema, através de terminais que incluem vídeo, teclado e
mouse (sistemas on-line). Para cada usuário, o SO aloca uma fatia de tempo (time-
slice) do processador. Caso o programa do usuário não esteja concluído neste
intervalo de tempo, ele é substituído por um de outro usuário, e fica esperando por
uma nova fatia de tempo.
Não só o processador é compartilhado nesse sistema, mas também a
memória e os periféricos, como discos e impressoras. O sistema cria para o usuário
um ambiente de trabalho próprio, dando a impressão de que todo o sistema está
dedicado, exclusivamente, a ele.
Estes sistemas são de implementação mais complexa.
1.5.2.3. Sistemas de Tempo Real

Os sistemas de tempo real (real-time) são semelhantes aos sistemas de
tempo compartilhado, a maior diferença é o tempo de resposta exigido no
processamento das aplicações.
Nos sistemas de tempo real, um programa detém o processador o tempo
que for necessário, ou até que apareça outro prioritário em função de sua
importância no sistema. Esta importância ou prioridade de execução é controlada
pela própria aplicação e não pelo sistema operacional, como nos sistemas de tempo
compartilhado.
Esses sistemas, normalmente, estão presentes em controle de processos,
como no monitoramento de refinarias de petróleo, controle de tráfego aéreo, de
usinas termoelétricas e nucleares, ou em qualquer aplicação onde o tempo de
resposta é fator fundamental.
1.5.3. Sistemas com Multiprocessadores

Os sistemas com multiprocessadores caracterizam-se por possuir duas ou
mais UCP’s interligadas, trabalhando em conjunto. Um fator-chave no
desenvolvimento de sistemas com múltiplos processadores é a forma de
comunicação entre as UCPs e o grau de compartilhamento de memória e
periféricos.
11
Os conceitos utilizados no projeto de sistemas com múltiplos processadores

incorporam os conceitos utilizados para multiprogramação, além de outras
características e vantagens como:
ª Escalabilidade: possibilidade de aumentar a capacidade computacional com
menor custo.
ª Reconfiguração: capacidade de um sistema continuar o processamento
mesmo se um dos processadores falhar.
ª Balanceamento: possibilidade de distribuir a carga de processamento entre os
diversos sistemas de computação, melhorando o desempenho como um todo.
Podemos classificar os Sistemas com Múltiplos Processadores em

Fortemente Acoplados e Fracamente Acoplados.
1.5.3.1. Sistemas Fortemente Acoplados

Nos sistemas fortemente acoplados existem dois ou mais processadores
compartilhando a mesma memória e controlados por um único sistema operacional.
Permitem que vários programas sejam executados ao mesmo tempo, ou que um
programa seja dividido em subprogramas, para execução simultânea em vários
processadores, em vez de um processador de alta velocidade e custo elevado. São
utilizados em processamento científico, simulações e processamento de imagens.
Os sistemas fortemente acoplados ainda podem ser classificados em:
ª Sistemas Assimétricos: caracterizam-se por possuir um processador

(primário), responsável pelo controle dos demais processadores (secundários) e
pela execução do sistema operacional.
Vantagem: simples de implementar.
Desvantagem: dependência do processador primário e utilização ineficiente dos
recursos do sistema, no caso do processador mestre receber muitas
interrupções dos escravos para serem tratadas.
ª Sistemas Simétricos: todos os processadores realizam as mesmas funções,

podendo executar o sistema operacional independentemente.
Vantagem: independência de um processador principal, todos executam a
mesma função. Melhor balanceamento do processamento e das operações de
entrada e saída.
Desvantagem: implementação mais complexa.
1.5.3.2. Conceitos e Organização dos Sistemas Fortemente Acoplados
ª Multiprocessamento: uma tarefa pode ser executada, ao mesmo tempo, por

mais de um processador (paralelismo). Podemos analisar o multiprocessamento
em dois níveis:
• Processamento Vetorial: permite a manipulação de vetores inteiros,
possibilitando a execução da mesma operação sobre diferentes elementos
de um ou mais vetores.
• Processamento Paralelo: é a possibilidade de uma aplicação ser
executada por mais de um processador ao mesmo tempo.
12
ª Organização Funcional: O esquema de comunicação interna das UCPs,

memória e dispositivos de E/S (unidades funcionais) é fundamental no projeto
de sistemas com múltiplos processadores. As organizações funcionais de
multiprocessadores podem ser divididas, basicamente, em três tipos:
• Barramento Comum: a forma mais simples de comunicação entre
múltiplos processadores e outras unidades funcionais é interligar todos os
componentes a um barramento comum.
• Barramento Cruzado: as unidades funcionais podem ser conectadas entre
si através de barramentos cruzados, criando uma rede de interconexões.
• Memória Multiport: além das vantagens do barramento cruzado, permite
acessos simultâneos de processadores a um mesmo módulo de memória.
1.5.3.3. Sistemas Fracamente Acoplados

Os sistemas fracamente acoplados caracterizam-se por possuir dois ou mais
sistemas de computação interligados através de linhas de comunicação. Cada
sistema possui o seu próprio sistema operacional, gerenciando os seus recursos,
como processador, memória e dispositivos de E/S. Os sistemas fracamente
acoplados ainda podem ser classificados em:
ª Sistemas Operacionais de Rede: cada nó (sistema independente) possui seu

próprio sistema operacional, além de um hardware e software que possibilitam
ao sistema ter acesso a outros componentes da rede, compartilhando seus
recursos. O melhor exemplo de utilização dos sistemas operacionais de rede são
as redes locais (Local Area Network-LAN).
ª Sistemas Operacionais Distribuídos: cada componente possui seu próprio

sistema operacional, memória, processador e dispositivos. O que diferencia o
sistema operacional de rede dos sistemas distribuídos (cluster) é o grau de
interação entre os nós. Para o usuário e suas aplicações é como se não existisse
uma rede de computadores, mas sim um único sistema centralizado. Os
sistemas distribuídos permitem que uma aplicação seja dividida em diferentes
partes (aplicações distribuídas), que se comunicam através de linha de
comunicação, podendo cada parte ser executada por um sistema diferente. A
grande vantagem é a capacidade de redundância do sistema, conceito muito
utilizado em aplicações de missão crítica, como controle de tráfego aéreo,
conhecidas como sistemas de tolerância a falhas.
1.5.3.4. Organização dos Sistemas Fracamente Acoplados

A organização dos sistemas fracamente acoplados ou topologia, define como
são interligados fisicamente os diversos sistemas da rede. As principais
organizações são:
ª Barramento
Na organização de barramento, os sistemas são conectados a uma única
linha de comunicação e todos compartilham o mesmo meio, tanto para receber
como para enviar mensagens. Esse tipo de organização é utilizado geralmente em
redes locais. Neste tipo de topologia, caso haja algum problema com o meio de
transmissão, todos os nós da rede ficarão incomunicáveis.
13
ª Organização Distribuída
Na organização distribuída existem linhas de comunicação ponto-a-ponto
que ligam os sistemas e caminhos alternativos entre os diversos nós da rede. Caso
uma linha de comunicação apresente problema, linhas alternativas permitirão que a
rede continue em funcionamento. Este tipo de organização é utilizado geralmente
em redes distribuídas.
1.6. Sistemas Multiprogramáveis
A possibilidade de periféricos funcionarem simultaneamente entre si,

juntamente com a UCP, permitiu a execução de tarefas concorrentes, que é o
princípio básico para o projeto e implementação de sistemas multiprogramáveis.
Características dos sistemas monoprogramáveis:

Baixa utilização dos recursos do sistema como: processador, memória e
periféricos.
Somente um programa pode estar na memória e o processador fica dedicado,
exclusivamente, à execução deste único programa.
Subutilização da memória. Um programa que não ocupe toda a memória
ocasiona a existência de áreas livres, sem utilização.
Mais simples de implementar, pois não existem questões de concorrência para
serem tratadas pelo sistema operacional.
Exemplo de Utilização do Sistema

Leitura de um registro 0,0015 segundos
Execução de 100 instruções 0,0001 segundos
Total 0,0016 segundos
Porcentagem de utilização da CPU 0,0001 / 0,0015 = 0,066 = 6,6%
Características dos sistemas multiprogramáveis:
Vários programas podem estar residentes na memória, concorrendo pela

utilização da UCP. Nesse caso, a UCP permanece menos tempo ociosa e a
memória principal é utilizada de forma mais eficiente, pois existem vários
programas residentes se revezando na utilização do processador.
A utilização concorrente da UCP deve ser implementada de maneira que,

quando um programa perde o uso do processador e depois retorna para
continuar o processamento, seu estado deve ser idêntico ao do momento em
que foi interrompido. O programa deverá continuar sua execução exatamente
na instrução seguinte àquela em que havia parado, aparentando ao usuário que
nada aconteceu, ou seja, ficando todo este mecanismo transparente para ele.
14
Em sistemas multiprogramáveis é possível compartilhar os periféricos. Como,

por exemplo, compartilhar impressoras entre vários usuários e realizar o acesso
concorrente a discos por diversos programas.
A eficiência proporcionada por um sistema multiprogramável resulta em maior
complexidade do sistema operacional, já que alguns problemas surgem com
esse tipo de implementação.
Exemplo:
Nos próximos itens serão mostrados alguns mecanismos e dispositivos que

possibilitam a implementação de um sistema de tarefas concorrentes, ou seja,
sistema multiprogramável.
1.6.1. Interrupção e Exceção

Durante a execução de um programa, alguns eventos podem ocorrer
durante o seu processamento, obrigando a intervenção do sistema operacional.
Este tipo de intervenção é chamado interrupção ou exceção e pode ser resultado da
execução de instruções do próprio programa, gerado pelo sistema operacional ou
por algum dispositivo de hardware. Nestas situações o fluxo de execução do
programa é desviado para uma rotina especial de tratamento. O que diferencia uma
interrupção de uma exceção é o tipo de evento que gera esta condição.
Interrupção: gerada pelo sistema operacional ou algum dispositivo de hardware e,

neste caso, independe do programa que está sendo executado. Um exemplo é
quando um periférico avisa à UCP que está pronto para transmitir algum dado.
Neste caso, a UCP deve interromper o programa para atender a solicitação do
dispositivo.
Exceção: é o resultado direto da execução de uma instrução do próprio programa.

Situações como a divisão de um número por zero ou a ocorrência de um overflow
caracterizavam essa situação. Os mecanismos de tratamento de exceções, muitas
vezes, podem ser escritos pelo próprio programador. Dessa forma, é possível evitar
que um programa seja encerrado no caso de ocorrer, por exemplo, um overflow.
No momento em que a unidade de controle detecta a ocorrência de algum

tipo de interrupção, o programa em execução é interrompido, e o controle é
desviado para uma rotina responsável pelo tratamento da interrupção. Muitas
vezes, após a execução dessa rotina, o controle deve voltar ao programa que,
anteriormente, estava sendo processado. Para isso acontecer, é necessário que, no
momento da interrupção, um conjunto de informações sobre a execução do
15
programa seja preservado. Essas informações consistem no conteúdo de alguns

registradores, que deverão ser restaurados posteriormente para a continuação do
programa.
Exemplo:
Programa
Salva os
registradores Rotina de Tratamento
da Interrupção
Identifica a origem
da interrupção
Interrupção
Obtém o endereço da
rotina de tratamento
Restaura os
registradores
Não existe apenas um tipo de interrupção. No momento que uma

interrupção acontece, a UCP deve saber para qual rotina de tratamento deverá ser
desviado o fluxo de execução. Essa informação está em uma estrutura do sistema
chamada vetor de interrupção.
No caso de múltiplas interrupções ocorrerem, o processador deve saber qual
interrupção terá de atender primeiro. Para isso, as interrupções deverão possuir
prioridades, em função da necessidade de atendimento de cada uma.
As interrupções podem ser classificadas como mascaráveis (podem ser
desabilitadas pelo processador) e não mascaráveis (o tratamento é sempre
obrigatório).
1.6.2. Operações de Entrada / Saída (E/S)

Em sistemas primitivos, a comunicação entre a UCP e os periféricos era
controlada por um conjunto de instruções especiais, denominadas instruções de
entrada/saída, executadas pela própria UCP.
A implementação de um dispositivo chamado controlador ou interface

permitiu à UCP agir de maneira independente dos dispositivos de E/S. Com este
novo elemento a UCP não se comunica mais diretamente com os periféricos, mas
sim através do controlador.
UCP Memória Controlador
16
Existiam duas formas básicas do processador controlar as operações de E/S:

ª Na primeira, o processador ficava constantemente testando o estado do
periférico de E/S para saber quando a operação chegaria ao seu final, este
controle é chamado de E/S Controlada por Programa.
ª Outra forma derivada da anterior, porém mais inteligente, era permitir que,
após o início da transferência dos dados, a UCP ficasse livre para se ocupar de
outras tarefas. Assim, em determinados intervalos de tempo, o sistema
operacional deveria realizar um teste para saber do término ou não da operação
de E/S em cada dispositivo (Polling).
Com a implementação do mecanismo de interrupção no hardware dos

computadores, as operações de E/S puderam ser realizadas de uma forma mais
eficiente. Em vez de o sistema periodicamente verificar o estado de uma operação
pendente, o próprio controlador interrompe a UCP para avisar do término da
operação. Com este mecanismo, denominado E/S Controlada por Interrupção, a
UCP, após a execução de um comando de leitura ou gravação, fica livre para o
processamento de outras tarefas. Quando a transferência termina, o próprio
periférico se encarrega de sinalizar o processador.
A operação de E/S Controlada por Interrupção é muito mais eficiente que a
E/S Controlada por Programa. Apesar disto, essa implementação ainda
sobrecarregava a UCP, uma vez que toda a transferência de dados entre memória e
periféricos exigia a intervenção da UCP. A solução para este problema foi a
implementação, por parte do controlador, de uma técnica de transferência de dados
denominada DMA (Direct Memory Access), isto é, acesso direto a memória. Esta
técnica permite que um bloco de dados seja transferido entre memória e periféricos
sem a intervenção da UCP, exceto no início e no final da transferência. A área de
memória utilizada pelo controlador na técnica de DMA é chamado buffer, sendo
reservada exclusivamente para este propósito.
1.6.3. Buffering
A técnica de buffering consiste na utilização de uma área de memória para a
transferência de dados entre os periféricos e a memória principal denominada
buffer. O buffering veio permitir que, quando um dado fosse transferido para o
buffer após uma operação de leitura, o dispositivo de entrada pudesse iniciar uma
nova leitura. Neste caso, enquanto a UCP manipula o dado localizado no buffer, o
dispositivo realiza outra operação de leitura no mesmo instante. O mesmo
raciocínio pode ser aplicado para operações de gravação, onde a UCP coloca o dado
no buffer para um dispositivo de saída manipular.
Memória
Gravação Principal Gravação Controlador
UCP de E/S
Buffer
Leitura Leitura
17
1.6.4. Spooling
A técnica de spooling (simultaneous peripherical operation on-line) foi
introduzida no final dos anos 50 para aumentar a produtividade e a eficiência dos
sistemas operacionais.
O spooling, basicamente, utiliza o disco como um grande buffer, permitindo
que dados sejam lidos e gravados em disco, enquanto outras tarefas são
processadas.
Um exemplo dessa técnica está presente quando impressoras são utilizadas.
No momento em que um comando de impressão é executado por um programa, as
informações que serão impressas são gravadas em um arquivo em disco (arquivo
de spool), para ser impresso posteriormente pelo sistema.
Arquivo Sistema
Programa Impressão
De Spool Operacional
1.6.5. Reentrância
É comum, em sistemas multiprogramáveis, vários usuários executarem os
mesmos utilitários do sistema operacional simultaneamente, como, por exemplo,
um editor de texto. Se cada usuário que utilizasse o editor de texto trouxesse o
código do utilitário para a memória, haveria diversas cópias de um mesmo
programa na memória principal, o que ocasionaria um desperdício de espaço.
Reentrância é a capacidade de um código de programa (código reentrante)
poder ser compartilhado por diversos usuários, exigindo que apenas uma cópia do
programa esteja na memória.
A reentrância permite que cada usuário possa entrar em um ponto diferente
do código reentrante, manipulando dados próprios, exclusivos de cada usuário.
1.6.6. Proteção do Sistema

Nos sistemas multiprogramáveis, onde diversos usuários compartilham os
mesmos recursos, deve existir uma preocupação, por parte do sistema operacional,
de garantir a integridade dos dados pertencentes a cada usuário.
ª O sistema operacional tem que ter mecanismos para proteger que o programa
de um usuário acesse o código do programa de outro usuário e do próprio
sistema operacional.
ª Quando um programa reserva um periférico para realizar alguma operação,
como, por exemplo, na utilização de uma impressora, nenhum outro programa
deve interferir até que o primeiro programa a libere.
ª Compartilhamento de arquivos em disco permite que dois ou mais usuários
acessem um mesmo arquivo simultaneamente e caso o acesso não seja
controlado pelo sistema operacional, podem ocorrer problemas de
inconsistência. Para isto os sistemas multiprogramáveis implementam o
esquema de lock (bloqueio) de arquivo que permite o controle pelo sistema do
acesso concorrente a arquivos.
18
1.7. Estrutura do Sistema Operacional

Existe uma grande dificuldade em compreender a estrutura e o
funcionamento de um sistema operacional, pois ele não é executado como uma
aplicação tipicamente sequencial, com início, meio e fim. As rotinas do sistema são
executadas sem uma ordem pré-definida, baseadas em eventos dissociados do
tempo (eventos assíncronos).
1.7.1. Núcleo do Sistema ou Kernel (cérebro)

Conjunto de rotinas (procedimentos e funções) que oferecem serviços aos
usuários do sistema e suas aplicações, bem como outras rotinas do próprio sistema.
As principais funções do núcleo são:

ª Tratamento de interrupções;
ª Criação e eliminação de processos;
ª Sincronização e comunicação entre processos;
ª Escalonamento e controle de processos;
ª Gerência de memória;
ª Gerência do sistema de arquivos;
ª Operações de entrada e saída;
ª Contabilização e segurança do sistema.
1.7.2. System Calls

É um mecanismo implementado para proteger o núcleo do sistema, para
evitar que uma aplicação, que tenha acesso ao núcleo, realize uma operação que o
danifique, fazendo com que o sistema fique comprometido e inoperante.
O usuário (ou aplicação), quando deseja solicitar algum serviço do sistema,
realiza uma chamada a uma de suas rotinas (ou serviços) através de system calls
(chamadas ao sistema), que são portas de entrada para se ter acesso ao núcleo do
sistema operacional. Para cada serviço existe uma system call associada e cada
sistema operacional tem o seu próprio conjunto (biblioteca) de chamadas, com
nomes, parâmetros e formas de ativação específicos.
System Núcleo
Aplicação (kernel) Hardware
Call
O mecanismo de ativação e comunicação entre a aplicação e o sistema é

semelhante ao mecanismo implementado quando um programa modularizado ativa
um dos seus procedimentos e funções.
As system calls podem ser divididas em grupos de função:
Gerência de Processos
Criação e eliminação de processos;
Alteração das características do processo;
Sincronização e comunicação entre processos.
19
Gerência de Memória
Alocação e desalocação de memória.
Gerência de Entrada/Saída
Operações de entrada/saída;
Manipulação de arquivos e diretórios.
1.7.3. Modos de Acesso

Existem certas instruções que não podem ser colocadas diretamente à
disposição das aplicações, pois a sua utilização indevida ocasionaria sérios
problemas à integridade do sistema. Sendo assim, algumas instruções, como
operações de entrada e saída, só devem ser executadas pelo sistema operacional,
para impedir a ocorrência de problemas de segurança e até mesmo, violação do
sistema. As instruções que têm o poder de comprometer o sistema são conhecidas
como instruções privilegiadas, enquanto as instruções não-privilegiadas são aquelas
que não oferecem perigo ao sistema.
Para permitir que uma aplicação possa executar uma instrução privilegiada,
o processador implementa um mecanismo de modos de acesso. Existem,
basicamente, dois modos de acesso:
ª Modo Usuário – Quando o processador trabalha em modo usuário, uma
aplicação só pode executar instruções não-privilegiadas, tendo acesso a um
número reduzido de instruções.
ª Modo Kernel – Uma aplicação pode ter acesso ao conjunto total de instruções
do processador.
O modo de acesso é determinado por um conjunto de bits, localizado em

um registrador especial da UCP, que indica o modo de acesso corrente. Através
desse registrador, o hardware verifica se uma instrução pode ou não ser executada
pela aplicação.
A melhor maneira de controlar o acesso às instruções privilegiadas é permitir

que apenas o sistema operacional tenha acesso a elas. Sempre que uma aplicação
necessita de um serviço que incorra em risco para o sistema, a solicitação é feita
através de uma system call. A system call altera o modo de acesso do processador
para um modo mais privilegiado (modo kernel). Ao término da rotina do sistema, o
modo de acesso é retornado para o modo usuário.
Programa
Usuário A
Programas dos Usuários
Programa Executam no modo usuário
Memória System Call Usuário B
Principal
Sistema Operacional
Rotina do
Executa no modo kernel
Sistema
20
O núcleo do Sistema Operacional sempre é executado em modo kernel, pois

deve possuir a capacidade de gerenciar e compartilhar todos os seus recursos,
solucionando, em diversos níveis, os problemas de acesso às instruções
privilegiadas.
1.7.4. Estruturas de Sistemas Operacionais

Existem, basicamente, três maneiras de organizar o código do sistema
operacional e o inter-relacionamento entre seus diversos componentes:
• Sistemas Monolíticos.
• Sistemas em Camadas.
• Sistemas Cliente-Servidor.
1.7.4.1. Sistemas Monolíticos

A organização mais comum é aquela que estrutura o sistema como um
conjunto de rotinas que podem interagir livremente umas com as outras. A
estrutura monolítica pode ser comparada com uma aplicação formada por vários
procedimentos que são compilados separadamente e depois linkados, formando um
grande e único programa executável.
Aplicação Aplicação
Modo Usuário
Modo Kernel
System Calls
Hardware
1.7.4.2. Sistemas em Camadas

Um sistema em camadas divide o sistema operacional em camadas
sobrepostas. Cada módulo oferece um conjunto de funções que podem ser
utilizadas por outros módulos. Módulos de uma camada podem fazer referência
apenas a módulos de camadas inferiores.
A vantagem da estrutura em camadas é isolar as funções do sistema
operacional, facilitando sua alteração e depuração, além de criar uma hierarquia de
níveis de modos de acesso, protegendo as camadas mais internas.
21
5 Operador
4 Programas de usuário
3 Entrada/Saída
2 Comunicação
1 Gerência de memória
0 Multiprogramação
1.7.4.3. Sistemas Cliente/Servidor

Uma tendência dos sistemas operacionais modernos é tornar o núcleo do
sistema operacional o menor e mais simples possível. Para implementar esta idéia,
o sistema é dividido em processos, sendo cada um responsável por oferecer um
conjunto de serviços, como serviços de arquivo, serviços de criação de processos,
serviços de memória, serviços de escalonamento, etc.
Sempre que uma aplicação deseja um serviço, ela solicita ao processo
responsável. Neste caso, a aplicação que solicita um serviço é chamada de cliente,
enquanto o processo que responde à solicitação é chamado de servidor. Um cliente
que pode ser uma aplicação de um usuário ou um outro componente do sistema
operacional, solicita um serviço enviando uma mensagem para o servidor. O
servidor responde ao cliente através de uma outra mensagem. É função do núcleo
do sistema realizar a comunicação, ou seja, a troca de mensagens entre o cliente e
o servidor.
Servidor
Cliente Servidor de
de Rede
Memória
Servidor Servidor
de de
Arquivo Processo
Modo Usuário
Modo Kernel
Núcleo (Kernel)
Hardware
A utilização deste modelo permite que os servidores executem em modo

usuário, ou seja, não tenham acesso direto a certos componentes do sistema.
Apenas o núcleo do sistema, responsável pela comunicação entre clientes e
servidores, executa em modo kernel. Como conseqüência, se um erro ocorrer em
um servidor, este servidor pode parar, mas o sistema não ficará inteiramente
comprometido. Além disso, a implementação de sistemas cliente/servidor permite
22
isolar as funções do sistema operacional por diversos processos (servidores)

pequenos e dedicados a serviços específicos. Como conseqüência, o sistema
operacional passa a ser de mais fácil manutenção.
Como os servidores se comunicam através de trocas de mensagens, não
importa se os clientes e servidores estão sendo processados com um processador,
com múltiplos processadores (fortemente acoplado) ou num ambiente distribuído
(fracamente acoplado).
Apesar das vantagens deste modelo, ele é de difícil implementação. O que é
implementado na prática é uma combinação do modelo de camadas com o modelo
cliente-servidor. O núcleo do sistema, além de ser responsável pela comunicação
entre o cliente e servidor, passa a incorporar outras funções críticas do sistema,
como escalonamento de processos, gerência de memória, além das funções de
devices drivers.
23
2. Processo
2.1. Introdução
O processo pode ser entendido com um programa em execução, só que seu
conceito é mais abrangente. Este conceito torna-se mais claro quando pensamos na
forma em que os sistemas multiprogramáveis (multitarefa) atendem a diversos
usuários (tarefas) e mantém informações a respeito dos vários programas que
estão sendo executados concorrentemente.
Como sabemos, um sistema multiprogramável simula um ambiente de
monoprogramação para cada usuário, isto é, cada usuário do sistema tem a
impressão de possuir o processador exclusivamente para ele. Nesses sistemas, o
processador executa a tarefa de usuário durante um intervalo de tempo (time-slice)
e, no instante seguinte, está processando outra tarefa. A cada troca, é necessário
que o sistema preserve todas as informações da tarefa que foi interrompida, para
quando voltar a ser executada não lhe faltar nenhuma informação para a
continuação do processamento. A estrutura responsável pela manutenção de todas
as informações necessárias à execução de um programa, como conteúdo de
registradores e espaço de memória, chama-se processo.
2.2. Modelo de Processo

O sistema operacional materializa o processo através de uma estrutura
chamada bloco de controle de processo (Process Control Block- PCB). A partir do
PCB, o sistema mantém todas as informações sobre o processo, como sua
identificação, prioridade, estado corrente, recursos alocados por ele e informações
sobre o programa em execução.
Ponteiros
Estado do Processo
Nome do Processo
Prioridade do Processo Bloco de
Controle do
Registradores Processo (PCB)
Limites de memória
Lista de Arquivos Abertos
:
:
:
O sistema gerencia os processos através de system calls, que realizam

operações como criação, eliminação, sincronização, suspensão de processos, entre
outras.
24
O processo pode ser dividido em três elementos básicos:

ª Contexto de hardware;
ª Contexto de software;
ª Espaço de endereçamento.
2.2.1. Contexto de Hardware

O contexto de hardware constitui-se, basicamente, do conteúdo de
registradores: program counter (PC), stack pointer (SP) e bits de estado. Quando
um processo está em execução, seu contexto de hardware está armazenado nos
registradores do processador. No momento em que o processo perde a utilização da
UCP, o sistema salva suas informações no seu contexto de hardware.
A troca de um processo por outro na UCP, realizada pelo sistema
operacional, é denominada mudança de contexto (context switching). A mudança
de contexto consiste em salvar o conteúdo dos registradores da UCP e carregá-los
com os valores referentes ao do processo que esteja ganhando a utilização do
processador. Essa operação resume-se, então, em substituir o contexto de
hardware de um processo pelo de outro.
Processo A Sistema Operacional Processo B
executando
Salva Registradores do Processo A
Carrega Registradores do Processo B

executando
Salva Registradores do Processo B
Carrega Registradores do Processo A

executando
2.2.2. Contexto de Software

O contexto de software especifica características do processo que vão influir
na execução de um programa, como, por exemplo, o número máximo de arquivos
abertos simultaneamente ou o tamanho máximo do buffer para operações de E/S.
Essas características são determinadas no momento da criação do processo,
podendo ser alteradas durante sua existência.
O contexto de software define basicamente três grupos de informações
sobre um processo: sua identificação, suas quotas e seus privilégios.
ª Identificação: Cada processo criado pelo sistema recebe uma identificação

única (PID – process identification), representada por um número. Através do
PID, o sistema operacional e outros processos podem fazer referência a um
determinado processo e, por exemplo, alterar uma de suas características.
25
O processo também possui uma identificação do usuário ou do processo que o

criou (owner). Cada usuário possui uma identificação única no sistema (UID –
user identification), atribuída ao processo no momento de sua criação.
ª Quotas: São os limites de cada recurso do sistema que o processo pode alocar.
Caso uma cota seja insuficiente, o processo poderá ser executado lentamente
ou mesmo não ser executado. Alguns exemplos de quotas que aparecem na
maioria dos sistemas operacionais são:
• Número máximo de arquivos abertos simultaneamente;
• Tamanho máximo de memória que o processo pode alocar;
• Número máximo de operações de E/S pendentes;
• Tamanho máximo do buffer para operações de E/S;
• Número máximo de processos e subprocessos que podem ser criados.
ª Privilégios: Definem o que o processo pode ou não fazer em relação ao

sistema e aos outros processos.
2.2.3. Espaço de Endereçamento

O espaço de endereçamento é a área de memória do processo onde o
programa será executado, além do espaço para os dados utilizados por ele. Cada
processo possui o seu próprio espaço de endereçamento, que deve ser protegido do
acesso dos demais processos.
2.3. Estados do Processo

Um processo, em um sistema multiprogramável (multitarefa), não é
executado todo o tempo pelo processador. Durante sua existência, ele passa por
uma série de estados. Basicamente, existem três estados em que um processo
pode se encontrar no sistema:
ª Execução (running): Um processo é dito em estado de execução quando está

sendo processado pelo UCP. Em sistemas com apenas um processador, somente
um processo pode estar sendo executado em um dado instante de tempo. Já
em sistemas com múltiplos processadores, vários processos podem estar sendo
executados ao mesmo tempo, dependendo do número de processadores. Existe
também a possibilidade de um mesmo processo ser executado por mais de um
processador (processamento paralelo).
ª Pronto (ready): Um processo está no estado de pronto quando apenas

aguarda uma oportunidade para executar, ou seja, espera que o sistema
operacional aloque a UCP para sua execução.
ª Espera (wait): Um processo está no estado de espera quando aguarda algum

evento externo ou por algum recurso para poder prosseguir o seu
processamento. Como exemplo, podemos citar o término de uma operação de
entrada e saída ou a espera de uma determinada data e/ou hora para poder
continuar sua execução.
26
O sistema operacional gerencia os processos através de listas encadeadas,

onde cada PCB (bloco de controle de processo) tem um ponteiro para o seu
sucessor. Assim:
PCB #5 PCB #1
Lista de
processos
em estado
de pronto : :
: :
PCB #9 PCB #2 PCB #4

Lista de
processos
em estado
de espera : : :
: : :
2.4. Mudanças de Estado do Processo

Um processo muda de estado diversas vezes, durante o seu processamento,
em função de eventos originados por ele próprio (eventos voluntários) ou pelo
sistema operacional (eventos involuntários).
Basicamente, existem quatro mudanças de estado que podem ocorrer a um
processo:
Execução
d
b
a
Espera Pronto
c
ª Pronto → Execução: Quando um processo é criado, o sistema o coloca em

uma lista de processos no estado de pronto, onde aguarda a oportunidade de
ser executado (a). Cada sistema tem seus próprios critérios e algoritmos para a
escolha da ordem em que os processos serão executados (escalonamento).
ª Execução → Espera: Um processo em execução passa para o estado de espera

por eventos gerados pelo próprio processo, como, por exemplo, uma operação
de entrada/saída (b).
ª Espera → Pronto: Um processo passa do estado de espera para o estado de

pronto quando a operação solicitada é atendida, ou o recurso esperado é
concedido.
Um processo no estado de espera sempre terá de passar pelo estado de pronto
antes de poder ser novamente selecionado para execução (c). Não existe a
mudança do estado de espera para o estado de execução diretamente.
27
ª Execução → Pronto: Um processo em execução passa para o estado de

pronto por eventos gerados pelo sistema, como, por exemplo, o fim da fatia de
tempo que o processo possui para sua execução (d). Neste caso, o processo
volta para a fila de pronto, onde aguarda por uma nova oportunidade para
continuar o seu processamento.
2.5. Subprocesso e Thread

Um processo pode criar outros processos de maneira hierárquica. Quando
um processo (processo pai) cria um outro, chamamos o processo criado de
subprocesso ou processo filho. O subprocesso, por sua vez, pode criar outros
subprocessos. Como conseqüência desta estrutura, caso um processo deixe de
existir, os subprocessos subordinados são eliminados.
O uso de subprocessos no desenvolvimento de aplicações concorrentes
demanda o consumo de diversos recursos do sistema (contexto de hardware,
contexto de software e espaço de endereçamento).
Na tentativa de diminuir o tempo gasto na criação/eliminação de processos,
bem como economizar recursos do sistema como um todo, foi introduzido o
conceito de thread (linha). Threads compartilham o processador da mesma maneira
que um processo. Por exemplo, enquanto um thread espera por uma operação de
E/S, outro thread pode ser executado.
A grande diferença entre subprocessos e threads é em relação ao espaço de
endereçamento. Enquanto subprocessos possuem, cada um, espaços de
endereçamento independentes e protegidos, threads compartilham o mesmo
espaço de endereçamento do processo, sem nenhuma proteção, permitindo assim
que um thread possa alterar dados de outro thread.
2.6. Processos do Sistema

O conceito de processo, além de estar associado a aplicações de usuários,
pode também ser implementado na própria estrutura de um sistema operacional,
para retirar código do seu núcleo, tornando-o menor e mais estável. No caso de
uma ou mais funções não serem desejadas, basta não ativar os processos
responsáveis, o que permitirá liberar memória para os processos dos usuários.
Algumas das funções do sistema operacional que podem ser implementadas
através de processos:
• Auditoria e segurança;
• Serviços de rede;
• Contabilização do uso de recursos;
• Contabilização de erros;
• Gerência de impressão;
28
• Gerência de jobs batch;

• Temporização;
• Comunicação de eventos;
• Interface de comandos (shell).
2.7. Tipos de Processos

Os processos podem ser classificados de acordo com o tipo de
processamento que realizam. Assim:
ª CPU-bound (ligado a CPU) – quando o processo passa a maior parte do

tempo no estado de execução, ou seja, utilizando o processador. Este tipo de
processo realiza poucas operações de entrada/saída e é encontrado em
aplicações matemáticas ou científicas, que efetuam muitos cálculos e poucas
operações de leitura/gravação.
ª I/O-bound (ligado à E/S) – quando o processo passa a maior parte do tempo

no estado de espera, pois realiza um elevado número de operações de
entrada/saída. Esse tipo de processo é encontrado em aplicações comerciais,
que se baseiam em leitura, processamento e gravação.
29
3. Comunicação entre Processos
3.1. Introdução
É comum processos que trabalham juntos (concorrentes) compartilhem
recursos do sistema, como arquivos, registros, dispositivos e áreas de memória. Na
verdade, não importa quais recursos são compartilhados, pois problemas
decorrentes dessa interação serão os mesmos. De maneira geral, o
compartilhamento de recursos entre processos pode gerar situações indesejáveis,
capazes até de comprometer o sistema.
Vejamos um exemplo onde dois processos trocam informações através de
operações de gravação e leitura em um buffer. Um processo só poderá gravar
dados no buffer caso ele não esteja cheio. Da mesma forma, um processo só
poderá ler dados armazenados do buffer se existir algum dado a ser lido. Em
ambos os casos, os processos deverão aguardar até que o buffer esteja pronto para
as operações de gravação ou de leitura.
Processo Sincronização Processo

Gravador Leitor
Dados Dados
Buffer
Os mecanismos que garantem a comunicação entre processos concorrentes

e o acesso a recursos compartilhados são chamados mecanismos de sincronização.
No projeto de sistemas operacionais multiprogramáveis, é fundamental a
implementação de mecanismos de sincronização que garantam sua integridade e
confiabilidade.
Este capítulo se detém na comunicação entre processos em sistemas
fortemente acoplados.
3.2. Especificação de Concorrência em Programas

Na abordagem dos problemas e soluções decorrentes da comunicação entre
processos, utilizaremos diversos algoritmos. Para implementá-los será necessária a
utilização de estruturas que permitam a especificação de concorrência em
programas.
A primeira notação para a especificação da concorrência em um programa
foram os comandos FORK e JOIN.
30
program A; program B;
. .
. .
Fork B; .
. end.
.
Join B;
.
end.
O programa A começa a ser processado e, ao encontrar o comando FORK,

faz com que seja criado um outro processo para a execução do programa B,
concorrentemente a A. O comando JOIN permite que o programa A sincronize-se
com B, ou seja, quando o programa A encontrar o comando JOIN, só continuará a
ser processado após o término de B.
Uma das implementações mais simples de expressar concorrência em um
programa é a utilização dos comandos PARBEGIN e PAREND.
parbegin
comando_1;
comando_2;
(...)
comando_n;
parend;
O comando PARBEGIN especifica que a seqüência de comandos seja
executada concorrentemente em uma ordem imprevisível, através da criação de
um processo (Processo_1, Processo_2, ..., Processo_n) para cada comando
(Comando_1, Comando_2, ..., Comando_n). O comando PAREND define um ponto
de sincronização, onde o processamento só continuará quando todos os processos
criados já tiverem terminado suas execuções.
Processo
Principal
Processo Processo Processo Processo

1 2 3 n
Processo
Principal
Para compreendermos realmente como funciona esta estrutura, vejamos em

uma aplicação prática, onde calculamos o valor da expressão aritmética:
x := SQRT (1024) + (35.4 * 0.23) – (302 / 7);
31
PROGRAM Expressao;
VAR X, Temp1, Temp2, Temp3 : REAL;
BEGIN
PARBEGIN
Temp1 := SQRT (1024);
Temp2 := 35.4 * 0.23;
Temp3 := 302 / 7;
PAREND;
X := Temp1 + Temp2 – Temp3;
WRITELN (‘x = ‘, X);
END.
Os comandos de atribuição situados entre PARBEGIN e PAREND são
executados concorrentemente entre si. O cálculo final de X só poderá ser realizado
quando todas as variáveis dentro da estrutura tiverem sido calculadas.
3.3. Problemas de Compartilhamento de Recursos

Para compreender melhor como a sincronização entre processo é
fundamental quando recursos são compartilhados em sistemas multiprogramáveis,
vejamos um problema aplicado a situações práticas:
Suponha um arquivo de contas bancárias, onde cada cliente tem seu saldo
controlado. Suponha então que dois caixas diferentes possam atualizar o saldo um
mesmo cliente simultaneamente. O primeiro caixa lê o registro de cliente e soma ao
campo saldo o valor do lançamento. Antes de gravar o novo saldo no arquivo, outro
caixa lê o registro do mesmo cliente, que está sendo atualizado, para realizar outro
lançamento. Independente de qual caixa atualize primeiro o saldo no arquivo, o
dado gravado estará inconsistente.
3.4. Solução para Problemas de Compartilhamento

A solução mais simples, para evitar o problema de compartilhamento
anterior, é impedir que dois ou mais processos acessem um mesmo recurso no
mesmo instante. Para isso, enquanto um processo estiver acessando determinado
recurso, todos os outros que queiram acessar esse mesmo recurso deverão esperar
até que o primeiro processo termine o acesso. Esta idéia de exclusividade de acesso
é denominada exclusão mútua.
A exclusão mútua deve apenas afetar os processos concorrentes quando um
deles estiver fazendo acesso ao recurso compartilhado. A parte do código do
programa onde é feito o acesso ao recurso compartilhado é denominada região
crítica.
Os mecanismos que implementam a exclusão mútua utilizam um protocolo
de acesso à região crítica. Toda vez que um processo for executar sua região
crítica, ele obrigatoriamente executará, antes, um protocolo de entrada nessa
região. Da mesma forma que, ao sair, deverá executar um protocolo de saída.
32
begin
(...)
Entra_regiao_critica; (* protocolo de entrada *)
Regiao_critica;
Sai_regiao_critica; (* protocolo de saída *)
(...)
end
3.5. Problemas de Sincronização

Na tentativa de implementar a exclusão mútua, algumas soluções
introduzem novos problemas, que chamaremos de problemas de sincronização.
Qualquer solução para os problemas de compartilhamento de recursos entre
processo, passa necessariamente pela solução dos problemas de sincronização.
A seguir, examinaremos alguns problemas, bastante comuns, decorrentes
da sincronização entre processos.
3.5.1. Velocidade de Execução dos Processos

A velocidade de execução dos processos pode interferir em uma boa solução
para o problema de exclusão mútua. Um processo mais rápido que queira acessar
sua região crítica pode ficar muito tempo esperando, por estar esperando por um
processo mais lento.
3.5.2. Starvation
Um outro problema, também decorrente da sincronização entre processos, é
denominado starvation. Starvation é a situação onde um processo nunca consegue
executar sua região crítica e, conseqüentemente, acessar o seu recurso
compartilhado. Isto pode acontecer, por exemplo, quando um processo tem baixa
prioridade em relação aos outros, que concorram pelo mesmo recurso. Uma solução
bastante simples para esse problema é a criação de filas de pedidos de alocação
para cada recurso compartilhado. O esquema de o primeiro a chegar ser o primeiro
a ser atendido (FIFO) elimina o problema do starvation.
3.5.3. Sincronização Condicional

Outra situação na qual é necessária a sincronização entre processos
concorrentes, é quando um recurso compartilhado não se encontra pronto para ser
utilizado pelos processos. Nesse caso, o processo que deseja acessar o recurso
deverá ser colocado no estado de espera, até o recurso ficar pronto para o
processamento. Esse tipo de sincronização é chamado sincronização condicional.
Um exemplo clássico é a comunicação entre dois processos através de
operações de gravação e leitura em um buffer. Nessa comunicação, um processo
grava dados em um buffer, enquanto outro lê, concorrentemente, os dados do
buffer. Os processos envolvidos devem estar sincronizados, de forma que um
processo não tente gravar dados em um buffer cheio ou ler de um buffer vazio.
33
3.6. Soluções de Hardware para o Problema de Exclusão

Mútua
3.6.1. Desabilitação de Interrupções

A solução mais simples para o problema da exclusão mútua é fazer com que
o processo, antes de entrar em sua região crítica, desabilite todas as interrupções
externas e as reabilite após deixar a região crítica. Um dos problemas deste
mecanismo é quando o processo que desabilitou as interrupções não torna a
habilitá-las. Nesse caso, o sistema, provavelmente, terá seu funcionamento
seriamente comprometido.
3.6.2. Instrução Test-and-Set

Muitos processadores possuem uma instrução especial que permite ler uma
variável, armazenar seu conteúdo em outra área e atribuir um novo valor a essa
variável. Esse tipo especial de instrução é chamado instrução test-and-set e tem
como característica ser sempre executada sem interrupção, ou seja, trata-se de
uma instrução indivisível. Assim, não existe a possibilidade de dois processos
estarem manipulando uma variável compartilhada ao mesmo tempo, possibilitando
a implementação da exclusão mútua.
A instrução test-and-set possui o formato abaixo e na sua execução o valor
lógico da variável Y é copiado para X, sendo atribuído à variável Y o valor lógico
verdadeiro.
Test-and-Set (X,Y);
Para coordenar o acesso concorrente a um recurso, a instrução test-and-set
utiliza uma variável lógica global que chamaremos bloqueio. Quando a variável
bloqueio for falsa, qualquer processo poderá alterar seu valor para verdadeiro,
através da instrução test-and-set e, assim, acessar o recurso de forma exclusiva.
Ao terminar o acesso, o processo deve simplesmente retornar o valor da variável
para falso, liberando o acesso ao recurso.
program programa_test_and_set;
var bloqueio: boolean;
procedure processo_A;
var pode_a : boolean;
begin
repeat
pode_a := true;
while (pode_a) do
test_and_set (pode_a, bloqueio);
regiao_critica_A;
bloqueio := false;
until false;
end;
procedure processo_B;
var pode_b : boolean;
begin
34
repeat
pode_b := true;
while (pode_b) do
test_and_set (pode_b, bloqueio);
regiao_critica_B;
bloqueio := false;
until false;
end;
begin
bloqueio := false;
PARBEGIN
processo_A;
processo_B;
PAREND;
end.
3.7. Soluções de Software para o Problema de Exclusão Mútua

Além da exclusão mútua, que soluciona os problemas de compartilhamento
de recursos, três fatores fundamentais para a solução dos problemas de
sincronização deverão ser atendidos:
ª O número de processadores e o tempo de execução dos processos concorrentes
devem ser irrelevantes.
ª Um processo, fora de sua região crítica, não pode impedir que outros processos
entrem nas suas próprias regiões críticas.
ª Um processo não pode ficar indefinidamente esperando para entrar em sua
região crítica.
As ferramentas mais recentes de software utilizadas para a solução de

problemas de sincronização entre processos são os SEMÁFOROS, uma solução de
alto nível denominada MONITORES e a TROCA DE MENSAGENS.
3.7.1. Semáforos
O conceito de semáforo foi proposto como uma solução mais geral e
simples, para os problemas de sincronização entre processos concorrentes.
Um semáforo é uma estrutura composta de uma FILA e uma variável inteira,
não negativa, que só pode ser manipulada por duas instruções: DOWN e UP. Estas
instruções funcionam como protocolo de entrada e saída no caso de exclusão
mútua.
Sempre que deseja entrar na sua região crítica, um processo executa uma
instrução DOWN. Se o semáforo for maior que 0, este é decrementado de 1, e o
processo que solicitou a operação pode executar sua região crítica. Entretanto, se
uma instrução DOWN é executada em um semáforo cujo valor seja igual a 0, o
processo que solicitou a operação ficará no estado de espera, em uma fila
associada ao semáforo.
35
O processo que está acessando o recurso, ao sair da sua região crítica,

executa uma instrução UP, incrementando o semáforo de 1 e liberando o acesso ao
recurso. Se um ou mais processos estiverem esperando, devido a operações DOWN
pendentes o sistema escolhe um processo na fila de espera e muda seu estado para
pronto.
As instruções DOWN e UP em sintaxe PASCAL não convencional:
type semaforo = record
fila_espera : fila;
valor : integer;
end;
procedure DOWN (var s : semaforo);

begin
if (s.valor = 0) then
coloca_processo_na_fila_de_espera
else
s.valor := s.valor – 1;
end;
procedure UP (var s : semaforo);

begin
if (tem_processo_esperando) then
tira_da_fila_de_espera
else
s.valor := s.valor + 1;
end;
As operações DOWN e UP são indivisíveis; assim, é garantido que, se uma
das operações for iniciada, nenhum outro processo poderá ter acesso ao semáforo
até o término dessa operação.
O programa a seguir mostra uma solução para o problema de exclusão
mútua entre dois processos através do uso de semáforos. Inicialmente, o semáforo
está com o valor 1, indicando que nenhum processo está executando sua região
crítica. O Processo_A executa a instrução DOWN, fazendo com que o semáforo seja
decrementado de 1 e passe a ter o valor 0. Em seguida, o Processo_A ganha o
acesso a sua região crítica. O Processo_B também executa a instrução DOWN, mas
como seu valor é igual a 0, ficará aguardando até que o Processo_A execute a
instrução UP, ou seja, volte o valor do semáforo para 1.
program semaforo;
var s : semaforo;
procedure processo_A;
begin
repeat
DOWN(s);
regiao_critica_A;
UP(s);
until false;
end;
36
procedure processo_B;
begin
repeat
DOWN(s);
regiao_critica_B;
UP(s);
until false;
end;
begin
s.valor := 1;
PARBEGIN
processo_A;
processo_B;
PAREND;
end.
3.7.2. Monitores
O uso de semáforos exige do programador muito cuidado, pois qualquer
engano pode levar a problemas de sincronização imprevisíveis. Monitores são
mecanismos de sincronização de alto nível, que tentam tornar mais fácil o
desenvolvimento e a correção de programas concorrentes.
Vejamos um exemplo bem simples, onde dois processos somam e
diminuem, concorrentemente, o valor da variável compartilhada X.
program exemplo;
monitor regiao_critica;
var x : integer;
procedure soma;
begin
x:= x + 1;
end;
procedure diminui;
begin
x := x –1 ;
end;
begin
x := 0;
end;
begin
PARBEGIN
regiao_critica.soma;
regiao_critica.diminui;
PAREND;
end;
A inicialização da variável compartilhada X com o valor zero só acontece
uma vez, no momento da primeira ativação do monitor regiao_critica. Neste
exemplo, pode-se garantir que o valor de X ao final da execução concorrente dos
procedimentos de soma e diminuição será igual a zero. Isso porque, como os
procedimentos estão definidos dentro do monitor, estará garantida a execução
mutuamente exclusiva entre eles.
37
3.7.3. Troca de Mensagens

Troca de mensagem é um mecanismo de comunicação e
sincronização entre processos, implementado pelo sistema operacional através de

duas rotinas do sistema: SEND e RECEIVE. A rotina SEND é responsável por enviar
uma mensagem para um processo receptor, e a rotina RECEIVE por receber uma
mensagem de um processo transmissor. As rotinas podem ser representadas
através dos procedimentos a seguir:
SEND (receptor, mensagem);
RECEIVE (transmissor, mensagem);
Os procedimentos SEND e RECEIVE, mesmo não sendo suas execuções
mutuamente exclusivas, permitem tanto a comunicação entre processos como a
sincronização entre eles. A comunicação ocorre porque um processo, ao receber
uma mensagem, obtém dados enviados de outro processo. A sincronização é obtida
porque uma mensagem somente pode ser lida após ter sido enviada, restringindo,
dessa forma, a ordem na qual os dois eventos devem ocorrer.
Exemplo:
program produtor_consumidor;
procedure produtor;
var msg: tipo_msg;
begin
repeat
produz_mensagem (msg);
SEND (msg);
until false;
end;
procedure consumidor;
var msg: tipo_msg;
begin
repeat
RECEIVE (msg);
consome_mensagem (msg);
until false;
end;
begin
PARBEGIN
produtor;
consumidor;
PAREND;
end.
3.8. Deadlock
Um processo é dito em deadlock quando está esperando por um evento que
nunca ocorrerá. Esta situação é consequência, na maioria das vezes, do
compartilhamento de recursos do sistema entre vários processos, sendo que cada
processo deve ter acesso ao recurso de forma exclusiva (exclusão mutua).
38
4. Gerência do Processador
4.1. Introdução
O conceito básico que gerou a implementação dos sistemas
multiprogramáveis foi a possibilidade de a UCP ser compartilhada entre diversos
processos. Por isso, o procedimento para o escalonamento de processos (seleção
de processos entre os vários que estão na fila de pronto para utilização do
processador), é uma das principais funções executadas pelo sistema operacional
multiprogramável.
Execução Processo
(UCP)
Escalonamento
Processo
Pronto
Espera
Processo
Processo
Processo
Principais Objetivos do Escalonador de Processos:

ª Manter a UCP ocupada o maior tempo possível;
ª Balancear a utilização do processador entre os diversos processos;
ª Maximizar o throughput do sistema (número de processos executados num
intervalo de tempo);
ª Oferecer um tempo de resposta razoável para os usuários interativos.
Para atender alguns desses objetivos, os sistemas operacionais devem levar

em consideração as características dos processos, ou seja, se um processo é do
tipo batch, interativo, CPU-bound ou I/O-bound. Sistemas de tempo real e de
tempo compartilhado também são aspectos fundamentais para a implementação de
uma política de escalonamento.
4.2. Critérios de Escalonamento

ª Utilização de UCP: É desejável que o processador fique a maior parte do seu
tempo ocupado;
ª Throughput: O throughput representa o número de processos (tarefas)
executados em um intervalo de tempo. A maximização do throughput é
desejada na maioria dos sistemas.
ª Tempo de Turnaround: Tempo que um processo leva desde sua admissão no
sistema até o seu término, levando em consideração o tempo de espera para
alocação de memória, espera na fila de processos prontos para execução,
processamento na UCP e operações de E/S.
39
ª Tempo de Resposta: Em sistemas interativos, o tempo de resposta é o tempo

decorrido do momento da submissão de um pedido até a primeira resposta
produzida.
De um modo geral, qualquer algoritmo de escalonamento busca otimizar a

utilização da UCP e o throughput, enquanto tenta diminuir o tempo de turnaround e
de resposta.
4.3. Escalonamento Não-preempitivo

O escalonamento não-preemptivo é aquele que quando um processo ganha
o direito de utilizar a UCP, nenhum outro processo pode tirar esse recurso. Alguns
escalonamentos não-preemptivos são:
4.3.1. Escalonamento First-In-First-Out (FIFO)

O processo que chega primeiro (first-in) ao estado de pronto é o primeiro a
ser selecionado para ocupar a UCP (first-out).
Problema: Impossibilidade de prever quando o processo terá sua execução
iniciada.
4.3.2. Escalonamento Shortest-Job-First (SJF)

Este algoritmo associa cada processo (ou job) ao seu tempo de execução.
Dessa forma, quando o processador está livre, o processo em estado de pronto que
precisar de menor tempo de UCP para terminar o seu processamento é selecionado
para execução.
Problema: Determinar quanto tempo de UCP cada processo necessita para o seu
processamento.
4.3.3. Escalonamento Cooperativo

A partir do momento que o processo está em execução, este
voluntariamente libera o processador, retornando a fila de pronto.
Problema: Um programa pode não liberar o processador, monopolizando desta
forma a UCP.
Observação: Escalonamento FIFO e SJF não podem ser aplicados em sistemas de

tempo compartilhado, onde um tempo de resposta razoável deve ser garantido
para usuários interativos.
Exercício: Simule as políticas de escalonamento não-preemptivas: FIFO, SJF e

HRN, para situação de chegada de processos representada pela régua de tempo:
Tempo 1 2 3 4 5 6 7
(A,4), (C,3) (D,2), (F,1) (G,3), (I,1)
(B,2) (E,5) (H,2)
Onde: (X,Y), representa um identificador do processo (X) e o tempo estimado de
execução do processo (Y).
40
4.4. Escalonamento Preempitivo

Um algoritmo de escalonamento é denominado preemptivo quando o
sistema pode interromper um processo em execução para que outro processo
utilize o processador. O escalonamento preemptivo permite que o sistema dê
atenção imediata a processos mais prioritários, como no caso de sistemas de tempo
real, além de proporcionar melhores tempos de resposta em sistemas de tempo
compartilhado. Outro benefício é o compartilhamento do processador de uma
maneira mais uniforme entre os processos. Vejamos, a seguir, alguns dos principais
algoritmos de escalonamento preemptivos.
4.4.1. Escalonamento Circular (Round Robin)

Projetado para sistema de tempo compartilhado, é semelhante ao
escalonamento FIFO, porém, quando um processo passa para o estado de
execução, ou seja, ganha a UCP, existe um tempo limite para sua utilização de
forma contínua. Quando este tempo, denominado time-slice ou quantum, expira, o
processo volta para o fim da fila de prontos, dando a vez para outro processo. Este
mecanismo é definido como preempção por tempo.
Problema: Não faz um compartilhamento eqüitativo, pois este escalonamento
trata todos os processo de maneira igual.
4.4.2. Escalonamento por Prioridades

Nesse esquema, processos de maior prioridade são escalonados
preferencialmente. Toda vez que um processo vai para a fila de pronto com uma
prioridade maior do que processo em execução, o sistema deve interromper o
processo corrente, colocá-lo no estado de pronto e selecionar o de maior prioridade
para ser executado. Este mecanismo é definido como preempção por prioridade.
A prioridade é estática quando não é modificada durante a existência do
processo. A prioridade é dinâmica se pode ser ajustada durante a vida do processo.
4.4.3. Escalonamento por Múltiplas Filas

Como os diversos processos do sistema possuem características de
processamento diferentes, é difícil que um único mecanismo de escalonamento seja
adequado a todos os tipos de processos.
O escalonamento por múltiplas filas implementa diversas filas de processos
no estado de pronto, onde cada processo é associado exclusivamente a uma delas.
Cada fila possui mecanismo próprio de escalonamento, em função das
características dos processos.
Cada fila possui uma prioridade associada, que estabelece quais filas são
prioritárias em relação às outras. O sistema só pode escalonar processos de uma
fila, se todas as outras de prioridade maior estiverem vazias.
41
4.4.4. Escalonamento por Múltiplas Filas com Realimentação

Semelhante ao escalonamento anterior, porém os processos não
permanecem em uma mesma fila até o término do processamento. Neste
escalonamento, o sistema tenta identificar dinamicamente o comportamento de
cada processo, ajustando assim suas prioridades de execução e mecanismos de
escalonamento.
Problema: Devido a sua complexidade, este escalonamento pode gerar um grande
overhead ao sistema, o que, mesmo assim, pode justificar sua implementação.
4.4.5. Escalonamento de Sistemas de Tempo Real

Nos sistemas operacionais de tempo real, o fator tempo é crítico. Neste tipo
de escalonamento não existe o conceito de quantum ou time-slice. O
escalonamento é realizado unicamente com base no esquema de prioridades. Para
cada processo é atribuída uma prioridade associada à sua importância dentro do
sistema. Esta prioridade deve ser estática, não devendo ser alterada no decorrer
do processamento.
Este escalonamento deve ser empregado na solução de aplicações onde
existam graus de exigências em relação ao tempo de execução das tarefas. Por
exemplo, um sistema de controle de tráfego aéreo.
4.5. Escalonamento com Múltiplos Processadores

O escalonamento para sistemas com múltiplos processadores é bem mais
complexo. A abordagem é diferenciada quando tratamos de sistemas fracamente
acoplados ou fortemente acoplados.
Em sistemas fracamente acoplados cada processador faz seu próprio

escalonamento local.
Em sistemas fortemente acoplados é possível implementar uma única fila de

pronto para todos os processadores. Todos os processos estão presentes nesta
única fila e são escalonados no primeiro processador disponível. Nesta solução é
importante que, para a execução do algoritmo de escalonamento, seja
implementada a exclusão mútua para o seu código.
42
Bibliografia
Livros:
MACHADO, Francis B.; MAIA, Luiz Paulo. Arquitetura de Sistemas Operacionais.

2. Ed. Rio de Janeiro: Livros Técnicos e Científicos, 1997.
OLIVEIRA, Rômulo Silva de; CARISSIMI, Alexandre da Silva; TOSCANI, Simão

Sirineo. Sistemas Operacionais. 2ª Edição. Porto Alegre: Sagra-Luzzatto, 2001.
TANEMBAUM, A. S. Sistemas Operacionais Modernos. Editora Guanabara

Koogan, 1995.
Endereços Eletrônicos:
http://www.ccuec.unicamp.br/treinamento_int2004/linux_basico/index.html
http://
43

Sop Apostila

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Sop Apostila

Hochgeladen von

Copyright:

Verfügbare Formate

Faculdade Cenecista de Varginha - MG

Bacharelado em Sistemas de Informação

Prof. José Eduardo S. Gomes

1. Sistemas Operacionais ......................................................................... 1

3. Comunicação entre Processos ............................................................... 30

4. Gerência do Processador ...................................................................... 39

1.1. Conceitos Básicos de Sistema Operacional

Em torno de um computador, existem usuários com problemas para serem

O sistema operacional não resolve os problemas do usuário final. Ele não

Funções principais do SO:

1.2. Máquina de Níveis

1.3.1. Primeira Fase (1945-1955)

1.3.2. Segunda Fase (1956-1965)

Cartões Perfurados Processamento

Inicialmente, os programas passaram a ser perfurados em cartões, que,

1.3.3. Terceira Fase (1966-1980)

ª Substituição das fitas por discos magnéticos, permitindo a alteração na ordem

1.3.4. Quarta Fase (1981-1990)

1.3.5. Quinta Fase (1991-2000)

1.4. Conceitos de Hardware e Software

Serão apresentados alguns conceitos básicos sobre hardware e software

1.4.1. Conceitos de Hardware

Unidade Central de Processamento (UCP)

Unidade Lógica Unidade de

1.4.1.1. Unidade Central de Processamento

• Contador de instrução – é o registrador responsável pelo armazenamento do

• Apontador de pilha – é o registrador que contém o endereço de memória do

• Registrador de estado – é responsável por armazenar informações sobre a

1.4.1.4. Memória Principal

1.4.1.5. Memória Cache

1.4.1.6. Memória Secundária

Maior Maior custo e

1.4.1.7. Dispositivos de Entrada e Saída

1.4.1.10. Ativação e Desativação do Sistema

1.4.1.11. Arquiteturas RISC e CISC

1.4.2. Conceitos de Software

No decorrer do texto, utilizaremos o termo utilitário, sempre que desejarmos

O linker (ligador) é o utilitário responsável por gerar, a partir de um ou mais

1.4.2.6. Linguagem de Controle

1.4.2.7. Linguagem de Máquina

Os microprogramas definem a linguagem de máquina de cada computador.

1.5. Tipos de Sistemas Operacionais

1.5.1. Sistemas Monoprogramáveis / Monotarefa

Vantagem: são simples de implementação, não exigindo preocupação com

Desvantagem: a memória e o processador são subutilizados.

1.5.2. Sistemas Multiprogramáveis / Multitarefa

Vantagem: aumento da produtividade dos seus usuários e a redução de custo, a

Desvantagem: sistemas mais complexos, o sistema se preocupa em gerenciar o

O conceito de sistema multiprogramável está tipicamente associado aos

Os sistemas multiprogramáveis/multitarefas podem ser classificados pela

1.5.2.1. Sistemas Batch

1.5.2.2. Sistemas de Tempo Compartilhado

1.5.2.3. Sistemas de Tempo Real

1.5.3. Sistemas com Multiprocessadores

Os conceitos utilizados no projeto de sistemas com múltiplos processadores

Podemos classificar os Sistemas com Múltiplos Processadores em

1.5.3.1. Sistemas Fortemente Acoplados

ª Sistemas Assimétricos: caracterizam-se por possuir um processador

ª Sistemas Simétricos: todos os processadores realizam as mesmas funções,

1.5.3.2. Conceitos e Organização dos Sistemas Fortemente Acoplados

ª Multiprocessamento: uma tarefa pode ser executada, ao mesmo tempo, por

ª Organização Funcional: O esquema de comunicação interna das UCPs,

1.5.3.3. Sistemas Fracamente Acoplados

ª Sistemas Operacionais de Rede: cada nó (sistema independente) possui seu

Vários programas podem estar residentes na memória, concorrendo pela

A utilização concorrente da UCP deve ser implementada de maneira que,

Em sistemas multiprogramáveis é possível compartilhar os periféricos. Como,