Projeto de Processadores Programáveis

Universidade Federal do Rio Grande do Norte Departamento de Engenharia de Computação e Automação Projeto de Processadores Programáveis DCA0119 Sistemas Digitais Heitor Medeiros Florencio

Sumário Processadores de propósitos gerais. Arquitetura básica do datapath: ULA e registradores. Operações básicas do datapath. Arquitetura básica do controlador: contador de programa (), registrador de instrução () e bloco de controle. Operações básicas do controlador. Exemplos de projetos de processadores de propósitos gerais. Processador AMR7. Projeto de um processador programável de três instruções. Projeto do processador programável BIP I.

Introdução Processadores de propósitos gerais: Circuito digital cuja tarefa de processamento em particular, ao invés de ser construída no próprio circuito, fica armazenada em uma memória. Processador de propósito único para luz de alerta de cinto de segurança e 3 2 1 0 2x4 x(t) x(t-1) x(t-2) c0 c1 c2 xt0 xt1 + xt2 + reg Processador de propósito único para filtro F de 3 taps Programa para luz de alerta de cinto de segurança Instruction memory I 0 Programa para filtro F Data memory D n-bit 2x1 Register file RF ALU Datapath Processador de propósitos gerais Outros a programas

Arquitetura Básica do Datapath Processamento consiste de: Carregar os dados. Transformar (processar) os dados. Armazenar os dados. Datapath: Uma memória de dados guarda todos os dados que um processador programável poderá acessar. Um processador programável precisa: carregar os dados da memória em um banco de registradores. alimentar unidade funcionais para executar as operações necessários. carregar os dados resultantes de volta nos registradores e na memória. Data memory D n-bit 2x1 Register file RF ALU Datapath Conectado de alguma forma ao mundo exterior

Operações básicas do Datapath Operação de carga: essa operação carrega (lê) dados da memória para colocar no banco de registradores. Operação da ULA: essa operação transforma dados de dois registradores Operação de armazenamento: essa operação armazena dados na memória. Data memory D Data memory D Data memory D n-bit 2x1 n-bit 2x1 n-bit 2x1 Register file RF Register file RF Register file RF ALU ALU ALU Operação de carga Op. de ULA Op. de armazenamento

Operações básicas do Datapath Exemplo: D[9] = D[0] + D[1]: é necessário descrever a sequencia de operações: 0: RF[0] = D[0] 1: RF[1] = D[1] 2: RF[2] = RF[0] + RF[1] 3: D[9] = RF[2] Essas instruções formam o programa. As instruções foram armazenadas na memória de instruções. O controlador lê cada instrução e então executa no datapath utilizando os registradores: : controlador de programa. : registrador de instrução. Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] Data memory D n-bit 2x1 Register file RF ALU Datapath

Controlador O controlador é responsável por: saber a posição da próxima instrução na memória. Através do registrador: contador de programa (). armazenar a atual instrução no registrador de instrução (). decodificar a instrução. requisitar a execução da instrução pelo datapath. Partes básicas de um controlador: Contador de programa () Registrador de instrução () Bloco de controle Instruction memory I

Exemplo: operações do controlador Exemplo: Ações do controlador: Buscar a instrução. Decodificar a instrução. Ativar a execução da instrução. Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 0 1 RF[0]=D[0] Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 1 RF[0]=D[0] Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 1 RF[0]=D[0] Data memory D D[0]: 99 n-bit 2x1 Register file RF R[0]:?? 99 (a) Fetch (b) Decode "load" Execute (c) Datapath ALU

Exemplo: operações do controlador Exemplo: Ações do controlador: Buscar a instrução. Decodificar a instrução. Ativar a execução da instrução. Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 1 2 RF[1]=D[1} Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 2 RF[1]=D[1] Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 2 RF[1]=D[1] Data memory D D[1]: 102 n-bit 2x1 Register file RF R[1]:?? 102 (a) Fetch (b) Decode "load" Execute (c) Datapath ALU

Exemplo: operações do controlador Exemplo: Ações do controlador: Buscar a instrução. Decodificar a instrução. Ativar a execução da instrução. Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 2 3 (a) Fetch RF[2]=RF[0]+RF[1] Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 3 (b) Decode RF[2]=RF[0]+RF[1] "ALU (add)" Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 3 RF[2]=RF[0]+RF[1] Execute (c) Data memory D n-bit 2x1 Register file RF R[2]:?? 201 Datapath 99 102 ALU 201

Exemplo: operações do controlador Exemplo: Ações do controlador: Buscar a instrução. Decodificar a instrução. Ativar a execução da instrução. Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 3 4 D[9]=RF[2] Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 4 D[9]=RF[2] Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 4 D[9]=RF[2] Data memory D D[9]=?? 201 n-bit 2x1 Register file RF R[2]: 201 (a) Fetch (b) Decode "store" Execute (c) Datapath ALU

