UNIVERSIDADE PAULISTA – UNIP FUNDAMENTOS DE SISTEMAS OPERACIONAIS

PROFESSOR PAULO HENRIQUE RODRIGUES > APOSTILA_02 <

SISTEMAS MONOTAREFA, MULTITAREFA, MULTIUSUÁRIO

Sistemas Monotarefa: Em computação, chama-se monotarefa um sistema operacional que permite a realização

de apenas uma tarefa de cada vez. Um dos mais famosos sistemas operacionais monotarefa é o MS-DOS, um

dos primeiros sistemas operacionais para computadores pessoais.

Sistemas Multitarefa: O primeiro passo para a criação de programas multitarefas foi a criação dos programas

TSR’s (Terminate and Stay Resident), que eram pequenos programas que permaneciam em memória enquanto

se executava outro programa, geralmente alternados com combinações de teclas. Exemplo: agendas e antivírus.

O passo seguinte foi a emulação de multitarefa. Exemplos são as primeiras versões do Windows (Windows 3.1 e

Windows 3.11, em que este trabalhava sobre o DOS (sistema operacional monotarefa) mas o núcleo do

programa tratava de fazer a sua própria gestão de processos. Se um processo bloqueasse o Windows, todas as

aplicações também travariam pois eram dependentes de um mesmo gestor de controle.

Posteriormente, surgiu um das principais componentes dos Sistemas Operacionais atuais, o escalonador de

processos (scheduler) que faria a gestão, qualificação e gerenciamento de prioridade dos processos sem afetar o

núcleo do Sistema Operacional.

Existem dois tipos de sistemas multitarefa:

1) Multitarefa de antecipação – Sistemas Operacionais com esta qualidade esforçam-se para conseguir uma

“democratização” dentro do processador. O kernel mantém em registro de todos os processos em execução

(árvores de processos, em virtude desses processos estarem ligados uns aos outros como os ramos de uma

árvore). Entre outros atributos acerca de cada processo, essa “árvore” inclui uma informação de prioridade

com a qual o kernel calcula o tempo de CPU que deve dar a cada processo. Quando esse tempo acaba, o

kernel tira o controle da CPU do processo e dá a outro processo que vem a seguir na fila. Quando a fila

acaba, o kernel volta a dar o controle da CPU ao primeiro processo, fechando o ciclo. Exemplos de Sistemas

Operacionais Multitarefa por Antecipação: Unix, Linux, BSD, Mac OS X, Windows NT4 e sistemas Windows

posteriores.

2) Multitarefa de cooperação – Neste tipo de sistema não há controle sobre o tempo de CPU que cada

processo consome. É dado o controle da CPU ao processo, e ele só devolve quando estiver pronto.

Atualmente quase nenhum sistema operacional utiliza esse modelo de multiprocessamento. O problema

maior nesse modelo é que quando um processo bloqueia a CPU, todos os processos em memória são

atingidos. Esse sistemas são também conhecidos como sistemas operacionais com alternância de tarefas

(task-switching). Exemplos: Windows 95/98, Mac OS.

Sistemas Multiusuário

Sistemas Operacionais Multiusuários são caracterizados por sistemas onde podem existir vários usuários para

uma mesma estação, garantindo a privacidade para os usuários e a possibilidade de gerenciamento dos recursos

de cada usuário em particular.

Um sistema multiusuário garante também uma maior segurança, principalmente para quem irá administrar o

sistema, pois em sistemas desse tipo cada serviço roda utilizando um usuário pertencente ao próprio serviço,

com permissão apenas para manipular arquivos utilizados para o funcionamento do serviço.

Caso houvesse apenas um usuário (uma única conta) e o mesmo pudesse manipular todo o sistema, o sistema

seria completamente vulnerável a ataques.

Uma conta pode ser vista como uma entidade a nível do sistema operacional que armazena informações do

tipo:

· Nome do usuário (username);

· Identificador do usuário no sistema (UID);

· Grupo ou equipe de trabalho;

· Diretório pessoal do usuário;

· Interpretador de comandos que o usuário utiliza;

· Credenciais ou senhas do usuário;

· Permissões do usuário.

Exemplos de Sistemas Operacionais Multiusuário: Unix, Linux, Windows Server.

SISTEMAS COM COMPARTILHAMENTO DE TEMPO (TIME SHARING)

Os sistemas operacionais multiprogramados apareceram numa época em que os usuários acessavam as

máquinas através de "terminais burros" (sem capacidade de processamento local). Todo o processamento era

feito num computador central, cujo tempo de processamento era então compartilhado pelos vários usuários.

São também conhecidos como sistemas online. Para cada usuário o sistema aloca uma fatia de tempo (time

slice) de processador, e caso o programa não seja concluído neste intervalo de tempo, é substituído por outro

usuário e aguarda outra fatia de tempo.

Memória e periféricos também são compartilhados.

O sistema cria para o usuário um ambiente de trabalho próprio, dando a impressão de que todo o sistema está

dedicado a ele.

SISTEMAS DISTRIBUÍDOS

Os sistemas são distribuídos quando ocorre a computação paralela e descentralizada, realizada por dois ou mais

computadores conectados através de uma rede, cujo objetivo é concluir uma tarefa em comum.

Segundo Tanenbaum, sistema distribuído é uma “coleção de computadores independentes que se apresenta ao

usuário como um sistema único e consistente”. Computação distribuída consiste em adicionar o poder

computacional de diversos computadores interligados por uma rede de computadores, ou quando temos dois

ou mais processadores trabalhando em conjunto num mesmo computador, para processar colaborativamente

determinada tarefa de forma coerente e transparente, ou seja, como se apenas um único e centralizado

computador estivesse executando a tarefa.

O uso de tais sistemas tem se expandido nos últimos anos principalmente devido ao contínuo barateamento e

disponibilidade de hardware para computadores, bem como de meios físicos de comunicação. As vantagens de

