Sop Apostila

Faculdade Cenecista de Varginha - MG

FACECA

Bacharelado em Sistemas de Informação

Prof. José Eduardo S. Gomes Fevereiro / 2005

SUMÁRIO

Página

1. Sistemas Operacionais ......................................................................... 1 1.1. Conceitos Básicos de Sistema Operacional ..................................... 1 1.2. Máquina de Níveis ...................................................................... 2 1.3. Histórico .................................................................................... 3

1.3.1. Primeira Fase (1945-1955) ................................................. 3 1.3.2. Segunda Fase (1956-1965) ................................................. 3 1.3.3. Terceira Fase (1966-1980) ................................................. 3 1.3.4. Quarta Fase (1981-1990) ................................................... 4 1.3.5. Quinta Fase (1991-2000) ................................................... 4

1.4. Conceitos de Hardware e Software ................................................ 4 1.4.1. Conceitos de Hardware ....................................................... 5

1.4.1.1. Unidade Central de Processamento .............................. 5 1.4.1.2. Clock ....................................................................... 5 1.4.1.3. Registradores ........................................................... 5 1.4.1.4. Memória Principal ...................................................... 6 1.4.1.5. Memória Cachê ......................................................... 6 1.4.1.6. Memória Secundária .................................................. 6 1.4.1.7. Dispositivos de Entrada e Saída .................................. 6 1.4.1.8. Barramento .............................................................. 6 1.4.1.9. Pipeline ................................................................... 7 1.4.1.10. Ativação e Desativação do Sistema ............................ 7 1.4.1.11. Arquitetura RISC e CISC .......................................... 7

1.4.2. Conceitos de Software ........................................................ 7 1.4.2.1. Tradutor .................................................................. 8 1.4.2.2. Interpretador ............................................................ 8 1.4.2.3. Linker ...................................................................... 9 1.4.2.4. Loader ..................................................................... 9 1.4.2.5. Depurador ................................................................ 9 1.4.2.6. Linguagem de Controle .............................................. 9 1.4.2.7. Linguagem de Máquina .............................................. 9 1.4.2.8. Microprogramação ..................................................... 9

1.5. Tipos de Sistemas Operacionais .................................................... 10 1.5.1. Sistemas Monoprogramáveis/Monotarefa .............................. 10 1.5.2. Sistemas Multiprogramáveis/Multitarefa ............................... 10

1.5.2.1. Sistemas Batch ......................................................... 11 1.5.2.2. Sistemas de Tempo Compartilhado .............................. 11 1.5.2.3. Sistemas de Tempo Real ............................................ 11

1.5.3. Sistemas com Multiprocessadores ........................................ 11 1.5.3.1. Sistemas Fortemente Acoplados .................................. 12 1.5.3.2. Conceitos e Organização dos Sist. Fort. Acopl. ............. 12 1.5.3.3. Sistemas Fracamente Acoplados ................................. 13 1.5.3.4. Organização dos Sist. Fracamente Acoplados ................ 13

1.6. Sistemas Multiprogramáveis ......................................................... 14 1.6.1. Interrupção e Exceção ........................................................ 15 1.6.2. Operações de Entrada ........................................................ 16 1.6.3. Buffering .......................................................................... 17 1.6.4. Spooling ........................................................................... 18 1.6.5. Reentrância ...................................................................... 18 1.6.6. Proteção do Sistema .......................................................... 18

1.7. Estrutura do Sistema Operacional ................................................. 19 1.7.1. Núcleo do Sistema ou Kernel (cérebro) ................................. 19 1.7.2. System Calls ..................................................................... 19 1.7.3. Modos de Acesso ............................................................... 20 1.7.4. Estruturas de Sistemas Operacionais .................................... 21

1.7.4.1. Sistemas Monolíticos ................................................. 21 1.7.4.2. Sistemas em Camadas ............................................... 21 1.7.4.3. Sistemas Cliente/Servidor .......................................... 22

2. Processos ........................................................................................... 24 2.1. Introdução ................................................................................. 24 2.2. Modelo de Processo .................................................................... 24

2.2.1. Contexto de Hardware ........................................................ 25 2.2.2. Contexto de Software ......................................................... 25 2.2.3. Espaço de Endereçamento .................................................. 26

2.3. Estados do Processo ................................................................... 26 2.4. Mudanças de Estado do Processo .................................................. 27 2.5. Subprocesso e Thread ................................................................. 28 2.6. Processos do Sistema .................................................................. 28 2.7. Tipos de Processos ...................................................................... 29

3. Comunicação entre Processos ............................................................... 30 3.1. Introdução ................................................................................. 30 3.2. Especificação de Concorrência em Programas ................................. 30 3.3. Problemas de Compartilhamento de Recursos ................................. 32 3.4. Solução para Problemas de Compartilhamento ............................... 32 3.5. Problemas de Sincronização ......................................................... 33

3.5.1. Velocidade de Execução dos Processos ................................. 33 3.5.2. Starvation ........................................................................ 33 3.5.3. Sincronização Condicional ................................................... 33

3.6. Soluções de Hardware para o Problemas de Exclusão Mútua ............. 34 3.6.1. Desabilitação de Interrupções ............................................. 34 3.6.2. Instrução Test-and-Set ...................................................... 34

3.7. Soluções de Software para o Problemas de Exclusão Mútua .............. 35 3.7.1. Semáforos ........................................................................ 35 3.7.2. Monitores ......................................................................... 37 3.7.3. Troca de Mensagens .......................................................... 38

3.8. Deadlock ................................................................................... 38

4. Gerência do Processador ...................................................................... 39 4.1. Introdução ................................................................................. 39 4.2. Critérios de Escalonamento .......................................................... 39 4.3. Escalonamento Não-preemptivo ................................................... 40

4.3.1. Escalonamento First-In-First-Out (FIFO) ............................... 40 4.3.2. Escalonamento Shortest-Job-First (SJF) ................................ 40 4.3.3. Escalonamento Cooperativo ................................................ 40

4.4. Escalonamento Preemptivo .......................................................... 41 4.4.1. Escalonamento Circular ...................................................... 41 4.4.2. Escalonamento por Prioridades ............................................ 41 4.4.3. Escalonamento por Múltiplas Filas ........................................ 41 4.4.4. Escalonamento por Múltiplas Filas com Realimentação ............ 42 4.4.5. Escalonamento de Sistemas de Tempo Real .......................... 42

4.5. Escalonamento com Múltiplos Processadores .................................. 42

8. Bibliografia .............................................................................. Livros ................................................................................... Endereços Eletrônicos .............................................................

FACECA – Faculdade Cenecista de Varginha Sistemas de Informação

SOP – Sistemas Operacionais Prof. José Eduardo S. Gomes

1

1. Sistemas Operacionais

1.1. Conceitos Básicos de Sistema Operacional

Em torno de um computador, existem usuários com problemas para serem resolvidos. Por exemplo, um usuário precisa editar texto, enquanto outro precisa fazer a contabilidade da empresa. O problema de cada usuário será resolvido por um programa específico. No exemplo, um editor de textos e um sistema de contabilidade. O dispositivo físico capaz de executar esses programas é o hardware do computador.

Os programas possuem muito em comum. Por exemplo, tanto o editor de texto quanto a contabilidade precisam acessar o disco. A forma de acesso aos periféricos é a mesma para todos os programas. Para um melhor aproveitamento do hardware, vários usuários compartilham simultaneamente o computador. Entretanto, os programas podem apresentar necessidades conflitantes, pois disputam os recursos do equipamento. Por exemplo, o editor de texto e a contabilidade podem querer utilizar, ao mesmo tempo, a única impressora disponível.

O sistema operacional é uma camada de software colocada entre o hardware e os programas que executam tarefas para os usuários. Essa visão de um sistema computacional é ilustrada na figura abaixo. O sistema operacional é responsável pelo acesso aos periféricos. Sempre que um programa necessita de algum tipo de operação de entrada e saída, ele a solicita ao sistema operacional. Dessa forma, o programador não precisa conhecer os detalhes do hardware. Informações do tipo “como enviar um caractere para a impressora” ficam escondidas dentro do sistema operacional. Ao mesmo tempo, como todos os acessos aos periféricos são feitos através do sistema operacional, ele pode controlar qual programa está acessando qual recurso. É possível, então, obter uma distribuição justa e eficiente dos recursos. Por exemplo, a divisão do espaço em disco entre os usuários é feita pelo sistema operacional. Ela pode ser feita, considerando-se dois aspectos: a eficiência no acesso ao disco e a ocupação equilibrada do disco pelos usuários.



2

O sistema operacional não resolve os problemas do usuário final. Ele não

serve para editar texto, nem faz a contabilidade da empresa. Entretanto, através dele, podemos obter uma maior eficiência e conveniência no uso do computador. A eficiência é obtida através do compartilhamento dos recursos. A conveniência é obtida através de uma interface mais confortável para a utilização dos recursos computacionais.

Normalmente, o processador está executando programas de usuário. Para isso que o computador foi comprado. Somente quando ocorre algum evento especial, o sistema operacional é ativado. Dois tipos de eventos ativam o sistema operacional: uma chamada de sistema ou uma interrupção de periférico.

Uma chamada de sistema corresponde a uma solicitação de serviço por parte do programa em execução. Primeiramente, deve ser verificada a legalidade da solicitação. Por exemplo, um pedido para que arquivos de outros usuários sejam destruídos deverá ser recusado. No caso de uma solicitação legal, ela é realizada, e a resposta é devolvida ao programa.

Em função das chamadas de sistema, o sistema operacional envia comandos para os controladores dos periféricos. O controlador deve informar ao sistema operacional quando a operação estiver concluída. Isso é feito através de uma interrupção. Quando a interrupção acontece, o processador pára o que está fazendo e passa a executar uma rotina específica do sistema operacional. Como a interrupção do periférico avisa o término de alguma operação de entrada e saída, possivelmente uma chamada de sistema foi concluída. Nesse caso, um programa à espera de resposta poderá ser liberado.

Um sistema operacional (SO) é um conjunto de rotinas executadas pelo processador, da mesma forma que qualquer outro programa. Sua função principal é controlar o funcionamento do computador, como um gerente dos diversos recursos disponíveis no sistema.

Funções principais do SO:

Facilidade de acesso aos recursos do sistema Compartilhamento de recursos de forma organizada e protegida

1.2. Máquina de Níveis

Usuário Sistema Operacional

Hardware

Aplicativos Utilitários

Sistema Operacional Linguagem de Máquina

Microprogramação Dispositivos Físicos

Hardware



3

1.3. Histórico

A evolução dos SO está relacionada ao desenvolvimento dos equipamentos.

1.3.1. Primeira Fase (1945-1955)

Durante a Segunda Guerra. ENIAC – 18mil válvulas, 70 mil resistores, 30 toneladas. Consumia 140 KWatts,

5.000 adições por segundo. Para trabalhar nessas máquinas, era necessário conhecer profundamente o

funcionamento do hardware, pois a programação era feita em painéis, através de fios, utilizando linguagem de máquina.

UNIVAC I – criado para o senso americano de 1950. Nesta fase, ainda não existia o conceito de Sistema Operacional.

1.3.2. Segunda Fase (1956-1965)

Criação do transistor e das memórias magnéticas. Surgimento das primeiras linguagens de programação: Assembly e Fortran. SO com seu próprio conjunto de rotinas para operações de E/S. Processamento batch.

Inicialmente, os programas passaram a ser perfurados em cartões, que, submetidos a uma leitora, eram gravados em uma fita de entrada. A fita, então, era lida pelo computador, que executava um programa de cada vez, gravando o resultado do processamento em uma fita de saída. Ao término de todos programas, a fita de saída era lida e impressa. A esse tipo de processamento, onde um lote (batch) de programas era submetido ao computador, deu-se o nome de processamento batch.

1.3.3. Terceira Fase (1966-1980)

Circuitos Integrados (CIs) e microprocessadores. Computadores de porte menor e baixo custo (minicomputadores). Conceitos de multiprogramação: compartilhamento de memória principal e

processador. Permite que, enquanto um programa espera por uma operação de leitura/gravação, o processador executa um outro programa.

Processamento Fita de Entrada

Cartões Perfurados

Processamento Fita de SaídaFita de Entrada

Processamento Fita de Saída

Relatórios



4

Substituição das fitas por discos magnéticos, permitindo a alteração na ordem

de execução das tarefas que antes era puramente seqüencial: spooling. Foram adicionados terminais de vídeo e teclado para interação on-line do

usuário. Multiprogramação (divisão da memória em partições, onde cada programa

espera sua vez para ser executado e compartilhamento do processador) usando time-sharing (tempo compartilhado).

Criação do UNIX (1969), escrito em linguagem C.

1.3.4. Quarta Fase (1981-1990)

Integração em larga escala (LSI) e muito larga escala (VLSI). Surgimento dos microcomputadores PC (Personal Computer), dos sistemas DOS

(Disk Operation System) e VMS (Virtual Memory System). Surgem as estações de trabalho (workstations) que, apesar de monousuárias,

permitem que se executem diversas tarefas concorrentes, criando o conceito de multitarefa.

Máquinas com mais de um processador, exigindo dos SO mecanismos de controle e sincronismo e possibilitando o multiprocessamento.

Difusão das redes WAN, MAN e LAN com o desenvolvimento de protocolos de rede e sistemas operacionais para rede.

1.3.5. Quinta Fase (1991-2000)

Grandes avanços em termos de hardware, software e telecomunicações. Evolução das aplicações, que necessitam cada vez mais de capacidade de

processamento e armazenamento de dados. Sistemas especialistas, sistemas multimídia, banco de dados distribuídos, inteligência artificial são alguns exemplos da necessidade cada vez maior.

Evolução da microeletrônica, ULSI (Ultra Large Scale Integration). Arquiteturas paralelas, baseadas na organização de multiprocessadores não

convencionais. Processamento distribuído de forma que as funções do sistema operacional

estejam espalhadas por vários processadores através de redes de computadores.

Arquitetura cliente-servidor, aplicada basicamente a redes locais, passa a ser oferecida em redes distribuídas, permitindo que qualquer pessoa tenha acesso a todo tipo de informação, independente de onde ela esteja armazenada.

Desenvolvimento de interfaces gráficas para os SO: Windows, Linux, etc.

1.4. Conceitos de Hardware e Software

Serão apresentados alguns conceitos básicos sobre hardware e software relacionados à organização de computadores, necessários para a compreensão dos demais tópicos sobre fundamentos do sistema operacional.



5

1.4.1. Conceitos de Hardware

Todos os componentes de um computador são agrupados em três subsistemas básicos: unidade central de processamento, memória principal e dispositivo de entrada e saída.

Unidade Central de Processamento (UCP)

Unidade Lógica Unidade de

1.4.1.1. Unidade Central de Processamento

A Unidade Central de Processamento (UCP), ou processador, tem como função principal unificar todo o sistema, controlando as funções realizadas por cada unidade funcional. A UCP também é responsável pela execução de todos os programas do sistema, que obrigatoriamente deverão estar armazenados na memória principal.

1.4.1.2. Clock

O clock é um dispositivo, localizado na UCP, que gera pulsos elétricos síncronos em um determinado intervalo de tempo (sinal de clock).

1.4.1.3. Registradores

Os registradores são dispositivos de alta velocidade, localizados na UCP, para armazenamento temporário de dados. Alguns registradores de uso específico:

• Contador de instrução – é o registrador responsável pelo armazenamento do endereço da próxima instrução que a UCP deverá executar.

• Apontador de pilha – é o registrador que contém o endereço de memória do topo da pilha, que é a estrutura de dados onde o sistema mantém informações sobre as tarefas que estão sendo processadas e tiveram que ser interrompidas por algum motivo.

• Registrador de estado – é responsável por armazenar informações sobre a execução do programa. A cada instrução executada, o registrador de estado é alterado conforme o resultado gerado pela instrução.

e Aritmética Controle (ULA) (UC)

Registradores

Dispositivos de Entrada e Saída

Memória Principal



6

1.4.1.4. Memória Principal

A memória principal, também conhecida como memória primária ou real, é a parte do computador onde são armazenados instruções e dados.

1.4.1.5. Memória Cache

A memória cache é uma memória volátil de alta velocidade. O tempo de acesso a um dado nela contido é muito menor que se o mesmo estivesse na memória principal.

Toda vez que o processador faz referência a um dado armazenado na memória principal, ele “olha” antes na memória cache. Se o processador encontrar o dado na cache, não há necessidade do acesso à memória principal; do contrário, o acesso é obrigatório.

1.4.1.6. Memória Secundária

A memória secundária é um meio permanente (não volátil) de armazenamento de programas e dados. Enquanto a memória principal precisa estar sempre energizada para manter suas informações, a memória secundária não precisa de alimentação.

O acesso à memória secundária é lento, se comparado com o acesso à memória cache ou à principal, porém seu custo é baixo e sua capacidade de armazenamento é bem superior à da memória principal.

Registradores

Maior capacidade de armazenamento

Maior custo e maior velocidade de acesso

Memória Cache

Memória Principal Memória Secundária

1.4.1.7. Dispositivos de Entrada e Saída

Os dispositivos de entrada e saída (E/S) são utilizados para permitir a comunicação entre o computador e mundo externo. Através desses dispositivos, a UCP e a memória principal podem se comunicar, tanto com usuários quanto com memórias secundárias, a fim de realizar qualquer tipo de processamento.

1.4.1.8. Barramento

A UCP, a memória principal e os dispositivos de E/S são interligados através de linhas de comunicação denominadas barramentos, barras ou vias. Um barramento (bus) é um conjunto de fios paralelos (linhas de transmissão), onde trafegam informações, como dados, endereços ou sinais de controle.



7

1.4.1.9. Pipelining

O conceito de processamento pipeline se assemelha muito a uma linha de montagem, onde uma tarefa é dividida em subtarefas, executadas em diferentes estágios dentro da linha de produção.

Da mesma forma que em uma linha de montagem, a execução de uma instrução pode ser dividida em subtarefas, como as fases de busca da instrução e dos operandos, execução e armazenamento dos resultados. O processador, através de suas várias unidades funcionais pipeline, funciona de forma a permitir que, enquanto uma instrução se encontra na fase de execução, uma outra instrução possa estar na fase de busca simultaneamente.

1.4.1.10. Ativação e Desativação do Sistema

Toda vez que um computador é ligado, é necessário que o sistema operacional seja carregado da memória secundária para a memória principal. Esse processo, denominado ativação do sistema (boot), é realizado por um programa localizado em uma posição específica do disco (boot block), geralmente o primeiro bloco.

Na maioria dos sistemas, também existe o processo de desativação (shutdown). Este procedimento permite que as aplicações e componentes do sistema sejam desativados de forma ordenada, garantindo a integridade do sistema.

1.4.1.11. Arquiteturas RISC e CISC

Um processador com arquitetura RISC (Reduced Instruction Set Computer) se caracteriza por possuir poucas instruções de máquina, em geral bastante simples, que são executadas diretamente pelo hardware. Na sua maioria, estas instruções não acessam a memória principal, trabalhando principalmente com registradores que, neste tipo de processador, se apresentam em grande número. Estas características, além de ajudarem as instruções serem executadas em alta velocidade, facilitam a implementação do pipeline. Como exemplos de processadores RISC podemos citar o Sparc (SUN), RS-6000 (IBM), PA-RISC (HP), Alpha AXP (DEC) e Rx000 (MIPS).

Os processadores CISC (Complex Instruction Set Computers) já possuem instruções complexas que são interpretadas por microprogramas. O número de registradores é pequeno e qualquer instrução pode referenciar a memória principal. Neste tipo de arquitetura, a implementação do pipeline é mais difícil. São exemplos de processadores CISC o VAX (DEC), 80x86 e o Pentium (Intel), e o 68xxx (Motorola).

1.4.2. Conceitos de Software

O hardware, por si só, não tem a menor utilidade. Para torná-lo útil, existe um conjunto de programas, utilizado como interface entre as necessidades dos usuários e as capacidades do hardware.



8

No decorrer do texto, utilizaremos o termo utilitário, sempre que desejarmos

fazer referência a softwares relacionados mais diretamente com serviços do sistema operacional, como compiladores, linkers e depuradores. Os softwares desenvolvidos pelos usuários serão denominados softwares aplicativos, ou apenas aplicações.

1.4.2.1. Tradutor

Nos sistemas operacionais antigos, o ato de programar era bastante complicado, já que os programas eram desenvolvidos em linguagem de máquina e carregados diretamente na memória principal para execução.

Com o surgimento das primeiras linguagens de montagem (assembly languages) e das linguagens de alto nível, o programador deixou de se preocupar com muitos aspectos pertinentes ao hardware, como em qual região da memória o programa deveria ser carregado ou quais endereços de memória seriam reservados para as variáveis.

Apesar das inúmeras vantagens proporcionadas pelas linguagens de montagem e alto nível, os programas escritos nessas linguagens (programas –fonte) não estão prontos para serem diretamente executados pela UCP. Para isso, eles têm de passar por uma etapa de conversão, onde toda representação simbólica dos programas é traduzida para código de máquina. Esta conversão é realizada por um software denominado tradutor.

