SISTEMAS OPERACIONAIS

Ricardo Luís de Freitas

SISTEMAS OPERACIONAIS
INTRODUÇÃO ......................................................................................................................................... 1 1.1. Definição............................................................................................................................................ 1 1.1.1. S.O. como Máquina Virtual ........................................................................................................ 2 1.1.2. S.O. como Gerenciador de Recursos............................................................................................ 3 1.2. Histórico............................................................................................................................................. 3 1.2.1. Válvulas e Painéis de Conexão (1945-1955)................................................................................ 3 1.2.2. Transístores e Sistemas de Lote (batch) (1955-1965)................................................................... 4 1.2.3. Circuitos Integrados e Multiprogramação (1965-1980)................................................................ 5 1.2.4. Computadores Pessoais e Redes (1980 - 1990) ............................................................................ 7 2. PROCESSOS ............................................................................................................................................. 8 2.1. Introdução .......................................................................................................................................... 8 2.1.1. Hierarquia de Processos ............................................................................................................ 10 2.1.2. Estados dos Processos ............................................................................................................... 10 2.1.3. Implementação de Processos ..................................................................................................... 11 3. COMUNICAÇÃO ENTRE PROCESSOS ................................................................................................ 12 3.1. Condições de Disputa ....................................................................................................................... 12 3.2. Seções Críticas ................................................................................................................................. 13 3.3. Exclusão Mútua com Espera Ocupada .............................................................................................. 14 3.3.1. Desabilitando interrupções ........................................................................................................ 14 3.3.2. Variáveis de Comporta.............................................................................................................. 14 3.3.3. Alternância Estrita.................................................................................................................... 14 3.4. SLEEP e WAKEUP.......................................................................................................................... 15 3.5. Semáforos......................................................................................................................................... 18 3.6. Monitores ......................................................................................................................................... 19 3.7. Passagem de Mensagens................................................................................................................... 22 4. ESCALONAMENTO DE PROCESSOS .................................................................................................. 25 4.1. Escalonamento "Round-Robin"......................................................................................................... 26 4.2. Escalonamento com Prioridade......................................................................................................... 27 4.3. Filas Múltiplas ................................................................................................................................. 28 4.4. Menor Serviço (job) Primeiro ........................................................................................................... 29 4.5. Escalonamento Dirigido a Política.................................................................................................... 30 4.6. Escalonamento em Dois Níveis......................................................................................................... 30 5. GERENCIAMENTO DE MEMÓRIA ...................................................................................................... 32 5.1. Gerenciamento de Memória sem Troca ou Paginação ....................................................................... 32 5.2. Monoprogramação sem Troca ou Paginação ..................................................................................... 32 5.3. Multiprogramação ............................................................................................................................ 32 5.3.1. Multiprogramação com Partições Fixas..................................................................................... 33 5.3.2. Relocação e Proteção................................................................................................................. 34 5.3.3. Troca (swapping) ...................................................................................................................... 36 5.3.4. Multiprogramação com Partições Variáveis............................................................................... 36 5.4. Gerenciamento de Espaço................................................................................................................. 37 5.4.1. Gerencimento com Mapa de Bits............................................................................................... 37 5.4.2. Gerenciamento com Listas Encadeadas ..................................................................................... 38 5.5. Alocação de Espaço de Troca (swap) ................................................................................................ 39 5.6. Memória Virtual............................................................................................................................... 40 5.6.1. Paginação ................................................................................................................................. 40 5.6.2. Segmentação............................................................................................................................. 43 6. ALGORITMOS DE MUDANÇA DE PÁGINA........................................................................................ 45 6.1. Mudança Ótima de Página................................................................................................................ 45 6.2. Mudança da Página não Recentemente Usada................................................................................... 46 6.3. Mudança de Página "Primeira a Entrar, Primeira a Sair"(FIFO) ....................................................... 47 6.4. Mudança da Página Menos Recentemente Utilizada ......................................................................... 47 6.5. Simulando LRU em Software ........................................................................................................... 48 1.

6.6. Considerações de Projeto para Sistemas de Paginação....................................................................... 49 6.6.1. Modelo do Conjunto Ativo (Working Set) ................................................................................. 50 6.6.2. Rotinas de Alocação Local X Global ......................................................................................... 51 6.6.3. Tamanho da Página .................................................................................................................. 53 6.6.4. Considerações de Implementação.............................................................................................. 54 7. ENTRADAS E SAÍDAS .......................................................................................................................... 56 7.1. Princípios de Hardware de E/S ......................................................................................................... 56 7.1.1. Dispositivos de E/S ................................................................................................................... 56 7.1.2. Controladores de Dispositivos ................................................................................................... 57 7.1.3. Acesso Direto à Memória.......................................................................................................... 57 7.2. Princípios de Software de E/S........................................................................................................... 58 7.2.1. Objetivos do Software de E/S .................................................................................................... 58 7.2.2. Tratadores de Interrupção ......................................................................................................... 59 7.2.3. Condutores de Dispositivos (device drivers) .............................................................................. 60 7.2.4. Software Independente de Dispositivo ....................................................................................... 60 7.2.5. Software de E/S no Espaço de Usuário ...................................................................................... 62 8. DEADLOCK ........................................................................................................................................... 63 8.1. Recursos........................................................................................................................................... 63 8.2. Modelamento de Deadlock................................................................................................................ 64 8.3. O "Algoritmo da Avestruz"............................................................................................................... 67 8.4. Detecção e Recuperação.................................................................................................................... 67 8.5. Prevenção de Deadlock..................................................................................................................... 68 8.6. Evitação Dinâmica de Deadlock ....................................................................................................... 69 8.6.1. Algoritmo do Banqueiro para um único Recurso ....................................................................... 69 8.6.2. O Algoritmo do Banqueiro para Vários Recursos ...................................................................... 71 9. SISTEMA DE ARQUIVOS...................................................................................................................... 73 9.1. Visão do Usuário .............................................................................................................................. 73 9.2. Pontos Básicos com Relação a Arquivos ........................................................................................... 73 9.3. Diretórios ......................................................................................................................................... 74 9.3.1. Conceito ................................................................................................................................... 74 9.3.2. Estrutura do Diretório ............................................................................................................... 75 9.4. Projeto de Sistema de Arquivos......................................................................................................... 77 9.4.1. Gerenciamento do Espaço em Disco.......................................................................................... 77 9.4.2. Armazenamento de Arquivos .................................................................................................... 78 9.4.3. Arquivos Compartilhados ......................................................................................................... 81

Ricardo Luís de Freitas

Notas de Aula - Sistemas Operacionais -

1

1. INTRODUÇÃO
1.1. Definição

Qualquer pessoa que teve algum contato com um sistema de computação sabe que o mesmo consiste em dois componentes principais: o hardware (que engloba toda a parte fisicamente montada, em geral em circuitos eletrônicos) e o software (que compreende toda a programação para levar o hardware a executar o que foi determinado pelo usuário). É óbvio que a falta de qualquer um dos componentes acima acarreta a inutilidade do outro, bem como a ineficiência de um tem implicações sérias na utilização do outro. O que talvez não seja de conhecimento difundido é o fato de que, nos sistemas atuais, tanto o hardware como o software apresentam uma organização aproximada em camadas, de forma a facilitar a sua utilização. É possível apresentar um esquema para essa organização como na Figura1:

Figura1: Organização do hardware e software em camadas

Na parte de hardware, a linguagem de máquina é

o que o usuário "enxerga" do

processador, isto é , o seu único modo de operar com o processador é através da linguagem de máquina. Ao chegar no processador uma instrução de máquina, a microprogramação é a responsável pela interpretação e controle da sua execução, através da ativação dos dispositivos físicos. Em alguns processadores pequenos a interpretação e controle de execução é também realizada por meio de dispositivos, deixando portanto de existir a

formatação.O. a função do S. é apresentar ao usuário uma máquina com as seguintes características: i) Facilidade de operação: isto é . leitura ou escrita. todos os futuros posicionamentos serão errados. Para possibilitar o desenvolvimento de programas aplicativos existem programas como compiladores. bem como fornecer facilidades extras ao usuário existe o sistema operacional. Um exemplo típico disto é a escrita em disco flexível. Na parte de Software. Para permitir a utilização eficiente dos recursos de hardware. entre outros. do tipo de acesso (leitura.O.O.O.Ricardo Luís de Freitas Notas de Aula . S. Atualmente existem diversos controladores de disco que cuidam eles mesmo de tarefas como posicionamento da cabeça. Estes programas não deixam de ser aplicativos. de forma que se a mesma se apresenta inicialmente mal posicionada. o objetivo final são os programas aplicativos. o deslocamento da mesma para a trilha requerida. deve fornecer uma interface entre o usuário e o hardware que apresenta maior facilidade de programação de a presente originalmente no hardware. verificação de erros. pois cada movimento posterior da cabeça é sempre relativo.1. editores de texto. espera do setor: que representa uma espera até que a cabeça de leitura se posiciona sobre o setor. escrita dos dados . apenas são voltados ao programador e não ao usuário final. Além destes passos podem existir outros. No entanto mesmo nestes casos o processo de controle restante ao processador central é complicado. um controlador precisa das seguintes instruções: recalibração: corresponde a um ajuste da cabeça de leitura na primeira trilha. Pode-se dividir as funções do S.verificação: para garantir que os dados foram verdadeiramente escritos e sem nenhum erro. dependendo do controlador utilizado. movimento da cabeça: isto é . escrita. Para esta operação. o S. depuradores. em duas categorias: a definição de uma máquina virtual e o gerenciamento de recursos.Sistemas Operacionais - 2 camada de microprogramação.1. 1. como Máquina Virtual Como formador de uma máquina virtual. pois exige tarefas como: • controle das trilhas e setores físicos onde se encontra ou deve ser colocada a informação . etc) e de se ocorrem erros ou não.

2. A programação era realizada através de painéis onde as conexões realizadas representavam os 0 e 1 dos códigos binários da linguagem de máquina. e os avanços em hardware. pode fornecer também algumas capacidades não presentes no computador original.O.1.O. realizar a contagem de utilização de recursos e mediar conflitos nos pedidos de recursos por vários programas. consistindo em salas inteiras de circuito. aceitar (ordenadamente) requisições de um dado recurso. múltiplos usuários e sistemas de proteção de acesso.Ricardo Luís de Freitas Notas de Aula . Não existia o . consumindo energia elétrica suficiente para cidades inteiras. Válvulas e Painéis de Conexão (1945-1955) Os primeiros computadores foram implementados através de válvulas a vácuo.O.O. visto que os mesmos são bastante frequentes nos meios magnéticos atuais devido a condições transitórias Como vemos. Para isto.Sistemas Operacionais - 3 • tentar novamente no caso de ocorrência de erros. o programador médio não deve ser envolvido com os detalhes deste processo todo. ao S. enfatizando a relação entre a evolução dos S.1.2. por exemplo.2. 1. S. 1. Histórico Para uma melhor idéia do curso de desenvolvimento dos sistemas operacionais atuais. 1. como Gerenciador de Recursos Como um gerenciador de recursos. compete cuidar de quem está usando que recurso. apresentamos a esquematização da evolução histórica dos mesmos.O. os sistemas operacionais fornecem métodos muito mais simples e estruturados de uma forma mais voltada aos problemas do usuário do que é a estrutura interna do computador ii) Extensão das capacidades da máquina: o S. como. é controlar (ou gerenciar) a utilização de todos os recursos fornecidos pelo hardware e a sua distribuição entre os diversos programas que competem por ele de forma a garantir: i) a execução correta dos diversos programas ii) alta eficiência na utilização dos recursos Dentro deste ponto de vista então. a função do S.

Transístores e Sistemas de Lote (batch) (1955-1965) A introdução dos transístores. ii) o operador junta os conjuntos de cartões e. Se o compilador FORTRAN for necessário. buscando conjuntos de cartões a serem utilizados e pela lentidão dos dispositivos de entrada e saída (leitora de cartões e impressora). Este processo. iv) os programas da fita são executados e o resultado é gravado em outra fita magnética. programadores e pessoal da manutenção. iii) a fita magnética é levada ao processador principal e lida. sendo que cada usuário introduzia o seu programa por painéis e aguardava os resultados. com a utilização de um computador mais barato.2.Sistemas Operacionais - 4 conceito de sistema operacional. ele é colocado (também como um conjunto de cartões) na leitora. devido à baixa confiabilidade das válvulas a vácuo. Entretanto. Seu uso era portanto restrito à entidades governamentais. ii) o operador pega os cartões e os coloca na leitura. . grava-os em uma fita magnética. desperdiça muito tempo de programação devido ao deslocamento do operador pela sala. A probabilidade de falha do sistema durante a execução de algum programa era altíssima. grandes corporações e universidades. resumidamente: i) perfuração de um conjunto de cartões com o programa a ser executado. 1. com a consequente redução de tamanho e consumo e o aumento da confiabilidade permitiu o desenvolvimento dos primeiros sistemas realmente utilizáveis fora dos círculos acadêmicos e governamentais. Para maximizar a eficiência na utilização dos processadores. devendo ser acondicionados em grandes salas com ar condicionado e operados por pessoal profissional. O processo de execução de uma tarefa (job) era.Ricardo Luís de Freitas Notas de Aula . operadores.2. o que garantiu a comercialidade dos mesmos. Começa a surgir nesta época a distinção entre projetistas. iii) o resultado sai na impressora e é levado pelo operador para um local onde o usuário o recolhe. foi utilizada um novo procedimento: i) perfuração dos cartões e envio ao operador. os computadores ainda eram extremamente grandes e caros. e devido ao surgimento das unidades de fita magnética. construtores. além de lento.

Este processo. Este aumento do tempo de resposta do sistema se dá em função de se juntar uma quantidade razoável de conjuntos de cartões para se gravar uma fita. vi) a saída da impressora é entregue aos usuários. Circuitos Integrados e Multiprogramação (1965-1980) Com a introdução de circuitos integrados. de forma que os próprios se responsabilizam pelo controle da transferência de dados entre eles e a memória principal. 1. ii) durante a execução de programas com alta utilização de entrada e saída (ex: programas comerciais com consultas à base de dados e impressão de relatórios) o processador permanece durante grande porcentagem do tempo aguardando os dispositivos de entrada/saída.Ricardo Luís de Freitas Notas de Aula . Isto fica ainda mais crítico quando um dos programas de uma fita apresenta um tempo de execução muito elevado. bem com um aumento em sua complexidade e generalidade. Estes foram fatores fundamentais para o sucesso do conceito de multiprogramação. que permitem um acesso aleatório à informação contida nos mesmos.3. Isto permitiu o desenvolvimento de dispositivos de entrada e saída inteligentes. . que somente permitem um acesso aos dados na ordem em que os mesmos estão gravados (note que isto pode ficar transparente através de uma programação cuidadosa. cada usuário. Outro desenvolvimento importante foi a introdução dos discos.2. Simultaneamente com a utilização de circuitos integrados.Sistemas Operacionais - 5 v) esta fita de saída é levada ao computador secundário (mais barato). Porém aumentou o tempo de resposta do sistema para cada usuário. denominado OFF-LINE. A idéia provém dos seguintes fatos: i) durante a execução de programas que realizam alta utilização de cálculos (ex: programas científicos) todos os dispositivos de entrada e saída permanecem inativos. surgiu o conceito de multiprogramação. diferentemente das fitas magnéticas. apresentado a seguir. Desta forma. entretanto com alto custo em tempo de execução). deve aguardar a execução de diversos outros programas armazenados na mesma fita. garantiu uma maior eficiência na utilização do processador principal. houve uma grande redução no tamanho e custo dos sistemas. lida e seu conteúdo impresso em uma impressora comum. para obter a resposta a seu programa.

o sistema continuava sendo um sistema de lotes. executando programas diversos ou cooperando na execução de um mesmo programa. Para diminuir o tempo de resposta do sistema a um dado job foi introduzido o conceito de compartilhamento de tempo ("time-sharing"). e não necessariamente por ordem de chegada.Sistemas Operacionais - 6 Desta forma. o sistema operacional podia escolher entre eles por prioridade. Multiprogramação: corresponde a diversos programas distintos executando em um mesmo processador. principalmente quando se está realizando a depuração de programas. se alguma tarefa precisa aguardar a transferência de dados para um dispositivo. no fundo. dentro de um mesmo sistema de computação. com a leitura simultânea dos dados para um meio de armazenamento mais rápido e com a transferência de dados entre os meios realizada simultaneamente com a operação da unidade de processamento principal.: Multiprogramação e multiprocessamento: Estes conceitos devem ser claramente distinguidos. outra tarefa pode utilizar o processador central neste período. sendo o tempo entre a apresentação de um conjunto de cartões e a retirada do resultado extremamente alto. até este ponto. Outro conceito introduzido foi o de "SPOOL (de "Simultaneous Peripherical Operation On Line") que corresponde à leitura imediata dos jobs para o disco no momento da sua chegada. sendo que ao terminar um dos jobs ativos. . dispondo de diversos jobs a serem executados no disco. alguns lotes com a utilização do tempo disponível devido à lentidão de entrada de dados dos usuários. Este processo tem a vantagem de que. no qual cada usuário possui um terminal ligado em linha com o computador. surgiu a idéia de se colocar diversas tarefas (jobs) dentro de alguma "partição" da memória principal e executando simultaneamente de forma que. com uma menor capacidade de processamento numérico mas também com um custo muito menor. podendo ainda o computador rodar. Nesta época também surgiram os minicomputadores. desapareceu praticamente o tempo manual de montagem e desmontagem de fitas. um novo job é imediatamente carregado do disco para a partição de memória vazia e executado (partição é um trecho de memória alocado a um job). Obs. Entretanto. Multiprocessamento: corresponde a diversos processadores. Além disso.Ricardo Luís de Freitas Notas de Aula .

