ApostilaSO 2008

SISTEMAS OPERACIONAIS
APOSTILA por Luclia Ribeiro
Nada lhe posso dar que j no exista em voc mesmo.

No posso abrir-lhe outro mundo de imagens, alm daquele que h em sua
prpria alma. Nada lhe posso dar a no ser a oportunidade, o impulso, a chave. Eu o ajudarei a tornar visvel o seu prprio mundo, e isso tudo.
(Hermann Hesse)
Verso 6 ago/08
ndice
"A alma tem terrenos infranqueveis, onde retemos nossos
sonhos dourados ou um tenebroso drago. Assim fazemos
por medo de que ambos nos escapem, temendo que nos
roubem o ouro ou nos devore o drago (Ralph Emerson)
NDICE .................................................................................................................................................................. 2
VISO GERAL ..................................................................................................................................................... 6
1.1
1.2
1.2.2
1.3
1.3.1
1.4
1.4.1
1.5
1.5.1
1.5.2
1.5.3
1.5.4
1.5.5
1.5.6
1.6
1.6.1
1.6.2
a)
b)
c)
1.6.3
1.7
INTRODUO ................................................................................................................................... 6
O SISTEMA OPERACIONAL - FUNCIONALIDADES.................................................................... 6
O SISTEMA OPERACIONAL VISTO COMO UM GERENTE DE RECURSOS............................. 6
SISTEMA OPERACIONAL NA VISO DO USURIO.................................................................... 7
CHAMADAS DE SISTEMA ............................................................................................................. 7
PROJETO DO SISTEMA OPERACIONAL........................................................................................ 8
INTERRUPO x EXCEO......................................................................................................... 8
HISTRICO DOS SISTEMAS OPERACIONAIS .............................................................................. 9
DCADA DE 1940 (Ausncia de SOs)............................................................................................ 9
DCADA DE 1950 (Processamento em Batch) .............................................................................. 9
DCADA DE 1960 (Processamento Time-sharing)...................................................................... 10
DCADA DE 1970 (Multiprocessamento) .................................................................................... 10
DCADA DE 1980 (Computadores Pessoais):............................................................................. 10
DCADA DE 1990 (Sistemas Distribudos): ................................................................................ 11
CLASSIFICAO DOS SISTEMAS OPERACIONAIS .................................................................. 11
SISTEMAS MONOPROGRAMVEIS OU MONOTAREFAS........................................................ 11
SISTEMAS MULTIPROGRAMVEIS OU MULTITAREFAS ....................................................... 11
Sistemas Batch.................................................................................................................................... 12
Sistemas de Tempo Compartilhado .................................................................................................... 12
Sistemas de Tempo Real ..................................................................................................................... 12
SISTEMAS COM MLTIPLOS PROCESSADORES .................................................................... 13
EXERCCIOS .................................................................................................................................... 15
MULTIPROGRAMAO................................................................................................................................. 16
2.1
INTRODUO ................................................................................................................................. 16
2.2
MECANISMO BSICO .................................................................................................................... 16
2.3
O CONCEITO DE PROCESSO ......................................................................................................... 17
2.4
ESTRUTURA DO PROCESSO ......................................................................................................... 18
2.4.1
CONTEXTO DE HARDWARE ...................................................................................................... 19
2.4.2
CONTEXTO DE SOFTWARE ....................................................................................................... 19
2.4.3
ESPAO DE ENDEREAMENTO ............................................................................................... 20
2.4.4
BLOCO DE CONTROLE DE PROCESSO ................................................................................... 20
2.5
ESTADOS DO PROCESSO .............................................................................................................. 20
2.6
MUDANA DE ESTADO DO PROCESSO ..................................................................................... 21
2.7
CRIAO E ELIMINAO DE PROCESSOS................................................................................ 22
2.8
PROCESSOS INDEPENDENTES, SUBPROCESSOS E THREADS .............................................. 23
2.9
PROCESSOS PRIMEIRO (FOREGROUND) E SEGUNDO PLANO (BACKGROUND) ................ 24
2.10.
PROCESSOS LIMITADOS POR CPU (CPU-BOUND) E POR E/S (I/O-BOUND).......................... 24
2.11
SELEO DE PROCESSOS............................................................................................................. 24
2.11.1
FILAS PARA SELEO DE PROCESSOS .............................................................................. 24
2.11.2
ESCALONADORES .................................................................................................................. 25
2.12
EXERCCIOS .................................................................................................................................... 25
PROGRAMAO CONCORRENTE.............................................................................................................. 27
3.1
INTRODUO ................................................................................................................................. 27
3.2
DEFINIO ...................................................................................................................................... 27
3.3
SINCRONIZAO ........................................................................................................................... 27
3.4
ESPECIFICAO DE CONCORRNCIA EM PROGRAMAS....................................................... 29
3.5
PROBLEMAS DE COMPARTILHAMENTO DE RECURSOS....................................................... 30
2
Sistemas Operacionais Lucilia Ribeiro
3.6
EXCLUSO MTUA ....................................................................................................................... 32
3.7
SOLUES DE HARDWARE ......................................................................................................... 32
3.7.1
DESABILITAO DAS INTERRUPES.................................................................................... 32
3.7.2
INSTRUO TEST-AND-SET LOCKED (TSL)............................................................................ 33
3.8
SOLUES DE SOFTWARE ........................................................................................................... 33
3.8.1
PRIMEIRO ALGORITMO: ESTRITA ALTERNNCIA................................................................. 33
3.8.2
SEGUNDO ALGORITMO:............................................................................................................ 34
3.8.3
TERCEIRO ALGORITMO: ........................................................................................................... 35
3.8.4
QUARTO ALGORITMO: .............................................................................................................. 35
3.8.5
ALGORITMO DE PETERSON...................................................................................................... 36
3.9
PROBLEMA DO PRODUTOR-CONSUMIDOR OU SINCRONIZAO CONDICIONAL .......... 37
3.10
SEMFOROS.................................................................................................................................... 38
3.10.1
EXCLUSO MTUA UTILIZANDO SEMFOROS ................................................................ 38
3.10.2
SINCRONIZAO CONDICIONAL UTILIZANDO SEMFOROS......................................... 39
3.11
TROCA DE MENSAGENS ............................................................................................................... 40
3.12
PROBLEMAS CLSSICOS DE SINCRONIZAO ...................................................................... 41
3.12.1
PROBLEMA DOS FILSOFOS GLUTES............................................................................. 41
3.12.2
PROBLEMA DO BARBEIRO DORMINHOCO........................................................................ 41
3.13
EXERCCIOS .................................................................................................................................... 42
DEADLOCK........................................................................................................................................................ 44
4.1
INTRODUO ................................................................................................................................. 44
4.2
EXEMPLOS DE DEADLOCKS........................................................................................................ 44
4.2.1
DEADLOCK DE TRFEGO ......................................................................................................... 44
4.2.2
DEADLOCK SIMPLES DE RECURSOS ...................................................................................... 44
4.2.3
DEADLOCK EM SISTEMAS DE SPOOLING .............................................................................. 44
4.2.4
ADIAMENTO INDEFINIDO......................................................................................................... 45
4.3
RECURSOS ....................................................................................................................................... 45
4.4
QUATRO CONDIES NECESSRIAS PARA DEADLOCKS .................................................... 46
4.5
O MODELO DO DEADLOCK .......................................................................................................... 46
4.6
MTODOS PARA LIDAR COM DEADLOCKS.............................................................................. 47
4.7
O ALGORITMO DO AVESTRUZ .................................................................................................... 48
4.8
DETECO DE DEADLOCKS........................................................................................................ 48
4.8.1
DETECO DO DEADLOCK COM UM RECURSO DE CADA TIPO....................................... 48
4.8.2
DETECO DO DEADLOCK COM VRIOS RECURSOS DE CADA TIPO............................. 49
4.9
RECUPERAO DE DEADLOCKS................................................................................................ 50
4.9.1
RECUPERAO ATRAVS DA PREEMPO ........................................................................... 50
4.9.2
RECUPERAO ATRAVS DE VOLTA AO PASSADO .............................................................. 50
4.9.3
RECUPERAO ATRAVS DE ELIMINAO DE PROCESSOS.............................................. 50
4.10
TENTATIVAS DE EVITAR O DEADLOCK ................................................................................... 51
4.10.1
ESTADOS SEGUROS E INSEGUROS ..................................................................................... 51
4.10.2
ALGORITMO DO BANQUEIRO PARA UM NICO TIPO DE RECURSO............................ 51
4.11
PREVENO DE DEADLOCKS ..................................................................................................... 52
4.11.1
ATACANDO O PROBLEMA DA EXCLUSO MTUA........................................................... 52
4.11.2
ATACANDO O PROBLEMA DA POSSE E DA ESPERA......................................................... 52
4.11.3
ATACANDO O PROBLEMA DA CONDIO DE NO-PREEMPO................................. 52
4.11.4
ATACANDO O PROBLEMA DA ESPERA CIRCULAR ........................................................... 52
4.12
EXERCCIOS .................................................................................................................................... 53
GERNCIA DO PROCESSADOR ................................................................................................................... 55
5.1
INTRODUO ................................................................................................................................. 55
5.2
FUNES BSICAS ........................................................................................................................ 55
5.3
CRITRIOS DE ESCALONAMENTO ............................................................................................. 55
5.4
ESTRATGIAS DE ESCALONAMENTO....................................................................................... 56
5.5
ESCALONAMENTO FIRST COME FIRST SERVED (FCFS) OU FIFO ......................................... 56
5.6
ESCALONAMENTO MENOR JOB PRIMEIRO OU SJF (SHORTEST JOB FIRST) ............................. 57
5.7
ESCALONAMENTO PRXIMA TAXA DE RESPOSTA MAIS ALTA OU HRRN ....................... 57
5.8
ESCALONAMENTO MENOR TEMPO REMANESCENTE OU SRT ............................................. 58
5.9
ESCALONAMENTO CIRCULAR OU ROUND ROBIN (RR) ......................................................... 58
5.10
ESCALONAMENTO POR PRIORIDADES..................................................................................... 59
5.11
ESCALONAMENTO POR MLTIPLAS FILAS ............................................................................. 59
5.12
ESCALONAMENTO DE TEMPO REAL ......................................................................................... 60
5.12.1
ESCALONAMENTO DE TEMPO REAL ESTTICOS ............................................................. 61
5.12.2
ESCALONAMENTO DE TEMPO REAL DINMICOS............................................................ 61
5.13
EXERCCIOS .................................................................................................................................... 61
GERNCIA DE MEMRIA ............................................................................................................................. 66
6.1
6.2
6.3
6.4
6.5
6.5.1
6.5.2
6.5.3
6.6
6.7
INTRODUO ................................................................................................................................. 66
FUNES BSICAS ........................................................................................................................ 66
ALOCAO CONTGUA SIMPLES ............................................................................................... 66
TCNICA DE OVERLAY................................................................................................................... 67
ALOCAO PARTICIONADA ....................................................................................................... 67
ALOCAO PARTICIONADA ESTTICA................................................................................... 67
ALOCAO PARTICIONADA DINMICA ................................................................................. 69
ESTRATGIAS DE ALOCAO DE PARTIO ........................................................................ 69
SWAPPING ....................................................................................................................................... 72
EXERCCIOS .................................................................................................................................... 73
MEMRIA VIRTUAL ....................................................................................................................................... 76

7.1
7.2
7.3
7.4
7.4.1
7.4.2
7.4.3
7.4.4
7.4.5
7.4.6
7.5
7.6
7.7
INTRODUO ................................................................................................................................. 76
ESPAO DE ENDEREAMENTO VIRTUAL ................................................................................ 76
MAPEAMENTO................................................................................................................................ 77
PAGINAO .................................................................................................................................... 77
PAGINAO MULTINVEL ......................................................................................................... 80
POLTICAS DE BUSCA DE PGINAS......................................................................................... 80
POLTICAS DE ALOCAO DE PGINAS ................................................................................ 81
POLTICAS DE SUBSTITUIO DE PGINAS.......................................................................... 81
WORKING SET ............................................................................................................................. 82
ALGORITMOS DE SUBSTITUIO DE PGINAS..................................................................... 83
SEGMENTAO.............................................................................................................................. 86
SEGMENTAO PAGINADA ........................................................................................................ 87
EXERCCIOS .................................................................................................................................... 87
SISTEMA DE ARQUIVOS ................................................................................................................................ 94

8.1
8.2
8.3
8.4
8.4.1
8.4.2
8.4.3
8.5
8.6
8.6.1
8.6.2
8.6.3
8.7
8.8
8.8.1
8.8.2
8.8.3
8.8.4
8.9
8.10
INTRODUO ................................................................................................................................. 94
HIERARQUIA DE DADOS .............................................................................................................. 94
ARQUIVOS ....................................................................................................................................... 95
SISTEMAS DE ARQUIVOS ............................................................................................................. 95
DIRETRIOS ................................................................................................................................ 96
METADADOS................................................................................................................................ 97
MONTAGEM................................................................................................................................. 99
ORGANIZAO DE ARQUIVO ................................................................................................... 100
MTODOS DE ALOCAO.......................................................................................................... 101
ALOCAO CONTGUA............................................................................................................ 101
ALOCAO COM LISTA LIGADA ............................................................................................ 101
ALOCAO COM LISTA LIGADA USANDO UM NDICE ...................................................... 102
GERNCIA DE ESPAO EM DISCO ............................................................................................ 103
CONTROLE DE BLOCOS LIVRES ............................................................................................... 103
MAPA DE BITS ........................................................................................................................... 103
LISTA ENCADEADA................................................................................................................... 103
AGRUPAMENTO ........................................................................................................................ 104
CONTADORES............................................................................................................................ 104
CONSISTNCIA EM BLOCOS...................................................................................................... 104
EXERCCIOS .................................................................................................................................. 104
GERNCIA DE DISPOSITIVOS.................................................................................................................... 106

9.1
INTRODUO ............................................................................................................................... 106
9.2
ACESSO AO SUBSISTEMA DE ENTRADA E SADA................................................................. 106
9.3
SUBSISTEMA DE ENTRADA E SADA ....................................................................................... 107
9.4
DEVICE DRIVERS ......................................................................................................................... 108
9.5
CONTROLADORES ....................................................................................................................... 108
9.6
DISPOSITIVOS DE ENTRADA E SADA ..................................................................................... 109
9.7
DISCOS............................................................................................................................................ 109
9.8
ESCALONAMENTO DO BRAO DO DISCO .............................................................................. 111
9.8.1 PRIMEIRO A CHEGAR, PRIMEIRO A SER ANTENDIDO (FCFS)................................................ 111
9.8.2. MENOR SEEK PRIMEIRO (Shortest Seek First - SSF) .................................................................. 111
9.8.3. ALGORITMO DO ELEVADOR (Scan)............................................................................................ 112

9.8.4. ALGORITMO CIRCULAR (C-Scan)................................................................................................ 112
9.9
EXERCCIOS .................................................................................................................................. 112
BIBLIOGRAFIA ............................................................................................................................................... 114
01 Viso Geral
Viso Geral
As coisas so sempre melhores no comeo

(Blaise Pascal)
1.1
INTRODUO
Um computador sem software nada seria. O software pode ser dividido, a grosso modo, em duas categorias: os programas do sistema, que gerenciam a operao do prprio
computador, e os programas de aplicao, que resolvem problemas para seus usurios.
O mais importante dos programas de sistema o sistema operacional, que controla
todos os recursos do computador, e fornece a base sobre a qual os programas aplicativos
so escritos.
Um sistema operacional, por mais complexo que possa parecer, apenas um conjunto de rotinas executado pelo processador, de forma semelhante aos programas dos usurios. Sua principal funo controlar o funcionamento de um computador, gerenciando a
utilizao e o compartilhamento dos seus diversos recursos, como processadores, memrias e dispositivos de entrada e sada.
Sem o sistema operacional, um usurio para interagir com o computador deveria conhecer profundamente diversos detalhes sobre hardware do equipamento, o que tornaria
seu trabalho lento e com grandes possibilidades de erros.
A grande diferena entre um sistema operacional e aplicaes convencionais, a maneira como suas rotinas so executadas em funo do tempo. Um sistema operacional
no executado de forma linear como na maioria das aplicaes, com incio, meio e fim.
Suas rotinas so executadas concorrentemente em funo de eventos assncronos, ou
seja, eventos que podem ocorrer a qualquer momento.
1.2
O SISTEMA OPERACIONAL - FUNCIONALIDADES
O Sistema Operacional o software que controla todos os recursos do computador e

fornece a base sobre a qual os programas aplicativos so escritos e suas principais funcionalidades so: Mquina Virtual ou Estendida e Gerente de Recursos.
1.2.1 O SISTEMA OPERACIONAL VISTO COMO UMA MQUINA ESTENDIDA
Programar em nvel de arquitetura uma tarefa ingrata para qualquer usurio de um
sistema de computador. Para tratar da entrada/sada numa unidade de disco flexvel, por
exemplo, o usurio deveria trabalhar com comandos relativos a: leitura/escrita de dados,
movimento da cabea, formatao de trilhas e inicializao, sensoriamento, reinicializao e calibrao do controlador e do driver de disquete.
bvio dizer que o programador no vai querer lidar com esse tipo de detalhes, desejando portanto uma abstrao de alto nvel. Assim, deve haver um programa que esconda do usurio o verdadeiro hardware e apresente-lhe um esquema simples de arquivos identificados que possam ser lidos ou escritos. Tal programa o sistema operacional.
Do ponto de vista de mquina estendida, o sistema operacional trata ainda de outras
questes incmodas como: interrupes, temporizadores, gerncia de memria etc.
A funo do sistema operacional, nesse ponto de vista, apresentar ao usurio uma
mquina virtual equivalente ao hardware, porm muito mais fcil de programar.
1.2.2 O SISTEMA OPERACIONAL VISTO COMO UM GERENTE DE RECURSOS
Em sistemas onde diversos usurios compartilham recursos do sistema computacional, necessrio controlar o uso concorrente desses recursos. Se imaginarmos uma impressora sendo compartilhada, dever existir algum tipo de controle para que a impresso de um usurio no interfira nas dos demais. Novamente o sistema operacional que
01 Viso Geral
tem a responsabilidade de permitir o acesso concorrente a esse e a outros recursos de

forma organizada e protegida.
No apenas em sistemas multiusurio que o sistema operacional importante. Se
pensarmos que um computador pessoal nos permite executar diversas tarefas ao mesmo
tempo, como imprimir um documento, copiar um arquivo pela Internet ou processar uma
planilha, o sistema operacional deve ser capaz de controlar a execuo concorrente de
todas essas atividades.
Assim, o sistema operacional deve gerenciar o uso dos recursos, contabilizando o uso
de cada um e garantindo acesso ordenado de usurios a recursos atravs da mediao
de conflitos entre as diversas requisies existentes.
1.3
SISTEMA OPERACIONAL NA VISO DO USURIO
A arquitetura de um sistema operacional corresponde imagem que o usurio tem do

sistema, a forma como ele percebe o sistema. Essa imagem definida pela interface atravs da qual o usurio acessa os servios do sistema operacional. Essa interface, assim
como a imagem, formada pelas chamadas de sistema e pelos programas de sistema.
1.3.1 CHAMADAS DE SISTEMA
Os programas solicitam servios ao sistema operacional atravs das chamadas de
sistema. Elas so semelhantes s chamadas de sub-rotinas. Entretanto, enquanto as
chamadas de sub-rotinas so transferncias para procedimentos normais do programa,
as chamadas de sistema transferem a execuo para o sistema operacional. Atravs de
parmetros, o programa informa exatamente o que necessita. O retorno da chamada de
sistema, assim como o retorno de uma sub-rotina, faz com que a execuo do programa
seja retomada a partir da instruo que segue a chamada. Para o programador assembly, as chamadas de sistema so bastante visveis. Em uma linguagem de alto nvel, elas
ficam escondidas dentro da biblioteca utilizada pelo compilador. O programador chama
sub-rotinas de uma biblioteca. So as sub-rotinas da biblioteca que chamam o sistema.
Por exemplo, qualquer funo da biblioteca que acesso o terminal (como printf na linguagem C) exige uma chamada de sistema. Como foi exposto antes, o acesso aos perifricos
feito, normalmente, pelo sistema operacional.
A lista de servios do sistema operacional agora transformada em uma lista de
chamadas de sistema. A descrio dessas chamadas forma um dos mais importantes
manuais de um sistema operacional. Por exemplo, considere um programa que lista o
contedo de um arquivo texto na tela do terminal. Ele faz uma chamada de sistema para
verificar se o arquivo a ser listado existe. Um dos parmetros dessa chamada ser provavelmente o nome do arquivo. O restante do programa um lao no qual so feitas
sucessivas leituras do arquivo e escritas no terminal. Essas duas operaes tambm correspondem a chamadas de sistema.
A parte do sistema operacional responsvel por implementar as chamadas de sistema
normalmente chamada de ncleo ou kernel. Os principais componentes do kernel de
qualquer sistema operacional so a gerncia do processador, a gerncia de memria, o sistema de arquivos e a gerncia de entrada e sada. Cada um desses componentes ser visto detalhadamente.
Em funo da complexidade interna de um kernel completo, muitos sistemas operacionais so implementados em camadas. Primeiro, um pequeno componente de software
chamado microncleo ou microkernel implementa os servios mais bsicos associados
com sistemas operacionais. Em cima do microkernel, usando os seus servios, o kernel
propriamente dito implementa os demais servios. A figura abaixo ilustra um sistema no
qual, acima do hardware, existe um microkernel que oferece servios bsicos tais como
gerncia do processador, alocao e liberao de memria fsica e instalao de novos
tratadores de dispositivos. O kernel do sistema oferece servios tais como sistema de
arquivos, memria virtual e protocolos de comunicao.
Alguns sistemas permitem que as aplicaes acessem tanto as chamadas de sistema
suportadas pelo kernel quanto os servios oferecidos pelo microkernel. Entretanto, na
01 Viso Geral
maioria das vezes, apenas o cdigo do kernel pode acessar os servios do microkernel,
enquanto aplicaes ficam restritas s chamadas de sistema do kernel.
Servios do Microkernel
1.4
Aplicaes
Kernel
Microkernel
Hardware
Chamadas de Sistema
PROJETO DO SISTEMA OPERACIONAL
Na viso de projeto, o mais importante como o sistema est organizado internamente. A organizao de um sistema operacional corresponde forma como ele implementa os vrios servios.
O sistema operacional no resolve os problemas do usurio final. Ele no serve para
editar textos, nem faz a contabilidade de uma empresa. Entretanto, atravs dele, podemos obter uma maior eficincia e convenincia no uso do computador. A eficincia obtida atravs do compartilhamento dos recursos. A convenincia obtida atravs de uma
interface mais confortvel para a utilizao dos recursos computacionais.
Normalmente o processador est executando programas de usurio. 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 interrupo de perifrico.
Uma chamada de sistema corresponde a uma solicitao de servio por parte do
programa em execuo. Primeiramente, deve ser verificada a legalidade da solicitao.
Por exemplo, um pedido para que arquivos de outros usurios sejam destrudos dever
ser recusado. No caso de uma solicitao legal, ela realizada, e a resposta devolvida
ao programa. possvel que a chamada de sistema envolva o acesso a um perifrico.
Nesse caso, o programa dever esperar at que o perifrico conclua a operao solicitada.
Em funo das chamadas de sistema, o sistema operacional envia comandos para os
controladores dos perifricos. O controlador deve informar ao sistema operacional quando a operao estiver concluda. Isso feita atravs de uma interrupo. Quando a interrupo acontece, o processador pra o que est fazendo e passa a executar uma rotina
especfica do sistema operacional. Como a interrupo do perifrico avisa o trmino de
alguma operao de entrada e sada, possivelmente uma chamada de sistema foi concluda. Nesse caso, um programa espera de resposta poder ser liberado.
1.4.1 INTERRUPO x EXCEO
Uma interrupo sempre gerada por algum evento externo ao programa e, neste
caso, independe da instruo que est sendo executada. Um exemplo de interrupo
ocorre quando um dispositivo avisa ao processador que alguma operao de E/S est
completa. Neste caso, o processador deve interromper o programa para tratar o trmino
da operao.
Ao final da execuo de cada instruo, a unidade de controle verifica a ocorrncia de
algum tipo de interrupo. Neste caso, o programa em execuo interrompido e o controle desviado para uma rotina responsvel por tratar o evento ocorrido, denominada
rotina de tratamento de interrupo. Para que o programa possa posteriormente voltar a ser executado, necessrio que, no momento da interrupo, um conjunto de informaes sobre a sua execuo seja preservado.
Para cada tipo de interrupo existe uma rotina de tratamento associada, para qual o
fluxo de execuo deve ser desviado. A identificao do tipo de evento ocorrido fundamental para determinar o endereo da rotina de tratamento.
01 Viso Geral
Existem dois mtodos utilizados para o tratamento de interrupes. O primeiro utiliza

uma estrutura de dados chamada vetor de interrupo, que contm o endereo inicial
de todas as rotinas de tratamento existentes associadas a cada tipo de evento. O outro
mtodo utiliza um registrador de status que armazena o tipo de evento ocorrido. Neste
mtodo s existe uma nica rotina de tratamento, que no seu incio testa o registrador
para identificar o tipo de interrupo e trat-la de maneira adequada.
As interrupes so decorrentes de eventos assncronos, ou seja, no relacionadas
instruo do programa corrente, portanto so imprevisveis e podem ocorrer mltiplas
vezes de forma simultnea. Uma maneira de evitar esta situao a rotina de tratamento inibir as demais interrupes.
Porm alguns processadores no permitem que interrupes sejam desabilitadas, fazendo com que exista um tratamento para a ocorrncia de mltiplas interrupes. Normalmente, existe um dispositivo denominado controlador de pedidos de interrupo,
responsvel por avaliar as interrupes geradas e suas prioridades de atendimento.
Uma exceo semelhante a uma interrupo, sendo a principal diferena o motivo
pelo qual o evento gerado. A exceo resultado direto da execuo de uma instruo
do prprio programa, como a diviso de um nmero por zero ou a ocorrncia de overflow
em uma operao aritmtica.
A diferena fundamental entre exceo e interrupo que a primeira gerada por
um evento sncrono, enquanto a segunda gerada por eventos assncronos. Um evento
sncrono quando resultado direto da execuo do programa corrente. Tais eventos so
previsveis e, por definio, s pode ocorrer um nico de cada vez.
1.5
HISTRICO DOS SISTEMAS OPERACIONAIS
A evoluo dos Sistemas Operacionais est intimamente relacionada com o desenvolvimento dos computadores. Objetivando permitir um conhecimento geral, o histrico dos
Sistemas Operacionais aqui apresentados ser dividido em dcadas. Em cada uma das
dcadas sero discutidas as principais caractersticas do hardware e do Sistema Operacional da poca.
1.5.1 DCADA DE 1940 (Ausncia de SOs)
A Segunda Guerra Mundial acelerou as pesquisas para o desenvolvimento dos primeiros computadores (Mark I, ENIAC etc.), objetivando dinamizar o processo de realizao
de clculos. Os computadores, ento desenvolvidos, eram baseados em vlvulas. Eles
ocupavam salas inteiras e no possuam um SO. Com isso, programar, por exemplo, o
ENIAC para realizar um determinado clculo poderia levar dias, pois era necessrio conhecer profundamente o funcionamento de seu hardware e utilizar linguagem de mquina.
1.5.2 DCADA DE 1950 (Processamento em Batch)
01 Viso Geral
O desenvolvimento do transistor permitiu um grande avano da informtica. Assim,

os computadores tornaram-se menores, mais confiveis e mais rpidos. Nesta dcada
observa-se o surgimento dos primeiros SOs e a programao das mquinas se dava atravs de cartes perfurados.
Os processos a serem executados entravam seqencialmente no processador e rodavam at terminar. Este tipo de processamento ficou conhecido como processamento em
batch ou lote, o qual ilustrado pela figura abaixo:
Pode no parecer um avano, mas anteriormente os programas eram submetidos pelo operador, um a um, fazendo com que o processador ficasse ocioso entre a execuo
de um job e outro. Com o processamento batch, um conjunto de programas era submetido de uma vez s, o que diminua o tempo de espera entre a execuo dos programas,
permitindo, assim, melhor aproveitamento do processador.
1.5.3 DCADA DE 1960 (Processamento Time-sharing)
Nesta dcada entram em cena os circuitos integrados (CIs), o que permitiu que os
computadores se tornassem mais baratos e, portanto, mais acessveis s organizaes
empresariais. Na poca em questo os processos no mais monopolizavam o uso do processador, mas sim compartilhavam o mesmo. Dessa forma, o tempo de processamento
passou a ser igualmente dividido entre os processos existentes. Esta tcnica de processamento acabou ficando conhecida como processamento time-sharing ou processamento
de tempo compartilhado.
1.5.4 DCADA DE 1970 (Multiprocessamento)
Nesta dcada a integrao em larga escala (Large Scale Integration LSI) e a integrao em muito grande escala (Very Large Scale Integration - VLSI) permitiram uma
reduo significativa no tamanho e no custo dos computadores. Com isso, os computadores com mltiplos processadores tornaram-se acessveis e os processos passaram a ser
executados em paralelo. Este tipo de processamento ficou conhecido como multiprocessamento, o qual ilustrado pela figura abaixo:
1.5.5 DCADA DE 1980 (Computadores Pessoais):

10
01 Viso Geral
Os computadores pessoais tornam-se mais acessveis comercialmente e a microcomputao se consolidou. Assim, surgiram os SOs voltados especificamente para os ento
chamados microcomputadores (ex.: CP/M6, MS-DOS7, OS/28 etc.). interessante destacar que neste perodo a rpida evoluo dos processadores dos computadores pessoais
permitiu que seus SOs incorporassem importantes recursos como interface grfica e multimdia. O baixo custo dos equipamentos permitiu, tambm, o surgimento das redes locais e com isso desenvolveram-se os Sistemas Operacionais de Rede (ex.: Novell Netware, LAN Manager etc.);
1.5.6 DCADA DE 1990 (Sistemas Distribudos):
Durante a dcada de 1990 o crescimento das redes de computadores, especialmente
a Internet, propiciou o surgimento de sistemas computacionais novos que se caracterizam por possurem uma coleo de processadores que no compartilham memria ou
barramento e que se comunicam via rede. Estes sistemas acabaram sendo chamados de
sistemas fracamente acoplados que possibilitaram o surgimento dos sistemas distribudos, onde diversos SOs presentes nos computadores de uma rede interagem o suficiente
para dar a impresso de que existe um nico Sistema Operacional controlando toda a
rede e os recursos computacionais ligados a ela. Atualmente, os pesquisadores da rea
de Sistemas Operacionais concentram boa parte de seus esforos nos estudos sobre os
Sistemas Operacionais Distribudos.
1.6
CLASSIFICAO DOS SISTEMAS OPERACIONAIS
A evoluo dos sistemas operacionais acompanhou a evoluo do hardware e das aplicaes por ele suportadas. Muitos termos inicialmente introduzidos para definir conceitos e tcnicas foram substitudos por outros. Isto fica muito claro quando tratamos da
unidade de execuo do processador. Inicialmente, eram utilizados os termos programas
ou job, depois surgiu o conceito de processo, e agora, o conceito de thread.
1.6.1 SISTEMAS MONOPROGRAMVEIS OU MONOTAREFAS

Os primeiros Sistemas Operacionais eram tipicamente voltados para a execuo de
um nico programa. Qualquer outra aplicao, para ser executada, deveria aguardar o
trmino do programa corrente. Os sistemas monoprogramveis se caracterizam por permitir que o processador, a memria e os perifricos permaneam exclusivamente dedicados execuo de um nico programa.
Neste tipo de sistema, enquanto um programa aguarda por um evento, como a digitao de um dado, o processador permanece ocioso, sem realizar qualquer tipo de processamento. A memria subutilizada caso o programa no a preencha totalmente, e os
perifricos, como discos e impressoras, esto dedicados a um nico usurio, nem sempre
utilizados de forma integral.
Comparados a outros sistemas, os sistemas monoprogramveis ou monotarefas so
de simples implementao, no existindo muita preocupao com problemas decorrentes
do compartilhamento de recursos.
1.6.2 SISTEMAS MULTIPROGRAMVEIS OU MULTITAREFAS
Neste tipo de sistema, os recursos computacionais so compartilhados entre os diversos usurios e aplicaes.
11
01 Viso Geral
Neste caso, enquanto um programa espera por uma operao de leitura ou gravao
em disco, outros programas podem estar sendo processados neste mesmo intervalo de
tempo. Nesse caso, podemos observar o compartilhamento da memria e do processador. O Sistema Operacional se preocupa em gerenciar o acesso concorrente aos seus
diversos recursos.
As vantagens do uso de tais sistemas so a reduo do tempo de resposta das aplicaes processadas no ambiente e de custos, a partir do compartilhamento dos diversos
recursos do sistema entre as diferentes aplicaes.
A partir do nmero de usurios que interagem com o sistema, podemos classificar os
sistemas multiprogramveis como monousurio ou multiusurio.
Os sistemas multiprogramveis podem tambm ser classificados pela forma com que
suas aplicaes so gerenciadas, podendo ser divididos em sistemas batch, de tempo
compartilhado ou de tempo real. Um Sistema Operacional pode suportar um ou mais
desses tipos de processamento, dependendo de sua implementao.
a) Sistemas Batch
Foram os primeiros tipos de Sistemas Operacionais multiprogramveis a serem
implementados. O processamento em batch tem a caracterstica de no exigir a interao
do usurio com a aplicao. Todas as entradas e sadas de dados so implementadas por
algum tipo de memria secundria, geralmente arquivos em disco.
Esses sistemas, quando bem projetados, podem ser bastante eficientes, devido
melhor utilizao do processador; entretanto, podem oferecer tempos de resposta longos. Atualmente, os Sistemas Operacionais implementam ou simulam o processamento
batch, no existindo sistemas exclusivamente dedicados a este tipo de processamento.
b) Sistemas de Tempo Compartilhado
Tais sistemas, tambm conhecidos como time-sharing, permitem que diversos
programas sejam executados a partir da diviso do tempo do processador em pequenos
intervalos, denominados fatia de tempo (time-slice). Caso a fatia de tempo no seja suficiente para a concluso do programa, esse interrompido pelo Sistema Operacional e
submetido por um outro, enquanto fica aguardando por uma nova fatia de tempo. O sistema cria um ambiente de trabalho prprio, dando a impresso de que todo o sistema
est dedicado, exclusivamente, para cada usurio.
Geralmente, sistemas de tempo compartilhado permitem a interao dos usurios
com o sistema atravs de terminais que incluem vdeo, teclado e mouse. Esses sistemas
possuem uma linguagem de controle que permite ao usurio comunicar-se diretamente
com o Sistema Operacional atravs de comandos.
A maioria das aplicaes comerciais atualmente so processadas em sistemas de
tempo compartilhado, que oferecem tempos baixos de respostas a seus usurios e menores custos, em funo da utilizao compartilhada dos diversos recursos do sistema.
c) Sistemas de Tempo Real
12
01 Viso Geral
Os sistemas de tempo real (real-time) diferem dos de tempo compartilhado no