Sistemas Distribuídos incluem a possibilidade de seu crescimento incremental (ou seja, novos computadores e

linhas de comunicação serem acrescidos ao sistema), a possibilidade de implementação de tolerância a falhas

através da replicação de processos em unidades de computação distintas. Embora o hardware desses sistemas

estejam num estágio avançado de desenvolvimento, o mesmo não se pode afirmar em relação ao software,

devido a complexidade adicional inerente a sua distribuição.

A organização do hardware em sistemas com várias CPUs se dá por:

SISTEMAS PARALELOS

Constituído de vários processadores tipicamente homogêneos e localizados em um mesmo computador

Entre os sistemas paralelos, temos duas vertentes:

Multicomputadores – cada processador possui sua própria memória local

Multiprocessadores – os processadores compartilham memória

SISTEMAS FORTEMENTE ACOPLADOS

São compostos de dois ou mais processadores compartilhando a mesma memória e controlados por apenas um

único sistema operacional

Sistemas fortemente acoplados geralmente são utilizados em sistemas que fazem uso intensivo da CPU, e o

processamento é voltado para a solução de um único problema.

SISTEMAS FRACAMENTE ACOPLADOS

Possuem dois ou mais sistema de computação, conectados através de linhas de comunicação. Cada sistema

funciona de modo independente, possui seus próprios processadores, memória e dispositivos.

Podemos dizer que uma rede de computadores é um Sistema Fracamente Acoplado. Cada nó é totalmente

independente do outro, podendo inclusive possuir sistemas operacionais diferentes. Caso uma conexão ou nó

sofra qualquer problema, os sistemas podem continuar operando normalmente.

Um exemplo clássico de computação distribuída (Fracamente Acoplada) é o projeto “Seti at Home”

(http://setiathome.ssl.berkeley.edu/), que visa procurar, em sinais de rádio interplanetários, algum vestígio de

vida extraterrestre. Um exemplo são os clusters de Servidores de Datacenters.

SISTEMAS DE TEMPO REAL

Sistemas de tempo real são sistemas cujas características dependem do cumprimento de requisitos temporais e

lógicos e onde as consequências do não cumprimento desses mesmos requisitos podem causar prejuízos

nefastos, como por exemplo, relacionados a segurança de pessoas. Nesta perspectiva, um Sistema Operacional

de Tempo Real (SOTR ou RTOS – em inglês, “real-time operating system”) é uma aplicação multitarefa na qual

várias tarefas críticas devem ser processadas em simultâneo. O sistema deve assegurar que as tarefas críticas

sejam tratadas em tempo útil. O uso de SOTR simplifica o projeto de um sistema. De um modo geral, um sistema

pode sempre ser desmontado num conjunto de processos. A função do SOTR é gerenciar esses processos

atribuindo-lhes "espaço" para que cada um deles execute, sem que isso destrua a integridade temporal do

sistema, isto é, dando prioridade para os processos críticos.

GERENCIAMENTO DE PROCESSOS

CONCEITUAÇÃO DE PROCESSOS

Um conceito chave em qualquer sistema operacional é o processo. Um processo é basicamente um programa

em execução. Associado com cada processo está seu espaço de endereçamento que o processo pode ler e

gravar. O espaço de endereçamento contém o programa executável, os dados do programa e sua pilha. Também

associado com cada processo está um conjunto de registradores, incluindo o contador de programa, o ponteiro

da pilha, outros registradores de hardware e todas as demais informações necessárias para executar o

programa.

Quando um processo é interrompido por qualquer motivo, ele deve ser reiniciado exatamente no mesmo

estado em que estava quando foi suspenso. Isso significa que todas as informações sobre o processo devem ser

explicitamente salvas em algum lugar durante a suspensão. Quando um processo é suspenso temporariamente,

todos esses ponteiros devem ser salvos. Em muitos sistemas operacionais, todas as informações sobre cada

processo são armazenados em uma tabela do sistema operacional chamada tabela de processos, que é uma

matriz (ou lista encadeada) de estruturas, uma para cada processo atualmente existente.

As chamadas-chave do sistema de gerenciamento de processos são as que lidam com a criação e com o

encerramento de processos. Um exemplo típico é um processo chamado de interpretador de comandos ou shell

(que lê comandos do terminal). O usuário digita um comando que requisita a compilação de um programa. O

shell agora deve criar um novo processo que executará o compilador. Quando esse processo terminar a

compilação, ele executa uma chamada de sistema para encerrá-lo.

Se um processo pode criar um ou mais processos (referidos como processos-filho), os quais podem criar

processos-filho, rapidamente chegamos a estrutura de árvore de processos. Processos relacionais que estão

cooperando para executar uma tarefa frequentemente precisam comunicar-se entre si e sincronizar suas

atividades. Essa comunicação é chamada comunicação interprocessos.

Outras chamadas de sistema:

requisitar mais memória ou liberar memória não utilizada;

esperar um processo-filho terminar;

substituir o programa por um diferente.

Os sinais são análogos ao software das interrupções de hardware e podem ser gerados por uma variedade de

causas além da expiração de temporizadores.

CONCEITO DE PROCESSO E/OU PROGRAMA

Uma analogia para um processo (ou programa) é um confeiteiro seguindo a receita para se fazer um bolo (o

programa é a receita do bolo)

Se o filho do confeiteiro se machuca então o processo e todos os estados “fazer o bolo” é salvo pelo

confeiteiro e ele dá início ao processo de prioridade mais alta, seguindo o livro de primeiros socorros

Cada processo constitui uma atividade

Todo processo possui um programa associado, uma entrada, uma saída e um estado.

CRIAÇÃO DE PROCESSOS

Nos sistemas simples ou aqueles projetados para executar apenas uma única atividade (controlador de forno de

microondas) é possível ter todos os processos que serão necessários quando o sistema é ligado. Em sistema de

propósito geral, é necessário algum modo de criar e terminar processos durante a operação, quando for preciso.

Quatro eventos principais fazem com que processos sejam criados:

1) início do processo;

