pipeline 4 bits

8/7/2019 Pipeline 4 Bits

1/38

Universidade de So PauloInstituto de Cincias Matemticas de So CarlosDepartamento de Sistemas de Computao SSC

SSC-114 Arquitetura de Computadores

CPU 4 bits com Pipeline

Andr Mrcio de Lima CurvelloFernando Pasquini SantosLeonardo Almeida Bonetti

So Carlos, Junho de 2010


2/38

2

Andr Mrcio de Lima Curvello

Fernando Pasquini Santos

Leonardo Almeida Bonetti

Projeto de CPU 4Bits com Pipeline

Projeto de uma CPU com arquitetura de 4bits,

executando programas sob um pipeline de cinco estgios,

implementado em VHDL pelo software Altera Quartus II.

Prof. Responsvel:

Jorge Luiz e Silva

So Carlos, Junho de 2010


3/38

3

"Computadores so ferramentas magnficas para a

realizao de nossos sonhos, mas nenhuma mquina pode

substituir a fasca do esprito humano, compaixo, amor, e

compreenso." (Louis Gerstner)


4/38

4

Este projeto visa a implementao de um processador 4 bits com todas as suas funcionalidades e a presena de um

pipeline com cinco estgios (fetch, decode, fetchdata, exec e store) utilizando a linguagem de descrio de hardware

VHDL e o software Altera Quartus II. Para tanto, informaes gerais como conjunto de instrues escolhidas e os

estgios do pipeline sero apresentados. As instrues sero poucas, de modo que possibilitem apenas a construo

de programas simples para observarmos a execuo nesta arquitetura. Em seguida, cada estrutura responsvel pelo

funcionamento da CPU ser apresentada juntamente com seu cdigo implementado. Para validao do projeto comoum processador funcional, sero apresentados testes realizados no software junto aos valores esperados para cada

entrada, dados programas simples na memria de programa.

Sumrio1. Introduo ................................................................................................................................................................. 6

1.1 CPU 4 bits .......................................................................................................................................................... 6

1.2 Pipeline .............................................................................................................................................................. 6

1.3 Organizao do Texto e Outros Detalhes ......................................................................................................... 6

2. Caractersticas da Arquitetura .................................................................................................................................. 6

2.1 Caractersticas Gerais ........................................................................................................................................ 6

2.2 Instrues e Formato ........................................................................................................................................ 7

2.3 Pipeline .............................................................................................................................................................. 8

2.4 Problemas e Cuidados Especiais na Construo dos Programas ...................................................................... 9

3. Implementao ....................................................................................................................................................... 113.1 Memria de Progama, Memria de Dados e Banco de Registradores ........................................................... 11

3.2 Unidade fetch .............................................................................................................................................. 13

3.3 Unidade decode............................................................................................................................................ 14

3.4 Unidade fetchData .................................................................................................................................... 15

3.5 Unidade exec ................................................................................................................................................ 16

3.6 Unidade store .................................................................................................................................................. 17

3.7 Diagrama .bdf Completo e Cdigo VHDL Correspondente ............................................................................. 19

4. Simulaes .............................................................................................................................................................. 25

4.1 Memrias e Registradores .............................................................................................................................. 25

4.2 Busca de Instruo e Decodificao ................................................................................................................ 26

4.3 Busca de Dados ............................................................................................................................................... 27

4.4 Operaes na ULA ........................................................................................................................................... 29

4.5 Armazenamento ............................................................................................................................................. 31

4.6 Jumps e Condicionais ...................................................................................................................................... 35

5. Discusso e Concluso ............................................................................................................................................ 37

Bibliografia ...................................................................................................................................................................... 38


5/38

5

Figura 1 Problema no pipeline quando duas instrues querem ler e escrever na mesma posio de memria. As

instrues esto em sequncia e so representadas pelos nmeros 000, 001, etc. ....................................................... 9

Figura 2 Soluo para o problema descrito na Figura 1. .............................................................................................. 10

Figura 3 Problema da leitura de valores antes da modificao real ............................................................................ 10

Figura 4 Trecho do arquivo .mif para o contedo da ROM de programa. Repare que o programa de teste 1 est

colocado no incio da memria. ...................................................................................................................................... 11Figura 5 Janela do MegaWizard Plug-In Manager definindo a memria de programa. .............................................. 12

Figura 6 Bloco funcional da memria de dados (RAM 2-port). ................................................................................... 12

Figura 7 Bloco funcional do banco de registradores. ................................................................................................... 13

Figura 8 Diagrama .bdf do pipeline (nvel mais alto). (continua) ................................................................................. 19

Figura 9 Diagrama .bdf simples para simulao das memrias e banco de registradores .......................................... 25

Figura 10 Resultados da simulao do comportamento das memrias e banco de registradores. ............................ 26

Figura 11 - Diagrama .bdf para simulao da busca de instruo e decodificao. ....................................................... 26

Figura 12 Resultados da simulao da busca de instruo e decodificao ................................................................ 27

Figura 13 Resultados da simulao anterior aplicando-se um sinal de Reset. ............................................................ 27

Figura 14 Diagrama .bdf para simulao da busca de dados (incluindo busca de instruo e decodificao). .......... 28Figura 15 Resultados da simulao da busca de dados ............................................................................................... 29

Figura 16 Diagrama .bdf para simulao da execuo das instrues (incluindo estgios anteriores)....................... 30

Figura 17 - Resultados da simulao da execuo de instrues ................................................................................... 31

Figura 18 - Diagrama .bdf para simulao do armazenamento (incluindo estgios anteriores) .................................... 33

Figura 19 - Resultados da simulao do armazenamento na CPU.................................................................................. 34

Figura 20 Simulao do pipeline com o programa 4 (sem tratamento de leituras/escritas em posies iguais) ....... 35

Figura 21 Resultados da simulao do pipeline com um programa envolvendo Jump If Equal. ................................. 37

