Apostila de Sistema Operacional

CONTEDO INTRODUO ................................................................................................... 6 FUNCIONALIDADES ......................................................................................... 6 A espinha dorsal do sistema operacional ....................................................... 7 Funes do Sistema Operacional ...................................................................... 8 Gerncia de Processos................................................................................... 8 Gerncia de Memria Principal....................................................................... 9 Gerncia de Arquivos ..................................................................................... 9 Gerncia do Sistema de I/O............................................................................ 9 Gerncia de Armazenamento Secundrio .................................................... 10 Rede ............................................................................................................. 10 Sistemas de Proteo ................................................................................... 10 Interpretador de Comandos do Sistema ....................................................... 11 Objetivos, Mecanismos e Polticas ............................................................... 11 Implementao do Sistema .......................................................................... 12 Configurao do Sistema.............................................................................. 12 EVOLUO HISTRICA ................................................................................. 12 Dcada de 1940 (ausncia de sos) .............................................................. 13 Dcada de 1950 (processamento em batch) ................................................ 13 Dcada de 1960 (processamento time-sharing) ........................................... 14 Dcada de 1970 (multiprocessamento) ........................................................ 14 Dcada de 1980 (computadores pessoais): ................................................. 15 Dcada de 1990 (sistemas distribudos): ...................................................... 15 SERVIOS DO SISTEMA OPERACIONAL ..................................................... 15 O sistema operacional visto como uma mquina estendida ......................... 16 O sistema operacional visto como um gerente de recursos ......................... 16

CHAMADAS DE SISTEMA .............................................................................. 17 GERENCIAMENTO DE ENTRADA E SADA................................................... 18 Subsistema de entrada e sada .................................................................... 20 Dispositivos de entrada e sada .................................................................... 21 Controladores dos dispositivos ..................................................................... 22 Drivers dos dispositivos ................................................................................ 22 GERENCIAMENTO DO PROCESSADOR....................................................... 24 Funes bsicas ........................................................................................... 24 Escalonamento de processos ....................................................................... 25 Estratgias de escalonamento...................................................................... 26 Algoritmos de escalonamento....................................................................... 27
Escalonamento first come first served (fcfs) ou fifo ........................................................... 27 Escalonamento menor job primeiro ou sjf (shortest job first)............................................ 28 Escalonamento prxima taxa de resposta mais alta ou hrrn .............................................. 29 Escalonamento menor tempo remanescente ou srt .......................................................... 29 Escalonamento circular ou round robin (rr) ........................................................................ 30 Escalonamento por prioridades .......................................................................................... 32 Escalonamento por mltiplas filas ...................................................................................... 33 Escalonamento de tempo real ............................................................................................ 34 Escalonamento de tempo real estticos ............................................................................. 35 Escalonamento de tempo real dinmicos ........................................................................... 35

Programao concorrente ............................................................................ 36 Processos concorrentes ............................................................................... 37 Comunicao e sincronizao de processos ................................................ 38 Programas multithreads ................................................................................ 41 Problemas clssicos de sincronizao ......................................................... 41

CONSTRUES CONCORRENTES DE ALTO NVEL .................................. 43 DEADLOCK...................................................................................................... 43 Deadlock de trfego ...................................................................................... 44 Deadlock simples de recursos ...................................................................... 44 Deadlock em sistemas de spooling .............................................................. 44 Adiamento indefinido .................................................................................... 45 PREVENINDO DEADLOCKS........................................................................... 45 Atacando o problema da excluso mtua ..................................................... 45 Atacando o problema da posse e da espera ................................................ 46 Atacando o problema da condio de no-preempo ................................ 46 Atacando o problema da espera circular ...................................................... 46 DETECO E RECUPERAO DE DEADLOCKS ........................................ 47 Recuperao atravs da preempo ............................................................ 47 Recuperao com rollback ........................................................................... 47 Recuperao atravs de eliminao de processos ...................................... 48 GERENCIAMENTO DE MEMRIA .................................................................. 48 ALOCAO CONTGUA SIMPLES ................................................................. 49 POLTICAS BSICAS ...................................................................................... 50 SISTEMAS MONOPROGRAMADOS .............................................................. 50 SISTEMAS MULTIPROGRAMVEIS OU MULTITAREFAS ............................ 51 Sistemas Batch ............................................................................................. 51 Sistemas de Tempo Compartilhado .............................................................. 52 Sistemas de Tempo Real.............................................................................. 53 SISTEMAS COM MLTIPLOS PROCESSADORES ....................................... 53 Sistemas Fortemente Acoplados .................................................................. 54 Sistemas Fracamente Acoplados ................................................................. 55 E que novas formas de gerncia de memria sejam implementadas. ............. 57

PARTIES FIXAS ......................................................................................... 57 PARTIES VARIVEIS ................................................................................. 58 SWAPPING ...................................................................................................... 59 MEMRIA VIRTUAL ........................................................................................ 60 PAGINAO .................................................................................................... 60 Paginao multinvel ..................................................................................... 63 Polticas de busca de pginas ...................................................................... 64 Polticas de alocao de pginas ................................................................. 65 Polticas de substituio de pginas ............................................................. 66 Working set ................................................................................................... 67 Algoritmos de substituio de pginas ......................................................... 69 TIMO .......................................................................................................... 70 FIFO ............................................................................................................. 70 Segunda Chance .......................................................................................... 71 Relgio.......................................................................................................... 71 NUR (Not Recently Used) ............................................................................. 72 LRU (Least Recently Used) .......................................................................... 73 SEGMENTAO ............................................................................................. 75 Segmentao paginada ................................................................................ 77 Gerenciamento de arquivos ............................................................................. 78 SISTEMAS DE ARQUIVOS ............................................................................. 79 DIRETRIOS ................................................................................................... 79 Sistema de Arquivo de nvel nico ................................................................ 80 Sistema de Arquivo estruturado hierarquicamente ....................................... 80 Nomes de caminhos relativos ....................................................................... 81 Bibliografia........................................................................................................ 83

INTRODUO

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

FUNCIONALIDADES

O Sistema Operacional o software que controla todos os recursos do computador e fornece a base sobre a qual os programas aplicativos so escritos.

No nvel mais simples, o sistema operacional realiza duas tarefas: 1. Gerencia os recursos de hardware e software do sistema. Em um computador de mesa, esses recursos incluem o processador, a memria, o espao em disco etc. Em um telefone celular, o sistema operacional gerencia o teclado, a tela, a agenda, a bateria e a conexo de rede;

2. Proporciona uma maneira estvel e consistente para lidar com o hardware, sem ter de conhecer todos os detalhes do hardware. A primeira tarefa, ou seja, o gerenciamento de recursos de software e hardware uma tarefa extremamente importante. Diversos programas e mtodos de entrada de dados competem pela ateno da CPU (Unidade Central de Processamento) e demandam memria, espao em disco e largura de banda de entrada/sada. O sistema operacional faz o papel do bom pai. Ele cuida para que cada aplicativo tenha os recursos necessrios para o funcionamento e gerencia a capacidade limitada do sistema para atender a todos os usurios e aplicativos. A segunda tarefa fornecer uma interface consistente para os aplicativos. A interface especialmente importante se mais de um tipo de computador utiliza o sistema operacional ou se o hardware do computador constantemente atualizado. Uma API (Application Program Interface - Interface de Programao de Aplicativos) permite que o desenvolvedor do software escreva um programa em um computador e tenha um alto nvel de segurana de que este aplicativo vai rodar em outro computador do mesmo tipo, mesmo que a quantidade de memria e a rea de armazenamento sejam diferentes. Mesmo que um computador seja nico, um sistema operacional assegura que os aplicativos continuem funcionando aps as atualizaes de hardware. Isso acontece porque o sistema operacional, e no o aplicativo, que gerencia o hardware e a distribuio dos seus recursos. Um dos desafios do desenvolvedor de sistemas operacionais criar um sistema flexvel o suficiente para reconhecer hardwares de milhares de fabricantes diferentes. Os sistemas atuais podem acomodar milhares de impressoras, Drivers e perifricos especiais em qualquer combinao possvel. A espinha dorsal do sistema operacional

Nem todos os computadores tm sistemas operacionais. O computador que controla o forno de microondas da sua cozinha, por exemplo, no precisa de um. Um forno de microondas realiza um conjunto bastante especfico de tarefas e as informaes de entrada so bastante simples (um teclado numrico e alguns botes com aes pr-definidas). O hardware tambm

simples e nunca muda. Para um computador como esse, um sistema operacional seria completamente desnecessrio. Isso aumentaria os custos de desenvolvimento e produo e complicaria um processo que bastante simples. O computador de um forno de microondas sempre executa o mesmo programa codificado por hardware. Em outros dispositivos, o sistema operacional cria a possibilidade de: realizar uma variedade de tarefas; interagir com os usurios de forma complexa; acompanhar as necessidades que mudam com o tempo. Todos os computadores de mesa tm sistemas operacionais. Os mais comuns so os da famlia Windows, da Microsoft, o OS X, sistema operacional do Macintosh desenvolvido pela Apple, o Linux, sistema operacional desenvolvido por Linus Torvalds e pela comunidade de desenvolvedores de software open source. A famlia UNIX de sistemas operacionais (que foram desenvolvidos por uma srie de pessoas, empresas e colaboradores). Existem ainda centenas de outros sistemas operacionais desenvolvidos para aplicaes especficas como mainframes, robtica, manufatura, sistemas de controle em tempo real e etc.

FUNES DO SISTEMA OPERACIONAL Gerncia de Processos Gerncia de Memria Principal Gerncia de Arquivos Gerncia do Sistema de I/O Gerncia de Armazenamento Secundrio Rede Sistema de Proteo Interpretador de Comandos do Sistema Gerncia de Processos Processo um programa em execuo e necessita de certos recursos, como tempo de CPU, memria, arquivos e dispositivos de I/O, para completar sua tarefa. Responsabilidades do Sistema Operacional:

o o o o o

criar e destruir processos do usurio e do sistema; suspender e reativar processos; fornecer mecanismos para a comunicao entre processos; fornecer mecanismos para a sincronizao entre processos; fornecer mecanismos para o tratamento de deadlocks (impasses).

Gerncia de Memria Principal A memria principal um armazenador de acesso rpido e compartilhvel entre a CPU e os dispositivos de I/O, alm de ser voltil, ou seja, perder seu contedo em caso de falhas no sistema. Responsabilidades do Sistema Operacional: o conhecer quais partes da memria esto sendo usadas e por quem; o decidir quais processos sero carregados quando o espao da memria torna-se disponvel; o alocar e liberar espao da memria quando for necessrio. Gerncia de Arquivos Um arquivo uma coleo de informaes definidas pelo seu criador. Normalmente representa programas (fonte, objeto e executvel) ou dados. Responsabilidades do Sistema Operacional: o o o o o criar e remover arquivos; criar e remover diretrios; disponibilizar primitivas para manipulao de arquivos e diretrios; mapear os arquivos no dispositivo de armazenamento secundrio; copiar arquivos entre dispositivos de armazenamento no volteis.

Gerncia do Sistema de I/O Ocultar as peculiaridades de dispositivos de hardware especficos do usurio. O subsistema de I/O consiste em:

o o o o

buffering, caching e spooling; interface geral de driver de dispositivo (device-driver); drivers para dispositivos de hardware especficos. apenas o driver de dispositivo conhece as peculiaridades do dispositivo especfico ao qual foi atribudo.

Gerncia de Armazenamento Secundrio A memria principal (armazenamento primrio) voltil e muito pequena para armazenar todos os dados e programas permanentemente, portanto, o sistema computacional deve fornecer armazenamento secundrio para auxiliar a memria principal. Responsabilidades do Sistema Operacional: o gerenciamento de espao livre; o alocao de armazenamento; o escalonamento de disco (ordenao e seleo das operaes p/ o uso de discos). Rede Coleo de computadores compartilhando recursos. Cada computador tem seu prprio processador, memria e clock, alm do sistema operacional. Os computadores so interligados atravs de um sub-sistema comunicao e utilizam protocolos para viabilizar a comunicao. Acesso aos recursos compartilhados permitem: speed-up computacional (aumento na velocidade de processamento); aumentar a disponibilidade dos dados; aumentar a confiabilidade. Sistemas de Proteo Proteo refere-se a qualquer mecanismo para controlar o acesso de programas, processos ou usurios aos recursos do sistema ou de outros usurios. de

10

O mecanismo de proteo deve: distinguir entre uso autorizado e no autorizado; especificar o tipo de controle a ser utilizado; fornecer os meios para viabilizar estes controles. Interpretador de Comandos do Sistema Os comandos so enviados ao sistema operacional atravs de uma interface caractere ou orientada a mouse (grfica). Comandos ORIENTADOS A TECLADO x ORIENTADOS A MOUSE Outros nomes: SHELL (casca do sistema), prompt do sistema, console texto, interpretador de linha de comando Os comandos interagem com: o gerenciamento de processos; manipulao de I/O; gerenciamento de armazenamento secundrio; gerenciamento de memria principal; proteo; acesso arquivos do sistema; rede. Objetivos, Mecanismos e Polticas Objetivos do Usurio: O sistema operacional deve ser conveniente para o uso, fcil de aprender, confivel, seguro e rpido. Objetivos do Sistema: O sistema operacional deve ser fcil de projetar, implementar e manter, assim como ser flexvel, confivel, livre de erros e eficiente. Os mecanismos determinam como tudo dever se feito e as polticas determinam o que dever ser feito.

11

 A separao das polticas dos mecanismos um princpio importante. Ela permite a maximizao da flexibilidade caso mudanas nas polticas venham a ocorrer.

Implementao do Sistema Os sistemas operacionais atuais so escritos utilizando-se linguagens de alto nvel. Vantagens: rapidez na escrita do cdigo; mais compacta; facilidade de desenvolvimento e debug; portabilidade. Configurao do Sistema Os sistemas operacionais podem ser gerados levando em considerao a plataforma destino. Tipo de CPU Quantidade de memria Dispositivos presentes Tipo de escalonamento/uso do sistema (Servidor/Desktop) Etc.. Ex.: Linux foi portado para vrias plataformas O processo de configurao/compilao determina qual a plataforma que o sistema vai ser executado

EVOLUO HISTRICA A evoluo dos Sistemas Operacionais est intimamente relacionada com o desenvolvimento dos computadores. Objetivando permitir um conhecimento

12

geral, o histrico dos Sistemas Operacionais aqui apresentados ser dividido em dcadas. Em cada uma das dcadas sero discutidas as principais caractersticas do hardware e do Sistema Operacional da poca.

