Arquitectura de Computadores I
2008/2009
“Implementação de um Processador monociclo de 16
bits”
GRUPO: 2 LABORATORIO nº: 4
Trabalho realizado por:
Carlos Ramos 21150262…[email protected]
Claudio Rama 21140186…[email protected]
Emanuel Ferreira 21170219…[email protected]
2
INDICE
1. Introdução ........................................................................................... 3
2. Descrição geral do processador ........................................................... 4
2.1 - Atribuição dos respectivos OPCodes ............................................................................... 5
2.2 - Linhas de Controlo da ALU ............................................................................................... 5
2.3 – Acção desejada para cada tipo de Instrução .................................................................. 5
2.4 - Controle dos Caminhos de Dados através da Unidade de Controlo............................... 6
2.5 – Descrição da execução das Instruções ............................................................................ 6
3. Descrição detalhada............................................................................. 7
3.1 - ALU .................................................................................................................................... 7
3.2 - Unidade de Registos......................................................................................................... 9
3.3 - Memória de Instruções .................................................................................................. 10
3.4 - Memória de dados ......................................................................................................... 12
3.5 - Unidade de controlo....................................................................................................... 14
3.5.1 - Controlador da ALU ..................................................................................................... 16
3.6 - Contador de programa ................................................................................................... 17
4. Execução de uma aplicação................................................................ 18
5. Adição de nova instrução................................................................... 21
6. Conclusões ......................................................................................... 22
ANEXOS.................................................................................................... 23
1 - Teste Memória de Instruções ........................................................................................... 23
2 – Teste Unidade de Controlo............................................................................................... 24
3 – Teste Controlador ALU ..................................................................................................... 25
4 – Teste Unidade de Registo................................................................................................. 26
5 – Teste ALU .......................................................................................................................... 27
6 – Teste Memória de Dados ................................................................................................. 28
3
1. Introdução
Este Trabalho Pratico consiste na construção de um modelo de processador monociclo de 16 bits como os seguintes requisitos: Opcode de 5 bits(com o 3º bit sempre igual a 1); 8 Registos. E depois testar o seu funcionamento através da execução de instruções.
Baseado numa arquitectura RISC monociclo, contém os seguintes componentes básicos: -Contador de programa; Memória de Instruções (1kb); Memória de dados(1kb); Unidade de registos; Unidade aritmética e lógica (ALU); Unidade de controlo.Que suportarão um subconjunto de instruções do processador MIPS pré-estabelecidas pelo professor, composto por instruções de acesso à memoria load Word (lw) e store Word (sw), instruções lógicas e aritméticas (sub, andi, slt, not) e instruções de desvioBNE e BLT e jump (j), constituindo três classes de instruções com os seguintes formatos:
-Instruções do Tipo R: -são as instruções lógicas e aritméticas (sub, slt, not);
- Instruções do Tipo I:
-são as instruções de acesso á memoria load Word (lw) e store Word (sw), salto condicionado e operações lógicas (andi) em que vez de ser passado um segundo registo para leitura, passa-se um valor imediato nos últimos 5 bits da instrução;
- Instruções do Tipo J:
-são as instruções que efectuam um salto incondicional. O endereço na memória de instruções para a qual se pretende saltar vem nos 11 bits menos significativos de instrução.
OPCode (5 bits) RS (3 bits) Rt (3 bits) Rd (3 bits) FUNC (2 bits)15-11 10-8 7-5 4-2 1-0
OPCode (5 bits) RS (3 bits) Rd (3 bits) Valor Imediato (5 bits)15-11 10-8 7-5 4-0
OPCode (5 bits) Valor Imediato (11 bits)15-11 10-0
4
Mesmo sendo estas classes de instruções de divertes existem algumas semelhanças entre elas, por exemplo todas elas utilizam a ALU (Unidade aritmética e lógica) após a leitura dos registos. As instruções de acesso à memória usam a ALU para efectuar o cálculo do endereço, As instruções lógicas e aritméticas executam a própria operação e os desvios condicionais efectuam comparações.
Após usar a ALU, as acções necessárias para completar a execução das instruções de cada classe são diferentes. Uma instrução que referencia a memória precisa realizar o acesso à memória. Nas instruções lógicas e aritméticas é preciso armazenar o resultado produzido pela ALU num registo. E, numa instrução de desvio pode ser necessário modificar o endereço da próxima instrução a ser buscada da memória.
2. Descrição geral do processador
O esquema seguinte representa o nosso processador, apresentação também dos BUS e dos respectivos bits que cada um suporta:
5
2.1 - Atribuição dos respectivos OPCodes
OPCODE Instruções00100 Tipo-R00101 LW00110 SW00111 ANDi01100 BNE01101 BLT01110 Tipo-J
2.2 - Linhas de Controlo da ALU
LinhaControlo
Função
000 SUB
001 NOT
010 SLT
011 ANDi
100 ADD
2.3 – Acção desejada para cada tipo de Instrução
Instruções OPCodeAcção
desejadaALUop
Funct OperaçãoAop1 Aop0
SUB Tipo-R Subtracção 0 0 00 000NOT Tipo-R Not 0 0 01 001SLT Tipo-R Slt 0 0 10 010BNE Branch Subtracção 0 1 - 000BLT Branch Subtracção 0 1 - 000
ANDi ANDi And 1 0 - 0111SW SW Adição 1 1 - 0000LW LW Add 1 1 - 0000
J Tipo-J - X X - XXX
6
2.4 - Controle dos Caminhos de Dados através da Unidade de Controlo
A Unidade de Controlo é a responsável para gera os sinais de escrita para todos os elementos de estados, os sinais dos selectores de todos os multiplexas e os sinais para o controle das operações da ALU.
A tabela seguinte mostra a definição dos sinais de saída produzidos pela unidade de controlo para controlar a execução dos diversos componentes do caminho de dados.
Instr. RegDst ALUcr RegWrite MemtoRegMemory Bracnh
BNE_BLTALUop JUMP
MemEnable Write_Read
Tipo - R 1 0 1 0 0 X 0X 00 0LW 0 1 1 1 1 0 0X 11 0SW 0 1 0 0 1 1 0X 11 0
ANDi 0 1 1 0 0 X 0X 10 0BNE 0 0 0 0 0 X 10 01 0
BLT 0 0 0 0 0 X 11 01 0Tipo - J x x x x 0 X XX XX 1
2.5 – Descrição da execução das Instruções
Para as instruções do tipo R (sub,not,slt),usa 3 registos (RS,RT,RD) vai necessitar de ler dois registos(RS e RT) da memória de Registos em que entram e fazem a sua operação na ALU, em que o resultado dessa operação é escrito no terceiro registo (RD) dado na instrução. A instrução SLT aproveita o ultimo bit que provem da subtração e insere-o no primeiro bits do seu bus de 16bits.
Para o LW e SW, instruções do Tipo I, usam dois registos RS,RT, sendo que o conteúdo de RS é lido para ALU e faz-se uma somado do offset dos 5 últimos bits que foram a anteriormente estendidos a 16 bits pelo Sign Extend, o resultado dessa operação é o endereço a ser lido(LW) ou escrito (SW) na memória de dados. Para o LW lê da memória de dados e escreve em RT, para o SW escreve na memória de dados o conteúdo de RT.
Para o BNE e o BLT , usa dois registos (RS,RT) e usa a ALU para fazer a comparação (Subtração), o BNE faz a comparação atraves da soma logica (ultilizando um or de 16 entradas) dos 16 bits que provem da subtração se o resultado for 1 logo a condição é verdadeira e vice versa, e o BLT faz a comparação ultilizando o ultimo bit que provem da subtração se o valor for 1 condição e verdadiera .Fora da ALU faz-se a soma do PC+4 e 16 bits que foram anterior-mente estendidos de 5 bits (IMM da instrução) para 16 bits e Shitf left de 1 devido ao último bit ser sempre zero. O resultado desta soma será o endereço a ser apontado pelo PC.
Para o J (jump), vai buscar na instrução os últimos 11 bits ,para que o salto seja sempre multiplo de 2 , faz um Shitf left de 1 bit, os restantes 4 bits [15-12] para completar o endereço
7
são os 4 bits mais significativos do endereço da instrução imediatamente a instrução que o PC aponta no momento (PC+2), sendo posteriormente esse endereço a ser apontado pelo PC.
3. Descrição detalhada
O processador de 16 bits ira ser constituído por vários blocos, cada um responsável pela sua função. O processador é constituído assim pelos seguintes constituintes:
a ALU é a unidade aritmética logica responsável por efetuar os cálculos necessários para o processador.
a memoria de registos que é responsável por guardar e ler dados temporários para serem usados na ALU ou serem escritos na memoria de dados, contem 4 entradas das quais duas contem o endereço dos registos a ler, outra contem o endereço do registo a escrever e outra contem os dados a serem escritos nesse registo.
a memoria de dados é responsável por guardar os dados que vem do resultado da ALU e por ler dados do endereço dado.
a memoria de instruções que contem as instruções de 16bits que vão ser processadas no processador, e que é lido do endereço dado na entrada.
Program counter é responsável por guardar o endereço da próxima instrução a ser lida
a unidade de controlo que é responsável por saber que operações vai ordenar consoante cada instrução.
3.1 - ALU
A ALU foi construída de acordo com as acções desejadas para pelo controlador da ALU e instruções especificados para o processador.
É constituída por um AND de 16 bits com duas entradas e uma saída construída através da junção de 16 and’s normais do Xilinx – ISE (and2), por um inversor de 16 bits (inv16) que faz o papel de um NOT, e também constituída por um ADSU16 componente este que quando enviado o sinal 1 ou 0 para a sua entrada ADD faz adições (1) ou subtracções (0) as subtracções são feitas em complementos de dois o que leva a necessidade de alimentar a entrada CIN do ADSU16 com o valor 1 e em caso de uma adição valor 0 o que leva a existência de um multiplexa que selecciona os valores de acordo com cada uma dessas duas acções . Existe um multiplexa de entradas de 16 bits que tem como função seleccionar a saída de acordo com acção que se deseja.
8
Na ALU encontra também as saídas do BNE e BLT lidos este a um multiplexa que selecciona (BRANCH) a comparação pretendida de acordo o valor enviado pela unidade de controlo.
Imagem 1 - interior da ALU
Imagem 2 - símbolo da ALU
9
3.2 - Unidade de Registos
A unidade de registos serve para guardar e ler dados ou endereços de 16bits de forma a serem usados na ALU ou a serem escritos na memória de dados. A nossa memória de registos terá 8 registos sendo por isso construída por 7 IO_FLIP_FLOPs (IFDX16) e também, considerando o registo zero, constituído por um bus de 16 bits a zero.
Os registos são seleccionados para serem lidos através de dois Multiplexa de 8 entradas de 16 bits e uma saída igualmente de 16 bits, que são seleccionados pela selecção do registo pretendido na entrada da unidade registo (ReadReg1 (2:0) ou ReadReg2 (2:0)). O registo a que se pretende escrever entra pela entrada WriteReg (2:0) e através de um descodificador e com o RegWrite, informação está enviado pela unidade de controlo, com o valor 1 que activa o FLIP-FLOP para escrita.
Imagem 3 - interior da Unidade de Registos
10
Imagem 4 - símbolo da unidade Registos
3.3 - Memória de Instruções
A memória de instruções é um componente apenas de leitura serve apenas para ler as instruções gravada na ROM. Recebe o endereço de 16 bits e envia o seu conteúdo de 16 bits para a saída.
O processador tem um Memória de instrução de 1kb, dividido em 4 blocos de 256b feitos a partir de 8 ROM256x1 cada bloco com uma entrada de endereço de 8 bits e saída 8 bits de saída.
Este blocos estão em conjuntos de 2 blocos que juntos forma um saída de 16 bits e entrada 8 bits para o endereço, sendo o segundo bloco adicionado o valor 1 através do ADD8 que permites endereçar os endereços impar.
Imagem 5 - símbolo de um Bloco de 256b
11
Imagem 6 - interior do Bloco de 256b
Imagem 7 - Memória de instruções
12
Imagem 8 - interior Memória de Instruções
3.4 - Memória de dados
A memoria de dados é um componente que guarda conteúdos de 16 bits e dos quais podem ser lidos. Ela tem uma capacidade de 1kb e foi construída através do componente do Xilinx-Se RAMB16_S18. A Memoria contem um controlador de escrita e leitura que é o ENABLE ligado a unidade de controlo e outro controlador WRITE_READ ligada também a unidade de controlo que quando recebe o valor 0 só faz leitura e o valor 1 armazena o conteúdo da entrada DATA (15:0) de acordo com o endereço recebido ADD (15:0).
13
Imagem 9 - interior da RAM
Imagem 10 - símbolo da Memória de Dados
14
3.5 - Unidade de controlo
A unidade de controlo trata-se de um componente que controla os outros competentes através de linhas de selecção, isto dependendo do opcode. No nosso caso o opcode é de 5 bits com o 3º bit sempre a 1 logo a entrada na unidade de controlo é de 5 bits de entrada. Tabela de verdade representada em baixo:
Opcode RegDst ALUcr RegWrite MemtoRegMemory Bracnh
BNE_BLTALUop JUMP
MemEnable Write_Read
00100 1 0 1 0 0 0 00 00 000101 0 1 1 1 1 0 00 11 000110 0 1 0 0 1 1 00 11 000111 0 1 1 0 0 0 00 10 001100 0 0 0 0 0 0 10 01 001101 0 0 0 0 0 0 11 01 001110 0 0 0 0 0 0 0 00 1
Imagem 11 - símbolo da Unidade de Controlo
15
Imagem 12 - interior da Unidade de Controlo
16
3.5.1 - Controlador da ALU
Unidade de controlo da ALU que recebe como entrada o func e as linhas de controlo da unidade de controlo principal (Aop1 e Aop0). Consoante a entrada do aluop a unidade deverá ver ou não a entrada func de modo a gerar um valor na saída do OP (2:0).
Imagem 13 - interior Controlador ALU
Imagem 14 - símbolo Controlador ALU
17
3.6 - Contador de programa
O contador de programa ou PC é a unidade que controla os deslocamentos no processador, inicialmente a zero vai deslocando sempre em múltiplos de dois . é controlado por um reset que força a inicialização a zero e por um clock que controla também o unidade de registo e a memória de dados.
Imagem 15 - interior PC
Imagem 16 - símbolo PC
18
4. Execução de uma aplicação
A seguinte instrução foi codificada e inicializada nas ROMs:
LW $R1, 0($0)BNE $R1,$0,SALTO1
LOOP: SUB $R6, $R1, $R2ANDI $R3,$R6,11BLT $R3,$R2,SALTO3J SALTO2
SALTO1 : J LOOPSALTO3: NOT $R2,$R3,$R3SALTO 2: SW $R2, 16($0)
Codificação dos registos:
$0 ->000$R1->001$R2->010$R3->011$R6->110
Codificação em binário e hexadecimal do código:
0 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0 0x28200 1 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0x60240 0 1 0 0 0 0 1 0 1 0 1 1 0 0 0 0x21580 0 1 1 1 1 1 0 0 1 1 0 1 0 1 1 0x3E6B0 1 1 0 1 0 1 0 0 1 1 0 0 0 1 0 0x6A620 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0x70080 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0x70020 0 1 0 0 0 1 1 0 1 1 0 1 0 0 1 0x23690 0 1 1 0 0 0 0 0 1 0 1 0 0 0 0 0x3050
19
Inicialização da ROM :
ENDERÇOS #ROM 8 7 6 5 4 3 2 1 Valor em Hexadecimal das ROMs
0 0 0 1 0 0 0 0 0 0 C 0 6 0//VALOR
ROM1
1 0 0 1 0 1 0 0 0 0 9 3 C 0//VALOR
ROM2
2 0 0 1 0 0 1 0 0 0 0 0 8 4//VALOR
ROM3
3 0 1 1 0 0 0 0 0 0 4 6 D 2//VALOR
ROM4
4 0 1 0 1 1 0 0 0 3 2 8 9 0//VALOR
ROM5
5 0 0 1 0 0 0 0 1 2 E B E F//VALOR
ROM6
6 0 1 1 0 1 0 1 1 1 6 B 5 8//VALOR
ROM7
7 0 0 1 1 1 1 1 0 0 0 0 0 0//VALOR
ROM88 0 1 1 0 0 0 1 0 H L9 0 1 1 0 1 0 1 0
10 0 0 0 0 1 0 0 011 0 1 1 1 0 0 0 012 0 0 0 0 0 0 1 013 0 1 1 1 0 0 0 014 0 1 1 0 1 0 0 115 0 0 1 0 0 0 1 116 0 1 0 1 0 0 0 017 0 0 1 1 0 0 0 0
20
Execução detalhada do programa simulada no XILINX – ISE:
Imagem 17 - simulação do processador
21
5. Adição de nova instrução
Dada a seguinte instrução, iremos descrever as alterações que poderiam ser feitas no processador de forma a possibilitar a sua execução:
SLL RD, RO, IMM
Tratasse de um Shilt Left Logical, instrução que tem por fim deslocar o valor contido no registo RO para esquerda o numero de bits especificado em IMM e preenchendo o bits menos significativos com 0’s e esse valor depois é guardado no registo RD.
Começaríamos por criar um novo Opcode para a nossa instrução:
OPCode INST.01111 SLL
Efectuar um Shilt Left Logical é como multiplica-se o valor em RO em potência de dois, ou seja, no caso de o deslocamento ser dado pelo IMM seria R0 x 2IMM.
O valor de IMM seria passado pelos 5 bits menos significativos e teríamos de construir uma unidade que teria como função calcular 2IMM esse resultado seria logo estendido para 16 bits e entraria na ALU onde seria efectuado a seguinte operação R0 x 2IMM:
- Para o caso seria necessário juntar um multiplexa que através do sinal (SLL) enviado pela unidade de controlo seleccionaria extender o valor dos 5 bits mais significativos para 16 bits ou calcular 2IMM.
Ao controlador da ALU seria introduzido uma nova operação em que dava a ordem para fazer a multiplicação R0 x 2IMM e esse resultado seriam escritos no registo destino RD.
Tabela Unidade de Controlo modificada:
Instr. RegDst IMM ALUcr RegWrite MemtoRegMemory Bracnh
BNE_BLT ALUop JUMPMemEnable Write_Read
Tipo - R 1 0 0 1 0 0 X 0X 000 0LW 0 0 1 1 1 1 0 0X 011 0SW 0 0 1 0 0 1 1 0X 011 0
ANDi 0 0 1 1 0 0 X 0X 010 0BNE 0 0 0 0 0 0 X 10 001 0BLT 0 0 0 0 0 0 X 11 001 0
Tipo - J x X x x x 0 X XX XXX 1SLL 0 1 1 1 0 0 X XX 100 0
22
Tabela Controlador da ALU:
LinhaControlo
Função
000 SUB
001 NOT
010 SLT
011 ANDi
100 ADD
110 MULT
6. Conclusão
Com este trabalho ficamos a conhecer de uma forma mais profunda, e detalhada o funcionamento de um processador monociclo. Ficamos com melhor compreensão da função de cada parte de um processador e de como uma instrução é executada.
23
ANEXOS
1 - Teste Memória de Instruções
24
2 – Teste Unidade de Controlo
25
3 – Teste Controlador ALU
26
4 – Teste Unidade de Registo
27
5 – Teste ALU
28
6 – Teste Memória de Dados
29