Luiz Paulo Maia

SOsim: SIMULADOR PARA O ENSINO DE

SISTEMAS OPERACIONAIS

Orientador: Ageu C. Pacheco Jr., Ph.D.

Ncleo de Computao Eletrnica NCE

Instituto de Matemtica IM
Universidade Federal do Rio de Janeiro UFRJ

Rio de Janeiro, Maro de 2001

ii

SOsim: SIMULADOR PARA O ENSINO DE

SISTEMAS OPERACIONAIS

Luiz Paulo Maia

DISSERTAO SUBMETIDA AO CORPO DOCENTE DO INSTITUTO DE

MATEMTICA/NCLEO

DE

COMPUTAO

ELETRNICA

(NCE)

DA

UNIVERSIDADE FEDERAL DO RIO DE JANEIRO, COMO PARTE DOS

REQUISITOS NECESSRIOS OBTENO DO GRAU DE MESTRE EM
CINCIAS EM INFORMTICA.
Aprovada por:

Prof. Ageu C. Pacheco Jr., Ph.D.

Prof. Oswaldo Vernet de Souza Pires, D.Sc.

Profa. Margareth Simes Penello Meirelles, D.Sc.

RIO DE JANEIRO, RJ BRASIL

MARO DE 2001

iii

FICHA CATALOGRFICA

MAIA, LUIZ PAULO.

SOsim:

Simulador

para

Ensino

de

Sistemas

Operacionais. [Rio de Janeiro] 2001

IX, 85 p. 29,7 cm (IM/NCE/UFRJ, M.Sc., Informtica,
2001)
Dissertao Universidade Federal do Rio de Janeiro,
IM/NCE
1. Sistemas Operacionais. 2. Educao. 3. Ensino.
I. Tese (Mestr. IM/NCE/UFRJ). II Ttulo.

iv

AGRADECIMENTOS
Gostaria de agradecer inicialmente a Srgio Guedes (NCE/UFRJ), Eduardo Luiz Pareto
(NCE/UFRJ), Osvaldo Vernet (NCE/UFRJ), Fbio Ferrentine (NCE/UFRJ), Francis
Berenger Machado (PUC-Rio), Jos Lucas Mouro Rangel Netto (PUC-Rio), Sergio
Lifschitz (PUC-Rio) e Denis Cople (UERJ) pelo apoio dado na realizao deste
trabalho.
Gostaria tambm de agradecer especialmente ao meu orientador, professor Ageu
Pacheco (NCE/UFRJ), por sua pacincia e habilidade em lidar com as dificuldades de
um mestrando em tempo parcial.
Gostaria de agradecer Deise Lobo Cavalcante (Dona Deise), Regina Clia Gomes
Lima e aos demais profissionais da Secretaria Acadmica do IM/UFRJ.
Gostaria de agradecer aos amigos e familiares, presentes e ausentes, que tanto me
apoiaram para a realizao deste trabalho.
Finalmente, gostaria de agradecer Maria Clara e Maria Luiza por abrirem mo do
tempo que deveria dedicar a elas para a confeco deste trabalho de tese.

DEDICATRIA
Gostaria de dedicar este projeto ao mestre dos mestres, Prof. Jlio Salek Aude
(NCE/UFRJ), falecido poucas semanas antes da concluso deste trabalho.
Serei sempre grato a ele, por me mostrar o que ser realmente um professor. Dedicao,
humildade, pacincia, bom humor, conhecimento, simplicidade, didatismo eram apenas
alguns dos adjetivos para uma aula sua.
Fora da sala de aula, o Prof. Salek era um implementador de idias, uma usina de
realizaes. Alguns tm as idias, outros implementam, mas poucos idealizam e
realizam. Qualquer um com estes predicados poderia estar trabalhando em um dos mais
modernos centros de pesquisa do mundo. Mas no, o Prof. Salek escolheu o caminho
mais difcil para realizar seus desafios.
Professor, esteja o senhor onde estiver, saiba que seu trabalho e suas idias continuaro
a influenciar muitas pessoas, especialmente seus ex-alunos como eu. Espero, algum dia,
voltar a frequentar suas classes. Muito obrigado por tudo.

vi

Resumo da Tese apresentada ao IM/NCE/UFRJ como parte dos requisitos necessrios

para a obteno do grau de Mestre em Cincias (M.Sc.).

SOsim: Simulador para o Ensino de Sistemas Operacionais

Luiz Paulo Maia
Maro/2001
Orientador: Ageu C. Pacheco Jr.
Programa: Informtica
Um problema comum a professores e alunos de disciplinas na rea da Cincia da
Computao, tais como arquitetura de computadores e sistemas operacionais, a
relativa dificuldade em caracterizar a real dinmica dos eventos computacionais. Por
melhor que sejam o conhecimento e a comunicao do mestre, o racioccio e a ateno
dispensados pelos alunos, o perfeito entendimento dos conceitos abordados fica
comprometido pela esttica inerente da abordagem das disciplinas.
No caso especfico de sistemas operacionais, aps vrios anos envolvido com o seu
ensino, passei a procurar uma forma de dinamizar os conceitos e tcnicas apresentados.
O presente trabalho, conseqncia desta experincia, visa construir um simulador
grfico (SOsim) que sirva de ferramenta visual de suporte efetivo para o ensino e
aprendizado dos conceitos e tcnicas implementados nos sistemas operacionais atuais,
de forma a tornar este processo mais fcil e eficaz.
Aps finalizado, o simulador ser colocado disponvel na Internet para que professores
e alunos tenham acesso gratuito ao software de apoio educacional. Desta forma, o
programa poder ser utilizado como ferramenta de apoio ao ensino presencial ou
distncia.

vii

Abstract of Thesis presented to IM/NCE/UFRJ as a partial fulfillment of the

requirements for the degree of Master of Science (M.Sc.)

SOsim: A Simulator Supporting Lectures on Operating Systems

Luiz Paulo Maia
March/2001

Advisors: Ageu C. Pacheco Jr.

Department: Informatics
A common problem faced by teachers and students in classes of Computer Science
matters, such as computer architecture and operating systems, is the relative difficulty in
well reflecting the real dynamic nature of the computing events involved. No matter
how solid might be the knowledge and the communicating ability of the instructor, as
also the concentration and close attention paid by the students, the well understanding of
the concepts presented is impaired by the implicit static nature of the class or lecture
presentation.
In the specific case of operating systems, after many years lecturing on the subject, I
started searching for a way on improving the dynamics of the concepts & techniques
approached. The present work is the outcome of that search, and implements a simulator
(SOsim) with visual graphic facilities to serve as an effective supporting tool for a better
teaching & learning of the concepts & techniques implemented in current operating
systems, as a way to turn the whole process more efficient.
On completion, the simulator will be made available on the Internet, so that free access
to its educational contents will be assured to students and instructors.

viii

SUMRIO
1

VISO GERAL

1.1 Introduo --------------------------------------------------------------------------------------- 1

1.2 Motivao---------------------------------------------------------------------------------------- 2
1.3 Trabalho Proposto ------------------------------------------------------------------------------ 3
1.4 Estrutura do Trabalho -------------------------------------------------------------------------- 5
2

CONSIDERAES EDUCACIONAIS

2.1 Introduo --------------------------------------------------------------------------------------- 6

2.2 Modelos de Ensino ----------------------------------------------------------------------------- 6
2.3 Ferramentas de Ensino------------------------------------------------------------------------- 8
2.4 Trabalhos Relacionados --------------------------------------------------------------------- 10
2.4.1 BASI --------------------------------------------------------------------------------------- 11
2.4.2 NACHOS --------------------------------------------------------------------------------- 12
2.4.3 OSP ---------------------------------------------------------------------------------------- 13
2.4.4 MINIX ------------------------------------------------------------------------------------- 13
2.4.5 FreeBSD----------------------------------------------------------------------------------- 14
2.4.6 TROPIX ----------------------------------------------------------------------------------- 14
2.5 SOsim ------------------------------------------------------------------------------------------ 15
3

MODELO PROPOSTO

3.1 Introduo ------------------------------------------------------------------------------------- 19

3.2 Processo---------------------------------------------------------------------------------------- 21
3.2.1 Estados do Processo --------------------------------------------------------------------- 23
3.2.2 Mudanas de Estado do Processo------------------------------------------------------ 24
3.3 Gerncia do Processador -------------------------------------------------------------------- 26
3.3.1 Escalonamento No-Preemptivo------------------------------------------------------- 26
3.3.2 Escalonamento Preemptivo------------------------------------------------------------- 27
3.3.3 Critrios de Escalonamento ------------------------------------------------------------ 31

ix

3.4 Gerncia de Memria ------------------------------------------------------------------------ 32

3.4.1 Memria Virtual ------------------------------------------------------------------------- 33
3.4.2 Mapeamento ------------------------------------------------------------------------------ 35
3.4.3 Paginao --------------------------------------------------------------------------------- 36
3.4.4 Poltica de Busca de Pginas ----------------------------------------------------------- 38
3.4.5 Poltica de Alocao de Pginas ------------------------------------------------------- 39
3.4.6 Working Set------------------------------------------------------------------------------- 39
3.4.7 Poltica de Substituio de Pginas---------------------------------------------------- 41
3.4.8 Swapping ---------------------------------------------------------------------------------- 43
3.4.9 Thrashing---------------------------------------------------------------------------------- 44
4

ARQUITETURA E IMPLEMENTAO

4.1 Introduo ------------------------------------------------------------------------------------- 45

4.2 Orientao por Objetos ---------------------------------------------------------------------- 46
4.3 Multithread ------------------------------------------------------------------------------------ 47
4.4 Ambiente do Simulador --------------------------------------------------------------------- 49
4.5 Objetos do Simulador ------------------------------------------------------------------------ 54
4.6 Objeto Processo------------------------------------------------------------------------------- 57
4.6.1 Criao do Processo --------------------------------------------------------------------- 58
4.6.2 Visualizao dos Processos------------------------------------------------------------- 61
4.6.3 Visualizao dos PCBs------------------------------------------------------------------ 62
4.7 Gerncia do Processador -------------------------------------------------------------------- 63
4.8 Gerncia de Memria ------------------------------------------------------------------------ 65
4.8.1 Mapeamento ------------------------------------------------------------------------------ 68
4.8.2 Tamanho de Pgina ---------------------------------------------------------------------- 69
4.8.3 Lista de Frames--------------------------------------------------------------------------- 69
4.8.4 Poltica de Substituio de Pginas---------------------------------------------------- 70
4.8.5 Arquivo de Paginao ------------------------------------------------------------------- 73
4.9 Estatsticas de Simulao-------------------------------------------------------------------- 75

CONCLUSES E TRABALHOS FUTUROS

5.1 Introduo ------------------------------------------------------------------------------------- 77

5.2 Concluses------------------------------------------------------------------------------------- 77
5.3 Trabalhos Futuros ---------------------------------------------------------------------------- 78
REFERNCIAS BIBLIOGRFICAS ------------------------------------------------------ 81

xi

LISTA DE FIGURAS
Fig. 1.1 Viso da interface grfica do simulador--------------------------------------------- 4
Fig. 2.1 Interao simulador, professor e aluno -------------------------------------------- 15
Fig. 3.1 Sistema operacional genrico ------------------------------------------------------- 20
Fig. 3.2 Processo -------------------------------------------------------------------------------- 22
Fig. 3.3 Mudanas de estado do processo --------------------------------------------------- 25
Fig. 3.4 Espao de endereamento virtual--------------------------------------------------- 34
Fig. 3.5 Tabela de mapeamento--------------------------------------------------------------- 35
Fig. 3.6 Tabela de pginas--------------------------------------------------------------------- 37
Fig. 4.1 Ambiente monothread --------------------------------------------------------------- 48
Fig. 4.2 Ambiente multithread ---------------------------------------------------------------- 49
Fig. 4.3 Console--------------------------------------------------------------------------------- 50
Fig. 4.4 Gerncia do Processador------------------------------------------------------------- 51
Fig. 4.5 Gerncia de Memria ---------------------------------------------------------------- 52
Fig. 4.6 Log do simulador --------------------------------------------------------------------- 53
Fig. 4.7 Estatsticas do simulador ------------------------------------------------------------ 53
Fig. 4.8 Criao de processo(s) -------------------------------------------------------------- 59
Fig. 4.9 Visualizao dos processos --------------------------------------------------------- 61
Fig. 4.10 Process Control Block-------------------------------------------------------------- 62
Fig. 4.11 Estados dos processos no simulador---------------------------------------------- 63
Fig. 4.12 Opes de escalonamento---------------------------------------------------------- 64
Fig. 4.13 Memria principal------------------------------------------------------------------- 66
Fig. 4.14 Opes de memria ----------------------------------------------------------------- 67
Fig. 4.15 Tabela de pginas ------------------------------------------------------------------- 68
Fig 4.16 Poltica de substituio de pginas ------------------------------------------------ 71
Fig. 4.17 Arquivo de paginao e swapping ------------------------------------------------ 74

xii

LISTA DE TABELAS
Tab. 4.1 Formulrios --------------------------------------------------------------------------- 57
Tab. 4.2 Cdigos pr-definidos --------------------------------------------------------------- 60
Tab. 4.3 Tipos de instrues ------------------------------------------------------------------ 60
Tab. 4.4 Operaes sobre processos --------------------------------------------------------- 61
Tab. 4.5 Aumento de prioridade -------------------------------------------------------------- 65
Tab. 4.6 Indicadores estatsticos-------------------------------------------------------------- 75

CAPTULO 1 - VISO GERAL

1.1 Introduo
Na maioria dos cursos de computao, quer sejam graduao, mestrado, ps-graduao
ou extenso oferecida uma disciplina ou mais voltadas especificamente para o ensino
da arquitetura de sistemas operacionais. Estas disciplinas so a base de conhecimento
conceitual para que os alunos tenham a compreenso do funcionamento de sistemas
operacionais em uso atualmente, como as diversas verses do Unix (Linux, Solaris,
AIX, FreeBSD etc.) e a famlia Windows da Microsoft.
O currculo da disciplina Sistemas Operacionais envolve diversos aspectos um tanto
complexos, tais como o conceito de processos, escalonamento, gerncia de memria
virtual etc. A experincia de alunos e professores nesta rea tem mostrado como
grande a dificuldade em ensinar e compreender os modelos e tcnicas apresentados.
O modelo tradicional de aula em que o professor segue uma bibliografia e um
cronograma rgido de aulas, no suficiente para que a maioria dos alunos tenha uma
compreenso precisa do que est sendo ensinado. O problema no est no modelo de
ensino, baseado no comportamentalismo, mas na falta de ferramentas capazes de
traduzir os conceitos tericos apresentados em conceitos prticos.
Envolvido profissionalmente com a formao de recursos humanos tcnicos,
especificamente nesta rea de sistemas operacionais, pude observar durante estes anos
que as dificuldades do ensino e aprendizado do assunto no esto restritas somente ao
mbito acadmico. As mesmas limitaes aparecem em cursos especficos para
profissionais responsveis pela manuteno e gerncia de sistemas comerciais.
O simulador aqui desenvolvido tem como objetivo auxiliar o ensino e aprendizado de
sistemas operacionais. O SOsim servir como ferramenta de suporte visual para aulas de
sistemas operacionais, inclusive aquelas ministradas distncia. A distribuio do
software ser gratuita, estando disponvel na Internet para download.

1.2 Motivao
No incio da dcada de 1990, a bibliografia de referncia existente de boa qualidade no
pas sobre o tema Sistemas Operacionais era unicamente em lngua inglesa, dificultando
em muito sua aplicao nos cursos relacionados ao assunto. Ciente desta carncia, o
livro "Introduo Arquitetura de Sistemas Operacionais" foi escrito e publicado, na
tentativa de facilitar o ensino e aprendizado de sistemas operacionais [MACHADO,
1992]. A primeira edio foi amplamente aceita pela comunidade acadmica,
principalmente nos cursos de graduao e extenso. Uma segunda edio revisada e
ampliada foi lanada posteriormente com o novo nome de "Arquitetura de Sistemas
Operacionais" [MACHADO, 1997]. Neste perodo, o livro foi adotado em inmeras
instituies de ensino, inclusive em outros estados. Em 1998, colocamos na Internet
uma pgina com informaes adicionais sobre o livro e o tema [MAIA, 1998].
Apesar de todo o trabalho desenvolvido para facilitar o ensino e aprendizado de
sistemas operacionais, existe um problema que o material impresso no resolve. Por
melhores que sejam o professores e alunos, a apresentao da dinmica dos algoritmos e
mecanismos implementados limita-se visualizao de uma pequena seqncia de
eventos que tenta representar um grande nmero de situaes. Por exemplo, o
mecanismo de gerncia de memria virtual, que envolve tabelas de mapeamento e
traduo de endereos, extremamente difcil de ser apresentado de forma clara, devido
sua dinmica e complexidade.
A melhor forma de resolver o problema da apresentao da dinmica de um sistema
operacional seria implementar uma ferramenta que reduzisse a distncia entre o modelo
real e o modelo conceitual, tornando este ltimo mais prximo da realidade. Com base
nesta idia, foi o desenvolvido um simulador grfico (SOsim) que serve de ferramenta
visual de suporte para o ensino e aprendizado dos conceitos e tcnicas implementados
nos sistemas operacionais atuais, de forma a tornar este processo mais efetivo.
O simulador ser colocado disponvel na Internet para que professores e alunos tenham
acesso gratuito ao software de apoio educacional. Juntamente com o simulador, ser