Os sistemas operacionais para redes são divididos em duas categorias: 1.O.Ricardo Luís de Freitas Notas de Aula . de forma que nenhum usuário tenha conhecimento de quantos computadores há na rede ou de em qual (ou quais) computador o seu específico programa está executando..4.2. . sistemas operacionais distribuídos: em que o sistema operacional faz com que todos os computadores da rede formem uma unidade. provavelmente. 2. Computadores Pessoais e Redes (1980 . mas a relação para por aí. 1. sistemas operacionais de rede: no qual cada usuário tem conhecimento de seu próprio computador e pode acessar dados em outros computadores.Sistemas Operacionais - 7 Note que foi a existência de multiprocessamento entre os dispositivos de entrada/saída e o processador central que tornou atrativa a introdução da multiprogramação.1990) Com a integração em larga escala e o surgimento dos microcomputadores. não têm nenhum interesse em vir a conhecer algo. que consistem em computadores distintos interligados por elementos de comunicação. Um outro desenvolvimento interessante que foi bastante impulsionado pelos microcomputadores (apesar de não depender dos mesmos) é o de sistemas operacionais para redes de computadores. que corresponde ao desenvolvimento de sistemas operacionais para serem utilizados por pessoas sem nenhum conhecimento de computação e que. surge também o conceito de "user-friendly" para S.