O tradutor, pelo tipo de linguagem de programação utilizada, pode ser chamado de montador ou compilador.

• O montador (assembler) é o utilitário responsável por gerar, a partir de um programa escrito em linguagem de montagem, um programa em linguagem de máquina não executável (módulo-objeto).

A linguagem de montagem está diretamente ligada às características da arquitetura do processador. Em função disto, este tipo de linguagem é diferente para cada computador, pois a linguagem de máquina e, conseqüentemente, a linguagem de montagem são características específicas do processador.

• O compilador é o utilitário responsável por gerar, a partir de um programa escrito em uma linguagem de alto nível, um programa em linguagem de máquina não executável (módulo-objeto).

As linguagens de alto nível, como Pascal, Fortran, Cobol, não têm nenhuma relação direta com a máquina, ficando essa preocupação exclusivamente com o compilador. Assim, os programas-fonte podem ser transportados entre computadores de diversos fabricantes, desde que existam regras de definição para a linguagem. Isso permite o desenvolvimento de aplicações independentes do equipamento.

1.4.2.2. Interpretador

O interpretador é considerado um tradutor que não gera código-objeto. A partir de um programa-fonte, escrito em linguagem de alto nível, o interpretador, no momento da execução do programa, traduz cada instrução e a executa em seguida.



9

1.4.2.3. Linker

O linker (ligador) é o utilitário responsável por gerar, a partir de um ou mais módulos objetos, um único programa executável. Suas funções básicas são resolver todas as referências simbólicas existentes entre os módulos objetos e reservar memória para a execução do programa.

1.4.2.4. Loader

O loader (carregador) é o utilitário responsável por colocar fisicamente na memória um programa para execução.

1.4.2.5. Depurador

O depurador (debugger) é o utilitário que permite ao usuário controlar toda a execução de um programa a fim de detectar erros na sua estrutura.

1.4.2.6. Linguagem de Controle

A linguagem de controle (linguagem de comando) é a forma mais direta de um usuário se comunicar com o sistema operacional.

Esses comandos, quando digitados pelos usuários, são interpretados por um programa denominado interpretador de comandos ou shell. O interpretador reconhece a linha de comando, verifica sua sintaxe, envia mensagens de erro e faz chamadas a rotinas do sistema. Dessa forma, o usuário dispõe de uma interface interativa com o sistema operacional, para realizar tarefas como acessar um arquivo em disco ou consultar um diretório.

1.4.2.7. Linguagem de Máquina

A linguagem de máquina de um computador é a linguagem de programação que o processador realmente pode entender. Cada processador possui um conjunto único de instruções de máquina, definido pelo próprio fabricante.

Um programa em linguagem de máquina é totalmente codificado em formato binário, o que torna o entendimento confuso para o usuário.

1.4.2.8. Microprogramação

Os microprogramas definem a linguagem de máquina de cada computador.

Linker

Módulo Objeto

Módulo Objeto

Programa Executável



10

1.5. Tipos de Sistemas Operacionais

Os tipos de Sistemas Operacionais e sua evolução estão intimamente relacionados com a evolução do hardware e das aplicações por ele suportadas.

Abordaremos aqui os diversos tipos de sistemas operacionais, suas características, vantagens e desvantagens:

Tipos de SO:

1. Sistemas Monoprogramáveis / Monotarefa

2. Sistemas Multiprogramáveis / Multitarefa

3. Sistemas com Múltiplos Processadores

1.5.1. Sistemas Monoprogramáveis / Monotarefa

Os primeiros sistemas operacionais eram voltados para a execução de um único programa (job). Qualquer outro programa, para ser executado, deveria aguardar o término do programa concorrente.

Os sistemas monoprogramáveis se caracterizam por permitir que o processador, a memória e os periféricos permaneçam exclusivamente dedicados à execução de um único programa.

Os sistemas monotarefa, como também são chamados, se caracterizam por permitir que todos os recursos do sistema fiquem exclusivamente dedicados a uma única tarefa.

Vantagem: são simples de implementação, não exigindo preocupação com sistemas de proteção.

Desvantagem: a memória e o processador são subutilizados.

1.5.2. Sistemas Multiprogramáveis / Multitarefa

Os sistemas multiprogramáveis são mais complexos e eficientes que os sistemas monoprogramáveis. Vários programas dividem os mesmos recursos de processador, memória e periféricos.

A partir do número de usuários que interagem com o sistema, podemos classificar os sistemas multiprogramáveis como monousuário e multiusuário.

Vantagem: aumento da produtividade dos seus usuários e a redução de custo, a partir do compartilhamento dos diversos recursos do sistema.

Desvantagem: sistemas mais complexos, o sistema se preocupa em gerenciar o acesso concorrente aos seus recursos.

O conceito de sistema multiprogramável está tipicamente associado aos mainframes e minicomputadores, onde existe a idéia do sistema sendo utilizado por vários usuários (multiusuário).

Os sistemas multitarefa, como também são chamados, se caracterizam por permitir que o usuário edite um texto, imprima um arquivo, copie um arquivo pela rede e calcule uma planilha.



11

Os sistemas multiprogramáveis/multitarefas podem ser classificados pela

forma com que suas aplicações são gerenciadas, podendo ser divididos em sistemas batch, de tempo compartilhado ou de tempo real.

1.5.2.1. Sistemas Batch

Os sistemas batch (lote) foram os primeiros sistemas multiprogramáveis a serem implementados e caracterizam-se por terem seus programas armazenados em disco ou fita, onde esperam para ser executados sequencialmente. Não permitem a interação com o usuário durante a sua execução.

1.5.2.2. Sistemas de Tempo Compartilhado

Os sistemas de tempo compartilhado (time-sharing) permitem a interação dos usuários com o sistema, através de terminais que incluem vídeo, teclado e mouse (sistemas on-line). Para cada usuário, o SO aloca uma fatia de tempo (time-slice) do processador. Caso o programa do usuário não esteja concluído neste intervalo de tempo, ele é substituído por um de outro usuário, e fica esperando por uma nova fatia de tempo.

Não só o processador é compartilhado nesse sistema, mas também a memória e os periféricos, como discos e impressoras. O sistema cria para o usuário um ambiente de trabalho próprio, dando a impressão de que todo o sistema está dedicado, exclusivamente, a ele.

Estes sistemas são de implementação mais complexa.

1.5.2.3. Sistemas de Tempo Real

Os sistemas de tempo real (real-time) são semelhantes aos sistemas de tempo compartilhado, a maior diferença é o tempo de resposta exigido no processamento das aplicações.

Nos sistemas de tempo real, um programa detém o processador o tempo que for necessário, ou até que apareça outro prioritário em função de sua importância no sistema. Esta importância ou prioridade de execução é controlada pela própria aplicação e não pelo sistema operacional, como nos sistemas de tempo compartilhado.

Esses sistemas, normalmente, estão presentes em controle de processos, como no monitoramento de refinarias de petróleo, controle de tráfego aéreo, de usinas termoelétricas e nucleares, ou em qualquer aplicação onde o tempo de resposta é fator fundamental.

1.5.3. Sistemas com Multiprocessadores

Os sistemas com multiprocessadores caracterizam-se por possuir duas ou mais UCP’s interligadas, trabalhando em conjunto. Um fator-chave no desenvolvimento de sistemas com múltiplos processadores é a forma de comunicação entre as UCPs e o grau de compartilhamento de memória e periféricos.



12

Os conceitos utilizados no projeto de sistemas com múltiplos processadores

incorporam os conceitos utilizados para multiprogramação, além de outras características e vantagens como:

Escalabilidade: possibilidade de aumentar a capacidade computacional com menor custo.

Reconfiguração: capacidade de um sistema continuar o processamento mesmo se um dos processadores falhar.

Balanceamento: possibilidade de distribuir a carga de processamento entre os diversos sistemas de computação, melhorando o desempenho como um todo.

Podemos classificar os Sistemas com Múltiplos Processadores em Fortemente Acoplados e Fracamente Acoplados.

1.5.3.1. Sistemas Fortemente Acoplados

Nos sistemas fortemente acoplados existem dois ou mais processadores compartilhando a mesma memória e controlados por um único sistema operacional. Permitem que vários programas sejam executados ao mesmo tempo, ou que um programa seja dividido em subprogramas, para execução simultânea em vários processadores, em vez de um processador de alta velocidade e custo elevado. São utilizados em processamento científico, simulações e processamento de imagens. Os sistemas fortemente acoplados ainda podem ser classificados em:

Sistemas Assimétricos: caracterizam-se por possuir um processador (primário), responsável pelo controle dos demais processadores (secundários) e pela execução do sistema operacional.

Vantagem: simples de implementar.

Desvantagem: dependência do processador primário e utilização ineficiente dos recursos do sistema, no caso do processador mestre receber muitas interrupções dos escravos para serem tratadas.

Sistemas Simétricos: todos os processadores realizam as mesmas funções, podendo executar o sistema operacional independentemente.

Vantagem: independência de um processador principal, todos executam a mesma função. Melhor balanceamento do processamento e das operações de entrada e saída.

Desvantagem: implementação mais complexa.

1.5.3.2. Conceitos e Organização dos Sistemas Fortemente Acoplados

Multiprocessamento: uma tarefa pode ser executada, ao mesmo tempo, por mais de um processador (paralelismo). Podemos analisar o multiprocessamento em dois níveis:

• Processamento Vetorial: permite a manipulação de vetores inteiros, possibilitando a execução da mesma operação sobre diferentes elementos de um ou mais vetores.

• Processamento Paralelo: é a possibilidade de uma aplicação ser executada por mais de um processador ao mesmo tempo.



13

Organização Funcional: O esquema de comunicação interna das UCPs,

memória e dispositivos de E/S (unidades funcionais) é fundamental no projeto de sistemas com múltiplos processadores. As organizações funcionais de multiprocessadores podem ser divididas, basicamente, em três tipos:

• Barramento Comum: a forma mais simples de comunicação entre múltiplos processadores e outras unidades funcionais é interligar todos os componentes a um barramento comum.

• Barramento Cruzado: as unidades funcionais podem ser conectadas entre si através de barramentos cruzados, criando uma rede de interconexões.

• Memória Multiport: além das vantagens do barramento cruzado, permite acessos simultâneos de processadores a um mesmo módulo de memória.

1.5.3.3. Sistemas Fracamente Acoplados Os sistemas fracamente acoplados caracterizam-se por possuir dois ou mais