Dcada de 1940 (ausncia de S.Os) A Segunda Guerra Mundial acelerou as pesquisas para o desenvolvimento dos primeiros computadores (Mark I, ENIAC etc.), objetivando dinamizar o processo de realizao de clculos. Os computadores, ento desenvolvidos, eram baseados em vlvulas. Eles ocupavam salas inteiras e no possuam um SO. Com isso, programar, por exemplo, o ENIAC para realizar um determinado clculo poderia levar dias, pois era necessrio conhecer profundamente o funcionamento de seu hardware e utilizar linguagem de mquina.

Dcada de 1950 (processamento em batch) O desenvolvimento do transistor permitiu um grande avano da informtica. Assim, os computadores tornaram-se menores, mais confiveis e mais rpidos. Nesta dcada observa-se o surgimento dos primeiros S.Os e a programao das mquinas se dava atravs de cartes perfurados. Os processos a serem executados entravam seqencialmente no processador e rodavam at terminar. Este tipo de processamento ficou conhecido como processamento em batch ou lote, o qual ilustrado pela figura abaixo:

Pode no parecer um avano, mas anteriormente os programas eram submetidos pelo operador, um a um, fazendo com que o processador ficasse ocioso entre a execuo de um job e outro. Com o processamento batch, um

13

conjunto de programas era submetido de uma vez s, o que diminua o tempo de espera entre a execuo dos programas, permitindo, assim, melhor aproveitamento do processador.

Dcada de 1960 (processamento time-sharing) Nesta dcada entram em cena os circuitos integrados (C.Is), o que permitiu que os computadores se tornassem mais baratos e, portanto, mais acessveis s organizaes empresariais. Na poca em questo os processos no mais monopolizavam o uso do processador, mas sim compartilhavam o mesmo. Dessa forma, o tempo de processamento passou a ser igualmente dividido entre os processos existentes. Esta tcnica de processamento acabou ficando conhecida como processamento time-sharing ou processamento de tempo compartilhado.

Dcada de 1970 (multiprocessamento) Nesta dcada a integrao em larga escala (Large Scale Integration LSI) e a integrao em muito grande escala (Very Large Scale Integration - VLSI) permitiram uma reduo significativa no tamanho e no custo dos

computadores. Com isso, os computadores com mltiplos processadores tornaram-se acessveis e os processos passaram a ser executados em paralelo. Este tipo de processamento ficou conhecido como

multiprocessamento, o qual ilustrado pela figura abaixo:

14

Dcada de 1980 (computadores pessoais): Os computadores pessoais tornam-se mais acessveis comercialmente e a microcomputao se consolidou. Assim, surgiram os S.Os voltados

especificamente para os ento chamados microcomputadores (ex.: CP/M, MSDOS, OS/2 etc.). interessante destacar que neste perodo a rpida evoluo dos processadores dos computadores pessoais permitiu que seus S.Os incorporassem importantes recursos como interface grfica e multimdia. O baixo custo dos equipamentos permitiu, tambm, o surgimento das redes locais e com isso desenvolveram-se os Sistemas Operacionais de Rede (ex.: Novell Netware, LAN Manager etc.);

Dcada de 1990 (sistemas distribudos): Durante a dcada de 1990 o crescimento das redes de computadores, especialmente a Internet, propiciou o surgimento de sistemas computacionais novos que se caracterizam por possurem uma coleo de processadores que no compartilham memria ou barramento e que se comunicam via rede. Estes sistemas acabaram sendo chamados de sistemas fracamente acoplados que possibilitaram o surgimento dos sistemas distribudos, onde diversos SOs presentes nos computadores de uma rede interagem o suficiente para dar a impresso de que existe um nico Sistema Operacional controlando toda a rede e os recursos computacionais ligados a ela. Atualmente, os pesquisadores da rea de Sistemas Operacionais concentram boa parte de seus esforos nos estudos sobre os Sistemas Operacionais Distribudos.

SERVIOS DO SISTEMA OPERACIONAL Execuo de programas Operaes de I/O Manipulao do Sistema de Arquivos Comunicaes Deteco de Erros Alocao de Recursos Contabilizao

15

 Proteo O Sistema Operacional o software que controla todos os recursos do computador e fornece a base sobre a qual os programas aplicativos so escritos e suas principais funcionalidades so: Mquina Virtual ou Estendida e Gerente de Recursos.

O sistema operacional visto como uma mquina estendida Programar em nvel de arquitetura uma tarefa ingrata para qualquer usurio de um sistema de computador. Para tratar da entrada/sada numa unidade de disco flexvel, por exemplo, o usurio deveria trabalhar com comandos relativos a: leitura/escrita de dados, movimento da cabea, formatao de trilhas e inicializao, sensoriamento, reinicializao e calibrao do controlador e do drive de disquete. bvio dizer que o programador no vai querer lidar com esse tipo de detalhes, desejando, portanto uma abstrao de alto nvel. Assim, deve haver um programa que esconda do usurio o verdadeiro hardware e apresente-lhe um esquema simples de arquivos identificados que possam ser lidos ou escritos. Tal programa o sistema operacional. Do ponto de vista de mquina estendida, o sistema operacional trata ainda de outras questes incmodas como: interrupes, temporizadores, gerncia de memria etc. A funo do sistema operacional, nesse ponto de vista, apresentar ao usurio uma mquina virtual equivalente ao hardware, porm muito mais fcil de programar.

O sistema operacional visto como um gerente de recursos Em sistemas onde diversos usurios compartilham recursos do sistema computacional, necessrio controlar o uso concorrente desses recursos. Se imaginarmos uma impressora sendo compartilhada, dever existir algum tipo de controle para que a impresso de um usurio no interfira nas dos demais. Novamente o sistema operacional que tem a responsabilidade de permitir o

16

acesso concorrente a esse e a outros recursos de forma organizada e protegida. No apenas em sistemas multiusurio que o sistema operacional importante. Se pensarmos que um computador pessoal nos permite executar diversas tarefas ao mesmo tempo, como imprimir um documento, copiar um arquivo pela Internet ou processar uma planilha, o sistema operacional deve ser capaz de controlar a execuo concorrente de todas essas atividades. Assim, o sistema operacional deve gerenciar o uso dos recursos,

contabilizando o uso de cada um e garantindo acesso ordenado de usurios a recursos atravs da mediao de conflitos entre as diversas requisies existentes.

CHAMADAS DE SISTEMA Os programas solicitam servios ao sistema operacional atravs das chamadas de sistema. Elas so semelhantes s chamadas de sub-rotinas. Entretanto, enquanto as chamadas de sub-rotinas so transferncias para procedimentos normais do programa, as chamadas de sistema transferem a execuo para o sistema operacional. Atravs de parmetros, o programa informa exatamente o que necessita. O retorno da chamada de sistema, assim como o retorno de uma sub-rotina, faz com que a execuo do programa seja retomada a partir da instruo que segue a chamada. Para o programador assembly (exemplo de cdigo assemby no anexo A), as chamadas de sistema so bastante visveis. Em uma linguagem de alto nvel, elas ficam escondidas dentro da biblioteca utilizada pelo compilador. O programador chama subrotinas de uma biblioteca. So as sub-rotinas da biblioteca que chamam o sistema. Por exemplo, qualquer funo da biblioteca que acesso o terminal (como printf na linguagem C) exige uma chamada de sistema. Como foi exposto antes, o acesso aos perifricos feito, normalmente, pelo sistema operacional. A lista de servios do sistema operacional agora transformada em uma lista de chamadas de sistema. A descrio dessas chamadas forma um dos mais importantes manuais de um sistema operacional. Por exemplo, considere um programa que lista o contedo de um arquivo texto na tela do terminal. Ele faz

17

uma chamada de sistema para verificar se o arquivo a ser listado existe. Um dos parmetros dessa chamada ser provavelmente o nome do arquivo. O restante do programa um lao no qual so feitas sucessivas leituras do arquivo e escritas no terminal. Essas duas operaes tambm correspondem a chamadas de sistema. A parte do sistema operacional responsvel por implementar as chamadas de sistema normalmente chamada de ncleo ou kernel. Os principais componentes do kernel de qualquer sistema operacional so a gerncia do processador, a gerncia de memria, o sistema de arquivos e a gerncia de entrada e sada. Cada um desses componentes ser visto detalhadamente. Em funo da complexidade interna de um kernel completo, muitos sistemas operacionais so implementados em camadas. Primeiro, um pequeno componente de software chamado microncleo ou microkernel implementa os servios mais bsicos associados com sistemas operacionais. Em cima do microkernel, usando os seus servios, o kernel propriamente dito implementa os demais servios. A figura abaixo ilustra um sistema no qual, acima do hardware, existe um microkernel que oferece servios bsicos tais como gerncia do processador, alocao e liberao de memria fsica e instalao de novos tratadores de dispositivos. O kernel do sistema oferece servios tais como sistema de arquivos, memria virtual e protocolos de comunicao. Alguns sistemas permitem que as aplicaes acessem tanto as chamadas de sistema suportadas pelo kernel quanto os servios oferecidos pelo microkernel. Entretanto, na maioria das vezes, apenas o cdigo do kernel pode acessar os servios do microkernel, enquanto aplicaes ficam restritas s chamadas de sistema do kernel.

GERENCIAMENTO DE ENTRADA E SADA O Sistema Operacional deve tornar as operaes de E/S o mais simples possvel para o usurio e suas aplicaes. Para isso, o sistema possui um

18

conjunto de rotinas, denominado rotinas de entrada/sada, que faz parte do subsistema de E/S e permite ao usurio realizar operaes de E/S sem se preocupar com detalhes do dispositivo que est sendo acessado. Nesse caso, quando um usurio cria um arquivo em disco, no lhe interessa como a formatao do disco, nem em que trilha ou setor o arquivo ser gravado.

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

19

Subsistema de entrada e sada O subsistema de E/S responsvel por realizar as funes comuns a todos os tipos de dispositivos. a parte do Sistema Operacional que oferece uma interface uniforme com as camadas superiores. Independncia de Dispositivos: Cada dispositivo trabalha com unidades de informao de tamanhos diferentes, como caracteres ou blocos. O subsistema de E/S responsvel por criar uma unidade lgica de transferncia do dispositivo e repass-la para os nveis superiores, sem o conhecimento do contedo da informao. Tratamento de Erros: Normalmente, o tratamento de erros nas operaes de E/S realizado pelas camadas mais prximas ao hardware. Existem, porm, certos erros que podem ser tratados e reportados de maneira uniforme pelo sistema de arquivos, independentemente do dispositivo. Erros como a gravao em dispositivos de entrada, leitura em dispositivos de sada e operaes em dispositivos inexistentes podem ser tratados nesse nvel. Compartilhamento: Todos os dispositivos de E/S so controlados, com o objetivo de obter o maior compartilhamento possvel entre os diversos usurios de forma segura e confivel. Alguns dispositivos podem ser compartilhados simultaneamente, outros, como a impressora, devem ter acesso exclusivo, e o sistema deve controlar seu compartilhamento de forma organizada. responsvel tambm por implementar todo um mecanismo de proteo de acesso aos dispositivos. No momento que o usurio realiza uma operao de E/S, verificado se o seu processo possui permisso para realizar a operao. Bufferizao: Essa tcnica permite reduzir o nmero de operaes de E/S, utilizando uma rea de memria intermediria chamada de buffer. Por exemplo, quando um dado lido do disco, o sistema traz para a rea de buffer no s o dado solicitado, mas um bloco de dados. Caso haja uma solicitao de leitura de um novo dado que pertena ao bloco anteriormente lido, no existe a necessidade de uma nova operao de E/S, melhorando desta forma a eficincia do sistema.

20

Interface Padronizada: O subsistema de E/S deve oferecer uma interface padronizada que permita a incluso de novos drivers sem a necessidade de alterao da camada de subsistema de E/S.

Dispositivos de entrada e sada So utilizados para permitir a comunicao entre o sistema computacional e o mundo externo. A transferncia de dados pode ocorrer atravs de blocos de informao ou caracteres, por meio dos controladores dos dispositivos. Em funo da forma com que os dados so armazenados, os dispositivos de E/S podem ser classificados em duas categorias: estruturados e no-estruturados. Os dispositivos estruturados (block devices) caracterizam-se por armazenar informaes em blocos de tamanho fixo, possuindo cada qual um endereo que pode ser lido ou gravado de forma independente dos demais. Discos magnticos e pticos so exemplos. Os dispositivos estruturados classificam-se em dispositivos de acesso direto e seqencial, em funo da forma com que os blocos so acessados. Acesso direto quando um bloco pode ser recuperado diretamente atravs de um endereo, como por exemplo, o disco magntico. Acesso seqencial quando, para se acessar um bloco, o dispositivo deve percorrer

sequencialmente os demais blocos at encontr-lo. A fita magntica um bom exemplo. Os dispositivos no-estruturados (character devices) so aqueles que enviam ou recebem uma seqncia de caracteres sem estar estruturada no formato de um bloco. A seqncia de caracteres no enderevel, no permitindo operaes de acesso direto ao dado. Terminais, impressoras e interfaces de rede so exemplos de tais dispositivos.

21

Controladores dos dispositivos So componentes de hardware responsveis por manipular diretamente os dispositivos de E/S. Possuem memria e registradores prprios utilizados na execuo de instrues enviadas pelo driver. Em operaes de leitura, o controlador deve armazenar em seu buffer interno uma seqncia de bits proveniente do dispositivo at formar um bloco. Aps verificar a ocorrncia de erros, o bloco pode ser transferido para um buffer de E/S na memria principal. A transferncia do bloco pode ser realizado pela UCP ou por um controlador de DMA (Acesso Direto Memria). O uso da tcnica de DMA evita que o processador fique ocupado com a transferncia do bloco para a memria. De forma simplificada, uma operao de leitura em disco utilizando DMA teria os seguintes passos: 1. A UCP, atravs do driver, inicializa os registradores do controlador de DMA e, a partir desse ponto, fica livre para realizar outras atividades. 2. O controlador de DMA solicita ao controlador de disco a transferncia do bloco do disco para o seu buffer interno. 3. Terminada a transferncia, o controlador de disco verifica a existncia de erros. 4. Caso no haja erros, o controlador de DMA transfere o bloco para o buffer de E/S na memria principal. 5) Ao trmino da transferncia, o controlador de DMA gera uma interrupo avisando ao processador que o dado j se encontra na memria principal.

Drivers dos dispositivos Os drivers tratam de aspectos particulares dos dispositivos. Recebem comandos gerais sobre acessos aos dispositivos e traduzem para comandos especficos, que podero ser executados pelos controladores. Alm disso, o driver pode realizar outras funes, como a inicializao do dispositivo e seu gerenciamento. Por exemplo, na leitura sncrona de um dado em disco, o driver recebe a solicitao de um determinado bloco e informa ao controlador o disco, cilindro,

22

