EKSMIPS: Um Simulador para o Processador MIPS

EKSMIPS: Um Simulador para o Processador MIPS
Elder E. Schemberger1, Kenzo Araujo2, Sidgley C. Andrade3
Departamento de Informática – Universidade Estadual de Maringá (UEM)
CEP 87020-900 – Maringá – PR – Brasil
{1elderes, 2k34z00, 3sidgley}@gmail.com
Abstract. Simulators may be used in several areas of knowledge in order to facilitate
the use of processes which depend on different nested aspects. In the context of
Computer Architecture, simulators are important tools to reinforce learning about the
behavior of real system, to predict error occurrence, and to manipulate specific details
and others. In order to study the processors, there are several simulators in the
literature, from Von Neumann’s architecture model to RISC architecture. This paper
shows a simulator which represents the functionality of MIPS R2000/R3000 (RISC),
and the execution of detailed instructions aimed at facilitating the understanding of its
functionality.
Resumo. Simuladores podem ser usados em diversas áreas do conhecimento, a fim de
facilitar o entendimento de processos que dependem de vários aspectos aninhados. No
contexto de Arquitetura de Computadores, simuladores são ferramentas importantes
para reforçar a aprendizagem sobre o comportamento de um sistema real, prever a
ocorrência de erros, manipular detalhes específicos e afins. Para o estudo de
processadores, há diversos simuladores propostos na literatura, que abordam desde o
modelo da arquitetura de Von Neumann até a arquitetura RISC. Este artigo apresenta
um simulador que representa o funcionamento do processador MIPS R2000/R3000
(RISC), tornando possível visualizar a execução de instruções de maneira detalhada
objetivando facilitar o entendimento do funcionamento das mesmas.
Palavras Chaves: Simulador, Processador, MIPS, RISC.
1. Introdução
Simuladores podem ser usados em diversas áreas do conhecimento como Física, Biologia,
Engenharias, Matemática, entre outras. No contexto de Ciência da Computação há vários
simuladores usados para auxiliar o ensino de conteúdos em disciplinas específicas, haja vista que
na maioria das vezes se trabalha com objetivos não palpáveis, como algoritmos, matemática
computacional, modelagens, e afins.
Especificamente na disciplina de Arquitetura de Computadores, o uso de simuladores é
bastante utilizado para aperfeiçoar o aprendizado acerca de processadores, fornecendo maiores
detalhes do funcionamento dos mesmos no que tange o tipo de instruções e/ou como elas são
executadas, por exemplo.
Os simuladores também propiciam um ambiente mais conveniente do que uma máquina
real. Através deles é possível verificar a existência de erros e prever a necessidade de mudanças,
podendo realizá-las com muito mais facilidade, uma vez que o projeto é construído primeiro no
simulador e não fisicamente. Deste modo é permitida a adição de novas instruções, novas
características, ou simplesmente a coleta de dados estatísticos para uma melhor análise do
funcionamento do processador [4].
Este artigo apresenta uma proposta de simulador para a arquitetura MIPS, o EKSMIPS.
MIPS é bastante utilizado para estudo da arquitetura de processadores por ser de notória
simplicidade e clareza [7]. É a arquitetura base para construção de vários simuladores, a saber:
R10k, ProcSIM, WinMIPS, MARS, WebSimple, SPIM, SimDE, entre outros. Alguns destes
simuladores serão descritos na Seção 3.
A Seção 2 apresenta a arquitetura MIPS, sua evolução e principais características. Na
Seção 3 são relacionados alguns trabalhos correlatos ao tema abordado, mostrando
características e funcionalidades de simuladores que também abordam a arquitetura MIPS. O
simulador proposto é apresentado na Seção 4, onde é detalhado suas características,
funcionamento e demais considerações sobre o projeto. A Seção 5 traz as considerações finais e
a proposição de trabalhos futuros.
2. O Processador MIPS
O MIPS nasceu nos anos 80 a partir de um trabalho realizado por John Hennessy, na
Universidade de Stanford. O trabalho tinha como objetivo explorar o padrão RISC (Reduced
Instruction Set Computing), e é ainda considerado o mais elegante neste contexto. O conceito
introduzido por Hennessy foi tão bem sucedido que em 1984 foi formada a MIPS Technologies,
Inc, a fim de comercializar os microprocessadores MIPS, que conseguem estar entre os mais
eficientes a cada geração, mesmo permanecendo entre os mais simples.
MIPS segue a arquitetura RISC com um número limitado de formatos de instrução, todas
com o mesmo tamanho. Tem 32 registradores de propósito geral que comportam palavras de 32
bits cada [7][8][9].
Há vários modelos do MIPS que serão descritos na Subseção 2.1. Neste artigo, o
processador tomado como base para o projeto do simulador foi o MIPS R2000/R3000, descrito
por Patterson e Hennessy [4].
2.1 Traço Superficial da Evolução do MIPS
Como supracitado, o projeto do MIPS foi tão bem sucedido na Universidade que se decidiu
comercializá-lo. Na segunda metade da década de 1980 o R2000 surgiu no mercado com a MIPS
Technologies, Inc.
O R3000, próximo na sucessão, se aproveitou de um processo de fabricação mais
avançado, juntamente com algumas melhorias de hardware, que combinados deram um impulso
considerável ao desempenho. Do ponto de vista do programador, o R3000 era quase
indistinguível do R2000. No início dos anos 90, já se usava o R3000 em aplicações embarcadas,
como impressoras a laser de alto desempenho e equipamentos de editoração [6].
Em 1991 chegou ao mercado o R4000, um projeto corajoso e inovador. Incluía um
conjunto de instruções de 64 bits, cache interna de 8 KB, um clock inimaginável para a época
(100 MHz), e suporte a memória compartilhada. Foi um projeto ambicioso, mas se comparado
com o R3000, precisava de mais ciclos de clock para executar uma determinada seqüência de
instruções. O R4000 tem um pipeline mais longo, o que o torna menos eficiente [8].
Outra versão do MIPS a se destacar foi o R10000, lançado no início de 1996. Foi o
primeiro a de fato implementar a execução fora de ordem. Há ainda várias outras versões do
MIPS, conforme a Tabela 1 apresenta, na forma de uma linha cronológica com algumas
características marcantes.
Tabela 1. Modelos e características da evolução do MIPS.
Modelo Freqüência (MHz) Ano Transistores (Milhões) R2000 8 – 16.67 1985 0,11 R3000
12–40 1988 0,11 R4000 100 1991 1,35 R4400 100–250
1992
2,3
R4600 100–133
1994
2,2
R4700 133 1996 ‐ R5000 150–200 1996 3.7 R8000 75–90
1994
2.6
R10000 150–250 1996 6.7 R12000 270–400 1998 6.9 R14000 500–600 2001 7.2 R16000 700–1000 2002 ‐ R24K 750+ 2003 ‐ MIPS 34K 750+ 2005 ‐ 2.2 Características
Esta subseção apresenta algumas características dos processadores MIPS, que servem de base
para a implementação do simulador proposto na Seção 4.
2.2.1 Pipeline
A arquitetura MIPS pode trabalhar com pipeline. Esta é dividida em cinco estágios, cada um
tendo uma faixa fixa de tempo, que geralmente é um ciclo de clock do processador (apesar de
que algumas ações têm somente meio clock, de modo que o pipeline MIPS de cinco estágios use
de fato 4 ciclos) [6]. A Figura 1 apresenta uma ilustração padrão dos estágios da pipeline do
MIPS:
Figura 1. Os Cinco estágios do pipeline do MIPS [6].
Cada etapa pode ser resumida conforme o que segue:
• IF: Obtém a próxima instrução a partir da cache de instrução (I-cache);
• RD: Obtém o conteúdo dos registradores;
• ALU: Realiza uma operação aritmética ou lógica em um ciclo de clock;
• MEM: É a fase em que a instrução pode ler/escrever na cache de dados (Dcache);
• WB: Armazena o valor obtido a partir de uma operação no arquivo de registro;
2.2.2 Instruções
Existem várias características/restrições no que tange as instruções da arquitetura MIPS. Uma
delas, por exemplo, é que todas as instruções têm 32 bits, ou seja, nenhuma instrução usa apenas
dois ou três bytes de memória e nenhuma instrução pode ser maior do que 4 bytes.
As instruções MIPS podem ser classificadas em quatro grupos, conforme descrito abaixo
[4][3][6]:
• R-Type: Grupo que contém todas as instruções que não requerem um valor
imediato, deslocamento de endereço de memória, ou endereço de memória para
especificar um operando. Isto inclui a aritmética e lógica, com todos os operandos
em registros, instruções de deslocamento e instruções de salto. Todas as
instruções R-Type usam opcode 000000, e têm o seguinte formato:
opcode (6) rs (5) rt (5) rd (5)
shamt (5) function (6)
Onde:
o Opcode: 000000;
o rs: Registrador com o primeiro operando fonte;
o rt: Registrador como segundo operando fonte;
o rd: registrador destino;
o shamt: campo para o deslocamento;
o function: código de função. É associado ao opcode.
• I-Type: Grupo que contem as instruções com um operando imediato. Com
exceção dos opcodes 000000, 0100xx e 00001x, todos os outros são usados por
instruções I-Type. As instruções deste grupo têm o seguinte formato (onde os
campos têm o mesmo significado listado no tópico acima):
opcode (6) rs (5) rt (5)
Imediado (16)
• J-Type: Grupo composto por duas instruções de salto direto (j e jal). Estas
instruções requerem um endereço de memória para especificar seus operandos.
Usam o opcode 00001x. Instruções deste grupo tem o seguinte formato (os
campos têm os mesmos significados listados no tópico R-Type):
opcode (6)
Alvo (26)
• Coprocessor Instructions: Todos os processadores MIPS tem dois coprocessadores padrão, CP0 e CP1. CP0 é para processos de vários tipos de
exceções. O CP1 é um processador de ponto flutuante. Todas as instruções de uso
do co-processador usam o opcode 0100xx.
Na Seção 4 onde o Simulador proposto é apresentado, serão listadas as instruções
implementadas, enquadrando-as nos respectivos grupos conforme apresentados nesta seção.
2.2.3 Endereçamento e Acesso à Memória
Sistemas baseados no processador MIPS dividem a memória em três partes, conforme ilustra a
Figura 2. Tal convenção não é imposição ou limitação do hardware, e sim uma convenção a fim
de permitir que programas e ferramentas diferentes possam trabalhar em um formato padrão
[4][8].
Figura 2: Estrutura da memória do MIPS.
A primeira parte, que inicia em 40000016 (4194304 em decimal) é o segmento de
instruções, trecho de memória onde são alocadas as instruções do programa.
A seção intermediária, iniciada em 1000000016 (268435456 em decimal) é o segmento de
dados, que por sua vez é seccionado em dois: A primeira secção contém todos os objetos cujo
tamanho é conhecido em tempo de compilação e que devem existir durante a execução do
programa (dados estáticos). Imediatamente acima desta seção ficam os dados dinâmicos, isto é,
aqueles que são alocados durante a execução do programa. Esta seção é gerenciada pelo Sistema
Operacional e pode ser expandida [4].
A terceira parte é o segmento da pilha, que reside no topo do espaço de endereçamento a
partir de 7FFFFFFF16 (2147483647 em decimal), e cresce na direção de endereços abaixo [9].
Algumas outras características podem ser destacadas, entre elas:
• A memória é byte-endereçada: Quando os dados são de um registro de
processador MIPS, todas as operações trabalham no registro inteiro, mesmo não o
ocupando todo;
• Carregar/Armazenar devem ser alinhados: Operações de memória só podem
carregar ou armazenar dados de endereços alinhados para se adequar ao tipo de
dados a ser transferido;
• Saltar instruções: O tamanho das instruções de 32 bits pode ser um problema. O
opcode menor em uma instrução MIPS é de 6 bits, deixando 26 bits para definir o
destino de um salto. Uma vez que todas as instruções são quatro bytes alinhados
na memória, os dois bits de endereço menos significativos necessariamente não
podem ser armazenados, permitindo um intervalo de endereços de 228 = 256 MB,
o que pode ser um problema, dependendo do tamanho do programa.
2.2.4 Registradores
A fim de padronizar, há uma convenção para os nomes dos registradores do MIPS. A Tabela 2
apresenta estes nomes relacionados ao número e à função do registrador [7].
Tabela 2. Relação Número/Nome/Função dos Registradores do MIPS.
Número do Registrador Nome Usado para zero
0 Sempre retorna 0 at
1 (assembly temporary) Reservado para o assembly v0,
v1
2‐3 Receber o valor retornado por subrotinas a0 – a3 (arguments) Parâmetros para subrotinas 4‐7 t0 – t7
8‐15 (temporaries) Para ser usado pelas subrotinas t8, t9
24, 25 s0 – s7 Registro de variáveis das subrotinas 16‐23 26, 27 28 29 30 31 k0, k1
gp
sp
s8/fp
ra
Reservado para ser usado por interrupções do SO (global pointer) Apontador de área global (stack pointer) (frame pointer) Registrador de endereço de retorno Conforme é possível observar na Tabela 2, existem 32 registradores, cada um deles
contendo 32 bits (para o R2000/R3000, especificamente).
Há ainda os registradores especiais, por exemplo: HI e LO. Na arquitetura MIPS a
instrução de multiplicação, por exemplo, tem seu resultado distribuído entre os registradores HI
e LO, onde os bits mais significativos do resultado são armazenados no registrador HI e os bits
menos significativos são alocados no registrador LO [3].
3. Trabalhos relacionados
Esta seção apresenta alguns trabalhos correlatos ao tema abordado, ou seja, outros simuladores
para o processador MIPS.
3.1 MARS (MIPS Assembly and Runtime Simulator)
O MARS (MIPS Assembly and Runtime Simulator) foi desenvolvido em JAVA (J2SE Runtime
Environment) com a IDE gráfica implementada usando Swing. Inicialmente foi desenvolvido
pelo professor Ph.D. Kenneth R. Vollmar (Universidade Estadual de Missouri), e teve sua
continuidade dada pelo professor Dr. Peter Sanderson (Faculdade Otterbein de Westerville). Foi
apresentado em 2005 em formato de painel, no evento Technical Symposium on Cmputer
Science Education – SIGCSE [2].
A versão atual é a 3.8, lançada em Janeiro de 2010, e apresenta algumas melhorias e
correções das versões anteriores. Está disponível para download em sua home page1, onde
também há instruções para sua configuração e execução. Tem como requisito apenas o JRE 1.4
(ou superior). A Figura 3 apresenta uma screenshot do simulador ao final da execução do
algoritmo de Fibonacci.
Figura 3. Screenshot da IDE MARS 3.8 após execução das instruções do algoritmo Fibonacci.
1
Home Page do MARS: http://courses.missouristate.edu/KenVollmar/MARS/
A IDE MARS 3.8 apresenta duas guias: Edit e Execute. Em Edit é possível editar os
comandos ou abrir um arquivo com as extensões *.asm ou *.s. Ao utilizar os comandos o
simulador carrega as instruções no segmento de texto (Text Segment), mostrando-as em decimal
ou hexadecimal e mnemônico no segmento de dados (Data Segment). Os registradores podem
ser visualizados em hexadecimal ou decimal e podem ser alterados, mesmo durante a execução
de um programa (o que ocorre na guia Execute).
Além da execução do programa todo de uma vez, é permitido a execução passo a passo.
As mensagens sobre a execução do programa e seu resultado podem ser visualizadas na parte
inferior da janela nas guias Mars Messages e Run I/O.
Além destes recursos, há outras funcionalidades extras no MARS. Algumas delas são:
• Branch History Table Simulator: Tabela que apresenta o histórico dos desvios que
ocorreram;
• Data Cache Simulation Tool: Apresenta o desempenho dos dados em cache em
forma de ilustração e simulação;
• Floating Point Representation: Representação de ponto flutuante em 32-bit IEEE
754.
• Instruction Counter: Conta o número de instruções executadas por tipo (R, I e J);
• Instruction Statistics: Estatística das instruções ALU, Jump, Branch, Memory e
Other;
• Screen Magnifer: Captura a tela de execução;
• Memory Reference Visualization: Permite visualizar as referências à memória de
forma gráfica.
3.2 ProcSim (Processor Simulator)
O simulador ProcSim (Processor Simulator) foi desenvolvido por James M. Garton para uma
dissertação de mestrado na Universidade de Leicester (Reino Unido) no ano de 2005. Foi
codificado em JAVA, e simula o Processador MIPS R2000 [5].
Ao executar o simulador é possível visualizar o datapath do processador e a dinâmica
dos dados. É possível identificar a funcionalidade de cada componente.
Para visualizar a execução das instruções de um “modo animado”, o ProcSim necessita
de um arquivo *.xml, contendo os detalhes dos componentes para a interatividade das
animações. Ao carregar o arquivo, o simulador apresenta um conjunto de diagramas, ilustrando
os caminhos de cada execução, conforme apresentado na Figura 4.
O ProcSim oferece a possibilidade de executar arquivos no formato *.asm (assembly),
*.sim (ProcSim), e *.xml. Para carregar um arquivo, o simulador mostra-se bastante intuitivo,
bastando seguir o “caminho tradicional”: File; Open Sim ou Open Assembly.
A versão atual do ProcSim é a 2.0 e está disponível para download no site do projeto2.
Está também disponível a documentação para a configuração e execução do simulador, além de
alguns exemplos implementados para análise.
As restrições existentes para o simulador ProcSim são:
• Sistema operacional Windows 95/XP/Vista/7 ou qualquer distribuição Linux;
• Processador com no mínimo de 1Ghz;
• Java (JRE) 1.5 ou superior;
E recomenda-se que a resolução da tela seja pelo menos 1024x768 ou, para uma melhor
visualização 1280x1024.
2
Home Page do ProcSim http://jamesgart.com/procsim.
Figura 4. Screenshot do simulador ProcSim após execução das instruções de um algoritmo com
algumas funções aritméticas.
3.3 R10k
O simulador R10k é baseado no funcionamento do processador MIPS R10000, e foi
implementado utilizando a linguagem Delphi em 2007 pelos acadêmicos Nelson Gonçalves Jr. e
Renata Lopes da Silva, e os professores João Angelo Martini e Ronaldo Gonçalves (DIN –
UEM3). O objetivo da implementação do simulador foi de oferecer suporte ao processo de
ensino-aprendizagem de processadores superescalares [1].
Ao executar instruções no simulador é possível acompanhar o comportamento do
processador através dos painéis que representam as entidades funcionais do processador. A
Figura 5 ilustra a execução de algumas instruções no simulador R10k, após o 7º ciclo.
Entre as funcionalidades exibidas na interface do R10k é possível destacar os seguintes
painéis:
• Memória: É representada a memória de instruções, de dados e a pilha do
processador MIPS R10000;
• Busca: Mostra a fila de instruções (instruções trazidas da memória). Possui
capacidade para armazenar até oito instruções;
• Decodificação: Apresenta as instruções que estão sendo executadas.
• Registradores Especiais: O PC (Program Counter) indica o endereço da
próxima instrução a ser buscada na memória. O SP (Stack Pointer) que indica o
endereço do topo da pilha. O HI e LO são registradores utilizados para o
armazenamento de resultados de operações de multiplicação e divisão;
• Registradores: O simulador R10k possui 64 registradores de inteiros
(identificados pela letra S). Tem também outros 64 registradores para
representar ponto flutuante (identificados T). Tal identificação fica ao lado do
número do registrador;
• Remessa: Apresenta a fila de ponto flutuante, fila de endereços e fila de inteiros;
• Execução: Apresenta a dinâmica da execução de um código carregado para a
memória;
3
Departamento de Informática – Universidade Estadual de Maringá: http://din.uem.br/
•
Instruções Finalizadas: Traz para o usuário um histórico das instruções
executadas.
Figura 5. Screenshot do simulador R10k após execução de algumas instruções.
Ao executar testes no simulador R10k pode-se notar que este é de fácil utilização e
possui uma interface intuitiva, seja criando exemplos ou utilizando os disponíveis. O R10k está
disponível para download, mas não foi possível encontrar informações dos autores sobre
requisitos mínimos tanto de hardware e/ou software.
3.4 WebSimple - MIPS
O WebSimples-MIPS é um simulador do processador MIPS que apresenta uma interface
orientada ao aprendizado e possibilidade de execução via Web, visando a execução em vários
ambientes ou plataformas. Foi implementado na linguagem JAVA a fim de se tornar
independente de Sistema Operacional [10].
O projeto iniciou-se em 2008 na PUCMinas4 pelos acadêmicos Bruno de Sousa, Matheus
Moreira, Rafael Nogueira, Rodrigo Martins e o professor Carlos da Silva Martins. A Figura 6
ilustra o simulador WebSimple – MIPS após a execução de alguma instruções (lado esquerdo da
figura) e um relatório de tais funções executadas (lado direito da figura).
Figura 6. Screenshot do simulador WebSimple-MIPS após a execução de algumas instruções (lado
esquerdo) e do relatório da execução (lado direito).
4
Pontifícia Universidade Católica de Minas Gerais: http://www.pucminas.br//
O simulador WebSimple -MIPS apresenta uma interface dividida em quatro áreas e
permite ao usuário a configuração da simulação, a visualização do fluxo de instruções, a
visualização e edição do código Assembly e o controle da simulação. É possível determinar, por
exemplo, qual o tempo do ciclo do processador e a velocidade da simulação (escolhendo a
velocidade máxima de simulação, o relatório é gerado instantaneamente).
Os controles de simulação também permitem ao usuário a escolha entre simulação
automática ou passo a passo. Através do simulador, a partir do tempo de execução e da carga de
trabalho no processador com pipeline e no processador monociclo, pode ser calculado o speedup.
O simulador WebSimple-MIPS apresenta também, através do speedup, as vantagens de
se explorar o paralelismo fazendo uso de pipeline. Informações como essas que são apresentadas
no relatório permitem a uma análise detalhada do comportamento da técnica pipeline em
situações que ocorrem dependência de dados, por exemplo.
Este simulador está disponível no site do projeto5 tanto para download quanto para ser
executado através de um browser. Como requisito é necessário apenas uma máquina virtual
JAVA (para executar o aplicativo) ou o plugin equivalente para o navegador.
4. Simulador Proposto
Esta seção apresentada a proposta de um simulador para o processador MIPS: o EKSMIPS
R2000/R3000.
O propósito do simulador EKSMIPS é possibilitar a visualização da execução de algumas
instruções do processador MIPS, com direcionamento didático, a fim de facilitar o entendimento
do funcionamento do mesmo. As instruções implementadas e demais detalhes de funcionamento
do simulador são descritos nas subseções a seguir.
4.1 Características do Simulador Proposto
A linguagem de programação escolhida para implementar o simulador EKSMIPS foi Delphi.
Para melhor visualizar o conjunto de instruções e funcionalidades implementadas no
simulador há uma seção de ajuda, acessada facilmente pela interface, a fim de orientar os
alunos/usuários quanto aos detalhes das instruções, correlacionando-as com o funcionamento da
arquitetura MIPS.
A interface gráfica implementada, mostrada na Figura 7, apresenta em uma única tela
todos os campos para visualização do usuário, para que o processo de simulação possa ser
acompanhado por completo.
5
Projeto WebSimple-MIPS: http://201.17.130.17/matheus/simple/
Figura 7. Screenshot do simulador proposto com algumas instruções sendo executadas.
4.2 Funcionamento do Simulador Proposto
Para iniciar uma simulação no EKSMIPS deve-se importar um arquivo com extensão *.asm ou
*.txt contendo as instruções. É possível também adicionar direto pela interface as instruções com
os devidos parâmetros em termos de registradores e/ou valores.
Para inserir uma instrução, o EKSMIPS ajuda o usuário no sentido de listar todas
contempladas, para que não ocorra o constrangimento de ser adicionada uma instrução com
sintaxe incorreta ou que não esteja implementada pelo simulador. Como o propósito do
simulador é de auxílio didático, isso é de fundamental importância.
Se o usuário digitar um caractere inválido ao referenciar um registrador por exemplo, o
EKSMIPS informará ao usuário que tal instrução não pôde ser decodificada, indicando o local
do erro.
Depois de inseridas as instruções, o simulador possibilita a execução das mesmas passo a
passo ou de maneira automática, a fim de acompanhar o comportamento dos registradores,
memória, etc. A execução automática realiza ciclos de 200 milissegundos na configuração
padrão, tempo que pode ser editado pelo usuário.
Para facilitar a dinâmica das partes que compõem o processador, o simulador mostra a
visualização e a identificação dos tipos de instrução e como eles são decodificados,
desmembrando as instruções conforme a especificação do MIPS requer. Os opcodes e functions
são exibidos em hexadecimal. Para os registradores sempre é exibido o nome de cada um. Os
valores contidos nos registradores não são editáveis. Caso seja necessário realizar alguma
edição, esta deve ser feita através das instruções.
Ao encerrar a execução das instruções carregadas e/ou inseridas, é exibido na parte
inferior da interface gráfica o número de ciclos de instruções executadas e o conteúdo da
memória em ASCII.É possível também exportar as instruções inseridas (arquivo *.asm).
Outros detalhes do funcionamento do EKSMIPS são descritos no arquivo de ajuda.
4.3 Considerações sobre o projeto
Esta seção relaciona o funcionamento do simulador proposto com as convenções utilizadas pelo
processador MIPS.
4.3.1 Memória
A Subseção 2.2.3 abordou o funcionamento da memória em sistemas que se baseiam no
processador MIPS. O EKSMIPS foi implementado de acordo com tais convenções descritas
nesta subseção.
Com relação às características do simulador proposto, os endereços são mostrados em
hexadecimal a fim de familiarizar o aluno/usuário com esta notação. Já os dados são exibidos em
formato decimal.
Como o espaço de endereçamento é bastante grande para ser apresentado por inteiro, este
foi restringido, no entanto sem desrespeitar a convenção utilizada. Na interface são exibidos
desde 1000000016 até 100003AC16.
Outra característica do EKSMIPS é a apresentação do segmento de pilha separado do
segmento de memória, a fim de facilitar a localização dos endereçamentos entre os segmentos de
pilha e de dados.
4.3.2 Instruções
Foram implementadas 25 instruções para o EKSMIPS. As instruções implementadas podem ser
visualizadas na Tabela 3, separadas pelo tipo de cada (que foi descrito na Subseção 2.2.2). O
arquivo de ajuda detalha o funcionamento destas instruções de maneira individual.
Grupo
R-Type
I-Type
J-Type
Tabela 3. Operações implementadas pelo EKSMIPS.
Instruções Implementadas
ADD
ADDU
DIV
MULT
SUB
SUBU
AND
OR
XOR
SLT
SLTU
JR
ADDI
ADDIU
SW
LW
XORI
SLTI
SLTIU
BEQ
J
NOP
NOR
ORI
BNE
4.3.3 Overflow aritmético
O EKSMIPS faz o tratamento de overflow em algumas instruções aritméticas onde o MIPS
também realiza. Em valores que ultrapassam os 32 bits, o EKSMIPS apresenta uma mensagem
de erro. As instruções que podem gerar esse tipo de exceção são: ADD, SUB, MULT, DIV, SUBU,
OR, XOR, XORI e ORI.
As operações que executam cálculos verificam o overflow ao somar dois valores que o
resultado seja maior do que 32 bits. As operações lógicas tratam o overflow quando o valor deve
ser convertido para binário e também ultrapassa os 32 bits.
4.3.4 Posição inválida de memória
No processador MIPS, as palavras começam em endereços que sejam múltiplos de quatro. Esta
necessidade é chamada restrição de alinhamento, presente em muitas arquiteturas [4]
O simulador proposto faz o tratamento de referência inválida à memória, nas
instruções SW e LW que trazem endereços que não se encaixam no tamanho da palavra
manipulada pelo MIPS. Caso isso venha a ocorrer, é exibida uma mensagem ao usuário.
4.4 Testes de execução
Esta subseção apresenta alguns programas para testar a execução do EKSMIPS. Como
supracitado, para executá-los basta inserir as instruções manualmente via interface ou importar o
arquivo. A Tabela 4 está subdivida em 6 partes, contendo pequenos trechos de código que
podem ser usados como testes iniciais do simulador..
Tabela 4. Códigos para teste de execução do EKSMIPS.
(a) Contador (b) Violação do Segmento de Dados. ADDI $t1 $t1 10
ADDI $t8 $t0 0x10000001
ADDI $t9 $t8 1
ADDI $t2 $t0 65
ADD $t8 $t9 $t8
SW $t2 4($t8)
BEQ $t8 $t1 0
LW $t1 4($t8)
J 0x00400008
NOP
ADDI $t2 $t0 0x10000000
SW $t8 4($t2)
NOP
(c) Jump. ADDI $t8 $t2 10
ADD $t9 $t9 $t8
ADDI $t7 $t2 1
BEQ $t7 $t7 1
J 0x00400004
ADD $t9 $t9 $t8
NOP
(d) DIV. ADDI $t8 $t2 10
ADDI $t9 $t2 3
ADD $t7 $t8 $t9
DIV $t7 $t9
NOP
(e) XORI. ADDI $t9 $0 7
XORI $t2 $t9 1
NOP
(f) AND. ADDI $t8 $t2 3
ADDI $t9 $t2 1
AND $t2 $t9 $t8
NOP
Os códigos-testes exibidos na Tabela 4 servem de exemplos básicos de algumas das instruções
implementadas pelo EKSMIPS. O Código (a) executa um contador. O Código (b) demonstra um
conjunto de instruções que geram uma violação do segmento de dados. Este exemplo é
interessante de ser executado no simulador proposto para poder visualizar o tratamento que é
feito quando ocorre alguma infração. Em (c) e descrito um código que executa um salto. O
Código (d) apresenta um código que realiza uma divisão. Na parte (e) da tabela é exibido a
sintaxe e parâmetros da instrução XORI. E, finalmente em (f), um exemplo da instrução AND.
4.5 EKSMIPS e outros simuladores
Na Seção 3 foram detalhados quatro trabalhos referentes ao contexto deste: MARS, ProcSim,
R10k e WebSimple-MIPS.
O objetivo desta subseção é traçar um comparativo, em formato de tabela, das principais
características do simulador EKSMIPS com tais trabalhos relacionados. A Tabela 5 apresenta
esta comparação, onde as funcionalidades existentes são identificadas por um X.
Tabela 5. Traço comparativo entre o simulador proposto (em destaque) e outros relativos.
Simuladores
WebSimple EKSMIPS
MARS
ProcSim
R10k
Funcionalidades
Código assembly A partir de arquivo X X X X X Permite edição X X X X Criação do código Direta / Total X X X X X X X X X Passo‐a‐passo X X X X X Tratamento de overflow aritmético X X Permite edição dos registradores diretamente X X X X Hexadecimal X Binário X X X X X X X X Análise Léxica Execução Exibição de dados Decimal Área de mensagem X X X X Através da tabela comparativa é possível perceber que as funcionalidades básicas de um
simulador para a arquitetura MIPS são comuns entre os trabalhos relacionados, e que o
EKSMIPS não deixa a desejar em nenhuma delas.
Entretanto, cada simulador possui características particulares já destacadas quando da
descrição dos mesmos nas Seções 3 e 4. Tais aspectos podem ser diferenciais no momento da
escolha de um simulador no auxílio da aprendizagem.
5 Conclusões e Trabalhos Futuros
Trabalhar com simuladores é de notória relevância no contexto de ensino/aprendizagem,
predição de erros e afins.
Através do estudo de trabalhos relacionados e da implementação do EKSMIPS foi
possível observar que acompanhando a execução das instruções, o usuário pode visualizar toda a
dinâmica existente em um processador MIPS, facilitando o entendimento do mesmo. O propósito
do simulador proposto esteve neste contexto, e foi atingido.
Em todo tempo preocupou-se com o foco didático do simulador, do funcionamento à
exibição das informações na interface.
O tratamento e o que motivou erros também foi considerado, e tal informação é sempre
apresentada como uma mensagem, para que force a interrupção da execução das instruções e
informe ao usuário, visando a aprendizagem do mesmo. Para facilitar o uso do simulador há um
arquivo de ajuda com a descrição das instruções e exemplos, que também está disponível via
Web.
Como trabalhos futuros, sugere-se que sejam implementadas as demais instruções não
contempladas no EKSMIPS. Ao trabalhar neste projeto, também foi possível abstrair a
relevância de um aplicativo que, tendo como entrada um código em uma linguagem de alto nível
(C, por exemplo), converta-o para as instruções do MIPS. Pode-se também implementar outra
versão do EKSMIPS que trabalhe com pipeline, a fim de demonstrar o paralelismo que este tipo
de arquitetura proporciona.
Referências Bibliográficas
[1] JUNIOR, N. G.; SILVA, R. L.; GONÇALVES, R. L.; MARTINI, J. A. R10k: Um
Simulador de Arquitetura Superescalar. In: Workshop sobre Educação em Arquitetura de
Computadores – WEAC, 2007.
[2] MARS. MARS – Mips Assembly and Runtime Simulator. Disponível em:
<http://courses.missouristate.edu/KenVollmar/MARS>. Acessado em 14/06/2010.
[3] MIPS Technologies. MIPS32® Architecture For Programmers. Vol. II: The MIPS32®
Instruction Set, 2008.
[4] PATTERSON, D.; HENNESSY, J. Organização e Projeto de Computadores – A
Interface Hardware/Software, 3ª ed., Campus, 2005.
[5] ProcSIM. A Visual MIPS R2000 Processor Simulator – Freeware. Disponível em:
<http://jamesgart.com/procsim>. Acessado em 11/06/2010.
[6] STALLINGS, W. Computer Organization and Architecture: designing for performance.
4. ed., Prentice-Hall, 1996.
[7] SWEETMAN, D. See MIPS Run, 2ª ed., Morgan Kaufmann, 2006.
[8] TANEMBAUM, A. Organização Estruturada de Computadores. 5ª ed., Prentice-Hall,
2007.
[9] VOLLMAR, K.; SANDERSON, P. A MIPS Assembly Language Simulator Designed for
Education. In: Journal of Circuits, Systems and Computers (JCSC), 2005. pp. 95-101.
[10]
WebSimple.
S|I|M|P|L|E
Simulador
de
Pipeline.
<http://201.17.130.17/matheus/simple>. Acessado em 16/06/2010.
Disponível
em: