sistemas operacionais pronatec- prof. manoel

PRONATEC/SEDUC-PI SISTEMAS OPERACIONAIS

1

SISTEMAS

OPERACIONAIS


2

PROGRAMA DE DISCIPLINA

ESCOLA OFERTANTE:

CURSO: TÉCNICO EM INFORMÁTICA

SEMESTRE: ANO: 2013

DISCIPLINA: SISTEMAS OPERACIONAIS

MÓDULO: I

C/H ANUAL: 85h/a

C/H SEMANAL: 5h/a

I – Objetivos

A disciplina Sistemas Operacionais tem por objetivo fornecer ao aluno uma visão detalhada dos principais mecanismos envolvidos na concepção de um sistema operacional moderno. Compreendendo sua importância, conhecendo as metodologias utilizadas para controle e aproveitamento dos recursos do computador; conhecendo os principais componentes de um sistema operacional e dos mecanismos e técnicas usadas para desenvolvê-los.

Apresentar aos estudantes os conceitos e princípios básicos dos sistemas operacionais de computadores digitais, observando os sistemas operacionais como gerente dos recursos computacional e como elemento de interface entre programas de aplicação e os recursos da máquina.

II – Conteúdo VISÃO GERAL Introdução 2. Definição de Sistemas Operacionais 3. História dos Sistemas Operacionais 4 Classificação dos Sistemas Operacionais 5 Funcionalidades 6 Estruturas do Sistema Operaciona 7 Chamadas de Sistemas 8 Arquiteturas de Sistemas Operacionais GERENCIAMENTO DE PROCESSOS 1 Introdução ao modelo de processos 2 Estados de um Processo 3 Threads 4 Comunicação Interprocessos. 5 Seções Críticas 6 Deadlocks : Impasse entre Processos


3

7 Gerenciador de processos 8 Escalonamento de processos 9 Escalonamentos Não-Preemptivos 10 Escalonamentos Preemptivos GERENCIAMENTO DE ENTRADA E SAÍDA 1 Introdução 2. Princípios de Hardware de E/S Controladoras de Dispositivos 3 Princípios de Software de E/S GERENCIAMENTO DE MEMÓRIA 1 Introdução 2. Gerenciamento Básico de Memória 3. Gerencia de Memória para Multiprogramação 3 Memória Virtual GERENCIA DE ARQUIVOS 1. Introdução aos Sistemas de Arquivos 2 Tipos de Arquivos 3 Atributos 3 Operações 4 Implementação de Arquivos 5 Diretórios

III - Metodologia - Aulas expositivas e dialogadas, - Aulas práticas com Simulação e Demonstração utilizando o Simulador de Sistema Operacional SOsim 2.0, - Apresentação de seminários e Discussão dirigida, -Atividades e exercícios propostos no material. IV - Avaliação

- A avaliação dos discentes será realizada perante os resultados diagnósticos aplicados ao longo do módulo e dividida conforme as formas formativas e somativas de verificação de aprendizagem.

Os instrumentos de avaliação formal (provas e/ou trabalhos) compõem o valor máximo de 5 (cinco) pontos e terão um complemento de 5 (cinco) pontos considerando aspectos qualitativos como: participação nas discussões sobre tópicos da disciplina, a resolução de exercícios, a execução de trabalhos de pesquisa, assiduidade, realização de trabalhos práticos. . V – Bibliografia TANEMBAUM,A.S. Sistemas Operacionais Modernos .2ª edição . São Paulo,Ed.Prentice Hall,2003 LEÃO,Erico Meneses : Sistemas Operacionais .Universidade Aberta do Brasil OLSEN .Diogo Roberto .Sistemas Operacionais/ LAUREANO.Marcos Aurélio.-Curitiba: Editora do Livro Técnico .2010 Maziero, Carlos Alberto. Sistemas Operacionais Conceitos Básicos .2011 Machado, Francis B. Arquitetura de Sistemas Operacionais.Ed. LTC Abraham Silberschatz .Sistemas Operacionais: Conceitos e Aplicações.Ed. Campus


4

Tanenbaum , A.S. Sistemas Operacionais Modernos .Ed. Campus A evolução dos sistemas operacionais-Traduzido e adaptado por Raimundo G Nóbrega Filho o texto Operating Systems: Design And Implementation,Andrew S. Tanenbaum - Editora Prentice Hall http://www.inf.ufes.br/~zegonc/material/Sistemas%20Operacionais/Introducao.pdf http://www.afms.com.br/sistemas_operacionais.html www.docstoc.com/.../Lista-de-Exercícios-respondida---Grupo-Educacion Simulador de Ensino para Sistemas Operacionais http://www.training.com.br/sosim/- http://www.ppgia.pucpr.br/_maziero http://www.inf.unioeste.br/~marcio/SO/Aula9SistemadeArquivos.pdf http://docente.lages.ifsc.edu.br/juliano.goncalves/MaterialDidatico/Sistemas%20Operacionais/Exerc%C3%ADcios%20Revis%C3%A3o%20ProvaI.pdf http://dainf.ct.utfpr.edu.br/~maziero/lib/exe/fetch.php/so:filesystem.pdf http://www.cafw.ufsm.br/~roberto/?page_id=26 http://www.metropoledigital.ufrn.br/aulas/disciplinas/sist_operacional


5

SUMÁRIO VISÃO GERAL ..................................................................................................................................... 6

1 Introdução ....................................................................................................................... 6 2. Definição de Sistemas Operacionais ............................................................................... 7 3. História dos Sistemas Operacionais ................................................................................ 8 4 Classificação dos Sistemas Operacionais ....................................................................... 12 5 Funcionalidades ............................................................................................................. 17 6 Estruturas do Sistema Operacional ................................................................................. 18 7 Chamadas de Sistemas ................................................................................................... 19 8 Arquiteturas de Sistemas Operacionais .......................................................................... 19

GERENCIAMENTO DE PROCESSOS .....................................................................................................24 1 Introdução ao modelo de processos ................................................................................ 24 2 Estados de um Processo ................................................................................................. 26 3 Threads ......................................................................................................................... 27 4 Comunicação Interprocessos. ......................................................................................... 28 5 Seções Críticas .............................................................................................................. 30 6 Deadlocks : Impasse entre Processos ............................................................................. 30 Gerenciador de Processos ................................................................................................. 34 8 Escalonamento de Processos .......................................................................................... 34 9 Escalonamentos Não-Preemptivos ................................................................................. 35 10 Escalonamentos Preemptivos ....................................................................................... 36

II ATIVIDADE PRÁTICA .......................................................................................................................41 GERENCIAMENTO DE ENTRADA E SAÍDA ...........................................................................................43

1 Introdução ..................................................................................................................... 43 2. Princípios de Hardware de E/S...................................................................................... 43 Controladoras de Dispositivos .......................................................................................... 44 3 Princípios de Software de E/S ........................................................................................ 45

GERENCIAMENTO DE MEMÓRIA ...............................................................................................49 1 Introdução ..................................................................................................................... 49 2. Gerenciamento Básico de Memória .............................................................................. 50 3. Gerencia de Memória para Multiprogramação .............................................................. 51 Memória Virtual ............................................................................................................... 55

GERENCIA DE ARQUIVOS...................................................................................................................59 1. Introdução aos Sistemas de Arquivos ............................................................................ 59 2 Tipos de Arquivos ......................................................................................................... 61 3 Atributos ....................................................................................................................... 61 3 Operações ...................................................................................................................... 62 4 Implementação de Arquivos .......................................................................................... 63 5 Diretórios ...................................................................................................................... 67

REFERENCIAS BIBLIOGRÁFICAS ..........................................................................................................70


6

VISÃO GERAL

1 Introdução

O Sistema Operacional é um software que habilita as aplicações e interagem

com o hardware de um computador, suas aplicações gerenciam todos os recursos do sistema (memória,processador,discos,impressoras e outros dispositivos ) de forma organizada e otimizada.(Livro Técnico ,Sistemas Operacionais . pág.09)

Os sistemas Operacionais podem ser encontrados em dispositivos que vão de telefones celulares e automóveis e de computadores pessoais a computadores de grande porte

O software, de um modo geral, é utilizado para solucionar os problemas do usuário, enquanto que o hardware do computador é o dispositivo físico capaz de executar esses softwares. Esses softwares, responsáveis por realizar as atividades dos usuários, comumente são chamados de programas aplicativos.

Como pode ser visto na Figura , levando em consideração que temos uma

camada intermediária, o SO entre os programas aplicativos e o hardware em si, o usuário não necessita conhecer toda a complexidade de implementação do hardware do Sistema Computacional para, assim, poder utilizá-lo.

O Sistema Operacional, de fato, opera como uma interface entre o usuário e o dispositivo físico em si, no qual o usuário, quando necessita acessá-lo, faz essa solicitação diretamente ao Sistema Operacional.


7

O sistema operacional é uma estrutura de software ampla, muitas vezes complexa que incorpora aspectos de baixo nível (como drives de dispositivos e gerência de memória física) e de alto nível (como programas utilitários e a própria interface gráfica).

Podemos concluir que os objetivos básicos de um sistema operacional podem ser sintetizados em duas palavras-chave: “abstração” e “gerência”, cujos principais aspectos são detalhados a seguir.

2. Definição de Sistemas Operacionais Segundo Tanenbaum, podemos definir um Sistema Operacional levando em

consideração dois pontos de vistas: O Sistema Operacional como uma Máquina estendida; O Sistema Operacional como gerenciador de recursos. O Sistema Operacional como uma Máquina estendida

Acessar os recursos de hardware de um sistema de computação pode ser uma tarefa complexa, devido às características específicas de cada dispositivo físico e a complexidade de suas interfaces.

O usuário (que pode ser um programador ou um usuário final), comumente, não está interessado em saber os detalhes funcionais dos dispositivos. Como exemplo, o usuário não quer saber o que é preciso, em nível de hardware, para que seja lida uma determinada informação um disco rígido (tarefa bem complexa, que exige o conhecimento de registradores, motores, cilindros e outros dispositivos físicos). O usuário deseja ter uma interface mais palpável e mais simples de lidar. No caso dos discos, por exemplo, uma abstração típica seria que o disco contenha um conjunto de nomes de arquivos. A partir desses nomes, é possível realizar as operações básicas (abrir, ler, escrever e fechar), sem se importar qual a velocidade e estado atual do motor, por exemplo.

Assim, o Sistema Operacional aparece como o programa que esconde do usuário a complexidade do hardware e apresenta uma visão fácil e simples para as operações sobre os dispositivos. Essa visão é equivalente a uma máquina estendida ou máquina virtual, mais fácil de lidar.

O Sistema Operacional como gerenciador de recursos

Por outro lado, o Sistema Computacional é composto de uma série de recursos, no qual podemos enumerar: processadores, memórias, discos, mouses, teclados, impressoras, placas de rede e uma infinidade de dispositivos em geral. Dessa forma, o Sistema Operacional aparece como sendo o responsável por organizar e alocar de forma ordenada todos esses recursos disponíveis.

Essa tarefa, em uma primeira vista, pode parecer simples. Porém, quando se tem vários programas disputando os recursos,que são limitados, é necessário utilizar técnicas de alocação dos dispositivos, a fim de se evitar inconsistências e, até mesmo, situações que resultem numa parada do sistema de uma forma geral.Então cabe ao


8

sistema operacional definir políticas para gerenciar o uso dos recursos de hardware pelos aplicativos, e resolver eventuais disputas e conflitos.

Assim, um sistema operacional visa abstrair o acesso e gerenciar os recursos de hardware, provendo aos aplicativos um ambiente de execução abstrato, no qual o acesso aos recursos se faz através de interfaces simples, independentes das características e detalhes de baixo nível, e no qual os conflitos no uso do hardware são minimizados.

Objetivos de um Sistema Operacional Tornar a utilização do computador eficiente e conveniente, a fim de ter

um ganho de produtividade e, dessa forma, utilizar o Sistema Computacional para agilizar as atividades do dia-a-dia;

Garantir a integridade e segurança dos dados armazenados e processados pelos programas e dos recursos físicos disponíveis.

3. História dos Sistemas Operacionais Os Sistemas Operacionais, ao longo dos anos, vêm se desenvolvendo e

ganhando novas características, sendo necessário partimos ao seu histórico para que possamos compreender como se deu essa evolução. Partindo do pressuposto que a história dos Sistemas Operacionais sempre esteve intimamente vinculado à história das arquiteturas de computadores, iremos fazer um breve resumo dos principais eventos relacionados à evolução dos Sistemas Operacionais.( ERICO MENESES LEÃO,SISTEMAS OPERACIONAIS )

Início

Máquina Analítica de Babage

O primeiro computador digital, de fato, foi projetado por volta da década de

1820 pelo matemático Charles Babbage e intitulada como motor analítico. Esta máquina, por se tratar de um equipamento puramente mecânico e a tecnologia da época não permitir a construção de engrenagens de alta precisão o qual Babbage necessitava, nunca funcionou adequadamente. Assim, o motor analítico de Babbage não possuía Sistema Operacional.


9

Primeira Geração (1945-1955)

Impulsionado pela Segunda Guerra Mundial, surgiram os grandes

computadores digitais, formados por milhares de válvulas e que ocupavam salas inteiras. Estes computadores, desenvolvidos por Howard Aiken e John Von Neumann, eram extremamente lentos.

Para trabalhar nesta máquina era necessário o conhecimento do funcionamento do seu hardware, onde a programação era feita através de linguagem de máquina, freqüentemente ligando painéis de conectores com fios para o controle das funções básicas.

Nessa época, ainda não existia o conceito de Sistema Operacional. Por esse fato, esta geração ficou conhecida como a geração das válvulas e painéis de conectores.

Segunda Geração (1956-1965) Em 1952, a Bell Laboratories inventou o Transístor que passou a ser um

componente básico na construção de computadores e que lhes garantia algumas vantagens como menor aquecimento, maior poder de cálculo, mais fiável e rápido, menor consumo de energia para além de não precisar de tempo para aquecer. Os cálculos passaram a ser medidos de segundos para microssegundos. O primeiro computador a transístores é o TRADIC, da Bell Laboratories e apareceu em 1955, possuía 800 transístores cada um em seu próprio recipiente. Outro modelo dessa época era o IBM 1401, com uma capacidade memória base de 4.096 bytes operando em ciclos de memória de 12 microssegundos. O tamanho dos computadores era ainda bastante grande e a instalação de um destes IBM 1401 ocupava uma sala. Em 1958 apareceu o IBM TX-0, tinha um monitor de vídeo de alta qualidade, alem de ser rápido e relativamente pequeno. O PDP-1 virou mania no MIT pois os alunos utilizavam o computador para jogar Rato-no-Labirinto e Spacewar com o auxílio de uma caneta óptica e um joystick. O elevado preço desta máquina restringia a sua utilização a aplicações estratégicas do governo, grandes empresas e universidades.

ENIAC Mark I


10

Primeiro transistor