Tabela 1 Especificaes Gerais da Arquitetura .............................................................................................................. 7Tabela 2 Especificao do Conjunto de Instrues ........................................................................................................ 8

Programa 1 Exemplo de programa vulnervel a erros de leitura/escrita do pipeline e sua correo, inserindo

instrues Nop para evitar os problemas descritos. ...................................................................................................... 10

Programa 2 Programa de teste simples para simular a busca de dados ..................................................................... 28

Programa 3 Teste de operaes na ULA (sem respeitar as condies de acesso memria e banco de

registradores). ................................................................................................................................................................. 29

Programa 4 Programa genrico para teste geral do pipeline sem o uso da instruo JIE. ....................................... 31

Programa 5 Semelhante ao Programa 3 Programa genrico para teste geral do pipeline sem o uso da instruo

JIE. mas sem o tratamento especial para pipeline (remove-se as instrues Nop). ................................................... 35

Programa 6 Programa de teste para a instruo JIE no pipeline. As instrues aps 008 sero utilizadas como

prova de que a CPU no as executa (caso elas executem, os valores sero acusados no registrador Output). ......... 36
http://c/Users/Fernando%20Pasquini/Desktop/Monografia.docx%23_Toc266101486http://c/Users/Fernando%20Pasquini/Desktop/Monografia.docx%23_Toc266101486http://c/Users/Fernando%20Pasquini/Desktop/Monografia.docx%23_Toc266101486http://c/Users/Fernando%20Pasquini/Desktop/Monografia.docx%23_Toc266101486


6/38

6

1. Introduo1.1CPU 4 bitsCPU o componente responsvel por realizar todas as operaes que compem a execuo das instrues de

um programa. Normalmente, sua estrutura mais bsica composta por um banco de registradores que armazenam

os dados em execuo, alguns multiplexadores que servem para orientar o fluxo dos dados, uma Unidade LgicaAritmtica para os clculos lgicos e matemticos envolvendo estes dados, e barramentos de dados para acesso

memria, para leitura e gravao das instrues e dados. E para ordenar tudo isso, temos uma Unidade de Controle,

que coordena o funcionamento dos componentes de modo a executar as instrues.

Ao dizermos que uma CPU do tipo 4 bits, estamos ressaltando que todos os dados com os quais a CPU lida so

do tamanho de 4 bits; ou seja, 4 dgitos binrios. Este tambm ser o tamanho dos registradores internos e dos

dados interpretveis a serem armazenados na memria.

1.2PipelinePipeline uma tcnica de hardware que permite que a CPU realize a busca de uma ou mais instrues alm daprxima a ser executada. Estas instrues so colocadas em uma fila de memria dentro da (CPU) onde aguardam o

momento de serem executadas. uma tcnica semelhante a uma linha de produo de uma fbrica. utilizada para

acelerar a velocidade de operao da CPU, uma vez que a prxima instruo a ser executada est normalmente

armazenada dentro da CPU e no precisa ser buscada da memria, normalmente muito mais lenta que a CPU [4].

Um processador com pipeline desenvolvido com a unidade de controle (UC) dividida em diversos estgios,

cada um responsvel por um tipo de operao controlada a ser realizada no hardware. Cada estgio intercalado

por um registrador que armazena as informaes de cada instruo que est sendo executada; e a cada pulso de

clock os dados so enviados para os estgios subsequentes. A execuo completa das instrues se d pela

passagem completa da mesma por todos os estgios.

1.3Organizao do Texto e Outros DetalhesO seguinte trabalho ser dividido na seo 2, onde descreveremos aspectos gerais do processador, incluindo seu

conjunto de instrues e os estgios do pipeline. A seo 3 se encarregar de mostrar o cdigo do processador, em

VHDL, e outros detalhes de implementao. A seo 4 mostrar uma srie de testes realizados, demonstrando o

funcionamento da CPU. Enfim, a seo 5 apresentar uma discusso rpida sobre a implementao e questes de

desempenho, obtendo concluses acerca do trabalho realizado.

2. Caractersticas da Arquitetura2.1Caractersticas GeraisA arquitetura da CPU 4 bits consistir em uma unidade central de controle, contendo o pipeline; uma memria

ROM exclusiva para programas, uma memria RAM exclusiva para armazenamento de dados de variveis1, um

banco de registradores e sinais de entrada (Clock e Reset).

A memria ROM de programa ir conter 256 palavras de 16 bits cada uma. Como o formato das instrues no

passar de 16 bits, este foi o tamanho de palavra escolhido.

A memria RAM de armazenamento de dados ter 256 palavras de 4 bits cada uma2; de forma que os endereos

contm 8 bits. O tamanho de 4 bits para cada palavra faz com que cada uma delas tenha o valor de um registrador

1Uma arquitetura com duas memrias reservadas para programa e dados tambm conhecida por arquitetura Harvard.


7/38

7

que pode ser armazenado. A memria necessariamente deve suportar a leitura e escrita simultneas de dados (dual-

port ou 2-port), para permitir o paralelismo em nvel de pipeline. Ou seja, enquanto uma unidade faz a leitura de

uma posio de memria, a outra deve ser capaz de escrever em outra, no mesmo pulso de clock. Note que podem

ocorrer problemas com esta abordagem; e para isto, cabe ao programador ou compilador se assegurar que no h

instrues lendo e escrevendo dados no mesmo lugar simultaneamente. Veremos as precaues a serem tomadas

quando descrevermos do pipeline em si.

O banco de registradores ir conter 16 registradores, todos endereveis com 4 bits. Este banco de registradores

no s deve permitir que dados sejam lidos e escritos simultaneamente, como tambm deve permitir duas leituras

simultneas, apresentando duas sadas de dados (leituras de dois registradores no caso de operaes aritmticas,

por exemplo). Novamente, devem ser tomadas precaues quanto leitura e escrita simultneas em posies iguais.

