Pipeline 4 Bits
-
Upload
fernando-pasquini -
Category
Documents
-
view
268 -
download
0
Transcript of 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
-
8/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
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)
-
8/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
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 -
8/7/2019 Pipeline 4 Bits
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.
-
8/7/2019 Pipeline 4 Bits
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/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
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.
-
8/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
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:
-
8/7/2019 Pipeline 4 Bits
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:
-
8/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
15/38
15
-- Add, Sub or MovRegAddr1
-
8/7/2019 Pipeline 4 Bits
16/38
16
if (Clear = '1') then -- Verifica ClearOpcodeOut
-
8/7/2019 Pipeline 4 Bits
17/38
17
if (Clear = '1') then -- Verifica ClearOpcodeOut -- Add
Result -- Sub
Result
-
8/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
19/38
19
PMemWren
-
8/7/2019 Pipeline 4 Bits
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;
-
8/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
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);
-
8/7/2019 Pipeline 4 Bits
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,
-
8/7/2019 Pipeline 4 Bits
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);
-
8/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
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.
-
8/7/2019 Pipeline 4 Bits
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:
-
8/7/2019 Pipeline 4 Bits
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:
-
8/7/2019 Pipeline 4 Bits
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:
-
8/7/2019 Pipeline 4 Bits
30/38
30
Figura 16 Diagrama .bdf para simulao da execuo das instrues (incluindo estgios anteriores)
-
8/7/2019 Pipeline 4 Bits
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
-
8/7/2019 Pipeline 4 Bits
32/38
32
Diagrama .bdf:
-
8/7/2019 Pipeline 4 Bits
33/38
33
Figura 18 - Diagrama .bdf para simulao do armazenamento (incluindo estgios anteriores)
-
8/7/2019 Pipeline 4 Bits
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:
-
8/7/2019 Pipeline 4 Bits
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):
-
8/7/2019 Pipeline 4 Bits
36/38
-
8/7/2019 Pipeline 4 Bits
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.
-
8/7/2019 Pipeline 4 Bits
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