Terceira Geração (1966-1970)

Circuitos integrados

A terceira geração é conhecida com geração dos circuitos integrados (CI’s) e da multiprogramação, diminuindo consideravelmente o preço do computador, possibilitando assim sua aquisição por empresas. Esta época se caracteriza pelo grande aumento do poder de processamento e, também, a diminuição dos equipamentos.

Nesta época, a IBM lançou o System/360, que era uma série de computadores pequena, poderosa e, sobre tudo, compatível. O 360 foi projetado para manipular cálculos tanto científicos como comerciais, ou seja, em uma única família de máquinas era possível satisfazer as necessidades de praticamente todos os clientes.

Porém, para atender todas as aplicações e periféricos disponíveis por essa família de máquinas, a IBM teve que desenvolver um Sistema Operacional (OS/360)


11

extremamente grande e complexo, posto que as aplicações disponíveis, comumente, eram contraditórias. Este Sistema Operacional consistia de milhões de linhas de linguagem assembler escrita por milhares de programadores e muitos bugs, que exigiam versões e mais versões a fim de corrigi-los.

Apesar de todos os problemas, o OS/360 e os Sistemas Operacionais semelhantes atenderam a maioria dos seus clientes razoavelmente bem. Além disso, eles lançaram várias técnicas utilizadas até hoje, como exemplo a multiprogramação. A multiprogramação consistia em dividir a memória em várias partições a fim de permitir que várias tarefas sejam carregadas em cada partição. Enquanto uma tarefa esperava alguma operação de Entrada ou Saída, outra tarefa poderia usar o processador (CPU).

Outro recurso disponível nos Sistemas Operacionais da terceira geração era a capacidade de ler Jobs (tarefas) de cartões para o disco. Assim, sempre que um job acabava sua execução, o Sistema Operacional podia carregar um novo job do disco para a partição e executá-lo. Esta técnica é conhecida como spooling.

Entretanto, os Sistemas Operacionais ainda eram basicamente sistemas em lote e que não exigiam comunicação com o usuário. Assim, muitos programadores sentiam falta das máquinas de primeira geração, que eram disponibilizadas por completa para eles e, assim, podiam depurar seus programas. Assim, a multiprogramação evoluiu preocupada em oferecer aos usuários tempos de respostas razoáveis e uma interface cada vez mais amigável. Para tal, cada programa na memória utilizaria o processador em pequenos intervalos de tempo. Esse sistema de divisão de tempo ficou conhecido como compartilhamento de Tempo (time-sharing).

A terceira geração também é marcada pelo surgimento do Sistema Operacional UNIX, escrito em linguagem de programação de alto nível, que se tornou popular no mundo acadêmico, entre órgãos do governo e entre muitas empresas.

Quarta Geração (1980-1990)

Computador Pessoal


12

De fato, a década de 1980 é caracterizada pelo surgimento dos computadores pessoais. Os computadores pessoais se tornaram possíveis devido ao advento de novas tecnologias, impulsionados pelo avanço da indústria de hardware, com a introdução de novos circuitos integrados. Os computadores pessoais permitiram que as pessoas pudessem ter seu próprio computador.

Os equipamentos desta geração se tornaram cada vez menores, mais velozes e, principalmente, mais baratos. Esses novos equipamentos, com alta disponibilidade de poder de computação, especialmente a computação altamente interativa, normalmente com excelentes gráficos, levaram ao crescimento de uma importante indústria, a indústria de softwares para computadores pessoais.

Dois Sistemas Operacionais inicialmente dominaram o cenário dos computadores pessoais: o MS-DOS (Microsoft) e o UNIX. O MS-DOS foi amplamente utilizado no IBM PC e em computadores com a tecnologia Intel. Esse Sistema Operacional evolui para o sistema conhecido como Windows.

Outra evolução que surgiu nesta geração foi o crescimento de redes de computadores pessoais executando Sistemas Operacionais de rede e Sistemas Operacionais distribuídos. Em um Sistema Operacional de rede, os usuários podem conectar-se a máquinas remotas e copiar arquivos de uma máquina para a outra.

Quinta Geração (Dias atuais) Em 1993, Surge o primeiro processador Pentium dotado de memórias de 108

pinos, ou DIMM. Depois vem o Pentium II, o Pentium III e mais recentemente o Pentium 4 (sem contar os modelos similares da concorrente AMD). Nesse meio tempo iam surgindo o slot AGP de 64 bits, memórias com mais pinos e maior velocidade, HD´s cada vez mais rápidos e com maior capacidade, etc. Basicamente são os computadores modernos. Ampliou-se drasticamente a capacidade de processamento de dados, armazenamento e taxas de transferência. Também é nessa época que os processos de miniaturização são iniciados, diminuindo o tamanho e aumentando a velocidade dos agora "populares" PC´s. O conceito de processamento está a ir para os processadores paralelos, ou seja, a execução de muitas operações em simultâneo. Na realidade, as maiores novidades desta época são os novos processadores, cada vez mais velozes.

A informática evolui cada vez mais rapidamente e as velocidades de

processamento dobram em períodos cada vez mais curtos. Para se ter uma noção disso, basta observar que entre os modelos de computador mais antigos, os espaçamentos entre uma novidade e outra eram de dezenas de anos, sendo que hoje não chega a durar um mês. Isso leva-nos a concluir que o avanço científico e do poder de cálculo avança de maneira que não se encontra paralelo da história humana, fazendo baixar os custos e tornando acessíveis os computadores às pessoas de baixa renda.

4 Classificação dos Sistemas Operacionais Os Sistemas Operacionais evoluíram juntamente com a evolução do hardware

e das aplicações por ele suportada. Muitos termos inicialmente introduzidos para definir conceitos e técnicas foram substituídos por outros.


13

Abordaremos neste tópico, os diversos tipos de Sistemas Operacionais classificados quanto ao seu tipo de processamento, apontando suas principais características.

Classificação dos Sistemas Operacionais

Sistemas Monoprogramáveis ou Monotarefas Os Sistemas monoprogramáveis ou monotarefas são caracterizados por alocar

o Sistema Computacional disponível exclusivamente para um único programa, ou seja, um programa tem todos os dispositivos, incluindo periféricos, memória e processador disponível durante todo o tempo em que ele está ativo, mesmo se não estiver usando.

Os primeiros sistemas operacionais eram tipicamente voltados para a execução de um único programa. Os sistemas monoprogramáveis estão tipicamente relacionados ao surgimento dos primeiros computadores na década de 1960 e se caracterizam por permitir que todos os recursos do sistema fiquem exclusivamente dedicados a uma única tarefa, como ilustrado na Figura abaixo.

Sistemas Mono Programáveis


14

Era muito clara a desvantagem deste tipo de sistema, no que diz respeito à

limitação de tarefas (uma de cada vez), o que provocava um grande desperdício de recursos de hardware.

Sistemas Multiprogramáveis ou Multitarefa Constituindo-se uma evolução dos sistemas monoprogramáveis, neste tipo de

sistema os recursos computacionais são compartilhados entre os diversos usuários e aplicações: enquanto um programa espera por um evento, outros programas podem estar processando neste mesmo intervalo de tempo. Neste caso, podemos observar o compartilhamento da memória e do processador. O sistema operacional se incumbe de gerenciar o acesso concorrente aos seus diversos recursos, como processador, memória e periféricos, de forma ordenada e protegida, entre os diversos programas.

As vantagens do uso deste tipo de sistema são a redução do tempo de resposta das aplicações, além dos custos reduzidos devido ao compartilhamento dos recursos do sistema entre as diferentes aplicações. Apesar de mais eficientes que os monoprogramáveis, os sistemas multiprogramáveis são de implementação muito mais complexa.

Sistemas Multiprogramáveis

Os sistemas multiprogramáveis podem ser classificados pelo número de usuários que interagem com o sistema e pela forma com que suas aplicações são gerenciadas.

Quanto ao número de usuários que interagem com o Sistema, podem ser

classificados a seguir: Sistemas monousuários: Apenas um usuário interage com o sistema,

podendo realizar várias atividades ao mesmo tempo, como edição de texto, impressão e acesso a Internet, por exemplo.

Sistemas multiusuários: Sistema Operacional que possibilita vários usuários simultâneos. Esse sistema deve suportar a identificação de cada recurso, tais como arquivos, processos, ou conexões de redes e impor regras de controles de acesso


15

para impedir o uso desses recursos por usuários não identificados. Os principais sistemas operacionais como Linux, Windows são considerados multiusuários.

De acordo com a forma com que suas aplicações são gerenciadas, podem ser

divididos em: sistemas batch, de tempo compartilhado e de tempo real, de acordo com a figura abaixo.

. Sistemas Batch : Neste tipo de sistemas todos os programas são

colocados em uma fila para execução do processador .Este recebe um programa após o outro (em seqüência). Atualmente o termo batch é utilizado para definir um conjunto de comandos que rodam sem interferência do usuário.

Estes sistemas, se bem projetados, podem ser bastante eficientes devido à melhor utilização do processador, mas podem oferecer tempos de resposta bastante longos. Atualmente, os sistemas operacionais simulam este tipo de processamento, não havendo sistemas dedicados a este tipo de execução.

Sistemas de Tempo Compartilhado: Também chamados sistemas de

time-sharing, permitem que diversos programas sejam executados a partir da divisão de tempo do processador em pequenos intervalos, denominados fatia de tempo (ou time-slice). Caso a fatia de tempo não seja suficiente para a conclusão do programa, este é interrompido pelo sistema operacional e substituído no processador por outro, enquanto aguarda nova fatia de tempo. Neste tipo de processamento, cada usuário tem a impressão de que a máquina está dedicada ao seu programa, como se ele fosse o único usuário a se utilizar do sistema.

Geralmente permitem interação do usuário com a aplicação através de terminais compostos por monitor, teclado e mouse. Estes sistemas possuem uma linguagem de controle que permite ao usuário interagir com o sistema operacional através de comandos. Assim, é possível verificar arquivos armazenados em disco ou cancelar execução de programas. Normalmente, o sistema responde em apenas alguns segundos à maioria destes comandos, o que se levou a chamá-los também de sistemas on-line.

A maioria das aplicações comerciais atualmente é processada em ambiente de tempo compartilhado, que oferece tempos baixos de respostas a seus usuários e menores custos, em função do alto grau de compartilhamento dos diversos recursos do sistema.

Sistemas Multiprogramáveis/

Multitarefa

Sistemas BATCH ou

Lote

Sistemas de Tempo Compartilhado

Sistemas de Tempo Real


16

Sistemas de Tempo Real: Este tipo de sistema é implementado de forma bastante semelhante ao de tempo compartilhado. O que caracteriza a diferença entre eles é o tempo exigido no processamento das aplicações.

Enquanto nos sistemas de tempo compartilhado o tempo de processamento pode variar sem comprometer as aplicações em execução, nos sistemas de tempo real os tempos de execução devem estar dentro de limites rígidos, que devem ser obedecidos, caso contrário poderão ocorrer problemas irreparáveis.

No sistema de tempo real não existe a idéia de fatia de tempo como nos sistemas de tempo compartilhado. Um programa ocupa o processador o tempo que for necessário ou até que apareça um outro com um nível de prioridade maior. Esta prioridade de execução é definida pela própria aplicação e não pelo sistema operacional, como nos sistemas de tempo compartilhado.

Estes sistemas são utilizados em aplicações de controle de processos, como monitoramento de refinarias de petróleo, controle de tráfego aéreo, de usinas, ou em qualquer aplicação onde o tempo de processamento é fator fundamental.

Sistemas Multiprocessadores Os sistemas com múltiplos processadores caracterizam-se por possuir duas ou

mais CPUs interligadas e trabalhando em conjunto. Esta característica traz com principal vantagem permitir que vários programas sejam executados ao mesmo tempo ou que um mesmo programa seja subdividido em várias partes para serem executadas simultaneamente em mais de um processador, de fato. Os conceitos aplicados ao projeto de sistemas com múltiplos processadores incorporam os mesmos princípios básicos e benefícios apresentados na multiprogramação, além de outras características e vantagens específicas como escalabilidade, disponibilidade e balanceamento de carga.

Escalabilidade: É a capacidade de ampliar o poder computacional do sistema apenas adicionando novos processadores.

Disponibilidade: É a capacidade de manter o sistema em operação mesmo em casos de falhas.

Balanceamento de carga: É a possibilidade de distribuir o processamento entre os diversos processadores da configuração a partir da carga de trabalho de cada processador, melhorando, assim, o desempenho do sistema como um todo.

Esta técnica permitiu a criação de sistemas computacionais voltados para processamento científico, prospecção de petróleo, simulações, processamento de imagens e CAD.

Um fator chave no desenvolvimento dos sistemas multiprocessador é a forma de comunicação entre as CPUs e o grau de compartilhamento da memória e dos dispositivos de E/S. Em função destes fatores, podemos classificar os sistemas multiprocessador de acordo com a figura a seguir:


17

Na figura podemos perceber a divisão dos sistemas multiprocessador em duas

categorias iniciais: sistemas fortemente acoplados e fracamente acoplados. A grande diferença entre estas duas categorias é que nos sistemas fortemente acoplados existe apenas uma memória a ser compartilhada pelos processadores do conjunto, enquanto que nos fracamente acoplados cada sistema tem sua própria memória individual. A taxa de transferência entre processadores e memória em sistemas fortemente acoplados é muito maior que nos fracamente acoplados.

Nos sistemas fortemente acoplados a memória principal e os dispositivos de E/S são gerenciados por um único sistema operacional. Quando todos os processadores na arquitetura são iguais, diz-se que o sistema é simétrico. No entanto, quando os processadores são diferentes, dá-se à arquitetura a denominação assimétrica.

Nos sistemas fracamente acoplados, como os processadores estão em arquiteturas diferentes, somente interligados por cabos de interconexão, cada CPU constitui uma máquina independente, com memória própria, dispositivos de E/S e sistemas operacionais independentes.

Nesta subdivisão, temos como exemplo as redes e os sistemas distribuídos.

Rede: A característica deste sistema é possibilitar o compartilhamento de recursos e disponibilizá-lo para uso.

Distribuídos: Os recursos de cada máquina estão disponíveis globalmente de forma transparente para o usuário. Do ponto de vista das aplicações é como se não houvesse um conjunto de vários computadores, mas apenas um único sistema centralizado. Portanto o usuário desconhece qual o computador que atendeu a sua solicitação. Infelizmente, estes sistemas operacionais não são uma realidade no mercado.

Outros exemplos de sistemas distribuídos são os clusters, são formados por um conjunto de computadores convencionais ,os quais são ligados em rede e comunicam-se por meio do sistemas, trabalhando como se fossem uma única máquina de grande porte .

5 Funcionalidades Para cumprir seus objetivos de abstração e gerência, o sistema operacional

deve atuar em várias frentes. Cada um dos recursos do sistema possui suas particularidades, o que impõe exigências específicas para gerenciar e abstrair os