lanada a terceira edio do livro Arquitetura de Sistemas Operacionais. Nesta nova

edio, alm da reviso e ampliao do material, estaremos atuando mais fortemente na
Internet, oferecendo exerccios e propostas de trabalhos baseados no SOsim.
1.3 Trabalho Proposto
A idia do presente projeto de tese em questo surgiu a partir de um trabalho de final de
curso de graduao em Informtica na UFRJ, desenvolvido para a disciplina de
Arquitetura de Computadores I, orientado na ocasio pelo Prof. Ageu C. Pacheco Jr.,
denominado de CPUsim [JUNQUEIRA, 1997].
O CPUsim permite visualizar dinamicamente o funcionamento de uma unidade central
de processamento (CPU), atravs do acompanhamento das aes de execuo e de
transferncia em/entre seus componentes clssicos: unidade lgica e aritmtica (ULA),
unidade de controle (UC) e memria principal. O CPUsim tornou-se uma tima
ferramenta de auxlio ao ensino de disciplinas ligadas arquitetura e organizao de
computadores.
O SOsim tem objetivos semelhantes ao simulador CPUsim, ou seja, servir de ferramenta
visual que mostre de forma precisa o funcionamento e os conceitos envolvidos em um
sistema operacional multiprogramvel. Atravs de uma interface simples, o aluno e/ou
professor podem utilizar o software educacional para consolidar conceitos apresentados
em sala de aula. Conceitos como processo, gerncia de processador e gerncia de
memria podem ser apresentados e analisados com o auxlio do simulador (Fig. 1.1).
O simulador de fcil instalao, no exige qualquer conhecimento de linguagem de
programao para ser utilizado e pode ser executado em um computador pessoal (PC)
que tenha o sistema operacional Microsoft Windows. O software foi desenvolvido em
Borland Delphi, utilizando-se o conceito de orientao a objetos, o que permite o fcil
acesso ao cdigo fonte e sua alterao.

Fig. 1.1 - Viso da interface grfica do simulador

A seguir, so apresentadas as principais contribuies esperadas para o ensino e
aprendizado de sistemas operacionais, a partir da efetiva utilizao do simulador SOsim:

Ampliar a eficincia no processo de ensino/aprendizado, a partir de sua interface

grfica e dos recursos de animao;

Melhorar a comunicao professor-aluno, ampliando o poder de compreenso e

entendimento dos conceitos por parte dos alunos;

Oferecer apoio para aulas presenciais e distncia;

Tornar a transferncia e aquisio de conhecimento mais participativa;

Atingir vrios tipos de cursos de sistemas operacionais e uma ampla diversidade de

professores e alunos.

1.4 Estrutura do Trabalho

Este trabalho foi organizado em captulos, sendo que neste primeiro captulo foi feita
uma abordagem geral das motivaes para o desenvolvimento desta dissertao de tese.
O captulo 2 apresenta os fundamentos educacionais que norteam o projeto do
simulador. O captulo 3 enfoca as diversas caractersticas do modelo proposto, base para
a compreenso dos demais captulos.
O captulo 4 descreve a arquitetura e implementao do simulador, com suas estruturas
internas, algoritmos e interfaces grficas, dando nfase gerncia do processador e
gerncia de memria, com ateno especial para a gerncia de memria virtual.
Finalmente, o captulo 5 trata das concluses sobre a tese apresentada e oferece
sugestes para trabalhos futuros.

CAPTULO 2 CONSIDERAES EDUCACIONAIS

2.1 Introduo
O simulador SOsim um software educacional voltado ao suporte do ensino de
conceitos ligados arquitetura de sistemas operacionais modernos, no entanto, o
simulador precisa ser utilizado dentro de um contetxo pedaggico. Isto significa que o
software no um fim em si mesmo, mas um meio de se ampliar as possibilidades e
efetividades do ensino.
Este captulo apresenta as consideraes educacionais que servem de suporte para o
simulador. Inicialmente so apresentados os modelos de ensino comportamentalista e
construtivista, e os tipos de ferramentas de ensino utilizadas atualmente. Em seguida,
so analisados os trabalhos relacionados disponveis. Finalmente so apresentadas as
vantagens educacionais da utilizao do simulador SOsim para o ensino de sistemas
operacionais.
2.2 Modelos de Ensino
De uma forma bastante resumida, sero apresentados os dois modelos de
ensino/aprendizado mais adotados atualmente: o comportamentalista (behaviorista) e o
construtivista [MELO, 1999]. A compreenso destas duas teorias de ensino necessria
para entender as vantagens pedaggicas trazidas pelo projeto SOsim.
No modelo comportamentalista, os alunos ficam diante de um professor que passa seus
conhecimentos seguindo um programa de curso bem definido e seqencial, geralmente
com base em uma bibliografia especfica. Nesta teoria, os alunos so avaliados atravs
de notas, a partir de critrios previamente definidos pelo professor. O modelo
comportamentalista fundamentado principalmente na figura do professor, ou seja, o
foco centrado no professor e no no aluno [BRENDA, 1998]. O comportamentalismo
tem sido o modelo de ensino/aprendizado dominante no pas.

No modelo construtivista, o professor tem a funo de facilitador (ou mediador) do

conhecimento e no um transmissor deste. Sua funo motivar nos alunos o esprito de
investigao crtico, participativo e cooperativo. Neste modelo, o foco principal no
aluno e o professor passa a ter o papel de tutor e incentivador do conhecimento
[HANLEY, 1994].
A concepo do simulador utilizar a teoria construtivista para incentivar o aluno a
explorar as diversas situaes e aprender com seus prprios erros, o que evitado no
modelo comportamentalista. Apesar do software no oferecer a possibilidade de
construo

colaborativa

de

conhecimento,

so

apresentadas

algumas

outras

caractersticas que o qualificam como tal:

Proporciona mltiplas representaes da realidade;

Enfatiza a construo do conhecimento;

Oferece um ambiente de aprendizado que simula a realidade, utilizando estudo de

casos;

Favorece o pensamento reflexivo em funo da experincia com o ambiente de

simulao;

Facilita a identificao, definio e soluo de problemas;

Permite ao aluno o controle do experimento, garantindo uma evoluo natural da

complexidade das simulaes.

A grande vantagem deste projeto de software educacional permitir a criao de um

ambiente hbrido de ensino/aprendizado, onde o comportamentalismo aplicado em
sala de aula e o construtivismo como apoio formao do conhecimento, permitindo a
experimentao das teorias apresentadas em sala de aula.
previsto em verses futuras tornar o SOsim em uma ferramenta educacional mais
colaborativa, permitindo trabalhos em grupos na forma de projetos e a construo
colaborativa do conhecimento. Seriam introduzidas interfaces pr-definidas com os
principais mdulos do simulador, de forma que novos mdulos pudessem ser
implementados/alterados conforme a realidade a ser simulada.

2.3 Ferramentas de Ensino

As primeiras ferramentas de ensino que utilizavam o computador foram baseadas na
mquina de B.F. Skinner, que implementava o conceito de instruo programada. Este
conceito baseia-se em dividir o contedo do curso em mdulos pequenos, logica e
seqencialmente encadeados. Cada mdulo finalizado com uma ou mais questes que
devem ser respondidas pelo aluno. Se o resultado esperado for alcanado o aluno passa
para o prximo mdulo, caso contrrio o aluno deve retornar e rever um ou mais
mdulos [VALENTE, 1993].
Durante a dcada de 1960, diversos programas de instruo programada foram
implementados, dando incio ao conceito de Computer Aided Instruction (CAI) ou
Programas Educacionais por Computador (PEC). A disseminao do CAI somente
aconteceu com a massificao do uso dos microcomputadores, permitindo a criao de
vrios tipos de cursos, como tutoriais, exerccio-e-prtica, avaliaes, jogos e
simulaes.
Existe um consenso que o computador no deve ser utilizado para ensinar diretamente,
substituindo o professor, mas sim promover o aprendizado, passando a ser uma
ferramenta educacional. Isto significa que o professor deixa de ser o repassador de
conhecimento e torna-se o criador de ambientes de ensino e facilitador do processo de
aprendizado.

Programas Tutorias

Os programas tutoriais so uma verso computadorizada das aulas tradicionais. Suas

vantagens em relao ao modelo convencional a utilizao de animaes, som,
controle do desempenho do aluno, aferio do aprendizado etc.
A maioria dos programas tutoriais so verses eletrnicas do mundo real, ou seja, da
sala de aula, guardando todos os problemas deste modelo de ensino. A tendncia dos

programas tutoriais a implementao de tcnicas de inteligncia artificial para

analisar, avaliar e oferecer solues para as dificuldades do aluno.

Programas Exerccio-e-Prtica

Os programas exerccio-e-prtica (drill-and-practice) so utilizados para revisar os

conceitos apresentados em aula, utilizando as caractersticas de multimdia dos sistemas
computadorizados. Estes programas requerem respostas freqentes do aluno,
propiciando o feedback imediato, exploram o lado de multimdia e interatividade do
software educacional, sendo apresentados geralmente em forma de jogos.

Simulaes

Uma simulao envolve a criao de modelos dinmicos e simplificados do mundo real.

As primeiras simulaes foram desenvolvidas para criar um ambiente seguro para
atividades que oferecessem risco ao ser humano, como as simulaes de viagens
espaciais e mergulhos profundos. Posteriormente, as simulaes foram aplicadas a
processos que exigiam grande investimento de tempo e/ou dinheiro, como na indstria
automobilstica e aviao.
No mundo acadmico, a simulao permite ao aluno desenvolver hipteses, test-las,
analisar os resultados e sedimentar seus conhecimentos. O potencial educacional deste
tipo de ferramenta muito superior que os programas tradicionais, como tutoriais e
exerccio-e-prtica.
Existem diversas reas do conhecimento que fazem uso de simulaes, como
engenharia, fsica, qumica, biologia, economia etc. Na rea da Cincia da Computao
existem simuladores que auxiliam no ensino de vrias disciplinas, como redes de
computadores, tcnicas de programao, arquitetura de computadores [HERROD, 1998]
[JUNQUEIRA, 1997], sistemas operacionais, dentre outras.

10

A grande vantagem deste tipo de software educacional sua simplicidade de utilizao,

dispensando o aluno de detalhes de instalao e interao dos ambientes reais. A
simulao deve ser utilizada como uma complementao das aulas tradicionais, de
forma a sedimentar os conceitos e tcnicas apresentados.
Apesar de suas vantagens, a construo de simuladores no simples, pois envolve um
grande esforo de programao e recursos multimdia (som, vdeo, imagem) para tornar
a simulao prxima da realidade. Estes fatos tornam os projetos de simuladores longos
e dispendiosos financeiramente.
Este tipo de ferramenta indicada para cursos onde o aluno possui pouco conhecimento
prvio de sistemas operacionais, sendo indicado especialmente para cursos de extenso
e graduaes de curta durao.
2.4 Trabalhos Relacionados
Existem, atualmente, duas categorias de ferramentas que so utilizadas para o ensino de
sistemas operacionais: sistemas reais e simuladores.
Os sistemas reais oferecem o cdigo fonte para ser estudado e analisado por alunos e
professores. Inicialmente, o sistema deve ser instalado em um hardware apropriado,
exatamente como um sistema comercial. A partir de uma interface de comandos, o
aluno ou professor poder interagir com o sistema operacional e verificar sua
implementao no cdigo fonte do sistema.
A vantagem deste tipo de abordagem permitir ao aluno estudar em detalhes a
implementao de um sistema operacional, principalmente as interfaces com a
arquitetura de hardware, possibilitando ao aluno realizar alteraes no cdigo fonte e
verificar suas conseqncias na prtica. Nesta categoria podemos citar os sistemas
MINIX, FreeBSD, Linux e TROPIX.

11

O maior problema deste tipo de abordagem justamente a necessidade de entrar em

detalhes de implementao do sistema. A grande maioria dos currculos de sistemas
operacionais no tem esse objetivo e, mesmo que tivesse, a carga horria disponvel no
seria suficiente.
Este tipo de ferramenta de ensino mais indicado para estudantes de mestrado que
estejam interessados em especializao na rea de sistemas operacionais, que j tenham
bons conhecimentos de arquitetura de computadores e slidos conceitos de sistemas
operacionais.
Simuladores, por outro lado, oferecem uma forma mais acessvel a professores e alunos
de estudar os mecanismos bsicos de um sistema operacional, sem entrar em detalhes de
instalao do software, da arquitetura de hardware, programao assembly etc. Nesta
categoria podemos citar o BASI, NACHOS, OSP e o SOsim, objeto desta tese.
No caso especfico de simuladores para o estudo de sistemas operacionais existem os
genricos, que abordam a maioria dos mdulos de gerncia necessrios a um sistema
operacional, e os especficos, focados em algum mdulo do sistema, como de
escalonamento ou comunicao entre processos. O SOsim um simulador genrico que
cobre os principais mdulos de um sistema operacional moderno.
A seguir, so apresentadas as principais ferramentas voltadas para auxiliar o ensino de
sistemas operacionais:
2.4.1 BASI
O Ben-Ari Concurrent Interpreter (BASI) um simulador que permite desenvolver
programas concorrentes utilizando diversos mecanismos de sincronizao, como
semforos, mutexes e monitores. Como a maioria dos sistemas operacionais
multiprogramveis precisa implementar primitivas de sincronizao, geralmente as
disciplinas de sistemas operacionais apresentam estes conceitos, porm, de forma
superficial [BYNUM, 1996].

12

Sem a utilizao de um simulador deste tipo, a implementao prtica das tcnicas de

programao concorrente fica dependente de uma ou mais linguagens de programao,
como Pascal Concorrente, Modula e Ada. Outra opo seria a utilizao de system calls
do prprio sistema operacional, o que obrigaria ao estudante entrar em detalhes
especficos do sistema.
O BASI foi desenvolvido com base na verso do Pascal definido por M. Ben-Ari. Esta
verso um subconjunto do Pascal Padro (Pascal-S), definido por Niklaus Wirth, com
extenses para programao paralela, como construes cobegin/coend, wait e signal.
Comparado com outras linguagens concorrentes, o BASI oferece uma variedade de
tcnicas de sincronizao com uma sintaxe simples, permitindo que qualquer
programador C ou Pascal tenha acesso ao simulador.
O ambiente do BACI pode ser compilado e utilizado em ambientes Linux, RS/6000
AIX, SunOS, SGI IRIX e DOS, com pequenas modificaes nos arquivos de
configurao [BYNUM, 1999].
2.4.2 NACHOS
O NACHOS (Not Another Completely Heuristic Operating System) foi desenvolvido
por Tom Anderson, Wayne Christopher e Stephen Procter na Univerdade de Berkeley
Califrnia, com o propsito especfico de ser uma ferramenta para o auxlio ao ensino
de sistemas operacionais em cursos de graduao, podendo ser utilizado gratuitamente
[ANDERSON, 1999].
O ambiente foi concebido para que o aluno possa estudar, compreender e adicionar
componentes ao sistema, escrevendo cdigo para a gerncia de threads, gerncia de
arquivos, multiprogramao, memria virtual e redes. Alm do simulador para o sistema
operacional, o NACHOS oferece um ambiente de hardware simulado, onde o sistema
operacional suportado.

13

O NACHOS foi desenvolvido em C++ e est disponvel para a maioria das plataformas
Unix, como HP-UX, IBM-AIX, Sun Solaris, Linux e FreeBSD, alm do MS-DOS. At
o momento no existe uma verso para o sistema Windows da Microsoft.
2.4.3 OSP
O OSP (Operating System Project) foi desenvolvido por Michael Kifer e Scott Smolka,
no Departamento de Cincia da Computao da Universidade Suny Stony Brook, Nova
York [KIFER, 1991].
O simulador consiste de vrios mdulos, cada um responsvel por um servio do
sistema operacional, como escalonamento, tratamento de interrupes, gerncia de
arquivos, gerncia de memria e comunicao entre processos. A partir de um gerador
de projetos (OSP Project Generator) possvel montar um sistema operacional com
mdulos j existentes e mdulos desenvolvidos pelo prprio aluno.
O OSP foi desenvolvido em Linguagem C, sendo suportado pela maioria das
plataformas Unix, como SunOS, HP-UX, IBM-AIX, Linux e FreeBSD. Desta forma,
para que o aluno possa interagir com o ambiente necessrio ter domnio de
programao em Linguagem C em ambiente Unix, alm do conhecimento de estrutura
de dados.
2.4.4 MINIX
O MINIX um sistema operacional compatvel com o Unix que pode ser utilizado
gratuitamente para o ensino de sistemas operacionais, pois permite que um aluno instale
o sistema em um microcomputador e estude o seu cdigo fonte para compreender seu
funcionamento [TANENBAUM, 1996].
O MINIX foi desenvolvido pelo professor Andrew Tanenbaum da Vrije Universiteit em
Amsterdam, Holanda. Existem verses do sistema compatveis com a famlia de
processadores Intel, Macintosh, Amiga, Atari e SPARC da Sun Microsystems. O

14