sistemas de computação interligados através de linhas de comunicação. Cada sistema possui o seu próprio sistema operacional, gerenciando os seus recursos, como processador, memória e dispositivos de E/S. Os sistemas fracamente acoplados ainda podem ser classificados em:

Sistemas Operacionais de Rede: cada nó (sistema independente) possui seu próprio sistema operacional, além de um hardware e software que possibilitam ao sistema ter acesso a outros componentes da rede, compartilhando seus recursos. O melhor exemplo de utilização dos sistemas operacionais de rede são as redes locais (Local Area Network-LAN).

Sistemas Operacionais Distribuídos: cada componente possui seu próprio sistema operacional, memória, processador e dispositivos. O que diferencia o sistema operacional de rede dos sistemas distribuídos (cluster) é o grau de interação entre os nós. Para o usuário e suas aplicações é como se não existisse uma rede de computadores, mas sim um único sistema centralizado. Os sistemas distribuídos permitem que uma aplicação seja dividida em diferentes partes (aplicações distribuídas), que se comunicam através de linha de comunicação, podendo cada parte ser executada por um sistema diferente. A grande vantagem é a capacidade de redundância do sistema, conceito muito utilizado em aplicações de missão crítica, como controle de tráfego aéreo, conhecidas como sistemas de tolerância a falhas.

1.5.3.4. Organização dos Sistemas Fracamente Acoplados

A organização dos sistemas fracamente acoplados ou topologia, define como são interligados fisicamente os diversos sistemas da rede. As principais organizações são:

Barramento

Na organização de barramento, os sistemas são conectados a uma única linha de comunicação e todos compartilham o mesmo meio, tanto para receber como para enviar mensagens. Esse tipo de organização é utilizado geralmente em redes locais. Neste tipo de topologia, caso haja algum problema com o meio de transmissão, todos os nós da rede ficarão incomunicáveis.



14

Organização Distribuída

Na organização distribuída existem linhas de comunicação ponto-a-ponto que ligam os sistemas e caminhos alternativos entre os diversos nós da rede. Caso uma linha de comunicação apresente problema, linhas alternativas permitirão que a rede continue em funcionamento. Este tipo de organização é utilizado geralmente em redes distribuídas.

1.6. Sistemas Multiprogramáveis

A possibilidade de periféricos funcionarem simultaneamente entre si, juntamente com a UCP, permitiu a execução de tarefas concorrentes, que é o princípio básico para o projeto e implementação de sistemas multiprogramáveis.

Características dos sistemas monoprogramáveis:

Baixa utilização dos recursos do sistema como: processador, memória e periféricos.

Somente um programa pode estar na memória e o processador fica dedicado, exclusivamente, à execução deste único programa.

Subutilização da memória. Um programa que não ocupe toda a memória ocasiona a existência de áreas livres, sem utilização.

Mais simples de implementar, pois não existem questões de concorrência para serem tratadas pelo sistema operacional.

Exemplo de Utilização do Sistema

Leitura de um registro 0,0015 segundos

Execução de 100 instruções 0,0001 segundos

Total 0,0016 segundos

Porcentagem de utilização da CPU 0,0001 / 0,0015 = 0,066 = 6,6%

Características dos sistemas multiprogramáveis:

Vários programas podem estar residentes na memória, concorrendo pela utilização da UCP. Nesse caso, a UCP permanece menos tempo ociosa e a memória principal é utilizada de forma mais eficiente, pois existem vários programas residentes se revezando na utilização do processador.

A utilização concorrente da UCP deve ser implementada de maneira que, quando um programa perde o uso do processador e depois retorna para continuar o processamento, seu estado deve ser idêntico ao do momento em que foi interrompido. O programa deverá continuar sua execução exatamente na instrução seguinte àquela em que havia parado, aparentando ao usuário que nada aconteceu, ou seja, ficando todo este mecanismo transparente para ele.



15

Em sistemas multiprogramáveis é possível compartilhar os periféricos. Como,

por exemplo, compartilhar impressoras entre vários usuários e realizar o acesso concorrente a discos por diversos programas.

A eficiência proporcionada por um sistema multiprogramável resulta em maior complexidade do sistema operacional, já que alguns problemas surgem com esse tipo de implementação.

Exemplo:

Nos próximos itens serão mostrados alguns mecanismos e dispositivos que possibilitam a implementação de um sistema de tarefas concorrentes, ou seja, sistema multiprogramável.

1.6.1. Interrupção e Exceção

Durante a execução de um programa, alguns eventos podem ocorrer durante o seu processamento, obrigando a intervenção do sistema operacional. Este tipo de intervenção é chamado interrupção ou exceção e pode ser resultado da execução de instruções do próprio programa, gerado pelo sistema operacional ou por algum dispositivo de hardware. Nestas situações o fluxo de execução do programa é desviado para uma rotina especial de tratamento. O que diferencia uma interrupção de uma exceção é o tipo de evento que gera esta condição.

Interrupção: gerada pelo sistema operacional ou algum dispositivo de hardware e, neste caso, independe do programa que está sendo executado. Um exemplo é quando um periférico avisa à UCP que está pronto para transmitir algum dado. Neste caso, a UCP deve interromper o programa para atender a solicitação do dispositivo.

Exceção: é o resultado direto da execução de uma instrução do próprio programa. Situações como a divisão de um número por zero ou a ocorrência de um overflow caracterizavam essa situação. Os mecanismos de tratamento de exceções, muitas vezes, podem ser escritos pelo próprio programador. Dessa forma, é possível evitar que um programa seja encerrado no caso de ocorrer, por exemplo, um overflow.

No momento em que a unidade de controle detecta a ocorrência de algum tipo de interrupção, o programa em execução é interrompido, e o controle é desviado para uma rotina responsável pelo tratamento da interrupção. Muitas vezes, após a execução dessa rotina, o controle deve voltar ao programa que, anteriormente, estava sendo processado. Para isso acontecer, é necessário que, no momento da interrupção, um conjunto de informações sobre a execução do



16

programa seja preservado. Essas informações consistem no conteúdo de alguns registradores, que deverão ser restaurados posteriormente para a continuação do programa.

Exemplo:

Salva os registradores

Identifica a origem da interrupção

Obtém o endereço da rotina de tratamento

Restaura os registradores

Programa

Interrupção

Rotina de Tratamento da Interrupção

Não existe apenas um tipo de interrupção. No momento que uma interrupção acontece, a UCP deve saber para qual rotina de tratamento deverá ser desviado o fluxo de execução. Essa informação está em uma estrutura do sistema chamada vetor de interrupção.

No caso de múltiplas interrupções ocorrerem, o processador deve saber qual interrupção terá de atender primeiro. Para isso, as interrupções deverão possuir prioridades, em função da necessidade de atendimento de cada uma.

As interrupções podem ser classificadas como mascaráveis (podem ser desabilitadas pelo processador) e não mascaráveis (o tratamento é sempre obrigatório).

1.6.2. Operações de Entrada / Saída (E/S)

Em sistemas primitivos, a comunicação entre a UCP e os periféricos era controlada por um conjunto de instruções especiais, denominadas instruções de entrada/saída, executadas pela própria UCP.

A implementação de um dispositivo chamado controlador ou interface permitiu à UCP agir de maneira independente dos dispositivos de E/S. Com este novo elemento a UCP não se comunica mais diretamente com os periféricos, mas sim através do controlador.

UCP Memória Controlador



17

Existiam duas formas básicas do processador controlar as operações de E/S:

Na primeira, o processador ficava constantemente testando o estado do periférico de E/S para saber quando a operação chegaria ao seu final, este controle é chamado de E/S Controlada por Programa.

Outra forma derivada da anterior, porém mais inteligente, era permitir que, após o início da transferência dos dados, a UCP ficasse livre para se ocupar de outras tarefas. Assim, em determinados intervalos de tempo, o sistema operacional deveria realizar um teste para saber do término ou não da operação de E/S em cada dispositivo (Polling).

Com a implementação do mecanismo de interrupção no hardware dos computadores, as operações de E/S puderam ser realizadas de uma forma mais eficiente. Em vez de o sistema periodicamente verificar o estado de uma operação pendente, o próprio controlador interrompe a UCP para avisar do término da operação. Com este mecanismo, denominado E/S Controlada por Interrupção, a UCP, após a execução de um comando de leitura ou gravação, fica livre para o processamento de outras tarefas. Quando a transferência termina, o próprio periférico se encarrega de sinalizar o processador.

A operação de E/S Controlada por Interrupção é muito mais eficiente que a E/S Controlada por Programa. Apesar disto, essa implementação ainda sobrecarregava a UCP, uma vez que toda a transferência de dados entre memória e periféricos exigia a intervenção da UCP. A solução para este problema foi a implementação, por parte do controlador, de uma técnica de transferência de dados denominada DMA (Direct Memory Access), isto é, acesso direto a memória. Esta técnica permite que um bloco de dados seja transferido entre memória e periféricos sem a intervenção da UCP, exceto no início e no final da transferência. A área de memória utilizada pelo controlador na técnica de DMA é chamado buffer, sendo reservada exclusivamente para este propósito.

1.6.3. Buffering

A técnica de buffering consiste na utilização de uma área de memória para a transferência de dados entre os periféricos e a memória principal denominada buffer. O buffering veio permitir que, quando um dado fosse transferido para o buffer após uma operação de leitura, o dispositivo de entrada pudesse iniciar uma nova leitura. Neste caso, enquanto a UCP manipula o dado localizado no buffer, o dispositivo realiza outra operação de leitura no mesmo instante. O mesmo raciocínio pode ser aplicado para operações de gravação, onde a UCP coloca o dado no buffer para um dispositivo de saída manipular.

MemóriaPrincipal

UCP

Controlador

de E/S

Gravação Gravação

Buffer

Leitura Leitura



18

1.6.4. Spooling

A técnica de spooling (simultaneous peripherical operation on-line) foi introduzida no final dos anos 50 para aumentar a produtividade e a eficiência dos sistemas operacionais.

O spooling, basicamente, utiliza o disco como um grande buffer, permitindo que dados sejam lidos e gravados em disco, enquanto outras tarefas são processadas.

Um exemplo dessa técnica está presente quando impressoras são utilizadas. No momento em que um comando de impressão é executado por um programa, as informações que serão impressas são gravadas em um arquivo em disco (arquivo de spool), para ser impresso posteriormente pelo sistema.

Programa Sistema Operacional

Arquivo De Spool

Impressão

1.6.5. Reentrância

É comum, em sistemas multiprogramáveis, vários usuários executarem os mesmos utilitários do sistema operacional simultaneamente, como, por exemplo, um editor de texto. Se cada usuário que utilizasse o editor de texto trouxesse o código do utilitário para a memória, haveria diversas cópias de um mesmo programa na memória principal, o que ocasionaria um desperdício de espaço.