Veremos abaixo um resumo das caractersticas principais da arquitetura descrita.

Tabela 1 Especificaes Gerais da Arquitetura

Resumo da Especificao da Arquitetura

N de Registradores 16 (4 bits de endereo)

N de Instrues 8 (4 bits para representao)

ROM de Programa 256 palavras de 16 bits (8 bits para end.)

RAM de Dados 256 palavras de 4 bits (8 bits para end.)

Estgios do Pipeline 5

2.2Instrues e FormatoA CPU ter poucas instrues, j que queremos verificar somente o funcionamento do pipeline com programas

simples. So 8 instrues definidas, com exceo da instruo Nop, que indica que o processador fica ocioso. O

cdigo de operao desta ltima pode ser definido como 0000, no entanto, podemos represent-la, na

implementao, por qualquer sequncia de bits que no esto utilizados por outras instrues.

Add(RX


8/38

8

est sendo processado nas outras unidades (que so instrues que ocorrem depois do jump). Esta

instruo tambm requer um tratamento especial na construo do programa, devendo-se evitar que o

registrador CmpFlag mude inesperadamente na hora de sua execuo na unidade de store. Veremos

isto adiante.

Output (Sada


9/38

9

fetchdata (busca de dados): Se encarrega de obter dados a partir dos endereos deregistradores e da memria de dados recebidas. A unidade acessa o banco de registradores e a

memria RAM, enviando os endereos das posies desejadas, e obtendo os dados contidos nas

mesmas. Ento, estas informaes so passadas adiante, junto com o cdigo operacional da

instruo e os possveis endereos da memria de programa e valores numricos literais.

exec (execuo de operaes): Recebidos de fetchdata os valores nos registradoresrequeridos para as operaes, esta unidade funciona como ULA Unidade Lgico-Aritmtica. Nela

so realizadas as operaes de adio e subtrao entre os registradores e definido o flag de

comparao (CmpFlag). Caso nenhuma operao lgico-aritmtica seja feita, a unidade

simplesmente retransmite o valor necessrio para a unidade store. Tambm, em todas as

ocasies, so retransmitidos os cdigos de operao, endereos e valores numricos literais.

store (armazenamento): A ltima unidade de controle do pipeline se encarrega da tarefafundamental de armazenar os valores obtidos na memria RAM ou memria de dados. Ela tambm

responsvel por analisar o flag de comparao e atualizar o valor do contador de programa

(ProgCount) caso preciso, realizando as instrues de Jump If Equal. Quando isto ocorre, a

unidade libera um sinal Clear para todas as outras unidades, aniquilando as instrues emandamento (que vm depois da instruo de Jump). A unidade ento entra num estado chamado

denominado ClrCtrl (controle do Clear), onde ela tambm ignora a instruo vinda de exec e

permanece inativa por um ciclo de clock, desativando o sinal de Clear no final deste. Por fim, a

unidade tambm define o valor em Output.

2.4Problemas e Cuidados Especiais na Construo dos ProgramasUm processador com pipeline tambm apresenta dificuldades adicionais de construo dos programas a nvel

Assembly, comparado com uma unidade de controle simples. Conforme j foi dito, uma vez que o pipeline necessita

de memrias e bancos de registradores com suporte a leitura e escrita simultneas, teremos srios problemas

quando, em um s ciclo de clock, deseja-se ler e escrever numa mesma posio de memria ou registrador. Temos o

problema ilustrado na Figura 1 Problema no pipeline quando duas instrues querem ler e escrever na mesma

posio de memria. As instrues.

Figura 1 Problema no pipeline quando duas instrues querem ler e escrever na mesma posio de memria. As instrues esto em

sequncia e so representadas pelos nmeros 000, 001, etc.

Isto pode ser facilmente resolvido intercalando o programa com vrias instrues Nop, evitando esta situao

no pipeline. Observe a Figura 2 Soluo para o problema descrito na Figura 1.


10/38

10

Figura 2 Soluo para o problema descrito na Figura 1.

Note tambm que temos outro problema srio com o pipeline no podemos permitir que uma instruo

que necessite do valor de um registrador venha imediatamente aps este registrador ser modificado. O problema

que o valor poder ser lido na unidade fetch sem que haja tempo para que ele seja realmente modificado, e assim,

teremos um valor indesejvel. O problema ilustrado na Figura 3 Problema da leitura de valores antes da

modificao real e resolvido simplesmente adiando a leitura (preenchendo o intervalo com outras instrues ou

simplesmente adicionandoNop

).

Figura 3 Problema da leitura de valores antes da modificao real

Tendo visto os possveis problemas com a execuo sequencial dos programas, podemos concluir que, dada

uma instruo que atualiza um registrador ou posio de memria, devemos realizar uma leitura da mesma somente

a um intervalo de duas instrues da instruo de escrita. Abaixo temos transcrito um exemplo de programa sem a

preocupao do pipeline, e sua modificao respectiva evitando os problemas descritos.

Programa 1 Exemplo de programa vulnervel a erros de leitura/escrita do pipeline e sua correo, inserindo instrues Nop para evitar os

problemas descritos.

Programa Vulnervel Programa Corrigido000 Set R1 5001 Set R2 5002 Stx R1 &001003 Add R1 R2004 Set R3 10005 Mov R0 R1006 Lox R1 &001007 Sub R0 R3

000 Set R1 5001 Set R2 5002 Nop003 Stx R1 &001004 Nop005 Add R1 R2006 Set R3 10007 Nop008 Mov R0 R1009 Lox R1 &001010 Nop

11 Sub R0 R3


11/38

11

3. ImplementaoRetornando ao que foi dito na seo 1.3, a implementao da CPU 4 bits foi feita no software Altera Quartus II,

verso 9.1 Build 350 Web Edition. Cada estgio do pipeline constitui um bloco descrito em VHDL (VHSIC Hardware

Description Language); enquanto a conexo entre eles foi feita em um arquivo do tipo .bdf, formato utilizado pelo

software para representar diagramas de blocos (editvel pelo prprio software).

As descries VHDL das unidades de controle foram feitas por um modelo procedural (sequencial) baseado em

mquina de estados; ou seja, o comportamento de cada unidade moldado por um valor que se encontra na

entrada da mesma, que a sada da unidade anterior. Este valor (estado) exatamente o cdigo operacional da

instruo que est no pipeline.

Apresentaremos a seguir uma breve descrio de cada bloco e seus respectivos cdigos.

3.1Memria de Progama, Memria de Dados e Banco de RegistradoresO software Quartus II apresenta uma ferramenta interessante de gerao automtica de blocos funcionais,

chamada MegaWizard Plug-In Manager. Ele se utiliza dos conceitos de megafunction (megafuno), um bloco pr-

montado onde se basta passar alguns valores para que seu cdigo de descrio seja construdo. Assim, podemos

criar rapidamente vrias unidades que levariam tempo at serem construdas; e foi o que fizemos com as memrias

de programa e dados e o banco de registradores.

Para a memria ROM de programa, utilizamos a megafuno ROM 1-PORT. Foram inseridos os parmetros j

descritos na seo 2.1, e definiu-se um arquivo do tipo .mif (Memory Initialization File) para o contedo da ROM,

que o programa em si. Este tipo de arquivo pode ser aberto no software, podendo-se editar cada posio de

memria com um nmero real inteiro, sem sinal, correspondente sequncia de dgitos binrios da instruo. Por

exemplo, no caso do programa de teste 1, descrito na seo , temos o seguinte trecho do arquivo .mif aberto no

software:

Figura 4 Trecho do arquivo .mif para o contedo da ROM de programa. Repare que o programa de teste 1 est colocado no incio da

memria.

Temos tambm a janela do MegaWizard Plug-In Manager que define a memria ROM, definida pelo nome

progrom:


12/38

12

Figura 5 Janela do MegaWizard Plug-In Manager definindo a memria de programa.

Repare no smbolo do bloco da memria e os latches de clock. No caso da memria acima, a cada ciclo de clock,

o valor na entrada (address[7..0]) passado para a memria, que joga os dados na sada (q[15..0]).

No caso da memria RAM de programa, utilizamos a megafuno RAM 2-PORT; ou seja, uma RAM dual-port

conforme descrito na seo 2.1. Foram definidos os parmetros de nmero e tamanho das palavras, e tambm queela sempre inicia com uma sequncia de dados definidos em outro arquivo .mif. Temos o smbolo do bloco

dataram:

Figura 6 Bloco funcional da memria de dados (RAM 2-port).

Para o banco de registradores, o ideal seria program-lo diretamente, sem a utilizao de uma megafuno. No

entanto, para fins prticos, definimos como a megafuno ALT3PRAM. Esta megafuno voltada mais para

aplicaes como memria RAM, no entanto, como no h preocupao com a latncia e/ou rapidez das

transferncias, optamos por utiliz-la para um banco de registradores. Temos o smbolo de RegBank:


13/38

13

Figura 7 Bloco funcional do banco de registradores.

Note que, como descrito na seo 2.1, o banco de registradores deve ser capaz de realizar duas leituras e

uma escrita no mesmo pulso de clock (por isto a megafuno ALT3PRAM uma RAM do tipo 3-port). Definimos

tambm que ele sempre ir iniciar com todas as posies em zero.

Tendo definido os componentes de armazenamento de dados, partiremos para a descrio do pipeline em

si.

3.2Unidade fetchLIBRARY ieee;USE ieee.std_logic_1164.all;USE ieee.numeric_std.all;

entity fetch isport(

Clk : in std_logic;Rst: in std_logic;

-- Valor de ProgCount, passado para a ROMInstAddrOut : out std_logic_vector(7 downto 0);

-- Recebe o valor na memria ROM e repassa para decodeInstrIn : in std_logic_vector(15 downto 0);InstrOut : out std_logic_vector(15 downto 0);

-- Sinais para escrita em ProgCountWrtPC : in std_logic;PCIn : in std_logic_vector(7 downto 0)

);end fetch;

architecture behavior of fetch is-- Contador de Programa / Program Counter :-- armazena o valor corrente na memria de programasignal ProgCount : std_logic_vector(7 downto 0);

beginprocess (Clk)

beginif (Clk'event and Clk='1') then

if (Rst = '1') then -- Zerar tudo em caso de ResetProgCount


14/38

14

elsif (WrtPC = '1') then-- Caso deseja-se escrever em ProgCount,-- j interpreta-se isto como um Clear (como-- nas outras unidades). ProgCount definido.ProgCount


15/38

15

-- Add, Sub or MovRegAddr1


16/38

16

if (Clear = '1') then -- Verifica ClearOpcodeOut


17/38

17

if (Clear = '1') then -- Verifica ClearOpcodeOut -- Add

Result -- Sub

Result


18/38

18

-- sinal Wren esteja em uma destas unidadesResultIn : in std_logic_vector(3 downto 0);ResultOut : out std_logic_vector(3 downto 0);

DMemAddrIn : in std_logic_vector(7 downto 0);DMemAddrOut : out std_logic_vector(7 downto 0);

RegAddrIn : in std_logic_vector(3 downto 0);RegAddrOut : out std_logic_vector(3 downto 0);

PMemAddrIn : in std_logic_vector(7 downto 0);PMemAddrOut : out std_logic_vector(7 downto 0);

-- Wren: Write Enable (quando em 1, autoriza-- a escrita na memria)DMemWren : out std_logic;RegWren : out std_logic;

-- Para execuo de JIECmpFlagIn : in std_logic;PMemWren : out std_logic;ClearAll : out std_logic;

-- Valor OutputOutputData : out std_logic_vector(3 downto 0) );

end store;

architecture behavior of store is

begin

process (Clk)-- Varivel de estado para o Clearvariable ClrCtrl : std_logic := '0';begin

if (Clk'event and Clk = '1') then-- verifica se entrou no estado ClrCtrlif (ClrCtrl = '1') then

ClearAll


19/38

19

PMemWren


20/38

20

Observe o sinal de clock invertido entrando nas memrias RAM e ROM e no banco de registradores. Isto

necessrio para que dados sejam lidos e interpretados por uma unidade de controle em somente um ciclo de clock

(caso a memria seja to rpida quanto ela).

O software Quartus II tambm oferece uma funcionalidade interessante de transformar um diagrama .bdf emuma descrio VHDL correspondente. Isto til caso deseja-se utilizar o cdigo em uma plataforma que no suporte

estes diagramas. Temos ento, o cdigo:

LIBRARY ieee;


21/38

21

USE ieee.std_logic_1164.all;

LIBRARY work;

ENTITY pipeline4bits ISPORT(

Clk : IN STD_LOGIC;Rst : IN STD_LOGIC;Output : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)

);END pipeline4bits;

ARCHITECTURE bdf_type OF pipeline4bits IS

COMPONENT progromPORT(clock : IN STD_LOGIC;

address : IN STD_LOGIC_VECTOR(7 DOWNTO 0);q : OUT STD_LOGIC_VECTOR(15 DOWNTO 0)

);

END COMPONENT;

COMPONENT fetchPORT(Clk : IN STD_LOGIC;

Rst : IN STD_LOGIC;WrtPC : IN STD_LOGIC;InstrIn : IN STD_LOGIC_VECTOR(15 DOWNTO 0);PCIn : IN STD_LOGIC_VECTOR(7 DOWNTO 0);InstAddrOut : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);InstrOut : OUT STD_LOGIC_VECTOR(15 DOWNTO 0)

);END COMPONENT;

COMPONENT decodePORT(Clk : IN STD_LOGIC;Clear : IN STD_LOGIC;DInstrIn : IN STD_LOGIC_VECTOR(15 DOWNTO 0);DMemAddr : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);FixedVal : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);Opcode : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);PMemAddr : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);RegAddr1 : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);RegAddr2 : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)

);END COMPONENT;