trilha e setor que o bloco se localiza, iniciando, dessa forma, a operao. Enquanto se realiza a leitura, o processo que solicitou a operao colocado no estado de espera at que o controlador avise a UCP do trmino da operao atravs de uma interrupo que, por sua vez, ativa novamente o driver. Aps verificar a inexistncia de erros, o driver transfere as informaes para a camada superior. Com os dados disponveis, o processo pode ser retirado do estado de espera e retornar ao estado de pronto para continuar seu processamento. Os drivers fazem parte do ncleo do Sistema Operacional, sendo escritos geralmente em assembly. Devido ao alto grau de dependncia entre os drivers e o restante do ncleo do SO, os fabricantes desenvolvem, para um mesmo dispositivo, diferentes drivers, um para cada Sistema Operacional. Sempre que um novo dispositivo instalado, o driver deve ser adicionado ao ncleo do sistema. Nos sistemas mais antigos, a incluso de um novo driver significava a recompilao do kernel, uma operao complexa e que exigia a reinicializao do sistema. Atualmente, alguns sistemas permitem a fcil instalao de novos drivers sem a necessidade de reinicializao.

23

GERENCIAMENTO DO PROCESSADOR Nos Sistemas Operacionais Multiprogramados, sempre que o processador fica sem utilizao, ocorre o acionamento do Gerente de Processos ou Escalonador de Processos que tem como principal funo selecionar o processo que deve ocupar o processador. Dessa maneira, o trabalho do Escalonador de Processos pode permitir que o computador se torne mais produtivo atravs da otimizao do uso do processador. Assim sendo, o escalonamento de processos constitui a base dos Sistemas Operacionais Multiprogramadados e, portanto, faz-se importante conhecer suas principais caractersticas, bem como os algoritmos de escalonamento mais utilizados.

Funes bsicas

A poltica de escalonamento de um Sistema Operacional possui diversas funes bsicas, como a de manter o processador ocupado a maior parte do tempo, balancear o uso da CPU entre processos, privilegiar a execuo de aplicaes crticas, maximizar o throughput do sistema e oferecer tempos de resposta razoveis para usurios interativos. Cada Sistema Operacional possui sua poltica de escalonamento adequada ao seu propsito e s suas

24

caractersticas. Sistemas de tempo compartilhado, por exemplo, possuem requisitos de escalonamento distintos dos sistemas de tempo real. A rotina do Sistema Operacional que tem como principal funo implementar os critrios da poltica de escalonamento chamada escalonador (scheduler). Em um sistema multiprogramvel, o escalonador fundamental, pois todo o compartilhamento do processador dependente dessa rotina. Outra rotina importante na gerncia do processador conhecida como despachante (dispatcher), responsvel pela troca de contexto dos processos aps o escalonador determinar qual processo deve fazer uso do processador. O perodo de tempo gasto na substituio de um processo em execuo por outro denominado latncia do despachante.

Escalonamento de processos As caractersticas de cada Sistema Operacional determinam quais so os principais aspectos para a implementao de uma poltica de escalonamento adequada. Por exemplo, sistemas de tempo compartilhado exigem que o escalonamento trate todos os processos de forma igual, evitando assim, a ocorrncia de starvation(ficar muito tempo sem receber a CPU). J em sistemas de tempo real, o escalonamento deve priorizar a execuo de processos crticos em detrimento da execuo de outros processos. a) Utilizao do processador: o processador deve permanecer ocupado o mximo de tempo possvel. Deve ser frisado que quando o sistema computacional trabalha com uma taxa de utilizao do processador por volta de 30%, ele considerado um sistema com carga baixa de processamento. Porm, quando o mesmo trabalha com uma taxa na faixa de 90%, ele considerado um sistema computacional bastante carregado; b) Throughput ou vazo: representa o nmero mximo de processos executados em um determinado intervalo de tempo o nmero de processos que so executados em uma determinada frao de tempo, geralmente uma hora, deve ser elevado ao mximo. c) Tempo de processador ou Tempo de CPU: o tempo que o processo leva no estado de execuo durante seu processamento. As polticas de

25

escalonamento no influenciam o tempo de processador de um processo, sendo este tempo funo apenas do cdigo da aplicao e da entrada de dados. d) Tempo de espera: o tempo total que um processo permanece na fila de pronto durante seu processamento, aguardando para ser executado. A reduo do tempo de espera dos processos desejada pela maioria das polticas de escalonamento. e) Tempo de retorno (turnaround): o tempo que um processo leva desde sua criao at o seu trmino, considerando-se o tempo gasto na alocao de memria, na fila de processos prontos, nas operaes de entrada/sada e, ainda, o seu tempo de processamento.Deve ser o menor possvel; f) Tempo de resposta: o tempo decorrido entre uma requisio ao sistema ou aplicao e o instante em que a resposta exibida. Em sistemas interativos, podemos entender como o tempo decorrido entre a ltima tecla digitada pelo usurio e o incio da exibio do resultado no monitor. Em geral, o tempo de resposta no limitado pela capacidade de processamento do sistema computacional, mas pela velocidade dos dispositivos de E/S. De uma maneira geral, qualquer poltica de escalonamento busca otimizar a utilizao do processador e a vazo, enquanto tenta diminuir os tempos de retorno, espera e resposta. Apesar disso, as funes que uma poltica de escalonamento deve possuir so muitas vezes conflitantes. Dependendo do tipo de Sistema Operacional, um critrio pode ter maior importncia do que outros, como nos sistemas interativos onde o tempo de resposta tem grande relevncia.

Estratgias de escalonamento

As estratgias de escalonamento de processos so definidas em funo da atividade de preempo, a qual consiste na capacidade de permitir a interrupo da execuo de um processo para executar um outro, sem prejuzo lgica de execuo de ambos. As estratgias de escalonamento so duas:

26

a) Escalonamento no-preemptivo: com esta estratgia um processo que entra no processador roda at terminar, sem jamais ser interrompido. Este foi o primeiro tipo de escalonamento desenvolvido e foi utilizado nos SOs de processamento em batch; b) Escalonamento preemptivo: esta estratgia baseada na atividade de preempo, ou seja, permite a suspenso temporria da execuo de um processo para outro rodar, sem prejuzo lgico de execuo a ambos. A maioria dos SOs da atualidade utiliza esta estratgia de escalonamento.

Algoritmos de escalonamento Escalonamento first come first served (fcfs) ou fifo Neste algoritmo os processos so organizados em uma fila por ordem de chegada e toda vez que for necessrio escalonar um processo para rodar, o Gerente de Processos seleciona o primeiro da fila. Os processos que forem chegando para serem executados so colocados no final da fila, conforme ilustrado pela Figura anterior. A prxima Figura apresenta um exemplo de utilizao do algoritmo FIFO. Nela possvel observar a existncia de trs processos a serem executados, obedecendo ordem de chegada de cada um, e, ainda, os seus respectivos tempos estimados e finais de execuo.

27

A principal vantagem de utilizao do FIFO a sua simplicidade de implementao, haja visto que o Gerente de Processos necessita apenas manter uma fila de processos e escalonar para rodar um aps o outro. Contudo, o algoritmo em questo apresenta algumas deficincias e a mais importante delas a impossibilidade de se saber ao certo qual o tempo de turnaround (que o tempo transcorrido desde o momento em que o software entra e o instante em que termina sua execuo; tempo de resposta: intervalo entre a chegada ao sistema e inicio de sua execuo; tempo de espera: soma dos perodos em que o programa estava no seu estado pronto) de um processo. Um outro problema existente que o FIFO um algoritmo no preemptivo (So algoritmos que permitem que um processo seja interrompido durante sua execuo, quer seja por fora de uma interrupo de entrada/sada, quer seja em decorrncia da politica de escalonamento adotada e aplicada por parte do escalonador de processos ou simplesmente por fora do trmino da execuo do processo. Aps a interrupo deste processo, ocorre o que se chama de troca de contexto, que consiste em salvar o contedo dos registradores e a memoria utilizada pelo processo e conceder outro processo o privilgio de executar na CPU, restaurando assim o contexto deste ultimo processo) e, portanto, a sua aplicao em sistemas

computacionais que possuam muitos processos de usurios interativos, como os da atualidade, considerada ineficiente. Escalonamento menor job primeiro ou sjf (shortest job first) O algoritmo de escalonamento do menor trabalho primeiro (Shortest Job First SJF) possui uma poltica que estabelece, conforme evidenciado na Figura abaixo, que o processo com menor tempo estimado de execuo aquele que deve rodar primeiro. Assim sendo, este algoritmo parte do pressuposto que o tempo de execuo de cada processo conhecido. Na sua concepo inicial, o escalonamento SJF no preemptivo. Sua vantagem sobre o escalonamento FIFO est na reduo do tempo mdio de retorno dos processos, porm no SJF possvel haver starvation (inanio) para processos com tempo de processador muito longo ou do tipo CPU-bound.

28

A principal vantagem do algoritmo em questo que ele privilegia processos de usurios interativos. Assim, estes usurios podem, por exemplo, conseguir obter respostas rpidas aos seus comandos. J sua desvantagem principal que, normalmente, no se conhece, a priori, o tempo que um processo ir ocupar o processador e este fato dificulta a implementao do SJF em sua forma original. Escalonamento prxima taxa de resposta mais alta ou hrrn Esse algoritmo corrige algumas das deficincias do SJF, particularmente o adiamento indefinido contra processos mais longos e o favoritismo excessivo em relao a processos curtos. O HRRN (Highest Response Ratio Next) usa uma disciplina de escalonamento no preemptiva na qual a prioridade de cada processo uma funo no apenas do seu tempo de execuo, mas tambm do seu tempo de espera. HRRN calcula prioridades dinmicas segundo a frmula apresentada posteriormente. Como o Tempo de CPU aparece no denominador, processos mais curtos recebem preferncia. Entretanto, porque o Tempo de Espera aparece no numerador, processos mais longos que esto espera tambm recebero tratamento favorvel. Quanto maior a razo, maior a prioridade.

Escalonamento menor tempo remanescente ou srt Uma implementao do escalonamento SJF com preempo conhecida escalonamento de menor tempo remanescente ou SRT (Shortest Remaining Time). Nessa poltica, toda vez que um processo no estado de pronto tem um tempo de processador estimado menor do que o processo em execuo, o Sistema Operacional realiza uma preempo, substituindo-o pelo novo processo.

29

O algoritmo deve manter informaes sobre o tempo que est sendo gasto no servio do processo em execuo e realizar preempes ocasionais. Processos que acabaram de chegar cujos tempos de execuo so curtos executam quase imediatamente. Todavia, o tempo mdio de espera e a varincia dos tempos de espera dos processos mais longos so ainda maiores do que no SJF.

Escalonamento circular ou round robin (rr) um escalonamento do tipo preemptivo, projetado especialmente para sistemas de tempo compartilhado. Neste algoritmo, a cada processo atribui-se um intervalo de tempo, chamado de fatia de tempo (time-slice) ou quantum, durante o qual ele poder usar o processador. No escalonamento circular, toda vez que um processo escalonado para execuo, uma nova fatia de tempo concedida. Caso a fatia de tempo expire, o Sistema Operacional interrompe o processo em execuo, salva seu contexto e direciona-o para o final da fila de pronto. Este mecanismo conhecido como preempo por tempo. Objetivando facilitar a compreenso do funcionamento do Round-Robin, a Figura a seguir apresenta um exemplo de utilizao do mesmo.

30

O Round-Robin apresenta como vantagens principais a sua simplicidade de implementao e, ainda, o fato de no permitir que processos monopolizem o processador. J a sua desvantagem mais evidente que ele no faz distino entre a prioridade dos processos. Assim sendo, um processo de tempo-real vai competir pelo processador em condies de igualdade com um processo que seja um jogo de entretenimento, por exemplo. Outra desvantagem a dificuldade de se definir o tamanho do quantum, pois se este for muito pequeno, ocorrero sucessivas trocas de contexto, baixando a eficincia do sistema operacional. Por outro lado, se o quantum for muito grande, os usurios interativos ficaro insatisfeitos. Obs.: O valor do quantum depende do projeto de cada sistema operacional e, geralmente, ele se encontra entre 10 e 100 milissegundos.

31

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

O escalonamento com prioridades apresenta como principal ponto positivo o fato de permitir a diferenciao dos processos segundo critrios de importncia. Este fato torna-se bastante relevante quando se considera o projeto de um Sistema Operacional de Tempo Real, por exemplo. A desvantagem de utilizao do algoritmo em estudo a possibilidade de os processos de baixa prioridade nunca serem escalonados, caracterizando uma

32

situao conhecida como starvation (adiamento indefinido). Contudo, esta desvantagem pode ser superada atravs do uso da tcnica de aging (envelhecimento), a qual consiste em incrementar gradativamente a prioridade dos processos que ficam muito tempo sem rodar. Escalonamento por mltiplas filas Este algoritmo preemptivo, como o prprio nome sugere, considera a existncia de vrias filas de processos no estado de pronto, cada uma delas com sua prioridade de execuo e seu algoritmo de escalonamento. Os processos so associados s filas em funo de caractersticas particulares como, por exemplo, tipo de processo, rea de memria ocupada etc. A principal vantagem deste algoritmo que ele permite que se utilize um algoritmo de escalonamento diferente para cada fila. Assim, possvel que uma fila utilize o FIFO, enquanto outra usa o Round-Robin, por exemplo. Como desvantagem deste algoritmo tem-se o fato de que sua implementao mais complexa que a dos outros j estudados, pois cada uma das filas de prioridade pode utilizar um algoritmo de escalonamento diferente.

33

Escalonamento de tempo real Um objetivo primrio dos algoritmos apresentados anteriormente era garantir alta utilizao de recursos. Processos que devem executar periodicamente (como uma vez por minuto) requerem algoritmos de escalonamento diferentes. Por exemplo, os tempos de espera ilimitados no SJF podem ser catastrficos para um processo que verifique a temperatura de um reator nuclear. Similarmente, um sistema que use SRT para escalonar um processo que reproduza um videoclipe produziria uma reproduo entrecortada.

Escalonamento de Tempo Real atende s necessidades de processos que devem produzir sadas corretas em determinado momento (ou seja, que tem uma restrio de tempo). Um processo de tempo real pode dividir suas instrues em tarefas isoladas, cada qual deve concluir em determinado prazo. Outros processos de tempo real podem executar certa tarefa periodicamente, como atualizar as localizaes de avies em um sistema de controle areo. Escalonadores de tempo real devem garantir que as restries de tempo sejam cumpridas. Estratgias de escalonamento de tempo real so classificadas conforme quo bem cumprem os prazos de um processo. Escalonamento de tempo real no crtico garante que processos de tempo real sejam despachados antes de outros processos do sistema, mas no garante qual processo, se que algum deles, cumprir suas restries de tempo. O Escalonamento de tempo real crtico garante que as restries de prazo de um processo sejam sempre atendidas. Cada tarefa especificada por um processo de tempo real crtico deve concluir antes de seu prazo final; caso isso no acontea, os resultados podero ser catastrficos, entre eles trabalho invlido, falha de sistema ou at danos aos usurios do sistema. Sistemas de tempo real crtico podem conter processos peridicos que realizam suas computaes em intervalos de tempo regulares (por exemplo, coletar dados de controle de trfego areo a cada segundo) e processos assncronos que executam em respostas a eventos (por exemplo, responder a altas temperaturas no ncleo de uma usina nuclear).