Reentrância é a capacidade de um código de programa (código reentrante) poder ser compartilhado por diversos usuários, exigindo que apenas uma cópia do programa esteja na memória.

A reentrância permite que cada usuário possa entrar em um ponto diferente do código reentrante, manipulando dados próprios, exclusivos de cada usuário.

1.6.6. Proteção do Sistema

Nos sistemas multiprogramáveis, onde diversos usuários compartilham os mesmos recursos, deve existir uma preocupação, por parte do sistema operacional, de garantir a integridade dos dados pertencentes a cada usuário.

O sistema operacional tem que ter mecanismos para proteger que o programa de um usuário acesse o código do programa de outro usuário e do próprio sistema operacional.

Quando um programa reserva um periférico para realizar alguma operação, como, por exemplo, na utilização de uma impressora, nenhum outro programa deve interferir até que o primeiro programa a libere.

Compartilhamento de arquivos em disco permite que dois ou mais usuários acessem um mesmo arquivo simultaneamente e caso o acesso não seja controlado pelo sistema operacional, podem ocorrer problemas de inconsistência. Para isto os sistemas multiprogramáveis implementam o esquema de lock (bloqueio) de arquivo que permite o controle pelo sistema do acesso concorrente a arquivos.



19

1.7. Estrutura do Sistema Operacional

Existe uma grande dificuldade em compreender a estrutura e o funcionamento de um sistema operacional, pois ele não é executado como uma aplicação tipicamente sequencial, com início, meio e fim. As rotinas do sistema são executadas sem uma ordem pré-definida, baseadas em eventos dissociados do tempo (eventos assíncronos).

1.7.1. Núcleo do Sistema ou Kernel (cérebro)

Conjunto de rotinas (procedimentos e funções) que oferecem serviços aos usuários do sistema e suas aplicações, bem como outras rotinas do próprio sistema.

As principais funções do núcleo são:

Tratamento de interrupções;

Criação e eliminação de processos;

Sincronização e comunicação entre processos;

Escalonamento e controle de processos;

Gerência de memória;

Gerência do sistema de arquivos;

Operações de entrada e saída;

Contabilização e segurança do sistema.

1.7.2. System Calls

É um mecanismo implementado para proteger o núcleo do sistema, para evitar que uma aplicação, que tenha acesso ao núcleo, realize uma operação que o danifique, fazendo com que o sistema fique comprometido e inoperante.

O usuário (ou aplicação), quando deseja solicitar algum serviço do sistema, realiza uma chamada a uma de suas rotinas (ou serviços) através de system calls (chamadas ao sistema), que são portas de entrada para se ter acesso ao núcleo do sistema operacional. Para cada serviço existe uma system call associada e cada sistema operacional tem o seu próprio conjunto (biblioteca) de chamadas, com nomes, parâmetros e formas de ativação específicos.

Aplicação System Call

Núcleo (kernel)

Hardware

O mecanismo de ativação e comunicação entre a aplicação e o sistema é semelhante ao mecanismo implementado quando um programa modularizado ativa um dos seus procedimentos e funções.

As system calls podem ser divididas em grupos de função:

Gerência de Processos Criação e eliminação de processos; Alteração das características do processo; Sincronização e comunicação entre processos.



20

Gerência de Memória

Alocação e desalocação de memória.

Gerência de Entrada/Saída Operações de entrada/saída; Manipulação de arquivos e diretórios.

1.7.3. Modos de Acesso

Existem certas instruções que não podem ser colocadas diretamente à disposição das aplicações, pois a sua utilização indevida ocasionaria sérios problemas à integridade do sistema. Sendo assim, algumas instruções, como operações de entrada e saída, só devem ser executadas pelo sistema operacional, para impedir a ocorrência de problemas de segurança e até mesmo, violação do sistema. As instruções que têm o poder de comprometer o sistema são conhecidas como instruções privilegiadas, enquanto as instruções não-privilegiadas são aquelas que não oferecem perigo ao sistema.

Para permitir que uma aplicação possa executar uma instrução privilegiada, o processador implementa um mecanismo de modos de acesso. Existem, basicamente, dois modos de acesso:

Modo Usuário – Quando o processador trabalha em modo usuário, uma aplicação só pode executar instruções não-privilegiadas, tendo acesso a um número reduzido de instruções.

Modo Kernel – Uma aplicação pode ter acesso ao conjunto total de instruções do processador.

O modo de acesso é determinado por um conjunto de bits, localizado em

um registrador especial da UCP, que indica o modo de acesso corrente. Através desse registrador, o hardware verifica se uma instrução pode ou não ser executada pela aplicação.

A melhor maneira de controlar o acesso às instruções privilegiadas é permitir que apenas o sistema operacional tenha acesso a elas. Sempre que uma aplicação necessita de um serviço que incorra em risco para o sistema, a solicitação é feita através de uma system call. A system call altera o modo de acesso do processador para um modo mais privilegiado (modo kernel). Ao término da rotina do sistema, o modo de acesso é retornado para o modo usuário.

Programa Usuário A

Programa Usuário B

System Call

Rotina do Sistema

Programas dos Usuários Executam no modo usuário

Sistema Operacional Executa no modo kernel

Memória Principal



21

O núcleo do Sistema Operacional sempre é executado em modo kernel, pois deve possuir a capacidade de gerenciar e compartilhar todos os seus recursos, solucionando, em diversos níveis, os problemas de acesso às instruções privilegiadas.

1.7.4. Estruturas de Sistemas Operacionais

Existem, basicamente, três maneiras de organizar o código do sistema operacional e o inter-relacionamento entre seus diversos componentes: • Sistemas Monolíticos. • Sistemas em Camadas. • Sistemas Cliente-Servidor.

1.7.4.1. Sistemas Monolíticos

A organização mais comum é aquela que estrutura o sistema como um conjunto de rotinas que podem interagir livremente umas com as outras. A estrutura monolítica pode ser comparada com uma aplicação formada por vários procedimentos que são compilados separadamente e depois linkados, formando um grande e único programa executável.

Aplicação Aplicação

System Calls

Hardware

Modo Usuário

Modo Kernel

1.7.4.2. Sistemas em Camadas

Um sistema em camadas divide o sistema operacional em camadas sobrepostas. Cada módulo oferece um conjunto de funções que podem ser utilizadas por outros módulos. Módulos de uma camada podem fazer referência apenas a módulos de camadas inferiores.

A vantagem da estrutura em camadas é isolar as funções do sistema operacional, facilitando sua alteração e depuração, além de criar uma hierarquia de níveis de modos de acesso, protegendo as camadas mais internas.



22

5 Operador 4 Programas de usuário 3 Entrada/Saída 2 Comunicação 1 Gerência de memória 0 Multiprogramação

1.7.4.3. Sistemas Cliente/Servidor

Uma tendência dos sistemas operacionais modernos é tornar o núcleo do sistema operacional o menor e mais simples possível. Para implementar esta idéia, o sistema é dividido em processos, sendo cada um responsável por oferecer um conjunto de serviços, como serviços de arquivo, serviços de criação de processos, serviços de memória, serviços de escalonamento, etc.

Sempre que uma aplicação deseja um serviço, ela solicita ao processo responsável. Neste caso, a aplicação que solicita um serviço é chamada de cliente, enquanto o processo que responde à solicitação é chamado de servidor. Um cliente que pode ser uma aplicação de um usuário ou um outro componente do sistema operacional, solicita um serviço enviando uma mensagem para o servidor. O servidor responde ao cliente através de uma outra mensagem. É função do núcleo do sistema realizar a comunicação, ou seja, a troca de mensagens entre o cliente e o servidor.

Servidor de

Memória

Servidor de

Rede

Servidor de

Arquivo

Servidor de

Processo

Cliente

Modo Usuário

Modo Kernel

Núcleo (Kernel)

Hardware

A utilização deste modelo permite que os servidores executem em modo usuário, ou seja, não tenham acesso direto a certos componentes do sistema. Apenas o núcleo do sistema, responsável pela comunicação entre clientes e servidores, executa em modo kernel. Como conseqüência, se um erro ocorrer em um servidor, este servidor pode parar, mas o sistema não ficará inteiramente comprometido. Além disso, a implementação de sistemas cliente/servidor permite



23

isolar as funções do sistema operacional por diversos processos (servidores) pequenos e dedicados a serviços específicos. Como conseqüência, o sistema operacional passa a ser de mais fácil manutenção.

Como os servidores se comunicam através de trocas de mensagens, não importa se os clientes e servidores estão sendo processados com um processador, com múltiplos processadores (fortemente acoplado) ou num ambiente distribuído (fracamente acoplado).

Apesar das vantagens deste modelo, ele é de difícil implementação. O que é implementado na prática é uma combinação do modelo de camadas com o modelo cliente-servidor. O núcleo do sistema, além de ser responsável pela comunicação entre o cliente e servidor, passa a incorporar outras funções críticas do sistema, como escalonamento de processos, gerência de memória, além das funções de devices drivers.



24

2. Processo

2.1. Introdução

O processo pode ser entendido com um programa em execução, só que seu conceito é mais abrangente. Este conceito torna-se mais claro quando pensamos na forma em que os sistemas multiprogramáveis (multitarefa) atendem a diversos usuários (tarefas) e mantém informações a respeito dos vários programas que estão sendo executados concorrentemente.

Como sabemos, um sistema multiprogramável simula um ambiente de monoprogramação para cada usuário, isto é, cada usuário do sistema tem a impressão de possuir o processador exclusivamente para ele. Nesses sistemas, o processador executa a tarefa de usuário durante um intervalo de tempo (time-slice) e, no instante seguinte, está processando outra tarefa. A cada troca, é necessário que o sistema preserve todas as informações da tarefa que foi interrompida, para quando voltar a ser executada não lhe faltar nenhuma informação para a continuação do processamento. A estrutura responsável pela manutenção de todas as informações necessárias à execução de um programa, como conteúdo de registradores e espaço de memória, chama-se processo.

2.2. Modelo de Processo

O sistema operacional materializa o processo através de uma estrutura chamada bloco de controle de processo (Process Control Block- PCB). A partir do PCB, o sistema mantém todas as informações sobre o processo, como sua identificação, prioridade, estado corrente, recursos alocados por ele e informações sobre o programa em execução.

Bloco de Controle do

Processo (PCB)

Ponteiros

Estado do Processo

Nome do Processo Prioridade do Processo

Registradores

Limites de memória

Lista de Arquivos Abertos : : :