COMPONENT fetchdataPORT(Clk : IN STD_LOGIC;Clear : IN STD_LOGIC;DMemAddrIn : IN STD_LOGIC_VECTOR(7 DOWNTO 0);FixedValIn : IN STD_LOGIC_VECTOR(3 DOWNTO 0);OpcodeIn : IN STD_LOGIC_VECTOR(3 DOWNTO 0);PMemAddrIn : IN STD_LOGIC_VECTOR(7 DOWNTO 0);RegAddr1In : IN STD_LOGIC_VECTOR(3 DOWNTO 0);RegAddr2In : IN STD_LOGIC_VECTOR(3 DOWNTO 0);DMemAddrOut : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);FixedValOut : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);OpcodeOut : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);PMemAddrOut : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);RegAddr1Out : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);RegAddr2Out : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)

);END COMPONENT;

COMPONENT dataram


22/38

22

PORT(wren : IN STD_LOGIC;clock : IN STD_LOGIC;data : IN STD_LOGIC_VECTOR(3 DOWNTO 0);rdaddress : IN STD_LOGIC_VECTOR(7 DOWNTO 0);wraddress : IN STD_LOGIC_VECTOR(7 DOWNTO 0);q : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)

);

END COMPONENT;

COMPONENT regbankPORT(wren : IN STD_LOGIC;

clock : IN STD_LOGIC;data : IN STD_LOGIC_VECTOR(3 DOWNTO 0);rdaddress_a : IN STD_LOGIC_VECTOR(3 DOWNTO 0);rdaddress_b : IN STD_LOGIC_VECTOR(3 DOWNTO 0);wraddress : IN STD_LOGIC_VECTOR(3 DOWNTO 0);qa : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);qb : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)

);END COMPONENT;