MINIX foi desenvolvido em Linguagem C, oferece suporte a multiprogramao,

permite acesso multiusurio, disponibiliza diversos utilitrios e bibliotecas, oferece um
compilador C e suporte ao protocolo TCP/IP, dentre outras facilidades.
2.4.5 FreeBSD
O FreeBSD surgiu em 1993, na Universidade da California Berkeley, com base no
sistema 4.4BSD-Lite2, sendo suportado nas plataformas Intel e Compaq Alpha. O
sistema oferecido gratuitamente e pode ser utilizado para praticamente qualquer
aplicao, inclusive pedaggica [FREEBSD, 2000].
Suas principais caractersticas so:

Multitarefa preemptiva e suporte a multiplos usurios;

Suporte aos protocolos da famlia TCP/IP;

Esquema de gerncia de memria virtual;

Suporte a mltiplos processadores simtricos (SMP);

Vrias linguagens para desenvolvimento, como GNU C/C++, FORTRAN e Perl;

Cdigo fonte aberto, que permite seu estudo e/ou alterao.

2.4.6 TROPIX
O TROPIX um sistema operacional de filosofia Unix, desenvolvido no NCE/UFRJ
(Ncleo de Computao Eletrnico/Universidade Federal do Rio de Janeiro) e mantido
pelos professores Pedro Salenbauch e Oswaldo Vernet [TROPIX, 2000].
Foi inicialmente concebido em 1982, com o nome de PLURIX para um computador
tambm desenvolvido no NCE, o PEGASUS, baseado no processador Motorola 68000.
A partir de 1994, foi iniciada a converso do sistema para a plataforma Intel (386, 486 e
Pentium).

15

O TROPIX possui diversas aplicaes, tais como o ensino/aprendizado de sistemas

operacionais, desenvolvimento de software e implementao de servidores Internet. A
distribuio do sistema gratuita e seus manuais esto em portugus.
Suas principais caractersticas so:

Sistema multiusurio e multitarefa, com suporte a threads;

Memria compartilhada;

Utilitrios bsicos do Unix;

Ambiente de desenvolvimento em ANSI C;

Suporte para redes TCP/IP, SLIP e PPP;

Servios de rede do tipo telnet, rlogin, FTP, WWW, POP3 etc.

2.5 SOsim
O SOsim foi desenvolvido para servir de ferramenta de auxlio para o ensino de
sistemas operacionais, tornando o trabalho do professor mais eficaz. Aproximando a
teoria prtica, o simulador permite facilitar o entendimento e o aprendizado por parte
dos alunos. O software oferece a possibilidade de ampliar a interao entre alunos e
professores, em funo das experincias que cada um tenha desenvolvido (Fig. 2.1).

Fig. 2.1 - Interao simulador, professor e aluno

16

A seguir, so apresentadas as principais caractersticas e vantagens do simulador

SOsim:

Maior eficincia

O simulador permite aumentar a efetividade do processo de ensino/aprendizado,

principalmente em cursos de curta durao e baixos pr-requisitos. A partir de sua
interface grfica e dos recursos de animao possvel visualizar facilmente os diversos
conceitos e tcnicas encontrados em um sistema operacional multiprogramvel.
Alm disto, o software oferece opes de configurao que permitem que diferentes
algoritmos possam ser analisados e avaliados, como por exemplo o algoritmo de
escalonamento utilizado. Alm disso, o simulador oferece as opes de visualizao de
eventos atravs de logs e estatsticas dos diversos mdulos.
Como o uso do simulador, o professor tem a chance de apresentar os conceitos e
tcnicas de forma mais clara a partir de animaes, melhorando a comunicao com os
alunos e ampliando, assim, o poder de compreenso e entendimento dos conceitos
apresentados.

Facilidade de uso

A maioria dos software utilizados para o apoio ao ensino de sistemas operacionais cria
um ambiente idntico ao mundo real. Em funo do alto grau de complexidade de um
sistema operacional real, h um correspondente grau de dificuldade em utilizar este tipo
de software como ferramenta de suporte ao ensino.
O SOsim permite que o professor apresente a dinmica de um sistema operacional sem
necessariamente entrar em detalhes de hardware e/ou software, como exigido pelos
simuladores reais. O software no exige qualquer conhecimento de programao para
ser utilizado. Sua interface grfica intuitiva, eliminando as barreiras tradicionais
encontradas nos programas existentes. Este atributo especialmente importante nos

17

cursos com nfase em conceitos e no na implementao detalhada dos componentes de

um sistema operacional.
O aluno pode interagir com o simulador de forma a criar uma situao real e verificar
suas conseqncias. Por exemplo, ao criar um processo CPU-bound de alta prioridade, o
sistema fica dedicado a esta tarefa at o seu trmino.

Apoio presencial e no-presencial

Os professores podem utilizar o simulador em sala de aula como ferramenta de apoio s

aulas presenciais ou recomendar seu uso em outros momentos, como em laboratrios
nas escolas ou mesmo ser utilizado nos computadores pessoais dos prprios alunos.
Neste caso, o software educacional torna-se uma extenso da sala de aula, funcionando
como uma ferramenta de apoio no-presencial.

Diversidade de pblico

O simulador pode ser utilizado em cursos bsicos, intermedirios e avanados de

sistemas operacionais. Neste ltimo caso, o professor poder criar projetos que faam
alteraes nos mdulos j existentes e/ou inseres de facilidades ainda no
implementadas. Uma srie de sugestes para projetos pode ser obtida no Captulo 5 Concluses e Trabalhos Futuros.
Para que os alunos possam alterar o cdigo fonte do simulador necessrio o
conhecimento de orientao por objetos, Pascal e conhecimentos bsicos de Borland
Delphi [CALVERT, 1996]. Apesar da aparente dificuldade, estes conhecimentos fazem
parte da maioria dos cursos correntes de Cincia da Computao, sendo um bom
momento para integrar e consolidar diferentes disciplinas e reas de conhecimento.

18

Ambiente padronizado

O simulador foi concebido para ser executado no ambiente Windows da Microsoft. A

escolha deste ambiente operacional deve-se ao fato de ser amplamente utilizado tanto no
mundo acadmico quanto no comercial, alm de ser suportado por uma plataforma
padro de hardware. Alm disto, o software pode ser executado com poucos recursos de
hardware e no exige qualquer tipo de dispositivo especial.

Facilidade de modificao e ampliao

O projeto do simulador foi desenvolvido em um ambiente orientado a objetos,

simplificando em muito a compreenso do cdigo fonte e facilitando suas futuras
ampliaes. O cdigo do SOsim foi desenvolvido na linguagem Pascal, utilizando o
software Borland Delphi. Este ambiente de desenvolvimento permite aos interessados
em ler e/ou alterar o cdigo fonte do simulador, uma forma mais fcil e rpida de
implementar modificaes, se comparado ao ambiente Unix que geralmente utiliza
Linguagem C/C++.

19

CAPTULO 3 MODELO PROPOSTO

3.1 Introduo
Um sistema operacional, por mais complexo que possa parecer, apenas um conjunto
de rotinas executado pelo processador, da mesma forma que qualquer outro programa.
Sua principal funo controlar o funcionamento de um sistema computacional,
gerenciando seus diversos recursos como processadores, memrias e dispositivos de
entrada e sada [MACHADO, 1997].
A grande diferena entre um sistema operacional e aplicaes convencionais a
maneira como suas rotinas so executadas em funo do tempo. Um sistema
operacional no executado de forma linear como na maioria das aplicaes, com
incio, meio e fim. Suas rotinas so executadas em funo de eventos assncronos, ou
seja, eventos que ocorrem a qualquer momento.
Os sistemas multiprogramveis ou multitarefa permitem que diversos programas
dividam os mesmos recursos computacionais concorrentemente, como memria
principal, processador e dispositivos de entrada/sada. Para cada programa, o sistema
operacional aloca uma fatia de tempo (time-slice) do processador. Caso o programa no
esteja concludo nesse intervalo de tempo, ele substitudo por um outro, e fica
esperando por uma nova fatia de tempo. No s o processador compartilhado nesse
sistema, mas tambm a memria e os perifricos. O sistema cria para cada usurio um
ambiente de trabalho prprio (mquina virtual), dando a impresso de que todo o
sistema est dedicado exclusivamente a ele.
As vantagens do uso de sistemas multiprogramveis so o aumento da produtividade
dos seus usurios e a reduo de custos, a partir do compartilhamento dos diversos
recursos do sistema. Por exemplo, enquanto um programa espera por uma operao de
leitura ou gravao em disco, outros programas podem estar sendo processados neste
mesmo intervalo de tempo. O sistema operacional preocupa-se em gerenciar o acesso

20

concorrente aos seus diversos recursos, como memria, processador e perifricos, de

forma ordenada e protegida, entre os diversos programas (Fig. 3.1).

Fig. 3.1 - Sistema operacional genrico

Sistemas multiprogramveis so de implementao complexa e para que seu projeto
tenha sucesso necessrio abordar cinco reas principais: processo, gerncia de
memria, proteo, escalonamento, gerncia de recursos e estruturao do sistema
[DENNING, 1980]. O SOsim tem como principal objetivo apresentar os conceitos e
tcnicas encontrados nos sistemas operacionais multiprogramados. O projeto do
simulador implementa, em diferentes nveis de detalhamento, as reas acima citadas
por Denning, utilizando como base os algoritmos encontrados nos sistemas operacionais
OpenVMS da Compaq [LEVY, 1980] [MILLER, 1992] e Windows 2000 da Microsoft
[SOLOMON, 1998].

21

3.2 Processo
Um processo pode ser entendido inicialmente como um programa em execuo, s que
seu conceito mais abrangente. Este conceito torna-se mais claro quando pensamos de
que forma os sistemas multiprogramveis (multitarefa) atendem os diversos usurios
(tarefas) e mantm informaes a respeito dos vrios programas que esto sendo
executados concorrentemente [MACHADO, 1997].
Um sistema multiprogramvel simula um ambiente de monoprogramao para cada
usurio, isto , cada usurio do sistema tem a impresso de possuir o processador
exclusivamente para ele. Nesses sistemas, o processador executa a tarefa de um usurio
durante um intervalo de tempo e, no instante seguinte, est processando outra tarefa. A
cada troca necessrio que o sistema preserve todas as informaes da tarefa que foi
interrompida, para quando voltar a ser executada no lhe faltar nenhuma informao
para a continuao do processamento. estrutura computacional interna, responsvel
pela manuteno de todas as informaes necessrias execuo de um programa,
como contedo de registradores e espao de memria, d-se o nome processo.
O conceito de processo pode ser refinado como sendo o ambiente onde se executa um
programa. A execuo de um mesmo programa pode ser afetada dependendo do
processo no qual ele processado. O processo pode ser dividido em trs elementos
bsicos: contexto de hardware, contexto de software e espao de endereamento, que
juntos mantm todas as informaes necessrias execuo do programa (Fig. 3.2).
O contexto de hardware constitui-se basicamente no contedo de registradores: program
counter (PC), stack pointer (SP) e bits de estado. Quando um processo est em
execuo, o contexto de hardware est armazenado nos registradores do processador.
No momento em que o processo perde a utilizao da CPU, o sistema salva o seu
contexto.

22

Fig. 3.2 - Processo

O contexto de hardware fundamental para a implementao dos sistemas time-sharing,
onde os processos se revezam na utilizao do processador, podendo ser interrompidos
e, posteriormente, restaurados como se nada tivesse acontecido. A troca de um processo
por outro na CPU, realizada pelo sistema operacional, denominada mudana de
contexto (context switching). A mudana de contexto consiste em salvar o contedo dos
registradores da CPU e carreg-los com os valores referentes ao do processo que esteja
ganhando a utilizao do processador. Essa operao resume-se, ento, em substituir o
contexto de hardware de um processo pelo de outro.
O contexto de software especifica caractersticas do processo que vo influir na
execuo de um programa, como o nmero mximo de arquivos abertos
simultaneamente ou o tamanho do buffer para operaes de E/S. Essas caractersticas
so determinadas no momento da criao do processo, mas algumas podem ser alteradas
durante sua existncia. O contexto de software define basicamente trs grupos de
informaes de um processo: sua identificao, suas quotas e seus privilgios.
O espao de endereamento a rea de memria do processo onde um programa poder
ser executado, alm do espao para os dados utilizados por ele. Cada processo possui
seu prprio espao de endereamento, que deve ser protegido do acesso dos demais
processos.

23

3.2.1 Estados do Processo

Um processo no executado todo o tempo pelo processador. Durante sua existncia,
ele passa por uma srie de estados. O simulador implementa trs estados em que um
processo pode se encontrar: execuo, pronto e espera.

Estado de execuo

Um processo dito no estado de execuo (running) quando est sendo processado pela
CPU. Como o simulador implementa apenas um processador, somente um processo
pode estar sendo executado em um dado instante de tempo. Os processos se revezam na
utilizao do processador seguindo uma poltica estabelecida pelo escalonador.

Estado de pronto

Um processo est no estado de pronto (ready) quando apenas aguarda uma oportunidade
para executar, ou seja, espera que o sistema operacional aloque a CPU para sua
execuo. O escalonador responsvel por determinar a ordem pela qual os processos
em estado de pronto devem ganhar a CPU. Normalmente existem vrios processos no
sistema no estado de pronto.

Estado de espera

Um processo est no estado de espera (wait) quando aguarda algum evento externo ou
algum recurso para poder prosseguir seu processamento. O simulador implementa trs
tipos de estado de espera: um processo pode estar esperando o trmino de uma operao
de entrada/sada, aguardando ser retirado do estado de suspenso (resume) ou a espera
pelo trmino de um page fault.

24

3.2.2 Mudanas de Estados do Processo

Um processo muda de estado diversas vezes durante seu processamento, em funo de
eventos originados por ele prprio, como uma operao de entrada/sada, ou pelo
sistema operacional, como trmino de quantum e preempo. O simulador implementa
as quatro principais mudanas de estado que podem ocorrer a um processo em um
sistema operacional multiprogramvel:

Pronto Execuo

Quando um processo criado, o sistema o coloca em uma lista de processos no estado

de pronto, onde aguarda uma oportunidade para ser executado (Fig. 3.3a). O simulador
oferece trs opes de escalonamento, apresentadas posteriormente neste captulo.

Execuo Espera

Um processo em execuo passa para o estado de espera por eventos gerados pelo
prprio processo (Fig. 3.3b). Nesse caso, o processo ficar neste estado esperando pela
concluso do evento solicitado. O simulador coloca um processo no estado de espera em
trs situaes: quando o processo faz uma operao de entrada/sada, gera um page fault
ou suspenso pelo usurio.

Espera Pronto

Um processo no estado de espera passa para o estado de pronto quando a operao

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 execuo (Fig. 3.3c).

25

Execuo Pronto

Um processo em execuo passa para o estado de pronto por eventos gerados pelo
sistema. O simulador implementa dois eventos deste tipo: o fim da fatia de tempo (timeslice) que o processo possui para sua execuo (quantum-end) e preempo (Fig. 3.3d).
Nestes casos, o processo volta para a fila de pronto, onde aguardar por uma nova
oportunidade para continuar seu processamento.

Fig. 3.3 - Mudanas de estado do processo

3.2.3 Sinais
Um sinal est para um processo, assim como as interrupes esto para o sistema
operacional. Os sinais permitem notificar os processos de eventos sncronos e
assncronos, sendo fundamentais para a gerncia, comunicao e sincronizao de
processos [MAIA, 1999].

26

A gerao de um sinal ocorre quando o sistema operacional notifica o processo atravs

de bits de sinalizao localizados no seu PCB. Por exemplo, quando um processo
eliminado, o sistema ativa o bit correspondente. No momento em que o processo
escalonado, o bit testado e o processo eliminado.
O SOsim utiliza sinais para a eliminao e suspenso de processos, de forma semelhante
implementada pelos sistemas operacionais.
3.3 Gerncia do Processador
O conceito bsico que gerou a implementao dos sistemas multiprogramveis foi a
possibilidade de a CPU ser compartilhada entre diversos processos. Para isso, todo
sistema multiprogramvel possui um critrio para determinar qual a ordem na escolha
dos processos para execuo entre os vrios que concorrem pela utilizao do
processador [MACHADO, 1997].
O procedimento de seleo uma das principais funes realizadas por um sistema
operacional, sendo conhecido como escalonamento (scheduling). A parte do cdigo do
sistema operacional responsvel pelo escalonamento chamada de escalonador
(scheduler).
Os principais objetivos do escalonamento so, basicamente, manter a CPU ocupada a
maior parte do tempo, balancear a utilizao do processador entre os diversos processos,
maximizar o throughput do sistema e oferecer tempos de resposta razoveis para os
usurios interativos. Esses objetivos devem ser atendidos de forma que o sistema trate
todos os processos igualmente, evitando assim que um processo fique indefinidamente
esperando pela utilizao do processador (starvation). Para atender alguns desses
objetivos, muitas vezes conflitantes, os sistemas operacionais devem levar em
considerao caractersticas dos processos, ou seja, se um processo do tipo batch,
interativo, CPU-bound ou I/O-bound.

27

O algoritmo principal implementado pelo simulador muito semelhante ao dos sistemas