2) execução de uma chamada ao sistema de criação de processo por um processo em execução;

3) uma requisição do usuário para criar um novo processo;

4) início de um job em lote.

Quando um sistema operacional é iniciado criam-se vários processos, alguns processos de usuários (em primeiro

plano), outros do próprio sistema (segundo plano) e que apresentam função específica.

Exemplos de processo em segundo plano: requisições de páginas web, mensagens eletrônicas (outlook). Esses

processos são chamados de “daemons”.

Para ver os processos que estão em execução em Sistemas Unix/Linux utiliza-se o comando “ps uxa”

Para ver os processos que estão em execução em Sistemas Windows pressiona-se CTRL + ALT + DEL

Muitas vezes, um processo em execução emitirá chamadas ao sistema para criar um ou mais novos

processos para ajudá-lo em seu trabalho. Em um sistema multiprocessado, permitir que cada processo execute

em uma CPU diferente também torna o trabalho mais rápido.

Em sistemas interativos, os usuários podem iniciar um programa digitando um comando ou clicando (duas

vezes) em um ícone. Cada uma dessas ações inicia um novo processo e executa nele o programa selecionado.

Em sistemas Unix, baseados em comandos que executam o “X Window”, o novo processo toma posse da

janela na qual ele se iniciou. No Windows, quando iniciado, um processo não tem uma janela, mas ele pode criar

uma (ou mais de uma). Nos dois sistemas os usuários podem ter múltiplas janelas abertas ao mesmo tempo,

cada uma executando algum processo. Usando o mouse, o usuário seleciona uma janela e interage com o

processo.

TÉRMINO DE PROCESSOS

Todos os processos executam e terminam, em razão de alguma das seguintes condições:

1) saída normal (voluntária)

2) saída por erro (voluntária)

3) erro fatal (involuntário)

4) cancelamento por um outro processo (involuntário)

Quando um processo termina no Unix/Linux ele emite uma chamada ao sistema com a função “kill”. No

Windows a função correspondente chama-se “TerminateProcess”.

ESTADO DE PROCESSOS

Cada processo é uma entidade independente, com seu próprio contador de programa e estado interno, mas

muitas vezes os processos precisam interagir com os outros. Um processo pode gerar uma saída que outro

processo usa como entrada.

Exemplo Unix/Linux: “cat arquivo arquivo2 arquivo3|grep sorocaba”

Existem três estados para um processo:

1) em execução (usando realmente a CPU naquela momento)

2) pronto (executável, mas temporariamente parado para dar lugar a outro processo)

3) bloqueado (incapaz de executar enquanto um evento externo não ocorrer)

Transições 2 e 3 são causados pelo escalonador de processos – uma parte do sistema operacional – sem que o

processo saiba disso. Transição 2 ocorre quando o escalonador decide que o processo em execução já teve

tempo suficiente de CPU e é o momento de deixar outro processo ocupar o tempo da CPU.

IMPLEMENTAÇÃO DE PROCESSOS

Para implementar o modelo de processos, o sistema operacional mantém uma tabela (um vetor de estruturas)

chamada de tabela de processos, com uma entrada para cada processo. Essa tabela contém informações sobre

o estado do processo, seu contador de programa, o ponteiro da pilha, a alocação de memória, os estado de seus

arquivos abertos, sua informações sobre contabilidade e escalonamento e tudo o mais sobre o processo que

deva ser salvo quando o processo passar do estado em execução para o estado pronto ou bloqueado, para que

ele possa ser reiniciado depois, como se nunca tivesse sido bloqueado.

CONDIÇÕES DE CORRIDA A REGIÕES CRÍTICAS

Por causa do paralelismo dos processos pode ocorrer que num dia tudo funcione bem e no outro dia haja uma

pane com o mesmo procedimento. Ex: num dia o operador manda o Word imprimir um arquivo e em seguida

manda o Excel imprimir outro arquivo. Em geral esta operação dá certo. Num certo dia, não dá. Por quê?

Porque, por coincidência, tanto o Word quanto o Excel perguntaram ao mesmo tempo quantos arquivos havia

no spool. E os dois receberam a resposta de que o spool estava vazio. E os dois pegaram o primeiro "slot" do

spool e colocaram nele um arquivo a ser impresso.

Chamamos de CONDIÇÃO DE CORRIDA a esta situação em que o resultado final depende de uma condição

particular. Se nenhuma providência for tomada, a CONDIÇÃO DE CORRIDA existe. Nem por isto o resultado será

necessariamente desastroso. E isto é o mais grave. Se você fizer, testar e vender um sistema, mas simplesmente

esquecer de verificar se há CONDIÇÃO DE CORRIDA, pode estar vendendo uma bomba de retardo. A pane pode

surgir só muitos anos depois.

Como impedir que dois processos executem ao mesmo tempo, cada um, a sua REGIÃO CRÍTICA?

REGIÃO CRÍTICA é o trecho de programa do processo que manipula um RECURSO COMUM. Veja que para um

dado recurso (o spool, no exemplo) pode haver dois ou mais processos que tenham regiões críticas. Outras

regiões de programa podem ser críticas em relação a diferentes recursos. Uma região de programa só é crítica

se ela se refere, se ela manipula, um recurso que outro programa (processo) também manipula.

O ideal é que exista uma variável comum, que é consultada por todos os processos envolvidos, quando desejam

utilizar aquele recurso, de forma a impedir os problemas descritos acima.

CONCORRÊNCIA E SINCRONIZAÇÃO

MONITORES E SEMÁFOROS

Um semáforo é um protocolo usado para controle do acesso a recursos compartilhados. Seu objetivo é assinalar

a ocorrência de eventos ou sincronizar tarefas. Genericamente, é uma permissão que uma tarefa adquire para