PROCESSOS 2. e a distribuição de tempo da UCP real entre os diversos processos. Define-se um processo como um programa em execução.O. na grande maioria dos casos uma única UCP é compartilhada entre todos os processos. mas tantas UCP virtuais quantos forem os processos. considera-se todo o software como organizado em um número de processos sequenciais ou. Introdução No método tradicional de S. Na realidade. Cada processo trabalha como se possuísse para si uma UCP (unidade central de processamento. mais simplesmente.1. conforme a Figura 2 apresentada abaixo. Com isto. é o fato de que a taxa de execução de cada processo não é uniforme nem reproduzível. sendo que para sua especificação completa. o processador principal do computador) própria. Os processos. PC). e que apresenta fundamental importância no desenvolvimento de sistemas operacionais. onde é mostrada a execução na UCP real. Um fator derivado do método como a implementação das UCP virtuais é realizada. e outros dados necessários à definição completa de seu estado. entretanto mesmo nestes casos ocorre a necessidade de compartilhamento de várias ou todas UCP pelos diversos processos. . processos. a aparência criada ao usuário. existe apenas uma UCP real. em uma mesma UCP real executam um por vez. registradores. Alguns sistemas de multiprocessamento apresentam diversas UCP reais. mas essa execução é realizada de forma a criar a ilusão de que os mesmos estão executando em paralelo.Sistemas Operacionais - 8 2.Ricardo Luís de Freitas Notas de Aula .. Figura 2: Distribuição de tempo da UCP real entre os diversos processos. Isto é . contador de programa (Program Counter. chamada UCP virtual. deve-se incluir tanto o programa propriamente dito como os valores de variáveis.

ex.: não se pode fazer um programa que execute certo número de repetições de um "loop" e com isso espere conseguir uma demora fixa de tempo. Como não é muito forte. que a mesma esteja em uma linguagem apropriada). Neste caso poder-se-ia estabelecer a seguinte comparação: O padeiro é a UCP.) e segue a receita de um livro de receitas. ele começa a chorar e julga extremamente importante cuidar da picada de abelha antes de acabar o pão. etc. Suponha agora que. em que ponto da receita ele está e qual a disposição de todos os componentes da massa e seu estado atual) para que possa ser reassumido no mesmo ponto em que foi interrompido. O processo neste caso corresponde ao ato de o padeiro estar executando o pão da receita com as entradas disponíveis. Outro fato importante aqui é que o processo de preparação do pão deve ser guardado com todo o seu estado corrente (isto é . nem em relação a diversas execuções de um mesmo processo. . Terminado o curativo da picada o padeiro volta a amassar o pão no mesmo ponto em que parou. como um segundo). fazendo com que o atual tenha sua continuação retardada.Sistemas Operacionais - 9 quer-se dizer que não é possível assumir nada com relação à taxa com que cada processo será executado. os ingredientes são as entradas e a receita é o programa (desde que o padeiro entenda tudo o que está escrito na receita. água. Isto ocorre porque não se sabe o momento em que a UCP será chaveada para outro processo. Para fixar melhor a diferença entre um programa e um processo. nem em relação a outros processos. bromato. enquanto o padeiro está amassando o pão (um dos passos indicados pela receita) ele é picado por uma abelha. Para fazer um pão ele se utiliza de alguns ingredientes (farinha.Ricardo Luís de Freitas Notas de Aula . isto é . Uma das implicações disto é que os programas não podem ser feitos levando em consideração as temporizações de execução das instruções (p. Aqui tem-se uma interrupção (a picada de abelha) fazendo a UCP (padeiro) chavear do processo de preparação do pão para o processo de curativo da picada. Para isto ele dispõe de novas entradas (os medicamentos) e de um novo programa (o livro de primeiros socorros). observe a seguinte comparação extravagante: Suponha um padeiro não muito experiente. sal.

. Por isso. o processo grep deve ser bloqueado até haver entradas. Um pai pode apresentar diversos filhos. Durante a sua existência. Estados dos Processos Durante a sua existência. Como a saída do processo cat está ligada à entrada do processo grep por meio de um pipe. stdin (normalmente o terminal do usuário). stdout (normalmente o terminal do usuário). No entanto. utilizando como entrada a entrada padrão. um processo pode necessitar interagir com outros processos. e o que pediu a geração recebe o nome de pai. Hierarquia de Processos Em todos os S. Serão apresentados os três mais importantes e os fatos que levam os processos a mudar de um estado à outro. Na geração de um novo processo. cap2 e cap3. 2. pode ocorrer de que o processo grep queira ler um dado de entrada que ainda não foi gerado pelo cat.10 2.1. um processo tem a possibilidade de gerar outros processos. Este é o caso dos processo cat e grep no exemplo abaixo: cat cap1 cap2 cap3 | grep arquivo o processo cat é utilizado para concatenar arquivos e apresentar a saída concatenada na saída padrão do sistema.1. mas cada filho só pode ter um pai. gerando uma hierarquia de processos. no caso do exemplo.Sistemas Operacionais . os processos podem se apresentar. de multiprogramação deve haver alguma forma de criar e terminar processos conforme o necessário à execução dos pedidos de usuários. O programa grep é utilizado para selecionar as linhas em que aparece uma dada cadeia de caracteres. que por sua vez podem gerar outros. do ponto de vista do sistema.2. Por exemplo. isto é .Ricardo Luís de Freitas Notas de Aula . ele concatena os arquivos de nomes cap1. o processo gerado recebe o nome de filho. como não se sabe a que taxa cada um será executado. procura as linhas em que aparece a palavra arquivo. O primeiro estado a considerar consiste naquele em que um processo está efetivamente executando. e assim sucessivamente. durante a execução desses dois processos. cap2 e cap3). no nosso exemplo.O. um processo pode gerar uma saída que será utilizada por outro. a linha acima faz com que a saída seja todas as linhas que contêm a palavra "arquivo" nos três arquivos citados (cap1. em diferentes estados. está rodando. Quando isto ocorre.1.

Neste caso o processo está pronto. além dos programas à serem executados. tendo como principal objetivo a conciliação da necessidade de eficiência do sistema como um todo e de justiça para com os processos individuais. ponteiro de pilha (SP).Ricardo Luís de Freitas Notas de Aula . escalonador selecionou este processo 4. estado dos arquivos abertos. entrada ficou disponível Em alguns sistemas. Em outros sistemas. necessárias ao escalonador. bloqueamento por falta de entrada 2.Sistemas Operacionais . que consiste em um vetor de estruturas com uma entrada por processo.O. Esses dados são armazenados na chamada tabela de processos. O escalonador (scheduler) citado acima é uma parte do S. para permitir que um processo seja reassumido exatamente no ponto em que foi interrompido. registradores. responsável pelo chaveamento da UCP entre os diversos processos. Implementação de Processos Para a implementação de processos.3. . o bloqueamento é realizado automaticamente pelo próprio sistema. sem que o usuário precise se ocupar disso durante a programação. Esta estrutura contém dados como: contador de programa (PC). o processo deve requisitar o bloqueamento. Os três estados e suas interrelações podem ser apresentados como na Figura 3: EXECUÇÃO 1 3 2 BLOQUEADO 4 PRONTO Figura 3: Estados de um Processo Onde: as transições entre os processo estão numeradas de acordo com a anotação: 1.11 Outro estado a considerar é quando o processo tem todas as condições de executar. devem ser guardadas algumas informações. escalonador selecionou um outro processo 3. mas não pode pois a UCP foi alocada para a execução de um outro processo. 2. além de diversas outras informações.1. quando notar que não dispõe de entradas.

um processo A resolve requisitar a impressão de um arquivo chamado a. após o que foi interrompido pelo escalonador. para o processo A. Para isto lê o valor de entra. veja na Figura 4 Figura 4 Tem-se também duas variáveis.prg. onde encontra 7. Considera-se o diretório de spool como organizado em diversas unidades numeradas. Este processo (B). Então. no caso indicado na Figura 4. entra e sai que são utilizadas respectivamente para indicar qual a próxima unidade de diretório vazia (e que portanto pode ser ocupada por um novo nome de arquivo) e qual a próxima unidade a ser impressa.12 3. Supondo então que o processo A leu entra=7. COMUNICAÇÃO ENTRE PROCESSOS 3. o valor de entra continua sendo 7 e. podem ocorrer as chamadas condições de disputa. simplesmente fazendo com que cada um envie o nome de um arquivo a ser impresso.Ricardo Luís de Freitas Notas de Aula .prg na . e imprimindo os arquivos na ordem em que foram solicitados pelos diversos usuários). Cada programa que deseja a impressão de um arquivo envia o nome do mesmo para o diretório de spool. e incrementa entra para 8. que retorna exatamente no ponto onde estava. sendo que cada unidade pode conter o nome de um arquivo. na qual cada um pode escrever ou ler. Exemplifica-se isto através de um spooler de impressora (que corresponde a um programa que permite diversos usuários utilizarem uma mesma impressora. resolve então imprimir o arquivo b. ele colocar a. onde entra=7. colocar o nome do arquivo na unidade correspondente e incrementar o valor de entra de um.Sistemas Operacionais . Para isto. Condições de Disputa Quando existe compartilhamento entre processos de uma memória. Após isto o escalonador determina a volta da execução do processo A. Considera-se que o programa funciona lendo os nomes dos arquivos a imprimir de um diretório de spool. Supondo que. coloca b. ele precisa ler o valor da variável entra. que determinou o início da execução do processo B.1.prg.prg na unidade 7 do diretório de spool. portanto.

e os S. .2. não são feitas suposições sobre a velocidade relativa dos processos e sobre o número de UCPs. Além disto.prg) e incrementa o valor de entra que leu (isto é . Note que o problema de disputa ocorreu. e portanto o processo que o requisitou não será servido. O resultado de tudo isto é que o pedido de impressão de b. 3. nenhum processo deve esperar um tempo arbitrariamente longo para entrar em sua região crítica.13 unidade 7 do diretório de spool (exatamente onde tinha sido colocado b. 3. nenhum processo parado fora de sua região crítica pode bloquear outros processos 4. Isto é o que se chama de uma condição de disputa.prg desapareceu. que não requerem acesso a dados de outros processos. devem ser evitadas. no programa de spool da impressora.Ricardo Luís de Freitas Notas de Aula . como a apresentada acima. que será armazenado em entra.Sistemas Operacionais . devido ao fato de existirem dois processos acessando "simultaneamente" os dados compartilhados entre os mesmos. para haver uma cooperação eficiente e correta entre os processos. Isto é o que se chama de exclusão mútua. Durante a maior parte do tempo um processo executa computações internas. 2. proibindo que mais de um processo leia e escreva simultaneamente em uma área de dados compartilhada. Isto nos indica que as condições de disputa podem ser evitadas.O. Os trechos de programa em que os processos estão executando computações sobre dados compartilhados com outros processos são chamados de seções críticas. Seções Críticas Claramente as condições de disputa. Para evitar disputas basta então garantir que não haverão dois processos simultaneamente em suas seções críticas. 7) gerando como resultado 8. devem ser construídos de forma a evitar disputas entre os diversos processos. não podem haver dois processos simultaneamente em suas seções críticas. deve-se satisfazer as seguintes condições: 1.

3. O algoritmo apresentado abaixo representa um exemplo disto. e as reabilite imediatamente antes de sair. coloca em 1 e prossegue o processamento. Exclusão Mútua com Espera Ocupada 3.3. não poder mais executar. teste o valor da comporta: se for 0 (aberta).3. que quando em 0 indica que a região crítica está livre. deve ser restrita ao mesmo. necessária a algumas tarefas do kernel. b.3. pois somente serão desabilitadas as interrupções da UCP que estiver rodando o programa Daí conclui-se que a desabilitação de interrupções.2. antes de entrar. 3. colocando em 0 quando terminar.O.Ricardo Luís de Freitas Notas de Aula .Sistemas Operacionais . em uma estrita alternância. 3. Alternância Estrita Esta é uma solução que obriga que a região crítica seja dada a um dos processos por vez. Esta solução apresenta os seguintes problemas: a. o que significa que se algum se esquecer de reabilitá-las. e se for 1 (fechada) aguarda até se tornar 0.3.14 3. e quando em 1 indica que a mesma está ocupada. Isto impede que a UCP seja chaveada para outro processo. Desta forma.1. é possível fazer com que cada processo. os usuários devem ter o direito de desabilitar interrupções. O grande problema com esta solução é que a disputa apenas se transferiu da região crítica para a variável de comporta (pense no que ocorre se um processo for interrompido imediatamente depois de ler o valor da variável e antes de alterá-lo.). Variáveis de Comporta Pode-se pensar numa solução em que se estabeleça uma variável auxiliar. denominada variável de comporta (lock variable).. Desabilitando interrupções A forma mais simples de garantir a exclusão mútua é fazer com que cada processo desabilite interrupções ao entrar na região crítica. pois o chaveamento é realizado através de uma interrupção periódica vinda de um relógio que ativa o escalonador. com a utilização de uma variável vez. se o computador possuir várias UCP o método não funciona. o S. que indica de qual processo é a vez de entrar na região crítica: ..

end end. chamado H. secao_normal. procedure proc_1. secao_normal. begin while (TRUE) do begin while (vez ≠ 1) (*espera*) secao_critica. um enorme desperdício de UCP. o que significa que o número de acessos de cada processo deve ser exatamente igual ao do outro. do. pois após entregar a seção crítica para o outro processo não pode mais pedi-la novamente. 3. pois se um dos processos pára fora de sua seção crítica. o outro não poderá prosseguir normalmente. e representa. vez := 1. chamado L de baixa prioridade. O problema com a solução de alternância estrita é que requer que os dois processos se alternem precisamente. existe uma violação da regra 3 apresentada acima. Além disto.Ricardo Luís de Freitas Notas de Aula .15 procedure proc_0. pois o processo L está . SLEEP e WAKEUP As soluções com espera ocupada têm o grave inconveniente de desperdiçar tempo de UCP nos loops de espera para a entrada na região crítica.4. vez := 0. se o processo H tenta entrar em sua região crítica não pode. do. então. de alta prioridade e outro. end end. Se o processo L estiver executando em sua região crítica quando o processo H é selecionado para execução.Sistemas Operacionais . O teste contínuo de uma variável na espera de um certo valor é chamado de espera ocupada. Suponha dois processos: um. Além disto apresenta um outro problema quando se trata de processos com prioridades diferente. begin while (TRUE) do begin while (vez ≠ 0) (*espera*) secao_critica. como é evidente.

Em ambos os casos. Tem-se neste caso uma situação chamada de deadlock.16 dentro da mesma e. (* coloca item no buffer *) cont:= cont+1. de forma que surgem problemas em duas situações: i) quando o produtor deseja colocar mais dados em um buffer cheio ii) quando o consumidor deseja retirar dados de um buffer vazio. pois apresenta prioridade mais baixa. portanto fica em um loop de espera. Para isto. onde nenhum dos processos pode prosseguir pois está aguardando alguma condição que somente pode ser atingida pela execução do outro. observe o problema do produtor e do consumidor. (* se buffer cheio. colocando-o disponível para execução quando o escalonador julgar adequado.Ricardo Luís de Freitas Notas de Aula . O buffer apresenta uma capacidade finita de reter dados. Para exemplificar a utilização de SLEEP e WAKEUP. No programa abaixo tem-se uma tentativa de resolver o problema do produtorconsumidor com a utilização de SLEEP e WAKEUP. e outro chamado consumidor que retira dados do buffer. dorme *) entra_item(item). WAKEUP: pega um processo em estado bloqueado e o transfere para o estado pronto. define-se duas rotinas SLEEP e WAKEUP. end acorda consumidor *) end. (* produz um item *) if (cont=N) then SLEEP. Mas. Neste problema clássico existem dois processos: um chamado produtor que coloca dados em um buffer. de itens *) if (cont=1) then WAKEUP(consumidor). como H tem alta prioridade. somente sendo acordado quando o outro processo alterar a situação do buffer e executar WAKEUP.Sistemas Operacionais . . SLEEP: faz com que o processo que está executando seja transferido do estado de rodando para o de bloqueado. (* inicialmente buffer vazio *) procedure produtor. (*se buffer estava vazio. begin while (TRUE) do begin produz_item(item). faz-se com que o processo que não pode acessar o buffer no momento execute um SLEEP e seja bloqueado. A variável cont é compartilhada entre os dois processos: cont:=0. que realizam a espera através do bloqueamento do processo. (* incremente n. ao invés do desperdício do tempo de UCP. o processo L não poder executar até que H termine.

esta solução não resolve o problema geral. em algum momento o produtor lota o buffer e também dorme WAKEUP é perdido Tem-se portanto uma condição em que tanto o produtor como o consumidor estão dormindo. produtor coloca item e incrementa cont para 1 4. (* se buffer estava cheio. (* lê item do buffer *) cont:= cont-1. (* decrementa n. o que caracteriza novamente um deadlock. dorme *) remove_item(item). para ele cont=0 (foi o valor lido) e portanto. quando um WAKEUP for enviado para um processo já acordado. Infelizmente este programa apresenta um problema na utilização da variável cont. de itens *) if (cont=N-1) then WAKEUP(produtor). (* utiliza o item lido *) end end. Pode-se. sendo que a próxima vez que o processo realizar SLEEP.Sistemas Operacionais . Entretanto. escalonador interrompe consumidor e roda produtor 3. . consumidor lê cont=0 2. o problema pode ser resolvido com a inclusão de um bit de espera de WAKEUP. porém o problema geral ainda permaneceria. construir casos com três processos onde um bit de espera não é suficiente. por exemplo.Ricardo Luís de Freitas Notas de Aula . acorda produtor *) consome_item(item). Veja nos seguintes passos: 1. não podendo ser acordados pelos outros. O aumento para três ou mais bits poderia resolver esses casos. (* se buffer vazio. chama WAKEUP para o consumidor 5. Para este caso simples. dorme 7. se o bit estiver marcado então o processamento prossegue como se o WAKEUP tivesse sido automático. Assim. consumidor volta a executar. o bit será marcado. mas como já estava rodando o 6.17 procedure consumidor. como descobre que cont=1. begin while (TRUE) do begin if (cont=0) then SLEEP.

5. são consideradas todas as ações de DOWN(v) e UP(v) como indivisíveis. (* poe item no buffer *) UP(mutex). (* um a mais cheio *) end end. (* um vazio a menos *) DOWN(mutex). A solução do produtor-consumidor com semáforos é utilizamos três variáveis semáforo: mutex : semáforo binário que garante a exclusão mútua dentro da região crítica vazio : que indica o número de posições vazias no buffer cheio : que indica o número de posições cheias no buffer amutex:= 1. A essa variável se deu o nome de semáforo. Veja que. begin while (TRUE) do begin produz_item(item). nas representações acima. o processamento é realizado sem interrupções. isto é . Para trabalhar com os semáforos Dijkstra propôs duas primitivas: DOWN(v) : generalização de SLEEP. DOWN(vazio). que pode ser definida como: if (v=0) then WAKEUP else v:= v+1. (* testa exclusao mutua *) entra_item(item). (* sai da exclusao mutua *) UP(cheio). que pode ser definida como: if (v>0) then v:= v-1 else SLEEP.Sistemas Operacionais . (* N locais vazios *) cheio:= 0. (* 0 locais cheios *) procedure produtor. (* primeiro o produtor *) vazio:= N. apresentada abaixo. Dijkstra propôs a utilização de uma variável inteira que conta o número de WAKEUP realizados. Semáforos Para resolver este problema. onde .18 3.Ricardo Luís de Freitas Notas de Aula . UP(v) : generalização de WAKEUP.

associamos um semáforo chamado disco à interrupção de disco. Hoare e Brinch Hansen propuseram uma primitiva de sincronização de alto nível conhecida como monitor. Isto mostra que a programação com semáforos deve ser muito cuidadosa.Sistemas Operacionais .19 procedure consumidor. A melhor forma de ocultar uma interrupção é através da utilização de semáforos. Para evitar essas dificuldades. pois o produtor já terá pedido a exclusão mútua (com a execução de DOWN(mutex)) quando percebe que o buffer está cheio (com DOWN(vazio)) e então para.Ricardo Luís de Freitas Notas de Aula . ficando bloqueado. Por exemplo. Monitores Os semáforos resolvem o problema de acesso às regiões críticas. Os monitores apresentam as seguintes características: • os processos chamam rotinas no monitor quando desejam. mas não têm acesso a suas variáveis e estruturas de dados internas. . quando um processo necessita de dados do disco executa um DOWN(disco).6. (* sai da exclusao mutua *) UP(vazio). Mas então o consumidor não pode mais retirar ítens do buffer pois não pode mais entrar na região crítica. variáveis e estruturas de dados. desbloqueando o processo requisitante. (* um cheio a menos *) DOWN(mutex). Em um monitor se agrupam conjuntamente rotinas. ocorrerá deadlock quando o buffer estiver cheio. end end. se revertermos acidentalmente o DOWN(vazio) com o DOWN(mutex) no produtor. (* testa exclusao mutua *) remove_item(item). entretanto apresentam grande dificuldade de utilização. begin while (TRUE) do begin DOWN(cheio). Por exemplo. (* le item do buffer * UP(mutex). Ao surgir a interrupção de disco esta executa UP(disco). (* um vazio a mais *) consome_item(item). com o valor inicialmente de 0. • apenas um processo pode estar ativo no monitor em cada instante. 3. Assim. no código para o produtor-consumidor.

O problema do produtor-consumidor com a utilização de monitor é apresentado pelo pseudocódigo abaixo.20 • o monitor é reconhecido pelo compilador e. Se houver. tratado de uma forma especial. além das operações WAIT e SIGNAL. quando estes não podem prosseguir.Ricardo Luís de Freitas Notas de Aula . portanto. onde utilizamos um dialeto de PASCAL que supomos reconhecer os comandos de monitor. quando o produtor encontra o buffer cheio). Esta última é mais simples de implementar e conceitualmente mais fácil: se um signal é executado em uma variável de condição em que diversos processos estão esperando. e se não houver o processamento prossegue. Um outro processo então pode acordá-lo executando um signal na mesma variável de condição). Para evitar que dois processos estejam ativos no monitor simultaneamente. o processo chamante é suspenso. Hoare propôs que o processo recém acordado fosse executado. • quem escreve as rotinas do monitor não precisa saber como a exclusão mútua será implementada. devemos ter uma regra que diga o que deve ocorrer após signal. . • o compilador é o responsável pela implementação da exclusão mútua entre as rotinas do monitor (em geral através de um semáforo binário). Quando uma rotina de monitor não pode continuar executa um WAIT em alguma variável de condição (por exemplo: cheio. Brinch Hansen propôs que o processo que executa um signal deve deixar imediatamente o monitor (isto é . bastando colocar todas as seções críticas em rotinas de monitor Para possibilitar o bloqueamento de processos. o signal deve ser a última operação realizada por uma rotina de monitor. introduziram-se as variáveis de condição. apenas um deles (determinado pelo escalonador) é revivido. • as primeiras instruções de cada rotina do monitor realizam um teste para verificar se existe outro processo ativo no monitor no mesmo instante.Sistemas Operacionais .

Sistemas Operacionais . cont: integer procedure coloca. .vazio: boolean. if cont=N-1 then signal(cheio). entra_item. procedure consumidor. cont:=cont-1. var cheio. end. remove_item. procedure produtor. if count = 1 then signal(vazio).21 monitor ProdutorConsumidor. begin while true do begin produz_item. cont:=0 end monitor. end end. begin if cont = N then wait(cheio). begin while true do begin ProdutorConsumidor. end. ProdutorConsumidor. procedure retira.retira. end end. cont := cont+1.Coloca. consome_item. begin if cont=0 then wait(vazio).Ricardo Luís de Freitas Notas de Aula .

3. No caso atual a disputa não ocorre. este envie uma outra mensagem acusando a recepção. que tinham problemas graves de disputa. Portanto. possui alguns inconvenientes: a.&mensagem). pode ocorrer de uma mensagem ser perdida. pode concluir que a mensagem foi perdida e tenta a transmissão .22 As operações wait e signal são muito parecidas com as de sleep e wakeup. RECEIVE : recebe uma mensagem de uma origem especificada: RECEIVE(origem. Assim.Ricardo Luís de Freitas Notas de Aula . se o processo que envia não receber a recepção dentro de certo tempo. Passagem de Mensagens Para possibilitar o trabalho com sistemas distribuídos e também aplicável à sistemas de memória compartilhada temos o conceito de passagem de mensagens. Se pensamos na conexão de processadores por uma rede. Para se resguardar disto o processo que envia e o que recebe podem concordar em que. pois no monitor não podem haver duas rotinas simultaneamente.Sistemas Operacionais . b. são inaplicáveis para sistemas distribuídos.&mensagem). isto é .7. o receptor pode bloquear até que uma chegue. são uma construção de alto nível. onde cada processador conta com sua própria e independente memória. Este método usa as seguintes primitivas: SEND : envia uma mensagem para um destino dado: SEND(destino. eles se baseiam (tanto quanto os semáforos) na consideração da existência de uma memória comum compartilhada por todos os processadores. a linguagem que os implementa deve reconhecer os comandos de monitor empregados (muito poucas linguagens de fato os implementam). Os monitores possibilitam uma grande facilidade para a programação paralela. Se nenhuma mensagem estiver disponível no momento de executar RECEIVE. tão logo uma mensagem seja captada pelo receptor. Entretanto. que deve ser reconhecida pelo compilador.

Estas mensagens de volta são mensagens especiais chamadas de mensagens de reconhecimento. begin for i:=0 to N-1 do SEND(produtor. então pode ocorrer que duas máquinas se dêem o mesmo nome. Em geral a “encriptação” das mensagens com alguma chave é útil. sendo o endereço formado por processo@máquina. Os problemas de conflito podem ser grandemente diminuídos pelo agrupamento de máquinas em domínios. Normalmente isto é conseguido com uma nomeação do tipo processo@máquina. mas o reconhecimento é perdido. e não de um impostor. (* aguarda mensagem vazia *) faz_mensagem(m. de forma a garantir que os dados estão sendo realmente recebidos do servidor requisitado. o que é normalmente realizado pela colocação de números consecutivos em cada mensagem original.m). e também para um servidor saber com certeza qual o cliente que requisitou. e o receptor irá recebê-la duas vezes.Sistemas Operacionais . o enviador irá retransmitir a mensagem. de forma a identificar corretamente a origem e o destino de uma mensagem. deve ser possível a distinção entre uma mensagem antiga retransmitida e uma nova mensagem.item).Ricardo Luís de Freitas Notas de Aula . (* pega item da mensagem *) . begin while (TRUE) do begin produz_item(item). podemos resolver o problema do produtor-consumidor como apresentado no programa abaixo: procedure produtor. Outro fator importante a considerar é o de autenticação.m). (* pega mensagem *) extrai_item(m.domínio. Utilizando a passagem de mensagens e sem memória compartilhada. (* constroi mensagem*) SEND(consumidor. Suponha agora que a mensagem original é recebida corretamente. procedure consumidor.item). Sistemas de mensagens também precisam saber exatamente quais os nomes dos diversos processos. (* envia N vazios *) while (TRUE) do begin RECEIVE(produtor. Se o número de máquinas for muito grande e não houver uma autoridade central.m). Neste caso. RECEIVE(consumidor. (* envia item ao consumidor *) end end.m). Portanto.23 novamente.

(* envia resposta vazia *) Nesta solução assumimos que todas as mensagens têm o mesmo tamanho e que mensagens enviadas.m). uma nova estrutura de dados que representa um local onde diversas mensagens podem ser bufferizadas. A passagem de mensagens pode ser feita de diversas formas. ele é bloqueado até que este último esteja pronto (e viceversa). assinalando-se um endereço único para cada processo e fazendo as mensagens serem endereçadas aos processos. 2.24 consome_item(item). Neste caso. então.Ricardo Luís de Freitas Notas de Aula . Este mecanismo é conhecido como rendezvous. . 3. fazendo com que. são automaticamente armazenadas pelo sistema operacional. mas ainda não recebidas. com a utilização de mailbox. das quais citaremos três: 1. end end. Se um processo tenta enviar para uma mailbox cheia ou receber de uma mailbox vazia ele é automaticamente suspenso até que a mailbox apresente as condições para a operação. SEND(produtor. se o processo que envia executa SEND antes do de recepção. Caso o buffer esteja cheio. No início são enviados N vazios para permitir ao produtor encher todo o buffer antes de bloquear. eliminando toda a bufferização. o produtor bloqueia no RECEIVE e aguarda a chegada de uma nova mensagem vazia. os endereços em SEND e RECEIVE são as mailbox e não os processos.Sistemas Operacionais .

a maioria dos computadores dispõe de um relógio. d.Ricardo Luís de Freitas Notas de Aula . qual o próximo processo a ser executado.Sistemas Operacionais . realizar algum compromisso entre os diversos critérios. a cada instante. Com o objetivo de prevenir que um processo rode durante um tempo excessivo. A cada interrupção. justiça: cada processo deve conseguir sua parte justa do tempo de UCP. Podemos estabelecer os seguintes critérios para um algoritmo de escalonamento: a.O. O escalonador (scheduler) é .O. Para dificultar que os objetivos sejam alcançados. de forma a que todos os processos tenham a sua chance de utilizar a UCP. minimização do tempo que os usuários de lotes (batch) devem aguardar até conseguir a saída desses pedidos.25 4. O escalonador deve. encarregada de decidir. b. de forma que devemos prejudicar alguns para conseguir melhoras em outros. . Como pode ser facilmente notado. ESCALONAMENTO DE PROCESSOS Chamamos de escalonamento (scheduling) de processos o ato de realizar o chaveamento dos processos ativos. Chamamos de algoritmo de escalonamento o método utilizado pelo escalonador para decidir. o S. e. eficiência: garantir uma ocupação de 100% do tempo da UCP. tempo de resposta: minimizar o tempo de resposta a comandos de usuários interativos. entre todos os processos prontos para executar. portanto. a parte do S. qual o que será rodado em cada instante. interrompe a execução do processo atual e roda o escalonador para decidir qual o próximo processo a ser executado. Vejamos agora algumas formas de implementar o escalonamento. de acordo com regras bem estabelecidas. que é um dispositivo de temporização que interrompe a UCP a cada intervalo dado de tempo. e contrasta com a estratégia de execução até o término. vários critérios acima entram em contradição entre si. maximizar o número de serviços (jobs) processados por hora. ainda temos o fato de que cada processo é único e imprevisível. portanto. c. Esta estratégia de interromper um processo em execução é chamada de escalonamento preemptivo (preemptive scheduling).

nem muito grande nem muito pequeno. Quando um quantum termina sem o processo acabar. o primeiro processo dessa lista para execução. isto pode acarretar um tempo de resposta muito grande para usuários interativos. se o valor do quantum for muito pequeno.1.Isso ocorre porque existe o tempo de chaveamento (tempo para que o processo em execução seja interrompido. o escalonador decida qual o próximo processo e o estado deste novo processo seja restaurado). Por outro lado. processos prontos). chamado de quantum. teremos uma grande proporção do tempo de execução da UCP gasta com o processo de chaveamento.26 4.Sistemas Operacionais . A UCP também pode ser entregue a outro processo caso o processo bloqueie ou termine antes do fim do quantum. Escalonamento "Round-Robin" Neste método. que não é de interesse para os usuários. Se o processo ainda está rodando ao fim de seu quantum. Neste caso. Devemos pois escolher um valor de compromisso. então. de acordo com o tempo de chaveamento. Veja por exemplo se. o tempo de resposta para um processo pode ser de até 5s. teremos uma utilização de 20% do tempo total para o chaveamento. para um chaveamento de 5ms escolhemos um quantum de 500ms. Para a implementação deste método. o escalonador mantém uma lista de processos executáveis (isto é . Figura 5 O valor do quantum deve ser cuidadosamente escolhido. se o valor do quantum for muito grande.Ricardo Luís de Freitas Notas de Aula . o mesmo é colocado no fim dessa lista. Assim. Entretanto. tenha seu estado atual salvo. . Neste caso o tempo gasto com o chaveamento é menos que 1% do tempo total. a UCP é entregue à outro processo no momento do término ou do bloqueio. no qual se permite que ele execute. Veja a Figura 5 para melhor esclarecimento. se todo o chaveamento de processos leva 5ms. a cada processo se dá um intervalo de tempo. Por exemplo. se temos 10 processos executando. O escalonador seleciona. a UCP é tomada deste processo e o escalonador seleciona um novo para rodar. e o quantum for de 20ms.

Isto é feito pois as operações de entrada/saída são realizadas independentemente da UCP. e assim por diante. por toda a hierarquia. se um processo executa muitas dessas operações.O.Ricardo Luís de Freitas Notas de Aula . os processos iniciados por um general devem ter prioridade sobre os processos iniciados por um coronel. As prioridades podem ser associadas a processos de forma estática ou dinâmica. o escalonador calcula a fração de tempo que o processo utilizou do seu quantum na última chamada. Assim. devemos introduzir o conceito de prioridade. não deixando espaço a outros processos. ao requisitar uma operação de entrada/saída o processo faz uma chamada para o S. No instante da criação de um processo. No momento em que sua prioridade fica abaixo de um outro processo pronto ele é interrompido e o outro processo (agora com prioridade mais alta) é executado. Se o processo utilizou apenas uma pequena fração (e não terminou) é provavelmente porque está esperando dados de um dispositivo de E/S. Dizemos que uma prioridade é estática quando ela é associada no momento da criação do processo (mesmo que depois ela seja decrementada para impedir o processo de monopolizar a UCP). e fica bloqueado. baseado em estatísticas sobre a execução deste processo em quanta anteriores. Desta .27 4. Quando o escalonador tiver que escolher.2. Como exemplo de prioridades estáticas. quando percebe que um dado processo efetua muitas operações de entrada/saída. o escalonador pode. sejam eles altamente urgentes e importantes. podemos imaginar que em um sistema implantado em um quartel. de forma que. Como exemplo de prioridade dinâmica. decrementar sua prioridade. qual o que será executado em seguida. entre os processos prontos.Sistemas Operacionais . aumenta a sua prioridade. Lembre-se que. podemos citar um sistema que. a cada vez que o processo é escalado para execução. associamos ao mesmo uma prioridade. ele escolhe o de mais alta prioridade. Para poder oferecer um tratamento distinto à processos diversos. sejam eles de pouca importância ou sem urgência. Escalonamento com Prioridade O esquema de round-robin trata igualmente todos os processos dos sistemas. Uma prioridade é dinâmica quando o escalonador é que decide seu valor. Para implementar essa forma de prioridade. pois enquanto suas transferências estão se executando a UCP pode estar alocada a outro processo que executa cálculos. é conveniente deixar que ele requisite uma nova operação o mais rápido possível. Como esse esquema pode fazer com que um processo seja executado indefinidamente. processos com grande utilização de E/S não significam muita carga para a UCP. aguardando o fim da operação.

fazendo com que todos os processos de uma mesma classe revezem-se como explicado para o escalonamento round-robin. os processos da classe imediatamente abaixo recebem 2 quanta. num processo que necessita de 100 quanta para executar. 4. um valor proporcional ao inverso da fração de quantum ocupado. 32. A solução encontrada foi o estabelecimento de classes de prioridade. 37.28 forma. A utilização prática demonstrou que era necessário que os processos com muita utilização de UCP (também chamados de processos limitados pela UCP. Muitas vezes é útil agrupar os processos em classes de prioridades. Por outro lado.3. "CPU-bound") ganhassem um quantum grande de uma só vez. 8. Adicionalmente a isso. 16. cada vez que um processo utiliza todos os quanta que recebeu ele é abaixado de uma classe (fazendo com que seja escolhido menos frequentemente. Isto é . pois isso implicaria em um tempo de resposta muito grande.Sistemas Operacionais . 4. mas execute durante mais tempo). ele é selecionado para execução 7 vezes (7 . nas potências de 2. Como exemplo. Assim. podemos utilizar para prioridade. 4 quanta. escalonamento de prioridade entre as diversas classes. ii. 2. fazem com que os processos devessem ser lidos do disco e escritos no disco a cada chaveamento. Filas Múltiplas que o computador forçava um chaveamento de processos O fato importante aqui é extremamente lento. escalonamento round-robin dentro de cada classe. os processos de classes mais baixas recebem um número maior de quanta para processamento. de forma a reduzir o número de chaveamentos executados nesse processo. os processos da classe mais alta existente recebem 1 quantum. Os processos de classes mais altas são escolhidos para execução mais frequentemente que os de classes mais baixas. fazem um escalonamento em dois níveis: i.Ricardo Luís de Freitas Notas de Aula . e assim sucessivamente. Por outro lado. não podemos atribuir quanta grandes para todos os processos. pois apenas um processo podia estar presente na memória em cada instante. teremos execuções de 1. como já vimos. os processos da classe seguinte. executando todos os processos das classes de prioridades mais altas antes das classes mais baixas.

A estratégia consiste em escolher para execução. Se escolhemos os três jobs de 4 minutos antes do de 8.Ricardo Luís de Freitas Notas de Aula . sendo um de 8 minutos (o A) e três de 4 minutos (B. C e D). teríamos um tempo de resposta muito ruim. teremos a seguinte configuração: tempo de resposta de A: 8 minutos tempo de resposta de B: 8 + 4 = 12 minutos tempo de resposta de C: 8 + 4 + 4 = 16 minutos tempo de resposta de D: 8 + 4 + 4 + 4 = 20 minutos tempo de resposta médio: 14 minutos. se um processo começa com uma grande quantidade de cálculos. exige comunicação com o usuário). mas em seguida se torna interativo (isto é . entre todos os jobs disponíveis. sendo que no método de round-robin tradicional ele seria selecionado 100 vezes até acabar (100 chaveamentos). durante a execução de um processo grande. aquele de menor tempo de execução. bastava sentar no terminal e teclar aleatoriamente <RET> para ter o tempo de execução melhorado. na esperança de que o mesmo irá se tornar interativo. C e D). muitas vezes os usuários já têm uma boa estimativa dos tempos de execução do programa (em geral porque o programa é rodado constantemente). como definido até aqui.29 chaveamentos para este processo).4. foi implementado o seguinte método: cada vez que um <RET> é teclado no terminal de um processo. tem o grave inconveniente de que. teremos: . Se o job de 8 minutos for escolhido antes. Vê-se então que a implementação prática de uma estratégia eficiente é muito mais difícil na prática do que em princípio. Para eliminar este problema. Nestes sistemas. B. este método. A estratégia de menor serviço primeiro (shortest job first) é útil fundamentalmente para sistemas de lotes (batch). Para ver como esta estratégia consegue melhorar o tempo médio de resposta do sistema. este processo é transferido para a classe de prioridade mais alta. Esta solução funcionou bem até que um usuário descobriu que. consideremos o seguinte caso: existem quatro jobs disponíveis (A. 4. Por outro lado.Sistemas Operacionais . Em seguida ele contou sua "descoberta" a todos. Menor Serviço (job) Primeiro As estratégias apresentadas anteriormente são úteis para sistemas de time-sharing.

Ricardo Luís de Freitas Notas de Aula . iii. consideramos que todos os processo executáveis estão na memória. se existem n usuários ativos. mas ainda é uma boa aproximação. Este geralmente não é o caso. compute. compute quanto tempo já se passou desde que o usuário iniciou sua seção e divide-se pelo número de usuários. Um exemplo de uma promessa simples e fácil de cumprir é a de que. iv. Esta estratégia garante o mínimo tempo de resposta médio possível. escolhe para execução aquele usuário que apresenta a menor razão. 4. Escalonamento Dirigido a Política Outra forma de cuidar do escalonamento é fazer uma promessa ao usuário e procurar cumpri-la. desde que se conheçam todos os serviços simultaneamente. Para cumprir essa promessa podemos usar o seguinte método: i. Escalonamento em Dois Níveis Até aqui. então.5. manter parte dos processos em disco. gerando o que será chamado de tempo destinado ao processo. para cada usuário. Se os serviços não são todos conhecidos simultaneamente o tempo de resposta médio pode não ser o mínimo. pois. ii. cada um receberá aproximadamente 1/n do tempo de UCP. é mantido um valor do tempo de UCP que ele já utilizou desde que entrou. Precisaremos. pois dificilmente a memória principal comportará todos os dados necessários.Sistemas Operacionais . a razão entre o tempo utilizado e o tempo destinado.6. .30 tempo de resposta de B: 4 minutos tempo de resposta de C: 4 + 4 = 8 minutos tempo de resposta de D: 4 + 4 + 4 = 12 minutos tempo de resposta de A: 4 + 4 + 4 + 8 = 20 minutos tempo de resposta médio: 11 minutos. que será chamado tempo utilizado. 4. para cada usuário.

ii. iii.31 O problema que surge é que o tempo para ativar um processo que está em disco é muito maior que o tempo necessário para ativar um processo que está na memória (uma a duas ordens de grandeza maior). iv.Sistemas Operacionais . Para realizar a escolha de qual conjunto de processos deve ser colocado na memória principal o escalonador de alto nível deve responder perguntas tais como: • Quanto tempo se passou desde que o processo foi posto ou retirado ? • Quanto tempo de UCP o processo teve recentemente ? • Qual o tamanho do processo ? • Qual a prioridade do processo ? . um subconjunto dos processos executáveis é mantido na memória. um outro subconjunto é mantido no disco. um outro escalonador (chamado de alto nível) é utilizado para trocar periodicamente o conjunto de processo que estão na memória (substituindo-os por alguns que estavam no disco). ou outros semelhantes) apenas entre os processos que estão na memória. O funcionamento será então da seguinte forma: i. um escalonador (chamado de baixo nível) é utilizado para realizar o chaveamento (por qualquer dos métodos já descritos.Ricardo Luís de Freitas Notas de Aula . A melhor solução para isto é a utilização de um escalonador em dois níveis.

Algumas razões para isso são as seguintes: . com exceção da parte reservada ao sistema operacional.2. 5. • Os grandes computadores em geral oferecem serviços interativos simultaneamente para diversos usuários. temos um único processo executando por vez.Sistemas Operacionais . que permanece constantemente em local pré-determinado da memória. estudaremos o caso mais simples em que não é realizada nem troca nem paginação. carrega um programa do disco para a memória. que se sobrepor ao anterior.1. Neste caso. quando a memória principal não é suficientemente grande para manter todos os processos.32 5. aguarda comandos do usuário para carregar um novo programa. que é o responsável por cuidar de quais partes da memória estão em uso. GERENCIAMENTO DE MEMÓRIA Trataremos agora da parte do S. 5. antes de estudar esses métodos.Muitas aplicações são mais facilmente programáveis quando as dividimos em dois ou mais processos. conhecida como gerenciador de memória. a monoprogramação praticamente não é mais utilizada em sistemas grandes. Entretanto. alocar memória a processos quando eles precisam. 5.3. O S. Multiprogramação Apesar de largamente utilizada em microcomputadores. é impossível de se trabalhar com um único processo na .O. executa-o e. Gerenciamento de Memória sem Troca ou Paginação Troca e paginação são métodos utilizados de movimentação da memória para o disco e vice-versa durante a execução dos processos. de forma que o mesmo pode utilizar toda a memória disponível. quais estão livres. em seguida. desalocar quando eles não mais necessitarem e gerenciar a troca (swapping) dos processos entre memória principal e disco. Monoprogramação sem Troca ou Paginação Neste caso.O.Ricardo Luís de Freitas Notas de Aula .

Uma forma de tratar com essas partições seria então a seguinte: (i) cria-se uma fila para cada partição existente.33 memória por vez. pelo operador. devemos agora analisar de que forma este objetivo pode ser conseguido.: o primeiro a chegar é atendido antes). por exemplo. (ii)cada vez que um processo é iniciado.ex. • É necessário que diversos processos estejam "simultaneamente" em execução. nas quais.1. por questão de eficiência. com apenas um processo por vez na memória representaria constantemente estar lendo e escrevendo no disco). Essas partições poderiam ser criadas. ele é colocado na fila da menor partição capaz de o executar. (iii)os processo em cada partição são escolhidos de acordo com alguma forma de política (p. ao inicializar o sistema. possivelmente diferentes.Ricardo Luís de Freitas Notas de Aula .Sistemas Operacionais . a UCP deve ser entregue a outro processo. pois isso representaria grande sobrecarga devido à constante necessidade de chavear de um processo para outro (o que. o que implica em grandes esperas. 5. devido ao fato de que muitos deles estão constantemente realizando operações de E/S. A forma mais simples é dividir a memória existente em n partições fixas.3. Multiprogramação com Partições Fixas Já que percebemos a importância da existência de diversos processos na memória. Este método pode ser simbolizado como na Figura 6 : Figura 6: Esquema de Múltiplas Filas .

Ricardo Luís de Freitas

Notas de Aula - Sistemas Operacionais - 34

Uma desvantagem óbvia desse esquema é a de que pode ocorrer que uma partição grande esteja sem utilização, enquanto que diversos processos estão aguardando para utilizar uma partição menor (p.ex.: na figura acima temos três processos aguardando pela partição 1, enquanto que a partição 3 está desocupada). Podemos resolver esse problema da seguinte forma: (i) estabelecemos apenas uma fila para todas as partições; (ii)quando uma partição fica livre, um novo processo que caiba na partição livre é escolhido e colocado na mesma, conforme indicado na Figura 7:

Figura 7: Esquema de Fila Única O problema que surge aqui é a forma de escolha implícita no item (ii). Se a partição livre for entregue para o primeiro processo da fila, pode ocorrer de que uma partição grande seja entregue a um processo pequeno, o que não é desejável (pois implica desperdício de memória). Por outro lado, se percorremos a fila procurando o maior processo aguardando que caiba na partição, isto representará servir melhor os processos grandes em detrimento dos pequenos.

5.3.2. Relocação e Proteção Relocação e proteção são dois problemas introduzidos pela multiprogramação, e que precisam ser resolvidos. A necessidade da relocação pode ser vista nas figuras anteriores, onde fica claro que processos diferentes executam em posições de memória diferentes e, portanto, com endereços diferentes.

Ricardo Luís de Freitas

Notas de Aula - Sistemas Operacionais - 35

Suponha uma rotina em um programa que, ao término da ligação dos módulos deste, é colocada na posição 100 em relação ao início do programa. É claro que se esse programa for ser executado na partição 1, todas as chamadas dessa rotina devem ser enviadas para a posição de memória 100k+100. Se o programa for executado na partição 2, as chamadas para essa mesma rotina devem ser enviadas para a posição 200k+100. Uma possível solução é modificar as instruções conforme o programa é carregado na memória. Desta forma, quando o S.O. carrega o programa, adiciona a todas as instruções que se referenciem a endereços, o valor do ponto inicial de carga do programa (i.e., o início da partição escolhida para o mesmo). Esta solução exige que o ligador (linker) coloque no início do código binário do programa uma tabela (ou uma lista) que apresente as indicações das posições no programa que devem ser modificadas no carregamento. Esta solução entretanto não resolve o problema da proteção, pois nada impede que um programa errado ou malicioso leia ou altere posições de memória de outros usuários (dado que as referências são sempre as posições absolutas de memória). Uma solução para isto adotada no IBM 360 foi a de dividir a memória em unidades de 2k bytes e associar um código de proteção de 4 bits a cada uma dessas regiões. Durante a execução de um processo, o PSW contém um código de 4 bits, que é testado com todos os acessos à memória realizados pelo processo, e gera uma interrupção se tentar acessar uma região de código diferente. Uma solução alternativa tanto para o problema da relocação como para o da proteção é a utilização de registradores de base e limite. Sempre que um processo é carregado na memória, o S.O. ajusta o valor do registrador de base de acordo com a disponibilidade de memória. Este registrador é utilizado de forma que, sempre que um acesso é realizado na memória pelo processo, o valor do registrador de base é automaticamente somado, o que faz com que o código do programa em si não precise ser modificado durante o carregamento. O registrador de limite é utilizado para determinar o espaço de memória que o processo pode executar. Todo acesso realizado pelo processo à memória é testado com o valor do

registrador limite, para verificar se esse acesso está se realizando dentro do espaço reservado ao processo (caso em que ele é válido) ou fora do seu espaço (acesso inválido). Uma vantagem adicional do método dos registradores base e limite é o de permitir que um programa seja movido na memória, mesmo após já estar em execução. No método anterior isto não era possível sem realizar todo o processo de alteração dos endereços novamente.

Ricardo Luís de Freitas

Notas de Aula - Sistemas Operacionais - 36

5.3.3. Troca (swapping) Num sistema em batch, desde que se mantenha a UCP ocupada o máximo de tempo possível, não existe razão para se complicar o método de gerenciamento da memória. Entretanto, num sistema de time-sharing, onde muitas vezes existe menos memória do que o necessário para manter todos os processos de usuário, então é preciso que uma parte dos processos sejam temporariamente mantidos em disco. Para executar processos que estão no disco, eles devem ser enviados para a memória, o que significa retirar algum que lá estava. Este processo é denominado troca (swapping), e é o que passaremos a estudar.

5.3.4. Multiprogramação com Partições Variáveis A utilização de partições fixas para um sistema com swapping é ineficiente, pois implicaria em que grande parte do tempo as partições estariam sendo utilizadas por processos muito pequenos para as mesmas. A solução para isso é tratarmos com partições variáveis, isto é, partições que variam conforme as necessidades dos processos, tanto em tamanho, como em localização, como em número de partições. Isto melhora a utilização de memória mas também complica a alocação e desalocação de memória. É possível combinar todos os buracos formados na memória em um único, o que é conhecido como compactação de memória, mas isto é raramente utilizado, devido à grande utilização de UCP requerida. Um ponto importante a considerar é quanta memória deve ser alocada a um processo, quando o mesmo é iniciado. Se os processos necessitam de uma certa quantidade pré-fixada e invariante de memória, então basta alocar a quantidade necessária para cada processo ativo e o problema está resolvido. Entretanto, muitas vezes os processos necessitam de mais memória durante o processamento (alocação dinâmica de memória). Neste caso, quando um processo necessita de mais memória, podem ocorrer dois casos: a. existe um buraco (região não ocupada) de memória próximo ao processo: neste caso, basta alocar memória desse buraco; b. o processo está cercado por outros processos, ou o buraco que existe não é suficiente: neste caso, podemos tomar alguma das seguintes ações:

Ricardo Luís de Freitas

Notas de Aula - Sistemas Operacionais - 37

• mover o processo para um buraco de memória maior (grande o suficiente para as novas exigências do processo); • se não houver tal espaço, alguns processos devem ser retirados da memória, para deixar espaço para esse processo; • se não houver espaço no disco para outros processos, o processo que pediu mais espaço na memória deve ser morto (kill). Quando se espera que diversos processos cresçam durante a execução, pode ser uma boa idéia reservar espaço extra para esses processos quando os mesmos são criados, para eliminar a sobrecarga de lidar com movimentação ou troca de processos. Trataremos agora de duas das formas principais de cuidar da utilização de memória: mapas de bits, listas e sistemas de desabrochamento.

5.4.

Gerenciamento de Espaço

5.4.1. Gerencimento com Mapa de Bits Este método consiste em formar um mapa de bits. A memória é subdividida em unidades de um certo tamanho. A cada uma dessas unidades é associado um bit que, se for 0 indica que essa parte da memória está livre, e se for 1, indica que ela está ocupada. O tamanho da unidade que é associada com um bit deve ser cuidadosamente escolhida, entretanto, mesmo com a associação de apenas 4 bytes de memória para cada bit no mapa, a parte da memória gasta com esse mapa é de apenas 3%. Se escolhemos mais de 4 bytes, o espaço ocupado pela tabela será menor, mas o desperdício de memória crescerá . A Figura 8 mostra um trecho de memória e o mapa de bits associado.

Figura 8

apresenta-se cercado por dois segmentos. o gerenciador deve percorrer o mapa de bits para encontrar k bits iguais a zero consecutivos. o que não é um processo simples. A lista apresenta-se em ordem de endereços.38 A desvantagem desse método. mantemos uma lista encadeada de segmentos alocados e livres. Assumimos que o gerenciador de memória sabe quanto espaço alocar ao processo: . desde que não seja nem o primeiro nem o último da lista. H indica um buraco e P um processo.4. sendo que cada segmento é um processo ou um buraco entre dois processos.Ricardo Luís de Freitas Notas de Aula .2. de forma que quando um processo termina ou é enviado para o disco. temos também a lista associada ao trecho de memória indicado. é que. Gerenciamento com Listas Encadeadas Neste caso. Vejamos agora alguns algoritmos que podem ser utilizados para escolher o ponto em que deve ser carregado um processo recém criado ou que veio do disco por uma troca (foi swapped in). o que nos dá as quatro possibilidades mostradas na Figura 9: Figura 9 Note que os buracos adjacentes devem ser combinados num único. quando um novo processo que ocupa k unidades de memória deve ser carregado na memória. a atualização da lista é simples: cada processo.Sistemas Operacionais . Na Figura 8. anteriormente apresentada. 5. que podem ser buracos ou outros processos.

5. Alocação de Espaço de Troca (swap) Chamamos de espaço de troca ao espaço ocupado no disco pelos processos que aí estão guardados pelo fato de que foram retirados da memória devido a uma troca (swap). É um algoritmo mais lento e. outra para 8k. uma fila para 2k. 3. de forma que não está. . quando temos duas listas separadas. Os quatro algoritmos podem ter sua velocidade aumentada pela manutenção de duas listas separadas.). simulações demonstram que tem um desempenho pior que o First Fit. entretanto.Ricardo Luís de Freitas Notas de Aula . É um algoritmo rápido. cada processo tem no disco um espaço reservado para o mesmo. Worst Fit (pior ajuste): sugerido pelo fracasso do algoritmo anterior. First Fit (primeiro encaixe): neste caso. Best Fit (melhor encaixe): consiste em verificar toda a lista e procurar o buraco que tiver espaço mais próximo das necessidades do processo. sendo constantemente mudado de lugar. quando um processo termina. Simulações mostraram que também seu desempenho é ruim. procura a partir do último ponto em que encontrou. com a diferença de que em alguns sistemas. a liberação de seu espaço é complicada. consiste em pegar sempre o maior buraco disponível.5. Simulações mostraram que esse algoritmo apresenta um desempenho próximo ao anterior. a busca de um buraco com o tamanho requerido é extremamente rápido.Sistemas Operacionais . é o Quick Fit (ajuste rápido). Next Fit (próximo encaixe): o mesmo que o algoritmo anterior. 4. o algoritmo consiste em percorrer a fila até encontrar o primeiro espaço em que caiba o processo. Os algoritmos para gerenciar o espaço alocado em disco para swap são os mesmos apresentados para o gerenciamento da memória.39 1. como na memória. outra para 4k. só que ao invés de procurar sempre a partir do início da lista. além disso. etc. Neste caso. 2. devido à necessidade de reagrupar os buracos e modificá-los de fila. devido ao fato de tender a encher a memória com pequenos buracos sem nenhuma utilidade. uma para processos e outra para buracos. Ainda outro algoritmo possível. que consiste em manter listas separadas para alguns dos tamanhos mais comuns especificados (por exemplo.

6. Quando um dos overlays terminava a execução. e que podiam ser rodadas separadamente. deve ser realizado pelo programador. pelos discos serem dispositivos de bloco. Antes. Memória Virtual Quando os programas começaram a ficar grandes demais para a quantidade de memória necessária. Nesta técnica.1. mas que não apresenta os inconvenientes dos overlays. Por exemplo.Ricardo Luís de Freitas Notas de Aula . sendo que existe uma forma de decisão cuidadosa de quais devem permanecer no disco e quais na memória. estabeleçamos o conceito de espaço virtual. A técnica de memória virtual é uma outra forma de executar um programa que não cabe na memória existente. dos dados. Neste caso. Da mesma forma.Sistemas Operacionais . um processador com endereçamento de 16 bits possui um espaço virtual de 64k bytes (se o endereçamento for em bytes). chamadas overlays. Paginação Paginação é uma técnica muito utilizada em sistemas com memória virtual. que aliás não é simples. o programa era subdividido em partes menores. a primeira solução adotada foi a de utilização de overlay. um outro poderia ser carregado na mesma posição de memória utilizada pelo anterior (isto existe ainda em linguagens como o Turbo-Pascal e o Aztec C). e da pilha são mantidas no disco.40 Um fator adicional de diferença é o fato de que.6. 5. a quantidade de espaço reservado para os processos no disco deverão ser múltiplas do tamanho do bloco. por ser realizada de forma automática pelo próprio computador. Chamamos de espaço virtual ao espaço de memória que pode ser referenciado por um programa qualquer em dado processador. de forma que cada um pensa ter uma quantidade de memória que somadas ultrapassam a quantidade real de memória. 5. O problema com este método é que todo o trabalho de divisão de programas em overlays. podemos alocar diversos processos na memória virtual. Quando uma instrução como: . partes do programa.

o 1000h corresponde a um endereço virtual. qual o quadro de página que corresponde à mesma. . No exemplo acima.41 LD A. Quando o computador possui memória virtual.Ricardo Luís de Freitas Notas de Aula . A MMU tem uma tabela que indica. e páginas de 4k bytes. Se o processador tenta acessar o endereço 0. a MMU verifica que isto corresponde ao primeiro endereço da primeira página.(1000h). temos um espaço virtual de 64k bytes. de acordo com uma tabela. No exemplo da Figura 10. para cada página. uma memória física de 32k bytes. A operação da MMU pode ser explicada conforme apresentado na Figura 10: Figura 10 O espaço de endereços virtuais é dividido em unidades chamadas páginas e o espaço de memória física é dividido em unidades chamadas quadros de página. o endereço virtual corresponde ao endereço efetivamente colocado no duto de endereçamento da memória.Sistemas Operacionais . seria colocado no duto de endereços o valor binário correspondente a 1000h. que corresponde a um chip ou um conjunto de chips que translada esse endereço virtual em um endereço físico. carrega acumulador com conteúdo do endereço 1000 (em hexadecimal) é apresentada no Z80. de um espaço de endereçamento virtual de 64k bytes. MMU (memory management unit). Em um computador sem memória virtual. de mesmo tamanho das páginas. esse endereço virtual é enviado para uma unidade de gerenciamento de memória.

pega os 4 bits do índice de página. Para saber isto.. se não estiver. a MMU mantém na tabela de translação um bit para cada página que indica se a mesma está presente na memória ou não. depois.O.42 verifica então que essa primeira página está alocada no terceiro quadro de página (i.e. de 16 bits do endereço virtual. . na Figura 10.Ricardo Luís de Freitas Notas de Aula . ocorrer o caso de que um acesso seja realizado para uma página que não está na memória. acessa a posição correspondente da tabela de translação. gera uma interrupção para carregamento e. A Figura 11 mostra a operação da MMU. sendo os 4 restantes utilizados como um índice para qual das 16 páginas está sendo referenciada. o que chama uma rotina de tratamento de interrupção específica para o S. apresentada acima. No entanto. verifica o valor colocado nessa entrada da tabela de translação e os junta aos 12 bits de deslocamento dentro da página. A forma mais comum de implementação da MMU. que então se encarrega do carregamento da página faltante e o ajuste correspondente na tabela de translação. A MMU portanto. como nem todas as páginas do espaço virtual podem estar residentes na memória simultaneamente. é gerada uma falta de página (page fault). Por exemplo. o de número 2). é escolher alguns dos bits mais significativos do endereço virtual como indicadores do número de página e o restante dos bits como um deslocamento dentro dessa página. Se um acesso for realizado a uma página ausente. Note que nem o processador nem a memória precisaram ficar sabendo da existência de paginação. verifica se a página está presente na memória. Converte então esse endereço para 8192 (decimal) e envia esse endereço convertido para a memória.Sistemas Operacionais . 12 serão utilizados para o deslocamento (pois são necessários 12 bits para endereçar os 4k bytes de uma página).

43 Figura 11 5.Ricardo Luís de Freitas Notas de Aula . diferentemente da paginação.Sistemas Operacionais . os arquivos podem ser acessados como se fossem posições de memória. Veja que. Segmentação A paginação fornece uma forma de se conseguir grandes espaços de endereçamento lineares em uma quantidade finita de memória física. de forma que neste caso. Dessa forma. Em algumas aplicações. cada um com dado número de bytes.6. A Figura 12 mostra uma implementação comum de segmentação em microcomputadores com o processador 68000. Os diferentes segmentos são associados a diversos programas ou mesmo arquivos.2. . O espaço é bidimensional no sentido de que é dividido em um certo número de segmentos. um endereçamento é sempre expresso da forma (segmento. é preferível ter um espaço bidimensional. deslocamento). Essa estratégia facilitou o compartilhamento de objetos entre processos diferentes. na segmentação os programadores (ou os compiladores) levavam cuidadosamente em conta a segmentação. no entanto. tentando colocar entidades diferentes em segmentos diferentes.

O descritor do segmento contém o tamanho do segmento (1 a 16 páginas). A cada um dos 16 processos. a única coisa que o S. sendo que cada descritor contém até 16 páginas. . a MMU associa uma seção com 64 descritores de segmento. Deve-se enfatizar que este é apenas um exemplo de esquema de segmentação e não o único possível.44 Figura 12 Note que o hardware suporta até 16 processos.Ricardo Luís de Freitas Notas de Aula .Sistemas Operacionais . Note também que para trocar de processo.O. bits que indicam a proteção associada com o segmento e um ponteiro para uma tabela de páginas. cada um com 1024 páginas de 4k bytes cada (isto é. cada processo com um endereço virtual de 4M bytes). precisa fazer é alterar um registrador de 4 bits e isso automaticamente muda os acessos às tabelas.

deve escolher uma das páginas atualmente residentes na memória para ser removida.45 6.Ricardo Luís de Freitas Notas de Aula . quantas instruções serão executadas antes que a página seja referenciada).Sistemas Operacionais . pois exigiria conhecimento de situações futuras (De que forma um S. onde temos um controle completo das execuções dos processos. além de escolher outra para ser removida. caso a página a ser removida tenha sido alterada. o S.. Este método é utilizado apenas em simulações. isto é. removêssemos uma página amplamente utilizada. O problema que surge aqui é o seguinte: de que forma escolher a página a remover ? É claro que devemos procurar remover uma página que não seja muito necessária aos processos em execução.e. para cada página presente na memória. o método delineado acima não pode ser implementado numa situação real. quantas instruções faltam para a mesma ser referenciada (i. Se. ao contrário. de forma a liberar um quadro de página para a colocação da página faltante. O que devemos considerar então é o seguinte: como determinar qual página não está sendo muito utilizada ? Os próximos ítens discutiram alguns métodos de se realizar essa escolha. ocorre um page fault). conseguiria determinar quantas instruções faltam para uma página ser referenciada?). • retirar a página que for demorar mais tempo para ser novamente referenciada. para fins de comparação de algum algoritmo com o algoritmo ótimo.e. devemos remover uma página não muito utilizada. . Deve-se tomar o cuidado.O. de reescrevê-la no disco. em pouco tempo uma referência à mesma seria realizada. o que ocasionaria um page-fault e a necessidade de recarregar esta página. Como é fácil perceber. 6. Mudança Ótima de Página O método ótimo de mudança de página consiste no seguinte: • determinar.1.O.. ALGORITMOS DE MUDANÇA DE PÁGINA No momento em que é detectada a falta de uma página (i.

que não tiveram nenhuma referência desde o último tiquetaque do relógio. Mudança da Página não Recentemente Usada Este método seleciona para retirar uma página que não tenha sido recentemente utilizada. A classe 3 ocorre para uma página que já foi alterada e referenciada desde o último tiquetaque. pode simular esses bits através da utilização dos mecanismos de proteção de páginas. . marcam-se todas as páginas como ausentes.O. . da seguinte forma: • Inicialmente. no momento da ocorrência do page fault. O método de determinar se uma página foi recentemente utilizada é então o seguinte: • a cada tiquetaque do relógio. Esse algoritmo apresenta as vantagens de ser implementável de forma simples e eficiente. Estes bits. M: indica se a página foi modificada. Para determinar se uma página foi ou não utilizada recentemente.Ricardo Luís de Freitas Notas de Aula . são alterados automaticamente (por hardware) quando uma referência à página é realizada. o S. os bits R e M da página correspondente são colocados em 1. quando uma instrução lê um dado em uma certa posição de memória. Uma vez que esses bits sejam colocados em 1. temos três categorias de páginas: classe 0: R=0. sem ter sido alterada. • quando ocorre um page fault. M=1 classe 2: R=1. o bit R da página correspondente é automaticamente colocado em 1. M=0 classe 3: R=1.O. conta-se com o auxílio de 2 bits associados com cada uma das páginas na memória: R: indica se a página já foi referenciada. coloca todos os bits R das páginas em 0. Assim. M=0 classe 1: R=0.Sistemas Operacionais . o S.escolhe-se para ser retirada uma das páginas que pertencer à classe mais baixa não vazia. presentes em muitos hardwares de paginação. Esses bits são colocados inicialmente em 0 quando uma página é carregada na memória. Quando o hardware não dispõe dos bits R e M. As classes 0 e 1 são as correspondentes às classes 2 e 3 (respectivamente). eles só podem voltar a 0 através de instruções em software.46 6. quando uma instrução escreve em uma dada posição de memória. M=1 A classe 2 ocorre para uma página que foi referenciada pelo menos uma vez desde o último tiquetaque do relógio.2.

mantém-se uma fila de páginas referenciadas. • prossegue analisando a fila. Uma variação dessa solução é o algoritmo conhecido como segunda chance: • verifica o bit R da página mais velha. Ao entrar uma nova página. Primeira a Sair"(FIFO) Neste caso.O. 6. O problema com este algoritmo é que pode retirar páginas muito valiosas (i. Mudança de Página "Primeira a Entrar. • o S.O. até encontrar uma página com R=0 (no pior caso. • se R for 1.. LRU) Este método se baseia nas seguintes observações: . então marca numa tabela interna o bit M correspondente a essa página. Uma possível solução para esse problema consiste na utilização dos bits R e M: • verifica os bits R e M da página mais antiga.. • o S. poderá então marcar a página como de leitura e escrita (Read-Write). 6. prossegue para as classes seguintes (1. põe R em 0 e coloca a página no fim da fila.O. em uma tabela interna. substituindo a que estava colocada no início da fila. que teve seu R alterado para 0).47 • quando uma página é referenciada.e. 2 e 3). então marca essa página como presente. Mudança da Página Menos Recentemente Utilizada (Least Recently Used. continua procurando na fila. escolhe-a para ser retirada. • o S. • se em toda a fila não achou nenhum classe 0. utiliza essa página. ela entra no fim da fila. mas permite apenas leitura (i.3. • se não for.Ricardo Luís de Freitas Notas de Aula . • quando uma escrita for tentada nessa página. e o S. Read-Only).O.4. uma interrupção de acesso inválido será gerada.Sistemas Operacionais . • se essa página for classe 0. marca também. páginas que. será a primeira página. um bit R simulado para essa página. • se R for zero. apesar de estarem a bastante tempo na memória estão sendo amplamente utilizadas).e. é gerado um page fault (pois a página está marcada como ausente).

Sistemas Operacionais . depois de cada referência à memória.5. retiramos a página que apresentar o menor número em sua linha (este número é interpretado pela associação de todos os bits da linha da esquerda para a direita). Simulando LRU em Software Nas soluções de LRU apresentadas até agora. escolhemos a página com o menor valor no campo de armazenamento do contador (pois essa será a página que foi referenciada a mais tempo). Na primeira. quando ocorre um page fault. colocamos em 0 todos os bits da coluna i da tabela.48 • páginas muito utilizadas nas instruções mais recentes provavelmente permanecerão muito utilizadas nas próximas instruções. para cada página. desenvolveu-se uma aproximação para LRU. consideramos sempre a necessidade de hardware especial. cada entrada na tabela de páginas. Na segunda solução. Mas. Vejamos agora duas possíveis soluções por hardware. com as mais recentemente utilizadas no começo e as menos recentemente utilizadas no final. tem também associado um campo com tantos bits quantos os do contador C. . Com esse contador. • páginas que não são utilizadas a tempo provavelmente não serão utilizadas por bastante tempo.cada instrução executada. O problema básico com este algoritmo é que a sua implementação é muito dispendiosa: deve-se manter uma lista de todas as páginas na memória. e agimos da seguinte forma: • quando a página i é referenciada. e esta lista deve ser alterada a cada referência de memória.Ricardo Luís de Freitas Notas de Aula . com um número relativamente grande de bits (p.: 64 bits). retira a página que a mais tempo não é referenciada. Note-se que a implementação por software é completamente inviável em termos de tempo de execução. em seguida. O algoritmo então consiste no seguinte: quando ocorre um page fault. • quando ocorre um page fault. em software. temos uma matriz n X n de bits. colocamos em 1 todos os bits da linha i da tabela e. e quando não existe hardware especial para LRU ? Com essa consideração em vista.ex. da seguinte forma: • um contador é mantido. realizamos o seguinte procedimento: . chamada NFU (não frequentemente utilizada). que pode ser realizada por software. mantemos no processador um contador C. para n quadros de páginas. 6. o contador C é armazenado na entrada correspondente à página referenciada. incrementamos esse contador.

escolhe-se a página com valor menor nesse contador. Por exemplo. não conseguimos mais distinguir as páginas mais antigas. o bit R correspondente a cada uma das páginas é somado a esse contador (portanto.6. colocando-a como candidata à substituição. A alteração consiste no seguinte: • os contadores são deslocados 1 bit à direita. para que um sistema de paginação tenha um bom desempenho. O grande problema com esse algoritmo é que. além do algoritmo de paginação propriamente dito. Esse algoritmo é conhecido como algoritmo de aging. É obvio que uma página que não foi referenciada a 4 tique-taques ter 4 zeros à esquerda e. se a página foi referenciada dentro desse intervalo de relógio. o valor do contador será mantido) • quando ocorre um page fault. o número de bits do contador é finito e. Este algoritmo tem duas diferenças fundamentais em relação ao algoritmo de LRU: 1. No entanto. 6.Sistemas Operacionais . uma página não referenciada a 9 tique-taques não pode ser distinguida de uma página não referenciada a 1000 tique-taques. caso contrário. Considerações de Projeto para Sistemas de Paginação Veremos alguns pontos que devem ser considerados. quando este chega a zero. 2. uma modificação simples pode ser feita no método evitando esse inconveniente. não consegue decidir qual a referencia mais recente com intervalos menores que um tiquetaque. se uma página intensivamente utilizada durante um certo tempo. ao invés de ao bit mais à direita (menos significativo). portanto. o valor do contador será incrementado. . em geral 8 bits é suficiente para determinar que uma página já não é mais necessária. mesmo quando não for mais necessária (pois adquiriu um valor alto no contador). antes de somar R • R é somado ao bit mais à esquerda (mais significativo) do contador. ela tender a permanecer na memória.Ricardo Luís de Freitas Notas de Aula . com 8 bits no contador. portanto um valor baixo.49 • a cada interrupção de relógio. Felizmente.

quando um processo que estava em disco deve ser colocado na memória? Se deixarmos que esse processo gere tantos page fault quanto necessários para a carga do seu working set. Por outro lado. Devemos então. passando-se então a utilizar as de análise semântica e assim por diante. então ocorrer thrashing. que ocorre quando um processo gera muitos page fault em poucas instruções. o que significa que os processos mantém. teremos uma execução muito lenta.Ricardo Luís de Freitas Notas de Aula . Esta estratégia pura pode ser melhorada.Sistemas Operacionais .6. Baseado neste fato. que corresponde ao conjunto de páginas correntemente em uso de um dado processo. (Obs: processos residentes na memória são aqueles que o escalonador de baixo nível utiliza para a seleção do atualmente . se todo o conjunto ativo de um processo estiver na memória principal.50 6. Um primeiro dado importante a considerar é a existência. que durante um certo tempo acessa as páginas correspondentes à análise sintática. Se a soma total dos working set de todos os processos residentes em memória é maior que a quantidade de memória disponível. o que ocasionará uma grande diminuição em seu tempo de execução. devido à necessidade de constantes trocas de páginas entre memória e disco. depois essas páginas deixam de ser necessárias. referências a frações pequenas do total do número de páginas necessárias a ele. em cada uma das fases de sua execução. É fácil de notar que. Modelo do Conjunto Ativo (Working Set) Num sistema puro de paginação. de uma localidade de referências. Vejamos agora algumas considerações com relação aos tamanhos dos working set. Surge então a seguinte consideração: o que fazer quando um processo novo é iniciado ou. determinar qual é o working set do processo e carregá-lo na memória antes de permitir que o processo comece a executar. ele executará praticamente sem gerar page faults.1. que também pode ser chamado de paginação por demanda. se não houver espaço para todo o conjunto ativo de um processo. O ato de carregamento adiantado das páginas (antes da ocorrência do page fault para a mesma) é chamado pré-paginação. como veremos a seguir. de alguma forma. surge o conceito de conjunto ativo (working set). seguindo o algoritmo de substituição de página escolhido. até que passe a uma nova fase do processamento. na grande maioria dos processos. o sistema começa sem nenhuma página na memória e elas vão sendo carregadas à medida em que forem necessária. Aqui surge o conceito de thrashing. este gerará muitos page faults. num sistema com swap. Um exemplo disso é um compilador. Este é o chamado modelo do conjunto ativo (working set model).

. veja a Figura 13 onde. Rotinas de Alocação Local X Global Devemos agora determinar de que forma a memória será alocada entre os diversos processos executáveis que competem por ela.) Portanto. para a colocação da página requerida. 6.51 em execução. Após os fatos apresentados acima. Para exemplificar a diferença entre as duas técnicas. surge a questão: como determinar quais as páginas de um processo que fazem parte de seu working set? Uma possível solução para isto é utilizar o algoritmo de aging. qualquer página que não seja referenciada por n tique-taques consecutivos é retirada do working set do processo). a certos intervalos de tempo. enquanto que para uma estratégia global. não importa a qual processo ela esteja alocada. • alocação global: quando um page fault é gerado. escolhe para retirar uma das páginas da memória. considerando como parte do working set apenas as páginas que apresentem ao menos um bit em 1 em seus primeiros n bits (i.e.Sistemas Operacionais . a página retirada será a A5 (conforme (b)).6. que são descritas a seguir: • alocação local: quando é gerado um page fault em um dado processo.Ricardo Luís de Freitas Notas de Aula . devemos escolher os processos residentes em memória de forma que a soma de seus working set não seja maior que a quantidade de memória disponível. As duas estratégias básicas são chamadas de alocação local e alocação global. é gerado um page fault para a página A6 (os números ao lado das páginas indicam o valor do contador do algoritmo de aging).. a página retirada será a B3. retiramos uma das páginas do próprio processo.2. O valor de n deve ser definido experimentalmente. Se seguimos uma estratégia local. O escalonador em alto nível é o responsável pela troca (swap) dos processos residentes em memória. na situação da figura (a).

os algoritmos globais apresentam maior eficiência. Entretanto isto apresenta um problema. devemos resolver a seguinte questão: de que forma o sistema pode decidir dinamicamente (i. • se o working set de um processo diminui. enquanto que a estratégia global muda dinamicamente a alocação de memória.Ricardo Luís de Freitas Notas de Aula . Em geral. se nos decidimos por utilização de uma estratégia global.. Entretanto.Sistemas Operacionais . 20ms). conforme indicado acima. Uma solução melhor para esse problema é a utilização de um algoritmo de alocação por frequência de falta de página (PFF: page fault frequency). a estratégia local tende a desperdiçar memória. Esta técnica é baseada no fato de que a taxa de falta de páginas para um dado processo decresce com o aumento do número de quadros de página alocados para esse processo.Veja a Figura 14 .52 Figura 13 É fácil de notar que a estratégia local mantém fixa a quantidade de memória destinada a cada processo. a todo instante) quantos quadros de página alocar para cada processo (em outras palavras: qual o tamanho do working set do processo em cada instante) ? Uma possível solução é realizar a monitoração pelos bits de aging.e. enquanto que as indicações de aging só mudam a cada tique-taque do relógio (digamos. o working set de um processo pode mudar em poucos microssegundos. a estratégia local tende a gerar thrashing. devido aos seguintes fatos: • se o working set de um processo aumenta.

metade da página final de qualquer segmento é desperdiçada (pois os programas e áreas de dados não terminam necessariamente em múltiplos de página). Assim. Tamanho da Página Um outro fator que deve ser cuidadosamente estudado é o tamanho da página. além do de transferência.Ricardo Luís de Freitas Notas de Aula .6. temos um acesso ao disco. Considerações a favor de páginas grandes: • quanto menor o tamanho da página. . Existem considerações em favor tanto de páginas pequenas quanto de páginas grandes. • quando uma página precisa ser carregada na memória.53 Figura 14 6.Sistemas Operacionais . menos Tamanhos comumente encontrados de página são: 512 bytes. aumentando a eficiência. o que significa menor tempo de chaveamento de processos. se já transferimos uma quantidade maior de bytes a cada acesso.3. • um programa que consista em processos pequenos pode executar utilizando menos memória quando o tamanho da página é pequeno. então páginas maiores necessitarão registradores. como veremos: Considerações a favor de páginas pequenas: • na média. Isto é conhecido como fragmentação interna. 2 kbytes e 4 kbytes. diminuímos a influência dos dois primeiros fatores do tempo. • se o processador central precisa alterar registradores internos referente à tabela de páginas a cada chaveamento de processo. maior o tamanho da tabela de páginas (para uma dada quantidade de memória virtual). com os correspondentes tempos de busca e espera de setor. 1 kbytes.

Considerações de Implementação Normalmente. permitindo que estas sejam compartilhadas e impedindo o compartilhamento das páginas que são de leitura e escrita (p. Um outro problema mais difícil de resolver é o seguinte: . Existem basicamente duas soluções para este problema: 1. apresentaremos alguns exemplos a seguir.: o texto sob edição). após terminada a transferência. ou um compilador). destes para o buffer do processo. Se este outro processo gera um page fault. um outro processo é selecionado para execução. ele pode estragar a nova informação carregada pelo page fault. quando queremos implementar um sistema de paginação.ex.ex.Ricardo Luís de Freitas Notas de Aula .6. i) Bloqueamento de Páginas na Memória Quando um processo bloqueia aguardando a transferência de dados de um dispositivo para um buffer. impedindo que a mesma seja retirada da memória. existe a possibilidade de que a página escolhida para ser retirada seja justamente aquela onde se encontra o buffer que estava aguardando a transferência do dispositivo. ii) Páginas Compartilhadas Um outro problema que surge está relacionado com o fato de que diversos processo podem estar.: o código do programa). realizar as transferências de dispositivos sempre para buffers internos do kernel e.: diversos usuários rodando um editor.4.54 6.Sistemas Operacionais .ex. é conveniente que essas informações comuns sejam armazenadas em páginas que são compartilhadas pelos processos que as utilizam. A solução para este problema é simples: basta saber quais as páginas que são apenas de leitura (p. utilizando o mesmo programa (p. por exemplo. devemos considerar alguns fatos que complicam um pouco seu gerenciamento. os textos que estão sendo editados em um mesmo editor. 2. Para evitar duplicação de informações na memória. Se o dispositivo tentar então transferir para esse buffer. em um dado momento. Um problema que surge logo de início é o seguinte: algumas partes não podem ser compartilhadas como. trancamento da página que contém o buffer.

estão compartilhando o código de um editor. pois se isto ocorresse. • se um dos processo é enviado para o disco (swap) temos uma situação semelhante ao caso do término de um deles (como acima). entretanto. A e B. Este processo. o que representaria muita sobrecarga para o sistema. . seriam gerados muitos page fault para o processo B. portanto.55 • suponha que dois processos.Sistemas Operacionais . sai da memória algumas de suas páginas (as que correspondem ao código do editor) não poderão ser retiradas devido a serem compartilhadas. não é simples. A solução para isto é manter alguma forma de estrutura de dados que indique quais das páginas residentes estão sendo compartilhadas. • se A termina a edição e.Ricardo Luís de Freitas Notas de Aula .

a interface oferecida para todos os dispositivos de E/S deve ser a mesma (o que garante a Independência de Dispositivo . .device independency). que no entanto está muitas vezes ligada à sua operação interna. 7.Ricardo Luís de Freitas Notas de Aula .1. • dispositivos de caracteres: entrega ou aceita uma cadeia de caracteres. podendo ser lido independentemente de todos os outros.O. cada um dos quais com o seu próprio endereço. 7.Sistemas Operacionais . vemos que a classificação acima não é exaustiva. Na medida do possível. realizando apenas uma interrupção a intervalos predefinidos. Dispositivos de E/S Divide-se os dispositivos de E/S em duas categorias: • dispositivos de bloco: armazenam a informação em blocos de tamanho fixo. Por exemplo o relógio. servindo apenas como orientação para uma melhor compreensão de diversos dispositivos. Alguns dispositivos não se adaptam bem a nenhuma das duas categorias acima. Com isto. sem considerar qualquer estrutura de bloco. ENTRADAS E SAÍDAS Uma das funções principais de um S.1. Princípios de Hardware de E/S Os dispositivos de E/S serão enfocados sob o ponto de vista de sua programação. Ex: terminal e impressora. é controlar o acesso aos dispositivos de entrada e saída (abreviadamente: E/S ou I/O) e fornecer aos usuários uma interface simples com os mesmos.1. Ex: discos.56 7. que nem apresenta estrutura de bloco nem realiza transmissão de caracteres.

pela UCP. Os microcomputadores ---e diversos minicomputadores--.Ricardo Luís de Freitas Notas de Aula . 7. que retiram grande parte da carga da UCP com relação ao processamento de E/S. os registradores dos controladores são incluídos num espaço separado de endereçamento. o acesso a disco é feito da seguinte forma: 1. cuidando de todos os detalhes do funcionamento do dispositivo.se utilizam.1.3. vejamos como opera o acesso a disco com e sem a utilização dessa técnica. com os seus controladores). Acesso Direto à Memória Vários controladores (especialmente de dispositivos de bloco) suportam uma técnica de transferência conhecida como acesso direto à memória (DMA).1. bem como da organização da informação de forma a ser reconhecida pela UCP.2. chamados canais de E/S. Sistemas maiores em geral se utilizam de dutos múltiplos e computadores especializados de E/S. As operações de E/S são então realizadas através da escrita. do esquema de duto único. que são utilizados para comunicação com a UCP.O. • registradores em espaço de E/S: neste caso.57 7. . Cada controlador possui alguns registradores. Para exemplificar a operação do DMA. que controla o dispositivos.Sistemas Operacionais . sendo por isso denominada controlador ou adaptador. A interface entre o controlador e o dispositivo é geralmente de baixo nível. o controlador de disco lê. os bits de dados vindos do disco. um a um. para comunicação com os dispositivos de E/S (isto é. • parte eletrônica. Controladores de Dispositivos Em geral. os dispositivos estão constituídos em duas partes: • parte mecânica. de comandos nos registradores dos controladores e da leitura de resultados nesses mesmos registradores. Esta comunicação pode ser realizada de duas formas: • registradores no espaço de memória: neste caso. Quando não existe DMA. os registradores dos controladores ocupam posições no espaço de endereçamento da memória. conhecido como espaço de E/S. que é a que efetivamente executa as ações requeridas. O S. trata com o controlador e não com o dispositivo em si.

Princípios de Software de E/S Deve-se procurar organizar o software de E/S em camadas.2. esse ciclo gasta um tempo considerável da UCP devido à necessidade desta permanecer num "loop" para a transferência de todos os dados provindos do disco. Como pode ser visto. para dispositivos diversos. 2. e mesmo terminais de vídeo e linhas seriais. Objetivos do Software de E/S Os conceitos importantes que devem ser considerados num projeto de software para E/S são os seguintes: 1. é feito um teste para verificar se houve erros.2. é utilizada a técnica de DMA. O S. como discos flexíveis. endereço de memória onde ela quer que a informação seja colocada. se não houve erros. deve ser possível escrever programas que possam ser utilizados. 7. e não o usuário. 2. estes já se encontram na posição correta da memória.58 2.Sistemas Operacionais . . quando o S. o controlador causa uma interrupção na UCP 4.O. discos rígidos. 3. a UCP entra num "loop" de leitura. é que deve cuidar dos problemas causados pelas diferenças entre os dispositivos. a UCP dá ao controlador dados sobre o setor a ler. que faz com que o ciclo de transferência do disco fique como abaixo: 1. após o controlador ler o bloco e verificar os erros. como indicado anteriormente. que lê um byte por vez do controlador. denominação uniforme: os nomes dados aos dispositivos devem ser independentes do tipo do mesmo. Para eliminar o tempo gasto pela UCP nesse "loop". 7.Ricardo Luís de Freitas Notas de Aula . de forma que as camadas mais baixas ocultem as particularidades do hardware às camadas mais altas e estas últimas se ocupem de apresentar ao usuário uma interface clara e agradável. sem alteração. 3. quando um bloco completo foi transferido. e número de bytes que devem ser transferidos. independência de dispositivo: isto é. quiser utilizar os dados.O.1. não sendo necessário utilizar tempo de UCP para a transferência. ele automaticamente copia todo o bloco na posição de memória especificada.

ex. software em nível de usuário Vejamos as atribuições de cada uma dessas camadas. deve cuidar de fazer com que uma transferência assíncrona apareça ao usuário como síncrona. de forma que os níveis superiores somente se ocupem com erros que não podem ser tratados pelos níveis inferiores. o programa para até que ela esteja pronta (por exemplo. O mesmo já não acontece com outros (p.O.: discos.O. de forma conhecimento da existência de interrupções. Quando a interrupção correspondente ocorre.O. deve ser capaz de cuidar tanto de dispositivos compartilhados como de dispositivos dedicados. de uma forma que evite problemas em quaisquer dos casos.: impressora). tratamento de erros: deve-se tratar os erros nos níveis tão mais próximos do hardware quanto possível. O S.. software de E/S independente de dispositivo 4. a rotina de interrupção desbloqueia esse processo (através de um V que a menor parte possível do sistema tome . as interrupções devem ser tratadas nos níveis mais baixos do S.Sistemas Operacionais . um interrupção é gerada para informar a UCP de que a operação foi completada. de forma que. O método tradicional de trabalho é fazer com que os condutores de dispositivos (device drivers) sejam bloqueados quando executam um comando de E/S. 7. 5. que devem ser utilizados por um único usuário por vez. Os objetivos indicados acima podem ser atingidos de um modo abrangente e eficiente estruturando-se o software de E/S em quatro camadas: 1. Tratadores de Interrupção Devido a extrema dependência do hardware.2. ao pedir uma transferência. condutores de dispositivos (device drivers) 3.ex. O S. num read). a UCP pede uma transferência e em seguida vai realizar outras operações. podendo vários usuários possuírem arquivos abertos no mesmo). 4. tratadores de interrupções 2.2. é mais simples que as transmissões sejam consideradas bloqueantes.59 3. Ao se escrever programas. transmissão síncrona (bloqueante) X assíncrona (interrupções): na transmissão assíncrona. dispositivos compartilhados X dedicados: alguns dispositivos podem ser compartilhados entre diversos usuários sem problema (p.Ricardo Luís de Freitas Notas de Aula . Quando a transferência está pronta.

60 em semáforo. sendo a única parte do S. o condutor bloqueado será acordado por um interrupção proveniente do controlador.2.3.2. Condutores de Dispositivos (device drivers) O condutor de dispositivo contém todo o código dependente do dispositivo.4. devendo transformar o pedido dos termos abstratos em que é realizado para termos concretos. As funções geralmente realizadas pela parte do software independente de dispositivo são as seguintes: . que tem conhecimento do controlador utilizado.Ricardo Luís de Freitas Notas de Aula .O. a tarefa do condutor de dispositivo é aceitar comandos do software independente de dispositivo e fazer com que sejam executados.O. Em termos gerais. 7. etc.O. não sendo necessário o bloqueamento. 7. Os dados obtidos com a operação são então passados ao software independente de dispositivo. verificar o estado do motor (ligado ou desligado). A partir desse ponto temos duas situações possíveis: 1. Software Independente de Dispositivo A separação exata entre os condutores e o software independente de dispositivo é variável com o S. uma classe de dispositivos correlacionados. verificar onde fisicamente o bloco requisitado se encontra. dependendo do tipo de sincronização utilizado pelo S. Cada condutor de dispositivo maneja um tipo de dispositivo ou. ou um signal em variável de condição ou da transmissão de uma mensagem. O condutor de dispositivo envia os comandos aos controladores (através dos registradores corretos) e verifica que esses comandos sejam corretamente executados. Por exemplo. no condutor de disco.). posição da cabeça de leitura.Sistemas Operacionais . o controlador executa o comando automaticamente. o controlador leva algum tempo até terminar a execução do comando. caso em que o condutor de dispositivo se bloqueia. no máximo. 2. No primeiro caso. Ele então determina os comandos que devem ser enviados ao controlador do dispositivo e os envia.

• bufferização: deve existir bufferização para se poder lidar com situações como as seguintes: a) dispositivos de bloco requerem o acesso a blocos completos. • alocação de memória em dispositivos de bloco: a descoberta de quais o blocos livres e quais os ocupados em um dispositivo de bloco não é dependente do dispositivo e pode. Essas diferenças devem ser ocultadas. • alocação e liberação de dispositivos dedicados: pode ser tratada também nesta parte do S. entretanto.Sistemas Operacionais . portanto. como qualquer arquivo.O. • fornecimento de um tamanho de bloco independente do dispositivo: para dispositivos de bloco. não existindo nenhuma proteção implícita. • denominação dos dispositivos: consiste no mapeamento dos nomes simbólicos nos condutores corretos. Já em computadores grandes. b) em dispositivos de caracteres.: leitora de cartões). devemos fazer com que todos os presentes no sistema apresentem ao usuário o mesmo número de blocos. . • proteção dos dispositivos: em microprocessadores. alguns apresentam um caracter por vez (p.O. o tratamento desse erro é independente do dispositivo.ex. ou o dispositivo pode enviar antes que o usuário esteja pronto para ler. portanto. o acesso a dispositivos de E/S é protegido pelos bits rwx. o usuário pode tentar escrever mais rápido do que o dispositivo pode ler. uma mensagem deve ser enviada e o sistema terminado.61 • interfaceamento uniforme para os condutores de dispositivo: é a função básica. após um condutor informar um erro. compreendendo a execução de funções comuns a todos os dispositivos de E/S. em geral o usuário pode fazer o que desejar com os dispositivos de E/S. No UNIX.ex. Para dispositivos de caracter. enquanto que o usuário pode requerer acesso a unidades menores. No entanto. enquanto que outros apresentam-nos em conjuntos de vários caracteres (p. sendo em geral o erro informado ao processo que pediu o acesso.: terminais).Ricardo Luís de Freitas Notas de Aula . o acesso a dispositivos de E/S é proibido aos usuários. ser realizada neste nível do S. Normalmente isto é feito com chamadas de sistema do tipo open (para pedir acesso) e close (para liberar o acesso). No caso de um erro que possa comprometer completamente o funcionamento do sistema. ser executada nos condutores de dispositivos. • informe de erros: a maioria dos erros é altamente dependente do hardware e deve.

o daemon o imprime quando possível.Sistemas Operacionais . chamado daemon. Temos também os sistemas de spooling. considere o que ocorreria caso um usuário realizasse open e não utilizasse a impressora por horas. é criado um processo especial. e um diretório de spool. No entanto. A impressora poderia ser tratada através da utilização de open e close.: printf). Quando um processo quer imprimir um arquivo ele o coloca no diretório de spool e. Muitas dessas rotinas não fazem nada mais do que colocar os parâmetros no local apropriado para a chamada de sistema e realizar a chamada. . Outras entretanto fazem um trabalho real. incluindo-se as de E/S. O exemplo típico de dispositivo que utiliza spool é a impressora.Ricardo Luís de Freitas Notas de Aula . que é o único a ter permissão de acesso à impressora.2. Chamadas de sistema. Dessa forma. Software de E/S no Espaço de Usuário Uma parte do software de E/S consiste em rotinas de biblioteca ligadas com programas de usuário e mesmo programas inteiros rodando fora do modo kernel. são feitas geralmente por rotinas de biblioteca. então.62 7.5. em geral de formatação de dados (p.ex. que consistem em uma forma de tratar dispositivos de E/S dedicados em sistemas de multiprogramação.

63 8. A única solução nesses casos é não utilizar spool nesse dispositivo. sendo dois métodos utilizados: 1. Requisitar o recurso 2. . Utilizar o recurso 3. Para a utilização de um recurso temos. caso em que cada uma pode ser utilizada para satisfazer um pedido distinto.1. No entanto. 8. Para alguns recursos.Sistemas Operacionais .Ricardo Luís de Freitas Notas de Aula . Recursos podem ser dispositivos de hardware ou trechos de informação. então. situação na qual permanecerão indefinidamente. o processo é bloqueado e acordado quando o recurso estiver disponível. a saída gerada (principalmente quando se trata de saída para fita magnética) pode incluir até 50 Mbytes.ex. Suponha a seguinte situação: • processo A pede unida e de fita magnética e recebe • processo B pede plotter e recebe • processo A pede plotter sem liberar a fita magnética • processo B pede fita magnética sem liberar plotter Neste caso percebemos que tanto o processo A como o processo B são postos para dormir. o processo que o requisitou é forçado a aguardar. a seguinte sequência a ser realizada pelo processo: 1. antes que a saída possa se iniciar (pense no que ocorreria caso um daemon iniciasse a impressão antes que o arquivo seja completamente gerado e o processo que gera o arquivo para por algumas horas antes de terminar a geração). esta solução pode gerar deadlock. diversas instâncias idênticas podem estar disponíveis (p. DEADLOCK Um problema com a técnica de spool é que o arquivo inteiro precisa ser escrito no disco. o que inviabiliza que todos os dados sejam escritos no disco antes de serem enviados ? unidade. mas fazer com que os usuários tenham acesso exclusivo ao mesmo quando precisarem. Recursos Chamaremos de recurso qualquer objeto ao qual deva ser dado acesso exclusivo para cada processo.: diversas unidades de fita). Em alguns casos. Liberar o recurso Se um recurso não estiver disponível quando for requisitado.

onde A e B são processo e R e S são recursos: .Ricardo Luís de Freitas Notas de Aula .: aguardar algum tempo e pedir novamente) 8. 2. aguardando o recurso. Quatro condições são necessárias para que ocorra deadlock: 1. então. Não existe preempção: recursos dados a um processo não podem ser tomados de volta. cada membro do conjunto está esperando pela liberação de um recurso que apenas outro membro do conjunto pode liberar. Modelamento de Deadlock Deadlock: ocorre quando cada processo de um conjunto de processos está esperando por um evento que apenas outro processo do mesmo conjunto pode causar.ex.64 2. que o próprio processo deve decidir a ação a tomar (p.Sistemas Operacionais . 3. 4. Em muitos casos. Eles precisam ser explicitamente liberados pelo processo. cada um dos quais aguardando um recurso em posse do próximo membro da cadeia. Podemos modelar a distribuição dos recursos e das requisições dos mesmos através de um grafo com dois tipos de nós: • circular: representa um processo • retangular: representa um recurso O significado dos arcos entre os nós é o seguinte: • arco de um recurso para um processo: indica que esse recurso está entregue ao processo apontado. Posse e espera (hold and wait): um processo que já possui algum recurso pode requisitar outros e aguardar por sua liberação.2. é enviado um código de erro ao processo indicando que a requisição falhou sendo. o evento esperado é a liberação de um recurso qualquer. Veja a Figura 15. isto é. • arco de um processo para um recurso: indica que o processo está bloqueado. Espera circular: Deve haver uma cadeia circular de dois ou mais processos. O número de processos ou recursos envolvidos nessa situação não é importante. Exclusão mútua: cada recurso ou está associado a exatamente um processo ou está disponível.

Sistemas Operacionais . o grafo correspondente será como indicado na Figura 16: .O. Suponhamos então que queremos realizar o escalonamento dos processos em um método de round-robin.Ricardo Luís de Freitas Notas de Aula . e de três recursos R. então claramente não teremos deadlock. As requisições de recursos podem então ocorrer da seguinte forma: A pede R B pede S C pede T A pede S B pede T C pede R Neste ponto. mas também não teremos nenhum paralelismo.65 A S A R S R (a) B (b) B (c) Figura 15 Analisemos agora um caso mais complexo. S. Suponhamos ainda para cada processo a seguinte ordem de requisição e liberação de recursos: A: pede R pede S libera R libera S B: pede S pede T libera S libera T C: pede T pede R libera T libera R Se o S. Suponhamos a existência de três processos A. executa cada um dos processo por vez. esperando que um processo termine antes de executar o outro. e T. B e C.

liberar os recursos na ordem que julgar mais adequada. fazendo com que o mesmo aguardasse para iniciar quando já não houvesse perigo de deadlock. tem liberdade de executar os processos e.O. A B C A B C A B C R S T R S T R S T (l) (m) (n) . Note que a partir deste ponto. se ele soubesse da possibilidade de ocorrência de deadlock na situação acima.Sistemas Operacionais . como o S. Entretanto. indicando um deadlock. poderia deferir. Assim a ordem de execução poderia ser a seguinte: A pede R C pede T A pede S C pede R A libera R A libera S E vemos então que não haverá deadlock.Ricardo Luís de Freitas Notas de Aula . B pode iniciar a receber os recursos. A Figura 17 indica a evolução dos pedidos indicados acima. portanto. por exemplo. a execução do processo B.66 A B C A B C A B C R S T R S T R S T (a) A B C A (b) B C A (c) B C R S T R S T R S T (d) (e) (f) Figura 16 Vemos então que ocorreu uma cadeia circular de processos e recursos.

Detecção e Recuperação Nesta técnica. Evitação dinâmica. 8. em compiladores ou no hardware. prevenção.Sistemas Operacionais . ignorar o problema 2. detecção e recuperação 3.4. um dos processos do ciclo deve ser morto . através da manutenção de um grafo de recursos. O UNIX utiliza este método. o alto preço pago pelos usuários para se prevenir os deadlocks. negando uma das quatro condições necessárias 4.O. o S.O. 2. por uma alocação cuidadosa dos recursos Vejamos as técnicas e implicações envolvidas.3. esta solução é a mais utilizada devido aos seguintes fatores: 1. baixa probabilidade de ocorrência de deadlock. O "Algoritmo da Avestruz" A estratégia mais simples para lidar com o deadlock é a mesma da avestruz frente a um perigo: colocar a cabeça em um buraco na areia e fingir que o problema não existe. Apesar de teoricamente inaceitável.. que é constantemente atualizado e onde se verifica a ocorrência de ciclos. Se houver algum ciclo. 8.Ricardo Luís de Freitas Notas de Aula . apenas monitora as requisições e liberações de recursos. como veremos mais detalhadamente a seguir.67 A B C A B C A B C R S T R S T R S T (o) (p) (q) Figura 17 Em geral são utilizadas quatro estratégias para se tratar com o deadlock: 1. muito menor do que da ocorrência de quebra do sistema por erros no próprio S.

entretanto. Um problema com este método é que muitos processos não sabem com antecedência quais os recursos de que irão necessitar até começar a execução.2. esta condição não pode ser eliminada. Se todos os recursos estiverem disponíveis então ele é executado. geralmente em batch. evitar que se formem ciclos fechados no grafo de recursos): • cada processo só pode ter um recurso por vez e. então o deadlock é impossível. esta condição não pode ser quebrada. Caso contrário. pois não pode haver acesso por dois processos simultaneamente e nem sempre a técnica de spool pode ser empregada. 3) Não preempção: é fácil notar que tomar um recurso de um processo para entregá-lo a outro é gerador de confusão. o processo deve aguardar.) nunca é satisfeita.Ricardo Luís de Freitas Notas de Aula . ter cuidado de que qualquer arquivo modificado pelo processo morto deve ser restaurado ao seu estado original antes de iniciar o processo novamente. se desejar outro. Um modo diferente de quebrar esta condição é fazer com que. . Se garantirmos que uma das quatro condições necessárias (veja item 4.5. É uma técnica utilizada em computadores grandes. o processo deva liberar temporariamente todos aqueles que possui e somente se conseguir o novo recurso é que pode pegar os anteriores de volta. onde um processo pode ser morto e mais tarde reinicializado. Prevenção de Deadlock Consiste em impor restrições aos processos de forma que o deadlock seja impossível. Portanto. outro processo deve ser morto e assim sucessivamente. 2) Posse e espera: Uma forma de negar esta condição é fazer com que cada processo requisite todos os recursos que irá necessitar antes de iniciar a execução. Portanto. para alguns recursos é necessária a exclusão mútua. Isto impossibilitaria coisas simples como cópia de uma fita para outra. Analisemos quais as possibilidades de eliminar as condições: 1) Exclusão mútua: como vimos. até que o ciclo seja quebrado. Se ainda permanecer o ciclo.68 (terminado à força). para pedir um novo recurso.Sistemas Operacionais . deve liberar o que possui. 8.3. 4) Espera circular: Vejamos alguns métodos de evitar a espera circular (isto é. Deve-se. Outro problema é que os recursos não serão utilizados otimamente (Você sabe indicar por que?).

6.O. 8. mas eles não precisam de todas elas imediatamente.1.6. Evitação Dinâmica de Deadlock Neste método procura-se evitar o deadlock sem impor restrições aos processos. Algoritmo do Banqueiro para um único Recurso O algoritmo do banqueiro. 8. É o que analisaremos agora. introduzido por Dijkstra em 1965 evita deadlocks. de forma que o banqueiro reservou 10 unidades para atender todos os pedidos (que totalizam 32 unidades). O problema aqui é que se torna difícil encontrar uma numeração que satisfaça a maioria das possíveis condições de acesso. em cada momento. Cliente A B C D disponível: 10 Figura 18 Considera-se que: • cada cliente pode. Isto é possível desde que alguma informação sobre a utilização de recursos pelo processo seja disponível antecipadamente ao S. Consiste em simular as decisões de um banqueiro no empréstimo de certa quantia de dinheiro. como veremos. C e D) que têm linhas de crédito com um banqueiro.Ricardo Luís de Freitas Notas de Aula . Usado 0 0 0 0 Máximo 6 5 4 7 .Sistemas Operacionais . sujeito a certas condições especiais.69 • é dada uma numeração global a todos os recursos e os processos só podem requisitar recursos em ordem numérica estritamente crescente. • o banqueiro pode escolher livremente o momento de atendimento dos pedidos realizados. realizar um pedido desde que este não faça com que ultrapasse seu limite de crédito. apenas se comprometendo em atendê-lo em um tempo finito. B. Cada um especificou o número máximo de unidades de crédito que irá precisar. Na Figura 18 vemos a representação de quatro clientes (A.

bem como dos recursos ainda disponíveis em um dado momento. analisar cuidadosamente cada pedido de recurso. pegar as 5 unidades de volta e emprestar à A.Sistemas Operacionais .70 • após o recebimento de todo o crédito que especificou inicialmente (isto é. o cliente B fizesse um pedido de mais uma unidade e o banqueiro atendesse. portanto.Ricardo Luís de Freitas Notas de Aula . o cliente se compromete a devolver. O banqueiro deve. Na Figura 19 temos um exemplo: Cliente A B C D disponível: 2 Figura 19 Usado 1 1 2 4 Máximo 6 5 4 7 Um estado é dito seguro se existe uma sequência de outros estados que leva a que todos os clientes recebam seus empréstimos até seus limites de crédito. garantindo que todos os clientes foram atendidos. na mesma situação da Figura 19. tudo o que lhe foi emprestado. pois o banqueiro pode emprestar as duas unidades à C. pegar as 6 unidades de volta e emprestar 3 delas à D. Teríamos então a situação da Figura 20: Cliente A B C D disponível: 1 Figura 20 Usado 1 2 2 4 Máximo 6 5 4 7 . Chamamos de estado a situação dos empréstimos. Suponhamos entretanto que. o seu valor de Máximo). pegando então as 7 unidades de volta. dentro de um tempo finito. para garantir que não entre numa situação da qual não possa sair. O estado da Figura 18 é seguro. Vejamos um exemplo. pegar a devolução do mesmo (4 unidades) e emprestar à B.

Desta forma estaríamos novamente numa situação segura. o banqueiro não pode contar com isso. como na Figura 21: FALTANDO A B C D E 1 0 3 0 2 1 1 1 0 1 0 1 0 1 1 0 2 0 0 0 ENTREGUES A B C 3 0 1 0 1 1 1 0 1 1 0 0 . e devolver os 4 que já pediu ao banqueiro. pois não há forma de o banqueiro garantir o atendimento de todos os pedidos. Importante notar que ainda não estamos em deadlock.2. montamos duas matrizes. Por exemplo. Portanto.71 Como é fácil verificar. Se for.Ricardo Luís de Freitas Notas de Aula . verificar se conceder o mesmo leva a um estado seguro ou não. o que pode vir a gerar um deadlock. o cliente D pode decidir que não precisa mais de novos recursos. sendo que cada linha das matrizes corresponde a um processo e cada coluna corresponde a um tipo de recurso. pois os valores de máximo não precisam necessariamente ser atingidos. finge que esse cliente já devolveu tudo que possuía. para cada pedido que chega. o algoritmo do banqueiro consiste em. uma de recursos entregues e outra de recursos ainda necessários.6. Para verificar se o estado é seguro ou não ele deve verificar se o disponível é suficiente para atender o cliente mais próximo de seu máximo.Sistemas Operacionais . No entanto. marca o mesmo como terminado e verifica se pode atender o cliente mais próximo do máximo entre os que restam. Se ele puder levar a bom termo esse processo. O Algoritmo do Banqueiro para Vários Recursos Neste caso. pois não tem formas de saber quando um cliente irá necessitar ou não do máximo que especificou. atendendo (em sua análise) todos os clientes. este não é um estado seguro. Se levar a um estado seguro o cliente é satisfeito. então o estado é seguro. 8.

72 D E 1 0 1 0 0 0 1 0 Figura 21 Temos também três vetores E. liberando todos os recursos que estava ocupando 3. repetir os passos 1 e 2 até que todos os processos sejam marcados como terminados. O problema com este algoritmo é que os processos raramente sabem com antecedência a quantidade máxima de recursos que necessitarão.Ricardo Luís de Freitas Notas de Aula . os processos precisam avisar com antecedência das suas necessidades de recursos. Além disso. Se não existir uma linha assim. procuramos uma linha L cujos recursos ainda necessários sejam todos menores que os correspondentes valores no vetor D. da seguinte forma: 1. Assumir que o processo da linha L requereu todos os recursos e terminou. Se isto for conseguido o estado é seguro. sendo que apenas se utilizam alguns em aplicações de propósito específico. o sistema provavelmente entrará em deadlock e o estado não é seguro. E = (6 3 4 2) P => recursos possuídos por algum processo. D = (1 0 2 0) Como no caso de um único recurso. o que invalida as análises realizadas. então. Não é conhecido nenhum algoritmo para cuidar do caso geral. P e D que indicam: E => recursos existentes. 2. o número de processo no sistema varia dinamicamente. Para descobrir se um estado é seguro ou não procedemos. P = (5 3 2 2) D => recursos disponíveis. .Sistemas Operacionais .

ler. Visão do Usuário Para o usuário de um sistema operacional. destruir. escrever.).73 9. permitem que usuários definam objetos chamados arquivos e apresentam operações especiais (realizadas por chamadas de sistema).1. etc. sob esse ponto de vista. Os pontos principais de um sistema de arquivos. Três formas comuns de organização de arquivos são apresentadas na Figura 22: Figura 22 . SISTEMA DE ARQUIVOS 9. Pontos Básicos com Relação a Arquivos Os S. 9.Sistemas Operacionais .2.O. que permitem agir sobre o mesmo (criar. são os seguintes: • O que é um arquivo? • Como se dão nomes aos arquivos? • Como se protegem arquivos contra acessos não autorizados? • Que operações podem ser realizadas sobre um arquivo? Para cada sistema operacional. as respostas à essas perguntas são dadas de forma diferente. o sistema de arquivos representa a parte com que ele tem mais contato.Ricardo Luís de Freitas Notas de Aula .

para com as extensões variam desde alguns que não utilizam a extensão para nada.BAT. Um outro ponto importante com relação a arquivos é sua utilização para obter a independência de dispositivo. os arquivos são considerados como consistindo de uma sequência de blocos.ex.ex.O.O. fornecer acessos aos arquivos independente dos dispositivos utilizados para o armazenamento do arquivo.COM. o arquivo é organizado em blocos. cada um de um dado tamanho (é o caso do CP/M). até sistemas em que o tipo de extensão é extremamente importante para o sistema (p. Em geral. os S. formando-se uma árvore de blocos para cada arquivo (é o padrão ISAM: indexed sequential access method). 9.: CP/M).O. sendo que cada bloco consiste de certo número de regiões de dados e também de ponteiros para outros blocos semelhantes. . Com relação a isso. .O. ele poderia se recusar a rodar o compilador PASCAL em qualquer arquivo que não tivesse extensão . os arquivos são considerados como constituídos de uma sequência de bytes (é o caso do UNIX). • uma hierarquia de diretórios (p. surge a necessidade de se especificar a localização de um arquivo com relação à hierarquia de diretórios. Por exemplo. O modo geralmente utilizado é a especificação de um caminho (path). Algumas possibilidades de organização dos diversos arquivos em diretórios são as seguintes: • um único diretório para todos os arquivos (p. especiais (subdividido em de bloco e de caracter) e pipes. Nestes casos. No segundo caso.: os . caracterizam os arquivos em alguns tipos. que pode ser indicado de duas formas: .EXE. No último caso. um diretório para cada usuário.ex.Ricardo Luís de Freitas Notas de Aula . é a extensão (p. uma para cada arquivo. as atitudes dos S. diretório. procurando os S. Diretórios 9. o UNIX caracteriza os arquivos em: regulares.: MS-DOS e UNIX). algumas pequenas diferenças existem na utilização dos diversos tipos de arquivos.3.1.74 No primeiro caso.PAS).3.ex. servindo a mesma apenas como mnemônico para o usuário. Conceito Os diretórios são organizados como um conjunto de diversas entradas.Sistemas Operacionais . Uma forma de diferenciar arquivos fornecida por alguns S. No terceiro caso. etc do MS-DOS).

caminho relativo: (associado a diretório de trabalho: working directory): indica como se faz para chegar até o arquivo partindo do diretório de trabalho atual. 2.3. Nesse campo temos o número correspondente à aquela entrada do arquivo (0 para a primeira entrada. caminho absoluto: indica todo o caminho até o arquivo a partir da raiz da hierarquia. ii) MS-DOS O MS-DOS apresenta uma estrutura como a apresentada na Figura 24: . 16 espaços são reservados para os números dos blocos em cada entrada no diretório. i) CP/M O CP/M possui um único diretório. com o valor de "extent" ajustado correspondentemente). Estrutura do Diretório Devemos estabelecer agora de que forma as informações sobre os arquivos devem ser organizadas no diretório. do MS-DOS e do UNIX (árvores de diretórios). O contador de blocos (block count) indica quantos desses 16 espaços reservados estão efetivamente sendo utilizados (quando o arquivo ocupa mais de 16 blocos.Ricardo Luís de Freitas Notas de Aula . Para isto veremos três exemplos de diretórios: o do CP/M (diretório único). uma nova entrada deve ser alocada para o mesmo no diretório. 1 para a segunda. O campo "extent" é utilizado para arquivos que ocupam mais de uma entrada no diretório (quando são maiores que o tamanho possível em uma única entrada). e assim sucessivamente).Sistemas Operacionais .75 1.2. 9. que consiste de diversas entradas como a mostrada na Figura 23: Figura 23 O código de usuário associa cada arquivo a um usuário identificado por um número.

