Copuri BAB - Implementação de conjunto de instruções para uma máquina RISC em FPGA

I

MPLEMENTAÇÃO DE CONJUNTO DE INSTRUÇÕES PARA UMA MÁQUINA

RISC

EM

FPGA

Bernardo Auzier Bentes Couri

Orientador: Prof. Dr. Maurílio Pereira Coutinho

Instituto de Engenharia de Sistemas e Tecnologias da Informação (IESTI)

Resumo - Este artigo tem como objetivo apresentar a implementação e simulação de um subconjunto do conjunto de instruções do microprocessador RISC MIPS em FPGA utilizando VHDL. Ao final do traba-lho é apresentado alguns resultados da simulação u-sando o sistema de desenvolvimento da Altera Quar-tus II.

Palavras-Chave: Arquitetura do conjunto de instru-ções, máquinas RISC, linguagens de descrição de hardware.

I – INTRODUÇÃO

A disciplina de ECO-007-Computadores Digitais do curso de Engenharia de Computação da Universidade Federal de Itajubá tem por objetivo o projeto e a imple-mentação da arquitetura do conjunto de instruções de processadores. A complexidade que envolve tal assunto muitas vezes impede os alunos de compreender melhor como os processadores são implementados. O livro texto adotado no curso [1], apresenta de forma didática este estudo, de tal forma que os alunos da disciplina possam entender as diversas fases do desenvolvimento e imple-mentação de processadores. Com um texto bem organi-zado, são apresentados aos alunos os aspectos relevantes do projeto de máquinas RISC, sempre levando em conta os quatro princípios do projeto de conjunto de instruções para a obtenção de uma solução balanceada.

Este artigo tem por objetivo apresentar a implementação do modelo projetado no capítulo 5 do livro texto [1], mais especificamente o projeto de um processador de ciclo único (single cycle processor). A intenção deste trabalho é apresentar a solução de estudo inicial, para que os futu-ros alunos da disciplina ECO-007 possam acrescentar ao projeto básico, novas instruções, novas metodologias de temporização, pipelining, etc. Isto fornecerá um ponto de partida para os futuros alunos, fazendo com que possam

se concentrar no desenvolvimento de novos exem-plos/metodologias.

A implementação proposta considera o seguinte subcon-junto de instruções do processador MIPS:

 Instruções de referência à memória load word (LW) e store word (SW);

 Instruções aritméticas (ADD e SUB);  Instruções Branch e Jump (BEQ e JMP);

Ao examinar a implementação, os alunos terão a oportu-nidade de ver como a arquitetura do conjunto de instru-ções determina muitos aspectos da implementação e, também, como a escolha de outras estratégias de imple-mentação afetam a taxa de clock e o CPI da máquina. Muitos dos conceitos utilizados para implementar o sub-conjunto do MIPS neste artigo são as mesmas idéias bá-sicas que são utilizadas para construir uma ampla gama de computadores, de máquinas de alto desempenho a microprocessadores de propósito geral e processadores de propósito especial.

II – VISÃO GERAL DA IMPLEMENTAÇÃO

A Fig. 1 apresenta a visão geral da implementação de um processador MIPS. Todas as instruções propostas no item I para implementação possuem os dois primeiros passos idênticos:

 Enviar o contador de programa (PC) para a me-mória que contém o código e buscar a instrução da memória;

 Ler 1 ou 2 registros, usando os campos apropri-ados do opcode da instrução para identificar os registradores.

T

RABALHO

F

INAL DE

G

RADUAÇÃO

O

UTUBRO

/2011

U

NIVERSIDADE

F

EDERAL DE

I

TAJUBÁ

Após estes dois passos, as ações necessárias para comple-tar a instrução dependerão da classe da instrução. Feliz-mente, para cada uma das três classes de instruções, as ações são na maioria as mesmas. Por exemplo, todas as instruções usam a ALU, após a leitura dos registros. Após o uso da ALU, as ações para completar a execução das instruções diferem um pouco para cada classe.