34

Escalonamento de tempo real estticos Esses algoritmos no ajustam a prioridade do processo ao longo do tempo. Porque as prioridades so calculadas somente uma vez, esses algoritmos tendem a ser simples e a incorrer em pouca sobrecarga. Eles so limitados, pois no podem se ajustar ao comportamento varivel do processo e dependem de os recursos estarem funcionando e disposio para garantir que sejam cumpridas as restries de tempo. Sistemas de tempo real crticos tendem a usar algoritmos de escalonamento estticos, porque incorrem em baixa sobrecarga e relativamente fcil de provar que as restries de prazo de cada processo sejam atendidas. O algoritmo de escalonamento por taxa monotnica ou RM (Rate Monotonic), por exemplo, um algoritmo de alternncia circular, preemptivo, por prioridade, que eleva a prioridade de um processo linearmente (monotonicamente) com a freqncia (taxa) com a qual ele deve executar. Esse algoritmo de escalonamento frequentemente. O algoritmo por taxa monotnica com prazo pode ser usado quando um processo peridico especifica um prazo que no seja igual ao seu perodo. esttico favorece processos peridicos que executam

Escalonamento de tempo real dinmicos Escalonar processos ajustando suas prioridades durante a execuo, o que pode causar sobrecarga significativa. Alguns algoritmos tentam minimizar a sobrecarga de escalonamento designando prioridades estticas a alguns processos, e prioridades dinmicas a outros. O algoritmo de escalonamento por prazo mais curto primeiro (Earliest Deadline First EDF) do tipo preemptivo que despacha primeiro o processo com prazo mais curto. Se o processo que chegar tiver um prazo mais curto do que o processo em execuo, o sistema provocar a preempo do processo em execuo e despachar o que acabou de chegar. O objetivo minimizar o rendimento cumprindo os prazos do maior nmero de processos por unidade de tempo

35

(anlogo ao SRT) e minimizando o tempo mdio de espera (o que evita que processos curtos percam seus prazos enquanto processos longos executam). Estudos provam que, se um sistema fornecer preempo por hardware (temporizadores de interrupo) e os processos de tempo real que esto em escalonamento no forem interdependentes, o EDF minimiza a quantidade de tempo pelo qual o projeto mais atrasado perde seu prazo. Todavia, muitos sistemas de tempo real no fornecem preempo por hardware, portanto outros algoritmos devem ser empregados.

Programao concorrente
Programao concorrente tem sido usada frequentemente na construo de sistemas operacionais e em aplicaes nas reas de comunicao de dados e controle industrial. Esse tipo de programao torna-se ainda mais importante com o advento dos sistemas distribudos e das mquinas com arquitetura paralela.

Definio Um programa que executado por apenas um processo chamado de programa seqencial. A grande maioria dos programas escritos so assim. Nesse caso, existe somente um fluxo de controle durante a execuo. Isso permite, por exemplo, que o programador realize uma execuo imaginria de seu programa apontando com o dedo, a cada instante, a linha do programa que est sendo executada no momento. Um programa concorrente executado simultaneamente por diversos processos que cooperam entre si, isto , trocam informaes. Para o programador realizar agora uma execuo imaginria, ele vai necessitar de vrios dedos, um para cada processo que faz parte do programa. Nesse contexto, trocar informaes significa trocar dados ou realizar algum tipo de sincronizao. necessria a existncia de interao entre os processos para que o programa seja considerado concorrente. Embora a interao entre processos possa ocorrer atravs de acesso a arquivos comuns, esse tipo de

36

concorrncia tratada na disciplina de Banco de Dados. A concorrncia tratada aqui utiliza mecanismos rpidos para interao entre processos: variveis compartilhadas e trocas de mensagens. O verbo concorrer admite em portugus vrios sentidos. Pode ser usado no sentido de cooperar, como em tudo coopera para o bom xito da operao. Tambm pode ser usado com o significado de disputa ou competio, como em ele concorreu a uma vaga na universidade. Em uma forma menos comum ele significa tambm existir simultaneamente. De certa forma, todos os sentidos so aplicveis aqui na programao concorrente. Em geral, processos concorrem (disputam) pelos mesmos recursos do hardware e do sistema operacional. Por exemplo, processador, memria, perifricos, estruturas de dados, etc. Ao mesmo tempo, pela prpria definio de programa concorrente, eles concorrem (cooperam) para o xito do programa como um todo. Certamente, vrios processos concorrem (existem simultaneamente) em um programa concorrente. Logo, programao

concorrente um bom nome para esse assunto. natural que processos de uma aplicao concorrente compartilhem recursos do sistema, como arquivos, registros, dispositivos de E/S e reas de memria. O compartilhamento de recursos entre processos pode ocasionar situaes indesejveis, capazes at de comprometer a execuo das aplicaes. Para evitar esse tipo de problema os processos concorrentes devem ter suas execues sincronizadas, a partir de mecanismos oferecidos pelo Sistema Operacional, com o objetivo de garantir o processamento correto dos programas.

Processos concorrentes Considere que exista uma casa onde moram duas pessoas que raramente se encontram. Quando uma chega a outra sai e vice-versa. A melhor forma de comunicao atravs de bilhetes.

37

Nessa casa, consome-se sempre um litro de leite por dia. No pode ocorrer a falta do leite nem to pouco o excesso do mesmo. Tentaremos resolver o Problema do Leite na Geladeira utilizando algoritmos com funes genricas.

Comunicao e sincronizao de processos

Primeira tentativa de resolver o Problema do Leite na Geladeira:

E se A for atropelada quando for comprar o leite? Segunda tentativa de resolver o Problema do Leite na Geladeira: mudar o significado do aviso. A vai comprar se no tiver aviso; B vai comprar se tiver aviso.

38

 somente A deixa um aviso, e somente se j no existe um aviso somente B remove um aviso, e somente se houver um aviso portanto, ou existe um aviso, ou nenhum se houver um aviso, B compra leite, se no houver aviso, A compra leite portanto, apenas uma pessoa (processo) vai comprar leite Agora suponha que B saiu de frias. A vai comprar leite uma vez e no poder comprarmais at que B retorne. Portanto essa "soluo" no boa; em particular ela pode levar a "inanio". Terceira tentativa de resolver o Problema do Leite na Geladeira: utilizar dois avisos diferentes.

39

A soluo est quase correta. S precisamos de uma maneira de decidir quem vai comprar o leite quando ambos deixarem avisos. Quarta tentativa de resolver o Problema do Leite na Geladeira: em caso de empate, A vai comprar o leite.

Esta soluo funciona, mas no muito elegante. Ela ainda tem os seguintes problemas: A pode ter que esperar enquanto B est na padaria Enquanto A est esperando ele est consumindo recursos. Alm disso, seria muito difcil estender esta soluo para muitos processos com diferentes pontos de sincronizao.

40

Programas multithreads; Problemas clssicos de sincronizao Para a compreenso de como a sincronizao entre processos concorrentes fundamental para a confiabilidade dos sistemas multiprogramveis, so apresentados alguns problemas de compartilhamento de recursos. A primeira situao envolve o compartilhamento de um arquivo em disco; a segunda apresenta uma varivel na memria principal sendo compartilhada por dois processos. O primeiro problema analisado a partir do programa Conta_Corrente, que atualiza o saldo bancrio de um cliente aps um lanamento de dbito ou crdito no arquivo de contas corrente Arq_Contas. Neste arquivo so armazenados os saldos de todos os correntistas do banco. O programa l o registro do cliente no arquivo (Reg_Cliente), l o valor a ser depositado ou retirado (Valor_Dep_Ret) e, em seguida, atualiza o saldo no arquivo de contas. Considerando processos concorrentes pertencentes a dois funcionrios do banco que atualizam o saldo de um mesmo cliente simultaneamente, a situao de compartilhamento do recurso pode ser analisada. O processo do primeiro funcionrio (Caixa 1) l o registro do cliente e soma ao campo Saldo o valor do lanamento de dbito. Antes de gravar o novo saldo no arquivo, o processo do segundo funcionrio (Caixa 2) l o registro do mesmo cliente, que est sendo atualizado, para realizar outro lanamento, desta vez de crdito. Independentemente de qual dos processos atualize primeiro o saldo no arquivo, o dado gravado estar inconsistente. Um outro exemplo, seria o spool de impresso. Quando um processo deseja imprimir um arquivo, ele entra com o nome do arquivo em um diretrio especial de spool. Outro processo, o impressor, verifica periodicamente este diretrio, para ver se h arquivos a serem impressos. Havendo, eles so impressos e seus nomes so retirados do diretrio. Imagine que nosso diretrio tenha as entradas de 0 a infinito, onde cada uma delas armazena um arquivo. Duas variveis compartilhadas: out aponta para o nome do arquivo a ser impresso e in para a prxima entrada livre do diretrio.

41

Mais ou menos simultaneamente, os processos A e B decidem colocar um arquivo na fila de impresso. S que ocorre o seguinte: A l a varivel entrada e armazena o valor 7. Depois disso ocorre uma interrupo de tempo, onde o processo A deve ceder o processador para o processo B. Este l o valor de entrada 7, mesmo valor que A obteve quando fez a leitura. B guarda o nome do seu arquivo na entrada 7 do diretrio, atualizando entrada para 8, continuando seu processamento em algum momento seguinte, A vai reiniciar seu processamento no exato ponto onde parou. Ao examinar o valor da varivel local onde guardou a entrada livre no spool de impresso, encontrar 7 e escrever o nome do arquivo na entrada 7 do diretrio, apagando o nome do arquivo escrito por B e ainda no impresso. Atualiza a varivel para 8 e continua o processamento. Acontecer que o processo B nunca ter seu arquivo impresso. Analisando os dois exemplos apresentados, possvel concluir que em qualquer situao, onde dois ou mais processos compartilham um mesmo recurso, devem existir mecanismos de controle para evitar esses tipos de problemas.

42

Situaes como esta, onde dois ou mais processos esto acessando dados compartilhados, e o resultado final do processamento depende de quem roda quando, so chamadas de condies de corrida.

CONSTRUES CONCORRENTES DE ALTO NVEL DEADLOCK Um conjunto de N processos est em deadlock quando cada um dos N processos est bloqueado espera de um evento que somente pode ser causado por um dos N processos do conjunto. Obviamente, essa situao somente pode ser alterada por alguma iniciativa que parta de um processo fora do conjunto dos N processos. Ou ainda: um processo em um sistema multiprogramado dito estar em uma situao de deadlock quando ele est esperando por um evento particular que jamais ocorrer. Em um deadlock em um sistema, um ou mais processos esto em deadlock. Em sistemas multiprogramados, o compartilhamento de recursos uma das principais metas dos sistemas operacionais. Quando recursos so

compartilhados entre uma populao de usurios, e cada usurio mantm controle exclusivo sobre os recursos particulares a ele alocados, possvel que haja a ocorrncia de deadlocks no sentido em que alguns usurios jamais sejam capazes de terminar seu processamento. Talvez a forma de ilustrar um deadlock seja com um exemplo de uma lei aprovada pela assemblia norte-americana no incio deste sculo: "Quando dois trens se aproximarem um do outro em um cruzamento, ambos devero parar completamente e nenhum dos dois dever ser acionado at que o outro tenha partido."

Exemplos de deadlocks

43

Deadlock de trfego Um certo nmero de automveis est tentando atravessar uma parte da cidade bastante movimentada, mas o trfego ficou completamente paralisado. O trfego chegou numa situao onde somente a polcia pode resolver a questo, fazendo com que alguns carros recuem na rea congestionada. Eventualmente o trfego volta a fluir normalmente, mas a essa altura os motoristas j se aborreceram e perderam tempo considervel.

Deadlock simples de recursos Muitos deadlocks ocorrem em sistemas de computao devido natureza de recursos dedicados (isto , os recursos somente podem ser usados por um usurio por vez). Suponha que em um sistema o processo A detm um recurso 1, e precisa alocar o recurso 2 para poder prosseguir. O processo B, por sua vez, detm o recurso 2, e precisa do recurso 1 para poder prosseguir. Nesta situao, temos um deadlock, porque um processo est esperando pelo outro. Esta situao de espera mtua chamada muitas vezes de espera circular.

Deadlock em sistemas de spooling Um sistema de spooling serve, por exemplo, para agilizar as tarefas de impresso do sistema. Ao invs do aplicativo mandar linhas para impresso diretamente para a impressora, ele as manda para o spool, que se encarregar de envi-las para a impressora. Assim o aplicativo rapidamente liberado da tarefa de imprimir. Em alguns sistemas de spool, todo o job de impresso deve ser gerado antes do incio da impresso. Isto pode gerar uma situao de deadlock, uma vez que o espao disponvel em disco para a rea de spooling limitado. Se vrios processos comearem a gerar seus dados para o spool, possvel que o espao disponvel para o spool fique cheio antes mesmo de um dos jobs de impresso tiver terminado de ser gerado. Neste caso, todos os processos

44

ficaro esperando pela liberao do espao em disco, o que jamais vai acontecer. A soluo nesse caso seria o operador do sistema cancelar um dos jobs parcialmente gerados. Para resolver o problema sem a interveno do operador, o SO poderia alocar uma rea maior de spooling, ou a rea de spooling poderia ser varivel dinamicamente. Alguns sistemas, como o do Windows 3.x/95, utilizam todo o espao em disco disponvel. Entretanto, pode acontecer de o disco possuir pouco espao e o problema ocorrer da mesma forma. A soluo definitiva seria implementar um sistema de spooling que comeasse a imprimir assim que algum dado estivesse disponvel, sem a necessidade de se esperar por todo o job.

Adiamento indefinido Em sistemas onde processos ficam esperando pela alocao de recursos ou pelas decises de escalonamento, possvel que ocorra adiamento indefinido tambm chamado de bloqueamento indefinido (ou starvation). Adiamento indefinido pode ocorrer devido s polticas de escalonamento de recursos do sistema, principalmente quando o esquema utiliza prioridades (conforme j vimos). Isto pode ser evitado permitindo que a prioridade de um processo em espera cresa conforme ele espera por um recurso.

PREVENINDO DEADLOCKS Se pudermos garantir que pelo menos uma das quatro condies necessrias para que um deadlock ocorra nunca ser satisfeita, poderemos garantir que ser estruturalmente impossvel a ocorrncia de deadlocks (Havender, 1968).