tempo exigido no processamento das aplicaes.
Enquanto em sistemas de tempo compartilhado o tempo de processamento pode
variar sem comprometer as aplicaes em execuo, nos sistemas de tempo real os
tempos de processamento devem estar dentro de limites rgidos, que devem ser obedecidos, caso contrrio podero ocorrer problemas irreparveis.
No existe a idia de fatia de tempo. Um programa utiliza o processador o tempo
que for necessrio ou at que aparea outro mais prioritrio. Essa prioridade definida
pela prpria aplicao. Esto presentes em aplicaes de controle de usinas termoeltricas e nucleares, controle de trfego areo, ou em qualquer outra aplicao onde o tempo
de processamento fator fundamental.
1.6.3 SISTEMAS COM MLTIPLOS PROCESSADORES
Um sistema com mltiplos processadores possui duas ou mais CPUs interligadas trabalhando em conjunto. A vantagem desse tipo de sistema permitir que vrios programas sejam executados ao mesmo tempo ou que um mesmo programa seja subdividido
em partes para serem executadas simultaneamente em mais de um processador.
Os conceitos aplicados ao projeto de sistemas com mltiplos processadores incorporam os mesmos princpios bsicos e benefcios apresentados na multiprogramao, alm
de outras vantagens especficas como escalabilidade, disponibilidade e balanceamento de
carga.
Escalabilidade a capacidade de ampliar o poder computacional do sistema apenas
adicionando outros processadores. Em ambientes com um nico processador, caso haja
problemas de desempenho, seria necessrio substituir todo o sistema por uma outra configurao com maior poder de processamento. Com a possibilidade de mltiplos processadores, basta acrescentar novos processadores configurao.
Disponibilidade a capacidade de manter o sistema em operao mesmo em casos
de falhas. Neste caso, se um dos processadores falhar, os demais podem assumir suas
funes de maneira transparente aos usurios e suas aplicaes, embora com menor
capacidade de computao.
Balanceamento de Carga a possibilidade de distribuir o processamento entre os
diversos processadores da configurao a partir da carga de trabalho de cada processador, melhorando assim, o desempenho do sistema como um todo.
Esses sistemas podem ser classificados quanto forma de comunicao entre as

CPUs e quanto ao grau de compartilhamento da memria e dos dispositivos de E/S. Assim, podemos classific-los em fortemente acoplados e fracamente acoplados.
a) Sistemas Fortemente Acoplados

13
01 Viso Geral
Num sistema fortemente acoplado dois ou mais processadores compartilham uma

nica memria e so controlados por um nico sistema operacional. Um sistema fortemente acoplado utilizado geralmente em aplicaes que fazem uso intensivo da CPU e
cujo processamento dedicado soluo de um nico problema.
Os sistemas fortemente acoplados podem ser divididos em simtricos ou assimtricos. Os simtricos caracterizam-se pelo tempo uniforme de acesso memria principal
pelos diversos processadores.
Inicialmente, tais sistemas estavam limitados aos sistemas de grande porte, restritos ao ambiente universitrio e s grandes corporaes. Com a evoluo dos computadores pessoais e das estaes de trabalho, os sistemas multitarefa evoluram para permitir a existncia de vrios processadores no modelo simtrico. Atualmente, a grande
maioria dos Sistemas Operacionais, como o Unix e o Windows 2000, implementa esta
funcionalidade.
b) Sistemas Fracamente Acoplados
Num sistema fracamente acoplado dois ou mais sistemas de computao so conectados atravs do uso de linhas de comunicao. Nesses sistemas, ocorre o processamento distribudo entre os diversos computadores. Cada sistema funciona de forma independente, possuindo seu(s) prprio(s) processador(es). Em funo destas caractersticas,
tambm so conhecidos como multicomputadores.
Com a evoluo dos computadores pessoais e das estaes de trabalho, juntamente com o avano das telecomunicaes e da tecnologia de redes, surgiu um novo
modelo de computao, chamado modelo de rede de computadores. Em uma rede existem dois ou mais sistemas independentes (hosts), interligados atravs de linhas de comunicao, que oferecem algum tipo de servio aos demais. Neste modelo, a informao
deixa de ser centralizada em poucos sistemas de grande porte e passa ser distribuda
pelos diversos sistemas da rede.
14
01 Viso Geral
Com base no grau de integrao dos hosts da rede, podemos dividir os sistemas
fracamente acoplados em Sistemas Operacionais de Rede e Sistemas Distribudos. A
grande diferena entre os dois modelos a capacidade do Sistema Operacional em criar
uma imagem nica dos servios disponibilizados pela rede.
Os Sistemas Operacionais de Rede permitem que um host compartilhe seus
recursos, como impressora ou diretrio, com os demais hosts da rede. Um exemplo deste
tipo de sistema so as redes locais, onde uma estao pode oferecer servios de arquivos
e impresso para as demais estaes da rede, dentre outros servios.
Enquanto nos Sistemas Operacionais de Rede os usurios tm conhecimento dos
hosts e seus servios, nos Sistemas Distribudos o Sistema Operacional esconde os
detalhes dos hosts individuais e passa a trat-los como um conjunto nico, como se fosse um sistema fortemente acoplado. Os sistemas distribudos permitem, por exemplo,
que uma aplicao seja dividida em partes e que cada parte seja executada por hosts
diferentes da rede de computadores. Para o usurio e suas aplicaes como se no
existisse a rede de computadores, mas sim um nico sistema centralizado.
1.7
EXERCCIOS
1) Como seria utilizar um computador sem um Sistema Operacional?
2) O que um Sistema Operacional? Fale sobre suas principais funes.
3) Quais os tipos de Sistemas Operacionais existentes?
4) Por que dizemos que existe uma subutilizao de recursos em sistemas monoprogramveis?
5) Qual a grande diferena entre sistemas monoprogramveis e multiprogramveis?
6) Quais as vantagens dos sistemas multiprogramveis?
7) Um sistema monousurio pode ser um sistema multiprogramvel? D um exemplo.
8) Quais so os tipos de sistemas multiprogramveis?
9) O que caracteriza um sistema batch? Quais aplicaes podem ser processadas
neste tipo de ambiente?
10) Como os processos so executados em um sistema time-sharing? Quais as vantagens em utiliz-los?
11) Qual a grande diferena entre sistemas de tempo compartilhado e tempo real?
Quais aplicaes so indicadas para sistemas de tempo real?
12) O que so sistemas com mltiplos processadores e quais as vantagens em utilizlos?
13) Qual a grande diferena entre sistemas fortemente e fracamente acoplados?
14) O que um sistema fracamente acoplado? Qual a diferena entre Sistemas Operacionais de rede e Sistemas Operacionais distribudos?
15) Cite dois exemplos de Sistemas Operacionais de rede.
-xSistemas Operacionais Lucilia Ribeiro
15
02 Multiprogramao
Multiprogramao
Cada ferramenta carrega consigo o esprito com o qual foi criada.

(Werner Karl Heisenberg)
2.1
INTRODUO
Como visto no captulo anterior, a multiprogramao torna mais eficiente o aproveitamento dos recursos do computador. Isso conseguido atravs da execuo simultnea
de vrios programas. Neste contexto, so exemplos de recursos o tempo do processador,
o espao na memria, o tempo de perifrico, entre outros. Este captulo trata dos principais conceitos associados com a multiprogramao.
2.2
MECANISMO BSICO
Os sistemas multiprogramveis surgiram a partir de limitaes existentes nos monoprogramveis. Nesse, muitos recursos computacionais de alto custo permaneciam muitas
vezes ociosos por longo perodo de tempo, pois enquanto uma leitura de disco realizada, o processador fica parado. O tempo de espera longo, j que as operaes com dispositivos de entrada e sada so muito lentas se comparadas com a velocidade com que
o processador executa as instrues.
A tabela abaixo apresenta um exemplo de um programa que l registros de um arquivo e executa, em mdia, 100 instrues por registro lido. Neste caso, o processador
gasta aproximadamente 93% do tempo esperando o dispositivo de E/S concluir a operao para continuar o processamento.
Leitura de um registro
Execuo de 100 instrues
0,0015 s
0,0001 s
Total
0,0016 s
% utilizao da Cpu (0,0001 / 0,0016) = 0,066 = 6,6%

Outro aspecto a ser considerado a subutilizao da memria principal. Um programa que no ocupe totalmente a memria ocasiona a existncia de reas livres sem utilizao. Nos sistemas multiprogramveis, vrios programas podem estar residentes em
memria, concorrendo pela utilizao do processador.
A utilizao concorrente da CPU deve ser implementada de maneira que, quando um
programa perde o uso do processador e depois retorna para continuar sua execuo, seu
estado deve ser idntico ao do momento em que foi interrompido. O programa dever
continuar sua execuo exatamente de onde parou, aparentando ao usurio que nada
aconteceu.
As vantagens proporcionadas pela multiprogramao podem ser percebidas onde existem um sistema computacional por exemplo, com um disco, um terminal e uma impressora, como mostra a tabela abaixo. Neste ambiente so executados trs programas,
que possuem caractersticas de processamento distintas.
Em um ambiente monoprogramvel, os programas so executados seqencialmente.
Sendo assim, o Prog1 processado em 5 minutos, enquanto o Prog2 espera para comear sua execuo, que leva 15 minutos. Finalmente, o Prog3 inicia sua execuo aps 20
minutos e completa seu processamento em 10 minutos, totalizando 30 minutos na execuo dos trs programas. No caso de os programas serem executados concorrentemente, em um sistema multiprogramvel, o ganho na utilizao dos recursos e tambm no
tempo de resposta considervel.
16
02 Multiprogramao
CARACTERISTICAS
PROG1
PROG2
PROG3
Utilizao da CPU
alta
baixa
baixa
Operaes de E/S
poucas
muitas
muitas
Tempo de processamento
5 min
15 min
10 min
Memria utilizada
50 KB
100 KB
80 KB
Utilizao do disco
no
no
sim
Utilizao do terminal
no
sim
no
Utilizao da impressora
no
no
sim
Em um sistema multiprogramado diversos programas so mantidos na memria

ao mesmo tempo. A figura abaixo mostra uma possvel organizao da memria. Nesse
sistema existem 3 programas de usurio na memria principal, prontos para serem executados. Vamos supor que o sistema operacional inicia a execuo do programa 1. Aps
algum tempo, da ordem de milissegundos, o programa 1 faz uma chamada de sistema.
Ele solicita algum tipo de operao de entrada ou sada. Por exemplo, uma leitura do
disco. Sem a multiprogramao, o processador ficaria parado durante a realizao do
acesso. Em um sistema multiprogramado, enquanto o perifrico executa o comando enviado, o sistema operacional inicia a execuo de um outro programa. Por exemplo, o
programa 2. Dessa forma, processador e perifrico trabalham juntos. Enquanto o processador executa o programa 2, o perifrico realiza a operao solicitada pelo programa 1.
Memria Principal
Sistema Operacional
(256 Kbytes)
Programa Usurio 1
(160 Kbytes)
Programa Usurio 2
(64 Kbytes)
Programa Usurio 3
(32 Kbytes)
2.3
Endereos
00000 H (0)
3FFFF H (262143)
40000 H (262144)
67FFF H (425983)
68000 H (425984)
77FFF H (491519)
78000 H (491520)
7FFFF H (524287)
O CONCEITO DE PROCESSO
O conceito de processo a base para a implementao de um sistema multiprogramvel. O processador projetado apenas para executar instrues, no sendo capaz de
distinguir qual programa se encontra em execuo.
A gerncia de processos uma das principais funes de um Sistema Operacional. Atravs de processos, um programa pode alocar recursos, compartilhar dados, trocar informaes e sincronizar sua execuo. Nos sistemas multiprogramveis, os processos
so executados concorrentemente, compartilhando, dentro outros recursos, o uso do
processador, da memria principal e dos dispositivos de E/S. Nos sistemas com mltiplos
processadores, no s existe a concorrncia de processos pelo uso do processador, como
tambm a execuo simultnea de processos nos diferentes processadores.
Nos primeiros sistemas computacionais apenas um programa podia ser executado de
cada vez. Tal programa tinha acesso a todos os recursos do sistema. Atualmente, diverSistemas Operacionais Lucilia Ribeiro
17
02 Multiprogramao
sos programas executam simultaneamente num sistema computacional. Entretanto, para

que isso seja possvel necessrio um controle maior na diviso de tarefas entre os vrios programas. Da resultou o conceito de processo.
Um processo um programa em execuo, incluindo os valores correntes de todos os
registradores do hardware, e das variveis manipuladas por ele no curso de sua execuo. Embora um processador execute vrios processos ao mesmo tempo, dando ao usurio a impresso de paralelismo de execuo, num dado instante apenas um processo
progride em sua execuo. Em outras palavras, em cada momento o processador est
executando apenas um processo e seu uso compartilhado entre os vrios processos
existentes. Um processo que num instante est usando o processador depois de um certo
tempo interrompido e o processador cedido a outro processo. Assim, num grande
intervalo de tempo todos os processos tero progredido. O rpido chaveamento do processador entre vrios processos chamado multiprogramao. Para que haja esse chaveamento necessrio o uso de algum algoritmo de escalonamento para determinar
quando o trabalho de um processo deve ser interrompido e qual o prximo processo a
ser servido.
A diferena entre um processo e um programa sutil, mas crucial. Imagine um cientista de programao que tem excelentes dotes culinrios e esteja preparando um bolo
de aniversrio para a filha. Ele tem sua disposio uma receita de bolo, e uma dispensa
com os ingredientes necessrios. A receita o programa, ou seja, um algoritmo em alguma linguagem conhecida, o cientista de programao o processador e os ingredientes os dados de entrada. J o processo vem a ser a atividade resultante da preparao
do bolo: leitura da receita, busca dos ingredientes, mistura dos ingredientes, etc. Imagine agora que a filha do nosso cientista aparea chorando, por haver sido picada por uma
abelha, enquanto o pai est fazendo o bolo. Neste caso, o cientista deve guardar em que
ponto da receita ele estava (o estado do processo corrente salvo), apanhar um livro de
primeiros socorros e seguir as instrues contidas no captulo do livro sobre picada de
abelhas. Aqui vemos o processador, mais precisamente o cientista da computao, sendo
chaveado de um processo (preparao do bolo), para outro de maior prioridade (administrao de cuidados mdicos), cada um deles constitudo de um programa diferente
(receita versus livro de primeiros socorros). Quando o ferro da abelha tiver sido retirado
da filha do cientista, este poder voltar preparao do bolo, continuando seu trabalho a
partir do ponto onde ele foi interrompido.
A idia principal que um processo constitui uma atividade. Ele possui programa, entrada, sada e um estado. Um nico processador pode ser compartilhado entre os vrios
processos, com algum algoritmo de escalonamento usado para determinar quando parar
o trabalho sobre um processo e servir outro.
Um processo tambm pode ser definido como o ambiente onde um programa executado. Este ambiente, alm das informaes sobre a execuo, possui tambm o quanto
de recursos do sistema cada programa pode utilizar, como o espao de endereamento,
tempo de processador e rea em disco.
2.4
ESTRUTURA DO PROCESSO
Um processo formado por trs partes, que juntas mantm todas as informaes necessrias execuo de um
programa: Contexto de Hardware, Contexto de Software e Espao de Endereamento.
18
02 Multiprogramao
2.4.1 CONTEXTO DE HARDWARE

Armazena o contedo dos registradores gerais da CPU, alm dos registradores de uso
especfico, como o Contador de Programas, o Ponteiro de Pilha e o Registrador de Status.
A troca de um processo por outro no processador, comandada pelo Sistema Operacional, denominada troca de contexto. A troca de contexto consiste em salvar o contedo dos registradores do processo que est deixando a CPU e carreg-los com os valores
referentes ao do novo processo que ser executado. Essa operao resume-se em substituir o contexto de hardware de um processo pelo de outro.
2.4.2 CONTEXTO DE SOFTWARE

No contexto de software so especificadas caractersticas e limites dos recursos que
podem ser alocados pelo processo, como o nmero mximo de arquivos abertos simultaneamente, prioridade de execuo e o tamanho do buffer para operao de E/S. Muitas
destas caractersticas so determinadas no momento da criao do processo, enquanto
outras podem ser alteradas durante sua existncia.
A maior parte das informaes do contexto de software do processo so provenientes
de um arquivo do Sistema Operacional, conhecido como arquivo de contas. Neste arquivo, gerenciado pelo administrador do sistema, so especificados os limites dos recursos
que cada processo pode alocar.
O contexto de software composto por trs grupos de informaes sobre o processo:
identificao, quotas e privilgios.
Identificao: cada processo criado pelo Sistema Operacional recebe uma
identificao nica (PID Process Identification) representada por um nmero. Atravs
da PID o Sistema Operacional e outros processos podem fazer referncia a qualquer processo existente.
19
02 Multiprogramao
Quotas: so os limites de cada recurso do sistema que um processo pode

alocar. Caso uma quota seja insuficiente, o processo ser executado lentamente, interrompido durante seu processamento ou mesmo no ser executado. Exemplos:
o Nmero mximo de arquivos abertos simultaneamente;
o Tamanho mximo de memria principal e secundria que o processo pode alocar;
o Nmero mximo de operaes de E/S pendentes;
o Tamanho mximo do buffer para operaes de E/S;
o Nmero mximo de processos e threads que podem ser criados.
Privilgios: os privilgios ou direitos definem as aes que um processo
pode fazer em relao a ele mesmo, aos demais processos e ao Sistema Operacional.
Privilgios que afetam o prprio processo permitem que suas caractersticas possam
ser alteradas, como prioridade de execuo, limites alocados na memria principal e secundria etc. J os privilgios que afetam os demais processos permitem, alm da alterao de suas prprias caractersticas, alterar as de outros processos.
Privilgios que afetam o sistema so os mais amplos e poderosos, pois esto relacionados operao e gerncia do ambiente, como a desativao do sistema, alterao de
regras de segurana, criao de outros processos privilegiados, modificao de parmetros de configurao do sistema, dentro outros. A maioria dos Sistemas Operacionais
possui uma conta de acesso com todos estes privilgios disponveis, com o propsito de o
administrador gerenciar o Sistema Operacional. No sistema Unix existe a conta root, no
Windows a conta administrador e no OpenVMS existe a conta system com este perfil.
2.4.3 ESPAO DE ENDEREAMENTO
a rea de memria pertencente ao processo onde as instrues e os dados do programa so armazenados para execuo. Cada processo possui seu prprio espao de
endereamento, que deve ser devidamente protegido do acesso dos demais processos.
2.4.4 BLOCO DE CONTROLE DE PROCESSO
O processo implementado pelo Sistema Operacional atravs de uma estrutura de
dados chamada Bloco de Controle de Processo (Process Control Block PCB). A partir do
PCB, o Sistema Operacional mantm todas as informaes sobre o contexto de hardware,
contexto de software e espao de endereamento de cada processo.
2.5
ESTADOS DO PROCESSO
Em um sistema multiprogramvel, um processo no deve alocar a CPU com exclusividade, de formas que possa existir um compartilhamento no uso do processador. Os processos passam por diferentes estados ao longo do seu processamento, em funo de
20
02 Multiprogramao
eventos gerados pelo Sistema Operacional ou pelo prprio processo. Um processo ativo
pode encontrar-se em trs estados diferentes:
Rodando (Execuo ou running): nesse estado, o processo est sendo

processado pela CPU. Somente um processo pode estar sendo executado em um dado
instante. Os processos se alternam na utilizao do processador.
Pronto (ready): um processo est no estado de pronto quando aguarda

apenas para ser executado. O Sistema Operacional responsvel por determinar a ordem e os critrios pelos quais os processos em estado de pronto devem fazer uso do
processador. Em geral existem vrios processos no sistema no estado de pronto organizados em listas encadeadas.
Bloqueado (Espera ou wait): nesse estado, um processo aguarda por algum evento externo ou por algum recurso para prosseguir seu processamento. Como
exemplo, podemos citar o trmino de uma operao de E/S ou a espera de uma determinada entrada de dados para continuar sua execuo. O sistema organiza os vrios processos no estado de espera tambm em listas encadeadas, separados por tipo de evento.
Neste caso, quando um evento acontece, todos os processos da lista associada ao evento
so transferidos para o estado de pronto.
2.6
MUDANA DE ESTADO DO PROCESSO
Um processo muda de estado durante seu processamento em funo de eventos originados por ele prprio (eventos voluntrios) ou pelo Sistema Operacional (eventos involuntrios). Basicamente, existem quatro mudanas de estado que podem ocorrer a um
processo:
1) Rodando Bloqueado: essa transio ocorre por eventos gerados pelo prprio
processo, como uma operao de E/S.
2) Rodando Pronto: um processo em execuo passa para o estado de pronto
por eventos gerados pelo sistema, como o trmino da fatia de tempo que o processo
possui para sua execuo. Nesse caso, o processo volta para a fila de pronto, onde aguarda por uma nova oportunidade para continuar seu processamento.
3) Pronto Rodando: o Sistema Operacional seleciona um processo da fila de
prontos para executar.
4) Bloqueado Pronto: um processo passa de bloqueado para pronto quando a
operao solicitada atendida ou o recurso esperado concedido.
Logicamente, os dois primeiros estados so similares. Em ambos os casos o processo

vai executar, s que no segundo no h, temporariamente, CPU disponvel para ele. O
terceiro estado diferente dos dois primeiros, pois o processo no pode executar, mesmo que a CPU no tenha nada para fazer.
Quatro transies so possveis entre esses trs estados. A transio 1 ocorre quando
um processo descobre que ele no pode prosseguir.
As transies 2 e 3 so causadas pelo escalonador de processos sem que o processo
saiba disso. A transio 2 ocorre quando o escalonador decide que o processo em execu21
02 Multiprogramao
o deve dar lugar a outro processo para utilizar a CPU. A transio 3 ocorre quando
hora do processo ocupar novamente a CPU. O escalonamento isto , a deciso sobre
quando e por quanto tempo cada processo deve executar um tpico muito importante. Muitos algoritmos vm sendo desenvolvidos na tentativa de equilibrar essa competio que exige eficincia para o sistema como um todo e igualdade para os processos individuais.
A transio 4 ocorre quando acontece um evento externo pelo qual um processo estava aguardando (como a chegada de alguma entrada).
2.7
CRIAO E ELIMINAO DE PROCESSOS
A criao de um processo ocorre a partir do momento em que o Sistema Operacional

adiciona um novo PCB sua estrutura e aloca um espao de endereamento na memria
para uso. No caso da eliminao de um processo, todos os recursos associados ao processo so desalocados e o PCB eliminado pelo Sistema Operacional.
A criao de processos pode ocorre por diferentes razes: 1) logon interativo: desta
forma, um processo criado atravs do estabelecimento de uma sesso interativa por
um usurio a partir de um terminal; 2) criao por um outro processo: um processo j
existente pode criar outros processos, sendo estes novos processos independentes ou
subprocessos; 3) criao pelo sistema operacional: o Sistema Operacional pode criar novos processos com o intuito de oferecer algum tipo de servio.
Depois de criado, um processo comea a executar e faz seu trabalho. Contudo, nada
para sempre, nem mesmo os processos. Mais cedo ou mais tarde o novo processo terminar, normalmente em razo de alguma das seguintes condies: 1) Sada normal
(voluntria); 2) Sada por erro (voluntria); 3) Erro fatal (involuntrio) e 4) Cancelamento por um outro processo (involuntrio).
Na maioria das vezes, os processos terminam porque fizeram seu trabalho. Quando
acaba de compilar o programa atribudo a ele, o compilador avisa ao sistema operacional
que ele terminou. Programas baseados em tela suportam tambm o trmino voluntrio.
Processadores de texto, visualizadores da Web (browsers) e programas similares tem um
cone que o usurio pode clicar para dizer ao processo que remova quaisquer arquivos
temporrios que ele tenha aberto e ento termine.
O segundo motivo para trmino que o processo descobre um erro. Por exemplo, se
um usurio digita um comando para compilar um arquivo que no existe, o compilador
simplesmente emite uma chamada de sada ao sistema. Processos interativos com base
na tela geralmente no fecham quando parmetros errados so fornecidos. Em vez disso,
uma caixa de dilogo aparece e pergunta ao usurio se ele quer tentar novamente.
A terceira razo para o trmino um erro causado pelo processo, muitas vezes por
um erro de programa. Entre os vrios exemplos esto a execuo de uma instruo ilegal, a referncia memria inexistente ou a diviso por zero.
22
02 Multiprogramao
A ltima razo se d quando um processo executa uma chamada ao sistema dizendo

ao sistema operacional para cancelar algum outro processo. Em alguns sistemas, quando
um processo termina, voluntariamente ou no, todos os processos criados por ele so
imediatamente cancelados tambm. Contudo, nem o Unix nem o Windows funcionam
dessa maneira.
2.8
PROCESSOS INDEPENDENTES, SUBPROCESSOS E THREADS
Processos independentes, subprocessos e threads so maneiras diferentes de implementar a concorrncia dentro de uma aplicao. Neste caso, busca-se subdividir o cdigo
em partes para trabalharem de forma cooperativa. Considere um banco de dados com
produtos de uma grande loja onde vendedores fazem freqentes consultas. Neste caso, a
concorrncia na aplicao proporciona um tempo de espera menor entre as consultas,
melhorando o desempenho da aplicao e beneficiando os usurios.
O uso de processos independentes a maneira mais simples de implementar a concorrncia. Neste caso
no existe vnculo do processo criado
com seu criador. A criao de um processo independente exige a alocao
de um PCB prprio.
Subprocessos so processos criados dentro de uma estrutura hierrquica. Neste modo, o processo criador
denominado processo pai enquanto o
novo processo chamado de subprocesso ou processo filho. O subprocesso, por sua vez, pode criar outras
estruturas de subprocessos. Uma caracterstica desta implementao a
dependncia existente entre o processo criador e o subprocesso. Caso um processo pai
deixe de existir, os subprocessos subordinados so automaticamente eliminados.
Uma outra caracterstica neste tipo de implementao que subprocessos podem
compartilhar quotas com o processo pai. O uso de processos independentes e subprocessos no desenvolvimento de aplicaes concorrentes demanda consumo de diversos recursos do sistema. Sempre que um novo processo criado, o sistema deve alocar recursos (contexto de hardware, de software e espao de endereamento), consumindo tempo de
CPU. No momento do trmino dos processos, o
Sistema Operacional tambm dispensa tempo
para desalocar recursos previamente alocados.
Outro problema a comunicao e sincronizao entre processos, considerada pouco eficiente, visto que cada processo possui seu prprio
espao de endereamento.
O conceito de thread foi introduzido na tentativa de reduzir o tempo gasto na criao, eliminao e troca de contexto de processos nas
aplicaes concorrentes, bem como economizar
recursos do sistema como um todo. Em um
ambiente multithread, um nico processo pode
suportar mltiplos threads, cada qual associado
a uma parte do cdigo da aplicao. Neste caso
no necessrio haver diversos processos para a implementao da concorrncia. Threads compartilham o processador da mesma maneira que um processo, ou seja, enquanto
um thread espera por uma operao de E/S, outro thread pode ser executado.
Cada thread possui seu prprio contexto de hardware, porm compartilha o mesmo
contexto de software e espao de endereamento com os demais threads do processo. O
23
02 Multiprogramao
compartilhamento do espao de endereamento permite que a comunicao de threads

dentro de um mesmo processo seja realizada de forma simples e rpida. Este assunto
melhor detalhado no prximo captulo.
2.9
PROCESSOS PRIMEIRO (FOREGROUND) E SEGUNDO PLANO (BACKGROUND)
Um processo de primeiro plano (interativo) aquele que permite a comunicao

direta do usurio com o processo durante o seu processamento. Um processo de segundo plano (batch) aquele onde no existe a comunicao com o usurio durante o
seu processamento. Neste caso, os canais de E/S no esto associados a nenhum dispositivo de E/S interativo, mas em geral a arquivos de E/S.
2.10. PROCESSOS LIMITADOS POR CPU (CPU-BOUND) E POR E/S (I/O-BOUND)

Esta classificao se d de acordo com a utilizao do processador e dos dispositivos
de E/S. Um processo definido como limitado por CPU quando passa a maior parte do
tempo no estado de execuo, ou seja, utilizando o processador. Como exemplo temos
os processos utilizados em aplicaes cientficas que efetuam muitos clculos.
Um processo limitado por E/S quando passa a maior parte do tempo no estado
bloqueado, pois realiza um elevado nmero de operaes de E/S. Esse tipo de processo
encontrado em aplicaes comerciais, que se baseiam em leitura, processamento e gravao. Os processos interativos tambm so exemplos de processos limitados por E/S.
2.11
SELEO DE PROCESSOS
Uma alocao eficiente da CPU importante para a eficcia global de um sistema. Para tal, diversos algoritmos foram desenvolvidos na tentativa de se ter uma alocao justa
do processador. A multiprogramao tem como objetivo maior maximizar a utilizao da
CPU, ou seja, evitar sempre que possvel que o processador fique ocioso.
2.11.1
FILAS PARA SELEO DE PROCESSOS
24
02 Multiprogramao
Num sistema com multiprogramao, os diversos processos existentes no estado de

pronto so colocados numa fila conhecida como fila de processos prontos. Um novo processo criado inicialmente colocado na fila de processos prontos. Ele (assim como os
outros processos no estado de pronto) espera nessa fila at ser selecionado para execuo. Essa fila pode ser armazenada como uma lista ligada.
bom salientar que o uso de dispositivos como, por exemplo, uma unidade de fita,
pode implicar a necessidade de espera por parte do processo, j que o dispositivo pode
estar sendo usado por outro processo. Assim, cada dispositivo tem sua prpria fila, chamada fila de dispositivo, com descries dos processos que esto esperando para usar o
dispositivo.
2.11.2
ESCALONADORES
Como foi dito anteriormente, um processo passa por vrias filas de seleo durante
sua execuo. Para realizar a alocao de recursos, o sistema operacional deve selecionar os processos dessas filas de alguma maneira. Um escalonador um programa responsvel pelo trabalho de escolher processos e de escalar processos para execuo. O
escalonador de processos escolhe processos guardados em disco e os carrega na memria para execuo. Pode-se dizer que ele seleciona processos que passaram a poder
competir pela CPU. J o escalonador da CPU escolhe dentre os processos prontos aquele
que ser executado, alocando a CPU a ele.
A execuo do escalonador da CPU deve ser muito rpida. Se levar 10 ms para escolher um processo que ser executado por 100 ms, ento 10/(100 + 10) = 9% da CPU
ser desperdiada unicamente para a alocao de recursos para realizar o trabalho.
Outra diferena marcante entre os dois tipos de escalonadores que o escalonador
de processos executado com freqncia bem inferior, j que entre a criao de dois
processos podem transcorrer vrios minutos. O escalonador de processos controla o nmero de processos na memria (grau de multiprogramao).
Um escalonador de processos deve manter na memria uma mistura balanceada entre processos que realizam muitas E/S (processos interativos) e processos que usam bastante a CPU. Se todos os processos dependerem de E/S, a fila de prontos estar sempre
vazia e o escalonador de CPU ter pouco o que fazer. Caso tenha processos que dependam mais de processamento, a fila de processos em espera pela realizao de operaes
de E/S estar sempre vazia, os dispositivos de E/S ficaro inativos e o sistema ter um
desempenho ruim.
2.12
EXERCCIOS
16) O que um processo? Diferencie processo de programa.

17) Por que o conceito de processo to importante no projeto de sistemas multiprogramveis?
18) possvel que um programa execute no contexto de um processo e no execute
no contexto de um outro? Por qu?
19) Quais partes compem um processo?
20) O que contexto de hardware de um processo e como a implementao da troca de contexto?
21) Qual a funo do contexto de software? Exemplifique cada grupo de informao.
22) O que o espao de endereamento de um processo?
23) Como o Sistema Operacional implementa o conceito de processo? Qual a estrutura
de dados indicada para organizar os diversos processos na memria principal?
25
02 Multiprogramao
24) Cada processo descrito por um bloco de controle de processos. Quais so as informaes contidas no BCP?
25) Defina os trs estados possveis de um processo.
26) Faa o diagrama de estados de um processo demonstrando e explicando as transies de um estado para outro.
27) D um exemplo que apresente todas as mudanas de estado de um processo,
juntamente com o evento associado a cada mudana.
28) Na teoria, com trs estados poderia haver seis transies, duas para cada estado.
Contudo, somente quatro transies so mostradas. Por que?
29) Diferencie processos multithreads, subprocessos e processos independentes.
30) Explique a diferena entre processos de primeiro plano e de segundo plano.
31) D exemplos de aplicao limitada por CPU e limitada por E/S.
32) Trace um paralelo entre o Escalonador de Processos e o Escalonador de CPU.
-x-
26
03 Programao Concorrente
Programao Concorrente
No se pode conceber a maioria sem a unidade.

(Plato)
3.1
INTRODUO
Programao concorrente tem sido usada frequentemente na construo de sistemas

operacionais e em aplicaes nas reas de comunicao de dados e controle industrial.
Esse tipo de programao torna-se ainda mais importante com o advento dos sistemas
distribudos e das mquinas com arquitetura paralela.
3.2
DEFINIO
Um programa que executado por apenas um processo chamado de programa

seqencial. A grande maioria dos programas escritos so assim. Nesse caso, existe somente um fluxo de controle durante a execuo. Isso permite, por exemplo, que o programador realize uma execuo imaginria de seu programa apontando com o dedo, a
cada instante, a linha do programa que est sendo executada no momento.
Um programa concorrente executado simultaneamente por diversos processos
que cooperam entre si, isto , trocam informaes. Para o programador realizar agora
uma execuo imaginria, ele vai necessitar de vrios dedos, um para cada processo
que faz parte do programa. Nesse contexto, trocar informaes significa trocar dados ou
realizar algum tipo de sincronizao. necessria a existncia de interao entre os processos para que o programa seja considerado concorrente. Embora a interao entre
processos possa ocorrer atravs de acesso a arquivos comuns, esse tipo de concorrncia
tratada na disciplina de Banco de Dados. A concorrncia tratada aqui, utiliza mecanismos rpidos para interao entre processos: variveis compartilhadas e trocas de mensagens.
O verbo concorrer admite em portugus vrios sentidos. Pode ser usado no sentido
de cooperar, como em tudo coopera para o bom xito da operao. Tambm pode ser
usado com o significado de disputa ou competio, como em ele concorreu a uma vaga
na universidade. Em uma forma menos comum ele significa tambm existir simultaneamente. De certa forma, todos os sentidos so aplicveis aqui na programao concorrente. Em geral, processos concorrem (disputam) pelos mesmos recursos do hardware e
do sistema operacional. Por exemplo, processador, memria, perifricos, estruturas de
dados, etc. Ao mesmo tempo, pela prpria definio de programa concorrente, eles concorrem (cooperam) para o xito do programa como um todo. Certamente, vrios processos concorrem (existem simultaneamente) em um programa concorrente. Logo, programao concorrente um bom nome para esse assunto.
natural que processos de uma aplicao concorrente compartilhem recursos do sistema, como arquivos, registros, dispositivos de E/S e reas de memria. O compartilhamento de recursos entre processos pode ocasionar situaes indesejveis, capazes at
de comprometer a execuo das aplicaes. Para evitar esse tipo de problema os processos concorrentes devem ter suas execues sincronizadas, a partir de mecanismos oferecidos pelo Sistema Operacional, com o objetivo de garantir o processamento correto dos
programas.
3.3
SINCRONIZAO
O problema apresentado a seguir no um dos vrios problemas clssicos apresentados na disciplina sistemas operacionais. utilizado somente como um exemplo figurado para fixar os conceitos desse tpico.
27
Considere que exista uma casa onde moram duas pessoas que raramente se encontram. Quando uma chega a outra sai e vice-versa. A melhor forma de comunicao
atravs de bilhetes.
Nessa casa, consome-se sempre um litro de leite por dia. No pode ocorrer a falta do
leite nem to pouco o excesso do mesmo.
Tentaremos resolver o Problema do Leite na Geladeira utilizando algoritmos com
funes genricas.
O Problema do Leite na Geladeira
Hora Pessoa A
Pessoa B
6:00 Olha a geladeira: sem leite
6:05 Sai para a padaria
6:10 Chega na padaria
Olha a geladeira: sem leite
6:15 Sai da padaria
Sai para a padaria
6:20 Chega em casa: guarda o leite Chega na padaria