operacionais OpenVMS da Compaq e Windows 2000 da Microsoft, e foi escolhido por
permitir a implementao de diversas opes de escalonamento.
3.3.1 Escalonamento No-Preemptivo
Nos primeiros sistemas multiprogramveis, onde predominava tipicamente o
processamento batch, o escalonamento implementado era do tipo no-preemptivo.
Nesse tipo de escalonamento, quando um processo (ou job) ganha o direito de utilizar a
CPU, nenhum outro processo pode lhe tirar esse recurso.
Nesse esquema, o processo que chegar primeiro (first-in) o primeiro a ser selecionado
para execuo (first-out) e quando um processo ganha o processador, ele utilizar a
CPU sem ser interrompido. Seu algoritmo de implementao bastante simples, sendo
necessria apenas uma fila, onde os processos que passam para o estado de pronto
entram no seu final e so escalonados quando chegarem ao seu incio.
O problema do escalonamento FIFO a impossibilidade de se prever quando um
processo ter sua execuo iniciada, j que isso varia em funo do tempo de execuo
dos demais processos que se encontram na sua frente. Outro problema a possibilidade
de processos CPU-bound de menor importncia prejudicarem processos I/O-bound mais
prioritrios.
Essa poltica de escalonamento foi inicialmente implementada em sistemas batch, sendo
ineficiente, se aplicada da forma original em sistemas de tempo compartilhado.
Atualmente, sistemas de tempo compartilhado utilizam o escalonamento FIFO com
variaes, permitindo, assim, sua implementao.
3.3.2 Escalonamento Preemptivo
Um algoritmo de escalonamento dito preemptivo quando o sistema pode interromper
um processo em execuo para que outro processo utilize o processador. O

28

escalonamento preemptivo permite que o sistema d ateno imediata a processos mais

prioritrios, alm de proporcionar melhores tempos de resposta em sistemas de tempo
compartilhado. Outro benefcio decorrente deste tipo de escalonamento o
compartilhamento do processador de uma maneira mais uniforme entre os processos.
Vejamos, a seguir, os dois algoritmos de escalonamento preemptivos implementados
pelo simulador:

Escalonamento por tempo

No escalonamento por tempo sempre que um processo passa para o estado de execuo,
ou seja, ganha a CPU, existe um tempo-limite para sua utilizao de forma contnua,
denominado time-slice ou quantum. Quando esse tempo, expira, sem que antes a CPU
seja liberada pelo processo, este volta ao estado de pronto, dando a vez para outro
processo. Esse mecanismo definido como preempo por tempo.
A fila de processos em estado de pronto tratada como uma fila circular. O
escalonamento realizado, alocando a CPU para cada processo da fila no intervalo de
tempo determinado pelo quantum. O valor do quantum de tempo pode ser alterado
dinamicamente pelo usurio durante a execuo da simulao.
Atravs do escalonamento por tempo, nenhum processo poder monopolizar a CPU,
sendo o tempo mximo alocado continuamente para um determinado processo igual ao
quantum. No caso de sistemas de tempo compartilhado, onde vrios usurios utilizam o
sistema concorrentemente, esse algoritmo bastante adequado.

Escalonamento por prioridades

O escalonamento por tempo consegue melhorar a distribuio do tempo de CPU em

relao ao escalonamento no-preemptivo, porm ainda no consegue implementar um
compartilhamento eqitativo entre os diferentes tipos de processos. Isso acontece em

29

razo de o escalonamento por tempo tratar todos os processos de uma maneira igual, o
que nem sempre desejvel.
Um processo CPU-bound leva vantagem, na utilizao da CPU, sobre o processo I/Obound. Como, no escalonamento por tempo, um processo I/O-bound compete pelo
processador da mesma forma que um processo CPU-bound, e o processo I/O-bound
passa a maior parte do tempo no estado de espera, o processo CPU-bound tem mais
chance de ser executado.
Para solucionar esse problema, os processos I/O-bound devem levar alguma vantagem
no escalonamento, a fim de compensar o excessivo tempo gasto no estado de espera.
Como alguns processos devem ser tratados de maneira diferente dos outros, preciso
associar a cada um deles uma prioridade de execuo. Nesse esquema, processos de
maior prioridade so escalonados preferencialmente. Toda vez que um processo for para
a fila de pronto com prioridade superior ao do processo em execuo, o sistema dever
interromper o processo corrente, coloc-lo no estado de pronto e selecionar o de maior
prioridade para ser executado. Esse mecanismo definido como preempo por
prioridade.
Todos os sistemas de tempo compartilhado implementam algum esquema de prioridade,
de forma a dar maior importncia a um processo no momento do escalonamento. A
prioridade uma caracterstica do contexto de software de um processo, podendo ser
esttica ou dinmica. O simulador oferece a possibilidade de prioridade esttica ou
dinmica, atravs das opes da gerncia do processador.
A prioridade dita esttica quando no modificada durante a existncia do processo.
Apesar da simplicidade de implementao, a prioridade esttica pode ocasionar tempos
de resposta elevados. Na prioridade dinmica, a prioridade do processo pode ser
ajustada de acordo com o tipo de processamento realizado pelo processo e/ou a carga do
sistema. Todo o processo, ao sair do estado de espera, recebe um acrscimo sua
prioridade. Dessa forma, os processos I/O-bound tero mais chance de ser escalonados
e, assim, compensar o tempo que passam no estado de espera. importante perceber

30

que os processos CPU-bound no so prejudicados, pois podem ser executados

enquanto os processos I/O-bound esperam por algum evento.

Escalonamento por mltiplas filas com realimentao

O escalonamento por mltiplas filas com realimentao (multi-level feedback queues)

implementa diversas filas, onde cada qual tem associada uma prioridade de execuo,
porm os processos no permanecem em uma mesma fila at o trmino do
processamento. Neste escalonamento, o sistema tenta identificar dinamicamente o
comportamento de cada processo, ajustando assim suas prioridades de execuo. O
escalonamento por mltiplas filas com realimentao um algoritmo de escalonamento
generalista, podendo ser implementado em qualquer tipo de sistema operacional.
Esse esquema permite que os processos sejam redirecionados entre as filas do sistema,
fazendo com que o sistema operacional implemente um mecanismo de ajuste dinmico,
denominado mecanismo adaptativo, que tem como objetivo ajustar os processos em
funo do comportamento do sistema. Os processos no so previamente associados s
filas de pronto, e sim direcionados pelo sistema entre as diversas filas com base no seu
comportamento.
Um processo, ao ser criado, entra no final da fila de mais alta prioridade. Cada fila
implementa o mecanismo de FIFO para escalonamento. Quando um processo em
execuo deixa a CPU, seja por preempo por prioridade ou por solicitao a um
recurso do sistema, ele reescalonado dentro da mesma fila. Caso o processo esgote seu
quantum de tempo, ele redirecionado para uma fila de menor prioridade (preempo
por tempo). O escalonamento de um processo em uma fila s acontece quando todas as
outras filas de prioridades mais altas esto vazias. A fila de mais baixa prioridade
implementa o mecanismo do escalonamento circular.
Essa poltica de escalonamento atende as necessidades dos diversos tipos de processos.
No caso de processos I/O-bound, ela oferece um bom tempo de resposta, j que esses
processos tm prioridades altas por permanecerem a maior parte do tempo nas filas de

31

mais alta ordem. No caso de processos CPU-bound, a tendncia que, ao entrar na fila
de mais alta prioridade, o processo ganhe o processador, gaste seu quantum de tempo e
seja direcionado para uma fila de menor prioridade. Dessa forma, quanto mais tempo
um processo utiliza do processador, mais ele vai caindo para filas de menor prioridade.
3.3.3 Critrios de Escalonamento
Um algoritmo de escalonamento tem como principal funo decidir qual dos processos
prontos para execuo deve ser alocado CPU. Cada sistema operacional necessita de
um algoritmo de escalonamento adequado a seu tipo de processamento. A seguir,
apresentaremos os principais critrios de escalonamento:

Utilizao da CPU

Na maioria dos sistemas desejvel que o processador permanea a maior parte do seu
tempo ocupado. Uma utilizao na faixa de 30% indica um sistema com uma carga de
processamento baixa, enquanto que na faixa de 90% indica um sistema bastante
carregado, prximo da sua capacidade total.

Throughput

O throughput representa o nmero de processos (tarefas) executados em um

determinado intervalo de tempo. Quanto maior o throughput, maior o nmero de tarefas
executadas em funo do tempo. A maximizao do throughput desejada na maioria
dos sistemas.

Tempo de turnaround

Tempo que um processo leva desde sua admisso no sistema at ao seu trmino,
levando em considerao o tempo de espera para alocao de memria, espera na fila de
processos prontos para execuo, processamento na CPU e operaes de E/S.

32

Tempo de resposta

Em sistemas interativos, o tempo de resposta o tempo decorrido do momento da

submisso de um pedido ao sistema at a primeira resposta produzida. O tempo de
resposta no o tempo utilizado no processamento total de uma tarefa, e sim o tempo
decorrido at que uma resposta seja apresentada. Este tempo, geralmente, limitado
pela velocidade do dispositivo de sada.
De uma maneira geral, qualquer algoritmo de escalonamento busca otimizar a utilizao
da CPU e o throughput, enquanto tenta diminuir os tempos de turnaround e de resposta.
Dependendo do tipo do sistema, um critrio pode ser mais enfatizado do que outros,
como, por exemplo, nos sistemas interativos, onde o tempo de resposta deve ser mais
considerado.
O algoritmo de escalonamento no o nico responsvel pelo tempo de execuo de um
processo. Outros fatores, como o tempo de processamento e de espera em operaes de
E/S, devem ser considerados no tempo total da execuo. O escalonamento somente
afeta o tempo de espera de processos na fila de pronto.
3.4 Gerncia de Memria
Na memria principal residem todos os programas e dados que sero executados ou
referenciados pelo processador. Um programa residente na memria secundria para ser
executado deve ser, de alguma forma, carregado para a memria principal. A
organizao e gerncia da memria principal tm sido fatores importantes no projeto de
sistemas operacionais. Enquanto nos sistemas monoprogramveis a gerncia da
memria no muito complexa, nos sistemas multiprogramveis ela torna-se crtica.
Isso ocorre devido necessidade de se manter o maior nmero de processos possvel
utilizando a memria eficientemente, tornando sua gerncia muito mais difcil
[MACHADO, 1997].

33

Existem inmeros mecanismos de gerncia de memria, como alocao contgua,

esquemas de overlay, alocao particionada esttica e dinmica, e memria virtual.
Mesmo a gerncia de memria virtual pode ser implementada utilizando-se paginao,
segmentao ou uma mistura de ambos. No projeto do SOsim implementou-se apenas a
gerncia de memria virtual com paginao, que ser detalhada neste item.
Os mecanismos anteriores memria virtual no foram contemplados neste projeto por
servirem apenas para apresentar a evoluo histrica da gerncia de memria, pois, na
prtica, no so mais implementados na maioria dos sistemas operacionais comerciais,
com exceo de alguns supercomputadores, por questes de desempenho. A gerncia de
memria virtual com segmentao pura muito pouco utilizada. Geralmente, os
sistemas que utilizam segmentao tambm implementam paginao, em um modelo
hbrido. Este ltimo modelo recomendado para trabalhos futuros.
O algoritmo de memria virtual implementado muito semelhante ao dos sistemas
operacionais OpenVMS da Compaq e Windows 2000 da Microsoft, e foi escolhido por
permitir a implementao de diversos conceitos importantes, como working set.
3.4.1 Memria Virtual
Memria virtual (virtual memory) uma tcnica sofisticada e poderosa de gerncia de
memria, onde as memrias principal e secundria so combinadas, dando ao usurio a
iluso de existir uma memria muito maior que a memria principal [DENNING,
1970].
O conceito de memria virtual est baseado em desvincular o endereamento feito pelo
programa dos endereos fsicos da memria principal. Assim, os programas e suas
estruturas de dados deixam de estar limitados ao tamanho da memria primria
disponvel. Para permitir que apenas partes realmente necessrias execuo do
processo estejam na memria, o cdigo deve ser dividido em blocos e mapeados na
memria principal, a partir do espao de endereamento virtual. O espao de
endereamento virtual representa o conjunto de endereos virtuais que os processos

34

podem enderear. Analogamente, o conjunto de endereos reais chamado espao de

endereamento real.
O espao de endereamento virtual no tem nenhuma relao direta com os endereos
no espao real. Um programa pode fazer referncia a endereos virtuais que estejam
fora dos limites do espao real, ou seja, os programas e suas estruturas de dados no
esto mais limitados ao tamanho da memria fsica disponvel. Como os programas
podem ser muito maiores que a memria fsica, apenas parte deles pode estar residente
na memria em um determinado instante. O sistema operacional utiliza a memria
secundria como extenso da memria principal e o transporte de programas entre uma
e outra d-se de maneira dinmica e transparente ao usurio. Quando um programa
executado, s uma parte do cdigo fica residente na memria principal, permanecendo o
restante na memria secundria at o momento de ser referenciado (Fig. 3.4).

Fig. 3.4 - Espao de endereamento virtual

Outra vantagem da memria virtual permitir um nmero maior de processos
compartilhando a memria, j que apenas algumas partes de cada processo estaro
residentes. Isto leva a uma utilizao mais eficiente tambm do processador, permitindo
um maior nmero de processos no estado de pronto.

35

3.4.2 Mapeamento
O mapeamento permite ao sistema operacional traduzir um endereo localizado no
espao de endereamanto virtual do processo para um endereo no espao real. Como
conseqncia do mapeamento, um programa no precisa estar necessariamente contguo
na memria principal para ser executado.
Cada processo tem o mesmo espao de endereamento virtual, como se possusse sua
prpria memria virtual. O mecanismo de traduo se encarrega de manter tabelas de
mapeamento exclusivas para cada processo, relacionando os endereos virtuais do
processo s suas posies na memria fsica (Fig. 3.5). Quando um programa est sendo
executado, o sistema, para realizar a traduo, utiliza a tabela de mapeamento do
processo no qual o programa executa. Se um outro programa vai ser executado no
contexto de outro processo, o sistema deve passar a referenciar a tabela do novo
processo.

Fig. 3.5 - Tabela de mapeamento

36

Neste esquema, como cada processo tem a sua prpria tabela de mapeamento e a
traduo dos endereos realizada pelo sistema, garantida a proteo dos espaos de
endereamento dos processos, a menos que haja compartilhamento explcito de
memria (shared memory).
Caso o mapeamento fosse realizado para cada clula na memria principal, o espao
ocupado pelas tabelas na memria real seria to grande quanto o espao de
endereamento virtual de cada processo, o que inviabilizaria a implementao do
mecanismo de memria virtual. Em funo disso, as tabelas mapeiam blocos de
informaes, cujo tamanho determina o nmero de entradas existentes nas tabelas de
mapeamento. Quanto maior o bloco, menos entradas nas tabelas de mapeamento e,
conseqentemente, tabelas de mapeamento que ocupam um espao de memria menor.
Existem sistemas que trabalham apenas com blocos do mesmo tamanho (paginao),
outros que utilizam blocos de tamanhos diferentes (segmentao) e, ainda, h sistemas
que trabalham com os dois tipos de blocos (segmentao com paginao). O simulador
implementa apenas a gerncia de memria virtual com paginao.
3.4.3 Paginao
Paginao (paging) a tcnica de gerncia de memria onde o espao de
endereamento virtual e o espao de endereamento real so divididos em blocos do
mesmo tamanho, chamados pginas. As pginas no espao virtual so denominadas
pginas virtuais (virtual pages), enquanto as pginas no espao real so chamadas de
pginas reais (frames).
Todo o mapeamento realizado em nvel de pgina, atravs de tabelas de pginas. Cada
pgina virtual do processo possui uma entrada na tabela de pginas (Page Table Entry PTE), com informaes de mapeamento que permitem ao sistema localizar a pgina real
correspondente na memria principal (Fig. 3.6).

37

Fig. 3.6 - Tabela de pginas

Quando um programa executado, as pginas virtuais so transferidas da memria
secundria para a memria principal e colocadas em frames. Sempre que o programa
fizer referncia a um endereo virtual, o mecanismo de mapeamento localizar, no PTE
da tabela do processo, o endereo fsico do frame.
Alm da informao sobre a localizao da pgina virtual, o PTE possui outras
informaes, entre elas o bit de validade (valid bit), que indica se uma pgina est ou
no na memria fsica. Se o bit tem o valor 0, indica que a pgina virtual no est na
memria principal, enquanto, se for igual a 1, a pgina est localizada na memria.
Sempre que o processo faz referncia a um endereo virtual, o simulador verifica,
atravs do bit de validade, se a pgina que contm o endereo referenciado est ou no
na memria principal. Caso no esteja, dizemos que ocorreu um page fault e, neste caso,
o sistema deve transferir a pgina da memria secundria para a memria fsica.

38

Quando um processo faz referncia a um endereo e ocorre um page fault, o processo

