Sistemas Operacionais

SISTEMAS OPERACIONAIS
JANEIRO 2013
Sumrio
1 Introduo ................................................................................................................... 5
1.1 O Hardware ................................................................................................................................ 5 1.2 O Software ................................................................................................................................. 5 1.3 Mquina de Nveis ..................................................................................................................... 5 1.4 O Sistema Operacional............................................................................................................... 6 1.4.1 O Sistema Operacional como uma Mquina Estendida ...................................................... 6 1.4.2 O Sistema Operacional como um Gerenciador de Recursos .............................................. 6 1.5 Histrico dos Sistemas Operacionais ......................................................................................... 7 1.5.1 1 Gerao (1945-1955) - vlvulas e painis de conectores................................................ 7 1.5.2 2 Gerao (1955-1965) - transistores e sistemas de lote.................................................... 7 1.5.3 3 Gerao (1965-1980) - circuitos integrados ................................................................... 8 1.5.4 4 Gerao (1980-hoje) - integrao em larga escala .......................................................... 8 1.6 Conceitos de Hardware .............................................................................................................. 8 1.7 Conceitos de Software ............................................................................................................. 10 1.8 Conceitos de Sistema Operacional ........................................................................................... 10 1.8.1 Processos ........................................................................................................................... 10 1.8.2 Arquivos ............................................................................................................................ 11 1.8.3 Interpretador de Comandos (Shell) ................................................................................... 11 1.8.4 Chamadas de Sistema........................................................................................................ 12 1.9 Tipos de Sistemas Operacionais .............................................................................................. 14 1.9.1 Multiprocessamento .......................................................................................................... 15 1.10 Sistemas Multiprogramveis .................................................................................................. 16 1.11 Estrutura do Sistema Operacional .......................................................................................... 17 1.11.1 Modos de Operao ........................................................................................................ 17 1.11.2 Ativao e Desativao do Sistema ................................................................................ 17 1.11.3 Sistemas Monolticos ...................................................................................................... 18 1.11.4 Sistemas em Camadas ..................................................................................................... 18 1.11.5 Mquinas Virtuais ........................................................................................................... 19 1.11.6 Sistemas Microkernel ...................................................................................................... 20 1.12 Exerccios ............................................................................................................................... 20
2 Processos .................................................................................................................. 22
2.1 Mudana de Contexto .............................................................................................................. 23 2.2 Subprocesso e Thread .............................................................................................................. 24 2.3 Tipos de Processos ................................................................................................................... 25 2.4 Processos Cooperativos............................................................................................................ 25 2.5 Exerccios ................................................................................................................................. 26
3 Comunicao Entre Processos.................................................................................. 27

3.1 Condio de Corrida ................................................................................................................ 27 3.2 Regio Crtica .......................................................................................................................... 28 3.3 Sincronizao Condicional ...................................................................................................... 28 3.4 Excluso Mtua por Hardware ................................................................................................ 29 3.4.1 Desabilitao de Interrupes ........................................................................................... 29 3.4.2 Instruo TSL (Test and Set Lock) ................................................................................... 29 3.5 Excluso Mtua por Software com Espera Ativa .................................................................... 30 Sistemas Operacionais ii
3.5.1 Alternncia Estrita............................................................................................................. 30 3.5.2 Soluo de Peterson .......................................................................................................... 31 3.6 Excluso Mtua por Software sem Espera Ativa..................................................................... 31 3.6.1 Semforos.......................................................................................................................... 31 3.6.2 Monitores .......................................................................................................................... 33 3.6.3 Troca de Mensagens.......................................................................................................... 35 3.7 Deadlock .................................................................................................................................. 37 3.7.1 Preveno de Deadlock ..................................................................................................... 37 3.7.2 Deteco do Deadlock ...................................................................................................... 38 3.7.3 Correo do Deadlock ....................................................................................................... 38 3.8 Problemas Clssicos de Comunicao Interprocessos ............................................................. 38 3.8.1 Problema dos Filsofos Comendo .................................................................................... 38 3.8.2 Problema dos Leitores e dos Escritores ............................................................................ 40 3.8.3 Problema do Barbeiro Adormecido .................................................................................. 40 3.9 Exerccios ................................................................................................................................. 41
4 Gerncia do Processador .......................................................................................... 43

4.1 Algoritmos de Escalonamento ................................................................................................. 44 4.1.1 Escalonamento First In First Out (FIFO) .......................................................................... 44 4.1.2 Escalonamento Shortest Job First (SJF)............................................................................ 44 4.1.3 Escalonamento Cooperativo ............................................................................................. 44 4.1.4 Escalonamento Circular (Round Robin) ........................................................................... 44 4.1.5 Escalonamento por Prioridade .......................................................................................... 45 4.1.6 Escalonamento por Mltiplas Filas ................................................................................... 46 4.1.7 Escalonamento por Mltiplas Filas com Realimentao .................................................. 46 4.1.8 Escalonamento em Sistemas de Tempo Real .................................................................... 47 4.2 Escalonamento com Mltiplas UCPs....................................................................................... 47 4.3 Exerccios ................................................................................................................................. 47
5 Gerncia de Memria ............................................................................................... 49

5.1 Atribuio de Endereos .......................................................................................................... 49 5.2 Carregamento Dinmico .......................................................................................................... 49 5.2.1 Ligao Dinmica ............................................................................................................. 50 5.3 Alocao Contgua Simples ..................................................................................................... 50 5.4 Alocao Particionada.............................................................................................................. 50 5.4.1 Alocao Particionada Esttica ......................................................................................... 50 5.4.2 Alocao Particionada Dinmica ...................................................................................... 51 5.4.3 Estratgias para Escolha da Partio ................................................................................. 51 5.5 Swapping .................................................................................................................................. 53 5.6 Memria Virtual ....................................................................................................................... 53 5.6.1 Espao de Endereamento Virtual .................................................................................... 54 5.6.2 Paginao .......................................................................................................................... 54 5.6.3 Segmentao ..................................................................................................................... 60 5.6.4 Segmentao com Paginao ............................................................................................ 61 5.6.5 Segmentao com Paginao: O Pentium Intel ................................................................ 62 5.6.6 Proteo ............................................................................................................................. 63 5.6.7 Compartilhamento de Memria ........................................................................................ 63 5.6.8 Trashing ............................................................................................................................ 63 5.7 Exerccios ................................................................................................................................. 64
Sistemas Operacionais
iii
6 Sistema de Arquivos ................................................................................................. 67

6.1 Arquivos ................................................................................................................................... 67 6.1.1 Organizao de Arquivos .................................................................................................. 67 6.1.2 Mtodos de Acesso ........................................................................................................... 68 6.1.3 Tipos de Arquivos ............................................................................................................. 68 6.1.4 Operaes de Entrada/Sada.............................................................................................. 69 6.1.5 Atributos............................................................................................................................ 69 6.2 Diretrios ................................................................................................................................. 69 6.3 Alocao de Espao em Disco ................................................................................................. 70 6.3.1 Alocao Contgua ............................................................................................................ 71 6.3.2 Alocao por Lista Encadeada .......................................................................................... 71 6.3.3 Alocao por Lista Encadeada Utilizando ndice ............................................................. 72 6.3.4 Ns-I (Alocao Indexada) ............................................................................................... 72 6.4 Exemplos de Implementao de Diretrios ............................................................................. 73 6.4.1 Diretrios no CP/M ........................................................................................................... 73 6.4.2 Diretrios no MS-DOS ..................................................................................................... 73 6.4.3 Diretrios no UNIX .......................................................................................................... 74 6.5 Proteo de Acesso .................................................................................................................. 74 6.5.1 Senha de Acesso................................................................................................................ 74 6.5.2 Grupos de Usurios ........................................................................................................... 74 6.5.3 Lista de Controle de Acesso.............................................................................................. 75 6.6 Implementao de Cache ......................................................................................................... 75 6.7 Exerccios ................................................................................................................................. 75
7 Gerncia de Dispositivos .......................................................................................... 77

7.1 O Hardware de Entrada/Sada .................................................................................................. 77 7.1.1 Espera em Ciclo ................................................................................................................ 78 7.1.2 Interrupes ....................................................................................................................... 79 7.1.3 Acesso Direto Memria ................................................................................................. 79 7.2 Operaes de Entrada/Sada..................................................................................................... 79 7.3 Subsistema de Entrada/Sada ................................................................................................... 80 7.4 Drivers de Dispositivo ............................................................................................................. 80 7.5 Controladores ........................................................................................................................... 81 7.6 Dispositivos de Entrada/Sada ................................................................................................. 82 7.6.1 Discos de RAM ................................................................................................................. 82 7.6.2 Disco Rgido ..................................................................................................................... 82 7.7 Exerccios ................................................................................................................................. 85
8 Bibliografia ............................................................................................................... 87
iv
1 Introduo
1.1 O Hardware
Um sistema computacional moderno consiste em: 1 ou mais processadores; memria RAM; disco; interface de rede; impressora; placa de vdeo; etc.
extremamente difcil escrever um programa para controlar todos os dispositivos. preciso isolar o programador do hardware. Soluo: Colocar uma camada de software por sobre o hardware bsico para gerenciar o sistema e oferecer ao usurio uma mquina virtual.
1.2 O Software
O software permite ao computador recuperar, armazenar e processar informaes. De forma geral pode ser dividido em duas espcies: programas de sistema e programas aplicativos. Os programas de sistema gerenciam a operao do computador, enquanto os programas aplicativos executam o trabalho que o usurio deseja. O sistema operacional o principal programa de sistema. Ele fornece a base para que programas aplicativos possam ser escritos.
1.3 Mquina de Nveis

O hardware no tem muita utilidade isoladamente. So os programas (softwares) que realizam as operaes que os usurios desejam. O hardware o responsvel pela execuo das instrues do software para que seja realizada alguma tarefa. Tanto o hardware quanto o software so logicamente equivalentes, interagindo de forma nica para o usurio. Nos primeiros computadores, a programao era realizada em painis, atravs de fios, o que era uma grande dificuldade para os programadores da poca. A soluo foi o surgimento do sistema operacional, que tornou a interao entre usurio e computador mais simples, confivel e eficiente. A partir desse acontecimento a parte fsica do computador tornou-se transparente para o usurio. Partindo desse princpio, podemos considerar o computador como uma mquina de nveis, onde inicialmente existem dois nveis: o nvel do hardware e o nvel do sistema operacional. Assim o usurio pode enxergar a mquina como sendo apenas o sistema operacional (como se o hardware no existisse). Um computador possui tantos nveis quantos forem necessrios para adequar o usurio s suas diversas aplicaes. Quando o usurio est trabalhando em um desses nveis, no necessita saber da existncia das outras camadas.
Sistema Bancrio Compiladores
Reserva de Passagem Editores
Navegador WEB Shell
Programas aplicativos
Programas de sistema
Sistema Operacional Linguagem de Mquina Microprograma
Hardware
Dispositivos Fsicos
Os programas de sistema que executam acima do Sistema Operacional executam no modo usurio, enquanto o sistema operacional executa no modo kernel (ou modo supervisor), sendo protegido do usurio pelo hardware. A linguagem de mquina no um hardware propriamente dito, mas considera-se que ela faz parte do hardware. O microprograma s existe em mquinas CISC. Ele tem a funo de interpretar a linguagem de mquina.
1.4 O Sistema Operacional

O sistema operacional um programa que atua como um intermedirio entre o usurio e o hardware. Seu propsito fornecer um ambiente no qual os usurios possam executar seus programas e tem como principal objetivo tornar conveniente o uso de um sistema computacional usando o hardware de maneira eficiente. O sistema operacional realiza basicamente duas funes sem muita correlao, funcionando como uma mquina estendida e como um gerenciador de recursos. 1.4.1 O Sistema Operacional como uma Mquina Estendida A arquitetura da maior parte dos computadores no nvel de linguagem de mquina difcil de programar (principalmente E/S). Para escrever em um disco, por exemplo, preciso escolher a trilha, a cabea e o setor, formatar, inicializar a controladora e o dispositivo, etc., tudo isto escrevendo em registradores. O sistema operacional o programa que esconde do programador a complexidade do hardware, fornecendo-lhe uma interface bastante simples. O sistema operacional tambm oculta detalhes relacionados a interrupes, temporizadores, gerenciamento de memria e outros recursos de baixo nvel. Deste ponto de vista, a funo do sistema operacional apresentar ao usurio uma mquina estendida (ou mquina virtual), que apesar de equivalente ao verdadeiro hardware mais fcil de programar. Ele facilita o acesso aos recursos do sistema. 1.4.2 O Sistema Operacional como um Gerenciador de Recursos Computadores consistem em processadores, memrias, temporizadores, discos, etc. Sob um ponto de vista alternativo ao anterior, a funo do sistema operacional oferecer um esquema de alocao ordenada e controlada dos dispositivos que compem o computador, entre os programas que competem por ele. Exemplo: Acesso impressora. Quando um computador tem mltiplos usurios a necessidade de gerenciar e proteger a memria e outros recursos ainda maior, para evitar que um usurio interfira no trabalho de outro. Sistemas Operacionais 6
Este ponto de vista sustenta que a tarefa principal do sistema operacional monitorar quem est utilizando qual recurso, atender requisies de recursos, medir a utilizao dos recursos e medir as requisies conflitantes de diferentes processos.
1.5 Histrico dos Sistemas Operacionais

A histria dos sistemas operacionais est intimamente relacionada histria da arquitetura das mquinas nas quais eles rodam. Os primeiros sistemas operacionais foram desenvolvidos para facilitar o uso do hardware. A medida que os sistemas operacionais foram desenvolvidos tornou-se evidente que mudanas no projeto de hardware poderia simplific-los. Desta forma, os sistemas operacionais no s foram influenciados pela arquitetura dos computadores, como tambm influenciaram no desenvolvimentos destas arquiteturas. 1.5.1 1 Gerao (1945-1955) - vlvulas e painis de conectores Um nico grupo de pessoas projetava, construa, programava e operava cada mquina. Toda a programao era feita em linguagem de mquina ligando fios aos painis de conectores (no existia sequer a linguagem Assembly). No existia o conceito de sistema operacional. O ENIAC (Electronic Numerical Integrator and Computer) foi o primeiro computador eletrnico digital de propsito geral. Ele possua 18.000 vlvulas, 10.000 capacitores, 70.000 resistores e pesava 30 toneladas. Quando em operao consumia 140 quilowatts e era capaz de realizar 5.000 adies por segundo. O UNIVAC I (Universal Automatic Computer) foi a primeira mquina comercial a ser construda, criada especialmente para o censo americano de 1950. 1.5.2 2 Gerao (1955-1965) - transistores e sistemas de lote Com a inveno do transistor os computadores se tornaram menores, mais confiveis, mais rpidos e passaram a consumir menos energia. As memrias de ncleo magntico foram substitudas por memrias mais rpidas e com maior capacidade de armazenamento. Os computadores passaram a ser fabricados e vendidos com a expectativa de uma durabilidade maior. Nesta gerao surgiram as primeiras linguagens de programao. Para executar um job o programador escrevia seus programas em cartes perfurados (Fortran, Assembly ou Cobol). Os usurios no interagiam diretamente com o sistema o operador pegava o conjunto de cartes do programador e os carregava na mquina junto com o conjunto de cartes do compilador. O resultado era gerado em uma impressora. O sistema operacional destas mquinas tinha a funo de carregar os cartes em memria e transferir o controle da mquina para o programa recm carregado. Os sistemas operacionais passaram a ter seu prprio conjunto de rotinas para operaes de entrada e sada (E/S), facilitando o trabalho dos programadores. Para agilizar o processamento, servio com necessidades semelhantes eram agrupados formando um mesmo lote (batch), e executados como um grupo. Neste ambiente a UCP ficava quase sempre ociosa devido velocidade dos mecanismos de E/S. As mquinas desta gerao executavam cerca de 200.000 instrues por segundo.
1.5.3 3 Gerao (1965-1980) - circuitos integrados No incio da dcada de 60 a maioria dos fabricantes de computadores tinham duas linhas de produtos, uma linha cientfica e uma linha comercial. A IBM desenvolveu o Sistema 360 (System 360), uma famlia de mquinas compatveis a nvel de software, onde elas diferiam em preo e performance. Foi preciso desenvolver um sistema operacional que executasse em todos os modelos, sendo bom tanto em ambientes cientficos quanto em ambientes comerciais. O OS/360 era um sistema operacional muito grande escrito em Assembly que continha muitos problemas, necessitando de um fluxo contnuo de verses. Com ele foram introduzidos os conceitos de multiprogramao, spool (para entrada e sada de jobs) e tempo compartilhado (com terminais on-line). Em 1969 surge o sistema operacional UNIX, construdo com base no MULTICS. As mquinas desta gerao executavam cerca de 5 milhes de instrues por segundo. 1.5.4 4 Gerao (1980-hoje) - integrao em larga escala O desenvolvimento de circuitos LSI e VLSI permitiu o desenvolvimento de computadores pessoais. Surgiram tambm as estaes de trabalho (computadores pessoais mais poderosos, geralmente ligados em rede). Surgiram os sistemas operacionais DOS (Disk Operation System) e VMS (Virtual Memory System). Surgiram os conceitos de multitarefa e multiprocessamento, assim como mquinas com mais de um processador, impulsionados por aplicaes que exigiam uma grande quantidade de clculos. Com a difuso das WANs foram desenvolvidos vrios protocolos de rede para a interconexo de computadores. Os softwares de rede passaram a estar intimamente relacionados ao sistema operacional e surgem os sistemas operacionais de rede. As mquinas mais modernas desta gerao executam bilhes de instrues de ponto flutuante por segundo.
1.6 Conceitos de Hardware

Memria
Unidade de Controle
UCP
Unidade Lgica e Aritmtica
Entrada
Sada
A unidade central de processamento (UCP), ou simplesmente processador, controla as funes realizadas por cada unidade funcional do restante do sistema. Ela executa as instrues dos programas atravs de duas unidades bsicas: unidade de controle (UC) e unidade lgica e aritmtica (ULA). Sua velocidade medida pelo nmero de instrues que ela executa por segundo (MIPS e FLOPS). A unidade lgica e aritmtica tem por funo realizar operaes sobre os dados que lhe so entregues, enquanto cabe unidade de controle enviar sinais de controle a todas as partes do sistema para que essas partes possam funcionar de forma coordenada a fim de executar as instrues que so entregues UCP.
Barramento de dados
Acumulador Registradores
RDM REM
Barramento de endereos
Memria Principal
CI RI
ULA
Decodificador de instrues UC
Barramento interno
Clock Unidade de Controle
Unidade Lgica e Aritmtica
O relgio (clock) gera pulsos peridicos para sincronizar o sistema. O sinal do relgio usado pela unidade de controle para a execuo das instrues. Em conjunto com a UCP determina a velocidade do sistema. Registradores so dispositivos de alta velocidade localizados na UCP para armazenamento temporrio de dados. O nmero de registradores varia de acordo com a arquitetura da UCP. Existem registradores de uso especfico e registradores de uso geral. Alguns exemplos de registradores de uso especfico so: contador de instrues - CI (program counter - PC), apontador da pilha - AP (stack pointer SP) e registrador de estado - RE (program status word - PSW). Na memria principal so armazenados instrues e dados durante a execuo de um programa. composta por unidades chamadas clulas, que contm bits. A clula acessada atravs de seu endereo. Uma clula endereada atravs do registrador de endereo de memria - REM (memory address register - MAR) e do registrador de dados da memria - RDM (Memory Buffer Register - MBR), ambos localizados na UCP. As memrias podem ser classificadas, de acordo com a sua volatilidade, em: R/W (RAM), ROM, PROM, EPROM e EEPROM. Podem ainda ser estticas ou dinmicas. A memria cache uma memria voltil de alta velocidade que tem seu uso limitado devido ao alto custo. Ela possui algoritmo prprio de operao, podendo ser separada em cache de instrues e cache de dados. A memria secundria um meio no voltil de armazenamento de programas e dados. Tem acesso lento quando comparado memria principal. Disco magntico, CD-ROM e unidade de fita so exemplos de memria secundria. Os dispositivos de entrada e sada (E/S) permitem a comunicao entre o computador e o mundo externo. Existem duas categorias de dispositivos de E/S: dispositivos utilizados como memria secundria e dispositivos utilizados para a comunicao homem-mquina. O barramento um conjunto de condutores onde trafegam dados, endereos e sinais de controle, interligando os vrios componentes do sistema. Exemplos de barramento para microcomputadores incluem: ISA, EISA, PCI, PCI-Express, AGP, USB, SCSI e SATA. Processadores RISC (Reduced Instruction Set Computer) se caracterizam por possurem poucas instrues, que so executadas diretamente pelo hardware. Costumam possuir um grande nmero de registradores. Exemplos de processadores RISC so Sparc (Sun), RS-6000 (IBM), Alpha (DEC) e o MIPS. Sistemas Operacionais 9
Processadores CISC (Complex Instruction Set Computer) possuem instrues complexas que so interpretadas pelo microprograma da UCP e costumam possuir um pequeno nmero de registradores. Exemplos de processadores CISC so a linha x86 e Pentium da Intel e a linha 68xxx da Motorola.
1.7 Conceitos de Software

O hardware do computador tem pouca utilizao prtica se no houver um conjunto de softwares que permitam ao usurio utilizar a mquina. O tradutor faz o mapeamento de uma linguagem em outra. Quando traduz da linguagem Assembly para um cdigo objeto conhecido como montador (assembler). Quando traduz de uma linguagem de alto nvel para um cdigo objeto conhecido como compilador. O interpretador um software que no momento da execuo do programa traduz cada instruo e a executa. A maior desvantagem dos interpretadores o tempo gasto com a traduo no momento da execuo. Sua vantagem permitir tipos de dados dinmicos. O linker o responsvel por gerar, a partir de um ou mais mdulos objeto, um nico programa executvel. Ele deve procurar em bibliotecas as funes referenciadas nos objetos. O loader o programa responsvel por carregar um programa em memria para execuo. O depurador (debugger) um utilitrio que permite ao usurio controlar a execuo de um programa a fim de detectar erros. A linguagem de mquina a linguagem que a UCP entende e pode ser processada diretamente por seu hardware. O microprograma um programa interno s UCPs CISC que interpreta a linguagem de mquina destas UCPs. Processadores microprogramveis permitem a criao de novas instrues atravs da modificao de seu microprograma.
1.8 Conceitos de Sistema Operacional

A interface entre o sistema operacional e os programas de usurio definida pelo conjunto de instrues estendidas que o sistema operacional proporciona. Estas instrues estendidas so conhecidas por chamadas de sistema (ou system calls). As chamadas de sistema variam de um sistema operacional para outro. 1.8.1 Processos Um processo basicamente um programa em execuo mais seu espao de endereamento (incluindo valores de variveis) e conjunto de registradores. Associado a cada processo est seu espao de endereamento (ou imagem de ncleo). O espao de endereamento uma lista de endereos da memria onde o processo pode ler e escrever, contendo o programa executvel, os dados e a pilha. Tambm associado com cada processo est um conjunto de registradores (contador de instrues, ponteiro da pilha, etc.). Periodicamente o sistema operacional pode parar de executar um processo e comear a executar outro. Mais tarde o processo deve ser reiniciado no mesmo estado em que estava quando parou. As informaes sobre o processo so armazenadas em uma tabela conhecida como tabela de processos. As principais chamadas do sistema de gerenciamento de processos so as que lidam com a criao e com o encerramento de processos. Se um processo pode criar um ou mais processos filho, que podem criar novos processos filho, obtm-se uma rvore de processos. Sistemas Operacionais 10
Processos que cooperam para executar determinada tarefa costumam se comunicar. Essa comunicao chamada de comunicao interprocessos. Ocasionalmente necessrio transmitir informaes para um processo que no as est aguardando. Neste caso envia-se um sinal ao processo. A cada usurio do sistema corresponde um uid (identificao de usurio). Cada processo tem a uid do usurio que o iniciou. 1.8.2 Arquivos Uma das funes do sistema operacional esconder as peculiaridades dos discos e outros dispositivos de E/S. So necessrias chamadas de sistema para criar, remover, ler e escrever arquivos. Para fornecer um local para manter os arquivos existe o conceito de diretrio. So necessrias chamadas de sistema para criar e remover diretrios, assim como inserir e remover arquivos de diretrios. As entradas de diretrios podem ser arquivos ou diretrios. Cada arquivo dentro da hierarquia de diretrios pode ser especificado por seu nome de caminho a partir do diretrio raiz (por seu caminho absoluto) ou por seu caminho a partir do diretrio de trabalho atual (caminho relativo). Processos podem mudar seu diretrio de trabalho emitindo uma chamada de sistema. Arquivos e diretrios costumam ser protegidos. As permisses so verificadas no momento em que solicitada a abertura de um arquivo. Se o acesso for permitido devolvido um nmero inteiro chamado descritor de arquivo. Alguns sistemas operacionais permitem acesso a um sistema de arquivos somente se ele estiver montado em um sistema de arquivos raiz ou primrio. Existe um recurso denominado pipe que um tipo de pseudo-arquivo que pode ser utilizado para conectar dois processos. 1.8.3 Interpretador de Comandos (Shell) Um dos componentes mais importantes de um sistema operacional o interpretador de comandos (shell), que constitui a interface entre o usurio e o sistema operacional. Alguns sistemas operacionais incluem o interpretador de comandos em seu ncleo, enquanto outros tratam o interpretador de comandos como um programa especial. Uma forma usual de requerer que uma tarefa seja realizada pelo sistema operacional por meio do uso de comandos de controle. Nestes sistemas, um programa que l e interpreta comandos de controle automaticamente executado. Tal programa frequentemente conhecido como a shell (casca) do sistema. Sua tarefa bastante simples: obter o prximo comando e providenciar para que ele seja executado. Nesse aspecto, os sistemas operacionais costumam ser bastante diferentes uns dos outros. Um exemplo de interface amigvel pode ser encontrado no Macintosh e no Windows, com janelas, menus e mouse. Outros usurios preferem interpretadores de comandos com interfaces mais poderosas, complexas e mais difceis de aprender, onde so digitados comandos que so mostrados em uma tela ou terminal. As interfaces dos interpretadores de comandos do UNIX e do MS-DOS so desta forma. O interpretador de comandos, faz uso pesado de muitos recursos do sistema operacional, sendo a interface primria entre o usurio e o sistema operacional. Exemplos de comandos: date date > arq Sistemas Operacionais 11
sort <arq1 >arq2 cat arq1 arq2 arq3 | sort > /dev/lp cat arq1 arq2 arq3 | sort > /dev/lp & 1.8.4 Chamadas de Sistema A interao entre os processos dos usurios e o sistema operacional feita por meio de chamadas de sistema (system calls). Em geral as chamadas de sistema esto disponveis em linguagem Assembly, mas alguns sistemas permitem que as chamadas de sistema sejam feitas diretamente em uma linguagem de alto nvel. Sero vistos alguns exemplos de chamadas de sistemas do padro POSIX divididos em seis categorias: gerenciamento de processos; sinais; gerenciamento de arquivos; gerenciamento de diretrio; proteo; gerenciamento de tempo.
Chamadas de sistema para gerenciamento de processos: pid = fork() Cria um processo filho. pid = waitpid(pid, &statloc, opts) Bloqueia at que o processo filho termine. s = wait(&status) Bloqueia at que um processo filho termine. Obsoleta. s = execve(name, arg, envp) Substitui a imagem de memria por um processo. exit(status) Termina o processo. size = brk(addr) Especifica o segmento de dados. pid = getpid() Retorna o id do processo. pid = getpgrp() Retorna o id do grupo do processo. l = ptrace(req, pid, addr, data) Permite controlar a execuo de outro processo.
Exemplo de um shell simples:

while (1) { ler_comando(comando, parametros); if (fork() != 0) waitpid(-1, &status, 0); /* cdigo pai */ else execve(comando, parametros, 0); /* executa comando */ }
Chamadas de sistema para sinalizao: s = sigaction(sig, &act, &oldact) Especifica a ao a ser executada para um sinal. s = sigreturn(&context) Retorna de uma rotina de tratamento de sinal. s = sigprocmask(how, &set, &old) Altera a lista de sinais bloqueados. s = sigpending(set) Retorna o conjunto de sinais pendentes por loqueio. s = sigsuspend(mask) Suspende o processo at que chegue um dos sinais selecionados. s = kill(pid, sig) Envia um sinal a um processo. residual = alarm(seconds) Programa um sinal SIGALARM. s = pause() Suspende o processo at a chegada de um sinal.
Exemplo:
12
void handler(int sig) { printf("Terminada a execucao\n"); exit(0); } main() { signal(SIGINT, handler); while (1); }
Chamadas de sistema para gerenciamento de arquivos: fd = create(name, mode) Cria um novo arquivo. uma chamada obsoleta. fd = mknod(name, mode, addr) Cria arquivos especiais. fd = open(file, how, ...) Abre um arquivo, criando se necessrio. s = close(fd) Fecha o arquivo. n = read(fd, buffer, nbytes) L dados de um arquivo. n = write(fd, buffer, nbytes) Grava dados em um arquivo. pos = lseek(fd, offset, whence) Move o ponteiro do arquivo. s = stat(name, &buf) Retorna informaes sobre um arquivo. s = fstat(fd, &buf) Retorna informaes sobre um arquivo aberto. fd = dup(fd) Cria cpia do descritor de arquivos. s = pipe(&fd[0]) Cria um par de descritor de arquivos ligados por um pipe. s = ioctl(fd, request, argp) Operaes em arquivos especiais. f = access(name, amode) Verifica se o processo tem permisso para acessar o arquivo. s = rename(old, new) Muda o nome do arquivo. s = fcntl(fd, cmd, ...) Executa operaes especiais em arquivos.
Exemplo de configurao de pipeline entre 2 processos:

pipeline (char *process1, char *process2) { int fd[2]; pipe(&fd[0]); if (fork() != 0) { /* processo pai */ close(fd[0]); close(STD_OUTPUT); dup(fd[1]); close(fd[1]); execve(process1, NULL, 0); } else { /* processo filho */ close(fd[1]); close(STD_INPUT); dup(fd[0]); close(fd[0]); execve(process2, NULL, 0); }
Chamadas de sistema para gerenciamento de diretrios: s = mkdir(name, mode) Cria diretrio. s = rmdir(name) Remove diretrio vazio. s = link(name1, name2) Cria uma nova entrada para um arquivo em um diretrio. s = unlink(name) Remove uma entrada de diretrio. s = mount(special, name, flag) Monta um sistema de arquivos. s = umount(special) Desmonta um sistema de arquivos. s = sync() Fora a escrita de blocos em cache no disco. 13
s = chdir(dirname) Muda o diretrio de trabalho. s = chroot(dirname) Muda o diretrio raiz. Chamadas de sistema para proteo: s = chmod(name, mode) Muda as permisses de um arquivo. uid = getuid() Retorna o id do usurio do processo. gid = getgid() Retorna o id do grupo do usurio do processo. s = setuid(uid) Muda o id do usurio do processo. s = setgid(gid) Muda o id do grupo do processo. s = chown(name, owner, group) Muda o dono do arquivo. oldmask = umask(complmode) Muda a mscara de criao de arquivos. seconds = time(&seconds) Obtm a hora. s = stime(tp) Ajusta o relgio. s = utime(file, timep) Altera a hora de ltimo acesso do arquivo. s = times(buffer) Obtm quanto tempo de UCP o processo utilizou.
Chamadas de sistema para gerenciamento de tempo:
1.9 Tipos de Sistemas Operacionais

Os sistemas operacionais podem ser classificados em sistema monoprogramvel/monotarefa, sistema multiprogramvel/multitarefa e sistema com mltiplos processadores. O sistema monoprogramvel/monotarefa voltado para a execuo de um nico programa. Para executar outro programa, o programa corrente em execuo deve terminar antes. Processador, memria, perifricos e outros recursos so dedicados exclusivamente ao programa em execuo. Nesses sistemas enquanto um programa aguarda por um evento o processador permanece ocioso. Caso a memria no seja totalmente utilizada pelo programa ela subutilizada. No existe preocupao com a proteo do sistema. No sistema multiprogramvel/multitarefa vrios programas podem estar em execuo simultaneamente. O sistema operacional se preocupa em gerenciar, de forma ordenada e protegida, o acesso concorrente aos seus recursos. Dependendo do nmero de usurios que podem usar o sistema, ele pode ser classificado como monousurio ou multiusurio. Um sistema monousurio aquele em que somente um usurio pode estar utilizando o sistema, mesmo que executando mais de um programa em um determinado instante. J um sistema multiusurio permite que mais de um usurio utilize o sistema simultaneamente. As vantagens dos sistemas multiprogramveis so o aumento da produtividade dos usurios e a reduo de custos a partir do compartilhamento dos diversos recursos do sistema. Os sistemas multiprogramveis/multitarefa podem ser classificados pela forma como suas aplicaes so gerenciadas em: Sistemas batch Programas ficam armazenados em discos ou fitas, esperando para serem executados sequencialmente. Sistemas batch multiprogramados Programas ficam armazenados na memria. Quando um programa que est sendo executado e precisa esperar por uma tarefa, em vez da UCP ficar ociosa ela passa a executar outro programa, e assim por diante. Sistemas de tempo compartilhado (time-sharing) So uma extenso da multiprogramao. Permitem a interao de usurios com o sistema atravs de terminais. Cada usurio recebe uma fatia do tempo do processador.
14
Sistemas de tempo real Semelhantes aos sistemas de tempo compartilhado, atendendo ao tempo de resposta exigido para as aplicaes. O escalonamento no se d por fatia de tempo, mas sim por prioridade. Os sistemas com (multiprocessamento). mltiplos processadores so estudados no tpico a seguir
1.9.1 Multiprocessamento Um sistema multiprocessado um sistema que possui mais de uma UCP, localizadas prximas uma das outras, se comunicando e compartilhando um barramento, por onde so transmitidos os dados entre os componentes do sistema computacional. A principal vantagem do multiprocessamento o aumento da quantidade de trabalho realizado por unidade de tempo (throughput) do sistema como um todo. Um sistema multiprocessado pode ser desenvolvido para apresentar maior confiabilidade, sendo construdo de forma que a parada de um processador no provoque a parada do sistema como um todo. Os sistemas com mltiplos processadores caracterizam-se por possuir duas ou mais UCPs interligadas, trabalhando em conjunto. Em funo da forma como as UCPs se comunicam e do grau de compartilhamento de memria e outros recursos, os sistemas com mltiplos processadores podem ser classificados em fortemente acoplados ou fracamente acoplados. Nos sistemas fortemente acoplados existem dois ou mais processadores compartilhando uma nica memria e controlados por um nico sistema operacional. So geralmente utilizados no processamento de aplicaes que fazem uso intensivo da UCP. Sua grande vantagem o aumento do throughput. Subdividem-se ainda em sistemas simtricos e sistemas assimtricos. Nos sistemas fortemente acoplados assimtricos existe um processador principal, responsvel pelo controle dos demais processadores e pela execuo do sistema operacional. O processador principal tambm responsvel por realizar todas as operaes de entrada e sada. Nos sistemas fortemente acoplados simtricos todos os processadores realizam a mesma funo, exceto pela inicializao do sistema (boot), que realizada por um nico processador. O sistema operacional deve ser construdo de forma a evitar conflitos entre os processadores. Nos sistemas fracamente acoplados existem dois ou mais sistemas de computao conectados atravs de linhas de comunicao. Cada sistema possui seu prprio sistema operacional e funciona de forma independente. Sua utilizao caracterizada pelo processamento distribudo entre os vrios processadores. Subdividem-se ainda em sistemas operacionais de rede e sistemas operacionais distribudos. No sistema operacional de rede cada n possui seu prprio sistema operacional, podendo inclusive ser diferente dos demais. Caso haja perda da conexo entre os ns, os sistemas podem operar normalmente, podendo apenas ter alguns recursos indisponveis. Permite, entre outras, cpia remota de arquivos, emulao de terminal, impresso remota, gerncia remota e correio eletrnico. Os usurios esto cientes da existncia de mltiplos computadores e podem se conectar a mquinas remotas. No sistema operacional distribudo cada n da rede possui seu prprio sistema operacional, mas com um relacionamento mais forte entre os ns. Geralmente os sistemas operacionais dos ns o mesmo. Aparece para os usurios como um sistema tradicional. O usurio no sabe onde seus programas esto sendo executados e onde seus arquivos so armazenados. Permite que um aplicativo execute em mais de um processador. Os sistemas distribudos podem ser considerados como uma evoluo dos sistemas fortemente acoplados, onde uma aplicao pode ser executada por qualquer processador. Sua grande vantagem a possibilidade de redundncia do sistema. Sistemas Operacionais 15
Mesmo que um sistema no tenha programas que tenham sido escritos para tirar vantagem da mquina ter mais de um processador, vantajoso ter mais de um processador na mquina, uma vez que isto permitir que mais de um processo seja executado simultaneamente, aumentando o throughput do sistema.
1.10 Sistemas Multiprogramveis

A possibilidade de perifricos e dispositivos funcionarem simultaneamente, juntamente com a UCP, permitiu a execuo de tarefas concorrentes, que o princpio para projeto de sistemas multiprogramveis. Nos sistemas multiprogramveis vrios processos podem estar residentes em memria concorrendo pela utilizao da UCP. Quando um processo solicita uma operao de E/S, outros processos podero estar disponveis para utilizar a UCP. A utilizao concorrente da UCP deve ser implementada de maneira que, quando um processo perde seu uso e depois retorna para continuar o processamento, seu estado deve ser idntico ao do momento em que foi interrompido. Durante a execuo de um processo, alguns eventos podem ocorrer, obrigando a interveno do sistema operacional. Este tipo de interveno chamado interrupo ou exceo. O que diferencia uma interrupo de uma exceo o tipo de evento que gera esta condio. Uma interrupo gerada pelo sistema operacional ou por algum dispositivo e independe do programa que est sendo executado. No momento em que a unidade de controle detecta a ocorrncia de algum tipo de interrupo, o programa em execuo interrompido, e o controle desviado para uma rotina responsvel pelo tratamento da interrupo. Muitas vezes, aps a execuo dessa rotina, o controle deve voltar ao programa que estava sendo processado. Para isso acontecer necessrio que, no momento da interrupo, um conjunto de informaes sobre a execuo do programa seja preservado. Essas informaes consistem no contedo de alguns registradores que devero ser restaurados posteriormente para a continuao do programa.
Programa
Salva os registradores
Identifica a origem da interrupo
Rotina de tratamento
Interrupo
Obtm o endereo da rotina de tratamento

Restaura os registradores
No momento que uma interrupo acontece, a UCP deve saber para qual rotina de tratamento dever ser desviado o fluxo de execuo. Essa informao est em uma estrutura do sistema chamada vetor de interrupo. A interrupo o mecanismo que tornou possvel a implementao da concorrncia nos computadores, sendo o fundamento dos sistemas multiprogramveis. Uma exceo resultado direto da execuo de uma instruo do prprio programa. O mecanismo de tratamento de excees semelhante ao de interrupes e podem ser escritas pelo prprio programador. Dessa forma, possvel evitar que um programa seja encerrado no caso de ocorrer, por exemplo, uma diviso por zero. Sistemas Operacionais 16
1.11 Estrutura do Sistema Operacional

O sistema operacional formado por um conjunto de rotinas que oferecem servios s aplicaes dos usurios do sistema, bem como a outras rotinas do prprio sistema. Esse conjunto de rotinas chamado de kernel ou ncleo do sistema. As principais funes do kernel so: tratamento de interrupes; criao e eliminao de processos; sincronizao e comunicao entre processos; escalonamento e controle dos processos; gerncia de memria; gerncia do sistema de arquivos; operaes de E/S; contabilizao e segurana do sistema.
Para proteger o kernel, os usurios solicitam servios atravs de chamadas de sistemas.

Aplicao Chamada de Sistema Ncleo Hardware
1.11.1 Modos de Operao Para que um sistema operacional possa trabalhar de forma segura preciso existir um esquema de proteo que proteja o sistema operacional e todos os outros programas e dados de qualquer programa incorreto. Assim necessrio que o hardware oferea pelo menos dois modos de operao para diferenciar os modos de execuo. Estes modos so conhecidos como modo usurio e modo kernel. O modo kernel tambm conhecido como modo supervisor ou modo privilegiado. Existem instrues que s devem ser executadas pelo sistema operacional para impedir problemas de segurana do sistema. Instrues que tem o poder de comprometer o sistema so conhecidas como instrues privilegiadas, enquanto instrues que no oferecem perigo ao sistema so conhecidas como instrues no privilegiadas. Quando o sistema est no modo usurio as aplicaes podem executar somente instrues no privilegiadas. Quando o sistema est no modo kernel as aplicaes podem executar qualquer instruo do processador. Durante a inicializao do sistema (boot) o sistema est no modo kernel. Quando o sistema operacional carregado ele inicia a execuo de processos do usurio no modo usurio. Sempre que ocorre uma interrupo o modo de operao muda para o modo kernel e, antes de transferir o controle da mquina para um processo do usurio, ele coloca a UCP novamente no modo usurio. Sempre que uma aplicao necessita de um servio privilegiado ela deve fazer uma chamada de sistema. A chamada de sistema muda o modo de operao para o modo kernel, executando o servio e voltando ao modo usurio. Caso uma aplicao tente executar uma instruo privilegiada sem estar no modo kernel uma exceo ser gerada. 1.11.2 Ativao e Desativao do Sistema Toda vez que um computador ligado, necessrio que o sistema operacional seja carregado da memria secundria para a memria principal. Esse processo denominado ativao do sistema (boot).
17
Alm da carga do sistema operacional, a ativao do sistema tambm consiste na execuo de arquivos de inicializao. Nestes arquivos so especificados procedimentos de inicializao e configurao de hardware e software especficos para cada ambiente. Na maioria dos sistemas tambm existe o processo de desativao (shutdown). Este procedimento permite que as aplicaes e componentes do sistema sejam desativados de forma ordenada, garantindo a integridade do sistema. 1.11.3 Sistemas Monolticos No existe uma estrutura real. O sistema operacional escrito como uma coleo de procedimentos, cada um podendo chamar qualquer um dos outros. Os procedimentos so compilados e linkados em um nico programa executvel. Cada procedimento visvel aos demais. possvel ter um mnimo de estrutura requisitando-se chamadas de sistema ao colocar os parmetros em locais bem definidos e chamar interrupes. A mquina comutada para o modo kernel e o controle transferido ao sistema operacional. Quando a chamada termina o controle devolvido ao programa de usurio.
Programa de usurio 2
Programas de usurio executados no modo usurio
Programa de usurio 1
4
Sistema operacional executado no modo kernel
1 3 2
1. Interrupo gerada para o kernel 2. S.O. determina o servio necessrio 3. S.O. chama o procedimento de servio 4. Controle retorna para o programa de usurio
1.11.4 Sistemas em Camadas So definidas camadas sobrepostas onde cada camada oferece um conjunto de funes que podem ser utilizadas pelas camadas superiores. A vantagem da estruturao em camadas isolar as funes do sistema operacional, criando uma hierarquia e protegendo as camadas mais internas. A depurao de erros tambm simplificada. Como cada nvel usa apenas operaes fornecidas por nveis inferiores, o sistema operacional pode ser depurado da camada mais interna para a mais externa sem grandes dificuldades. Um problema com a implementao em camadas a queda de desempenho provocada no sistema, uma vez que qualquer operao deve passar por todas as camadas inferiores at chegar ao hardware.
Usurio
5 4
3
Operador
Programas de usurio
Supervisor Executivo
Kernel
Entrada/Sada
Comunicao Gerncia de memria Multiprogramao MULTICS
2
1 0
VMS
18
Abaixo segue uma breve descrio das camadas do MULTICS. A camada 0 lida com a alocao do processador alternando entre processos quando ocorrem interrupes ou quando temporizadores expiram. Acima da camada 0 os processos no precisam se preocupar se existe mais de um processo sendo executado. A camada 1 faz o gerenciamento de memria, alocando espao para os processos. Acima dela os processos no precisam se preocupar se esto em memria ou em disco. A camada 2 manipula a comunicao de cada processo com a console do operador. Acima dela cada processo tem seu prprio console de operador. A camada 3 cuida de gerenciar os dispositivos de E/S. Acima dela cada processo pode lidar com dispositivos de E/S abstratos amigveis. Na camada 4 residem os programas de usurios, que no precisam se preocupar com gerenciamento de processos, memria, console e E/S. O processo do operador do sistema se localiza na camada 5. 1.11.5 Mquinas Virtuais No hardware bsico executado o monitor de mquina virtual, oferecendo vrias mquinas virtuais camada superior. Tais mquinas virtuais so cpias exatas do hardware bsico e cada uma pode executar qualquer sistema operacional. Quando um processo executa uma chamada de sistema: A chamada interceptada pelo sistema operacional da mquina virtual; O sistema operacional emite as instrues normais de E/S de hardware; As instrues so interceptadas pelo monitor de mquina virtual que as executa simulando o hardware real.
processos processos kernel kernel kernel kernel Monitor de mquina virtual processos processos
hardware Mquina sem monitor de mquina virtual
hardware Mquina com monitor de mquina virtual
Colocando a multiprogramao como responsabilidade do monitor de mquina virtual podese oferecer uma mquina estendida mais simples, flexvel e fcil de manter. O modelo de mquina virtual no s oferece a possibilidade de executar diferentes sistemas operacionais em um mesmo hardware como tambm garante o isolamento total entre as mquinas, fornecendo um excelente nvel de segurana entre elas. Em uma outra abordagem a mquina virtual pode ser criada com um subconjunto dos recursos da mquina real. Em uma camada mais baixa executado um programa chamado exokernel, que atribui recursos s mquinas virtuais e garante que nenhuma mquina virtual utilize recursos de outra. Cada mquina virtual pode ter seu prprio sistema operacional. Tem a vantagem de economizar uma camada de mapeamento necessria ao monitor de mquina virtual, j que o monitor de mquina virtual precisa manter uma tabela dos recursos em uso por cada mquina virtual.
19
1.11.6 Sistemas Microkernel Uma tendncia nos sistemas operacionais modernos mover o mximo do cdigo para as camadas superiores, implementando parte das funes do sistema operacional em processos de usurio. Isto faz com que o ncleo seja menor e mais simples. Para requisitar um servio um processo de usurio (processo cliente) envia uma requisio a um processo servidor. O kernel gerencia a comunicao entre os processos. Tal diviso torna as partes menores e mais fceis de gerenciar. Para trocar alguma caracterstica do sistema operacional basta modificar o servidor especfico. Se algum servidor falhar o sistema operacional no ficar completamente comprometido. O modelo se adapta facilmente a sistemas com mltiplos processadores e sistemas distribudos. Quando o cliente se comunica com um servidor ele no precisa saber em que processador ou mquina o servidor se encontra. Nem todos os processos servidores podem executar em modo usurio, j que alguns precisam utilizar instrues privilegiadas (drivers, por exemplo). O kernel deve incorporar estas funes ou devem existir alguns processos servidores crticos executando em modo kernel. Outra soluo implementar mecanismos no kernel deixando a poltica para os servidores no espao do usurio.
Processo cliente Processo cliente Processo servidor Servidor terminal kernel ...... Servidor arquivos Servidor memria
Modo usurio Modo kernel
1.12 Exerccios
1) Qual a diferena entre programas aplicativos e programas de sistema? O sistema operacional um programa de sistema ou um programa aplicativo? 2) Qual o objetivo em se instalar um sistema operacional em um computador? 3) Quais as dificuldades que um programador teria no desenvolvimento de uma aplicao para um ambiente sem sistema operacional? 4) Explique a seguinte afirmao: O sistema operacional pode ser visto como uma mquina estendida ou como um gerenciador de recursos. 5) Explique o conceito de mquina estendida. Qual sua vantagem? 6) Qual a funo da unidade central de processamento (UCP) de um computador? 7) Quais so os componentes de uma UCP e quais so suas funes? 8) Qual a diferena entre registrador, memria cache, memria principal e memria secundria? 9) O que so memrias volteis e no volteis? 10) Quais as diferenas entre processadores CISC e processadores RISC? 11) O que se entende por ativao do sistema (boot) e desativao do sistema (shutdown). 12) Qual a diferena entre tradutor e interpretador? 13) Qual a diferena entre um compilador e um linker? 14) O que um microprograma? 15) Por que o cdigo objeto gerado por um compilador ainda no pode ser executado? 16) Por que a execuo de programas interpretados mais lenta do que a de programas compilados? 17) Qual a funo do linker? Sistemas Operacionais 20
18) Qual a funo do loader? 19) Como um depurador pode facilitar o trabalho de um programador? 20) O que so as chamadas de sistema de um sistema operacional? 21) O que um interpretador de comandos (shell)? 22) O que diferencia um sistema operacional monoprogramvel/monotarefa de um sistema operacional multiprogramvel/multitarefa? Que tipo de importncia cada um deles costuma dar proteo do sistema? 23) Por que diz-se que um sistema operacional monoprogramvel subutiliza o sistema? 24) Por que a proteo do sistema to importante para um sistema operacional multitarefa? 25) O que vem a ser um sistema com mltiplos processadores? Qual a vantagem? 26) vantajoso ter mais de uma UCP em uma mquina somente se esta mquina executar programas aplicativos desenvolvidos para explorar o paralelismo da mquina? Explique. 27) O que vem a ser um sistema multiprogramvel? 28) O que caracteriza um sistema batch? 29) Como funcionam os sistemas de tempo compartilhado? Qual a vantagem na sua utilizao? 30) Qual a diferena entre sistemas de tempo compartilhado e de tempo real? 31) Quando se deve utilizar um sistema operacional de tempo real? 32) Qual a diferena entre sistema multiprocessados simtricos e assimtricos? 33) Qual a importncia do mecanismo de interrupo para um sistema operacional multitarefa? 34) Qual a diferena entre uma interrupo e uma exceo? 35) Explique o funcionamento do mecanismo de interrupes. 36) O que o ncleo (kernel) do sistema operacional? Cite 2 funes importantes. 37) Qual a diferena entre um processo estar executando no modo usurio ou no modo kernel? 38) O que so instrues privilegiadas e no privilegiadas? 39) O que uma chamada de sistema? Qual sua importncia para a segurana do sistema? 40) Como um programador pode fazer para executar uma chamada de sistema em seu programa? 41) O que um sistema operacional com estrutura monoltica? 42) Cite uma vantagem de se projetar um sistema operacional em camadas. 43) Qual a funo do monitor de mquina virtual? 44) O que se pode falar sobre a interferncia do funcionamento de uma mquina virtual em outra dentro de um mesmo computador? 45) O que caracteriza um sistema operacional com estrutura microkernel? 46) Como funciona o modelo cliente-servidor na arquitetura microkernel? Cite vantagens na sua utilizao?
21
2 Processos
Os primeiros sistemas permitiam a execuo de apenas um programa de cada vez. Esse programa tinha o controle completo do sistema e acesso a todos os seus recursos. Os sistema atuais permitem que diversos programas sejam carregados na memria e executados simultaneamente. Essa evoluo tornou necessrio um controle maior na diviso de tarefas dos vrios programas, resultando na noo de processo. Em um sistema multiprogramvel a UCP alterna entre processos, dedicando um pouco de seu tempo a cada um, dando a iluso de paralelismo. Este esquema costuma ser chamado de pseudoparalelismo. Neste modelo, todo software executado no computador organizado em processos sequenciais, ou, simplesmente, processos. Este modelo foi desenvolvido para tornar o paralelismo mais fcil de tratar, uma vez que monitorar atividades paralelas muito difcil. Um processo um programa em execuo, incluindo os valores atuais dos registradores e variveis, assim como seu espao de endereamento. Um programa por si s no um processo, mas uma entidade passiva. Um processo uma entidade ativa, com um contador de instrues que especifica a prxima instruo a ser executada e um conjunto de registradores a ele associado. Embora dois processos possam estar associados a um mesmo programa, so duas sequncias de execuo distintas. Conceitualmente, cada processo tem sua prpria UCP. Com a UCP alternando entre os processos, a velocidade com que um processo executa no ser uniforme.
D C B A
Tempo
Processo
4 processos concorrendo
preciso dispor de uma forma de criar e destruir processos quando for necessrio. No UNIX os processos so criados pela chamada de sistema fork que cria uma cpia exata do processo em execuo. Em outros sistemas existem chamadas para criar um processo, carregar sua memria, e comear a executar. O Windows pode criar processos das duas formas. Eventualmente um processo que est em execuo necessita parar momentaneamente sua execuo por estar aguardando uma informao ainda no disponvel ou porque j executou por muito tempo e precisa liberar a UCP para outro processo. Um processo pode mudar de estado, podendo estar nos estados novo, executando, pronto, bloqueado ou terminado.
Novo 1 Bloqueado Terminado 4 6 1. O processo admitido no sistema 2. O escalonador pe o processo selecionado em execuo 3. O processo interrompido 4. O processo bloqueia para E/S ou evento 5. Fim de E/S ou ocorrncia de evento esperado 6. O processo termina sua execuo
5 2
Pronto
Executando
Para implementar o modelo de processos o sistema operacional mantm uma tabela de processos, com uma entrada por processo. Esta entrada chamada de Bloco de Controle de Processo BCP (Process Control Block PCB), e contm todas as informaes do processo. Algumas entradas do BCP so: Sistemas Operacionais 22
estado do processo prioridade do processo nmero do processo registradores da UCP informaes relativas ao gerenciamento de memria informaes de contabilidade informaes sobre operaes de E/S etc.
Essa viso d origem ao seguinte modelo:

0 1 2 3 ... Escalonador n-2 n-1
processos sequenciais gerencia interrupes e agendamento
O nvel mais baixo do sistema operacional o escalonador (tambm conhecido como agendador). Ele cuida do gerenciamento de interrupes e dos detalhes de como iniciar e parar processos. Tambm costuma ser muito pequeno. Um processo passa pelas vrias filas de seleo durante sua execuo. Cabe ao escalonador selecionar processos destas filas e decidir qual ser o prximo a ser executado. O escalonador chamado com muita frequncia. Um processo pode ser executado por apenas alguns milissegundos e ter que esperar por ter feito uma requisio de E/S. O escalonador costuma ser chamado pelo menos uma vez a cada 100 ms para realizar a troca de processos. Devido ao pequeno intervalo de tempo entre as chamadas ao escalonador sua execuo deve ser bastante rpida para que no se gaste muito tempo de UCP com trabalho de gerncia.
2.1 Mudana de Contexto

Para transferir o controle da UCP de um processo para outro necessrio guardar o estado do processo em execuo e carregar o estado do processo a entrar em execuo. Esta tarefa conhecida como mudana de contexto (ou troca de contexto). O tempo gasto na mudana de contexto varia e depende de fatores como velocidade da memria, quantidade de registradores e existncia de instrues especiais. Este tempo costuma variar de 1 a 1000 s. O contexto de um processo pode ser dividido em 3 elementos bsicos: contexto de hardware, contexto de software e espao de endereamento. O contexto de hardware constitui-se basicamente do contedo dos registradores. No momento em que o processo perde a UCP, o sistema salva suas informaes. Ele fundamental para a implementao dos sistemas multiprogramveis. O contexto de software especifica caractersticas do processo que vo influir na execuo de um programa. Ele define basicamente 3 grupos de informaes sobre um processo: identificao, quotas e privilgios. A identificao identifica o processo para o sistema de forma nica, atravs de seu pid, uid e gid. Quotas so os limites de cada recurso que o sistema operacional pode alocar, como nmero de arquivos abertos, quantidade de memria, nmero subprocessos que podem ser criados, etc. Privilgio o que o processo pode ou no fazer em relao ao sistema e outros processos. O espao de endereamento a rea de memria do processo onde o programa ser executado e a rea de memria onde os dados do processo sero armazenados. Cada processo possui seu prprio espao de endereamento, que deve ser protegido dos demais.
23
2.2 Subprocesso e Thread

Quando um processo (processo pai) cria um outro processo, o processo criado conhecido como subprocesso ou processo filho. O subprocesso, por sua vez, pode criar outros subprocessos. Caso um processo deixe de existir, os subprocessos subordinados so eliminados. A utilizao de subprocessos permite dividir uma aplicao em partes que podem trabalhar de forma concorrente. O uso de subprocessos demanda consumo de diversos recursos do sistema. Sempre que um novo processo criado o sistema deve alocar recursos (contexto de hardware, contexto de software e espao de endereamento) para ele, alm de consumir tempo de UCP. Ainda, cada processo possui seu prprio BCP. Na tentativa de diminuir o tempo gasto na criao/eliminao de processos, bem como economizar recursos do sistema, foi introduzido o conceito de thread. Em um ambiente com mltiplos threads no necessrio haver vrios processos para se implementar aplicaes concorrentes. Threads compartilham o processador da mesma maneira que um processo. Cada thread possui seu prprio conjunto de registradores (contexto de hardware), porm compartilha o mesmo espao de endereamento com os demais threads do processo. No momento em que um thread perde a utilizao do processador, o sistema salva suas informaes. Threads passam pelos mesmos estados que um processo. A grande diferena entre subprocessos e threads em relao ao espao de endereamento. Subprocessos possuem, cada um, espaos independentes e protegidos. Threads, por outro lado, compartilham o mesmo espao de endereamento do processo, sem nenhuma proteo, permitindo que um thread possa alterar dados de outro thread. Threads so desenvolvidos para trabalharem de forma cooperativa, voltados para desempenhar uma tarefa em conjunto. Threads tambm so conhecidas como processos leves. A mudana de contexto entre threads em um mesmo processo exige uma alterao de um conjunto de registradores, mas no necessrio nenhum outro trabalho, como gerenciamento de memria, por exemplo, tornando-a mais leve que a mudana de contexto entre processos.
thread contador de programa processo
3 processos, com 1 thread cada
1 processo com 3 threads
Quando mltiplos threads esto presentes no mesmo processo, alguns campos da tabela de processos no so por processo, mas por thread. Em alguns sistemas os threads so gerenciados no espao do usurio, sem o conhecimento do sistema operacional. o caso do pacote P-threads (POSIX). A comutao de threads muito mais rpida quando feita no espao do usurio por no precisar fazer uma chamada ao kernel. Porm, quando os threads so executados no espao do usurio e um thread bloqueia, todo o processo bloqueado pelo kernel. Threads no nvel do usurio tambm faz com que o tempo dedicado a threads de diferentes processos no seja distribudo de uma forma justa.
24
2.3 Tipos de Processos

Existem basicamente dois tipos de processos com relao ao tipo de processamento que executam: CPU-bound e I/O-bound. Os processos do tipo CPU-bound passam a maior parte do tempo no estado executando, realizando poucas operaes de E/S. Costumam ser encontrados em aplicaes cientficas. Os processos do tipo I/O-bound passam a maior parte do tempo no estado bloqueado por realizar um elevado nmero de operaes de E/S. Costumam ser encontrados em aplicaes comerciais. Processos interativos tambm so exemplos deste tipo de processo.
2.4 Processos Cooperativos

Os processos concorrentes em um sistema operacional podem ser independentes ou cooperativos. Um processo um processo independente se ele no afeta e no afetado por nenhum outro processo do sistema. Por outro lado, qualquer processo que afetada ou afetado por outro processo dito um processo cooperativo. Algumas razes para a cooperao entre processos so: Compartilhamento de informaes Acesso concorrente a recursos. Aumento da velocidade de processamento Aplicaes que podem ser divididas em subtarefas a serem executadas paralelamente. Modularidade Dividir as funes do sistema em processos separados. Convenincia Permitir a troca de dados entre processos dos usurios. Para que possa ser implementada a cooperao entre processos preciso existir mecanismos que permitam aos processos comunicarem-se uns com os outros e sincronizarem suas aes. Para ilustrar o conceito de processos cooperativos pode-se usar o exemplo do produtor/consumidor. Um processo produtor produz informaes que so consumidas por um processo consumidor. Para permitir a execuo concorrente dos processos produtor e consumidor preciso haver uma rea de armazenamento de itens a qual os dois processos tenham acesso. Ainda, os dois processos devem estar sincronizados para que o consumidor no tente consumir quando no houver item produzido. Outro problema que a rea de armazenamento costuma ser limitada. Assim o produtor s poder produzir enquanto houver espao para armazenamento de itens. O controle de acesso a rea de armazenamento pode ser feito por meio do sistema operacional usando comunicao interprocessos ou explicitamente pelo programador com o uso de memria compartilhada. Utilizando memria compartilhada teramos as seguintes definies compartilhadas pelos processos:
const n = ...; type item = ...; var buffer: array [0..n-1] of item; counter, in, out: integer;
A rea de armazenamento compartilhada implementada por meio de uma fila circular. A varivel in aponta para a prxima posio livre na rea de armazenamento, enquanto out aponta para a primeira posio ocupada na rea de armazenamento. O cdigo do processo produtor fica: Sistemas Operacionais 25
repeat nextp := produz_item; while (counter = n) do (*faz nada*); buffer[in] := nextp; in := (in+1) mod n; counter := counter + 1; until false;
O cdigo do processo consumidor fica:

repeat while (counter = 0) do (*faz nada*); nextc := buffer[out]; out := (out+1) mod n; counter := counter - 1; consome_item(nextc); until false;
2.5 Exerccios
1) O que um processo? 2) Pode-se afirmar que um programa executado em uma mesma mquina com sistema operacional multitarefa levar sempre o mesmo tempo para terminar sua execuo? Explique. 3) Quais os estados em que um processo pode estar? Que transies podem ocorrer entre estes estados? 4) Para cada possvel mudana de estado de um processo, cite um exemplo de evento que pode levar a tal mudana. 5) Qual a funo do bloco de controle de processos (PCB)? 6) Qual a funo do escalonador de um sistema operacional? 7) O que significa mudana de contexto? 8) Que importncia tem a tabela de processos para a mudana de contexto? 9) O que so threads? 10) Qual a diferena entre threads e subprocessos? 11) Como o uso de threads pode melhorar o desempenho de aplicaes paralelas em ambientes com mltiplos processadores? 12) Cite uma vantagem de se utilizar threads no lugar de processos cooperativos. 13) O que diferencia um processo CPU-bound de um processo I/O-bound? 14) D exemplos de aplicaes CPU-bound e I/O-bound. 15) O que so processos cooperativos? 16) Cite duas razes para a cooperao entre processos.
26
3 Comunicao Entre Processos

O surgimento dos sistemas multiprogramveis tornou possvel criar aplicaes nas quais diferentes partes de seu cdigo pudessem executar de forma concorrente. Tais aplicaes so conhecidas como aplicaes concorrentes. comum que processos de aplicaes concorrentes compartilhem recursos do sistema. No importa quais recursos so compartilhados, os problemas decorrentes sero os mesmos. O compartilhamento de recursos entre processos pode gerar situaes indesejveis capazes de comprometer o sistema. Se dois processos concorrentes trocam informaes atravs de um buffer, um processo s poder gravar dados caso o buffer no esteja cheio, enquanto um processo s poder ler dados caso o buffer no esteja vazio. Em qualquer caso, os processos devero aguardar at que o buffer esteja pronto para as operaes de E/S. As consideraes anteriores levam a 3 questes: Como um processo passa informaes a outro? Como certificar que 2 processos no se interfiram? Como realizar o sequenciamento quando um processo depende do outro? bastante comum que aplicaes concorrentes necessitem trocar informaes. Tal comunicao pode se dar por intermdio de variveis compartilhadas (memria compartilhada) ou por troca de mensagens. Mas, independente do mecanismo de comunicao utilizado, preciso que os processos tenham condies de se manterem sincronizados. Os mecanismos que garantem a comunicao entre processos concorrentes e o acesso a recursos compartilhados so chamados mecanismos de sincronizao. Os mesmos mecanismos se aplicam a threads.
3.1 Condio de Corrida

Em alguns sistemas, processos que esto trabalhando em conjunto muitas vezes utilizam uma memria comum, onde cada processo pode ler ou escrever. Este armazenamento compartilhado pode ser feito na memria principal ou em um arquivo em disco. Seja, por exemplo, um programa que atualize o saldo de um cliente aps o lanamento de um dbito ou um crdito em um registro. O trecho do programa que faz a atualizao poderia ser:
Read(Arquivo, Registro); Readln(Valor_cred_deb); Registro.Saldo := Registro.Saldo + Valor_cred_deb; Write(Arquivo, Registro);
Suponha que o processo seja executado de forma concorrente por dois caixas e que o primeiro processo leia o valor do registro. Caso o segundo processo venha a ler tambm o valor do mesmo registro antes que o primeiro tenha a oportunidade de gravar sua alterao, haver uma inconsistncia ao final das operaes. Uma delas no ser efetivada. Problemas como esse so conhecidos como condio de corrida, que quando dois ou mais processos esto acessando dados compartilhados e o resultado final do processamento depende de quem executa quando.
27
3.2 Regio Crtica

Como evitar as condies de corrida? A forma mais simples impedir que dois ou mais processos acessem um mesmo recurso no mesmo instante, impedindo que eles acessem o recurso compartilhado simultaneamente. Quando um processo estiver acessando o recurso os demais devero esperar. A esta exclusividade de acesso d-se o nome de excluso mtua, uma questo importante para o desenvolvimento de um sistema operacional. A parte do programa que acessa a memria compartilhada denominada seo crtica ou regio crtica (RC). Quando um processo est executando dentro de sua regio crtica, nenhum outro processo pode entrar na regio crtica.
Begin ...... Entra_Regiao_Critica; Regiao_Critica; Sai_Regiao_Critica; ...... End.
No suficiente evitar que o processo seja interrompido dentro da regio crtica. So quatro as condies para uma boa soluo: 1. 2. 3. 4. No pode haver mais de um processo simultaneamente dentro de suas regies crtica. Nenhuma suposio pode ser feita sobre a velocidade ou o nmero de UCPs. Nenhum processo que execute fora de sua regio crtica pode bloquear outro processo. Nenhum processo deve ter que esperar eternamente para entrar em sua regio crtica (starvation).
Como pode ser observado, para garantir a implementao da excluso mtua os processos envolvidos devem fazer acesso aos recursos compartilhados de forma sincronizada.
3.3 Sincronizao Condicional

Outra situao na qual necessria a sincronizao entre processos concorrentes quando um recurso compartilhado no se encontra pronto para ser utilizado. Nesse caso, o processo que deseja acessar o recurso dever ser colocado no estado bloqueado at o recurso ficar pronto para o processamento. Um exemplo clssico a comunicao entre dois processos atravs de operaes de gravao e leitura em um buffer. Os processos envolvidos devem estar sincronizados de forma que um processo no tente gravar dados em um buffer cheio ou ler de um buffer vazio. Abaixo mostrado, produtor/consumidor. como exemplo de sincronizao condicional, o programa
PROGRAM Produtor_Consumidor; CONST TamBuf = (* Tamanho qualquer *); (* Tamanho do Buffer *) TYPE Tipo_Dado = (* Tipo qualquer *); (* Tipo do dado *) VAR Buffer : ARRAY [1..TamBuf] OF Tipo_Dado; Dado : Tipo_Dado; Cont : 0..TamBuf; (* Contador que controla o Buffer *) PROCEDURE Produtor; BEGIN REPEAT Produz_Dado (Dado); WHILE (Cont = TamBuf) DO (* Nao faz nada *); Grava_Buffer (Dado, Cont); UNTIL False; END;
28
PROCEDURE Consumidor; BEGIN REPEAT WHILE (Cont = 0) Do (* Nao faz nada *); Le_Buffer (Dado, Cont); Consome_Dado (Dado); UNTIL False; END; BEGIN Cont := 0; PARBEGIN Produtor; Consumidor; PAREND; END.
Nessa soluo, a tarefa de colocar e retirar os dados do buffer realizada pelos procedimentos Grava_Buffer e Le_Buffer. Essas duas rotinas devero ser executadas de forma mutuamente exclusiva.
3.4 Excluso Mtua por Hardware

As solues por hardware no podem ser utilizadas por qualquer programa, pois normalmente requerem o uso de instrues privilegiadas, mas so importantes de serem estudadas porque criam mecanismos que permitem a implementao das solues por software. 3.4.1 Desabilitao de Interrupes Consiste em permitir ao processo do usurio desabilitar interrupes antes de entrar na regio crtica de forma a evitar que o processo seja interrompido dentro da regio crtica. Como a mudana de contexto s pode ser realizada atravs de interrupes, o processo que as desabilitou ter acesso exclusivo garantido. O processo deve habilitar novamente as interrupes ao sair da regio crtica. No bom que processos de usurios possam desativar interrupes. Alm disso, sistemas com mais de uma UCP s tero uma delas desativada. um mecanismo til apenas quando utilizado pelo kernel. 3.4.2 Instruo TSL (Test and Set Lock) Consiste em uma instruo especial da UCP que permite ler uma varivel, armazenar seu contedo em uma outra e atribuir um novo valor a essa varivel. Tal instruo tem como caracterstica ser sempre executada sem ser interrompida. Assim, no existe a possibilidade de dois processos estarem manipulando uma varivel compartilhada ao mesmo tempo, possibilitando a implementao da excluso mtua.
Test_and_Set (X,Y);
A instruo possui o formato acima e quando executada o valor lgico de Y copiado para X, sendo atribudo Y o valor lgico verdadeiro.
PROGRAM Programa_Test_and_Set; VAR Bloqueio : BOOLEAN; PROCEDURE Processo_A; VAR Pode_A : BOOLEAN; BEGIN REPEAT Pode_A := True; WHILE (Pode_A) Do Test_and_Set (Pode_A, Bloqueio); Regiao_Critica_A; Bloqueio := False; UNTIL False; END;
29
PROCEDURE Processo_B; VAR Pode_B : BOOLEAN; BEGIN REPEAT Pode_B := True; WHILE (Pode_B) Do Test_and_Set (Pode_B, Bloqueio); Regiao_Critica_B; Bloqueio := False; UNTIL False; END; BEGIN Bloqueio := False; PARBEGIN Processo_A; Processo_B; PAREND; END.
A soluo apresentada acima, apesar de funcionar apresenta o problema de ser uma soluo com espera ativa (espera ocupada), ou seja, apesar do processo no poder continuar sua execuo, ele continua consumindo tempo de UCP desnecessariamente.
3.5 Excluso Mtua por Software com Espera Ativa

As primeiras solues por software que surgiram para implementar a excluso mtua, apesar de mais simples, apresentam o problema da espera ativa. A seguir so mostradas duas destas solues. 3.5.1 Alternncia Estrita Dois processos concorrem de forma alternada por uma regio crtica e testam continuamente uma varivel at que seu valor seja o desejado. Assim, eles alternam a ordem de entrada na regio crtica.
Program Alternancia; var vez: char; procedure Processo_A; begin repeat while (vez = 'B') do (* nao faz nada *); Regiao_Critica_A; vez := 'B'; Processamento_Longo; until false; end; procedure Processo_B; begin repeat while (vez = 'A') do (* nao faz nada *); Regiao_Critica_B; vez := 'A'; until false; end; begin vez := 'A'; parbegin Processo_A; Processo_B; parend; end.
30
A soluo apresentada tem o problema de desperdiar tempo de UCP (espera ativa), alm de violar as 2a e 3a condies para uma boa soluo. 3.5.2 Soluo de Peterson Peterson apresentou uma soluo totalmente por software em 1981.
Program Peterson; var CA, CB: Boolean; Vez: Char; Procedure Processo_A; Begin Repeat CA := True; Vez := 'B'; While (CB and Vez='B') do (* faz nada *); Regiao_Critica_A; CA := False; Processamento_A; Until False; End; Procedure Processo_B; Begin Repeat CB := True; Vez := 'A'; While (CA and Vez='A') do (* faz nada *); Regiao_Critica_B; CA := False; Processamento_B; Until False; End; Begin CA := False; CB := False; ParBegin Processo_A; Processo_B; ParEnd; End.
3.6 Excluso Mtua por Software sem Espera Ativa

A espera ativa gasta tempo de UCP e apresenta o problema da inverso de prioridade, que ocorre quando um processo de maior prioridade deseja entrar em sua regio crtica mas no pode porque outro processo de menor prioridade j est na regio crtica. O processo de maior prioridade no pode entrar na regio crtica e o de menor prioridade recebe pouco tempo de UCP para sair da regio crtica. Para resolver este problema melhor utilizar mecanismos de sincronizao para bloquear um processo que deseja entrar na regio crtica e no pode, evitando que a UCP seja utilizada de forma desapropriada. 3.6.1 Semforos Um semforo uma varivel inteira que conta sinais enviados a ela. Associadas aos semforos existem duas operaes especiais: up e down. A operao down decrementa o valor do semforo se ele for maior que 0, seno o processo bloqueado. A operao up incrementa o valor do semforo caso no hajam processos que tenham sido bloqueados pela operao down, seno um processo desbloqueado. Sistemas Operacionais 31
No caso da excluso mtua, as instrues down e up funcionam como protocolos 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. Se seu valor for maior que 0, nenhum processo est utilizando o recurso, caso contrrio, o processo fica impedido de acessar o recurso. Sempre que deseja entrar na sua regio crtica um processo executa uma instruo down. Se o semforo for maior que 0 ele decrementado de 1 e o processo que solicitou a operao pode executar sua regio crtica. Se uma instruo down executada em um semforo cujo valor seja 0, o processo que solicitou a operao ficar no estado bloqueado em uma fila associada ao semforo. Quando o processo que est acessando o recurso sai de sua regio crtica, ele executa uma instruo up, incrementando o semforo de 1 e liberando o acesso ao recurso. Se um ou mais processos estiverem esperando, o sistema escolhe um processo na fila de espera e muda seu estado para pronto. As operaes up e down so realizadas pelo sistema operacional, que deve garantir que elas sejam executadas atomicamente. Exemplo de utilizao de semforos para acesso regio crtica:
Program Semaforo; Var s: semaforo; Procedure Processo_A; Begin Repeat Down(s); Regiao_Critica_A; Up(s); Until False; End; Procedure Processo_B; Begin Repeat Down(s); Regiao_Critica_B; Up(s); Until False; End; Begin s := 1; ParBegin Processo_A; Processo_B; ParEnd; End.
Exemplo de sincronizao condicional com semforos (produtor/consumidor):