continuar sendo executada. Se o semáforo já estiver em uso, a tarefa é suspensa até que o semáforo seja

liberado.

COMUNICAÇÃO INTERPROCESSOS

É possível projetar um sistema controlador de um forno de microondas (simples) ou controlador de uma central

nuclear (complexo) sem usar o conceito de processos, e sem o perigo de duas tarefas críticas serem executadas

ao mesmo tempo. Bsta uma série de “ifs” dentro de um grande while:

While (1){ if(hora_de_baixar_as_barras){....}

if(hora_de_medir_a_radiacao){....}

if(hora_de_recarregar_uranio){....}

...

}

Por que escrever o controle da Usina Nuclear usando o conceito de processos, se é perfeitamente possível viver

sem isso?

Perceba que dentro de cada bloco acima há muito tempo perdido. Se era hora de baixar as barras o computador

tinha de dar a ordem ao robô que baixa as barras e o computador fica esperando até o robô terminar o serviço.

Só depois ia tratar de medir a radiação. Alguém teve a brilhante idéia de reescrever o sistema de controle da

usina atômica usando o conceito de SISTEMAS OPERACIONAIS. Só que, como toda a solução, novos problemas

surgiram.

Cada bloco acima foi colocado na memória, e para cada bloco foi criada uma área de dados, e para cada bloco

foi criada uma pilha nova, e cada bloco foi rebatizado de PROCESSO_A, PROCESSO_B, PROCESSO_C.

Uma das grandes vantagens de escrever um sistema operacional e depois escrever programas para ele,

programas que se tornarão processos, é que não precisa compilar todo o grande laço da usina nuclear hipotética

mostrado acima a cada vez que um dos blocos é modificado.

A outra grande vantagem foi dita: os processos rodam todos ao mesmo tempo, usando melhor a CPU.

E uma terceira vantagem é que o mesmo programa pode servir para núcleo de outros processos. Basta ver o

Word. Uma só cópia do Word fica na memória e ele pode editar muitos arquivos ao mesmo tempo. Basta trocar

de janela. Em cada janela a pilha, os dados e o arquivo aberto são diferentes.

Mais uma vantagem: podemos criar um novo processo com o sistema em funcionamento. Qual o preço a

pagar?

O preço é que há processos INDEPENDENTES e há processos COLABORADORES. Há processos que devem

trabalhar em harmonia. Para harmonizar os processos foi necessário dotá-los de um sistema de comunicação. É

a COMUNICAÇÃO INTERPROCESSOS. Exatamente como dois motoristas numa cidade: cada um pode ir para

onde quiser, quando quiser, ao mesmo tempo que os outros motoristas. SALVO nas esquinas. A manobra de

acelerar, numa esquina, não pode ser feita ao mesmo tempo. Essa manobra é chamada, em informática,

REGIÃO CRÍTICA DO PROGRAMA. A faixa pintada na esquina é o RECURSO COMUM AOS DOIS PROCESSOS. Pode

ser comum a vários processos.

Podemos fazer um paralelo entre processos e seres vivos. Eles obviamente foram programados por alguém, mas

a partir do momento em que o programa do processo ganha um espaço em memória, ganha uma pilha, ganha

uma área de dados, e, principalmente, ganha uma identidade, ele se torna autônomo.

Um mesmo programa, colocado mais tarde na memória, vai se comportar de forma diferente. Porque

dependerá de dados a lhe serem fornecidos. Dependerá da política de escalonamento...

Nem todo processo precisa se comunicar com outro processo. Se um processo cuida de abrir as portas da usina

conforme o horário, o dia da semana, os feriados, ele não precisa se comunicar com o processo que controla as

barras de combustível nuclear. Em geral os processos rodam simultaneamente, mas em alguns casos é

conveniente que os processos interessados num recurso se ponham de acordo.

Não é apenas para decidir quem pode entrar em sua região crítica, e quem deve esperar para entrar em sua

região crítica que precisamos da comunicação interprocessos.

Há também o caso em que um processo deve passar uma informação a outro, como os processos que ordenam

arquivos e depois enviam o nome do arquivo para o processo de impressão.

ESCALONAMENTO DE PROCESSOS

Escalonamento se refere a como os processos são distribuídos para execução no processador (ou

processadores) em um Sistema de Computação.

Segundo Tanenbaum: “Quando mais de um processo é executável, o Sistema Operacional deve decidir qual será

executado primeiro. A parte do Sistema Operacional dedicada a esta decisão é chamada escalonador (scheduler)

e o algoritmo utilizado é chamado algoritmo de escalonamento (scheduling algorithm).”

A forma como ocorre o escalonamento é, em grande parte, responsável pela produtividade e eficiência atingidas

por um Sistema de Computação. Mais do que um mecanismo, o escalonamento deve representar uma política

de tratamento dos processos que permita obter os melhores resultados possíveis em um sistema.

Escalonamento Não Preemptivo

Quando o processador responsável por um processo não pode ser retirado até que o processo seja finalizado.

Escalonamento Preemptivo

A CPU designada para um processo pode ser retirada em favor de outro processo. Algoritmos preemptivos são

mais adequados para sistemas em que múltiplos processos requeiram atenção do sistema (no caso de sistemas

multiusuários interativos - de tempo compartilhado) ou sistema de tempo real. A preempção, nesses casos,

representa a mudança do processo em execução. Dessa forma, para que a CPU seja retirada de um processo,

anteriormente interrompido, é fundamental que ocorra a mudança de contexto dos processos. Essa mudança

existe que todo o estado de execução de um processo seja adequadamente armazenado para sua posterior

recuperação.

Já os algoritmos não preemptivos são mais simples, comparados aos preemptivos, e adequados ao

processamento não interativo, como o caso de processamentos em lote. Embora não proporcionem