6:25 -
Sai da padaria
6:30 -
Chega em casa: Ah! No!
Primeira tentativa de resolver o Problema do Leite na Geladeira:

Processos A e B
if (SemLeite) {
if (SemAviso) {
Deixa Aviso;
Compra Leite;
Remove Aviso;
}
}
E se A for atropelada quando for comprar o leite?
Segunda tentativa de resolver o Problema do Leite na Geladeira: mudar o significado do aviso. A vai comprar se no tiver aviso; B vai comprar se tiver aviso.
Processo A
if (SemAviso) {
if (SemLeite) {
Compra Leite;
}
Deixa Aviso;
}
Processo B
if (Aviso) {
if (SemLeite) {
Compra Leite;
}
Remove Aviso;
}
somente A deixa um aviso, e somente se j no existe um aviso

somente B remove um aviso, e somente se houver um aviso
portanto, ou existe um aviso, ou nenhum
se houver um aviso, B compra leite, se no houver aviso, A compra leite
portanto, apenas uma pessoa (processo) vai comprar leite
Agora suponha que B saiu de frias. A vai comprar leite uma vez e no poder comprar mais at que B retorne. Portanto essa "soluo" no boa; em particular ela pode
levar a "inanio".
Terceira tentativa de resolver o Problema do Leite na Geladeira: utilizar dois avisos
diferentes.
28
Processo A
Processo B
Deixa AvisoA;
if (SemAvisoB) {
if (SemLeite) {
Compra Leite;
}
}
Remove AvisoA;
Deixa AvisoB;
if (SemAvisoA) {
if (SemLeite) {
Compra Leite;
}
}
Remove AvisoB;
A soluo est quase correta. S precisamos de uma maneira de decidir quem vai
comprar o leite quando ambos deixarem avisos.
Quarta tentativa de resolver o Problema do Leite na Geladeira: em caso de empate,
A vai comprar o leite.
Processo A
Deixa AvisoA;
if (SemAvisoB) {
if (SemLeite) {
Compra Leite;
}
} else {
while (AvisoB) {
EsperaAToa;
/* pode sentar */
}
if (SemLeite) {
CompraLeite;
}
}
Remove AvisoA;
Processo B
Deixa AvisoB;
if (SemAvisoA) {
if (SemLeite) {
Compra Leite;
}
}
Remove AvisoB;
Esta soluo funciona, mas no muito elegante. Ela ainda tem os seguintes problemas:
A pode ter que esperar enquanto B est na padaria
Enquanto A est esperando ele est consumindo recursos.
Alm disso, seria muito difcil estender esta soluo para muitos processos com diferentes pontos de sincronizao.
3.4
ESPECIFICAO DE CONCORRNCIA EM PROGRAMAS
Existem vrias notaes utilizadas para especificar a concorrncia em programas, ou

seja, as partes de um programa que devem ser executadas concorrentemente. As tcnicas mais recentes tentam expressar a concorrncia no cdigo dos programas de uma
forma mais clara e estruturada.
A primeira notao para a especificao da concorrncia em um programa foram os
comandos FORK e JOIN, introduzidos por Conway (1963) e Dennis e Van Horn (1966). O
exemplo a seguir apresenta a implementao da concorrncia em um programa com uma
sintaxe simplificada.
O programa A comea a ser executado e, ao encontrar o comando FORK, faz com que
seja criado um outro processo para a execuo do programa B, concorrentemente ao
programa 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 aps o
trmino da execuo do programa B. Os comandos FORK e JOIN so bastante poderosos
e prticos, sendo utilizados de forma semelhante no Sistema Operacional Unix.
29
PROGRAM A;
.
.
FORK B;
.
.
JOIN B;
.
.
END.
PROGRAM B;
.
.
.
.
.
END.
Uma das implementaes mais claras e simples de expressar concorrncia em um

programa a utilizao dos comandos PARBEGIN e PAREND (Dijkstra, 1965). O comando
PARBEGIN especifica que a seqncia de comandos seja executada concorrentemente em
uma ordem imprevisvel, atravs da criao de um processo (P1, P2, Pn) para cada comando (C1, C2, Cn). O comando PAREND define um ponto de sincronizao, onde o processamento s continuar quando todos os processos ou threads criados j tiverem terminado suas execues.
Para exemplificar, o programa Expressao realiza o clculo do valor da expresso aritmtica. Os comandos de atribuio simples situados entre PARBEGIN e PAREND so
executados concorrentemente. O clculo final de X s poder ser realizado quando todas
as variveis dentro da estrutura tiverem sido calculadas.
X := SQRT (1024) + (35.4 * 0.23) - (302 / 7)
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.
3.5
PROBLEMAS DE COMPARTILHAMENTO DE RECURSOS
Para a compreenso de como a sincronizao entre processos concorrentes fundamental para a confiabilidade dos sistemas multiprogramveis, so apresentados alguns
problemas de compartilhamento de recursos. A primeira situao envolve o compartilhamento de um arquivo em disco; a segunda apresenta uma varivel na memria principal sendo compartilhada por dois processos.
O primeiro problema analisado a partir do programa Conta_Corrente, que atualiza o
saldo bancrio de um cliente aps um lanamento de dbito ou crdito no arquivo de
contas corrente Arq_Contas. Neste arquivo so armazenados os saldos de todos os correntistas do banco. O programa l o registro do cliente no arquivo (Reg_Cliente), l o
valor a ser depositado ou retirado (Valor_Dep_Ret) e, em seguida, atualiza o saldo no
arquivo de contas.
Considerando processos concorrentes pertencentes a dois funcionrios do banco que
atualizam o saldo de um mesmo cliente simultaneamente, a situao de compartilhamento do recurso pode ser analisada. O processo do primeiro funcionrio (Caixa 1) l o
registro do cliente e soma ao campo Saldo o valor do lanamento de dbito. Antes de
gravar o novo saldo no arquivo, o processo do segundo funcionrio (Caixa 2) l o registro
do mesmo cliente, que est sendo atualizado, para realizar outro lanamento, desta vez
de crdito. Independentemente de qual dos processos atualize primeiro o saldo no arquivo, o dado gravado estar inconsistente.
30
PROGRAM Conta_Corrente;
.
.
READ (Arq_Contas, Reg_Cliente);
READLN (Valor_Dep_Ret);
Reg_Cliente.Saldo :=
Reg_Cliente.Saldo + Valor_Dep_Ret;
WRITE (Arq_Contas, Reg_Cliente);
.
.
END.
Caixa
Comando
Saldo Arquivo
Valor dep/ret
Saldo Memria
READ
1000
1000
READLN
1000
-200
1000
:=
1000
-200
800
READ
1000
1000
READLN
1000
+300
1000
:=
1000
+300
1300
WRITE
800
-200
800
WRITE
1300
+300
1300
Um outro exemplo, seria o spool de impresso. Quando um processo deseja imprimir

um arquivo, ele entra com o nome do arquivo em um diretrio especial de spool. Outro
processo, o impressor, verifica periodicamente este diretrio, para ver se h arquivos a
serem impressos. Havendo, eles so impressos e seus nomes so retirados do diretrio.
Imagine que nosso diretrio tenha as entradas de 0 a infinito, onde cada uma delas
armazena um arquivo. Duas variveis compartilhadas: out aponta para o nome do arquivo a ser impresso e in para a prxima entrada livre do diretrio.
Diretrio
de Spool
abc
prog. c
prog. n
out = 4
Processo A
in = 7
Processo B
Mais ou menos simultaneamente, os processos A e B decidem colocar um arquivo na

fila de impresso. S que ocorre o seguinte: A l a varivel entrada e armazena o valor
7. Depois disso ocorre uma interrupo de tempo, onde o processo A deve ceder o processador para o processo B. Este l o valor de entrada 7, mesmo valor que A obteve
quando fez a leitura. B guarda o nome do seu arquivo na entrada 7 do diretrio, atualizando entrada para 8, continuando seu processamento
31
Em algum momento seguinte, A vai reiniciar seu processamento no exato ponto onde
parou. Ao examinar o valor da varivel local onde guardou a entrada livre no spool de
impresso, encontrar 7 e escrever o nome do arquivo na entrada 7 do diretrio, apagando o nome do arquivo escrito por B e ainda no impresso. Atualiza a varivel para 8 e
continua o processamento. Acontecer que o processo B nunca ter seu arquivo impresso.
Analisando os dois exemplos apresentados, possvel concluir que em qualquer situao, onde dois ou mais processos compartilham um mesmo recurso, devem existir mecanismos de controle para evitar esses tipos de problemas.
Situaes como esta, onde dois ou mais processos esto acessando dados compartilhados, e o resultado final do processamento depende de quem roda quando, so chamadas de condies de corrida.
3.6
EXCLUSO MTUA
Como evitar a ocorrncia de condies de corrida? A questo chave para evitar qualquer problema em compartilhamento de recursos encontrar formas de proibir que mais
de um processo acesse o dado compartilhado ao mesmo tempo.
Ou seja: implementando a excluso mtua, uma forma de se ter certeza de que se
um processo estiver usando uma varivel ou arquivo compartilhados, os demais sero
impedidos de fazer a mesma coisa.
As partes do programa, cujo processamento pode levar ocorrncia de condies de
corrida, so denominadas regies crticas. Evitando que dois processos estejam processando suas sees crticas ao mesmo tempo, evitaria a ocorrncia de condies de
corrida.
Embora essa soluo impea as condies de corrida, isso no suficiente para que
processos paralelos que usam dados compartilhados executem corretamente. Precisamos
evitar tambm outras situaes indesejadas:
1.
Nenhum processo que esteja fora de sua regio crtica pode bloquear a execuo de outro processo
2.
Nenhum processo pode esperar indefinidamente para entrar em sua regio
crtica (starvation ou espera indefinida)
Diversas solues foram propostas para garantir a excluso mtua de processos concorrentes. A seguir, so apresentadas algumas solues de hardware e de software com
discusses sobre benefcios e problemas de cada proposta.
3.7
SOLUES DE HARDWARE
A excluso mtua pode ser implementada atravs de mecanismos de hardware:
3.7.1 DESABILITAO DAS INTERRUPES

Nesta soluo, ao adentrar sua regio crtica, o processo desabilita as interrupes da
mquina. Isto garante que outro processo no ser escalonado para rodar. Imediatamente aps deixar a sua regio crtica, o processo habilita novamente as interrupes. Esta
uma soluo funcional, porm ela compromete o nvel de segurana do sistema computacional, pois se um processo desabilitar as interrupes e, por um motivo qualquer, no
habilit-las novamente, todo o sistema estar comprometido.
Em sistemas com mltiplos processadores, essa soluo torna-se ineficiente devido
ao tempo de propagao quando um processador sinaliza aos demais que as interrupes
devem ser habilitadas ou desabilitadas.
BEGIN
.
Desabilita_Interrupcoes;
Regiao_Critica;
Habilita_Interrupcoes;
.
END.
32
3.7.2 INSTRUO TEST-AND-SET LOCKED (TSL)

Muitos processadores possuem uma instruo de mquina especial que permite ler
uma varivel, armazenar seu contedo em uma outra rea e atribuir um novo valor
mesma varivel. Essa instruo especial chamada test-and-set-locked (TSL) e tem
como caracterstica ser executada sem interrupo, ou seja, trata-se de uma instruo
atmica ou indivisvel. Dessa forma, garantido que dois processos no manipulem uma
varivel compartilhada ao mesmo tempo, possibilitando a implementao da excluso
mtua.
A instruo TSL possui o formato a seguir, e quando executada o valor lgico da varivel Y copiado para X, sendo atribudo varivel Y o valor lgico verdadeiro:
TSL (X,Y);
Para coordenar o acesso concorrente a um recurso, a instruo TSL utiliza uma varivel lgica global, que no programa Test-And-Set denominada Bloqueio. Quando a varivel Bloqueio for falsa, qualquer processo poder alterar seu valor para verdadeiro atravs da instruo TSL e, assim, acessar o recurso de forma exclusiva. Ao terminar o acesso, o processo deve simplesmente retornar o valor da varivel para falso, liberando o
acesso ao recurso.
PROGRAM Test_And_Set;
VAR Bloqueio : BOOLEAN;
BEGIN
Bloqueio := False;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
PROCEDURE Processo_A;
VAR Pode_A : BOOLEAN;
BEGIN
Pode_A := True;
WHILE (Pode_A) DO
TSL(Pode_A, Bloqueio);
Regiao_Critica_A;
Bloqueio := False;
END;
PROCEDURE Processo_B;
VAR Pode_B : BOOLEAN;
BEGIN
Pode_B := True;
WHILE (Pode_B) DO
TSL(Pode_B, Bloqueio);
Regiao_Critica_B;
Bloqueio := False;
END;
O uso de uma instruo especial de mquina oferece algumas vantagens, como a

simplicidade de implementao da excluso mtua em mltiplas regies crticas e o uso
da soluo em arquiteturas com mltiplos processadores. A principal desvantagem a
possibilidade do starvation, pois a seleo do processo para acesso ao recurso arbitrria.
3.8
SOLUES DE SOFTWARE
Diversos algoritmos foram propostos na tentativa de implementar a excluso mtua

atravs de solues de software. As primeiras solues tratavam apenas da excluso
mtua para dois processos e, inicialmente, apresentavam alguns problemas. Veremos os
algoritmos de forma evolutiva at alcanar uma soluo definitiva para a excluso mtua
entre N processos.
3.8.1 PRIMEIRO ALGORITMO: ESTRITA ALTERNNCIA
Este mecanismo utiliza uma varivel de bloqueio, indicando qual processo pode ter
acesso regio crtica. Inicialmente, a varivel global Vez igual a A, indicando que o
Processo A pode executar sua regio crtica. O Processo B, por sua vez, fica esperando
enquanto Vez for igual a A. O Processo B s executar sua regio crtica quando o Processo A atribuir o valor B varivel de bloqueio Vez. Desta forma, estar garantida a
excluso mtua entre os dois processos.
33
PROGRAM Algoritmo1;
VAR Vez : CHAR;
BEGIN
Vez := A;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
BEGIN
WHILE (Vez = B) DO;
Regiao_Critica_A;
Vez := B;
Processamento_A;
END;
BEGIN
WHILE (Vez = A) DO;
Regiao_Critica_B;
Vez := A;
Processamento_B;
END;
Este algoritmo apresenta duas limitaes: 1) a primeira surge do prprio mecanismo

de controle. O acesso ao recurso compartilhado s pode ser realizado por dois processos
e sempre de maneira alternada. Caso o Processo A permanea muito tempo na rotina
Processamento_A, possvel que o Processo B queira executar sua regio crtica e no
consiga, mesmo que o Processo A no esteja mais utilizando o recurso. Como o Processo
B pode executar seu loop mais rapidamente que o Processo A, a possibilidade de executar sua regio crtica fica limitada pela velocidade de processamento do Processo A. 2) no
caso da ocorrncia de algum problema com um dos processos, de forma que a varivel
de bloqueio no seja alterada, o outro processo permanecer indefinidamente bloqueado.
3.8.2 SEGUNDO ALGORITMO:
O problema principal do primeiro algoritmo que ambos os processos trabalham com
uma mesma varivel global, cujo contedo indica qual processo tem o direito de entrar
na regio crtica. Para evitar esta situao, o segundo algoritmo introduz uma varivel
para cada processo (CA e CB) que indica se o processo est ou no em sua regio crtica.
Neste caso, toda vez que um processo desejar entrar em sua regio crtica, a varivel do
outro processo testada para verificar se o recurso est livre para uso.
PROGRAM Algoritmo2;
VAR CA, CB : BOOLEAN;
BEGIN
CA := false;
CB := false;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
BEGIN
WHILE (CB) DO;
CA := true;
Regiao_Critica_A;
CA := false;
Processamento_A;
END;
BEGIN
WHILE (CA) DO;
CB := true;
Regiao_Critica_B;
CB := false;
Processamento_B;
END;
Neste segundo algoritmo, o uso do recurso no realizado necessariamente alternado. Caso ocorra algum problema com um dos processos fora da regio crtica, o outro
processo no ficar bloqueado, o que, porm, no resolve por completo o problema. Caso um processo tenha um problema dentro da sua regio crtica ou antes de alterar a
varivel, o outro processo permanecer indefinidamente bloqueado. Mais grave que o
problema do bloqueio que esta soluo, na prtica, pior do que o primeiro algoritmo
apresentado, pois nem sempre a excluso mtua garantida. Observe abaixo:
34
Processo_A
Processo_B
CA
CB
WHILE (CB)
WHILE (CA)
false
false
CA := true
CB := true
true
true
Regiao_Critica_A
Regiao_Critica_B
true
true
3.8.3 TERCEIRO ALGORITMO:

Este algoritmo tenta solucionar o problema apresentado no segundo, colocando a instruo da atribuio das variveis CA e CB antes do loop de teste.
PROGRAM Algoritmo3;
BEGIN
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
BEGIN
CA := true;
WHILE (CB) DO;
CA := true;
Regiao_Critica_A;
CA := false;
Processamento_A;
END;
BEGIN
CB := true;
WHILE (CA) DO;
CB := true;
Regiao_Critica_B;
CB := false;
Processamento_B;
END;
Esta alterao resulta na garantia da excluso mtua, porm introduz um novo problema, que a possibilidade de bloqueio indefinido de ambos os processos. Caso os dois
processos alterem as variveis CA e CB antes da execuo da instruo WHILE, ambos os
processos no podero entrar em suas regies crticas, como se o recurso j estivesse
alocado.
3.8.4 QUARTO ALGORITMO:
No terceiro algoritmo, cada processo altera o estado da sua varivel indicando que ir
entrar na regio crtica sem conhecer o estado do outro processo, o que acaba resultando
no problema apresentado. O quarto algoritmo apresenta uma implementao onde o
processo, da mesma forma, altera o estado da varivel antes de entrar na sua regio
crtica, porm existe a possibilidade de esta alterao ser revertida.
PROGRAM Algoritmo4;
BEGIN
CA := false;
CB := false;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
35
BEGIN
CA := true;
WHILE (CB) DO
BEGIN
CA := false;
{pequeno intervalo de tempo}
CA := true;
END
Regiao_Critica_A;
CA := false;
END;
BEGIN
CB := true;
WHILE (CA) DO
BEGIN
CB := false;
{pequeno intervalo de tempo}
CB := true;
END
Regiao_Critica_B;
CB := false;
END;
Apesar de esta soluo garantir a excluso mtua e no gerar o bloqueio simultneo

dos processos, uma nova situao indesejada pode ocorrer eventualmente. No caso de
os tempos aleatrios serem prximos e a concorrncia gerar uma situao onde os dois
processos alterem as variveis CA e CB para falso antes do trmino do loop, nenhum dos
dois processos conseguir executar sua regio crtica. Mesmo com esta situao no sendo permanente, pode gerar alguns problemas.
3.8.5 ALGORITMO DE PETERSON
A primeira soluo de software que garantiu a excluso mtua entre dois processos
sem a incorrncia de outros problemas foi proposta pelo matemtico holands T. Dekker
com base no primeiro e quarto algoritmos. Esse algoritmo possui uma lgica bastante
complexa. Posteriormente, G. L. Peterson props outra soluo mais simples.
Este algoritmo apresenta uma soluo para dois processos que pode ser facilmente
generalizada para o caso de N processos. Similar ao terceiro algoritmo, esta soluo,
alm das variveis de condio (CA e CB) que indicam o desejo de cada processo entrar
em sua regio crtica, introduz a varivel Vez para resolver os conflitos gerados pela concorrncia.
Antes de acessar a regio crtica, o processo sinaliza esse desejo atravs da varivel
de condio, porm o processo cede o uso do recurso ao outro processo, indicado pela
varivel Vez. Em seguida, o processo executa o comando WHILE como protocolo de entrada da regio crtica. Neste caso, alm da garantia da excluso mtua, o bloqueio indefinido de um dos processos no loop nunca ocorrer, j que a varivel Vez sempre permitir a continuidade da execuo de um dos processos.
PROGRAM Algoritmo_Peterson;
Vez : CHAR;
BEGIN
CA := false;
CB := false;
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
BEGIN
CA := true;
Vez := B;
WHILE (CB and Vez = B) DO;
Regiao_Critica_A;
CA := false;
Processamento_A;
END;
BEGIN
CB := true;
Vez := A;
WHILE (CA and Vez = A) DO;
Regiao_Critica_B;
CB := false;
Processamento_B;
END;
36
Apesar de todas solues at ento apresentadas implementarem a excluso mtua,

todas possuam uma deficincia conhecida como espera ocupada (busy waiting). Todas
as solues baseadas na espera ocupada possuem dois problemas em comum e eles so:
a) Perda de tempo de processamento: todas as solues utilizam-se de um lao
de espera ocupada para impedir que dois processos entrem ao mesmo tempo em suas
regies crticas e tais laos consomem, desnecessariamente, o tempo do processador;
b) Prioridade invertida: este problema ocorre quando existem dois processos executando, um A de alta prioridade, e outro B de baixa prioridade e o Gerente de Processos est programado para colocar para rodar qualquer processo de alta prioridade que
esteja no estado de pronto. Objetivando verificar tal problema, considera-se que o processo A comea a rodar e solicita uma operao de entrada/sada e migra para o estado de bloqueado. Nesse momento, escalonado para rodar o processo B, que logo entra em sua regio crtica. Em seguida, a operao de entrada/sada solicitada por A
concluda e ele, ento, migra do estado de bloqueado para o de pronto e tenta adentrar
em sua regio crtica e fica preso no lao de espera ocupada, pois o processo B j se
encontra dentro de sua regio crtica correspondente. Diante disso, o processo B jamais
ser escalonado novamente para rodar, pois A est executando o seu lao de espera
ocupada e o Gerente de Processos no ir escalonar A que, por sua vez, no deixar a
sua regio crtica, caracterizando, dessa forma, uma situao de bloqueio conhecida como prioridade invertida.
3.9
PROBLEMA DO PRODUTOR-CONSUMIDOR ou SINCRONIZAO CONDICIONAL
Sincronizao Condicional uma situao onde o acesso ao recurso compartilhado

exige a sincronizao de processos vinculada a uma condio de acesso. Um recurso pode no se encontrar pronto para uso devido a uma condio especfica. Nesse caso, o
processo que deseja acess-la dever permanecer bloqueado at que o recurso fique
disponvel.
O problema do produtor-consumidor, ilustrado na figura abaixo, consiste em dois
processos que compartilham um buffer de tamanho fixo. Um dos processos, o produtor,
coloca informao no buffer, e o outro, o consumidor, as retira. Assim sendo, fcil perceber a existncia de duas situaes que precisam ser tratadas. A primeira delas ocorre
quando o produtor deseja colocar informao no buffer e este se encontra cheio. A segunda situao acontece quando o consumidor quer retirar uma informao do buffer
que est vazio.
Conforme j foi mencionado, tanto uma quanto outra situao necessita ser adequadamente tratada. Diante disso, tem-se que uma soluo para a primeira das situaes
(buffer cheio) fazer com que o processo produtor interrompa sua execuo enquanto
no existir ao menos uma posio vazia no buffer. Uma soluo para a segunda situao
(buffer vazio) manter o consumidor parado enquanto no houver pelo menos uma informao no buffer.
O programa a seguir exemplifica o problema. O recurso compartilhado um buffer,
definido no algoritmo com o tamanho TamBuf e sendo controlado pela varivel Cont.
Sempre que a varivel Cont for igual a 0, significa que o buffer est vazio e o processo
37
Consumidor deve permanecer aguardando at que se grave um dado. Da mesma forma,

quando a varivel Cont for igual a TamBuf, significa que o buffer est cheio e o processo
Produtor deve aguardar a leitura de um novo dado. Nessa soluo, a tarefa de colocar e
retirar os dados do buffer realizada, respectivamente, pelos procedimentos Grava_Buffer e Le_Buffer, executados de forma mutuamente exclusiva. No est sendo considerada, neste algoritmo, a implementao da excluso mtua na varivel compartilhada Cont.
PROGRAM Produtor_Consumidor_1;
CONST TamBuf
= (* Tamanho qualquer *);
TYPE Tipo_Dado = (* Tipo qualquer *);
VAR Buffer : ARRAY [1..TamBuf] OF Tipo_Dado;
Dado
: Tipo_Dado;
Cont
: 0..TamBuf;
BEGIN
Cont := 0;
PARBEGIN
Produtor;
Consumidor;
PAREND;
END.
PROCEDURE Produtor;
BEGIN
Produz_Dado (Dado);
WHILE (Cont = TamBuf) DO;
Grava_Buffer (Dado, Cont);
Cont++;
END;
PROCEDURE Consumidor;
BEGIN
WHILE (Cont = 0) DO;
Le_Buffer (Dado);
Consome_Dado (Dado, Cont);
Cont--;
END;
Apesar de o algoritmo apresentado resolver a questo da sincronizao condicional,

ou do buffer limitado, o problema da espera ocupada tambm se faz presente, sendo
somente solucionado pelos mecanismos de sincronizao semforos e monitores.
3.10
SEMFOROS
Um semforo uma varivel inteira, no-negativa, que s pode ser manipulada por
duas instrues atmicas: DOWN e UP. A instruo UP incrementa uma unidade ao valor
do semforo, enquanto DOWN decrementa a varivel. Como, por definio, valores negativos no podem ser atribudos a um semforo, a instruo DOWN executada em um semforo com valor 0, faz com que o processo entre no estado de espera. Em geral, essas
instrues so implementadas no processador, que deve garantir todas essas condies.
Podem ser classificados como binrios ou contadores. Os binrios, tambm chamados de mutexes (mutual exclusion semaphores), s podem assumir os valores 0 e 1,
enquanto os contadores podem assumir qualquer valor inteiro positivo, alm do 0.
Semforos contadores so bastante teis quando aplicados em problemas de sincronizao condicional onde existem processos concorrentes alocando recursos do mesmo
tipo (pool de recursos). O semforo inicializado com o nmero total de recursos do pool
e, sempre que um processo deseja alocar um recurso, executa um DOWN, subtraindo 1
do nmero de recursos disponveis. Da mesma forma, sempre que o processo libera um
recurso para o pool, executa um UP. Se o semforo contador ficar com o valor igual a 0,
isso significa que no existem mais recursos a serem utilizados, e o processo que solicita
um recurso permanece em estado de espera, at que outro processo libere algum recurso para o pool.
3.10.1 EXCLUSO MTUA UTILIZANDO SEMFOROS
A excluso mtua pode ser implementada atravs de um semforo binrio associado
ao recurso compartilhado. A principal vantagem desta soluo em relao aos algoritmos
anteriormente apresentados, a no ocorrncia da espera ocupada.
38
As instrues DOWN e UP funcionam como protocolos de entrada e sada, respectivamente, para que um processo possa entrar e sair de sua regio crtica. O semforo fica
associado a um recurso compartilhado, indicando quando o recurso est sendo acessado
por um dos processos concorrentes. O valor do semforo igual a 1 indica que nenhum
processo est utilizando o recurso, enquanto o valor 0 indica que o recurso est em uso.
Sempre que deseja entrar na sua regio crtica, um processo executa uma instruo
DOWN. Se o semforo for igual a 1, este valor decrementado, e o processo que solicitou a operao pode executar as instrues da sua regio crtica. De outra forma, se uma
instruo DOWN executada em um semforo com valor igual a 0, o processo fica impedido do acesso, permanecendo em estado de espera e, conseqentemente, no gerando
overhead no processador.
O processo que est acessando o recurso, ao sair de sua regio crtica, executa uma
instruo UP, incrementando o valor do semforo e liberando o acesso ao recurso. Se um
ou mais processos estiverem esperando pelo uso do recurso, o sistema selecionar um
processo na fila de espera associada ao recurso e alterar o seu estado para pronto.
As instrues DOWN e UP, aplicadas a um semforo S, podem ser representadas pelas definies a seguir, em uma sintaxe Pascal no convencional:
TYPE Semaforo = RECORD
Valor : INTEGER;
Fila_Espera : (*Lista de processos pendentes*);
END;
PROCEDURE DOWN (Var S : Semaforo);
BEGIN
IF (S = 0) THEN Coloca_Proc_Fila
ELSE
S := S - 1;
END;
PROCEDURE UP (Var S : Semaforo);

BEGIN
S := S + 1;
IF(Tem_Proc_Espera)THEN(Tira_Proc);
END;
O programa Semaforo_1 apresenta uma soluo para o problema da excluso mtua

entre dois processos utilizando semforos. O semforo inicializado com o valor 1, indicando que nenhum processo est executando sua regio crtica.
PROGRAM Semaforo_1;
VAR S : Semaforo := 1;
BEGIN
PARBEGIN
Processo_A;
Processo_B;
PAREND;
END.
BEGIN
DOWN (S);
Regiao_Critica_A;
UP (S);
Processamento_A;
END;
BEGIN
DOWN (S);
Regiao_Critica_B;
UP (S);
Processamento_B;
END;
O Processo A executa a instruo DOWN, fazendo com que o semforo seja decrementado de 1 e passe a ter o valor 0. Em seguida, o Processo A ganha o acesso sua
regio crtica. O Processo B tambm executa a instruo DOWN, mas como seu valor
igual a 0, ficar aguardando at que o Processo A execute a instruo UP, ou seja, volte
o valor semforo para 1.
3.10.2 SINCRONIZAO CONDICIONAL UTILIZANDO SEMFOROS
O problema do produtor/consumidor um exemplo de como a excluso mtua e a
sincronizao condicional podem ser implementadas com o uso de semforos. O programa ProdutorConsumidor2 apresenta uma soluo para esse problema, utilizando um bufSistemas Operacionais Lucilia Ribeiro
39
fer de apenas duas posies. O programa utiliza trs semforos, sendo um do tipo binrio, utilizado para implementar a excluso mtua e dois semforos contadores para a
sincronizao condicional. O semforo binrio Mutex permite a execuo das regies crticas Grava_Buffer e Le_Buffer de forma mutuamente exclusiva. Os semforos contadores Vazio e Cheio representam, respectivamente, se h posies livres no buffer para
serem gravadas e posies ocupadas a serem lidas. Quando o semforo Vazio for igual a
0, significa que o buffer est cheio e o processo produtor dever aguardar at que o consumidor leia algum dado. Da mesma forma, quando o semforo Cheio for igual a 0, significa que o buffer est vazio e o consumidor dever aguardar at que o produtor grave
algum dado. Em ambas as situaes, o semforo sinaliza a impossibilidade de acesso ao
recurso.
CONST TamBuf
= 2;
VAR Vazio : Semaforo := TamBuf;
Cheio : Semaforo := 0;
Mutex : Semaforo := 1;
BEGIN
PARBEGIN
Produtor;
Consumidor;
PAREND;
END.
PROCEDURE Produtor;
BEGIN
Produz_Dado;
DOWN (Vazio);
DOWN (Mutex);
Grava_Buffer;
P (Mutex);
UP (Cheio);
END;
BEGIN
DOWN (Cheio);
DOWN (Mutex);
Le_Buffer;
P (Mutex);
UP (Vazio);
Consome_Dado;
END;
Por exemplo, consideremos que o processo Consumidor o primeiro a ser executado.

Como o buffer est vazio (Cheio = 0), a operao DOWN (Cheio) faz com que o processo
Consumidor permanea no estado de espera. Em seguida, o processo Produtor grava um
dado no buffer e, aps executar o UP (Cheio), libera o processo Consumidor, que estar
apto para ler o dado do buffer.
3.11
TROCA DE MENSAGENS
um mecanismo de comunicao e sincronizao entre processos. O Sistema Operacional possui um subsistema de mensagem que suporta esse mecanismo sem que haja
necessidade do uso de variveis compartilhadas. Para que haja a comunicao entre os
processos, deve existir um canal de comunicao, podendo esse meio ser um buffer ou
um link de uma rede de computadores.
Os processos cooperativos podem fazer uso de um buffer para trocar mensagens atravs de duas rotinas: SEND (receptor, mensagem) e RECEIVE (transmissor, mensagem). A rotina SEND permite o envio de uma mensagem para um processo receptor,
enquanto a rotina RECEIVE possibilita o recebimento de mensagem enviada por um processo transmissor.
Uma soluo para o problema do produtor/consumidor apresentada utilizando a troca de mensagens.
BEGIN
PARBEGIN
Produtor;
Consumidor;
PAREND;
END.
PROCEDURE Produtor;
40
VAR Msg : Tipo_Msg;

BEGIN
Produz_Mensagem (Msg);
SEND (Msg);
END;
3.12
VAR Msg : Tipo_Msg;

BEGIN
RECEIVE (Msg);
Consome_Mensagem (Msg);
END;
PROBLEMAS CLSSICOS DE SINCRONIZAO
A literatura sobre sistemas operacionais est repleta de problemas interessantes que

tm sido amplamente discutidos e analisados a partir de vrios mtodos de sincronizao.
3.12.1 PROBLEMA DOS FILSOFOS GLUTES
Este problema, conforme ilustra a figura abaixo, considera a existncia de cinco filsofos sentados em torno de uma mesa redonda. Cada filsofo tem sua frente um prato
de macarro.
Um filsofo que deseje comer precisa contar com o auxlio de 2 garfos e entre cada
prato existe um garfo. A vida de um filsofo consiste em perodos nos quais ele alternadamente come e pensa. Quando um filsofo sente fome, ele tenta tomar posse dos garfos sua direita e sua esquerda, um por vez, em qualquer ordem. Se ele tiver sucesso
nesta empreitada, come um pouco do macarro, libera os garfos e continua a pensar. A
questo a ser respondida : como escrever um programa para simular a ao de cada
filsofo que nunca leve a situaes de bloqueio?
3.12.2 PROBLEMA DO BARBEIRO DORMINHOCO

Neste problema, considera-se uma barbearia onde existe um barbeiro, uma cadeira
de barbeiros e diversos lugares onde os clientes que estiverem esperando, podero sentar. Se no houver nenhum cliente presente, o barbeiro simplesmente senta em sua cadeira e cai no sono. Quando chegarem fregueses, enquanto o barbeiro estiver cortando o
cabelo de outro, estes devem ou sentar, se houver cadeira vazia, ou ir embora, se no
houver nenhuma cadeira disponvel.
41
3.13
EXERCCIOS
33) Defina o que uma aplicao concorrente e d um exemplo de sua utilizao.