PROGRAM Produtor_Consumidor; CONST TamBuf = (* Tamanho qualquer *); (* Tamanho do buffer *) TYPE Tipo_Dado = (* Tipo qualquer *); VAR Vazio : Semaforo; (* Quantas entradas do buffer estao vazias *) Cheio : Semaforo; (* Quantas entradas do buffer estao ocupadas *) Mutex : Semaforo; (* Semaforo usado para garantir a exclusao mutua *) Buffer : ARRAY [1..TamBuf] OF Tipo_Dado; Dado1, Dado2 : Tipo_Dado; PROCEDURE Produtor; BEGIN REPEAT Produz_Dado (Dado1); down (Vazio); down (Mutex);
32
Grava_Dado (Dado1, Buffer); up (Mutex); up (Cheio); UNTIL False; END; PROCEDURE Consumidor; BEGIN REPEAT down (Cheio); down (Mutex); Le_Dado (Dado2, Buffer); up (Mutex); up (Vazio); Consome_Dado (Dado2); UNTIL False; END; BEGIN Vazio := TamBuf; Cheio := 0; Mutex := 1; PARBEGIN Produtor; Consumidor; PAREND; END.
Deve-se ter cuidado com o uso de semforos. No exemplo do produtor/consumidor, se o produtor fizer down em mutex antes de em vazio e o buffer estiver cheio, o consumidor faz down em mutex para acessar o buffer e os dois processos bloqueiam. Semforo devem ser usados com cuidado. Pode-se ocultar o mecanismo de interrupes utilizando um semforo para cada dispositivo de E/S. 3.6.2 Monitores O uso de semforos exige do programador muito cuidado, pois qualquer engano pode levar a problemas de sincronizao imprevisveis e difceis de reproduzir. Monitores so mecanismos de sincronizao de alto nvel que tentam tornar mais fceis o desenvolvimento e a correo de programas concorrentes. Um monitor uma coleo de variveis, procedimentos e estruturas de dados que so agrupados em um pacote. Em um dado instante somente um processo pode estar ativo em um monitor. Toda vez que algum processo chama um procedimento do monitor, o monitor verifica se j existe outro processo executando qualquer procedimento do monitor. Caso exista, o processo ficar aguardando a sua vez at que tenha permisso para executar.
Variveis Globais Procedimento
Procedimento
Procedimento Procedimento Cdigo de Inicializao
33
As variveis globais do monitor so visveis apenas a ele e a seus procedimentos. O bloco de comandos do monitor responsvel por inicializar essas variveis, sendo executado apenas urna vez na ativao do programa onde est declarado o monitor. Cabe ao compilador implementar as excluses mtuas em entradas de monitor. A clusula synchronized da linguagem Java um exemplo de implementao de monitores. O programador transforma regies crticas em procedimentos de monitor colocando todas as regies crticas em forma de procedimentos no monitor. Desta forma o desenvolvimento de programas concorrentes fica mais fcil. Para a implementao da sincronizao condicional necessrio utilizar variveis de condio e duas instrues que operam sobre elas: wait e signal. Por exemplo, quando o produtor no pode continuar faz wait na varivel full e fica bloqueado. O consumidor pode ento entrar na regio crtica e acordar o produtor com signal. Para no haver mais de um processo na regio crtica, signal tem que ser a ltima instruo executada na regio crtica.
PROGRAM Produtor_Consumidor; CONST TamBuf = (* Tamanho qualquer *); (* Tamanho do buffer *) TYPE Tipo_Dado = (* Tipo qualquer *); VAR Buffer : ARRAY [1..TamBuf] OF Tipo_Dado; MONITOR Condicional; VAR Vazio, Cheio : Condition; (* Variaveis de condicao *); Cont : INTEGER; PROCEDURE Produz(Dado : Tipo_Dado); BEGIN IF (Cont = TamBuf) THEN WAIT (Cheio); Grava_Dado (Dado, Buffer); Cont := Cont + 1; IF (Cont = 1 THEN SIGNAL (Vazio); END; PROCEDURE Consome(var Dado : Tipo_Dado); BEGIN IF (Cont = 0) THEN WAIT (Vazio); Le_Dado (Dado, Buffer); Cont := Cont - 1; IF (Cont = TamBuf - 1) THEN SIGNAL (Cheio); END; BEGIN Cont := 0; END; (* Termina monitor *) PROCEDURE Produtor; VAR Dado : Tipo_Dado; BEGIN REPEAT Produz_Dado (Dado); Condicional.Produz (Dado); UNTIL False; END; PROCEDURE Consumidor; VAR Dado : Tipo_Dado; BEGIN REPEAT Condicional.Consome (Dado); Consome_Dado (Dado); UNTIL False; END; BEGIN PARBEGIN Produtor; Consumidor;
34
PAREND; END.
3.6.3 Troca de Mensagens A troca de mensagens um mecanismo de comunicao e sincronizao entre processos sem a necessidade de utilizao de memria compartilhada. Ela implementada pelo sistema operacional atravs das rotinas send e receive. A rotina send responsvel por enviar uma mensagem para um processo receptor enquanto a rotina receive responsvel por receber uma mensagem de um processo.
send (Receptor, Mensagem); receive (Transmissor, Mensagem);
Os procedimentos send e receive, mesmo no tendo suas execues mutuamente exclusivas, permitem tanto a comunicao entre processos quanto a sincronizao entre eles. Um problema com a troca de mensagens que uma mensagem de um processo P para outro processo Q pode ser perdida em algum lugar. Existem trs mtodos bsicos para tratamento dessa falha: O sistema operacional responsvel por detectar a ocorrncia dessa falha e por enviar novamente a mensagem. O processo remetente responsvel por detectar a ocorrncia dessa falha e por transmitir novamente a mensagem. O sistema operacional responsvel por detectar a ocorrncia dessa falha e notifica o processo remetente de que a mensagem foi perdida. A deteco de mensagens perdidas no sempre necessria. Alguns protocolos de rede especificam que o envio de mensagens no confivel, enquanto outros garantem o envio. O mtodo mais comum de deteco de mensagem perdida baseado em expirao de tempo. Quando uma mensagem enviada, uma mensagem de confirmao de recebimento da mensagem enviada de volta. O sistema operacional ou um processo pode ento especificar um intervalo de tempo durante o qual ele espera pela chegada da confirmao de recebimento da mensagem. Se a confirmao no chegar nesse perodo supem-se que a mensagem se perdeu e ela reenviada. No entanto possvel que ela no tenha se perdido, mas simplesmente demorado mais do que o esperado. Nesse caso, pode-se ter vrias cpias de uma mesma mensagem. Deve existir um mecanismo para fazer a distino entre esses vrios tipos de mensagens. Esse problema pode ser resolvido numerando-se as mensagens. Para que dois processos se comuniquem, eles devem ter uma maneira de se referir um ao outro. No mecanismo de comunicao direta, tambm conhecida como endereamento direto, cada processo que queira se comunicar com outro deve usar explicitamente o nome do processo receptor ou remetente da mensagem. Nesse esquema, as primitivas send e receive so definidas: send (P, mensagem) Envia uma mensagem ao processo P. receive (Q, mensagem) Recebe uma mensagem do processo Q. A comunicao direta s permite a comunicao entre dois processos. Seu maior problema a necessidade da especificao da identificao dos processos envolvidos na troca de mensagens. O exemplo produtor/consumidor para este caso : Produtor
REPEAT Produz_Dado (Dado); SEND (Consumidor, Dado); UNTIL False;
Consumidor
REPEAT RECEIVE (Produtor, Dado); Consome_Dado (Dado); UNTIL False;
35
Esse exemplo exibe uma simetria no endereamento, tanto o processo remetente quanto o destinatrio precisam usar o nome do outro processo para se comunicar. Uma variante desse esquema usa uma assimetria no endereamento, apenas o remetente necessita usar o nome do receptor. Assim, as primitivas send e receive so definidas: send (P, mensagem) Envia uma mensagem ao processo P. receive (id, mensagem) Recebe uma mensagem de qualquer processo e a identificao do processo com o qual a comunicao ocorreu armazenado na varivel id. Na comunicao indireta, tambm conhecida como endereamento indireto, as mensagens so enviadas e recebidas por intermdio de uma rea compartilhada conhecida como caixa postal (mailbox). Uma caixa postal pode ser vista abstratamente como um lugar no qual processos podem colocar mensagens e do qual mensagens podem ser retiradas. Nesse esquema um processo pode se comunicar com outro por intermdio de diversas caixas postais diferentes. Dois processos s podem se comunicar se compartilharem o uso de alguma caixa postal. As primitivas send e receive so definidas: send(A, mensagem) Envia uma mensagem para a caixa postal A. receive(A, mensagem) Recebe uma mensagem da caixa postal A. A troca de mensagens pode ou no bloquear os processos envolvidos. Basicamente, existem duas formas de troca de mensagens entre processos: comunicao sncrona e comunicao assncrona. Na comunicao sncrona, quando um processo envia uma mensagem fica esperando at que o processo receptor leia a mensagem, ou quando um processo tenta receber uma mensagem permanece esperando at que o processo transmissor envie alguma mensagem. Esse tipo de comunicao dispensa a necessidade de buffers. Esse mecanismo tambm conhecido como rendezvous. Na comunicao assncrona nem o receptor permanece aguardando o envio de uma mensagem nem o transmissor o seu recebimento. Alm da necessidade de buffers para armazenar as mensagens, deve haver outros mecanismos de sincronizao que permitam ao processo identificar se uma mensagem j foi enviada ou recebida. A grande vantagem da comunicao assncrona o maior paralelismo na execuo dos processos. O programa a seguir ilustra a utilizao de troca de mensagens para o produtor/consumidor.
PROGRAM Produtor_Consumidor; PROCEDURE Produtor; VAR Msg : Tipo_Msg; BEGIN REPEAT Produz_Mensagem (Msg); SEND (Msg); UNTIL False; END; PROCEDURE Consumidor; VAR Msg : Tipo_Msg; BEGIN REPEAT RECEIVE (Msg); Consome_Mensagem (Msg); UNTIL Falte; END; BEGIN PARBEGIN Produtor; Consumidor; PAREND;
36
END.
3.7 Deadlock
Um processo est em deadlock quando est esperando por um evento que nunca ocorrer. Essa situao costuma ser consequncia do compartilhamento de recursos do sistema entre vrios processos, sendo que cada processo deve ter acesso ao recurso de forma exclusiva. Sendo A e B dois processos que necessitem dos recursos 1 e 2, suponha que A adquira o recurso 1 e que B adquira o recurso 2. Se no futuro A precisar do recurso 2 e B precisar do recurso 1, os dois processos entraro em espera circular, levando ao deadlock. Para que ocorram situaes de deadlock em um sistema, so necessrias pelo menos quatro condies: 1. Cada recurso s pode estar alocado a um nico processo em um determinado instante (excluso mtua). 2. Um processo, alm dos recursos j alocados, pode estar esperando por outros recursos. 3. Um recurso no pode ser liberado de um processo s porque outros processos desejam o mesmo recurso (no preempo). 4. Um processo pode ter de esperar por um recurso alocado a outro processo e vice-versa (espera circular). 3.7.1 Preveno de Deadlock Para prevenir a ocorrncia de deadlocks basta garantir que uma das quatro condies necessrias para sua ocorrncia nunca se satisfaa. A ausncia da primeira condio (excluso mtua) certamente acaba com o problema do deadlock. Entretanto, a falta da excluso mtua gera inconsistncias srias no nvel dos processos e do sistema. Na segunda condio, se for possvel evitar que os processos que j possuam recursos garantidos requisitem novos recursos, estar resolvido o problema do deadlock. Uma maneira de implementar esse mecanismo , sempre que um processo necessitar de recursos para executar, ele deve requisit-los antes de comear sua execuo. Se todos os recursos necessrios ao processo estiverem disponveis o processo poder aloc-los e iniciar sua execuo. Caso contrrio, nenhum recurso ser alocado e o processo ficar no estado bloqueado. Esse mecanismo pode produzir um grande desperdcio na utilizao dos recursos do sistema. Outro problema decorrente desse mecanismo a dificuldade de se determinar o nmero de recursos que um processo dever alocar antes da sua execuo. No entanto, o mais grave nesse mtodo a possibilidade de um processo sofrer starvation, ou seja, todos os recursos necessrios sua execuo nunca estarem disponveis ao mesmo tempo. A terceira condio pode ser evitada quando permitimos que um recurso seja retirado de um processo no caso de outro processo necessitar do mesmo recurso. A liberao de recursos j garantidos por um processo pode ocasionar srios problemas, podendo at fazer o processo perder todo o processamento at ento realizado. Outro problema desse mecanismo a possibilidade de um processo sofrer starvation, quando o processo garante alguns recursos necessrios sua execuo e o sistema os libera em seguida. A ltima maneira de evitar um deadlock excluir a possibilidade da espera circular (quarta condio). Uma forma de implementar esse mecanismo forar o processo a ter apenas um recurso de cada vez. Se necessitar de outro recurso, deve liberar o primeiro. Outra forma de implementar tal mecanismo numerar os recursos e forar que os processos possam alocar os recursos somente em determinada ordem.
37
3.7.2 Deteco do Deadlock Em sistemas que no possuam mecanismos que previnam a ocorrncia de deadlocks, necessrio um esquema de deteco e correo do problema. Para detectar deadlocks os sistemas operacionais devem manter estruturas de dados capazes de identificar cada recurso do sistema, o processo que o est alocando e os processos que esto espera da liberao do recurso. Toda vez que um recurso alocado ou liberado por um processo, a estrutura deve ser atualizada. Dependendo do tipo de sistema, o ciclo de busca por um deadlock pode variar. Em sistemas de tempo compartilhado, o tempo de busca pode ser maior, sem comprometer o desempenho e a confiabilidade do sistema. Sistemas de tempo real, por sua vez, devem constantemente certificar-se da ocorrncia de deadlocks, porm essa maior segurana gera mais overhead no sistema. 3.7.3 Correo do Deadlock Uma soluo bastante utilizada pela maioria dos sistemas operacionais simplesmente eliminar um ou mais processos envolvidos no deadlock, eliminando a espera circular. A eliminao dos processos envolvidos no deadlock pode no ser simples, dependendo do tipo do recurso envolvido. Se um processo estiver atualizando um arquivo ou imprimindo uma listagem, o sistema deve garantir que esses recursos sejam liberados sem problemas. Os processos eliminados no tm como ser recuperados, porm outros processos que estavam em deadlock podero prosseguir. Uma soluo menos drstica envolve a liberao de apenas alguns recursos alocados aos processos para outros processos, at que o ciclo de espera termine. Para que essa soluo seja realmente eficiente, necessrio que o sistema possa suspender um processo, liberar seus recursos e, aps a soluo do problema, retornar execuo do processo sem perder o processamento j realizado. Esse mecanismo conhecido como rollback e, alm do overhead gerado, muito difcil de ser implementado por ser bastante dependente da aplicao que est sendo processada.
3.8 Problemas Clssicos de Comunicao Interprocessos

3.8.1 Problema dos Filsofos Comendo um problema que visa demonstrar a sincronizao entre processos. Consiste em filsofos sentados em torno de uma mesa redonda, cada um com um prato de macarro a sua frente. O macarro escorregadio e s pode ser comido se forem usados dois garfos. Os filsofos s pensam ou comem, e para comer precisam dos dois garfos. Eles s pegam os garfos na hora de comer. Soluo errada:
procedure filosofo(i: integer); begin while (true) begin pensa; pega_garfo(ESQ(i)); pega_garfo(DIR(i)); come; libera_garfo(ESQ(i)); libera_garfo(DIR(i)); end; end;
Se todos pegarem o garfo esquerdo, todos os processos ficaro bloqueados. Se colocar as 5 declaraes aps pensa protegidas por um semforo binrio funciona, mas somente um filsofo come por vez. Sistemas Operacionais 38
Uma soluo correta :

Program Filosofos; const N=5; PENSANDO=0; FOME=1; COMENDO=2; var estado: array [1..N] of integer; mutex: semaphore; S: array [1..N] of semaphore; i: integer; function ESQ(i:integer): integer; begin ESQ := ((i-1) mod N) + 1; end; function DIR(i:integer): integer; begin DIR := ((i+1) mod N) + 1; end; procedure teste(i: integer) begin if ((estado[i]=FOME) and (estado[ESQ(i)]<>COMENDO) and (estado[DIR(i)]<>COMENDO)) then begin estado[i] := COMENDO; up(S[i]); end; end; procedure pega_garfos(i: integer); begin down(mutex); estado[i] := FOME; teste(i); up(mutex); down(s[i]); end; procedure larga_garfos(i: integer); begin down(mutex); estado[i] := PENSANDO; teste(ESQ(i)); teste(DIR(i)); up(mutex); end; procedure filosofo(i: integer); begin while (true) begin pensa; pega_garfos(i); come; larga_garfos(i); end; end; begin mutex := 1; for i:=1 to N do S[i] := 0; for i:=1 to N do estado[i] := PENSANDO; parbegin for i:=1 to N do filosofo(i); end; end.
39
3.8.2 Problema dos Leitores e dos Escritores Visa resolver o problema de atualizar um banco de dados no qual vrios processos esto realizando consultas paralelamente. Procura-se uma soluo na qual as consultas possam ser realizadas em paralelo, ao passo que uma atualizao s poder ocorrer se o processo conseguir acesso exclusivo ao banco de dados.
Program LeitoresEscritores; var mutex, db: semaphore; rc: integer; procedure escritor; begin while (true) begin cria_dados; down(db); escreve_banco_dados; up(db); end; end; procedure leitor; begin while (true) begin down(mutex); rc := rc + 1; if (rc=1) then down(db); up(mutex); le_banco_dados; down(mutex); rc := rc - 1; if (rc=0) then up(db); up(mutex); usa_dados; end; end; begin mutex := 1; db := 1; rc := 0; (* Iniciar processos leitores e escritores *) end.
Problema: Escritor s acessa se nenhum leitor quiser acessar antes. 3.8.3 Problema do Barbeiro Adormecido Simula uma barbearia onde vrios barbeiros esto a disposio dos clientes que entram. Se no houver cliente, o barbeiro dorme. O primeiro cliente que chega acorda um barbeiro para ter seu cabelo cortado. O cliente que chega e encontra todos os barbeiros ocupados senta-se em uma das cadeiras para aguardar at que um barbeiro fique livre. Se no tiver cadeira para sentar o cliente vai embora.
Program BarbeiroAdormecido; const CADEIRAS=5; var clientes, barbeiros, mutex: semaphore; esperando: integer; procedure barbeiro; begin while(true) begin down(clientes);
40
down(mutex); esperando := esperando - 1; up(barbeiros); up(mutex); corta_cabelo; end; end; procedure cliente; begin down(mutex); if (esperando<CADEIRAS) then begin esperando := esperando + 1; up(clientes); up(mutex); down(barbeiros); cabelo_cortado; end else up(mutex); end; begin clientes := 0; barbeiros := 0; mutex := 0; esperando := 0; (* iniciar processos clientes e barbeiros *) end.
3.9 Exerccios
1) O que uma aplicao concorrente? 2) O que um mecanismo de sincronizao? 3) O que condio de corrida? Por que ela problemtica? 4) O que regio crtica? Qual a sua finalidade? 5) Por que o mecanismo de excluso mtua evita a condio de corrida? 6) O que starvation? 7) Para que serve a sincronizao condicional? 8) Como a desabilitao de interrupes pode evitar a condio de corrida? 9) Por que no adianta desabilitar interrupes em sistemas com mais de uma UCP? 10) Por que no conveniente que o sistema operacional permita que um programa de usurio possa desabilitar interrupes? 11) O que espera ativa? Por que ela deve ser evitada? 12) Explique de forma sucinta como o funcionamento dos semforos. 13) O mecanismo de semforo pode ser utilizado para resolver o problema de starvation? Explique. 14) Como o mecanismo de semforo pode ser utilizado para resolver o problema da condio de corrida? 15) Como o mecanismo de semforo pode ser utilizado para realizar a sincronizao condicional? 16) A utilizao errada de semforos pode levar ao travamento de uma aplicao? Explique. Sistemas Operacionais 41
17) Como o funcionamento dos monitores como soluo para a condio de corrida? Por que signal deve ser a ltima instruo executada na regio crtica? 18) Por que monitores so de mais fcil utilizao pelos programadores do que os semforos? 19) Para a cooperao entre processos pode ser utilizada memria compartilhada ou troca de mensagens. Qual a diferena? 20) Explique de forma sucinta como funciona o mecanismo de troca de mensagens. 21) Na troca de mensagens, qual a diferena entre comunicao direta e comunicao indireta? 22) Na troca de mensagens, qual a diferena entre comunicao sncrona e comunicao assncrona? 23) No mecanismo de troca de mensagens, o que ocorre quando um processo tenta enviar uma mensagem ao outro e o canal de comunicao no tem mais espao para armazenar esta mensagem? 24) O que deadlock? 25) Qual a diferena entre preveno de deadlock e deteco do deadlock? 26) Cite uma forma de corrigir o deadlock.
42
4 Gerncia do Processador
A multiprogramao tem como objetivo permitir que, a todo instante, haja algum processo sendo executado para maximizar a utilizao da UCP. O conceito que possibilitou a implementao de sistemas multiprogramveis foi a possibilidade da UCP ser compartilhada entre diversos processos. Portanto, deve existir um critrio para determinar qual a ordem na escolha dos processos para execuo dentre os vrios que concorrem pela UCP. O procedimento de seleo conhecido como escalonamento (scheduling). A parte do sistema operacional responsvel pelo escalonamento o escalonador (scheduler), as vezes chamado de agendador. Sempre que a UCP se torna ociosa o escalonador seleciona um processo, dentre aqueles que esto na memria prontos para serem executados, e aloca a UCP para que ele possa ser executado. Os principais objetivos do escalonamento so: Manter a UCP ocupada a maior parte do tempo; Balancear a utilizao da UCP entre os processos; Maximizar o throughput do sistema; Oferecer tempos de resposta razoveis para os usurios interativos.
Esses objetivos devem ser atendidos de forma que nenhum processo fique esperando indefinidamente pela utilizao do processador (starvation). A principal funo de um algoritmo de escalonamento decidir qual dos processos prontos deve ser alocado UCP. Os principais critrios de escalonamento so: Imparcialidade Oferecer uma fatia justa da UCP a cada processo. Utilizao da UCP desejvel que a UCP passe a maior parte de seu tempo ocupada. Throughput (produtividade) Representa o nmero de processos executados durante um intervalo de tempo. Tempo de processamento (turnaround) Tempo que um processo leva desde a sua admisso no sistema at o seu trmino. Tempo de resposta Em sistemas interativos, o tempo desde o momento da submisso de um pedido at a primeira resposta produzida. Tempo de espera Tempo que um processo fica esperando na fila de processos prontos. Algumas destas metas so contraditrias. Sempre que se favorece alguma meta outra prejudicada. Outra complicao que o comportamento dos processos imprevisvel. O algoritmo de escalonamento no o nico responsvel pelo tempo de execuo de um processo. Ele afeta somente o tempo de espera na fila de processos prontos. Os algoritmos de escalonamento podem ser classificados como preemptivos ou no-preemptivos. Quando o sistema pode interromper um processo durante sua execuo para coloc-lo no estado pronto e colocar outro processo no estado executando, tem-se um sistema preemptivo. Seno tem-se um sistema no-preemptivo. O escalonamento preemptivo permite que o sistema d ateno imediata a processos mais prioritrios, alm de proporcionar melhor tempo de resposta em sistemas de tempo compartilhado. Outro benefcio decorrente o compartilhamento do processador de uma maneira mais uniforme.
43
A troca de um processo por outro na UCP (mudana de contexto) causada pela preempo, gera um overhead ao sistema. Para isto no se tornar crtico, o sistema deve estabelecer corretamente os critrios de preempo. Sistemas que usam escalonamento preemptivo tm o problema da condio de corrida, o que no ocorre com sistemas que usam escalonamento no-preemptivo. No escalonamento nopreemptivo, quando um processo ganha o direito de utilizar a UCP, nenhum outro processo pode lhe tirar esse recurso.
4.1 Algoritmos de Escalonamento

4.1.1 Escalonamento First In First Out (FIFO) Nesse escalonamento, o processo que chegar primeiro o primeiro a ser selecionado para execuo. necessria apenas uma fila, onde os processos que passam para o estado pronto entram no seu final. Quando um processo ganha a UCP, ele a utiliza sem ser interrompido, caracterizando-o como um algoritmo no-preemptivo. O problema do escalonamento FIFO a impossibilidade de se prever quando um processo ter sua execuo iniciada. Outro problema a possibilidade de processos CPU-bound de menor importncia prejudicarem processos I/O-bound mais prioritrios. Este algoritmo foi inicialmente implementado em sistemas batch. 4.1.2 Escalonamento Shortest Job First (SJF) Esse algoritmo associa a cada processo seu tempo de execuo. Quando a UCP est livre, o processo no estado pronto que precisar de menos tempo para terminar selecionado para execuo. O escalonamento SJF beneficia processos que necessitam de pouco processamento e reduz o tempo mdio de espera em relao ao FIFO. O problema determinar quanto tempo de UCP cada processo necessita para terminar seu processamento. Em ambientes de produo possvel estimar o tempo de execuo, mas em ambientes de desenvolvimento muito difcil. um algoritmo de escalonamento no-preemptivo e, assim como o FIFO, tambm foi utilizado nos primeiros sistemas operacionais com processamento batch. 4.1.3 Escalonamento Cooperativo Tanto o SJF quanto o FIFO no so algoritmos de escalonamento aplicveis a sistemas de tempo compartilhado, onde um tempo de resposta razovel deve ser garantido a usurios interativos. No escalonamento cooperativo, quando um processo j est em execuo a um determinado tempo, ele voluntariamente libera a UCP retornando para a fila de processos prontos. Sua principal caracterstica est no fato da liberao da UCP ser uma tarefa realizada exclusivamente pelo processo em execuo, que a libera para um outro processo. No existe nenhuma interveno do sistema operacional na execuo do processo. Isto pode ocasionar srios problemas na medida em que um programa pode no liberar a UCP ou um programa mal escrito pode entrar em loop, monopolizando a UCP. um algoritmo de escalonamento no-preemptivo. 4.1.4 Escalonamento Circular (Round Robin) Esse algoritmo bem semelhante ao FIFO. Entretanto, quando um processo passa para o estado executando, existe um tempo limite (conhecido como time-slice ou quantum) para utilizao da UCP de forma contnua. Quando esse tempo expira o processo volta ao estado pronto, dando a vez para outro processo.
44
A fila de processos no estado pronto tratada como uma fila circular. O escalonamento realizado alocando a UCP para cada processo da fila no intervalo de tempo determinado pelo quantum. Se o quantum for muito pequeno gasta-se muito tempo de UCP com trabalho administrativo. Se o quantum for muito grande a interatividade fica prejudicada, j que um processo que sai de execuo pode demorar muito a voltar. Em geral, o quantum varia de 10 a 100 ms. Atravs do escalonamento circular, nenhum processo poder monopolizar a UCP, caracterizando-o como um algoritmo de escalonamento preemptivo.
Processo atual Prximo processo Processo atual Prximo processo
preempo
Um problema com o escalonamento circular que ele no oferece qualquer tratamento diferenciado a processos I/O-bound. Assim processos CPU-bound tero a tendncia de monopolizar a utilizao da UCP enquanto processos I/O-bound permanecem a espera. 4.1.5 Escalonamento por Prioridade O escalonamento circular consegue melhorar a distribuio do tempo de UCP em relao aos escalonamentos no-preemptivos, porm ainda no consegue implementar um compartilhamento equitativo entre os diferentes tipos de processos. Para solucionar esse problema, os processos I/O-bound devem levar alguma vantagem no escalonamento, a fim de compensar o tempo excessivo gasto no estado bloqueado. Como alguns processos devem ser tratados de maneira diferente dos outros, preciso associar a cada um deles uma prioridade de execuo. Assim, processos de maior prioridade so escalonados preferencialmente. A preempo por prioridade implementada mediante um relgio que interrompe o processador periodicamente para que a rotina de escalonamento reavalie prioridades e, possivelmente, escalone outro processo, caracterizando-o como um algoritmo de escalonamento preemptivo. Todos os sistemas de tempo compartilhado implementam algum esquema de prioridade. A prioridade uma caracterstica do contexto de software de um processo, podendo ser esttica ou dinmica. Tem-se a prioridade esttica quando a prioridade no modificada durante a existncia do processo. Apesar da simplicidade de implementao, a prioridade esttica pode ocasionar tempos de resposta elevados. Na prioridade dinmica, a prioridade do processo pode ser ajustada de acordo com o tipo de processamento realizado pelo processo e/ou a carga do sistema. Quando o processo sai do estado bloqueado, recebe um acrscimo sua prioridade. Dessa forma, os processos I/O-bound tero mais chance de ser escalonados e compensar o tempo que passam no estado bloqueado. Para evitar que processos com maior prioridade executem indefinidamente, a prioridade diminuda com o passar do tempo. Uma outra forma de se obter prioridade dinmica fazer com que o quantum do processo seja inversamente proporcional frao do ltimo quantum utilizado. Embora os sistemas de prioridade dinmica sejam mais complexos e gerem um overhead maior, o tempo de resposta oferecido compensa.
45
4.1.6 Escalonamento por Mltiplas Filas Como os processos de um sistema possuem diferentes caractersticas de processamento, difcil que um nico mecanismo de escalonamento seja adequado a todos. Uma boa poltica seria classificar os processos em funo do tipo de processamento realizado e aplicar a cada grupo mecanismos de escalonamentos distintos. O escalonamento por mltiplas filas implementa diversas filas de processo no estado pronto, onde cada processo associado exclusivamente a uma delas. Cada fila possui um mecanismo prprio de escalonamento, em funo das caractersticas do processo. Nesse esquema, os processos devem ser classificados, previamente, em funo do tipo de processamento, para poderem ser encaminhados a uma determinada fila. Cada fila possui uma prioridade associada, que estabelece quais filas so prioritrias em relao s outras. O sistema s pode escalonar processos de uma fila se todas as outras de prioridade maior estiverem vazias. Para exemplificar esse escalonamento, considere que os processos, em funo de suas caractersticas, sejam divididos em trs grupos: sistema, interativo e batch. Os processos do sistema devem ser colocados em uma fila de prioridade superior dos outros processos, implementando um algoritmo de escalonamento baseado em prioridades. Os processos de usurios interativos devem estar em uma fila de prioridade intermediria, implementando, por exemplo, o escalonamento circular. O mesmo mecanismo de escalonamento pode ser utilizado na fila de processos batch, com a diferena de que esta fila dever possuir uma prioridade mais baixa. 4.1.7 Escalonamento por Mltiplas Filas com Realimentao No escalonamento por mltiplas filas os processos so previamente associados a uma determinada fila. No caso de um processo que altere o seu comportamento no correr do tempo, esse esquema falho, pois o processo no poder ser redirecionado para uma outra fila mais adequada. O escalonamento por mltiplas filas com realimentao tambm implementa diversas filas, onde cada qual tem associada uma prioridade de execuo, porm os processos no permanecem obrigatoriamente em uma mesma fila at o trmino do processamento. Esse esquema permite que os processos sejam redirecionados entre as filas do sistema, fazendo com que o sistema operacional implemente um mecanismo de ajuste dinmico (mecanismo adaptativo) que tem como objetivo ajustar os processos em funo de seu comportamento. Um processo, ao ser criado, entra no final da fila de mais alta prioridade. Quando um processo em execuo deixa a UCP, seja por preempo por prioridade ou por solicitao a um recurso do sistema, ele reescalonado dentro da mesma fila. Caso o processo esgote seu quantum, ele redirecionado para uma fila de menor prioridade. O quantum em cada fila varia em funo da sua prioridade. Quanto maior a prioridade da fila, menor o seu quantum. Assim, o quantum dos processos no esttico, variando em funo da fila na qual ele se encontra. Essa poltica de escalonamento atende as necessidades dos diversos tipos de processos. No caso de processos I/O-bound, ela oferece um bom tempo de resposta, j que esses processos tm prioridades altas por permanecerem a maior parte do tempo nas filas de mais alta ordem. No caso de processos CPU-bound, a tendncia de que, ao entrar na fila de mais alta prioridade, o processo ganhe a UCP, gaste seu quantum de tempo e seja direcionado para uma fila de menor prioridade. O maior problema deste algoritmo que por sua complexidade ele pode gerar um grande overhead ao sistema.
46
4.1.8 Escalonamento em Sistemas de Tempo Real Sistemas de tempo real devem ser utilizados quando existem aplicaes que necessitem dar respostas imediatas a alguns eventos do sistema. O escalonador deve levar em conta a a importncia relativa da tarefa para o sistema e trat-la com a prioridade adequada. Assim, o algoritmo de escalonamento por prioridade o mais adequado para sistemas deste tipo. No deve haver o conceito de fatia de tempo e a prioridade de cada processo deve ser esttica.
4.2 Escalonamento com Mltiplas UCPs

