Implementação da unidade de controle de um
processador
OBJETIVOS
Conhecer as funções realizadas pela Unidade de Controle
Implementar uma unidade de controle para o datapath estudado, completando um processador simples
Entender a codificação de instruções em campos de bits
Conhecer a sequência básica de execução de instruções e os mecanismos que alteram esta sequência, como também como estes afetam a implementação do contador de programa (PC)
Compreender a formação de sinais de controle a partir das instruções armazenadas em memória
Implementar uma memória ROM completamente combinacional através de uma descrição em Verilog
Verificar o funcionamento de um processador através da execução de algumas instruções
INTRODUÇÃO
Neste experimento será implementada uma unidade de controle, que juntamente com o datapath desenvolvido nos experimentos anteriores, define um processador bastante simples, capaz de executar 19 instruções. Este processador, apesar de muito simples, possui algumas características típicas de projetos mais modernos de processadores, e servirá como base para o estudo de outros processadores existentes. Este processador possui a característica de executar uma instrução por ciclo de clock. Para isto diversas opções de projeto foram tomadas. Em particular, temos a transformação de dados realizada de forma completamente combinacional. Outra exigência particular reside no fato de termos uma memória de instruções também combinacional, o que não é usual. A principal limitação deste processador reside na impossibilidade de termos instruções complexas, que utilizem o datapath por mais de um ciclo de clock. Estas operações mais complexas, como multiplicação, por exemplo, precisam ser realizadas com várias instruções existentes, na forma de uma subrotina.
O funcionamento deste processador pode ser verificado manualmente, realizando-se diversas instruções, através da aplicação dos sinais de controle e valores dos dados nas chaves da placa DE2 e a observação dos resultados através dos LEDs e displays de 7 segmentos. Também podemos armazenar um programa em uma memória de instruções. Esta memória completamente combinacional pode ser criada em Verilog, utilizando um vetor de vetores de bits, ou utilizando uma descrição em Verilog similar a um decodificador (opção que será implementada neste experimento). Outra possibilidade, que será utilizada no próximo experimento, consiste na utilização do gerador de macrocélulas (circuitos pré-definidos) do Quartus-II.
PREPARAÇÃO
HDL_3
A unidade de controle a ser implementada já foi completamente definida e a sua lógica simplificada. Desta forma, a maneira mais simples de implementação consiste em utilizar o projeto já feito e descrevê-lo diretamente em Verilog. Para simplificar o processo, algumas dicas de implementação são mostradas na seção sobre implementação. Além do datapath realizado nos experimentos anteriores, será necessária a utilização de decodificadores de 4 bits para sete segmentos, incluindo os valores hexadecimais. Estes decodificadores são utilizados para mostrar o valor do PC e de um dos 8 registradores.
UMA ARQUITETURA DE UM COMPUTADOR SIMPLES
Estamos introduzindo uma arquitetura de um computador simples para obter um entendimento inicial sobre projeto de computadores e para ilustrar projetos de controle para sistemas programáveis. Em um sistema programável, uma parte da entrada do processador consiste de uma sequência de instruções. Cada instrução especifica uma operação para o sistema realizar, quais operandos usar para a operação, onde armazenar os resultados da operação e/ou, em alguns casos, qual instrução executar em seguida. Para um sistema programável, as instruções são normalmente armazenadas em memória, que pode ser RAM (memória de leitura e escrita) ou ROM (memória de leitura apenas). Para executar as instruções em sequência, é necessário fornecer o endereço na memória da instrução a ser executada. Em um computador, este endereço vem de um registrador chamado de contador de programa (PC, do inglês program counter). Como o nome sugere, o PC tem lógica que permite que ele conte. Além disso, para mudar a sequência de operações usando decisões baseadas em informações de estado, o PC precisa de capacidade de carregamento paralelo. Assim, no caso de sistemas programáveis, a unidade de controle contém um PC e lógica de decisão associados, como também a lógica necessária para interpretar as instruções para poder executá-las. Executar uma instrução significa ativar a sequência de microoperações no datapath (e em outros lugares) necessária para efetuar a operação especificada pela instrução. Em contraste, note que para um sistema não programável a unidade de controle não é responsável por obter as instruções da memória nem é responsável por seqüenciar a execução destas instruções. Não há um PC ou registrador similar em um sistema desses. Em vez disso, a unidade de controle determina as operações a serem realizadas e a sequência destas operações baseada apenas nas suas entradas e nos bits de estado.
ARQUITETURA DO CONJUNTO DE INSTRUÇÕES
O usuário especifica as operações a serem realizadas e sua sequência usando um programa, que é uma lista de instruções que especificam as operações, os operandos e sequência em que o processamento deve ocorrer. O processamento de dados realizado pelo computador pode ser alterado ao especificar um novo programa com diferentes instruções ou ao especificar as mesmas instruções com dados diferentes. Instruções e dados são normalmente armazenados conjuntamente na mesma memória. Por meio de técnicas como memória cache, pode parecer que estes provêm de memórias diferentes. A unidade de controle lê uma instrução da memória, decodifica e executa a instrução ao lançar uma sequência de uma ou mais microoperações. A habilidade de executar um programa
proveniente da memória é a propriedade singular mais importante de um computador de propósito geral. A execução de um programa armazenado em memória contrasta fortemente com o controle feito com máquinas de estado usuais, que executam operações seqüenciadas apenas pelas entradas e sinais de estado.
Uma instrução é uma coleção de bits que instrui o computador a realizar uma operação específica. Chamamos a coleção de instruções de um computador seu conjunto de instruções e a descrição detalhada do conjunto de instruções a sua arquitetura do conjunto de instruções (ISA, do inglês Instruction Set Architecture). Arquiteturas de conjunto de instruções simples possuem três componentes principais: os recursos de armazenamento, os formatos de instruções e as especificações das instruções.
RECURSOS DE ARMAZENAMENTO
Os recursos de armazenamento para um computador simples são representados pelo diagrama da Figura 1. No diagrama é colocada a estrutura do computador como vista por um usuário que esteja programando em uma linguagem que especifique diretamente as instruções a serem executadas. São dados os recursos que o usuário vê como disponível para armazenar informações. Note que a arquitetura inclui duas memórias, uma para armazenar instruções e outra para armazenar os dados. Estas podem ser realmente memórias diferentes ou podem ser a mesma memória, mas vistas como diferentes do ponto de vista da CPU (devido ao uso de estruturas auxiliares, como memória cache). Também é visível ao programador, no diagrama, um banco de registradores com oito registradores de 16 bits e um contador de programa de 16 bits.
Figura 2. Três formatos de instrução
FORMATOS DE INSTRUÇÃO
O formato de uma instrução é normalmente descrito por uma caixa retangular simbolizando os bits da instrução, como estas aparecem em palavras na memória ou em um registrador de controle. Os bits são divididos em grupos ou partes denominados campos. A cada campo é atribuído um item específico, como o código da operação, um valor constante ou um endereço do banco de registradores. Os vários campos especificam diferentes funções para as instruções e, quando mostradas conjuntamente, constituem um formato de instrução.
O código da operação de uma instrução, normalmente denominado de “opcode” (do inglês, operation code), é o grupo de bits de uma instrução que especifica uma operação, tal como somar, subtrair, deslocar ou complementar. O número de bits requeridos pelo opcode de uma instrução é uma função do número total de operações do conjunto de instruções. Ele deve consistir de pelo menos m bits para até 2m operações distintas. O projetista atribui uma
combinação de bits (um código) para cada operação. O computador é projetado para aceitar esta configuração de bits no momento apropriado na sequência de atividades e para fornecer a sequência de palavras de controle que executam a operação especificada. Como um exemplo específico, considere um computador com um máximo de 128 operações distintas, uma delas sendo uma operação de soma. O opcode atribuído para esta operação consiste de sete bits 0000010. Quando o opcode 0000010 é detectado pela unidade de controle, uma sequências de palavras de controle é aplicada ao datapath para realizar a soma pretendida.
O opcode de uma instrução especifica a operação a ser realizada. A operação deve ser realizada usando dados armazenados nos registradores do computador ou em memória (ou seja, no conteúdo de um dos recursos de armazenamento). Uma instrução, portanto, deve especificar não apenas a operação, mas também os registradores ou palavra da memória em que os operandos são encontrados e onde o resultado deverá ser salvo. Os operandos podem ser especificados por uma instrução de duas formas. Um operando é dito ser especificado
explicitamente se a instrução contém bits determinados para sua identificação. Por exemplo, a instrução que realiza uma soma pode conter três números binários especificando os registradores que contêm os dois operandos e o registrador que recebe o resultado. Uma operação é dita como definida implicitamente se é incluída como parte da definição da própria operação, como representada pelo opcode, ao invés de ser dado na instrução. Por exemplo, em uma operação de Incrementar Registrador, um dos operando é implicitamente +1.
Os três formatos de instrução do computador simples são ilustrados na Figura 2. Suponha que o computador tenha um banco de registradores consistindo de oito registradores, R0 até R7. O formato da instrução na Figura 2(a) consiste de um opcode que especifica o uso de três ou menos registradores, conforme necessário. Um dos registradores é assinalado como um destino para o resultado e dois dos registradores como fontes dos operandos. Por conveniência, os nomes dos campos são abreviados para “DR” (registro de destino, do inglês, destination register), “AS” para “registro fonte A (do inglês, source register A)” e “SB” para “registro fonte B (do inglês, source register B)”. As quantidades de campos de registradores e registradores realmente utilizados são determinados pelo opcode específico. O opcode também especifica o uso dos registradores. Por exemplo, para uma operação de subtração, suponha que os três bits em “AS” sejam 010, especificando R2, os três bits em “SB” sejam 011, especificando R3, e os três bits em “DR” sejam 001, especificando R1. Então o conteúdo de R3 será subtraído do conteúdo de R2 e o resultado será colocado em R1. Como um exemplo adicional, suponha que a operação seja um armazenamento (na memória). Suponha também que os três bits de “AS” especifiquem R4 e os três bits em “SB” especifiquem R5. Para esta operação particular, é assumido que o registrador especificado em “AS” contenha o endereço e o registrado especificado em “SB” contém o operando a ser guardado. Então o valor de R5 é armazenado na posição de memória dada pelo valor em R4. O campo “DR” não tem nenhum efeito, uma vez que a operação de armazenamento evita que o banco de registradores seja escrito.
O formato de instrução da Figura 2(b) tem um opcode, dois campos de registradores e um operando. O operando é uma constante chamada de operando imediato, já que está imediatamente disponível na própria instrução. Por exemplo, para uma operação de soma imediata com “AS” especificado como R7, “DR” especificado como R2 e operando “OP” igual a 011, o valor 3 é somado ao conteúdo de R7 e o resultado da soma é colocado em R2. Como o operando é de apenas três bits e não os 16 bits completos, os 13 bits restantes precisam ser preenchidos usando-se preenchimento com zero ou extensão de sinal. Nesta ISA, o preenchimento com zero é especificado para o operando.
O formato de instrução na Figura 2(c), em contraste com os outros dois formatos, não modifica nenhum conteúdo do banco de registradores ou da memória. Em vez disso, ele altera a ordem em que as instruções são buscadas da memória. A posição de uma instrução a ser buscada é determinada pelo contador de programa, denotada como “PC”. Primariamente, o contador de programa busca uma instrução de endereços seqüenciais na memória enquanto o programa é executado. Mas boa parte do poder de um processador vem da habilidade de modificar a ordem da execução das instruções baseado no resultado das operações realizadas. Estas mudanças na ordem da execução das instruções são baseadas no uso de instruções referidas com saltos (em inglês, jumps) e desvios (em inglês, branches).
O exemplo de formato dado na Figura 2(c) para instruções de salto e desvio têm um código de operação, um campo de registro “AS” e um campo fragmentado de endereços “AD”. Se um desvio (possivelmente baseado no conteúdo do registrador especificado) deve ocorrer, o novo endereço é formado adicionando-se o conteúdo do “PC” com o conteúdo do campo de endereço de 6 bits. Este método de endereçamento é chamado relativo ao “PC” e o campo de endereço de 6 bits, referido como um deslocamento de endereço (em inglês, offset address), é tratado como um número em complemento de 2. Para preservar a representação em complemento de 2, a extensão de sinal é aplicada ao endereço de 6 bits para formar um deslocamento de 16 bits antes da soma. Se o bit mais a esquerda do campo de endereço “AD” é um 1, então os 10 bits a sua esquerda são preenchidos com 1s para dar um deslocamento negativo em complemento de 2. Se o bit mais a esquerda do campo de endereço for 0, então os 10 bits a sua esquerda são preenchidos com 0s para dar um deslocamento positivo em complemento de 2. O deslocamento é somado ao conteúdo do “PC” para formar a localização da qual a próxima instrução será buscada. Por exemplo, com o valor do “PC” igual a 55, suponha que um desvio deva ocorrer para a posição 35, se o conteúdo de R6 for igual a zero. O opcode especificaria uma instrução de desviar-se-zero, “AS” especificaria R6 e “AD” seria a representação em 6 bits em complemento de 2 de 55 + (-20) = 35 e a próxima instrução será buscada a partir do endereço 35. Caso contrário, se R6 não for zero, o “PC” irá contar para 56 e a próxima instrução será buscada a partir do endereço 56. Este método de endereçamento sozinho fornece apenas endereços de desvios dentro de uma pequena faixa abaixo e acima do valor do “PC”. O salto (jump) fornece uma faixa mais ampla de endereços ao utilizar o conteúdo sem sinal de um registrador de 16 bits como o alvo do salto.
ESPECIFICAÇÃO DAS INSTRUÇÕES
As especificações das instruções descrevem cada uma das instruções distintas que podem ser executadas pelo sistema. Para cada instrução, o opcode é dado juntamente com um nome abreviado chamado de mnemônico, que pode ser usado como uma representação simbólica para o opcode. Este mnemônico, juntamente com uma representação para cada um dos campos adicionais no formato da instrução, representa a notação a ser usada para especificar todos os campos de uma instrução simbolicamente. Esta representação simbólica é então convertida para a representação binária da instrução por um programa chamado de assembler (montador, em inglês). A descrição da operação efetuada pela execução da instrução é dada, incluindo os bits de estado que são afetados pela instrução. Esta descrição pode ser textual ou pode usar uma notação de transferência de registradores.
As especificações das instruções para o computador simples são dados na Tabela 1. A notação de transferência de registradores é utilizada para descrever as operações realizadas. Os bits de estado válidos para cada instrução, também são indicados. Para poder ilustrar as instruções, suponha que tenhamos uma memória com 16 bits por palavra com instruções tendo um dos formatos da Figura 2. Instruções e dados, em binário, são colocados na memória, como mostrado na Tabela 2. Esta informação armazenada representa as quatro instruções ilustrando os formatos distintos. No endereço 25, temos uma instrução no formato registradores que especifica a operação subtrair R3 de R2 e carregar a diferença em R1. Esta operação é representada simbolicamente na coluna do canto direito da Tabela 2. Observe que
o opcode de 7 bits para subtração é 0000101, ou decimal 5. Os bits restantes da instrução especificam os três registradores: 001 especifica o registrador de destino como sendo R1, 010 especifica o registrador de fonte A como sendo R2 e 011 especifica o registrador de destino B como sendo R3.
Tabela 1. Especificações das instruções para o Computador Simples. Observe que nas instruções com *, PC PC + 1 também é realizado para preparar para a próxima instrução.
Tabela 2. Representação das Instruções e Dados
Na posição de memória 35 está uma instrução no formato registradores para armazenar o conteúdo de R5 na posição de memória especificada por R4. O opcode é 0100000,
ou decimal 32, e a operação é dada simbolicamente, novamente, na coluna direita da figura. Suponha que R4 contenha 70 e R5 contenha 80. Então a execução desta instrução irá armazenar o valor 80 na posição de memória 70, substituindo o valor original de 192 armazenado lá.
No endereço 45 aparece uma instrução no formato imediato que soma 3 ao conteúdo de R7 e carrega o resultado em R2. O opcode para esta instrução é 66 e o operando para ser somado é o valor 3 (011) no campo OP, os últimos três bits da instrução.
Na posição 55 aparece a instrução de desvio descrita anteriormente. O opcode para esta instrução é 96 e o registrador fonte é especificado como R6. Observe que “AD” (esquerdo) contém 101 e “AD” (direito) contém 100. Colocando estes dois valores juntos e aplicando a extensão de sinal, obtemos 1111111111101100, que representa -20 em complemento de 2. Se o registrador R6 tiver conteúdo zero, então -20 será somado ao valor do “PC” resultando em 35. Se o registrador R6 não for zero, o novo valor de “PC” será 56. Note que assumimos que a soma com o ”PC” acontece antes que o “PC” seja incrementado, o que é o caso neste computador simples. Em sistemas reais, no entanto, por vezes o “PC” já foi incrementado para apontar para a próxima instrução na memória. Nestes casos, o valor armazenado em AD precisa ser ajustado de acordo para obter o endereço correto para o desvio, neste caso, -19.
O posicionamento das instruções na memória como mostrado na Tabela 2 é de certa forma arbitrária. Em muitos computadores, o comprimento da palavra é de 32 ou 64 bits, de forma que os formatos das instruções permitem armazenar operandos imediatos e endereços muito maiores que estes que utilizamos. Dependendo da arquitetura do computador, alguns dos formatos das instruções podem ocupar duas ou mais palavras consecutivas da memória. Além disso, o número de registradores costuma ser maior, de forma que os campos de registradores precisam ter mais bits.
Neste ponto, é vital reconhecer a diferença entre uma operação do computador e uma microoperação do hardware. Uma operação é especificada por uma instrução armazenada em binário na memória do computador. A unidade de controle do computador utiliza o endereço ou endereços fornecidos pelo contador de programa para recuperar a instrução da memória. Ela então decodifica os bits do opcode e outras informações na instrução para realizar as microoperações necessárias para a execução da instrução. Diferentemente, uma microoperação é especificada pelos bits em uma palavra de controle no hardware que é decodificada para executar as microoperações. A execução de uma operação do computador normalmente requer uma sequência ou programa de microoperações no lugar de uma única microoperação.
CONTROLE EM LÓGICA PARA CICLO ÚNICO
O diagrama de blocos de um computador que possui uma unidade de controle realizada com lógica (hardwired) que busca e executa uma instrução em um único ciclo de clock é mostrada na Figura 3. Nós nos dirigimos a este como o computador (processador) ciclo único. Os recursos de armazenamento, formatos de instrução e especificações das instruções para este computador foram vistos anteriormente. O datapath mostrado é o mesmo estudado
com m = 3 e n = 16 (número de bits de endereçamento dos registradores e largura dos barramentos). A memória de dados M é ligada ao datapath nas conexões de saída de endereços (Address Out), saída de dados (Data Out) e entrada de dados (Data In). Ela possui apenas um sinal de controle MW, que é 1 para escrever na memória e 0 caso contrário.
Figura 3. Diagrama de Blocos de um Computador de Ciclo Único
A unidade de Controle aparece no lado esquerdo da Figura 3. Embora não seja usualmente vista como fazendo parte de uma unidade de controle, a memória de instruções, juntamente com as entradas de endereço e a saída de instruções são mostradas por conveniência dentro da unidade de controle. Nós não escrevemos na memória de instruções durante a execução de um programa, fazendo-a aparecer neste modelo como sendo um componente combinacional em vez de seqüencial. Como discutido previamente, o PC fornece o endereço da instrução para a memória de instruções e a saída de instruções da memória vai para a lógica de controle, que neste caso é o decodificador de instruções. A saída da memória de instruções também vai para a Extensão e Preenchimento com zero, que fornecem o deslocamento de endereço e a entrada de constante, Constant In, para o datapath, respectivamente. O bloco Extensão coloca cópias do bit mais a esquerda do campo de 6 bits AD, preservando sua representação em complemento de 2. O bloco de Preenchimento com
Zero acrescenta 13 zeros à esquerda do campo de operando (OP) da instrução para formar um operando sem sinal de 16 bits para usar no datapath. Por exemplo, o valor do operando 110 torna-se 0000000000000110 ou +6.
O PC é atualizado em cada ciclo de clock. O comportamento do PC, que é um registrador complexo, é determinado pelo opcode, e pelos bits de estado N e Z. Um registrador complexo opera em diversos modos. No caso do PC ele opera como contador e com carga de valor inicial. Se ocorre um salto, o novo PC torna-se o valor do barramento A. Se um desvio é implementado, então o novo valor do PC é a soma do PC anterior e o deslocamento de endereço com sinal (estendido), que em complemento de 2 pode ser positivo ou negativo. Caso contrário, o PC é incrementado de 1. Um salto (jump) ocorre se o bit 13 na instrução for igual a 1. Para o bit 13 igual a 0, ocorre um desvio condicional. O bit de status que é a condição para o desvio, é selecionado pelo bit 9 da instrução. Para o bit 9 igual a 1, N é selecionado, e para o bit 9 igual a 0, Z é selecionado.
Observe que não há lógica seqüencial na parte de controle além do PC. Logo, afora fornecer o endereço para a memória de instruções, a lógica de controle é combinacional em nosso caso. Este fato, combinado com a estrutura do datapath e o uso de memórias de instruções de dados separadas, permitem que o computador de ciclo único obtenha e execute uma instrução da memória de instruções, tudo em um só ciclo de clock.
DECODIFICADOR DE INSTRUÇÕES
O decodificador de instruções é um circuito combinacional que fornece todas as palavras de controle para o datapath, baseado nos conteúdos dos campos da instrução. Vários campos da palavra de controle podem ser obtidos diretamente do conteúdo dos campos da instrução. Observando a Figura 4, vemos que os campos de controle “DA”, “AA” e “BA” são iguais aos campos da instrução “DR”, “AS” e “SB”, respectivamente. Ainda, o campo de controle “BC”, para seleção do bit de estado para desvio condicional é definido diretamente do último bit do Opcode. Os campos restantes da palavra de controle incluem os bits de controle do datapath e da memória de dados “MB”, “MD”, “RW” e “MW”. Há dois bits adicionais para o controle do PC: “PL” e “JB”. Se ocorre um salto ou um desvio, PL = 1, carregando o valor do PC. Para PL = 0, o PC é incrementado. Com PL = 1, JB = 1 informa um salto e JB = 0 informa um desvio condicional. Algumas dos bits isolados da palavra de controle requerem lógica para sua implementação. No intuito de projetar esta lógica, nós dividimos as várias instruções possíveis para este computador simples em diferentes tipos de funções e atribuímos os três primeiros bits do opcode para os vários tipos. Os tipos de instruções mostrados na Tabela 3 são baseados no uso específico do hardware do computador, tal como o MUX B, a Unidade Funcional, o Banco de registradores, a Memória de Dados e o PC. Por exemplo, o primeiro tipo de função utiliza a ULA, ajusta o MUX B para usar registradores como fonte, ajusta o MUX D para usar a saída da Unidade Funcional e escrever no banco de registradores. Outros tipos de funções são definidos pelas diversas combinações usando uma entrada constante em vez de um registrador, leitura e escrita na Memória de Dados e manipulação do PC para saltos e desvios.
Olhando-se a relação entre os tipos de função das instruções e os valores das palavras-código necessários para suas implementações, os bits de 15 a 13 e o bit 9 foram atribuídos
como mostrado na Tabela 3. Esta atribuição objetiva minimizar a lógica necessária para implementar o decodificador. Para realizar o projeto do decodificador, os valores para todos os campos de bits isolados na palavra de controle foram determinados a partir dos tipos de funções e colocados na Tabela 3. Observe que há algumas entradas irrelevantes (don’t care, X). Tratando a Tabela X como uma tabela verdade e otimizando as funções lógicas, resulta na lógica para o decodificador de instruções mostrada na Figura 4. Na otimização foram utilizados códigos don’t care para os bits 15, 14, 13 e 9. Isto implica que se um destes códigos aparecer em um programa, o efeito é desconhecido. Um projeto mais conservador especificaria RW, MW e PL como sendo zero para estes códigos para assegurar que o estado dos recursos de armazenamento seriam preservado. A otimização resulta na lógica da Figura 5 para implementar “MB”, “MD”, “RW”, “MW”, “PL” e “JB”.
O restante da lógica no decodificador lida com o campo “FS”. Para todas as instruções menos o desvio condicional e o salto incondicional, os bits de 9 a 12 são alimentados diretamente para formar o campo “FS”. Durante operações de desvio condicional, como Desviar se Zero, o valor no registrador fonte A deve ser passado por dentro da ULA de forma que os bits de status N e Z possam ser avaliados. Isto requer que FS = 0000. O bit 9, no entanto, às vezes precisa ser 1, no caso de uma instrução Desviar se Negativo. Para resolver este caso foi acrescentada uma lógica de habilitação do bit 9 que força “FS0” para zero sempre que PL = 1,
como mostrado na Figura 5.
Tabela 3. Tabela verdade para a lógica do decodificador de instruções
IMPLEMENTAÇÃO EM VERILOG
A implementação em HDL do circuito da unidade de controle pode ser realizada de diversas formas. O decodificador de instruções, como já teve o seu circuito otimizado pode ser implementado como atribuições contínuas usando operadores lógicos (&& e ||) ou operadores bit-a-bit (& e |). Também podem ser usadas as primitivas (AND, OR, etc) ou mesmo lógica procedural com if-else.
Outras partes combinacionais são extensão com sinal e o preenchimento com zero. Estes podem ser realizados com concatenação de vetores de bits.
A lógica de controle de desvio do registrador complexo PC é um circuito combinacional. Ela pode ser definida na lógica de próximo estado (valor) do PC. O valor do PC precisa ser modificado apenas na borda positiva do clock, usando um always @(posedge clock). Basicamente a lógica do próximo PC verifica o valor do bit PL. Se for zero o valor do PC é incrementado. Se for 1, o valor do PC é carregado de acordo com os bits JB e BC. Se JB for 1, o PC recebe o valor do barramento A. Se for 0, é necessário testar o valor dos bits Z e N. Se BC for zero, testa o valor de Z e se for 1 testa o valor de N. Em ambos os casos, se os bits estiverem setados, indicando que o desvio condicional deve ser tomado, o valor do PC é somado com o valor da extensão com sinal do campo AD.
TESTE MANUAL
O primeiro teste da execução da CPU pode ser feita utilizando as chaves para entrada das instruções. Neste caso, devemos fornecer mecanismos de apresentação dos valores do PC e dos registradores. O mecanismo sugerido utiliza os displays de sete segmentos e pode ser visto na Figura 5.
MEMÓRIA COMBINACIONAL
Como explicado anteriormente, para que este processador opere com um único ciclo de clock, é necessário que a memória de instruções se comporte como um circuito puramente combinacional. Neste experimento, isto é exatamente o que vai ser feito. Uma memória de apenas leitura combinacional é basicamente um decodificador (ou codificador, como queiram) que tem os endereços como entrada e os dados como saída. A sua implementação é feita da mesma forma que o decodificador de sete segmentos implementado nos experimentos anteriores. Deve-se lembrar que, como o número de bits de endereço é muito grande (16) haverão diversos códigos não definidos, que precisam ter valor “default”.
Esta memória deve ser definida como um módulo separado porque nos próximos experimentos ela será definida usando a ferramenta Quartus diretamente. Para isto, é preciso também que o módulo da CPU possua uma saída adicional de endereços (Code Addr) e uma entrada para as instruções (Inst In).
MODULARIDADE E INSTANCIAÇÃO
Como explicado nos experimentos anteriores, o módulo ”Mod_Teste”, que é o módulo TOP, deve ser reservado para os testes na placa. Ele não faz parte da definição da CPU. Ele instancia a CPU e as outras partes necessárias para o teste desta. Por exemplo, devemos implementar a CPU de forma que ela tenha todas as suas partes constituintes instanciadas internamente. Esta CPU terá como interface com o mundo exterior os sinais de CLOCK e RESET e os Sinais de interface com as memórias. Outras portas podem ser acrescentadas a esta CPU apenas para depuração, como por exemplo, portas que permitam a visualização dos registradores.
O módulo TOP (“Mod_Teste”) é o único que deve conhecer detalhes da placa, ou seja, nomes de chaves e de LEDs. Este módulo instancia a CPU, a memória e os circuitos de teste e os conecta nestas interfaces da placa.
TESTE DA CPU
Com o circuito completo, incluindo a memória combinacional, as chaves deixam de ser usadas como entradas para a CPU e podem ser usadas para definir o que vai ser visualizado. Podemos instanciar até 8 decodificadores de hexadecimal (4 bits) para sete segmentos, que são utilizados para visualizar o conteúdo do PC e de algum dos registradores. Um exemplo de circuito para teste pode ser visto na Figura 5.
Figura 5. Circuito para teste da CPU. Observe que o módulo TOP, que está sombreado, apenas instancia a CPU, a memória e os demais circuitos necessários para o teste.
Questões de Preparação
1. Descreva em Verilog usando atribuição contínua os vetores de 16 bits SE e ZF. SE é a extensão com sinal dos seis bits formado pela concatenação dos bits 8 a 6 e 2 a 0 de IR. Ou seja {IR[8:6},IR[2:0]}. ZF é o preenchimento com zeros a esquerda de IR[2:0].
2. Faça um decodificador com 16 bits de entrada e 16 bits de saída. A saída do decodificador deve ser uma letra do seu nome em código ASCII estendido para 16 bits com preenchimento com zero, uma letra para cada código de entrada. Por exemplo, para o nome “ALEXANDRE”, o decodificador retorna 16’h0041 (Código ASCII do A maiúsculo) para a entrada 16’h0000 e 16’h004C (L) para o endereço 16’h0001.
3. Escreva em Verilog o MUX AUX da Figura 5.
4. Escreva um programa de teste para esta CPU e converta cada instrução para o equivalente em binário. Este programa deve testar as diversas classes de instrução da CPU. Por exemplo, uma instrução para teste de operações com registradores e operações de desvio e jump.
5. Escreva a definição de portas de entrada e saída do módulo CPU da Figura 3.
6. Quais as conexões que devem ser feitas entre a unidade de controle e o datapath, de acordo com a Figura 3?
7. Pesquise como se determina o clock máximo de um circuito seqüencial sintetizado no Quartus II. Qual o clock máximo que você espera que esta CPU execute no FPGA? 8. Implemente em Verilog o decodificador de instruções da Figura 4. Este decodificador
transforma os 16 bits de uma instrução nos 20 bits da palavra de controle. Você consegue realizar esta descrição em uma única linha de Verilog?
UNIVERSIDADE FEDERAL DE CAMPINA GRANDE DEPARAMENTO DE ENGENHARIA ELETRICA
LABORATÓRIO DE ARQUITETURA DE SISTEMAS DIGITAIS ALUNO:
Tarefa de laboratório
Faça a descrição de hardware de um módulo, denominado controle, que implemente o hardware indicado na figura 1, usando Verilog.
Figura 1 – Módulo controle. O módulo apresenta as seguintes entradas e saídas
Entradas: V (1 bit) – Bit de Overflow; C (1 bit) – Bit Carry; N (1 bit) – Bit de Sinal; Z (1 bit) – Bit Zero;
Address_in (16 bits) – Dado que será somado, em complemento de 2, ao PC para atualizar seu valor;
Instru_in (16 bits) – Código de uma instrução lido da memória de instruções; Clock (1 bit) – Sinal de clock para controle do PC;
Reset (1 bit) – Sinal para zerar o PC.
Saídas: CONTROL (20 bits) – Palavra de controle, cuja descrição dos campos é apresentada na figura 4 do guia;
data_out1 (16 bits) – Dado de 16 bits, cujos três bits menos significativos BIT[2:0] são definidos a partir de bits da instrução e os 13 bits mais significativos BIT[15:3], são completados com zeros (0) pelo bloco “Zero_fill”. Bloco “Zero_fill” – Realiza a concatenação de 13 bits iguais a zero com os três bits menos
significativos da palavra de instrução (dado da entrada instru_in). Por exemplo; Instru_in[2:0]=101, então valor = 0000 0000 0000 0101
Bloco “Extend” – Esse bloco concatena os três bits menos significativos da palavra de instrução (dado da entrada instru_in) com o os três bits de 8 a 6, da mesma palavra. Na seqüência, o bloco concatena ao dado de 6 bits, até então gerado, mais 12 bits iguais ao valor do bit instru_in[8]. Por exemplo:
instru_in[2:0]=101, instru_in[8:6]=110, então, onde instru_in[8]=1 valor= 111111111111 110 101,
Bloco “Branch Control” – Esse bloco define a forma como o Contador de Programa (PC) é atualizado. Se alguma instrução de salto (JUMP) ou desvio (BRANCH) estiver sendo executada, identificadas pelos bits (Z, N, PL, JB, BC) o valor do PC é ajustado de acordo com a instrução. Caso contrário o PC apenas incrementa seu valor.
OBS: A operação do PC no módulo controle é síncrona(depende do sinal de clock). Os demais blocos que compõem o módulo são assíncronos, ou seja, o comportamento é o de um circuito combinacional.
Ao instanciar os módulos “ULA”, “Register_File”, “controle” e “memoria_instrucao”, as conexões a serem implementadas são mostradas na figura 2.
O módulo “memoria_instrucao”, indicado na figura como “Instruction memory”, será implementado conforme descrição a ser fornecida em sala no dia do laboratório.
Descrição das conexões:
ULA Register File
Bus_D → D_Data
A_Bus ← A_Data
B_Bus ← B_Data
ULA controle
FS ← FS (bits 9-6 da palavra de controle)
C → C
Z → Z
N → N
V → V
MB ← MB (bit 10 da palavra de controle)
MD ← MD (bit 5 da palavra de controle)
Figura 2 – Conexões entre módulos “controle”, “ULA”, “Register_File” e “memoria_instrucao”.
Register File controle
A_Data → address_in
AA ← AA (bits 16-14 da palavra de controle) BA ← BA (bits 13-11 da palavra de controle) DA ← DA (bits 19-17 da palavra de controle)
RW ← RW (bit 4 da palavra de controle)
memoria_instrucao controle
Address_in_mem ← PC_out
Data_out_mem → instru_in
Para visualizar os dados da palavra de controle, utilize 5 instâncias do decodificador HEXA – 7 Segmentos. Realize as conexões indicadas abaixo:
controle BCD – 7 Segmentos Palavra_de_controle[3:0] → IN (conv_0) Palavra_de_controle[7:4] → IN (conv_1) Palavra_de_controle[11:8] → IN (conv_2) Palavra_de_controle[15:12] → IN (conv_3) Palavra_de_controle[19:16] → IN (conv_4)
Ao implementar as conexões indicadas acima, será obtido o módulo apresentado na figura 2. O módulo “memoria_instrucao” deve ser implementado com uma porta de entrada de 16 bits, denominada “Address_in_mem” e uma porta de saída de 16 bits denominada “Data_out_mem”. A lógica funcional do bloco deverá implementar o código a seguir, iniciando pela posição de memória zero (0):
Posição Instrução Opcode
0000 LDI R0,3 0001 LDI R1,6 0002 MOVA R2, R0 0003 MOVB R3, R1 0004 ADD R4,R0,R1 0005 SUB R5,R3,R4 0006 BRZ R5, 3 0007 BRN R5, 3 000A JMP R0 Entradas SW[0] – clock; SW[1] – Reset Saídas
HEX0 – Out (conv_0); HEX1 – Out (conv_1); HEX2 – Out (conv_2); HEX3 – Out (conv_3); HEX4 – Out (conv_4); LEDR[15:0] – PC_out;
Para avaliar a funcionalidade da implementação, realize a execução da rotina. Observe os valores do PC e da palavra de dados para cada instrução executada. Os sinais de entrada que serão utilizados são o Clock e o Reset. Este serve para iniciar o PC com zero.