18

mesmos. Sob esta perspectiva, as principais funcionalidades implementadas por um sistema operacional típico são:

Gerência do Processador: Visa distribuir a capacidade de

processamento (uso de CPU) de forma justa. Deve-se lembrar que algumas aplicações demandam mais processamentos que outras (navegador de internet versus processamento de vídeo , por exemplo )

Gerência de Memória: Tem como objetivo fornecer a cada aplicação

um espaço próprio de memória, independente e isolada das demais aplicações

Gerência de Dispositivos: A função da gerência de dispositivos (também conhecida como gerência de entrada/saída) é implementar a interação com cada dispositivo por meio de drivers e criar modelos abstratos que permitam agrupar vários dispositivos distintos sob a mesma interface de acesso.

Gerência de Arquivos: Esta funcionalidade é construída sobre a

gerência de dispositivos e visa criar arquivos e diretórios, definindo sua interface de acesso e as regras para seu uso. É importante observar que os conceitos abstratos de arquivo e diretório são tão importantes e difundidos que muitos sistemas operacionais os usam para permitir o acesso a recursos que nada tem a ver com armazenamento.

Gerência de Proteção: Políticas de acesso e uso do sistema operacional.

Permite a definição de usuários ,grupos de usuários e registros de recursos por usuários. Interface Gráfica: A interação com usuário se faz necessário, assim a

maioria dos sistemas apresentam telas, nas quais se pode informar ao sistema operacional qual a operação que ele deverá fazer.

Suporte de Rede: A comunicação em rede é, atualmente, essencial ao

mundo dos computadores. Assim, o gerenciamento dessas comunicações se faz necessário e é realizado sob a abstração do sistema operacional sobre os dispositivos físicos, como placas de redes ou modem.

6 Estruturas do Sistema Operacional O sistema operacional é formado por um conjunto de rotinas que oferecem

serviços essenciais aos usuários, às suas aplicações, e também ao próprio sistema. A esse conjunto de rotinas dá-se o nome de núcleo do sistema ou kernel.

É fundamental não se confundir o núcleo do sistema com aplicações, utilitários ou o interpretador de comandos, que acompanham o sistema operacional. As aplicações são utilizadas pelos usuários de maneira transparente, escondendo todos os detalhes da interação com o sistema. Os utilitários, como os compiladores, editores de texto e interpretadores de comandos permitem aos usuários, desenvolvedores e administradores de sistema uma interação amigável com o sistema.

Existe uma grande dificuldade em compreender a estrutura e o funcionamento do sistema operacional, pois ele não é executado como uma aplicação tipicamente seqüencial, com início, meio e fim. Os procedimentos do sistema são executados concorrentemente sem uma ordem específica ou predefinida, com base em eventos


19

dissociados do tempo. Muitos desses eventos estão relacionados ao hardware e a tarefas internas do próprio sistema operacional.

7 Chamadas de Sistemas Uma grande preocupação no projeto de sistemas operacionais se refere à

implementação de mecanismos de proteção ao núcleo do sistema e também o controle de acesso aos serviços oferecidos pelo sistema. Caso uma aplicação que tenha acesso ao núcleo realize alguma operação que altere sua integridade, todo o sistema poderá ficar comprometido e inoperante.

As chamadas de sistemas (system calls) constituem a interface entre um programa do usuário e o Sistema Operacional. Elas podem ser entendidas como uma porta de entrada para acesso ao núcleo do sistema, que contém suas funções. Sempre que o usuário necessitar de algum serviço, é realizada uma chamada a uma de suas rotinas através de uma system call.

Através dos parâmetros fornecidos na system call, a solicitação é processada e uma resposta é enviada à aplicação juntamente com um estado de conclusão indicando o sucesso ou não da operação. Para cada serviço disponível existe um system call associada, e cada sistema operacional possui seu próprio conjunto de chamadas, com nomes, parâmetros e formas de ativação específica. Isto explica por que uma aplicação desenvolvida utilizando serviços de um determinado sistema operacional não pode ser diretamente portada para outro sistema.

8 Arquiteturas de Sistemas Operacionais Em função de sua arquitetura os sistemas operacionais podem ser classificados

em: Núcleo monolítico ou monobloco: É um núcleo que implementa uma

interface de alto nível, para possibilitar chamadas de sistemas específicas para gestão de processos , concorrência e gestão de memória por parte de módulos dedicados ,que são executados com privilégios especiais .Exemplos Windows e Linux.


20

Micronúcleo ou Microkernel : É um termo usado para caracterizar o

sistema cujas funcionalidades saíram do núcleo e foram para servidores ,que se comunicam com um núcleo mínimo possível do “espaço do sistema”(nesse, local o programa tem acesso a todas as instruções e a todo o hardware ) e deixando o máximo de recursos rodando no “espaço do usuário” (nesse espaço, o software sofre algumas restrições , não podendo acessar alguns hardware e não tendo acesso a todas as instruções )

Visão Geral de uma arquitetura micro-núcleo

Máquina Virtual: É uma arquitetura que permite que um sistema

operacional suporte aplicações de outro sistema (Linux executando sobre Windows, por exemplo)m ou mesmo outro sistema operacional completo. Possibilita que sobre um mesmo hardware possam ser executados dois ou mais sistemas operacionais. Exemplo VMware , VirtualBox.


21

EXERCICIOS

1. Como seria utilizar um computador sem um sistema operacional? Quais são suas

duas principais funções?

2. Defina Sistemas Operacionais, procurando abordar os dois pontos de vista segundo Tanembaum.

3. Explique o conceito de máquina virtual. Qual a grande vantagem em utilizar este

conceito?

4. Defina o conceito de uma máquina de níveis ou camadas.

5. Quais os tipos de sistemas operacionais existentes?

6. Por que dizemos que existe uma subutilização de recursos em sistemas monoprogamáveis?

7. Qual a grande diferença entre sistemas monoprogramáveis e sistemas

multiprogramáveis?

8. Quais as vantagens dos sistemas multiprogramáveis?

9. Um sistema monousuário pode ser um sistema multiprogramável? Dê um exemplo.

10. Quais são os tipos de sistemas multiprogramáveis?

11. O que caracteriza o processamento batch? Quais aplicações podem ser

processadas neste tipo de ambiente?

12. Os primeiros Sistemas Operacionais eram Monotarefas, já os atuais são Multitarefa. De acordo com os tipos de Sistemas Operacionais identifique-os na figura abaixo e explique seu funcionamento e suas principais características.

a.


22

13. Como funcionam os sistemas de tempo compartilhado? Quais as vantagens em

utilizá-los?

14. Qual a principal diferença entre sistemas de tempo compartilhado e tempo real? Quais aplicações são indicadas para sistemas de tempo real?

15. O que são sistemas com múltiplos processadores e quais as vantagens em utilizá-

los? 16. Qual a diferença entre sistemas fortemente acoplados e fracamente acoplados?

17. O que é um sistema fracamente acoplado? Qual a diferença entre sistemas

operacionais de rede e sistemas operacionais distribuídos?

18. Cite as principais funcionalidades de um projeto de Sistema Operacional.

19. O que é uma system call e qual sua importância para a segurança do sistema? Como as system calls são utilizadas por um programa?

20. O que é o núcleo do sistema e quais são suas principais funções?

21. Como o kernel do sistema operacional pode ser protegido pelo mecanismo de modos de acesso?

22. Explique as três arquiteturas do kernel de um Sistema Operacional.


23

ATIVIDADE COMPLEMENTAR

1) Faça uma pesquisa e tente identificar os principais sistemas operacionais em

uso. Classifique-os de acordo com sua arquitetura (monolítico, micronúcleo, ou máquina virtual) e tipo (rede, distribuído, multiusuário, etc.)

LEITURA COMPLEMENTAR

Existem diversos documentários sobre a história dos computadores. Pois bem, caso queira conhecer um pouco mais sobre a história recente do computador pessoal, existe um filme chamado “O Triunfo dos Nerds”, que conta a história da do surgimento da Microsot e da Apple, ou seja, o inicío da computação pessoal. Uma verdadeira aula de história!

Fonte da figura: http://macmagazine.uol.com.br/wp-content/uploads/2008/10/12-triunfosilicio2.jpg. Acesso em: 11 de Maio de 2010.

Também existe um pequeno e informativo vídeo sobre a história dos computadores no Museu do Telefone no Rio de Janeiro. Você pode assisti-lo através do link a seguir:

<http://midiaseducacao.blogspot.com/2009/06/historia-do-computador-em-minutos.html>.


24

GERENCIAMENTO DE PROCESSOS

1 introdução ao modelo de processos Os primeiros Sistemas Operacionais eram caracterizados por apenas um

programa poder ser executado de cada vez. Os computadores mais modernos são constituídos de Sistemas Operacionais com capacidade de executar várias tarefas ao mesmo tempo.

De fato, o processador pode ser alternado de um programa para o outro, executando cada um por um determinado tempo (comumente em milissegundos). Em outras palavras, para um determinado intervalo de tempo, vários programas utilizam uma fatia desse tempo para realizar suas atividades, passando, assim, para o usuário a falsa impressão de que todos eles estão sendo executados ao mesmo tempo.

Essa falsa impressão passada ao usuário de que vários programas estão sendo executados ao mesmo tempo é comumente conhecido por pseudoparalelismo. Para que isso seja possível é necessário um monitoramento das múltiplas atividades entre os vários programas, que se trata de uma tarefa difícil e bastante complexa.

Segundo Tanenbaum, os projetistas de Sistemas Operacionais desenvolveram um modelo que torna o paralelismo mais fácil de tratar, conhecido como modelo de processos, assunto desta unidade.

Conceito de Processos Um processo pode ser entendido inicialmente como um programa em

execução, que tem suas informações mantidas pelo sistema operacional. Num sistema multiusuário, cada usuário tem a impressão de possuir o

processador e todos os demais recursos reservados exclusivamente para si, mas isto não é verdade. Todos os recursos estão sendo compartilhados, inclusive a CPU. Neste caso, o processador executa o processo do usuário por um intervalo de tempo e, no instante seguinte, poderá estar processando outro programa, do mesmo ou de outro usuário.

Para que a troca de processos possa ser feita sem problemas, é necessário que todas as informações do programa que está sendo interrompido sejam guardadas, para que ele possa retornar à CPU exatamente do ponto em que parou não lhe faltando nenhuma informação vital à sua continuação. Todas as informações necessárias à execução de um programa fazem parte do processo.

Um processo também pode ser definido como o ambiente onde o programa é executado. Este ambiente, além das informações sobre a execução, possui também a quantidade de recursos do sistema que o programa pode utilizar como espaço de endereçamento, tempo do processador e área em disco.

Para que o Sistema Operacional gerencie os processos, primeiro ele deve ser capaz de: (1) criá-los, (2) reservar memória e (3) colocar os processos numa fila de espera para uso do processador. O próprio Sistema Operacional é um conjunto de vários processos que também compartilham a CPU para serem executados.


25

Por exemplo, quando você executa o programa Internet Explorer do sistema operacional Windows para navegar na Internet, na verdade, você está solicitando a criação do iexplorer.exe (processo do programa Internet Explorer) ao explorer.exe (processo genérico do sistema responsável por fornecer comandos básicos e gerenciar o ambiente gráfico padrão do Windows). A Figura 2 mostra a tela de um computador que está executando o Process Explorer, um programa de gerenciamento de processos que na sua tela inicial mostra todos os processos que estão executando em seu computador e a relação entre eles (por exemplo, se um processo é pai de um outro), observe como o processo iexplorer.exe está situado entre os processos filhos do explorer.exe.

Para você apenas visualizar quais processos estão sendo executado, o Windows

possui o gerenciador de tarefas do sistema. Uma forma de acessá-lo é pressionando os botões Ctrl, Alt e Del, simultaneamente e escolher a opção “Iniciar Gerenciador de Tarefas”,ou clicar com o botão direito do mouse na barra de tarefas do meu iniciar aba “Iniciar gerenciador de Processos”. Assim, você terá acesso a essa importante ferramenta do sistema e poderá utilizá-las não só para visualizar os processos, mas também, caso ocorra algum problema com um processo específico, você poderá encerrá-lo.


26

2 Estados de um Processo Os vários processos criados competem entre si pela atenção do processador a

cada instante, cabendo ao gerenciador de processos do Sistema Operacional estabelecer uma ordem

Em diferentes momentos, um processo pode está utilizando-se do processador,

ou simplesmente aguardando, além disso, existem situações onde o processo, mesmo tendo o processador disponível, fica impossibilitado de prosseguir a execução, pois geralmente está aguardando por alguma entrada. Então, para que não exista desperdício no uso do processador, processos que estejam aguardando algum dado externo ficam bloqueados, deixando aos demais processos disputarem o uso do processador. Dessa forma, podemos dizer que os processos podem está em três estados, que seriam:

Executando: um processo está no estado executando quando ele, de fato, está sendo processado pela CPU. Em sistemas monoprocessados (único processador), somente um processo por vez pode estar de posse da CPU em um dado instante. Os processos se alternam na utilização do processador.

Pronto: um processo está no estado de pronto quando ele possui todas as condições necessárias para a sua execução, porém, não está de posse do processador. Em geral, existem vários processos no sistema prontos para serem executados e o Sistema Operacional é responsável por, dessa lista de processos, selecionar qual utilizar o processador em um determinado instante de tempo.

Bloqueado: um processo está no estado de bloqueado quando ele aguarda por algum evento externo ou por algum recurso do sistema indisponível no momento. Por exemplo, se um processo necessita de uma informação de algum dispositivo de E/S, enquanto essa informação não se torna disponível, o processo entra no estado de bloqueado.

Os três estados de um processo em um Sistema Operacional tornam possível algumas transições, como ser observado na Figura abaixo.

.

DICA !

Para visualizar a árvore de processos no Windows, existe o programa Process Explorer que traz muito mais informações que o gerenciador de tarefas do Windows. Além de apresentar a estrutura de processos, indicando o parentesco entre eles, informa dados referente a cada processo, como a quantidade de memória utilizada por cada um. Vale a pena conferir, ele é um software gratuito disponível no seguinte link para download:

<http://www.baixaki.com.br/download/process-explorer.htm>


27

A transição 1 (Executando - Bloqueado) ocorre quando um processo que

estava utilizando o processador precisou de algum evento externo (operação de Entrada/Saída, por exemplo), não podendo continuar executando, passando, assim, para o estado de bloqueado.

A transição 2 (Bloqueado - Pronto) ocorre quando o evento externo, no

qual o processo bloqueado aguardava, acontece. Nesse caso, o processo passa para o estado de pronto e volta para a fila para poder concorrer novamente ao processador. Se não existir nenhum processo na fila de prontos, naturalmente, o processo desbloqueado utilizar a CPU.

Já as transições 3 (Pronto - Executando) e 4 (Executando -Pronto) são

