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….a21150262@alunos.isec.pt

Claudio Rama 21140186….a21140186@alunos.isec.pt

Emanuel Ferreira 21170219….a21170219@alunos.isec.pt

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