O mecanismo de escalonamento para sistemas com mltiplas UCPs bem mais complexo que com uma nica UCP. A abordagem diferenciada para sistemas fracamente acoplados ou fortemente acoplados. Em sistemas fracamente acoplados, cada UCP faz seu prprio escalonamento local. O sistema possui, alm da UCP, sua memria principal, sistema operacional, algoritmo de escalonamento e sua prpria fila de processos prontos para execuo. Se vrias UCPs idnticas estiverem disponveis em um sistema fortemente acoplado, seria possvel usar uma fila de processos prontos separada para cada UCP. Entretanto uma UCP poderia ficar ociosa, enquanto outra estivesse muito ocupada. Assim, implementa-se uma nica fila de processos prontos para todas as UCPs. Todos os processos esto presentes nesta nica fila e so escalonados no primeiro processador disponvel. Como a memria nica para todas as UCPs e todos os programas, no faz diferena em qual UCP a execuo ocorrer. Este caso em que no importa em qual das UCPs se dar a execuo do processo conhecido como multiprocessamento simtrico. Nesta soluo importante que seja implementada a excluso mtua. No caso de mais de uma UCP tornar-se disponvel em um mesmo instante, no pode haver a possibilidade de um mesmo processo ser escalonado por duas UCPs diferentes. Uma outra soluo designar uma UCP que executa o algoritmo de escalonamento, sendo ela a responsvel por determinar a tarefa de cada UCP do sistema.
4.3 Exerccios
1) Qual a funo do escalonador de um sistema operacional? 2) No que se refere gerncia do processador, o que diferencia um sistema operacional preemptivo de um sistema operacional no-preemptivo? 3) Por que um algoritmo de escalonamento preemptivo pode levar ao problema da condio de corrida? 4) Por que no algoritmo de escalonamento FIFO processos CPU-bound de menor importncia podem prejudicar processos I/O-bound prioritrios? 5) Como o algoritmo de escalonamento SJF reduz o tempo mdio de espera em relao ao FIFO? 6) Como funciona o escalonamento cooperativo? Ele preemptivo? Explique. 7) Como possvel que um processo consiga utilizar a UCP sem dar a chance de outro processo entrar em execuo quando se usa escalonamento cooperativo? 8) O que quantum para um algoritmo de escalonamento preemptivo? 9) O que diferencia o escalonamento circular (Round Robin) do escalonamento por prioridade? Sistemas Operacionais 47
10) Para o escalonamento circular, o que quantum? 11) Por que um valor alto para quantum prejudica a interatividade? 12) Como o sistema operacional faz para garantir que o escalonamento circular seja preemptivo? 13) Por que processos I/O-bound podem ser prejudicados no escalonamento circular? Como o escalonamento por prioridade resolve este problema? 14) Explique sucintamente como funciona um algoritmo de escalonamento por prioridade. 15) Qual a diferena entre prioridade esttica e prioridade dinmica para um algoritmo de escalonamento por prioridade? 16) Como o escalonador determina o prximo processo a entrar em execuo em um sistema de tempo real? 17) Como o escalonador de tempo real trata o quantum? 18) Em um sistema com mltiplas UCPs, possvel que um processo que saiu de execuo em uma UCP, quando volte ao estado pronto, entre em execuo em outra UCP? Explique. 19) O que multiprocessamento simtrico?
48
5 Gerncia de Memria
Na memria principal residem todos os programas e dados que sero executados ou referenciados pela UCP. Toda vez que for ser executado um programa residente na memria secundria deve-se carreg-lo na memria principal. Enquanto nos sistemas monoprogramveis a gerncia da memria no muito complexa, nos sistemas multiprogramveis ela se torna crtica, uma vez que o sistema operacional deve gerenciar o acesso dos vrios processos memria de forma concorrente. O gerenciador de memria a parte do sistema operacional que gerencia a hierarquia de memria. Seu trabalho consiste em: Controlar que parte da memria est em uso. Alocar memria para os processos. Gerenciar a troca entre a memria principal e o disco.
5.1 Atribuio de Endereos

Um programa armazenado em disco como um arquivo binrio executvel. Para ser executado ele deve ser colocado em memria como parte de um processo. Os sistemas operacionais atuais permitem que os processos dos usurios sejam colocados em qualquer parte da memria. Assim, embora o espao de endereamento do computador comece no endereo zero, este espao no precisa ser o endereo inicial de um processo. Os endereos usados nos programas podem ser representados de maneiras diferentes. No programa fonte os endereos costumam ser simblicos, representados por nomes de variveis. O compilador normalmente associa este endereo simblico a um endereo relativo, como uma posio a partir do incio do programa. O loader por sua vez transforma endereos relativos em endereos absolutos. A atribuio de endereos a instrues ou dados pode ser feita: Em tempo de compilao A posio de memria em que o programa ser armazenado conhecida durante a compilao. Se precisar mudar o programa deve ser recompilado. Em tempo de carga A atribuio final de endereos absolutos feita durante a carga do programa em memria. Em tempo de execuo Quando um programa durante sua execuo, pode ser transferido de um local para outro na memria. A atribuio de endereos deve ser feita somente durante a execuo.
5.2 Carregamento Dinmico

No carregamento dinmico o programa dividido em um programa principal e uma srie de rotinas que ficam armazenadas em disco. Para a execuo o programa principal carregado na memria. Quando uma rotina chamada, ela carregada na memria. A vantagem do carregamento dinmico que uma rotina no usada nunca carregada na memria. O carregamento dinmico no requer obrigatoriamente suporte especial do sistema operacional, mas o sistema operacional pode fornecer chamadas de sistema para facilitar sua implementao.
49
5.2.1 Ligao Dinmica O conceito de ligao dinmica similar ao de carregamento dinmico, s que na ligao dinmica a ligao (linkedio) que realizada em tempo de execuo. Este recurso comumente utilizado para bibliotecas do sistema. Sua ausncia obriga que todos os programas do sistema tenham uma cpia das rotinas do sistema que utiliza, gerando um grande desperdcio tanto de espao em disco quanto de memria. Com este mecanismo includo no cdigo executvel do programa um cdigo para ligao dinmica, que indica onde e como armazenar uma rotina de biblioteca. Este recurso pode ser estendido para casos em que ocorrem mudanas no cdigo da biblioteca. Uma biblioteca pode ser substituda por uma nova verso e todos os programas que a usam passaro automaticamente a usar a nova verso. Diferentemente do carregamento dinmico, a ligao dinmica costuma requerer algum suporte do sistema operacional.
5.3 Alocao Contgua Simples

Nesse esquema a memria principal dividida em duas partes: uma para o sistema operacional e outra para o programa do usurio. Assim o programador deve criar suas aplicaes, preocupado apenas em no ultrapassar o espao de memria disponvel. O usurio tem controle sobre toda a memria principal, podendo acessar qualquer posio de memria. Para proteger o sistema operacional, alguns sistemas implementam proteo atravs de registradores, que delimitam as reas do sistema operacional e do usurio. Assim, sempre que um programa de usurio faz referncia a um endereo na memria, o sistema verifica se o endereo est nos seus limites. A principio, os programas dos usurios estavam limitados ao tamanho da memria principal disponvel. A soluo encontrada foi dividir o programa em partes, de forma que pudessem executar independentemente uma da outra, utilizando uma mesma rea de memria. Essa tcnica chamada de overlay (sobreposio). A definio das reas de overlay funo do programador. O tamanho de uma rea de overlay ser estabelecido a partir do tamanho do maior mdulo. A tcnica de overlay tem a vantagem de permitir ao programador expandir os limites da memria principal, mas pode trazer implicaes quanto ao desempenho das aplicaes pela excessiva transferncia entre as memrias principal e secundria.
5.4 Alocao Particionada

Nos sistemas monoprogramveis o processador permanece ocioso e a memria subutilizada, enquanto o programa aguarda por algum evento. Para a multiprogramao ser eficiente necessrio que vrios programas tenham a possibilidade de estarem na memria principal ao mesmo tempo. 5.4.1 Alocao Particionada Esttica Nos primeiros sistemas multiprogramveis, a memria foi dividida em pedaos de tamanho fixo, chamados parties. O tamanho das parties era estabelecido na fase de inicializao do sistema. Sempre que fosse necessria a alterao do tamanho de uma partio o sistema deveria ser reinicializado com uma nova configurao. Os programas s podiam executar em uma das parties, mesmo se outras estivessem disponveis, por causa dos compiladores e montadores que geravam apenas cdigo absoluto. A esse tipo de alocao chamou-se alocao particionada esttica absoluta. Sistemas Operacionais 50
Com a evoluo dos compiladores, linkers e loaders, a gerao de cdigo relocvel foi possvel e os programas puderam ser carregados em qualquer partio. Assim foi criado um novo tipo de organizao, denominado alocao particionada esttica relocvel. Neste esquema o endereo base determinado durante o carregamento do programa. Para manter o controle sobre quais parties estavam alocadas ou no, os sistemas possuam uma tabela delimitando cada partio, seu tamanho e se estava em uso ou no. 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.
Memria Principal
Sistema Operacional
Endereo inicial
Partio onde o programa est sendo executado

Endereo final
Tanto nos sistemas de alocao absoluta quanto nos de alocao relocvel, os programas normalmente no preenchiam totalmente as parties onde eram carregados. Alm disso, se um programa for maior que qualquer partio livre, ele ficar aguardando uma que o acomode, mesmo que existam parties adjacentes que somadas totalizem o tamanho do programa. Esse tipo de problema conhecido como fragmentao interna. 5.4.2 Alocao Particionada Dinmica A alocao particionada esttica leva ao problema da fragmentao, diminuindo a capacidade de compartilhamento de memria. Na alocao particionada dinmica no existe o conceito de parties de tamanho fixo. Nesse esquema, cada processo cria uma partio com o tamanho que necessita.
Sistema Operacional Sistema Operacional Processo A Processo B A
2 MB 2 MB 3 MB
B
3 MB
C
4 MB
D
2 MB
Processo C Processo D
12 MB
4 MB
2 MB 1 MB
A fragmentao comear a ocorrer quando os programas forem terminando e deixando espaos na memria, no permitindo o ingresso de novos programas. Este tipo de fragmentao denominada fragmentao externa. Depois de detectada a fragmentao, existem duas solues para o problema. Na primeira, os espaos adjacentes so reunidos, produzindo um nico espao de tamanho maior. A segunda soluo envolve a relocao de todas as parties ocupadas, eliminando todos os espaos entre elas. Esse mecanismo de compactao, tambm conhecido como alocao dinmica com relocao, reduz o problema da fragmentao, mas a complexidade do seu algoritmo e o consumo de recursos do sistema podem torn-lo invivel. 5.4.3 Estratgias para Escolha da Partio Existem basicamente cinco estratgias para determinar em qual partio livre um programa ser carregado: primeiro ajuste, prximo ajuste, melhor ajuste, pior ajuste e ajuste rpido. Sistemas Operacionais 51
A melhor estratgia a ser adotada depende do tamanho dos programas processados no ambiente. Independentemente do algoritmo utilizado, o sistema deve possuir uma relao de reas livres com o endereo e o tamanho de cada uma. Na representao com lista encadeada mantida uma lista encadeada com os segmentos alocados e com os segmentos livres. A manuteno mais rpida se a lista for duplamente encadeada.
A
Lista encadeada
...
PA 0 5
L 18 2
L 5 3
PD 20 6
PB 8 6
PE 26 3
PC 14 4
L 29 3
Mantendo a lista classificada por endereo, quando um processo termina, a rea que ele ocupava pode se juntar a uma ou duas lacunas adjacentes formando uma s lacuna. 5.4.3.1 Algoritmo do Primeiro Ajuste (First-fit) Esse algoritmo escolhe a primeira partio livre de tamanho suficiente para carregar o processo. Ele costuma ser muito rpido por pesquisar o mnimo possvel. Nesse algoritmo a lista de reas livres costuma estar ordenada por endereo. 5.4.3.2 Algoritmo do Prximo Ajuste semelhante ao algoritmo do primeiro ajuste, mas inicia sua procura a partir do ponto em que parou na procura anterior. 5.4.3.3 Algoritmo do Melhor Ajuste (Best-fit) Esse algoritmo escolhe a partio em que o processo deixa o menor espao sem utilizao. Nesse algoritmo, se a lista de reas livres no estiver ordenada por tamanho, o tempo de busca por uma rea desocupada pode comprometer seu desempenho. Uma desvantagem desse mtodo que alocada a partio que deixa a menor rea livre, existindo uma tendncia de que a memria fique com pequenas reas no contguas, aumentando o problema da fragmentao. 5.4.3.4 Algoritmo do Pior Ajuste (Worst-fit) Esse algoritmo escolhe a partio em que o processo deixa o maior espao sem utilizao. Ao utilizar as parties maiores, so deixados espaos livres maiores que permitem a um maior nmero de programas utilizar a memria, diminuindo o problema da fragmentao. Simulaes mostraram que este algoritmo no traz bons resultados. 5.4.3.5 Algoritmo do Ajuste Rpido Este algoritmo mantm listas separadas para alguns tamanhos mais comuns. Ele tambm gera lacunas pequenas, mas extremamente rpido na alocao de memria. Simulaes mostraram que dentre os algoritmos acima o que obteve melhores resultados foi o algoritmo do primeiro ajuste, sendo o mais rpido e o que consome menos recursos do sistema. A lista de lacunas pode ser mantida ordenada de formas diferentes a fim de beneficiar o algoritmo que estiver em uso. Um outro aspecto a ser levado em conta que processos podem crescer. Portanto bom deixar lacunas entre os processos para que seja permitido o seu crescimento. Sistemas Operacionais 52
5.5 Swapping
Mesmo com o aumento da eficincia da gerncia de memria, muitas vezes um programa no podia ser executado por falta de uma partio livre disponvel. A tcnica de swapping veio tentar resolver o problema da insuficincia de memria. Nos esquemas anteriores, um processo permanecia na memria principal at o final da sua execuo. Eles funcionam bem para sistemas em lote, mas para sistemas de tempo compartilhado uma nova estratgia deve ser adotada, uma vez que pode no haver memria suficiente para armazenar todos os processos. O swapping uma tcnica aplicada gerncia de memria para programas que esperam por memria livre para serem processados. O sistema escolhe um processo que levado da memria principal para o disco (swap out), retornando posteriormente para a memria principal (swap in). Um dos problemas gerados pelo swapping a relocao dos processos. No caso de um processo que sai e volta muitas vezes para a memria, necessrio que a relocao seja realizada pelo loader a cada carregamento. Essa situao torna o mecanismo ineficiente em funo do tempo gasto para o carregamento. A melhor soluo uma implementao em hardware para permitir que a relocao seja realizada durante a execuo do programa. Esse tipo de mecanismo denominado relocao dinmica. A relocao dinmica realizada atravs de um registrador especial denominado registrador de relocao. No momento em que o processo carregado na memria, o registrador recebe o endereo inicial da regio de memria que o processo ir ocupar. Toda vez que ocorrer uma referncia a algum endereo, o endereo contido na instruo ser somado ao contedo do registrador, gerando o endereo fsico. Assim um programa pode ser carregado em qualquer regio da memria. Quando o swap cria muitas lacunas pode-se ganhar espao movendo os processos para realizar a compactao de memria. A compactao costuma ser evitada por tomar muito tempo da UCP. Se o processo precisar alocar memria e existir uma lacuna entre ele e o processo adjacente, alocado espao desta lacuna. Se tal lacuna no existir o processo deve ser movido para uma lacuna com espao suficiente ou ento deve ser realizada uma compactao de memria. Se no existe espao na memria nem em disco o processo deve esperar ou ser eliminado. O conceito de swapping permitiu um maior compartilhamento da memria assim como um maior throughput. A tcnica se mostrou eficiente para sistemas com poucos usurios em ambientes com aplicaes pequenas. Seu maior problema o elevado custo das operaes de entrada/sada. O CTSS do MIT e o OS/360 da IBM so exemplos de sistemas operacionais que implementam tal tcnica.
5.6 Memria Virtual