realizados pelo escalonador de processos. Comumente, existem vários processos prontos e esperando para serem executados. Cabe então ao Sistema Operacional (escalonador) escolher, entre os processos prontos, qual utilizará o processador e poderá executar suas atividades. O Sistema Operacional (dependendo da política do escalonador) pode, também, retirar o processador de um determinado processo e disponibilizá-lo para outro processo.

3 Threads Atualmente, vários programas precisam executar várias tarefas ao mesmo

tempo, por exemplo, um sistema de segurança de um prédio precisa receber imagens de várias câmeras, gravá-las em um disco e ainda exibi-las em uma tela para que possam ser monitoradas.

Para que um único processo possa realizar mais que uma tarefa ao mesmo tempo , Há as Threads.

Threads são fluxos de execução (linha de controle) que rodam dentro de um processo, ou seja, uma Thread pode ser vista como um fluxo de execução de uma tarefa. Em processos tradicionais, há uma única linha de controle e um único contador de programa. Porém, alguns Sistemas Operacionais fornecem suporte para múltiplas linhas de controle dentro de um processo (sistemas multithread).


28

Ter múltiplas linhas de controle ou threads executando em paralelo em um processo equivale a ter múltiplos processos executando em paralelo em um único computador. Um exemplo tradicional do uso de múltiplas thread seria um navegador web, no qual pode ter uma thread para exigir imagens ou texto enquanto outro thread recupera dados de uma rede.

É importante destacar que as threads existem no interior de um processo e compartilham entre elas os recursos do processo, como o espaço de endereçamento (código e dados).

4 Comunicação Interprocessos. Em um Sistema Operacional, freqüentemente, os processos podem precisar

trocar informações entre eles ou podem solicitar a utilização de um mesmo recurso simultaneamente, como arquivos,registros, dispositivos de E/S e memória. O compartilhamento de recursos entre vários processos pode causar situações indesejáveis e, dependendo do caso, gerar o comprometimento da aplicação.

O Sistema Operacional tem a função de gerenciar e sincronizar processos concorrentes, com o objetivo de manter o bom funcionamento do sistema

Condições de Corrida Podemos definir uma condição de corrida quando dois ou mais processos

podem compartilhar algum espaço de memória compartilhado no qual, o resultado da informação deste espaço de armazenamento depende de quem executa. Um exemplo típico de condição de corrida, apontado por vários autores, é o spool de impressão.

Quando um processo deseja imprimir alguma informação, ele insere o nome de arquivo em um espaço denominado diretório de spooler. Existe outro processo, o servidor de impressão, que verifica periodicamente se há qualquer arquivo a ser impresso e, caso haja, ele os imprime e remove a informação do diretório.

Consideremos a seguinte situação: o diretório de spooler contém um número de entradas numeradas e um processo, quando deseja imprimir alguma informação, consulta uma variável (entrada) a fim de saber em qual posição inserir o nome de arquivo no diretório.

O diretório de impressão está ilustrado na Figura abaixo.

Diretório de spooler (impressão)


29

Podemos imaginar agora a seguinte situação: um processo A lê a variável entrada e armazena o valor dela (valor 0) em uma variável local. Porém, o tempo de execução do processo A termina e o Sistema Operacional o retira do processador, disponibilizando-o a um outro processo B. O processo B, por sua vez, também deseja imprimir um arquivo, acessa a área do diretório de impressão, verifica o valor da variável entrada (valor 0), armazena este valor em uma variável local e, por fim, insere o nome de seu arquivo a ser impresso na posição 0 do diretório de impressão, mudando o valor da variável entrada para 1.

A Figura abaixo visualiza esta situação atual.

Situação do Diretório de impressão após inserção do nome de arquivo do processo B

Por fim, o processo A retoma o processador, iniciando novamente de onde parou. Ao examinar em sua variável local o valor da variável entrada (esta informação ele guardou em sua tabela, momento em que ele parou a execução), o processo observa o valor 0 e escreve seu nome de arquivo nessa posição, apagando o nome de arquivo do processo B. Em seguida, incrementa o valor da variável entrada para 1.

A Figura abaixo mostra a nova situação do servidor de impressão.

Situação do Diretório de impressão após inserção do nome de arquivo do processo A


30

Internamente, o servidor de impressão continua consistente, porém o arquivo do processo B jamais será impresso. Caracterizamos este tipo de situação como uma condição de corrida.

5 Seções Críticas Para se evitar uma condição de corrida é preciso definir métodos que proíba

que mais de um processo acesse uma determinada área de memória compartilhada ao mesmo tempo. Esses métodos são conhecidos como exclusão mútua. Um processo, durante seu tempo de execução, pode realizar uma série de computações internas que não geram condições de corrida ou pode estar acessando memória compartilhada, que levam à condição de corrida.

A parte do programa no qual o processo acessa memória compartilhada é chamada seção crítica ou região crítica. Dessa forma, a solução para se evitar uma condição de corrida seria organizar os problemas de tal forma que nenhum de dois ou mais processos estivessem em suas regiões críticas ao mesmo tempo.

Para se ter uma boa solução de exclusão mútua, precisamos evitar algumas situações indesejáveis, como:

Nenhum processo que esteja fora de sua região crítica pode bloquear a execução de outro processo;

Nenhum processo deve esperar indefinidamente para poder entrar em sua região crítica.

6 Deadlocks : Impasse entre Processos O Sistema Computacional está repleto de recursos, que podem ser utilizados

pelos processos. Comumente, a quantidade de recursos disponíveis é muito menor que a quantidade de processos solicitando esse recurso. Dependendo do recurso, este fato pode gerar uma situação de bloqueio eterno do processo.

Podemos, assim, definir que um conjunto de processos está em deadlock ou impasse quando cada um desses processos está bloqueado esperando um evento que só pode ser gerado por outro processo desse conjunto. Como todos os processos estão bloqueados, nenhum deles poderá gerar um evento e, naturalmente, todos continuarão nessa situação.

Um bom exemplo apontado por Tanenbaum trata-se de dois processos querendo ler dados de um CD e imprimindo em uma impressora.

Suponha que o processo A solicite a impressora, que é disponibilizada. De forma análoga, o processo B solicita o CD-ROM,que lhe é disponibilizado. Agora o processo A solicita o CD-ROM, enquanto que o processo B solicita a impressora. Como ambos os recursos já estão alocados, o processo A e B serão bloqueados.

Nessa situação eles continuarão indefinidamente, pois nenhum processo terá como se finalizar e, por fim, liberar o recurso já alocado. Esses processos geram um deadlock.

É importante destacar, que os impasses podem ser gerados tanto por recursos de hardware quanto por recursos de software. Um recurso de software seria um impasse gerado no acesso a registros sendo assim, trataremos o termo recurso de uma forma geral.


31

Os recursos podem ser divididos em dois tipos: Recursos preemptíveis: trata-se de recursos que podem ser retirados de

um determinado processo sem gerar problema algum. Por exemplo, a memória. Recursos não-preemptíveis: trata-se de recursos que não podem ser

retirados de um determinado processo sem causar problemas. Por exemplo, é inviável retirar a impressora de um determinado processo que começou a imprimir sua saída.

Condições para um Impasse. Coffman demonstrou em 1971 que existe quatro condições para que haja um

impasse: Condição de exclusão mútua: Somente um processo de cada vez pode

acessar um recurso. Caso contrário, o recurso estará disponível. Condição de posse e espera: Um processo deve estar de posse de um

recurso e solicitando novos recursos. Condição de não preempção: Os recursos concedidos aos processos não

podem ser retirados deles. Condição de espera circular: Deve haver uma cadeia circular de dois ou

mais processos, cada um dos quais está esperando um recurso já segurado pelo próximo membro da cadeia e, assim por diante.

Métodos de Lidar com Deadlocks Existem várias formas de lidar com deadlocks. Em geral, temos quatro

métodos: Ignorar completamente o problema. Detectar e recuperar uma situação de deadlock. Prevenir um deadlock através da negação das quatros condições de

Coffman. Impedimento de um deadlock através de uma alocação dinâmica

cuidadosa de recursos. Por incrível que pareça, a estratégia mais usada nos

sistemas operacionais é a de ignorar os problemas de deadlock, pois os possíveis tratamentos desse tipo de situação podem acarretar em perdas de desempenho do sistema, comprometendo a execução dos processos.

Assim, é mais comum que os próprios softwares procurem evitar situações de deadlock na lógica em seus códigos e, no caso de ocorrer alguma situação de impasse, é preferível encerrar a execução de um processo ou até reiniciar o computador em casos mais extremos.

DICA !

O SOsim 2.0 (Simulador de Sistema Operacional) é um software educacional que permite simular situações de gerencias de um sistema Operacional .


32

EXERCICIO

1. Defina processos.

2. Por que o conceito de processo é tão importante no projeto de sistemas multiprogramáveis?

3. Descrevas os estados que um processo pode ocupar em um sistema

baseado no modelo de processos.

4. Comente as possíveis transições que podem ocorrer entre os estados de um processo.

5. O que são Threads. Caracterize os sistemas multithreads.

6. O que são condições de corrida?

7. O que é uma região crítica e exclusão mútua?

8. Cite as condições para se ter uma boa solução que evite condições de corrida.

9. Descreva de forma sucinta o método de exclusão mútua ativa

10. Defina deadlock .

11. Quais as condições segundo Coffman para que aconteça um impasse entre processos?


33

ATIVIDADE COMPLEMENTAR

1. Diversos exemplos na literatura de sistemas operacionais procuram demonstrar situações de deadlock. São exemplos simples, como o clássico exemplo dos cinco filósofos jantando. Procure na internet dados sobre esse exemplo e apresente.

ATIVIDADE PRÁTICA

1. Criação de Processos a) Práticas de simulação · Execute o simulador SOsim e identifique as quatro janelas que são abertas na

inicialização. · Crie um processo: janela Gerência de Processos / Criar – janela Criação de

Processos / Criar. b) Análise Prática · Na janela Gerência de Processos, observe algumas informações sobre o

contexto de software do processo como prioridade, estado do processo e tempo de

processador. · Na janela Gerência de Processador, observe o processo transacionando entre

estados. · Na janela Gerência de Processador, movimente a barra de Clock de UCP e

observe as variações ocorridas. c) Questão teórica para responder com a ajuda do simulador :Com base na

observação do comportamento do processo criado, identifique se o processo é I/Obound

ou CPU-bound. Justifique sua resposta.

2. Tipos de Processos a) Práticas de simulação · Reinicialize o simulador. · Crie um processo do tipo CPU-bound: janela Gerência de Processos / Criar –

janela Criação de Processos / Criar (tipo de processo deve ser CPU-bound). · Crie outro processo do tipo I/O-bound: janela Gerência de Processos / Cria –

janela Criação de Processos / Criar (tipo de processo deve ser I/O-bound). b) Análise Prática · Na janela Gerência de Processos, observe as mudanças de estado dos dois

processos. · Na janela Gerência de Processador, observe o comportamento dos processos e

as mudanças de contexto em função do tipo I/O-bound e CPU-bound. · Na janela Gerência de Processos, compare a taxa de crescimento do tempo de

processador dos dois processos.


34

c) Questão teórica para responder com a ajuda do simulador :Analise os efeitos gerados no caso de redução do tempo gasto na operação de E/S pelo processo

I/O-bound.

Gerenciador de Processos Com o surgimento dos sistemas multiprogramáveis, onde múltiplos processos

poderiam permanecer na memória e disputar o uso de um único processador, a gerência do processador tornou-se uma das atividades mais importantes em um sistema operacional.

A partir do momento em que vários processos podem estar no estado de pronto, devem ser estabelecidos critérios para definir qual processo será escolhido para fazer uso do processador. Tais critérios compõem a política de escalonamento, que é a base da gerência do processador e da multiprogramação em um sistema operacional.

Dentre as funções da gerência do processador, podemos citar: manter o processador ocupado a maior parte do tempo. balancear o uso da CPU entre processos, privilegiar a execução de aplicações críticas, maximizar o throughput e oferecer tempos de resposta razoáveis aos usuários interativos.

Cada sistema operacional possui sua política de escalonamento adequada ao seu propósito e às suas características. Sistemas de tempo compartilhado, por exemplo, possuem requisitos de escalonamento distintos dos sistemas de tempo real.

3. Escalonamento de Processos O escalonamento de processos é a forma com que os processadores

disponíveis (um ou vários) no Sistema Computacional são distribuídos ou alocados para os vários processos prontos.

A parte do Sistema Operacional responsável por selecionar qual será o processo que executará no processador é chamado de escalonador ou agendador. Dessa forma, a ordem com que os processos serão executados pelo processador é definida por um determinado algoritmo ou política de escalonamento de processos.

O projeto de um algoritmo de escalonamento deve levar em conta uma série de critérios , no qual alguns são apontados a seguir:

Throughput: é o número de processos executados em um determinado

intervalo de tempo. Quanto maior o throughput, maior o número de tarefas executadas em função do tempo. A maximização do throughput é desejada na maioria dos sistemas.

Tempo de Processador: é o tempo que um processo leva no estado de

execução, durante seu processamento. As políticas de escalonamento não interferem neste parâmetro, sendo este tempo função apenas do código executável e da entrada/saída de dados.

Tempo de Espera (pela CPU): é todo o tempo que o processo permanece

na fila de pronto, aguardando a liberação da CPU para ser executado. A redução deste tempo de espera é desejada pela maioria das políticas de escalonamento.


35

Tempo de Turnaround: é o tempo total que o processo permaneceu no sistema, desde sua criação até o momento em que é encerrado. São contados os tempos de alocação de memória, espera na fila de pronto e interrupção (E/S).

Tempo de Resposta: é o tempo decorrido entre uma requisição ao sistema

e o instante em que a resposta começa a ser exibida. Em sistemas interativos, como aplicações on-line ou acesso à Web, os tempos de resposta devem ser da ordem de apenas poucos segundos.

Os algoritmos de escalonamentos podem ser classificados em preemptíveis e não-preemptíveis. O algoritmo de escalonamento é não-preemptível quando o processador alocado para um determinado processo não pode ser retirado deste até que o processo seja finalizado.

Já o algoritmo de escalonamento é dito preemptível quando o processador alocado para um determinado processo pode ser retirado deste em favor de outro processo.

Atualmente a maioria dos sistemas são preemptívos

4. Escalonamentos Não-Preemptivos Algoritmo de Escalonamento FIFO (First in First out) Trata-se do algoritmo de escalonamento de implementação mais simples. Com

este algoritmo de escalonamento, o primeiro processo que solicita a CPU é o primeiro a ser alocado. Dessa forma, os processos que estão prontos para serem executados pela CPU são organizados numa fila, que funciona baseado na política FIFO (First in First out – Primeiro a entrar é o primeiro a sair).

Vejamos um exemplo. Considere o seguinte conjunto de processos:

Supondo que a ordem de chegada dos processos seja: A – B – C – D. Dessa

