UNIVERSIDADE FEDERAL DO ESTADO DE SÃO PAULO

BRUNO HIDEKI AMADEU OGATA

Implementação da Unidade Central de Processamento

em Verilog

São José dos Campos

2021
 BRUNO HIDEKI AMADEU OGATA

RA: 140884

Implementação da Unidade Central de Processamento

em Verilog

Relatório apresentado ao curso:

Laboratório de Sistemas
Computacionais: Arquitetura e
Organização de Computadores.

São José dos Campos

2021
 RESUMO

Aqui serão descritas as etapas seguidas para a implementação da

Unidade Central de Processamento ou Central Process Unit (CPU), mostrando
cada uma de suas unidades funcionais. A implementação será feita na
linguagem de descrição de hardware Verilog e baseada na arquitetura MIPS,
como descrito no relatório anterior para o ponto de checagem 1.

Palavras-chaves: Unidades funcionais, ALU, Unidade de Controle, Verilog.

 LISTA DE ILUSTRAÇÕES

Figura 1. Esquemático do processador MIPS......................................................9

Figura 2. Código do Program Counter em Verilog.............................................10
Figura 3. Código da Memória de Instruções em Verilog....................................10
Figura 4. Código do Banco de Registradores em Verilog..................................11
Figura 5. Código do Extensor de Bit em Verilog................................................12
Figura 6. Código da ULA em Verilog..................................................................13
Figura 7. Código do Controle da ALU em Verilog..............................................14
Figura 8. Código do Multiplexador de 5 bits em Verilog....................................14
Figura 9. Código do Multiplexador de 32 bits em Verilog..................................15
Figura 10. Código da Memória de Dados em Verilog........................................15
Figura 11. Parte do código da Unidade de Controle em Verilog.......................16
Figura 12. Código da CPU em Verilog...............................................................17
Figura 13. Waveform para teste da Memória de Instruções..............................18
Figura 14. Teste em waveform do Banco de Registradores..............................18
Figura 15. Teste em waveform da ULA..............................................................19
Figura 16. Teste em waveform da Memória de Dados......................................19
 SUMÁRIO

1 Introdução......................................................................................................6

2 Objetivos........................................................................................................7

2.1 Geral.............................................................................................................................7
2.2 Específicos....................................................................................................................7
3 Fundamentação Teórica................................................................................8

3.1 Verilog..........................................................................................................................8
3.2 Central Process Unit (CPU)...........................................................................................8
4 Desenvolvimento..........................................................................................10

4.1 Program Counter (PC).................................................................................................10

4.2 Memória de Instruções..............................................................................................10
4.3 Banco de Registradores..............................................................................................11
4.4 Extensor de Bit...........................................................................................................12
4.5 Unidade Lógica e Aritmética (ULA).............................................................................12
4.6 Controle da ALU.........................................................................................................13
4.7 Multiplexadores.........................................................................................................14
4.8 Memória de Dados.....................................................................................................15
4.9 Unidade de Controle..................................................................................................15
4.10 CPU.............................................................................................................................17
5 Resultados e Discussões.............................................................................18

6 Considerações Finais...................................................................................20

Referências.........................................................................................................21
 6

1 Introdução

Atualmente, máquinas como computadores e celulares são muito

comuns ao redor do mundo todo. Essas máquinas citadas possuem diversos
componentes internos, sendo um deles o processador.
Para podermos observar mais de perto o funcionamento de um
processador, a disciplina Laboratório de Sistemas Computacionais: Arquitetura
e Organização de Computadores é essencial, pois aqui projetaremos um
processador do zero, na linguagem de descrição de hardware Verilog, sendo
nesse caso baseado na arquitetura MIPS.
Nessa etapa do projeto será desenvolvida a Unidade Central de
Processamento, peça fundamental na execução das instruções anteriormente
definidas.
 7

2 Objetivos

2.1 Geral
Implementar a Unidade Central de Processamento em Verilog.

2.2 Específicos
 Implementar o Program Counter (PC);
 Implementar a Memória de Instruções
 Implementar o Banco de Registradores;
 Implementar a Unidade Lógica e Aritmética (ULA);
 Implementar a Memória de Dados;
 Implementar a Unidade de Controle;
 Testar as unidades funcionais.
 8

3 Fundamentação Teórica

3.1 Verilog
Verilog é uma linguagem de descrição de hardware, criada por Prabhu
Goel e Phil Moorby, para a empresa Automated Integrated Design Systems. É
usada para implementar projetos a nível de circuito e além disso fornece maior
rapidez e facilidade em sua implementação em relação à projetos em
esquemático.
É possível descarregar os códigos feitos em Verilog em FPGAs, por
meio de suas placas de desenvolvimento com base em circuitos integrados.

3.2 Central Process Unit (CPU)

A Unidade Central de Processamento é o “cérebro” de um sistema
computacional. É onde se realizam as instruções, assunto do relatório anterior.
Os principais componentes de uma CPU são:
 A ULA (Unidade Lógica e Aritmética) usada para realizar operações