O sistema gerencia os processos através de system calls, que realizam operações como criação, eliminação, sincronização, suspensão de processos, entre outras.



25

O processo pode ser dividido em três elementos básicos:

Contexto de hardware;

Contexto de software;

Espaço de endereçamento.

2.2.1. Contexto de Hardware

O contexto de hardware constitui-se, basicamente, do conteúdo de registradores: program counter (PC), stack pointer (SP) e bits de estado. Quando um processo está em execução, seu contexto de hardware está armazenado nos registradores do processador. No momento em que o processo perde a utilização da UCP, o sistema salva suas informações no seu contexto de hardware.

A troca de um processo por outro na UCP, realizada pelo sistema operacional, é denominada mudança de contexto (context switching). A mudança de contexto consiste em salvar o conteúdo dos registradores da UCP e carregá-los com os valores referentes ao do processo que esteja ganhando a utilização do processador. Essa operação resume-se, então, em substituir o contexto de hardware de um processo pelo de outro.

Processo A

Salva Registradores do Processo A

Carrega Registradores do Processo B

Salva Registradores do Processo B

Carrega Registradores do Processo A

Processo B

executando

executando

executando

Sistema Operacional

2.2.2. Contexto de Software

O contexto de software especifica características do processo que vão influir na execução de um programa, como, por exemplo, o número máximo de arquivos abertos simultaneamente ou o tamanho máximo do buffer para operações de E/S. Essas características são determinadas no momento da criação do processo, podendo ser alteradas durante sua existência.

O contexto de software define basicamente três grupos de informações sobre um processo: sua identificação, suas quotas e seus privilégios.

Identificação: Cada processo criado pelo sistema recebe uma identificação única (PID – process identification), representada por um número. Através do PID, o sistema operacional e outros processos podem fazer referência a um determinado processo e, por exemplo, alterar uma de suas características.



26

O processo também possui uma identificação do usuário ou do processo que o criou (owner). Cada usuário possui uma identificação única no sistema (UID – user identification), atribuída ao processo no momento de sua criação.

Quotas: São os limites de cada recurso do sistema que o processo pode alocar. Caso uma cota seja insuficiente, o processo poderá ser executado lentamente ou mesmo não ser executado. Alguns exemplos de quotas que aparecem na maioria dos sistemas operacionais são:

• Número máximo de arquivos abertos simultaneamente;

• Tamanho máximo de memória que o processo pode alocar;

• Número máximo de operações de E/S pendentes;

• Tamanho máximo do buffer para operações de E/S;

• Número máximo de processos e subprocessos que podem ser criados.

Privilégios: Definem o que o processo pode ou não fazer em relação ao sistema e aos outros processos.

2.2.3. Espaço de Endereçamento

O espaço de endereçamento é a área de memória do processo onde o programa será executado, além do espaço para os dados utilizados por ele. Cada processo possui o seu próprio espaço de endereçamento, que deve ser protegido do acesso dos demais processos.

2.3. Estados do Processo

Um processo, em um sistema multiprogramável (multitarefa), não é executado todo o tempo pelo processador. Durante sua existência, ele passa por uma série de estados. Basicamente, existem três estados em que um processo pode se encontrar no sistema:

Execução (running): Um processo é dito em estado de execução quando está sendo processado pelo UCP. Em sistemas com apenas um processador, somente um processo pode estar sendo executado em um dado instante de tempo. Já em sistemas com múltiplos processadores, vários processos podem estar sendo executados ao mesmo tempo, dependendo do número de processadores. Existe também a possibilidade de um mesmo processo ser executado por mais de um processador (processamento paralelo).

Pronto (ready): Um processo está no estado de pronto quando apenas aguarda uma oportunidade para executar, ou seja, espera que o sistema operacional aloque a UCP para sua execução.

Espera (wait): Um processo está no estado de espera quando aguarda algum evento externo ou por algum recurso para poder prosseguir o seu processamento. Como exemplo, podemos citar o término de uma operação de entrada e saída ou a espera de uma determinada data e/ou hora para poder continuar sua execução.



27

O sistema operacional gerencia os processos através de listas encadeadas,

onde cada PCB (bloco de controle de processo) tem um ponteiro para o seu sucessor. Assim:

: :

PCB #5 Lista de processos em estado de pronto

Lista de processos em estado de espera

::

PCB #1

: :

PCB #9

::

PCB #2

: :

PCB #4

2.4. Mudanças de Estado do Processo

Um processo muda de estado diversas vezes, durante o seu processamento, em função de eventos originados por ele próprio (eventos voluntários) ou pelo sistema operacional (eventos involuntários).

Basicamente, existem quatro mudanças de estado que podem ocorrer a um processo:

b Execução

Espera Pronto c

da

Pronto → Execução: Quando um processo é criado, o sistema o coloca em uma lista de processos no estado de pronto, onde aguarda a oportunidade de ser executado (a). Cada sistema tem seus próprios critérios e algoritmos para a escolha da ordem em que os processos serão executados (escalonamento).

Execução → Espera: Um processo em execução passa para o estado de espera por eventos gerados pelo próprio processo, como, por exemplo, uma operação de entrada/saída (b).

Espera → Pronto: Um processo passa do estado de espera para o estado de pronto quando a operação solicitada é atendida, ou o recurso esperado é concedido.

Um processo no estado de espera sempre terá de passar pelo estado de pronto antes de poder ser novamente selecionado para execução (c). Não existe a mudança do estado de espera para o estado de execução diretamente.



28

Execução → Pronto: Um processo em execução passa para o estado de

pronto por eventos gerados pelo sistema, como, por exemplo, o fim da fatia de tempo que o processo possui para sua execução (d). Neste caso, o processo volta para a fila de pronto, onde aguarda por uma nova oportunidade para continuar o seu processamento.

2.5. Subprocesso e Thread

Um processo pode criar outros processos de maneira hierárquica. Quando um processo (processo pai) cria um outro, chamamos o processo criado de subprocesso ou processo filho. O subprocesso, por sua vez, pode criar outros subprocessos. Como conseqüência desta estrutura, caso um processo deixe de existir, os subprocessos subordinados são eliminados.

O uso de subprocessos no desenvolvimento de aplicações concorrentes demanda o consumo de diversos recursos do sistema (contexto de hardware, contexto de software e espaço de endereçamento).

Na tentativa de diminuir o tempo gasto na criação/eliminação de processos, bem como economizar recursos do sistema como um todo, foi introduzido o conceito de thread (linha). Threads compartilham o processador da mesma maneira que um processo. Por exemplo, enquanto um thread espera por uma operação de E/S, outro thread pode ser executado.

A grande diferença entre subprocessos e threads é em relação ao espaço de endereçamento. Enquanto subprocessos possuem, cada um, espaços de endereçamento independentes e protegidos, threads compartilham o mesmo espaço de endereçamento do processo, sem nenhuma proteção, permitindo assim que um thread possa alterar dados de outro thread.

2.6. Processos do Sistema

O conceito de processo, além de estar associado a aplicações de usuários, pode também ser implementado na própria estrutura de um sistema operacional, para retirar código do seu núcleo, tornando-o menor e mais estável. No caso de uma ou mais funções não serem desejadas, basta não ativar os processos responsáveis, o que permitirá liberar memória para os processos dos usuários.

Algumas das funções do sistema operacional que podem ser implementadas através de processos:

• Auditoria e segurança;

• Serviços de rede;

• Contabilização do uso de recursos;

• Contabilização de erros;

• Gerência de impressão;



29

• Gerência de jobs batch;

• Temporização;

• Comunicação de eventos;

• Interface de comandos (shell).

2.7. Tipos de Processos

Os processos podem ser classificados de acordo com o tipo de processamento que realizam. Assim:

CPU-bound (ligado a CPU) – quando o processo passa a maior parte do tempo no estado de execução, ou seja, utilizando o processador. Este tipo de processo realiza poucas operações de entrada/saída e é encontrado em aplicações matemáticas ou científicas, que efetuam muitos cálculos e poucas operações de leitura/gravação.

I/O-bound (ligado à E/S) – quando o processo passa a maior parte do tempo no estado de espera, pois realiza um elevado número de operações de entrada/saída. Esse tipo de processo é encontrado em aplicações comerciais, que se baseiam em leitura, processamento e gravação.



30

3. Comunicação entre Processos

3.1. Introdução

É comum processos que trabalham juntos (concorrentes) compartilhem recursos do sistema, como arquivos, registros, dispositivos e áreas de memória. Na verdade, não importa quais recursos são compartilhados, pois problemas decorrentes dessa interação serão os mesmos. De maneira geral, o compartilhamento de recursos entre processos pode gerar situações indesejáveis, capazes até de comprometer o sistema.

Vejamos um exemplo onde dois processos trocam informações através de operações de gravação e leitura em um buffer. Um processo só poderá gravar dados no buffer caso ele não esteja cheio. Da mesma forma, um processo só poderá ler dados armazenados do buffer se existir algum dado a ser lido. Em ambos os casos, os processos deverão aguardar até que o buffer esteja pronto para as operações de gravação ou de leitura.

Processo Gravador

Buffer

Sincronização

Dados Dados

Processo

Leitor Os mecanismos que garantem a comunicação entre processos concorrentes e o acesso a recursos compartilhados são chamados mecanismos de sincronização. No projeto de sistemas operacionais multiprogramáveis, é fundamental a implementação de mecanismos de sincronização que garantam sua integridade e confiabilidade. Este capítulo se detém na comunicação entre processos em sistemas fortemente acoplados.

3.2. Especificação de Concorrência em Programas

Na abordagem dos problemas e soluções decorrentes da comunicação entre processos, utilizaremos diversos algoritmos. Para implementá-los será necessária a utilização de estruturas que permitam a especificação de concorrência em programas.

A primeira notação para a especificação da concorrência em um programa foram os comandos FORK e JOIN.



31

program A; . . Fork B; . . Join B; . end.

program B; . . . end.

O programa A começa a ser processado e, ao encontrar o comando FORK, faz com que seja criado um outro processo para a execução do programa B, concorrentemente a A. O comando JOIN permite que o programa A sincronize-se com B, ou seja, quando o programa A encontrar o comando JOIN, só continuará a ser processado após o término de B.

Uma das implementações mais simples de expressar concorrência em um programa é a utilização dos comandos PARBEGIN e PAREND.

parbegin comando_1; comando_2; (...) comando_n; parend;

O comando PARBEGIN especifica que a seqüência de comandos seja executada concorrentemente em uma ordem imprevisível, através da criação de um processo (Processo_1, Processo_2, ..., Processo_n) para cada comando (Comando_1, Comando_2, ..., Comando_n). O comando PAREND define um ponto de sincronização, onde o processamento só continuará quando todos os processos criados já tiverem terminado suas execuções.