Atacando o problema da excluso mtua

45

Se no houver possibilidade de nenhum recurso ser entregue exclusivamente a um nico processo, nunca teremos configurada uma situao de deadlock. No entanto, est claro tambm que dar permisso a dois processos para acessar a mesma impressora ao mesmo tempo vai levar a uma situao catica. Evitar ento, entregar um recurso, quando ele no for absolutamente necessrio, e tentar estar certo de que o mnimo possvel de processos est precisando de recursos.

Atacando o problema da posse e da espera Se pudermos impedir processos de manter a posse de recursos enquanto esperam por outros recursos, poderemos eliminar os deadlocks. Uma forma de se alcanar este objetivo exigir que todos os processos requisitem todos os recursos de que precisam, antes de iniciar a execuo. Um problema imediato que pode ocorrer com esta abordagem o fato de muitos processos no conhecerem com antecedncia quantos e quais os recursos necessrios sua execuo.

Atacando o problema da condio de no-preempo A anlise da terceira condio (no-preempo) revela-se ainda menos promissora do que a segunda. Se um processo tem alocado uma impressora e est no meio da impresso de seus resultados, tomar fora a impressora porque um plotter de que ele vai precisar no est disponvel uma grande besteira.

Atacando o problema da espera circular Resta-nos somente uma condio para tentar resolver a questo dos deadlocks. A condio de espera circular pode ser eliminada de diversas maneiras. Uma delas simplesmente seguindo a regra de que um processo s est autorizado a usar apenas um recurso por vez. Se ele precisar de um segundo recurso, deve liberar o primeiro.

46

Outra forma utilizar uma numerao global para todos os recursos. Agora a regra : processos podem solicitar recursos sempre que necessrio, mas todas as solicitaes precisam ser feitas em ordem numrica.

DETECO E RECUPERAO DE DEADLOCKS Uma tcnica detectar e recuperar os deadlocks. Quando ela usada, o sistema no se preocupa em prevenir a ocorrncia de deadlocks. Em vez disso, ele permite que os mesmos ocorram, tenta detectar as ocorrncias, e age no sentido de normalizar a situao, aps sua ocorrncia.

Recuperao atravs da preempo Algumas vezes possvel tomar temporariamente um recurso de seu atual dono e entreg-lo a outro processo. Outras vezes necessria a interveno manual. A capacidade de tomar um recurso de um processo, deixar que outro processo o utilize e devolv- lo ao processo original, sem que este tenha conhecimento do que est acontecendo, depende muito do recurso. Por exemplo, para tomar uma impressora de seu proprietrio atual, o operador deve recolher as folhas impressas e coloc-las numa pilha. O processo pode ento ser suspenso. A impressora pode ser entregue a um outro processo. Quando este terminar, a pilha de folhas impressas do processo anterior deve ser colocada de novo na bandeja de sada, sendo o processo reiniciado. Agora, interromper a gravao em uma unidade de CD-ROM pode se tornar muito complicado.

Recuperao com rollback Consiste em escrever histricos dos processos em andamento, contendo todas as informaes necessrias para que em caso de deadlock, o sistema possa

47

voltar atrs e alocar um ou outro recurso diferente para evitar o impasse novamente.

Recuperao atravs de eliminao de processos a maneira mais rude, mas tambm a mais simples de se eliminar a situao de deadlock. Por exemplo, um processo pode estar de posse de uma impressora e estar precisando de um plotter, e outro processo pode estar precisando da impressora, estando com o plotter. Esto em deadlock. A eliminao de um outro processo que possui tanto a impressora quanto o plotter pode solucionar esse impasse.

O ideal que seja eliminado um processo que possa rodar de novo desde o incio sem produzir nenhum efeito negativo ao sistema. Por exemplo, uma compilao pode sempre recomear, pois tudo o que ela faz ler um arquivofonte e produzir um arquivo-objeto. Sua eliminao far com que a primeira rodada no tenha influncia alguma na segunda. Por outro lado, um processo que atualiza uma base de dados no pode ser eliminado e voltar a rodar uma segunda vez em condies seguras.

GERENCIAMENTO DE MEMRIA Historicamente, a memria principal sempre foi vista como um recurso escasso e caro. Uma das maiores preocupaes dos projetistas foi desenvolver Sistemas Operacionais que no ocupassem muito espao de memria e, ao mesmo tempo, otimizassem a utilizao dos recursos computacionais. Mesmo com a reduo do custo e conseqente aumento da capacidade, seu gerenciamento um dos fatores mais importantes no projeto de Sistemas Operacionais.

48

Ns (na qualidade de projetistas de sistemas) consideramos a memria principal em termos de organizao de memria. Colocamos apenas um nico processo na memria principal ou inclumos vrios processos ao mesmo tempo (ou seja, implementamos a multiprogramao)? Se a memria principal contiver diversos processos simultaneamente, damos a cada um a mesma quantidade de espao ou dividimos a memria principal em pores de tamanhos diferentes? Definimos parties rigidamente por perodos estendidos ou dinamicamente, permitindo que o sistema se adapte rapidamente s mudanas das necessidades dos processos? Exigimos que processos executem em uma partio especfica ou em qualquer lugar onde couberem? Exigimos que um sistema coloque cada processo em um bloco contguo de localizaes de memria ou permitimos que divida processos em blocos separados e os coloque em quaisquer molduras disponveis na memria principal? Vamos falar sobre tudo isso.

ALOCAO CONTGUA SIMPLES Foi implementada nos primeiros Sistemas Operacionais, porm ainda est presente em alguns sistemas monoprogramveis. Nesse tipo de organizao, a memria principal subdividida em duas reas: uma para o Sistema Operacional e outra para o programa do usurio. Dessa forma, o programador deve desenvolver suas aplicaes preocupado apenas, em no ultrapassar o espao de memria disponvel. Nesse esquema, o usurio tem controle sobre toda a memria principal, podendo ter acesso a qualquer posio de memria, inclusive a rea do Sistema Operacional. Para proteger o sistema desse tipo de acesso, que pode ser intencional ou no, alguns sistemas implementam proteo atravs de um registrador que delimita as reas do Sistema Operacional e do usurio. Dessa forma, sempre que um programa faz referncia a um endereo na memria, o sistema verifica se o endereo est dentro dos limites permitidos. Caso no esteja, o programa cancelado e uma mensagem de erro gerada, indicando que houve uma violao no acesso memria principal.

49

POLTICAS BSICAS O objetivo principal de um sistema computacional executar programas. Tais programas devem estar, ainda que parcialmente, localizados na memria principal para executarem. Contudo, a memria principal, normalmente, no possui tamanho suficiente para armazenar todos os programas a serem executados, bem como os dados por eles utilizados. Este fato levou a maioria dos Sistemas Operacionais modernos a utilizarem principalmente, dos discos rgidos como dispositivos secundrios de apoio a memria. Assim, faz-se necessria a presena do software de gerncia de memria que , tambm, conhecido como Gerente de Memria e possui como objetivos principais controlar quais partes da memria esto ou no em uso e tratar as dificuldades inerentes ao processo de swapping _ processo de troca de dados entre a memria principal e o disco rgido.

SISTEMAS MONOPROGRAMADOS Os primeiros Sistemas Operacionais eram tipicamente voltados para a execuo de um nico programa. Qualquer outra aplicao, para ser executada, deveria aguardar o trmino do programa corrente. Os sistemas monoprogramveis se caracterizam por permitir que o processador, a memria e os perifricos permaneam exclusivamente dedicados execuo de um nico programa. Neste tipo de sistema, enquanto um programa aguarda por um evento, como a digitao de um dado, o processador permanece ocioso, sem realizar qualquer tipo de processamento. A memria subutilizada caso o programa no a preencha totalmente, e os perifricos, como discos e impressoras, esto dedicados a um nico usurio, nem sempre utilizados de forma integral. Comparados a outros sistemas, os sistemas monoprogramveis ou

monotarefas so de simples implementao, no existindo muita preocupao com problemas decorrentes do compartilhamento de recursos.

50

SISTEMAS MULTIPROGRAMVEIS OU MULTITAREFAS Neste tipo de sistema, os recursos computacionais so compartilhados entre os diversos usurios e aplicaes. Neste caso, enquanto um programa espera por uma operao de leitura ou gravao em disco, outros programas podem estar sendo processados neste mesmo intervalo de tempo. Nesse caso, podemos observar o

compartilhamento da memria e do processador. O Sistema Operacional se preocupa em gerenciar o acesso concorrente aos seus diversos recursos. As vantagens do uso de tais sistemas so a reduo do tempo de resposta das aplicaes processadas no ambiente e de custos, a partir do compartilhamento dos diversos recursos do sistema entre as diferentes aplicaes. A partir do nmero de usurios que interagem com o sistema, podemos classificar os sistemas multiprogramveis como monousurio ou multiusurio. Os sistemas multiprogramveis podem tambm ser classificados pela forma com que suas aplicaes so gerenciadas, podendo ser divididos em sistemas batch, de tempo compartilhado ou de tempo real. Um Sistema Operacional pode suportar um ou mais desses tipos de processamento, dependendo de sua implementao.

Sistemas Batch

51

Foram os primeiros tipos de Sistemas Operacionais multiprogramveis a serem implementados. O processamento em batch tem a caracterstica de no exigir a interao do usurio com a aplicao. Todas as entradas e sadas de dados so implementadas por algum tipo de memria secundria, geralmente arquivos em disco. Esses sistemas, quando bem projetados, podem ser bastante eficientes, devido melhor utilizao do processador; entretanto, podem oferecer tempos de resposta longos. Atualmente, os Sistemas Operacionais implementam ou simulam o

processamento batch, no existindo sistemas exclusivamente dedicados a este tipo de processamento.

SISTEMAS DE TEMPO COMPARTILHADO Tais sistemas, tambm conhecidos como time-sharing, permitem que diversos programas sejam executados a partir da diviso do tempo do processador em pequenos intervalos, denominados fatia de tempo (time-slice). Caso a fatia de tempo no seja suficiente para a concluso do programa, esse interrompido pelo Sistema Operacional e submetido por um outro, enquanto fica aguardando por uma nova fatia de tempo. O sistema cria um ambiente de trabalho prprio, dando a impresso de que todo o sistema est dedicado, exclusivamente, para cada usurio. Geralmente, sistemas de tempo compartilhado permitem a interao dos usurios com o sistema atravs de terminais que incluem vdeo, teclado e mouse. Esses sistemas possuem uma linguagem de controle que permite ao usurio comunicar-se diretamente com o Sistema Operacional atravs de comandos. A maioria das aplicaes comerciais atualmente so processadas em sistemas de tempo compartilhado, que oferecem tempos baixos de respostas a seus usurios e menores custos, em funo da utilizao compartilhada dos diversos recursos do sistema.

52

SISTEMAS DE TEMPO REAL Os sistemas de tempo real (real-time) diferem dos de tempo compartilhado no tempo exigido no processamento das aplicaes. Enquanto em sistemas de tempo compartilhado o tempo de processamento pode variar sem comprometer as aplicaes em execuo, nos sistemas de tempo real os tempos de processamento devem estar dentro de limites rgidos, que devem ser obedecidos, caso contrrio podero ocorrer problemas irreparveis. No existe a idia de fatia de tempo. Um programa utiliza o processador o tempo que for necessrio ou at que aparea outro mais prioritrio. Essa prioridade definida pela prpria aplicao. Esto presentes em aplicaes de controle de usinas termoeltricas e nucleares, controle de trfego areo, ou em qualquer outra aplicao onde o tempo de processamento fator fundamental.

SISTEMAS COM MLTIPLOS PROCESSADORES Um sistema com mltiplos processadores possui duas ou mais CPUs interligadas trabalhando em conjunto. A vantagem desse tipo de sistema permitir que vrios programas sejam executados ao mesmo tempo ou que um mesmo programa seja subdividido em partes para serem executadas simultaneamente em mais de um processador. Os conceitos aplicados ao projeto de sistemas com mltiplos processadores incorporam os mesmos princpios bsicos e benefcios apresentados na multiprogramao, alm de outras vantagens especficas como escalabilidade, disponibilidade e balanceamento de carga.

Escalabilidade a capacidade de ampliar o poder computacional do sistema apenas adicionando outros processadores. Em ambientes com um nico processador, caso haja problemas de desempenho, seria necessrio substituir todo o sistema por uma outra configurao com maior poder de

53

processamento. Com a possibilidade de mltiplos processadores, basta acrescentar novos processadores configurao. Disponibilidade a capacidade de manter o sistema em operao mesmo em casos de falhas. Neste caso, se um dos processadores falhar, os demais podem assumir suas funes de maneira transparente aos usurios e suas aplicaes, embora com menor capacidade de computao. Balanceamento de Carga a possibilidade de distribuir o processamento entre os diversos processadores da configurao a partir da carga de trabalho de cada processador, melhorando assim, o desempenho do sistema como um todo.

Esses sistemas podem ser classificados quanto forma de comunicao entre as CPUs e quanto ao grau de compartilhamento da memria e dos dispositivos de E/S. Assim, podemos classific-los em fortemente acoplados e fracamente acoplados.

SISTEMAS FORTEMENTE ACOPLADOS Num sistema fortemente acoplado dois ou mais processadores compartilham uma nica memria e so controlados por um nico sistema operacional. Um sistema fortemente acoplado utilizado geralmente em aplicaes que fazem uso intensivo da CPU e cujo processamento dedicado soluo de um nico problema.

54

Os sistemas fortemente acoplados podem ser divididos em simtricos ou assimtricos. Os simtricos caracterizam-se pelo tempo uniforme de acesso memria principal pelos diversos processadores. Inicialmente, tais sistemas estavam limitados aos sistemas de grande porte, restritos ao ambiente universitrio e s grandes corporaes. Com a evoluo dos computadores pessoais e das estaes de trabalho, os sistemas multitarefa evoluram para permitir a existncia de vrios processadores no modelo simtrico. Atualmente, a grande maioria dos Sistemas Operacionais, como o Unix e o Windows 2000, implementa esta funcionalidade.

SISTEMAS FRACAMENTE ACOPLADOS Num sistema fracamente acoplado dois ou mais sistemas de computao so conectados atravs do uso de linhas de comunicao. Nesses sistemas, ocorre o processamento distribudo entre os diversos computadores. Cada sistema funciona de forma independente, possuindo seu(s) prprio(s) processador(es). Em funo destas caractersticas, tambm so conhecidos como

multicomputadores. Com a evoluo dos computadores pessoais e das estaes de trabalho, juntamente com o avano das telecomunicaes e da tecnologia de redes, surgiu um novo modelo de computao, chamado modelo de rede de

55

computadores. Em uma rede existem dois ou mais sistemas independentes (hosts), interligados atravs de linhas de comunicao, que oferecem algum tipo de servio aos demais. Neste modelo, a informao deixa de ser centralizada em poucos sistemas de grande porte e passa ser distribuda pelos diversos sistemas da rede.