34) Relacione Regio Crtica com Condio de Corrida.
35) Considere uma aplicao que utilize uma matriz na memria principal para a comunicao entre vrios processos concorrentes. Que tipo de problema pode ocorrer quando dois ou mais processos acessam uma mesma posio da matriz?
36) O que excluso mtua e como implementada?
37) Como seria possvel resolver os problemas decorrentes do compartilhamento da
matriz, apresentado anteriormente, utilizando o conceito de excluso mtua?
38) O que starvation e como podemos solucionar esse problema?
39) Qual o problema com a soluo que desabilita as interrupes para implementar a
excluso mtua?
40) O que espera ocupada?
41) Quais so os problemas comuns a todas as solues que se utilizam da espera ocupada para garantir a excluso mtua de execuo?
42) Explique o que sincronizao condicional e d um exemplo de sua utilizao.
43) Explique o que so semforos e d dois exemplos de sua utilizao: um para a soluo da excluso mtua e outro para sincronizao condicional.
44) Em uma aplicao concorrente que controla saldo bancrio em contas-correntes,
dois processos compartilham uma regio de memria onde esto armazenados os
saldos dos clientes A e B. Os processos executam concorrentemente os seguintes
passos:
Processo 1 (Cliente A)
Processo 2 (Cliente B)
/* saque em A */
1a. x := saldo_cliente_A;
1b. x := x 200;
1c. saldo_cliente_A := x;
/* saque em A */
2a. y := saldo_cliente_A;
2b. y := y 100;
2c. saldo_cliente_A := y;
/* deposito em B */
1d. x := saldo_cliente_B;
1e. x := x + 100;
1f. saldo_cliente_B := x;
/* deposito em B */
2d. y := saldo_cliente_B;
2e. y := y + 200;
2f. saldo_cliente_B := y;
Supondo que os valores dos saldos de A e B sejam, respectivamente, 500 e 900,

antes de os processos executarem, pede-se:
a) Quais os valores corretos esperados para os saldos dos clientes A e B aps o
trmino da execuo dos processos?
b) Quais os valores finais dos saldos dos clientes se a seqncia temporal de execuo das operaes for: 1a, 2a, 1b, 2b, 1c, 2c, 1d, 2d, 1e, 2e, 1f, 2f?
c) Utilizando semforos, proponha uma soluo que garanta a integridade dos
saldos e permita o maior compartilhamento possvel dos recursos entre os
processos, no esquecendo a especificao da inicializao dos semforos.
45) O problema dos leitores/escritores apresentado a seguir, consiste em sincronizar
processos que consultam/atualizam dados em uma base comum. Pode haver mais
de um leitor lendo ao mesmo tempo; no entanto, enquanto um escritor est atuaSistemas Operacionais Lucilia Ribeiro
42
lizando a base, nenhum outro processo pode ter acesso a ela (nem mesmo leitores).
VAR Acesso : Semaforo := 1;
Exclusao : Semaforo := 1;
Nleitores : INTEGER := 0;
PROCEDURE Escritor;
BEGIN
ProduzDado;
DOWN (Acesso);
Escreve;
UP (Acesso);
END;
PROCEDURE Leitor;
BEGIN
DOWN (Exclusao);
Nleitores := Nleitores + 1;
IF (Nleitores = 1) THEN DOWN (Acesso);
UP (Exclusao);
Leitura;
DOWN (Exclusao);
Nleitores := Nleitores 1;
IF (Nleitores = 0) THEN UP(Acesso);
UP (Exclusao);
ProcessaDado;
END;
a) Suponha que exista apenas um leitor fazendo acesso base. Enquanto este
processo realiza a leitura, quais os valores das trs variveis?
b) Chega um escritor enquanto o leitor ainda est lendo. Quais os valores das
trs variveis aps o bloqueio do escritor? Sobre qual(is) semforo(s) se d o
bloqueio?
c) Chega mais um leitor enquanto o primeiro ainda no acabou de ler e o escritor
est bloqueado. Descreva os valores das trs variveis enquanto o segundo
leitor inicia a leitura.
d) Os dois leitores terminam simultaneamente a leitura. possvel haver problemas quanto integridade do valor da varivel Nleitores? Justifique.
e) Descreva o que acontece com o escritor quando os dois leitores terminam suas
leituras. Descreva os valores das trs variveis quando o escritor inicia a escrita.
f) Enquanto o escritor est atualizando a base, chegam mais um escritor e mais
um leitor. Sobre qual(is) semforo(s) eles ficam bloqueados? Descreva os valores das trs variveis aps o bloqueio dos recm-chegados.
g) Quando o escritor houver terminado a atualizao, possvel prever qual dos
processos bloqueados (leitor ou escritor) ter acesso primeiro base?
h) Descreva uma situao onde os escritores sofram (adiamento indefinido) starvation.
-x-
43
04 Deadlock
Deadlock
Para todo problema h uma soluo que simples, elegante e errada.

(H. L. Mencken)
4.1
INTRODUO
Um conjunto de N processos est em deadlock quando cada um dos N processos est

bloqueado espera de um evento que somente pode ser causado por um dos N processos do conjunto. Obviamente, essa situao somente pode ser alterada por alguma iniciativa que parta de um processo fora do conjunto dos N processos.
Ou ainda: um processo em um sistema multiprogramado dito estar em uma situao de deadlock quando ele est esperando por um evento particular que jamais ocorrer. Em um deadlock em um sistema, um ou mais processos esto em deadlock.
Em sistemas multiprogramados, o compartilhamento de recursos uma das principais metas dos sistemas operacionais. Quando recursos so compartilhados entre uma
populao de usurios, e cada usurio mantm controle exclusivo sobre os recursos particulares a ele alocados, possvel que haja a ocorrncia de deadlocks no sentido em que
alguns usurios jamais sejam capazes de terminar seu processamento.
Talvez a forma de ilustrar um deadlock seja com um exemplo de uma lei aprovada
pela assemblia norte-americana no incio deste sculo: "Quando dois trens se aproximarem um do outro em um cruzamento, ambos devero parar completamente e nenhum
dos dois dever ser acionado at que o outro tenha partido."
4.2
EXEMPLOS DE DEADLOCKS
4.2.1 DEADLOCK DE TRFEGO

Um certo nmero de automveis est tentando atravessar uma parte da cidade bastante movimentada, mas o trfego ficou completamente paralisado. O trfego chegou
numa situao onde somente a polcia pode resolver a questo, fazendo com que alguns
carros recuem na rea congestionada. Eventualmente o trfego volta a fluir normalmente, mas a essa altura os motoristas j se aborreceram e perderam tempo considervel.
4.2.2 DEADLOCK SIMPLES DE RECURSOS
Muitos deadlocks ocorrem em sistemas de computao devido natureza de recursos
dedicados (isto , os recursos somente podem ser usados por um usurio por vez).
Suponha que em um sistema o processo A detm um recurso 1, e precisa alocar o recurso 2 para poder prosseguir. O processo B, por sua vez, detm o recurso 2, e precisa
do recurso 1 para poder prosseguir. Nesta situao, temos um deadlock, porque um processo est esperando pelo outro. Esta situao de espera mtua chamada muitas vezes
de espera circular.
4.2.3 DEADLOCK EM SISTEMAS DE SPOOLING
Um sistema de spooling serve, por exemplo, para agilizar as tarefas de impresso do
sistema. Ao invs do aplicativo mandar linhas para impresso diretamente para a impressora, ele as manda para o spool, que se encarregar de envi-las para a impressora.
Assim o aplicativo rapidamente liberado da tarefa de imprimir.
Em alguns sistemas de spool, todo o job de impresso deve ser gerado antes do incio
da impresso. Isto pode gerar uma situao de deadlock, uma vez que o espao disponvel em disco para a rea de spooling limitado. Se vrios processos comearem a gerar
seus dados para o spool, possvel que o espao disponvel para o spool fique cheio anSistemas Operacionais Lucilia Ribeiro
44
04 Deadlock
tes mesmo de um dos jobs de impresso tiver terminado de ser gerado. Neste caso, todos os processos ficaro esperando pela liberao do espao em disco, o que jamais vai
acontecer. A soluo nesse caso seria o operador do sistema cancelar um dos jobs parcialmente gerados.
Para resolver o problema sem a interveno do operador, o SO poderia alocar uma
rea maior de spooling, ou a rea de spooling poderia ser varivel dinamicamente. Alguns sistemas, como o do Windows 3.x/95, utilizam todo o espao em disco disponvel.
Entretanto, pode acontecer de o disco possuir pouco espao e o problema ocorrer da
mesma forma.
A soluo definitiva seria implementar um sistema de spooling que comeasse a imprimir assim que algum dado estivesse disponvel, sem a necessidade de se esperar por
todo o job.
4.2.4 ADIAMENTO INDEFINIDO
Em sistemas onde processos ficam esperando pela alocao de recursos ou pelas decises de escalonamento, possvel que ocorra adiamento indefinido tambm chamado
de bloqueamento indefinido (ou starvation).
Adiamento indefinido pode ocorrer devido s polticas de escalonamento de recursos
do sistema, principalmente quando o esquema utiliza prioridades (conforme j vimos).
Isto pode ser evitado permitindo que a prioridade de um processo em espera cresa conforme ele espera por um recurso.
4.3
RECURSOS
Um sistema operacional pode ser visto de forma mais ampla como um gerenciador de
recursos. Ele responsvel pela alocao de vrios recursos de diversos tipos.
Aos objetos que os processos podem adquirir daremos o nome de recursos, para generalizar. Um recurso pode ser um dispositivo de hardware, como por exemplo, uma unidade de fita, ou uma informao, tal como um registro em uma base de dados. Um recurso algo que s pode ser usado por um nico processo em um determinado instante
de tempo.
Existem os recursos preemptveis e os no-preemptveis. Um recurso preemptvel
aquele que pode ser tomado do processo que estiver usando o recurso, sem nenhum
prejuzo para o processo. A memria e a CPU so exemplos.
Recursos no-preemptveis no podem ser tomados de processos aos quais foram alocados. Tm que ser executados at o fim. Exemplo, se um processo iniciou a impresso
de resultados, a impressora no poder ser tomada dele e entregue a outro processo,
sem que haja um prejuzo considervel no processamento do primeiro processo.
Alguns recursos so compartilhados entre vrios processos. Unidades de disco so
compartilhadas em geral. Memria principal e CPU so compartilhadas; apesar de que
em um instante a CPU pertence a um nico processo, mas sua multiplexao entre os
vrios processos transmite a idia de que est sendo compartilhada.
Recursos que tendem a estar envolvidos em deadlocks so aqueles que podem ser
usados por vrios processos, mas um de cada vez, ou seja: o recurso no-preemptivo.
Um sistema possui um nmero finito de recursos para serem distribudos entre processos concorrentes. Os recursos so classificados segundo vrios tipos, sendo que cada
tipo pode consistir de uma quantidade de instncias idnticas. Por exemplo, se considerarmos o tipo de recurso CPU, em uma mquina com dois processadores, temos duas
instncias do recurso CPU.
Se um processo requisita uma instncia de um tipo de recurso, a alocao de qualquer instncia daquele tipo ir satisfazer a requisio. Se em um determinado sistema
esta satisfao no ocorrer, isto significa que as instncias no so idnticas, e que as
classes de tipos de recursos no esto definidas corretamente. Por exemplo, suponha
que um sistema possui duas impressoras. Elas poderiam ser definidas como instncias de
um mesmo tipo de recurso. Entretanto se uma estivesse instalada no quarto andar, e
45
04 Deadlock
outra no trreo do prdio, os usurios do andar trreo podem no enxergar as duas impressoras como sendo equivalentes. Neste caso, classes de recursos separadas precisariam ser definidas para cada impressora.
Um processo pode requisitar um recurso antes de us-lo, e deve liber-lo depois de
seu uso. Um processo pode requisitar quantos recursos precisar para desempenhar a
tarefa para a qual foi projetado. Obviamente, o nmero de recursos requisitados no
pode exceder o nmero total de recursos disponveis no sistema.
Em uma situao de operao normal, um processo pode utilizar um recurso somente
nesta seqncia:
1) Requisitar: se a requisio no pode ser atendida imediatamente (por exemplo, o
recurso est em uso por outro processo), ento o processo requisitante deve esperar at
obter o recurso; 2) Usar: O processo pode operar sobre o recurso (por exemplo, se o
recurso uma impressora, ele pode imprimir) e 3) Liberar: O processo libera o recurso
4.4
QUATRO CONDIES NECESSRIAS PARA DEADLOCKS
Coffman, Elphick e Shosani (1971) enumeraram as seguintes quatro condies necessrias que devem estar em efeito para que um deadlock exista:
1) Condio de excluso mtua: cada recurso ou est alocado a exatamente um
processo ou est disponvel
2) Condio de posse e de espera: processos que estejam de posse de recursos
obtidos anteriormente podem solicitar novos recursos
3) Condio de no-preempo: recursos j alocados a processos no podem ser
tomados fora. Eles precisam ser liberados explicitamente pelo processo que detm sua
posse.
4) Condio de espera circular: deve existir uma cadeia circular de dois ou mais
processos, cada um dos quais esperando por um recurso que est com o prximo membro da cadeia
Todas as quatro condies acima citadas devem estar presentes para que possa ocorrer deadlock. Se uma delas estiver ausente, no h a menor possibilidade de ocorrer
uma situao de deadlock. Isto nos ajudar a desenvolver esquemas para prevenir deadlocks.
4.5
O MODELO DO DEADLOCK
As condies de deadlock podem, de acordo com Holt (1972), ser modeladas com o
uso de grafos dirigidos. Tais grafos tem dois tipos de ns: processos, representados por
crculos e recursos, representados por quadrados.
A figura abaixo exibe um grafo de alocao de recursos. (a) Um processo de posse de
um recurso. (b) Um processo solicitando um recurso. (c) Deadlock
A seguir, um exemplo de como o deadlock pode ocorrer e de como ele pode ser evitado.
46
04 Deadlock
1. A requisita R
2. B requisita S
3. C requisita T
4. A requisita S
5. B requisita T
6. C requisita R
ocorre deadlock
Requisita R
Requisita S
Libera R
Libera S
(a)
Requisita S
Requisita T
Libera S
Libera T
(b)
Requisita T
Requisita R
Libera T
Libera R
(c)
(d)
(e)
(f)
(h)
1. A requisita R
2. C requisita T
3. A requisita S
4. C requisita R
5. A libera R
6. A libera S
no deadlock
(i)
(j)
(k)
(l)
(m)
(n)
(o)
4.6
(g)
(p)
(q)
MTODOS PARA LIDAR COM DEADLOCKS
Evitar dinamicamente o deadlock, pela cuidadosa alocao dos recursos aos processos. Isto requer que seja fornecida ao sistema operacional informaes adicionais sobre
quais recursos um processo ir requisitar e usar durante sua execuo.
Prevenir o deadlock atravs da negao de uma das quatro condies necessrias
para que ocorra um deadlock
Detectar e recuperar uma situao de deadlock. Se no so usadas estratgias de
preveno ou para evitar deadlocks, existe a possibilidade de ocorrncia destes. Neste
47
04 Deadlock
ambiente, o sistema operacional pode possuir um algoritmo que consiga determinar se

ocorreu um deadlock, alm de um algoritmo que faa a recuperao da situao.
Ignorar completamente o problema. Se um sistema que nem previne, evita ou recupera situaes de deadlock, se um ocorrer, no haver maneira de saber o que aconteceu exatamente. Neste caso, o deadlock no detectado causar a deteriorao do desempenho do sistema, porque recursos esto detidos por processos que no podem continuar, e porque mais e mais processos, conforme requisitam recursos, entram em deadlock. Eventualmente o sistema ir parar de funcionar e ter que ser reinicializado manualmente.
Apesar do mtodo de ignorar os deadlocks no parecer uma abordagem vivel para o
problema da ocorrncia de deadlocks, ele utilizado na maioria dos sistemas operacionais, inclusive o UNIX. Em muitos sistemas, deadlocks no ocorrem de forma freqente,
como por exemplo, uma vez por ano. Assim, muito mais simples e "barato" usar este
mtodo do que os dispendiosos meios de prevenir, evitar, detectar e recuperar deadlocks.
4.7
O ALGORITMO DO AVESTRUZ
a abordagem mais simples: "enterre a cabea na areia e pense que no h nenhum

problema acontecendo".
A estratgia do UNIX em relao aos deadlocks simplesmente ignorar o problema,
pressupondo que a maioria dos usurios vai preferir a ocorrncia de deadlocks ocasionais, em vez de regras que forcem todos os usurios a s usar um processo, um arquivo
aberto, enfim, um exemplar de cada recurso. Se os deadlocks pudessem ser eliminados
de graa, no haveria nenhuma discusso a respeito da convenincia de tal abordagem.
O problema que o preo de sua eliminao alto, sobretudo pelo fato de se estabelecerem restries inconvenientes ao uso dos recursos do sistema. Desta forma, estamos
diante de uma deciso no muito agradvel, entre a convenincia e a correo.
4.8
DETECO DE DEADLOCKS
Uma segunda tcnica detectar e recuperar os deadlocks. Quando ela usada, o sistema no se preocupa em prevenir a ocorrncia de deadlocks. Em vez disso, ele permite
que os mesmos ocorram, tenta detectar as ocorrncias, e age no sentido de normalizar a
situao, aps sua ocorrncia.
4.8.1 DETECO DO DEADLOCK COM UM RECURSO DE CADA TIPO
Vamos comear com a existncia de um recurso de cada tipo. Ou seja, o sistema pode ter uma impressora, um plotter e uma unidade de fita, mas no duas impressoras,
por exemplo.
Para esse mtodo, construmos um grafo de recursos conforme j foi visto. Se tal
grafo contiver um ou mais ciclos, estar garantida pelo menos uma situao de deadlock.
Se no houver ciclos, o sistema no estar em deadlock.
Na figura, observamos que o grafo possui um ciclo, que pode ser notado pela simples
inspeo visual. Portanto, os processos D, E e G esto em deadlock. Apesar de ser relativamente simples eliminar a condio de deadlock, atravs do grfico, esse mtodo no
pode ser usado nos sistemas reais, onde h necessidade de um algoritmo para essa tarefa.
O algoritmo que usaremos como ilustrao, um dos mais simples, que inspeciona
um grafo e termina quando encontra um ciclo ou quando no encontra nenhum. Ele usa
uma estrutura de dados L, que uma lista de ns. Durante a execuo do algoritmo, os
arcos sero marcados para indicar que j foram inspecionados.
Ele toma cada um dos ns, em ordem, como se fosse a raiz de uma rvore e faz uma
pesquisa profunda nela. Se alguma vez ele visitar um n onde j tenha estado anteriormente, ento ele encontrou um ciclo. Ao exaurir todos os arcos de um determinado n,
ele volta para o n anterior. Se esta propriedade valer para todos, o grafo inteiro estar
livre de ciclos, de forma que o sistema no apresenta condio de deadlock.
48
04 Deadlock
Comeando por R, inicializando L como uma lista vazia. Acrescentamos R lista, e

nos deslocamos para o nico n possvel, A, adicionando-o tambm a L, fazendo ento
L=[R,A]. De A vamos para S, formando L=[R,A,S]. Como no h nenhum arco saindo
dele, significa que chegamos a um beco sem sada, de maneira que somos forados a
voltar para A. Como A no tem nenhum arco desmarcado saindo dele, voltamos para R,
completando nossa inspeo a partir de R.
R
Agora recomeamos o algoritmo partindo de A, fazendo com que L volte a ser uma
lista vazia. Esta busca tambm vai terminar rapidamente, de modo que vamos recomear, s que agora partindo de B. Da continuamos seguindo os arcos que saem deste n,
at encontrarmos D, quando L=[B,T,E,V,G,U,D]. Neste instante, devemos fazer uma escolha aleatria entre S e T. Se escolhermos S, alcanamos um beco sem sada, e voltamos a D, de onde voltamos a T, caracterizando um ciclo, razo pela qual o algoritmo deve parar. Se escolhermos T, estaremos visitando este n pela segunda vez, e ao atualizarmos a lista para l=[B,T,E,V,G,U,D,T], identificamos um ciclo e o algoritmo pra.
4.8.2
DETECO DO DEADLOCK COM VRIOS RECURSOS DE CADA TIPO
Quando existem vrias cpias de alguns dos recursos, necessria a adoo de uma
abordagem diferente para a deteco de deadlocks. Usaremos um algoritmo baseado
numa matriz.
Vamos denominar E de vetor de recursos existentes. Ele fornece o nmero total de
instncias de cada recurso existente. Por exemplo, se a classe 1 refere-se unidade de
fita, E1 = 2, significa que h duas unidades de fitas no sistema
Seja D o vetor de recursos disponveis, com Di fornecendo o nmero de instncias do
recurso i atualmente disponveis. Se ambas as unidades de fita estiverem alocadas, D1 =
0.
Agora necessitamos de duas matrizes: C, a matriz de alocao corrente e R, a matriz
de requisies.
Como exemplo, vamos considerar a figura abaixo, onde existem trs processos e
quatro classes de recursos, as quais chamamos arbitrariamente de unidades de fita, plotters, impressoras e unidades de CD-ROM.
O processo 1 est de posse de uma impressora, o processo 2 de duas unidades de fita e de uma de CD-ROM, e o processo 3 tem um plotter e duas impressoras. Cada um
dos processos precisa de recursos adicionais, conforme mostra a matriz R.
Para rodar este algoritmo, procuramos por um processo cujas necessidades de recursos possam ser satisfeitas. As necessidades do processo 1 no podero ser atendidas,
pois no h unidades de CD ROM disponveis. O processo 2 tambm no ter suas requisies atendidas por falta de impressora livre. Felizmente, as requisies do processo 3
podero ser satisfeitas, de maneira que ele ser posto para rodar, ficando D = (0,0,0,0),
e ao final de seu processamento, devolver seus recursos ao pool de recursos disponveis, fazendo com que D = (2,2,2,0).
49
04 Deadlock
Neste momento o processo 2 pode rodar, ficando D=(1,2,1,0), e ao devolver seus recursos far D=(4,2,2,1). Nesta situao o ltimo processo poder rodar, fazendo com
que no haja deadlock no sistema.
Se acontecer que algum processo necessite de um recurso a mais do que os disponveis, todo o sistema estar em deadlock.
Recursos existentes
a
fit
as
de
s
or
e
s
s
de
d
s
r
re
da
da otte
p
i
i
Un
Un
Pl
Im
M
RO
D
C
de
E = (4 2 3 1)
Matriz de alocao corrente
0 0 1 0
C= 2 0 0 1
0 1 2 0
Recursos disponveis
M
RO
D
a
C
fit
s
de
de
ra
s
o
e
de
ss
rs
ad
re
te
da
id
ot mp
ni
Un
U
Pl
I
D = (2 1 0 0)
Matriz de requisies
2 0 0 1
R= 1 0 1 0
2 1 0 0
Bem, agora j sabemos como detectar deadlocks, mas, quando devemos procurar por
eles? Podemos fazer isso a cada vez que um novo recurso for solicitado, mas custar
muito caro, apesar de detectarmos o deadlock o mais cedo possvel. Uma estratgia alternativa a de verificar a cada k minutos, ou quando o nvel de utilizao do processador atingir um determinado nvel muito baixo.
4.9
RECUPERAO DE DEADLOCKS
J vimos como detectar deadlocks, e agora, como recuperar o sistema?
4.9.1 RECUPERAO ATRAVS DA PREEMPO

Algumas vezes possvel tomar temporariamente um recurso de seu atual dono e
entreg-lo a outro processo. Outras vezes necessria a interveno manual. A capacidade de tomar um recurso de um processo, deixar que outro processo o utilize e devolv-lo ao processo original, sem que este tenha conhecimento do que est acontecendo,
depende muito do recurso.
Por exemplo, para tomar uma impressora de seu proprietrio atual, o operador deve
recolher as folhas impressas e coloc-las numa pilha. O processo pode ento ser suspenso. A impressora pode ser entregue a um outro processo. Quando este terminar, a pilha
de folhas impressas do processo anterior deve ser colocada de novo na bandeja de sada,
sendo o processo reiniciado.
Agora, interromper a gravao em uma unidade de CD-ROM pode se tornar muito
complicado.
4.9.2 RECUPERAO ATRAVS DE VOLTA AO PASSADO
Consiste em escrever histricos dos processos em andamento, contendo todas as informaes necessrias para que em caso de deadlock, o sistema possa voltar atrs e
alocar um ou outro recurso diferente para evitar o impasse novamente.
4.9.3 RECUPERAO ATRAVS DE ELIMINAO DE PROCESSOS
a maneira mais rude, mas tambm a mais simples de se eliminar a situao de deadlock.
Por exemplo, um processo pode estar de posse de uma impressora e estar precisando
de um plotter, e outro processo pode estar precisando da impressora, estando com o
plotter. Esto em deadlock. A eliminao de um outro processo que possui tanto a impressora quanto o plotter pode solucionar esse impasse.
50
04 Deadlock
O ideal que seja eliminado um processo que possa rodar de novo desde o incio sem
produzir nenhum efeito negativo ao sistema. Por exemplo, uma compilao pode sempre
recomear, pois tudo o que ela faz ler um arquivo-fonte e produzir um arquivo-objeto.
Sua eliminao far com que a primeira rodada no tenha influncia alguma na segunda.
Por outro lado, um processo que atualiza uma base de dados no pode ser eliminado e
voltar a rodar uma segunda vez em condies seguras.
4.10
TENTATIVAS DE EVITAR O DEADLOCK
Se o sistema for capaz de decidir se a alocao de determinado recurso ou no segura, e s fazer a alocao quando ela for segura, teremos como evitar deadlocks.
4.10.1 ESTADOS SEGUROS E INSEGUROS
Para escrever algoritmos que evitem deadlocks, precisamos usar informaes como
os Recursos existentes e os disponveis, bem como as Matrizes de alocao corrente e a
de Requisies.
Um estado dito seguro se no provocar deadlock, e houver uma maneira de satisfazer todas as requisies pendentes partindo dos processos em execuo.
Vamos exemplificar usando apenas um recurso. Na figura, temos um estado no qual
A tem trs instncias de um recurso, mas pode eventualmente precisar de nove. No momento, B tem duas e pode precisar ao todo de quatro. De maneira similar, C tem duas,
mas pode precisar adicionalmente de mais cinco. Existe um total de 10 instncias deste
recurso, estando sete alocadas e trs livres.
Possui Mximo
Possui Mximo
Possui Mximo
Possui Mximo
Possui Mximo
Livre: 3
Livre: 1
Livre: 5
Livre: 0
Livre: 7
(a)
(b)
(c)
(d)
(e)
O estado mostrado primeiramente (Fig. a) seguro, pois existe uma seqncia de alocaes que permitem que todos os processos venham a terminar seus processamentos.
Para tanto, o escalonador pode rodar B exclusivamente, at que ele precise de mais duas
instncias do recurso, levando ao estado da Fig. b. Quando B termina, chegamos ao estado da Fig. c. Ento o escalonador pode rodar C, chegando ao estado da Fig. d. Quando
C termina, atingimos o estado ilustrado na Fig. 3E. Agora A pode obter as seis instncias
adicionais do recurso, necessrias a que ele termine sua execuo. Ento o estado inicial
considerado seguro, pois o sistema, atravs de um escalonamento cuidadoso, pode
evitar a ocorrncia de deadlocks.
Se por acaso, A requisita e ganha um outro recurso na Fig. b. Podemos encontrar
uma seqncia de alocaes que funcione garantidamente. No. Podemos, ento, concluir que a requisio de A por um recurso adicional no deveria ser atendida naquele momento.
Um estado inseguro no leva necessariamente a um deadlock. A diferena entre um
estado seguro e um inseguro que, de um estado seguro, o sistema pode garantir que
todos os processos vo terminar, enquanto que a partir de um inseguro esta garantia
no pode ser dada.
4.10.2 ALGORITMO DO BANQUEIRO PARA UM NICO TIPO DE RECURSO
Dijkstra (1965) idealizou um algoritmo de escalonamento que pode evitar a ocorrncia de deadlocks, conhecido como algoritmo do banqueiro. Ele baseia-se nas mesmas
premissas adotadas por um banqueiro de um pequeno banco para garantir ou no crdito
a seus correntistas.
Usando a mesma analogia mostrada no item acima, considerando que os clientes so
os processos e as unidades de crdito representam os recursos, e o banqueiro faz o papel do sistema operacional.
51
04 Deadlock
Na figura a seguir, temos trs cenrios de alocao de recursos: (a) Seguro. (b) Seguro. (c) Inseguro.
Possui Mximo
Possui Mximo
Possui Mximo
Livre: 10
Livre: 2
Livre: 1
(a)
(b)
(c)
O mesmo algoritmo pode ser generalizado para tratar com diversos tipos de recursos,
utilizando matrizes.
Todos os livros srios de Sistemas Operacionais descrevem tal algoritmo com detalhes. Apesar de teoricamente maravilhoso, este algoritmo na prtica intil, pois os processos quase nunca sabem com antecedncia a quantidade de recursos de que vo precisar. Alm do mais, tal quantidade no fixa e os recursos que estavam disponveis em
determinado momento podem "sumir" repentinamente (uma unidade de fita pode quebrar).
4.11
PREVENO DE DEADLOCKS
Se pudermos garantir que pelo menos uma das quatro condies necessrias para
que um deadlock ocorra nunca ser satisfeita, poderemos garantir que ser estruturalmente impossvel a ocorrncia de deadlocks (Havender, 1968).
4.11.1 ATACANDO O PROBLEMA DA EXCLUSO MTUA
Se no houver possibilidade de nenhum recurso ser entregue exclusivamente a um
nico processo, nunca teremos configurada uma situao de deadlock. No entanto, est
claro tambm que dar permisso a dois processos para acessar a mesma impressora ao
mesmo tempo vai levar a uma situao catica.
Evitar ento, entregar um recurso, quando ele no for absolutamente necessrio, e
tentar estar certo de que o mnimo possvel de processos est precisando de recursos.
4.11.2 ATACANDO O PROBLEMA DA POSSE E DA ESPERA
Se pudermos impedir processos de manter a posse de recursos enquanto esperam
por outros recursos, poderemos eliminar os deadlocks. Uma forma de se alcanar este
objetivo exigir que todos os processos requisitem todos os recursos de que precisam,
antes de iniciar a execuo.
Um problema imediato que pode ocorrer com esta abordagem o fato de muitos processos no conhecerem com antecedncia quantos e quais os recursos necessrios sua
execuo.
4.11.3 ATACANDO O PROBLEMA DA CONDIO DE NO-PREEMPO
A anlise da terceira condio (no-preempo) revela-se ainda menos promissora do
que a segunda. Se um processo tem alocado uma impressora e est no meio da impresso de seus resultados, tomar fora a impressora porque um plotter de que ele vai precisar no est disponvel uma grande besteira.
4.11.4 ATACANDO O PROBLEMA DA ESPERA CIRCULAR
Resta-nos somente uma condio para tentar resolver a questo dos deadlocks. A
condio de espera circular pode ser eliminada de diversas maneiras. Uma delas simplesmente seguindo a regra de que um processo s est autorizado a usar apenas um
recurso por vez. Se ele precisar de um segundo recurso, deve liberar o primeiro.
Outra forma utilizar uma numerao global para todos os recursos. Agora a regra :
processos podem solicitar recursos sempre que necessrio, mas todas as solicitaes
precisam ser feitas em ordem numrica.
52
04 Deadlock
Resumindo:
4.12
CONDIO
ABORDAGEM
Excluso Mtua
Alocar todos os recursos usando spool
Posse e Espera
Requisitar todos os recursos inicialmente
No-Preempo
Tomar recursos de volta
Espera Circular
Ordenar numericamente os recursos
EXERCCIOS
46) Quando que um processo est em deadlock?

47) Descreva o deadlock em sistemas de spooling.
48) Dentro do contexto de deadlock, o que a espera circular?
49) Um sistema operacional pode ser visto de forma mais ampla como um gerenciador de recursos. Ele responsvel pela alocao de vrios recursos de diversos tipos. O que seriam recursos nesse contexto?
50) Diferencie recursos preemptveis e no-preemptveis.
51) Em sistemas onde processos ficam esperando pela alocao de recursos ou pelas
decises de escalonamento, possvel que ocorra adiamento indefinido (ou starvation) e conseqentemente um deadlock. O que vem a ser isso?
52) Existem quatro condies necessrias que devem estar presentes para que possa
ocorrer deadlock. Se uma delas estiver ausente, no h a menor possibilidade de
ocorrer uma situao de impasse. Quais so elas? Cite e explique cada uma.
53) De acordo com Havender, 1968, se pudermos garantir que pelo menos uma das
quatro condies necessrias para que um deadlock ocorra (excluso mtua, posse e espera, no-preempo e espera circular) nunca sejam satisfeitas, poderemos garantir que ser estruturalmente impossvel a ocorrncia dos mesmos. Fale
como isso poderia ser feito considerando o contexto descrito.
54) Existem trs formas de recuperar o sistema depois da deteco de um deadlock:
recuperao atravs da preempo, atravs da volta ao passado e atravs da eliminao de processos. Fale sobre cada uma delas.
55) Considerando a seguinte matriz de alocao de recursos, onde p o nmero de
recursos que determinado processo possui, m o nmero mximo de recursos
que esse processo pode requerer e L o nmero de recursos Livres no sistema
computacional diga se o estado seguro ou no e demonstre isso atravs das
matrizes. Considere que o sistema computacional tenha 10 recursos disponveis:
p
A 1
B 1
C 2
D 4
L= 2
m
7
5
4
9
53
04 Deadlock
56) Quando existem vrias cpias de alguns recursos em um sistema computacional,

necessrio a adoo de uma abordagem que utiliza vetores e matrizes para a
deteco de deadlocks. Supondo que em um sistema computacional, existam trs
processos e quatro classes de recursos: 5 unidades de fita, 3 plotters,4 impressoras e 2 unidades de CD-ROM. Considerando E o vetor de recursos existentes, D o
vetor de recursos disponveis, C a matriz de alocao corrente dos processos e R a
matriz de requisies, demonstre, atravs da alocao cuidadosa de recursos, se
existe ou no a ocorrncia de deadlock. Lembre-se que preciso inicialmente,
preencher o vetor D.
E = (5 3 4 2)
C=
2
1
0
D=(
1
0
2
0
2
1
1
0
0
)
R=
3
1
4
0
0
1
2
0
1
1
1
2
57) Quando existem vrias cpias de vrios recursos em um sistema computacional,

necessria a adoo de uma abordagem que utiliza vetores e matrizes para a deteco de deadlocks. Considerando E o vetor de recursos existentes, D o vetor de
recursos disponveis, C a matriz de alocao corrente dos processos e R a matriz
de requisies, responda:
a) Se existir cinco processos sendo executados, quantas linhas tero as matrizes
C e R?
b) Em que situao o vetor E igual ao vetor D?
c) O que est acontecendo se a primeira linha da matriz C e a primeira linha da
matriz R estiverem zeradas?
d) Respondendo em funo dos valores das matrizes e dos vetores, em que situao o sistema detectaria um deadlock?
-x-
54
05 Gerncia do Processador
Gerncia do Processador
"Mesmo os cus, os planetas e este centro observam grau, prioridade e lugar

(William Shakespeare)
5.1
INTRODUO
Nos Sistemas Operacionais Multiprogramados, sempre que o processador fica sem

