Você está na página 1de 21

Universidade Federal do Rio Grande do Sul Instituto de Informtica - PPGC CMP 114 - Arquitetura e Projeto de Sistemas VLSI I Prof.

Andr Reis Prof. Flvio R. Wagner Prof. Luigi Carro

Descrio VHDL do MIPS Pipeline

Alunos: Lisane Brisolara de Brisolara Maurcio Lima Pilla

Porto Alegre, 7 de agosto de 2000.

Sumrio
1. 2. INTRODUO........................................................................................................................................................5 IMPLEMENTAO ..............................................................................................................................................7 2.1. ESTGIO DE BUSCA ...............................................................................................................................................7 2.2. ESTGIO DE DECODIFICAO .............................................................................................................................8 2.3. ESTGIO DE EXECUO .......................................................................................................................................9 2.3.1. Controle da ULA:.................................................................................................................................... 10 2.4. ESTGIO DE MEMRIA .......................................................................................................................................12 2.5. ESTGIO DE WRITEBACK.....................................................................................................................................12 2.6. UNIDADE DE CONTROLE DO MIPS....................................................................................................................12 3. INTERLIGAO DOS ESTGIOS............................................................................................................... 13 3.1. FORWARDING.......................................................................................................................................................13 3.2. DETECO DE DESVIOS ......................................................................................................................................14 4. VALIDAO E SIMULAO........................................................................................................................ 15 4.1. TESTE R-FORMAT ................................................................................................................................................15 4.2. TESTE DE A CESSO M EMRIA .........................................................................................................................17 4.3. TESTE DA INSTRUO DE DESVIO.....................................................................................................................19 5. 6. CONCLUSES ...................................................................................................................................................... 20 BIBLIOGRAFIA................................................................................................................................................... 21

ndice de Figuras
FIGURA 1 - ESTGIO DE BUSCA.......................................................................................................................................7 FIGURA 2 - ESTGIO DE DECODIFICAO .....................................................................................................................9 FIGURA 3 - ESTGIO DE EXECUO.................................................................................................................10 FIGURA 4 - CIRCUITO DE CONTROLE DA ULA................................................................................................11 FIGURA 5 - ESTGIO DE MEMRIA ....................................................................................................................12 FIGURA 6 - GRAFO DE DEPENDNCIAS ............................................................................................................16 FIGURA 7 RESULTADO DO TESTE R-FORMAT..............................................................................................17 FIGURA 8 RESULTADO DO TESTE DE ACESSO MEMRIA ..................................................................18 FIGURA 9 RESULTADO DO TESTE DA INSTRUO DE DESVIO CONDICIONAL..............................19

ndice de Tabelas
TABELA 1 - CDIGOS E OPERAES DA ULA.................................................................................................................10 TABELA 2 - TABELA-VERDADE PARA SINAL DA ULA ..................................................................................................11 TABELA 3 - ALUOP CORRESPONDENTES S INSTRUES ..........................................................................................11

1. Introduo
O objetivo deste trabalho desenvolver uma descrio VHDL do processador MIPS com pipeline de instrues, unidade de deteco de dependncias e mecanismo para deteco e tratamento de salto condicionais (branchs). Em funo do perodo de durao deste trabalho no foram implementadas todas as instrues do MIPS e o tratamento de excees. A implementao apresentada neste trabalho foi baseada no MIPS original de Hennessy e Patterson [HEN98] e na verso monociclo de [HAM00]. O MIPS um processador com um conjunto de instrues reduzido (RISC), desenvolvido em 1980. O uso de uma arquitetura RISC permite simplificar a lgica de controle do processador e, com isso, obtm-se um ganho em rea que poder ser utilizada para outros fins, como acrscimo de mais blocos de memria cache. O seu conjunto de instruo utilizado ainda hoje, com modificaes, pela Sony, Silicon Graphics, NEC e por diversos outros fabricantes de microprocessadores. O MIPS possui trs formatos de instrues diferentes: R-format, I-format e Jformat. As instrues do tipo R-format executam operaes de lgica e aritmtica somente em dados armazenados em registradores, operaes estas como ADD, SUB, AND, OR e SLT. As instrues do tipo I-format englobam dois tipos aquelas que fazem referncia a memria como instrues de load e store e as instrues de branch, salto incondicional. As instrues do tipo J-format executam operaes de jump incondicional, mas estas no sero implementadas neste trabalho. Na Tabela 1, pode-se observar o formato das instrues do MIPS. Tabela 1: Formato das instrues do MIPS 5 bits 5 bits 5 bits 5 bits Rs Rs Rt Rt

Tamanho 6 bits do campo R-Format Opcode I-Format Opcode J-Format Opcode

5 bits

Rd Shift Function Address/immeadiate value Branch target address

A implementao do MIPS desenvolvida neste trabalho cobre um subconjunto das instrues do MIPS. Na Tabela 2, pode-se observar o cdigo de cada uma destas instrues implementadas. Observa-se tambm a existncia de um campo de funo que s usado para as instrues do tipo R-format para determinar a operao executada pela unidade lgica aritmtica (ULA).

Mnemnico ADD SUB AND OR SLT LW SW BEQ

Tabela 2: Cdigo das instrues implementadas Formato Opcode R 0 R 0 R 0 R 0 R 0 I 35 I 43 I 4

Funo 32 34 36 37 42 -

A memria do MIPS endereada a byte e portanto, adiciona-se quatro para o clculo do prximo endereo da palavra de 32 bits da memria, sendo os endereos de memria de 32 bits. O MIPS possui somente dois modos de endereamento: o modo imediato, que usa uma constante de16 bits contida na prpria instruo, e o modo base e deslocamento, no qual o endereo efetivo o contedo de um registrador base somado com um deslocamento contido na instruo. O endereamento chamado registrador indireto pode ser obtido com o deslocamento igual a zero. Pode-se utilizar ainda o modo absoluto, obtido atravs do uso de $0 como registrador base, pois seu valor sempre zero.

2. IMPLEMENTAO
Aps o estudo da organizao e arquitetura do processador, baseado em [HEN98], desenvolveu-se separadamente cada um dos componentes que compem os estgios do pipeline do MIPS. Depois de testados individualmente, os estgios foram conectados e testados novamente. Para a correta sincronizao dos estgios, foram usados pares de signals VHDL entre os mesmos. Para cada par de signals, um est conectado ao estgio anterior e o outro ao prximo estgio. Quando o relgio sobe para 1, o valor copiado do primeiro para o segundo signal. A implementao desenvolvida neste trabalho uma arquitetura RISC com pipeline de cinco estgios, o estgio de busca (fetch), estgio de decodificao, estgio de execuo, de memria e de escrita nos registradores (writeback). Nesta seo relata-se a implementao dos estgios de pipeline desta arquitetura.

2.1.

Estgio de Busca

O estgio de Busca (Figura 1) responsvel pelo fornecimento de instrues para o pipeline, a partir da ordem definida no programa. Para determinar o valor da prxima instruo h duas possibilidades: A prxima instruo a ser buscada segue a ltima instruo no cdigo do programa (seqencial, o PC incrementado de 4). A prxima instruo a ser buscada determinada por uma instruo de desvio. No segundo caso, necessrio esperar pelo resultado do clculo do desvio e se este realmente tomado, no caso de um desvio condicional.

4 Next PC
PC

A D D

ADD Result
1

M U X

Memria E de Instrues

Clock Zero Branch

Figura 1 - Estgio de Busca 7

Na Figura 1, observa-se que a fonte do prximo PC (Program Counter) determinado pelo AND entre Zero e Branch. O sinal Zero determina se o resultado da ULA na ltima operao foi zero. O sinal Branch depende da instruo no estgio de Execuo, sendo 1 quando esta for um desvio. Assim, quando estes dois sinais so iguais a 1, o resultado da soma do prximo PC com o deslocamento na instruo de desvio determina o valor a ser armazenado no PC. Em caso contrrio, o PC recebe o endereo da prxima instruo no fluxo seqencial de instrues (PC+4). O somador para calcular o PC+4 encontra-se dentro do estgio de Busca. Para implementar a memria de instrues, usando um modelo Harvard (memria de instrues e de dados separadas), foi usado um mdulo lpm_rom da Altera. Este mdulo acrescenta uma memria ROM. Para determinar o contedo da memria ROM, usado um arquivo com a descrio do programa em formato hexadecimal. Para cada programa novo, necessrio recompilar todo o pipeline, o que dificulta o teste do microprocessador. Porm, no foi encontrada uma forma simples de evitar a recompilao de todo o cdigo. A memria de instrues e o estgio de Busca encontram-se descritos em arquivos separados, sendo conectados no pipeline. Desta forma, torna-se mais fcil observar o acesso a esta memria, bem como fazer futuras modificaes.

2.2.

Estgio de Decodificao

O estgio de Decodificao responsvel pela interpretao das instrues e pelo gerenciamento do banco de registradores. A Figura 2 mostra os componentes do estgio de Decodificao. Alm do banco de registradores com duas leituras e uma escrita por ciclo, implementado como um componente parametrizado, h ainda um estensor de sinal para transformar os 16 bits menos significativos da instruo em um valor de 32 bits, que pode ento ser operado no estgio de Execuo. O banco de registradores foi implementado como uma entidade separada, podendo ser determinado na instanciao o nmero de registradores. Cada registrador inicializado com o valor correspondente ao seu ndice no banco de registradores, para diminuir o tamanho necessrio aos programas de teste [HAM00] . O registrador $0 mantm permanentemente o valor 0 (zero) . Para as simulaes, o banco de registradores foi instanciado com apenas 4 registradores de 32 bits cada, para diminuir o tempo necessrio compilao e simulao do projeto.

RegWrite

Reg1 em leitura

5
Reg.2 em leitura

Dados em leitura 1 Dados em leitura 2

5 5
Reg. em escrita Dados em escrita

Banco de registradores

Instruo [15 - 0]

16 Sign extend

32

Figura 2 - Estgio de Decodificao

2.3.

Estgio de Execuo
Neste estgio, existem duas unidades de execuo (Figura 3): Unidadde para clculo de endereo de branch (apenas soma) Unidade Lgica e Aritmtica ( and, or, add e sub ).

Os sinais de controle dos multiplexadores so detalhes importantes. O sinal ALUscr gerado pelo bloco de controle para selecionar o segundo operando da ULA, este pode ser o dado lido de um registrador, no caso das instrues Rtype e de branch ou um endereo no caso das instrues de load e store. Os outros dois multiplexadores foram inseridos para permitir o forwarding dos dados, ou seja eliminar as bolhas inseridas no pipeline quando h uma dependncia de dados. Agora, alm do dado lido dos registradores, o operando da ula pode ser o resultado de um estgio de execuo de uma instruo anterior que escreve em um registrador que a instruo que est sendo executada l, permitindo que o valor possa ser repassado para instruo corrente antes do estgio de escrita dos registradores (write-back) da instruo anterior ocorra, ou ainda o resultado de uma busca na memria no qual o registrador destino utilizado pela instruo corrente. Os sinais de controle dos multiplexadores, AluSelA e AluSelB, so gerados no bloco de deteco de harzard. 9

PC + 4

ADD
Sign Extend Read Data 1 Memory Forward AluForward Read Data 2 Sign Extend
0

Shift Left 2

ADD Result

00

M U 01 X 10 source AluSelB
00

Zero

ULA
Result

M U X
1

M U 01 X 10 AluSelA AluForward ALU Control Instruo [31 - 26]

ALUSrc Memory Forward

Figura 3 - Estgio de Execuo

2.3.1.

Controle da ULA

O controle da ULA tem como entrada o opcode, ou seja, os 6 bits mais significativos da palavra de instruo e mais os 6 bits menos significativos da instruo, gerando a partir destes um sinal de trs bits para a ULA. Este sinal, denominado func, determina qual a operao que a ULA executar. Na Tabela 1, pode-se observar os cdigos e suas operaes correspondentes executadas pela ULA. Tabela 1 - Cdigos e Operaes da ULA Cdigo 000 001 010 110 111 Operao AND OR ADD SUB Set-on-less-than

Na Tabela 2, observa-se a tabela-verdade para a gerao do sinal de funo da ULA a partir de um sinal conhecido como ALUOp, gerado do opcode, e dos seis bits menos 10

significativos da instruo, utilizados apenas para as instrues do tipo R-format (instrues lgicas e aritmtica). Tabela 2 - Tabela-Verdade para Sinal da ULA ALUOp
AluOp1 AluOp0

0 X 1 1 1 1 1

0 1 X X X X X

F5 X X X X X X X

Cdigo da Funo (R-Format) F4 F3 F2 F1 F0 X X X X X X X X X X X 0 0 0 0 X 0 0 1 0 X 0 1 0 0 X 0 1 0 1 X 1 0 1 0

Operao da ULA 0 1 0 1 0 0 1 1 1 1 1 0 0 1 0 0 0 0 0 1 1

A partir da Tabela 2, obtm-se o circuito de controle da ULA, o qual pode ser observado na Figura 4.

AluOp1

AluOp0 Operation2

F3 F2 F1 F0

Operation1 Operation0

Figura 4 - Circuito de Controle da ULA

O sinal ALUOp, que obtido a partir do opcode da instruo, gerado nesta implementao no bloco de controle da ULA, e no no bloco de controle central conforme as outras verses consultadas [HEN98, BRO00]. Na Tabela 3, pode-se observar o ALUOp correspondente a cada instruo desta implementao do MIPS. Tabela 3 - ALUOp Correspondentes s Instrues Instruo Load e Store Beq R-format 00 01 1X ALUOp

11

2.4.

Estgio de Memria

O estgio de Memria (Figura 5), implementado atravs de um componente lpq_ram_qd da Altera, permite a leitura e a escrita no mesmo ciclo. A escrita habilitada apenas no final do ciclo e somente se o sinal MemWrite, que indica instruo de store, estiver ativo.
MemWrite

Data Memory Address Read Data

Write Data

MemRead

Figura 5 - Estgio de Memria A memria de dados foi implementada atravs de um bloco lpm_ram_dq da Altera [HAM00]. Este bloco permite dois acessos de leitura e um acesso de escrita no mesmo ciclo, sendo assim adequado implementao do MIPS pipeline.

2.5.

Estgio de Writeback

O estgio de Writeback alimenta o estgio de Decodificao com o valor a ser escrito no banco de registradores. Quando o dado a ser escrito resultado de uma instruo de leitura da memria (lw), o dado proveniente da memria selecionado. Caso contrrio, ser passado para o estgio de Decodificao o resultado da ULA.

2.6.

Unidade de Controle do MIPS

A unidade de controle implementada simples, consistindo de uma mquina de estados finitos (FSM). Esta gera, a partir da palavra de instruo, os seguintes sinais de controle: RegWrite - sinal que habilita a escrita no banco de registradores; MemToReg - sinal que indica que o dado a ser escrito no registrador de destino um dado vindo da memria; AluSrc - sinal que indica qual o segundo operando da ULA, podendo este ser o valor lido do segundo registrador, ou um deslocamento de 16 bits, vindo da palavra de instruo e

12

estendido para 32 bits que servir para o clculo do endereo para as instrues de load ou store. MemWrite - sinal que habilita a escrita na memria, gerado na instruo de store. MemRead - sinal que habilita a leitura da memria, gerado na instruo de load. Branch - sinal que indica uma instruo de branch e juntamente com o sinal de zero obtido aps o estgio de execuo determina se ocorrer ou no o salto. RegDst - sinal utilizado para selecionar o registrado destino.

3. Interligao dos Estgios


Aps a concluso da implementao dos estgios e da unidade de controle, passouse para a etapa de interligao dos estgios do pipeline. Nesta etapa, foi necessrio levantar todos os sinais que deveriam ser passados de um estgio para outro. Para interconectar dois estgios quaisquer do pipeline, foram usadas duplas de sinais. Na subida do relgio, o sinal copiado do primeiro para o segundo sinal, funcionando assim como um latch. Para os sinais de controle, foi utilizado um pipeline paralelo. Este pipeline, que comea no componente que gera os sinais de controle, cuida para que estes sinais acompanhem a instruo correspondente no pipeline de execuo e ajam nos ciclos corretos.

3.1.

Forwarding

Nos programas, possvel encontrar muitas dependncias de dados, que em um pipeline geram bolhas na execuo das instrues e afetam o desempenho do mesmo [HEN98]. Um exemplo de dependncia de dados quando uma instruo l um registrador escrito por uma instruo anterior. No caso de uma implementao pipeline, o registrador pode ainda no ter recebido o valor e, ento, a execuo da instruo que l este registrador pode obter um valor diferente do esperado. Uma soluo para contornar estas dependncias de dados fazer com que o pipeline espere at que o registrador receba o valor correto, atravs da deteco da dependncia e introduo de bolhas (stalls) no pipeline. Bolhas so instrues NOP que, desta forma, no modificam o estado do processador. Porm, como as dependncias de dados so comumente encontradas nos programas, a perda de desempenho ocasionada pelo uso do mecanismo de bolhas pode tornar-se muito elevada. Desta forma, foram desenvolvidos mecanismos que fornecem os valores dos registradores para o estgio de execuo antes que estes possam ser escritos no banco de registradores, chamados de forwarding [HEN98].

13

Foram criados caminhos para o forwarding de valores dos estgios de Memria e Writeback para o estgio de execuo. As dependncias entre instrues de load e qualquer outra instruo imediatamente posterior que leia o registrador de destino de instrues load apenas detectado, sendo ento inserida uma bolha no pipeline de instrues. O mecanismo de forwarding criado verifica se o registrador da dependncia o $0. Como o registrador $0 possui sempre o valor zero, o forwarding no deve atuar nestes casos.

3.2.

Deteco de Desvios

As instues de desvio condicional (branch) modificam o fluxo de controle do processamento caso uma determinada condio seja verificada. Assim como nas dependncias de dados, as dependncias de controle geradas pelos desvios devem ser devidamente tratadas, podendo ser usado tambm um mecanismo de bolhas para tanto. Desta forma, quando um desvio condicional encontrado, bolhas so introduzidas no pipeline at que seja conhecido o resultado da execuo do desvio. Outra forma, utilizada nesta implementao e de acordo com [HEN98], utiliza uma previso esttica de que o desvio sempre no tomado e continua buscando instrues quando da ocorrncia de uma instruo branch. Quando o desvio resolvido, o hardware de controle verifica se o desvio foi tomado. Neste caso, necessrio descartar as instrues buscadas depois da instruo de branch. Isto feito atravs do reset dos registradores entre os estgios de Busca e Decodificao e os estgios de Decodificao e Execuo. Como a escrita de registradores somente ocorre no estgio de Writeback, o reset dos registradores entre os estgios anteriores Execuo garante que o banco de registradores no ser alterado inadvertidamente.

14

4. Validao e Simulao
Para validar o processador MIPS pipeline desenvolvido neste trabalho, as simulaes foram desenvolvidas em duas fases. Inicialmente, os estgios e componentes foram simulados separadamente e os resultados foram comparados com os esperados. Aps obter resultados satisfatrios nestas simulaes, os estgios foram conectados e programas completos foram simulados. Os programas de teste criados exercitam cada uma das instrues implementadas. Estes programas so pequenos, dada a complexidade e dificuldade de visualizar os resultados em uma implementao pipeline. Alm de verificar a validade dos resultados, os aspectos de temporizao dos estgios devem ser observados. Os testes no foram mais complexos devido a restries de tempo e pessoal para a elaborao e execuo das mesmas. O forwarding de dados e os aspectos relacionados previso de desvios tambm foram verificados nestes testes, aumentando a complexidade desta validao. Os testes foram divididos em trs categorias, correspondentes aos trs tipos de instrues: Instrues R-format (lgico e aritmticas); Instrues de acesso memria (load e store); Instrues de desvio (branch).

4.1.

Teste R-Format

As instrues R-Format so processadas pelos estgios de Busca, Decodificao e Execuo. No estgio de Memria, os resultados so apenas repassados para o estgio de Writeback, que, por sua vez, passa os resultados de volta para o estgio de Decodificao, onde so finalmente escritos. O programa abaixo testa o resultado das operaes, bem como o forwarding e o armazenamento dos registradores:
00: 01: 02: 03: 04: 05: 430820; 621822; 231020; 421820; 611820; 30020; --add --sub --add --add --add --add $1, $3, $2, $3, $3, $0, $2, $3, $1, $2, $3, $0, $3 $2 $3 $2 $1 $3 10000110000100000100000 11000100001100000100010 1000110001000000100000 10000100001100000100000 11000010001100000100000 110000000000100000

Inicialmente, o valor 5 armazenado em $1, na linha 00. Depois, armazenado no registrador $3 o valor 1. Na linha 02, o registrador $2 recebe o valor 6. Em 03, o registrador $3 recebe o valor 12 (0C, em hexadecimal). Depois, o mesmo registrador $3 recebe 17 (hexadecimal 11). Finalmente, o valor do registrador $3 mostrado na linha 05.

15

Este cdigo possui diversas dependncias de dados. A Figura 6 mostra o grafo de dependncias entre as instrues. Os nodos representam as instrues, enquanto que os arcos representam as dependncias, sendo anotados com o registrador que causa a dependncia de dados verdadeira. As dependncias entre 01 e 02, 02 e 03, 03 e 04, 04 e 05 exercitam os caminhos de forwarding do estgio de Memria. J a dependncia entre 00 e 02 exercitam o caminho de forwarding proveniente do estgio de Writeback. Finalmente, a dependncia entre 00 e 04 resolvida pela escrita do registrador $1, no usando nenhum caminho de forwarding. 00 $1 01 $3 $1 02 $2 03 $3 04 $3 05 Figura 6 - Grafo de Dependncias A Figura 7 mostra o resultado da execuo do cdigo acima. O sinal ALUResultProbe mostra o resultado da ULA. Os sinais RegWriteAddrProbe e RegWriteDataProbe mostram o registrador destino e o dado a ser armazenado, respectivamente. Os sinais RegRead1Probe e RegRead2Probe mostram o valor lido do primeiro e do segundo registrador. Os sinais RegAddr1Probe e RegAddr2Probe mostram, respectivamente, os endereos do primeiro e do segundo registrador a serem lidos. Os resultados podem ser observados, neste caso, tanto na sada da ULA quanto no valor escrito nos registradores. Os valores obtidos com as simulaes correspondem aos valores esperados.

16

Figura 7 Resultado do Teste R-Format

4.2.

Teste de Acesso Memria

Para testar o acesso memria executado por instrues de load e store, foi utilizado o programa abaixo:
00: 01: 02: 03: 04: 05: 06: 8C010002; 8C220003; AC020006; 8C030006; 0; 0; 30020; --lw $1, 02($0) 10001100000000010000000000000010 --lw $2, 03($1) 10001100001000100000000000000011 --sw $2, 06($0) 10101100000000100000000000000110 --lw $3, 06($0) 10001100000000110000000000000110 --nop --nop --add $0, $0, $3

Adicionalmente, a memria de dados foi inicializada com os seguintes valores:


00: 01: 02: 03: 04: 05: 06: 00; 01; 02; 03; 04; 05; 06;

A linha 00 carrega o registrador $1 com o valor da clula de memria 02 (02). A instruo 01, por sua vez, busca o valor da memria 5 (5), havendo a necessidade de um stall (bolha) no pipeline porque o valor de $1 ainda no foi buscado na memria no ciclo em que 01 executa. Depois, o contedo do registrador $2 (5) armazenado na posio 06. Na instruo 03, o valor da memria 06 lido para o registrador $3. Finalmente, na instruo 06, o valor do registrador $3 (5) adicionado a zero.

17

O resultado da execuo deste teste pode ser observado na Figura 8. Alm dos sinais utilizados na Figura 7, outros sinais importantes para a anlise dos resultados so mostrados. O sinal RegWriteSignalProbe mostra o valor do sinal de escrita do registrador. Apenas na execuo das instrues de store, para este programa, o sinal RegWriteSignalProbe permanece em zero.

Figura 9 Resultado do Teste de Acesso Memria Figura 8 Resultado do Teste de Acesso Memria O sinal PCProbeFD mostra o endereo da instruo que est no estgio de Decodificao. Os sinais MemoryReadProbe e MemoryWriteProbe mostram os valores que esto sendo lidos e escritos na memria de dados. J o sinal MemoryWriteSignalProbe mostra o sinal de escrita na memria. No caso de acessos memria, o endereo o resultado da ULA. Assim, o sinal ALUResultProbe pode ser utilizado para observar este valor. Nesta implementao do MIPS, as bolhas no pipeline so criadas apenas quando uma instruo qualquer possui uma dependncia de dados verdadeira em relao a uma instruo de load que imediatamente lhe antecede. Neste caso, necessrio esperar por um ciclo antes que o valor correto do registrador seja lido da memria. A primeira implementao do MIPS no tratava deste tipo de dependncia no caso de loads, exigindo que o compilador colocasse uma instruo independente seguindo estas instrues [HEN98]. Atravs da anlise do cdigo, verifica-se que h duas dependncias de dados verdadeiras, entre 00 e 01 e entre 01 e 02. Como as dependncias referem-se a instrues imediatamente seguintes loads, so necessrias duas bolhas para obter o resultado correto. O programa executou corretamente quando, no final, o registrador $3 recebe o valor 5, como observado na Figura 8. Desta forma, este programa executou corretamente.

18

4.3.

Teste da Instruo de Desvio

A instruo beq (branch if equal) foi a nica instruo de desvio implementada. As instrues de desvio condicional do MIPS utilizam um deslocamento, que adicionado ao valor do PC da instruo incrementado de 4. O programa utilizado para testar a instruo de desvio beq simplesmente compara o valor do registrador $0 com o prprio, sempre saltando para a posio 00 novamente, como o cdigo abaixo.
00: 1000FFFC; --beq $0, $0, FFFC 10000000000001111111111111100

O resultado da simulao deste programa pode ser observado na Figura 10. A primeira instruo buscada, representada no sinal FetchedInstruction, H1000FFFC, cujo opcode 04 (sinal OpcodeProbe). Depois, esta instruo buscada novamente. Assim, o programa fica neste lao, sem nunca terminar. Portanto, a instruo funcionou adequadamente.

Figura 9 Resultado do Teste da Instruo de Desvio Condicional

19

5. Concluses
Neste trabalho, foi desenvolvida uma verso pipeline do MIPS em VHDL. O microprocessador resultante coube em um FPGA EPF10K30EFC484-1, utilizando 1310 clulas lgicas e 16384 bits de memria. Neste chip, foram encerrados todos os blocos bsicos para um microprocessador, inclusive uma memria de instrues e uma memria de dados. Apesar de j contar com uma verso multiciclo em VHDL do processador MIPS [HAM00], vrias dificuldades foram encontradas no desenvolvimento e validao desta verso pipeline. A ferramenta utilizada, Altera MAX+plus II, apresenta eventualmente problemas internos, sendo ento necessrio apagar todos os arquivos por ela gerados e recompilar todo o projeto. Alm disto, a ferramenta no compila automaticamente todas as dependncias de um determinado projeto, sendo necessrio compilar um a um os arquivos com as constantes, tipos e packages. A temporizao do pipeline e a verificao dos resultados foi outra tarefa difcil. Facilidades de sada (impresso na tela) no esto disponveis nesta verso do MAX+plus II, dificultando a depurao. O desenvolvimento de programas de teste, sem um assembler, uma tarefa que, por si s, j complexa e que facilmente pode apresentar erros. Como trabalhos futuros, possvel descrever este processador em RTL (Register Transfer Level), podendo ento comparar e validar os resultados dos dois modelos. O conjunto de instrues suportado pode ser acrescido de outras instrues ou tipos de endereamento.Tambm podem ser implementadas outras tcnicas para a explorao do paralelismo em nvel de instruo como, por exemplo, previsores de desvios dinmicos. Outro trabalho possvel trocar componentes por novas verses, mais otimizadas. Esta descrio tambm pode ser utilizada como caso de teste para disciplinas da rea de Microeletrnica.

20

6. Bibliografia
[BRO00] BROWN, S.; VRANESIC, Z. Fundamentals of Digital Logic with VHDL Design. Boston: McGraw-Hill, 2000. [HAM00] HAMBLEN, J. O.; FURMAN, M. D. Rapid Prototyping of Digital Systems: a tutorial approach. Boston: Kluwer Academic Publishers, 2000. [HEN98] HENESSY, J. L.; PATTERSON, D. A. Computer Organization and Design: the hardware/software interface. San Francisco: Morgan Kaufmann Publishers, 2. ed, 1998.

21

Você também pode gostar