Com base no grau de integrao dos hosts da rede, podemos dividir os sistemas fracamente acoplados em Sistemas Operacionais de Rede e Sistemas Distribudos. A grande diferena entre os dois modelos a capacidade do Sistema Operacional em criar uma imagem nica dos servios disponibilizados pela rede. Os Sistemas Operacionais de Rede permitem que um host compartilhe seus recursos, como impressora ou diretrio, com os demais hosts da rede. Um exemplo deste tipo de sistema so as redes locais, onde uma estao pode oferecer servios de arquivos e impresso para as demais estaes da rede, dentre outros servios. Enquanto nos Sistemas Operacionais de Rede os usurios tm conhecimento dos hosts e seus servios, nos Sistemas Distribudos o Sistema Operacional esconde os detalhes dos hosts individuais e passa a trat-los como um conjunto nico, como se fosse um sistema fortemente acoplado. Os sistemas distribudos permitem, por exemplo, que uma aplicao seja dividida em partes e que cada parte seja executada por hosts diferentes da rede de

56

computadores. Para o usurio e suas aplicaes como se no existisse a rede de computadores, mas sim um nico sistema centralizado. Os sistemas multiprogramveis so muito mais eficientes no uso do processador, necessitando assim, que diversos programas estejam na memria principal ao mesmo tempo. E que novas formas de gerncia de memria sejam implementadas. PARTIES PARTIES FIXAS Nos primeiros sistemas multiprogramveis, a memria era dividida em pedaos de tamanho fixo, chamados parties. O tamanho das parties, estabelecido na fase de inicializao do sistema, era definido em funo do tamanho dos programas que executariam no ambiente. Sempre que fosse necessria a alterao do tamanho de uma partio, o sistema deveria ser desativado e reinicializado com uma nova configurao. Esse tipo de gerncia de memria conhecido como alocao particionada esttica ou alocao fixa. Inicialmente, os programas s podiam ser carregados em apenas uma partio especfica, mesmo se outras estivessem disponveis. Essa limitao se devia aos compiladores e montadores, que geravam apenas cdigo absoluto. No cdigo absoluto, todas as referncias a endereos no programa so posies fsicas na memria principal, ou seja, o programa s poderia ser carregado a partir do endereo de memria especificado no seu prprio cdigo. Se, por exemplo, os programas A e B estivessem sendo executados, e a terceira partio estivesse livre, os programas C e E no poderiam ser processados. A esse tipo de gerncia de memria chamou-se alocao particionada esttica absoluta. Com a evoluo dos compiladores, o cdigo gerado deixou de ser absoluto e passa a ser relocvel. No cdigo relocvel, todas as referncias a endereos no programa so relativas ao incio do cdigo e no a endereos fsicos de memria. Desta forma, os programas puderam ser executados a partir de qualquer partio. Quando o programa carregado, o loader calcula todos os endereos a partir da posio inicial onde o programa foi alocado. Caso os

57

programas A e B terminassem, o programa E poderia ser executado em qualquer uma das parties. Esse tipo de gerncia denominado alocao particionada esttica relocvel. Para manter controle sobre quais parties esto alocadas, a gerncia de memria mantm uma tabela com o endereo inicial de cada partio, seu tamanho, e se est em uso. Sempre que um programa carregado para a memria, o sistema percorre a tabela, na tentativa de localizar uma partio livre, onde o programa possa ser carregado. Nesse esquema de alocao de memria, a proteo baseia-se em dois registradores, que indicam os limites inferior e superior da partio onde o programa est sendo executado. Tanto nos sistemas de alocao absoluta quanto nos de alocao relocvel, os programas, normalmente, no preenchem totalmente as parties onde so carregados. Por exemplo, os programas C, A e E no ocupam integralmente o espao das parties onde esto alocados, deixando 1 KB, 3 KB e 5 KB de reas livres. Este tipo de problema, decorrente da alocao fixa das parties, conhecido como fragmentao interna.

PARTIES VARIVEIS Na tentativa de evitar o desperdcio de memria ocasionado pelo mtodo tratado na subseo anterior, foi desenvolvido um outro esquema de multiprogramao. Este outro esquema considera que o tamanho das parties de memria no so fixos e conhecido como alocao particionada dinmica ou parties variveis. Nesse esquema, o programa utilizaria o espao necessrio, tornando essa rea sua partio. Como os programas utilizam apenas o espao que necessitam, o problema da fragmentao interna no ocorre. Porm, nesse caso, existe um problema que no to bvio quanto no esquema anterior. Um tipo diferente de fragmentao comear a ocorrer, quando os programas forem terminando e deixando espaos cada vez menores na memria, no permitindo o ingresso de novos programas. Na figura, mesmo existindo 12 KB livres de memria principal, o programa D, que necessita de 6 KB no poder

58

ser carregado para execuo, pois este espao no est disposto contiguamente. Esse tipo de problema chamado de fragmentao externa. Existem duas solues para o problema da fragmentao externa. Na primeira soluo, conforme os programas terminam, apenas os espaos livres adjacentes so reunidos, produzindo reas livres de tamanho maior. A segunda soluo envolve a relocao de todas as parties ocupadas, eliminando todos os espaos entre elas e criando uma nica rea livre contgua. Para que esse processo seja possvel, necessrio que o sistema tenha a capacidade de mover os diversos programas na memria principal, realizar relocao dinmica. A complexidade do seu algoritmo e o consumo de recursos Sistema Operacional sistema para a relocao dinmica, podem tornla invivel.

SWAPPING

Mesmo com o aumento da eficincia da multiprogramao da gerncia e, de

particularmente,

memria, muitas vezes um programa no podia ser executado por falta de uma partio livre disponvel. A tcnica de swapping foi introduzida para contornar o problema da

insuficincia de memria principal. Em todos os esquemas um

apresentados

anteriormente,

processo permanecia na memria principal at o final da sua execuo, inclusive nos momentos em que esperava por um evento, como uma operao de E/S. O swapping uma tcnica aplicada gerncia de memria para programas que esperam por memria livre para serem executados. Nesta situao, o sistema escolhe um processo residente, que transferido da memria principal para a memria

59

secundria (swap out), geralmente disco. Posteriormente, o processo carregado de volta da memria secundria para a memria principal (swap in) e pode continuar sua execuo como se nada tivesse ocorrido. O algoritmo de escolha do processo a ser retirado da memria principal deve priorizar aquele com menores chances de ser executado. Para que essa tcnica seja utilizada, essencial que o sistema oferea um loader que implemente a relocao dinmica. No momento em que o programa carregado na memria, o registrador recebe o endereo inicial da posio de memria que o programa ir ocupar. Toda vez que ocorrer uma referncia a algum endereo, o endereo contido na instruo ser somado ao contedo do registrador, gerando, assim, o endereo fsico. Dessa forma, um programa pode ser carregado em qualquer posio de memria.

MEMRIA VIRTUAL Memria Virtual uma tcnica sofisticada e poderosa de gerncia de memria, onde as memrias principal e secundria so combinadas, dando ao usurio a iluso de existir uma memria muito maior que a capacidade real da memria principal. O conceito de memria virtual fundamenta-se em no vincular o endereamento feito pelo programa dos endereos fsicos da memria principal. Desta forma, programas e suas estruturas de dados deixam de estar limitados ao tamanho da memria fsica disponvel, pois podem possuir endereos associados memria secundria. Outra vantagem da tcnica de memria virtual permitir um nmero maior de processos compartilhando a memria principal, j que apenas partes de cada processo estaro residentes. Isto leva a uma utilizao mais eficiente tambm do processador. Alm disso, essa tcnica possibilita minimizar o problema da fragmentao da memria principal.

PAGINAO

60

 a tcnica de gerncia de memria onde o espao de endereamento virtual e o real so divididos em blocos do mesmo tamanho chamados pginas. A definio do tamanho da pgina um fator importante no projeto de sistemas que implementam memria virtual por paginao. O tamanho da pgina est associado arquitetura do hardware e varia de acordo com o processador, mas normalmente est entre 512 e 16MB. Pginas no espao virtual so denominadas pginas virtuais, enquanto as pginas no espao real so chamadas de pginas reais, molduras ou frames. Todo o mapeamento de endereo virtual em real realizado atravs de tabelas de pginas. Cada processo possui sua prpria tabela e cada pgina virtual do processo possui uma entrada na tabela de pginas (ETP), com informaes de mapeamento que permitem ao sistema localizar a pgina real correspondente. Nessa tcnica, o endereo virtual formado pelo nmero da pgina virtual (NPV) e por um deslocamento. O NPV identifica unicamente a pgina virtual que contm o endereo, funcionando como um ndice na tabela de paginas. O deslocamento indica a posio do endereo virtual em relao ao incio da pgina na qual se encontra. O endereo fsico obtido, ento, combinando-se o endereo do frame, localizado na tabela de pginas, com o deslocamento, contido no endereo virtual. Alm da informao sobre a localizao da pgina virtual, a ETP possui outras informaes, como o bit de validade (valid bit) que indica se uma pgina est ou no na memria principal. Sempre que o processo referencia um endereo virtual, a unidade de gerncia de memria verifica, atravs do bit de validade, se a pgina que contm o endereo referenciado est ou no na memria principal. Caso a pgina no esteja na memria, dizemos que ocorre uma falta de pgina (page fault). Neste caso, o sistema transfere a pgina da memria secundria para a memria principal, realizando uma operao de E/S conhecida como page in ou paginao. O nmero de faltas de pgina gerado por um processo depende de como o programa foi desenvolvido, alm da poltica de gerncia de memria

61

implementada pelo Sistema Operacional. O nmero de falta de pginas geradas por cada processo em um determinado intervalo de tempo definido como taxa de paginao.

62

Paginao multinvel Em sistemas que implementam apenas um nvel de paginao, o tamanho das tabelas de pginas pode ser um problema. Em uma arquitetura de 32 bits para endereamento e pginas com 4KB por processo, onde cada entrada na tabela de pginas ocupe 4 bytes, a tabela de pginas poderia ter mais de um milho de entradas e ocuparia 4 MB de espao. Imaginando vrios processos residentes na memria principal, manter tabelas desse tamanho para cada processo certamente seria de difcil gerenciamento. Uma boa soluo para contornar o problema a utilizao de tabelas de pginas multinvel. Com a finalidade de propiciar um melhor entendimento do mencionado conceito, considere-se um sistema computacional com palavra de 32 bits, 4 GB de espao de endereamento virtual e pginas de tamanho 4K. Nesta configurao, a palavra que chega MMU dividida em trs partes, como indica a Figura:

Dessa forma, cada entrada do primeiro nvel gerencia 4 MB de espao e cada entrada do segundo mapeia 4KB, totalizando 4GB. A Figura abaixo apresenta um exemplo de funcionamento da MMU para o caso de tabelas de pginas multinvel

63

1) MOVE REG 4206600 MOVE REG? 2) 4206600 0000000001 | 0000000011 | 000000001000 3) 0000000001 = 1 (TP1) Endereos de 4Mb a 8 Mb de TP1 4) 0000000011 = 3 (TP2) Endereo da Base = 12.288 5) 000000001000 = 8 (Deslocamento) 6) Endereo Real=Base + Deslocamento = 12.288 + 8 =12.296 MOVE REG 12296 POLTICAS DE BUSCA DE PGINAS Determina quando uma pgina deve ser carregada para a memria. Basicamente, existem duas estratgias para este propsito: paginao sob demanda e pr-paginao ou paginao antecipada. Na paginao sob demanda, as pginas dos processos so transferidas da memria secundria para a principal apenas quando so referenciadas. Este mecanismo conveniente, na medida em que leva para a memria principal apenas as pginas realmente necessrias execuo do programa. Desse modo, possvel que partes no executadas do programa, como rotinas de tratamento de erros, nunca sejam carregadas para a memria.

64

Na pr-paginao, o sistema carrega para a memria principal, alm da pgina referenciada, outras pginas que podem ou no ser necessrias ao processo ao longo do processamento. Se imaginarmos que o programa est armazenado seqencialmente no disco, existe uma grande economia de tempo em levar um conjunto de pginas da memria secundria, ao contrrio de carregar uma de cada vez. Por outro lado, caso o processo no precise das pginas carregadas antecipadamente, o sistema ter perdido tempo e ocupado memria principal desnecessariamente.

POLTICAS DE ALOCAO DE PGINAS Determina quantas molduras (frames) cada processo pode manter na memria principal. Existem, basicamente, duas alternativas: alocao fixa e alocao varivel. Na poltica de alocao fixa, cada processo tem um nmero mximo de molduras que pode ser utilizado durante a execuo do programa. Caso o nmero de pginas reais seja insuficiente, uma pgina do processo deve ser descartada para que uma nova seja carregada. O limite de pginas deve ser definido no momento da criao do processo, com base no tipo da aplicao que ser executada. Essa informao faz parte do contexto de software do processo. Apesar de sua simplicidade, a poltica de alocao fixa de pgina apresenta dois problemas. Se o nmero mximo de pginas alocadas for muito pequeno, o processo tender a ter um elevado nmero de falta de pgina, o que pode impactar no desempenho de todo o sistema. Por outro lado, caso o nmero de pginas seja muito grande, cada processo ir ocupar na memria principal um espao maior do que o necessrio, reduzindo o nmero de processos residentes e o grau de multiprogramao. Na poltica de alocao varivel, o nmero mximo de pginas pode variar durante sua execuo em funo de sua taxa de paginao e da ocupao da memria principal.

65

Este mecanismo, apesar de ser mais flexvel, exige que o Sistema Operacional monitore constantemente o comportamento dos processos, gerando maior overhead.

POLTICAS DE SUBSTITUIO DE PGINAS

Em algumas situaes, quando um processo atinge o seu limite de alocao de molduras e necessita alocar novas pginas na memria principal, o Sistema Operacional deve selecionar, dentre as diversas pginas alocadas, qual dever ser liberada. Este mecanismo chamado de poltica de substituio de pginas. Uma pgina real, quando liberada por um processo, est livre para ser utilizada por qualquer outro. A partir dessa situao, qualquer estratgia de substituio de pginas deve considerar se uma pgina foi ou no modificada antes de liber-la. Se a pgina tiver sido modificada, o sistema dever grav-la na memria secundria antes do descarte, preservando seu contedo para uso em futuras referncias. Este mecanismo conhecido como page out. O Sistema Operacional consegue identificar as pginas modificadas atravs de um bit que existe em cada entrada da tabela de pginas, chamado bit de modificao. Sempre que uma pgina sofre uma alterao, o valor do bit de modificao alterado, indicando que a pgina foi modificada. A poltica de substituio de pginas pode ser classificada conforme seu escopo, ou seja, dentre os processos residentes na memria principal quais so candidatos a ter pginas realocadas. Em funo deste escopo, pode ser definida como local ou global. Na poltica de substituio local, apenas as pginas do processo que gerou a falta de pgina so candidatas a realocao. Os frames dos demais processos no so avaliados para substituio. J na poltica de substituio global, todas as pginas alocadas na memria principal so candidatas a substituio, independente do processo que gerou a falta de pgina.