repetindo-se esse procedimento até encontrar o fim do arquivo." e ". etc). então. ao invés de no diretório.Ricardo Luís de Freitas Notas de Aula .. busca-se a entrada na FAT correspondente a esse primeiro bloco e encontra-se lá o número do bloco seguinte. Além dos arquivos normais. possibilitando a formação de uma árvore de subdiretórios. com tantos i-nodes quantos necessários. Quando o atributo de um arquivo indica que ele é do tipo diretório. Um dos campos indica o número do primeiro bloco alocado para o arquivo. A raiz tem seu i-node armazenado em uma posição fixa do disco. cada diretório possui também as entradas ". escondido. Para encontrar o bloco seguinte.76 Figura 24 O campo de atributos é utilizado para indicar qual o tipo de arquivo (arquivo normal.Sistemas Operacionais . devido ao fato de que todas as informações sobre um arquivo estão reunidas no i-node desse arquivo.". o mesmo consistirá de entradas como as apresentadas aqui. iii) UNIX O diretório do UNIX é extremamente simples. geradas no momento . podendo inclusive apresentar entradas do tipo diretório. diretório. sistema. Note que a entrada no diretório de uma arquivo apresenta também o tamanho do arquivo. Cada entrada no diretório é como na Figura 25: Figura 25 Os diretórios são arquivos como qualquer outros.

