Monografia EPSOsim v. 1.10.35_FINAL

FACULDADE FARIAS BRITO
CIÊNCIA DA COMPUTAÇÃO
JOEL OLIVEIRA DE CARVALHO
EPSOSIM – SIMULADOR DE ESCALONAMENTO DE PROCESSOS EM
SISTEMAS OPERACIONAIS
FORTALEZA
2011
JOEL OLIVEIRA DE CARVALHO
EPSOSIM – SIMULADOR DE ESCALONAMENTO DE PROCESSOS EM
SISTEMAS OPERACIONAIS
Monografia de graduação apresentada na
Faculdade Farias Brito como requisito parcial
do curso de Ciência da Computação para
obtenção do título de Bacharel em Ciência da
Computação.
Orientado por: MSc. Sérgio Araújo Yunes
FORTALEZA
2011
II
EPSOSIM – SIMULADOR DE ESCALONAMENTO DE PROCESSOS EM
SISTEMAS OPERACIONAIS
Joel Oliveira de Carvalho
PARECER _____________________
NOTA: FINAL (0 – 10): _______
Data: ____/____/_________
BANCA EXAMINADORA:
__________________________________
MSc. Sérgio Araújo Yunes
(Orientador)
___________________________________
MSc. Francisco Lúcio Gomes Guimarães
(Examinador)
___________________________________
MSc. José Helano Matos Nogueira
(Examinador)
III
Dedico este trabalho ao Deus Todo Poderoso, ao Senhor dos Exércitos
e Pai dos espírito. Ao seu Filho amado Senhor Jesus Cristo e ao
Espírito Santo a qual nos ensina e corrige. A meu pai João Ananias
que me ajudou financeiramente no começo de minha jornada. A
minha mãe Antônia pelo incentivo e apoio.
IV
AGRADECIMENTOS
Primeiramente, agradeço a Deus que verdadeiramente nos ama mesmo nós sendo
ingratos, pecadores, imerecível da sua misericórdia. Pois Ele não muda e está é a razão de
nós não sermos consumidos (Malaquias 6.3).
Aos meus pais João Ananias, por ter me ajudado financeiramente no início do curso e
Antônia por ter me apoiado e à minha irmã Jackeline, por ter me incentivado. A meu irmão
Jarbas por ter me ajudado. À minha prima Samilly Dantas, por ter contribuído em minhas
pesquisas.
Ao professor Sérgio Yunes, por ter me orientado, colaborado e se empenhado para a
conclusão deste trabalho. Ao Professor de metodologia científica Leonardo por ter revisado.
Aos meus amigos e colega de trabalho Marcos Rafael, Cristtiano pelos conselhos e por
ter cooperado com o meu o projeto.
Agradeço aos professores que participaram da banca, ao professor Helano Matos. E ao
professor Lúcio Guimarães por tornar este trabalho com mais qualidade, por ser um professor
muito crítico e perceptivo. Ao professor e coordenador do curso de Ciência da Computação
Ricardo Wagner pelos conselhos e pelas críticas construtivas.
Aos meus colegas e professores, todos que contribuíram direto e indiretamente para a
conclusão deste trabalho.
V
Posso todas as coisas em Cristo que me fortalece. (Filipenses 4.13)
VI
RESUMO
No Brasil há uma grande carência de ferramentas de ensino-aprendizagem prática para o
ensino da disciplina de Sistemas Operacionais. Existem entre os alunos certas dificuldades em
compreender o conteúdo das disciplinas teóricas do curso de Ciência da Computação,
Engenharia da Computação e Sistemas de Informações, no qual os professores se empenham
em transmitir. Com a interface gráfica do simulador, torna mais viável para aos alunos a
visualização dos assuntos complexos e abstratos de escalonamento de processos da disciplina
de Sistemas Operacionais. Os alunos serão capazes de resolver suas atividades com mais
eficiência e tirar suas dúvidas do conceito teórico com base na observação no simulador. O
simulador EPSOsim busca de forma simples, prática e detalhada simular os algoritmos de
escalonamento de processos.
Palavras chaves: escalonamento de processos, Sistemas Operacionais, algoritmos, FIFO,
Round Robin, prioridade.
VII
ABSTRACT
In Brazil it has a great lack of tools of practical teach-learning for the education of disciplines
of Operational Systems. Difficulties in understanding the content of them exist between the
certain pupils discipline theoreticians of the course of computer science, engineering of the
computation and systems of information, in which the professors if pledge in transmitting.
With the graphical interface of the simulator, it becomes more viable for the pupils the
visualization of the complex subjects and abstract of scheduling of processes of it disciplines
of Operational Systems. The pupils will be capable to decide its activities with more
efficiency and to take off its doubts of the theoretical concept on the basis of the comment in
the simulator. The EPSOsim simulator search of form simple, practical and detailed to
simulate the algorithms of scheduling of processes.
Words keys: scheduling of processes, Operational Systems, algorithms, FIFO, Round Robin,
priority.
VIII
SUMÁRIO
INTRODUÇÃO ..................................................................................................................................................... 1
METODOLOGIA ................................................................................................................................................. 2
1.
TEORIAS EDUCACIONAIS E FERRAMENTAS DE ENSINO-APRENDIZAGEM ....................... 4
1.1
ENSINO CONTEUDISTA ...................................................................................................................... 4
1.2
TEORIA CONSTRUTIVISTA ................................................................................................................. 4
1.3
FERRAMENTAS DE AUXÍLIO AO ENSINO-APRENDIZAGEM ................................................................. 5
1.3.1 SIMULADORES ................................................................................................................................... 5
1.3.1.1 SOSIM ............................................................................................................................................... 6
1.3.1.2 SISO ................................................................................................................................................. 7
1.3.1.3 NACHOS ............................................................................................................................................ 7
1.3.1.4 MOSS ............................................................................................................................................... 8
1.3.2 SISTEMAS REAIS ................................................................................................................................ 9
1.3.2.1 MINIX .............................................................................................................................................. 9
1.3.3 LINUX.............................................................................................................................................. 10
1.3.3.1 PROJETO GNU ................................................................................................................................ 12
1.3.3.2 KERNEL LINUX ................................................................................................................................ 13
2.
SISTEMAS OPERACIONAIS E O ESCALONAMENTO DE PROCESSOS .................................. 15
2.1
CONCEITOS BÁSICOS DE SISTEMAS OPERACIONAIS......................................................................... 15
2.2
PROCESSOS...................................................................................................................................... 18
2.2.1 PROCESSOS X THREADS.................................................................................................................... 19
2.2.2 MULTIPROGRAMAÇÃO .................................................................................................................... 20
2.2.3 BLOCO DE CONTROLE ..................................................................................................................... 21
2.3
ESCALONAMENTO DE PROCESSOS ................................................................................................... 22
2.3.1 PREEMPTIVO E NÃO-PREEPTIVO ...................................................................................................... 23
2.3.2 FUNÇÕES DO ESCALONAMENTO DE PROCESSOS .............................................................................. 24
2.3.3 CATEGORIA DE ALGORITMOS DE ESCALONAMENTO EM LOTE, INTERATIVO E TEMPO REAL. .......... 26
3.
4.
ARQUITETURA DO SIMULADOR ..................................................................................................... 28
3.1
CLASSES E OBJETOS DO SIMULADOR ............................................................................................... 28
3.2
DIAGRAMA DE CLASSES .................................................................................................................. 33
FUNCIONAMENTO E DESCRIÇÃO DO AMBIENTE ..................................................................... 35
4.1
AMBIENTE DO SIMULADOR ............................................................................................................. 35
IX
4.2
JANELA PRINCIPAL .......................................................................................................................... 36
4.3
JANELA CONFIGURAÇÃO DO SISTEMA ............................................................................................. 37
4.4
JANELAS DE ESCALONAMENTO DE PROCESSOS ............................................................................... 39
4.4.1 JANELA FIFO .................................................................................................................................. 43
4.4.2 JANELA SJF ..................................................................................................................................... 45
4.4.3 JANELA SRT .................................................................................................................................... 47
4.4.4 JANELA CIRCULAR .......................................................................................................................... 48
4.4.5 JANELA PRIORIDADE NÃO-PREEMPTIVO ......................................................................................... 51
4.4.6 JANELA PRIORIDADE PREEMPTIVO .................................................................................................. 53
4.4.7 JANELA CIRCULAR COM PRIORIDADES ............................................................................................ 54
4.4.8 JANELA MÚLTIPLAS FILAS .............................................................................................................. 55
4.5
JANELA DIAGRAMA DE GANTT........................................................................................................ 57
5.
CONCLUSÃO .......................................................................................................................................... 58
6.
REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................................... 60
7.
ANEXOS ................................................................................................................................................... 65
ANEXO I – CÓDIGO-FONTE DA JANELA CONFIGURAÇÃO DO SISTEMA ..................................................... 65
ANEXO II – CÓDIGO-FONTE DO COMPONENTE DE CORES DOS PROCESSOS .............................................. 77
X
LISTA DE FIGURAS
Figura 1 – Simulador SOsim (MAIA, 2007).................................................................. 6
Figura 2 – Simulador SISO 2.0 (PAULO, 2009) ........................................................... 7
Figura 3 – O MINIX 3 (EQUINOX, 2007) .................................................................. 10
Figura 4 – Kalango Linux (SONYMASTER, 2009).................................................... 11
Figura 5 – Big Linux (SONYMASTER, on-line) ........................................................ 12
Figura 6 – Representação gráfica de um Kernel monolítico (DOI, 2005) ................... 13
Figura 7 – Colossus foi criado em 1941. (SARAIVA, 2009) ...................................... 16
Figura 8 – Jobs (BRANCO, on-line) ........................................................................... 16
Figura 9 – Batch e a multiprogramação (CARDOSO, 2006) ...................................... 17
Figura 10 – Monitor Residente (VAGO, 2011) ........................................................... 17
Figura 11 – Processo (GUIZZI, 2010). ........................................................................ 18
Figura 12 – Multiprogramação (MEDEIROS, 2006)................................................... 20
Figura 13 – (PCB) - Bloco de Controle de Processo (MACHADO; MAIA, 2009). ... 21
Figura 14 – Estados de processos ................................................................................. 23
Figura 15 – Diagrama de classe do formulário de configuração do sistema................ 33
Figura 16 – Janela principal ......................................................................................... 37
Figura 17 – Configuração do sistema ........................................................................... 38
Figura 18 – Janela de estado de criação do processo. .................................................. 39
Figura 19 – Layout padrão usada nos escalonamentos FIFO, SJF, SRT e Round Robin
.................................................................................................................................................. 41
Figura 20 – Informações de processos ......................................................................... 42
Figura 21 – Uso da política de escalonamento FIFO com o diagrama de Gantt ......... 43
Figura 22 – Janela que simula o funcionamento do escalonamento FIFO .................. 44
Figura 23 – Exemplo da política de escalonamento SJF com o diagrama de Gantt. ... 45
Figura 24 – Janela que simula o funcionamento do escalonamento SJF ..................... 46
Figura 25 – Janela que simula o funcionamento do escalonamento SRT..................... 47
XI
Figura 26 – Diagrama de Gantt do escalonamento Round Robin, com quantum igual a
oito. ........................................................................................................................................... 49
Figura 27 – Diagrama de Gantt do escalonamento Round Robin, com quantum igual a
cinco. ........................................................................................................................................ 49
Figura 28 – Diagrama de Gantt do escalonamento Round Robin, com quantum igual a
dois. .......................................................................................................................................... 50
Figura 29 – Janela que simula o funcionamento do escalonamento Round Robin ...... 51
Figura 30 – Janela que simula o funcionamento do escalonamento não-preemptivo .. 52
Figura 31 – Janela que simula o funcionamento do escalonamento preemptivo ......... 54
Figura 32 – Janela que simula o funcionamento do escalonamento circular com
prioridade ................................................................................................................................. 55
Figura 33 – Janela que simula o funcionamento do escalonamento múltiplas filas .... 56
Figura 34 – Diagrama de Gantt do simulador EPSOsim (Escalonamento FIFO) ....... 57
XII
LISTA DE TABELAS
Tabela 1 – Escalonamento de processos e suas respectivas filas de criação. ............... 31
Tabela 2 – Lista de escalonamentos e objetos (fila de prontos) ................................... 31
Tabela 3 – Lista de escalonamentos e objetos (usadas três filas de prontos) ............... 32
Tabela 4 – Formulário do simulador EPSOsim ........................................................... 35
XIII
LISTA DE ABREVIATURA E SIGLAS
CPU (Central Processing Unit) – Unidade de Processamento de Dados.
CTSS (Compatible Time-Sharing System) – Sistema Compatível de Divisão por
Tempo.
FCFS (First Come First Server) – O Primeiro a Chegar é o Primeiro a ser Servido.
FIFO (First In First Out) – Primeiro a Entrar é o Primeiro a Sair.
GNU (Gnu is Not Unix) – GNU não é Unix.
MEC – Ministério da Educação.
MOSS – (Modern Operating Systems Simulators) – Simulador Moderno de Sistemas
Operacionais.
PC (Program Counter) – Contador de Programa.
PCB (Processo Controle Block) – Bloco de Controle de Processo.
PID (Process Identification) – Identificação do Processo.
SESu – Secretaria de Ensino Superior.
SISO – Simulador de Sistema Operacional.
SJF (Shortest Job First) – Processo Mais Curto Primeiro.
SP (Stack pointer) – Ponteiro de Pilha.
SR (Status Register) – Registradores de Status.
SOsim Simulador de Sistemas Operacionais.
SuSE (Software und System-Entwicklung) – Desenvolvimento de Software e Sistema.
UFRJ – Universidade Federal do Rio de Janeiro.
VCL (Visual Component Libary) – Biblioteca de Componentes Visuais.
MMU (Memory Management Unit) – Unidade de Gerência de Memória.
UML (Unified Modelling Language) – Linguagem de Modelagem Unificada.
XIV
INTRODUÇÃO
As Diretrizes Curriculares do Ministério da Educação (MEC) recomendam que o
assunto Sistemas Operacionais esteja presente no conjunto das disciplinas tecnológicas dos
cursos de Ciência da Computação, Engenharia de Computação, Sistemas de Informação e
Licenciatura em Computação (MEC; Diretrizes; SESu, on-line). Trata-se de uma disciplina
relevante, de extenso conteúdo e que aborda aspectos crucias do funcionamento de um
sistema de computação, dentre eles: programação concorrente, gerência de processos,
gerência de memória, gerência de arquivos, gerência de E/S e memória virtual.
Uma das formas de facilitar o processo ensino-aprendizagem consiste em realizar
atividades práticas que permitam ao aluno visualizar o conceito teórico.
Dentre essas
atividades se inclui a utilização de programas simuladores. A utilização de simuladores
permite ver, associar e analisar conceitos diante de situações práticas que imitam a realidade.
Diante desse cenário, o presente trabalho propõe, a criação de um simulador como ferramenta
de apoio ao ensino da disciplina de Sistemas Operacionais e que possa ser utilizado no
contexto dos objetivos e realidade dos cursos que contemplam a disciplina.
O presente trabalho visa desenvolver um simulador como recurso de apoio didático ao
ensino do assunto escalonamento de processos da disciplina Sistemas Operacionais, buscando
agregar novos algoritmos ainda não explorados nos simuladores existentes e gerar gráficos
com informações das simulações.
Espera-se que o simulador seja capaz de representar o funcionamento do Sistema
Operacional por meio de recursos gráficos de modo a contribuir com o processo de ensinoaprendizagem de disciplinas que abordem esse assunto. Com a implementação do simulador,
o aluno terá mais conhecimento e obterá mais experiência para fazer uma determinada
atividade em sala de aula.
1
METODOLOGIA
De acordo com Perin Filho (1995), existem três estratégias para solução de problemas
são elas: a experimentação direta, a resolução analítica e a simulação de sistema. O projeto
consiste na estratégia de simulação de sistemas, na qual é desenvolvido um programa de
computador para simular um sistema real que apresentará o funcionamento dos Sistemas
Operacionais.
O desenvolvimento do simulador será norteado fundamentalmente pelos resultados
dos seguintes passos:
•
Levantamento dos trabalhos existentes que visam apoiar o ensino da disciplina de
Sistemas Operacionais;
•
Pesquisa junto aos professores e alunos de Sistemas Operacionais visando identificar
os aspectos, mecanismos e conceitos de Sistemas Operacionais que geram mais
dúvidas nos alunos;
O levantamento dos trabalhos existentes será feito utilizando os recursos da biblioteca
da Faculdade Farias Brito, notadamente a ferramentas de busca na internet, tal como o Google
Acadêmico. Após a descoberta dos simuladores existentes, um grupo desses será escolhido
para testes. A análise das funcionalidades, e levantamento dos pontos positivos e negativos
será verificada com a instalação e uso de cada simulador.
Após a definição das funcionalidades requeridas para o simulador, será feito um
levantamento a respeito da linguagem de programação que será usada para o desenvolvimento
do projeto. Pretende-se utilizar uma ferramenta de desenvolvimento como a ferramenta
Borland Delphi, pois esta possui bibliotecas com bastantes recursos, comparado com outras
linguagens de programação.
2
Pretende-se desenvolver e modelar o simulador com o método de orientação a objeto,
visando o reuso e a facilidade de inclusão de novas funcionalidades. E será usada a ferramenta
de modelagem UML, Star UML, para o desenvolvimento do artefato diagrama de classe.
3
1.
TEORIAS EDUCACIONAIS E FERRAMENTAS DE ENSINOAPRENDIZAGEM
Nas seções seguintes serão abordadas algumas teorias, ferramentas de simulação e
sistemas reais que faz parte do ensino-aprendizagem dos alunos.
1.1
ENSINO CONTEUDISTA
Há cerca de duas décadas surgiu o modelo de ensino conteudista, que prepara
indivíduos passivos, no qual é transmitido ao aluno uma grande quantidade de informação por
um determinado período de tempo, sem se preocupar se realmente os alunos estão
aprendendo. Muitos alunos tentam memorizam o conteúdo que é transmitido. Logo depois, é
exigido dos alunos resultados por meio de provas escrita ou oral. Com o passar do tempo,
grande parte do que foi memorizado pelo aluno é perdido, devido à transmissão ser
momentânea e superficial (CASTRO, 2011).
Hoje em dia, grande parte dos intelectuais educadores não concorda com este padrão
de ensino. Eles pesquisam sobre as possíveis conseqüências, agregam novos conhecimentos
contra este modelo e favorecem novos meios práticos para se dissociar dessa abordagem
teórica (CASTRO, 2011).
1.2
TEORIA CONSTRUTIVISTA
O construtivismo ou sócio-construtivismo empenha-se a explicar a inteligência
humana, do modo que determine ações mútuas entre indivíduos e o meio, procurando
incentivar o conhecimento científico. O construtivismo deriva do conhecimento e da
aprendizagem das teorias da epistemologia genética de Jean Piaget, que se empenhou em
analisar a passagem do individuo que possui um conhecimento inferior para um conhecimento
superior (BALDI, 2010). O construtivismo teve também como pesquisador sócio-histórico
Lev Vygotsky, onde afirma que:
4
O homem não nasce inteligente, mas também não é passivo sob a influência
do meio, isto é, ele responde a estímulos externos agindo sobre eles para
construir e organizar o seu próprio conhecimento, de forma cada vez mais
elaborada (BALDI, 2010).
Piaget emprega dois conceitos importantíssimos no que diz respeito ao saber e ao
funcionamento da mente humana: assimilação e acomodação. Estes dois processos procuram
restaurar um equilíbrio mental perturbado pela influência de um dado incombinável, aquilo
que já se conhece, chamado de princípio de equilibração (RODRÍGUEZ, 1999).
Há duas vertentes no princípio de equilíbrio. No primeiro caso, o dado entra em
contato e é assimilado por um esquema já existente, onde se amplia. No segundo caso, o novo
dado é incompatível com o esquema já formulado e então cria novo esquema acomodando
novo conhecimento. Este novo esquema será então ampliado na medida em que o indivíduo
estabelecer relações com o meio. A teoria construtivista foi usada para solucionar muitos
problemas educacionais existentes. Os educadores se empenharam bastante neste modelo no
qual investiram muito, mas constataram resultados inferiores ao que esperavam.
(RODRÍGUEZ, 1999).
1.3
FERRAMENTAS DE AUXÍLIO AO ENSINO-APRENDIZAGEM
Na subárea da programação, existem certas dificuldades entre os alunos com relação à
implementação nos algoritmos de escalonamento de processos. Tais problemas ficam ainda
mais difíceis sem a ajuda de uma ferramenta que auxilie no ensino-aprendizagem, ou de
algum software que simule os algoritmos de escalonamento de processos.
Nas próximas seções, serão abordadas algumas ferramentas de apoio ao ensino, tais
como simuladores, os quais demonstram algumas funções dos Sistemas Operacionais, e que
estão disponíveis na internet.
1.3.1 SIMULADORES
A simulação antigamente era estigmatizada apenas como fingimento ou farsa, porém
na era da tecnologia ganhou um sentido mais positivo. Atualmente, a simulação pode ser uma
5
ferramenta que ajude a compreender melhor o espectro computacional, ou seja, o
funcionamento interno de um determinado dispositivo eletrônico. Alguns simuladores de
Sistemas Operacionais serão apresentados a seguir.
1.3.1.1 SOSIM
O SOsim (Simulador de Sistemas Operacionais) foi desenvolvido por Luiz Paulo Maia
em sua tese de mestrado na Universidade Federal do Rio de Janeiro (UFRJ). O SOsim é um
software educativo que auxilia no ensino-aprendizado de professores e alunos. Ele foi
desenvolvido com o intuito de ser uma ferramenta gratuita (MAIA, 2001), está disponível no
site, na página www.training.com.br/SOsim/. Este simulador ilustra alguns conceitos da
disciplina Sistemas Operacionais, tais como multiprogramação, processos e suas mudanças de
estado, gerência do processador (escalonamento) e a gerência da memória virtual. A figura 1
ilustra um exemplo do simulador SOsim:
Figura 1 – Simulador SOsim (MAIA, 2007)
6
1.3.1.2 SISO
O simulador SISO (Simulador de Sistema Operacional) é um applet disponível na web
no site http://martins.webcindario.com/jsiso/bin/index.html. O SISO simula a detecção de
deadlock e foi criado com o intuito de auxiliar no ensino-aprendizagem da disciplina a
Sistemas Operacionais. O SISO é um simulador muito prático. Seu funcionamento não exige
uma instalação, podendo ser executado diretamente pela internet. Para isso é necessário que o
computador tenha a Java Runtime Environment 1.5 ou superior (PAULO, 2009). A figura 2
ilustra um exemplo do simulador SISO 2.0:
Figura 2 – Simulador SISO 2.0 (PAULO, 2009)
1.3.1.3 NACHOS
O simulador de Sistema Operacional Nachos foi criado com o uso na linguagem C++,
usando uma abordagem de orientação a objetos. Também possui algumas partes
7
desenvolvidas com o uso da linguagem C. O simulador Nachos simula uma máquina virtual
que utiliza a arquitetura MIPS (Microprocessor without Interlocked Pipeline Stages Microprocessador sem Estágios Interligados de Pipeline) - não confundir com MIPS (Milhões
de Instruções Por Segundo). O MIPS é utilizado em aplicações como: computadores de alto
desempenho (Silicon Graphics), sistemas embarcados, em Sistemas Operacionais portáteis,
roteadores (CISCO) e videogames (GONÇALVES, 2011).
Na implementação do Nachos foi declarada a classe “Machine, a qual possui métodos
parecidos com os do assembly MIPS, onde a cada linha de código é traduzida pelo próprio
simulador em instrução executável, e então compilado habitualmente para uma máquina alvo,
por exemplo. O Sistema Operacional Linux, normalmente utiliza o compilador g++, no qual o
código-fonte é compilado neste compilador (g++), gerando assim o código MIPS que
corresponde ao código do hardware. Para compilar é preciso à instalação de um compilador
especial diferente do compilador padrão dos Sistemas Operacionais, o compilador cruzado
(cross-compiler) (GONÇALVES, 2011).
No simulador Nachos há várias rotinas, tais como: threads e chamadas de
procedimento remoto. O Nachos foi desenvolvido por várias pessoas de diversos países, tais
como: Estados Unidos, Canadá, França e Alemanha. Thomas Anderson foi um dos criadores
do Nachos e em seu site na internet está disponível toda informação, documentação, patch e
versões (ANDERSON, 2008).
1.3.1.4 MOSS
O MOSS (Modern Operating Systems Simulators) ou simulador moderno de Sistemas
Operacionais é um pequeno simulador com uma coleção de programas desenvolvidos em
Java. Ele foi criado por Ray Ontko e Alexander Reeder, que se basearam no conceito do livro
de Andrew S. Tanenbaum (professor de Ciências da Computação da Vrije Universiteit na
Amsterdã em Holanda) com ajuda da Prentice Hall (Editora líder educacional nos EUA). O
simulador está disponível tanto para sistemas Windows como para Linux (ONTKO, 2008).
8
O simulador MOSS reúne um conjunto de programas de quatro diferentes aplicativos
tais como: simulador de escalonamento, simulador de deadlock, simulador de gerência de
memória e simulador de sistema de arquivos. No programa de simulação de escalonamento o
estudante pode escrever seus próprios algoritmos de escalonamento, podendo especificar o
número de processos, a média, e o desvio padrão para calcular o tempo de I/O, o tempo de
bloqueio para cada processo e a duração da simulação (ONTKO, 2008).
O programa de simulação de deadlock apresenta uma interface gráfica que permite ao
aluno percorrer os programas que estão em execução em cada um dos processos e os
processos bloqueados, para analisar os casos de impasse e como podem ser evitados,
detectados e/ou resolvidos (ONTKO, 2008).
1.3.2 SISTEMAS REAIS
Os sistemas reais que serão apresentados na subseção a seguir possuem códigos-fonte
disponíveis na web, tornando assim possível a interação entre alunos e professores com o
Sistema Operacional. Além disso, qualquer pessoa pode alterar o código-fonte e observar seus
efeitos na prática.
1.3.2.1 MINIX
MINIX é um Sistema Operacional do tipo Unix-like (é parecido com Unix), gratuito e
com código fonte disponível na web (TANENBAUM, 2011a). Ele foi criado para uso
educacional em 1987 por Andrew S. Tanenbaum, com o objetivo de ajudar nas suas aulas de
Sistemas Operacionais. O desenvolvimento da nova versão, MINIX 3, está sendo liderado
outra vez por Andrew S. Tanenbaum. Segundo suas publicações em artigos, Tanenbaum diz
que o Sistema Operacional MINIX será mais seguro do que Linux e o Windows (AVRAM,
2009). Após algum tempo trabalhando no projeto em uma lista de discussão (TORVALDS,
1996), Linus diz o seguinte:
Como eu mencionei há um mês atrás, estou trabalhando numa versão
independente de um S.O. similar ao Minix para computadores AT-386. Ele
está, finalmente, próximo do estado em que poderá ser utilizado (embora
possa não ser o que você espera), e eu estou disposto a disponibilizar o
9
código-fonte para ampla distribuição. Ele está na versão 0.02... Contudo eu
tive sucesso ao executar bash,gcc , gnu-make, gnu-sed,compressão etc, nele
(TORVALDS, 1996).
É esperado que o MINIX versão 3, seja um Sistema Operacional altamente confiável,
livre de falhas como os aparelhos televisores, sistemas embarcados ou aplicações críticas
(sistemas de controle de tráfego aéreo, processamento de pedidos para uma cadeia de lojas de
varejo, entre outros). A figura 3 ilustra a janela do MINIX versão 3:
Figura 3 – O MINIX 3 (EQUINOX, 2007)
1.3.3 LINUX
Geralmente, os Sistemas Operacionais que usam o kernel (núcleo) Linux são tidos
como Sistema Operacional Linux. O kernel Linux foi criado pelo finlandês Linus Torvalds
(OLIVEIRA et. al., 2004). Linus inspirou-se no projeto MINIX do professor Tanenbaum.
10
Como já foi descrito na subseção 1.3.2.1, o MINIX é um sistema bem simples, criado com
propósitos didáticos e bastante disseminado no meio acadêmico. Depois que Linus criou a
versão inicial do Sistema Operacional Linux, disponibilizou o MINIX em grupo de discussão
na internet, com a intenção de ser um material de estudo para acadêmicos na área da
computação, mas logo que divulgou outras pessoas entraram no projeto e contribuíram com
novas funcionalidades.
O Linux faz parte de um conjunto de softwares mais um kernel Linux, formando a
chamada distribuição. Existem várias distribuições, tais como: Red Hat, Debian, Slackware,
SuSE, Mandrake e Conectiva (TANENBAUM, 2005). As Figuras 4 e 5 ilustram duas
distribuições Linux:
Figura 4 – Kalango Linux (SONYMASTER, 2009)
11
Figura 5 – Big Linux (SONYMASTER, on-line)
1.3.3.1 PROJETO GNU
GNU é um significado recursivo de (GNU Não é Unix). GNU também se refere a um
animal nativo da África, sendo ele o logotipo da empresa do projeto Free Software
Foundation (Fundação para o Software Livre), que foi criada em 1985 por Richard Smallman
(GNU, 2009). Stallman fundou o GNU com a intenção de criar um Sistema Operacional livre.
Em 1991, o sistema estava praticamente pronto, mas precisava de um núcleo. Smallman tinha
seu grupo, que estava desenvolvendo seu próprio núcleo, chamado de Hurd. Foi então que
Smallman conheceu Linus. Linus tinha desenvolvido o núcleo que Stallman tanto precisava.
O núcleo Hurd da GNU está em desenvolvimento desde 1991. O um projeto GNU reuniu
diversos programadores. Foram desenvolvidas ferramentas para o conjunto de software que
compõe o Sistema Operacional Linux. Entre as ferramentas, podem ser citados o compilador
gcc, o editor de texto emac, o editor de gráficos gimp, o ambiente de janelas gnome, etc.
(GNU, on-line).
12
1.3.3.2 KERNEL LINUX
O núcleo do Linux foi dividido em duas categorias, o núcleo de desenvolvimento e o
núcleo estável. O núcleo de desenvolvimento é aquele em que os programadores podem
modificar o código, sendo por isso chamado de núcleo de experimentação. O núcleo estável é
conhecido pelos programadores como confiável. Nessa fase o núcleo já parcialmente pronto é
lançado para as comunidades da internet. Existem bugs menores para serem corrigidos nessa
parte, os quais geram os chamados realeases. A versão é determinada por três números, por
exemplo, 1.0.12. No momento em que eu estava digitando esta linha do projeto a versão do
kernel do Linux estava em 2.6.31.6.
O primeiro número indica uma troca radical do núcleo começando do zero. O segundo
número indica se a versão é de desenvolvimento ou estável. Se for par, a versão é estável,
caso contrário de desenvolvimento. O terceiro número referisse a correções de bugs menores
em um núcleo, é o chamado realease (OLIVEIRA, et. al., 2004, p. 175). A Figura 6 ilustra
um Kernel Monolítico.
Figura 6 – Representação gráfica de um Kernel monolítico (DOI, 2005)
13
O núcleo é classificado de duas formas, monolítico e micronúcleo. No monolítico
estão todos os componentes que fazem parte de um único código. O micronúcleo
(microkernel) é constituído de funcionalidades reduzidas, tais como escalonador simples,
primitivas de sincronização e mecanismos de comunicação entre processos. Os outros
componentes no qual compõe um Sistema Operacional são implementados separadamente
(OLIVEIRA, et. al., 2004).
14
2. SISTEMAS
PROCESSOS
OPERACIONAIS
E
O
ESCALONAMENTO
DE
É relevante notar que há uma demanda de recursos muito grande, que faz parte do diaa-dia de um usuário. Essa exigência requer que os programas respondam de forma rápido,
onde o usuário não perceba as ações do que há por trás do sistema, é frustrante para o usuário
ficar esperando a resposta de um determinado recurso no qual solicitou. Quando o usuário
solicita um recurso através de um programa, é notório que o Sistema Operacional resolva a
solicitação (apud. OLIVEIRA, et. al., 2004, p. 1). . Oliveira (2004) conceitua o Sistema
Operacional como uma camada de software colocada entre o hardware e as aplicações que
executam tarefas para o usuário.
Para um melhor entendimento sobre Sistemas Operacionais, nas subseções a seguir,
serão abordados os seguintes assuntos: origem, funções e conceito do Sistema Operacional
(gerência de processos, gerência de memória, memória virtual, sistemas de arquivos,
sincronização de arquivo, seus mecanismos que antigamente eram usados, especificamente o
funcionamento dos Jobs, além dos mecanismos que são usados atualmente. Será visto
também monitores residentes, multiprogramação, conceitos e funções de escalonamentos de
processos e os principais algoritmos de escalonamento de processos.
2.1
CONCEITOS BÁSICOS DE SISTEMAS OPERACIONAIS
Na década de 40 não existiam Sistemas Operacionais, o programador era o próprio
operador do computador, que o controlava por meio de chaves, fios e luzes de aviso. Naquela
época havia uma planilha chamada de alocação de horário, onde em certo horário o
programador executava um programa que possibilitava o controle total da máquina. Nesta
mesma década surgiram os operadores profissionais, com isso o programador deixou de
operar o computador durante a execução de um programa (OLIVEIRA et. al., 2004). A figura
7 ilustra o antigo computador Colossus da década de 1940:
15
Figura 7 – Colossus foi criado em 1941. (SARAIVA, 2009)
Em consequência do surgimento dos operadores, surgiu o job, que enfileirava tarefas,
onde era compilado, executado e os dados eram lidos por meio de cartões perfurados. O Jobs
podia chamar vários programas e funcionavam por etapas: o montador era executado e
traduzia o programa de assembly para a linguagem de máquina. O programa então era ligado
às rotinas de I/O de uma biblioteca, depois de ligarem as rotinas de I/O então podia ser
carregado e executado. Caso houvesse um erro na execução, tirava-se uma cópia na listagem
do conteúdo de toda a memória principal (OLIVEIRA, et. al., 2004). A figura 8 mostra um
exemplo de Jobs:
Figura 8 – Jobs (BRANCO, on-line)
Os Jobs eram uma forma de agrupar programas em lotes, com isso surgiu a idéia de
sistema em batch. O sistema em batch era um arquivo com um conjunto de comandos
executados sequencialmente. Mesmo com o agrupamento de Jobs os programas ainda eram
16
colocados para executar de forma manual (OLIVEIRA, et. al., 2004). A figura 9 compara o
processamento de um sistema em batch e multiprogramação, será
rá visto o assunto de
multiprogramação na seção 2.2.2:
Figura 9 – Batch e a multiprogramação (CARDOSO, 2006)
Na década dee 50 surgiu o monitor residente cuja função era automatizar a execução
dos Jobs. Conforme Oliveira et. al. (2004),
), a sua função era a transição dos programas no
computador. Quando
uando um programa terminava, o monitor residente se comprometia de
carregar outro programa automaticamente e o executava. Os monitores residentes ficavam o
tempo todo na memória principal
incipal e reduziam o tempo que se levava para transferir um job
para outro. A figura 10 ilustra um exemplo de monitor
m
residente:
Figura 10 – Monitor Residente (VAGO, 2011)
17
2.2
PROCESSOS
O processo é simplesmente um programa em execução, ou pode-se dizer que,
processo seja um módulo carregável e executável de maneira concorrente com outros
processos separadamente. Cada processo possui um espaço de endereçamento. O espaço de
endereço é uma lista de posições de memória que varia de zero a uma quantidade máxima de
posições onde o referente processo pode ler ou escrever. O espaço de endereçamento contém
o programa executável, os dados do programa e sua pilha (TANENBAUM, 2005).
Os processos se comunicam através de mecanismos tais como: sinais, pipes, named
piped, memória compartilhada, soquete (socket) e trocas de mensagem (SILBERSCHATZ, et.
al., 2005). Através de um processo, um programa pode alocar recursos, compartilhar dados,
trocar informação e sincronizar sua execução (GUIZZI, 2010). Os processos em sistemas
multiprogramados são executados concorrentemente, compartilhando o uso da CPU, memória
principal e dos dispositivos de E/S. O processo é dividido em três grupos, conforme a figura
11:
Figura 11 – Processo (GUIZZI, 2010).
18
•
Contexto de software
•
Contexto de hardware
•
Espaço de endereçamento.
O armazenamento do conteúdo dos registradores gerais e registradores específicos
(PC - contador de programa, SP - ponteiro de pilha e SR - registradores de status), acontecem
através do contexto de hardware (MACHADO, et. al., 2009). Um das fases mais importantes
de um processo é a mudança de contexto, isto é, onde são guardadas as informações do
contexto de software e de hardware de um determinado processo que deverá ser selecionado
para CPU. A mudança de um processo para outro acontece de maneira muito rápido,
imperceptível para o usuário, dando a ilusão de execução simultânea (TANENBAUM, 2005).
De acordo com Machado (2009), no contexto de software existem três grupos importantes:
•
Identificação - PID (Process Identification – Identificação do Processo), owner
(UID – User Identification – Identificação do usuário), nome, data e hora da
criação, prioridade da execução, tempo de processador (burst time).
•
Quotas - número máximo de arquivos abertos, tamanho máximo da memória
principal e secundária, número máximo de operações de E/S, tamanho máximo do
buffer, número máximo do sub-processos e threads
•
Privilégios ou direito - permissões entre o próprio processo (prioridade de
execução, limitação da alocação das memórias seja ela principal, secundária e etc),
entre os demais processos (características) e entre o Sistema Operacional
(desativação do sistema, modificação de regras de segurança, criação de outros
processos privilegiados, alteração de parâmetro de configuração do sistema)
2.2.1 PROCESSOS X THREADS
Threads são semelhantes aos processos e contém seu próprio conjunto de
registradores, contador de programa e pilhas. Um thread é a unidade básica de um processo,
19
vários threads concorrem entre si dentro de um processo, onde são executadas separadamente.
Tanenbaum (2005) diz que os threads podem realizar execuções múltiplas ocorrendo no
mesmo ambiente de processo com alto grau de paralelismo. No entanto, múltiplos threads são
equivalentes a múltiplos processos onde os processos são executados em paralelo em um
único computador.
Existem dois ambientes de thread, a monothread e a multithread, na monothread cada
processo comporta apenas um thread no seu espaço de endereçamento, isto é, implementado
exclusivamente com uso de múltiplos processos isolados. No ambiente multithread, um
processo pode conter diversas threads concorrendo entre si. (MACHADO; MAIA, 2009).
2.2.2 MULTIPROGRAMAÇÃO
Os primeiros sistemas de computadores, apenas um programa podia ser executado por
vez, pois nesta época não existia a idéia de multiprogramação. Na década de 60 surgiu o
conceito de multiprogramação, onde permite que vários programas concorram de forma
pseudo-paralela ao mesmo tempo. Ao contrário do monitor residente, onde executava um
programa de cada vez e permitia que o processador ficasse ocioso (OLIVEIRA, et. al., 2004,
pag. 8-9). A figura 12 ilustra um exemplo de multiprogramação:
Figura 12 – Multiprogramação (MEDEIROS, 2006)
20
2.2.3 BLOCO DE CONTROLE
O Sistema Operacional implementa o processo por meio de uma estrutura de dados
localizada em seu núcleo, chamada de Bloco de Controle de Processo ou em inglês PCB
(Process Control Block). Os PCBs ficam residentes em uma área protegida da memória
principal, seu tamanho é limitado por um parâmetro do Sistema Operacional (MACHADO;
MAIA, 2009). De acordo com Machado (2009), a função do PCBs é armazenar informações
sobre o contexto de hardware e contexto de software e espaço de endereçamento referente a
cada processo, tais como:
1. PID (Process Identification) - Identificação do processo;
2. Prioridade do processo;
3. Estado do processo (criação, aptos, execução, bloqueado e finalização);
4. Localização e quantidade de memória principal usada pelo processo;
5. Ponteiros para o encadeamento dos blocos de controle dos próximos processos;
6. Informações de contabilidade (espaço de memória ocupado, tempo de
processador entre outros);
7. Identificador do processo pai;
8. Contador de programa;
9. Recursos que o processo pode ter acesso;
10. Ponteiro de pilha de processos.
A figura 13 ilustra o Bloco de Controle de Processo visto anteriormente:
Figura 13 – (PCB) - Bloco de Controle de Processo (MACHADO; MAIA, 2009).
21
2.3
ESCALONAMENTO DE PROCESSOS
O escalonamento de processos ou agendador de tarefas é conceituado como sendo
uma atividade organizacional feita através da CPU ou um sistema distribuído (STALLINGS,
2004). À medida que os processos são criados é passado para o estado de pronto, a partir de
então, é necessários critérios para estabelecer a escolha do processo na qual deverá utilizar o
processador. Tais critérios para a escolha do processo são chamados de política de
escalonamento.
Maia (2009) diz que a política de escalonamento é à base da multiprogramação e
gerência de processos em Sistemas Operacionais. Um processo, no decorrer do seu
processamento passa por diferentes estados, em cargo de eventos gerados pelo Sistema
Operacional ou pelo próprio processo. De acordo com Tanenbaum (2005) resume os estados
de um processo em três estados, no qual os processos podem se encontrar em:
•
Execução – o processo é alocado na CPU;
•
Pronto – temporariamente parado para dar lugar a outro processo;
•
Bloqueado – aguardando o término de um evento externo para que possa
continuar a execução.
Conforme Cunha (2003), para poder criar um processo são necessárias as seguintes
ações do Sistema Operacional:
•
O mapa de memória do processo, com as regiões de código, dados e pilha.
•
Os valores iniciais de variáveis do ambiente.
•
Os valores iniciais dos registradores do processador, quando o programa for
posto em execução.
•
Os canais iniciais para as entradas e saídas.
•
Uma entrada numa tabela, interna ao Sistema Operacional, na qual expõe o
estado de cada processo.
22
Após as ações, o novo processo está apto para a execução. Outros autores têm uma
concepção diferente com relação aos estados dos processos, como Silberchatz (2005), no qual
define os estados dos processos em cinco estados. A figura 14 ilustra cinco estados dos
processos do modelo proposto por Silberchatz (2005), mostrando o fluxo dos processos:
Fatia de tempo
(preempção ou
interrupção)
Criação
CPU
Fila de Aptos
Admitir
Liberar
Finalização
Despachar
Espera de
evento
Desbloquear
E/S
Bloquear
Erro Crítico
Fila de Espera
Figura 14 – Estados de processos
1. Novo ou criação: onde o processo é criado;
2. Pronto ou aptos: o processo está esperando para ser atribuído a um processador;
3. Execução (CPU): as instruções estão sendo executadas;
4. Espera ou bloqueado: o processo está esperando que ocorra algum evento;
5. Finalização/Terminado: o processo é finalizado.
2.3.1 PREEMPTIVO E NÃO-PREEPTIVO
Há dois grupos principais nos algoritmos de escalonamento, preemptiva e nãopreemptiva. O escalonamento não-preemptivo foi o primeiro a ser implementado nos sistema
multiprogramado, os processos CPU-Bound assumem todo o controle da CPU gastando todo
23
seu tempo de processador na CPU, em seguida é repassado para o estado de finalização. Nos
processos do tipo IO-Bound, caso não exista nenhuma instrução para que ocorra à mudança
do estado de execução para o estado de espera, o processo é também repassado para o estado
de finalização (MACHADO; MAIA, 2009).
Os algoritmos de escalonamento não-preemptivo, não é muito utilizado atualmente,
pois os processos que se localiza na fila de pronto devem esperar o processo que está em
execução até ser finalizado, tornando o tempo médio de espera muito maior comparado com
outros algoritmos preemptivo (MACHADO, et. al., 2009).
Os escalonamentos do tipo preemptivo, o processo é removido da CPU devido ter
acabado a fatia de tempo (timeslice), idéia usada principalmente no escalonamento circular,
ou por preempção por prioridade, usada nos escalonamentos por prioridade. Isso acontece
devido à chegada na fila de pronto um processo com maior prioridade do que o processo
alocado na CPU. Nos sistemas atuais é comum utilizar uma combinação de diversos
escalonamentos de processos, isto depende da necessidade do sistema.
2.3.2 FUNÇÕES DO ESCALONAMENTO DE PROCESSOS
Uma das funções mais importantes do Sistema Operacional é o scheduler
(escalonador). Diante disto, no processador, todo o compartilhamento dos processos está
sujeito a esta função, no qual difere de critérios estabelecidos na implementação. Outra função
importante é o dispatcher (despachador), que é responsável pela a troca de contexto do
processo e passar o controle que antes era da CPU para o processo. O período em que
acontece a troca de contexto é chamado de latência de dispatcher. Em sistemas onde existe a
fatia de tempo (timeslice ou quantum), o dispatcher usa um circuito chamado de temporizador
onde calcula a fatia de tempo do próximo processo (MACHADO; MAIA, 2009). Conforme
Machado (2009), as políticas de escalonamento exigem determinados critérios:
1. Manter o processador ocupado a maior parte do tempo.
24
2. Balancear o uso do processador entre os processos.
3. Maximizar o sistema.
4. Oferecer tempo de resposta razoável para o usuário interativo.
O objetivo dos algoritmos de escalonamento é tratar todos os processos de forma igual
evitando o starvation (inanição), jargão na computação no qual o processo morre de fome. Os
processos ociosos ficam indefinitivamente esperando a utilização do processador
(SILBERCHATZ, et. al., 2005). Serão descritos a seguir, alguns critérios que devem ser
considerados nas políticas de escalonamento. De acordo com Machado (2009), em todos os
casos é desejável existir:
•
Justiça: cada processo deve ter sua parte justa ou integra na CPU, dependendo
do tipo de cada processo.
•
Aplicação da política: verificar se a política é cumprida.
•
Equílibrio: todas as partes do sistema devem está ocupada.
•
Turnaround: tempo gasto deste a criação do processo até sua finalização,
contabilizando o tempo em que o processo gasta na espera para a alocação de
memória, na fila de pronto, fila de espera, processamento e operações de E/S.
O objetivo das técnicas de escalonamento é justamente diminuir o tempo de
turnaround.
Segundo Machado (2009), nos sistemas em lote devem respeitar os determinados
requisitos:
•
Throughput (vazão): número de processos que são executados em um espaço
de tempo, quanto maior o throughput melhor.
•
Tempo de Resposta: tempo desde que é solicitada a requisição do processo, até
no instante que é exibida.
•
Utilização da CPU: conservar a CPU sempre ocupada. É estabelecida uma
porcentagem em que o processador fica ocupado (0 a 100%). A utilização de
30% indica que o sistema está com a carga de processamento baixa e com a
25
porcentagem de 90% indicam que está consideravelmente alta, ou seja, o
sistema está sobrecarregado.
Ainda de acordo com Machado (2009), nos sistemas interativos devem seguir os
requisitos:
•
Cumprimento dos prazos: evitar perda de dados;
•
Previsibilidade: evitar a degradação da qualidade em sistemas multimídias
Machado (2009), diz ainda que nos casos de sistemas em tempo real os algoritmos de
escalonamento devem priorizar os processos críticos.
2.3.3 CATEGORIA
TEMPO REAL.
DE
ALGORITMOS
DE
ESCALONAMENTO
EM
LOTE, INTERATIVO
E
Existem determinados critérios que devem ser estabelecidos para a boa implementação
dos algoritmos de escalonamento de processos de um Sistema Operacional, isso depende de
seu ambiente em lote, interativo ou tempo real. Nos sistemas em lote, os processos são
enfileirados no estado de pronto, em seguida, o escalonador escolhe um processo para ser
alocado na CPU até usar todo seu tempo de processador e ser transferido para o estado de
finalização. Os sistemas em lote possuem um tempo de resposta muito lento, os usuários
ficam esperando exaustivamente pela resposta do programa (TANENBAUM, 2005).
Os sistemas interativos são caracterizados pela a preempção, os processos ficam
alternando entre si na utilização da CPU. Não se pode confundir o tempo de resposta com o
tempo de turnaround, o tempo de resposta equivale com o tempo decorrido até o momento
em que é apresentado os resultados nos sistemas. Na maioria das vezes, esse tempo é restrito
devido à velocidade do dispositivo de saída (MAZIERO, 2008, p. 6). Mais detalhes sobre
esses algoritmos serão vistos no capitulo 4.
Sistemas em tempo real são aqueles em que devem reagir de forma imediata em
26
determinado espaço de tempo. Por exemplo, um programa player de vídeo como o Real
Player deve obter os bits do disco para converter em vídeo em um intervalo crítico de tempo,
se o cálculo que fizer for muito demorado, pode ter certos problemas nos resultados da saída,
saindo em intervalos diferentes, ou com alguma falha, ou até com o áudio soando diferente
(TANENBAUM, 2005).
Segundo Tanenbaum (2005), os sistemas em tempo real são usados em hospitais,
aeronaves, robôs e etc. A implementação desses sistemas funciona da seguinte maneira, o
programa é dividido em vários processos onde seu tempo de vida pode durar menos que um
segundo.
27
3.
ARQUITETURA DO SIMULADOR
Este capítulo aborda assuntos da arquitetura do simulador, suas funcionalidades com
base no modelo de Silberchatz (2005), apresentado no capítulo 2 (Sistemas Operacionais e o
escalonamento de processos). Mais adiante, neste capítulo será descrito as classes e objetos do
simulador dando ênfase na implementação do simulador e especificações de sua estrutura
interna.
3.1
CLASSES E OBJETOS DO SIMULADOR
O simulador EPSOsim usa biblioteca de classes VCL (Visual Component Library), é
uma biblioteca que tornam a estrutura do código mais organizado, diminuindo assim a
complexidade do código-fonte (PODGORETSKY ANATOLY, 2011). O simulador usa o
conceito da abstração no paradigma de orientação a objeto, ou seja, modela conceitos do
mundo real com base em um elemento, uma entidade ou um problema específico, no caso do
simulador a representação dos processos computacionais foi representada por uma instância
de objeto. Atualmente, é muito raro um Sistema Operacional usar o conceito de orientação a
objeto, sistemas que usa este conceito permitem a redução do acoplamento entre os módulos
(MACHADO; MAIA, 2009).
No simulador foi implementada a classe Tprocesso (vide anexo I), no qual é
instanciado um objeto toda vez que um usuário aciona o botão criar da janela de estado de
criação do processo (vide figura 18), onde são repassados os parâmetros necessários que
caracteriza o processo, desta forma a representação de um novo processo é criada. Veja a
linha de código abaixo, onde é instanciado um objeto e inserido na estrutura de dados fila:
FI.Push(Tprocesso.create(Ppid, Ptipo, Pcor, PTempoProc, Pprioridade));
Na classe Tprocesso foram definidos cinco atributos semelhantes ao do contexto de
software de um Sistema Operacional real. Veja os cinco atributos abaixo:
28
•
PID: número de identificação do processo.
•
Tipo de processo: possuem os tipos CPU-Bound, I/O-Bound Disco, I/O-Bound
CD, I/O-Bound USB Flash. Apenas os tipos dos processos no escalonamento
por múltiplas filas diferem dos demais escalonamentos, abaixo os itens que o
compõe:
1. Processo de sistema CPU-Bound;
2. Processo de sistema I/O-Bound;
3. Processos Interativos CPU-Bound;
4. Processos Interativos I/O-Bound;
5. Processos Batch CPU-Bound;
6. Processos Batch I/O-Bound;
•
Cor do processo: determina a cor de cada processo, no simulador existe 83
cores na versão do Delphi 2010 (vide anexo II) e 19 cores na versão Delphi 7.
•
Tempo de processador: tempo de cada processo, referente ao uso da CPU.
•
Prioridade: determina a prioridade de cada processo dos escalonamentos de
processos por prioridade (não-preemptivo, preemptivo e circular).
•
Turnaround: tempo desde a criação até a finalização de cada processo.
Na classe TSistema (vide anexo I) foi instanciado apenas o objeto S, este objeto
contém as informações do sistema, veja abaixo:
•
FatiaTempoSistema:
usado para a realizar a preempção por tempo no
escalonamento circular.
•
TempoDecorridoSistema: conta o tempo decorrido de um processo na CPU,
usado como um variável auxiliar da fatia de tempo.
29
•
TempoAcessoDisco: quantidade de tempo em que os processos do tipo IOBound disco realiza entrada e saída.
•
TtempoAcessoUSBFlash: quantidade de tempo em que os processos do tipo
IO-Bound USB Flash realiza entrada e saída.
•
TempoAcessoCD: quantidade de tempo em que os processos do tipo IO-Bound
CD realiza a entrada e saída.
•
TempoClock: relógio do escalonamento, tem o default igual a um,
representando um segundo.
•
TempoThroughput: números de processos executado em um determinado
espaço de tempo.
•
TempoInicialGantt: tempo inicial do diagrama de Gantt, equivale ao parâmetro
x do componente do diagrama, equivalente ao tempo em que o processo entra
na CPU.
•
TempoFinalGantt: tempo final do diagrama de Gantt equivale ao parâmetro y
do componente do diagrama, equivalente ao tempo em que o processo sai na
CPU.
•
UT: usada no diagrama de Gantt para fazer o somatório do tempo dos
processos em que ficou no estado de pronto.
•
UTAux: variável auxiliar da unidade de tempo, também usada no diagrama de
Gantt para obter o tempo dos processos em que ficou no estado de pronto.
Na classe TDisco (vide anexo I) foi instanciada o objeto D, este objeto contém
informações dos processos IO-Bound, foram criados quatro atributos, veja os quatro baixo:
•
Ocupado: verifica a CPU se está ocupada ou não.
•
TempoEsperado: contador de tempo dos processos do tipo IO-Bound, usado
junto com o atributo tempoDecorrido, é atualizado de acordo com o tipo, seja
disco, CD ou USB Flash. Veja abaixo o trecho de código que atualiza este
atributo:
if (Tprocesso(FCPU.peek).tipo = 'I/O Bound - Disco') then
30
TDisco(D).StempoEsperado(TSistema(S).FtempoAcessoDisco);
if (Tprocesso(FCPU.peek).tipo = 'I/O Bound - CD') then
TDisco(D).StempoEsperado(TSistema(S).FtempoAcessoCD);
if (Tprocesso(FCPU.peek).tipo = 'I/O Bound – USB Flash') then
TDisco(D).StempoEsperado(TSistema(S).FtempoAcessoUSBFlash);
•
TempoDecorrido: Atributo contador usado para contar o tempo em que os
processos IO-Bound estão no estado de espera.
•
TempoIO: tempo de I/O dos processos do tipo IO-Bound.
Foram implementadas diversas filas, na mesma estrutura de fila vista na seção 3.3.
Primeiramente, foi criado o objeto FI, da classe TQueue (fila), que representa a fila do estado
de criação. No caso dos algoritmos de escalonamento múltiplas filas e por prioridade, foram
criadas três instâncias da classe TQueue, FI1, FI2 e FI3, tendo em vista que esses algoritmos
usam três filas de prontos. Abaixo a tabela 1, descreve os escalonamentos e seus respectivos
objetos no qual representa a fila de criação (estado de criação):
Tabela 1 – Escalonamento de processos e suas respectivas filas de criação.
FIFO, SJF, SRT e Round Robin
FI
Múltiplas Filas, Prioridade
FI1
Não-Preemptiva, Prioridade
FI2
Preemptiva e Circular
FI3
com prioridade
Abaixo na tabela 2 e 3, descreve os escalonamentos e seus respectivos objetos no qual
representa a fila de prontos:
Tabela 2 – Lista de escalonamentos e objetos (fila de prontos)
FIFO
FAFF
SJF
FASJF
31
SRT
FASRT
Round Robin
FARR
Tabela 3 – Lista de escalonamentos e objetos (usadas três filas de prontos)
Múltiplas Filas
FAPP
FARR
FAFF
Prioridade
FAPP1
Não-Preemptiva
FAPP2
FAPP3
Prioridade
FAPSP1
Preemptiva
FAPSP2
FAPSP3
Circular
FACP1
com prioridade
FACP2
FACP3
Foi instanciado o objeto FE no qual representa a fila de espera (estado de espera),
além do objeto FEAux usado como fila auxiliar para os objetos no estado de espera. Foram
criadas com o intuito de apenas ser uma fila auxiliar para coordenar os processos, representa
respectivamente o estado de execução e o I/O dos processos. E finalmente, o objeto FIN, que
representa o estado de finalização (estado de término). Neste estado os processos não são
excluídos, suas informações ficam mantidas até o início de outro escalonamento.
32
3.2
DIAGRAMA DE CLASSES
No simulador EPSOsim existem quatro principais classes que são TSistema,
Tprocesso, TCPU e a TDisco. A figura 15 ilustra o diagrama de classe do simulador
EPSOsim:
Figura 15 – Diagrama de classe do formulário de configuração do sistema.
33
As classes TCPU e TDisco fazem associação com a classe Tprocesso. Com isso,
vários objetos (processo) da classe Tprocesso pode usar apenas um objeto (disco) da classe
TDisco. Da mesma forma, vários objetos (processo) da classe Tprocesso podem usar apenas
um objeto (CPU) da classe TCPU. A classe TSistema é apenas uma classe externa.
Na classe TSistema foram declaradas as filas de pronto, em que cada fila pode existir
de zero a n instância de processos da classe TProcesso. Na classe TDisco uma fila (FE – Fila
de Espera) pode conter de zero a n processos. A fila FEAux faz o intermédio entre o estado de
espera e o estado de pronto. Da mesma forma, a fila FCPU serve de transição entre a fila de
pronto e a fila de espera.
34
4.
FUNCIONAMENTO E DESCRIÇÃO DO AMBIENTE
Neste capítulo será apresentado o ambiente do simulador, suas descrições,
funcionalidades e alguns trechos do seu desenvolvimento.
4.1
AMBIENTE DO SIMULADOR
O ambiente do simulador foi desenvolvido de acordo com o modelo de
escalonamento de processos de Silbershartz (2005) visto no capítulo 2 seção 2.3, de forma
bem detalhada comparada com os simuladores disponíveis na internet. Abaixo a tabela 4, é
descrita a lista de formulários existente no simulador EPSOsim:
Tabela 4 – Formulário do simulador EPSOsim
Formulários do Simulador EPSOsim
Form1
Janela principal
Form2
Janela de simulação do escalonamento FIFO
Form3
Janela de criação de processo
Form4
Janela de simulação do escalonamento SJF
Form5
Janela de simulação do escalonamento Round Robin
Form6
Janela de simulação do escalonamento múltiplas filas
Form7
Janela de configuração de sistema
Form8
Janela de simulação do escalonamento prioridade não-preemptivo
Form9
Janela do diagrama de Gantt
Form10
Janela de créditos
Form11
Janela de simulação do escalonamento prioridade preemptivo
Form12
Janela de simulação do escalonamento circular com prioridade
Form17
Janela de informações de processos
35
Form18
Janela de simulação do escalonamento SRT
Conforme mostra a tabela 4, o simulador consiste em uma janela principal, oito
janelas que simulam os escalonamentos de processos, uma janela do diagrama de Gantt,
uma janela configuração do sistema, uma janela de informações de processos, outra janela do
estado da criação dos processos. O simulador EPSOsim foi desenvolvido não como uma
demonstração real do Sistema Operacional, pois se fosse como o funcionamento real de um
Sistema Operacional, não seria possível para o usuário perceber o funcionamento, porque no
Sistema Operacional os processos são escalonados de maneira muito rápida e
imperceptível. O simulador foi desenvolvido com a intenção de transmitir para o aluno o
melhor entendimento do assunto de escalonamento de processos.
Uma das idéias
para facilitar a percepção do usuário, foi à criação dos processos com cores diferentes, desta
forma dará para diferenciar um processo do outro.
4.2
JANELA PRINCIPAL
Inicialmente, foi criada a janela principal onde será o ponto inicial da aplicação. Nesta
janela o usuário pode abrir as janelas dos escalonamentos através das ilustrações com formato
de esferas coloridas ou pelo menu de escalonamento de processos, que foi dividido em dois
grupos: escalonamento de processos em lote e escalonamento de processos em sistemas
interativos. A figura 16 ilustra a janela principal:
36
Figura 16 – Janela principal
4.3
JANELA CONFIGURAÇÃO DO SISTEMA
O formulário de configuração do sistema é uma das partes mais importante do
simulador, neste formulário contém as classes principais do simulador. Veja mais detalhes do
código-fonte da configuração do sistema no anexo I. Nesta janela o usuário poderá alterar os
seis parâmetros conforme mostra a figura 17:
37
Figura 17 – Configuração do sistema
1. Tempo de clock: altera o clock do sistema. Foi considerado um clock inicial
(default) razoavelmente lento, pois assim, é mais perceptivo e coerente ao usuário o
funcionamento do escalonamento.
2.
Fatia de tempo: o usuário pode definir neste campo a fatia de tempo (timeslice)
usado no escalonamento Round Robin e circular com prioridade.
3. Tempo de acesso ao disco: determina o tempo do IO/Bound disco.
4. Tempo de acesso ao CD: determina o tempo do IO/Bound CD.
5. Tempo de acesso ao USB Flash: determina o tempo do IO/Bound USB Flash.
6. Tempo de IO: determina o tempo de espera dos processos de I/O.
38
4.4
JANELAS DE ESCALONAMENTO DE PROCESSOS
Inicialmente, antes de começar a simulação é preciso criar os processos, podem-se
criar inicialmente nove processos para os escalonamentos FIFO, SJF, SRT e RR e vinte e sete
processos para os escalonamentos múltiplas filas e prioridades (não-preemptivo, preemptivo e
circular). Para os escalonamentos de prioridade não-preemptivo, prioridade preemptivo,
circular com prioridade e múltiplas filas, após a inicialização da simulação o usuário pode
inserir quantos processos for necessário. Ao pressionar o botão criar processo nas janelas de
escalonamento (ver a figura 18), abre-se uma janela onde é possível determinar os parâmetros
necessários para a criação do processo. A figura 18 ilustra a janela de criação de processo:
Figura 18 – Janela de estado de criação do processo.
Conforme a figura 18, o usuário pode determinar os parâmetros do processo. Exceto o
PID do processo o qual é gerado automaticamente. O componente gráfico que seleciona a
prioridade, somente aparecerá quando a janela de escalonamento de processos por prioridade
(não-preemptivo, preemptivo e circular) for acionada, neste campo o usuário poderá definir a
prioridade de 1 a 3. No campo tempo de processamento o usuário poderá definir de 1 a 100,
foi limitado devido à visualização dos componentes gráficos dos processos. O botão criar
serve para cria o processo em si. O botão close é usado para fechar a janela de criação de
processos. O botão “Del. Tudo” (deletar tudo), exclui todos os processos.
39
No componente tipo de processo (vide figura 18) o usuário poderá escolher os tipos de
processo: CPU-Bound, I/O-Bound Disco, I/O-Bound CD, I/O-Bound USB Flash. Apenas os
tipos dos processos no escalonamento por múltiplas filas diferem dos demais escalonamentos,
veja abaixo:
1. Processo de sistema CPU-Bound;
2. Processo de sistema I/O-Bound;
3. Processos Interativos CPU-Bound;
4. Processos Interativos I/O-Bound;
5. Processos Batch CPU-Bound;
6. Processos Batch I/O-Bound;
A figura 19 ilustra o layout padrão usada nos escalonamentos FIFO, SJF, SRT e
Round Robin, onde contém os cinco estados criação, prontos, execução, bloqueado e
finalização:
40
Figura 19 – Layout padrão usada nos escalonamentos FIFO, SJF, SRT e Round
Robin
Conforme a figura 19, para dar início o escalonamento de processo é preciso clicar no
botão iniciar. E o botão diagrama de Gantt exibe a janela diagrama de Gantt. Com essa
funcionalidade, ficará melhor acompanhar e entender o tempo de execução de cada processo.
No botão finalizar processos, quando o processo passa para o estado de execução, logo é
transferido para o estado de finalização mesmo que o processo não tenha acabado todo seu
tempo de processamento. Quando todos os processos forem finalizados é mostrado o
diagrama de Gantt até o ponto em que foram finalizados. No botão abortar, a simulação é
interrompida e a janela referente ao escalonamento é fechada voltando para janela principal.
41
O botão pause e o botão play referente aos botões azuis (vide figura 19), nestes botões
o usuário poderá pausar e continuar a execução do escalonamento de processo. É possível
selecionar o intervalo de tempo do clock e do tempo de espera no componente conhecido
como “spinedit”, estes componentes estão localizados a direita do botão pause. No botão
“Inf. Processos” (Informações de processos), o usuário pode visualizar as informações dos
processos tais como: cor, alias do processo (campo processo), tipo do processo (campo tipo),
tempo de processador (campo t. burst), turnaround (campo t. execução), tempo de espera e o
estado do processo. A figura 20 ilustra a janela de Informações de processos:
Figura 20 – Informações de processos
42
Nas seções seguintes, serão apresentadas as janelas em que ocorre a simulação dos
escalonamentos de processos, primeiramente será mostrado o escalonamento FIFO.
4.4.1 JANELA FIFO
O FIFO (em inglês First in First Out - Primeiro a Entrar é o Primeiro Sair) também
denominado de FCFS (em inglês First Come First Serve – o primeiro a chegar é o primeiro a
ser servido) é considerado o escalonamento mais simples de ser entendido. O FIFO funciona
da seguinte forma, quando um processo é criado no estado de criação, é inserido no final de
uma estrutura de dados fila chamada de fila de aptos ou prontos. À medida que os processos
são criados, o Sistema Operacional faz o armazenamento das informações de cada processo
no bloco de controle de processos (PCB), mais detalhes do PCB, ver na seção 2.2.3
(PIOVESANA, 2010).
Para compreender e visualizar melhor o funcionamento dos escalonamentos de
processos e obter os parâmetros para se calcular o tempo médio de espera dos processos é
necessário criar o diagrama de Gantt. A figura 21 será ilustrado o diagrama de Gantt do
escalonamento FIFO:
Tempo médio de espera:
(0+8+15) = 23/3
=7,666666666666667 u.t.
0
1
2
3
4
5
6
7
8
9 10 11
12 13 14
15
16 17 18 19
20
Figura 21 – Uso da política de escalonamento FIFO com o diagrama de Gantt
43
Gantt é um diagrama em barra que ilustra os intervalos de tempo de uma ou mais
tarefas, tem como parâmetros para criar as barras o início e fim de cada tarefa. Para se
calcular o tempo médio de espera é preciso fazer o somatório do tempo decorrente de cada
processo em que ficou na fila de prontos e dividir pelo número de processos o resultado é
medido por unidades de tempo (u.t.). Mais detalhes do funcionamento do escalonamento
FIFO, veja na seção 4.5. A figura 22 ilustra a janela de escalonamento FIFO:
Figura 22 – Janela que simula o funcionamento do escalonamento FIFO
O FIFO é não-preemptivo, isto é, o escalonador não interrompe os processos em
execução. O processo que estiver no início da fila de pronto será selecionado e alocado na
CPU. Em seguida, o processo ficará na CPU até acabar todo seu tempo de processador (burst
time) (LEITÃO, 2010).
44
4.4.2 JANELA SJF
O SJF (Shortest Job First) em português processo mais curto primeiro, este algoritmo
de escalonamento poderia ser implementado usando uma lista ordenada na ordem crescente
dos tempos de vida dos processos (OLIVEIRA et. al., 2001).
No SJF pode ocorrer o starvation (inanição), por exemplo, um processo com um
tempo de processador definido como 30, este processo fica infinitamente no estado de pronto,
pois sempre há processos no estado de pronto com um tempo de processador menor do que
30. No caso deste exemplo, se existir outro processo com um tempo de processador igual a
30, o desempate é tirado de acordo com a política FIFO. A figura 23 ilustra o diagrama de
Gantt do escalonamento SJF:
Tempo médio de espera:
(0+5+12) = 17/3 =
5,666666666666667 u.t
0
1
2
3
4
5
6
7
8
9
10 11
12 13
14
15 16 17 18 19
20
Figura 23 – Exemplo da política de escalonamento SJF com o diagrama de Gantt.
De acordo com Machado (2009), uma das vantagens do escalonamento SJF com
relação ao FIFO, é que possui um tempo médio de espera menor. Foram representados três
processos de tempo de processamento iguais para cada escalonamento FIFO e SJF,
comparando o diagrama de Gantt do escalonamento FIFO da figura 21 com o diagrama do
escalonamento SJF da figura 23, o resultado do FIFO equivale a 7.666666666666667 u.t.,
45
enquanto do SJF equivale a 5.666666666666667 u.t.. A figura 24 a janela de escalonamento
SJF:
Figura 24 – Janela que simula o funcionamento do escalonamento SJF
Conforme a figura 24, quando inicia o escalonamento no botão iniciar, todos os
processos são transferidos do estado de criação para o estado de pronto e ordenados pelo
tempo de processamento na ordem crescente no sentido da direita para esquerda da fila de
pronto. Diante disso, será selecionado o processo de menor tempo de processamento para ser
alocado na CPU. Caso o processo for do tipo CPU-Bound, é utilizado todo o seu tempo de
processador na CPU. O usuário poderá visualizar o tempo de processador na parte inferior do
estado de execução. Utilizado todo o tempo de processador na CPU, o processo é passado
para o estado de finalização.
46
No caso dos processos IO-Bound, o processo é transposto rapidamente para o final da
fila de espera no estado bloqueado. No simulador os processos são enfileirados no sentido da
esquerda para direita. Nos estado de espera, o primeiro processo da fila é escolhido para
realizar operações de entrada e saída, nesta fase o usuário poderá acompanhar o progresso
desta operação no componente processbar. Após realizar as operações de entrada e saída, o
processo é repassado novamente para o estado de pronto, no final da fila de prontos. Quando
o processo IO-Bound utilizar todo o seu tempo de processamento (burst time), o processo é
finalizado passado para o estado de término.
4.4.3 JANELA SRT
O SRT (Shortest Remaining Time) é um escalonamento que significa tempo
mais curto remanescente, este escalonamento é uma versão semelhante ao
escalonamento SJF. O que diferencia o SRT do SJF é a preempção (MACHADO;
MAIA, 2009). A figura 25 ilustra o escalonamento SRT:
Figura 25 – Janela que simula o funcionamento do escalonamento SRT
47
O SRT é preemptivo, isso funciona da seguinte forma, no momento do escalonamento
ao chegar à fila de pronto um processo de menor tempo de processador do que o processo em
execução é realizado a troca dos processos destes processos. O processo que antes estava na
CPU é realocado na posição correta na fila de prontos. E o processo recém chegado é alocado
na CPU (MACHADO; MAIA, 2009).
Uma das vantagens do SRT é que os processos de menor tempo de processamento têm
um tempo de resposta superior do que processos de maior tempo de processamento, além de
possuir um throughput maior. Uma desvantagem é que pode ocorrer o starvation onde
processos de maior tempo de processamento podem nunca ser executados. Outra diferença
notória deste escalonamento está nos processos do tipo IO-Bound, após realizar as operações
de entrada e saída é repassado para a fila de pronto. Com isso, os processos na fila de pronto
são realocados na posição correta em que são reordenados pelo tempo de processador
(MACHADO; MAIA, 2009).
4.4.4 JANELA CIRCULAR
O Round Robin é uma das políticas de escalonamento mais antigas e usadas. Uma das
características dos algoritmos Round Robin é a utilização da fatia de tempo (timeslice). A
fatia de tempo é utilizada para realizar a preempção por tempo, no qual o processo é removido
da CPU pelo tempo definido da fatia de tempo (MACHADO; MAIA, 2009). De acordo com
Machado (2009), no caso da fatia de tempo tender ao infinito o escalonamento Round Robin
equivale ao escalonamento FIFO. As três as figuras a seguir, figuras 26, 27 e 28 ilustra o
diagrama de Gantt do escalonamento Round Robin, respectivamente com um quantum igual a
8, 5 e 2.
48
Quantum = 8
Tempo Médio de Espera:
(0 + 8 + 15+ 20) = 43/ 3 =
14,33333333333333 u.t
0
1
2
3
4
5
6
7
8
9
10 11 12 13 14
15
16 17 18 19
20
Figura 26 – Diagrama de Gantt do escalonamento Round Robin, com quantum igual a oito.
Quantum = 5
Tempo Médio de Espera:
(0 + 5 + 10 + 10 + 8) = 33/ 3
= 11 u.t
0
1
2
3
4
5
6
7
8
9
10
11 12 13 14
15
16 17
18 19 20
Figura 27 – Diagrama de Gantt do escalonamento Round Robin, com quantum igual a cinco.
49
Quantum = 2
Tempo Médio de Espera:
(0+2+4+4+4+4+4+4+4+4) =
34/3 = 11,33333333333333
u.t
0
1
2
3
4
5
6
7
8
9
10
11
12 13 14 15 16
17
18 19 20
Figura 28 – Diagrama de Gantt do escalonamento Round Robin, com quantum igual a dois.
Conforme Machado (2009), quando o quantum é muito pequeno, acontece excessivos
números de preempções por tempo, isso compromete a performance de um sistema. No
simulador o usuário pode alterar a variável fatia de tempo na janela de configuração (vide
seção 4.3). A figura 29 ilustra o escalonamento Round Robin:
50
Figura 29 – Janela que simula o funcionamento do escalonamento Round Robin
Como em todos os escalonamentos do simulador, os processos são criados e inseridos
no estado de criação. Em seguida, são transferidos para fila de pronto. Mais adiante, é
selecionado o primeiro processo da fila de pronto e é alocado na CPU. Com isso, no caso de
processos CPU-Bound, quando termina a fatia de tempo, o processo retorna para o estado de
pronto, onde é desalocado da CPU e inserido no final da fila de pronto. Desta forma, a CPU
fica livre para a entrada do próximo processo (MACHADO; MAIA, 2009).
4.4.5 JANELA PRIORIDADE NÃO-PREEMPTIVO
No escalonamento por prioridade é comum a preferência a determinados tipos de
processos com relação a outros tipos, neste tipo de escalonamento não existe o conceito de
fatia de tempo. A prioridade é determinada principalmente pelo gerenciador da CPU ou
51
administrador, onde é atribuído um valor a variável de prioridade do contexto de software a
cada processo (ALMEIDA, [s.d]).
Alguns sistemas têm como o processo de maior prioridade o número zero, outros
sistemas usam o zero como sendo o processo de menor prioridade. Outros sistemas dão mais
prioridade aos processos que tem menos tempo de turnaround, processos que usa menos
memória, processos IO-Bound e etc. Estes critérios depende da implementação do algoritmo
de escalonamento de prioridade (MACHADO; MAIA, 2009).
No simulador, cada fila possui um nível de prioridade, os processos da primeira fila
tem prioridade 1, os processos da segunda fila tem prioridade 2 e os processos da terceira fila
tem prioridade 3. Os processos que possui menor número de prioridade é o que possui maior
prioridade, nos quais são os primeiros a serem executado. Quando os processos da fila de
prioridade 1 for esvaziada, o escalonador passa a escalonar os processos da fila de prioridade
2, quando a fila de prioridade 2 é esvaziada, o escalonador passa a escalonar os processos da
fila número 3. A figura 30 representa o escalonamento por prioridade não-preemptivo:
Figura 30 – Janela que simula o funcionamento do escalonamento não-preemptivo
52
Uma das características que define o escalonamento não-preemptivo, é quando um
processo x está em execução e outro processo y entra na fila de pronto, no qual o processo y
tem maior prioridade do que o processo x. Com isso, não ocorre à preempção por prioridade,
o processo x continua executando até acabar o tempo de processador, isso para os processos
do tipo CPU-Bound. No caso dos processos IO-Bound o processo é despachado para a fila de
bloqueado, logo em seguida, é repassado para a fila de pronto (MACHADO; MAIA, 2009).
Neste escalonamento pode ocorrer a inanição (starvation), ou seja, o processo de
prioridade inferior corre o risco de nunca ser executado, neste caso a solução é o
envelhecimento (aging), em que aumenta o nível de prioridade do processo (MACHADO;
MAIA, 2009). O envelhecimento não foi implementado no simulador EPSOsim, mas é
possível o usuário fazer com que aconteça o envelhecimento mesmo que não possua nada que
indique o envelhecimento no simulador.
4.4.6 JANELA PRIORIDADE PREEMPTIVO
O escalonamento por prioridade preemptivo possui a preempção por prioridade, não
confundir com preempção por tempo. A diferença do escalonamento por prioridade
preempção com o escalonamento por prioridade não-preemptivo, é quando um processo x de
maior prioridade entra na fila de pronto no momento em que outro processo y de menor
prioridade utiliza a CPU, neste momento acontece à preempção por prioridade, onde o
processo y é desalocado da CPU para a entrada do processo x de maior prioridade. A figura
31 ilustra a janela de escalonamento preemptivo:
53
Figura 31 – Janela que simula o funcionamento do escalonamento preemptivo
4.4.7 JANELA CIRCULAR COM PRIORIDADES
O escalonamento circular por prioridade é uma combinação do escalonamento Round
Robin com o escalonamento por prioridade, isto quer dizer que pode existir tanto a preempção
por tempo quanto a preempção por prioridade (MACHADO; MAIA, 2009). A figura 32
representa o escalonamento circular com prioridade:
54
Figura 32 – Janela que simula o funcionamento do escalonamento circular com prioridade
De acordo com Machado (2009), uma das vantagens do escalonamento circular com
prioridade, é que possui um melhor equilíbrio dos processos no uso da CPU. Normalmente,
os processos do tipo IO-Bound recebem mais privilégios por intermédio do administrador de
sistema, isso para que se tenha um balanceamento mais justo.
4.4.8 JANELA MÚLTIPLAS FILAS
Os algoritmos de escalonamento de múltiplas filas é implementado usando várias filas
no estado de prontos. Cada fila de pronto é determinado por níveis ou classes de prioridade,
onde podem ser aplicados vários tipos de escalonamentos de processos, tais como: FIFO,
Round Robin, SJF, por prioridade e etc (MACHADO; MAIA, 2009).
55
Uma das características deste escalonamento é que pode estabelecer vários critérios,
um dos critérios é que, se um processo for do tipo I/O-Bound, o processo passa para a fila de
maior prioridade. Caso o processo for do tipo CPU-Bound, o processo passa para a fila de
menor prioridade, depende muito da implementação do algoritmo escalonamento
(MACHADO; MAIA, 2009). A figura 33 será ilustrado o escalonamento Múltiplas Filas:
Figura 33 – Janela que simula o funcionamento do escalonamento múltiplas filas
Na janela de escalonamento de múltiplas filas do simulador foi usada três filas, onde
cada fila representa um escalonamento diferente, a primeira fila representa o escalonamento
por prioridade, a segunda fila representa o escalonamento Round Robin e a terceira fila
representa o escalonamento FIFO. À medida que a fila é totalmente esvaziada, o escalonador
desce a um nível de prioridade.
56
4.5
JANELA DIAGRAMA DE GANTT
O diagrama de Gantt foi criado por Henry L. Gantt em 1917 é um tipo de gráfico em
barra usado pelos chefes de projeto para cronogramas de projeto. O diagrama de Gantt é
muito simples de criar e de entende (KIOSKEA, 2009). A figura 34 o diagrama de Gantt com
base nos mesmos valores do diagrama ilustrado na seção 4.4.1 (FIFO):
Figura 34 – Diagrama de Gantt do simulador EPSOsim (Escalonamento FIFO)
No eixo x (horizontal), indica o tempo das tarefas, seja representado por segundo,
minuto, hora, mês, dia, mês, ano e etc. No eixo y (vertical) do diagrama de Gantt, representa
as tarefas, onde no simulador são processos computacionais (KIOSKEA, 2009). No
simulador, o diagrama de Gantt registra o momento em que entra o primeiro processo na CPU
(início do escalonamento), até o último processo no qual finalizou seu tempo de processador
na CPU (final do escalonamento).
57
5.
CONCLUSÃO
No início desde trabalho, foi visto o relevante grau de dificuldade para se compreender
os assuntos predominantemente teóricos abordados na disciplina de Sistemas Operacionais, os
quais implicam em uma série de dificuldades para os alunos de graduação dos cursos de
computação.
Há assuntos na disciplina de Sistemas Operacionais muito importantes, porém
complexos. A gerência de processos faz parte um destes assuntos, como também o
escalonamento de processos. Diante disto, foi desenvolvido o simulador EPSOsim, o
qual demonstra o funcionamento dos escalonamentos de processos, permitindo a visualização
dos resultados dos processos em tempo de execução na tabela de informações dos processos
(vide figura 20).
Foi criado o simulador de escalonamento de processo que permite a visualização
gráfica do funcionamento dos algoritmos. O simulador possui oito algoritmos de
escalonamento que são:
FIFO;
SJF;
SRT;
Circular;
Circular com prioridade;
Por prioridade preemptiva;
Por prioridade não-preemptivo;
Múltiplas Filas.
O simulador permite a visualização do diagrama de Gantt, o qual é uma das partes
fundamentais do simulador. O diagrama de Gantt registra os processos desde o início até final
do escalonamento. Com este instrumento, os alunos terão mais facilidade em aprender sobre o
funcionamento dos escalonamentos de processos.
58
A criação desta ferramenta educativa representa uma contribuição para o estudo de
algoritmos de escalonamento, em especial na disciplina Sistemas Operacionais. É possível
perceber que a ferramenta servirá para temas de futuros alunos em trabalhos acadêmicos,
monografias e dissertações. Espera-se que o simulador contribua com o processo de ensinoaprendizagem de disciplinas que abordem algoritmos de escalonamento
59
6.
REFERÊNCIAS BIBLIOGRÁFICAS
ALMEIDA, Helder C. P. Princípios de Sistemas Operacionais. Disponível em:
<http://www.cefetto.org/~05203130/superior/I%20periodo/Aula%20introdu%e7%e3o%20a%20computa%e7%
e3o/Princ%edpios%20de%20Sistemas%20Operacionais%20%20Gerenciador%20de%20Processador%20e%20Processos%20-%20Final2.ppt> Acesso em
05 de Junho de 2011.
ANDERSON, Thomas. Nexos. 2008. Disponível em:
<http://www.cs.washington.edu/homes/tom/nachos/> Acesso em 21 de Novembro de 2009.
AVRAM, Abel. MINIX 3 Promises to be more secure than windows or linux. Disponível
em: <www.infoq.com/br/news/2009/05/MINIX> Acesso em 10 de Outubro de 2009.
BALDI,
Sérgio
Dario.
Construtivismo.
2010.
Disponível
<http://www.artigos.com/artigos/humanas/educacao/construtivismo-10900/artigo/>
em
Acesso
em: 11 Junho 2011
BRANCO, Ricardo Rubira. Sistemas Operacionais. Disponível em:
<http://www.kernelhacking.com/rodrigo/docs/OS/AulaFGP1.pdf>
Acesso
em
28
de
Novembro de 2009.
CARDOSO,
Nogueira
Paes.
Sistemas
Operacionais.
2006.
Disponível
em:
<http://algol.dcc.ufla.br/~olinda/arquivos/so%20aula%201.pdf> Acesso em 01 de Dezembro
de 2009.
CASTRO, Giselle Fernandes. Ensino conteudista versus Escola atual. Disponível em:
<http://www.apagina.pt/?aba=7&cat=69&doc=7368&mid=2> Acesso em 28 de Maio de 2011.
60
CUNHA, Jose C. Estados de um processo num sistema de multiprogramação. 2003.
Disponível em: <http://www-asc.di.fct.unl.pt/~jcc/ASC2/Teoricas/a4/node10.htm>Acesso em
09 Novembro de 2010
DOI, Marcio Ken Iti. Microkernel. 2005. Disponível em:
<http://www.tiparana.com.br/articles.php?id=12> Acesso em 01 de Dezembro de 2009.
EQUINOX.
MINIX
3.
2007.
Disponível
em:
<http://www.minix3.org/news/screendump.png> Acesso em 21 de Novembro de 2009.
FILHO, Clovis Perin. Introdução à Simulação de Sistemas. 1995. 159f. Campinas, SP:
Editora da UNICAMP.
GNU. GNU Operating System. 2009. Disponível em: <http://www.gnu.org/> Acesso em 19
de Novembro de 2009.
GONÇALVES, José Pereira Filho. Trabalho info1142. 2008. Disponível em:
<http://www.inf.ufes.br/~zegonc/material/Sistemas%20Operacionais/SO%20old/S.O/SO%20
2005/Nachos%20-%20info1142.htm> Acesso em 28 de Maio de 2011.
GUIZZI. Processo. 2010. Disponível em:
<http://www.scribd.com/doc/5565560/03PROCESSOS> Acesso em 01 Novembro de 2010.
KIOSKEA. Diagrama de GANTT. 2009. Disponível em:
<http://pt.kioskea.net/contents/projet/gantt.php3 > Acesso em 12 de Junho de 2011.
LEITÃO,
Gustavo.
Processos.
2010.
Disponível
em
<http://www.dca.ufrn.br/~guga/downloads/par/aulas/Aula3-Processos.pdf>Acesso em 28 de
Novembro de 2010.
61
MACHADO, Francis Berenger, MAIA, Luiz Paulo. Um framework construtivista no
aprendizado de Sistemas Operacionais - uma proposta pedagógica com o uso do
simulador SOsim. Disponível em: <http://www.training.com.br/SOsim/sbcwei04.pdf>
Acesso em 10 de Setembro de 2009.
MAIA, Luiz Paulo, MACHADO, Francis Berenger. Laboratório SOsim - Gerência de
Processos. Disponível em: <http://www.inf.puc-rio.br/~francis/aso3ed/aso-labSOsim-cap5processo.pdf > Acesso em 10 de Setembro de 2009.
MAIA, Luiz Paulo. SOsim: Simulador para o ensino de Sistemas Operacionais. Tese de
Mestrado,
NCE/UFRJ,
mar.
2001.
Disponível
em:
<http://www.training.com.br/SOsim/SOsim_tese.zip> Acesso em 10 de Setembro de 2009.
MACORATTI, José Carlos. UML - Diagrama de Classes e objetos. Disponível em:
<http://www.macoratti.net/net_uml1.htm> Acesso em 29 de Maio de 2011.
RODRÍGUEZ, Miguel Ángel Martínez. l Enfoque sociocultural en el estudio del desarrollo
y la educación. Escuela Nacional de Estudios Profesionales. 1999. Campus Iztacala.
Universidad Nacional Autónoma de México. Artigo publicado na Revista Eletrônica de
Investigação Educativa. UABC. México.
MAZIERO, Carlos. Sistemas Operacionais I - Conceitos Básicos. 2008. Disponível em:
<http://www.ppgia.pucpr.br/~maziero/lib/exe/fetch.php/so:so-cap01.pdf > Acesso em 04 de
Junho de 2011.
MEC/SESu, Comissão de especialistas de ensino de computação e informática. Disponível
em: <http://www.inf.ufrgs.br/mec> Acesso em 10 de Outubro de 2009.
MEDEIROS, Raissa Dantas Freire de. Gerência de Memória. 2006. Disponível em:
<http://www.ucb.br/prg/professores/raissad/disciplinas/2006_2/SO/material/memoria/memori
a.html> Acesso em 01 de Dezembro de 2009.
62
OLIVEIRA, R. S.; CARISSIMI, Alexandre da S.; TOSCANI, S. S. Sistemas Operacionais.
3. ed. Porto Alegre: Editora Sagra Luzzatto, 2004, 259p.
ONTKO, Ray. Modern Operating Systems Simulators. 2008. Disponível em:
<http://www.ontko.com/moss/> Acesso em 21 de Novembro de 2009.
PAULO, Marcus. SISO 2.0 - Simulador de Sistema Operacional (Módulo de Deadlock).
2009.
Disponível
em:
<http://www.martins.eti.br/2009/03/siso-20-simulador-de-
sistema.html> Acesso em 01 de Dezembro de 2009.
PERIN FILHO, Clovis. Introdução à Simulação de Sistemas. Campinas, SP: UNICAMP,
1995, 159p.
PIOVESANA, Rodrigo. Processos. Disponível em:
<http://www.slideshare.net/rodrigo.piovesana/processos-3360190>
Acesso
em
18
de
Novembro de 2010.
PODGORETSKY ANATOLY. Object Pascal Language Guide.
Disponível em:
<http://www.podgoretsky.com/ftp/Docs/Delphi/D5/oplg/oplg.pdf> Acesso em 10 de Maio de
2011.
SARAIVA, Márcio. em: Um "exame de DNA" na carreira de dois grandes cientistas para
descobrirmos
o
"pai"
da
nossa
profissão.
2009.
Disponível
em:
<http://www.dsc.ufcg.edu.br/~pet/jornal/agosto2009/materias/carreira.html> Acesso em 28 de
Novembro de 2009.
SESu. Diretrizes curriculares para os cursos de graduação. Disponível em:
<http://portal.mec.gov.br/sesu/index.php?option=content&task=view&id=430&Itemid=420>
Acesso em 10 de Outubro de 2009.
63
SILBERSCHATZ, Avi; GALVIN, Peter B.; GAGNE, Greg. Operating System Concepts.
7.ed. Hoboken: Wiley. 2005.
SONYMASTER (2009). Especial - A Historia do Sistema Operacional Unix (Linux).
Disponível em:<http://forum.outerspace.terra.com.br/showthread.php?t=209016> Acesso em
28 de Novembro de 2009.
STALLINGS, William (2004). Sistemas Operacionais internas e Princípios de Design
(quinta
edição
internacional).
Prentice
Hall. ISBN 0-13-147954-7.
Disponível
em:
<http://pt.wikipedia.org/wiki/Escalonamento_de_processos>Acesso em 15 Novembro de
2010
TANENBAUM, Andrew, em: Sistemas Operacionais modernos. 2. ed. Rio de Janeiro:
Editora Prentice Hall. 2005.
TANENBAUM, Andrew. MINIX 3 – Download. 2011. Disponível em:
<http://www.minix3.org/download/> Acesso em 04 de Junho de 2011.
TORVALDS, Linus. Lignux, what's the matter with you people? 1996. Disponível em:
<http://groups.google.com/group/comp.os.linux.misc/msg/7781d4221fceedb2> Acesso em 21
de Novembro de 2009.
VAGO,
El
Rincón
del.
Sistemas
Operativos.
Disponível
em:
<http://html.rincondelvago.com/sistemas-operativos_12.html> Acesso em 12 de Junho de
2011.
64
7.
ANEXOS
ANEXO I – CÓDIGO-FONTE DA JANELA CONFIGURAÇÃO DO SISTEMA
unit Unit7;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Spin, Buttons, Contnrs,ExtCtrls, ComCtrls;
type
TForm7 = class(TForm)
Label4: TLabel;
BitBtn5: TBitBtn;
BitBtn2: TBitBtn;
Label2: TLabel;
Label9: TLabel;
Label10: TLabel;
Label11: TLabel;
Label8: TLabel;
Label7: TLabel;
Label1: TLabel;
SpinEdit2: TSpinEdit;
SpinEdit6: TSpinEdit;
SpinEdit7: TSpinEdit;
SpinEdit9: TSpinEdit;
SpinEdit10: TSpinEdit;
SpinEdit8: TSpinEdit;
SpinEdit1: TSpinEdit;
procedure BitBtn2Click(Sender: TObject);
procedure BitBtn1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure BitBtn5Click(Sender: TObject);
function Calculate(SMyExpression: string; digits: Byte): string;
//
Calculate
a
simple
expression.
Supported
are:
http://www.swissdelphicenter.ch/en/showcode.php?id=470
private
{ Private declarations }
public
{ Public declarations }
end;
Real
Numbers,
parenthesis.
TProcesso = class(TInterfacedObject)
private
public
{ ----- Atributos ----- }
Fcor:Tcolor;
Fpid:integer;
FTempoProcessador:integer; //tempo de processo
FtempoExecucao:integer;
FtempoTurnaround:integer;
FtempoEsperaProcesso :integer;
Fporcentagem:integer;
Ftipo:String;
Fprioridade:integer;
{ ----- Construtor ----- }
constructor
create
(cor:
Tcolor;
pid:integer;
TempoProcessador:integer;
tempoExecucao:integer;
porcentagem:integer;
tipo:string;
prioridade:integer;
tempoTurnaround:integer; tempoEsperaProcesso:integer);
//destructor Destroy;
{ ----- Funções e procedimetos ----- }
function GTempoProcessador:integer;
procedure STempoProcessador(valor:integer);
function Gcor:Tcolor;
procedure Scor(valor:Tcolor);
65
function Gpid:integer;
procedure Spid(valor:integer);
function GtempoExecucao:integer;
procedure StempoExecucao(valor:integer);
function GtempoTurnaround:integer;
procedure StempoTurnaround(valor:integer);
function GtempoEsperaProcesso:integer;
procedure StempoEsperaProcesso(valor:integer);
function Gporcentagem:integer;
procedure Sporcentagem(valor:integer);
function Gtipo:String;
procedure Stipo(valor:String);
function Gprioridade:integer;
procedure Sprioridade(valor:integer);
{ ------ Gets E Sets ------ }
property cor: Tcolor
read Gcor
property pid:integer
read Gpid
property TempoProcessador:integer
read GTempoProcessador
STempoProcessador;
property
tempoExecucao:integer
read GtempoExecucao
StempoExecucao;
property
tempoTurnaround:integer
read GtempoTurnaround
StempoTurnaround;
property
tempoEsperaProcesso:integer
read GtempoEsperaProcesso
StempoEsperaProcesso;
property
porcentagem:integer
read Gporcentagem
Sporcentagem;
property tipo: String
read Gtipo
property
prioridade:integer
read Gprioridade
Sprioridade;
end;
write Scor;
write Spid;
write
write
write
write
write
write Stipo;
write
TCPU = class(TInterfacedObject)
public
{ ------ Atributos ------ }
Focupado:integer;
FtempoDecorrido:integer;
FProcessoExecutando:Tprocesso;
{ ------ Construtor ------ }
constructor create;
//destructor Destroy;
{ ------ Funções e procedimentos ------ }
function Gocupado:integer;
procedure Socupado(valor:integer);
function GtempoDecorrido:integer;
procedure StempoDecorrido(valor:integer);
function GProcessoExecutando:Tprocesso;
procedure SProcessoExecutando(valor:Tprocesso);
{ ------ Gets E Sets ------ }
property ocupado:integer
read Gocupado
write Socupado;
property
tempoDecorrido:integer
read
GtempoDecorrido
write
StempoDecorrido;
property
ProcessoExecutando:Tprocesso
read
GProcessoExecutando
write
SProcessoExecutando;
procedure incrementaTempoDecorrido;
function removeProcessoExecutando:Tprocesso;
procedure insereProcessoExecutando(processo:Tprocesso);
end;
TDisco = class(TInterfacedObject)
public
{ ------ Atributos ------ }
Focupado :integer;
FtempoEsperado :integer;
FtempoDecorrido :integer;
FtempoIO :integer;
FProcessoIO:Tprocesso;
{ ------ Construtor ------ }
constructor
create(ocupado:integer; tempoEsperado:integer;
tempoIO:integer);
tempoDecorrido:integer;
66
//destructor Destroy;
{ ------ Funções e procedimentos ------ }
function Gocupado:integer;
procedure Socupado(valor:integer);
function GtempoEsperado:integer;
procedure StempoEsperado(valor:integer);
function
GtempoDecorrido:integer;
procedure StempoDecorrido(valor:integer);
function GtempoIO:integer;
procedure StempoIO(valor:integer);
function GProcessoIO:Tprocesso;
procedure SProcessoIO(valor:Tprocesso);
{ ------ Gets E Sets ------ }
property ocupado
:integer
read
property tempoEsperado
:integer
read
property tempoDecorrido :integer
read
property tempoIO
:integer
read
Gocupado
GtempoEsperado
GtempoDecorrido
GtempoIO
write
write
write
write
Socupado;
StempoEsperado;
StempoDecorrido;
StempoIO;
end;
TSistema = class(TInterfacedObject)
public
{ ------ Atributos ------ }
FfatiaTempoSistema
:integer;
FtempoDecorridoSistema :integer;
FtempoAcessoDisco
:integer;
FtempoAcessoUSBFlash :integer;
FtempoAcessoCD
:integer;
FtempoClock
:integer;
FtempoThroughput
:integer;
FtempoInicialGantt
:integer;
FtempoFinalGantt
:integer;
FtempoMedioTurnaround :integer;
FUT
:integer;
FUTAux
:String;
FLimitePrioridade
:integer;
FCalculaUnidadeTempo
:String;
{ ------ Construtor ------ }
constructor
create(fatiaTempoSistema:integer;
tempoDecorridoSistema:integer;
tempoAcessoDisco:integer;
tempoAcessoUSBFlash:integer;
tempoAcessoCD:integer;
tempoClock:integer;
tempoThroughput:integer;
tempoInicialGantt:integer;
tempoFinalGantt:integer; UT:integer; UTAux:String; LimitePrioridade:integer);
//destructor Destroy;
{ ------ Funções e procedimentos ------ }
function GfatiaTempoSistema:integer;
procedure SfatiaTempoSistema(valor:integer);
function GtempoDecorridoSistema:integer;
procedure StempoDecorridoSistema(valor:integer);
function GtempoAcessoDisco:integer;
procedure StempoAcessoDisco(valor:integer);
function GtempoAcessoUSBFlash:integer;
procedure StempoAcessoUSBFlash(valor:integer);
function GtempoAcessoCD:integer;
procedure StempoAcessoCD(valor:integer);
function GtempoClock:integer;
procedure StempoClock (valor:integer);
function GtempoThroughput:integer;
procedure StempoThroughput (valor:integer);
function GtempoInicialGantt:integer;
procedure StempoInicialGantt (valor:integer);
function GtempoFinalGantt:integer;
procedure StempoFinalGantt (valor:integer);
function GUT:integer;
procedure SUT(valor:integer);
function GUTAux:String;
procedure SUTAux (valor:String);
function GLimitePrioridade:integer;
procedure SLimitePrioridade (valor:integer);
function GtempoMedioTurnaround:integer;
procedure StempoMedioTurnaround (valor:integer);
67
function GCalculaUnidadeTempo:String;
procedure SCalculaUnidadeTempo (valor:String);
{ ------ Gets E Sets ------ }
property fatiaTempoSistema
:integer
read
GfatiaTempoSistema
SfatiaTempoSistema;
property tempoDecorridoSistema :integer
read
GtempoDecorridoSistema
StempoDecorridoSistema;
property tempoAcessoDisco
:integer
read
GtempoAcessoDisco
StempoAcessoDisco;
property tempoAcessoUSBFlash
:integer read GtempoAcessoUSBFlash
StempoAcessoUSBFlash;
property tempoAcessoCD
:integer
read
GtempoAcessoCD
StempoAcessoCD;
property tempoClock
:integer
read
GtempoClock
StempoClock;
property tempoThroughput
:integer
read
GtempoThroughput
StempoThroughput;
property tempoInicialGantt
:integer
read
GtempoInicialGantt
StempoInicialGantt;
property tempoFinalGantt
:integer
read
GtempoFinalGantt
StempoFinalGantt;
property UT
:integer read GUT
property UTAux
:String
read GUTAux
property LimitePrioridade
:integer
read
GLimitePrioridade
SLimitePrioridade;
property tempoMedioTurnaround
:integer
read
GtempoMedioTurnaround
StempoMedioTurnaround;
property CalculaUnidadeTempo
:String
read
GCalculaUnidadeTempo
SCalculaUnidadeTempo;
write
write
write
write
write
write
write
write
write
write
write
SUT;
SUTAux;
write
write
write
Protected
end;
var
Form7
S
D
:TForm7;
:TSistema;
:TDisco;
//Objeto Sistema
//Objeto Disco
implementation
uses Unit1, Unit2, Unit3, Unit4, Unit5, Unit6, Unit8;
{$R *.dfm}
{-----CONSTRUTORES-----}
constructor
TProcesso.create(cor:
Tcolor;
pid:integer;
TempoProcessador:integer;
tempoExecucao:integer;
porcentagem:integer;
tipo:string;
prioridade:integer;
tempoTurnaround:integer; tempoEsperaProcesso:integer);
begin
Fcor
:= cor;
Fpid
:= pid;
FTempoProcessador
:= TempoProcessador;
FtempoExecucao
:= tempoExecucao;
Fporcentagem
:= porcentagem;
Ftipo
:= tipo;
Fprioridade
:= prioridade;
FtempoTurnaround
:= tempoTurnaround;
FtempoEsperaProcesso := tempoEsperaProcesso;
end;
constructor TCPU.create;
begin
ocupado
:= 0;
tempoDecorrido := 0;
end;
68
constructor TDisco.create(ocupado:integer;
tempoIO:integer);
begin
Focupado
:= ocupado;
FtempoEsperado
:= tempoEsperado;
FtempoDecorrido
:= tempoDecorrido;
FtempoIO
:= tempoIO;
end;
tempoEsperado:integer;
tempoDecorrido:integer;
constructor
TSistema.create(fatiaTempoSistema:integer;
tempoDecorridoSistema:integer;
tempoAcessoDisco:integer;
tempoAcessoUSBFlash:integer;
tempoAcessoCD:integer;
tempoClock:integer;
tempoThroughput:integer;
tempoInicialGantt:integer;
tempoFinalGantt:integer; UT:integer; UTAux:String; LimitePrioridade:integer);
begin
Self.FfatiaTempoSistema
:=
fatiaTempoSistema;
Self.FtempoDecorridoSistema :=
tempoDecorridoSistema;
Self.FtempoAcessoDisco
:=
tempoAcessoDisco;
Self.FtempoAcessoUSBFlash
:=
tempoAcessoUSBFlash;
Self.FtempoAcessoCD
:=
tempoAcessoCD;
Self.FtempoClock
:=
tempoClock;
Self.FtempoThroughput
:=
tempoThroughput;
Self.FtempoInicialGantt
:=
tempoInicialGantt;
Self.FtempoFinalGantt
:=
tempoFinalGantt;
Self.FUT
:=
UT;
Self.FUTAux
:=
UTAux;
Self.FLimitePrioridade
:=
LimitePrioridade;
end;
{destructor TProcesso.Destroy;
begin
inherited Destroy;
end;
destructor TCPU.Destroy;
begin
inherited Destroy;
end;
destructor TDisco.Destroy;
begin
inherited Destroy;
end;
destructor TSistema.Destroy;
begin
inherited Destroy;
end;
}
{**************CLASSE CPU**************}
procedure TCPU.incrementaTempoDecorrido;
begin
FtempoDecorrido := tempoDecorrido + 1;
end;
function TCPU.removeProcessoExecutando: Tprocesso;
begin
ocupado
:= 0;
tempoDecorrido
:= 0;
result
:= processoExecutando;
end;
procedure TCPU.insereProcessoExecutando(processo:Tprocesso);
begin
ocupado
:= 1;
tempoDecorrido
:= 0;
processoExecutando
:= processo;
69
end;
function TCPU.Gocupado:integer;
begin
result := Self.FOcupado;
end;
procedure TCPU.Socupado(valor:integer);
begin
Self.Focupado := valor - 1;
end;
function TCPU.GtempoDecorrido:integer;
begin
result := Self.FtempoDecorrido;
end;
procedure TCPU.StempoDecorrido(valor:integer);
begin
Self.FtempoDecorrido := valor - 1;
end;
function TCPU.GProcessoExecutando:Tprocesso;
begin
result := Self.FProcessoExecutando;
end;
procedure TCPU.SProcessoExecutando(valor:Tprocesso);
begin
Self.FProcessoExecutando := valor;
end;
{*************CLASSE PROCESSO************}
function TProcesso.GTempoProcessador:integer;
begin
result := Self.FTempoProcessador;
end;
procedure TProcesso.STempoProcessador(valor:integer);
begin
Self.FTempoProcessador := FTempoProcessador - valor;
end;
function TProcesso.Gcor:Tcolor;
begin
result := Self.Fcor;
end;
procedure TProcesso.Scor(valor:Tcolor);
begin
Self.Fcor := valor;
end;
function TProcesso.Gpid:integer;
begin
result := Self.Fpid;
end;
procedure TProcesso.Spid(valor:integer);
begin
Self.Fpid := valor;
end;
function TProcesso.GtempoExecucao:integer;
begin
result := Self.FtempoExecucao;
end;
70
procedure TProcesso.StempoExecucao(valor:integer);
begin
Self.FtempoExecucao := FtempoExecucao - valor;
end;
function TProcesso.GtempoTurnaround:integer;
begin
result := Self.FtempoTurnaround;
end;
procedure TProcesso.StempoTurnaround(valor:integer);
begin
Self.FtempoTurnaround := Self.FtempoTurnaround + valor;
end;
function TProcesso.GtempoEsperaProcesso:integer;
begin
result := Self.FtempoEsperaProcesso;
end;
procedure TProcesso.StempoEsperaProcesso(valor:integer);
begin
Self.FtempoEsperaProcesso := FtempoEsperaProcesso + valor;
end;
function TProcesso.Gporcentagem:integer;
begin
result := Self.Fporcentagem;
end;
procedure TProcesso.Sporcentagem(valor:integer);
begin
Self.Fporcentagem := valor;
end;
function TProcesso.Gtipo:string;
begin
result := Self.Ftipo;
end;
procedure TProcesso.Stipo(valor:string);
begin
Self.Ftipo := valor;
end;
function TProcesso.Gprioridade:integer;
begin
result := Self.Fprioridade;
end;
procedure TProcesso.Sprioridade(valor:integer);
begin
Self.Fprioridade := valor;
end;
{************* CLASSE SISTEMA **************}
function TSistema.GfatiaTempoSistema:integer;
begin
result := Self.FfatiaTempoSistema;
end;
procedure TSistema.SfatiaTempoSistema(valor:integer);
begin
Self.FfatiaTempoSistema := valor;
end;
function TSistema.GtempoDecorridoSistema:integer;
begin
result := Self.FtempoDecorridoSistema;
end;
71
procedure TSistema.StempoDecorridoSistema(valor:integer);
begin
Self.FtempoDecorridoSistema := Self.FtempoDecorridoSistema + valor;
end;
function TSistema.GtempoAcessoDisco:integer;
begin
result := Self.FtempoAcessoDisco;
end;
procedure TSistema.StempoAcessoDisco(valor:integer);
begin
Self.FtempoAcessoDisco := valor;
end;
function TSistema.GtempoAcessoUSBFlash:integer;
begin
result := Self.FtempoAcessoUSBFlash;
end;
procedure TSistema.StempoAcessoUSBFlash(valor:integer);
begin
Self.FtempoAcessoUSBFlash := valor;
end;
function TSistema.GtempoAcessoCD:integer;
begin
result := Self.FtempoAcessoCD;
end;
procedure TSistema.StempoAcessoCD(valor:integer);
begin
Self.FtempoAcessoCD := valor;
end;
function TSistema.GtempoClock:integer;
begin
result := Self.FtempoClock;
end;
procedure TSistema.StempoClock (valor:integer);
begin
Self.FtempoClock := valor;
end;
function TSistema.GtempoThroughput:integer;
begin
result := Self.FtempoThroughput;
end;
procedure TSistema.StempoThroughput(valor:integer);
begin
Self.FtempoThroughput := FtempoThroughput + valor;
end;
function TSistema.GtempoInicialGantt:integer;
begin
result := Self.FtempoInicialGantt;
end;
procedure TSistema.StempoInicialGantt(valor:integer);
begin
Self.FtempoInicialGantt := FtempoInicialGantt + valor;
end;
function TSistema.GtempoFinalGantt:integer;
begin
result := Self.FtempoFinalGantt;
72
end;
procedure TSistema.StempoFinalGantt(valor:integer);
begin
Self.FtempoFinalGantt := FtempoFinalGantt + valor;
end;
function TSistema.GUT:integer;
begin
result := Self.FUT;
end;
procedure TSistema.SUT(valor:integer);
begin
Self.FUT := FUT + valor;
end;
function TSistema.GUTAux:string;
begin
result := Self.FUTAux;
end;
procedure TSistema.SUTAux(valor:string);
begin
Self.FUTAux := FUTAux + valor + '+';
end;
function TSistema.GLimitePrioridade:integer;
begin
result := Self.FLimitePrioridade;
end;
procedure TSistema.SLimitePrioridade(valor:integer);
begin
Self.FLimitePrioridade := FLimitePrioridade + valor;
end;
function TSistema.GtempoMedioTurnaround:integer;
begin
result := Self.FtempoMedioTurnaround;
end;
procedure TSistema.StempoMedioTurnaround(valor:integer);
begin
Self.FtempoMedioTurnaround := FtempoMedioTurnaround + valor;
end;
function TSistema.GCalculaUnidadeTempo:string;
begin
result := Self.FCalculaUnidadeTempo;
end;
procedure TSistema.SCalculaUnidadeTempo(valor:string);
var count, i, j:integer;
VUT: string;
vUTAux: string;
begin
vUTAux := Copy(valor,1, count-1);
j := length(Copy(valor,1, count-1));
count := j;
for i := 1 to j do
begin
VUT := Copy(vUTAux, count,1);
dec(count);
if VUT = '+' then break;
end;
VUT := Copy(vUTAux,1,count);
Self.FCalculaUnidadeTempo
end;
:= VUT;
73
{********** CLASSE DISCO **********}
function TDisco.Gocupado:integer;
begin
result := Self.Focupado;
end;
procedure TDisco.Socupado(valor:integer);
begin
Self.Focupado := valor;
end;
function TDisco.GtempoEsperado:integer;
begin
result := Self.FtempoEsperado;
end;
procedure TDisco.StempoEsperado(valor:integer);
begin
Self.FtempoEsperado := valor;
end;
function TDisco.GtempoDecorrido:integer;
begin
result := Self.FtempoDecorrido;
end;
procedure TDisco.StempoDecorrido(valor:integer);
begin
Self.FtempoDecorrido := Self.FtempoDecorrido + valor;
end;
function TDisco.GtempoIO:integer;
begin
result := Self.FtempoIO;
end;
procedure TDisco.StempoIO(valor:integer);
begin
FtempoIO := valor;
end;
function TDisco.GProcessoIO:Tprocesso;
begin
result := Self.FProcessoIO;
end;
procedure TDisco.SProcessoIO(valor:Tprocesso);
begin
Self.FProcessoIO := valor;
end;
procedure TForm7.BitBtn1Click(Sender: TObject);
begin
Tsistema(S).SfatiaTempoSistema(SpinEdit2.Value);
Tsistema(S).StempoClock(SpinEdit6.Value);
TSistema(S).StempoAcessoDisco(SpinEdit7.Value);
TSistema(S).StempoAcessoCD(SpinEdit9.Value);
TSistema(S).StempoAcessoDisco(SpinEdit10.Value);
TDisco(D).StempoIO(SpinEdit8.Value);
TSistema(S).SLimitePrioridade(SpinEdit1.Value);
Form3.SpinEdit1.MaxValue := Form7.SpinEdit1.Value ;
Application.MessageBox('Opera磯
Sucesso!','Aviso',mb_Ok+mb_IconExclamation);
end;
Realizada
com
procedure TForm7.BitBtn2Click(Sender: TObject);
74
begin
close;
end;
function TForm7.Calculate(SMyExpression: string; digits: Byte): string;
//
Calculate
a
simple
expression.
Supported
are:
http://www.swissdelphicenter.ch/en/showcode.php?id=470
var
z: Char;
ipos: Integer;
Real
Numbers,
parenthesis.
function StrToReal(chaine: string): Real;
var
r: Real;
Pos: Integer;
begin
Val(chaine, r, Pos);
if Pos > 0 then Val(Copy(chaine, 1, Pos - 1), r, Pos);
Result := r;
end;
function RealToStr(inreal: Extended; digits: Byte): string;
var
S: string;
begin
Str(inreal: 0: digits, S);
realToStr := S;
end;
procedure NextChar;
var
s: string;
begin
if ipos > Length(SMyExpression) then
begin
z := #9;
Exit;
end
else
begin
s := Copy(SMyExpression, ipos, 1);
z := s[1];
Inc(ipos);
end;
if z = ' ' then nextchar;
end;
function Expression: Real;
var
w: Real;
function Factor: Real;
var
ws: string;
begin
Nextchar;
if z in ['0'..'9'] then
begin
ws := '';
repeat
ws := ws + z;
nextchar
until not (z in ['0'..'9', '.']);
Factor := StrToReal(ws);
end
else if z = '(' then
begin
Factor := Expression;
nextchar
75
end
else if z = '+' then Factor := +Factor
else if Z = '-' then Factor := -Factor;
end;
function Term: Real;
var
W: Real;
begin
W := Factor;
while Z in ['*', '/'] do
if z = '*' then w := w * Factor
else
w := w / Factor;
Term := w;
end;
begin
w := term;
while z in ['+', '-'] do
if z = '+' then w := w + term
else
w := w - term;
Expression := w;
end;
begin
ipos
:= 1;
Result := RealToStr(Expression, digits);
end;
procedure TForm7.FormCreate(Sender: TObject);
begin
SpinEdit2.Value
SpinEdit6.Value
SpinEdit7.Value
SpinEdit9.Value
SpinEdit10.Value
SpinEdit8.Value
SpinEdit1.Value
:=
:=
:=
:=
:=
:=
:=
Tsistema(S).GfatiaTempoSistema;
Tsistema(S).GtempoClock;
TSistema(S).GtempoAcessoDisco;
TSistema(S).GtempoAcessoCD;
TSistema(S).GtempoAcessoUSBFlash;
TDisco(D).GtempoIO;
TSistema(S).GLimitePrioridade;
end;
procedure TForm7.BitBtn5Click(Sender: TObject);
begin
close;
end;
end.
76
ANEXO II – CÓDIGO-FONTE DO COMPONENTE DE CORES DOS PROCESSOS
colorbox1.AddItem('clBackground',TObject(clBackground));
colorbox1.AddItem('clMaroon', TObject(clMaroon));
colorbox1.AddItem('Chocolate',TObject(clWebChocolate));
colorbox1.AddItem('Peru',TObject(clWebPeru));
colorbox1.AddItem('Ouro-Escuro (rod)',TObject(clWebDarkGoldenRod));
colorbox1.AddItem('RosyBrown',TObject(clWebRosyBrown));
colorbox1.AddItem('Azul-Royal',TObject(clWebRoyalBlue));
colorbox1.AddItem('Azul-Ardósia Médio',TObject(clWebMediumSlateBlue));
colorbox1.AddItem('clblue', TObject(TColor(clblue)));
colorbox1.AddItem('Azul CornFlower',TObject(clWebCornFlowerBlue));
colorbox1.AddItem('Azul Dodger',TObject(clWebDodgerBlue));
colorbox1.AddItem('Azul-Petroleo',TObject(clActiveCaption));
colorbox1.AddItem('Céu-Azul Profundo',TObject(clWebDeepskyBlue));
colorbox1.AddItem('Azul-Celeste',TObject(clSkyBlue));
colorbox1.AddItem('Azul-Claro',TObject(ClAqua));
colorbox1.AddItem('Ciano Claro',TObject(clWebLightCyan));
colorbox1.AddItem('Azure',TObject(clWebAzure));
colorbox1.AddItem('Azul Água-Marinho',TObject(clWebAquamarine));
colorbox1.AddItem('Turquesa Pálido',TObject(clWebPaleTurquoise));
colorbox1.AddItem('Azul LightSteel',TObject(clWebLightSteelBlue));
colorbox1.AddItem('Turquesa',TObject(clWebTurquoise));
colorbox1.AddItem('Turquesa Escuro',TObject(clWebDarkTurquoise));
colorbox1.AddItem('Azul Cadet',TObject(clWebCadetBlue));
colorbox1.AddItem('Ciano Escuro',TObject(clWebDarkCyan));
colorbox1.AddItem('Água-Marinho Médio',TObject(clWebMediumAquamarine));
colorbox1.AddItem('Azul-Esverdeada (Teal)',TObject(clTeal));
colorbox1.AddItem('Verde-Mar',TObject(clWebSeaGreen));
colorbox1.AddItem('Verde-Oliva Escuro',TObject(clWebDarkOliveGreen));
colorbox1.AddItem('Verde-Floresta',TObject(clWebForestGreen));
colorbox1.AddItem('Verde',TObject(clGreen));
colorbox1.AddItem('Verde-Oliva',TObject(clOlive));
colorbox1.AddItem('Verde Oliva Monótono',TObject(clWebOliveDrab));
colorbox1.AddItem('Verde Escuro',TObject(clWebLimeGreen));
colorbox1.AddItem('Verde-Mar Médio',TObject(clWebMediumSeaGreen));
colorbox1.AddItem('Verde-Mar Light',TObject(clWebLightSeaGreen));
colorbox1.AddItem('Verde-Mar Escuro',TObject(clWebDarkSeaGreen));
colorbox1.AddItem('Verde-Claro',TObject(clWebLightGreen));
colorbox1.AddItem('Verde-Primavera Médio',TObject(clWebMediumSpringGreen));
colorbox1.AddItem('Verde-Claro',TObject(clWebLightgrey));
colorbox1.AddItem('Verde Dinheiro',TObject(clMoneyGreen));
colorbox1.AddItem('Verde-Amarelo',TObject(clWebGreenYellow));
colorbox1.AddItem('Verde-Limão',TObject(clLime));
colorbox1.AddItem('Verde-Primavera',TObject(clWebSpringGreen));
colorbox1.AddItem('Vermelho Escuro',TObject(clWebDarkRed));
colorbox1.AddItem('Violeta-Vermelho Médio',TObject(clWebMediumVioletRed));
colorbox1.AddItem('Violeta-Vermelho Pálido',TObject(clWebPaleVioletRed));
colorbox1.AddItem('Vermelho Carmesim',TObject(clWebCrimson));
colorbox1.AddItem('Firebrick',TObject(clWebFirebrick));
colorbox1.AddItem('Vermelho Indiano',TObject(clWebIndianRed));
colorbox1.AddItem('Siena',TObject(clWebSienna));
colorbox1.AddItem('Vermelho',TObject(clRed));
77
colorbox1.AddItem('Laranja-Vermelho',TObject(clWebOrangeRed));
colorbox1.AddItem('Vermelho Tomate',TObject(clWebTomato));
colorbox1.AddItem('Salmão Escuro',TObject(clWebDarkSalmon));
colorbox1.AddItem('Salmão',TObject(clWebLightSalmon));
colorbox1.AddItem('Laranja-Escuro',TObject(clWebDarkOrange));
colorbox1.AddItem('Laranja',TObject(clWebOrange));
colorbox1.AddItem('Ouro',TObject(clWebGold));
colorbox1.AddItem('Amarelo',TObject(clYellow));
colorbox1.AddItem('Caqui Escuro',TObject(clWebDarkKhaki));
colorbox1.AddItem('Ouro Rod',TObject(clWebGoldenRod));
colorbox1.AddItem('Caqui',TObject(clWebKhaki));
colorbox1.AddItem('Ouro (Palerod)',TObject(clWebPaleGoldenrod));
colorbox1.AddItem('Ouro-Claro (rodYellow)',TObject(clWebLightGoldenrodYellow));
colorbox1.AddItem('Creme',TObject(clCream));
colorbox1.AddItem('LightCoral',TObject(clWebLightCoral));
colorbox1.AddItem('Rosa-Pink Profundo',TObject(clWebDeepPink));
colorbox1.AddItem('Rosa-Pink Quente',TObject(clWebHotPink));
colorbox1.AddItem('Rosa-Pink',TObject(clWebPink));
colorbox1.AddItem('Rosa-Pink Claro',TObject(clWebLightPink));
colorbox1.AddItem('Rosa Enevoado',TObject(clWebMistyRose));
colorbox1.AddItem('Magenta Escuro',TObject(clWebDarkMagenta));
colorbox1.AddItem('Purpura',TObject(clPurple));
colorbox1.AddItem('Violeta Escuro',TObject(clWebDarkViolet));
colorbox1.AddItem('Violeta Azul',TObject(clWebBlueViolet));
colorbox1.AddItem('Orquídea Escuro',TObject(clWebDarkOrchid));
colorbox1.AddItem('Orquídea Médio',TObject(clWebMediumOrchid));
colorbox1.AddItem('Orquídea',TObject(clWebOrchid));
colorbox1.AddItem('Lilás',TObject(clFuchsia));
colorbox1.AddItem('Violeta',TObject(clWebViolet));
colorbox1.AddItem('Ameixa',TObject(clWebPlum));
colorbox1.AddItem('Cardo',TObject(clWebThistle));
colorbox1.AddItem('Lavanda',TObject(clWebLavender));
78