Arquitetura Básica do Controlador De acordo com o exemplo anterior, observa-se que o controlador executa uma máquina de estados de três estágios básicos: Init =0 Fetch Decode =I[] =+1 busca, decodificação e execução. Execute Processadores de múltiplos ciclos.

Controlador - Operações Estágios de processamento: 1. Primeiro busca-se a instrução. Para isso, carrega-se a instruções corrente em e incrementa-se o para a próxima busca. = Memória () = + 1 Somador Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] Datapath Data memory D n-bit 2x1 Register file RF ALU

Controlador - Operações Estágios de processamento: 2. Segundo, decodifica-se a instrução para determinar qual é a operação. 3. Finalmente, executa-se a operação. Para isso, se for o caso, são ativadas as linhas de controle apropriadas para o datapath. Se a operação for do datapath, a operação poderá ser um dos três tipos: Carregar dado. Transformar dados. Armazenar dado. Instruction memory I 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] Data memory D n-bit 2x1 Register file RF ALU Datapath

Tópicos relevantes sobre o projeto A análise do projeto de um processador é dividido em duas partes: organização e arquitetura do processador. Arquitetura Organização Nível de abstração

Tópicos relevantes sobre o projeto A análise do projeto de um processador é dividido em duas partes: organização e arquitetura do processador. Modelo de arquitetura: Von Neumann e Harvard. Tamanho da palavra de dados: Número de bits do dado processado. Tamanho da palavra de instrução: Número de bits da instrução. Formato da instrução. Modos de endereçamento: Modos de acesso aos dados na(s) memória(s). Registradores. Conjunto de instruções. Arquitetura Organização Implementação da arquitetura.

Organização de Computadores Arquitetura Organização Implementação da arquitetura. Instruction memory Data memory D n-bit 2x1 Register file RF ALU Datapath

Tópicos relevantes sobre o projeto Modelo de arquitetura: Harvard. Bus de Endereços da MP Bus de Endereços da MD Bus de Dados da MP C P U Bus de Dados da MD Bus de Controle MEMÓRIA DE DADOS MEMÓRIA DE PROGRAMA UNIDADES DE E/S

Tópicos relevantes sobre o projeto Modelo de arquitetura: Von Neumann. CPU ALU Unidade de controle Bus de Endereços Bus de Dados Bus de Controle MEMÓRIA DE DADOS E DE PROGRAMA UNIDADES DE E/S

Tópicos relevantes sobre o projeto Modelo de arquitetura: Von Neumann. Memória de dados Memória de programa Data memory D Instruction memory n-bit 2x1 Register file RF ALU Datapath

Exemplos de projetos de processadores de propósitos gerais

Exemplo 1: Processador AMR7 Processador AMR7: arquitetura RISC; tamanho da palavra de dados de 32 bits; tamanho da palavra de instrução de 16 bits ou 32 bits;

Exemplo 2: Processador de três instruções Exemplo 2: Projeto de um processador programável de três instruções. Modelo de arquitetura: Von Neumann. Tamanho da palavra de dados: 16 bits. Tamanho da palavra de instrução: 16 bits. Formato da instrução (16 bits): operação operandos 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Modos de endereçamento: direto. Acesso direto à memória através do endereço de memória.

Exemplo 2: Processador de três instruções Conjunto de instruções: lista de instruções disponíveis. Instrução carregar: 0000 r 3 r 2 r 1 r 0 d 7 d 6 d 5 d 4 d 3 d 2 d 1 d 0 Instrução armazenar: 0001 r 3 r 2 r 1 r 0 d 7 d 6 d 5 d 4 d 3 d 2 d 1 d 0 Instrução somar: 0010 ra 3 ra 2 ra 1 ra 0 rb 3 rb 2 rb 1 rb 0 rc 3 rc 2 rc 1 rc 0 Desired program 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2} a Instruction memory 0: 0000 0000 00000000 1: 0000 0001 00000001 2: 0010 0010 0000 0001 3: 0001 0010 00001001 I opcode operands

Exemplo 2: Processador de três instruções Desired program 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2} Instruction memoryi 0: 0000 0000 00000000 1: 0000 0001 00000001 2: 0010 0010 0000 0001 3: 0001 0010 00001001 Computes D[9]=D[0]+D[1] Data memory D n-bit 2 1 Register file RF ALU Datapath