retirado do processador e colocado em estado de espera, at que a pgina seja lida do
disco. Depois da leitura da pgina em disco, o processo recolocado na fila de
processos pronto e quando for reescalonado poder continuar seu processamento.
3.4.4 Polticas de Busca de Pginas
O mecanismo de memria virtual permite a execuo de um programa sem que esteja
completamente residente na memria. A poltica de busca de pginas (fetch policy)
determina quando uma pgina deve ser trazida para a memria principal. Existem,
basicamente, duas alternativas: paginao por demanda e paginao antecipada.
Na paginao por demanda (demand paging), as pginas dos processos so transferidas
da memria secundria para a principal apenas quando so referenciadas. Este
mecanismo conveniente, na medida em que leva para a memria principal apenas as
pginas realmente necessrias execuo do programa. Desse modo, possvel que
partes do programa, como rotinas de tratamento de erros, nunca sejam carregadas para a
memria.
Na paginao antecipada (antecipatory paging ou prepaging), o sistema traz para a
memria, alm das pginas referenciadas, outras pginas que podem ou no ser
necessrias ao processo no futuro. No caso do processo no precisar das pginas
trazidas antecipadamente, o sistema ter perdido tempo de processador e ocupado
memria principal desnecessariamente.
O simulador implementa o mecanismo de paginao por demanda e o mecanismo de
paginao antecipada. A paginao antecipada opcional e implementada apenas na
criao de um processo.

39

3.4.5 Poltica de Alocao de Pginas

A poltica de alocao de pginas determina quantos frames cada processo pode alocar
na memria principal. Existem, basicamente, duas alternativas: a alocao fixa e
alocao varivel. O simulador implementa a poltica de alocao de pginas fixa, mas
permite que este valor seja definido na criao do processo.
Na poltica de alocao fixa, cada processo recebe um nmero mximo de pginas que
pode ser utilizado. Se o nmero de pginas for insuficiente, o processo gera um page
fault e cede uma pgina para obter uma nova. O nmero mximo de pginas pode ser
igual para todos os processos ou ser definido individualmente. Alocar o mesmo nmero
de pginas para todos os processos, apesar de justo, em princpio no funciona, caso os
processos tenham necessidades diferentes de memria, como geralmente acontece. Se
cada processo pode ter um nmero mximo de pginas, o limite pode ser definido com
base no tipo da aplicao (interativa ou batch), no incio da sua execuo.
Na poltica de alocao varivel, o nmero mximo de pginas alocadas ao processo
pode variar durante sua execuo, em funo de sua taxa de paginao, por exemplo. A
taxa de paginao o nmero de page faults por unidade de tempo de um processo.
Processos com elevadas taxas de paginao podem receber frames adicionais a fim de
reduzi-las, ao mesmo tempo que processos com taxas baixas de paginao podem cedelas. Este mecanismo, apesar de mais flexvel, exige que o sistema operacional monitore
o comportamento dos processos, provocando maior overhead.
3.4.6 Working Set
O mecanismo de memria virtual apesar de suas vantagens, introduz um grande
problema. Sempre que um processo faz referncia a uma de suas pginas e esta no se
encontra na memria (page fault), exige do sistema operacional pelo menos uma
operao de E/S, que, quando possvel, deve ser evitada.

40

Qualquer sistema que implementa paginao deve se preocupar em manter na memria

principal um certo nmero de pginas que reduza ao mximo a taxa de paginao dos
processos, ao mesmo tempo que no prejudique os demais processos que desejam ter
acesso memria. O conceito de working set surgiu a partir da anlise da taxa de
paginao dos processos. Quando um programa comea a ser executado, percebe-se
uma elevada taxa de page faults, que se estabiliza com o decorrer da execuo. Esse fato
est ligado ao princpio da localidade.
Localidade pode ser definido como a tendncia que existe em um programa de fazer
referncias a posies de memria de forma quase uniforme, ou seja, a instrues e
dados prximos. Isso significa que um processo tender a concentrar suas referncias
em um mesmo conjunto de instrues e dados na memria principal, durante um
determinado perodo de tempo. No caso do SOsim a questo da localidade muito forte
e pode ser muito bem observada. Todos os programas executados pelo simulador esto
em um loop infinito de cinco pginas. Este modelo explicado no Captulo 4
Arquiteturta e Implementao.
O working set de um processo o conjunto de pginas referenciadas por ele durante
determinado intervalo de tempo. Uma outra definio seria que o working set o
conjunto de pginas constantemente referenciadas pelo processo, devendo permanecer
na memria principal para que ele execute de forma eficiente. Caso contrrio, o
processo poder sofrer com a elevada taxa de paginao (thrashing), comprometendo
seu desempenho [DENNING, 1968] [DENNING, 1970] [DENNING, 1980].
Quando um processo criado, todas as suas pginas esto na memria secundria.
medida que acontecem referncias s pginas virtuais, elas so transferidas para o
working set do processo na memria principal (page in). Sempre que um processo faz
referncia a uma pgina, o sistema verifica se a pgina j se encontra no working set do
processo. Caso a pgina no se encontre no working set, ocorrer o page fault. O
working set do processo deve ter um limite mximo de pginas permitidas. Quanto
maior o working set, menor a chance de ocorrer uma referncia a uma pgina que no
esteja na memria principal (page fault).

41

O simulador implementa algo semelhante ao conceito de working set, muito prximo ao

utilizado nos sistemas OpenVMS e Windows 2000. Este conceito melhor examinado
no Captulo 4 Arquiteturta e Implementao.
3.4.7 Polticas de Substituio de Pginas
O maior problema na gerncia de memria virtual por paginao no decidir que
pgina carregar para a memria, mas quais pginas remover. Quando no existem
pginas livres disponveis na memria e novos frames devem ser alocados, a poltica de
substituio (replacement policy) de pginas determina, dentre as diversas pginas
residentes, quais devem ser realocadas.
Qualquer estratgia de substituio de pginas deve considerar se uma pgina foi ou no
modificada, antes de liber-la, caso contrrio, possveis dados armazenados na pgina
sero perdidos. Sempre que o sistema liberar uma pgina desse tipo, ele antes dever
grav-la na memria secundria (page out), preservando seu contedo. O sistema
mantm um arquivo de paginao (page file) onde as pginas modificadas so
armazenadas. Sempre que uma destas pginas for novamente referenciada, ela ser
trazida novamente para a memria principal.
O sistema consegue implementar esse mecanismo atravs do bit de modificao (dirty
ou modify bit), que existe na entrada de cada tabela de pginas. Sempre que uma pgina
alterada, o valor do bit de modificao alterado de 0 para 1, indicando que a pgina
foi modificada. No caso de pginas que no so modificadas, como pginas de cdigo,
existem as pginas originais no arquivo executvel armazenado na memria secundria,
que podem ser utilizadas sempre que necessrias. Tais pginas, quando liberadas, no
causam o overhead de gravao em disco.
A poltica de substituio pode ser classificada conforme seu escopo, ou seja, local ou
global. Na poltica local, apenas as pginas do processo que gerou o page fault so
candidatas a realocao. J na poltica global, todas as pginas residentes so avaliadas,

42

independente do processo que gerou o page fault. O simulador implementa uma poltica
de substituio local.
Independente se a poltica seja local ou global, os algoritmos de substituio de pginas
devem ter o objetivo de selecionar aquelas que tenham poucas chances de serem
utilizadas novamente num futuro prximo. Quanto mais elaborado e sofisticado o
algoritmo, maior tambm o overhead para o sistema.
Existem diversos algoritmos na literatura voltados para a implementao da poltica de
substituio de pginas, como FIFO (First-In-First-Out), buffer de pginas, LRU (LeastRecently-Used),

LFU

(Least-Frequently-Used)

NRU

(Not-Recently-Used)

[TANENBAUM, 1992]. O simulador implementa o algoritmo FIFO modificado com

buffer de pginas, utilizado nos sistemas OpenVMS e Windows 2000. Os algoritmos
LRU, LFU, dentre outros, no so implementados na prtica em sistemas operacioanais
modernos. O nico algoritmo que implementado na grande maioria dos sistemas Unix,
o FIFO circular (clock). Este algoritmo recomendado para trabalhos futuros. A
seguir, analisaremos as polticas de substituio de pginas implementadas pelo
simulador:

First-In-First-Out (FIFO)

Nesse esquema, a pgina que primeiro foi utilizada (first-in) ser a primeira a ser
escolhida (first-out), ou seja, o algoritmo seleciona a pgina mais antiga na memria.
Sua implementao pode ser feita associando a cada pgina o momento que foi trazida
para a memria ou utilizando uma fila, onde as pginas mais antigas esto no incio e as
mais recentes no final da fila.
Parece razovel pensar que uma pgina que esteja mais tempo na memria seja
justamente aquela que deva ser selecionada. Caso uma pgina seja constantemente
referenciada, o fator tempo torna-se irrelevante, e o sistema tem que retornar a mesma
pgina vrias vezes. O algoritmo FIFO raramente utilizado sem algum outro
mecanismo que minimize este problema, como o algoritmo de Buffer de Pginas.

43

Buffer de Pginas

O buffer de pginas utiliza como base o algoritmo FIFO, combinado com uma lista de
pginas livres (Free Page List FPL), que funciona em um esquema de fila. Sempre que
um processo solicita uma nova pgina, a pgina que est a mais tempo no seu working
set colocada no final da FPL. Para atender a solicitao do processo, a primeira pgina
da FPL selecionada. Alm da FPL, o simulador implementa uma segunda lista,
conhecida como lista de pginas modificadas (Modified Page List MPL), que
armazena as pginas modificadas que so retiradas do working set do processo.
importante notar que a pgina substituda continua fisicamente na memria, logo, se a
pgina for novamente referenciada, basta traze-la da FPL ou MPL, que funciona como
um buffer de pginas. O buffer de pginas permite criar um algoritmo de substituio de
pginas eficiente, sem o overhead de outras implementaes.
3.4.8 Swapping
A tcnica de swapping permite aumentar o nmero de processos compartilhando a
memria principal e, conseqentemente, o sistema. Em sistemas que implementam essa
tcnica, quando existem novos processos que desejam ser processados e no existe
memria real suficiente, o sistema seleciona um ou mais processos que devero sair da
memria para ceder espao aos novos processos.
H vrios critrios que podem ser aplicados na escolha do(s) processo(s) que deve(m)
sair da memria. Os mais utilizados so a prioridade e o estado do processo. O critrio
de estado seleciona os processos que esto no estado de espera, ou seja, aguardando por
algum evento. O critrio de prioridade escolhe, entre os processos, os de menor
prioridade de execuo.
Depois de escolhido o(s) processo(s), o sistema intervm e ativa uma rotina do sistema
responsvel por retirar (swap out) e trazer (swap in) os processos da memria principal
para a memria secundria, onde so gravados em um arquivo de swapping (swap file).

44

No simulador, os arquivos de swapping e paginao so implementados como um nico

arquivo em disco para facilitar a visualizao dos eventos relacionados.
3.4.9 Thrashing
Thrashing pode ser definido como sendo a excessiva transferncia de pginas entre a
memria principal e a memria secundria. No modelo proposto, thrashing pode ocorrer
em dois nveis: em nvel do prprio processo e em nvel do sistema.
Em nvel do processo, a excessiva paginao ocorre devido ao elevado nmero de page
faults, gerado pelo programa em execuo. Esse problema faz com que o processo passe
mais tempo esperando por pginas do que realmente sendo executado e ocorre devido
ao mau dimensionamento no tamanho do working set do processo, pequeno demais para
acomodar as pginas constantemente referenciadas por ele.
Em nvel do sistema, o thrashing ocorre quando existem mais processos competindo
por memria real que espao disponvel. Neste caso, o sistema tenta administrar a
memria de forma que todos os processos sejam atendidos, descarregando processos
para a memria secundria e carregando processos para a memria principal. Se esse
mecanismo for levado ao extremo, o sistema passar mais tempo fazendo swapping do
que executando processos.
De qualquer forma, se persistem mais processos para serem executados que memria
real disponvel, a soluo que realmente restaura os nveis de desempenho adequados
a expanso da memria principal. importante ressaltar que este problema no ocorre
apenas em sistemas que implementam memria virtual, mas tambm em sistemas com
outros mecanismos de gerncia de memria.

45

CAPTULO 4 ARQUITETURA E IMPLEMENTAO

4.1 Introduo
Este captulo aborda a arquitetura do simulador e sua implementao, com base nos
conceitos e mecanismos discutidos no Captulo 3 - Modelo Proposto. Alm disto, so
apresentandos o ambiente de trabalho e uma viso geral dos objetos que fazem parte de
sua estrutura interna. O captulo enfatiza especialmente implementao de processos,
dos mdulos de gerncia do processador e gerncia de memria.
Uma preocupao no desenvolvimento deste captulo foi de no entrar em detalhes da
implementao do cdigo fonte do software, mas sim de oferecer uma abordagem topdown do projeto e mostrar a utilizao da ferramenta educacional. importante
ressaltar tambm que a implementao do simulador no segue, necessariamente, as
mesmas estruturas de dados e procedimentos internos de um sistema operacional real.
4.2 Orientao por Objetos
O SOsim foi inteiramente implementado em uma linguagem de programao orientada
a objetos (OO), o Borland Delphi. A opo pela orientao por objetos foi,
principalmente, permitir a reduo da complexidade no desenvolvimento do software e
aumento da produtividade. No entanto, interessante perceber que poucos sistemas
operacionais so implementados na prtica com base nos conceitos de OO, apesar de
todas vantagens existentes. Alguns sistemas, como o Windows 2000, adotam esta
filosofia em certos nveis em funo da maior manutabilidade do sistema e facilidade de
ampliao de suas funcionalidades [SOLOMON, 1998].
Um objeto uma abstrao de software que pode representar algo real ou virtual, sendo
formado por um conjunto de propriedades (variveis) e procedimentos (mtodos). As
variveis possuem um tipo, que define os possveis valores que a varivel pode
representar, como um nmero inteiro, nmero real ou string. Os mtodos so rotinas
que, quando executadas, realizam alguma tarefa, como alterar o contedo de uma

46

varivel do objeto. Objetos comunicam-se apenas atravs de mensagens e o conjunto de

mensagens a que um objeto pode responder definido como protocolo de comunicao
[BOOCH, 1994].
Um exemplo de objeto no SOsim a implementao do conceito de processo. O objeto
Processo possui propriedades, como identificao, prioridade e quotas. Alm disto, um
processo possui procedimentos associados, como criar, eliminar, alterar a prioridade e
visualizar suas caracterticas.
As variveis de um objeto s podem ser alteradas por mtodos definidos na prpria
classe. A nica maneira de um objeto alterar as variveis de um outro objeto a atravs
da ativao de um de seus mtodos por uma mensagem. Este conceito, onde variveis e
mtodos so visveis apenas atravs de mensagens, conhecido como encapsulamento.
O encapsulamento funciona como uma proteo para as variveis e mtodos, alm de
tornar explcito qualquer tipo de comunicao com o objeto. Os mtodos que permitem
a comunicao do objeto com o mundo exterior so conhecidos como interfaces
pblicas (public).
Uma classe consiste de variveis e mtodos que representam caractersticas de um
conjunto de objetos semelhantes. O conceito de classe um dos pilares da programao
orientada a objetos, por permitir a reutilizao efetiva de cdigo.
O conceito de herana permite definir uma nova classe com base em uma j existente. A
classe criada (subclasse ou classe derivada) automaticamente herda todas as variveis e
mtodos da classe j existente (superclasse). O mecanismo de herana permite ainda
que a subclasse inclua ou sobreponha novas variveis e mtodos da superclasse. O
mecanismo de herana recursivo, permitindo criar-se uma hierarquia de classes. Nos
nveis mais altos da hierarquia esto caractersticas comuns a todos os objetos desta
classe, enquanto nos nveis inferiores esto especializaes das classes superiores. As
subclasses herdam as caractersticas comuns, alm de definirem suas propriedades
especficas.

47

Uma das grandes vantagens da programao OO a utilizao de bibliotecas de classes.

Estas bibliotecas lembram as bibliotecas de cdigo (procedimentos e funes),
utilizadas na programao modular. As bibliotecas de classes permitem uma capacidade
muito maior de compartilhamento e reutilizao de cdigo, pois possvel criar-se
subclasses para atender novas necessidades, em funo das classes j existentes. Muitas
bibliotecas so oferecidas juntamente com as ferramentas de desenvolvimento para
reduzir o tempo e a complexidade de projetos de software. O SOsim utiliza a biblioteca
de classes do Delphi, a Visual Component Library VCL [BORLAND, 1999].
O mecanismo de polimorfismo permite tratar objetos semelhantes de uma maneira
uniforme. Neste caso, possvel que se envie uma mesma mensagem para um conjunto
de objetos e que cada objeto responda de maneira diferente em funo da mensagem
recebida. Para ser implementado, o polimorfismo exige a utilizao do conceito de
herana e aplica-se apenas aos mtodos da classe. O protocolo de comunicao
estabelecido na classe mais alta da hierarquia que ser herdada por todas as subclasses
definidas posteriormente. Este mecanismo cria um protocolo padro de comunicao
com um conjunto de objetos, permitindo uma grande flexibilidade na agregao de
objetos semelhantes, mas no idnticos.
Concluindo, baseado nos conceitos de objetos, classes, encapsulamento, herana e
polimorfismo, o paradigma da OO representa uma forma evolucionria de pensar e
desenvolver software, trazendo inmeros benefcios criao de programas, dentre os
quais o mais notvel a reutilizao de cdigo, que reduz drasticamente os tempos de
desenvolvimento e manuteno de programas.
4.3 Multithread
Apesar do simulador no oferecer a facilidade de threads para seus usurios, o seu
projeto est baseado inteiramente no conceito de ambiente multithread. Diversos objetos
so implementados como threads para permitir a implementao do paralelismo
necessrio simulao de um sistema operacional multiprogramvel.