Memria virtual uma tcnica onde as memrias principal e secundria so combinadas, dando ao usurio a iluso de existir uma memria maior que a memria principal. At ento quando o programa era muito grande para caber na memria principal empregavase a tcnica de overlay, ficando a cargo do programador a diviso do programa em mdulos. Com a tcnica de memria virtual cabe ao sistema operacional dividir o programa em partes e manter em memria somente as partes do programa necessrias execuo do mesmo. As outras partes so mantidas na memria secundria.
53
Isto muito til porque verifica-se que, em muitos casos, nem todo o cdigo do programa executado. Por exemplo: Cdigo para tratamento de condies de erro. Tamanho da rea de memria alocada por listas e tabelas que no so sempre totalmente utilizadas. Opes e recursos de programas que raramente so utilizados. Mesmo quando todo o cdigo de um programa usado, ele no costuma ser usado inteiramente ao mesmo tempo. Ainda, a possibilidade de executar um programa armazenado apenas parcialmente na memria traz benefcios como: A rea de memria disponvel ao programa no fica limitada ao tamanho da memria fsica disponvel. Um nmero maior de programas pode ser executado simultaneamente. Uma menor quantidade de operaes de E/S necessrio para carregar programas na memria. O conceito de memria virtual est baseado em desvincular o endereamento feito pelo processo dos endereos fsicos da memria principal. Assim, os processos deixam de estar limitados ao tamanho da memria fsica disponvel. A memria virtual tambm minimiza o problema da fragmentao da memria. 5.6.1 Espao de Endereamento Virtual Quando se utiliza memria virtual um processo no faz referncia a endereos fsicos (endereos reais), apenas a endereos virtuais. No momento da execuo de uma instruo, o endereo virtual traduzido para um endereo fsico. O mecanismo de traduo de um endereo virtual para um endereo fsico denominado mapeamento. O conjunto de endereos virtuais que os processos podem enderear chamado espao de endereamento virtual, enquanto o conjunto de endereos reais chamado espao de endereamento real. O espao de endereamento virtual no tem nenhuma relao direta com os endereos no espao real. Como os processos podem ser muito maiores que a memria fsica, apenas parte deles pode estar residente na memria em um determinado instante. O sistema operacional utiliza a memria secundria como extenso da memria principal.
Memria virtual Memria principal
Memria secundria
Quando um usurio desenvolve uma aplicao cabe ao compilador e ao linker gerar o cdigo executvel em funo dos endereos virtuais, e ao sistema operacional cuidar dos detalhes durante a execuo. 5.6.2 Paginao A paginao uma tcnica de gerncia de memria onde o espao de endereamento virtual e o espao de endereamento real so divididos em blocos do mesmo tamanho, chamados pginas. Sistemas Operacionais 54
As pginas no espao virtual so denominadas pginas virtuais, enquanto as pginas no espao real so chamadas de pginas reais ou molduras de pgina (frames). Em geral as pginas variam de 512 bytes a 64 Kbytes.
Memria virtual
0 1 2 3 4 5 6 7 8 9
Memria principal
0 1 2 3 4
x x 1 x 2 4 x 0 3 x
moldura de pgina
pgina virtual
Todo o mapeamento realizado por intermdio de tabelas de pginas. Cada pgina virtual possui uma entrada na tabela contendo informaes de mapeamento que permitem ao sistema localizar a pgina real correspondente. Quando um processo entra no estado executando as pginas virtuais so transferidas da memria secundria para a memria principal e colocadas em molduras de pgina. Sempre que o processo fizer referncia a um endereo virtual o mecanismo de mapeamento localizar na tabela de pginas o endereo fsico da moldura de pgina. Nesse sistema, o endereo virtual formado pelo nmero da pgina virtual e um deslocamento dentro da pgina. O nmero da pgina virtual identifica unicamente uma pgina virtual na tabela de pginas, enquanto o deslocamento funciona como ndice dentro da pgina. O endereo fsico calculado somando-se o endereo da moldura de pgina (localizada na tabela de pginas) com o deslocamento (contido no endereo virtual).
n pgina virtual deslocamento
Tabela de pginas Memria principal
endereo do frame
+
endereo fsico
Alm da informao sobre a localizao da pgina virtual a tabela de pginas possui outras informaes como o bit presente/ausente, que indica se uma pgina est ou no na memria fsica. Sempre que o processo faz referncia a um endereo virtual, o sistema verifica, atravs do bit presente/ausente, se a pgina que contm o endereo referenciado est ou no na memria principal. Caso no esteja, o sistema tem que transferir a pgina da memria secundria para a memria principal. Toda vez que isso ocorre diz-se que ocorreu um falha de pgina (page fault). Quando ocorre uma falha de pgina uma interrupo gerada para passar o controle da UCP ao sistema operacional. O sistema operacional ento seleciona uma moldura de pgina (frame) para liberar e, se necessrio, a grava em disco. Por fim o sistema operacional carrega a pgina necessria na moldura de pgina que acabou de ser liberada. A medida que um processo vai tendo suas pginas carregadas ele tem suas molduras de pgina espalhadas pela memria, uma vez que elas entram onde h espao livre. Cada processo de usurio v a memria como um espao nico e contguo, contendo apenas esse processo. Mas na verdade o processo fica espalhado por toda a memria, que contm tambm outros processos. Para que haja uma conciliao entre a memria vista pelo programa do usurio e a Sistemas Operacionais 55
memria fsica necessrio que seja feita uma traduo de endereos virtuais em endereos fsicos, preferencialmente sem o conhecimento do programa do usurio. Nos sistemas atuais, a tarefa de traduo do endereo realizada pelo hardware, juntamente com o sistema operacional, de forma a no comprometer seu desempenho. Como a maioria das aplicaes tende a fazer referncia a um nmero reduzido de pginas, somente uma pequena frao da tabela de pginas realmente necessria. Assim, foi introduzido um hardware especial para mapear endereos virtuais em endereos fsicos sem a necessidade de acesso tabela de pginas, chamado memria associativa ou translation lookaside buffer (TLB). Este hardware fica dentro da unidade de gerenciamento de memria (memory management unit MMU) As pginas dos processos so transferidas da memria secundria para a principal apenas quando so referenciadas. Este mecanismo chamado paginao por demanda e conveniente, na medida em que leva para a memria principal apenas as pginas realmente necessrias execuo do processo. Assim, possvel que partes do programa nunca sejam carregadas para a memria. 5.6.2.1 Tabela de pginas A tabela de pginas tem o propsito de mapear pginas virtuais em molduras de pgina para formar um endereo fsico de memria, ou seja, realizar a traduo de um endereo virtual em um endereo fsico. Dois aspectos devem ser observados quanto a tabela de pginas. O primeiro deles que uma tabela pode ser muito grande, consumindo parte significativa da memria. Se um sistema utilizar, por exemplo, pginas de 4 Kbytes e 32 bits para endereamento, sua tabela de pginas ter mais que 1 milho de entradas. Se, por outro lado, forem utilizadas pginas muito grandes, haver um aumento na fragmentao interna. O segundo aspecto que o mapeamento deve ser feito da forma mais rpido possvel, pois feito a cada referncia memria, ou seja, uma ou mais vezes por instruo executada. Uma forma de diminuir o tamanho das tabelas de pginas atravs do uso de tabelas de pginas multinvel, que procura evitar manter toda a tabela de pginas na memria. Neste esquema existe uma tabela de pginas de primeiro nvel que usada para fornecer o endereo de uma moldura de pgina que contm uma tabela de pginas de segundo nvel, e assim por diante. Por exemplo, suponha um sistema onde so dedicados para cada processo 12 Mbytes, sendo 4 Mbytes para o cdigo executvel, 4 Mbytes para dados e 4 Mbytes para a pilha. Assim, tem-se para a tabela de pginas de primeiro nvel: Entrada 0 Tabela de pginas do cdigo executvel. Entrada 1 Tabela de pginas de dados. Entrada 2 Tabela de pginas da pilha. Entradas 3 a 1023 Invlidas.
32 bits de endereamento virtual
10 10 12
TP1
TP2
Deslocamento
1024 entradas para tabela de 2 nvel
Para o exemplo so necessrias apenas 4 tabelas em memria (a tabela de primeiro nvel mais 3 tabelas de segundo nvel). Desta forma armazena-se cerca de 4 mil entradas em memria, no lugar das cerca de 1 milho de entradas que seriam necessrias se no fossem utilizadas tabelas de pginas multinvel. A figura abaixo mostra um exemplo de como o funcionamento de uma tabela de pginas de dois nveis e a traduo de um endereo virtual em um endereo fsico: Sistemas Operacionais 56
pgina 0 pgina 1 1 . . 500 . . . . . pgina 100 n1 n2 p
100 . .
708
pgina 500
n1
n2
pgina 708 p
Tabela de pginas de primeiro nvel
Tabela de pginas de primeiro nvel
Endereo fsico
Tabela de pginas de segundo nvel
929 . . 900
Tabela de pginas de segundo nvel
pgina 900
pgina 929
Memria
Memria
O formato de uma entrada na tabela de pginas varia com o sistema, mas em geral costuma ser:
... n da moldura de pgina
presente/ausente proteo modificada referenciada desabilitar cache
O bit presente/ausente indica se a pgina est na memria principal ou no. A proteo informa que tipos de acesso so permitidos. O bit modificada informa se a pgina foi ou no modificada desde a sua carga do disco. O bit referenciada ligado sempre que a pgina referenciada. O bit desabilitar cache usado apenas em sistemas que usam E/S mapeada em memria, para evitar que o resultado de uma E/S seja mascarado. A cada busca de instruo ou dados so necessrios acessos extras memria para consultar as tabelas de pginas. fato que a maioria dos processos tende a fazer um grande nmero de referncias a um pequeno nmero de pginas. Assim surgiu a ideia de equipar os computadores com dispositivos de hardware para mapear os endereos sem passar pelas tabelas de pginas. Estes dispositivos so conhecidos como Translation Lookaside Buffers (TLB) ou memria associativa, e se encontram dentro da MMU (unidade de gerenciamento de memria). O TLB composto de entradas que contm informaes sobre a pgina mapeada. Quando um endereo virtual passado MMU, o hardware verifica se o nmero de pgina est no TLB. Se estiver e no violar bits de proteo, a moldura de pgina ser obtida diretamente do TLB, caso contrrio ser gerada uma falha de TLB. Quando o nmero de pgina no est no TLB, ele expulsa uma das entradas e a substitui pela entrada da tabela de pginas que acabou de ser pesquisada. Para algumas UCPs o gerenciamento e o tratamento de falhas do TLB so feitos inteiramente pelo hardware da MMU. Para outras UCPs a MMU simplesmente gera uma falha de TLB e passa o problema ao sistema operacional. Neste caso, o sistema operacional dever localizar a pgina, remover uma entrada do TLB, carregar a pgina e reiniciar a instruo que falhou. Se o TLB for grande (64 entradas costuma ser suficiente) o gerenciamento por software ser eficiente. O ganho principal do gerenciamento do TLB por software que a MMU fica mais simples, sobrando mais espao para cache. Sistemas Operacionais 57
5.6.2.2 Pginas Compartilhadas Outra vantagem do mecanismo de paginao a possibilidade de compartilhamento de cdigo, evitando que processos oriundos de um mesmo programa necessitem manter em memria cpias de um mesmo cdigo executvel. Isto possvel de ser realizado quando o processo utiliza cdigo reentrante, ou seja, um cdigo executvel que no modifica a si prprio. Para que se consiga o compartilhamento de pginas basta mapear as pginas virtuais dos processos em uma mesma moldura de pgina. Deve-se ter o cuidado de contabilizar quantos processos esto utilizando a mesma moldura de pgina para que ela no seja liberada de forma indevida. 5.6.2.3 Working Set (Conjunto Funcional) O mecanismo de memria virtual, apesar de suas vantagens, introduz um grande problema: sempre que um processo faz referncia a uma de suas pginas e ocorre uma falha de pgina exigido do sistema operacional pelo menos uma operao de E/S, que, quando possvel, deve ser evitada. O sistema deve se preocupar em manter na memria principal um certo nmero de pginas que reduza ao mximo a taxa de paginao dos processos, ao mesmo tempo que no prejudique os demais processos que desejam ter acesso memria. O conceito de working set (conjunto funcional) surgiu a partir da anlise da taxa de paginao dos processos. Quando um processo comea a ser executado, percebe-se uma elevada taxa de falhas de pginas, que se estabiliza com o decorrer de sua execuo. Esse fato est ligado diretamente a localidade (referncia localizada) que a tendncia que existe em um processo de fazer referncias a posies de memria prximas. Isso significa que um processo tender a concentrar suas referncias em um mesmo conjunto de pginas durante determinado perodo de tempo. Se a memria for pequena para armazenar o working set, o processo poder sofrer com a elevada taxa de paginao (trashing), comprometendo seu desempenho. 5.6.2.4 Alocao Global x Alocao Local A substituio de pgina global permite selecionar uma moldura de pgina para um processo do conjunto de todas as molduras de pgina da memria, mesmo que esteja alocada a outro processo. Na substituio local uma moldura de pgina alocada a um processo deve permanecer no conjunto de molduras de pgina reservadas para uso desse processo. Com a estratgia de substituio local a quantidade de molduras de pgina alocadas a um processo no varia. Com a alocao global um processo pode sempre alocar molduras de pgina de outros processos aumentando sua quantidade de molduras de pginas, desde que outros processos no selecionem suas molduras de pgina. Um problema com o algoritmo de substituio global que um processo no pode controlar sua prpria taxa de ocorrncia de pginas ausentes. O seu conjunto de pginas armazenadas na memria depender tambm do comportamento dos outros processos, uma vez que seu escalonamento no acontecer, obrigatoriamente, a uma taxa constante. Por outro lado, a substituio local pode retardar a execuo de um processo, no deixando disponvel a ele molduras de pgina utilizadas com menos frequncia. Em geral a substituio global resulta em uma maior quantidade de processos executados por unidade de tempo, sendo o mtodo mais utilizado.
58
5.6.2.5 Realocao de Pginas O maior problema na gerncia de memria virtual decidir quais pginas remover. Quando o limite do working set de um processo alcanado e este necessita de novas molduras de pgina, o sistema operacional deve escolher quais pginas devem ser liberadas. Qualquer estratgia de realocao de pginas deve considerar se uma pgina foi ou no modificada antes de liber-la. Sempre que o sistema for liberar uma pgina modificada, ele antes dever grav-la na memria secundria (page out), preservando seu contedo. O sistema mantm um arquivo de paginao onde as pginas modificadas so armazenadas. Sempre que uma destas pginas for novamente referenciada, ela ser trazida de volta para o working set do processo (page in). O sistema consegue implementar esse mecanismo atravs do bit modificada, que existe em cada entrada da tabela de pginas. Sempre que uma pagina alterada, o valor do bit modificada marcado como 1. A melhor estratgia de realocao de pginas seria aquela que escolhesse uma pgina que no fosse referenciada num futuro prximo, porm o sistema operacional no tem como prever se uma pgina ser ou no utilizada novamente. A seguir sero analisadas as principais estratgias adotadas pelos sistemas operacionais para a realocao de pginas. Aleatria A escolha aleatria no utiliza critrio algum de seleo. Todas as pginas tm a mesma chance de ser selecionada. Apesar de ser uma estratgia que consome poucos recursos do sistema, raramente utilizada por conta de sua baixa eficincia. Not Recently Used (NRU) Neste esquema so utilizados o bit referenciada (bit R - indica se a pgina foi referenciada ou no) e o bit modificada (bit M - indica se a pgina foi modificada desde que foi carregada em memria). Estes bits so marcados pelo hardware e desmarcados pelo sistema operacional. Periodicamente o bit R desmarcado pelo sistema operacional para determinar as pginas que foram acessadas recentemente. Quando ocorre uma falha de pgina, as pginas so divididas em quatro classes: Classe 0 No referenciada, no modificada. Classe 1 No referenciada, modificada. Classe 2 Referenciada, no modificada. Classe 3 Referenciada, modificada.
O algoritmo NRU remove uma pgina da classe no vazia com numerao mais baixa. First In First Out (FIFO) Nesse esquema, a pgina que foi utilizada primeiro ser a primeira a ser escolhida para ser liberada. Sua implementao bastante simples, sendo necessria apenas uma fila. Segunda Chance uma modificao do algoritmo FIFO para no jogar fora uma pgina muito utilizada. Neste algoritmo o bit referenciada da pgina mais antiga verificado. Se for 0 ela substituda, seno o bit ser marcado como 0, a pgina ir para o final da fila e a prxima pgina ser inspecionada. Least Frequently Used (LFU) Neste esquema a pgina menos referenciada (menos frequentemente utilizada) ser a pgina escolhida para ser substituda. Para isso mantido um contador do nmero de referncias feitas s pginas, e a pgina que tiver o contador com o menor valor ser a pgina escolhida. O algoritmo mantm na memria as pginas que so bastante utilizadas. uma boa estratgia, mas as pginas Sistemas Operacionais 59
que entram mais recentemente no working set sero aquelas que estaro com os contadores com menor valor. Outro problema que preciso manter uma lista ordenada por uso que deve ser alterada a cada acesso memria, gerando um grande overhead que dificulta sua utilizao. Least Recently Used (LRU) As pginas que foram intensamente utilizadas nas ltimas instrues provavelmente sero intensamente utilizadas nas instrues seguintes. Assim, essa estratgia seleciona a pgina que est a mais tempo sem ser referenciada (a pgina menos utilizada recentemente) para ser substituda. O problema que preciso manter uma lista ordenada por uso que deve ser alterada a cada acesso memria, gerando um grande overhead que dificulta sua utilizao. Simulao de LRU em Software Embora seja possvel implementar o LRU, as mquinas no costumam ter o hardware necessrio. Uma soluo utilizar o algoritmo no frequentemente utilizado (not frequently used NFU), que usa um contador de software associado a cada pgina. Esse contador iniciado com 0 e a cada interrupo do relgio o sistema operacional varre todas as pginas. O bit referenciada de cada pgina somado ao contador e zerado. Quando ocorre uma falha, a pgina com o contador mais baixo escolhida para ser substituda. Se, ao invs do bit referenciada ser somado ao contador, o contador tiver seus bits deslocados para a direita e o bit referenciada for somado esquerda, obtm-se o algoritmo da idade. Nesse algoritmo, quando uma falha ocorre a pgina que tem o menor valor de contador removida. Os algoritmos NFU e da idade diferenciam-se do LRU por no oferecerem uma noo exata do tempo. Se duas pginas tiverem igual histrico do bit referenciada no h como saber qual foi a menos utilizada. 5.6.3 Segmentao A memria estudada at o momento segue um modelo unidimensional, com endereos de 0 at um mximo. A segmentao uma tcnica de gerncia de memria onde os programas so divididos logicamente em sub-rotinas e estruturas de dados e colocados em blocos de informaes na memria. Os blocos podem ter tamanhos diferentes e so chamados segmentos, cada um com seu prprio espao de endereamento. Ainda, por constiturem espaos de endereamento diferentes, segmentos distintos podem crescer ou diminuir independentemente de forma dinmica, sem afetar os demais. Enquanto a paginao divide o processo em partes de tamanho fixo, sem qualquer ligao com a estrutura do programa, a segmentao permite uma relao entre a lgica do processo e sua diviso na memria. Os segmentos so mapeados atravs de tabelas de mapeamento de segmentos e os endereos so compostos pelo nmero do segmento e um deslocamento (endereo dentro do segmento). O nmero do segmento identifica unicamente uma entrada na tabela de segmentos, onde esto as informaes sobre o segmento na memria real. O endereo absoluto calculado a partir do endereo inicial do segmento mais o deslocamento. Alm do endereo do segmento na memria fsica, cada entrada na tabela de segmentos possui informaes sobre o tamanho do segmento, se ele est ou no na memria e sua proteo. Na segmentao, apenas os segmentos referenciados so transferidos da memria secundria para a memria real. Assim, para serem mais eficientes, os programas devem estar bem modularizados.
60
n do segmento deslocamento Tabela de segmentos Memria principal
endereo do segmento
+
endereo fsico
A figura abaixo exemplifica o uso de uma memria segmentada por um processo com cinco segmentos.
Sub-rotina 1 Pilha Segmento 0
1400
Segmento 3
Dados Segmento 0 Sub-rotina 2 Segmento 4 0 1 2 3 4 Limite Base 1000 1400 400 6300 400 4300 1100 3200 1000 4700
2400
3200
Segmento 3
Segmento 2 Segmento 4 5700 6300 Segmento 1 6700 4300 4700
Programa principal
Segmento 1
Segmento 2
A memria segmentada tambm facilita o trabalho do linkeditor, pois procedimentos em segmentos separados sempre comeam a executar no endereo 0. Assim, s preciso compilar e linkeditar as partes do programa do segmento alterado. Outro aspecto facilitado pela segmentao o do compartilhamento de cdigo e dados entre processos. Uma biblioteca compartilhada, por exemplo, pode ser colocada em um segmento e compartilhada por mltiplos processos. Ainda, segmentos diferentes podem ter protees diferentes. Por exemplo: Segmento de procedimento somente execuo. Segmento de dados leitura e escrita. O problema da fragmentao tambm ocorre nesse modelo, quando as reas livres so to pequenas que no acomodam nenhum segmento que necessite ser carregado. Nesse caso a compactao pode ser utilizada para resolver a fragmentao. 5.6.4 Segmentao com Paginao Permite a diviso lgica dos programas em segmentos que, por sua vez, so divididos em pginas, para que no precisem ser totalmente mantidos em memria. Assim, um endereo formado pelo nmero do segmento, um nmero de pgina dentro desse segmento e um deslocamento dentro dessa pgina. Atravs do nmero do segmento obtm-se uma entrada na tabela de segmentos que contm informaes da tabela de pginas do segmento. Com o nmero da pgina obtm-se uma entrada na tabela de pginas com informaes da pgina Sistemas Operacionais 61
na memria fsica. O endereo fsico obtido somando-se a posio inicial da moldura de pgina (frame) e o deslocamento.
n do segmento n pgina virtual deslocamento Tabela de segmentos Tabela de pginas
endereo do frame
endereo do segmento
Memria principal
+
endereo fsico
5.6.5 Segmentao com Paginao: O Pentium Intel O Pentium tem 16K segmentos independentes, cada um podendo conter at um bilho de palavras de 32 bits. A memria virtual constituda por duas tabelas, a LDT (Tabela Local de Descritores) e a GDT (Tabela Global de Descritores). Cada processo tem sua prpria LDT, mas a GDT nica, compartilhada por todos os processos. A LDT descreve os segmentos prprios de cada processo, enquanto que a GDT descreve os segmentos do sistema, incluindo o prprio sistema operacional. Para acessar um determinado segmento deve-se carregar um seletor para este segmento em um dos seis registradores de segmento (CS = segmento de cdigo, DS = segmento de dados, etc.). Cada seletor um nmero de 16 bits: 1 bit para informar se o segmento local ou global 13 bits para identificar o nmero da entrada 2 bits para proteo
13 ndice 1 2 Nvel de privilgio 0=GDT, 1=LDT
Quando o seletor carregado no registrador de segmento, o descritor correspondente buscado na LDT ou na GDT e armazenado em um dos registradores do microprograma para que possa ser acessado rapidamente. Um descritor consiste em oito bytes, contendo informaes como o endereo base, o tamanho e outras informaes do segmento. Para converter um par (seletor, deslocamento) em um endereo fsico: O microprograma descobre qual registrador de segmento est sendo utilizado e carrega o descritor em seus registradores. Se o segmento no existe ou no est carregado na memria gerada uma interrupo. O microprograma verifica se o deslocamento est dentro do segmento. Se no estiver gera uma interrupo. O deslocamento somado base do segmento para formar o endereo linear. Se a paginao estiver desativada o endereo linear interpretado como um endereo fsico. Se a paginao estiver ativada, o endereo linear ser interpretado como um endereo virtual e ser mapeado para o endereo fsico usando uma tabela de pginas de 2 nveis.
SELETOR
DESCRITOR Endereo de Base Limite Outros campos
DESLOCAMENTO + Endereo linear de 32 bits
62
Cada processo possui um diretrio de pginas que consiste em 1024 entradas de 32 bits. Cada entrada deste diretrio aponta para uma tabela de pginas que tambm contm 1.024 entradas de 32 bits, que apontam para molduras de pginas.
10 10 12
DIR
PGINA
DESLOCAMENTO
Diretrio de pginas
DIR
Tabela de pginas
PGINA
Moldura de pgina
DESLOCAMENTO
Entrada de diretrio aponta para a tabela de pginas
Entrada na tabela de pginas aponta para a moldura da pgina
O campo dir usado como ndice para o diretrio de pginas, a fim de localizar um ponteiro para a tabela de pginas correspondente. O campo pgina usado como ndice na tabela de pginas para encontrar o endereo fsico da moldura onde est a pgina. O campo deslocamento adicionado ao endereo da moldura para obteno do endereo fsico da palavra. Para evitar repetidas referncias memria o Pentium tem uma pequena memria associativa (TLB) que mapeia diretamente as pginas mais usadas recentemente no endereo fsico de suas molduras. Somente quando a combinao corrente no estiver no TLB que o mecanismo do sistema operacional ser acionado e o TLB ser atualizado com o resultado obtido. 5.6.6 Proteo Em qualquer sistema multiprogramvel deve existir um mecanismo que proteja o espao de memria de cada processo, assim como a rea do sistema operacional. No esquema de memria virtual a traduo dos endereos realizada pelo sistema operacional. Assim, impossvel que um processo tenha acesso a reas de memria de outros processos. A proteo necessria para impedir que um processo, ao acessar uma pgina ou segmento do sistema, a modifique. Mesmo as pginas e segmentos do processo podem estar definidas com uma proteo que impea, por exemplo, a gravao. Em sistemas que implementam paginao e/ou segmentao, a proteo deve ser realizada em nvel de cada pgina/segmento na memria. Esse mecanismo implementado utilizando-se as tabelas de mapeamento, onde alguns bits especificam os acessos permitidos a cada uma das pginas/segmentos. 5.6.7 Compartilhamento de Memria Em sistemas que implementam memria virtual bastante simples o compartilhamento de cdigo e dados entre processos. Para isso basta que as entradas das tabelas de pginas/segmentos apontem para as mesmas pginas/segmentos na memria principal. Assim possvel reduzir o nmero de programas na memria e aumentar o nmero de usurios compartilhando o mesmo recurso. A vantagem da segmentao em relao paginao no aspecto de compartilhamento baseiase na forma em que os programas so divididos. Como as tabelas de segmentos mapeiam estruturas lgicas, o compartilhamento de segmentos mais simples do que o de pginas. 5.6.8 Trashing Quando a quantidade de molduras de pgina alocadas a um processo decresce at um valor inferior ao conjunto funcional, sua execuo deve ser suspensa, liberando o espao ocupado por suas molduras de pgina. Caso este processo no seja suspenso e o nmero de pginas em uso seja Sistemas Operacionais 63
maior que o nmero de molduras de pgina disponveis, ocorrer um nmero excessivo de falhas de pgina. Quando o processo faz paginao excessiva, consumindo mais tempo em substituio de pginas do que executando seu cdigo, diz-se que est havendo trashing. Trashing pode ser definido como sendo a excessiva transferncia de pginas/segmentos entre a memria principal e a memria secundria. O trashing na paginao ocorre em dois nveis: no nvel do prprio processo e no nvel do sistema. No nvel do processo a excessiva paginao ocorre devido ao elevado nmero de falha de pginas, gerado pelo processo em execuo. Existem dois motivos que levam um processo a sofrer esse tipo de trashing: o mal dimensionamento do tamanho do conjunto funcional e a no obedincia ao conceito de localidade. No nvel do sistema o trashing ocorre quando existem mais processos competindo por memria do que espao disponvel. O sistema deve tentar administrar a memria de forma que todos os processos sejam atendidos. O primeiro passo a reduo do tamanho dos working sets dos processos, o que pode levar ao trashing no nvel do processo. Caso a reduo do working set no seja suficiente, o sistema comea o trabalho de swapping. Se esse mecanismo for levado ao extremo o sistema passar mais tempo fazendo swapping que executando os processos. O trashing na segmentao tambm ocorre em nvel de processo e em nvel de sistema. No nvel do processo, a transferncia de segmentos excessiva devido modularizao extrema do programa, no seguindo o conceito de localidade. No nvel do sistema o trashing bastante semelhante ao da paginao com a ocorrncia de swapping. De qualquer forma, se existem mais processos para serem executados que memria real disponvel, a nica soluo expandir a memria principal.
5.7 Exerccios
1) Por que a gerncia de memria para sistemas multiprogramveis mais crtica do que para sistemas monoprogramveis? 2) O que vem a ser atribuio de endereos em tempo de execuo? 3) Como funciona o carregamento dinmico? Qual a sua vantagem? 4) Como funciona a ligao dinmica? 5) Como o esquema de ligao dinmica pode ajudar na atualizao de softwares? 6) Por que o esquema de alocao contgua simples no apropriado para a multiprogramao? 7) Como a tcnica de overlay (sobreposio) permite expandir os limites da memria principal? Qual o impacto no desempenho? 8) Por que para a multiprogramao ser eficiente necessrio que mais de um programa possa estar carregado na memria principal simultaneamente? 9) Qual a diferena entre a alocao particionada esttica e a alocao particionada dinmica? 10) Como feita a proteo da memria nos esquemas de alocao particionada? Por que ela necessria? 11) Para a gerncia de memria, o que a fragmentao? Por que ela prejudicial? 12) Qual a diferena entre fragmentao interna e fragmentao externa? 13) O que a tcnica de swapping aplicada gerncia de memria? Qual a sua vantagem sobre a alocao particionada? Sistemas Operacionais 64
14) O swapping apresenta o problema da relocao. O que vem a ser relocao dinmica? Por que ela necessria? 15) O que a tcnica de memria virtual sob o ponto de vista da gerncia de memria? 16) Quais as vantagens de se utilizar memria virtual no lugar de swapping? 17) Qual o relacionamento entre espao de endereamento virtual e espao de endereamento real? 18) Como a tcnica de memria virtual permite que um programa ultrapasse os limites da memria principal? 19) O que vem a ser paginao para a gerncia de memria? 20) Qual a importncia da tabela de pginas para a tcnica de paginao aplicada memria virtual? 21) O que uma falha de pgina quando se est utilizando memria virtual? O que deve ser feito quando ela ocorre? 22) Como a paginao ajuda a diminuir o problema de fragmentao de memria? 23) Qual o propsito das tabelas de pginas? 24) Para que serve o bit presente/ausente nas tabelas de pginas? 25) Quando uma pgina carregada em memria precisar ser substituda por outra deve-se observar o bit modificada. Por qu? 26) Considere um sistema que utilize memria virtual com paginao. Supondo que o mapeamento das pginas virtuais em molduras de pgina seja realizado pela tabela de pginas abaixo, para qual endereo fsico ser mapeado o endereo virtual que tem nmero de pgina 2C9 e deslocamento 2CB (2C9:2CB)? n pgina virtual ... 2C7 2C8 2C9 2CA 2CB 2CC ... Endereo moldura ... 25000 3C000 8F000 BA000 45000 D8000 ... ....... ....... ....... ....... ....... ....... ....... ....... .......
27) Por que o mapeamento de memria deve ser realizado em blocos e no sobre clulas individuais? 28) Qual a funo do TLB (memria associativa) para a gerncia de memria? 29) Quando se usa a paginao possvel realizar o compartilhamento de pginas. O que vem a ser isto? Explique o benefcio que se obtm. 30) O que working set (conjunto funcional)? 31) Qual a relao existente entre working set (conjunto funcional) e trashing? 32) Explique o funcionamento do algoritmo da idade, usado para escolher uma pgina que deve ser retirada da memria. 33) O que a tcnica de segmentao aplicada gerncia de memria?
65
34) Quando se usa segmentao o endereo dado por um par segmento:deslocamento. Como o mapeamento de um endereo deste tipo em um endereo real? 35) Como a segmentao pode facilitar o compartilhamento de cdigo entre processos oriundos de um mesmo programa? 36) O que trashing? Como este problema pode ser solucionado?
66
6 Sistema de Arquivos
O armazenamento e a recuperao de informaes so atividades essenciais para qualquer tipo de aplicao. As principais exigncias para armazenamento de informaes so: Deve ser possvel armazenar uma grande quantidade de informaes. A informao deve sobreviver finalizao do processo que a utiliza. Mltiplos processos devem ser capazes de acessar as informaes concorrentemente. mediante a implementao de arquivos em discos ou outras mdias que o sistema operacional estrutura e organiza estas informaes. A parte responsvel por essa gerncia denominada sistema de arquivos. A manipulao de arquivos deve ocorrer de maneira uniforme, independentemente dos diferentes dispositivos de armazenamento. O sistema de arquivos constitudo de duas partes distintas: um conjunto de arquivos, que armazenam dados, e uma estrutura de diretrios, que organiza e fornece informaes sobre os arquivos do sistema.
6.1 Arquivos
Computadores podem armazenar dados em diferentes meios de armazenamento. Para que um sistema possa ser usado de forma conveniente, o sistema operacional deve oferecer uma viso lgica e uniforme do meio de armazenamento. Um arquivo constitudo de informaes, podendo representar programas ou dados. Um programa contm instrues compreendidas pela UCP (arquivo executvel), enquanto um arquivo de dados pode ser estruturado livremente (podem ser numricos, alfabticos, alfanumricos ou binrios). Arquivos podem ser armazenados pelo sistema operacional em diferentes dispositivos fsicos (fita magntica, disco magntico, CD-ROM, etc.). O tipo de dispositivo deve ser isolado pelo sistema operacional de forma que exista uma independncia entre os arquivos a serem manipulados e o meio de armazenamento. Um arquivo identificado por meio de um nome, e as regras para os nomes de arquivos variam de sistema para sistema. Em alguns sistemas operacionais o nome do arquivo composto por duas partes separadas com um ponto. A parte aps o ponto denominada extenso do arquivo e tem como finalidade identificar seu contedo. As principais diferenas entre as regras para os nomes de arquivo so: Quantidade mxima de caracteres. Diferenciao entre caracteres maisculos e minsculos. Uso de caracteres especiais. Nomes com extenso tendo significado ou no.
Quando um processo cria um arquivo ele deve dar um nome a este arquivo para que quando o processo termine o arquivo continue existindo e possa ser acessado por outros processos pelo mesmo nome. Ao receber um nome o arquivo se torna independente do processo, do usurio e at mesmo do sistema que o criou. 6.1.1 Organizao de Arquivos No momento da criao de um arquivo possvel definir que organizao ser adotada. Esta organizao pode ser uma estrutura suportada pelo sistema operacional ou definida pela prpria aplicao. Sistemas Operacionais 67
A forma mais simples de organizao de arquivos atravs de uma sequncia no estruturada de bytes. Nesse tipo de organizao o sistema de arquivos no impe nenhuma estrutura lgica para os dados (a aplicao deve definir toda a organizao). A grande vantagem a flexibilidade para criar diferentes estruturas de dados, mas todo o controle de acesso ao arquivo de inteira responsabilidade da aplicao. Uma forma estruturada para o armazenamento de arquivos a sequncia de registros de tamanho fixo. Nela o arquivo composto por uma srie de registros com estrutura interna caracterstica, e as operaes de leitura/gravao trabalham com registros inteiros. Outra estrutura a rvore de registros, uma organizao que composta por registros que no tem necessariamente o mesmo tamanho, e cada um contm um campo com uma chave em uma posio fixa. A rvore ordenada pelo campo chave de forma a permitir uma busca rpida.
1 byte 1 registro B C D H
A
F I
E
G J
L
K M N O
rvore
Sequncia de bytes
Sequncia de registros
6.1.2 Mtodos de Acesso Os primeiros sistemas operacionais acessavam os registros de um arquivo na ordem em que eram gravados, sendo a gravao de novos registros possvel apenas no final. A esse tipo de acesso d-se o nome de acesso sequencial. No possvel pular ou ler registros fora de ordem, mas possvel retroceder registros. Posteriormente surgiu um mtodo de acesso mais eficientes, o acesso aleatrio (acesso direto), que permite a leitura/gravao de um registro diretamente na sua posio relativa ao incio do arquivo. No acesso aleatrio no existe restrio ordem em que os registros so lidos ou gravados. O acesso aleatrio somente possvel quando o arquivo definido com registros de tamanho fixo. Em sistemas operacionais antigos o tipo de acesso ao arquivo determinado no momento em que o arquivo criado. Nos sistemas operacionais modernos todos os arquivos so de acesso aleatrio, excetuando-se os casos em que o dispositivo no qual o arquivo est armazenado no permita o acesso aleatrio. Existem ainda outros mtodos de acesso menos comuns, como o acesso indexado. O acesso indexado envolve a construo de um ndice para o arquivo. Esse ndice contm ponteiros para os blocos e, para acessar uma posio de arquivo, primeiro pesquisa-se o ndice e depois utiliza-se o ponteiro para a posio desejada. 6.1.3 Tipos de Arquivos Os sistemas operacionais costumam suportar vrios tipos de arquivos. Os tipos mais comuns so: Arquivos regulares Arquivos que contm informaes genricas como, por exemplo, dados dos usurios. Diretrios Arquivos de sistema usados para manter a estrutura do sistema de arquivos. Arquivos especiais de caractere Relacionam-se com operaes de E/S e costumam modelar dispositivos seriais. Arquivos especiais de bloco Usados para modelar dispositivos de bloco, em especial discos. Sistemas Operacionais 68
Em geral arquivos regulares so classificados como arquivo texto ou arquivo binrio. Um arquivo texto (ou arquivo ASCII) constitudo por linhas de texto que podem ter tamanhos diferentes e terminam por caracteres especiais para indicar o fim da linha. So arquivos que quando exibidos na tela ou impressos podem ser compreendidos pelas pessoas. Podem, ainda, ser editados com um editor de textos comum. Arquivos binrios so arquivos que no so arquivos texto. Sua listagem gera um conjunto de caracteres incompreensveis. Eles podem ser arquivos de usurios (com ou sem estrutura interna) ou arquivos executveis (com estrutura conhecida pelo sistema operacional e cdigos que so executados pela UCP). 6.1.4 Operaes de Entrada/Sada O sistema de arquivos oferece um conjunto de chamadas de sistema que permite s aplicaes realizarem operaes de E/S. As chamadas de sistema de E/S tm como funo oferecer uma interface simples e uniforme entre a aplicao e os diversos tipos de dispositivos. Na parte introdutria desta apostila foram mostradas as chamadas de sistema POSIX para gerenciamento de arquivos, que est presente na maioria dos sistemas operacionais. 6.1.5 Atributos Alm do nome e dos dados, arquivos costumam possuir informaes extras para controle denominadas atributos. Alguns atributos variam dependendo do sistema de arquivos, mas alguns como tamanho do arquivo, proteo, identificao do criador e data de criao, esto presentes em quase todos os sistemas. Os principais atributos so: Atributos relacionados com a proteo proteo (quem e de que maneira pode acessar), senha, criador, proprietrio. Atributos que controlam ou ativam alguma atividade especfica somente leitura, oculto, sistema, arquivo, ASCII/binrio, acesso aleatrio, temporrio, bloqueio. Atributos para arquivos cujos registros podem ser pesquisados comprimento do registro, posio da chave, comprimento da chave. Atributos relacionados com data/hora tempo de criao, tempo do ltimo acesso, tempo da ltima alterao. Atributos relacionados com o tamanho tamanho atual, tamanho mximo.
6.2 Diretrios
A estrutura de diretrios o modo como o sistema organiza logicamente os diversos arquivos contidos em um disco. O diretrio um arquivo que contm uma estrutura de dados com entradas associadas aos arquivos onde so armazenadas informaes como localizao fsica, nome, organizao e demais atributos. Quando solicitada a abertura de um arquivo o sistema operacional pesquisa o diretrio at encontrar uma entrada com o nome do arquivo. Quando a entrada encontrada o sistema operacional copia os atributos e os endereos de disco e os coloca em uma estrutura na memria, a tabela de arquivos, que contm todos os arquivos abertos. Quando o arquivo fechado, sua entrada na tabela de arquivos liberada. A implementao mais simples de uma estrutura de diretrios chamada de nvel nico, (um nvel), onde existe um nico diretrio contendo todos os arquivos do disco. Este modelo bastante limitado, j que no permite que usurios criem arquivos com o mesmo nome, o que ocasionaria um conflito no acesso aos arquivos. Este tipo de implementao no mais utilizado atualmente. Em uma outra estrutura, conhecida como diretrio de dois nveis, existe um diretrio para os arquivos do sistema e um diretrio para cada usurio. Com esta implementao, cada usurio pode Sistemas Operacionais 69
criar arquivos sem a preocupao de conhecer os demais arquivos do disco. Para que o sistema possa localizar arquivos nesta estrutura existe um nvel de diretrio adicional denominado master file directory, indexado pelo nome do usurio. Nele, cada entrada aponta para o diretrio de cada usurio. Para referenciar um arquivo neste tipo de estrutura necessrio especificar o diretrio onde ele se encontra e o seu nome, especificando assim seu caminho (path). A organizao dos arquivos em um nico diretrio no permite uma organizao adequada. A extenso para um modelo de mltiplos nveis permite que os arquivos sejam melhor organizados. Este modelo, chamado estrutura de diretrios em rvore ou sistema de diretrios hierrquico, atualmente adotado pela maioria dos sistemas operacionais. Na estrutura em rvore possvel criar quantos diretrios se deseje, podendo um diretrio conter arquivos ou outros diretrios (subdiretrios). Cada arquivo, nesta estrutura, possui um caminho (path) nico que descreve todos os diretrios desde a raiz at o diretrio no qual o arquivo est, mais o nome do arquivo. Quando o sistema de arquivos organizado como uma rvore de diretrios, os nomes de caminhos podem ser absolutos ou relativos. Um nome de caminho absoluto consiste no caminho desde o diretrio raiz (diretrio inicial do sistema de arquivos) at o arquivo. O nome de caminho relativo utilizado em conjunto com o conceito de diretrio de trabalho (diretrio atual) ,que o diretrio usado atualmente pelo processo e serve como base caso o nome do caminho no inicie com o diretrio raiz. Quando utilizado um caminho relativo, o caminho at o arquivo buscado a partir do diretrio de trabalho. Cada processo possui seu prprio diretrio de trabalho. Assim, se algum processo alterar seu diretrio de trabalho, os outros processos do usurio no sero afetados. A maioria dos sistemas que suporta estrutura de diretrios em rvore tem duas entradas especiais para cada diretrio: . Diretrio atual. .. Diretrio pai. Pode ser usada para subir na rvore de diretrios.
6.3 Alocao de Espao em Disco