Exemplo 2: Processador de três instruções Outro programa exemplo na memória de instruções: Calcular: D[5] = D[5] + D[6] + D[7] 0: 0000 0000 00000101 // RF[0] = D[5] 1: 0000 0001 00000110 // RF[1] = D[6] 2: 0000 0010 00000111 // RF[2] = D[7] 3: 0010 0000 0000 0001 // RF[0] = RF[0] + RF[1] // which is D[5]+D[6] 4: 0010 0000 0000 0010 // RF[0] = RF[0] + RF[2] // now D[5]+D[6]+D[7] 5: 0001 0000 00000101 // D[5] = RF[0]

Exemplo 2: Código de máquina x código assembly Código de máquina é um programa representado apenas por 0s e 1s. Facilidade para o programador: código em assembly. Instrução carregar: MOV Ra, d RF[a] = D[d]; Instrução armazenar: MOV d, Ra D[d] = RF[a]; Instrução somar: ADD Ra, Rb, Rc RF[a] = RF[b] + RF[c]; Programa: 0: RF[0]=D[0] 1: RF[1]=D[1] 2: RF[2]=RF[0]+RF[1] 3: D[9]=RF[2] 0: 0000 0000 00000000 1: 0000 0001 00000001 2: 0010 0010 0000 0001 3: 0001 0010 00001001 Código de máquina 0: MOV R0, 0 1: MOV R1, 1 2: ADD R2, R0, R1 3: MOV 9, R2 Código em assembly

Exemplo 2: Descrição do processador de três instruções Máquina de estado de alto nível do processador [1º passo do projeto RTL]. Init :=0 Busca :=I[] :=+1 Decodificador op=="0000" op=="0001" op=="0010" Carregar RF[ra]:=D[d] Armazenar D[d]:=RF[ra] Somar RF[ra] := RF[rb]+ RF[rc]

Exemplo 2: Projeto do processador de três instruções addr 16 clr up _clr rd I_rd _inc data 16 Id 16 I _ld D_addr 8 D_rd D_wr RF_s addr rd 256x16 wr W_data R_data s 16 1 16-bit 2x1 16 0 D Controlador RF_W_addr RF_W_wr RF_Rp_addr RF_Rp_rd RF_Rq_addr RF_Rq_rd 4 4 4 W_data W_addr W_wr Rp_addr Rp_rd Rq_addr Rq_rd 16x16 RF 16 Rp_data Rq_data alu_s0 16 16 s0 A B ALU Datapath 16

Exemplo 2: Controlador Máquina de estado finito do bloco controlador [3º passo do projeto RTL].

Exemplo 3: Processador BIP A família de processadores BIP (Basic Instruction-set Processor) foi desenvolvida por pesquisadores do Laboratório de Sistemas Embarcados e Distribuídos da Universidade do Vale do Itajaí UNIVALI. Projeto do processador BIP I: Arquitetura RISC do microcontrolador PIC (Programmable Intelligent Computer). Tamanho da palavra de dados e de instrução: 16 bits. Máquina orientada a acumulador e não possui banco de registradores. Todas as operações envolvem o acumulador (registrador especifico).

Exemplo 3: Atributos de arquitetura do Processador BIP Atributos de arquitetura do projeto do processador BIP I:

Exemplo 3: Atributos de arquitetura do Processador BIP Processador BIP I: formato da instrução. Processador BIP I: conjunto de instruções.

Exemplo 3: Processador BIP Modelo simplificado do processador BIP I: O processador BIP I foi projetado para executar instruções básicas para a implementação de equações baseadas em operações aritméticas de soma e subtração com número inteiros.

Ex. 3: Processador BIP I Organização detalhada

Ex. 3: BIP I - Datapath

Ex. 3: Executando instruções no BIP I

Exemplo 3: Processador BIP I O Bipide é uma Ambiente de Desenvolvimento Integrado educacional que permite relacionar os conceitos de lógica de programação com o hardware dos processadores BIP. Esse ambiente possibilita a criação de algoritmos e sua simulação na organização dos processadores BIP. http://bipide.com.br/ Utilize o Bipide para analisar as instruções.

Referências VAHID, Frank. Sistemas Digitais: projeto, otimização e HDLs. Bookman, 2008. Zeferino, Cesar Albenes. Projetando um Computador: Parte II Arquitetura do Processador BIP. Notas de aula. Disponível em: http://bipide.com.br/. Acesso em: 15/02/2016. Pereira, Rodrigo. PROCESSADORES PROGRAMÁVEIS - como projetar um processador em VERILOG - Organização - parte 2. Disponível em: http://www.embarcados.com.br/. Acesso em: 16/02/2016.

Dúvidas? Dúvidas por email: heitorm@dca.ufrn.br 40