interatividades, são mais eficientes e previsíveis quanto ao tempo de entrega de suas tarefas.

ALGORITMOS DE ESCALONAMENTO

Existem vários algoritmos de escalonamento cujo objetivo fundamental é alocar o processados para um certo

processo, dentre os vários existentes, otimizando um ou mais aspectos do comportamento geral do sistema. Os

mais algoritmos mais conhecidos são:

1) FIFO (First In, First Out)

Forma mais simples. No escalonamento FIFO (primeiro a entrar, primeiro a sair) os processos prontos são

colocados em uma fila organizada por ordem de chegada. Em seu momento, cada processo recebe a CPU até

que sua execução total seja completada, ou seja, o processo permanece em execução até que seja finalizado.

Dessa forma, o escalonamento FIFO é um algoritmo não preemptivo.

Embora todos os processos sejam tratados igualmente, processos de pequena duração serão favorecidos, pois

dependendo da quantidade de processos que existem para serem processados antes dele, e da duração de cada

um dos processos, o serviço oferecido para estes processos menores pode ser ruim.

Outro ponto a ser analisado é que processos importantes podem ficar esperando a execução de outros

processos menos importantes, pois FIFO não possui mecanismos para distinguir os processos, ou seja, não

distingue níveis de prioridade.

2) Escalonamento Round Robin (escalonamento circular)

No escalonamento Round Robin os processos também são organizados por fila segundo a ordem de chegada e

são despachados para execução pelo processador. Entretanto, ao invés de serem executados até o final, a cada

processo é concedido um pequeno intervalo de tempo, denominado fatia de tempo, também chamado de time-

slice, quantum de tempo ou quantum. Se o processo não finalizar nesse tempo, ele é substituído pelo próximo

processo na fila de processos prontos, sendo o processo interrompido colocado no final da fila. Isto quer dizer

que ao final da fatia de tempo do processo, ocorre a preempção do processador, ou seja, o processador é

designado a outro processo, sendo salvo o contexto do processo interrompido para permitir a continuidade da

conexão deste processo quando chegar o seu momento novamente.

O escalonamento Round Robin se baseia na utilização de temporizadores, sendo um algoritmo preemptivo e

bastante adequado para ambientes interativos, ou seja, em sistemas de tempo compartilhado onde existem

vários usuários simultâneos sendo, portanto, necessário garantir tempos de resposta razoáveis.

3) Escalonamento Shortest Job First

O escalonamento Shortest Job First (SJF - Menor Job Primeiro) é uma variante do escalonamento FIFO, onde os

processos em espera pelo processador são organizados em uma fila segundo seu tempo de serviço, sendo

colocados na frente os menores jobs, isto é, os que serão processados em intervalos de tempo menores.

Mesmo sendo uma forma de escalonamento não preemptivo, oferece a vantagem de proporcionar tempos

médios de espera menores do que aqueles obtidos por um esquema FIFO. O grande problema deste esquema

de escalonamento é que o tempo de processamento de um job não pode ser determinado antes de seu

processamento, sendo necessario o uso de estimativas feitas pelo usuário ou programador, ainda assim pouco,

precisas.

4) Escalonamento Multilevel Feedback Queues

O escalonamento MFQ (Multilevel Feedback Queues - Filas Multinível Realimentadas) é um interessante

esquema de escalonamento baseado em várias filas encadeadas.

Todos os processos são colocados inicialmente na fila de nível 1, a qual possui comportamento FIFO. Quando

utilizar a CPU podem ocorrer três situações:

1) o processo é finalizado e então retirado das filas;

2) o processo solicita o uso de dispositivos de E/S, ficando bloqueado até que o pedido de E/S seja atendido,

voltando para a mesma fila até que seu quantum se esgote;

3) tendo esgotado seu quantum inicial de tempo, o processo é colocado na fila de nível 2.

4) Observações:

O escalonamento MFQ possui níveis de prioridades sendo os processos que estão atualmente na fila 1 e os de

mais alta prioridade.A última fila apresenta um comportamento um pouco diferente: ela possui escalonamento

Round Robin, onde os processos permanecem até que sejam finalizados.

As seguintes observações são relevantes neste tipo de escalonamento:

a) processos cursos são favorecidos pois recebem tratamento prioritário enquanto permanecem nas filas de

nível superior;

b) processos com uso intenso de E/S são favorecidos, pois a utilização de E/S não os desloca para filas

inferiores, até que o seu quantum termine;

c) processos de duração maior também são favorecidos, pois os quanta de tempo são progressivamente

maiores nas filas de nível inferior.

GERENCIAMENTO DE MEMÓRIA

Memória é um importante recurso que deve ser gerenciado cuidadosamente. É senso comum perceber que,

embora a capacidade de memória disponível nos sistemas de computação cada vez aumente mais, os

desenvolvedores de software demandam por mais memória para que seus programas possam ser armazenados

e executados.

Como o próprio nome sugere, gerenciamento de memória é a tarefa desempenhada pela parte do SO que

gerencia a memória. É função desta parte do SO conhecer quais regiões da memória estão em uso e quais não

estão sendo usadas, alocar memória para processos quando eles necessitam dela e desalocá-la quando os

processos terminarem de ser executados e gerenciar o swapping entre a memória principal e o disco, quando a

memória principal não for grande o suficiente para comportar todos os processos.

A necessidade de manter múltiplos programas ativos na memória do sistema impõe outra necessidade: a de

controlar como esta memória é utilizada por estes vários programas. O gerenciamento de memória é, portanto,

o resultado da aplicação de duas práticas distintas dentro de um sistema de computação:

• como a memória é vista, isto é, como pode ser utilizada pelos processos existentes neste sistema;

• como os processos são tratados pelo SO quanto às suas necessidades de uso de memória.

ORGANIZAÇÃO HIERÁRQUICA DE MEMÓRIA

Em um sistema de computação, o armazenamento de dados ocorre em diversos níveis. Em outras palavras, o