Os discos so o meio de armazenamento secundrio mais comum no qual os arquivos so armazenados. As transferncias de dados entre a memria e o disco so realizadas em unidades chamadas blocos, cada qual constituda por um ou mais setores. Dependendo do disco um setor pode variar de 32 a 4096 bytes, sendo mais comum setores de 512 bytes. A criao de arquivos em disco exige que o sistema operacional tenha o controle de quais blocos no disco esto livres. Este controle realizado atravs de uma estrutura de dados que armazena informaes que possibilitam ao sistema de arquivos gerenciar o disco. A forma mais simples de implementar uma estrutura de espaos livres atravs de uma tabela denominada mapa de bits. A cada entrada da tabela associada um bloco do disco representado por um bit, que pode assumir valor igual a 0 (bloco livre) ou 1 (bloco alocado). Uma segunda maneira de realizar este controle por meio de uma lista encadeada de todos os blocos livres do disco. Cada bloco possui uma rea reservada para armazenamento do endereo do prximo bloco, e a partir do primeiro bloco livre pode-se ter acesso aos demais de forma encadeada. Suas principais restries so o espao utilizado no bloco com informao de controle e o fato do algoritmo de busca de espao livre sempre ter que realizar uma pesquisa sequencial na lista. Outra soluo leva em conta que blocos contguos so geralmente alocados ou liberados simultaneamente, enxergando o disco como um conjunto de segmentos de blocos livres. Assim possvel manter uma tabela de blocos livres com o endereo do primeiro bloco de cada segmento e o nmero de blocos livres contguos que se seguem. Sistemas Operacionais 70
0 5 10
1 6 11 16 21 26
2 7 12 17 22 27
3 8 13 18 23 28
4 9 14 19 24 29
11100 00011 11001 00111 00000 00111 Mapa de bits
15 20 25
Lista encadeada
Bloco Contador 03 03 12 12 15 15 20 20 Tabela de blocos livres
6.3.1 Alocao Contgua A alocao contgua consiste em armazenar um arquivo em blocos contguos de dados no disco. Neste tipo de alocao, o sistema localiza um arquivo atravs do endereo do primeiro bloco e da sua quantidade de blocos. O acesso a arquivos dispostos contiguamente no disco bastante simples tanto para o acesso sequencial quanto para o acesso aleatrio. Seu principal problema a alocao de espao livre para novos arquivos, j que para um arquivo ser criado com n blocos necessrio que exista uma cadeia de n blocos dispostos sequencialmente no disco. Pode-se enxergar o disco como um grande vetor onde os elementos podem ser considerados segmentos com tamanhos diferentes de blocos contguos, dispostos alternadamente entre segmentos ocupados e segmentos livres. No momento em que o sistema operacional deseja alocar espao para armazenar um novo arquivo, pode existir mais de um segmento livre disponvel com o tamanho exigido. Neste caso, necessrio que alguma estratgia de alocao seja adotada para selecionar qual o segmento na lista de blocos livres deve ser escolhido. As estratgias adotadas so as mesmas estudadas para escolha de partio em memria, existindo tambm o problema da fragmentao. Quando o disco estiver muito fragmentado para que se possa alocar espao para a criao do arquivo ser necessrio realizar a desfragmentao do disco, que consiste em mover os arquivos para abrir espao suficiente para o novo arquivo. A desfragmentao um processo demorado que deve ser realizado periodicamente. Nem sempre possvel determinar no momento da criao de um arquivo qual o seu tamanho mximo, podendo posteriormente existir a necessidade de extenso. A pr-alocao de espao uma soluo que, apesar de resolver o problema, pode fazer com que parte do espao alocado permanea ocioso. O sistema operacional IBM VM/CMS usava este tipo de alocao. 6.3.2 Alocao por Lista Encadeada Na alocao por lista encadeada um arquivo organizado como um conjunto de blocos ligados logicamente, independentemente da sua localizao fsica. Cada bloco deve possuir um ponteiro para o bloco seguinte e assim por diante. A entrada de diretrio precisa armazenar somente o endereo do primeiro bloco. A fragmentao do disco no ocorre na alocao encadeada j que os blocos alocados para um determinado arquivo no precisam estar em posies contguas. O que ocorre neste mtodo a fragmentao de arquivos, que a quebra do arquivo em diversos blocos espalhados pelo disco. A fragmentao dos arquivos resulta no aumento do tempo de acesso, pois o processo de leitura/gravao provoca um grande nmero de deslocamentos da cabea de leitura/gravao. Para otimizar o tempo das operaes de E/S importante que o disco seja desfragmentado periodicamente.
71
0 5
1 6
2 7
3 8
4 9
10
06
03
18
21
28
10
15 20 25
11
16 21 26
12
17 22 27
13
18 23 28
14
19 24 29
Alocao por lista encadeada
A alocao por lista encadeada s permite o acesso sequencial aos blocos de um arquivo. Isto constitui uma das principais desvantagens dessa tcnica. Alm disso desperdiado espao nos blocos com o armazenamento de ponteiros. Outro problema da alocao por lista encadeada referente confiabilidade. Se o valor de um ponteiro corrompido se perde o encadeamento do arquivo. 6.3.3 Alocao por Lista Encadeada Utilizando ndice um esquema de alocao muito parecido com a alocao por lista encadeada, mas no lugar de fazer o encadeamento utilizando um ponteiro no bloco, o encadeamento mantido em uma tabela. Embora a cadeia ainda precise ser seguida para o acesso aleatrio, ela seguida por intermdio da tabela, e no consultando bloco a bloco, e pode, ainda, ser mantida em memria, tornando o acesso mais rpido. A principal desvantagem que a tabela pode ser muito grande para discos grandes. Este problema pode ser minimizado agrupando os blocos em clusters para formar unidades maiores, mas isto provoca um maior desperdcio por causa da parte no utilizada do ltimo cluster, que tender a ser maior.
.. .. 06 .. .. .. .. 03 .. .. 28 .. .. .. .. .. .. .. 18 .. .. 21 .. -1 .. .. .. .. .. ..
0
5 10 15 20
1
6 11 16 21
2
7 12 17 22
3
8 13 18 23
4
9 14 19 24
Alocao por lista encadeada utilizando ndice
25
26
27
28
29
6.3.4 Ns-I (Alocao Indexada) O mtodo consiste em associar a cada arquivo uma tabela denominada n-i (n-ndice ou inode) que lista os atributos e os endereos em disco dos blocos do arquivo.
0 5
1 6
2 7
3 8
4 9
12 10 06 03 18 21 28 n-i
10
15 20 25
11
16 21 26
12
17 22 27
13
18 23 28
14
19 24 29
72
Os primeiros endereos de disco so armazenados no prprio n-i. Isto significa que para arquivos pequenos toda a informao est contida no prprio n-i e pode ser transferida para a memria quando o arquivo aberto. Para arquivos maiores, um dos endereos no n-i o endereo de um bloco do disco chamado bloco indireto simples, que contm endereos de blocos adicionais para o arquivo. No n-i existe ainda o endereo de um bloco indireto duplo e de um bloco indireto triplo. O bloco indireto duplo contm o endereo do bloco que possui uma lista de blocos indiretos simples relativos ao arquivo, enquanto o bloco indireto triplo contm o endereo do bloco que possui uma lista de blocos indiretos duplos.
N-i Atributos
Bloco indireto simples

Bloco indireto duplo
Bloco indireto triplo
6.4 Exemplos de Implementao de Diretrios

Quando solicitada a abertura de um arquivo, o sistema operacional usa o nome do caminho fornecido para localizar a entrada de diretrio. Uma questo importante onde armazenar os atributos. Alguns sistemas armazenam diretamente na entrada de diretrio, enquanto outros armazenam no n-i. 6.4.1 Diretrios no CP/M O CP/M possui apenas um diretrio, assim a pesquisa por um arquivo realizada somente neste diretrio. A entrada possui os nmeros de blocos de disco. Se um arquivo usa mais blocos de disco que os que se ajustam em uma entrada, so alocadas entradas adicionais. O CP/M no informa o tamanho do arquivo em bytes. Pode-se apenas saber quantos blocos esto alocados ao arquivo.
1 8
Nome do arquivo Cdigo do usurio Grau
3 1 Tipo (ext)
16
Endereos de blocos de disco Contagem de blocos
O campo cdigo do usurio identifica o proprietrio do arquivo. O nome de um arquivo composto pelo campo nome do arquivo (at 8 caracteres) concatenado com o campo tipo (at 3 caracteres, separados por um ponto. O campo grau usado para indicar a ordem em que as entradas do arquivo devem ser acessadas quando o arquivo for maior que 16 blocos. 6.4.2 Diretrios no MS-DOS um sistema de arquivos baseado em rvores de diretrios onde cada entrada de diretrio possui 32 bytes.
73
8
Nome do arquivo
10
Reservado
4 Tamanho
Nmero do primeiro bloco
Extenso
Atributos
Hora Data
O campo nmero do primeiro bloco usado como ndice para uma tabela que representa a lista encadeada de blocos. Diretrios podem conter outros diretrios, conduzindo a um sistema de arquivos hierrquico. 6.4.3 Diretrios no UNIX Cada entrada possui apenas um nome de arquivo e o nmero de seu n-i. As outras informaes sobre o arquivo esto contidas no n-i. Quando solicitada a abertura de um arquivo com caminho absoluto, o sistema operacional localiza o diretrio raiz (em uma posio fixa no disco) e busca diretrio a diretrio at chegar ao diretrio em que se encontra o arquivo. Ento o n-i do arquivo carregado e mantido em memria at que o arquivo seja fechado. Nomes com caminho relativo so pesquisados da mesma forma, exceto que iniciam a partir do diretrio de trabalho. A entrada . tem o nmero do prprio n-i, enquanto a entrada .. tem o nmero do n-i do diretrio pai.
6.5 Proteo de Acesso

Como os meios de armazenamento so compartilhados entre diversos usurios importante que mecanismos de proteo sejam implementados para garantir a proteo individual de arquivos e diretrios. O tipo de acesso a arquivos implementado mediante a concesso ou no dos diferentes acessos que podem ser realizados, como leitura, gravao, execuo e eliminao. O controle de acesso s operaes realizadas com diretrios possui diferenas em relao s operaes realizadas com arquivos. Existem diferentes mecanismos e nveis de proteo, cada qual com suas vantagens e desvantagens. 6.5.1 Senha de Acesso O controle de acesso por senha se resume ao usurio ter o conhecimento da senha e, consequentemente, ter a liberao do acesso ao recurso. Como cada recurso possui apenas uma senha, o acesso liberado ou no na sua totalidade. Assim, no possvel determinar quais tipos de operao podem ou no ser concedidas. Outra desvantagem a dificuldade de compartilhamento de arquivos, pois alm do dono do arquivo todos os demais usurios teriam que conhecer a senha de acesso. 6.5.2 Grupos de Usurios Esse tipo de proteo tem como princpio a associao de cada usurio do sistema a um ou mais grupos. Os grupos de usurios so organizados logicamente com o objetivo de compartilhar recursos, sendo que os usurios que desejam compartilhar recursos entre si devem pertencer a um mesmo grupo. Esse mecanismo implementa trs nveis de proteo: dono, grupo e todos. Na criao do recurso o usurio especifica se o recurso deve ser acessado somente pelo seu criador, pelos usurios do grupo ao qual ele pertence ou por todos os usurios do sistema. necessrio especificar o tipo de acesso (leitura, escrita, execuo e eliminao) para cada nvel de proteo. Sistemas Operacionais 74
6.5.3 Lista de Controle de Acesso A Lista de Controle de Acesso (Access Control List - ACL) consiste em uma lista associada a cada recurso, onde so especificados os usurios e os tipos de acesso permitidos. Quando um usurio tenta acessar um recurso, o sistema operacional verifica se a lista de controle de aceso autoriza a operao desejada. Essa estrutura pode ser bastante extensa. Isto pode levar a um overhead se comparado com o mecanismo de proteo por grupos de usurios por conta da pesquisa sequencial que o sistema dever realizar sempre que um acesso for solicitado. Em alguns sistemas possvel encontrar tanto o mecanismo de proteo por grupos de usurios quanto o por lista de controle de acesso, oferecendo uma maior flexibilidade ao mecanismo de proteo de arquivos e diretrios.
6.6 Implementao de Cache

O acesso a disco lento se comparado ao acesso memria principal. Este o principal fator para as operaes de E/S com discos serem um problema para o desempenho do sistema. Com o objetivo de minimizar este problema, a maioria dos sistemas de arquivos implementa uma tcnica denominada cache. Neste esquema o sistema operacional reserva uma rea na memria principal para que se tornem disponveis caches utilizados em operaes de acesso ao disco. Quando uma operao realizada o sistema verifica se a informao desejada se encontra na cache. Caso esteja disponvel no necessrio acesso ao disco. Caso o bloco requisitado no se encontre no cache, a operao de E/S realizada e a cache atualizada. Como existe uma limitao no tamanho da cache, cada sistema adota uma poltica para substituio de blocos como, por exemplo, a LRU. Apesar de melhorar o desempenho do sistema, aspectos de segurana devem ser levados em considerao. No caso de blocos de dados permanecerem por muito tempo na cache, a ocorrncia de problemas de energia pode ocasionar a perda de tarefas j realizadas e consideradas salvas em disco. Existem duas maneiras de tratar este problema. No primeiro caso o sistema operacional possui uma rotina que executa periodicamente atualizando em disco todos os blocos modificados da cache. Uma segunda alternativa realizar imediatamente uma atualizao no disco sempre que um bloco da cache for modificado (cache write-through). Quando a memria cache no atualiza o disco imediatamente temos a chamada cache write-back. A tcnica write-back implica em menor quantidade de operaes de E/S, porm o risco de perda de dados maior. Isto no acontece nas caches write-through em funo do seu prprio funcionamento, mas o aumento considervel nas operaes de E/S tornam este mtodo menos eficiente.
6.7 Exerccios
1) Qual o objetivo de um sistema de arquivos sob o ponto de vista do sistema operacional? 2) O que um arquivo? 3) Por que o sistema operacional deve isolar o usurio com relao ao tipo de dispositivo em que um arquivo foi armazenado? 4) As regras para formao do nome de um arquivo podem ser diferentes de um sistema de arquivos para outro? Explique. 5) O que caracteriza um sistema de arquivos que armazena arquivos como uma sequncia de registros de tamanho fixo? 6) Qual a diferena entre acesso sequencial e acesso aleatrio a um arquivo? 7) O que diferencia um diretrio de um arquivo regular? Sistemas Operacionais 75
8) Qual a diferena entre arquivos especias de caractere e arquivos especiais de bloco? 9) O que diferencia um arquivo texto (ASCII) de um arquivo binrio? 10) O que so atributos de arquivos? 11) O que a tabela de arquivos? 12) O que um sistema de diretrios hierrquico? 13) Qual a diferena entre o caminho absoluto e o caminho relativo de um arquivo? 14) Explique como funciona o esquema de alocao em disco utilizando: lista encadeada lista encadeada utilizando ndice n-i 15) O que a fragmentao para o esquema de alocao contnua de espao em disco para arquivos? 16) Por que se torna necessrio realizar a desfragmentao de disco no esquema de alocao contnua de espao em disco para arquivos? 17) O que a fragmentao para o esquema de alocao de arquivos por lista encadeada? 18) Qual a principal vantagem do esquema de alocao por lista encadeada utilizando ndice sobre o esquema de alocao por lista encadeada quando se deseja acrescentar informaes a um arquivo? 19) Por que se torna necessria a utilizao de clusters (agrupamento de setores) quando se utiliza a alocao por lista encadeada utilizando ndice? 20) Para que so utilizados os blocos indiretos no esquema de alocao indexada (ns-i)? 21) Onde so armazenados os atributos de arquivos nas implementaes de diretrios do: MS-DOS UNIX 22) Por que um sistema de arquivos precisa fornecer um esquema de proteo de acesso a arquivos e diretrios? 23) O que uma lista de controle de acesso? 24) Em que um sistema de cache auxilia no acesso a arquivos? 25) Qual a diferena entre uma cache write-through e uma cache write-back? 26) Que tipo de problema pode ocorrer que possa leva a um sistema de arquivos se tornar inconsistente por causa do uso de cache? Como pode ser resolvido?
76
7 Gerncia de Dispositivos
Os dispositivos que podem ser conectados a um computador podem variar de diversas maneiras. Alguns exemplos das diferenas existem entre os dispositivos so: transferncia por bloco ou caractere dados armazenados sequencialmente ou aleatoriamente transferncia sncrona ou assncrona acesso restrito ou compartilhado somente leitura ou leitura e escrita velocidade de acesso
Devido a esta grande variao, o sistema operacional precisa fornecer uma vasta gama de funcionalidade s aplicaes. A gerncia de dispositivos de entrada/sada (dispositivos de E/S) uma das funes mais complexas exercidas por um sistema operacional. Sua implementao estruturada atravs de camadas de software e de hardware, onde as camadas de mais baixo nvel escondem das camadas superiores as caractersticas do hardware, oferecendo uma interface simples e confivel para o usurio e suas aplicaes.
Software
Hardware
Operaes de E/S Subsistema de E/S Drivers de dispositivo Controladores Dispositivos
Independente do dispositivo
Dependente do dispositivo
A gerncia de dispositivos deve esconder das camadas superiores os diversos detalhes de cada perifrico e suas diferenas, como velocidade de operao, unidade de transferncia, representao dos dados, tipos de operaes, etc. As camadas so divididas em dois grupos. O primeiro grupo (independente do dispositivo) visualiza os diversos tipos de dispositivos do sistema de um modo nico, enquanto o segundo grupo (dependente do dispositivo) especfico para cada dispositivo. As metas do software de entrada/sada so: Independncia do dispositivo Processos devem poder ler/escrever de qualquer dispositivo sem a necessidade de ser alterado. Atribuio uniforme de nomes O nome de um arquivo ou dispositivo deve ser simples (uma string ou um nmero). Tratamento de erros Deve ser feito na camada mais baixa possvel. Se for possvel corrigir, deve ser feito de forma que camadas superiores no sintam. Transferncias sncronas assncronas O sistema operacional deve fazer com que todas as operaes de E/S bloqueiem para o processo do usurio. Dispositivos compartilhados dedicados O sistema operacional deve tratar todos os problemas inerentes ao acesso concorrente ao dispositivo.
7.1 O Hardware de Entrada/Sada