Fig.1 – Visão Geral da Implementação[1]

A implementação do modelo proposto foi desenvolvido em VHDL. O software escolhido para projetar e simular foi o Quartus II Web Edition, tendo como base a FPGA de baixo custo da Altera, Cyclone 2 – EP2C20. Esta FP-GA trabalha com no máximo 250MHz e fornece uma memória interna de 239,616 bits (29.25 Kbytes).

III – ARQUITETURA DO CONJUNTO DE

INSTRU-ÇÕES

O MIPS possui uma arquitetura do conjunto de instruções do tipo Load/Store. Isto significa que todas as operações aritméticas e lógicas são realizadas utilizando operandos armazenados em seus registradores internos. A memória de dados é acessada apenas pelas instruções Store Word (SW) e Load Word (LW) para armazenar o conteúdo do registrador ou fornecer dados a um registrador, respecti-vamente.

O processador MIPS possui 32 registradores de 32 bits de uso geral (denominados $0-$31), sendo que o registrador $0 é sempre igual a zero. No modelo proposto neste arti-go estes registradores foram implementados como um vetor de 32 posições, sendo que cada posição possui 32 bits. Para efeito de testes da implementação, todos os registradores foram inicializados com zero. O código VHDL para a definição da arquitetura da entidade é dada a seguir:

Declaração do vetor:

type register_file is array (0 to 31) of std_logic_vector (31 downto 0);

Inicialização dos registradores:

for i in 0 to 31 loop

register_array(i)<=conv_std_logic_vector(0,32); end loop;

A arquitetura do conjunto de instruções do MIPS organi-za suas instruções em palavras de 32 bits de comprimen-to. Em geral estas instruções são organizadas em 6 cam-pos conforme representado na Fig. 2. Estes camcam-pos cam- pos-suem os seguintes significados:

 Campo opcode: especifica a operação básica da instrução, tradicionalmente chamado de código de operação (opcode);

 Campo RS: primeiro registro do operando fonte;  Campo RT: segundo registro para o operando

fonte;

 Campo RD: registro do operando destino;  Campo SHMT: Número de deslocamentos, para

instruções de Shift;

 Campo FUNCT: Campo que seleciona uma va-riação da operação especificada no campo opco-de;

Fig.2 – Formato geral de instrução do MIPS Embora algumas instruções pudessem trazer conflito com este formato geral (por exemplo, as instruções L/S preci-sam de um campo para especificar o deslocamento do endereço), uma solução de compromisso foi tomada pelos projetistas que mantiveram o tamanho de 32 bits, mas criaram 3 diferentes formatos de instruções, como apre-sentado na Tabela 1. Nesta solução foi adotado que o deslocamento usado nas instruções L/S e nas instruções de desvio o tamanho do campo para especificar o deslo-camento do endereço é de 16 bits. A vantagem é queo formato original dos campos foi mantido, o que facilita sobremaneira no momento da implementação da unidade controle.

TABELA 1–TIPOS DE INSTRUÇÕES

A fig. 3 apresenta as instruções do MIPS consideradas para implementação. Nesta figura estão especificados o formato (R,I,J), o valor do campo opcode e um exemplo para cada instrução.

Deste subconjunto de instruções do MIPS foram escolhi-das as instruções apresentaescolhi-das na Tabela 2 para a imple-mentação proposta. Este subconjunto apresenta exemplos de instruções dos três possíveis tipos de instruções, além de incorporar exemplos de instruções do grupo aritméti-co, Load/Store e desvio incondicional. Desta forma esta implementação pode ser considerada um caso base para

que novas instruções e metodologias possam ser adicio-nadas, durante o desenvolvimento da disciplina ECO-007.

Fig.3 – Resumos das Instruções do MIPS[1]

TABELA 2–INSTRUÇÕES IMPLEMENTADAS