formas de responder às duas primeiras perguntas e rapidamente a formas de responder à segunda." e ". sendo que a primeira apresenta o i-node do próprio diretório e a segunda o i-node do diretório pai desse diretório.Sistemas Operacionais ..Ricardo Luís de Freitas Notas de Aula . Surge um problema nesta solução quando há necessidade de um arquivo crescer e não existe espaço consecutivo após o mesmo. Por outro lado. é a alocação para cada arquivo de blocos de tamanho fixo e não necessariamente contíguos no disco. . Os tamanhos comumente encontrados de blocos são de 512 bytes.77 da criação do diretório. para cada arquivo. o que é lento e muitas vezes impossível (em discos cheios). Uma possibilidade seria.4. 1k bytes.1. Para a raiz. sequencialmente (i. surge a seguinte questão: Qual o tamanho do bloco? A escolha de blocos de tamanho grande implica em que mesmo arquivos pequenos irão ocupar muito espaço no disco. todos os bytes do arquivo serão consecutivos no disco). alocar espaço no disco correspondente ao número de bytes necessários. devemos estabelecer o seguinte: • Como será feito o gerenciamento do espaço em disco? • Como serão armazenados os arquivos? • Como fazer tudo funcionar com eficiência e segurança? Veremos agora. 2k bytes e 4k bytes. A solução para este problema." são iguais. com alguns detalhes. 9. a escolha de blocos pequenos implica em um maior número de leituras em disco (para um dado tamanho de arquivo).e.. seria necessário deslocar o arquivo para outra parte do disco. Gerenciamento do Espaço em Disco A forma de gerenciamento do espaço em disco é a principal consideração que deve ser feita pelo projetista de sistemas de arquivos.4. então. Neste caso. Outro problema com este tipo de solução é a fragmentação do espaço em disco (da mesma forma que ocorria fragmentação da memória). Projeto de Sistema de Arquivos No projeto de sistemas de arquivos. Escolhida esta opção. ". 9. o que implica em aumento das influências do tempo de busca de trilhas e espera de setor.