forma, baseado na política FIFO, a ordem de execução dos processos é mostrado na Figura abaixo (diagrama de tempo).

Diagrama de tempo usando a política FIFO.


36

Para este conjunto de tarefas o tempo de espera do processo A é de 0 (zero) unidades de tempo; para o processo B de 12 unidades de tempo; para o processo C de 20 unidades de tempo; e para o processo D de 35 unidades de tempo. O tempo médio de espera na fila de prontos é de (0+12+20+35)/4, que equivale a 16,75 unidades de tempo.

Nesta política de escalonamento o tempo médio de espera é, com freqüência, um tanto longo. Outro ponto é que processos importantes podem ser obrigados a esperar devido à execução de outros processos menos importantes dado que o escalonamento FIFO não considera qualquer mecanismo de distinção entre processos.

Algoritmo de Escalonamento Menor Tarefa Primeiro (SJF –shortest job

first) Neste escalonamento o processo que tem o menor ciclo de processamento

(tempo de execução) será selecionado para usar o processador. Considerando o mesmo conjunto de tarefas apresentados, teríamos o diagrama

de tempo apresentado na Figura abaixo.

Diagrama de tempo usando a política Menor Tarefa Primeiro.

Nesta política de escalonamento, o tempo de espera do processo A é de 13 unidades de tempo; para o processo B de 5 unidades de tempo; para o processo C de 25 unidades de tempo; e para o processo D de 0 unidades de tempo. O tempo médio de espera na fila de prontos é de (13+5+25+0)/4, que equivale a 10,75 unidades de tempo.

Em média, nessa política de escalonamento, os processos tiveram que esperar menos para serem executados pelo processador.

Segundo Silberschatz, a dificuldade real com o algoritmo de Menor Tarefa Primeiro é saber o tempo de duração da próxima solicitação de CPU. Assim, trata-se de um algoritmo ótimo, porém, não pode ser implementado, pois não há modo de saber o tempo de duração do próximo pico de CPU. Uma abordagem possível é tentar aproximar-se do algoritmo de Menor Tarefa Primeiro.

5. Escalonamentos Preemptivos Algoritmo de Escalonamento Round Robin O algoritmo Round Robin, conhecido também como algoritmo de

escalonamento circular, também organiza a lista de processos prontos como uma fila simples, semelhante ao algoritmo FIFO.


37

. É muito semelhante ao FIFO (obedece a ordem de chegada á fila de PRONTO), mas quando um processo passa para o estado de execução há um limite de tempo para o uso contínuo do processador, chamado fatia de tempo (time-slice) ou quantum. Assim, toda vez que um processo é selecionado para execução uma nova fatia de tempo lhe é concedida. Caso esta fatia de tempo expire, o sistema operacional interrompe o processo, salva seu contexto e o direciona para a fila de PRONTO.

Algoritmo de Escalonamento por Prioridades Nesta política, os processos são organizados na fila de prontos baseado em

prioridades. Quem tiver maior prioridade vai para o início da fila. Quem tiver menor prioridade vai se encaixando no final da fila. Esta prioridade pode ser uma atribuição externa ao sistema.

Vejamos um exemplo. Considere o seguinte conjunto de processos:

Dessa forma, baseado na política de escalonamento por prioridades (quanto

menor o número, maior a prioridade), a ordem de execução dos processos é mostrado através da Figura abaixo (diagrama de tempo).

Diagrama de tempo usando a política por prioridades.

Alguns aspectos devem ser considerados na política de escalonamento por prioridades. Primeiro, se no sistema existir uma quantidade grande e interativa de processos de alta prioridade, podemos chegar a uma situação onde processos de baixa prioridade nunca executarão.

Uma possível solução para este problema é a utilização de prioridades dinâmicas. Dessa forma, os processos de baixa prioridade podem ter suas prioridades lentamente aumentadas, tendo, assim, chances de utilizar o processador.


38

Algoritmo de Escalonamento Múltiplas Filas Este escalonamento implementa várias filas de pronto, cada uma com

prioridade específica. Os processos são associados às filas de acordo com características próprias, como importância da aplicação, tipo de processamento ou área de memória necessária. Assim, não é o processo que detém a prioridade, mas sim a fila.. Dessa forma, ao invés de termos apenas uma única fila de prontos, poderíamos construir várias filas de prontos e agrupar os processos de mesma categoria nessas filas. Para cada fila poderíamos definir prioridades diferentes e políticas de escalonamentos específicas

.Um exemplo deste algoritmo seria considerar duas filas de prontos, uma com maior prioridade e outra de menor prioridade, as duas funcionando segunda a política Round Robin. Dessa forma, se a fila mais prioritária tiver processos, estes terão prioridade sobre o processador. Caso a fila mais prioritária estiver vazia, os processos prontos da fila menos prioritária irão concorrer ao processador.

2.4 Sincronização dos Recursos A sincronização dos recursos do computador é uma tarefa muito importante,

realizada pelos sistemas operacionais multitarefa e é feita em duas áreas distintas: Sincronização dos Dados: nesse caso o objetivo é manter os dados do

computador em perfeita integridade; Sincronização dos Processos: refere-se à sincronização da execução dos

processos,com o objetivo de se evitar o conflito na utilização dos recursos do computador;

A sincronização dos processos só faz sentido em sistemas multitarefa, em que a cada instante, vários processos poderão estar em execução. O trabalho do sistema operacional será garantir que cada processo seja concluído corretamente. Aqui, o conceito de processo será aplicado tanto ao processo em si quanto à thread, ou seja, a sincronização de processos e sincronização de threads serão tratados de maneiras unificadas, como Sincronização de Processos.

Para realizar a sincronização algumas medidas podem ser tomadas: a utilização de Barreiras, Travas, Semáforos, Comunicação e várias outras. Algumas dessas medidas são implementadas no código dos programas, como as Barreiras, e outras medidas são realizadas no sistema operacional, as Travas.

As Barreiras são criadas e gerenciadas pelos desenvolvedores de programas aplicativos. Dentro das instruções desses programas, deve-se incluir uma instrução de criação de Barreira. Quando um processo executa tal instrução, entra em estado de Espera (ou Bloqueio), e permanece assim até que todos os processos pertencentes ao mesmo programa também executem a instrução de Barreira. Com isso consegue-se colocar todos os processos no mesmo ponto de execução do programa.

Semáforos podem ser utilizados tanto pelos programas quanto pelo sistema operacional. São variáveis de controle, que indicam se um determinado recurso pode ser utilizado ou não. O modo mais frequente de controle é a utilização de um contador no semáforo. O contador indica a quantidade de processos que podem compartilhar o recurso, quando o limite é alcançado, nenhum processo a mais pode utilizar o mesmo recurso.

Barreiras e Semáforos geralmente são utilizados para lidar com situações em que vários processos podem (ou devem) compartilhar um mesmo recurso. Nos casos,


39

nos quais um recurso deve ser utilizado exclusivamente por apenas um processo é utilizada a Trava.

Alguns sistemas implementam Travas Simples, que impedem a utilização do recurso por outro processo, e outros sistemas implementam Travas Especiais, que emitem um sinal (aviso de erro) quando um processo tenta acessar um recurso já em uso. Existe também a possibilidade de se ter uma Trava Compartilhada por vários processos, mas nesse caso, o acesso ao recurso fica limitado apenas à leitura dos dados contidos nele.

Para o correto funcionamento dos métodos de sincronização, o processador deve estar preparado para permitir que os processos consigam compartilhar um recurso até o limite estabelecido, sem que haja conflito no controle de sincronia. Por exemplo, em um sistema de Trava, se ela estiver aberta significa que um processo poderá acessar o recurso. Se, em um mesmo instante, dois processos tentarem utilizar o recurso, os dois conseguirão acesso ao recurso e com certeza isso resultará em má utilização dele (imagine uma impressora imprimindo simultaneamente dois documentos diferentes).

Para evitar essa falha, os processadores devem possuir mecanismos de verificação e ativação da sincronia quase instantânea, ou no mínimo, não conflitante. Esses mecanismos no processador são instruções que realizarão a sincronização de maneira correta, as instruções serão do tipo “verificar e travar recurso”, uma mesma instrução faz a verificação e, se possível, o travamento do recurso. Esse mecanismo só é válido em computadores com um processador (podendo o processador ter vários núcleos). Em computadores com vários processadores, o controle da sincronização é mais complexo, havendo um maior número de considerações a serem feitas. A etapa de efetivação do sincronismo é muito importante, o tempo que ela demora não deve em hipótese alguma ser demorado. A efetivação da sincronização deve acontecer obrigatoriamente antes de o processador executar mais uma instrução de outro processo (ou do mesmo processo).

A etapa de liberação de uma sincronização também deve ser tratada de maneira adequada, pois em um ambiente de execução de múltiplos processos, para haver a real otimização da utilização dos recursos, os processos devem ter acesso aos mesmos assim que eles não estiverem em uso.


40

EXERCICIO

1. O que é política de escalonamento de um sistema operacional? 2. Quais as funções do escalonador e do dispatcher? 3. Quais os principais critérios utilizados em uma política de escalonamento? 4. Diferencie os tempos de processador, espera, turnaround e resposta. 5. Diferencie os escalonamentos preemptivos e não-preemptivos. 6. Qual a diferença entre os escalonamentos FIFO e circular? 7. Descreva o escalonamento SJF e o escalonamento por prioridades. 8. Qual a diferença entre preempção por tempo e preempção por prioridade? 9. O que é um mecanismo de escalonamento adaptativo? 10. Que tipo de escalonamento aplicações de tempo real exigem? 11.Considere um sistema operacional que implemente escalonamento circular

com fatia de tempo igual a 10 u.t.. Em um determinado instante de tempo, existem apenas três processos (P1, P2 e P3) na fila de pronto, e o tempo de UCP de cada processo é 18, 4 e 13 u.t, respectivamente. Qual o estado de cada processo no instante de tempo T, considerando a execução dos processos P1, P2 e P3, nesta ordem, e que nenhuma operação de E/S é realizada?

a) T = 8 u.t. b) T = 11 u.t. c) T = 33 u.t. 12. Considere um sistema operacional que implemente escalonamento circular

com fatia de tempo igual a 10 u.t. Em um determinado instante de tempo, existem apenas três processos (P1, P2 e P3) na fila de pronto,e o tempo de UCP de cada processo é 14, 4 e 12 u.t, respectivamente. Qual o estado de cada processo no instante de tempo T, considerando a execução dos processos P1, P2 e P3, nesta ordem, e que apenas o processo P1 realiza operações de E/S? Cada operação de E/S é executada após 5 u.t. e consome 10 u.t.

a) T = 8 u.t. b) T = 18 u.t.


41

c) T = 28 u.t. 13. Existem quatro processos (P1, P2, P3 e P4) na fila de pronto, com tempos

de UCP estimados em 9, 6, 3 e 5, respectivamente. Em que ordem os processos devem ser executados para minimizar o tempo de turnaround dos processos?

ATIVIDADE PRÁTICA

1) Estatísticas

a)Práticas de simulação · Reinicialize o simulador. · Ative a janela de Estatísticas em Console SOsim / Janelas / Estatísticas. · Crie dois novos processos: janela Gerência de Processos / Criar – janela criação de Processos / Criar. b)Análise Prática · Na janela Estatística, observe as informações: número de processos, estados

dos processos e processos escalonados c)Questão teórica para responder com a ajuda do simulador: Observe que

em alguns momentos existem processos no estado de pronto, porém nenhum em estado de execução. Explique a razão dessa situação.

2) Log de Execução dos Processos

a)Práticas de simulação · Reinicialize o simulador. · Ative a janela de Log em Console SOsim / Janelas / Log. · Crie dois novos processos do tipo CPU-bound: janela Gerência de Processos /

Cria – janela Criação de Processos / Criar (tipo de processo deve ser CPU- bound).

b)Análise Prática · Na janela Log, observe as informações sobre as mudanças de estado dos

processos observando o tempo que cada processo permanece nos estados de execução e Pronto.

· Reinicialize o simulador parametrizado com um valor de fatia de tempo diferente observe as diferenças na janela Log.

c)Questão teórica para responder usando o simulador :Analise comparativamente a concorrência de dois processos CPU-bound executando em dois sistemas operacionais que se diferenciam apenas pelo valor da fatia de tempo.

3) Suspensão e Eliminação de Processos

a)Práticas de simulação · Reinicialize o simulador.


42

· Crie dois novos processos: janela Gerência de Processos / Cria – janela criação de processos / Criar.

b)Análise Prática · Na janela Gerência de Processos, observe as informações sobre o contexto de

software dos processos criados. · Na janela Gerência de Processador, observe a concorrência no uso do

processador pelos dois processos. · Compare percentualmente os tempos de uso do processador entre os dois

processos. · Suspenda temporariamente um dos processos na janela Gerência de Processos

/ Suspender. · Observe os estados dos processos, a concorrência no uso do processador e

novamente compare percentualmente os tempos de uso do processador entre os dois processos.

· Libere o processo do estado de espera (suspenso) na janela Gerência de Processos / Prosseguir.

· Elimine um dos processos na janela Gerência de Processos / Finalizar. c)Questão teórica para responder com a ajuda do simulador :Ao se

eliminar um processo em estado de suspenso, o processo não é eliminado imediatamente.

Reproduza essa situação no simulador e explique a razão da situação. 4) Escalonamento Circular

a)Práticas de simulação · Execute o simulador SOsim e configure-o para trabalhar com Escalonamento

Circular: janela Console SOsim / Opções / Parâmetros do Sistema na guia Processador.

b)Análise Prática · Crie dois processos com a mesma prioridade (um CPU-bound e outro I/O-

bound): janela Gerência de Processos / Criar – janela Criação de Processos / Criar.

· Na janela Gerência de Processos, observe o tempo de processador de cada processo durante dois minutos e as mudanças de estado. Após esse período anote o tempo de processador de cada processo. Analise o balanceamento no uso do processador pelos dois processos.

· Na janela Gerência de Processos finalize os dois processos. · Na janela Gerência de Processador, aumente a fatia de tempo movimentando

a barra de fatia de tempo. · Na janela Gerência de Processos, observe mais uma vez o tempo de

processador de cada processo durante dois minutos e as mudanças de estado. Após esse período anote o tempo de Processador de cada processo. Compare os tempos anotados nas duas e analise o resultado do balanceamento no uso do processador pelos dois processos. Identifique as causas da variação.

c)Questão teórica para responder com a ajuda do simulador Considere a concorrência, nesse tipo de escalonamento, com dois processos

CPU-bound que não realizam operações de E/S. Qual o efeito da variação da fatia de tempo sobre o balanceamento no uso do processador?


43

GERENCIAMENTO DE ENTRADA E SAÍDA

1 Introdução Para gerenciar os dispositivos, os sistemas operacionais contam com