armazenamento é realizado em diferentes tipos de dispositivos devido à quatro fatores básicos:

1.) tempo de acesso;

2.) velocidade de operação;

3.) custo por unidade de armazenamento;

4.) capacidade de armazenamento.

Armazenamento interno: posições de memória disponíveis internamente ao processador para permitir ou

agilizar sua operação. É constituído dos registradores do processador e de seu cache interno.

Armazenamento primário: posições de memória externa diretamente acessíveis pelo processador. Ex: SRAM,

DRAM, EPROM, PROM, entre outras.

Armazenamento secundário: posições de memória externa que não podem ser acessadas diretamente pelo

processador, devendo ser movidas para o armazenamento primário antes de sua utilização. Geralmente são os

dispositivos de armazenamento de massa, tais como o disco rígido.

O armazenamento interno possui as maiores velocidades de acesso, ou seja os menores tempos de acesso,

representando os melhores dispositivos em termos de desempenho, embora sejam os mais caros. Por outro

lado, os dispositivos de armazenamento secundário são os de maior capacidade e os de melhor relação

custo/byte, mas consideravelmente mais lentos. O armazenamento primário representa um caso intermediário,

onde a velocidade e o tempo de acesso são adequadas a operação direta com o processador, mas cujo custo

ainda assim é alto.

Os registradores, implementados em número limitado devido ao seu custo, são geralmente usados para manter

dentro do processador dados freqüentemente utilizados. Os caches interno e externo devido a sua maior

velocidade, são usados para manter uma porção do programa que pode ser executada mais rapidamente do que

na memória principal, aumentando o desempenho do sistema. A memória primária armazena os programas e

dados em execução no sistema. Os dispositivos de armazenamento secundário são usados para preservação dos

dados de forma que permaneçam por um bom tempo. O cache de disco é utilizado para acelerar a operação das

unidades de disco, podendo esta técnica ser utilizada para outros tipos de periféricos.

Alocações Particionadas Estática e Dinâmica

Nos sistemas multiprogramados, a memória primária foi dividida em blocos chamados de partições.

Inicialmente, as partições, embora de tamanho fixo, não tinham necessariamente o mesmo tamanho,

possibilitando diferentes configurações para sua utilização. Este esquema era conhecido como alocação

particionada estática e tinha como grandes problemas:

- O fato dos programas, normalmente, não preencherem totalmente as partições onde eram carregados,

desperdiçando espaço;

- Se um programa fosse maior do que qualquer partição livre, ele ficaria aguardando uma que o acomodasse,

mesmo se existisse duas ou mais partições adjacentes que, somadas, totalizassem o tamanho do programa. Este

tipo de problema, onde pedaços de memória ficam impedidos de serem usados por outros programas, é

chamado de fragmentação ou segmentação.

Dado o problema da fragmentação/segmentação na alocação particionada estática, foi necessário um outro tipo

de alocação como solução e, conseqüentemente, o aumento do compartilhamento da memória. Na alocação

particionada dinâmica, foi eliminado o conceito de partições de tamanho fixo. Nesse esquema, cada programa

utilizaria o espaço que necessitasse, passando esse pedaço a ser sua partição.

A princípio, o problema da fragmentação/segmentação pareceu estar resolvido, porém, neste caso, a

fragmentação/segmentação começará a ocorrer, realmente, quando os programas forem terminando e

deixando espaços cada vez menores na memória, não permitindo o ingresso de novos programas.

ARQUIVO DE PAGINAÇÃO / MEMÓRIA VIRTUAL / ARQUIVO DE TROCA

Em um sistema de Processamento em Lotes, a organização de memória em partições fixas é simples e eficiente.

Desde que jobs suficientes possam ser mantidos na memória de modo que a CPU fique ocupada todo o tempo,

não existe razão para usar outra organização mais complexa. Em sistemas de tempo compartilhado, a situação é

diferente: normalmente existem mais usuários do que memória para manter todos os seus processos

(programas), de modo que é necessário manter os processos em excesso no disco. Para executar tais processos,

é necessário que eles sejam trazidos para a memória principal. O movimento de processos da memória principal

para o disco e vice-versa é denominado de swapping/ paginação.

Nas alocações particionadas estática e dinâmica, um programa permanecia na memória principal até o final da

sua execução, inclusive nos momentos em que esperava um evento, como uma operação de leitura ou gravação

em periféricos. Em outras palavras, o programa somente sairia da memória principal quando tivesse terminada

sua execução. Swapping pode ser usado em sistemas multiprogramados com partições de tamanho variável.

Desta forma, de acordo com algum critério, um programa pode ser movido da memória principal para o disco

(swap out) e, este mesmo programa, pode voltar do disco para a memória principal (swap in), como se nada

tivesse acontecido.

O swapping é realizado por rotinas especiais do SO chamadas de relocadores ou swappers. O relocador realiza

uma cópia desta área de memória em um arquivo especial denominado arquivo de troca ou swap file. Ao copiar

a área de memória para o disco, tal área é assinalada como livre, tornando-a disponível para outros processos.

SISTEMAS DE ARQUIVO

CONCEITUAÇÃO

Um conceito habitual que compõe praticamente todos os sistemas operacionais é o sistema de arquivos. Uma

das principais funções do sistema operacional é ocultar as peculiaridades dos discos e de outros dispositivos de

E/S, fornecendo ao programador um modelo agradável e claro de arquivos, independente de dispositivos.

Chamadas ao sistema são obviamente necessárias para criar, remover, ler e escrever arquivos. Antes que possa

ser lido, um arquivo deve ser localizado no disco, aberto e, depois de lido, ser fechado. Desse modo, chamadas

ao sistema são fornecidas para fazer essas tarefas.

Para ter um local para guardar os arquivos, a maioria dos sistemas operacionais fornece o conceito de diretório