48

Basicamente, multithreading uma tcnica de programao concorrente, que permite

projetar e implementar aplicaes concorrentes e paralelas de forma eficiente,
entretanto, o desenvolvimento de programas multithread no simples. A presena do
paralelismo introduz um novo conjunto de problemas, tais como a comunicao e
sincronizao de threads [MAIA, 1999] [PHAM, 1996].
O uso de (sub)processos no desenvolvimento de aplicaes concorrentes demanda
consumo de diversos recursos do sistema. Sempre que um novo processo criado, o
sistema deve alocar recursos (contexto de hardware, contexto de software e espao de
endereamento) para cada processo, alm de consumir tempo de CPU neste trabalho.
No caso do trmino do processo, o sistema dispensa tempo para desalocar recursos
previamente alocados. Na Fig. 4.1 existem trs processos, cada um com seu prprio
contexto de hardware, contexto de software e espao de endereamento.

Fig. 4.1 - Ambiente monothread

Como cada processo possui seu prprio espao de endereamento, a comunicao entre
os (sub)processos torna-se difcil e lenta, pois utiliza mecanismos tradicionais como
pipes, sinais, semforos, memria compartilhada ou troca de mensagem. Alm disto, o
compartilhamento de recursos comuns aos (sub)processos concorrentes, como memria
e arquivos abertos, no simples.
Com threads, um processo pode ter diferentes partes do seu cdigo sendo executadas
concorrentemente ou simultaneamente, com muito menos overhead que utilizando
mltiplos (sub)processos. Na Fig. 4.2 existe apenas um processo com trs threads de
execuo, cada um com seu program counter (PC).

49

Fig. 4.2 - Ambiente Multithread

Como todos os threads em um processo compartilham o mesmo espao de
endereamento, a comunicao entre os threads pode ser feita utilizando o
compartilhamento de memria (shared memory) de forma rpida e eficiente. De forma
semelhante ao compartilhamento de memria, os threads dentro do mesmo processo
podem compartilhar facilmente outros recursos, como descritores de arquivos,
temporizadores (timers), sinais, atributos de segurana etc.
4.4 Ambiente do Simulador
O ambiente do simulador foi desenvolvido pensando em oferecer aos seus usurios uma
interface simples e de fcil interao. A partir do uso de uma ferramenta de
desenvolvimento rpido de aplicaes (Rapid Development Application RAD)
orientada a objetos, neste caso o Borland Delphi, esta tarefa foi bastante simplificada
em funo da biblioteca de objetos disponvel.

50

Uma outra grande preocupao na implementao do simulador foi permitir que o

usurio possa acompanhar visualmente os diversos eventos envolvendo cada processo
no sistema. Se o simulador utilizasse a mesma dinmica de um sistema operacional real,
seria impossvel aos olhos humanos acompanhar os eventos e as mudanas de estado do
ambiente. Para isto, a utilizao de cores e a possibilidade de alterar a velocidade do
modelo so requisitos fundamentais.
O simulador quando inicialmente executado oferece trs janelas: a console do
simulador, gerncia do processador e gerncia de memria. A console permite abrir
mais duas janelas opcionais: uma para a janela de log e outra com estatsticas do
simulador.
O ambiente de janelas independentes permite ao usurio selecionar quais janelas so
importantes para analisar uma determinada situao, deixando as demais fechadas.
Outra vantagem permitir que o usurio escolha o nmero de janelas abertas em funo
da resoluo e do tamanho do monitor. Finalmente, um ambiente de janelas
independentes permite que se amplie o modelo mais facilmente do que se fosse uma
nica tela englobando todas as funcionalidades.

Console

A console permite criar e selecionar processos, abrir e fechar janelas, consultar o help
online e os crditos, e encerrar a execuo do simulador. Alm disto, a console permite
parar a simulao a qualquer momento e retom-la quando desejado. Esta facilidade
permite ao professor interromper o modelo em determinados momentos para esclarecer
algum evento ou dvida e, posteriormente, continuar o processamento (Fig. 4.3).

Fig. 4.3 - Console

51

Gerncia do processador

A janela Gerncia do Processador permite visualizar a mudana de estado dos

processos e definir opes relacionadas ao escalonador. Alm disto, possvel alterar a
dinmica do simulador a partir das barras de controle Tempo de espera, Quantum e
Freqncia clock (Fig. 4.4). Este mdulo melhor detalhado no item 4.7 Gerncia do
Processador.

Fig. 4.4 - Gerncia do Processador

Gerncia de memria

A janela Gerncia de Memria permite visualizar as pginas de memria livres, as

pginas de memria alocadas (modificadas ou no) e definir opes da gerncia de
memria virtual (Fig. 4.5). Alm disto, possvel acompanhar o tamanho da lista de
pginas livre (FPL Size) e lista de pginas modificadas (MPL Size). Este mdulo
melhor detalhado no item 4.8 Gerncia de Memria.

52

Fig. 4.5 - Gerncia de Memria

Log de mensagens

A janela Log permite acompanhar facilmente os eventos ocorridos no simulador e,

principalmente, os relacionados a um processo, pois utiliza a cor associada ao processo
para exibir a mensagem (Fig. 4.6).
Alm disto, o simulador cria em disco um arquivo contendo todas as mensagens
exibidas na janela de log. A cada execuo do simulador, um novo arquivo criado no
formato ms-dia-hora.txt, que pode ser lido por qualquer editor de textos.
recomendvel que o usurio elimine periodicamente os arquivos de log.

53

Fig. 4.6 Log do simulador

Estatsticas

A janela Estatsticas permite se ter uma viso geral do funcionamento do simulador e

acompanhar os principais indicadores de desempenho dos mdulos de gerncia do
processador e gerncia de memria (Fig. 4.7). As informaes contidas nesta janela
sero melhor analisadas no item 4.9 - Estatsticas.

Fig. 4.7 Estatsticas do simulador

54

4.5 Objetos do Simulador

O SOsim formado por diversos objetos de diferentes tipos. A descrio de cada um
destes objetos seria longa e tediosa, por isso optou-se por uma abordagem mais didtica,
sem entrar em detalhes do cdigo fonte.
Alguns objetos funcionam como threads dentro do simulador, permitindo a execuo
concorrente deste objetos. Esta caracterstica fundamental para um simulador que trata
de eventos assncronos, como em um sistema operacional. A programao concorrente,
porm, introduz uma srie de problemas de comunicao e sincronizao entre threads,
principalmente envolvendo estruturas de dados compartilhadas [BEN-ARI, 1990].
A seguir, so descritos os principais objetos do simulador e suas funes. O nome entre
parntesis significa o nome interno do mdulo.

Clock (u_Clock)

O objeto Clock um thread que tem a funo de apenas gerar pulsos para que o
simulador tenha uma temporizao. Estes pulsos so sinalizados ao objeto CPU, atravs
de uma interrupo em intervalos de 100 milisegundos. O intervalo do clock pode ser
alterado facilmente para acelerar o modelo atravs da barra de controle Freqncia
clock na janela Gerncia do Processador.

Ncleo (u_Kernel)

O objeto Ncleo mantm a lista de PCBs dos processos e o vetor de interrupo. O

simulador implementa um vetor de 16 nveis de prioridade, variando de 0 (menor) a 15
(maior). Apesar de poder suportar este esquema, todas as interrupes so tratadas com
o mesmo nvel de prioridade (zero), ou seja, as interrupes so tratadas
seqencialmente por ordem de chegada. Em um sistema operacional real esta
certamente no seria uma soluo adequada, mas em um simulador com fins

55

educacionais esta soluo funciona perfeitamente, devido ao pequeno nmero de

interrupes simultneas geradas no modelo.

CPU (u_CPU)

O objeto CPU (Central Processor Unit) o thread que executa as instrues dos
programas. Alm disto, a CPU reconhece e trata as interrupes armazenadas pelo
objeto ncleo. Semelhante a um sistema real, o processador verifica a cada instruo se
h interrupes e, neste caso, desvia para a rotina de tratamento apropriada. A CPU s
executa instrues de um programa quando no existem interrupes pendentes.

Processo (u_Processo)

O objeto Processo define os atributos e mtodos de um processo no simulador. Como

exemplos de atributos temos a identificao do processo (PID), data de sua criao,
tempo de CPU e a prioridade de execuo. Como exemplos de mtodos temos a criao
de um processo, sua suspenso e eliminao. Este objeto detalhado no item 4.6
Objeto Processo.

Escalonador (u_Escalonador)

O objeto Escalonador o thread que seleciona um processo para execuo. Este objeto
mantm uma estrutura de dados com todos os processos prontos para executar e,
conforme o algoritmo de escalonamento definido pelo usurio, seleciona um processo
para ganhar o processador.
O Escalonador oferece trs opes de algoritmos para a gerncia da CPU, sendo o mais
importante o algoritmo de escalonamento com mltiplas filas, preemptivo e com
prioridade dinmica. Este objeto detalhado no item 4.7 Gerncia do Processador.

56

Memria Virtual (u_MemoVirtual)

O objeto Memria Virtual responsvel por alocar e desalocar a memria principal para
os processos, utilizando o mecanismo de gerncia de memria virtual com paginao e
incluindo pre-paging, buffer de pginas e swapping. Este objeto mantm estruturas de
dados responsveis por controlar todas as reas livres e alocadas da memria principal e
secundria pelos processos em execuo. Este objeto detalhado no item 4.8 Gerncia
de Memria.

Espera (u_Espera)

O objeto Espera o thread responsvel por tratar todos os processos no estado de

espera. Este objeto recebe processos vindos da CPU, trata o tipo de evento ocorrido e
retorna o processo para o Escalonador conforme o tipo de evento.
Um processo pode sair do estado de execuo para o estado de espera por trs eventos:
operao de leitura/gravao, page fault ou suspenso. Os dois primeiros eventos
dependem do programa em execuo, enquanto o terceiro depende de um agente
externo (o usurio) que explicitamente suspende o processo.
Um processo pode sair do estado de espera para o estado de pronto por trs eventos:
trmino da operao de leitura/gravao, tmino da leitura da pgina que gerou o page
fault ou resumo do programa. Os dois primeiros eventos so simulados pelo objeto
utilizando um temporizador, que pode ser regulado a partir da barra de controle Tempo
de espera na tela Gerncia do Processador. O terceiro evento depende de um agente
externo (o usurio) para retirar o processo do estado de suspenso (resume).

Formulrios (f_*)

O simulador utiliza vrios formulrios para entrada/sada de parmetros e informaes,

como as janelas de log e estatsticas. A Tab. 4.1 apresenta uma breve descrio dos
principais mdulos implementados.

57

Form

Descrio

f_Console

Permite controlar o simulador.

f_Processo

Permite criar processos.

f_SelecProcesso

Permite selecionar um processo.

f_PCB

Permite visualizar o PCB dos processos.

f_Escalonador

Permite visualizar as mudanas de estado dos processos.

f_Opt_ Escalonador

Permite alterar caractersticas da gerncia do processador.

f_MemoriaVirtual

Permite visualizar a memria principal.

f_Opt_MV

Permite alterar caractersticas da gerncia de memria.

f_Pagefile

Permite visualizar o arquivo de paginao.

f_Log

Permite visualizar as mensagens geradas pelo simulador.

f_Estatistica

Permite visualizar estatsticas do simulador.

f_Creditos

Permite visualizar os crditos do trabalho.

Tab. 4.1 Formulrios

4.6 Objeto Processo

O simulador materializa o bloco de controle do processo (Process Control Block
PCB) atravs do objeto Processo, que mantm todas as suas informaes, como
identificao, prioridade, estado corrente e informaes sobre o programa em execuo.
Alm destes atributos, o objeto Processo possui mtodos que permitem sua criao,
alterao, suspenso e eliminao.
O objeto Processo pode ser dividido logicamente nos trs elementos bsicos que
formam o conceito de um processo tradicional: contexto de hardware, contexto de
software e espao de endereamento, que juntos mantm todas as informaes
necessrias ao controle do processo.
O contexto de hardware implementado pelo simulador formado, basicamente, do
contedo do registrador program counter (PC) e bits de estado. Quando um processo

58

est em execuo, o seu contexto de hardware est armazenado nos registradores do

processador. No momento em que o processo perde a utilizao da CPU, o sistema salva
suas informaes no seu contexto de hardware.
O contexto de software especifica caractersticas do processo que vo influir na
execuo de um programa, sendo que estas caractersticas so determinadas no
momento da criao do processo. O contexto de software no SOsim define basicamente
dois grupos de informaes sobre um processo: sua identificao e suas quotas.
Cada processo criado pelo simulador recebe uma identificao nica (PID process
identification), representada por um nmero e uma cor. O nmero criado a partir da
hora (hora, minutos e segundos) corrente. A cor pode ser selecionada pelo usurio ou o
simulador oferece uma das vrias opes de cores disponveis. O simulador evita a
repetio de cores utilizando um vetor de cores pr-definido.
As quotas so os limites de cada recurso do sistema que um processo pode alocar. Caso
uma quota seja insuficiente, o processo poder ser executado lentamente ou mesmo no
ser executado. Um exemplo de quota implementada no simulador o nmero mximo
de frames que o processo pode alocar.
O espao de endereamento a rea de memria do processo onde o programa ser
virtualmente executado. O simulador implementa uma tabela de pginas para cada
processo. Sendo assim, cada processo possui seu prprio espao de endereamento, que
protegido do acesso dos demais processos.
4.6.1 Criao do Processo
A criao de um processo bastante simples e pode ser feita a partir de valores prdefinidos oferecidos pelo simulador ou definidos pelo prprio usurio (Fig. 4.8). Por
uma questo de praticidade, o simulador permite que na hora da criao de um processo
se especifique o nmero de processos a serem criados. Por exemplo, se o usurio

59

especificar trs processos a serem criados, todas as caractersticas contidas no

formulrio, com exceo da cor, so repetidas nos processos.

Fig. 4.8 - Criao de processo(s)

A cor de cada processo deve ser atribuda de forma a evitar que dois processos tenham a
mesma cor, o que prejudicaria o acompanhamento visual dos processos. O simulador
permite selecionar uma cor especfica ou que o prprio software selecione uma cor em
funo de um vetor de cores pr-definido.
Na Fig. 4.8, a Prioridade define a prioridade base do processo e varia de 0 a 15
(default 0). O Limite de frames define o nmero mximo de pginas que um processo
pode alocar na memria principal e varia de 1 a 5 (default 5).
O programa implementa um esquema de perfis para a escolha do programa a ser
executado pelo simulador. Ao contrrio do usurio ter que escrever um programa em
assembly ou em uma linguagem de alto nvel, basta ele selecionar um perfil de cdigo
pr-definido. Existem seis Tipo de processo pr-definidos que podem ser
selecionados no momento da criao do processo (Tab. 4.2). Foi padronizado que todos
os tipos de cdigo geram apenas uma operao de gravao na memria, sempre na
primeira pgina do programa.

60

Programa

Descrio

CPU

No realiza operaes de entrada/sada.

IO_1

Realiza apenas operaes de entrada/sada do tipo 1.

IO_2

Realiza apenas operaes de entrada/sada do tipo 2.

IO_3

Realiza apenas operaes de entrada/sada do tipo 3.

MISTO_1

Realiza instrues de acesso memria e operaes de

entrada/sada do tipo 1.

MISTO_2

Realiza instrues de acesso memria e operaes de

entrada/sada do tipo 2.
Tab. 4.2 - Cdigos pr-definidos

Foram implementados cinco tipos de instrues que podem ser executadas pelo
processador (Tab. 4.3). A primeira instruo funciona apenas como um load que no
altera o contedo da memria. A segunda funciona como um store, alterando o
contedo da memria principal. Esta instruo importante para gerar pginas
modificadas no modelo de memria virtual. Do terceiro ao quinto tipos, as instrues
funcionam como uma operao de entrada/sada, obrigando o processo a ser colocado
no estado de espera. A diferena dos tipos de instrues de E/S apenas o boost na
prioridade base do processo.
Instruo

Descrio

Leitura da memria principal.

-1

Gravao na memria principal.

Operao de entrada/sada que permite aumento de prioridade de

um ponto.

Operao de entrada/sada que permite aumento de prioridade de

dois pontos.

Operao de entrada/sada que permite aumento de prioridade de

trs pontos.
Tab. 4.3 - Tipos de instrues

61

4.6.2 Visualizao dos Processos

O simulador permite visualizar todos os processos criados em um formato semelhante
ao apresentado por sistemas operacionais reais. Cada linha exibe a cor e a identificao
do processo, a prioridade base e dinmica respectivamente, o tempo de UCP e o nmero
de frames alocados na memria (Fig. 4.9). As informaes contidas na janela so
atualizadas em tempo-real, permitindo acompanhar as alteraes de alguns campos.

Fig. 4.9 - Visualizao dos processos

Operao

Descrio

Suspende

Faz com que o processo selecionado fique no estado de espera.

Resume

Faz com que um processo suspenso retorne para a fila de

processos no estado de pronto.

Finalizar