66

Na verdade, nem todas as pginas podem ser candidatas a substituio. Algumas pginas, como as do ncleo do sistema, so marcadas como bloqueadas e no podem ser realocadas.

WORKING SET Apesar de suas diversas vantagens, o mecanismo de memria virtual introduz um srio problema: caso os processos tenham na memria principal um nmero insuficiente de pginas para a execuo do programa, provvel que diversos frames referenciados ao longo do seu processamento no estejam na memria. Esta situao provoca a ocorrncia de um nmero elevado de falta de pgina e, conseqentemente, inmeras operaes de E/S. Neste caso, ocorre um problema conhecido como trashing, provocando srias

conseqncias ao desempenho do sistema. O conceito de working set surgiu com o objetivo de reduzir o problema do trashing e est relacionado ao princpio da localidade. Existem dois tipos de localidade que so observados durante a execuo da maioria dos programas. A localidade espacial a tendncia de que aps uma referncia a uma posio de memria sejam realizadas novas referncias a endereos prximos. A localidade temporal a tendncia de que aps a referncia a uma posio de memria esta mesma posio seja novamente referenciada em um curto intervalo de tempo.

67

O princpio da localidade significa, na prtica, que o processador tender a concentrar suas referncias a um conjunto de pginas do processo durante um determinado perodo de tempo. Imaginando um loop, cujo cdigo ocupe trs pginas, a tendncia de essas trs pginas serem referenciadas diversas vezes muito alta. A partir da observao do princpio da localidade, Peter Denning (1968), formulou o modelo de working set. Working set definido como sendo o conjunto das pginas referenciadas por um processo durante determinado intervalo de tempo. A figura ilustra que no instante t2, o working set do processo W(t2, t), so as pginas referenciadas no intervalo t (t2 t1), isto , as pginas P2, P3 e P8. o intervalo de tempo t denominado janela do working set. Podemos observar, ento, que o working set de um processo funo do tempo e do tamanho da janela do working set.

Dentro da janela do working set, o nmero de pginas distintas referenciadas conhecido como tamanho do working set. Na figura so apresentadas as

68

referncias s pginas de um processo nas janelas ta (t2 t1) e tb (t3 t2). O working set do processo no instante t2, com a janela ta, corresponde s pginas P2, P3, P4 e P5, e o tamanho do working set igual a quatro pginas. No instante t3, com a janela tb, o working set corresponde s pginas P5 e P6, e o tamanho igual a duas pginas.

O modelo de working set proposto por Denning possibilita prever quais pginas so necessrias execuo de um programa de forma eficiente. Caso a janela do working set seja apropriadamente selecionada, em funo da localidade do programa, o Sistema Operacional dever manter as pginas do working set de cada processo residente na memria principal. Considerando que a localidade de um programa varia ao longo da sua execuo, o tamanho do working set do processo tambm varia, ou seja, o seu limite de pginas reais deve acompanhar esta variao. O working set refletir a localidade do programa, reduzindo a taxa de paginao dos processos e evitando, conseqentemente, o trashing. Na prtica, o modelo de working set serve como base para inmeros algoritmos de substituio de pginas, como os apresentados a seguir.

Algoritmos de substituio de pginas A melhor estratgia de substituio de pginas seria aquela que escolhesse uma moldura que no fosse mais utilizada no futuro ou levasse mais tempo para ser novamente referenciada. Porm, quanto mais sofisticado o algoritmo, maior overhead para o Sistema Operacional implement-lo. O algoritmo deve tentar manter o working set dos processos na memria principal e, ao mesmo tempo, no comprometer o desempenho do sistema.

69

TIMO O melhor algoritmo de troca de pginas fcil de descrever, mas impossvel de implementar. O algoritmo opera da seguinte maneira: no momento que ocorre uma falta de pgina, um certo conjunto de pginas est na memria. Uma dessas pginas ser referenciada em muitas das prximas instrues. Outras pginas no sero referenciadas antes de 10, 100 ou talvez 1000 instrues. Cada pgina pode ser rotulada com o nmero de instrues que sero executadas antes que a pgina seja inicialmente referenciada. O algoritmo timo simplesmente diz que a pgina com o maior rtulo deve ser removida, adiando-se o mximo possvel a prxima falta de pgina. (A exemplo das pessoas, os computadores tambm tendem a adiar o quanto possvel a ocorrncia de eventos desagradveis). O nico problema com este algoritmo que ele no realizvel. No momento da falta de pgina, o sistema operacional no tem como saber quando cada uma das pginas ser referenciada de novo. No mximo podemos executar um programa em um simulador e, mantendo uma lista de todas as pginas referenciadas, implementar o algoritmo na segunda execuo (usando informaes coletadas na primeira execuo). FIFO Para ilustrar seu funcionamento, considere um supermercado que tem prateleiras suficientes para armazenar exatamente k produtos diferentes. Certo dia, alguma indstria introduz um novo tipo de alimento que faz um tremendo sucesso comercial. Nosso supermercado deve, ento, arranjar um jeitinho para vend-lo, eliminando de suas prateleiras algum outro produto. Uma possibilidade descobrir qual dos produtos este supermercado vem estocando h mais tempo (isto , algo que ele vem vendendo h 120 anos) e livrar-se dele. De fato, tal deciso tomada com facilidade, visto que o supermercado mantm uma lista de todos produtos vendidos atualmente, na

70

ordem em que eles entraram pela primeira vez no estoque. O mais novo est no fim da fila, e o mais velho no incio, devendo ser eliminado. Em algoritmos de substituio de pginas, a mesma idia pode ser aplicada. O sistema operacional mantm uma fila de todas as pginas que esto na memria, com a pgina no topo da fila sendo a mais antiga e a do fim da fila a que chegou h menos tempo. Na ocorrncia de uma falta de pgina, a pgina do incio deve ser removida, sendo a nova pgina adicionada ao fim desta fila. Quando aplicado ao problema do supermercado, o algoritmo FIFO tanto pode remover um dos itens mais vendidos, como sal ou manteiga, quanto um dos menos vendidos, como sacos de lixo. Quando aplicada aos computadores, o mesmo problema ocorre. Por isso, o algoritmo FIFO, em sua forma pura, nunca usado. A Figura traz uma simulao simplificada deste algoritmo;

Segunda Chance

Este algoritmo uma variao do FIFO, a nica diferena que existe um bit R associado a cada pgina. Se R for 0 a pgina considerada velha e no referenciada, de modo que ela deve ser removida da memria. Ao passo que, se R for 1, R deve ser zerado e a pgina colocada no fim da fila (torna-se jovem novamente).Contudo, se todas as pginas tiverem sido recentemente referenciadas, este algoritmo ir se comportar exatamente como o FIFO; Relgio O algoritmo da segunda chance est sempre movendo pginas do incio para o final da lista. Ento, com a finalidade de solucionar este problema,

71

desenvolveu-se o algoritmo do relgio, que possui uma lista ligada circular e um ponteiro que aponta para a pgina mais velha. Quando uma falta de pgina acontece, a pgina que est sendo apontada testada e, caso o seu bit R seja zero, ela deve abandonar a memria, porm se R for 1, R deve ser zerado e o ponteiro avana para o prximo n da lista. Este processo deve se repetir at que seja encontrado um n com R igual a zero;

NUR (Not Recently Used)

Para permitir que o sistema operacional colete estatsticas sobre quais pginas esto sendo usadas e quais no esto, muitos computadores com memria virtual tm 2 bits associados a cada pgina. Um bit, R ou bit de referncia, ativado pelo hardware sempre que a pgina a ele associada for referenciada. O outro bit, M ou bit de modificao, ativado pelo hardware quando uma pgina escrita. importante que estes bits sejam atualizados em qualquer referncia de memria, assim, essencial que eles sejam ativados pelo hardware. Uma vez que um bit for ativado, ele permanece ativado at que o sistema operacional o desative (por software). Os bits R e M podem ser usados para construir um algoritmo de paginao simples como se segue. Quando um processo iniciado, ambos os bits de pgina para todas estas pginas so declarados 0 pelo sistema operacional. Periodicamente (i.e. a cada interrupo de tempo), o bit R zerado, para distinguir pginas que no foram referenciadas recentemente daquelas que tenham sido. Quando uma falta de pgina ocorre, o sistema operacional examina todas as pginas e as classifica em 4 categorias baseado nos valores correntes de seus bits R e M: Classe 0: no referenciada, no modificada Classe 1: no referenciada, modificada Classe 2: referenciada, no modificada Classe 3: referenciada, modificada

72

Ainda que as pginas na classe 1 paream, primeira vista, impossveis de existir, elas ocorrem quando as pginas da classe 3 tm seu bit R zerado pela interrupo de tempo. O algoritmo NRU remove uma pgina aleatria da classe de numerao mais baixa no vazia. Implcito neste algoritmo que melhor remover uma pgina modificada que no foi referenciada pelo menos no ltimo clock, que uma pgina no modificada, mas muito usada. As caractersticas principais do NRU que ele fcil de entender, eficiente de se implementar, e gera um desempenho que, embora no timo, geralmente tido como adequado.

LRU (Least Recently Used) Uma boa aproximao para o algoritmo timo baseada em uma observao comum que as pginas muito usadas nas ltimas instrues, provavelmente o sero nas prximas instrues. Da mesma forma, pginas que no tm sido usadas por um longo tempo provavelmente continuaro sem uso. Esta observao sugere um algoritmo realizvel. Na ocorrncia de uma falta de pgina, este algoritmo ir remover as pginas menos referenciadas nas ltimas instrues, pois ele parte do princpio que as pginas que foram referenciadas nas ltimas instrues continuaro sendo acessadas. Embora o algoritmo LRU seja teoricamente realizvel, seu custo alto. Para implementao completa do LRU, necessrio manter uma lista ligada de todas as pginas em memria, com a pgina mais recentemente usada no incio e a menos recentemente usada no final. A dificuldade que a lista deve ser atualizada em toda referncia de memria. Encontrar a pgina na lista, remov-la de sua posio corrente, e mov-la para o incio representa um esforo no desprezvel. Manipular uma lista ligada a toda instruo proibitivo, at mesmo em hardware. Entretanto, h outras maneiras de implementar LRU com um hardware especial. Vamos considerar o caminho mais simples primeiro. Este mtodo requer equipar o hardware com um contador de 64 bits, C, que automaticamente incrementado aps cada instruo.

73

Alm disso, cada entrada na tabela de pginas deve tambm ter um campo grandeo bastante para conter o contador. Aps cada referncia de memria, o corrente valor de C armazenado na entrada da tabela de pginas para a pgina referenciada. Quando ocorre uma falta de pgina, o sistema operacional examina todos os contadores na tabela de pginas para achar o menor deles. A pgina correspondente a menos recentemente usada. Agora vejamos um segundo algoritmo LRU, tambm em hardware. Para uma mquina com N page frames, o LRU deve manter uma matriz de N x N bits, inicialmente todos zero. Sempre que uma moldura k for referenciada, o hardware coloca todos os bits da linha k em 1, e depois zera todos os bits da coluna k. Em cada instante, a linha com o menor valor binrio armazenado ser correspondente pgina usada h mais tempo; aquela com o prximo valor ser a prxima usada h mais tempo, e assim por diante. Um exemplo do funcionamento deste algoritmo aparece ilustrada na figura para quatro molduras de pgina e a seguinte ordem de referncias s pginas: 5 0 1 2 3 2 1 0 3 2 3 . Neste exemplo a pgina usada h mais tempo a 1

Considerando-se o funcionamento dos algoritmos de substituio de pginas, possvel pensar, de incio, que quanto maior for o nmero de page frames, menor ser a ocorrncia de faltas de pginas durante o perodo de execuo de um processo. Entretanto, estudos demonstraram que este pensamento nem sempre verdadeiro e este fato ficou conhecido como anomalia de Belady. Um exemplo de ocorrncia da mencionada anomalia encontra-se detalhado na Figura abaixo, onde utilizado o algoritmo de substituio de pginas FIFO que, inicialmente, simulado com 3 page frames e apresenta 9 faltas de

74

pginas. Em seguida, realizada a simulao do FIFO com 4 molduras de pginas e observado que o nmero de falta de pginas se eleva para 10. Dessa forma, possvel verificar a presena da anomalia de Belady, pois a memria fsica foi aumentada e o nmero de falta de pginas tambm.

Aps a verificao da anomalia de Belady, muitos estudos foram desenvolvidos e foi observado que alguns algoritmos no apresentavam tal anomalia e estes foram chamados de algoritmos de pilha. Obs.: 1) O LRU um algoritmo de pilha e no apresenta a anomalia de Belady; 2) O FIFO, como foi visto anteriormente, apresenta a anomalia de Belady. SEGMENTAO

75

 a tcnica de gerncia de memria onde o espao de endereamento virtual dividido em blocos de tamanhos diferentes chamados segmentos. Cada segmento tem um nmero e um tamanho, conforme pode ser observado na Figura. Nesta tcnica um programa dividido logicamente em sub-rotinas e estruturas de dados, que so alocados em segmentos na memria principal. Enquanto na tcnica de paginao o programa dividido em pginas de tamanho fixo, sem qualquer ligao com sua estrutura, na segmentao existe uma relao entre a lgica do programa e sua alocao na memria principal. Normalmente, a definio dos segmentos realizada pelo compilador, a partir do cdigo fonte do programa, e cada segmento pode representar um procedimento, uma funo, vetor ou pilha. Na segmentao, os endereos especificam o nmero do segmento e o deslocamento dentro do mesmo.

76

Assim, para mapear um endereo virtual composto pelo par <segmento, deslocamento> o hardware de segmentao considera a existncia de uma tabela de segmentos. Cada entrada da tabela de segmentos possui a base e o limite de cada segmento. A base contm o endereo fsico de incio do segmento e o limite especifica o seu tamanho. A figura apresentada a seguir ilustra o funcionamento do mapeamento de um endereo virtual em um sistema que utiliza a segmentao.

Os segmentos podem se tornar muito grandes e, s vezes, pode ser impossvel manter todos na memria ao mesmo tempo. Para resolver este problema implementa-se a paginao em cada um dos segmentos, dando origem, ento, segmentao paginada.

Segmentao paginada a tcnica de gerncia de memria onde o espao de endereamento dividido em segmentos e, por sua vez, cada segmento dividido em pginas. Esse esquema de gerncia de memria tem o objetivo de oferecer as vantagens de ambas as tcnicas.

