Questão: Como as instruções do processador funcionam?
A última versão, do nosso circuito para resolver equações de primeiro grau, já pode ser considerado como um computador com programa armazenado. O programa, gravado na ROM, deve controlar a atuação de todos pontos de controle e é sequenciado pelo contador de programa (Program Counter ou PC).
Para um fluxo de dados pequeno, como o nosso, essa não é uma tarefa tão desafiante. Porém, quando o fluxo fica mais complexo e possui mais pontos de controle, além da utilização de uma memória com uma palavra de dados grande (um bit para cada ponto de controle), a programação fica muito mais complexa e pouco intuitiva, ou seja, com mais possibilidades de erros.
Uma forma de resolver esses dois pontos é a criação de um código intermediário que represente as operações que devem ser executadas pelo fluxo de dados. Assim, criamos códigos binários e mnemônicos para simplificar a programação e diminuir o tamanho da unidade de armazenamento para o programa. Esses códigos, e seus mnemônicos, são as instruções do nosso computador.
Para tanto, vamos necessitar de um “conversor” entre o código criado e o conteúdo que deve ser aplicado aos pontos de controle. Esse conversor é chamado de decodificador de instruções.
O decodifcador de instruções pode ser implementado de duas formas distintas: com lógica combinacional (hard-wired); com uma memória ROM (microprogramado).
O sistema de sequenciamento do programa, é o mesmo mostrado na aula passada e está dentro da unidade funcional chamada de Próxima Instrução.
Vamos criar um novo projeto baseado na figura anterior (“Solução para Equação de Primeiro Grau com Decodificador de Instruções”), aproveitando o trabalho das aulas anteriores.
Por enquanto, vamos criar as seguintes instruções para o nosso novo computador:
Carrega Acumulador;
Limpa Acumulador;
Soma A e B e armazena no Acumulador;
Subtrai B de A e armazena no Acumulador;
Lembre de utilizar a tabela com os pontos de controle para criar as instruções desejadas e de criar nomes para essas instruções.
Note que ainda não nos preocuparemos com a instrução de desvio.
Temos quatro instruções mas iremos adicionar, futuramente, as instruções de comparação e desvio. Portanto, vamos considerar um conjunto de instruções com 16 instruções.
Para facilitar, vamos preencher a tabela abaixo com as condições dos pontos de controle para cada instrução.
Instrução | Mnemônico | Código Binário | Sel MUX | Habilita A | Reset A | Operação | ||
---|---|---|---|---|---|---|---|---|
Sem Operação | NOP | 0000 | ||||||
Carrega Acumulador | LDA | 0001 | ||||||
Soma A e B e armazena no Acumulador | SOMA | 0010 | ||||||
Subtrai B de A e armazena no Acumulador | SUB | 0011 | ||||||
Limpa o Acumulador | CLRA | 1111 |
De posse dessas informações, vamos criar o decodificador utilizando um circuito que faz a soma de produtos.
O primeiro passo é a decodificação dos produtos que representam as nossas instruções. Para isso, usaremos um decodificador com quatro bits de entrada e 16 bits de saída. Cada bit de saída, ou seja, cada produto, indicará uma instrução especificada na tabela anterior.
Para encontrar os produtos que devemos somar, devemos analisar cada ponto de controle separadamente. Para cada ponto de controle, anote os códigos binários das instruções que ativam esse ponto de controle (esses são os produtos que devem ser somados).
Agora, para cada ponto de controle, utilize uma porta OR com a saída ligada ao ponto de controle e as entradas ligadas às saídas dos produtos desse ponto de controle.
Para implementar esse circuito em VHDL, podemos utilizar a Atribuição Condicional de Sinais (when
).
É utilizada quando existe somente um objeto que receberá a atribuição de uma expressão quando a condição especificada for verdadeira.
As condições são avaliadas sequencialmente até que encontre o primeiro resultado verdadeiro. Nesse caso, a expressão referente a essa condição será avaliada e atribuída ao objeto.
Essa construção possui somente uma atribuição que receberá a expressão escolhida, pela primeira condição verdadeira, entre as diversas opções. Note que a existência de uma cláusula else final serve para evitar a implementação, incorreta, de latchs.
A sua sintaxe está mostrada abaixo:
O tipo de dados utilizado para o <target>, deve ser o mesmo que o da <expression>. Além disso, o tamanho, de ambos, deve ser coerente.
Além disso, podemos utilizar constantes para facilitar a leitura do código VHDL e para evitar erros. A declaração das constantes é parecida com a declaração de signal, como pode ser vista abaixo. O nosso decodificador ficaria conforme o mostrado no código abaixo.
library ieee;
use ieee.std_logic_1164.all;
entity decoderInstru is
port ( opcode : in std_logic_vector(3 downto 0);
saida : out std_logic_vector(3 downto 0)
);
end entity;
architecture comportamento of decoderInstru is
constant NOP : std_logic_vector(3 downto 0) := "0000";
constant LDA : std_logic_vector(3 downto 0) := "0001";
constant SOMA : std_logic_vector(3 downto 0) := "0010";
constant SUB : std_logic_vector(3 downto 0) := "0011";
constant CLRA : std_logic_vector(3 downto 0) := "1111";
begin
saida <= "0000" when opcode = NOP else
"XXXX" when opcode = LDA else
"XXXX" when opcode = SOMA else
"XXXX" when opcode = SUB else
"XXXX" when opcode = CLRA else
"0000"; -- NOP para os opcodes Indefinidos
end architecture;
Por fim, devemos adicionar o novo decodificador ao nosso novo projeto do computador e alterar a programação da ROM.
Para a programação da ROM, podemos utilizar constantes, com os opcodes, para facilitar a criação do código.
Com o circuito pronto, faça o teste utilizando a equação 3x - 4.
Responder o quiz de participação, no blackboard, em:
Conteúdos > Participação > Aula_3_Quiz-P1
O resultado da compilação será o circuito, em RTL, mostrado no diagrama abaixo.
Para fazer a simulação, reagrupe os sinais de entrada e saída conforme o mostrado na figura abaixo.
Além disso, repare nos valores da entrada de dados, mostrados abaixo.
Considerando o valor de X como sendo 3, o resultado da simulação está mostrado abaixo.
Esta Atividade deverá ser entregue através do Blackboard!