Faz com que o processo seja terminado e seu PCB eliminado.

PCB

Permite visualizar o bloco de controle do processo.

Tab. 4.4 - Operaes sobre processos

possvel realizar algumas operaes sobre um processo selecionado na janela de

visualizao de processos (Tab. 4.4). Alm destas operaes, o usurio poder alterar a

62

prioridade base de um processo, realizando um duplo clique no campo Prio do

processo selecionado.
4.6.3 Visualizao dos PCBs
O bloco de controle (Process Control Block - PCB) a alma de um processo. Nele
temos todas as informaes importantes para executar um programa em um ambiente
multiprogramvel. O simulador permite visualizar o PCB de qualquer processo
selecionado e observar seu contexto de hardware e software (Fig. 4.10).

Fig. 4.10 - Process Control Block

O PCB exibe todas as propriedades do processo e so atualizadas periodicamente,
permitindo observar as mudanas de suas caractersticas em tempo real. A opo PPT
permite visualizar a tabela de pginas do processo (Process Page Table PPT), que
representa o seu espao de endereamento. A partir das setas da Fig. 4.10, possvel
percorrer a lista de processos criados e observar seus atributos.

63

4.7 Gerncia do Processador

O ambiente de gerncia do processador responsvel por diversas funes no
simulador, sendo implementada por diversos mdulos. Na Fig. 4.11, existem trs
processos no simulador: o processo de cor vermelha est no estado de pronto para
execuo e aguarda pela liberao da CPU (objeto Escalonador), o processo em verde
est sendo executado (objeto CPU) e o de cor amarela aguarda por algum evento no
estado de espera (objeto Espera). A gerncia do processador permite acompanhar
facilmente as mudanas de estado de um processo, atravs de sua cor e posio no
modelo de trs estados.

Fig. 4.11 - Estados dos processos no simulador

Na parte inferior da janela Gerncia do Processador possvel alterar a dinmica de
funcionamento do simulador atravs de trs barras de controle. A barra Tempo de
espera permite controlar o tempo que um processo fica no estado de espera. A barra
Quantum permite controlar o tempo mximo que um processo pode permanecer na

64

CPU sem sofrer uma interrupo de time-slice. Finalmente a barra Freqncia clock
permite alterar o intervalo de tempo que a CPU sofre uma interrupo de clock.
O objeto Escalonador responsvel por manter a lista de processos prontos para
executao e selecionar dentre os processos disponveis um que ganhar o acesso ao
processador. Os processos no estado de pronto so selecionados em funo do algoritmo
de escalonamento escolhido (Fig. 4.12).

Fig. 4.12 - Opes de escalonamento

O escalonador implementa dezesseis nveis de prioridade, de zero (0) a quinze (15),
sendo que a seleo feita de forma decrescente, ou seja, os processos de maior
prioridade so escalonados primeiro. Para cada nvel de prioridade existe uma lista de
processos de mesma prioridade, funcionando no modelo de fila FIFO. Existem dois
motivos para a escolha deste intervalo: o primeiro oferecer um nmero suficiente de
nveis de prioridade em funo do espao disponvel para represent-los na tela e o
segundo por ser um intervalo real, semelhante aos utilizados nos sistemas OpenVMS e
Windows 2000.
A Prioridade mnima de tempo real define a partir de qual nvel de prioridade o
escalonamento de preempo por tempo est desabilitado. Na Fig. 4.12, a partir da
prioridade de nvel oito no existe mais o conceito de quantum, ou seja, um processo
nesta condio utiliza o processador enquanto no surgir um processo de maior
prioridade (preempo por prioridade) ou o processo no deixar espontneamente a
CPU. Este modelo de escalonamento hbrido permite que o simulador oferea um

65

ambiente para aplicaes de tempo compartilhado e de tempo real. Na mesma figura,

processos com prioridade entre zero e sete sero tratados como processos de tempo
compartilhado, enquanto processos entre oito e quinze sero considerados como de
tempo real.
A opo de Escalonamento preemptivo por prioridade habilita o simulador a
interromper um processo em execuo e transferi-lo para o estado de pronto no
momento que um processo de maior prioridade chega na lista de processos em estado de
pronto.
A opo de Escalonamento com prioridade dinmica habilita o simulador a dar
aumentos de prioridade (boost) aos processos em funo do tipo de evento que o fez sair
do estado de execuo para o estado de espera (Tab. 4.5). O tipo de operao de
entrada/sada definido no momento da criao do processo, a partir da escolha de uma
das opes de cdigo pr-definido (Fig. 4.8).
Boost

Tipo de evento

+1

Operao de E/S do tipo 1.

+2

Operao de E/S do tipo 2 e page fault.

+3

Operao de E/S do tipo 3.

Tab. 4.5 - Aumento de prioridade

O aumento de prioridade sempre dado a partir da prioridade base, ou seja, se um

processo tem prioridade base um e prioridade dinmica trs, caso o processo tenha um
boost de um, sua prioridade dinmica no ser quatro, mas sim dois. Processos com
prioridade base na faixa de prioridade de tempo real no sofrem aumento de prioridade.
4.8 Gerncia de Memria
A gerncia de memria virtual responsvel, basicamente, por alocar e desalocar
memria principal e secundria para os processos. Isto significa que o mdulo de

66

gerncia de memria (objeto MemoVirtual) responsvel pelo mapeamento, definio

de tamanho de pgina, polticas de busca, alocao e substituio de pginas e
swapping.
A janela Gerncia de Memria representa a memria prinicipal, formada por 100
frames numerados de 0 a 99 (Fig. 4.13). Conforme os processos so criados, os frames
so alocados para o processo. Cada frame alocado marcado com um crculo da mesma
cor que o processo, permitindo uma identificao rpida de quais as pginas cada
processo est alocando. No exemplo, o processo em verde est alocando os frames 0, 2,
4, 6 e 8 da memria principal, enquanto o processo em vermelho est alocando os
frames 1, 3, 5, 7 e 9. As pginas 0 e 1, de fundo escuro, representam pginas
modificadas dos processos.

Fig. 4.13 Memria principal

Na parte inferior da janela Gerncia de Memria existem dois contadores. O FPL
Size indica o tamanho da lista de pginas livres (Free Page List FPL) na memria, ou

67

seja, quantas pginas esto disponveis para uso. O MPL Size indica o tamanho da
lista de pginas modificadas (Modified Page List MPL), ou seja, quantas pginas
modificadas no foram gravadas no arquivo de paginao.
O mdulo de gerncia de memria oferece alguns parmetros de configurao da
gerncia de memria virtual (Fig. 4.14). A opo Poltica de busca de pginas permite
selecionar se a poltica de busca ser antecipada (default) ou por demanda. O esquema
de busca antecipada faz com que a gerncia de memria carregue antecipadamente o
programa a ser executado da memria secundria para a memria principal. O esquema
de pre-paging tambm foi includo no simulador por motivos didticos. Geralmente,
quando ensinamos as mudanas de estados do processo, muito pouco foi falado sobre
memria virtual e menos ainda sobre page fault. Na gerncia de memria virtual sem
paginao antecipada, as pginas de um programa so carregadas para a memria
principal por demanda. Isto gera um page fault inicial para cada pgina referenciada,
acarretando uma mudana do estado (execuo espera). Esta situao introduz mais
uma mudana de estado (page fault) no modelo, o que poderia complicar a abordagem
inicial das mudanas de estados do processo.

Fig. 4.14 - Opes de memria

A opo Implementar limite de frames ... habilitada faz com que o mdulo de
gerncia de memria utilize o conceito de conjunto de pginas mais referenciadas. Este
conceito melhor detalhado no item 4.8.3 Lista de Frames. A opo Mnimo de

68

pginas livres ... representa o nmero mnimo de pginas disponveis na memria

principal aceito pelo simulador, sendo o default 80% porcento. Quando este valor
atingido, o mdulo de gerncia de memria ativa o esquema de recuperao de pginas
para garantir o tamanho mnimo da lista de pginas livres especificado.
4.8.1 Mapeamento
Um programa no ambiente do simulador no faz referncia a endereos fsicos de
memria (endereos reais), mas apenas a endereos virtuais. No momento da execuo
de uma instruo, o endereo virtual traduzido para um endereo fsico, pois o
processador acessa apenas posies da memria principal. O mecanismo de traduo do
endereo virtual para endereo fsico denominado mapeamento.
Cada processo possui seu espao de endereamento prprio, implementado atravs de
uma tabela de pginas (Process Page Table PPT). Cada entrada na tabela de pginas
(Page Table Entry PTE) do processo permite mapear uma pgina virtual em um frame
na memria principal (Fig. 4.15). Cada PTE, alm do endereo do frame na memria
principal, possui dois bits de controle: um para indicar se a pgina est na memria
principal (V bit ou bit de validade) e outra para indicar se a pgina foi modificada (M
bit ou bit de modificao).
Na Fig. 4.15, o processo selecionado possui quatro pginas vituais (Virtual Page
Number - VPN) na memria principal: VPN0 a VPN3. Isto pode ser facilmente
acompanhado a cada page fault, que faz com que o simulador aloque um frame na
memria principal (Page Frame Number - PFN) e ligue o bit de validade (V Bit=1).
Alm disso, a VPN0 possui seu bit de modificao ligado (M bit=1), indicando que a
pgina foi modificada. Finalmente, a figura mostra que a VPN4 no foi ainda
referenciada (PFN=-1).

69

Fig. 4.15 - Tabela de pginas

4.8.2 Tamanho de pgina
A definio do tamanho de pgina em sistemas que implementam memria virtual por
paginao um importante fator no seu projeto. O tamanho da pgina est associado ao
hardware e varia de acordo com a arquitetura. No caso do SOsim, a definio do
tamanho de pgina no est relacionada arquitetura de hardware ou ao possvel
problema do tamanho da tabela de pginas dos processos. A questo mais importante
para a definio do tamanho de pgina a ser utilizado no simulador foi como conseguir
mostrar o funcionamento do mecanismo de memria virtual de uma forma que o aluno
consiga visualizar e entender o mecanismo.
A princpio, o simulador pode suportar qualquer tamanho de pgina, bastando alterar a
definio da constante PAGE_SIZE, definido com oito bytes. Como o tamanho mximo
de um programa de 40 bytes, definido na constante MAX_PGM_SIZE, o tamanho da
tabela de pginas de cada processo de cinco entradas (PTEs), variando de zero
(VPN0) a quatro (VPN4). Apesar de ser um valor pequeno, este nmero permite ao
aluno acompanhar facilmente a evoluo da alocao e substituio de pginas de um
ou mais processos na memria principal.

70

4.8.3 Lista de Frames

A lista de frames o conjunto de pginas que um processo possui na memria principal
em determinado instante de tempo. A lista de frames permite criar algo semelhante ao
conceito de working set, implementado pelos sistemas OpenVMS e Windows 2000.
Sempre que uma pgina referenciada, o bit de validade da entrada da tabela de pginas
(PTE) correspondente verificado. Caso ele esteja ligado indicar que esta uma
pgina vlida, pois est na lista de frames. Desta forma o sistema poder localizar a
pgina na memria real, atravs das demais informaes contidas no PTE. Por outro
lado, se o bit de validade no estiver ligado, significar que esta uma pgina no
vlida. Neste caso, podemos dizer que ocorreu um page fault, que a interrupo
(exceo) gerada quando uma pgina referenciada no est na lista de frames. Quando
isto acontece, o sistema se encarregar de trazer a pgina para a lista, atualizar o PTE e
executar novamente a referncia pgina, que agora ser vlida.
O SOsim utiliza a poltica de alocao de pginas fixa, ou seja, o tamanho da lista de
frames no alterado durante a simulao. O tamanho da lista de frames de cada
processo definido individualmente na sua criao e o default o processo ser criado
com cinco pginas. Este valor default permite que o processo tenha todas as suas
pginas na memria principal. O esquema de limite de frames pode ser desabilitado no
simulador atravs das opes da gerncia de memria virtual.
4.8.4 Poltica de Substituio de Pginas
Cada processo possui um limite mximo para o nmero de frames que podem ser
alocados na memria principal. Quando este limite alcanado e o processo necessita
trazer uma nova pgina para a lista de frames, um page fault ocorre e uma pgina deve
ser cedida em troca por uma nova pgina (Fig. 4.16a).
O simulador implementa a poltica de descartar a pgina mais antiga presente na lista de
frames, utilizando uma estrutura de dados do tipo fila (FIFO). Aparentemente esta

71

poltica pode no parecer apropriada, se partirmos do princpio que a pgina descartada

pode ser uma pgina muito referenciada. Para contornar este problema, o simulador
implementa o mecanismo de buffer de pginas que compensa a opo por essa poltica.
No momento em que um determinado processo descarta uma pgina, esta pgina pode
tomar rumos diferentes em funo das suas caractersticas. Para entender como isso
ocorre, preciso antes distinguir as pginas modificveis das no modificveis.

Fig 4.16 - Poltica de substituio de pginas

As pginas modificveis so aquelas que armazenam variveis, que naturalmente
trocam de valor durante a execuo do programa. Por outro lado, as pginas que contm
cdigo executvel do programa no podem ser alteradas e portanto so chamadas de no
modificveis. Uma pgina modificada no pode ser descartada quando sai da lista de
frames do processo, pois ela contm dados necessrios continuidade da execuo do

72

programa. preciso, ento, que essa pgina seja gravada em disco para que, na prxima
referncia, a mesma volte com os valores originalmente gravados. As pginas no
modificadas, por sua vez, no precisam desse tratamento, pois podem ser retiradas do
arquivo executvel quando necessrio (Fig. 4.16b).
Os tempos de leitura e gravao em disco so reconhecidamente elevados quando
comparados com o tempo de acesso memria. Logo, causaria um grande retardamento
na execuo do programa caso os procedimentos, antes descritos, fossem seguidos
fielmente. Imagine se a cada entrada ou sada de pgina da lista de frames fossem feitas
leitura e gravao em disco respectivamente! Para contornar esse problema o sistema
mantm duas listas que funcionam em conjunto no sentido de diminuir as operaes em
disco. Essas listas so a lista de pginas livres (Free Page List FPL) e a lista de
pginas modificadas (Modified Page List MPL), as quais funcionam como ser
descrito.
Cada PTE, alm do bit de validade, possui um bit de modificao (M bit) que indica se
a pgina sofreu alguma alterao no seu contedo. Assim, quando uma pgina deve ser
substituida, o bit de modificao primeiramente verificado. Caso esse esteja ligado
(indicando que houve modificao), a pgina passada do working set do processo para
a lista de pginas modificadas (Fig. 4.16c). Por outro lado, se o bit estiver desligado, a
pgina passada para a lista de pginas livres (Fig. 4.16d).
A lista de pginas livres uma estrutura de dados da gerncia de memria virtual
responsvel por manter informaes sobre todas as pginas fsicas da memria principal
que esto disponveis para serem utilizadas. Quando um processo libera uma pgina
para a lista de pginas livres, esta pgina no imediatamente utilizada, j que a pgina
deve percorrer a lista do fim at o seu incio (FIFO). Desta forma, as pginas que saem
da lista de frames permanecem na memria por algum tempo, permitindo que essas
mesmas pginas possam voltar para o processo sem operaes de leitura em disco (Fig.
4.16e).

73

Na ocorrncia de um page fault, a gerncia de memria pode eventualmente encontrar a

pgina requerida na lista de pginas livres ou na lista de pginas modificadas, gerando
um page fault sem operao de E/S, conhecido como soft page fault. Quando no ocorre
o esse tipo de page fault, o sistema obrigado a trazer a pgina requerida do disco (hard
page fault) e solicitar um novo frame lista de pginas livres, no qual a pgina ser
colocada.
A lista de pginas livres, eventualmente, fica com poucas pginas disponveis para
atender a demanda dos processos. Este parmetro definido nas opes de gerncia de
memria virtual, sendo que o default cinqenta porcento. Nesse caso, as pginas que
esto na lista de pginas modificadas so gravadas em disco no arquivo de paginao
(Fig. 4.16f) e suas pginas so passadas para a lista de pginas livres (Fig. 4.16g). Note
que apenas nesse caso as pginas modificadas so gravadas em conjunto no disco e,
portanto, apenas uma operao de gravao em disco efetuada.
Quando ocorre um page fault, a pgina requerida pode estar em vrios lugares como no
arquivo executvel, na lista de pginas modificadas, na lista de pginas livres ou no
arquivo de paginao (Fig.4.16h). O arquivo de paginao uma rea em disco comum
a todos os processos, onde as pginas modificveis so salvas para posterior
reutilizao, alm de servir como rea de swapping.
4.8.5 Arquivo de Paginao
O arquivo de paginao (pagefile) utilizado pelo mdulo de gerncia de memria com
dois propsitos bsicos: servir como repositrio para a lista de pginas modificadas e
como rea de swapping. Alguns sistemas operacionais, como o Windows 2000,
implementam este mecanismo de forma semelhante ao simulador, mas existem sistemas
que implementam dois arquivos separados para paging e swapping (OpenVMS) e outros
simplesmente no realizam swapping, apenas paginao. A deciso por implementar
este modelo foi, novamente, com fins educacionais, pois permite simular tanto o
mecanismo de paginao quanto o de swapping, concentrando os eventos em uma
mesma janela (arquivo) e simplificando a anlise (Fig. 4.17).