Outro ponto de simplicidade da arquitetura apresentada reside no fato do número reduzido de modos de endere-çamento. Esta é uma característica dos projetos de má-quina RISC. A Fig. 4 apresenta um resumo destes modos de endereçamento. No caso proposto existe somente um tipo de modo de endereçamento para acesso a dados na memória usado pelas instruções Load/Store. Os outros modos que serão usados no modelo proposto são registro (instruções aritméticas) e endereçamento pseudo-direto (instrução Jump).

Fig. 3 – Modos de endereçamento do MIPS[1]

IV – IMPLEMENTANDO A VIA DE DADOS

Antes de iniciar o projeto do processador proposto, deve-se decidir como a lógica de implementação da máquina deverá operar e como as operações da máquina serão sincronizadas (Metodologia do Clock). Da figura 1, nota-se que os elementos funcionais da implementação propos-ta consistem de dois tipos de dispositivos lógicos: ele-mentos que operam sobre dados (eleele-mentos combinacio-nais) e elementos que contém estado (elementos sequen-ciais). Um elemento de estado deve conter alguma forma de armazenamento interno, como por exemplo, registra-dores. Em geral este elemento deve conter ao menos 2 entradas e 1 saída, Uma das entradas deve ser o sinal de clock, que determina quando os dados serão armazenados na memória interna do elemento.

A metodologia de clock define no projeto quando os si-nais podem ser lidos (operação read) e quando eles po-dem ser escritos (operação write). É importante especifi-car a temporização destas operações, pois é inaceitável uma situação onde pode-se ter ao mesmo tempo uma ope-ração de read e write. Qual será o valor lido: o anterior ao write ou o novo valor? No modelo proposto será adotada a metodologia de “edge-triggered clocking”. Isto siginfi-ca que todos os estados da máquina serão atualizados na subida ou descida do sinal de clock ( transição do clock ou “clock edge”).A Fig. 4 apresenta 1 elemento combina-cional entre 2 elementos de estado, operando num modelo “single-cycle”: todos os sinais devem propagar do ele-mento de estado 1, através da lógica combinacional, para o elemento de estado 2 num único ciclo de clock. O tem-po necessário para os sinais alcançarem o elemento de estado 2, a partir de elemento de estado 1, define o com-primento do ciclo de clock (Caminho Crítico).

Fig.4 – Metodologia de Clock.

A implementação proposta utiliza um único ciclo de clock para todas as instruções e segue o modelo geral apresentado na Fig. 1. Desta forma, toda instrução come-ça a execução na transição do clock (“clock edge”) e completa a execução na próxima transição do clock. Embora didático este modelo não é prático, pois a im-plementação seria mais lenta que um modelo que permi-tisse que diferentes classes de instruções pudessem utili-zar número de ciclos de clock diferentes e, por conse-guinte, gastassem menos tempo por instrução.

Da Fig.1 podemos extrair os maiores componentes para a execução de cada classe de instrução do MIPS. São eles: Bloco Busca da Instrução, Bloco da Decodificação da

Elemento de estado 1 Lógica combinacional Elemento de estado 1 Clock

Instrução, Bloco da Execução, Bloco do Acesso à Memó-ria e Bloco Writeback.

Desta forma o projeto será divido em 5 grandes blocos. No entanto, para facilitar a programação da unidade de controle, que pertence ao Bloco da Decodificação da Ins-trução, esta unidade foi separada em um bloco próprio. O Bloco Writeback é uma combinação das saídas dos blo-cos de Acesso à Memória e Execução.

A seguir será apresentado a descrição de alto nível usan-do VHDL de cada um usan-dos blocos envolviusan-dos no processo de implementação do modelo proposto.

IV.1 – Bloco Busca da Instrução

Este bloco tem por objetivo obter a instrução da memória de instruções utilizando o valor atual do contador de pro-grama (PC). A memória de dados foi implementada con-siderando dados de 8 bits de comprimento (o processador MIPS é byte addressable e big-endian). Desta forma se fez necessário modificar o acesso a memória de instru-ções (32 bits cada), utilizando um somador de 4 na entra-da do PC. Para fins de programação esta unientra-dade será também responsável pela escolha do próximo valor do PC (Next_PC), como mostrado na Fig. 5.