COMPONENT execPORT(Clk : IN STD_LOGIC;

Clear : IN STD_LOGIC;DMemAddrIn : IN STD_LOGIC_VECTOR(7 DOWNTO 0);FixedVal : IN STD_LOGIC_VECTOR(3 DOWNTO 0);MemContent : IN STD_LOGIC_VECTOR(3 DOWNTO 0);OpcodeIn : IN STD_LOGIC_VECTOR(3 DOWNTO 0);PMemAddrIn : IN STD_LOGIC_VECTOR(7 DOWNTO 0);RegAddrIn : IN STD_LOGIC_VECTOR(3 DOWNTO 0);RegData1 : IN STD_LOGIC_VECTOR(3 DOWNTO 0);RegData2 : IN STD_LOGIC_VECTOR(3 DOWNTO 0);CmpFlag : OUT STD_LOGIC;

DMemAddrOut : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);OpcodeOut : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);PMemAddrOut : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);RegAddrOut : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);Result : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)

);END COMPONENT;

COMPONENT storePORT(Clk : IN STD_LOGIC;

CmpFlagIn : IN STD_LOGIC;DMemAddrIn : IN STD_LOGIC_VECTOR(7 DOWNTO 0);OpcodeIn : IN STD_LOGIC_VECTOR(3 DOWNTO 0);

PMemAddrIn : IN STD_LOGIC_VECTOR(7 DOWNTO 0);RegAddrIn : IN STD_LOGIC_VECTOR(3 DOWNTO 0);ResultIn : IN STD_LOGIC_VECTOR(3 DOWNTO 0);DMemWren : OUT STD_LOGIC;RegWren : OUT STD_LOGIC;PMemWren : OUT STD_LOGIC;ClearAll : OUT STD_LOGIC;DMemAddrOut : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);OutputData : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);PMemAddrOut : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);RegAddrOut : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);ResultOut : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)

);END COMPONENT;