utilizao, ocorre o acionamento do Gerente de Processos ou Escalonador de Processos
que tem como principal funo selecionar o processo que deve ocupar o processador.
Dessa maneira, o trabalho do Escalonador de Processos pode permitir que o computador
se torne mais produtivo atravs da otimizao do uso do processador.
Assim sendo, o escalonamento de processos constitui a base dos Sistemas Operacionais Multiprogramadados e, portanto, faz-se importante conhecer suas principais caractersticas, bem como os algoritmos de escalonamento mais utilizados.
5.2
FUNES BSICAS
A poltica de escalonamento de um
Sistema Operacional possui diversas funes bsicas, como a de manter o processador ocupado a maior parte do tempo, balancear o uso da CPU entre processos, privilegiar a execuo de aplicaes
crticas, maximizar o throughput do sistema e oferecer tempos de resposta razoveis para usurios interativos. Cada
Sistema Operacional possui sua poltica
de escalonamento adequada ao seu propsito e s suas caractersticas. Sistemas
de tempo compartilhado, por exemplo,
possuem requisitos de escalonamento
distintos dos sistemas de tempo real.
A rotina do Sistema Operacional que

tem como principal funo implementar os critrios da poltica de escalonamento chamada escalonador (scheduler). Em um sistema multiprogramvel, o escalonador fundamental, pois todo o compartilhamento do processador dependente dessa rotina.
Outra rotina importante na gerncia do processador conhecida como despachante
(dispatcher), responsvel pela troca de contexto dos processos aps o escalonador determinar qual processo deve fazer uso do processador. O perodo de tempo gasto na
substituio de um processo em execuo por outro denominado latncia do despachante.
5.3
CRITRIOS DE ESCALONAMENTO
As caractersticas de cada Sistema Operacional determinam quais so os principais

aspectos para a implementao de uma poltica de escalonamento adequada. Por exemplo, sistemas de tempo compartilhado exigem que o escalonamento trate todos os processos de forma igual, evitando assim, a ocorrncia de starvation. J em sistemas de
tempo real, o escalonamento deve priorizar a execuo de processos crticos em detrimento da execuo de outros processos.
a) Utilizao do processador: o processador deve permanecer ocupado o mximo
de tempo possvel. Deve ser frisado que quando o sistema computacional trabalha com
uma taxa de utilizao do processador por volta de 30%, ele considerado um sistema
55
com carga baixa de processamento. Porm, quando o mesmo trabalha com uma taxa na
faixa de 90%, ele considerado um sistema computacional bastante carregado;
b) Throughput ou vazo: representa o nmero mximo de processos executados
em um determinado intervalo de tempo o nmero de processos que so executados em
uma determinada frao de tempo, geralmente uma hora, deve ser elevado ao mximo.
c) Tempo de processador ou Tempo de CPU: o tempo que o processo leva no
estado de execuo durante seu processamento. As polticas de escalonamento no influenciam o tempo de processador de um processo, sendo este tempo funo apenas do
cdigo da aplicao e da entrada de dados.
c) Tempo de espera: o tempo total que um processo permanece na fila de pronto
durante seu processamento, aguardando para ser executado. A reduo do tempo de
espera dos processos desejada pela maioria das polticas de escalonamento.
d) Tempo de retorno (turnaround): o tempo que um processo leva desde sua
criao at o seu trmino, considerando-se o tempo gasto na alocao de memria, na
fila de processos prontos, nas operaes de entrada/sada e, ainda, o seu tempo de processamento. Deve ser o menor possvel;
e) Tempo de resposta: o tempo decorrido entre uma requisio ao sistema ou
aplicao e o instante em que a resposta exibida. Em sistemas interativos, podemos
entender como o tempo decorrido entre a ltima tecla digitada pelo usurio e o incio da
exibio do resultado no monitor. Em geral, o tempo de resposta no limitado pela capacidade de processamento do sistema computacional, mas pela velocidade dos dispositivos de E/S.
De uma maneira geral, qualquer poltica de escalonamento busca otimizar a utilizao
do processador e a vazo, enquanto tenta diminuir os tempos de retorno, espera e resposta. Apesar disso, as funes que uma poltica de escalonamento deve possuir so
muitas vezes conflitantes. Dependendo do tipo de Sistema Operacional, um critrio pode
ter maior importncia do que outros, como nos sistemas interativos onde o tempo de
resposta tem grande relevncia.
5.4
ESTRATGIAS DE ESCALONAMENTO
As estratgias de escalonamento de processos so definidas em funo da atividade

de preempo, a qual consiste na capacidade de permitir a interrupo da execuo de
um processo para executar um outro, sem prejuzo lgica de execuo de ambos.
As estratgias de escalonamento so duas:
a) Escalonamento no-preemptivo: com esta estratgia um processo que entra no
processador roda at terminar, sem jamais ser interrompido. Este foi o primeiro tipo de
escalonamento desenvolvido e foi utilizado nos SOs de processamento em batch;
b) Escalonamento preemptivo: esta estratgia baseada na atividade de preempo, ou seja, permite a suspenso temporria da execuo de um processo para outro
rodar, sem prejuzo lgico de execuo a ambos. A maioria dos SOs da atualidade utiliza
esta estratgia de escalonamento.
5.5
ESCALONAMENTO FIRST COME FIRST SERVED (FCFS) ou FIFO
Neste algoritmo os processos so organizados em uma fila por ordem de chegada e

toda vez que for necessrio escalonar um processo para rodar, o Gerente de Processos
seleciona o primeiro da fila. Os processos que forem chegando para serem executados
so colocados no final da fila, conforme ilustrado pela Figura anterior.
A prxima Figura apresenta um exemplo de utilizao do algoritmo FIFO. Nela possvel observar a existncia de trs processos a serem executados, obedecendo ordem
de chegada de cada um, e, ainda, os seus respectivos tempos estimados e finais de execuo.
56
A principal vantagem de utilizao do FIFO a sua simplicidade de implementao,

haja visto que o Gerente de Processos necessita apenas manter uma fila de processos e
escalonar para rodar um aps o outro. Contudo, o algoritmo em questo apresenta algumas deficincias e a mais importante delas a impossibilidade de se saber ao certo
qual o tempo de turnaround de um processo. Um outro problema existente que o
FIFO um algoritmo no preemptivo e, portanto, a sua aplicao em sistemas computacionais que possuam muitos processos de usurios interativos, como os da atualidade,
considerada ineficiente.
5.6
ESCALONAMENTO MENOR JOB PRIMEIRO ou SJF (Shortest Job First)
O algoritmo de escalonamento do menor trabalho primeiro (Shortest Job First - SJF)

possui uma poltica que estabelece, conforme evidenciado na Figura abaixo, que o processo com menor tempo estimado de execuo aquele que deve rodar primeiro. Assim
sendo, este algoritmo parte do pressuposto que o tempo de execuo de cada processo
conhecido.
Na sua concepo inicial, o escalonamento SJF no preemptivo. Sua vantagem sobre o escalonamento FIFO est na reduo do tempo mdio de retorno dos processos,
porm no SJF possvel haver starvation para processos com tempo de processador muito longo ou do tipo CPU-bound.
A principal vantagem do algoritmo em questo que ele privilegia processos de usurios interativos. Assim, estes usurios podem, por exemplo, conseguir obter respostas
rpidas aos seus comandos.
J sua desvantagem principal que, normalmente, no se conhece, a priori, o tempo
que um processo ir ocupar o processador e este fato dificulta a implementao do SJF
em sua forma original.
5.7
ESCALONAMENTO PRXIMA TAXA DE RESPOSTA MAIS ALTA ou HRRN
Esse algoritmo corrige algumas das deficincias do SJF, particularmente o adiamento

indefinido contra processos mais longos e o favoritismo excessivo em relao a processos
curtos. O HRRN (Highest Response Ratio Next) usa uma disciplina de escalonamento no
preemptiva na qual a prioridade de cada processo uma funo no apenas do seu tempo de execuo, mas tambm do seu tempo de espera. HRRN calcula prioridades dinmicas segundo a frmula apresentada posteriormente.
Como o Tempo de CPU aparece no denominador, processos mais curtos recebem preferncia. Entretanto, porque o Tempo de Espera aparece no numerador, processos mais
57
longos que esto espera tambm recebero tratamento favorvel. Quanto maior a razo, maior a prioridade.
Tempo de Espera
Prioridade
Tempo de CPU
=
Tempo de CPU
5.8 ESCALONAMENTO MENOR TEMPO REMANESCENTE ou SRT

Uma implementao do escalonamento SJF com preempo conhecida escalonamento de menor tempo remanescente ou SRT (Shortest Remaining Time). Nessa
poltica, toda vez que um processo no estado de pronto tem um tempo de processador
estimado menor do que o processo em execuo, o Sistema Operacional realiza uma
preempo, substituindo-o pelo novo processo.
O algoritmo deve manter informaes sobre o tempo que est sendo gasto no servio
do processo em execuo e realizar preempes ocasionais. Processos que acabaram de
chegar cujos tempos de execuo so curtos executam quase imediatamente. Todavia, o
tempo mdio de espera e a varincia dos tempos de espera dos processos mais longos
so ainda maiores do que no SJF.
5.9
ESCALONAMENTO CIRCULAR ou ROUND ROBIN (RR)
um escalonamento do tipo preemptivo, projetado especialmente para sistemas de

tempo compartilhado. Neste algoritmo, a cada processo atribui-se um intervalo de tempo, chamado de fatia de tempo (time-slice) ou quantum, durante o qual ele poder usar
o processador.
No escalonamento circular, toda vez que um processo escalonado para execuo,
uma nova fatia de tempo concedida. Caso a fatia de tempo expire, o Sistema Operacional interrompe o processo em execuo, salva seu contexto e direciona-o para o final da
fila de pronto. Este mecanismo conhecido como preempo por tempo.
Objetivando facilitar a compreenso do funcionamento do Round-Robin, a Figura a
seguir apresenta um exemplo de utilizao do mesmo.
58
O Round-Robin apresenta como vantagens principais a sua simplicidade de implementao e, ainda, o fato de no permitir que processos monopolizem o processador. J
a sua desvantagem mais evidente que ele no faz distino entre a prioridade dos processos. Assim sendo, um processo de tempo-real vai competir pelo processador em condies de igualdade com um processo que seja um jogo de entretenimento, por exemplo.
Outra desvantagem a dificuldade de se definir o tamanho do quantum, pois se este for
muito pequeno, ocorrero sucessivas trocas de contexto, baixando a eficincia do sistema operacional. Por outro lado, se o quantum for muito grande, os usurios interativos
ficaro insatisfeitos.
Obs.: O valor do quantum depende do projeto de cada sistema operacional e, geralmente, ele se encontra entre 10 e 100 milissegundos.
5.10
ESCALONAMENTO POR PRIORIDADES
O algoritmo em questo preemptivo e considera fatores externos para escolher qual

processo ir rodar em um dado momento. Assim, cada processo deve possuir uma prioridade de execuo a fim de que e o Gerente de Processos defina qual processo ir rodar.
Normalmente, o processo com maior prioridade aquele que deve ser executado primeiro. Contudo, existindo processos com prioridades iguais, os mesmos devem ser agrupados em classes e o Round-Robin , geralmente, aplicado nas mesmas para determinar
qual processo de uma classe ir rodar.
A prxima Figura apresenta um exemplo de uso do algoritmo de escalonamento com
prioridade.
O escalonamento com prioridades apresenta como principal ponto positivo o fato de

permitir a diferenciao dos processos segundo critrios de importncia. Este fato tornase bastante relevante quando se considera o projeto de um Sistema Operacional de
Tempo Real, por exemplo.
A desvantagem de utilizao do algoritmo em estudo a possibilidade de os processos de baixa prioridade nunca serem escalonados, caracterizando uma situao conhecida como starvation (adiamento indefinido). Contudo, esta desvantagem pode ser superada atravs do uso da tcnica de aging (envelhecimento), a qual consiste em incrementar gradativamente a prioridade dos processos que ficam muito tempo sem rodar.
5.11
ESCALONAMENTO POR MLTIPLAS FILAS
Este algoritmo preemptivo, como o prprio nome sugere, considera a existncia de

vrias filas de processos no estado de pronto, cada uma delas com sua prioridade de
execuo e seu algoritmo de escalonamento. Os processos so associados s filas em
59
funo de caractersticas particulares como, por exemplo, tipo de processo, rea de memria ocupada etc.
A principal vantagem deste algoritmo que ele permite que se utilize um algoritmo
de escalonamento diferente para cada fila. Assim, possvel que uma fila utilize o FIFO,
enquanto outra usa o Round-Robin, por exemplo.
Como desvantagem deste algoritmo tem-se o fato de que sua implementao mais
complexa que a dos outros j estudados, pois cada uma das filas de prioridade pode utilizar um algoritmo de escalonamento diferente.
5.12
ESCALONAMENTO DE TEMPO REAL
Um objetivo primrio dos algoritmos apresentados anteriormente, era garantir alta utilizao de recursos. Processos que devem executar periodicamente (como uma vez por
minuto) requerem algoritmos de escalonamento diferentes. Por exemplo, os tempos de
espera ilimitados no SJF podem ser catastrficos para um processo que verifique a temperatura de um reator nuclear. Similarmente, um sistema que use SRT para escalonar
um processo que reproduza um videoclipe produziria uma reproduo entrecortada. Escalonamento de Tempo Real atende s necessidades de processos que devem produzir sadas corretas em determinado momento (ou seja, que tem uma restrio de tempo). Um processo de tempo real pode dividir suas instrues em tarefas isoladas, cada
qual deve concluir em determinado prazo. Outros processos de tempo real podem executar certa tarefa periodicamente, como atualizar as localizaes de avies em um sistema
de controle areo. Escalonadores de tempo real devem garantir que as restries de
tempo sejam cumpridas.
Estratgias de escalonamento de tempo real so classificadas conforme quo bem
cumprem os prazos de um processo. Escalonamento de tempo real no crtico garante que processos de tempo real sejam despachados antes de outros processos do sistema, mas no garante qual processo, se que algum deles, cumprir suas restries de
tempo.
O Escalonamento de tempo real crtico garante que as restries de prazo de um
processo sejam sempre atendidas. Cada tarefa especificada por um processo de tempo
60
real crtico deve concluir antes de seu prazo final; caso isso no acontea, os resultados
podero ser catastrficos, entre eles trabalho invlido, falha de sistema ou at danos aos
usurios do sistema. Sistemas de tempo real crtico podem conter processos peridicos que realizam suas computaes em intervalos de tempo regulares (por exemplo,
coletar dados de controle de trfego areo a cada segundo) e processos assncronos
que executam em respostas a eventos (por exemplo, responder a altas temperaturas no
ncleo de uma usina nuclear).
5.12.1 ESCALONAMENTO DE TEMPO REAL ESTTICOS
Esses algoritmos no ajustam a prioridade do processo ao longo do tempo. Porque as
prioridades so calculadas somente uma vez, esses algoritmos tendem a ser simples e a
incorrer em pouca sobrecarga. Eles so limitados, pois no podem se ajustar ao comportamento varivel do processo e dependem de os recursos estarem funcionando e disposio para garantir que sejam cumpridas as restries de tempo.
Sistemas de tempo real crticos tendem a usar algoritmos de escalonamento estticos, porque incorrem em baixa sobrecarga e relativamente fcil de provar que as restries de prazo de cada processo sejam atendidas. O algoritmo de escalonamento por
taxa monotnica ou RM (Rate Monotonic), por exemplo, um algoritmo de alternncia
circular, preemptivo, por prioridade, que eleva a prioridade de um processo linearmente
(monotonicamente) com a freqncia (taxa) com a qual ele deve executar. Esse algoritmo de escalonamento esttico favorece processos peridicos que executam frequentemente. O algoritmo por taxa monotnica com prazo pode ser usado quando um processo peridico especifica um prazo que no seja igual ao seu perodo.
5.12.2 ESCALONAMENTO DE TEMPO REAL DINMICOS
Escalonam processos ajustando suas prioridades durante a execuo, o que pode
causar sobrecarga significativa. Alguns algoritmos tentam minimizar a sobrecarga de
escalonamento designando prioridades estticas a alguns processos, e prioridades dinmicas a outros.
O algoritmo de escalonamento por prazo mais curto primeiro (Earliest Deadline
First EDF) do tipo preemptivo que despacha primeiro o processo com prazo mais curto. Se o processo que chegar tiver um prazo mais curto do que o processo em execuo,
o sistema provocar a preempo do processo em execuo e despachar o que acabou
de chegar. O objetivo minimizar o rendimento cumprindo os prazos do maior nmero
de processos por unidade de tempo (anlogo ao SRT) e minimizando o tempo mdio de
espera (o que evita que processos curtos percam seus prazos enquanto processos longos
executam). Estudos provam que, se um sistema fornecer preempo por hardware (temporizadores de interrupo) e os processos de tempo real que esto em escalonamento
no forem interdependentes, o EDF minimiza a quantidade de tempo pelo qual o projeto
mais atrasado perde seu prazo. Todavia, muitos sistemas de tempo real no fornecem
preempo por hardware, portanto outros algoritmos devem ser empregados.
5.13
EXERCCIOS
58) O que poltica de escalonamento de um Sistema Operacional?

59) Qual a funo do escalonador e do despachante?
60) Quais os principais critrios utilizados em uma poltica de escalonamento?
61) Diferencie os tempos de processador, espera, retorno e resposta.
62) Qual a diferena entre escalonamento preemptivo e no-preemptivo?
63) Qual a diferena entre os escalonamentos FIFO e RR?
64) O que fatia de tempo?
65) Descreva o escalonamento SJF e o escalonamento por prioridades.
61
66) Considere um Sistema Operacional com escalonamento por prioridades onde a

avaliao do escalonamento realizada em um intervalo mnimo de 5 ms. Neste
sistema, os processos A e B competem por uma nica CPU. Desprezando os tempos de processamento relativo s funes do Sistema Operacional, a tabela a seguir fornece os estados dos processos A e B ao longo do tempo, medido em intervalos de 5 ms (E=execuo, P=pronto e B=bloqueado). O processo A tem menor
prioridade que o processo B
procA
procB
00-04
P
E
05-09
P
E
10-14
E
B
15-19
E
B
20-24
E
P
25-29
P
E
30-34
P
E
35-39
P
E
40-44
E
B
45-49
B
B
procA
procB
50-54
P
B
55-59
E
P
60-64
P
E
65-69
P
E
70-74
E
B
75-79
E
B
80-84
B
P
85-89
B
E
90-94
P
E
95-99
E
-
a) Em que tempos A sofre preempo?

b) Em que tempos B sofre preempo?
c) Refaa a tabela anterior supondo que o processo A mais prioritrio que o processo B.
67) Tomando como base os dados da tabela apresentada a seguir, ignorando a perda
de tempo causada pelas trocas de contexto e considerando que nenhum processo realiza
entrada/sada, informe o tempo que cada um dos processos efetivamente levar para
executar se os seguintes algoritmos de escalonamento forem utilizados: a) Round-Robin
com quantum de 2 minutos; b) SJF; c) Escalonamento com Prioridade.
Processo
A
B
C
D
E
Tempo CPU
1 min
7 min
5 min
4 min
3 min
Prioridade
4
2
3
4
1
68) Explique o funcionamento da tcnica de envelhecimento (aging) e quando ela pode ser utilizada.
69) Verificamos uma situao na qual um processo A, de alta prioridade, e um processo B de baixa prioridade interagem de forma a levar A a um loop eterno. Tal situao persistiria se utilizssemos o escalonamento round robin em vez do escalonamento com prioridade?
70) Os escalonadores round robin normalmente mantm uma fila com todos os processos prontos, com cada processo aparecendo uma vez nesta fila. O que pode
acontecer se determinado processo aparecer duas vezes na fila de prontos? Voc
pode encontrar alguma razo para que isto seja permitido?
71) Que tipos de critrios devem ser utilizados no momento da definio da fatia de
tempo a ser empregada em um determinado sistema?
72) Em um sistema operacional, o escalonador de curto prazo utiliza duas filas. A fila
"A" contm os processos do pessoal do CPD e a fila "B" contm os processos dos
alunos. O algoritmo entre filas fatia de tempo. De cada 11 unidades de tempo
de processador, 7 so fornecidas para os processos da fila "A", e 4 para os processos da fila "B". O tempo de cada fila dividido entre os processos tambm por
fatias de tempo, com fatias de 2 unidades para todos. A tabela abaixo mostra o
contedo das duas filas no instante zero. Considere que est iniciando um ciclo de
62
11 unidades, e agora a fila "A" vai receber as suas 7 unidades de tempo. Mostre a
sequncia de execuo dos processos, com os momentos em que feita a troca.
OBS: Se terminar a fatia de tempo da fila "X" no meio da fatia de tempo de um
dos processos, o processador passa para a outra fila. Entretanto, esse processo
permanece como primeiro da fila "X", at que toda sua fatia de tempo seja consumida.
Fila Processo Tempo de CPU
A
P1
P2
P3
P4
P5
P6
73) Quatro programas devem ser executados em um computador. Todos os programas so compostos por 2 ciclos de processador e 2 ciclos de E/S. A entrada e sada de todos os programas feita sobre a mesma unidade de disco. Os tempos para cada ciclo de cada programas so mostrados na tabela. Construa um diagrama
de tempo mostrando qual programa est ocupando o processador e o disco a cada
momento, at que os 4 programas terminem. Suponha que o algoritmo de escalonamento utilizado seja fatia de tempo, com fatias de 4 unidades. Qual a taxa de
ocupao do processador e do disco?
Programa Processador Disco Processador Disco
P1
10
12
P2
12
P3
10
P4
14
10
74) Um algoritmo de escalonamento de CPU determina a ordem para execuo dos

seus processos escalonados. Considerando n processos a serem escalonados em
um processador, quantos escalonamentos diferentes so possveis? Apresente
uma frmula em termos de n.
75) Considere um Sistema Operacional que implemente escalonamento circular com
quantum igual a 10 ut. Em um determinado instante de tempo, existem apenas
trs processos (P1, P2 e P3) na fila de pronto, e o tempo de CPU de cada processo
18, 4 e 13 ut, respectivamente. Qual o estado de cada processo no instante de
tempo T, considerando a execuo dos processos P1, P2 e P3, nesta ordem, e que
nenhuma operao de E/S realizada?
a) T = 8 ut
b) T = 11 ut
c) T = 33 ut
76) Considere um Sistema Operacional que implemente escalonamento circular com
quantum igual a 10 ut. Em um determinado instante de tempo, existem apenas
trs processos (P1, P2 e P3) na fila de pronto, e o tempo de CPU de cada processo
14, 4 e 12 ut, respectivamente. Qual o estado de cada processo no instante de
tempo T, considerando a execuo dos processos P1, P2 e P3, nesta ordem, e que
apenas o processo P1 realiza operaes de E/S? Cada operao de E/S executada aps 5 ut e consome 10 ut.
a) T = 8 ut
b)T = 18 ut
c)T = 28 ut
63
77) Considere as seguintes tabelas. Elabore o grfico de Gantt para os algoritmos SJF
preemptivo, RR e prioridade. Calcule os tempos mdios de retorno, resposta e espera para cada uma das situaes. Considere uma fatia de tempo de 2 instantes.
PROC
A
B
C
D
E
Tcheg
12
5
2
13
14
Prior
4
3
1
2
5
Tcpu
7
3
2
4
1
Tresp
Tret
Tesp
PROC
A
B
C
D
E
F
Tcheg
8
2
15
2
3
11
Prior
5
1
2
4
3
6
Tcpu
7
3
2
4
1
5
Tresp
Tret
Tesp
PROC
A
B
C
D
E
F
G
Tcheg
12
5
2
13
8
6
1
Prior
1
4
3
5
0
6
2
Tcpu
5
9
4
3
6
1
7
Tresp
Tret
Tesp
78) Qual a vantagem em ter diferentes tamanhos de quantum em diferentes nveis de

um sistema mltiplas filas?
79) Quando o algoritmo RR se degenera para o FIFO?
80) Quando o algoritmo MLF se degenera para o EDF? Isso pode ocorrer?
81) Com o escalonamento HRRN, processos curtos so sempre escalonados antes dos
longos? Justifique sua resposta.
82) Qual a vantagem em ter diferentes tamanhos de quantum em diferentes nveis de
um sistema mltiplas filas?
83) Considere as seguintes tabelas. Elabore o grfico de Gantt para o algoritmo Mltipla Fila. Calcule os tempos mdios de retorno, resposta e espera para cada uma
das situaes.
a) Algoritmos: Fila 1 FCFS; Fila 2 Prioridade; Fila 3 RR, com quantum = 3
Algoritmo entre filas: RR com quantum = 4
PROC
FILA
Tcheg
Tcpu
Prior
Tret
Tresp
Tesp
A
1
0
10
1
B
2
5
8
1
C
1
0
7
1
D
3
9
4
2
E
2
0
3
0
F
3
8
9
3
G
3
1
7
4
H
2
10
5
3
b) Algoritmos: Fila 1 SJF; Fila 2 FIFO; Fila 3 RR, com quantum = 2
64
Algoritmo entre filas: prioridade. Fila 1 = 2, Fila 2 = 3 e Fila 3 = 1

PROC
A
B
C
D
E
F
FILA
1
2
1
3
1
3
Tcheg
5
4
8
7
1
0
Tcpu
10
8
5
7
1
2
Prior
Tret
Tresp
Tesp
84) O processo P1 possui um tempo de CPU de 5 segundos e est esperando h 20

segundos. O processo P2 possui um tempo de CPU de 3 segundos e est esperando h 9. Se o sistema usar HRRN, qual processo executar primeiro?
85) Elabore o Grfico de Gantt utilizando os algoritmos RMS e EDF, considerando os
processos em tempo real com as seguintes caractersticas e que todos chegaram
no instante zero.
PROC
A
B
C
D
Tcpu
10
8
4
7
Prazo (D)
20
10
25
15
-x-
65
6 Gerncia de Memria
Gerncia de Memria
Uma grande memria no faz um filsofo, bem como

no pode um dicionrio ser chamado de gramtica.
(John Henry, cardeal Newman)
6.1
INTRODUO
Historicamente, a memria principal sempre foi vista como um recurso escasso e caro. Uma das maiores preocupaes dos projetistas foi desenvolver Sistemas Operacionais
que no ocupassem muito espao de memria e, ao mesmo tempo, otimizassem a utilizao dos recursos computacionais. Mesmo com a reduo do custo e conseqente aumento da capacidade, seu gerenciamento um dos fatores mais importantes no projeto
de Sistemas Operacionais.
Ns (na qualidade de projetistas de sistemas) consideramos a memria principal em
termos de organizao de memria. Colocamos apenas um nico processo na memria
principal ou inclumos vrios processos ao mesmo tempo (ou seja, implementamos a
multiprogramao)? Se a memria principal contiver diversos processos simultaneamente, damos a cada um a mesma quantidade de espao ou dividimos a memria principal
em pores de tamanhos diferentes? Definimos parties rigidamente por perodos estendidos ou dinamicamente, permitindo que o sistema se adapte rapidamente s mudanas das necessidades dos processos? Exigimos que processos executem em uma partio
especfica ou em qualquer lugar onde couberem? Exigimos que um sistema coloque cada
processo em um bloco contguo de localizaes de memria ou permitimos que divida
processos em blocos separados e os coloque em quaisquer molduras disponveis na memria principal? Vamos falar sobre tudo isso.
6.2
FUNES BSICAS
O objetivo principal de um sistema computacional executar programas. Tais programas devem estar, ainda que parcialmente, localizados na memria principal para executarem. Contudo, a memria principal, normalmente, no possui tamanho suficiente
para armazenar todos os programas a serem executados, bem como os dados por eles
utilizados. Este fato levou a maioria dos Sistemas Operacionais modernos a utilizarem
principalmente, dos discos rgidos como dispositivos secundrios de apoio a memria.
Assim, faz-se necessria a presena do software de gerncia de memria que , tambm, conhecido como Gerente de Memria e possui como objetivos principais controlar
quais partes da memria esto ou no em uso e tratar as dificuldades inerentes ao processo de swapping _ processo de troca de dados entre a memria principal e o disco rgido.
6.3
ALOCAO CONTGUA SIMPLES
Foi implementada nos primeiros Sistemas Operacionais, porm ainda est presente
em alguns sistemas monoprogramveis. Nesse tipo de organizao, a memria principal
subdividida em duas reas: uma para o Sistema Operacional e outra para o programa
do usurio. Dessa forma, o programador deve desenvolver suas aplicaes preocupado
apenas, em no ultrapassar o espao de memria disponvel.
Nesse esquema, o usurio tem controle sobre toda a memria principal, podendo ter
acesso a qualquer posio de memria, inclusive a rea do Sistema Operacional. Para
proteger o sistema desse tipo de acesso, que pode ser intencional ou no, alguns sistemas implementam proteo atravs de um registrador que delimita as reas do Sistema
Operacional e do usurio. Dessa forma, sempre que um programa faz referncia a um
endereo na memria, o sistema verifica se o endereo est dentro dos limites permiti66
6 Gerncia de Memria
dos. Caso no esteja, o programa cancelado e uma mensagem de erro gerada, indicando que houve uma violao no acesso memria principal.
6.4
TCNICA DE OVERLAY
Na alocao contgua simples, todos os programas esto limitados ao tamanho da rea de memria principal disponvel para o usurio. Uma soluo encontrada dividir o
programa em mdulos, de forma que seja possvel a execuo independente de cada
mdulo, utilizando uma mesma rea de memria. Essa tcnica chamada de overlay.
Considere um programa que tenha trs mdulos: um principal, um de cadastramento
e outro de impresso, sendo os mdulos de cadastramento e de impresso independentes. A independncia do cdigo significa que quando um mdulo estiver na memria para
execuo, o outro no precisa necessariamente estar presente. O mdulo principal comum aos dois mdulos; logo, deve permanecer na memria durante todo o tempo da
execuo do programa.
Como podemos verificar na figura, a
memria insuficiente para armazenar
todo o programa, que totaliza 9KB. A
tcnica de overlay utiliza uma rea de
memria comum, onde os mdulos de
cadastramento e de impresso podero
compartilhar a mesma rea de memria.
Sempre que um dos dois mdulos for
referenciado pelo mdulo principal, o
mdulo ser carregado da memria secundria para a rea de overlay.
A definio das reas de overlay
funo do programador, atravs de comandos especficos da linguagem de
programao utilizada. O tamanho de
uma rea de overlay estabelecido a
partir do tamanho do maior mdulo.
6.5
ALOCAO PARTICIONADA
Os sistemas multiprogramveis so muito mais eficientes no uso do processador, necessitando assim, que diversos programas estejam na memria principal ao mesmo tempo e que novas formas de gerncia de memria sejam implementadas.
6.5.1
ALOCAO PARTICIONADA ESTTICA

Nos primeiros sistemas multiprogramveis,
a memria era dividida em pedaos de tamanho fixo, chamados parties. O tamanho
das parties, estabelecido na fase de inicializao do sistema, era definido em funo do
tamanho dos programas que executariam no
ambiente. Sempre que fosse necessria a alterao do tamanho de uma partio, o sistema
deveria ser desativado e reinicializado com
uma nova configurao. Esse tipo de gerncia
de memria conhecido como alocao particionada esttica ou alocao fixa.
67
6 Gerncia de Memria
Inicialmente, os programas s podiam ser carregados em apenas uma partio especfica, mesmo se outras estivessem disponveis. Essa limitao se devia aos compiladores
e montadores, que geravam apenas cdigo absoluto. No cdigo absoluto, todas as referncias a endereos no programa so posies fsicas na memria principal, ou seja, o
programa s poderia ser carregado a partir do endereo de memria especificado no seu
prprio cdigo. Se, por exemplo, os programas A e B estivessem sendo executados, e a
terceira partio estivesse livre, os programas C e E no poderiam ser processados. A
esse tipo de gerncia de memria chamou-se alocao particionada esttica absoluta.
Com a evoluo dos compiladores, o cdigo gerado deixou de ser absoluto e passa a
ser relocvel. No cdigo relocvel, todas as
referncias a endereos no programa so relativas ao incio do cdigo e no a endereos
fsicos de memria. Desta forma, os programas puderam ser executados a partir de
qualquer partio. Quando o programa carregado, o loader calcula todos os endereos a
partir da posio inicial onde o programa foi
alocado. Caso os programas A e B terminassem, o programa E poderia ser executado em
qualquer uma das parties. Esse tipo de gerncia denominado alocao particionada
esttica relocvel.
Para manter controle sobre quais parties esto alocadas, a gerncia de memria mantm
uma tabela com o endereo inicial de cada partio, seu tamanho, e se est em uso. Sempre que
um programa carregado para a memria, o sistema percorre a tabela, na tentativa de localizar
uma partio livre, onde o programa possa ser
carregado.
Nesse esquema de alocao de memria, a
proteo baseia-se em dois registradores, que
indicam os limites inferior e superior da partio
onde o programa est sendo executado.
68
6 Gerncia de Memria
Tanto nos sistemas de alocao absoluta quanto nos de alocao relocvel, os programas, normalmente, no preenchem totalmente as parties onde so carregados. Por
exemplo, os programas C, A e E no ocupam integralmente o espao das parties onde
esto alocados, deixando 1 KB, 3 KB e 5 KB de reas livres. Este tipo de problema, decorrente da alocao fixa das parties, conhecido como fragmentao interna.
6.5.2
ALOCAO PARTICIONADA DINMICA
Na tentativa de evitar o desperdcio de memria ocasionado pelo mtodo tratado na

subseo anterior, foi desenvolvido um outro esquema de multiprogramao. Este outro
esquema considera que o tamanho das parties de memria no so fixos e conhecido
como alocao particionada dinmica ou parties variveis.
Nesse esquema, o programa utilizaria o espao necessrio, tornando essa rea sua partio. Como os programas
utilizam apenas o espao que necessitam, o problema da
fragmentao interna no ocorre. Porm, nesse caso, existe um problema que no to bvio quanto no esquema
anterior. Um tipo diferente de fragmentao comear a
ocorrer, quando os programas forem terminando e deixando espaos cada vez menores na memria, no permitindo
o ingresso de novos programas. Na figura, mesmo existindo 12 KB livres de memria principal, o programa D, que
necessita de 6 KB no poder ser carregado para execuo,
pois este espao no est disposto contiguamente. Esse
tipo de problema chamado de fragmentao externa.
Existem duas solues para o problema da fragmentao externa. Na primeira soluo, conforme os programas terminam, apenas os espaos
livres adjacentes so reunidos, produzindo reas livres de tamanho maior. A segunda
soluo envolve a relocao de todas as parties ocupadas, eliminando todos os espaos
entre elas e criando uma nica rea livre contgua. Para que esse processo seja possvel,
necessrio que o sistema tenha a capacidade de mover os diversos programas na memria principal, realizar relocao dinmica. A complexidade do seu algoritmo e o consumo de recursos Sistema Operacional sistema para a relocao dinmica, podem tornla invivel.
6.5.3
ESTRATGIAS DE ALOCAO DE PARTIO
Para que diversos programas estejam na memria principal ao mesmo tempo, novas
formas de gerncia de memria devem ser implementadas. Os Sistemas Operacionais
implementam algumas estratgias para determinar em qual rea livre um programa ser
carregado para execuo. Essas estratgias visam evitar ou diminuir o problema da
fragmentao externa.
A melhor estratgia a ser adotada por um sistema depende de uma srie de fatores,
sendo o mais importante o tamanho dos programas acessados no ambiente. IndepenSistemas Operacionais Lucilia Ribeiro
69
6 Gerncia de Memria
dentemente do algoritmo utilizado, o sistema deve possuir formas de saber quais reas
esto livres e quais no esto. Existem duas estratgias principais: Mapa de Bits e Lista
Encadeada.
a) MAPA DE BITS: esta estratgia divide a memria em pequenas unidades de
alocao e a cada uma delas associado um bit no mapa de bits. Convenciona-se que
um 0 no mapa indica que a unidade correspondente da memria est livre e 1
informa que est ocupada. A principal dificuldade em se utilizar o mapa de bits ocorre
quando for necessrio, por exemplo, trazer para a memria um processo que ocupa k
unidades de alocao. O Gerente de Memria deve, ento, procurar por k bits 0
consecutivos no mapa. Esta procura lenta, de forma que, na prtica, os mapas de bits
raramente so usados, ainda que eles sejam muito simples de serem implementados.
b) LISTAS LIGADAS: a presente estratgia utiliza uma lista ligada para controlar a
alocao/liberao de memria, onde tal lista contm os segmentos livres e ocupados da
memria. Um segmento pode ser um processo ou um buraco, conforme mostrado na
Figura.
No esquema de listas ligadas podem ser utilizados os algoritmos de alocao de memria apresentados na Tabela a seguir:
70
6 Gerncia de Memria
ALGORITMO
DESCRIO
Primeira Alocao
O Gerente de Memria procura ao longo da lista de segmentos at