Fig.5 – Busca da instrução.

Para visualizar o resultado desta busca na simulação, foi adicionado um sinal de saída igual a PC_Plus_4. Além disso, as unidades “Instruction Memory” e “PC” estão sincronizadas com um sinal de clock.

Segue a programação da unidade: entity instrfetch is

port(signal pc_out : out std_logic_vector(7 downto 0); signal instruction : out std_logic_vector(31 downto 0); signal add_result : in std_logic_vector(7 downto 0); signal pc_plus_4_out : out std_logic_vector(7 downto 0);

signal branch : in std_logic; signal branch_ne : in std_logic; signal zero : in std_logic; signal jump : in std_logic;

signal jump_address : in std_logic_vector(7 downto 0); signal clock, reset,clock2 : in std_logic);

end instrfetch;

A memória de instruções contida neste bloco foi imple-mentada utilizando o gerenciador de MegaFunções do software WebQuartus II, como apresentado na Fig.6.

Fig.6 – Configuração da Memória de Instruções. Esta memória foi configurada com 8192bits (256 palavras de 32bits) e o método de clock configurado como tipo

Clock Único. Por esse motivo foi necessário adaptar o

Contador de Programa, visto que a porta “endereço” que a memória recebe deve conter no máximo 8 bits. Isto não afeta o microprocessador, visto que ao receber os 32bits como endereço apenas os 8 primeiros serão lidos.

A FPGA utilizada não permite o uso de memória RAM/ROM assíncrona.

IV.2 – Bloco da Unidade de Controle

Este bloco é responsável por enviar 9 sinais de controle aos demais módulos, baseado no “opcode”. As denomi-nações dos sinais de controle seguem:

- “RegDst”: determina se o número do registrador-destino onde será escrito o resultado da operação vem dos bits 20 a 16 ou 15 a 11 da instrução de 32 bits;

- “Jump”: indica que o opcode é de uma instrução JMP; - “Branch”: Indica que o opcode é de uma instrução de desvio condicional (BEQ ou BNE);

- “MemRead”: garante que a saída de leitura de dados receberá o conteúdo da memória designado pela entrada de endereço;

- “MemtoReg”: determina se o valor na entrada do regis-trador de escrita vem da ALU ou da memória de dados; - “ALUOp”: determina qual a função que a ALU irá exe-cutar (e.g. add ou sub);

- “MemWrite”: é utilizado quando uma instrução Store escreve na memória de dados;

- “ALUSrc”: informa à ALU se o seu segundo operando vem do segundo registrador do banco de registradores ou se é o resultado da extensão de sinal;

- “RegWrite” é ativado ao escrever no banco de registra-dores

Fig.7 – Bloco Unidade de Controle.

A seguir é apresentada a descrição de alto nível em VH-DL para o bloco da unidade de controle:

entity controlunit is

port(signal opcode : in std_logic_vector (5 downto 0); signal regdst : out std_logic;

signal branch : out std_logic; signal branch_ne : out std_logic; signal memread : out std_logic; signal memtoreg : out std_logic;

signal alu_op : out std_logic_vector (1 downto 0); signal memwrite : out std_logic;

signal alusrc : out std_logic; signal regwrite : out std_logic; signal jump : out std_logic);

end controlunit;

IV.3 – Bloco de Decodificação da Instrução

A principal função deste bloco, apresentado na Fig.8, é decodificar os campos da instrução recebida do bloco de Busca da Instrução, identificando os registros a serem acessados, fazendo extensão sinalizada dos bits de 15 a 0 para um valor de 32 bits, indicando qual registro será escrito, etc. A seguir é apresentada a descrição de alto nível em VHDL para o bloco de decodificação da instru-ção:

entity operandfetch is