SIGNAL Clear : STD_LOGIC;SIGNAL DMemAddr : STD_LOGIC_VECTOR(7 DOWNTO 0);SIGNAL DMemWren : STD_LOGIC;SIGNAL FixedVal : STD_LOGIC_VECTOR(3 DOWNTO 0);


23/38

23

SIGNAL InvClk : STD_LOGIC;SIGNAL Opcode : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL PMemAddr : STD_LOGIC_VECTOR(7 DOWNTO 0);SIGNAL PMemWren : STD_LOGIC;SIGNAL RegAddr1 : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL RegAddr2 : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL RegWren : STD_LOGIC;

SIGNAL ToExecDMemAddr : STD_LOGIC_VECTOR(7 DOWNTO 0);SIGNAL ToExecFixedVal : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL ToExecOpcode : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL ToExecPMemAddr : STD_LOGIC_VECTOR(7 DOWNTO 0);SIGNAL ToExecRAMData : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL ToExecReg1Addr : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL ToExecReg1Data : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL ToExecReg2Data : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL WDMemAddr : STD_LOGIC_VECTOR(7 DOWNTO 0);SIGNAL WPMem : STD_LOGIC_VECTOR(7 DOWNTO 0);SIGNAL WrData : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL WRegAddr : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL SYNTHESIZED_WIRE_0 : STD_LOGIC_VECTOR(7 DOWNTO 0);

SIGNAL SYNTHESIZED_WIRE_1 : STD_LOGIC_VECTOR(15 DOWNTO 0);SIGNAL SYNTHESIZED_WIRE_2 : STD_LOGIC_VECTOR(15 DOWNTO 0);SIGNAL SYNTHESIZED_WIRE_3 : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL SYNTHESIZED_WIRE_4 : STD_LOGIC;SIGNAL SYNTHESIZED_WIRE_5 : STD_LOGIC_VECTOR(7 DOWNTO 0);SIGNAL SYNTHESIZED_WIRE_6 : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL SYNTHESIZED_WIRE_7 : STD_LOGIC_VECTOR(7 DOWNTO 0);SIGNAL SYNTHESIZED_WIRE_8 : STD_LOGIC_VECTOR(3 DOWNTO 0);SIGNAL SYNTHESIZED_WIRE_9 : STD_LOGIC_VECTOR(3 DOWNTO 0);

BEGIN

b2v_inst : progromPORT MAP(clock => InvClk,address => SYNTHESIZED_WIRE_0,q => SYNTHESIZED_WIRE_1);

InvClk Clk,

Rst => Rst,WrtPC => PMemWren,InstrIn => SYNTHESIZED_WIRE_1,

PCIn => WPMem,InstAddrOut => SYNTHESIZED_WIRE_0,InstrOut => SYNTHESIZED_WIRE_2);

b2v_inst3 : decodePORT MAP(Clk => Clk,

Clear => Clear,DInstrIn => SYNTHESIZED_WIRE_2,DMemAddr => DMemAddr,FixedVal => FixedVal,Opcode => Opcode,PMemAddr => PMemAddr,RegAddr1 => RegAddr1,RegAddr2 => RegAddr2);

b2v_inst4 : fetchdataPORT MAP(Clk => Clk,

Clear => Clear,DMemAddrIn => DMemAddr,


24/38

24

FixedValIn => FixedVal,OpcodeIn => Opcode,PMemAddrIn => PMemAddr,RegAddr1In => RegAddr1,RegAddr2In => RegAddr2,DMemAddrOut => ToExecDMemAddr,FixedValOut => ToExecFixedVal,

OpcodeOut => ToExecOpcode,PMemAddrOut => ToExecPMemAddr,RegAddr1Out => ToExecReg1Addr,RegAddr2Out => SYNTHESIZED_WIRE_3);

b2v_inst5 : dataramPORT MAP(wren => DMemWren,

clock => InvClk,data => WrData,rdaddress => ToExecDMemAddr,wraddress => WDMemAddr,q => ToExecRAMData);

b2v_inst6 : regbankPORT MAP(wren => RegWren,

clock => InvClk,data => WrData,rdaddress_a => ToExecReg1Addr,rdaddress_b => SYNTHESIZED_WIRE_3,wraddress => WRegAddr,qa => ToExecReg1Data,qb => ToExecReg2Data);

b2v_inst7 : execPORT MAP(Clk => Clk,

Clear => Clear,

DMemAddrIn => ToExecDMemAddr,FixedVal => ToExecFixedVal,MemContent => ToExecRAMData,OpcodeIn => ToExecOpcode,PMemAddrIn => ToExecPMemAddr,RegAddrIn => ToExecReg1Addr,RegData1 => ToExecReg1Data,RegData2 => ToExecReg2Data,CmpFlag => SYNTHESIZED_WIRE_4,DMemAddrOut => SYNTHESIZED_WIRE_5,OpcodeOut => SYNTHESIZED_WIRE_6,PMemAddrOut => SYNTHESIZED_WIRE_7,RegAddrOut => SYNTHESIZED_WIRE_8,

Result => SYNTHESIZED_WIRE_9);

b2v_inst8 : storePORT MAP(Clk => Clk,

CmpFlagIn => SYNTHESIZED_WIRE_4,DMemAddrIn => SYNTHESIZED_WIRE_5,OpcodeIn => SYNTHESIZED_WIRE_6,PMemAddrIn => SYNTHESIZED_WIRE_7,RegAddrIn => SYNTHESIZED_WIRE_8,ResultIn => SYNTHESIZED_WIRE_9,DMemWren => DMemWren,RegWren => RegWren,PMemWren => PMemWren,ClearAll => Clear,DMemAddrOut => WDMemAddr,OutputData => Output,PMemAddrOut => WPMem,RegAddrOut => WRegAddr,ResultOut => WrData);