ProcessoPrincipal

Para compreendermos realmente como funciona esta estrutura, vejamos em

uma aplicação prática, onde calculamos o valor da expressão aritmética:

x := SQRT (1024) + (35.4 * 0.23) – (302 / 7);

Processo 1

Processo2

Processo3

Processo n

ProcessoPrincipal



32

PROGRAM Expressao; VAR X, Temp1, Temp2, Temp3 : REAL;

BEGIN PARBEGIN

Temp1 := SQRT (1024); Temp2 := 35.4 * 0.23; Temp3 := 302 / 7;

PAREND; X := Temp1 + Temp2 – Temp3; WRITELN (‘x = ‘, X);

END.

Os comandos de atribuição situados entre PARBEGIN e PAREND são executados concorrentemente entre si. O cálculo final de X só poderá ser realizado quando todas as variáveis dentro da estrutura tiverem sido calculadas.

3.3. Problemas de Compartilhamento de Recursos

Para compreender melhor como a sincronização entre processo é fundamental quando recursos são compartilhados em sistemas multiprogramáveis, vejamos um problema aplicado a situações práticas:

Suponha um arquivo de contas bancárias, onde cada cliente tem seu saldo controlado. Suponha então que dois caixas diferentes possam atualizar o saldo um mesmo cliente simultaneamente. O primeiro caixa lê o registro de cliente e soma ao campo saldo o valor do lançamento. Antes de gravar o novo saldo no arquivo, outro caixa lê o registro do mesmo cliente, que está sendo atualizado, para realizar outro lançamento. Independente de qual caixa atualize primeiro o saldo no arquivo, o dado gravado estará inconsistente.

3.4. Solução para Problemas de Compartilhamento

A solução mais simples, para evitar o problema de compartilhamento anterior, é impedir que dois ou mais processos acessem um mesmo recurso no mesmo instante. Para isso, enquanto um processo estiver acessando determinado recurso, todos os outros que queiram acessar esse mesmo recurso deverão esperar até que o primeiro processo termine o acesso. Esta idéia de exclusividade de acesso é denominada exclusão mútua.

A exclusão mútua deve apenas afetar os processos concorrentes quando um deles estiver fazendo acesso ao recurso compartilhado. A parte do código do programa onde é feito o acesso ao recurso compartilhado é denominada região crítica.

Os mecanismos que implementam a exclusão mútua utilizam um protocolo de acesso à região crítica. Toda vez que um processo for executar sua região crítica, ele obrigatoriamente executará, antes, um protocolo de entrada nessa região. Da mesma forma que, ao sair, deverá executar um protocolo de saída.



33

begin (...) Entra_regiao_critica; (* protocolo de entrada *) Regiao_critica; Sai_regiao_critica; (* protocolo de saída *) (...) end

3.5. Problemas de Sincronização

Na tentativa de implementar a exclusão mútua, algumas soluções introduzem novos problemas, que chamaremos de problemas de sincronização. Qualquer solução para os problemas de compartilhamento de recursos entre processo, passa necessariamente pela solução dos problemas de sincronização.

A seguir, examinaremos alguns problemas, bastante comuns, decorrentes da sincronização entre processos.

3.5.1. Velocidade de Execução dos Processos

A velocidade de execução dos processos pode interferir em uma boa solução para o problema de exclusão mútua. Um processo mais rápido que queira acessar sua região crítica pode ficar muito tempo esperando, por estar esperando por um processo mais lento.

3.5.2. Starvation

Um outro problema, também decorrente da sincronização entre processos, é denominado starvation. Starvation é a situação onde um processo nunca consegue executar sua região crítica e, conseqüentemente, acessar o seu recurso compartilhado. Isto pode acontecer, por exemplo, quando um processo tem baixa prioridade em relação aos outros, que concorram pelo mesmo recurso. Uma solução bastante simples para esse problema é a criação de filas de pedidos de alocação para cada recurso compartilhado. O esquema de o primeiro a chegar ser o primeiro a ser atendido (FIFO) elimina o problema do starvation.

3.5.3. Sincronização Condicional

Outra situação na qual é necessária a sincronização entre processos concorrentes, é quando um recurso compartilhado não se encontra pronto para ser utilizado pelos processos. Nesse caso, o processo que deseja acessar o recurso deverá ser colocado no estado de espera, até o recurso ficar pronto para o processamento. Esse tipo de sincronização é chamado sincronização condicional.

Um exemplo clássico é a comunicação entre dois processos através de operações de gravação e leitura em um buffer. Nessa comunicação, um processo grava dados em um buffer, enquanto outro lê, concorrentemente, os dados do buffer. Os processos envolvidos devem estar sincronizados, de forma que um processo não tente gravar dados em um buffer cheio ou ler de um buffer vazio.



34

3.6. Soluções de Hardware para o Problema de Exclusão Mútua

3.6.1. Desabilitação de Interrupções

A solução mais simples para o problema da exclusão mútua é fazer com que o processo, antes de entrar em sua região crítica, desabilite todas as interrupções externas e as reabilite após deixar a região crítica. Um dos problemas deste mecanismo é quando o processo que desabilitou as interrupções não torna a habilitá-las. Nesse caso, o sistema, provavelmente, terá seu funcionamento seriamente comprometido.

3.6.2. Instrução Test-and-Set

Muitos processadores possuem uma instrução especial que permite ler uma variável, armazenar seu conteúdo em outra área e atribuir um novo valor a essa variável. Esse tipo especial de instrução é chamado instrução test-and-set e tem como característica ser sempre executada sem interrupção, ou seja, trata-se de uma instrução indivisível. Assim, não existe a possibilidade de dois processos estarem manipulando uma variável compartilhada ao mesmo tempo, possibilitando a implementação da exclusão mútua.

A instrução test-and-set possui o formato abaixo e na sua execução o valor lógico da variável Y é copiado para X, sendo atribuído à variável Y o valor lógico verdadeiro.

Test-and-Set (X,Y);

Para coordenar o acesso concorrente a um recurso, a instrução test-and-set utiliza uma variável lógica global que chamaremos bloqueio. Quando a variável bloqueio for falsa, qualquer processo poderá alterar seu valor para verdadeiro, através da instrução test-and-set e, assim, acessar o recurso de forma exclusiva. Ao terminar o acesso, o processo deve simplesmente retornar o valor da variável para falso, liberando o acesso ao recurso.

program programa_test_and_set; var bloqueio: boolean; procedure processo_A; var pode_a : boolean; begin repeat pode_a := true; while (pode_a) do test_and_set (pode_a, bloqueio); regiao_critica_A; bloqueio := false; until false; end; procedure processo_B; var pode_b : boolean; begin



35

repeat pode_b := true; while (pode_b) do test_and_set (pode_b, bloqueio); regiao_critica_B; bloqueio := false; until false; end; begin bloqueio := false; PARBEGIN processo_A; processo_B; PAREND; end. 3.7. Soluções de Software para o Problema de Exclusão Mútua

Além da exclusão mútua, que soluciona os problemas de compartilhamento de recursos, três fatores fundamentais para a solução dos problemas de sincronização deverão ser atendidos:

O número de processadores e o tempo de execução dos processos concorrentes devem ser irrelevantes.

Um processo, fora de sua região crítica, não pode impedir que outros processos entrem nas suas próprias regiões críticas.

Um processo não pode ficar indefinidamente esperando para entrar em sua região crítica.

As ferramentas mais recentes de software utilizadas para a solução de problemas de sincronização entre processos são os SEMÁFOROS, uma solução de alto nível denominada MONITORES e a TROCA DE MENSAGENS.

3.7.1. Semáforos

O conceito de semáforo foi proposto como uma solução mais geral e simples, para os problemas de sincronização entre processos concorrentes.

Um semáforo é uma estrutura composta de uma FILA e uma variável inteira, não negativa, que só pode ser manipulada por duas instruções: DOWN e UP. Estas instruções funcionam como protocolo de entrada e saída no caso de exclusão mútua.

Sempre que deseja entrar na sua região crítica, um processo executa uma instrução DOWN. Se o semáforo for maior que 0, este é decrementado de 1, e o processo que solicitou a operação pode executar sua região crítica. Entretanto, se uma instrução DOWN é executada em um semáforo cujo valor seja igual a 0, o processo que solicitou a operação ficará no estado de espera, em uma fila associada ao semáforo.



36

O processo que está acessando o recurso, ao sair da sua região crítica,

executa uma instrução UP, incrementando o semáforo de 1 e liberando o acesso ao recurso. Se um ou mais processos estiverem esperando, devido a operações DOWN pendentes o sistema escolhe um processo na fila de espera e muda seu estado para pronto.

As instruções DOWN e UP em sintaxe PASCAL não convencional:

type semaforo = record fila_espera : fila; valor : integer; end; procedure DOWN (var s : semaforo); begin if (s.valor = 0) then coloca_processo_na_fila_de_espera else s.valor := s.valor – 1; end; procedure UP (var s : semaforo); begin if (tem_processo_esperando) then tira_da_fila_de_espera else s.valor := s.valor + 1; end;

As operações DOWN e UP são indivisíveis; assim, é garantido que, se uma das operações for iniciada, nenhum outro processo poderá ter acesso ao semáforo até o término dessa operação.

O programa a seguir mostra uma solução para o problema de exclusão mútua entre dois processos através do uso de semáforos. Inicialmente, o semáforo está com o valor 1, indicando que nenhum processo está executando sua região crítica. O Processo_A executa a instrução DOWN, fazendo com que o semáforo seja decrementado de 1 e passe a ter o valor 0. Em seguida, o Processo_A ganha o acesso a sua região crítica. O Processo_B também executa a instrução DOWN, mas como seu valor é igual a 0, ficará aguardando até que o Processo_A execute a instrução UP, ou seja, volte o valor do semáforo para 1.

program semaforo; var s : semaforo; procedure processo_A; begin repeat DOWN(s); regiao_critica_A;

UP(s); until false; end;



37

procedure processo_B; begin repeat DOWN(s); regiao_critica_B;

UP(s); until false; end; begin s.valor := 1; PARBEGIN processo_A; processo_B; PAREND; end.

3.7.2. Monitores

O uso de semáforos exige do programador muito cuidado, pois qualquer engano pode levar a problemas de sincronização imprevisíveis. Monitores são mecanismos de sincronização de alto nível, que tentam tornar mais fácil o desenvolvimento e a correção de programas concorrentes.

Vejamos um exemplo bem simples, onde dois processos somam e diminuem, concorrentemente, o valor da variável compartilhada X.