gerenciadores específicos: Gerenciador de Impressão, Gerenciador de Disco, Gerenciador de Modem, Gerenciador USB, Gerenciador de Vídeo, entre outros, Para realizar essa tarefa, os sistemas operacionais recebem um conjunto de instruções específicas para o tratamento dos dispositivos. Cada gerenciador será responsável por realizar a administração e controle da utilização do respectivo dispositivo.

Princípios de hardware e de software de E/S.

2. Princípios de Hardware de E/S Segundo Tanenbaum, o hardware de entrada e saída pode ser visto sob dois

pontos de vista: Visão do Engenheiro Elétrico: vê o hardware sob o ponto de vista

de chips, fios, fontes de alimentação, de motores e de todos os componentes físicos que o constituem.

Visão do Programador: já o programador vê a interface apresentada para o software (comandos que o hardware aceita, as funções que ele executa e os erros que podem ser retornados).


44

Dispositivos de Entrada e Saída Os dispositivos de entrada e saída é o mecanismo utilizado para fazer a

interface entre o mundo exterior e o sistema e sem ele o computador não teria muita funcionalidade. É possível encontrar uma grande diversidade de dispositivos de entrada e saída, como: teclados, mouses, monitor de vídeo, impressora, scanners, dentre outros.

Os dispositivos de entrada e saída, dependendo do sentido o do fluxo de informações entre o sistema e o dispositivo, podem ser divididos, grosso modo, em dispositivos de entrada, dispositivos de saída ou dispositivos de entrada e saída. Os dispositivos de entrada são caracterizados por conter um fluxo de informações do dispositivo para o sistema, ou seja, são responsáveis por inserir no sistema informação do mundo externo. Já os dispositivos de saída são caracterizados pelo fluxo de informações do sistema para o mundo externo, ou seja, responsáveis por disponibilizar respostas ao mundo externo. Já os dispositivos e entrada e saída contemplam os dois fluxos.

Segundo Tanenbaum, os dispositivos também podem ser divididos, grosso modo, em duas categorias: dispositivos de bloco e dispositivos de caractere. Os dispositivos de bloco são caracterizados por armazenar informações em blocos de tamanhos fixos, cada um com seu endereço próprio. A propriedade essencial desse tipo de dispositivos é que é possível ler ou gravar blocos independentemente um do outro. O disco é um bom exemplo deste tipo de dispositivo.

Já os dispositivos de caractere são caracterizados por aceitar ou entregar um fluxo de caracteres, sem considerar qualquer estrutura de bloco, sem endereçamento ou qualquer operação de busca.

Embora esta classificação seja, de forma geral, muito utilizada, segundo o autor Tanenbaum, existem dispositivos que não são classificáveis em nenhum desses tipos. Como exemplo, tomemos por base os relógios. Os relógios são dispositivos que geram interrupções em intervalos definidos de tempo. Este dispositivo não se encaixa nos dispositivos de bloco, pois não possuem estrutura de blocos e, também, não se encaixam como dispositivos de caractere, pois não gera nenhum fluxo de caracteres.

Controladoras de Dispositivos Para que os dispositivos se comuniquem com o sistema, eles são ligados ao

computador através de um componente de hardware chamado de interface. Assim, os dispositivos não estão ligados diretamente aos barramentos do computador. Devido a diversidade de tipos de dispositivos, que abstrai diferentes formas de operações e complexidade, as interfaces empregam no seu projeto outro componente de hardware conhecido como controladora de dispositivo.

A controladora de dispositivo (chamada também de adaptador de dispositivo) trata-se de um componente eletrônico, comumente na forma de uma placa de circuito impresso, que pode ser inserido na placa mãe do computador. O dispositivo em si trata se de um componente mecânico. Uma controladora pode manipular mais de um dispositivo e, quando padronizadas, podem ser fabricadas por diversas empresas. Como exemplo de controladoras, temos as controladoras de disco IDE ou SCSI.

Cada controladora deve saber especificamente como o dispositivo a ela relacionado funciona, a fim de que possa enviar comandos a serem realizados.


45

Basicamente, uma controladora tem a função de converter um fluxo serial de bits em um bloco de bytes e executar uma correção de erros. Este bloco de bytes, montado em um buffer interno da controladora, após verificado erros, pode ser copiado para a memória principal. A maioria dos Sistemas Operacionais quase sempre lida com a controladora, não com o dispositivo.

As controladoras são formadas de um conjunto de registradores que são enxergados pelo processador. Esses registradores recebem ordens do processador, fornecem o estado de uma operação ou permitem a leitura ou escrita de dados do dispositivo. O Sistema Operacional quando deseja dar algum comando à controladora acessam esses registradores (cada registrador possui um endereço). Os endereços dos registradores podem fazer parte do espaço normal de endereçamento de memória. Esse esquema é conhecido como mapeamento de entrada e saída em memória.

Controladoras que suportam Acesso Direto à Memória As controladoras comuns (sem acesso direto à memória) recebem um fluxo de

caracteres, converte para um bloco, armazenado em seu buffer, depois verifica possíveis erros. Por seguinte, a controladora gera uma interrupção no Sistema Operacional, que por sua vez, começa a ler o bloco do buffer da controladora, cada byte por vez, e armazena-os na memória principal. Esta operação, naturalmente, exige desperdício de CPU.

O Acesso Direto à Memória (DMA – Direct Memory Access) é um mecanismo criado para liberar a CPU do trabalho de cópia dos dados da controladora para a memória. O controlador DMA é conectado diretamente ao barramento de dados e de endereços do computador, para ter a capacidade de acessar diretamente endereços de memória.

Com a controladora DMA, após o bloco ter sido lido do dispositivo completamente e verificado possíveis erros, ela copia o primeiro byte para o endereço de memória principal especificado pelo endereço de memória DMA. Após terminar a transferências dos dados para a memória principal, a controladora DMA gera uma interrupção para o Sistema Operacional, que ao ser iniciado já encontra o dado em memória principal.

Segundo Oliveira, a técnica de DMA é mais eficiente quando a operação de entrada e saída envolve a leitura ou escrita de muitos dados, como exemplo, uma leitura de disco. Nem todos os computadores utilizam a técnica de DMA. A justificativa disso é o fato de que a CPU, comumente, é bem mais rápida que a controladora DMA e pode fazer o trabalho de cópia de dados para a memória muito mais rápida.

3 Princípios de Software de E/S O software de entrada e saída, comumente, é organizado em uma estrutura de

camadas, no qual as camadas mais baixas têm como principal função esconder das camadas mais altas as peculiaridades do hardware. Já as camadas mais altas têm como principal função apresentar uma interface amigável e simples para o usuário final.

Algumas metas de software de entrada e saída podem ser apontadas: Independência de dispositivo: deve ser possível escrever programas que

podem, por exemplo, lê arquivos de qualquer dispositivo.


46

Atribuição uniforme de nomes: o nome de um arquivo ou de um dispositivo não pode depender do dispositivo.

Tratamento de erros: os erros devem ser tratados o mais perto possível do hardware.

Transferências síncronas ou assíncronas: a maior parte dos dispositivos de E/S são assíncronos e os programas dos usuários são mais fáceis de implementar através de bloqueios. Assim o Sistema Operacional deve fazer com que as operações pareçam, de fato, com bloqueios para os programas do usuário.

Dispositivos compartilháveis ou dedicados: O Sistema Operacional deve ser capaz de tratar dispositivos tanto dedicados como compartilhados de uma maneira que não gere problemas.

Manipuladores de Interrupções As interrupções devem ser escondidas do sistema. O ideal é bloquear um

processo que inicia uma operação de E/S e mantê-lo bloqueado até que a operação de E/S complete e a interrupção tenha ocorrido. O importante a se saber é que quando uma interrupção é gerada, o processo é desbloqueado, passando para um estado capaz de ser executado.

Drivers de Dispositivos O driver de dispositivo (device driver) é composto de um conjunto de módulos

de software cada um implementado para fornecer mecanismos de acesso a um dispositivo de entrada e saída específico. Assim, cada driver de dispositivo trata de um tipo de dispositivo ou de uma classe de dispositivos correlacionados.

De modo geral, um driver é responsável por aceitar uma solicitação abstrata (por exemplo, ler alguma informação) e cuidar para que esta solicitação seja atendida. Assim o driver de um dispositivo tem o conhecimento de como funciona a controladora funciona.

Software de E/S Independente de Dispositivo A principal função do software de E/S independente de dispositivo é executar

funções que são comuns para vários dispositivos e oferecer uma interface uniforme para o software de nível de usuário.

Segundo Oliveira, podemos enumerar alguns serviços sob responsabilidade dessa camada:

Nomeação de Dispositivo: Cada dispositivo deve receber um nome lógico e ser identificado a partir dele.

Buferização: Buffer é uma zona de memória temporária utilizada para armazenar dados enquanto eles estão sendo transferidos entre as diferentes camadas do software de E/S.

Cache de Dados: Armazenar na memória um conjunto de dados que estão sendo frequentemente utilizados.

Alocação e Liberação: Devido a alguns dispositivos admitirem, no máximo, um usuário por vez, o software de E/S deve gerenciar a alocação, liberação e uso destes dispositivos.

Tratamento de Erros: o software de E/S deve fornecer mecanismos de manipulação de erros, informando à camada superior o sucesso ou fracasso de uma operação.


47

Software de E/S de Nível de Usuário A visão dos dispositivos de E/S para o usuário consiste de bibliotecas

vinculadas em programas de usuários. Essas bibliotecas são fornecidas pelas linguagens de programação e podem ser utilizadas pelos usuários e ligadas com seus programas para compor o arquivo executável.

As funções de entrada e saída são dependentes e específicas de cada linguagem de programação. Por exemplo, na linguagem C as funções printf e scanf são utilizadas para impressão formatada e leitura, respectivamente. As bibliotecas de entrada e saída não fazem parte do núcleo do Sistema Operacional. Elas são associadas às várias linguagens de programação.


48

EXERCICIO 1) Qual o papel do Sistema Operacional com relação aos dispositivos de

entrada e saída? 2) Diferencie a visão do engenheiro elétrico e do programador quanto ao

hardware de entrada e saída. 3) Como são caracterizados os dispositivos de E/S de bloco e de caractere.

4) Qual a função dos Drivers de Dispositivos ? 5) Como funciona as controladoras que suportam DMA. 6) Aponte as metas de software de E/S, explicando cada uma. 7) Qual a principal função do software de E/S independente de dispositivo?


49

GERENCIAMENTO DE MEMÓRIA

1 Introdução Historicamente, a memória principal sempre foi vista como um recurso escasso

e caro. Uma das maiores preocupações dos projetistas foi desenvolver sistemas operacionais que não ocupassem muito espaço de memória e, ao mesmo tempo, otimizassem a utilização dos recursos computacionais. Mesmo atualmente, com a redução do custo e o aumento considerável da capacidade da memória principal, seu gerenciamento é dos fatores mais importantes no projeto e implementação dos sistemas operacionais.

O Sistema Operacional tem como principal função gerenciar a hierarquia de memória. A parte do SO responsável por essa função é chamada de gerenciamento de memória. Entre as funções do gerenciador de memória está em controlar as partes de memória utilizada e as partes não utilizadas, alocar (disponibilizar) memória para os processos, desalocar (retirar) memória de processos e gerenciar a troca entre memória principal (primária) e memória secundária.

Hierarquia de Memória

Basicamente, o gerenciamento da memória é a ferramenta utilizada para

permitir aos programas em execução no computador utilizarem a memória do computador para armazenar as instruções e dados que serão manipulados.

Os principais objetivos a serem alcançados no gerenciamento da memória são: Oferecer uma área de armazenamento para os processos serem

executados;


50

Proteger a execução dos processos contra eventuais falhas causadas por erro em um determinado processo;

Criar um ambiente de execução com desempenho satisfatório aos usuários;

Além dessas características, adicionalmente deseja-se de um bom gerenciador: Compartilhamento da memória entre os processos (em sistemas

avançados); Permitir aos programadores desenvolverem programas que tenham um

acesso transparente à memória do computador. Nos sistemas operacionais modernos, o gerenciamento da memória realizará

essas tarefas através da Proteção da Memória.

2. Gerenciamento Básico de Memória O esquema mais simples de gerenciamento de memória foi implementado nos

primeiros Sistemas Operacionais, porém ainda está presente em alguns sistemas monoprogramáveis. Este esquema é chamado por alguns autores como alocação contígua.

Basicamente, a memória principal disponível é dividida entre o Sistema Operacional e o programa em execução. Como este esquema de gerenciamento é utilizado em sistemas monoprogramáveis, temos apenas um processo em execução por vez.

Esquema Básico de gerenciamento de memória

Neste tipo de gerenciamento, o usuário tem acesso a toda memória principal,

inclusive o espaço do Sistema Operacional. É possível proteger a área de memória do Sistema Operacional utilizando registradores delimitadores de área de usuário e do SO.Assim, os programas estão limitados ao tamanho de memória principal disponível. Uma técnica conhecida como overlay, permite que um programa seja dividido em módulos, de forma que seja possível a execução independente de cada módulo, utilizando uma mesma área de memória.


51

3. Gerencia de Memória para Multiprogramação Atualmente, os sistemas multiprogramáveis são amplamente mais utilizados do

que os sistemas monoprogramáveis, devido a maior eficiência do uso do processador, pois permitem que múltiplos processos executem simultaneamente.

A forma mais simples de gerenciar memória em sistemas multiprogramáveis é dividindo a memória principal em partições estáticas e com tamanhos definidos, estabelecidas na fase de inicialização do sistema. Esse tipo de gerência é chamado por alguns autores por alocação particionada estática ou alocação fixa.

Quando um processo chega, ele é colocado em uma fila de entrada da partição menor capaz de armazená-lo. Como o esquema prevê que a partição é fixa, se o processo não ocupar o espaço total da sua partição, o resto de espaço é desperdiçado.

Esquema de gerencia de memória para multiprogramação com Partições Fixas.

Assim, os programas eram carregados em uma partição específica. Em algumas

situações, é possível que uma determinada fila exista uma quantidade grande de processos esperando pela partição enquanto que em outras filas de partição não exista nenhum processo. Isso era uma grande desvantagem para o sistema.

Por exemplo, na Figura acima podemos verificar que a partição 4 possui três

processos em espera, enquanto que na partição 2 não existe nenhum processo. Essa partição poderia, assim, ser utilizado por um desses processos na fila.

Dessa forma, uma solução para tentar contornar esse problema é implementar este método com uma única fila. Assim, quando uma determinada partição estivesse livre, o processo mais próximo do início da fila que melhor se ajusta à essa partição poderia ser carregado nela. Este método é mostrado na Figura abaixo.


52

Método de partições fixas com única fila.

Este método de gerência de memória baseado em partições fixas, de uma forma

ou de outra, gera um grande desperdício de memória, posto que, um processo ao ser carregado em uma partição, se ele não ocupa todo o seu espaço, o restante não poderá ser utilizado por nenhum outro processo.