25/38

25

END bdf_type;

4. SimulaesVrias simulaes foram feitas com a CPU 4 bits para garantir seu funcionamento. Comeamos primeiramente

com os blocos individuais e funes bsicas e avanamos em seguida para testes de nvel mais alto. Os testes foramrealizados pela ferramenta inclusa no software que gera sinais de sada baseados nos sinais de entrada indicados por

um arquivo .vwf (Vector Waveform File). O software tambm permite definir o modo de simulao a ser feita; e

assim, foi definida simulao funcional, ou seja, queremos simular somente o funcionamento da lgica do

processador, sem envolver tempos de atraso ou quaisquer outros parmetros.

Nas sees seguintes, apresentaremos uma breve descrio de cada simulao, a montagem utilizada em

diagrama .bdf e as formas de onda resultantes.

4.1

Memrias e Registradores

Em primeiro lugar necessrio verificar o funcionamento das memrias e o banco de registradores a seremutilizados na arquitetura. Testamos as memrias uma a uma, com todas as operaes de leitura e escrita.

O contedo inicial na memria ROM foi definido com o programa de teste 1, descrito na seo

(ASDASDASFGSDFS), e disposto na memria conforme na Figura 4 Trecho do arquivo .mif para o contedo da ROM

de programa. Repare que o programa de teste 1 est colocado no incio da memria. Os contedos na ROM e no

banco de registradores comeam todos em zero.

Figura 9 Diagrama .bdf simples para simulao das memrias e banco de registradores


26/38

26

Tivemos os seguintes resultados:

Figura 10 Resultados da simulao do comportamento das memrias e banco de registradores.

A cada subida de pulso de clock, podemos verificar que a sada da ROM apresentou o contedo correto de cada

posio, a RAM gravou corretamente os valores indicados e foi capaz de l-los, e o banco de registradores tambm

funcionou corretamente.

4.2Busca de Instruo e DecodificaoTestaremos agora o funcionamento da CPU ao retirar endereos da memria de programa e envi-los unidade

de decodificao, que colocar os dados retirados na sada. Teremos na memria ROM uma sequncia qualquer de

instrues. Verificaremos tambm o modelo de pipeline funcionando nestas duas unidades, ou seja, enquanto uma

instruo buscada, a outra decodificada. O teste de atualizao do contador de programa na unidade fetch

ser testado na seo 4.6. Temos a montagem de simulao (os fios desconectados posteriormente foram ligados no

fio terra):

Figura 11 - Diagrama .bdf para simulao da busca de instruo e decodificao.


27/38

27

Temos os resultados:

Figura 12 Resultados da simulao da busca de instruo e decodificao

Repare que enquanto a sada FetchOut apresenta um cdigo de operao (quatro primeiros bits), a sada

OpCodeOut apresenta o cdigo de operao da ltima instruo que foi buscada. Isto comprova o funcionamento

do pipeline.

Seguindo a simulao, temos um sinal de reset, que ir zerar o contador de programa. Temos:

Figura 13 Resultados da simulao anterior aplicando-se um sinal de Reset.

Observa-se que a execuo do programa voltou ao incio aps o sinal de Reset. As unidades fetch e decode

funcionam at aqui.

4.3Busca de DadosAps termos as instrues retiradas da memria e decodificadas em dados interpretveis, iremos realizar a

busca dos dados requeridos da memria RAM e do banco de registradores. Temos o diagrama:


28/38

28

Figura 14 Diagrama .bdf para simulao da busca de dados (incluindo busca de instruo e decodificao).

Utilizaremos o seguinte programa de teste para a simulao:

Programa 2 Programa de teste simples para simular a busca de dados

Assembly Binrio000 Add R1 R2001 Loadx R3 &00000001002 Mov R1 R0

000 011100010010xxxx001 1100001100000001002 010000010000xxxx

A memria RAM foi definida iniciando com o valor 5 (0101) na posio 00000001, e os registradores possuem 2

(0010) em R1, 3 (0011) em R2 e 12 em R0 (1100) (o valor de R3 irrelevante no momento). Temos o seguinte

resultado:


29/38

29

Figura 15 Resultados da simulao da busca de dados

Vemos que a os dados corretos foram colocados na sada da unidade fetchdata, seguindo a estrutura de

pipeline.

4.4Operaes na ULATestaremos agora o funcionamento da unidade de execuo (exec), que realiza as operaes necessrias e

envia os resultados e endereos de armazenamento para a unidade store. Temos um programa de teste que

utilizar todas as instrues da CPU (menos Output, que semelhante a Storex na execuo), embora ele pode

no funcionar quando adicionarmos a unidade store, j que no respeita a condio de no fazer acessos

simultneos em mesmas posies da memria ou registradores.

Programa 3 Teste de operaes na ULA (sem respeitar as condies de acesso memria e banco de registradores).

Assembly Binrio000 Add R1 R2001 Sub R3 R4002 Sub R5 R6003 Mov R1 R0004 Set R0 10005 Jie 00000110006 Loadx R7 &00000001007 Store R8 &00000010

000 011100010010xxxx001 011000110100xxxx002 011001010110xxxx003 010000010000xxxx004 010100001010xxxx005 100000000110xxxx006 1100011100000001007 1101100000000010

A posio de memria &00000001 ter o valor 1011(11). Temos a seguinte configurao nos registradores:

R0 R1 R2 R3 R4 R5 R6 R7 R80010(2) 0011(3) 0100(4) 0110(6) 0101(5) 0111(7) 0111(7) 1001(9) 1010(10)

Diagrama .bdf:


30/38

30

Figura 16 Diagrama .bdf para simulao da execuo das instrues (incluindo estgios anteriores)