port( read_data_1 : out std_logic_vector (7 downto 0); read_data_2 : out std_logic_vector (7 downto 0); write_reg : out std_logic_vector (4 downto 0); regwrite : in std_logic;

regdst : in std_logic;

alu_result : in std_logic_vector (7 downto 0); memtoreg : in std_logic;

read_data : in std_logic_vector (7 downto 0); instruction : in std_logic_vector (31 downto 0); sign_extend : out std_logic_vector (7 downto 0); jump_instr : out std_logic_vector (7 downto 0); clock, reset : in std_logic);

end operandfetch;

IV.4 – Bloco Execução

O bloco execução contém a ALU, que é responsável por realizar a operação determinada pelo sinal de controle ALUop. Em um somador separado da ALU, é realizado o cálculo do desvio relativo ao PC, através da soma de PC+4 com o valor do deslocamento com sinal extendido e deslocado de 2 bits a esquerda. A Fig. 9 apresenta o diagrama para o bloco execução. A descrição de alto ní-vel em VHDL para a ALU, o somador (“Add”) e o con-trole da ALU (“ALU control”) é apresentada a seguir: entity execution is

port( read_data_1 : in std_logic_vector (7 downto 0); read_data_2 : in std_logic_vector (7 downto 0); sign_extend : in std_logic_vector (7 downto 0); alusrc : in std_logic;

zero : out std_logic;

alu_result : out std_logic_vector (7 downto 0); funct_field : in std_logic_vector (5 downto 0); alu_op : in std_logic_vector (1 downto 0); add_result : out std_logic_vector (7 downto 0); pc_plus_4 : in std_logic_vector (7 downto 0); jump_instr : in std_logic_vector (7 downto 0); jump_address : out std_logic_vector (7 downto 0));

end execution;

Fig.8 – Bloco Decodificação da Instrução.

IV.5 – Bloco Memória de dados

A Memória de dados é utilizada apenas por instruções do tipo “Load” e “Store”. Uma instrução do tipo “Load” ativa o sinal de controle “MemRead” e utiliza o resultado da saída da ALU como sendo o endereço de memória para acessar o dado. O dado lido é então escrito no banco de registros. Uma instrução do tipo “Store” ativa o sinal de controle MemWrite e escreve o dado, obtido do banco de registros, no endereço de memória calculado pela ALU.

Fig.9 – Bloco Execução.

Fig. 10 apresenta o diagrama do bloco memória de dados com os sinais de controle utilizados para acessar a Memó-ria de dados.

Fig.10 – Unidade de Memória de dados. A Memória de Dados, tal como a Memória de Instruções, foi implementada utilizando o gerenciador de megafun-ções do software WebQuartus II, como pode ser visto na Fig.11.

Fig.11 – Configuração da Memória de Dados. Dada a limitação de memória da FPGA, a Memória de Dados foi definida como 256 palavras de 32 bits. Desta forma, apesar do MIPS poder trabalhar com até 232 bytes, a capacidade da memória foi restrita a 28 bytes. A Fig. 12 apresenta o diagrama completo para implementação do modelo single-cycle bem como os sinais de controle para cada tipo de instrução.

Fig. 12- Diagrama Completo para Máquina RISC Single-Cycle[1]

V – SIMULAÇÃO E RESULTADOS

A fim de testar a funcionalidade desta implementação, foi utilizado um arquivo de inicialização de memória para a RAM e outro para a ROM, onde foi inserido os dados da Tabela 3 na RAM e a sequência de instruções da Tabela 4 na ROM. Considerar para efeitos de teste que os registra-dores foram inicializados em 0, como especificado no item III.

TABELA 3–MEMÓRIA DE DADOS Endereço Dado 0x00000000 0x0000000A 0x00000001 0x0000000B

A primeira coluna “Endereço” representa os endereços de cada instrução em números hexadecimais. O PC irá sem-pre apontar para um desses endereços. A segunda coluna é composta pelo opcode das instruçõe em formato hexa-decimal.

TABELA 4–MEMÓRIA DE INSTRUÇÕES