77

Na viso do programador, sua aplicao continua sendo mapeada em segmentos de tamanhos diferentes, em funo das sub-rotinas e estruturas de dados definidas no programa. Por outro lado, o sistema trata cada segmento como um conjunto de pginas do mesmo tamanho, mapeadas por uma tabela de pginas associada ao segmento. Desta forma, um segmento no precisa estar contguo na memria principal, eliminando o problema da fragmentao externa encontrado na segmentao pura.

GERENCIAMENTO DE ARQUIVOS So recipientes que contm dados. Cada arquivo identificado por um nome e por uma srie de outros atributos que so mantidos pelo sistema operacional: tipo do contedo, tamanho, ltimo acesso, ltima alterao. O Sistema Operacional suporta diversas operaes sobre arquivos, como criao, destruio, leitura, alterao, etc. Em geral, essas operaes correspondem a chamadas de sistema que os programas de usurios podem usar para manipular arquivos. Existe, na prtica, uma enorme quantidade de diferentes tipos de arquivos, cada tipo com sua estrutura interna particular. No vivel para o sistema operacional conhecer todos os tipos de arquivos existentes. Em geral, os sistemas operacionais ignoram a estrutura interna dos arquivos. Para o sistema operacional, cada arquivo corresponde a uma seqncia de bytes, cujo significado conhecido pelo usurio que criou o arquivo. A nica exceo so os arquivos que contm programas executveis. Nesse caso, a estrutura interna definida pelo prprio sistema operacional, responsvel pela carga do programa para a memria quando esse deve ser executado. Como o conceito de tipo de arquivo til para os usurios, muitos sistemas operacionais suportam nomes de arquivos onde o tipo indicado. A forma usual acrescentar uma extenso no nome que identifique o tipo do arquivo em questo.

78

Arquivos podem consistir em um ou mais registros. Um registro fsico (ou bloco fsico) a unidade de informao realmente lida de ou escrita para um dispositivo de armazenamento. Um registro lgico (ou bloco lgico) uma coleo de dados tratada como uma unidade pelo software. Quando cada registro fsico contm exatamente um registro lgico, diz-se que o arquivo consiste em registros no blocados. Em um arquivo com registros de tamanho fixo, todos os registros tm o mesmo tamanho; o tamanho do bloco , ordinariamente, um mltiplo inteiro do tamanho do registro. Em um arquivo com registros de tamanhos variveis, os tamanhos dos registros podem variar at o tamanho do bloco.

SISTEMAS DE ARQUIVOS Um sistema de arquivo organiza arquivos e gerencia o acesso aos dados. Eles so responsveis por: Gerenciamento de arquivos fornecer os mecanismos para que os arquivos sejam armazenados, referidos, compartilhados e fiquem em segurana. Gerenciamento de armazenamento auxiliar alocar espao para arquivos em dispositivos de armazenamento secundrio. Mecanismos de integridade do arquivo garantir que as informaes armazenadas em um arquivo no sejam corrompidas. Quando a integridade do arquivo assegurada, os arquivos contm somente as informaes que devem conter. Mtodos de acesso como os dados armazenados podem ser acessados.

DIRETRIOS Considere um sistema de compartilhamento de grande escala que suporte uma grande comunidade de usurios. Cada usurio pode conter vrias contas; cada conta pode ter muitos arquivos. Alguns arquivos podem ser pequenos, como mensagens de e-mail; outros podem ser grandes, como listas de um controle de estoque.

79

 comum que contas de usurios contenham centenas e at milhares de arquivos. Com uma comunidade de vrios milhares de usurios, os discos de um sistema poderiam facilmente conter milhes de arquivos. Esses arquivos precisam ser acessados rapidamente para limitar os tempos de resposta. Para organizar e localizar arquivos rapidamente, sistemas de arquivos usam diretrios, que so arquivos que contm os nomes e as localizaes de outros arquivos do sistema de arquivos. Diferentemente de outros arquivos, um diretrio no armazena dados de usurios, mas campos como nome, localizao, tamanho, tipo, horrio de acesso, de modificao e de criao do arquivo.

Sistema de Arquivo de nvel nico

A organizao mais simples de sistemas de arquivo uma estrutura de diretrio de nvel nico (ou plana). Nessa implementao, o sistema de arquivo armazena todos os seus arquivos utilizando um s diretrio. Em um sistema de arquivo de nvel nico, dois arquivos no podem ter o mesmo nome. Porque a maioria dos ambientes contm um grande nmero de arquivos, muitos dos quais usam o mesmo nome, tais sistemas de arquivos so raramente implementados.

Sistema de Arquivo estruturado hierarquicamente

Um sistema de arquivo mais apropriado para a maioria dos ambientes pode ser organizado da maneira como apresentado na figura a seguir. Uma raiz indica em que lugar do dispositivo de armazenamento comea o diretrio-raiz. O nome de um arquivo usualmente formado como o nome de caminho desde o diretrio-raiz at o arquivo. Por exemplo, em um sistema de arquivo de dois nveis com os usurios BRUNA, ANDRE e SOFIA, no qual ANDRE tem os arquivos MESADA e ESTUDOS, o nome do caminho para o arquivo MESADA poderia ser formado como RAIZ:

80

ANDRE:MESADA. Nesse exemplo, RAIZ indica o diretrio-raiz. Sistemas hierrquicos de arquivo so implementados pela maioria dos sistemas de arquivos de propsito geral, mas o nome do diretrio-raiz pode variar entre sistemas de arquivos. O diretrio-raiz de um sistema de arquivo do Windows especificado por uma letra seguida de dois pontos (por exemplo, C:) e sistema de arquivo baseados no Unix usam uma barra inclinada ( / ). No Windows o exemplo utilizado acima seria C:\ANDRE\MESADA e no Unix seria /ANDRE/MESADA.

Nomes de caminhos relativos Muitos sistemas de arquivos suportam a noo de um diretrio de trabalho para simplificar a navegao usando nomes de caminhos. O diretrio de trabalho (representado pela entrada de diretrio . nos sistemas de arquivo do Windows e baseados no Unix) habilita usurios a especificar um nome de caminho que no comece no diretrio-raiz. Por exemplo, suponha que o diretrio de trabalho corrente tenha sido designado /home/hmd/ em um sistema de arquivos. O nome de caminho relativo para /home/hmd/lucilia/cap8 seria ./lucilia/cap8. Essa caracterstica reduz o tamanho do nome de caminho para acessar arquivos. Quando um sistema de arquivos encontra um nome de caminho relativo, forma um nome de caminho absoluto (ou seja, o caminho que comea na raiz) concatenando o diretrio de trabalho e o caminho relativo. O sistema de arquivo ento percorre a estrutura de diretrio para localizar o arquivo requisitado. O sistema de arquivo normalmente mantm uma referncia ao diretrio-pai do diretrio de trabalho, ou seja, o diretrio que est um nvel acima na hierarquia do sistema de arquivo. No Windows e nos sistemas baseados em Unix, .. uma referncia ao diretrio-pai. Ligao (link) uma entrada de diretrio que se refere a um arquivo de dados ou diretrio que normalmente est localizado em um diretrio diferente. Usurios comumente empregam ligaes para simplificar a navegao do sistema de arquivos e compartilhar arquivos. Por

81

exemplo, suponha que o diretrio de trabalho de um usurio seja /home/drc/ e o usurio compartilhe os arquivos de um outro usurio localizado no diretrio /home/hmd/lucilia. Criando uma ligao para /home/hmd/lucilia no diretrio de trabalho do usurio, esse pode acessar os arquivos compartilhados simplesmente por meio do nome de caminho relativo lucilia/. Ligao flexvel (tambm chamada de ligao simblica, atalho ou apelido), uma entrada de diretrio que contm o nome de caminho para um outro arquivo. O sistema de arquivos localiza o alvo da ligao flexvel percorrendo a estrutura do diretrio por meio do nome de caminho especificado. Ligao estrita uma entrada de diretrio que especifica a localizao do arquivo (normalmente um nmero de bloco) no dispositivo de armazenamento. O sistema de arquivo localiza os dados do arquivo da ligao estrita acessando diretamente o bloco fsico a que ela se refere.

A figura abaixo ilustra a diferena entre ligaes flexveis e ligaes estritas. Os arquivos hoje e ontem esto localizados nos blocos nmero 467 e 843, respectivamente. A entrada de diretrio hoje_hard uma ligao estrita, porque especifica o mesmo nmero de bloco (467) da entrada do diretrio hoje. A entrada de diretrio hoje_soft uma ligao flexvel, porque especifica o nome do caminho para hoje (neste caso, ./hoje)

82

BIBLIOGRAFIA Esta apostila foi totalmente baseada nos livros: Deitel h. M., deitel p. J. E choffnes d.r. sistemas operacionais. So paulo, 2005. Prentice hall. Tanembaum, andrew s. Sistemas operacionais modernos. So paulo, 2003. Prentice hall. Maia, luiz paulo e machado, francis berenger. Arquitetura de sistemas operacionais. Rio de janeiro, 2002. Ltc.

83

Anexo A

Assembly code

bin2dec.asm ; input8 bit binary number and print out decimal to screen. ; zeros and ones -> decimal value ORG 100h ; this macro prints a char in AL and advances ; the current cursor position: PUTC MACRO char PUSH AX MOV AL, char MOV AH, 0Eh INT 10h POP AX ENDM .data ; null terminated input string: DB "0" s1 DB "00000000", 0 sum DW 0 ; result. flag DB 0 .code CALL print DB 0dh, 0ah, "8 bit binary: ", 0 ; get string: MOV DX, 9 ; buffer size (1+ for zero terminator). LEA DI, s1 CALL GET_STRING ; check that we really got 8 zeros and ones MOV CX, 8 MOV SI, OFFSET s1 check_s: CMP [SI], 0 JNE ok0 MOV flag, 1 ; terminated. JMP convert ok0: CMP [SI], 'b' JNE ok1 MOV flag, 1 ; terminated. JMP convert ok1: ; wrong digit? Not 1/0? CMP [SI], 31h JNA ok2 JMP error_not_valid ok2: INC SI LOOP check_s ; start the conversion from string to value in SUM variable. convert: MOV BL, 1 ; multiplier. MOV CX, SI SUB CX, OFFSET s1 DEC SI JCXZ stop_program next_digit: MOV AL, [SI] ; get digit. SUB AL, 30h MUL BL ; no change to AX. ADD SUM, AX SHL BL, 1 DEC SI ; go to previous digit. LOOP next_digit ; done! converted number is in SUM. ; check if signed TEST sum, 0000_0000_1000_0000b JNZ print_signed_unsigned print_unsigned: CALL print DB 0dh, 0ah, "decimal: ", 0 MOV AX, SUM CALL PRINT_NUM_UNS JMP stop_program print_signed_unsigned: CALL print DB 0dh, 0ah, "unsigned decimal: ", 0 ; print out unsigned: MOV AX, SUM CALL PRINT_NUM_UNS CALL print DB 0dh, 0ah, "signed decimal: ", 0 ; print out singed: MOV AX, SUM CBW ; convert byte into word.

84

CALL PRINT_NUM JMP stop_program

CMP CX, DX ; buffer is full? JAE wait_for_key ; if so wait for 'BACKSPACE' or 'RETURN'... MOV [DI], AL INC DI INC CX ; print the key: MOV AH, 0Eh INT 10h JMP wait_for_key ;============================ exit: ; terminate by null: MOV [DI], 0 empty_buffer: POP DX POP DI POP CX POP AX RET GET_STRING

error_not_valid: CALL print DB 0dh, 0ah, "error: only zeros and ones are allowed!", 0 stop_program: ; wait for any key.... CALL print DB 0dh, 0ah, "press any key...", 0 MOV AH, 0 INT 16h RET ; copied from c:\emu8086\emu8086.inc GET_STRING PROC NEAR PUSH AX PUSH CX PUSH DI PUSH DX MOV CX, 0 ; char counter. ; buffer too small? ; ; reserve space for last

CMP DX, 1 JBE empty_buffer DEC zero. DX

ENDP

; copied from c:\emu8086\emu8086.inc PRINT_NUM PROC NEAR PUSH DX PUSH AX CMP AX, 0 JNZ not_zero PUTC '0' JMP printed_pn

;============================ ; loop to get and processes key presses: wait_for_key: MOV AH, 0 INT 16h CMP AL, 13 JZ exit ; get pressed key.

; 'RETURN' pressed?

not_zero: ; the check SIGN of AX, ; make absolute if it's negative: CMP AX, 0 JNS positive NEG AX PUTC '-'

CMP AL, 8 ; 'BACKSPACE' pressed? JNE add_to_buffer JCXZ wait_for_key ; nothing to remove! DEC CX DEC DI PUTC 8 ; backspace. PUTC ' ' ; clear position. PUTC 8 ; backspace again. JMP wait_for_key add_to_buffer:

positive: CALL PRINT_NUM_UNS printed_pn: POP AX POP DX RET ENDP ; copied from c:\emu8086\emu8086.inc PRINT_NUM_UNS PROC NEAR PUSH AX

85

PUSH PUSH PUSH

BX CX DX

; flag to prevent printing zeros before number: MOV CX, 1 ; (result of "/ 10000" is always less or equal to 9). MOV BX, 10000 ; 2710h - divider. ; AX is zero? CMP AX, 0 JZ print_zero begin_print: ; check divider (if zero go to end_print): CMP BX,0 JZ end_print ; avoid printing zeros before number: CMP CX, 0 JE calc ; if AX<BX then result of DIV will be zero: CMP AX, BX JB skip calc: MOV CX, 0 ; set flag.

PUSH AX MOV DX, 0 MOV AX, BX DIV CS:ten ; AX = DX:AX / 10 (DX=remainder). MOV BX, AX POP AX JMP print_zero: PUTC end_print: POP POP POP POP RET ten ENDP DX CX BX AX DW 10 ; used as divider. begin_print

'0'

MOV DX, 0 DIV BX ; AX = DX:AX / BX (DX=remainder). ; print last digit ; AH is always ZERO, so it's ignored ADD AL, 30h ; convert to ASCII code. PUTC AL

MOV div. skip:

AX, DX ; get remainder from last

; calculate BX=BX/10

; print text that follows the caller print PROC MOV CS:temp1, SI ; store SI register. POP SI ; get return address (IP). PUSH AX ; store AX register. next_char: MOV AL, CS:[SI] INC SI ; next byte. CMP AL, 0 JZ printed_ok MOV AH, 0Eh ; teletype function. INT 10h JMP next_char ; loop. printed_ok: POP AX ; re-store AX register. ; SI should point to next command after ; the CALL instruction and string definition: PUSH SI ; save new return address into the Stack. MOV SI, CS:temp1 ; re-store SI register. RET temp1 DW ? ; variable to store original value of SI register. ENDP

86