A comunicao de um dispositivo com o sistema computacional feita por intermdio de envio de sinais. Esta comunicao se d a partir de um ponto de comunicao denominado porta. O meio utilizado por um ou mais dispositivos para conexo com o restante do sistema computacional Sistemas Operacionais 77
denominado barramento. Para cada barramento definido um protocolo que especifica um conjunto de mensagens que podem ser enviadas atravs dele. A figura abaixo mostra uma estrutura tpica do barramento de um microcomputador. Ela possui um barramento que conecta o subsistema processadormemria aos dispositivos rpidos e um barramento de expanso que faz a comunicao com dispositivos mais lentos.
Discos SCSI Memria cache
Monitor
UCP
Controlador de terminal grfico Barramento
Controlador de Memria
Memria
Controlador SCSI
Controlador de disco IDE
Interface do barramento de expanso Porta paralela Porta serial
Barramento de expanso
Discos IDE
Teclado
Um controlador um conjunto de componentes eletrnicos para operao de uma porta, barramento ou dispositivo. Para que a UCP possa enviar comandos e dados a um controlador, o controlador faz uso de registradores para armazenar dados e sinais de controle. A comunicao da UCP com os controladores se d por operaes de leitura e escrita nestes registradores. Uma porta de E/S consiste tipicamente em 4 registradores: Status Contm bits que podem ser lidos pela UCP e fornecem informaes sobre o estado do dispositivo. Controle Pode ser modificado pela UCP para alterar o modo de funcionamento do dispositivo. Entrada de dados A UCP obtm valores do dispositivo lendo-os a partir deste registrador. Sada de dados A UCP envia valores ao dispositivo escrevendo-os neste registrador. 7.1.1 Espera em Ciclo Supondo que sejam utilizados 2 bits para controlar a troca de dados entra a UCP e o controlador, o controlador indica seu estado por meio de um bit ocupado no registrador de status (1 indica que o controlador est realizando alguma operao e 0 indica que o controlador est pronto para executar o prximo comando). A UCP usa o bit processar no registrador de controle, marcando-o para especificar que um comando deve ser processado. Assim, a comunicao entre a UCP e o controlador segue: 1. A UCP l repetidamente o bit ocupado at que o bit esteja desligado. 2. A UCP armazena um valor no registrador de sada de dados e liga o bit escrever no registrador de controle. 3. A UCP liga o bit processar. 4. O controlador v o bit processar ligado e liga o bit ocupado. 5. O controlador v o bit escrever ligado e l o valor armazenado no registrador de sada de dados, gravando este valor no dispositivo. 6. O controlador desliga os bits processar e ocupado para indicar que a operao de E/S terminou. Sistemas Operacionais 78
Se o tempo de espera para o dispositivo ficar pronto for muito grande, a UCP ficar ociosa por muito tempo enquanto poderia estar realizando outra tarefa. 7.1.2 Interrupes O problema da espera em ciclo o desperdcio de UCP que o mtodo gera. Para evitar este desperdcio o controlador pode fazer uso do mecanismo de interrupes para avisar a UCP sempre que ele estiver pronto. Ainda, o uso de interrupes possibilita UCP responder a eventos assncronos. 7.1.3 Acesso Direto Memria Para dispositivos de E/S cuja operao geralmente envolve grandes quantidades de dados, um desperdcio usar a UCP para fazer a transferncia, melhor utilizar um processador especializado chamado controlador de DMA (Direct Memory Access - Acesso Direto Memria). Para iniciar uma transferncia a UCP informa ao controlador de DMA um endereo no dispositivo de E/S, um endereo de memria, a quantidade de bytes a transferir e o sentido da transferncia. O controlador de DMA prossegue com a operao de E/S, usando diretamente o barramento, ficando a UCP livre para executar outras operaes. Quando o controlador de DMA termina a transferncia ele gera uma interrupo para avisar UCP.
7.2 Operaes de Entrada/Sada

Sempre que um processo realiza uma operao de E/S o sistema deve tornar a tarefa o mais simples possvel para o usurio e suas aplicaes. Para isso, o sistema operacional deve ser capaz de se comunicar com qualquer dispositivo que possa ser conectado ao hardware do computador. A maneira mais simples de um processo ter acesso a um dispositivo atravs de bibliotecas de comandos de entrada/sada, oferecidas pela maioria das linguagens de programao. Os comandos de E/S de linguagens de alto nvel independem do sistema operacional onde se est trabalhando. Para obter a independncia de dispositivos as operaes de E/S devem ser realizadas por intermdio de chamadas de sistema (system calls). As chamadas de sistema responsveis por essa comunicao so rotinas presentes na camada de mais alto nvel implementada pelo sistema operacional, permitindo ao usurio realizar operaes de E/S sem se preocupar com detalhes do dispositivo que est sendo acessado. O relacionamento entre os comandos de E/S oferecidos pelas linguagens de programao de alto nvel e as chamadas de sistema criado durante a linkedio do programa.
Aplicao Comandos de E/S Chamadas de sistema Dispositivos
Nem todo software de entrada/sada no nvel do usurio pertence biblioteca de procedimentos. Outra categoria importante a dos sistemas de spooling. O spool (Simultaneous Peripheral Operation On-Line) uma forma de se tratar com dispositivos dedicados que fazem parte de um sistema multiprogramado. Para realizar o spool so criados processos especiais denominados daemons e diretrios denominados diretrios de spooling. Para evitar que um processo ganhe o uso de um dispositivo compartilhado e no o libere mais, ou que mais de um processo ganhe acesso simultneo a um dispositivo que deva trabalhar de forma dedicada, o daemon o nico processo que poder ganhar o uso deste dispositivo. Sempre que um processo desejar escrever neste dispositivo, ele dever gerar um arquivo no diretrio de spooling e
79
solicitar ao daemon que faa a transferncia do arquivo para o dispositivo. Exemplos de daemons so daemon de impresso e daemon de rede.
7.3 Subsistema de Entrada/Sada

O subsistema de entrada/sada responsvel por realizar as funes que so comuns a todos os dispositivos oferecendo uma interface uniforme, ficando os aspectos especficos de cada perifrico a cargo dos drivers de dispositivo. Uma de suas funes mapear o nome do dispositivo com o seu respectivo driver. As camadas superiores conhecem apenas o nome do dispositivo e utilizam esse nome para terem acesso ao perifrico. Cada dispositivo trabalha com unidades de informao de tamanhos diferentes. O subsistema de E/S responsvel por criar uma unidade lgica de informao independente do dispositivo e repass-la aos nveis superiores. O tratamento de erros nas operaes de E/S costuma ser realizado nas camadas mais prximas ao hardware, mas certos erros podem ser tratados e reportados de forma uniforme independentemente do dispositivo pelo subsistema de E/S. Alguns dispositivos podem ser compartilhados simultaneamente entre diversos usurios, enquanto outros devem ter acesso exclusivo. O sistema operacional deve controlar os compartilhamentos de forma organizada. O subsistema de E/S responsvel tambm por implementar o mecanismo de proteo de acesso aos dispositivos. A bufferizao outra tarefa do subsistema de E/S. Ela permite reduzir o nmero de operaes de E/S utilizando uma rea de memria intermediria (buffer). Quando solicitada a leitura de um dado do disco o sistema traz para o buffer, alm do dado, um bloco de dados. Na prxima vez que uma nova leitura de um dado que pertena ao bloco for solicitada, ele j estar no buffer, evitando uma nova operao de E/S. Muitas das funes do subsistema de E/S esto envolvidas com o sistema de arquivos. A implementao de caches um exemplo desse relacionamento. As operaes de E/S podem ser classificadas de acordo com seu sincronismo. Um processo que realiza uma operao sncrona fica bloqueado at o trmino da operao, enquanto um processo que realiza uma operao assncrona no precisa aguardar pelo trmino da operao e pode continuar executando normalmente.
7.4 Drivers de Dispositivo

O driver de dispositivo (device driver), ou somente driver, tem como funo a comunicao com dispositivos de E/S em nvel de hardware. Enquanto o subsistema de E/S trata de funes que afetam a todos os dispositivos, os drivers tratam apenas dos seus aspectos particulares. Cada driver manipula somente um tipo de dispositivo ou grupo de dispositivos semelhantes. Os drivers tm como funo receber comandos genricos sobre acessos aos dispositivos e traduzilos para comandos especficos, que podero ser executados pelos controladores. O driver interage diretamente com as funes do controlador. Ele reconhece quantos registradores o controlador possui, como so utilizados e quais so seus comandos. Sua funo principal receber comandos abstratos e traduzi-los para comandos que o controlador possa executar.
80
Chamada de sistema
Ler bloco n
Driver de disco
disco x cilindro y Ler bloco no cabea w setor z
Controlador de disco
Aps a solicitao ao controlador o processo pode bloquear ou no. Um processo que foi bloqueado ser acordado por uma interrupo. O processo no ser bloqueado por uma operao de E/S somente se o dispositivo responde muito rpido a uma solicitao (um terminal, por exemplo). Depois de responder a uma solicitao o driver fica bloqueado aguardando uma nova solicitao, a no ser que haja uma outra solicitao enfileirada, caso em que ela passa ser atendida. Os drivers fazem parte do ncleo do sistema operacional. Devido ao alto grau de dependncia entre os drivers e as chamadas de sistema de E/S, os fabricantes desenvolvem, para um mesmo dispositivo, diferentes drivers (um para cada sistema operacional). Sempre que um novo dispositivo adicionado, o driver do dispositivo deve ser incorporado ao sistema.
7.5 Controladores
Os controladores so componentes eletrnicos (hardware) responsveis por manipular diretamente os dispositivos de E/S. Os drivers se comunicam com os dispositivos atravs dos controladores. O controlador costuma possuir memria e registradores prprios para executar instrues enviadas pelo driver. Quando se tem uma arquitetura com E/S mapeada em memria o endereo dos registradores fazem parte do espao de endereamento da memria (por exemplo, processadores 680x0 da Motorola). Outras arquiteturas possuem espao de endereamento especial de E/S, com cada controladora recebendo uma parte deste espao (por exemplo, processadores i386 da Intel). Os controladores fazem uso de interrupes para informar UCP quando esto prontos. Mquinas Pentium, por exemplo, possuem 15 linhas de IRQ (Interrupt Request Requisio de Interrupo), que podem ser configuradas de forma automtica (Plug and Play) ou de forma manual. As IRQs configuradas manualmente podem ser configuradas por hardware (switches ou jumpers) ou por software. Se a controladora for hard-wired no possvel mudar sua IRQ. O controlador de interrupes mapeia o software de servio da interrupo atravs do vetor de interrupes. Na maioria dos dispositivos orientados a bloco implementada a tcnica de DMA (Direct Memory Access Acesso Direto Memria) para transferncia de dados entre o controlador e a memria principal. Alguns controladores implementam tcnicas de cache semelhantes s implementadas pelos sistemas de arquivos, visando melhorar o desempenho. Normalmente o controlador avisa o sistema operacional do trmino de uma operao de gravao quando os dados no buffer do controlador so gravados no disco (write-through). O controlador tambm pode ser configurado para avisar do trmino da gravao quando os dados ainda se encontram no buffer do controlador (write-back), oferecendo ganho de desempenho. Um padro muito popular para a conexo de dispositivos a um computador o SCSI (Small Computer Systems Interface). O SCSI define padres de hardware e software que permitem conectar ao computador qualquer tipo de dispositivo. Para tanto deve-se configurar o sistema operacional com um driver SCSI e o hardware com um controlador SCSI, ao qual os perifricos so conectados. Sistemas Operacionais 81
7.6 Dispositivos de Entrada/Sada

Os dispositivos de E/S so responsveis pela comunicao entre o computador e o mundo externo. A transferncia de dados pode ser feita atravs de blocos de informao ou palavra a palavra, ambas por meio dos controladores dos dispositivos sob a superviso da UCP. Em funo da forma com que os dados so armazenados, os dispositivos de E/S podem ser classificados em duas categorias: dispositivos estruturados e dispositivos no estruturados. Os dispositivos estruturados (dispositivos de bloco) caracterizam-se por armazenar informaes em blocos de tamanho fixo, possuindo cada qual um endereo. Os blocos podem ser lidos ou gravados de forma independente. Os dispositivos estruturados classificam-se ainda em dispositivos de acesso direto e dispositivos de acesso sequencial. Em um dispositivo de acesso direto cada bloco pode ser acessado diretamente atravs de seu endereo, enquanto em um dispositivo de acesso sequencial o dispositivo deve percorrer sequencialmente o meio procura do bloco. Os dispositivos no estruturados (dispositivos de caractere) so aqueles que enviam/recebem uma sequncia de caracteres sem estar estruturada no formato de um bloco. No possvel o acesso ao dado aps a transmisso (os dados no possuem endereo). 7.6.1 Discos de RAM O disco de RAM um driver utilizado para permitir que uma parte da memria seja utilizada como um disco comum. Ele tem a vantagem de ter acesso instantneo, sendo adequado para programas e dados que so acessados frequentemente. O disco de RAM dividido em blocos, cada qual do mesmo tamanho que um bloco de disco. Quando o driver recebe uma solicitao ele calcula onde os dados devem ser lidos/escritos na memria e faz a transferncia. 7.6.2 Disco Rgido Um disco rgido constitudo por vrios discos sobrepostos, unidos por um eixo vertical girando a uma velocidade constante. Cada disco compe-se de trilhas concntricas, que so divididas em setores. As trilhas dos diferentes discos que ocupam a mesma posio vertical formam um cilindro. Para cada superfcie de um disco existe uma cabea de leitura/gravao. O conjunto de cabeas preso a um brao que se movimenta entre os vrios cilindros no sentido radial.
eixo Cabea de leitura/gravao
trilha
setor
brao
Discos modernos tm mais setores nas trilhas exteriores que nas trilhas interiores. O processamento destes detalhes feito pelo hardware da prpria unidade de disco. O tempo necessrio para ler/gravar um bloco de dados funo de trs fatores: tempo de busca, latncia e transferncia. O tempo de busca (seek) o tempo gasto para mover o brao at o cilindro onde o bloco se encontra. O tempo de latncia o tempo de espera at que o setor desejado Sistemas Operacionais 82
se posicione sob a cabea de leitura/gravao. O tempo de transferncia corresponde ao tempo necessrio para ler/gravar o bloco.
Transferncia
Cabea
Busca Latncia
O tempo total das operaes de E/S pode ser extremamente demorado se comparado ao tempo da UCP. Para a maioria dos discos magnticos o tempo de busca o fator de maior impacto no acesso aos dados. Se o driver de disco processa as solicitaes na ordem em que elas chegam (FCFS First Come First Served) no est havendo nenhuma otimizao no sistema. O driver pode manter uma tabela de solicitaes indexada pelo nmero do cilindro para melhorar o algoritmo. Um algoritmo conhecido como busca mais curta primeiro (SSF Shortest Seek First) trata a solicitao mais prxima a seguir, reduzindo o movimento total do brao em comparao com o FCFS. O SSF tem o problema da tendncia do brao permanecer no meio do disco a maior parte do tempo, havendo a possibilidade de solicitaes longe do meio obterem servio deficiente. O algoritmo do elevador resolve este problema movendo o brao sempre na mesma direo at que no haja mais solicitao nesta direo. A utilizao de cache associada com a leitura de mais dados que o solicitado tambm ajuda a melhorar o desempenho. A verificao por redundncia cclica (CRC) gravada junto com o setor para verificao de erros. 7.6.2.1 Arrays de Discos A redundncia pela utilizao de mltiplos discos rgidos (arrays de discos) uma forma muito comum de se aumentar o desempenho e a segurana no armazenamento de dados. O tipo mais comum de implementao de array de disco o RAID (Redundant Array of Inexpensive Drives). O RAID pode ser implementado tanto em software quanto em hardware. A implementao em software mais barata, mas torna o sistema mais lento. Quando implementado em hardware o RAID no s mais rpido, como tambm pode permitir a troca de um dispositivo defeituoso sem a necessidade de desligar o equipamento (o chamado hot swap). O RAID pode ser implementado em 7 nveis diferentes, cada um com um objetivo especfico. O RAID nvel 0 no redundante, consequentemente no deveria se chamar RAID. No nvel 0, os dados so divididos pelos discos, resultando em uma maior vazo. Considerando que nenhuma informao redundante armazenada o desempenho muito bom, mas uma falha de qualquer dos discos resulta na perda dos dados. Este nvel costumeiramente chamado de striping. O RAID nvel 1 prov redundncia escrevendo todos os dados em dois ou mais discos. O desempenho do nvel 1 tende a ser maior na leitura e menor na escrita quando comparado a um sistema com um nico disco, mas se qualquer dos discos falhar, nenhum dado perdido. Este um bom sistema redundante, uma vez que so requeridos somente dois discos. Porm, como um disco
83
usado para armazenar uma cpia dos dados, o custo por megabyte alto. Este nvel costumeiramente chamado de mirroring (espelhamento). O RAID nvel 2, que usa o cdigo de Hamming para correo erros, voltado para uso em discos que no tm deteco de erro embutida. O RAID nvel 3 divide os dados a nvel de byte por vrios discos, com paridade armazenada em um disco. A diviso a nvel de byte requer suporte por hardware para uso eficiente. O RAID nvel 4 divide os dados a nvel de bloco por vrios discos, com paridade armazenada em um disco. A informao de paridade permite a recuperao de falha provocada por falha em qualquer dos discos. O desempenho do nvel 4 muito bom para leitura (semelhante ao nvel 0). Para escrita, entretanto, necessrio que a paridade seja atualizada a todo instante. Isto reduz a velocidade para pequenas escritas randmicas; entretanto, para grandes escritas ou escritas sequenciais, ele bastante rpido. Como somente um disco do array armazena dados redundantes, o custo por megabyte do nvel 4 baixo. O RAID nvel 5 semelhante ao nvel 4, mas distribui a paridade entre os discos. Isto pode acelerar pequenas escritas em sistemas multiprocessados, j que o disco de paridade no se torna um gargalo. Como os dados da paridade precisam ser saltados em cada disco durante a leitura, o desempenho para leitura tende a ser menor que no nvel 4. O custo por megabyte igual ao do nvel 4. O RAID nvel 6 funciona como o RAID nvel 5, porm apresenta o dobro de bits para paridade. Com isto o sistema garante a integridade dos dados mesmo com a perda de dois discos.
possvel tambm a composio de diferentes nveis de RAID: RAID 0+1 uma combinao dos nveis 0 (striping) e 1 (mirroring), onde os dados so divididos entre os discos para melhorar o rendimento, mas tambm utilizam outros discos para duplicar as informaes. Assim, possvel utilizar o bom rendimento do nvel 0 com a redundncia do nvel 1. RAID 1+0 Exige ao menos 4 discos rgidos. Cada par ser espelhado, garantindo redundncia, e os pares sero distribudos, melhorando desempenho. At metade dos discos pode falhar simultaneamente, sem colocar o conjunto a perder, desde que no falhem os dois discos de um espelho qualquer. RAID 50 um arranjo hbrido que usa as tcnicas de RAID com paridade em conjuno com a segmentao de dados. Um arranjo RAID-50 essencialmente um arranjo com as informaes segmentadas atravs de dois ou mais arranjos. RAID 100 basicamente composto do RAID 10+0.
84
7.7 Exerccios
1) Por que a gerncia de dispositivos implementada mediante a utilizao de camadas? 2) Por que a gerncia de dispositivos esconde dos processos dos usurios os detalhes de cada perifrico? 3) Para um hardware de entrada/sada defina: porta barramento controlador 4) Por que a espera em ciclo no um bom mtodo para comunicao da UCP com um controlador? 5) Como a transferncia de dados por DMA? Qual a sua importncia para o sistema? 6) Por que a transferncia de dados por DMA prefervel em relao transferncia de dados individuais com utilizao de interrupes? 7) Como um programa faz para ter acesso s operaes de E/S? 8) Como se d em um sistema de multiprogramao o acesso de processos a dispositivos dedicados, como impressoras, que devem ser acessados com exclusividade pelos processos? 9) Para que serve a bufferizao no subsistema de E/S? 10) Qual a diferena entre uma operao de E/S sncrona e uma operao de E/S assncrona? 11) O que um driver de dispositivo (device driver)? 12) Qual a vantagem da implementao de cache em controladores de dispositivos de E/S? 13) Qual a diferena entre dispositivos de bloco e dispositivos de caractere? Sistemas Operacionais 85
14) Por que o processo de desfragmentao o disco torna o acesso aos arquivos mais rpido? 15) Explique como a utilizao de um RAID pode tornar o sistema mais rpido e seguro.
86
8 Bibliografia
Machado, F. B. & Maia, L. P., Arquitetura de Sistemas Operacionais, 4 a ed, LTC Editora, Rio de Janeiro, 2012. Silberschatz, A. & Galvin, P. B., Sistemas Operacionais Conceitos, 5a ed, Prentice Hall, So Paulo, 2000. Tanenbaum, A. S. & Woodhull, A. S., Sistemas Operacionais Projeto e Implementao, 2a ed, Ed. Bookman, Porto Alegre, 2000. Tanenbaum, A. S., Sistemas Operacionais Modernos, LTC Editora, Rio de Janeiro, 1995. Tanenbaum, A. S., Structured Computer Organization, 3rd ed, Prentice Hall International, 1990. Soares, L. F. G. et alii, Redes de Computadores Das LANs, MANs e WANS s Redes ATM, 2a ed, Ed. Campus, Rio de Janeiro, 1995. Tanenbaum, A. S., Redes de Computadores, 3a ed, Ed. Campus, Rio de Janeiro, 1997.
87

Idioma

Sistemas Operacionais

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

Sistemas Operacionais

Enviado por

Direitos autorais:

Formatos disponíveis

SISTEMAS OPERACIONAIS

3 Comunicao Entre Processos.................................................................................. 27

4 Gerncia do Processador .......................................................................................... 43

5 Gerncia de Memria ............................................................................................... 49

6 Sistema de Arquivos ................................................................................................. 67

7 Gerncia de Dispositivos .......................................................................................... 77

1.3 Mquina de Nveis

Sistema Bancrio Compiladores

Reserva de Passagem Editores

Navegador WEB Shell

Sistema Operacional Linguagem de Mquina Microprograma

1.4 O Sistema Operacional

1.5 Histrico dos Sistemas Operacionais

1.6 Conceitos de Hardware

Unidade Lgica e Aritmtica

Clock Unidade de Controle

Unidade Lgica e Aritmtica

1.7 Conceitos de Software

1.8 Conceitos de Sistema Operacional

Exemplo de um shell simples:

Exemplo de configurao de pipeline entre 2 processos:

Chamadas de sistema para gerenciamento de tempo:

1.9 Tipos de Sistemas Operacionais

1.10 Sistemas Multiprogramveis

Obtm o endereo da rotina de tratamento

1.11 Estrutura do Sistema Operacional

Para proteger o kernel, os usurios solicitam servios atravs de chamadas de sistemas.

Sistema operacional executado no modo kernel

hardware Mquina sem monitor de mquina virtual

hardware Mquina com monitor de mquina virtual

Essa viso d origem ao seguinte modelo:

2.1 Mudana de Contexto

2.2 Subprocesso e Thread

3 processos, com 1 thread cada

1 processo com 3 threads

2.3 Tipos de Processos

2.4 Processos Cooperativos

O cdigo do processo consumidor fica:

3 Comunicao Entre Processos

3.1 Condio de Corrida

3.2 Regio Crtica

3.3 Sincronizao Condicional

3.4 Excluso Mtua por Hardware

3.5 Excluso Mtua por Software com Espera Ativa

3.6 Excluso Mtua por Software sem Espera Ativa

Exemplo de sincronizao condicional com semforos (produtor/consumidor):

3.8 Problemas Clssicos de Comunicao Interprocessos

Uma soluo correta :

4.1 Algoritmos de Escalonamento

4.2 Escalonamento com Mltiplas UCPs

5.1 Atribuio de Endereos

5.2 Carregamento Dinmico

5.3 Alocao Contgua Simples

5.4 Alocao Particionada

Partio onde o programa est sendo executado

5.6 Memria Virtual

1024 entradas para tabela de 2 nvel

pgina 0 pgina 1 1 . . 500 . . . . . pgina 100 n1 n2 p

Tabela de pginas de primeiro nvel

presente/ausente proteo modificada referenciada desabilitar cache

n do segmento deslocamento Tabela de segmentos Memria principal

DESLOCAMENTO + Endereo linear de 32 bits