encontrar um buraco que seja suficientemente grande para abrigar o
processo. O buraco ento quebrado em 2 pedaos, um para o processo e outro para o espao no-utilizado, exceto no caso, altamente
improvvel, do tamanho do buraco corresponder exatamente ao do
processo.
Vantagem: Este algoritmo extremamente rpido, pois procura o
mnimo de tempo possvel.
Prxima Alocao
uma pequena variao do algoritmo da primeira alocao. Funciona exatamente igual ao algoritmo anterior, exceto pelo fato de
guardar a posio onde ele encontra um buraco conveniente. Da prxima vez que o algoritmo for chamado, ele inicia sua busca deste
ponto, em vez de comear de novo no incio da lista.
Desvantagem: Este algoritmo tem uma performance um pouco pior do que o da primeira alocao.
Melhor Alocao
Este algoritmo busca na lista inteira a melhor posio para armazenar o processo que est precisando de espao. Em vez de parar ao
encontrar um buraco grande, que poder ser necessrio mais tarde,
ele busca um buraco cujo tamanho seja o mais prximo possvel do
tamanho do processo.
Desvantagem: Este algoritmo mais lento do que o da primeira
alocao, pois precisa pesquisar toda lista cada vez que for chamado.
Ele tambm resulta em maior desperdcio de memria que o da primeira alocao, ou mesmo o da prxima alocao, pois ele tende a
dividir a memria em buracos muito pequenos, que se tornam difceis
de serem utilizados. O algoritmo da primeira alocao gera, em mdia, buracos maiores.
Pior Alocao
aquele que sempre aloca ao processo o maior buraco disponvel,

de forma que tal buraco, quando dividido, resulta em novo buraco
suficientemente grande para abrigar outro processo.
Desvantagem: Este algoritmo no apresenta bons resultados prticos.
Alocao Rpida
Este algoritmo mantm listas separadas para alguns dos tamanhos de buracos mais requisitados. Por exemplo, poder ser criada
uma tabela com n entradas, na qual a primeira entrada um ponteiro
para o incio de uma lista de buracos de 4K, a segunda para uma lista
de buracos de 8K, a terceira para buracos de 12K e assim por diante.
Com a Alocao Rpida, a busca de um buraco de determinado tamanho muito rpida.
Desvantagem: sua complexidade maior, uma vez que devem ser
gerenciadas vrias listas de buracos.
c) SISTEMA BUDDY: o sistema buddy uma estratgia que tira vantagem do fato
de os computadores usarem nmeros binrios para o endereamento, como uma forma
de acelerar a juno dos buracos adjacentes quando um processo termina ou quando
retirado da memria. A Figura traz um exemplo do funcionamento da referida estratgia.
Apesar de extremamente eficiente sob o aspecto da velocidade, o sistema buddy no
eficiente em termos de utilizao da memria. O problema decorre, obviamente, da
necessidade de se arredondar a requisio feita pelo processo para a prxima potncia
inteira de 2. Assim, a um processo de 35K deve ser alocado 54K. Os 29K excedentes
sero perdidos, ocasionando a fragmentao interna.
71
6 Gerncia de Memria
Memria
128 K
256 K
384 K
512 K
640 K
768 K
Inicialmente
1 M Buracos
1
128
Requisio de 70
Requisio de 35
64
256
512
256
512
64
128
512
Devoluo de A
128
64
128
512
Requisio de 60
128
128
512
Devoluo de B
128
64
128
512
128
512
Requisio de 80
Devoluo de D
256
Devoluo de C
6.6
896 K
1024
SWAPPING
Mesmo com o aumento da eficincia
da multiprogramao e, particularmente,
da gerncia de memria, muitas vezes
um programa no podia ser executado
por falta de uma partio livre disponvel. A tcnica de swapping foi introduzida para contornar o problema da insuficincia de memria principal.
Em todos os esquemas apresentados
anteriormente, um processo permanecia
na memria principal at o final da sua
execuo, inclusive nos momentos em
que esperava por um evento, como uma
operao de E/S. O swapping uma tcnica aplicada gerncia de memria para programas que esperam por memria
livre para serem executados. Nesta situao, o sistema escolhe um processo
residente, que transferido da memria
principal para a memria secundria
(swap out), geralmente disco. Posteriormente, o processo carregado de volta
da memria secundria para a memria
principal (swap in) e pode continuar sua
execuo como se nada tivesse ocorrido.
O algoritmo de escolha do processo a

ser retirado da memria principal deve priorizar aquele com menores chances de ser executado. Para que essa tcnica seja utilizada, essencial que o sistema oferea um loader que implemente a relocao dinmica.
No momento em que o programa carregado na memria, o registrador recebe o endereo inicial
da posio de memria que o programa ir ocupar. Toda vez que
ocorrer uma referncia a algum
endereo, o endereo contido na
instruo ser somado ao contedo
do registrador, gerando, assim, o
endereo fsico. Dessa forma, um
programa pode ser carregado em
qualquer posio de memria.
72
6 Gerncia de Memria
6.7
EXERCCIOS
86) Quais as funes bsicas da gerncia de memria?
87) Considere um sistema computacional com 40 KB de memria principal e que utilize um Sistema Operacional de 10 KB que implemente alocao contgua de memria. Qual a taxa de subutilizao da memria principal para um programa que
ocupe 20 KB de memria?
88) Suponha que um sistema computacional de 64 KB de memria principal e que utilize um Sistema Operacional de 14 KB que implemente alocao contgua de memria. Considere tambm um programa de 90 KB, formado por um mdulo principal de 20 KB e trs mdulos independentes, cada um com 10 KB, 20 KB e 30
KB. Como o programa poderia ser executado utilizando-se apenas a tcnica de
overlay?
89) Considerando o exerccio anterior, se o mdulo de 30 KB tivesse seu tamanho
aumentado para 40 KB, seria possvel executar o programa? Caso no possa, como o problema poderia ser contornado?
90) Qual a diferena entre fragmentao interna e externa da memria principal?
91) Suponha um sistema computacional com 128 KB de memria principal e que utilize um Sistema Operacional de 64 KB que implemente alocao particionada esttica relocvel. Considere tambm que o sistema foi inicializado com trs parties:
P1 (8 KB), P2 (24 KB) e P3 (32 KB). Calcule a fragmentao interna da memria
principal aps a carga de trs programas: PA, PB e PC.
a) P1 <- PA (6 KB); P2 <- PB (20 KB); P3 <- PC (28 KB)
b) P1 <- PA (4 KB); P2 <- PB (16 KB); P3 <- PC (26 KB)
c) P1 <- PA (8 KB); P2 <- PB (24 KB); P3 <- PC (32 KB)
92) Considerando o exerccio anterior, seria possvel executar quatro programas concorrentemente utilizando apenas a tcnica de alocao particionada esttica relocvel? Se for possvel, como? Considerando ainda o mesmo exerccio, seria possvel executar um programa de 32 KB? Se for possvel, como?
93) Qual a limitao da alocao particionada esttica absoluta em relao alocao
esttica relocvel?
94) Considere que os processos da tabela a seguir esto aguardando para serem executados e que cada um permanecer na memria durante o tempo especificado. O
Sistema Operacional ocupa uma rea de 20 KB no incio da memria e gerencia a
memria utilizando um algoritmo de particionamento dinmico modificado. A
memria total disponvel no sistema de 64 KB e alocada em blocos mltiplos
de 4 KB. Os processos so alocados de acordo com sua identificao (em ordem
crescente) e iro aguardar at obter a memria de que necessitam. Calcule a perda de memria por fragmentao interna e externa sempre que um processo
colocado ou retirado da memria. O Sistema Operacional compacta a memria
apenas quando existem duas ou mais parties livres adjacentes.
PROCESSOS
MEMRIA
TEMPO
30 KB
6 KB
10
36 KB
95) Considerando os algoritmos para escolha da partio dinamicamente, conceitue as

estratgias especificando prs e contras de cada uma.
73
6 Gerncia de Memria
96) Considere um sistema que possua as seguintes reas livres na memria principal,
ordenadas crescentemente: 10 KB, 4 KB, 20 KB, 18 KB, 7 KB, 9 KB, 12 KB e 15
KB. Para cada programa abaixo, qual seria a partio alocada utilizando-se os algoritmos Primeira Alocao, Prxima Alocao, Melhor Alocao e Pior Alocao?
a) 12 KB
b) 10 KB
c) 9 KB
97) Um sistema utiliza alocao particionada dinmica como mecanismo de gerncia

de memria. O Sistema Operacional aloca uma rea de memria total de 50 KB e
possui, inicialmente, os programas da tabela a seguir:
5 KB
Programa A
3 KB
Programa B
10 KB
Livre
6 KB
Programa C
26 KB
Livre
Realize as operaes abaixo seqencialmente, mostrando o estado da memria

aps cada uma delas. Resolva a questo utilizando as estratgias Melhor Alocao, Pior Alocao, Primeira Alocao e Prxima Alocao.
a) alocar uma rea para o programa D que possui 6 KB;
b) liberar a rea do programa A;
c) alocar uma rea para o programa E que possui 4 KB.
98) O que swapping e para que utilizada essa tcnica?
99) Por que importante o uso de um loader com relocao dinmica para que a tcnica de swapping possa ser implementada?
100) Apresente o mapa de bits e o esquema de listas ligadas para o dois layouts de
memria apresentados abaixo:
101) Considere um sistema com swapping no qual os seguintes buracos esto na

memria, na ordem apresentada: 17K, 4K, 20K, 18K, 7K, 9K, 11K e 15K. ConsiSistemas Operacionais Lucilia Ribeiro
74
6 Gerncia de Memria
dere, ainda, que foram sucessivamente carregados para a memria os processos

A, B e C de tamanhos 18K, 9K e 14K, respectivamente. Assim sendo, aplique os
algoritmos da Primeira Alocao e o da Prxima Alocao.
102) Um minicomputador usa o sistema buddy para gerenciar sua memria. Inicialmente, ele tem um bloco de 512K no endereo 0. Demonstre graficamente a situao da memria aps cada passo e responda ao final de todos os passos: a)
Quantos blocos livres restaram, b) quais os seus tamanhos e c) quais seus endereos.
a) Alocao do Processo A de 12 KB
b) Alocao do Processo B de 74 KB
c) Alocao do Processo C de 30 KB
d) Finalizao do Processo B
e) Alocao do Processo D de 200 KB
f) Finalizao do Processo A
g) Alocao do Processo E de 7 KB
-x-
75
7 Memria Virtual
Memria Virtual
Endereos servem para que escondamos nossa localizao.

(Saki (H. H. Munro))
7.1
INTRODUO
As implementaes vistas anteriormente no gerenciamento de memria se mostraram muitas vezes ineficientes. Alm disso, o tamanho de um programa e de suas estruturas de dados estava limitado ao tamanho da memria disponvel. A utilizao da tcnica de overlay para contornar este problema de difcil implementao na prtica e nem
sempre uma soluo garantida.
Memria Virtual uma tcnica sofisticada e poderosa de gerncia de memria, onde as memrias principal e secundria so combinadas, dando ao usurio a iluso de
existir uma memria muito maior que a capacidade real da memria principal. O conceito
de memria virtual fundamenta-se em no vincular o endereamento feito pelo programa
dos endereos fsicos da memria principal. Desta forma, programas e suas estruturas de
dados deixam de estar limitados ao tamanho da memria fsica disponvel, pois podem
possuir endereos associados memria secundria.
Outra vantagem da tcnica de memria virtual permitir um nmero maior de processos compartilhando a memria principal, j que apenas partes de cada processo estaro residentes. Isto leva a uma utilizao mais eficiente tambm do processador. Alm
disso, essa tcnica possibilita minimizar o problema da fragmentao da memria principal.
7.2
ESPAO DE ENDEREAMENTO VIRTUAL
O conceito de memria virtual se aproxima muito da idia de um vetor existente nas

linguagens de alto nvel. Quando um programa faz referncia a um elemento do vetor,
no h preocupao em saber a posio de memria daquele dado. O compilador se encarrega de gerar instrues que implementem esse mecanismo, tornando-o totalmente
transparente ao programador.
A memria virtual utiliza abstrao semelhante, s que em relao aos endereos dos
programas e dados. Um programa no ambiente de memria virtual no faz referncia a
endereos fsicos de memria (endereos reais), mas apenas a endereos virtuais.
No momento da execuo de uma instruo, o endereo virtual referenciado traduzido
para um endereo fsico, pois o processador manipula apenas posies da memria principal. O mecanismo de traduo do endereo virtual para o endereo fsico chamado de
mapeamento.
Como o espao de endereamento virtual no
tem nenhuma relao direta com os endereos no
espao real, um programa pode fazer referncia a
endereos virtuais que estejam fora dos limites da
memria principal, ou seja, os programas e suas
estruturas de dados no esto mais limitados ao
tamanho da memria fsica disponvel. Para que
isso seja possvel, o Sistema Operacional utiliza a
memria secundria como extenso da memria
principal. Quando um programa executado, somente uma parte do seu cdigo fica residente na
memria principal, permanecendo o restante na
memria secundria at o momento de ser referenciado. Esta condio permite aumentar o compartiSistemas Operacionais Lucilia Ribeiro
76
7 Memria Virtual
lhamento da memria principal entre muitos processos.

No desenvolvimento de aplicaes, a existncia dos endereos virtuais ignorada pelo programador. Os compiladores e linkers se encarregam de gerar o cdigo executvel
em funo do espao de endereamento virtual, e o Sistema Operacional cuida dos detalhes durante sua execuo.
7.3
MAPEAMENTO
O processador apenas executa instrues e referencia dados residentes no espao de

endereamento real; portanto, deve existir um mecanismo que transforme os endereos
virtuais em reais. Esse mecanismo chamado mapeamento.
Nos sistemas atuais, o mapeamento realizado por hardware juntamente com o Sistema Operacional. O dispositivo de hardware responsvel por esta traduo conhecido
como Unidade de Gerenciamento de Memria (Memory Management Unit MMU),
sendo acionado sempre que se faz referncia um endereo virtual. Depois de traduzido, o
endereo real pode ser utilizado pelo processador para acesso memria principal.
Cada processo tem o seu espao de endereamento virtual como se possusse sua
prpria memria. O mecanismo de traduo
se encarrega, ento, de manter tabelas de
mapeamento exclusivas para cada processo, relacionando os endereos virtuais do
processo s suas posies na memria real.
Caso o mapeamento fosse realizado para
cada clula na memria principal, o espao
ocupado pelas tabelas seria to grande
quanto o espao de endereamento virtual
de cada processo, o que inviabilizaria a implementao do mecanismo de memria
virtual. Em funo disso, as tabelas mapeiam blocos de dados, cujo tamanho determina o nmero de entradas existentes nas tabelas de mapeamento. Quanto maior o bloco, menos entradas nas tabelas de mapeamento e, conseqentemente, tabelas de
mapeamento que ocupam um menor espao
na memria.
Espao de
Endereamento
Virtual
232 endereos
232 endereos
264 endereos
264 endereos
Tamanho
do Bloco
Nmero
de Blocos
512 bytes
4 KB
4 KB
64 KB
223
220
252
248
Nmero de entradas
na tabela de
mapeamento
223
220
252
248
Como veremos a seguir, existem Sistemas Operacionais que trabalham apenas com
blocos de tamanho fixo (paginao), enquanto outros utilizam blocos de tamanho varivel (segmentao). Existe ainda um terceiro tipo de sistema que implementa ambas as
tcnicas (segmentao paginada).
7.4
PAGINAO
a tcnica de gerncia de memria onde o espao de endereamento virtual e o real

so divididos em blocos do mesmo tamanho chamados pginas. A definio do tamanho da pgina um fator importante no projeto de sistemas que implementam memria virtual por paginao. O tamanho da pgina est associado arquitetura do hardware
e varia de acordo com o processador, mas normalmente est entre 512 e 16MB. Pginas
77
7 Memria Virtual
no espao virtual so denominadas pginas virtuais, enquanto as pginas no espao

real so chamadas de pginas reais, molduras ou frames.
Todo o mapeamento de endereo
virtual em real realizado atravs de
tabelas de pginas. Cada processo
possui sua prpria tabela e cada pgina virtual do processo possui uma
entrada na tabela de pginas
(ETP), com informaes de mapeamento que permitem ao sistema localizar a pgina real correspondente.
Nessa tcnica, o endereo virtual
formado pelo nmero da pgina
virtual (NPV) e por um deslocamento. O NPV identifica unicamente
a pgina virtual que contm o endereo, funcionando como um ndice na
tabela de paginas. O deslocamento
indica a posio do endereo virtual
em relao ao incio da pgina na
qual se encontra. O endereo fsico
obtido, ento, combinando-se o endereo do frame, localizado na tabela de
pginas, com o deslocamento, contido no endereo virtual.
Alm da informao sobre a localizao da pgina virtual, a ETP possui
outras informaes, como o bit de
validade (valid bit) que indica se
uma pgina est ou no na memria
principal.
Sempre que o processo referencia
um endereo virtual, a unidade de
gerncia de memria verifica, atravs
do bit de validade, se a pgina que
contm o endereo referenciado est
ou no na memria principal. Caso a
pgina no esteja na memria, dizemos que ocorre uma falta de pgina
(page fault). Neste caso, o sistema
transfere a pgina da memria secundria para a memria principal,
realizando uma operao de E/S conhecida como page in ou paginao. O nmero de faltas de pgina
gerado por um processo depende de
como o programa foi desenvolvido,
alm da poltica de gerncia de memria implementada pelo Sistema
Operacional. O nmero de falta de
pginas geradas por cada processo
em um determinado intervalo de
tempo definido como taxa de paginao.
78
7 Memria Virtual
79
7 Memria Virtual
7.4.1
PAGINAO MULTINVEL
Em sistemas que implementam apenas um nvel de paginao, o tamanho das tabelas de pginas pode ser um problema. Em uma arquitetura de 32 bits para endereamento e pginas com 4KB por processo, onde cada entrada na tabela de pginas ocupe 4
bytes, a tabela de pginas poderia ter mais de um milho de entradas e ocuparia 4 MB
de espao. Imaginando vrios processos residentes na memria principal, manter tabelas
desse tamanho para cada processo certamente seria de difcil gerenciamento.
Uma boa soluo para contornar o problema a utilizao de tabelas de pginas
multinvel. Com a finalidade de propiciar um melhor entendimento do mencionado conceito, considere-se um sistema computacional com palavra de 32 bits, 4 GB de espao de
endereamento virtual e pginas de tamanho 4K. Nesta configurao, a palavra que chega MMU dividida em trs partes, como indica a Figura:
Dessa forma, cada entrada do primeiro nvel gerencia 4 MB de espao e cada entrada
do segundo mapeia 4KB, totalizando 4GB.
A Figura abaixo apresenta um exemplo de funcionamento da MMU para o caso de tabelas de pginas multinvel.
1) MOVE REG 4206600 MOVE REG?

2) 4206600 0000000001 | 0000000011 | 000000001000
3) 0000000001 = 1 (TP1) Endereos de 4Mb a 8 Mb de TP1
4) 0000000011 = 3 (TP2) Endereo da Base = 12.288
5) 000000001000 = 8 (Deslocamento)
6) Endereo Real=Base + Deslocamento = 12.288 + 8 =12.296 MOVE REG 12296
7.4.2
POLTICAS DE BUSCA DE PGINAS
80
7 Memria Virtual
Determina quando uma pgina deve ser carregada para a memria. Basicamente, existem duas estratgias para este propsito: paginao sob demanda e pr-paginao ou
paginao antecipada.
Na paginao sob demanda, as pginas dos processos so transferidas da memria
secundria para a principal apenas quando so referenciadas. Este mecanismo conveniente, na medida em que leva para a memria principal apenas as pginas realmente
necessrias execuo do programa. Desse modo, possvel que partes no executadas
do programa, como rotinas de tratamento de erros, nunca sejam carregadas para a memria.
Na pr-paginao, o sistema carrega para a memria principal, alm da pgina referenciada, outras pginas que podem ou no ser necessrias ao processo ao longo do
processamento. Se imaginarmos que o programa est armazenado seqencialmente no
disco, existe uma grande economia de tempo em levar um conjunto de pginas da memria secundria, ao contrrio de carregar uma de cada vez. Por outro lado, caso o processo no precise das pginas carregadas antecipadamente, o sistema ter perdido tempo e ocupado memria principal desnecessariamente.
7.4.3
POLTICAS DE ALOCAO DE PGINAS
Determina quantas molduras (frames) cada processo pode manter na memria principal. Existem, basicamente, duas alternativas: alocao fixa e alocao varivel.
Na poltica de alocao fixa, cada processo tem um nmero mximo de molduras
que pode ser utilizado durante a execuo do programa. Caso o nmero de pginas reais
seja insuficiente, uma pgina do processo deve ser descartada para que uma nova seja
carregada. O limite de pginas deve ser definido no momento da criao do processo,
com base no tipo da aplicao que ser executada. Essa informao faz parte do contexto de software do processo.
Apesar de sua simplicidade, a poltica de alocao fixa de pgina apresenta dois problemas. Se o nmero mximo de pginas alocadas for muito pequeno, o processo tender a ter um elevado nmero de falta de pgina, o que pode impactar no desempenho de
todo o sistema. Por outro lado, caso o nmero de pginas seja muito grande, cada processo ir ocupar na memria principal um espao maior do que o necessrio, reduzindo o
nmero de processos residentes e o grau de multiprogramao.
Na poltica de alocao varivel, o nmero mximo de pginas pode variar durante sua execuo em funo de sua taxa de paginao e da ocupao da memria principal. Este mecanismo, apesar de ser mais flexvel, exige que o Sistema Operacional monitore constantemente o comportamento dos processos, gerando maior overhead.
7.4.4
POLTICAS DE SUBSTITUIO DE PGINAS
Em algumas situaes, quando um processo atinge o seu limite de alocao de molduras e necessita alocar novas pginas na memria principal, o Sistema Operacional deve selecionar, dentre as diversas pginas alocadas, qual dever ser liberada. Este mecanismo chamado de poltica de substituio de pginas. Uma pgina real, quando
liberada por um processo, est livre para ser utilizada por qualquer outro. A partir dessa
situao, qualquer estratgia de substituio de pginas deve considerar se uma pgina
foi ou no modificada antes de liber-la. Se a pgina tiver sido modificada, o sistema
dever grav-la na memria secundria antes do descarte, preservando seu contedo
para uso em futuras referncias. Este mecanismo conhecido como page out.
O Sistema Operacional consegue identificar as pginas modificadas atravs de um bit
que existe em cada entrada da tabela de pginas, chamado bit de modificao. Sempre
que uma pgina sofre uma alterao, o valor do bit de modificao alterado, indicando
que a pgina foi modificada.
A poltica de substituio de pginas pode ser classificada conforme seu escopo, ou
seja, dentre os processos residentes na memria principal quais so candidatos a ter
pginas realocadas. Em funo deste escopo, pode ser definida como local ou global.
81
7 Memria Virtual
Na poltica de substituio local, apenas as pginas do processo que gerou a falta

de pgina so candidatas a realocao. Os frames dos demais processos no so avaliados para substituio.
J na poltica de substituio global, todas as pginas alocadas na memria principal so candidatas a substituio, independente do processo que gerou a falta de pgina. Na verdade, nem todas as pginas podem ser candidatas a substituio. Algumas
pginas, como as do ncleo do sistema, so marcadas como bloqueadas e no podem
ser realocadas.
7.4.5
WORKING SET
Apesar de suas diversas vantagens, o mecanismo de memria virtual introduz um srio problema: caso os processos tenham na memria principal um nmero insuficiente de
pginas para a execuo do programa, provvel que diversos frames referenciados ao
longo do seu processamento no estejam na memria. Esta situao provoca a ocorrncia de um nmero elevado de falta de pgina e, conseqentemente, inmeras operaes
de E/S. Neste caso, ocorre um problema conhecido como trashing, provocando srias
conseqncias ao desempenho do sistema.
O conceito de working set surgiu com o objetivo de reduzir o problema do trashing e
est relacionado ao princpio da localidade. Existem dois tipos de localidade que so
observados durante a execuo da maioria dos programas. A localidade espacial a
tendncia de que aps uma referncia a uma posio de memria sejam realizadas novas
referncias a endereos prximos. A localidade temporal a tendncia de que aps a
referncia a uma posio de memria esta mesma posio seja novamente referenciada
em um curto intervalo de tempo.
O princpio da localidade significa, na prtica, que o processador tender a concentrar suas referncias a um conjunto de pginas do processo durante um determinado perodo de tempo. Imaginando um loop, cujo cdigo ocupe trs
pginas, a tendncia de essas trs pginas serem referenciadas diversas vezes muito alta.
A partir da observao do princpio da localidade, Peter
Denning (1968), formulou o modelo de working set. Working set definido como sendo o conjunto das pginas referenciadas por um processo durante determinado intervalo
de tempo. A figura ilustra que no instante t2, o working set
do processo W(t2, t), so as pginas referenciadas no intervalo t (t2 t1), isto , as pginas P2, P3 e P8. o intervalo de tempo t denominado
janela do working set. Podemos observar, ento, que o working set de um processo
funo do tempo e do tamanho da janela do working set.
Dentro da janela do working set, o nmero de pginas distintas referenciadas conhecido como tamanho do working set. Na figura so apresentadas as referncias s
pginas de um processo nas janelas ta (t2 t1) e tb (t3 t2). O working set do processo
no instante t2, com a janela ta, corresponde s pginas P2, P3, P4 e P5, e o tamanho do
working set igual a quatro pginas. No instante t3, com a janela tb, o working set corresponde s pginas P5 e P6, e o tamanho igual a duas pginas.
82
7 Memria Virtual
O modelo de working set proposto por Denning possibilita prever quais pginas so
necessrias execuo de um programa de forma eficiente. Caso a janela do working set
seja apropriadamente selecionada, em funo da localidade do programa, o Sistema Operacional dever manter as pginas do working set de cada processo residente na memria principal. Considerando que a localidade de um programa varia ao longo da sua
execuo, o tamanho do working set do processo tambm varia, ou seja, o seu limite de
pginas reais deve acompanhar esta variao. O working set refletir a localidade do
programa, reduzindo a taxa de paginao dos processos e evitando, conseqentemente,
o trashing. Na prtica, o modelo de working set serve como base para inmeros algoritmos de substituio de pginas, como os apresentados a seguir.
7.4.6
ALGORITMOS DE SUBSTITUIO DE PGINAS
A melhor estratgia de substituio de pginas seria aquela que escolhesse uma moldura que no fosse mais utilizada no futuro ou levasse mais tempo para ser novamente
referenciada. Porm, quanto mais sofisticado o algoritmo, maior overhead para o Sistema Operacional implement-lo. O algoritmo deve tentar manter o working set dos processos na memria principal e, ao mesmo tempo, no comprometer o desempenho do
sistema.
a) TIMO: O melhor algoritmo de troca de pginas fcil de descrever, mas impossvel de implementar. O algoritmo opera da seguinte maneira: no momento que ocorre
uma falta de pgina, um certo conjunto de pginas est na memria. Uma dessas pginas ser referenciada em muitas das prximas instrues. Outras pginas no sero referenciadas antes de 10, 100 ou talvez 1000 instrues. Cada pgina pode ser rotulada
com o nmero de instrues que sero executadas antes que a pgina seja inicialmente
referenciada.
O algoritmo timo simplesmente diz que a pgina com o maior rtulo deve ser removida, adiando-se o mximo possvel a prxima falta de pgina. (A exemplo das pessoas,
os computadores tambm tendem a adiar o quanto possvel a ocorrncia de eventos desagradveis).
O nico problema com este algoritmo que ele no realizvel. No momento da falta
de pgina, o sistema operacional no tem como saber quando cada uma das pginas
ser referenciada de novo. No mximo podemos executar um programa em um simulador e, mantendo uma lista de todas as pginas referenciadas, implementar o algoritmo
na segunda execuo (usando informaes coletadas na primeira execuo).
b) FIFO: Para ilustrar seu funcionamento, considere um supermercado que tem prateleiras suficientes para armazenar exatamente k produtos diferentes. Certo dia, alguma
indstria introduz um novo tipo de alimento que faz um tremendo sucesso comercial.
Nosso supermercado deve, ento, arranjar um jeitinho para vend-lo, eliminando de suas prateleiras algum outro produto.
Uma possibilidade descobrir qual dos produtos este supermercado vem estocando
h mais tempo (isto , algo que ele vem vendendo h 120 anos) e livrar-se dele. De fato,
tal deciso tomada com facilidade, visto que o supermercado mantm uma lista de todos produtos vendidos atualmente, na ordem em que eles entraram pela primeira vez no
estoque. O mais novo est no fim da fila, e o mais velho no incio, devendo ser eliminado.
Em algoritmos de substituio de pginas, a mesma idia pode ser aplicada. O sistema operacional mantm uma fila de todas as pginas que esto na memria, com a pgina no topo da fila sendo a mais antiga e a do fim da fila a que chegou h menos tempo. Na ocorrncia de uma falta de pgina, a pgina do incio deve ser removida, sendo a
nova pgina adicionada ao fim desta fila. Quando aplicado ao problema do supermercado, o algoritmo FIFO tanto pode remover um dos itens mais vendidos, como sal ou manteiga, quanto um dos menos vendidos, como sacos de lixo. Quando aplicada aos computadores, o mesmo problema ocorre. Por isso, o algoritmo FIFO, em sua forma pura, nunca usado. A Figura traz uma simulao simplificada deste algoritmo;
83
7 Memria Virtual
c) Segunda Chance:
Este algoritmo uma variao do FIFO, a nica diferena que existe um bit R associado a cada pgina. Se R for 0 a pgina considerada velha e no referenciada, de
modo que ela deve ser removida da memria. Ao passo que, se R for 1, R deve ser
zerado e a pgina colocada no fim da fila (torna-se jovem novamente).Contudo, se todas
as pginas tiverem sido recentemente referenciadas, este algoritmo ir se comportar
exatamente como o FIFO;
d) Relgio:
O algoritmo da segunda chance est sempre movendo pginas do incio para o final
da lista. Ento, com a finalidade de solucionar este problema, desenvolveu-se o algoritmo do relgio, que possui uma lista ligada circular e um ponteiro que aponta para a pgina mais velha. Quando uma falta de pgina acontece, a pgina que est sendo apontada testada e, caso o seu bit R seja zero, ela deve abandonar a memria, porm se
R for 1, R deve ser zerado e o ponteiro avana para o prximo n da lista. Este processo deve se repetir at que seja encontrado um n com R igual a zero;
e) NUR (Not Recently Used):
Para permitir que o sistema operacional colete estatsticas sobre quais pginas esto
sendo usadas e quais no esto, muitos computadores com memria virtual tm 2 bits
associados a cada pgina. Um bit, R ou bit de referncia, ativado pelo hardware sempre que a pgina a ele associada for referenciada. O outro bit, M ou bit de modificao,
ativado pelo hardware quando uma pgina escrita. importante que estes bits sejam
atualizados em qualquer referncia de memria, assim, essencial que eles sejam ativados pelo hardware. Uma vez que um bit for ativado, ele permanece ativado at que o
sistema operacional o desative (por software).
Os bits R e M podem ser usados para construir um algoritmo de paginao simples
como se segue. Quando um processo iniciado, ambos os bits de pgina para todas estas pginas so declarados 0 pelo sistema operacional. Periodicamente (i.e. a cada interrupo de tempo), o bit R zerado, para distinguir pginas que no foram referenciadas
recentemente daquelas que tenham sido.
Quando uma falta de pgina ocorre, o sistema operacional examina todas as pginas
e as classifica em 4 categorias baseado nos valores correntes de seus bits R e M:
Classe 0: no referenciada, no modificada
Classe 1: no referenciada, modificada
Classe 2: referenciada, no modificada
Classe 3: referenciada, modificada
Ainda que as pginas na classe 1 paream, primeira vista, impossveis de existir,

elas ocorrem quando as pginas da classe 3 tm seu bit R zerado pela interrupo de
tempo.
O algoritmo NRU remove uma pgina aleatria da classe de numerao mais baixa
no vazia. Implcito neste algoritmo que melhor remover uma pgina modificada que
no foi referenciada pelo menos no ltimo clock, que uma pgina no modificada, mas
muito usada.
84
7 Memria Virtual
As caractersticas principais do NRU que ele fcil de entender, eficiente de se implementar, e gera um desempenho que, embora no timo, geralmente tido como adequado.
f) LRU (Least Recently Used):
Uma boa aproximao para o algoritmo timo baseada em uma observao comum
que as pginas muito usadas nas ltimas instrues, provavelmente o sero nas prximas instrues. Da mesma forma, pginas que no tm sido usadas por um longo tempo
provavelmente continuaro sem uso. Esta observao sugere um algoritmo realizvel. Na
ocorrncia de uma falta de pgina, este algoritmo ir remover as pginas menos referenciadas nas ltimas instrues, pois ele parte do princpio que as pginas que foram referenciadas nas ltimas instrues continuaro sendo acessadas.
Embora o algoritmo LRU seja teoricamente realizvel, seu custo alto. Para implementao completa do LRU, necessrio manter uma lista ligada de todas as pginas em
memria, com a pgina mais recentemente usada no incio e a menos recentemente usada no final. A dificuldade que a lista deve ser atualizada em toda referncia de memria. Encontrar a pgina na lista, remov-la de sua posio corrente, e mov-la para o
incio representa um esforo no desprezvel.
Manipular uma lista ligada a toda instruo proibitivo, at mesmo em hardware. Entretanto, h outras maneiras de implementar LRU com um hardware especial. Vamos
considerar o caminho mais simples primeiro. Este mtodo requer equipar o hardware
com um contador de 64 bits, C, que automaticamente incrementado aps cada instruo. Alm disso, cada entrada na tabela de pginas deve tambm ter um campo grande
o bastante para conter o contador. Aps cada referncia de memria, o corrente valor de
C armazenado na entrada da tabela de pginas para a pgina referenciada. Quando
ocorre uma falta de pgina, o sistema operacional examina todos os contadores na tabela de pginas para achar o menor deles. A pgina correspondente a menos recentemente usada.
Agora vejamos um segundo algoritmo LRU, tambm em hardware. Para uma mquina com N page frames, o LRU deve manter uma matriz de N x N bits, inicialmente todos
zero.
Sempre que uma moldura k for referenciada, o hardware coloca todos os bits da linha
k em 1, e depois zera todos os bits da coluna k. Em cada instante, a linha com o menor
valor binrio armazenado ser correspondente pgina usada h mais tempo; aquela
com o prximo valor ser a prxima usada h mais tempo, e assim por diante.
Um exemplo do funcionamento deste algoritmo aparece ilustrada na figura para quatro molduras de pgina e a seguinte ordem de referncias s pginas: 5 0 1 2 3 2 1 0 3 2
3 . Neste exemplo a pgina usada h mais tempo a 1
Considerando-se o funcionamento dos algoritmos de substituio de pginas, possvel pensar, de incio, que quanto maior for o nmero de page frames, menor ser a ocorrncia de faltas de pginas durante o perodo de execuo de um processo. Entretanto,
estudos demonstraram que este pensamento nem sempre verdadeiro e este fato ficou
conhecido como anomalia de Belady.
Um exemplo de ocorrncia da mencionada anomalia encontra-se detalhado na Figura
3.16, onde utilizado o algoritmo de substituio de pginas FIFO que, inicialmente,
simulado com 3 page frames e apresenta 9 faltas de pginas. Em seguida, realizada a
85
7 Memria Virtual
simulao do FIFO com 4 molduras de pginas e observado que o nmero de falta de

