curso de engenharia de computação …lyceumonline.usf.edu.br/salavirtual/documentos/1071.pdf · 1...
TRANSCRIPT
Curso de Engenharia de Computação
DESENVOLVIMENTO DE UM PROCESSADOR RISC EM VHDL
José Carlos Pereira
Itatiba – São Paulo – Brasil
Dezembro de 2006
ii
Curso de Engenharia de Computação
DESENVOLVIMENTO DE UM PROCESSADOR RISC EM VHDL
José Carlos Pereira
Monografia apresentada à disciplina Trabalho de Conclusão de Curso, do Curso de Engenharia de Computação da Universidade São Francisco, sob a orientação do Prof. Dr. Thales Coelho Borges Lima, como exigência parcial para conclusão do curso de graduação. Orientador: Prof. Dr. Thales Coelho Borges Lima
Itatiba – São Paulo – Brasil
Dezembro de 2006
iii
DESENVOLVIMENTO DE UM PROCESSADOR RISC EM VHDL
José Carlos Pereira
Monografia defendida e aprovada em 11 de Dezembro de 2006 pela Banca
Examinadora assim constituída:
Prof Dr Thales Coelho Borges Lima (Orientador)
USF – Universidade São Francisco – Itatiba – SP.
Prof Ms Claudio Maximiliano Zaina (Membro Interno)
USF – Universidade São Francisco – Itatiba – SP.
Prof Ms Ana Paula da Costa Cardoso (Membro Interno)
USF – Universidade São Francisco – Itatiba – SP.
iv
A meus pais José e Maria, sem os quais não
chegaria até aqui.
v
.Agradecimentos
Agradeço primeiramente ao Professor Thales C. B. Lima, meu orientador, que acreditou em
mim e incentivou-me para a conclusão deste trabalho, face aos inúmeros percalços do trajeto.
Agradeço também ao Professor Alencar de Melo Júnior, coordenador do curso, que sempre
me ajudou nas inúmeras questões acadêmicas.
Agradeço também todos os professores que me possibilitaram ter um crescimento acadêmico,
profissional e pessoal.
Eu agradeço fraternalmente a todos.
vi
Sumário
Lista de Siglas .........................................................................................................................vii
Lista de Figuras .....................................................................................................................viii
Lista de Tabelas ....................................................................................................................... ix
Resumo ...................................................................................................................................... x
Abstract ..................................................................................................................................... x
1 Introdução .......................................................................................................................... 1
2 Objetivo............................................................................................................................... 3
3 arquitetura risc e os processadores atuais....................................................................... 4 3.1 A arquitetura RISC........................................................................................................ 4 3.2 Os processadores atuais................................................................................................. 5
4 metodologia......................................................................................................................... 6 4.1 Estudo da linguagem VHDL......................................................................................... 6 4.2 A ferramenta de desenvolvimento Quartus II ............................................................... 7 4.3 Estudo sobre o processador MIPS................................................................................. 9
5 Desenvolvimento do processador MIPS em linguagem VHDL................................... 13 5.1 Módulos do processador MIPS ................................................................................... 13
5.1.1 Módulo unidade de controle.................................................................................13 5.1.2 Módulo busca da instrução...................................................................................14 5.1.3 Módulo decodificação ..........................................................................................15 5.1.4 Módulo de execução.............................................................................................15 5.1.5 Módulo memória de dados ...................................................................................16 5.1.6 Módulo integrador ................................................................................................17
6 testes .................................................................................................................................. 18 6.1 Teste de compilação.................................................................................................... 18 6.2 Simulação .................................................................................................................... 19
6.2.1 Definindo as instruções ........................................................................................19 6.2.2 Inicialização das memórias...................................................................................21
7 CONCLUSÕES................................................................................................................ 24 7.1 Contribuições .............................................................................................................. 24 7.2 Extensões..................................................................................................................... 24
Referências Bibliográficas ..................................................................................................... 25
vii
Lista de Siglas
CISC Complex Instruction Set Computer
CPU Central Processing Unit
CPLD Complex Programmable Logic Device
FPGA Field Programmable Gate Array
IEEE Institute of Electrical and Electronics Engineers
MIF Memory Initialization File
MIPS Microprocessor without interlocking pipe stages
PC Program Counter
PC Personal Computer
RISC Reduced Instruction Set Computer
ULA Unidade Lógica e Aritmética
VHDL Very-High-Speed Integrated Circuit Hardware Description
Language
viii
Lista de Figuras
Figura 4.2-1 - Tela principal da ferramenta Quartus II .................................................. 7
Figura 4.2-2 - Tela para seleção do arquivo de projeto .................................................... 8
Figura 4.2-3 - Desenvolvendo o projeto em VHDL no editor de texto ............................ 8
Figura 4.3-1 - Diagrama de blocos do processador MIPS com pipeline ........................ 12
Figura 5.1-1 - Arquivo para inicialização da memória de instrução ............................. 14
Figura 5.1-2 - Arquivo para inicialização da memória de dados ................................... 16
Figura 5.1-3 - Interligação com todos os módulos do processador MIPS ..................... 17
Figura 6.1-1 - Ferramenta de compilação do QuartusII ................................................ 18
Figura 6.2.2-1 - Inicialização da memória de dados ........................................................ 22
Figura 6.2.2-2 - Inicialização da memória de instruções ................................................. 23
ix
Lista de Tabelas
Tabela 4.3-1 - Formato das instruções do MIPS de 32 bits ......................................... 9
Tabela 4.3-2 - Conjunto de intsruções do MIPS 32 bits ............................................. 10
Tabela 6.2.1-1 – Conversão da instrução Lw $2, 00 .................................................... 20
Tabela 6.2.1-2 – Conversão da instrução Lw $3, 01 .................................................... 20
Tabela 6.2.1-3 – Conversão da instrução Add $1, $2, $3 ............................................. 21
Tabela 6.2.1-4 – Conversão da instrução Sw $1, 03 ...................................................... 21
x
Resumo
Esta monografia tem como objetivo o aprendizado, o desenvolvimento e prototipação de
processadores utilizando dispositivos lógicos programáveis, para a implementação de um
processador RISC (Reduced Instruction Set Computer), utilizando a linguagem VHDL (Very-
High-Speed Integrated Circuit Hardware Description Language). O estudo envolve o
conhecimento da arquitetura RISC e da linguagem VHDL para o desenvolvimento do
processador.
PALAVRAS-CHAVE: PROCESSADOR, RISC, VHDL
Abstract
This monograph has as objective the learning, the development and prototyping of processors
using programmable logical devices, for the implementation of a processor RISC (Reduced
Instruction Set Computer), using language VHDL (Very-High-Speed Integrated Circuit
Hardware Description Language). The study it involves the knowledge of architecture RISC
and language VHDL for the development of the processor.
KEY WORDS: PROCESSOR, VHDL, RISC
1
1 INTRODUÇÃO
O processador é a unidade principal de um sistema computacional, sendo responsável
pelo controle do fluxo dos programas, execução das operações lógicas e aritméticas, acesso à
memória e requisição aos dispositivos periféricos. Também é conhecido como CPU, (Central
Processing Unit).
A idéia original do projeto RISC, de produzir máquinas com um conjunto reduzido de
instruções é, em última análise, uma volta ao início da computação, pois os primeiros
computadores digitais tinham poucas instruções.
A característica de um processador RISC é ter um conjunto reduzido e simples de
instruções, o que simplifica o processamento; utilizam registradores para armazenar dados
temporariamente, que serão utilizados nas operações realizadas pelo processador; as
instruções são basicamente do tipo Load e Store, de desvio e de operações lógicas e
aritméticas e por fim, o emprego de pipelining, um dos fatores que permite aos processadores
RISC atingir seu objetivo de completar a execução de uma instrução a cada ciclo de relógio.
O projeto de um processador resume-se em:
• Definir o conjunto de instruções, ou seja, o formato e o tamanho das intruções.
• Implementar os componentes do processador em função das instruções já
definidas, como por exemplo, a unidade de controle, unidade lógica e aritmética e
os registradores.
A partir dessas premissas, é possível utilizar a linguagem VHDL, para simular o
funcionamento de um processador RISC.
Este trabalho encontra-se organizado da seguinte forma: no capítulo 2 são apresentados
os objetivos relacionados a esta dissertação. No capítulo 3 são apresentadas as características
da arquitetura RISC e dos processadores utilizados atualmente. O capítulo 4 aborda toda a
metodologia utilizada no desenvolvimento do processador RISC, os estudos sobre a
linguagem VHDL, a ferramenta Quartus® II utilizada no projeto e os estudos sobre o
2
processador MIPS1. No capítulo 5 são apresentadas as funcionalidades de cada módulo que
constitui o processador MIPS. Todos os módulos foram desenvolvidos utilizando a linguagem
VHDL. No capítulo 6 são apresentados os testes realizados e finalmente no capítulo 7 são
apresentadas as conclusões deste trabalho.
1 MIPS é um procesador RISC desenvolvido pela companhia MIPS Computer Systems [2].
3
2 OBJETIVO
A presente dissertação tem como objetivo realizar uma pesquisa para implementar um
processador RISC utilizando a linguagem VHDL (Very-High-Speed Integrated Circuit
Hardware Description Language).
Para o desenvolvimento do processador em linguagem VHDL foi utilizado a ferramenta
Quartus II®, da Altera2.
Este projeto foi baseado no MIPS (Microprocessor without interlocking pipe stages), que
é uma arquitetura de processadores RISC [2].
2 Altera, de Altera Corporation é um fabricante de dispositivos lógicos programáveis, desenvolvedor da
ferramenta de síntese e simulação denominada Quartus II.
4
3 ARQUITETURA RISC E OS PROCESSADORES ATUAIS
Este capítulo tem como objetivo apresentar as características da arquitetura RISC e dos
processadores utilizados atualmente.
3.1 A arquitetura RISC
A arquitetura RISC é constituída por um conjunto reduzido de instruções simples que
são executadas diretamente pelo hardware, sem a intervenção de um microcódigo, ou seja, as
instruções são executadas em apenas uma microinstrução [1].
Existe um conjunto de características que permite uma definição da arquitetura básica
RISC:
• O centro de todo computador é o datapath (ULA (Unidade Lógica e Aritmética),
registradores e os barramentos que fazem sua conexão). Uma das maiores
características das máquinas RISC é utilizar apenas uma instrução por ciclo de relógio;
• Projeto carrega/armazena, ou seja, as referências à memória são feitas por instruções
especiais de load e store;
• Inexistência de microcódigo, já que as instruções são executadas diretamente no
hardware;
• Instruções de formato fixo, facilitando a decodificação;
• Conjunto reduzido de instruções, facilitando a organização da unidade de controle e
tornando o processamento das instruções mais simples e rápido;
• Utilização de pipeline, uma técnica de dividir a execução de uma instrução em
estágios, permitindo a execução simultânea de múltiplas instruções. A medida que um
estágio é concluído, a instrução segue para o próximo e a instrução seguinte vai para
aquele estágio. Como as instruções RISC são de tamanho fixo, elas levam um ciclo
para completar cada estágio de pipeline. Por exemplo, se uma instrução puder ser
dividida em 4 fases, 4 instruções podem ser executadas simultaneamente;
5
• Utilização de conjuntos de registradores, para o armazenamento temporário de dados,
que serão utilizados em operações.
O principal objetivo de uma máquina RISC é executar uma instrução por ciclo de clock.
Como o acesso à memória utiliza mais ciclos, a solução foi criar um grande número de
registradores. Este número de registradores tem grande impacto na performance das máquinas
RISC, que só são possíveis devido sua simplicidade de projeto e a inexistência de
microcódigo, conforme [1] e [2].
3.2 Os processadores atuais
Atualmente, existem processadores híbridos que são essencialmente processadores
CISC, mas incorporam muitos recursos encontrados nos processadores RISC e vice-versa.
Não existe praticamente nenhum processador atualmente que siga estritamente uma das duas
arquiteturas. Tanto processadores da família x863, quanto processadores supostamente RISC,
misturam características das duas arquiteturas, por simples questão de performance [1].
A vantagem de uma arquitetura CISC (Complex Instruction Set Computer) é que nesta
já existem muitas das instruções armazenadas no próprio processador, o que facilita o trabalho
de programação, que já dispõe de praticamente todas as instruções que serão usadas em seus
programas. No caso de um chip estritamente RISC, a programação seria um pouco mais
complexa, pois como disporia apenas de instruções simples, teria sempre que combinar várias
instruções sempre que precisasse executar alguma tarefa mais complexa [2].
Os processadores atuais são uma combinação das duas arquiteturas. Internamente, o
processador processa apenas instruções simples. Estas instruções internas variam de
processador para processador, que se adapta ao projeto do chip. Sobre estas instruções
internas, tem-se um circuito decodificador, que converte as instruções complexas utilizadas
pelos programas em várias instruções simples, que podem ser entendidas pelo processador.
Estas instruções complexas, são iguais em todos os processadores usados em micros PC
(Personal Computer) [8].
3 x86 é uma arquitetura de processadores baseados na série x86 da Intel, como por exemplo, CPU 286, 386 e o
486.
6
4 METODOLOGIA
Este capítulo tem como objetivo detalhar toda a metodologia envolvida no projeto, os
estudos sobre a linguagem VHDL, os estudos sobre o processador MIPS e a ferramenta
utilizada na implementação do processador MIPS.
4.1 Estudo da linguagem VHDL
De acordo com [3] e [4], VHDL é uma linguagem padronizada pelo IEEE (Institute of
Electrical and Electronics Engineers) para descrever componentes digitais, permitindo a
transferência de projetos para qualquer tecnologia em construção de hardware existente ou
que ainda será desenvolvida.
A linguagem VHDL oferece uma variedade de construções que permitem modelar o
hardware em um elevado nível de abstração. É uma linguagem concorrente, ou seja, os
comandos envolvidos na ocorrência de um evento são executados simultaneamente, assim
como os elementos de um sistema digital executam as suas tarefas em conjunto [4].
A importância da utilização de linguagens de descrição de hardware se faz necessária em
diversos aspectos do projeto:
• Documentação do sistema: a própria descrição do sistema já é uma forma de
documentação para os projetistas em VHDL;
• Simulação em diversos níveis: desde a sua especificação funcional e temporal o
circuito pode ser simulado para verificar seu correto funcionamento;
• Simplifica a migração tecnológica: o sistema pode ser facilmente sintetizado em outras
tecnologias, desde que se disponha das ferramentas de baixo nível correspondentes;
• Reutilização de recursos: a construção de módulos, permite reutilizar parte de projetos
já realizados.
7
4.2 A ferramenta de desenvolvimento Quartus II
Conforme [5], a ferramenta Quartus® II version 6, desenvolvida pela Altera®, é um
ambiente para o desenvolvimento e síntese de projetos de FPGA (Field Programmable Gate
Array) e de CPLD (Complex Programmable Logic Device). O Quartus II permite o
desenvolvimento de sistemas digitais utilizando a interface gráfica ou o editor de texto, que
possibilita o uso da linguagem VHDL.
A figura 4.2-1 apresenta a tela principal do Quartus II.
Figura 4.2-1 - Tela principal da ferramenta Quartus II.
8
Após inicializar o Quartus II e visualizar a tela principal, conforme mostrado na figura
4.2-1, é possível selecionar uma das opções apresentadas na ferramenta, para o início do
desenvolvimento do projeto. Foi utilizada a opção VHDL File, conforme apresentada na
figura 4.2-2, que é o editor de texto utilizado no desenvolvimento do processador MIPS.
Figura 4.2-2 - Tela para seleção do arquivo de projeto.
A figura 4.2-3 apresenta o VHDL File, editor de texto usado no desenvolvimento do
projeto.
Figura 4.2-3 - Desenvolvendo o projeto em VHDL no editor de texto.
9
4.3 Estudo sobre o processador MIPS
MIPS é um exemplo de um moderno computador com conjunto reduzido de instruções
desenvolvido na década de 80. Estes processadores trabalham com um comprimento fixo de
instrução de 32 bits e possuem 32 registradores de 32 bits. O tamanho da palavra de memória
é de 32 bits [6].
Os processadores MIPS trabalham com três formatos de instruções, conforme [6]:
• Instruções I-Format: somente para LOAD e STORE, ou seja, para instruções
referentes aos operandos na memória;
• Instruções R-Format: executa instruções como ADD, AND, OR e operações
realizadas com os dados nos registradores. Estes requerem dois registradores de
operandos, Rs e Rt. Os resultados das operações são armazenados em um terceiro
registrador, Rd, mostrado na tabela 4.3-1;
• Instruções J-Format incluem instruções de desvio.
A tabela 4.3-1, apresenta o formato das instruções de um processador MIPS de 32 bits,
conforme [6] e [7]
Tabela 4.3-1 - Formato das instruções do MIPS de 32 bits.
Tamanho do campo 6 bits 5 bits 5 bits 5 bits 5 bits 6 bitsFormato R código de operação Rs Rt Rd deslocamento funçãoFormato I código de operação Rs RtFormato J código de operação
endereço / imediatoendereço-alvo
10
A tabela 4.3-2 apresenta o conjunto de instruções do processador MIPS, como descrito
em [6] e [7].
Tabela 4.3-2 – Conjunto de instruções do MIPS 32 bits.
O processador MIPS busca, decodifica e executa uma instrução em um ciclo de clock.
A partir do formato das instruções, como mostrado na tabela 4.3-1, o PC (Program Counter) é
utilizado para manter atualizado o endereço de memória da próxima instrução a ser executada.
A memória tem a função de armazenar os dados e as instruções. Esta consiste em uma coleção
de registradores numerados consecutivamente, onde cada um armazena um byte, quatro são
necessários para armazenar 32 bits ou 4 bytes [6].
O código de operação das instruções é enviado para a unidade de controle e o código
da função é enviado para a unidade lógica e aritmética. A unidade de controle é responsável
pelo controle de todas as operações dos componentes de um computador, fornecendo sinais de
temporização e sinais de controle, que são necessários para a execução das instruções.
Na ULA são realizadas as operações aritméticas e lógicas com os dados. O tipo de
operação a ser executado é determinado por sinais vindos da unidade de controle. Os dados a
serem operados poderão vir da memória ou dos dispositivos de entrada. Os resultados obtidos
poderão ser enviados para a memória ou para dispositivos de saída de dados [6].
Mnemônico Formato Campo código de operação
Campo função Instrução
Add R 0 32 Soma (com overflow)Addi I 8 - Soma imediata (com overflow)Addu R 0 33 Soma (sem overflow)Sub R 0 34 Subtração (com overflow)Subu R 0 35 Subtração (sem overflow)And R 0 36 Lógica ANDOr R 0 37 Lógica ORSll R 0 0 Deslocamento Lógico a EsquerdaSrl R 0 2 Deslocamento Lógico a DireitaSlt R 0 42 Setar se menor queLui I 15 - Carga imediata da parte superiorLw I 35 - Carga de palavraSw I 43 - Armazenamento de palavraBeq I 4 - Desvio se igualBne I 5 - Desvio se diferente
J J 2 - Desvio incondicionalJal J 3 - Desvio incondicional com ligaçãoJr R 0 8 Desvio incondicional para conteúdo de um registrador
11
Os registradores de instruções são campos de endereços, utilizados para endereçar os
dois barramentos do arquivo de registradores. As entradas do arquivo de registradores
permitem executar duas leituras independentes e uma escrita em um ciclo de clock. Este
implementa a decodificação da operação [7].
No processador MIPS há duas saídas do arquivo de registradores que alimentam com
dados as entradas da ULA. A unidade de controle gera sinais que são enviados a ULA, para a
execução das operações. Em seguida, instruções Load e Store são executadas para a leitura ou
escrita de dados na memória. Instruções R-format desviam dados da memória usando um
multiplexador. Por último, instruções R-format e Load escrevem de volta um novo valor no
arquivo de registradores.
O multiplexador é requerido para operações condicionais. Após todas as saídas
estarem estabilizadas, o próximo clock armazenará o novo valor no PC e o processo se
repetirá para a próxima instrução.
As instruções RISC são executadas mais rapidamente com a implementação de
pipeline. Com pipeline, a busca, decodificação, execução, memória de dados e arquivo de
registradores, realizam todo o trabalho em paralelo. Em um simples ciclo de clock, diferentes
instruções estão presentes no pipeline [6].
12
A figura 4.3-1 mostra o diagrama de blocos do processador MIPS com a
implementação de pipeline.
Figura 4.3-1 - Diagrama de blocos do processador MIPS com pipeline. Retirada de HENNESSY, John L.; PATTERSON, David A. Organização e Projeto de
Computadores: A interface Hardware/Software.
13
5 DESENVOLVIMENTO DO PROCESSADOR MIPS EM LINGUAGEM VHDL
Este capítulo apresenta todos os módulos que constituem o processador MIPS e a
descrição funcional de cada módulo, com base em [7]. Estes módulos são:
• Módulo unidade de controle;
• Módulo busca da instrução;
• Módulo decodificação;
• Módulo de execução;
• Módulo memória de dados;
• Módulo integrador.
Inicialmente, todos os módulos foram implementados separadamente utilizando a
linguagem VHDL. Em seguida, foram integrados com o objetivo de simular o funcionamento
de um processador MIPS4. O recurso requerido para esta implementação foi o editor de texto
da ferramenta Quartus II®, da Altera.
5.1 Módulos do processador MIPS
Nesta etapa é apresentada a descrição funcional de cada módulo do processador MIPS,
implementado em VHDL.
5.1.1 Módulo unidade de controle
Verifica o código de operação da instrução e gera os sinais de controle que serão
utilizados pelos outros módulos do processador.
4 Neste projeto não foi desenvolvido o módulo responsável pela simulação de pipeline, devido a
complexidade e as grandes alterações a serem feitas para o seu funcionamento.
14
5.1.2 Módulo busca da instrução
É constituído pela memória de instruções, pelo registrador PC e o hardware necessário
para computar o endereço da próxima instrução a ser executada.
A memória de instrução é inicializada utilizando um arquivo MIF (Memory
Initialization File). Este arquivo foi criado utilizando a ferramenta Quartus II sendo
responsável por armazenar as instruções que serão executadas. Sem esta inicialização, não é
possível simular o funcionamento do processador MIPS.
Conforme apresentado na figura 5.1-1, cada linha do arquivo representa os endereços
de memória, onde as instruções são armazenadas.
Figura 5.1-1 - Arquivo para inicialização da memória de instrução.
15
5.1.3 Módulo decodificação
Contém o arquivo de registradores. O processador MIPS, contém 32 registradores de
32 bits. Porém, para uma simulação mais rápida, o arquivo de registradores foi reduzido para
8 registradores de 8 bits. Os registradores são inicializados durante o reset. Uma estrutura em
VHDL é utilizada para inicializar os registradores durante o reset.
5.1.4 Módulo de execução
Responsável por simular os dados que serão manipulados pela ULA, a ULA
propriamente dita é um somador, responsável por incrementar o registrador PC e calcular o
endereço para operações de desvio.
Multiplexadores foram implementados para simular a seleção de diferentes dados que
serão enviados para a ULA. Para uma simulação mais rápida, a largura do barramento de
dados da ULA foi limitada em 8 bits.
16
5.1.5 Módulo memória de dados
Módulo responsável por simular a memória de dados. A memória de dados também
foi limitada a 256 posições de memória de 8 bits para facilitar a simulação.
A memória de dados é inicializada utilizando um arquivo MIF. Este arquivo é o
responsável por armazenar valores que serão manipulados durante a execução das instruções
contidas na memória de instruções.
Conforme mostrado na figura 5.1-2, cada linha do arquivo representa os endereços da
memória de dados, onde os dados são armazenados.
Figura 5.1-1 - Arquivo para inicialização da memória de dados.
17
5.1.6 Módulo integrador
Consiste em uma estrutura em VHDL, responsável pela integração dos outros cinco
módulos do processador MIPS. Este módulo foi estruturado de forma a realizar uma
interligação com os outros módulos e permitir a simulação do processador MIPS. Os módulos
foram interligados na seguinte seqüência:
1- Módulo busca da instrução;
2- Módulo decodificação;
3- Módulo unidade de controle;
4- Módulo de execução;
5- Módulo memória de dados.
A figura 5.1-3 apresenta o módulo integrador com as interligações com os demais
módulos.
Figura 5.1-3 - Interligação com todos os módulos do processador MIPS.
18
6 TESTES
Nesta etapa foram realizados os testes dos módulos desenvolvidos em linguagem VHDL.
Todos os testes foram realizados utilizando a ferramenta Quartus II®, da Altera.
Esses testes consistiram na compilação do código fonte de cada módulo do processador
MIPS.
6.1 Teste de compilação
Foram realizados inicialmente, os testes de cada módulo separadamente. O módulo
integrador foi o último a ser testado, pois este depende do funcionamento dos outros módulos.
Na figura 6.1-1, é mostrada a ferramenta de compilação do QuartusII.
Figura 6.1-1 - Ferramenta de compilação do QuartusII.
A ferramenta de compilação mostrada na figura 6.1-1 foi a mesma utilizada para os
testes de todos os módulos desenvolvidos.
19
6.2 Simulação
Para a simulação, foi necessário inicialmente, definir quais as instruções seriam
executadas pelo processador, carregar a memória de dados com os valores a serem
manipulados pelas instruções e em seguida inicializar a memória de instruções.
6.2.1 Definindo as instruções
Inicialmente, foram definidas as instruções que seriam executadas pelo processador.
Como exemplo, foram realizadas simulações com as seguintes instruções:
• Lw $2, 00 – carrega o conteúdo do endereço 00 da memória de dados no registrador
$2.
• Lw $3, 01 – carrega o conteúdo do endereço 01 da memória de dados no registrador
$3.
• Add $1, $2, $3 – realiza a soma do conteúdo dos registradores $2 e $3 e o resultado é
armazenado no regitrador $1.
• Sw $1, 03 – armazena no endereço 03 da memória de dados, o conteúdo do registrador
$1.
Para inserir as instruções mencionadas acima na memória de instruções, foi realizada,
inicialmente, a conversão das mesmas para o sistema binário. Foram utilizadas as informações
das tabelas 4.3-1 e 4.3-2 para as conversões. Em seguida para uma melhor visualização, foi
realizada utilizando a ferramenta Quartus II, a conversão para o sistema hexadecimal.
A instrução Lw $2, 00 é do formato I, conforme mostrado nas tabelas 4.3-1 e 4.3-2.
Na tabela 6.2.1-1 é apresentado o formato da instrução e a conversão para binário.
20
Tabela 6.2.1-1 – Conversão da instrução Lw $2, 00.
Código de operação Registrador rs Registrador rt Endereço/imediato
6 bits 5 bits 5 bits 16 bits
Lw $2 não utilizado 00
100011 00010 00000 0000000000000000
O numeral em binário, da tabela 6.2.1-1, foi inserido na memória de instrução para
posterior simulação. Todo esse procedimento foi o mesmo para as demais instruções.
A instrução Lw $3, 01 mostrada na tabela 6.2.1-2, apresenta o formato da instrução e a
conversão para binário.
Tabela 6.2.1-2 – Conversão da instrução Lw $3, 01.
Código de operação Registrador rs Registrador rt Endereço/imediato
6 bits 5 bits 5 bits 16 bits
Lw $3 não utilizado 00
100011 00011 00000 0000000000000001
A instrução Add $1, $2, $3 é do formato R, conforme apresentado nas tabelas 4.3-1 e
4.3-2. A tabela 6.2.1-3, apresenta o formato da instrução e a conversão para binário.
21
Tabela 6.2.1-3 – Conversão da instrução Add $1, $2, $3.
Código de operação Registrador
rs
Registrador
rt
Registrador
rd
Deslocamento Função
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
Add $1 $2 $3 não utilizado 32
000000 00001 00010 00011 00000 100000
A instrução Sw $1, 03 é do formato I, conforme apresentado nas tabelas 4.3-1 e 4.3-2.
A tabela 6.2.1-4, apresenta o formato da instrução e a conversão para binário.
Tabela 6.2.1-4 – Conversão da instrução Sw $1, 03.
Código de operação Registrador rs Registrador rt Endereço/imediato
6 bits 5 bits 5 bits 16 bits
Sw $1 não utilizado 03
101011 00001 00000 0000000000000011
Concluído o processo de conversão, as instruções em binário foram inseridas na
memória de instruções. Estas instruções utilizam os valores armazenados na memória de
dados para realizar as operações.
6.2.2 Inicialização das memórias
Para a simulação do processador, foi criado através da ferramenta Quartus II, um
arquivo MIF, que simulou a memória de dados, onde foram inseridos os dados utilizados pela
memória de instrução, para a inicialização do processamento. A figura 6.2.2-1, apresenta a
inicialização da memória de dados.
22
Figura 6.2.2-1 - Inicialização da memória de dados.
Os dados foram inseridos no sistema binário, nos endereços 00 e 01. Em seguida foram
convertidos para o sistema hexadecimal através da própria ferramenta. A figura 6.2.2-1
apresenta os dados no sistema hexadecimal.
Com os dados inseridos na memória de dados, foi criado um arquivo MIF para simular
a memória de instrução, onde foram inseridas as instruções, para a inicialização do
processamento. A figura 6.2.2-2 apresenta a inicialização da memória de instruções.
23
Figura 6.2.2-2 - Inicialização da memória de instruções.
As instruções foram inseridas no sistema binário nos endereços 00 até 03 e em seguida
convertidas para o sistema hexadecimal. A figura 6.2.2-2 mostra as instruções no sistema
hexadecimal. As instruções utilizam os dados da memória, realizam as operações e finalmente
os resultados são armazenados novamente na memória de dados.
24
7 CONCLUSÕES
A pesquisa desenvolvida ao longo deste trabalho buscou demonstrar, de uma maneira
sucinta, as características da arquitetura RISC, como por exemplo, o conjunto de instruções, o
ciclo de busca, a decoficação e execução das instruções.
Neste trabalho de conclusão de curso também foram apresentadas as características do
processador MIPS e os estudos relacionados a linguagem VHDL.
O principal objetivo neste trabalho foi implementar, utilizando a linguagem VHDL, o
processador MIPS. A partir da implementação, foi possível simular o funcionamento deste
processador, o que contribuiu para um melhor entendimento da arquitetura de computadores.
7.1 Contribuições
Resumidamente, as principais contribuições gerais deste estudo, são o entendimento do
processador MIPS e conseqüentemente da arquitetura RISC, o conhecimento da linguagem
VHDL e a sua utilização para o desenvolvimento e simulação do processador MIPS.
7.2 Extensões
Este trabalho pode ser continuado através da implementação do módulo pipeline, já que
o pipeline é um dos principais fatores que permite aos processadores MIPS atingir seu
objetivo de completar a execução de uma instrução a cada ciclo de clock.
25
Referências Bibliográficas
[1] MONTEIRO, Mario Antonio. Introdução a Organização de Computadores. 3 ed. Rio de Janeiro: LTC, 1996. [2] TANENBAUM, Andrew S. Organização Estruturada de Computadores. 3 ed. Rio de Janeiro: Prentice-Hall, 1992. [3] D´AMORE, Roberto. VHDL: Descrição e Síntese de Circuitos Digitais. Rio de Janeiro:LTC, 2005. [4] ORDONES, E. D. M. et al. Projeto, Desempenho e Aplicações de Sistemas Digitais em Circuitos Programáveis (FPGAs). São Paulo: Bless Gráfica e Editora , 1999. [5] ALTERA Corporation. Quartus II Version 6.0 Handbook, Volumes 1 through 5. URL: http://www.altera.com/literature/hb/qts/quartusii_handbook.pdf. Recuperado em 12/04/2006. [6] HAMBLEN, James O.; FURNAN, Michael D. Rapid Prototyping of Digital Systems: A Tutorial Approach. 2nd ed. Massachusetts: Kluwer Academic Publishers, 2002.
[7] HENNESSY, John L.; PATTERSON, David A. Organização e Projeto de Computadores: A interface Hardware/Software. 2 ed. Rio de Janeiro: LTC, 2000. [8] TANENBAUM, Andrew S. Organização Estruturada de Computadores. 4 ed. Rio de Janeiro: LTC, 2001.