Endereço Instrução 0x00 0x00000000 0x01 0x8C010001 0x02 0x00211020 0x03 0x00201822 0x04 0xAC010000 0x05 0x8C040000 0x06 0x00841020 0x07 0x08000000

A Tabela 5 apresenta um resumo das operações e os re-sultados esperados após a execução de cada instrução.

TABELA 5–RESULTADOS ESPERADOS

Endereço Instrução Operação Resultado

0x00 0x00000000 NOP - - - 0x01 0x8C010001 LW $1, 1($0) $1=0x0000000B 0x02 0x00211020 ADD $2, $1, $1 $2=0x00000016 0x03 0x00201822 SUB $3, $1, $0 $3=0x0000000B 0x04 0xAC010000 SW $1, 0($0) 0x00=0x000000 0B 0x05 0x8C040000 LW $4, 0($0) $4=0x0000000B 0x06 0x00842820 ADD $5, $4, $4 $5=0x00000016 0x07 0x08000000 JMP $0 PC=0x00

A terceira coluna da Tabela 5 é composta pela operação que será processada dada a instrução. A quarta coluna fornece o resultado esperado após o ciclo da instrução.

A Fig. 13 apresenta o resultado da simulação usando o software Quartus II.

Fig.13 – Resultado da primeira simulação. Pode-se observar que o resultado obtido não condiz com o esperado. Isto se deve a falta de sincronismo entre a memória de dados/instruções com as outras unidades. Para solucionar este problema, foi gerado um Clock mais rápido para as memórias, denominado clock_principal. Esta solução pode ser analisada na Fig.14.

Fig.14 – Resultado utilizando 2 clocks. A simulação completa pode ser vista no Anexo 1. Ao compilar o programa, o software faz uma análise de tempo de resposta de seus componentes que estão sendo utilizados e gera um relatório, que será utilizado para definir o Clock desta simulação. Segue na Fig.15 o resul-tado desta operação. Será definido um Clock menor, a fim de garantir a funcionalidade do projeto. O Clock má-ximo será então de 50MHz, para acessar as memórias. Por facilidade de programação, o Clock para as demais

unidade será definido como metade do Clock das memó-rias.

Fig.15 – Análise de tempo.

V. CONCLUSÃO

Foi apresentado a implementação de um subconjunto das instruções do microprocessador RISC MIPS, conforme descrito em [1]. A implementação utilizou as ferramenta Quartus II para definição do código VHDL e para as si-mulações do modelo implementado. Os resultados obti-dos foram satisfatórios para o que se propunha incialmen-te. Utilizou-se para implementação em hardware a FPGA de baixo custo da Altera, Cyclone II. Deve-se levar em conta a questão limitante da tecnologia utilizada em rela-ção a implementarela-ção das memórias de instrurela-ção e de dados. Embora diferente da especificação inicial, os re-sultados obtidos na simulação foram satisfatórios. Como trabalhos futuros podemos citar a implementação de novas instruções, utilização do modelo de multicycle, implementação de pipelining, memória cachê, etc. Estes pontos serão melhor discutidos na disciplina de ECO-007.

VI. AGRADECIMENTOS

Agradeço ao orientador Prof. Maurílio Pereira Coutinho pela oportunidade e pela ajuda na realização deste proje-to. Agradeço também ao Prof. Robson Luiz Moreno e ao Thiago Pouza Mussolini pelo suporte, e aos amigos e familiares pelo incentivo ao longo de minha graduação.

REFERÊNCIAS

[1] Hennessy,J.L., Patterson, D.A., “Computer Organi-zation and Design: The Hardware and Software In-terface”, 3ª Edição, 2005, Morgan and Kaufmann Pub., USA.

BIOGRAFIA:

Bernardo Auzier Bentes Couri

Nasceu em Santos Dumont (MG), em 1988. Estudou em Santos Dumont e Juiz de Fora. Ingressou na UNIFEI em 2006. Realizou estágio no LAB. DE MÁQUI-NAS da UNIFEI e atualmente esta esta-giando na SCHNEIDER ELECTRIC.