pginas se eleva para 10.
Dessa forma, possvel verificar a presena da anomalia de Belady, pois a memria
fsica foi aumentada e o nmero de falta de pginas tambm.
Aps a verificao da anomalia de Belady, muitos estudos foram desenvolvidos e foi

observado que alguns algoritmos no apresentavam tal anomalia e estes foram chamados de algoritmos de pilha.
Obs.: 1) O LRU um algoritmo de pilha e no apresenta a anomalia de Belady; 2) O
FIFO, como foi visto anteriormente, apresenta a anomalia de Belady.
7.5
SEGMENTAO
a tcnica de gerncia de memria
onde o espao de endereamento virtual
dividido em blocos de tamanhos diferentes chamados segmentos. Cada
segmento tem um nmero e um tamanho, conforme pode ser observado na
Figura. Nesta tcnica um programa
dividido logicamente em sub-rotinas e
estruturas de dados, que so alocados
em segmentos na memria principal.
Enquanto na tcnica de paginao o

programa dividido em pginas de tamanho fixo, sem qualquer ligao com
sua estrutura, na segmentao existe uma relao entre a lgica do programa e sua alocao na memria principal. Normalmente, a definio dos segmentos realizada pelo
compilador, a partir do cdigo fonte do programa, e cada segmento pode representar um
procedimento, uma funo, vetor ou pilha.
Na segmentao, os endereos especificam o nmero do segmento e o deslocamento
dentro do mesmo.
86
7 Memria Virtual
Assim, para mapear um endereo virtual composto pelo par <segmento, deslocamento> o hardware de segmentao considera a existncia de uma tabela de segmentos.
Cada entrada da tabela de segmentos possui a base e o limite de cada segmento. A base
contm o endereo fsico de incio do segmento e o limite especifica o seu tamanho.
A figura apresentada a seguir ilustra o funcionamento do mapeamento de um endereo virtual em um sistema que utiliza a segmentao.
Os segmentos podem se tornar muito grandes e, s vezes, pode ser impossvel manter todos na memria ao mesmo tempo. Para resolver este problema implementa-se a
paginao em cada um dos segmentos, dando origem, ento, segmentao paginada.
7.6
SEGMENTAO PAGINADA
a tcnica de gerncia de memria onde o espao de endereamento dividido em

segmentos e, por sua vez, cada segmento dividido em pginas. Esse esquema de gerncia de memria tem o objetivo de oferecer as vantagens de ambas as tcnicas.
Na viso do programador, sua aplicao continua sendo mapeada em segmentos de
tamanhos diferentes, em funo das sub-rotinas e estruturas de dados definidas no programa. Por outro lado, o sistema trata cada segmento como um conjunto de pginas do
mesmo tamanho, mapeadas por uma tabela de pginas associada ao segmento. Desta
forma, um segmento no precisa estar contguo na memria principal, eliminando o problema da fragmentao externa encontrado na segmentao pura.
7.7
EXERCCIOS
103) Quais os benefcios oferecidos pela tcnica de memria virtual? Como este
conceito permite que um programa e seus dados ultrapassem os limites da memria principal?
104) Explique como um endereo virtual de um processo traduzido para um endereo real na memria principal?
105) Por que o mapeamento deve ser feito em blocos e no sobre clulas individuais?
106) Qual a principal diferena entre os sistemas que implementam paginao e os
que implementam segmentao?
107)
Diferencie pgina virtual de pgina real.
87
7 Memria Virtual
108)
Para que serve o bit de validade nas tabelas de pgina?
109) Apresente o funcionamento binrio da MMU de uma mquina hipottica para

encontrar a instruo correspondente de: MOVE REG, 700
110) O que page fault , quando ocorre e quem controla a sua ocorrncia? Como
uma elevada taxa de falta de pgina pode comprometer o Sistema Operacional?
111) Descreva como ocorre a fragmentao interna em sistemas que implementam
a paginao.
112)
Compare as polticas de busca de pginas apresentadas.
113) Quais as vantagens e desvantagens da poltica de alocao de pginas varivel

comparada alocao fixa?
114) Um sistema com gerncia de memria virtual por paginao possui tamanho
de pgina com 512 posies, espao de endereamento virtual com 512 pginas
endereadas de 0 a 511 e memria real com 10 pginas numeradas de 0 a 9. o
contedo atual da memria real contm apenas informaes de um nico processo e descrito resumidamente na tabela abaixo:
Endereo Fixo
1536
2048
3072
3584
4608
Contedo
Pgina Virtual 34
Pgina Virtual 9
Tabela de Pginas
Pgina Virtual 65
Pgina Virtual 10
a) Considere que a entrada da tabela de pginas contm, alm do endereo do

frame, o nmero da pgina virtual. Mostre o contedo da tabela de pginas desse
processo.
88
7 Memria Virtual
b) Mostre o contedo da tabela de pginas aps a pgina virtual 49 ser carregada na memria a partir do endereo real 0 e a pgina virtual 34 ser substituda
pela pgina virtual 12.
c) Como o formato do endereo virtual deste sistema?
d) Qual endereo fsico est associado ao endereo virtual 4613?
115)
Encontre o endereo fsico correspondente aos seguintes endereos virtuais:
a) 67.219.712 = 0000010000.0000011011.000100000000
b) 113.819.552 = 0000011011.0010001011.111110100000
c) 545.591.437 = 0010000010.0001010001.000010001101
d) 416.219.160 = 0001100011.0011110000.000000011000
0
.
3
4
.
.
240
.
.
1023
0
1
2
.
.
16
.
27
.
99
.
130
1023
.
.
67
.
.
81
.
94
.
1023
0
.
.
27
.
.
139
.
.
1023
.
240
.
139
.
.
1011
.
1023
48k
04k
16 20 k
32 36 k
8 12 k
60 64 k
40 44 k
12 16 k
24 28 k
36 40 k
52 54 k
48 52 k
44 48 k
20 24 k
54 60 k
28 32 k
89
7 Memria Virtual
116) Um Sistema Operacional implementa gerncia de memria virtual por paginao, com frames de 2KB. A partir da tabela abaixo, que representa o mapeamento
de pginas de um processo em um determinado instante de tempo, responda:
Pgina
0
1
2
3
4
5
6
Residente
Sim
Sim
Sim
Sim
No
No
Sim
Frame
20
40
100
10
50
70
1000
a) Qual o endereo fsico de uma varivel

que ocupa o ltimo byte da pgina 3?
b) Qual o endereo fsico de uma varivel
que ocupa o primeiro byte da pgina 2?
c) Qual o endereo fsico de uma varivel
que tem deslocamento 10 na pgina 3?
d) Quais pginas do processo esto na
memria?
117) Um Sistema Operacional implementa gerncia de memria virtual por paginao. Considere endereos virtuais com 16 bits, referenciados por um mesmo processo durante sua execuo e sua tabela de pginas abaixo com no mximo 256
entradas. Esto representadas apenas as pginas presentes na memria real. Indique para cada endereo virtual a seguir a pgina virtual em que o endereo se
encontra, o respectivo deslocamento e se a pgina se encontra na memria principal nesse momento.
a) (307)10
b) (2049)10
c) (2304)10
Pgina
0
1
2
3
4
5
9
11
Endereo Fsico
8K
4K
24 K
0K
16 K
12 K
20 K
28 K
118) Uma memria virtual possui pginas de 1024 endereos, existem 8 pginas
virtuais e 4096 bytes de memria real. A tabela de pginas de um processo est
descrita abaixo. O asterisco indica que a pgina no est na memria principal:
Pgina Virtual
0
1
2
3
4
5
6
7
Pgina Real
3
1
*
*
2
*
0
*
a) Faa a lista/faixa de todos os endereos virtuais que iro causar falta

de pgina.
b) Indique o endereo real correspondente aos seguintes endereos
virtuais 0, 1023, 1024, 6500 e 3728.
119) Porque existe a necessidade de uma poltica de substituio de pginas? Compare as polticas de substituio local e global.
120)
Para que serve o bit de modificao nas tabelas de pginas?
121) Como o princpio da localidade viabiliza a implementao da gerncia de memria virtual por paginao?
122) Por que programas no estruturados esto sujeitos a uma alta taxa de paginao?
123)
Cite os principais algoritmos de substituio de pginas estudados.
90
7 Memria Virtual
124)
Explique o funcionamento do algoritmo de substituio de pginas NUR.
125) Explique o funcionamento do algoritmo de substituio de pginas da segunda

chance.
126) Informe a principal desvantagem de se utilizar o algoritmo de substituio de
pginas da segunda chance.
127) Informe a principal vantagem que o algoritmo do relgio possui sobre o da segunda chance.
128) Considere uma mquina com trs molduras de pgina (page frames), as quais
esto inicialmente vazias. Assim sendo, informe quantas faltas de pginas sero
geradas com a utilizao do algoritmo de substituio de pginas FIFO se a seqncia de referncia s pginas for: 0, 1, 2, 3, 0, 1, 4, 1, 2, 3, 1 e 4.
129) Considere uma mquina com quatro molduras de pgina (page frames), as
quais esto inicialmente vazias. Assim sendo, informe quantas faltas de pginas
sero geradas com a utilizao do algoritmo de substituio de pginas LRU se a
seqncia de referncia s pginas for: 0, 1, 2, 3, 0, 1, 4, 1, 2, 3, 1, 4 e 5.
130) Considere uma mquina com quatro molduras de pgina (page frames), as
quais esto inicialmente vazias, e uma seqncia de referncia s pginas igual a:
0, 1, 2, 3, 0, 1, 4, 1, 2, 3, 1, 4, 5, 4 e 1. Assim sendo, informe, justificando sua
resposta, quantas faltas de pginas sero geradas com a utilizao de cada um
dos algoritmos de substituio de pginas abaixo relacionados:
a) FIFO
b) LRU
c) Segunda Chance
131) Qual a principal desvantagem de se utilizar no projeto de um sistema paginado um tamanho de pgina considerado muito grande? E muito pequeno?
132)
O que a anomalia de Belady?
133) Considere um sistema com memria virtual por paginao com endereo virtual com 24 bits e pgina com 2048 endereos. Na tabela de pginas a seguir, de
um processo em determinado instante, o bit de validade 1 indica pgina na memria principal e o bit de modificao 1 indica que a pgina sofreu alterao.
Pgina
0
1
2
3
4
5
BV
1
1
1
0
0
1
BM
1
0
1
1
0
0
End. do Frame
30.720
0
10.240
*
*
6.144
a) Quantos bits possui o campo deslocamento do endereo virtual?

b) Qual o nmero mximo de entradas que
a tabela de pginas pode ter?
c) Qual o endereo fsico que ocupa o ltimo endereo da pgina 2?
d) Qual o endereo fsico traduzido do endereo virtual (00080A)16?
e) Caso ocorra uma falta de pgina e uma
das pginas do processo deva ser descartada, quais pginas poderiam sofrer page
out?
134) Considere um sistema de memria virtual que implemente paginao, onde o

limite de frames por processo igual a trs. Descreva para os itens abaixo, onde
apresentada uma seqncia de referncias a pginas pelo processo, o nmero
total de faltas de pginas para as estratgias de realocao de pginas FIFO e
LRU. Indique qual a mais eficaz para cada item:
a) 1 / 2 / 3 / 1 / 4 / 2 / 5 / 3 / 4 / 3
b) 1 / 2 / 3 / 1 / 4 / 1 / 3 / 2 / 3 / 3
91
7 Memria Virtual
135) Em um sistema de memria virtual que implementa paginao, as pginas

tm 4 K endereos, a memria principal possui 32 KB e o limite de pginas na
memria principal de 8 pginas. Um programa faz referncia a endereos virtuais situados nas pginas 0, 2, 1, 9, 11, 4, 5, 2, 3, 1 nesta ordem. Aps essa seqncia de acessos, a tabela de pginas completa desse programa tem a configurao abaixo. As entradas em branco correspondem a pginas ausentes.
Pgina
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
End. Fsico
8K
4K
24 K
0K
16 K
12 K
*
*
*
20 K
*
28 K
*
*
*
*
a) Qual o tamanho (em bits) e o formato do endereo virtual?

b) O processo faz novas referncias a endereos
virtuais situados nas pginas 5, 15, 12, 8 e 0 nesta
ordem. Complete o quadro a seguir, que ilustra o
processamento dessa seqncia de acessos utilizando a estratgia de remoo FIFO. Mostre o estado final da tabela de pginas.
Pgina
Referenciada
5
15
12
8
0
Pgina
Removida
Falta de Pgina
(Sim / No)
136) Em um computador, o endereo virtual de 16 bits e as pginas tm tamanho

de 2K. O limite de pginas reais de um processo qualquer de quatro pginas. Inicialmente, nenhuma pgina est na memria principal. Um programa faz referncia a endereos virtuais situados nas pginas 0, 7, 2, 7, 5, 8, 9, 2 e 4, nesta
ordem.
a) Quantos bits do endereo virtual destinam-se ao nmero da pgina? E ao
deslocamento?
b) Ilustre o comportamento da poltica de substituio LRU mostrando, a cada
referncia, quais pginas esto em memria, as faltas de pginas e as pginas
escolhidas para descarte.
137) Um sistema trabalha com gerncia de memria virtual por paginao. Para todos os processos do sistema, o limite de pginas na memria principal igual a
10. Considere um processo que esteja executando um programa e em um determinado instante de tempo (T) a sua tabela de pginas possui o contedo a seguir.
O bit de validade igual a 1 indica pgina na memria principal e o bit de modificao igual a 1 indica que a pgina sofreu alterao.
Nmero
da Pgina
0
1
2
3
4
5
6
7
8
9
10
BV
BM
1
1
1
1
1
1
1
1
1
0
0
0
0
0
1
0
0
1
1
0
0
0
Endereo do
Frame (Hexa)
3303A5
AA3200
111111
BFDCCA
765BFC
654546
B6B7B0
999950
888BB8
N/A
N/A
Responda s perguntas abaixo, considerando que os seguintes eventos

ocorrero nos instantes de tempo
indicados:
(T + 1): O processo referencia um
endereo na pgina 9 com page
fault.
endereo na pgina 1.
fault.
f l
92
7 Memria Virtual
a) Em quais instantes de tempo ocorrem um page out?

b) Em que instantes de tempo o limite de pginas do processo na memria
principal atingido?
c) Caso a poltica de realocao de pginas utilizada seja o FIFO, no instante
(T + 1), qual a pgina que est h mais tempo na memria principal?
d) Como o sistema identifica que no instante de tempo (T + 2) no h ocorrncia de falta de pgina?
138) Um sistema possui quatro frames. A tabela abaixo apresenta para cada pgina
o momento da carga, o momento do ltimo acesso, o bit de referncia e o bit de
modificao. Responda:
Frame
0
1
2
3
Carga
126
230
120
160
Referncia
279
260
272
280
BR
0
1
1
1
BM
0
0
1
1
a) Qual pagina ser substituda

utilizando o algoritmo NRU?
b) Qual pagina ser substituda
utilizando o algoritmo FIFO?
c) Qual pagina ser substituda
utilizando o algoritmo LRU?
139) Considere um processo com limite de pginas reais igual a quatro e um sistema que implemente a poltica de substituio de pginas FIFO. Quantos page
faults ocorrero considerando que as pginas virtuais so referenciadas na seguinte ordem: 0172327103. Repita o problema utilizando a poltica LRU e Segunda Chance
140)
O que trashing?
-x-
93
8 Sistema de Arquivos
Sistema de Arquivos
Est na minha memria trancado e voc mesma guardar a chave.

(William Shakespeare)
8.1
INTRODUO
O sistema de arquivos a parte do Sistema Operacional mais visvel para os usurios. Por isso o sistema de arquivos deve apresentar uma interface coerente e simples.
Ao mesmo tempo, arquivos so normalmente implementados a partir de discos magnticos e como um acesso a disco demora cerca de 10000 vezes mais tempo do que um acesso memria principal, so necessrias estruturas de dados e algoritmos que otimizem os acessos a disco gerados pela manipulao de arquivos.
importante observar que sistemas de arquivos implementam um recurso em software que no existe no hardware. O hardware oferece simplesmente espao em disco,
na forma de setores que podem ser acessados individualmente, em uma ordem aleatria.
O conceito de arquivo, muito mais til que o simples espao em disco, uma abstrao
criada pelo Sistema Operacional. Neste caso, temos o Sistema Operacional criando um
recurso lgico a partir dos recursos fsicos existentes no sistema computacional.
8.2
HIERARQUIA DE DADOS
Informaes so armazenadas em computadores segundo uma hierarquia de dados.

O nvel, mais baixo composto de bits. Bits so agrupados em padres de bits para
representar itens de dados de interesse em sistemas de computador. H 2n padres de
bits possveis para uma srie de n bits.
O nvel seguinte da hierarquia de dados representa padres de bits de tamanho fixo,
como bytes, caracteres e palavras. Quando se refere a armazenamento, um byte normalmente so 8 bits. Uma palavra representa o nmero de bits sobre os quais um processador pode operar de uma s vez. Assim, uma palavra so 4 bytes em processadores
de 32 bits e 8 bytes em processador de 64 bits.
Caracteres mapeiam bytes (ou grupos de bytes) para smbolos como letras, nmeros, pontuao e novas linhas. Muitos sistemas usam caracteres de 8 bits e, portanto,
podem ter 28, ou 256 caracteres possveis em seus conjuntos de caracteres. Os trs
conjuntos de caracteres mais populares em uso hoje so o ASCII (American Standard
Code for Information Interchange), o EBCDIC (Extended Binary Coded Decimal Interchange Code) e o Unicode.
O ASCII armazena caracteres como bytes de 8 bits e, assim, pode ter 256 caracteres
possveis em seu conjunto de caracteres. Devido ao pequeno tamanho de caracteres do
ASCII, ele no suporta conjuntos de caracteres internacionais. O EBCDIC frequentemente usado para representar dados em sistemas de computadores de grande porte
(mainframes), particularmente nos sistemas desenvolvidos pela IBM; tambm armazena
caracteres de 8 bits.
Unicode um padro reconhecido internacionalmente, bastante usado em aplicaes
da Internet e multilnges. Seu objetivo utilizar um nico nmero para representar cada caractere em todos os idiomas do mundo. O Unicode fornece representaes de 8, 16
e 32 bits do seu conjunto de caracteres. Para simplificar a converso de caracteres ASCII
em Unicode, a representao de 8 bits do Unicode, denominada UTF-8 (Unicode Character Set Translation Format-8 bits), corresponde diretamente ao conjunto de caracteres
ASCII. Arquivos HTML normalmente so codificados usando UTF-8. UTF-16 e UTF-32 oferecem conjuntos de caracteres maiores, que habilitam aplicaes a armazenar informaes que contenham caracteres de vrios alfabetos como o grego, o cirlico, o chins e
muitos outros. Todavia, exigem arquivos maiores para armazenar o mesmo nmero de
94
caracteres em comparao com o UTF-8. Por exemplo, a srie de 12 caracteres Hello

Word requer 12 bytes de armazenamento usando caracteres de 8 bits, 24 bytes usando
caracteres de 16 bits e 48 bytes usando caracteres de 32 bits.
Um campo um grupo de caracteres (por exemplo, o nome, o endereo ou o nmero de telefone de uma pessoa). Um registro um conjunto de campos. Um arquivo
um grupo de registros relacionados. O nvel mais alto da hierarquia de dados um sistema de arquivo ou banco de dados. Sistemas de arquivos so colees de arquivos, ou
colees de dados.
O termo volume representa uma unidade de armazenamento de dados que pode
conter vrios arquivos. Um volume fsico limitado a um nico dispositivo de armazenamento; um volume lgico como um volume que poderia ser utilizado em uma mquina
virtual pode estar disperso por muitos dispositivos. Exemplos de volumes so CDs,
DVDs, fitas e discos rgidos.
8.3
ARQUIVOS
So recipientes que contm dados. Cada arquivo identificado por um nome e por
uma srie de outros atributos que so mantidos pelo sistema operacional: tipo do contedo, tamanho, ltimo acesso, ltima alterao.
O Sistema Operacional suporta diversas operaes sobre arquivos, como criao,
destruio, leitura, alterao, etc. Em geral, essas operaes correspondem a chamadas
de sistema que os programas de usurios podem usar para manipular arquivos.
Existe, na prtica, uma enorme quantidade de diferentes tipos de arquivos, cada tipo
com sua estrutura interna particular. No vivel para o sistema operacional conhecer
todos os tipos de arquivos existentes. Em geral, os sistemas operacionais ignoram a estrutura interna dos arquivos.
Para o sistema operacional, cada arquivo corresponde a uma seqncia de bytes, cujo significado conhecido pelo usurio que criou o arquivo. A nica exceo so os arquivos que contm programas executveis. Nesse caso, a estrutura interna definida pelo
prprio sistema operacional, responsvel pela carga do programa para a memria quando esse deve ser executado.
Como o conceito de tipo de arquivo til para os usurios, muitos sistemas operacionais suportam nomes de arquivos onde o tipo indicado. A forma usual acrescentar
uma extenso no nome que identifique o tipo do arquivo em questo.
Arquivos podem consistir em um ou mais registros. Um registro fsico (ou bloco fsico)
a unidade de informao realmente lida de ou escrita para um dispositivo de armazenamento. Um registro lgico (ou bloco lgico) uma coleo de dados tratada como uma
unidade pelo software. Quando cada registro fsico contm exatamente um registro lgico, diz-se que o arquivo consiste em registros no blocados. Em um arquivo com registros de tamanho fixo, todos os registros tm o mesmo tamanho; o tamanho do bloco ,
ordinariamente, um mltiplo inteiro do tamanho do registro. Em um arquivo com registros de tamanhos variveis, os tamanhos dos registros podem variar at o tamanho do
bloco.
8.4
SISTEMAS DE ARQUIVOS
Um sistema de arquivo organiza arquivos e gerencia o acesso aos dados. Eles so

responsveis por:
Gerenciamento de arquivos fornecer os mecanismos para que os arquivos
sejam armazenados, referidos, compartilhados e fiquem em segurana.
Gerenciamento de armazenamento auxiliar alocar espao para arquivos em
dispositivos de armazenamento secundrio.
Mecanismos de integridade do arquivo garantir que as informaes armazenadas em um arquivo no sejam corrompidas. Quando a integridade do arquivo assegurada, os arquivos contm somente as informaes que devem
conter.
Mtodos de acesso como os dados armazenados podem ser acessados.
95
8.4.1
DIRETRIOS
Considere um sistema de compartilhamento de grande escala que suporte uma grande comunidade de usurios. Cada usurio pode conter vrias contas; cada conta pode ter
muitos arquivos. Alguns arquivos podem ser pequenos, como mensagens de e-mail; outros podem ser grandes, como listas de um controle de estoque.
comum que contas de usurios contenham centenas e at milhares de arquivos.
Com uma comunidade de vrios milhares de usurios, os discos de um sistema poderiam
facilmente conter milhes de arquivos. Esses arquivos precisam ser acessados rapidamente para limitar os tempos de resposta.
Para organizar e localizar arquivos rapidamente, sistemas de arquivos usam diretrios, que so arquivos que contm os nomes e as localizaes de outros arquivos do sistema de arquivos. Diferentemente de outros arquivos, um diretrio no armazena dados de usurios, mas campos como nome, localizao, tamanho, tipo, horrio de acesso,
de modificao e de criao do arquivo.
Sistema de Arquivo de nvel nico
A organizao mais simples de sistemas de arquivo uma estrutura de diretrio de
nvel nico (ou plana). Nessa implementao, o sistema de arquivo armazena todos os
seus arquivos utilizando um s diretrio. Em um sistema de arquivo de nvel nico, dois
arquivos no podem ter o mesmo nome. Porque a maioria dos ambientes contm um
grande nmero de arquivos, muitos dos quais usam o mesmo nome, tais sistemas de
arquivos so raramente implementados.
Sistema de Arquivo estruturado hierarquicamente
Um sistema de arquivo mais apropriado para a maioria dos ambientes pode ser organizado da maneira como apresentado na figura a seguir. Uma raiz indica em que lugar
do dispositivo de armazenamento comea o diretrio-raiz.
Diretrioraiz
Usurio
1
Usurio
2
Usurio
3
O nome de um arquivo usualmente formado como o nome de caminho desde o diretrio-raiz at o arquivo. Por exemplo, em um sistema de arquivo de dois nveis com os
usurios BRUNA, ANDRE e SOFIA, no qual ANDRE tem os arquivos MESADA e ESTUDOS,
o nome do caminho para o arquivo MESADA poderia ser formado como RAIZ:ANDRE:MESADA. Nesse exemplo, RAIZ indica o diretrio-raiz.
Sistemas hierrquicos de arquivo so implementados pela maioria dos sistemas de
arquivos de propsito geral, mas o nome do diretrio-raiz pode variar entre sistemas de
arquivos. O diretrio-raiz de um sistema de arquivo do Windows especificado por uma
letra seguida de dois pontos (por exemplo, C:) e sistema de arquivo baseados no Unix
usam uma barra inclinada ( / ). No Windows o exemplo utilizado acima seria
C:\ANDRE\MESADA e no Unix seria /ANDRE/MESADA.
96
Nomes de caminhos relativos

Muitos sistemas de arquivos suportam a noo de um diretrio de trabalho para
simplificar a navegao usando nomes de caminhos. O diretrio de trabalho (representado pela entrada de diretrio . nos sistemas de arquivo do Windows e baseados no Unix)
habilita usurios a especificar um nome de caminho que no comece no diretrio-raiz.
Por exemplo, suponha que o diretrio de trabalho corrente tenha sido designado
/home/hmd/ em um sistema de arquivos. O nome de caminho relativo para
/home/hmd/lucilia/cap8 seria ./lucilia/cap8. Essa caracterstica reduz o tamanho do nome de caminho para acessar arquivos. Quando um sistema de arquivos encontra um
nome de caminho relativo, forma um nome de caminho absoluto (ou seja, o caminho
que comea na raiz) concatenando o diretrio de trabalho e o caminho relativo. O sistema de arquivo ento percorre a estrutura de diretrio para localizar o arquivo requisitado.
O sistema de arquivo normalmente mantm uma referncia ao diretrio-pai do diretrio de trabalho, ou seja, o diretrio que est um nvel acima na hierarquia do sistema
de arquivo. No Windows e nos sistemas baseados em Unix, .. uma referncia ao diretrio-pai.
Ligao (link) uma entrada de diretrio que se refere a um arquivo de dados ou diretrio que normalmente est localizado em um diretrio diferente. Usurios comumente
empregam ligaes para simplificar a navegao do sistema de arquivos e compartilhar
arquivos. Por exemplo, suponha que o diretrio de trabalho de um usurio seja
/home/drc/ e o usurio compartilhe os arquivos de um outro usurio localizado no diretrio /home/hmd/lucilia. Criando uma ligao para /home/hmd/lucilia no diretrio de trabalho do usurio, esse pode acessar os arquivos compartilhados simplesmente por meio do
nome de caminho relativo lucilia/.
Ligao flexvel (tambm chamada de ligao simblica, atalho ou apelido), uma
entrada de diretrio que contm o nome de caminho para um outro arquivo. O sistema
de arquivos localiza o alvo da ligao flexvel percorrendo a estrutura do diretrio por
meio do nome de caminho especificado.
Ligao estrita uma entrada de diretrio que especifica a localizao do arquivo
(normalmente um nmero de bloco) no dispositivo de armazenamento. O sistema de
arquivo localiza os dados do arquivo da ligao estrita acessando diretamente o bloco
fsico a que ela se refere.
A figura abaixo ilustra a diferena entre ligaes flexveis e ligaes estritas. Os arquivos hoje e ontem esto localizados nos blocos nmero 467 e 843, respectivamente. A
entrada de diretrio hoje_hard uma ligao estrita, porque especifica o mesmo nmero
de bloco (467) da entrada do diretrio hoje. A entrada de diretrio hoje_soft uma ligao flexvel, porque especifica o nome do caminho para hoje (neste caso, ./hoje)
Ligao
Flexvel
Nome
hoje
Ontem
.
.
.
hoje_hard
hoje_soft
8.4.2
Diretrio
Localizao
467
843
.
.
.
467
Ligao estrita para hoje
./hoje
METADADOS
A maioria dos sistemas de arquivo armazena outros dados alm dos dados de usurio
e diretrio, como a localizao dos blocos livres de um dispositivo de armazenamento
(para garantir que um novo arquivo no sobrescreva blocos que esto sendo usados) e o
horrio em que um arquivo foi modificado. Essas informaes, denominadas metadaSistemas Operacionais Lucilia Ribeiro
97
dos, protegem a integridade dos dados e no podem ser modificadas diretamente por
usurios.
Antes de um sistema de arquivo poder acessar dados, seu dispositivo de armazenamento precisa ser formatado. Formatar uma operao dependente do sistema, mas
normalmente implica inspecionar o dispositivo de armazenamento em busca de quaisquer setores no utilizveis, apagando quaisquer dados que estejam no dispositivo e criando o diretrio-raiz do sistema de arquivo.
Descritores de arquivo
A forma bsica de implementar arquivos criar, para cada arquivo no sistema, um
descritor de arquivo. O descritor de arquivo um registro no qual so mantidas as informaes a respeito do arquivo: nome, extenso, tamanho, datas, usurios, etc.
O descritor de arquivo deve ficar em disco e de preferncia na mesma partio do arquivo. S que, se a cada acesso ao descritor, o SO precisasse ler do disco, o sistema de
arquivos teria um pssimo desempenho.
Para tornar mais rpido o acesso aos arquivos, o sistema de arquivos mantm na
memria uma tabela contendo todos os descritores dos arquivos em uso, chamado Tabela dos Descritores de Arquivos Abertos (TDAA). Quando um arquivo entra em uso, o seu
descritor copiado do disco para a memria.
Quando o processo que est sendo executado faz uma chamada para abrir um arquivo (open), o sistema de arquivos realiza as seguintes tarefas:
Localiza no disco o descritor de arquivo cujo nome foi fornecido. Caso o arquivo no
exista, retornado um cdigo de erro, que passado para o processo que chamou o open. No caso de sucesso, retorna o par <partio, endereo do descritor>.
Verifica se o arquivo solicitado j se encontra aberto. Isso feito atravs de uma
pesquisa na TDAA. Tal pesquisa feita tendo como chave no o nome do arquivo, mas
sim o nmero da partio e o endereo do descritor.
Caso o arquivo no esteja aberto, aloca uma entrada livre na TDAA e copia o descritor do arquivo que est no disco para a entrada alocada na TDAA.
Uma vez que o descritor do arquivo foi copiado para a memria, verifica se o processo em questo tem o direito de abrir o arquivo conforme solicitado. Se no tiver, a entrada na TDAA liberada e o open retorna um cdigo de erro.
A partir desse momento, o arquivo est aberto e pode ser acessado. Quando um processo realiza a chamada de sistema close, o nmero de processos utilizando o arquivo
em questo decrementado na sua respectiva entrada da TDAA. Quando esse nmero
chega a zero, significa que nenhum processo est usando o arquivo. Nesse caso, o descritor do arquivo atualizado em disco e a entrada da TDAA liberada.
As entradas da TDAA armazenam informaes que no variam conforme o processo
que est acessando o arquivo. Por exemplo, o tamanho do arquivo o mesmo, no importa qual processo execute o read ou write. Entretanto, existem informaes diretamente associadas com o processo que acessa o arquivo. Como por exemplo a posio corrente no arquivo. Em um dado instante, cada processo deseja acessar uma parte diferente
do arquivo. Da mesma forma, alguns processos podem abrir o arquivo para apenas leitura, enquanto outros abrem para leitura e escrita.
Essas informaes no podem ser mantidas na TDAA pois, como vrios processos podem acessar o mesmo arquivo, elas possuiro um valor diferente para cada processo. A
soluo criar, para cada processo, uma Tabela de Arquivos Abertos por Processo (TAAP). Cada processo possui a sua TAAP. Cada entrada ocupada na TAAP corresponde a um
arquivo aberto pelo processo correspondente. No mnimo, a TAAP contm em cada entrada: posio corrente no arquivo, tipo de acesso e apontador para a entrada correspondente na TDAA.
No exemplo, o processo 0 acessa o arquivo B atravs de referncias a entrada 1 da
sua TAAP. Muitos sistemas operacionais chamam esse nmero de handle do arquivo.
98
TAAP do Processo
0
Pos.Cor.12
Leitura
0
1
Pos.Cor.55
Leitura/Escrita
TDAA
0
Arquivo
A
1
2
Arquivo
B
3
TAAP do Processo
1
Pos.Cor.10
Leitura
8.4.3
MONTAGEM
Usurios muitas vezes requerem acesso a informaes que no fazem parte do sistema de arquivo nativo (o sistema de arquivo que est permanentemente montado em
um sistema particular e cuja raiz referida pelo diretrio-raiz). Por exemplo, muitos usurios armazenam dados em um segundo disco rgido, em DVD, ou em uma outra estao
de trabalho. Por essa razo, sistemas operacionais fornecem a capacidade de montar
vrios sistemas de arquivos. A montagem combina vrios sistemas de arquivos em um
nico espao de nomes um conjunto de arquivos que pode ser identificado por um
nico sistema de arquivo. O espao de nomes unificado permite que usurios acessem
dados de diferentes localizaes como se todos os arquivos estivessem posicionados dentro do sistema de arquivos nativo.
O comando montar designa um diretrio do sistema de arquivo nativo, denominado
ponto de montagem, para a raiz do sistema de arquivos montado. Os primeiros sistemas de arquivo windows apresentavam uma estrutura de montagem achatada; cada sistema de arquivo montado era designado por uma letra e localizado no mesmo nvel da
estrutura do diretrio. Por exemplo, normalmente o sistema de arquivo que continha o
sistema operacional era montado em C: e o sistema de arquivo seguinte, em D:.
Sistemas de arquivos compatveis com Unix, apresentam pontos de montagem que
podem ser localizados em qualquer lugar do sistema de arquivos. O contedo do diretrio
do sistema de arquivo nativo no ponto de montagem fica temporariamente oculto enquanto um outro sistema de arquivo montado naquele diretrio.
Em sistemas unix, alguns sistemas de arquivo so montados em um dos diretrios localizados em /mnt. Considere a figura a seguir. O comando de montagem coloca a raiz do
sistema de arquivo B sobre o diretrio /mnt/newfs/ do sistema de arquivo A. Aps a operao de montagem, os arquivos do sistema B podem ser acessador por meio de /mnt/newfs/
do sistema de arquivo A. Quando um sistema de arquivo montado, o contedo do diretrio no ponto de montagem fica disponvel para usurios at que o sistema de arquivo
seja desmontado.
A maioria dos sistemas operacionais suporta vrios sistemas de arquivos para armazenamento removvel, como o Universal Disk Format (UDF) para DVDs e o sistema de
arquivo ISO 9660 para CDs. Uma vez determinado o tipo de sistema de arquivo do dispositivo, o sistema operacional usa o sistema de arquivo apropriado para acessar o arquivo no dispositivo especificado. O comando desmontar permite que o usurio desconecte sistemas de arquivos montados. Essa chamada atualiza a tabela de montagem e
habilita o usurio a acessar quaisquer arquivos que estejam ocultos pelo sistema montado.
99
Sistema de Arquivo B
Sistema de Arquivo A
usr
home
usr
mnt
ontem
newfs
hoje
home
mnt
bin
Sistema de arquivo B montado no diretrio /mnt/newfs do sistema de arquivo A
usr
home
ontem
mnt
hoje
usr
newfs
home
mnt
bin
8.5
ORGANIZAO DE ARQUIVO
Organizao de arquivo refere-se maneira como os registros de um arquivo so organizados no armazenamento secundrio. Diversos esquemas de organizao de arquivo
foram implementados:
Seqencial: Registros so colocados em ordem fsica. O registro seguinte aquele
que vem depois, fisicamente, do registro anterior. Essa organizao natural para arquivos armazenados em fita magntica, um meio inerentemente seqencial. Arquivos de
disco tambm podem ser organizados sequencialmente mas, por vrias razes, os registros de um arquivo seqencial no so necessariamente armazenados contiguamente.
Direto: Registros so acessados diretamente (aleatoriamente) por seus endereos fsicos em um dispositivo de armazenamento de acesso direto. O usurio da aplicao coloca os registros em qualquer ordem adequada para uma aplicao particular.
Seqencial indexado: Registros em disco so organizados em seqncia lgica de
acordo com uma chave contida em cada registro. O sistema mantm um ndice contendo
os endereos fsicos de certos registros principais. Registros seqenciais indexados poSistemas Operacionais Lucilia Ribeiro
100
dem ser acessados sequencialmente pela ordem das chaves, ou podem ser acessados
diretamente pesquisando-se o ndice criado pelo sistema.
Particionado: , essencialmente, um arquivo de subarquivos seqenciais. Cada subarquivo seqencial denominado membro. O endereo de incio de cada membro armazenado no diretrio do arquivo. Arquivos particionados tm sido usados para armazenar bibliotecas de programas.
8.6
MTODOS DE ALOCAO
Para o sistema operacional, cada arquivo corresponde a uma seqncia de blocos lgicos, numerados a partir do zero. preciso mapear os nmeros de blocos lgicos desse
arquivo em nmeros de blocos fsicos. A maneira como o mapeamento realizado depende de como mantida a informao onde o arquivo est no disco.
8.6.1
ALOCAO CONTGUA
DISCO
Bloco Fsico
0
1
2
3
Bloco 0
Descritor
Bloco 1
Incio: 3
Bloco 2
Tamanho: 6
Bloco 3
Bloco 4
Bloco 5
9
10
11
12
13
Dos mtodos que objetivam associar blocos de disco a arquivos existentes, a alocao contgua o mais simples. Neste mtodo, os arquivos so armazenados no disco
como um bloco contguo de dados. Assim, para armazenar um arquivo de 70K em um
disco com blocos de 1K seriam necessrios 70 blocos consecutivos.
Vantagens:
Simplicidade de implementao, pois para se acessar todo o arquivo basta que seja
conhecido o endereo de seu primeiro bloco;
Performance excelente, pois a leitura do arquivo em disco pode acontecer em uma
nica operao.
Desvantagens:
O tamanho mximo do arquivo tem que ser conhecido no momento em que ele for
criado;
Ocasiona fragmentao no disco.
8.6.2 ALOCAO COM LISTA LIGADA
Neste mtodo, cada bloco fsico contm o endereo do prximo bloco fsico alocado a
esse mesmo arquivo.
101
Vantagens:
Evita-se a perda de espao em disco ocasionado pela fragmentao;
Para se acessar todo o arquivo, basta que seja conhecido o endereo de seu primeiro bloco.
Desvantagens:
Acesso randmico lento e difcil de ser implementado
DISCO
Bloco Fsico
0
1
Bloco 3
Bloco 0
2
3
Descritor
4
5
Incio: 3
Bloco 2
Bloco 4
11
Bloco 1
Bloco 5
-1
Tamanho: 6
9
10
11
12
13
8.6.3 ALOCAO COM LISTA LIGADA USANDO UM NDICE
Com a finalidade de se eliminar os problemas encontrados no caso anterior, nesse
mtodo, cada arquivo possui uma tabela de ndices. Cada entrada da tabela de ndices
contm o endereo de um dos blocos fsicos que forma o arquivo, chamados blocos de
ndices.
Blocos de ndices so denominados inodes (index nodes ns de ndice) em sistemas operacionais baseados no unix. O inode de um arquivo armazena os atributos do
arquivo, como seu proprietrio, tamanho, data e horrio de criao. Armazena tambm
os endereos de alguns dos blocos de dados do arquivo e ponteiros para blocos de continuao de ndices, denominados blocos indiretos. Estruturas de inodes suportam at
trs nveis de blocos indiretos. O primeiro bloco aponta para blocos de dados; esses blocos de dados so unicamente indiretos. O segundo bloco indireto contm ponteiros que
se referem somente a outros blocos indiretos; esses blocos indiretos apontam para blocos de dados duplamente indiretos. O terceiro bloco indireto aponta somente para outros
blocos indiretos que apontam somente para mais blocos indiretos, que apontam para
blocos de dados; esses blocos de dados so triplamente indiretos. O poder dessa estrutura hierrquica que ela estabelece um limite relativamente baixo ao nmero mximo de
ponteiros que devem ser seguidos para localizar dados de arquivo ela habilita os inodes
a localizar qualquer bloco de dados seguindo no mximo quatro ponteiros (o inode e at
trs nveis indiretos).
Vantagens:
Facilidade para se implementar um acesso randmico rpido, pois as entradas a serem seguidas encontram-se na memria
Para se acessar todo o arquivo basta que a entrada de diretrio contenha o endereo de seu primeiro bloco.
102
Desvantagens: Toda a tabela deve estar na memria durante todo o tempo.

DISCO
Bloco Fsico
DESCRITOR
0
1
Tamanho: 5
Bloco 3
ndices: 0
2
3
Bloco 0
4
5
Bloco 2
8.7
Bloco 4
Bloco 1
GERNCIA DE ESPAO EM DISCO
Existem alguns mtodos que objetivam associar blocos de disco a arquivos existentes, no entanto, algumas consideraes necessitam ser feitas com relao ao tamanho do
bloco (unidade de alocao):
Unidade de alocao muito grande: causar desperdcio de espao dentro da unidade
de alocao quando o arquivo for menor que a mesma;
Unidade de alocao muito pequena: um arquivo de tamanho razovel ser composto
de vrias unidades de alocao (blocos) e a sua leitura do disco ser lenta, pois a leitura
de cada um dos blocos leva um certo tempo, devido ao tempo de seek e latncia rotacional do disco.
Obs.: Normalmente, temos blocos de tamanhos que variam de 512 bytes at 2KB.
8.8
CONTROLE DE BLOCOS LIVRES
Existem quatro maneiras mais usuais de se realizar o controle dos blocos no utilizados do disco. Para exemplificar, tomaremos a seguinte memria, considerando blocos
preenchidos como ocupados e em branco como livres:
00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
8.8.1 MAPA DE BITS

Cada bloco representado por 1 bit. Se o bloco estiver livre, o bit ser 1; se ele estiver alocado, o bit ser 0. O mapa de bits para a memria acima seria:
11110000 00001111 11111110 00000000 11111111 00000000
8.8.2 LISTA ENCADEADA
Outra abordagem encadear os blocos de discos livres, mantendo um ponteiro ao
primeiro bloco livre. Tal bloco contm um ponteiro ao prximo bloco livre, e assim por
diante. A lista encadeada para o mesmo exemplo acima:
4 5, 5 6, 6 7, 7 8, 8 9, 9 10, 10 11, 11 23, 23 24, 24 25, 25
26, 26 27, 27 28, 28 29, 29 30, 30 31, 31 40, 40 41, 41 42...
103
8.8.3 AGRUPAMENTO
Uma modificao da abordagem de lista livre armazenar os endereos de n blocos
livres no primeiro bloco livre. Os primeiros n-1 desses blocos esto realmente livres. O
bloco final contm os endereos de outros n blocos livres, e assim por diante. A lista de
agrupamento para a memria acima, considerando um n = 4, seria:
4 5, 6, 7, 8
8 9, 10, 11, 23
23 24, 25, 26, 27
27 28, 29, 30, 31
31 40, 41, 42, 43
43 44, 45, 46, 47
8.8.4 CONTADORES
Outra abordagem aproveitar o fato de que, em geral, vrios blocos contguos podem ser alocados ou liberados simultaneamente, sobretudo quando o espao alocado
com o algoritmo de alocao contgua. Portanto, em vez de manter uma lista de n endereos de disco livres, podemos manter o endereo do primeiro bloco livre e o nmero n
de blocos contguos livres que seguem esse primeiro bloco. Assim ficaria a tabela de contadores:
Bloco Inicial
8.9
Quantidade de Blocos
4
23
40
CONSISTNCIA EM BLOCOS
Neste tipo de verificao, o programa utilitrio constri uma tabela possuindo dois
contadores: um indica quantas vezes um determinado bloco est presente em um arquivo e o outro informa quantas vezes um determinado bloco aparece como estando livre.
Situaes indesejadas possveis:
Um bloco no possui ocorrncia em nenhum arquivo e ele tambm no aparece na lista de blocos livres (bloco perdido).
Soluo: colocar o bloco perdido na lista de blocos livres.
Um bloco aparece duas vezes na lista de blocos livres.
Soluo: reconstruir a lista de blocos livres.
Um bloco est presente em mais de um arquivo.
Soluo: alocar um novo bloco e copiar nele o contedo do bloco problemtico. Em

seguida, fazer um dos arquivos apontar para este novo bloco.
Um bloco est presente em um arquivo e tambm na lista de blocos livres.
Soluo: remover o bloco da lista de blocos livres.

8.10
EXERCCIOS
141) Considerando que a unidade de alocao fsica de 2k, o tamanho da memria secundria de 64k e a primeira unidade de alocao est ocupada com a tabela de arquivos, faa o mapa de bits final depois de todos os passos a seguir. Em
seguida, faa a tabela de contadores, de agrupamento e a lista ligada mostrando
os espaos livres. Considere n = 4.
a) Escrever o arquivo A de 11k
b) Escrever o arquivo B de 6k
c) Remover o arquivo A
d) Alocar o arquivo C seqencial, de 15k.
e) Escrever o arquivo D com 31K, no seqencial.
104
f) Remover o arquivo B
142) Qual a diferena entre fragmentao externa e fragmentao interna? Demonstre graficamente.
143) Relacione a Tabela de Descritores de Arquivos Abertos (TDAA) e a Tabela de
Arquivos Abertos por Processo (TAAP), ilustrando e citando exemplos. Simule situaes de processos sendo executados e abrindo ou criando arquivos.
144) Cite as vantagens e desvantagens dos mtodos de alocao: contgua, encadeada e indexada. Demonstre atravs de figuras.
145) Existem alguns mtodos que objetivam associar blocos de disco a arquivos existentes. No entanto, algumas consideraes necessitam ser feitas com relao
ao tamanho do bloco. Porque no se deve ter unidades de alocao nem to
grandes nem to pequenas?
146) Considere que o sistema operacional XYZ utiliza contadores para o controle de
seus blocos livres. A lista est reproduzida abaixo. Monte o mapa de bits, agrupamento e a lista encadeada partindo dos contadores observados. Considere n=3.
26
10
02
147) Partindo agora de um mapa de bits utilizado para controle de blocos livres,
monte uma tabela de agrupamento, considerando n = 5: 11101101 10101000
11001100 11100000 11111011 00100100 00000000
148) Descreva as vantagens e desvantagens de armazenar dados de controle de
acesso como parte do bloco de controle de arquivo
-x-
105
9 Gerncia de Dispositivos
Gerncia de Dispositivos
O caminho do dever encontra-se no que est perto,

e o homem o procura no que est distante.
(Mncio)
9.1
INTRODUO
A Gerncia de Dispositivos de entrada/sada uma das principais e mais complexas

funes de um Sistema Operacional. Sua implementao estruturada atravs de camadas. As camadas de mais baixo nvel escondem caractersticas dos dispositivos das camadas superiores, oferecendo uma interface simples e confivel ao usurio e suas aplicaes.
As camadas so divididas em dois grupos, onde o primeiro grupo visualiza os diversos
tipos de dispositivos do sistema de um modo nico (Fig. a), enquanto o segundo especfico para cada dispositivo (Fig. b). A maior parte das camadas trabalha de forma independente do dispositivo.
9.2
ACESSO AO SUBSISTEMA DE ENTRADA E SADA
O Sistema Operacional deve tornar as operaes de E/S o mais simples possvel para
o usurio e suas aplicaes. Para isso, o sistema possui um conjunto de rotinas, denominado rotinas de entrada/sada, que faz parte do subsistema de E/S e permite ao usurio
realizar operaes de E/S sem se preocupar com detalhes do dispositivo que est sendo
acessado. Nesse caso, quando um usurio cria um arquivo em disco, no lhe interessa
como a formatao do disco, nem em que trilha ou setor o arquivo ser gravado.
106
As operaes de E/S devem ser realizadas atravs de chamadas de sistemas que

chamam as rotinas de E/S do ncleo do Sistema Operacional. Dessa forma, possvel
escrever um programa que manipule arquivos, estejam eles em disquetes, discos rgidos ou CD-Rom,
sem ter que alterar o cdigo para cada tipo de dispositivo.
A maneira mais simples de ter acesso a um dispositivo atravs de comandos de leitura/gravao e
chamadas a bibliotecas de rotinas oferecidas por linguagens de alto nvel, como C. A comunicao entre
os comandos de E/S oferecidos pelas linguagens de
programao de alto nvel e as chamadas de sistema
de E/S feita simplesmente atravs de passagem de
parmetros.
Um dos objetivos principais das chamadas de sistema de E/S simplificar a interface entre as aplicaes e os dispositivos. Com isso, elimina-se a necessidade de duplicao de rotinas idnticas nos diversos
aplicativos, alm de esconder do programador caractersticas especficas associadas programao de
cada dispositivo.
As operaes de E/S podem ser classificadas conforme o seu sincronismo. Uma operao dita sncrona quando o processo que realizou a operao fica
aguardando no estado de espera pelo seu trmino.
Assncrona quando o processo que realizou a operao no aguarda pelo seu trmino e continua pronto para ser executado. Neste caso, o
sistema deve oferecer algum mecanismo de sinalizao que avise ao processo que a operao foi terminada.
9.3
SUBSISTEMA DE ENTRADA E SADA
O subsistema de E/S responsvel por realizar as funes comuns a todos os tipos

de dispositivos. a parte do Sistema Operacional que oferece uma interface uniforme
com as camadas superiores.
Independncia de Dispositivos: Cada dispositivo trabalha com unidades de informao de tamanhos diferentes, como caracteres ou blocos. O subsistema de E/S responsvel por criar uma unidade lgica de transferncia do dispositivo e repass-la para os
nveis superiores, sem o conhecimento do contedo da informao.
Tratamento de Erros: Normalmente, o tratamento de erros nas operaes de E/S
realizado pelas camadas mais prximas ao hardware. Existem, porm, certos erros que
podem ser tratados e reportados de maneira uniforme pelo sistema de arquivos, independentemente do dispositivo. Erros como a gravao em dispositivos de entrada, leitura
em dispositivos de sada e operaes em dispositivos inexistentes podem ser tratados
nesse nvel.
Compartilhamento: Todos os dispositivos de E/S so controlados, com o objetivo de
obter o maior compartilhamento possvel entre os diversos usurios de forma segura e
confivel. Alguns dispositivos podem ser compartilhados simultaneamente, outros, como
a impressora, devem ter acesso exclusivo, e o sistema deve controlar seu compartilhamento de forma organizada. responsvel tambm por implementar todo um mecanismo de proteo de acesso aos dispositivos. No momento que o usurio realiza uma operao de E/S, verificado se o seu processo possui permisso para realizar a operao.
Bufferizao: Essa tcnica permite reduzir o nmero de operaes de E/S, utilizando
uma rea de memria intermediria chamada de buffer. Por exemplo, quando um dado
lido do disco, o sistema traz para a rea de buffer no s o dado solicitado, mas um bloco de dados. Caso haja uma solicitao de leitura de um novo dado que pertena ao bloSistemas Operacionais Lucilia Ribeiro
107
co anteriormente lido, no existe a necessidade de uma nova operao de E/S, melhorando desta forma a eficincia do sistema.
Interface Padronizada: O subsistema de E/S deve oferecer uma interface padronizada
que permita a incluso de novos drivers sem a necessidade de alterao da camada de
subsistema de E/S.
9.4
DEVICE DRIVERS
Tem como funo implementar a comunicao do subsistema de E/S com os dispositivos, atravs de controladores. Os drivers tratam de aspectos particulares dos dispositivos. Recebem comandos gerais sobre acessos aos dispositivos e traduzem para comandos especficos, que podero ser executados pelos controladores. Alm disso, o driver
pode realizar outras funes, como a inicializao do dispositivo e seu gerenciamento.
Por exemplo, na leitura sncrona de um dado em disco, o driver recebe a solicitao de um determinado bloco e informa ao controlador o disco, cilindro, trilha e
setor que o bloco se localiza, iniciando, dessa forma, a
operao. Enquanto se realiza a leitura, o processo que
solicitou a operao colocado no estado de espera at
que o controlador avise a UCP do trmino da operao
atravs de uma interrupo que, por sua vez, ativa novamente o driver. Aps verificar a inexistncia de erros,
o driver transfere as informaes para a camada superior. Com os dados disponveis, o processo pode ser retirado do estado de espera e retornar ao estado de pronto
para continuar seu processamento.
Os drivers fazem parte do ncleo do Sistema Operacional, sendo escritos geralmente

em assembly. Devido ao alto grau de dependncia entre os drivers e o restante do ncleo do SO, os fabricantes desenvolvem, para um mesmo dispositivo, diferentes drivers,
um para cada Sistema Operacional. Sempre que um novo dispositivo instalado, o driver
deve ser adicionado ao ncleo do sistema. Nos sistemas mais antigos, a incluso de um
novo driver significava a recompilao do kernel, uma operao complexa e que exigia a
reinicializao do sistema. Atualmente, alguns sistemas permitem a fcil instalao de
novos drivers sem a necessidade de reinicializao.
9.5
CONTROLADORES
So componentes de hardware responsveis por manipular diretamente
os dispositivos de E/S. Possuem memria e registradores prprios utilizados
na execuo de instrues enviadas
pelo driver. Em operaes de leitura, o
controlador deve armazenar em seu
buffer interno uma seqncia de bits
proveniente do dispositivo at formar
um bloco. Aps verificar a ocorrncia
de erros, o bloco pode ser transferido
para um buffer de E/S na memria
principal. A transferncia do bloco pode
108
ser realizado pela UCP ou por um controlador de DMA (Acesso Direto Memria). O uso
da tcnica de DMA evita que o processador fique ocupado com a transferncia do bloco
para a memria.
De forma simplificada, uma operao de leitura em disco utilizando DMA teria os seguintes passos: 1) A UCP, atravs do driver, inicializa os registradores do controlador de
DMA e, a partir desse ponto, fica livre para realizar outras atividades. 2) O controlador de
DMA solicita ao controlador de disco a transferncia do bloco do disco para o seu buffer
interno. 3) Terminada a transferncia, o controlador de disco verifica a existncia de erros. 4) Caso no haja erros, o controlador de DMA transfere o bloco para o buffer de E/S
na memria principal. 5) Ao trmino da transferncia, o controlador de DMA gera uma
interrupo avisando ao processador que o dado j se encontra na memria principal.
9.6
DISPOSITIVOS DE ENTRADA E SADA
So utilizados para permitir a comunicao entre o sistema computacional e o mundo

externo.
A transferncia de dados pode ocorrer atravs de blocos de informao ou caracteres,
por meio dos controladores dos dispositivos. Em funo da forma com que os dados so
armazenados, os dispositivos de E/S podem ser classificados em duas categorias: estruturados e no-estruturados. Os dispositivos estruturados (block devices) caracterizam-se por armazenar informaes em blocos de tamanho fixo, possuindo cada qual um
endereo que pode ser lido ou gravado de forma independente dos demais. Discos magnticos e pticos so exemplos.
Os dispositivos estruturados classificam-se em dispositivos de acesso direto e seqencial, em funo da forma com que os blocos so acessados. Acesso direto quando um bloco pode ser recuperado diretamente atravs de um endereo, como por exemplo o disco magntico. Acesso seqencial quando, para se acessar um bloco, o dispositivo deve percorrer sequencialmente os demais blocos at encontr-lo. A fita magntica
um bom exemplo.
Os dispositivos no-estruturados (character devices) so aqueles que enviam ou recebem uma seqncia de caracteres sem estar estruturada no formato de um bloco. A
seqncia de caracteres no enderevel, no permitindo operaes de acesso direto
ao dado. Terminais, impressoras e interfaces de rede so exemplos de tais dispositivos.
9.7
DISCOS
Diferentemente da memria principal, que fornece velocidade de acesso (quase) uniforme a todos os seus contedos, o armazenamento em disco de cabeote mvel exibe
velocidade de acesso varivel que depende das posies relativas entre o cabeote de
leitura-escrita e o dado requisitado. A figura a seguir mostra uma vista simplificada de
um disco rgido.
109
Dados so gravados em uma srie de discos magnticos, ou pratos (platters), conectados a uma haste (spindle) que gira em alta velocidade (comumente, milhares de rotaes por minuto).
Os dados de cada superfcie do disco so acessados por um cabeote de leituraescrita que paira a uma pequena distncia da superfcie do disco (muito menor do que
uma partcula de fumaa). Por exemplo, o disco da figura anterior contm dois pratos,
cada um com duas superfcies (superior e inferior) e quatro cabeotes de leitura-escrita,
um para cada superfcie. Um cabeote de leitura-escrita pode acessar dados imediatamente abaixo (ou acima) dele. Portanto, antes que os dados possam ser acessados, a
poro da superfcie do disco na qual eles devem ser lidos (ou escritos) deve girar at
ficar imediatamente abaixo (ou acima) do cabeote de leitura-escrita. O tempo que leva
para o dado girar da posio em que est at a extremidade do cabeote de leituraescrita denominado tempo de latncia rotacional. A latncia rotacional mdia de um
disco simplesmente a metade do tempo que ele leva para completar uma rotao. A
maioria dos discos rgidos exibe latncia rotacional mdia da ordem de vrios milissegundos.
Enquanto os pratos giram, cada cabeote de leitura-escrita desenha uma trilha circular de dados sobre a superfcie de um disco. Cada cabeote de leitura-escrita posicionado na extremidade de um brao de disco, ligado a um atuador (tambm denominado lana ou unidade de brao mvel). O brao move-se paralelamente superfcie do
disco. Quando o brao do disco movimenta os cabeotes de leitura-escrita para uma nova posio, um conjunto vertical diferente de trilhas circulares, ou cilindro, torna-se acessvel. O processo de levar o brao do disco at um novo cilindro denominado operao de busca (seek). Para localizar pequenas unidades de dados, o disco divide as
trilhas em diversos setores, quase sempre de 512 bytes (veja a figura). Portanto, um
sistema operacional pode localizar determinado dado especificando o cabeote (que indica qual superfcie do disco deve ser lida), o cilindro (que indica qual trilha a ser lida) e o
setor no qual o dado est localizado.
Para realizar um acesso a um disco rgido, necessrio posicionar o cabeote de leitura e escrita sob um determinado setor e trilha onde o dado ser lido ou escrito. Considerando-se a organizao de um disco, esse procedimento de posicionamento implica um
certo tempo: o tempo de acesso. O tempo de acesso definido por trs fatores:
Tacesso = tseek + tlatncia + ttransferncia
Tempo de Seek: tempo de locomoo do brao do disco at o cilindro desejado;
Latncia Rotacional: tempo para que o setor desejado passe sob a cabea de leitura;
Tempo de Transferncia: tempo de transferncia propriamente dito.
110
9.8
ESCALONAMENTO DO BRAO DO DISCO
Muitos processos podem gerar requisies para ler e escrever dados em um disco simultaneamente. Pelo fato desses processos s vezes fazerem requisies mais rapidamente do que podem ser atendidas pelo disco, formam-se filas de espera para reter as
requisies de disco. Alguns sistemas de computador mais antigos simplesmente atendiam a essas requisies segundo o algoritmo primeira a chegar, primeira a ser atendida (First-Come-First-Served -FCFS), pelo qual a requisio que chegou mais cedo
atendida em primeiro lugar. O FCFS um mtodo justo de alocar servio, mas, quando a
taxa de requisio (a carga) fica pesada, pode haver longos tempos de espera.
O FCFS exibe um padro de busca aleatrio no qual requisies sucessivas podem
causar buscas demoradas partindo dos cilindros mais internos para os mais externos.
Para reduzir o tempo gasto na busca de registros, nada mais razovel do que ordenar a
fila de requisies de alguma outra maneira que no seja o FCFS. Esse processo, denominado escalonamento de disco, pode melhorar significativamente o rendimento.
Escalonamento de disco envolve um exame cuidadoso de requisies pendentes para
determinar o modo mais eficiente de atend-las. Um escalonador de disco examina as
relaes posicionais entre as requisies que esto espera e, ento, reorganiza a fila de
modo que as requisies sejam atendidas com o mnimo de movimento mecnico.
Pelo fato de o FCFS no reordenar requisies, ele considerado por muitos como o
mais simples algoritmo de escalonarnento de disco. Porque os tempos de busca tendem a
ser maiores do que os tempos de latncia, a maioria dos algoritmos de escalonamento
concentra-se em minimizar o tempo total de busca para um conjunto de requisies. A
medida que diminui a lacuna entre os tempos de latncia rotacional e de busca, minimizar a latncia rotacional para um conjunto de requisies tambm pode melhorar o desempenho geral do sistema, especialmente sob cargas pesadas.
9.8.1 PRIMEIRO A CHEGAR, PRIMEIRO A SER ANTENDIDO (FCFS)
Neste algoritmo, o driver s aceita uma requisio de cada vez. O atendimento s requisies feito considerando-se a ordem de chegada das mesmas.
Requisio : 11, 1, 36, 16, 34, 9 e 12
Deslocamento do Brao: 10, 35, 20, 18, 25 e 3
Total Percorrido: 111
9.8.2. MENOR SEEK PRIMEIRO (Shortest Seek First - SSF)
Neste algoritmo, a prxima requisio a ser atendida ser aquela que exigir o menor
deslocamento do brao do disco.
Requisio: 11, 1, 36, 16, 34, 9 e 12
111
Seqncia de acesso: 11, 12, 9, 16, 1, 34 e 36

Obs.: O SSF reduz quase metade do movimento do brao do disco, quando comparado com o FCFS, porm apresenta tendncia em acessar o meio do disco, podendo levar
um pedido de acesso postergao indefinida.
9.8.3. ALGORITMO DO ELEVADOR (Scan)
Como o prprio nome do algoritmo sugere, este faz com que todas as requisies em
um determinado sentido sejam atendidas. Depois, as demais requisies em sentido oposto sero atendidas.
Requisio: 11, 1, 36, 16, 34, 9 e 12
9.8.4. ALGORITMO CIRCULAR (C-Scan)
O algoritmo Scan, imediatamente aps inverter a varredura, inicia o atendimento privilegiando os pedidos correspondentes aos cilindros recm servidos, por conseqncia os
pedidos dos cilindros do outro extremo da varredura, feitos anteriormente, devem esperar. O algoritmo C-Scan uma variao do Scan com o objetivo de eliminar esse privilgio.
Nesse caso, quando a varredura atinge o ltimo cilindro, o cabeote posicionado no
primeiro cilindro onde reinicia a varredura. Em outros termos, os pedidos so atendidos
em um s sentido da varredura.
Requisio: 11, 1, 36, 16, 34, 9 e 12
9.9
EXERCCIOS
149)
Explique o modelo de camadas aplicado na gerncia de dispositivos
150)
Qual a principal finalidade das rotinas de E/S?
151)
Quais as diferentes formas de um programa chamar rotinas de E/S?
152)
Quais as principais funes do subsistema de E/S?
153)
Qual a principal funo de um driver?
154) Por que o sistema de E/S deve criar uma interface padronizada com os device
drivers?
155)
Explique o funcionamento da tcnica de DMA e sua principal vantagem.
156)
Diferencie os dispositivos de E/S estruturados dos no-estruturados.
157) Desenhe um disco com 21 setores e um fator 3 de entrelaamento. Mostre

agora porque h uma minimizao no tempo de acesso utilizando esse artifcio.
158) As requisies do disco chegam ao driver do disco na seguinte ordem dos cilindros: 10, 22, 20, 2, 40, 6 e 38. Um posicionamento leva 6ms por cilindro moviSistemas Operacionais Lucilia Ribeiro
112
do. Quanto tempo necessrio para os algoritmos FCFS, SSF, Scan e C-Scan,
considerando que o brao est inicialmente no cilindro 20? Considere o movimento descendo.
159) Monte um quadro mostrando a seqncia do brao, o deslocamento a cada
instante e o deslocamento total percorrido pelo brao utilizando os algoritmos
FCFS, SSF, Scan e C-Scan. Considere as seguintes requisies e que o brao estava em repouso. Considere o sentido subindo.
Chegada
Requisies
1, 6, 20
13
5, 19
7, 9, 15
18, 32
-x-
113
Bibliografia
"S sei que nada sei (Scrates)
Esta apostila foi totalmente baseada nos livros:
DEITEL H. M., DEITEL P. J. e CHOFFNES D.R. Sistemas Operacionais. So

Paulo, 2005. Prentice Hall.
TANEMBAUM, Andrew S. Sistemas Operacionais Modernos. So Paulo,
2003. Prentice Hall.
MAIA, Luiz Paulo e MACHADO, Francis Berenger. Arquitetura de Sistemas
Operacionais. Rio de Janeiro, 2002. LTC.
114

ApostilaSO 2008

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

ApostilaSO 2008

Enviado por

Direitos autorais:

Formatos disponíveis

SISTEMAS OPERACIONAIS

APOSTILA por Luclia Ribeiro

Nada lhe posso dar que j no exista em voc mesmo.

MEMRIA VIRTUAL ....................................................................................................................................... 76

SISTEMA DE ARQUIVOS ................................................................................................................................ 94

GERNCIA DE DISPOSITIVOS.................................................................................................................... 106

9.8.3. ALGORITMO DO ELEVADOR (Scan)............................................................................................ 112

Sistemas Operacionais Lucilia Ribeiro

As coisas so sempre melhores no comeo

O SISTEMA OPERACIONAL - FUNCIONALIDADES

O Sistema Operacional o software que controla todos os recursos do computador e

tem a responsabilidade de permitir o acesso concorrente a esse e a outros recursos de

SISTEMA OPERACIONAL NA VISO DO USURIO

A arquitetura de um sistema operacional corresponde imagem que o usurio tem do

PROJETO DO SISTEMA OPERACIONAL

Sistemas Operacionais Lucilia Ribeiro

Existem dois mtodos utilizados para o tratamento de interrupes. O primeiro utiliza

HISTRICO DOS SISTEMAS OPERACIONAIS

O desenvolvimento do transistor permitiu um grande avano da informtica. Assim,

1.5.5 DCADA DE 1980 (Computadores Pessoais):

CLASSIFICAO DOS SISTEMAS OPERACIONAIS

1.6.1 SISTEMAS MONOPROGRAMVEIS OU MONOTAREFAS

Os sistemas de tempo real (real-time) diferem dos de tempo compartilhado no

Esses sistemas podem ser classificados quanto forma de comunicao entre as

a) Sistemas Fortemente Acoplados

Num sistema fortemente acoplado dois ou mais processadores compartilham uma

Sistemas Operacionais Lucilia Ribeiro

-xSistemas Operacionais Lucilia Ribeiro

Cada ferramenta carrega consigo o esprito com o qual foi criada.

% utilizao da Cpu (0,0001 / 0,0016) = 0,066 = 6,6%

Sistemas Operacionais Lucilia Ribeiro

Em um sistema multiprogramado diversos programas so mantidos na memria

sos programas executam simultaneamente num sistema computacional. Entretanto, para

Sistemas Operacionais Lucilia Ribeiro

2.4.1 CONTEXTO DE HARDWARE

2.4.2 CONTEXTO DE SOFTWARE

Sistemas Operacionais Lucilia Ribeiro

Quotas: so os limites de cada recurso do sistema que um processo pode

Rodando (Execuo ou running): nesse estado, o processo est sendo

Pronto (ready): um processo est no estado de pronto quando aguarda

MUDANA DE ESTADO DO PROCESSO

Logicamente, os dois primeiros estados so similares. Em ambos os casos o processo

CRIAO E ELIMINAO DE PROCESSOS

A criao de um processo ocorre a partir do momento em que o Sistema Operacional

A ltima razo se d quando um processo executa uma chamada ao sistema dizendo

PROCESSOS INDEPENDENTES, SUBPROCESSOS E THREADS

compartilhamento do espao de endereamento permite que a comunicao de threads

PROCESSOS PRIMEIRO (FOREGROUND) E SEGUNDO PLANO (BACKGROUND)

Um processo de primeiro plano (interativo) aquele que permite a comunicao

2.10. PROCESSOS LIMITADOS POR CPU (CPU-BOUND) E POR E/S (I/O-BOUND)

FILAS PARA SELEO DE PROCESSOS

Sistemas Operacionais Lucilia Ribeiro

Num sistema com multiprogramao, os diversos processos existentes no estado de

16) O que um processo? Diferencie processo de programa.

Sistemas Operacionais Lucilia Ribeiro

Sistemas Operacionais Lucilia Ribeiro

No se pode conceber a maioria sem a unidade.

Programao concorrente tem sido usada frequentemente na construo de sistemas

Um programa que executado por apenas um processo chamado de programa

Sistemas Operacionais Lucilia Ribeiro

6:00 Olha a geladeira: sem leite

6:05 Sai para a padaria

6:10 Chega na padaria