31/38

31

Resultados:

Figura 17 - Resultados da simulao da execuo de instrues

Observando os resultados da simulao, vemos que a execuo das operaes aritmticas e a passagem dos

valores necessrios unidade store ocorreu de maneira correta.

4.5ArmazenamentoTendo examinado quatro unidades de controle do pipeline, partiremos para a ltima, que completar o projeto

da CPU. Assim, nesta simulao testaremos a CPU por inteiro e seu comportamento com um programa (Programa 4

Programa genrico para teste geral do pipeline sem o uso da instruo JIE. que no possui instrues do tipo

Jump If Equal. O banco de registradores e a memria RAM comearo com todas as posies em zero.

Observando o programa, temos que a situao final dos registradores serR0=0

,R1=5

,R2=5

eR3=10

.

Programa 4 Programa genrico para teste geral do pipeline sem o uso da instruo JIE.

Assembly Binrio000 Set R1 5001 Set R2 5002 Nop003 Stx R1 &001004 Nop005 Add R1 R2006 Set R3 10007 Nop008 Mov R0 R1009 Lox R1 &001010 Nop011 Sub R0 R3012 Output R1013 Output R2014 Output R3015 Output R0

000 010100010101xxxx001 010100100101xxxx002 0000xxxxxxxxxxxx003 1101000100000001004 0000xxxxxxxxxxxx005 011100010010xxxx006 010100111010xxxx007 0000xxxxxxxxxxxx008 010000000001xxxx009 1100000100000001010 0000xxxxxxxxxxxx011 011000000011xxxx012 11110001xxxxxxxx013 11110010xxxxxxxx014 11110011xxxxxxxx015 11110000xxxxxxxx


32/38

32

Diagrama .bdf:


33/38

33

Figura 18 - Diagrama .bdf para simulao do armazenamento (incluindo estgios anteriores)


34/38

34

Resultados (lembrando que OpcodeOut a sada em exec):

Figura 19 - Resultados da simulao do armazenamento na CPU.

Observando os valores dos sinais de WriteEnable (Wren), os dados que esto sendo gravados, a retirada dos

mesmos, e por fim, os resultados em Output, vemos que o programa funcionou corretamente.

Este um bom momento para verificarmos o comportamento do simulador caso retiremos as instruesNop

,

fazendo com que haja leituras e escritas simultneas nas mesmas posies da memria e do banco de registradores.

Temos o programa:


35/38

35

Programa 5 Semelhante ao Programa 4 Programa genrico para teste geral do pipeline sem o uso da instruo JIE. mas sem o

tratamento especial para pipeline (remove-se as instrues Nop).

Assembly Binrio000 Set R1 5001 Set R2 5002 Stx R1 &001003 Add R1 R2004 Set R3 10005 Mov R0 R1006 Lox R1 &001007 Sub R0 R3008 Output R1009 Output R2010 Output R3011 Output R0

000 010100010101xxxx001 010100100101xxxx002 1101000100000001003 011100010010xxxx004 010100111010xxxx005 010000000001xxxx006 1100000100000001007 011000000011xxxx008 11110001xxxxxxxx009 11110010xxxxxxxx010 11110011xxxxxxxx011 11110000xxxxxxxx

Temos um trecho da simulao:

Figura 20 Simulao do pipeline com o programa 4 (sem tratamento de leituras/escritas em posies iguais)

Observe os valores em Result e Output de R1 o simulador do Quartus II detectou as leituras e escritas

simultneas e encontrou erros nos dados, representando-os como XXXX.

4.6Jumps e CondicionaisPor fim, testaremos o funcionamento da CPU com a incluso da instruo Jump If Equal, que dever zerar todas

as unidades quando chegar ao fim da execuo, evitando a execuo de instrues posteriores a ela. O diagrama

.bdf para o teste igual ao utilizado na seo 4.5. A memria de dados e o banco de registradores comearo todos

zerados. Temos o programa (um loop infinito):


36/38


37/38

37

Figura 21 Resultados da simulao do pipeline com um programa envolvendo Jump If Equal.

Observe o retorno do valor de FetchOut a 010100011110000, a instruo &001. O Jump If Equal

ocorreu. Tambm observa-se que o valor de Output permanece inalterado, demonstrando que nenhuma instruo

aps JIE realizada (pelo menos no o suficiente at que altere algum valor nos registradores ou memria).

5. Discusso e ConclusoA CPU 4 bits projetada ainda contm pouqussimas funcionalidades e no pode executar vrios tipos deprogramas por falta de recursos ou instrues. Por exemplo, neste trabalho no fizemos nenhum tratamento de

operaes com nmeros negativos ou flags de carry em caso de estouro nas operaes aritmticas. No obstante,

tambm no possvel definir o flag CmpFlag sem utilizar a instruo Sub, o que adiciona enormes dificuldades na

construo de estruturas condicionais e de loops, tornando programas simples, de certa forma, em programas

enormes e com muita manipulao aritmtica. No entanto, a CPU com pipeline ainda assim mais eficiente do que

uma implementao comum, sem pipeline, de uma CPU 4 bits.

Apesar de ser um projeto simples, a realizao do trabalho trouxe uma maior familiarizao com a linguagem de

descrio de hardware VHDL e com as etapas de projeto e design de um processador. O grupo achou muito

interessante e vislumbrou de perto os desafios enfrentados por grandes projetos e novas ideias de arquiteturas.


38/38

38

Bibliografia

[1] PATTERSON, HENNESY: Computer Organization and Design, 3rd edition

[2] Altera Quartus II Help (includo na instalao do software)

[3] Altera Quartus II Tutorial, http://lslwww.epfl.ch/pages/teaching/cours_lsl/sl_info/Labo5.b.pdf

[4] Wikipedia, http://pt.wikipedia.org/wiki/Pipeline

pipeline 4 bits

Documents