program exemplo; monitor regiao_critica;

var x : integer; procedure soma; begin

x:= x + 1; end; procedure diminui; begin

x := x –1 ; end;

begin x := 0; end;

begin

PARBEGIN regiao_critica.soma; regiao_critica.diminui;

PAREND; end;

A inicialização da variável compartilhada X com o valor zero só acontece uma vez, no momento da primeira ativação do monitor regiao_critica. Neste exemplo, pode-se garantir que o valor de X ao final da execução concorrente dos procedimentos de soma e diminuição será igual a zero. Isso porque, como os procedimentos estão definidos dentro do monitor, estará garantida a execução mutuamente exclusiva entre eles.



38

3.7.3. Troca de Mensagens

Troca de mensagem é um mecanismo de comunicação e

sincronização entre processos, implementado pelo sistema operacional através de duas rotinas do sistema: SEND e RECEIVE. A rotina SEND é responsável por enviar uma mensagem para um processo receptor, e a rotina RECEIVE por receber uma mensagem de um processo transmissor. As rotinas podem ser representadas através dos procedimentos a seguir:

SEND (receptor, mensagem); RECEIVE (transmissor, mensagem);

Os procedimentos SEND e RECEIVE, mesmo não sendo suas execuções mutuamente exclusivas, permitem tanto a comunicação entre processos como a sincronização entre eles. A comunicação ocorre porque um processo, ao receber uma mensagem, obtém dados enviados de outro processo. A sincronização é obtida porque uma mensagem somente pode ser lida após ter sido enviada, restringindo, dessa forma, a ordem na qual os dois eventos devem ocorrer.

Exemplo:

program produtor_consumidor;

procedure produtor; var msg: tipo_msg; begin repeat produz_mensagem (msg); SEND (msg); until false; end;

procedure consumidor; var msg: tipo_msg; begin repeat RECEIVE (msg); consome_mensagem (msg); until false; end;

begin PARBEGIN produtor; consumidor; PAREND; end.

3.8. Deadlock

Um processo é dito em deadlock quando está esperando por um evento que nunca ocorrerá. Esta situação é consequência, na maioria das vezes, do compartilhamento de recursos do sistema entre vários processos, sendo que cada processo deve ter acesso ao recurso de forma exclusiva (exclusão mutua).



39

4. Gerência do Processador

4.1. Introdução

O conceito básico que gerou a implementação dos sistemas multiprogramáveis foi a possibilidade de a UCP ser compartilhada entre diversos processos. Por isso, o procedimento para o escalonamento de processos (seleção de processos entre os vários que estão na fila de pronto para utilização do processador), é uma das principais funções executadas pelo sistema operacional multiprogramável.

Execução (UCP)

Espera

Pronto

Processo

Processo

Processo

ProcessoProcesso

Escalonamento

Principais Objetivos do Escalonador de Processos:

Manter a UCP ocupada o maior tempo possível;

Balancear a utilização do processador entre os diversos processos;

Maximizar o throughput do sistema (número de processos executados num intervalo de tempo);

Oferecer um tempo de resposta razoável para os usuários interativos.

Para atender alguns desses objetivos, os sistemas operacionais devem levar em consideração as características dos processos, ou seja, se um processo é do tipo batch, interativo, CPU-bound ou I/O-bound. Sistemas de tempo real e de tempo compartilhado também são aspectos fundamentais para a implementação de uma política de escalonamento.

4.2. Critérios de Escalonamento

Utilização de UCP: É desejável que o processador fique a maior parte do seu tempo ocupado;

Throughput: O throughput representa o número de processos (tarefas) executados em um intervalo de tempo. A maximização do throughput é desejada na maioria dos sistemas.

Tempo de Turnaround: Tempo que um processo leva desde sua admissão no sistema até o seu término, levando em consideração o tempo de espera para alocação de memória, espera na fila de processos prontos para execução, processamento na UCP e operações de E/S.



40

Tempo de Resposta: Em sistemas interativos, o tempo de resposta é o tempo decorrido do momento da submissão de um pedido até a primeira resposta produzida.

De um modo geral, qualquer algoritmo de escalonamento busca otimizar a utilização da UCP e o throughput, enquanto tenta diminuir o tempo de turnaround e de resposta.

4.3. Escalonamento Não-preempitivo

O escalonamento não-preemptivo é aquele que quando um processo ganha o direito de utilizar a UCP, nenhum outro processo pode tirar esse recurso. Alguns escalonamentos não-preemptivos são:

4.3.1. Escalonamento First-In-First-Out (FIFO)

O processo que chega primeiro (first-in) ao estado de pronto é o primeiro a ser selecionado para ocupar a UCP (first-out).

Problema: Impossibilidade de prever quando o processo terá sua execução iniciada.

4.3.2. Escalonamento Shortest-Job-First (SJF)

Este algoritmo associa cada processo (ou job) ao seu tempo de execução. Dessa forma, quando o processador está livre, o processo em estado de pronto que precisar de menor tempo de UCP para terminar o seu processamento é selecionado para execução.

Problema: Determinar quanto tempo de UCP cada processo necessita para o seu processamento.

4.3.3. Escalonamento Cooperativo

A partir do momento que o processo está em execução, este voluntariamente libera o processador, retornando a fila de pronto.

Problema: Um programa pode não liberar o processador, monopolizando desta forma a UCP. Observação: Escalonamento FIFO e SJF não podem ser aplicados em sistemas de tempo compartilhado, onde um tempo de resposta razoável deve ser garantido para usuários interativos.

Exercício: Simule as políticas de escalonamento não-preemptivas: FIFO, SJF e HRN, para situação de chegada de processos representada pela régua de tempo:

Tempo 1 2 3 4 5 6 7 (A,4),

(B,2) (C,3) (D,2),

(E,5) (F,1) (G,3),

(H,2) (I,1)

Onde: (X,Y), representa um identificador do processo (X) e o tempo estimado de execução do processo (Y).



41

4.4. Escalonamento Preempitivo

Um algoritmo de escalonamento é denominado preemptivo quando o sistema pode interromper um processo em execução para que outro processo utilize o processador. O escalonamento preemptivo permite que o sistema dê atenção imediata a processos mais prioritários, como no caso de sistemas de tempo real, além de proporcionar melhores tempos de resposta em sistemas de tempo compartilhado. Outro benefício é o compartilhamento do processador de uma maneira mais uniforme entre os processos. Vejamos, a seguir, alguns dos principais algoritmos de escalonamento preemptivos.

4.4.1. Escalonamento Circular (Round Robin)

Projetado para sistema de tempo compartilhado, é semelhante ao escalonamento FIFO, porém, quando um processo passa para o estado de execução, ou seja, ganha a UCP, existe um tempo limite para sua utilização de forma contínua. Quando este tempo, denominado time-slice ou quantum, expira, o processo volta para o fim da fila de prontos, dando a vez para outro processo. Este mecanismo é definido como preempção por tempo.

Problema: Não faz um compartilhamento eqüitativo, pois este escalonamento trata todos os processo de maneira igual.

4.4.2. Escalonamento por Prioridades

Nesse esquema, processos de maior prioridade são escalonados preferencialmente. Toda vez que um processo vai para a fila de pronto com uma prioridade maior do que processo em execução, o sistema deve interromper o processo corrente, colocá-lo no estado de pronto e selecionar o de maior prioridade para ser executado. Este mecanismo é definido como preempção por prioridade.

A prioridade é estática quando não é modificada durante a existência do processo. A prioridade é dinâmica se pode ser ajustada durante a vida do processo.

4.4.3. Escalonamento por Múltiplas Filas

Como os diversos processos do sistema possuem características de processamento diferentes, é difícil que um único mecanismo de escalonamento seja adequado a todos os tipos de processos.

O escalonamento por múltiplas filas implementa diversas filas de processos no estado de pronto, onde cada processo é associado exclusivamente a uma delas. Cada fila possui mecanismo próprio de escalonamento, em função das características dos processos.

Cada fila possui uma prioridade associada, que estabelece quais filas são prioritárias em relação às outras. O sistema só pode escalonar processos de uma fila, se todas as outras de prioridade maior estiverem vazias.



42

4.4.4. Escalonamento por Múltiplas Filas com Realimentação

Semelhante ao escalonamento anterior, porém os processos não permanecem em uma mesma fila até o término do processamento. Neste escalonamento, o sistema tenta identificar dinamicamente o comportamento de cada processo, ajustando assim suas prioridades de execução e mecanismos de escalonamento.

Problema: Devido a sua complexidade, este escalonamento pode gerar um grande overhead ao sistema, o que, mesmo assim, pode justificar sua implementação.

4.4.5. Escalonamento de Sistemas de Tempo Real

Nos sistemas operacionais de tempo real, o fator tempo é crítico. Neste tipo de escalonamento não existe o conceito de quantum ou time-slice. O escalonamento é realizado unicamente com base no esquema de prioridades. Para cada processo é atribuída uma prioridade associada à sua importância dentro do sistema. Esta prioridade deve ser estática, não devendo ser alterada no decorrer do processamento.

Este escalonamento deve ser empregado na solução de aplicações onde existam graus de exigências em relação ao tempo de execução das tarefas. Por exemplo, um sistema de controle de tráfego aéreo.

4.5. Escalonamento com Múltiplos Processadores

O escalonamento para sistemas com múltiplos processadores é bem mais complexo. A abordagem é diferenciada quando tratamos de sistemas fracamente acoplados ou fortemente acoplados.

Em sistemas fracamente acoplados cada processador faz seu próprio escalonamento local.

Em sistemas fortemente acoplados é possível implementar uma única fila de pronto para todos os processadores. Todos os processos estão presentes nesta única fila e são escalonados no primeiro processador disponível. Nesta solução é importante que, para a execução do algoritmo de escalonamento, seja implementada a exclusão mútua para o seu código.



43

Bibliografia Livros:

MACHADO, Francis B.; MAIA, Luiz Paulo. Arquitetura de Sistemas Operacionais. 2. Ed. Rio de Janeiro: Livros Técnicos e Científicos, 1997.

OLIVEIRA, Rômulo Silva de; CARISSIMI, Alexandre da Silva; TOSCANI, Simão Sirineo. Sistemas Operacionais. 2ª Edição. Porto Alegre: Sagra-Luzzatto, 2001.

TANEMBAUM, A. S. Sistemas Operacionais Modernos. Editora Guanabara Koogan, 1995.

Endereços Eletrônicos:

http://www.ccuec.unicamp.br/treinamento_int2004/linux_basico/index.html

http://

http://www.ccuec.unicamp.br/treinamento_int2004/linux_basico/index.html

Documents

Sop Apostila