74

Quando um processo criado, a gerncia de memria reserva um nmero pr-definido

(MAX_PAGEFILEQUOTA) de blocos no arquivo de paginao. Como pode ser
observado na Fig. 4.17, os blocos numerados de 11 19 esto marcados como
reservados (R). No mesmo arquivo existem pginas modificadas (fundo escuro) e
pginas no modificadas (fundo claro) de diversos processos.

Fig. 4.17 Arquivo de paginao e swapping

As pginas modificadas no arquivo de paginao so gravadas quando o nmero
mnimo de pginas livres est abaixo do limite mnimo definido nas opes de gerncia
de memria virtual (Fig. 4.14). Neste caso, aps a gravao da lista de pginas
modificadas no arquivo de paginao, suas pginas so em seguida liberadas para a lista
de pginas livres.
Caso a gravao da lista de pginas modificadas no seja suficiente para recuperar o
nmero mnimo de pginas livres, o processo de swapping iniciado. O algoritmo de
seleo do candidato a ser retirado da memria principal implementado em etapas e
segue os passos descritos a seguir:

75

1. Os processos no estado de suspenso (Susp) so os primeiros a serem

selecionados para deixarem a memria principal, passando para o estado de
SuspOut;
2. Se o limite de pginas livres no for alcanado, so selecionados os processos no
estado espera por uma operao de E/S (IO). Processos nesta situao so
gravados no arquivo de swap e passam para o estado IOOut;
3. Em seguida so selecionados os processos no estado de page fault (PFault), que
passam para o estado de PFOut;
4. Finalmente os processos no estado de pronto (Pronto) com menor prioridade so
selecionados para deixarem a memria e passam para o estado de ProntoOut.
Em todos os casos, as pginas dos processos na memria principal so liberadas para a
lista de pginas livres. As pginas dos processos que sofreram o processo de swapping
retornam memria quando so escalonados para execuo.
4.9 Estatsticas
A janela Estatsticas oferece ao usurio uma enorme variedade de indicadores dos
diversos mdulos que compem o simulador (Fig. 4.7). Estes valores podem ser
utilizados para comparar polticas e mostrar numericamente as vantagens entre elas.
Alm disso, as estatsticas permitem ao aluno ter contato com um lado da rea de
sistemas operacionais muito pouco discutido nas disciplinas sobre o tema, a parte de
anlise de desempenho. Os indicadores apresentados so em sua maioria utilizados na
prtica para que gerentes de sistemas faam estudos de performance em seus ambientes.
Na Tab. 4.6 so apresentados os principais indicadores estatsticos e uma descrio
suscinta de cada um.
Indicador

Descrio

Hora de Incio

Hora, minuto e segundos do incio de operao do simulador.

Tempo Decorrido

Diferena entre a hora corrente e a hora de incio.

76

Nmero de

Nmero de processos ativos no simulador, nos estados de

Processos

execuo, pronto e espera. Como o simulador implementa apenas

uma CPU, o nmero de processos em execuo sempre um.

Processos

Nmero de processos que saram do estado de pronto para o

Escalonados

estado de execuo, ou seja, foram escalonados para executar.

Througthput

Taxa de processos executados por segundo.

Turnaround

Tempo mdio para a execuo de um processo, desde sua criao

no simualador at o seu trmino.

Tempo Total de

Tempo total (em segundos) que a CPU esteve ocupada. Valores

CPU

prximos de 90% indicam que o processador est no limite de

sua utilizao.

Taxa de utilizao

Relao entre o tempo total de CPU e o tempo que o simulador

da CPU

est sendo utlizado.

Espera Fila de

Somatrio dos tempos de espera (em segundos) dos processos no

Pronto

estado de pronto para execuo.

Espera Mdia

Tempo mdio de espera (em segundos) dos processos no estado

de pronto para execuo.

Espera Acumulada

Tempo mdio acumulado de espera (em segundos) dos processos

no estado de pronto para execuo.

Memria em bytes

Memria principal total.

Memria em uso

Memria principal sendo utilizada pelos processos.

Livre

Porcentual de memria principal disponvel.

Total Page Fault

Nmero acumulado de page faults.

Page Faults/seg

Taxa de page faults por segundo.

Hw Page Fault

Total acumulado de hardware page faults.

Sw Page Fault

Total acumulado de software page faults.

Tab. 4.6 Indicadores estatsticos

77

CAPTULO 5 CONCLUSES E TRABALHOS FUTUROS

5.1 Introduo
Esta dissertao de tese apenas parte de um longo trabalho acadmico, que envolveu a
publicao de um livro com duas edies e vrios anos lecionando disciplinas direta ou
indiretamente ligadas ao estudo de sistemas operacionais.
O SOsim uma ferramenta de apoio educacional que permite facilitar enormemente o
processo de ensino e aprendizado dos conceitos e tcnicas envolvidos em um sistema
operacional multiprogramvel.
O simulador ser colocado gratuitamente para download na Internet, incluindo seu
cdigo fonte. Com o lanamento da terceira edio do livro Arquitetura de Sistemas
Operacionais, espera-se que a comunidade acadmica ganhe conhecimento da
existncia do software educacional e passe a utiliz-lo como suporte ao ensino na
disciplina de sistemas operacionais.
5.2 Concluses
Com o simulador so esperados um grande avano quantitativo e qualitativo no
processo de ensino. Esta melhora percebida principalmente em cursos de curta
durao, como em cursos tcnicos profissionalizantes e de extenso, ou cursos que
tenham alunos que no possuam, ou que possuam parcialmente, os pr-requisitos.
Os testes utilizando o simulador foram realizados nos cursos de graduao em
Informtica da PUC-Rio e ps-graduao em Programao e Anlise de Sistemas da
PUC-Rio/CCE. A partir dos testes implementados em sala de aula, constatou-se uma
srie de contribuies para o ensino e aprendizado de sistemas operacionais, tais como:

78

Ampliao da eficincia no processo de ensino/aprendizado por parte de professores

e alunos, permitindo que conceitos complexos fossem assimilados mais facilmente
pelos alunos;

Melhora na comunicao professor-aluno, reduzindo o tempo necessrio para as

apresentaes conceituais e, conseqentemente, permitindo ampliar o programa da
disciplina e/ou criar projetos prticos. Alm disso, o software motiva o debate e a
discusso sobre possveis cenrios de simulao;

Os testes realizados atingiram apenas a utilizao do software para apoio de aulas

presenciais. Em experimentos futuros, o simulador ser testado como ferramenta de
auxlio ao ensino distncia, mas de se supor que ganhos semelhantes aos
alcanados em aulas presenciais sejam obtidos;

Os testes mostraram que o software facilita a transferncia e aquisio de

conhecimento em funo do maior grau de participao dos alunos, que trocam suas
experincias;

Os testes indicam que os resultados variam conforme o tipo do curso (extenso,

graduao e ps-graduao) e dos pr-requisitos dos alunos,. Em cursos de menor
durao e/ou com alunos sem os pr-requisitos necessrios verifica-se um ganho
maior com a utilizao do simulador.

5.3 Trabalhos Futuros

O simulador aqui apresentado comprovadamente um avano para a melhoria do
ensino e aprendizado de sistemas operacionais, mas possvel ir muito alm. Em funo
do escopo inicialmente definido, foram implementados o ncleo (kernel) do simulador,
os mdulos de gerncia do processador e gerncia de memria.
Como motivao para trabalhos futuros, possvel considerar o desenvolvimento de
novos mdulos e funcionalidades descritas a seguir:

79

Desenvolvimento do mdulo de gerncia de sistema de arquivos, que permita a

criao de arquivos e diretrios, alm da manipulao dos mesmos atravs de uma
interface grfica;

A gerncia de dispositivos uma das reas mais complexas de um sistema

operacional. Mostrar o funcionamento de discos e fitas, alm de interfaces de rede,
seria desejvel;

A gerncia de mltiplos processadores permitiria visualizar um sistema

multiprocessado, sendo que o nmero de processadores poderia ser um parmetro
definido pelo prprio professor ou aluno;

Apesar de existirem bons simuladores na rea de comunicao e sincronizao entre

processos, nenhum possui uma interface grfica que facilite o processo de ensino,
alm de no apresentarem as interfaces com os demais mdulos de um sistema
operacional;

O estudo de sistemas operacionais, muitas vezes, deve considerar questes da

arquitetura de computadores. A criao de uma mquina virtual de hardware que
oferecesse a possibilidade de observar as dependncias entre os dois mundos seria
uma tima ferramenta para ambas as disciplinas;

A partir de uma mquina virtual seria possvel a criao de programas simples em

assembly, que poderiam ser interpretados pelo processador. Com esta facilidade, o
simulador permitiria comparar o cdigo de dois programadores e observar, por
exemplo, aquele de melhor desempenho;

A tcnica de paginao antecipada foi apenas empregada na criao de um processo.

possvel utilizar a mesma tcnica na ocorrncia de um page fault. Neste caso,
sempre que houver um page fault, o sistema poderia trazer, alm da pgina
referenciada, um conjunto de pginas para evitar operaes de leitura sucessivas;

80

O simulador implementa apenas um modelo de gerncia de memria: memria

virtual com paginao. Apesar deste modelo ser o mais empregado atualmente,
possvel implementar mecanismos alternativos, como por exemplo segmentao
com paginao, de forma a ampliar as funcionalidades do simulador;

O ambiente grfico, apesar de ser uma ferramenta poderosa de ensino, distancia o

aluno do mundo real. Existem ambientes que exigem uma interao entre o sistema
e o usurio atravs de linhas de comandos. O desenvolvimento de um shell de
comandos como opo, por exemplo, para a eliminao ou a suspenso de um
processo, seria bastante til em cursos mais prticos e menos conceituais;

possvel tornar o SOsim uma ferramenta educacional mais colaborativa,

permitindo o desenvolvimento de trabalhos em grupos, na forma de projetos, e a
construo do conhecimento cooperativo. Seriam introduzidas interfaces prdefinidas com os principais mdulos do simulador, de forma que novos mdulos
pudessem ser alterados e/ou implementados conforme a realidade a ser simulada;

Com a evoluo do ensino distncia, possvel imaginar um curso de sistemas

operacionais totalmente no-presencial, utilizando apenas a Internet como meio de
comunicao entre alunos e professor que poderiam estar geograficamente distantes.
Neste caso, o simulador teria um papel muito mais importante no processo de ensino
do que apenas uma ferramenta de apoio [DRISCOLL, 1998] [HALL, 1998].

Apesar da maioria dos tpicos sugeridos apresentarem um certo grau de complexidade

para o desenvolvimento por alunos principiantes, possvel que em cursos de graduao
e ps-graduo alguns dos temas propostos possam ser implementados.

81

REFERNCIAS BIBLIOGRFICAS
ANDERSON, T., LEVY, H., BERSHAD, B., LAZOWSKA, E. The Interaction of
Architecture and Operating System Design. ACM SIGPLAN Notices, vol. 26, n
4, pp. 108-120, April 1991.
ANDERSON,

T.E.,

Instructional

CHRISTOPHER,
Operating

W.A.,

System.

PROCTER,
Disponvel

S.J.
na

The

Nachos

Internet

em

http://www.cs.washington.edu/homes/tom/nachos/, 1999.
BACH, M.J. The Design of Unix Operating System. Prentice-Hall, 1986.
BEN-ARI, M. Principles of Concurrent and Distributed Programming. PrenticeHall, 1990.
BOOCH, G. Object-Oriented Analysis and Design with Applications. 2 Ed.,
Addison-Wesley, 1994.
BORLAND. Object Pascal Language Reference. Borland, 1999.
BORLAND. Developers Guide. Borland, 1999.
BORLAND. Programming with Delphi. Borland, 1999.
BORLAND. Visual Component Library (VCL). Borland, 1999.
BORLAND. Win32 API Documentation. Borland, 1999.
BRENDA, M. Instructional Design and Learning Theory. Disponvel na Internet em
http://www.usask.ca/education/coursework/802papers/mergel/brenda.htm, 1998.

82

BYNUM, B., CAMP, T. After You, Alfonse: A Mutual Exclusion Toolkit.

Proceedings of the 27th SIGCSE Technical Symposium on Computer Science
Education, Feb. 1996.
BYNUM, B., CAMP, T. After You, Alfonse: A Mutual Exclusion Toolkit - An
Introdution to BASI. Disponvel na Internet em http://www.mines.edu/fs_home/
tcamp/baci/, 1999.
CALVERT, C. Delphi Unleashed. Sams Publishing, 1996.
DENNING, P. The Working Set Model for Program Behavior. Communications of
the ACM, vol. 11, n 5, Mai 1968.
DENNING, P. Virtual Memory. Computer Surveys, vol. 2, n 3, Dec. 1970.
DENNING, P. Third Generation Computer Systems. Computer Surveys, vol. 3, n 4,
Dec. 1971.
DENNING, P. Working Sets Past and Present. IEEE Transactions on Software
Engineering, vol. SE-6, n 1, Jan. 1980.
DRISCOLL, M. Web-based Training: Tactics and Techniques for Designing Adult
Learning. Jossey-Bass/Pfeiffer, 1998.
EDWARDS, S. D., KING, D. R., WINBLAD, A. L. Object-Oriented Software.
Addison-Wesley, 1990.
FREEBSD. FreeBSD HandBook. Disponvel na Internet em http://www.freebsd.org/
handbook/index.html, 2000.
HALL, B. Web-based Training Cookbook. John Wiley & Sons, 1997.

83

HANLEY, S. On Constructivism. http://www.inform.umd.edu/UMS+State/UMDProjects/MCTP/Essays/Constructivism.txt, 1994.

HERROD, S.A., Using Complete Machine Simulation to Understand Computer
System Behavior. Tese de D.Ph., Stanford University, Feb. 1998.
JUNQUEIRA, L. MESQUITA, F., ARAJO, M. CPUsim Simulador da
Arquitetura de um Processador Acadmico. Projeto de Final de Curso, Depto de
Cincia da Computao da UFRJ, 1997.
KIFER, M., SMOLKA, S. OSP: An Environment for Operating Systems. AddisonWesley, 1991.
KIFER, M., SMOLKA, S. OSP: An Environment for Operating Systems (Instructor
Version). Addison-Wesley, 1991.
KLEIMAN, S., SHAH, D., SMALDERS, B. Programming with Threads. SunSoft
Press, Prentice-Hall, 1996.
LEVY, H.M., ECKHOUSE, R.H. Computer Programming and Architecture: The
VAX-11. Digital Press, 1980.
MACHADO,

F.M.,

MAIA,

L.P.

Introduo

Arquitetura

de

Sistemas

Operacionais. LTC, 1992.

MACHADO, F.M., MAIA, L.P. Arquitetura de Sistemas Operacionais. 2 ed., LTC,
1997.
MAIA, L.P. Pgina do Livro Arquitetura de Sistemas Operacionais. Disponvel na
Internet em http://home.ismnet.com.br/~lpmaia/aso.htm, 1998.

84

MAIA, L.P. Multithread. Monografia da disciplina Laboratrio de Sistemas

Operacionais II, NCE/UFRJ, 1999.
MELO, P.T. Reclalificao de Trabalhadores e Formao Distncia no Ensino
Mdio. Tese de M.Sc. COPPE/UFRJ, Fev. 1999.
MILLER, D.D. VAX/VMS Operating System Concepts. Digital Press, 1992.
NICHOLS, B., BUTTAR, D., FIRRELL, J. Pthreads Programming. O'Reilly Press,
1996.
PHAM, T.Q., GANG, P.K. Multithreaded Programming with Windows NT.
Prentice-Hall, 1996.
PLAT, D.S. Windows 95 and NT: Win32 API from Scratch: A Programmers
Workbook. Prentice-Hall, 1996.
RICHTER, J. Advanced Windows. 3 ed., Microsoft Press, 1997.
ROBBINS, K.A., ROBBINS, S. Practical Unix Programming: A Guide to
Concurrency, Comunication, and Multithreading. Prentice-Hall, 1996.
SILBERSCHATZ, A., GALVIN, P. Operating System Concepts. 5 ed., AddisonWesley, 1998.
SOLOMON, D.A. Inside Windows NT. 2 ed., Microsoft Press, 1998.
STALLINGS, W. Operating Systems: Internal and Design Principles. 3 ed.,
Prentice-Hall, 1997.
TANENBAUM, A.S. Modern Operating Systems. Prentice-Hall, 1992.

85

TANENBAUM, A.S. MINIX Information Sheet. Disponvel na Internet em

http://www.cs.vu.nl/~ast/minix.html, 1996.
TANENBAUM, A.S., WOODHULL, A.S. Operating Systems: Design and
Implementation. Prentice-Hall, 1997.
TROPIX. Projeto TROPIX. Disponvel na Internet em http://www.tropix.nce.ufrj.br,
2000.
VAHALIA, U. Unix Internals: The New Frontiers. Prentice-Hall, 1996
VALENTE, J.A. Diferentes Usos do Computador na Educao. n 57, jan/mar, 1993.
VOSS G. Object-Oriented Programming: An Introduction. McGraw-Hill, 1991.
WIRFS-BROCK, R., WILKERSON, B., WIENER, L. Designing Object-Oriented
Software. Prentice-Hall, 1990.