de 1 kbytes). muitas vezes não existem estes “buracos” contíguos no disco.4. o que implica numa grande sobrecarga de leituras em disco quando pretendemos realizar acesso aleatório às informações do arquivo. seria necessário ficar sempre reorganizando os espaços alocados no disco para criar os espaços necessários. o que torna o processo lento.Ricardo Luís de Freitas Notas de Aula . .ex. como no caso de gerenciamento de memória. Entretanto. são basicamente dois: • lista encadeada. num dados bloco (p. esta solução apresenta o problema de que para se buscar o n-ésimo bloco de um arquivo. neste caso.Sistemas Operacionais . Ou seja. é difícil de encontrar blocos vazios.2. basta carregar a lista de blocos vazios ao invés de ter que carregar as diversas partes do bit map uma por vez até achar o espaço necessário). A segunda opção é geralmente a melhor. A primeira forma que poderia ser pensada seria a alocação de blocos de forma contígua no disco. para armazenar um determinado arquivo seria percorrido o disco buscando por um espaço de blocos contíguos que permitissem seu armazenamento.78 Resta-nos uma consideração importante: de que forma cuidar de quais blocos do disco estão livres e quais estão ocupados? Os métodos. se queremos encontrar espaço para um novo arquivo. de forma que. Armazenamento de Arquivos Vejamos agora de que forma podemos fazer para saber quais os blocos que estão alocados a um dado arquivo. 9.. Neste caso. • bit map (mapa de bits). A primeira opção só é preferível quando o bit map não pode ser mantido todo na memória e o disco está bastante ocupado (isto pois. enquanto que na lista encadeada. pois como o disco está cheio. Um método possível é fazer uma lista encadeada utilizando os próprios blocos. devemos ler todos os n-1 blocos anteriores. principalmente quando todo o bit map pode ser mantido simultaneamente na memória. A grande vantagem desta estratégia é evitar a fragmentação que ocorre no uso de alocação contígua. Porém. alguns de seus bytes são utilizados para indicar qual o próximo bloco do arquivo. além do próprio bloco. com o método de bit map. o que inviabiliza esta solução. devemos ficar carregando as diversas partes do bit map do disco para a memória.

o número de setores no disco é limitado. Para melhor visualizar observe a Figura 26: Figura 26 Os problemas com esta solução são os seguintes: Como a FAT ocupa locais fixos no disco. devemos alterar completamente a FAT.Sistemas Operacionais . sendo que se quisermos utilizar discos maiores. Outra forma existente é a tabela de índices encontrada no sistema UNIX. Podemos resumir da seguinte forma: . eliminando simultaneamente os dois inconvenientes apontados. No MS-DOS. que pode ser carregada completamente na memória. o tamanho desta é limitado pelo número de setores alocados para a mesma. que poderia ser chamado de lista encadeada usando tabela. através de uma estrutura chamada FAT (file allocation table). que apresenta grande facilidade de expansão de tamanho dos arquivos. a FAT funciona da seguinte forma: a entrada no diretório correspondente a um arquivo indica o primeiro setor ocupado por um arquivo.Ricardo Luís de Freitas Notas de Aula . Como cada entrada na FAT corresponde a um número fixo de bits.79 Um modo de utilizar a lista encadeada sem os inconvenientes apresentados acima é o utilizado no MS-DOS. Esta solução consiste em formar a lista dos blocos de um arquivo em uma estrutura especial (tabela). a entrada na FAT correspondente a um setor indica o próximo setor alocado ao mesmo arquivo.

.e. se o arquivo ocupa mais do que 10 blocos. é reservado um novo bloco que irá apontar para blocos que contêm endereços dos blocos dos arquivos. • mesmo para os maiores arquivos. associa-se uma tabela.Ricardo Luís de Freitas Notas de Aula . no máximo são necessários três acessos a disco para se conseguir o endereço de qualquer de seus blocos.80 as listas (tabelas) de blocos de cada arquivo são mantidas em locais diferentes (i. O endereço desse bloco será armazenado em um número de bloco de endereçamento indireto.Sistemas Operacionais . se ainda forem necessários mais blocos do que couberam nas estruturas anteriores. o i-node de um arquivo possui informações de proteção. entre outras. Acompanhe o processo descrito acima pela Figura 27: Figura 27 As vantagens desse método são as seguintes: • os blocos indiretos são utilizados apenas quando necessário. chamada i-node (nó-índice). O número desse novo bloco é armazenado num bloco de endereçamento duplamente indireto. se ainda não for suficiente isso. se o arquivo ocupa até 10 blocos. contagem. os números desses blocos são colocados nesse espaço reservado no i-node. que será utilizado para armazenar tantos números de blocos desse arquivo quantos couberem no bloco. não existe um local fixo onde são guardadas as informações sobre os blocos de todos os arquivos). a cada arquivo. blocos. é alocado um bloco de endereçamento triplamente indireto. no i-node existem 10 números de blocos diretos. um novo bloco é alocado ao arquivo..

81 9. mas introduz um novo problema: se existirem quotas na utilização de discos (i. . no novo diretório.3. que pode ser ilustrado da seguinte forma: suponha que o usuário C seja o dono de um arquivo e. Em sistemas cujo diretório possui o endereço dos blocos do arquivo (como é o caso do CP/M). uma entrada com o nome do mesmo e o número do seu i-node.4. Este método é denominado "ligação simbólica". apenas um "path para este.ex.. mas apenas um ponteiro para uma estrutura que lista esses blocos. A primeira das soluções apresenta um problema. sem necessitar se preocupar em recopiar o arquivo).Sistemas Operacionais . quando C remover o arquivo. Veja que aqui. removendo apenas a entrada correspondente no diretório de C. basta fazer no novo diretório onde deve aparecer um arquivo. Isto evita que B fique com um arquivo sem sentido. o diretório de B terá uma entrada que não fará mais sentido.Ricardo Luís de Freitas Notas de Aula . pode perceber que outros usuários ainda querem utilizá-lo e não apaga o i-node do arquivo.O. uma entrada de um tipo especial. digamos tipo "link". essa alteração não aparecerá ao outro usuário. limites máximos de utilização de disco por cada usuário). então. que contém. o S. num projeto em grupo). outro usuário tenha automaticamente acesso a essas alterações. é conveniente que esses arquivos apareçam em diretórios diferentes (os dos diversos usuários) mas mantendo uma única cópia do mesmo em disco (de forma a garantir que quando um usuário faz alterações a esse arquivo. para estabelecer a ligação. Arquivos Compartilhados Quando diferentes usuários se referem a arquivos compartilhados (p. mantendo no i-node do arquivo um campo que indica quantos links foram realizados para aquele arquivo. O problema aqui é que quando um dos usuários faz uma alteração no arquivo que implique em reorganização dos blocos ocupados por ele. Neste caso. ao invés das informações usuais sobre o arquivo.e. o usuário B faz um link para o mesmo. Se permitimos que C apague o arquivo. teremos o fato de que C continuará pagando pela existência de um arquivo que já não lhe interessa. • podemos criar.. Isto pode ser solucionado (como foi no UNIX). Este é o caso dos i-node do UNIX. Existem duas possíveis soluções para esse problema: • não listar os números dos blocos no diretório. poderíamos realizar a ligação pela cópia dos números de blocos dos diretórios de um usuário para o de outro.

fazendo com que. ele seja copiado diversas vezes. que só permite ligações dentro do próprio disco). No entanto ela apresenta sobrecarga no tempo de acesso. para sistemas automáticos de cópia (em geral em backups). interligadas por uma rede (ao contrário do método do i-node.Sistemas Operacionais . pois. .Ricardo Luís de Freitas Notas de Aula . devido à necessidade de percorrer "paths" extras até se chegar no arquivo e de ocupar um i-node a mais. Uma outra vantagem desta solução é a de que permite realizar links com outras máquinas. quando o dono remove o arquivo o mesmo é eliminado e a partir desse ponto todos os outros usuários que tentarem acessar o arquivo por ligação simbólica terão a mensagem de "arquivo inexistente". As duas soluções apresentadas têm em comum uma desvantagem: o fato de que o arquivo aparece com diferentes paths no sistema.82 A segunda solução (ligação simbólica) não tem esses problemas.

Sign up to vote on this title
UsefulNot useful