Para evitar esse desperdício, foi desenvolvido um esquema de gerenciamento e alocação de memória dinamicamente, dependendo da necessidade do processo. Este esquema é conhecido como alocação com partições variáveis.

Alocação com Partições Variáveis Quando o método de alocação de partições variáveis é utilizado, o tamanho das

partições de memória é ajustado dinamicamente à medida que os processos vão chegando.

Nesse tipo de esquema, o processo utilizará um espaço de memória necessário, tornando esse espaço sua partição. Isto resolve o problema da fragmentação, pois as partições passarão a ser definidas a partir da alocação dos processos na memória.

O método é bem simples. Observe através da Figura abaixo, que um processo A ao chegar, é carregado na memória e o seu tamanho define do tamanho da sua partição. O processo B e C, de forma análoga, são carregados no espaço livre, ainda disponível. Ao chegar o processo D, não existe espaço livre contínuo suficiente para ele ser carregado.


53

Esquema de Alocação com Partições Variáveis.

Note que, para inserir o novo processo D na memória foi preciso retirar o

processo A, a fim de o espaço de memória suficiente seja disponibilizado para o novo processo. Assim, o processo A é atualizado em disco e o processo D é carregado em memória principal, podendo executar suas atividades.

Este processo de retirar um processo de memória, atualizar em disco e colocar outro no lugar é chamado, segundo Tanenbaum, por método de Troca.

A troca consiste em trazer um processo inteiro, executa-lo temporariamente e,

então, devolve-lo ao disco. Isto acontece quando a memória principal disponível é insuficiente para manter todos os nossos processos carregados (situação que seria a ótima).

Existe outra estratégia, que permite que apenas parte do programa fique em memória principal. Esta estratégia, bem mais complexa que a troca, é conhecida como Memória Virtual.

O método de alocação dinâmica da partição é bem mais flexível que o método de alocação estática. Porém, essa flexibilidade também complica mais a tarefa de alocar e desalocar a memória, assim como a monitoração da memória utilizada. O Sistema Operacional tem a função de gerenciar essa memória. De modo geral, há duas maneiras de monitorar o uso da memória: através do mapa de bits e listas encadeadas.

Gerenciamento de Memória com Mapa de Bits Com o mapa de bits, a memória é dividida em unidades de alocação e para

cada unidade é associado um bit no mapa. Se este bit estiver com valor 0 implica que esta unidade de alocação está vazia. Se este bit estiver com valor 1 implica que esta unidade de alocação está preenchida por algum processo.

Através da Figura abaixo é mais fácil compreender como essa estratégia de gerenciamento funciona. Considere a memória, particionada em XX unidades de


54

alocação, com processos e espaços vazios (lacunas). O mapa de bits dessa memória será configurado como mostrado na figura.

Memória dividida em unidade de alocação e o Mapa de bits correspondente

O ponto crucial do mapa de bits é a definição do tamanho da unidade de

alocação. Se ele for muito pequeno, o mapa de bits poderá ser muito grande. Se a unidade for muito grande, o mapa de bits será menor, mas uma quantia de memória poderá ser desperdiçada na última unidade se o tamanho do processo não for um múltiplo exato da unidade de alocação.

Gerenciamento de Memória com Listas Encadeadas Outra estratégia é manter uma lista encadeada dos segmentos de memória

alocados e livres, onde um segmento pode ser um processo ou lacuna entre dois processos.

Assim, cada nó da lista seria formado por uma entrada especificando se é um processo (P) ou uma lacuna (L), o endereço de onde se inicia a quantidade de unidades de alocação e um ponteiro para a próxima entrada. A Figura abaixo ilustra a mesma memória gerenciada através de listas encadeadas.

Memória dividida em unidade de alocação, monitorada através de lista encadeada


55

Memória Virtual Em 1961, Fotheringham desenvolveu um método conhecido como memória

virtual. O principal objetivo desta técnica é estender a memória principal através de memória secundária, dando impressão ao usuário que ele tem a disposição uma quantidade de memória maior do que a memória real disponível. Em outras palavras, para facilitar o entendimento, a técnica de memória virtual disponibiliza para o usuário uma memória de trabalho maior do que a memória principal (RAM). Esse espaço de memória adicional implementado em disco é conhecido como memória de swap.

Os primeiros sistemas operacionais implementavam técnicas rudimentares de memória virtual, que em comparação com os sistemas proprietários, em que os programas gerenciavam sua própria memória, tinham um desempenho abaixo do desejado para justificar uma substituição. Foi a IBM no final da década de 1960 que oficializou a adoção da memória virtual nos computadores ao lançar alguns modelos que utilizavam esse recurso. A partir de então, todas as empresas passaram a implantar nos sistemas operacionais a capacidade de gerenciamento da memória através da Memória Virtual.

A utilização de memória virtual em um sistema computadorizado depende principalmente da arquitetura do computador, mais especificamente, do modo de endereçamento de memória utilizado pelo processador. A Intel, desenvolvedora dos processadores Pentium, adotou o recurso de memória virtual em seus processadores em 1982 com o lançamento do modelo 80286. A Microsoft passou a utilizar o recurso de memória virtual apenas em 1990, no lançamento do MS-Windows 3.

Ilustração do método de memória virtual.

Assim, o Sistema Operacional deve manter parte do programa que está em uso na memória principal e parte dele na memória swap. Na multiprogramação, partes de vários processos podem ser mantidas em memória principal e partes em memória swap.


56

Paginação Segundo Silberstchaz, a paginação é um esquema de gerenciamento de

memória em que o espaço de endereçamento físico (endereços de memória principal) de um processo não é contíguo. A paginação, assim, evita o problema da fragmentação externa gerado pela alocação de memória dinâmica.

Os programas são capazes de gerar endereços, chamados de endereços virtuais. Esse conjunto de endereços forma o que chamamos de espaço de endereçamento virtual.

Em sistemas que não utilizam a técnica de memória virtual, o endereço virtual equivale ao endereço físico, especificando exatamente onde o programa será armazenado na memória principal.

Em computadores que utilizam a técnica de memória virtual, os endereços virtuais não vão diretamente para o barramento de memória. Primeiramente, ele passa por uma unidade chamada de Unidade de Gerenciamento de Memória (MMU – Memory Management Unit). A MMU tem como função mapear um endereço virtual para um endereço lógico. Adiante, o espaço de endereçamento virtual é dividido em unidade chamadas de páginas.

A memória principal também é dividida em unidades, do mesmo tamanho das páginas, chamadas de molduras de página (quadro). Assim, num sistema que contém páginas de 4k, as molduras também serão de 4k.

Considere a Figura abaixo, com o espaço de endereço virtual formado de 64k e o a memória física de 32k, com páginas de molduras de 4k.Note através da figura, que temos 16 páginas virtuais e 8 molduras de páginas. Quando um programa tenta acessar um endereço virtual, este é passado para a MMU, que vai analisar o mapeamento deste endereço e descobrir a qual moldura pertence. A MMU mapeia este endereço virtual para o endereço físico, que, por fim, é colocado no barramento de memória.

Técnica de Paginação


57

EXERCICIO

1. Qual a função do gerenciador de memória de um Sistema Operacional. 2. Como funciona o gerenciamento básico de memória. 3. Como funciona o gerenciamento de memória para multiprogramação por

alocação particionada estática. 4. Explique a técnica overlay 5. Como funciona o gerenciamento de memória para multiprogramação por

alocação com partições variáveis e qual sua vantagem com relação às partições fixas. 6. Diferencie as abordagens de gerenciamento de memória baseado por

troca e memória virtual. 9. Quais os benefícios oferecidos pela técnica de memória virtual? Como este

conceito permite que um programa e seus dados ultrapassem os limites da memória principal?

10. Defina Paginação 11. Explique o gerenciamento de memória com mapa de bits.


58

ATIVIDADE PRÁTICA

1) Espaço de Endereçamento Virtual a) Práticas de simulação Execute o simulador SOsim e configure-o para trabalhar com

Escalonamento Circular: janela Console SOsim / Opções / Parâmetros do Sistema na guia Processador.

Configure a política de busca de páginas sob demanda: janela Console SOsim / Opções / Parâmetros do Sistema na guia Memória.

Re-inicie o simulador SOsim para que a nova parametrização passe a ser válida.

b) Análise Prática Crie dois processos CPU-bound: janela Gerência de Processos / Criar – janela

Criação de Processos / Criar. Ative a janela Contexto do Processo para visualizar a tabela de páginas do

processo criado: Gerência de Processos / PCB na guia Tab. de Pag. Na janela Gerência de Memória observe a alocação dos frames na memória

principal. Na janela Contexto do Processo observe as alterações nas tabelas de páginas

dos dois processos navegando com as setas inferiores. c) Questões teóricas para responder com a ajuda do simulador Qual o espaço de endereçamento real máximo de um processo? Qual o espaço de endereçamento real mínimo de um processo? Qual o tamanho da página virtual?


59

GERENCIA DE ARQUIVOS

1. Introdução aos Sistemas de Arquivos O sistema de Arquivo é o modo como o sistema operacional organiza o acesso

aos arquivos e pastas no computador. Cada sistema de arquivo tem uma característica particular, mas em geral, seu propósito é criar abstração necessária para dar acesso físico aos dispositivos e permitir que sejam gravadas/lidas informações nele.( MARCOS AURELIO LAUREANO/Diogo Roberto Olsen,LIVRO TECNICO )

Segundo Tanenbaum, existem três requisitos essenciais para o armazenamento

de informação por longo prazo: Deve ser possível armazenar uma grande quantidade de

informação; A informação deve sobreviver ao término do processo que a usa; Múltiplos processos têm de ser capazes de acessar a informação

concorrentemente. A solução encontrada usualmente para o armazenamento de informações é

utilizar mídias externas e distintas da memória principal (volátil) em unidades chamadas arquivos, de modo que essas informações devem ser armazenadas de forma persistente, ou seja, não pode ser afetada pela criação e término de um processo. Assim, um arquivo só irá ser destruído quando seu proprietário removê-lo explicitamente. (ERICO MENESES LEÃO, SISTEMAS OPERACIONAIS)

Arquivo

Um arquivo é basicamente um conjunto de dados armazenados em um

dispositivo físico não-volátil, com um nome ou outra referência que permita sua localização posterior. Do ponto de vista do usuário e das aplicações, o arquivo é a unidade básica de armazenamento de informação em um dispositivo não-volátil, pois para eles não há forma mais simples de armazenamento persistente de dados. Arquivos são extremamente versáteis em conteúdo e capacidade: podem conter desde um texto ASCII com alguns bytes até sequências de vídeo com dezenas de gigabytes, ou mesmo mais (Carlos Alberto Maziero,Sistemas Operacionais: Conceitos e Mecanismos)

. Como um dispositivo de armazenamento pode conter milhões de arquivos, estes são organizados em estruturas hierárquicas denominadas diretórios.

A organização física e lógica dos arquivos e diretórios dentro de um dispositivo é denominada sistema de arquivos.

Um sistema de arquivos pode ser visto como uma imensa estrutura de dados armazenada de forma persistente em um dispositivo físico. Existe um grande número de sistemas de arquivos, dentre os quais podem ser citados o NTFS (nos sistemasWindows),Ext2/Ext3/Ext4 (Linux), HPFS (MacOS), FFS (Solaris) e FAT (usado em pendrives USB,máquinas fotográficas digitais e leitores MP3).


60

Nomeação de Arquivos Segundo Tanenbaum, o arquivo é um mecanismo de abstração, no qual oferece

meios de armazenar informações no disco e lê-las posteriormente. A característica mais importante de qualquer mecanismo de abstração é o modo como os objetos são gerenciados e nomeados, isto é, a nomeação de arquivos.

Um processo ao criar um arquivo, atribui um nome a ele e quando o processo termina, este arquivo continua existindo,possibilitando que outros processos possam ter acesso a ele simplesmente buscando por seu nome.

As regras de nomeação de arquivos variam de sistema para sistema, porém, como característica comum, todos os Sistemas Operacionais atuais permitem cadeias de caracteres de um até oito letras como nomes válidos de arquivos. Alguns Sistemas de Arquivos permite a utilização de caracteres especiais, outros não; alguns Sistemas de Arquivos permitem nomes com tamanhos até 255 caracteres; alguns Sistemas de Arquivos fazem distinção entre letras maiúsculas e minúsculas (case sensitive), como exemplo o Sistema de Arquivo do Unix, enquanto que outros não diferenciam,como exemplo o Sistema de Arquivo do MS-DOS e do Windows.

A maioria dos Sistemas Operacionais (na verdade, o Sistema de Arquivo do SO) suporta nomes de arquivos de duas partes, separados por um ponto. A parte após o ponto é chamada de extensão do arquivo e o conteúdo do arquivo. Essa extensão, em alguns Sistemas Operacionais, é utilizada para atribuir qual programa deve abrir aquele arquivo em específico.

Exemplos : arquivo.c – Arquivo fonte em C arquivo.mp3- Arquivo de música arquivo.dll-Biblioteca dinâmica Estruturas de Arquivos Segundo Tanenbaum, os arquivos podem ser estruturados, basicamente, através

de três maneiras, como visualizados na Figura abaixo

Estrutura de Arquivo


61

Seqüência de bytes não-estruturada: Nessa estrutura o SO não sabe o que o arquivo contém e tudo que ele enxerga é uma sequência de bytes. Tal estratégia apresenta uma máxima flexibilidade, uma vez que os programas dos usuários podem pôr qualquer coisa que queiram em seus arquivos e chamá-los do nome que lhes convier.

�Seqüência de registro de comprimento fixo: Um arquivo é uma seqüência de registros de tamanho fixo, cada um com alguma estrutura interna. A idéia central é que a operação de leitura retorna um registro e a operação de escrita sobrepõe ou anexa um registro.

Árvore de Registros: Um arquivo é constituído de uma árvore de registros (não necessariamente do mesmo tamanho), cada um contendo um campo-chave em uma posição fixa no registro, na qual a árvore é ordenada pelo campo-chave para que se busque mais rapidamente por uma chave específica. Além disso, novos registros podem ser adicionados ao arquivo, decidindo o sistema operacional onde colocá-los. Este tipo de arquivo é amplamente aplicado em computadores de grande porte usados ainda para alguns processamentos de dados comerciais.

2 Tipos de Arquivos Vários tipos de arquivos são suportados pelos Sistemas Operacionais. Podemos

enumerar os principais tipos: Arquivos comuns: Arquivos que contêm informações do usuário. Diretórios: Arquivos do sistema que mantêm a estrutura do sistema de

arquivos. Arquivos especiais de caracteres: Arquivos relacionados à entrada e

saída e usados para modelar dispositivos de E/S. Arquivos especiais de blocos: arquivos usados para modelar discos. Os arquivos comuns (informações do usuário), em geral, são arquivos ASCII