lógicas como AND e OR e operações aritméticas como a soma e
subtração;
 A UC (Unidade de Controle) responsável por selecionar os valores que
passaram pelos multiplexadores, dependendo das instruções, controlar
as flags como Alu_Op e a Alu_Src, por exemplo;
 Os registradores usados para armazenar os dados das instruções.
No caso deste projeto a CPU terá, além desses, outros componentes
como o Program Counter (PC), a Memória de Instruções, a Memória de Dados
e muitos multiplexadores, como mostra a Figura 1 a seguir:
 9

Figura 1. Esquemático do processador MIPS

Fonte: Referência [1].

 10

4 Desenvolvimento

4.1 Program Counter (PC)

O Program Counter ou Contador de Programa foi a primeira unidade
funcional a ser implementa nesse projeto. Na Figura 2 abaixo está o código do
PC em Verilog.
Figura 2. Código do Program Counter em Verilog

Fonte: Autor.

Foi acrescentada uma função de Reset nele para caso necessária

futuramente, pois nas instruções que foram definidas por enquanto essa função
não é necessária. O cálculo do ProxPC será feito em um módulo de um
multiplexador que será citado mais adiante.

4.2 Memória de Instruções

A memória de instruções é a responsável por decodificar as instruções.
A seguir na Figura 3 temos a memória de instruções:
Figura 3. Código da Memória de Instruções em Verilog

Fonte: Autor.
 11

Para a implementação da Memória de Instruções foi utilizado um

template fornecido pelo Quartus. Nela é lido um arquivo .txt com as instruções
a serem executadas pelo processador previamente escritas nele, na seção de
Resultados e Discussões será apresentado um teste em waveform com
algumas instruções inseridas nesse arquivo, mostrando o funcionamento da
memória.

4.3 Banco de Registradores

O banco de registradores do MIPS é formado por 32 registradores de 32
bits. A partir disso, a seguir é mostrado na Figura 4 o código em Verilog do
banco de registradores.
Figura 4. Código do Banco de Registradores em Verilog

Fonte: Autor.

Repare que quando a flag “Reg_Write” é ativada pela Unidade de

Controle é feita a escrita em um dos registradores, do valor contido em
“Reg_dados”.
 12

4.4 Extensor de Bit

O extensor de bit é utilizado para transformar uma entrada de 16 bits em
uma saída de 32 bits, para o caso das instruções do tipo I, que possuem um
espaço para o valor imediato de 16 bits. Abaixo, na Figura 5, está sua
implementação em Verilog.
Figura 5. Código do Extensor de Bit em Verilog

Fonte: Autor.

4.5 Unidade Lógica e Aritmética (ULA)

A Unidade Lógica e Aritmética pode realizar as seguintes operações:

 A + B;
 A – B;
 A x B;
 A / B;
 A and B;
 A or B;
 NOT(A);

A seguir, na Figura 6, foi implementado o código da ULA em Verilog.

 13

Figura 6. Código da ULA em Verilog.

Fonte: Autor.

A flag “ALU_Ctrl” vem da unidade funcional Controle da ALU que será

descrita a seguir e é responsável por selecionar na ULA a operação a ser
realizada.

4.6 Controle da ALU

O Controle da ALU é o responsável por indicar para a Unidade Lógica e
Aritmética qual operação deve ser realizada. Como foi citado no PC1, no
Controle da ALU as operações serão diferenciadas pelo seu OpCode e não
pelo campo Funct, pois no momento há poucas instruções então acaba não
 14

afetando como um todo. Desse modo, abaixo na Figura 7 está o código em

Verilog do Controle da ALU.
Figura 7. Código do Controle da ALU em Verilog

Fonte: Autor.

No caso das instruções do Tipo R, a Unidade de Controle mandará a

ALU_Op com o valor 1, para os casos das instruções do Tipo I, essa flag
chegará até o Controle da ALU com o valor 0. Desse modo, a ALU_Ctrl recebe
o sinal para saber a operação que será realizada nessas outras instruções.

4.7 Multiplexadores
Os multiplexadores são utilizados para fazer uma escolha entre uma
entrada ou outra dependendo do sinal de uma chave específica enviada pela
Unidade de Controle. Para esse projeto foram usados dois tipos de
multiplexadores, um de 5 bits e outro de 32 bits, que são mostrados,
respectivamente, pelas Figuras 8 e 9.
Figura 8. Código do Multiplexador de 5 bits em Verilog

Fonte: Autor.
 15

Figura 9. Código do Multiplexador de 32 bits em Verilog

Fonte: Autor.

4.8 Memória de Dados

A memória de dados é a responsável por armazenar os resultados
numéricos gerados pela CPU. Ela foi implementada a partir de um template
fornecido pelo Quartus, assim como a memória de instruções, e na Figura 8
abaixo está o código dela em Verilog.
Figura 10. Código da Memória de Dados em Verilog