como um modo de agrupar arquivos. São necessárias chamadas ao sistema para criar, renomear e remover

diretórios e também para colocar arquivos nesses diretórios e/ou removê-los de lá. Podemos colocar dentro de

diretório arquivos ou outros diretórios. Esse modelo dá origem a uma hierarquia, chamada de sistema de

arquivos.

Conceito importante de um sistema baseado em Unix: sistema de arquivos montados

Hierarquias de processos e de arquivos são organizadas como árvores, com a diferença que hierarquia de

processos normalmente não são muito profundas (mais de três níveis não é comum); já hierarquias de arquivos

compõe-se, em geral, de quatro, cinco ou mais níveis de profundidade. Hierarquias de processos costumam ter

pouco tempo de vida, no máximo alguns minutos; hierarquia de diretórios, por outro lado, podem existir por

anos.

Cada arquivo dentro da hierarquia de diretórios pode ser especificado fornecendo-se o caminho (path name) a

partir do topo da hierarquia de diretórios, o diretório-raiz. Esse caminhos absolutos formam uma lista de

diretórios que deve ser percorrida a partir do diretório-raiz para chegar até o arquivo, com barras separando os

componentes.

Ex: /etc/sysconfig/network-scripts/ifcfg-eth0

Permissões: antes que possa ser lido ou escrito, um arquivo precisa ser aberto e, nesse momento, as permissões

são verificadas.

Conceitos de arquivos em Unix: arquivos especiais permitem que dispositivos de E/S pareçam-se com arquivos.

Desse modo, eles podem ser lidos e escritos com as mesmas chamadas ao sistema usadas para ler e escrever

arquivos. Existem dois tipos de arquivos especiais: arquivos especiais de bloco e arquivos especiais de

caracteres. Arquivos especiais de bloco: discos. Arquivos especiais de caracteres: usados para modelar

impressoras , modems e outros dispositivos que recebem ou enviam caracteres serialmente. Por convenção os

arquivos especiais são mantidos no diretório /dev. Ex: /dev/lp (impressora)

DIRETÓRIOS

Para controlar os arquivos, os sistemas de arquivos têm, em geral, diretórios ou pastas, que em muitos sistemas

são também arquivos.

Sistema de diretório em nível único

A maneira mais simples de sistemas de diretório é ter apenas um diretório contendo todos os arquivos.

Nos primeiros sistemas esse sistema era comum, em parte porque havia apenas um usuário (projetos de

software mais simples).

A vantagem desse sistema é a facilidade de encontrar os arquivos rapidamente.

Sistema de diretório em dois níveis

Para evitar conflitos causados por diferentes usuários escolhendo o mesmo nome para seus arquivos, o próximo

passo foi oferecer a cada usuário um diretório privado. O que está implícito é que quando um usuário tentar

abrir um arquivo o sistema sabe qual é o usuário e então sabe em qual diretório buscar. Com consequência é

necessário algum tipo de procedimento de identificação, através de nome ou identificador, que não era

requerido em sistema de diretório de nível único.

Quando esse sistema é implementado em sua forma mais básica, os usuários podem ter acesso somente aos

arquivos em seus próprios diretórios. Contudo, uma pequena extensão é feita para permitir que os usuários

tenham acesso aos arquivos de outros usuários, fornecendo alguma indicação sobre o proprietário do arquivo a

ser aberto.

Uma situação na qual os usuários precisam ter acesso a outros arquivos, além dos seus próprios, é na execução

de programa do sistema. Ter as cópias de todos os programas utilitários em cada diretório é obviamente

ineficiente. Portanto, há a necessidade de um diretório de sistema que contenha os programas executáveis.

Sistema de diretórios hierárquicos

Hierarquia em dois níveis elimina os conflitos de nomes entre os usuários, mas náo é satisfatório para os

usuários com número muito grande de arquivos. É comum aos usuários quererem agrupar seus arquivos,

assumindo critérios lógicos.

Faz-se necessária, dessa forma, uma hierarquia geral, ou seja, uma árvore de diretórios. Com essa estratégia,

cada usuário pode ter tantos diretórios quantos necessários para agrupar os arquivos de uma maneira natural.

Quase todos os modernos sistemas de arquivos são organizados assim.

Nomes de caminhos

Quando o sistema de arquivos é organizado como uma árvore de diretórios, é preciso algum modo de

especificar o nome dos arquivos. São usados, comumente, dois métodos.

Nome de caminho absoluto – caminho formado entre o diretório raiz e o arquivo.

Exemplos:

Sistemas Unix: /usr/sysconfig/network-scripts/ifcfg-eth0

Sistemas Windows: c:\windows\system32\ansi.sys

Nome de caminho relativo – diretório atual de trabalho ou apontamento para um diretório próximo, não sendo

necessário mostrar todo o caminho ao SO.

Ex: “cat group” ou “cat ../passwd”

MÉTODOS DE ALOCAÇÃO E GERENCIAMENTO DE ESPAÇO

Os sistemas são geralmente armazenados em disco; portanto, o gerenciamento do espaço em disco é uma das

principais preocupações dos projetistas de sistemas. Existem duas estratégias geralmente utilizadas para

armazenar um arquivo de “n” bytes:

são alocados “n” bytes consecutivos de espaço em disco

o arquivo é dividido em vários blocos (não necessariamente contíguos)

Tamanho de bloco - Uma vez que se opte pelo armazenamento em blocos de tamanho fixo, a questão que surge

é qual deverá ser o tamanho do bloco (cluster). Tamanhos de blocos devem ser pensados em relação aos dados

que o sistema comportará.

Quotas de disco – Para impedir exageros no uso do espaço em disco, os sistemas operacionais multiusuário

oferecem um mecanismo para impor cotas de disco. A idéia é que o administrador de sistema atribua a cada

usuário um pedaço de espaço em disco e o sistema operacional assegure que os usuários não excedam suas