ou arquivos binários. Os arquivos ASCII são constituídos de linhas de texto, possuindo como grande vantagem o fato de que eles podem ser mostrados e impressos como são e poder ser editados com qualquer editor de textos. Além disso, facilita a conexão entre a saída de um programa e a entrada de outro. Já os arquivos binários, em geral, possuem alguma estrutura interna, conhecida pelos programas que os usam.

Todo Sistema Operacional deve reconhecer pelo menos um tipo de arquivo: seu próprio arquivo executável.

3 Atributos Conforme apresentado, um arquivo é uma unidade de armazenamento de

informações que podem ser dados, código executável, etc. Cada arquivo é caracterizado por um conjunto de atributos, que podem variar de acordo com o sistema de arquivos utilizado.

Os atributos mais usuais são: Nome: string de caracteres que identifica o arquivo para o usuário, como

“foto1.jpg”, “relatório.pdf”, “hello.c”, etc.;


62

“Tipo: indicação do formato dos dados contidos no arquivo, como áudio, vídeo, imagem, texto, etc”. Muitos sistemas operacionais usam parte do nome do arquivo para identificar o tipo de seu conteúdo, na forma de uma extensão: “.doc”, “.jpg”, “.mp3”, etc.;

Tamanho: indicação do tamanho do conteúdo do arquivo, em bytes ou registros;

Datas: para fins de gerência, é importante manter as datas mais importantes relacionadas ao arquivo, como suas datas de criação, de último acesso e de última modificação do conteúdo;

Proprietário: em sistemas multi-usuários, cada arquivo tem um proprietário, que deve estar corretamente identificado;

Permissões de acesso: indicam que usuários têm acesso àquele arquivo e que formas de acesso são permitidas (leitura, escrita, remoção, etc.);

Localização: indicação do dispositivo físico onde o arquivo se encontra e da posição do arquivo dentro do mesmo;

Outros atributos: vários outros atributos podem ser associados a um arquivo, por exemplo, para indicar se é um arquivo de sistema, se está visível aos usuários, se tem conteúdo binário ou textual, etc. Cada sistema de arquivos normalmente define seus próprios atributos específicos, além dos atributos usuais.

3 Operações As aplicações e o sistema operacional usam arquivos para armazenar e

recuperar dados. O uso dos arquivos é feito através de um conjunto de operações, geralmente implementadas sob a forma de chamadas de sistema e funções de bibliotecas. As operações básicas envolvendo arquivos são:

Criar: a criação de um novo arquivo implica em alocar espaço para ele no dispositivo de armazenamento e definir seus atributos (nome, localização, proprietário, permissões de acesso, etc.);

Abrir: antes que uma aplicação possa ler ou escrever dados em um arquivo, ela deve solicitar ao sistema operacional a “abertura” desse arquivo. O sistema irá então verificar se o arquivo existe verificar se as permissões associadas ao arquivo permitem aquele acesso, localizar seu conteúdo no dispositivo de armazenamento e criar uma referência para ele na memória da aplicação;

Ler: permite transferir dados presentes no arquivo para uma área de memória da aplicação;

Escrever: permite transferir dados na memória da aplicação para o arquivo no dispositivo físico; os novos dados podem ser adicionados no final do arquivo ou sobrescrever dados já existentes;

Mudar atributos: para modificar outras características do arquivo, como nome, localização, proprietário, permissões, etc.

Fechar: ao concluir o uso do arquivo, a aplicação deve informar ao sistema operacional que o mesmo não é mais necessário, a fim de liberar as estruturas de gerência do arquivo na memória do núcleo;

Remover: para eliminar o arquivo do dispositivo, descartando seus dados e liberando o espaço ocupado por ele.


63

Além dessas operações básicas, outras operações podem ser definidas, como copiar, mover ou renomear arquivos. Todavia, essas operações geralmente podem ser construídas usando as operações básicas.

4 Implementação de Arquivos A criação de arquivos exige que o sistema operacional tenha controle de quais

áreas ou blocos no disco estão livres. É importante o controle de quais blocos de discos estão relacionados a quais arquivos. Este gerenciamento pode ser feito, principalmente de varias formas: Alocação contígua, alocação por lista encadeada, alocação indexada e alocação combinada.

Alocação Contígua Consiste em armazenar um arquivo em blocos sequencialmente

dispostos.Neste tipo, o sistema localiza um arquivo através do endereço do primeiro bloco e da sua extensão em blocos.

Este tipo de alocação apresenta duas vantagens significativas. É bastante simples de implementar e de realizar o controle sobre os onde

os blocos estão. O desempenho de leitura é excelente, pois todo o arquivo pode ser lido

em uma única operação a partir do primeiro bloco de dados. Arquivos Início #blocos acorde.txt 010 003 prova.doc 002 008 Aula.pdf 017 005

Quando o sistema operacional deseja alocar espaço para um novo arquivo,

pode existir mais de um segmento livre disponivél com o tamanho exigido e é necessario que alguma estrategia de alocação seja adotada para selecionar qual segmento deve ser escolhido. Algumas estratégias podem ser utilizadas :

First-fit: O primeiro segmento livre com tamanho suficiente para alocar

o arquivo é selecionado . A busca na lista é sequencial, sendo interrompida tão logo se encontre o segmento adequado.

Best-fit: Seleciona o menor segmento livre disponível com tamanho

suficiente para armazenar o arquivo.


64

Worst-fit: O maior segmento é alocado e a busca por toda a lista se faz necessária, a menos que haja uma ordenação por tamanho

No entanto este tipo de implementação apresenta uma grande problema:

Fragmentação do disco. Como os arquivos podem ser criados e eliminados frequentemente, os segmentos livres vão se fragmentando em pequenos pedaços por todo o disco. O problema pode tornar-se crítico quando um disco possui blocos livres disponíveis, porém não existe um segmento contíguo em que o arquivo possa ser alocado.

Como alocar um arquivo com 4 blocos ?


65

O problema da fragmentação pode ser contornado através de rotinas que reorganizem todos os arquivos no disco de maneira que só exista um único segmento de blocos livres. Este procedimento, denominado desfragmentação.

A desfragmentação tem por objetivo reorganizar os arquivos no disco para que haja um unico segmento de blocos livres .Isto exige um grande numero de tempo e tem efeitos temporarios

Alocação por Lista Encadeada O arquivo é organizado como um conjunto de blocos ligados no disco.

Independente de sua localização física cada bloco deve possuir um ponteiro para o bloco seguinte.

Arquivos Início #blocos acorde.txt 010 003 prova.doc 002 008 Aula.pdf 017 005


66

A principal vantagem de se utilizar a alocação por lista encadeada está no fato de evita o grande desperdício em disco, comum na alocação contígua. Além disso, para acessar todo o arquivo é suficiente armazenar apenas o endereço de disco do primeiro bloco.

Porém, a principal desvantagem da utilização desse método é que o acesso aleatório é extremamente lento. Além disso, considerando que cada bloco terá que guardar o endereço do bloco seguinte, existe um gasto de memória adicional.

1.2.3. Alocação por Lista Encadeada Usando Índice

Neste tipo de alocação ocorre a existência de ponteiros indexando todos os blocos de arquivos em uma única estrutura denominada bloco de índice ou nó-índice (inode). Permite o acesso direto aos blocos de arquivo e não utiliza informações de controle nos blocos de dados como na alocação encadeada.

Arquivos Início #blocos acorde.txt 010 003 prova.doc 002 008 Aula.pdf 017 005


67

5 Diretórios A quantidade de arquivos em um sistema atual pode ser muito grande,

chegando facilmente a milhões deles em um computador desktop típico, e muito mais em servidores. Embora o sistema operacional possa tratar facilmente essa imensa quantidade de arquivos, essa tarefa não é tão simples para os usuários: identificar e localizar de forma inequívoca um arquivo específico em meio a milhões de outros arquivos pode ser impraticável. Para permitir a organização de arquivos dentro de uma partição, são usados diretórios. (Sistemas Operacionais: Conceitos e Mecanismos, Prof. Carlos Alberto Maziero)

Um diretório, também chamado de pasta (folder), representa um contêiner de informações, que pode conter arquivos ou mesmo outros diretórios. Da mesma forma que os arquivos, diretórios têm nome e atributos, que são usados na localização e acesso aos arquivos neles contidos. Cada espaço de armazenamento possui ao menos um diretório principal, denominado diretória raiz (root directory).

Em sistemas de arquivos mais antigos e simples, o diretório raiz de um volume estava definido em seus blocos de inicialização, normalmente reservados para informações de gerência. Todavia, como o número de blocos reservados era pequeno e fixo, o número de entradas no diretório raiz era limitado.

Nos sistemas mais recentes, um registro específico dentro dos blocos de inicialização aponta para a posição do diretório raiz dentro do sistema de arquivos, permitindo que este tenha um número muito maior de entradas.

O uso de diretórios permite construir uma estrutura hierárquica (em árvore) de armazenamento dentro de um volume, sobre a qual os arquivos são distribuídos.

Os primeiros sistemas de arquivos implementavam apenas o diretório raiz, que continha todos os arquivos do volume. Posteriormente, ofereceram subdiretórios, ou seja, um nível de diretórios abaixo do diretório raiz.

Os sistemas atuais oferecem uma estrutura muito mais flexível, com um número de níveis de diretório muito mais elevado, ou mesmo ilimitada (como no NTFS e no Ext3).A implementação de diretórios é relativamente simples: um diretório é implementado como um arquivo estruturado, cujo conteúdo é uma relação de entradas.

Figura 1 Projeto de Sistema de Arquivo hierárquico


68

Nomes de Caminhos Quando organizamos um Sistema de arquivos baseado em uma árvore de

diretórios, torna-se necessário uma forma de especificar o nome dos arquivos, e para isso são usados, comumente, dois métodos: nome de caminho absoluto e nome de caminho relativo.

Um nome de caminho absoluto é formado pelo caminho entre o diretório-raiz e o arquivo específico. Os nomes de caminhos absolutos sempre iniciam no diretório-raiz e são únicos.

Em Sistemas de Arquivos do Windows os componentes do caminho são separados por \. Já em Sistemas de Arquivos do Unix são separados por /.

Já o nome de caminho relativo é utilizado em conjunto com o conceito de diretório de trabalho (também chamado diretório atual).

Assim, um usuário pode designar um diretório de trabalho específico e quaisquer nomes de caminhos que não comecem a partir do diretório-raiz são interpretados em relação ao diretório do trabalho.

Como exemplo, imagine que o diretório de trabalho de um usuário UNIX seja /home/usuário, então o arquivo, cujo nome de caminho absoluto seja /home/usuário/arquivo.txt pode, simplesmente, ser interpretado como arquivo.txt.

Cada processo possui seu próprio diretório de trabalho. Dessa forma, quando um processo altera seu diretório de trabalho e depois sai, nenhum outro processo é afetado e nenhum vestígio da mudança é deixado no sistema de arquivos. Por outro lado, procedimentos de bibliotecas raramente alteram o diretório de trabalho e, quando precisam fazê-lo, eles sempre voltam para onde estavam, se não o resto do programa poderá não funcionar.

A maioria dos Sistemas Operacionais que suportam um sistema de diretório hierárquico tem duas entradas especiais em cada diretório: ponto (.) e o ponto-ponto (..). O ponto refere-se ao diretório atual, enquanto que o ponto-ponto refere-se ao diretório pai (diretório anterior). Como exemplo, se um usuário tiver trabalhando no diretório /home/usuário, caso utilize o ponto-ponto, ele estará subindo na árvore de diretórios, ou seja, referenciando o diretório /home. Se ele utilizar o ponto, estará referenciando o próprio diretório (/home/usuário).

Operações com Diretórios Como os arquivos, existem diversas chamadas ao sistema para gerenciar

diretórios, que, também, variam de sistema para sistema. As operações mais importantes são:

Criar: utilizado para criar um determinado diretório. Inicialmente é criado um diretório vazio, contendo apenas o ponto e o ponto-ponto.

Apagar: operação utilizada para apagar um determinado diretório. Normalmente, só é possível excluir um diretório vazio.

Abrir diretório: a partir desta operação é possível abrir um diretório. Antes de ler um diretório é preciso, inicialmente, abri-lo.

Fechar diretório: operação utilizada para fechar um diretório. Ler: esta chamada é utilizada para ler o conteúdo de um diretório. Renomear: fornece a possibilidade de alterar o nome do diretório.


69

EXERCÍCIO

1. Qual a função de um sistema de gerenciamento de arquivos em um Sistema Operacional.

2. O que são arquivos e diretórios. 3. Aponte as principais características de nomeação de arquivos. 4. Como os arquivos podem ser estruturados. 5. Enumere os principais atributos de um arquivo. 6. Enumere as principais operações com arquivos, explicando-as. 7. Como é caracterizado a implementação de um arquivo a partir de

alocação contígua. 8. Como é caracterizado a implementação de um arquivo a partir de listas

encadeadas. 9. O que muda na implementação de arquivos a partir de listas encadeadas com

índice.


70

REFERENCIAS BIBLIOGRÁFICAS

TANEMBAUM,A.S. Sistemas Operacionais Modernos .2ª edição . São Paulo,Ed.Prentice Hall,2003 LEÃO,Erico Meneses : Sistemas Operacionais .Universidade Aberta do Brasil OLSEN .Diogo Roberto .Sistemas Operacionais/ LAUREANO.Marcos Aurélio.-Curitiba: Editora do Livro Técnico .2010 Maziero, Carlos Alberto. Sistemas Operacionais Conceitos Básicos .2011 Machado, Francis B. Arquitetura de Sistemas Operacionais.Ed. LTC Abraham Silberschatz .Sistemas Operacionais: Conceitos e Aplicações.Ed. Campus Tanenbaum , A.S. Sistemas Operacionais Modernos .Ed. Campus A evolução dos sistemas operacionais-Traduzido e adaptado por Raimundo G Nóbrega Filho o texto Operating Systems: Design And Implementation,Andrew S. Tanenbaum - Editora Prentice Hall http://www.inf.ufes.br/~zegonc/material/Sistemas%20Operacionais/Introducao.pdf http://www.afms.com.br/sistemas_operacionais.html www.docstoc.com/.../Lista-de-Exercícios-respondida---Grupo-Educacion Simulador de Ensino para Sistemas Operacionais http://www.training.com.br/sosim/- http://www.ppgia.pucpr.br/_maziero

REFERENCIA SISTEMA DE ARQUIVO http://www.inf.unioeste.br/~marcio/SO/Aula9SistemadeArquivos.pdf REFERENCIA PROCESSOS http://docente.lages.ifsc.edu.br/juliano.goncalves/MaterialDidatico/Sistemas%20Operacionais/Exerc%C3%ADcios%20Revis%C3%A3o%20ProvaI.pdf http://dainf.ct.utfpr.edu.br/~maziero/lib/exe/fetch.php/so:filesystem.pdf http://www.cafw.ufsm.br/~roberto/?page_id=26 http://www.metropoledigital.ufrn.br/aulas/disciplinas/sist_operacional/aula_03.html

sistemas operacionais pronatec- prof. manoel

Technology