Fonte: Autor.

4.9 Unidade de Controle

 16

A Unidade de Controle é responsável por enviar os devidos sinais para

as demais unidades funcionais do processador, com o intuito de garantir que a
instrução está sendo realizada da maneira correta. Como já citado
anteriormente, as instruções do tipo R foram diferenciadas pelo seu OpCode,
desse modo, a Unidade de Controle ficou mais extensa, por isso na Figura 11 a
seguir será apresentada uma parte dessa unidade funcional.
Figura 11. Parte do código da Unidade de Controle em Verilog

Fonte: Autor.

Escolhi essa parte da UC pois mostra algumas instruções do tipo R, a or,

and e not e também algumas do tipo I, sendo a lw e a sw. A variável “Sinal” é
responsável por enviar o sinal da operação que será realizada na ULA, no caso
das instruções que não são do tipo R.
 17

4.10 CPU
O código da CPU foi montado a partir da junção de todas as unidades
funcionais, seguindo o molde da Figura 1 com adição da Unidade de Controle.
Abaixo, na Figura 12, está seu código em Veriog.
Figura 12. Código da CPU em Verilog

Fonte: Autor.
 18

5 Resultados e Discussões

Para essa etapa do projeto foram testadas, por meio de waveforms, as

unidades funcionais Memoria de Instruções, Banco de Registradoress, Unidade
Lógica e Aritmética e Memória de Dados.

Para testar a Memória de Instruções coloquei no arquivo txt três

instruções aleatórias e rodei o código. A intenção é ver se ao passar os ciclos
de clock a Memória de Instruções vai atualizando adequadamente o valor das
instruções. Abaixo, na Figura 13 temos o resultado desse teste.
Figura 13. Waveform para teste da Memória de Instruções

Fonte: Autor.

Veja que o PC é acrescentado de 4 em 4 e que a Instrução é

adequadamente atualizada a cada ciclo de clock.

É provável que para o próximo PC eu modifique o cálculo do PC pois se

for PC + 1 as instruções podem ser fornecidas a memória de instruções de
maneira mais intuitiva.

Para testar o Banco de Registradores a flag “Reg_Write” foi variada a

cada três ciclos de clock, o “Reg_1” foi mantido fixo com o valor 00001 e o
“Reg_2” mantido com o valor fixo 00010. Além disso, o “Reg_escrita” foi
incrementado de 1 em 1 a cada ciclo de clock. O resultado desse teste é
mostrado abaixo na Figura 14.
Figura 14. Teste em waveform do Banco de Registradores

Fonte: Autor.
 19

Os resultados obtidos mostraram que os registradores Rs, Rt e Rd

armazenaram os valores esperados.

No teste da ULA foi mantido um valor fixo de 15 para a entrada 1, 10

para a entrada 2 e a “ALU_Ctrl” foi incrementa de 1 a cada ciclo de clock,
desse modo puderam ser testadas todas as funcionalidades da ULA. A seguir,
na Figura 15, temos o resultado desse teste.
Figura 15. Teste em waveform da ULA

Fonte: Autor.

Os resultados das operações foram como o esperado, note que para as

operações lógicas os resultados devem ser observados em binário.

Por fim, foi feito o teste da Memória de Dados. Para esse teste o
“Mem_Write” fica ativo por 3 ciclos de clock e após isso é ativado o
“Mem_Read”, além disso, o “Write_Data” é incrementado de 1 a cada ciclo de
clock e o endereço de escrita também e, após 3 ciclos de clock o endereço de
leitura passa a ser incrementado. Assim, na Figura 16 é mostrado o resultado
desse teste.
Figura 16. Teste em waveform da Memória de Dados

Fonte: Autor.

Os resultados obtidos foram como o esperado, observe que apenas

quando o endereço de leitura é “ativado” a saída altera seu valor e, contém os
valores armazenados previamente na escrita.
 20

6 Considerações Finais

O projeto já está quase concluído, provavelmente para o produto final

será alterado o cálculo do PC para ser incrementado de 1 em 1, como dito
anteriormente. Além disso, faltam ser feitos os testes com a CPU completa e
implementar um módulo de comunicação que fará a comunicação com o FPGA
para o teste final.

Se tudo ocorrer como o previsto, em mais alguns dias o produto final já

estará finalizado.
 21

Referências

[1] < https://stackoverflow.com/questions/33334521/extending-mips-datapath-

to-implement-sll-and-srl> Fonte da Figura 1;

[2] Banco de Registradores:

<http://www2.pcs.usp.br/~labdig/pdffiles_2015/banco-registradores-ula.pdf>

[3] Unidade Central de Processamento:

<https://pt.wikipedia.org/wiki/Unidade_central_de_processamento>

[4] Trabalho de conclusão de curso do aluno Helder Celso Romero dos Santos
disponibilizado no Moodle da disciplina.