cotas.

CONFIABILIDADE E SEGURANÇA

A destruição de um sistema de arquivos é muitas vezes um desastre maior que a destruição de um computador.

Se um computador for aniquilado pelo fogo, por descarga elétrica ou outros meios, geralmente troca-se o

computador e resolve-se o problema.

Para um sistema de arquivo de um computador que estiver irrecuperavelmente perdido, seja por causa do

hardware, do software, etc, pode ser impossível. Se programas, documentos, fichas de clientes, comprovantes

de pagamento de impostos, bancos de dados, planos de marketing, ou outros dados forem perdidos para

sempre, as consequências podem ser catastróficas. Embora sistema de arquivos não ofereça qualquer proteção

contra destruição física do equipamento ou do meio de armazenamento, ele pode ajudar a proteger a

informação.

Eis algumas formas de realizar a proteção de sistemas de arquivos:

Cópias de segurança (backup) – Utilizados para recuperação e restauração de arquivos deletados, sobrescritos

ou alterados indevidamente.

Os backups são feitos, geralmente uma vez por dia, em fitas que possuem dezenas ou centenas de GB de dados.

Normalmente apenas dados/documentos são guardados em fita (arquivos do sistema operacional não fazem

parte do backup) e podem ser:

● completos – de todos os dados e documentos, mesmo os que não foram alterados

● incrementais – apenas dos dados e documentos que foram alterados

Compressão de dados – Quando se trabalham com quantidades imensas de dados, pode ser desejável

comprimir os dados antes de escrevê-los na fita. Contudo, para muitos algoritmos de compressão, um pequeno

defeito na fita de cópia de segurança pode pôr a perder o algoritmo de descompressão e tornar impossível ler

todo um arquivo ou até mesmo toda a fita. Portanto, a decisão de comprimir os dados de cópia de segurança

deve ser cuidadosamente considerada.

Dados ”vivos” – É difícil realizar a cópia dos dados quando o sistema de arquivo estiver sendo utilizado. Se os

arquivos e os diretórios estiverem sendo criados, removidos e modificados durante o processo de cópia, a cópia

poderá se tornar inconsistente. Além do mais, fazer uma cópia (backup) pode levar horas. Portanto talvez seja

necessário deixar o sistema off-line para que o backup seja realizado de forma consistente. É por esse motivo

que muitos backups são realizados após a meia-noite (ou fora de horário comercial).

GERENCIAMENTO DE ENTRADA E SAÍDA

Todos os computadores possuem dispositivos físicos para entrada e saída. Afinal, para que serviria um

computador se os usuários não pudessem dizer o que deve ser feito e não conseguissem verificar os resultados

depois do trabalho finalizado? Existem vários tipos de dispositivos de entrada e saída, como teclados, monitores

e impressoras. Cabe ao sistema operacional gerenciar esses dispositivos.

Consequentemente todo sistema operacional possui um subsistema de E/S para gerenciar seus dispositivos de

E/S. Alguns dos programas de E/S são independentes de dispositivo, isto é, aplicam-se igualmente bem a muitos

ou a todos os dispositivos. Outras partes dele, como os drivers de dispositivo, são específicos a cada dispositivo

de E/S.

ENTRADA/SAÍDA MAPEADA NA MEMÓRIA

Cada controlador tem alguns registradores usados para a comunicação com a CPU. Por meio da escrita nesses

registradores, o sistema operacional pode comandar o dispositivo para entregar ou aceitar dados, alternar por si

mesmo entre ligar e desligar ou executar alguma outra tarefa. A partir da leitura desses registradores, o sistema

operacional pode descobrir o estado do dispositivo, se ele está preparado para aceitar um novo comando e

assim por diante.

Além dos registradores de controle, muitos dispositivos têm um buffer de dados que o sistema operacional pode

ler ou escrever. Por exemplo, é comum aos computadores exibirem gráficos na tela de vídeo por meio de uma

memória de acesso aleatório (RAM) para vídeo, a qual é basicamente apenas um buffer de dados, disponível

para ser escrita pelos programas ou pelo sistema operacional.

A questão que surge é como a CPU se comunica com os registradores dos controladores e com os buffers de

dados dos dispositivos. Há duas possibilidades. A primeira é a seguinte: cada registrador de controle é associado

a um número de porta de E/S. A outra é mapear todos os registradores de controle no espaço de

endereçamento da memória.

DISPOSITIVOS DE ENTRADA E SAÍDA (INPUT E OUTPUT)

Os dispositivos de entrada e saída (E/S) ou input/output (I/O) são também denominados periféricos. Eles

permitem a interação do processador com o meio externo.

Exemplos de dispositivos de entrada de informações: teclado, mouse, drive de CD / DVD-ROM, scanner,

microfone, joystick, câmera filmadora, câmera digital, tela sensível ao toque, mesa gráfica e caneta ótica.

Exemplos de dispositivos de saída de informações: monitor de vídeo, drive de CD-ROM, caixa de som,

impressora, sensores (movimento, temperatura etc) e óculos (para realidade virtual).

Exemplos de dispositivos tanto de entrada como de saída de informações: modem, drive de disquete, gravador

de CD/DVD e disco rígido.

CHAMADAS AO SISTEMA (SYSTEM CALL)

A interface entre o sistema operacional e os programas dos usuários é definida pelo conjunto de chamadas ao

sistema que o sistema operacional oferece. As chamadas ao sistema disponíveis na interface variam de um

sistema operacional para outro (embora os conceitos básicos tendam a ser os mesmos). Exemplo:

computadores baseados em Unix possuem bibliotecas de procedimentos de chamadas ao sistema diferentes

daqueles baseados em Windows. Essa biblioteca de procedimentos de chamadas ao sistema são programas em

C e/ou em outras linguagens.

// PROF. PAULO HENRIQUE RODRIGUES – UNIVERSIDADE PAULISTA UNIP //