Embedded Systems Design: A Unified Hardware/Software...

1

Embedded Systems Design: A Unified Hardware/Software Introduction

Capítulo 3 Processadores de Propósito Geral: Software

2Embedded Systems Design: A Unified

Hardware/Software Introduction, (c) 2000 Vahid/Givargis

Tradução: Alice M. TokarniaEdição: Filipe I. Fazanaro Marco A. A. Henriques

Introdução

• Processador de Propósito Geral– Processador projetado para uma grande variedade de tarefas

computacionais– Baixo custo unitário, em parte devido à diluição do custo NRE sobre

grande quantidade de unidades produzidas• A Motorola vendeu, somente em 1996, meio bilhão de unidades do

microcontrolador 68HC05– Cuidadosamente desenvolvido em virtude de um alto custo NRE ser

aceitável• Pode oferecer bom desempenho, tamanho e consumo de energia

– Baixo custo NRE (diluído na grande quantidade de unidades vendidas), curto time-to-market/prototipagem, alta flexibilidade

• O usuário (final) simplesmente escreve softwares; não há necessidade de desenvolvimento do processador (parte física).

– a.k.a. “microprocessor” – o termo “micro” começou a ser utilizado quando os processadores passaram a ser implementados em um ou mais chips e não mais em salas inteiras




Arquitetura Básica

• Unidade de controle e datapath– Note a semelhança com

o processador dedicado

• Diferenças chaves– Datapath é genérico

– A unidade de controle não armazena o algoritmo – o algoritmo é programado na memória (compartilhada)

Processor

Control unit Datapath

ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status




Operações no Datapath

• Load– Transfere o conteúdo de

uma posição de memória para um registrador

• ALU operation– Operando e o resultado

de uma operação lógico-aritmética estão armazenados em registradores

• Armazenamento– Transfere o conteúdo

de um registrador para uma posição de memória

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

10

+1

11

11




Unidade de Controle

• Unidade de controle: determina as operações realizadas no datapath

– A seqüência das operações desejadas (“instruções”) são armazenadas na memória – “programa”

• Ciclo de instrução – quebra das operações em diversas sub-operações, uma para cada ciclo de relógio, e.g.:

– Aquisição de Instrução (Fetch): lê instrução da memória e armazena no registrador de instruções

– Decodificação: determina o significado da instrução

– Aquisição dos operandos (Fetch operands): move dados da memória para o registrador do datapath

– Execução: move dados através da ULA

– Armazena os resultados: escreve dados do registrador na memória

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

load R0, M[500] 500

501

100

inc R1, R0101

store M[501], R1102

R0 R1




Sub-Operações da Unidade de Controle

• Aquisição de Instrução (Fetch)– Lê próxima

instrução dentro do IR

– PC (program counter): sempre aponta para a próxima instrução

– IR: armazena a instrução a ser executada

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

load R0, M[500] 500

501

100

inc R1, R0101

store M[501], R1102

R0 R1100 load R0, M[500]





• Decodificação– Determina o

significado de cada instrução

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

load R0, M[500] 500

501

100

inc R1, R0101

store M[501], R1102

R0 R1100 load R0, M[500]





• Aquisição de operandos (Fetch operands)– Transfere dados da

memória para o registrador do datapath

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

load R0, M[500] 500

501

100

inc R1, R0101

store M[501], R1102

R0 R1100 load R0, M[500]

10





• Execução– ULA executa a

operação requerida– A instrução load

mostrada neste exemplo não requer uma operação lógica aritmética

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

load R0, M[500] 500

501

100

inc R1, R0101

store M[501], R1102

R0 R1100 load R0, M[500]

10





• Armazenamento dos resultados– Escrita de resultados

armazenados em registradores

– A instrução load mostrada neste exemplo não requer uma operação lógica aritmética

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

load R0, M[500] 500

501

100

inc R1, R0101

store M[501], R1102

R0 R1100 load R0, M[500]

10




Ciclos de Instrução

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

load R0, M[500] 500

501

100

inc R1, R0101

store M[501], R1102

R0 R1

PC=100

10

Fetch ops

Exec. Store results

clk

Fetch

load R0, M[500]

Decode

100





Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

load R0, M[500] 500

501

100

inc R1, R0101

store M[501], R1102

R0 R1

10

PC=100Fetch Decode Fetch

opsExec. Store

resultsclk

PC=101

inc R1, R0

Fetch Fetch ops

+1

11

Exec. Store results

clk

101

Decode





Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status

10...

...

load R0, M[500] 500

501

100

inc R1, R0101

store M[501], R1102

R0 R1

1110


opsExec. Store

resultsclk


opsExec. Store

resultsclk

PC=102

store M[501], R1

Fetch Fetch ops

Exec.

11

Store results

clk

Decode

102




Considerações sobre a Arquitetura

• Processador de N-bit – ULA de N-bit,

registradores, barramentos, memória, interface de dados

– Processador Embarcado: comumente 8-bit, 16-bit, 32-bit

– Desktop/servidores: 32-bit, 64-bits

• O tamanho do contador de programa (PC) determina o espaço de endereçamento

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status




Considerações sobre a Arquitetura

• Período do sinal de relógio– Inverso da freqüência

do sinal de relógio– Deve ser maior que o

maior atraso entre registradores no processador.

– Acesso à memória é sempre mais lento.

Processor


ALU

Registers

IRPC

Controller

Memory

I/O

Control/Status




Pipelining: Aumentando a produtividade – Throughput (instrução/tempo)

1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8

Fetch-instr.

Decode

Fetch ops.

Execute

Store res.

1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8

1 2 3 4 5 6 7 8

Wash

Dry

Time

Non-pipelined Pipelined

Time

Time

Pipelined

pipelined instruction execution

non-pipelined dish cleaning pipelined dish cleaning

Instruction 1




Arquiteturas Superescalar e VLIW

• Desempenho pode ser melhorado por meio de:– Relógios mais rápidos (contudo existe um limite)

– Pipelining: divisão da execução das instruções em estágios e sobreposição de estágios

– Múltiplas ULAs para suportar mais de uma seqüência de instruções• Superescalar

– Escalar: operações não-vetorizadas– Aquisição de instruções (fetches) em lotes; execução de quantas forem possíveis

• Pode necessitar de hardware para detectar instruções independentes– VLIW: cada palavra na memória possui múltiplas instruções independentes

• Conta com o compilador para detectar e escalonar as instruções




Duas arquiteturas de memória

Processor

Program memory

Data memory

Processor

Memory(program and data)

Harvard Princeton

• Princeton– Menor quantidade

de conexões à memória

• Harvard– Acesso simultâneo

a dados e programa nas memórias




Memória Cache

• Acesso à memória pode ser lento

• A memória Cache é pequena porém rápida e localizada perto do processador– Armazena cópias de partes da

memória– Pode conter (hit) ou não (miss)

os dados necessários ao processamento corrente.

Processor

Memory

Cache

Fast/expensive technology, usually on the same chip

Slower/cheaper technology, usually on a different chip




Visão do Programador

• O programador não necessita entender detalhes da arquitetura– Em vez disso, necessita saber quais instruções podem ser executadas

• Dois níveis de instruções:– Nível Assembly – Linguagens estruturadas (C, C++, Java, etc.)

• A maior parte do desenvolvimento hoje é realizado utilizando linguagens estruturadas– Porém, programação em linguagem assembly pode ser necessária– Drivers: partes do programa que comunicam com e/ou controlam

(acionam) outros dispositivos• Frequentemente têm considerações temporais detalhadas e grande

manipulação de bits• Assembly pode ser melhor opção nestes casos




Instruções em Assembly

opcode operand1 operand2




...

Instruction 1

Instruction 2

Instruction 3

Instruction 4

• Conjunto de Instruções– Define as instruções legais (válidas) para o processador

• Transferência de dados: memória/registrador, registrador/registrador, I/O, etc.• Aritimética/lógica: usa registradores como entradas para ULA e armazena resultados

em registradores• Branches: determina o valor do Program Counter (PC) quando deseja-se realizar um

desvio para outro ponto do código ao invés de seguir para a instrução subseqüente (PC+1)




Exemplo de conjunto simples de instruções

opcode operands

MOV Rn, direct

MOV @Rn, Rm

ADD Rn, Rm

0000 Rn direct

0010 Rn

0100 RmRn

Rn = M(direct)

Rn = Rn + Rm

SUB Rn, Rm 0101 Rm Rn = Rn - Rm

MOV Rn, #immed. 0011 Rn immediate Rn = immediate

Assembly instruct. First byte Second byte Operation

JZ Rn, relative 0110 Rn relative PC = PC+ relative (only if Rn is 0)

Rn

MOV direct, Rn 0001 Rn direct M(direct) = Rn

Rm M(Rn) = Rm




Modos de Endereçamento

Dados

Imediato

Registrador Direto

Registrador Indireto

Direto

Indireto

Dados

Campo do operando

Registrador de endereços

Registrador de endereços

Endereço de memória


Endereço de Memória Dados

Dados


Dados

Modo de Endereçamento

Conteúdo dos registradores Conteúdo de Memória




Exemplos de Programas

int total = 0;for (int i=10; i!=0; i--) total += i;// next instructions...

Programa em C

MOV R0, #0; // total = 0

MOV R1, #10; // i = 10

JZ R1, Next; // Done if i=0

ADD R0, R1; // total += i

MOV R2, #1; // constant 1

JZ R3, Loop; // Jump always

Loop:

Next: // next instructions...

SUB R1, R2; // i--

Programa em Assembly Equivalente

MOV R3, #0; // constant 0

0

1

2

3

5

6

7

• Exercícios– Handshake: espere até que o valor de M[254] seja diferente de 0, coloque

M[255] em 1, espere novamente até que M[254] retorne a 0, então coloque M[255] em 0 (assuma que essas localizações sejam portas).

– Conte as ocorrências de zero em um vetor armazenado em posições de memória entre 100 e 199.




Considerações do Programador

• Espaços para programas e dados na memória– Processadores embarcados frequentemente são muito

limitados• e.g., 64 K bytes de programa, 256 bytes de RAM (expansível)

• Registradores: Quantos existem?– Somente é preocupação para programadores em assembly

• I/O– Como é realizada a comunicação com os sinais externos?

• Interrupções




Visão Geral da Arquitetura do Microprocessador

• Se você está utilizando um microprocessador em particular, agora é um bom momento para revisar a sua arquitetura




Exemplo: driver de porta paralela

• Utilizando programação em linguagem assembly, é possível configurar a porta paralela do PC para realizar comunicação digital com dispositivos de E/S.– No próximo exemplo, a leitura e escrita em três registradores especiais.

Conferir a tabela acima.

– Exemplo: porta paralela monitora a chave de entrada e acende ou apaga o LED de acordo com a posição da chave.

PC Parallel port

Pin 13

Pin 2

Switch

LED

LPT Connection Pin I/O Direction Register Address

1 Output 0th bit of register #2

2-9 Output 0th bit of register #2

14,16,17 Output 1,2,3th bit of register #2

10,11,12,13,15 Input 6,7,5,4,3th bit of register #1




Exemplo de porta paralela

; This program consists of a sub-routine that reads; the state of the input pin, determining the on/off state; of our switch and asserts the output pin, turning the LED; on/off accordingly

.386

CheckPort procpush ax ; save the content

push dx ; save the contentmov dx, 3BCh + 1 ; base + 1 for register #1in al, dx ; read register #1and al, 10h ; mask out all but bit # 4cmp al, 0 ; is it 0?jne SwitchOn ; if not, we need to turn the LED on

SwitchOff:mov dx, 3BCh + 0 ; base + 0 for register #0in al, dx ; read the current state of the portand al, f7h ; clear first bit (masking)out dx, al ; write it out to the portjmp Done ; we are done

SwitchOn:mov dx, 3BCh + 0 ; base + 0 for register #0in al, dx ; read the current state of the portor al, 01h ; set first bit (masking)out dx, al ; write it out to the port

Done: pop dx ; restore the contentpop ax ; restore the content

CheckPort endp

extern “C” CheckPort(void); // defined in // assembly

void main(void) {while( 1 ) {

CheckPort();}

}

LPT Connection Pin I/O Direction Register Address

1 Output 0th bit of register #2

2-9 Output 0th bit of register #2

14,16,17 Output 1,2,3th bit of register #2

10,11,12,13,15 Input 6,7,5,4,3th bit of register #1

PC Parallel port

Pin 13

Pin 2

Switch

LED




Sistema Operacional

• Camadas opcionais do software fornecem serviços de baixo-nível para o programa (aplicação).– Administração de arquivos, acesso aos

discos

– Interface com teclado/display

– Escalonamento de múltiplos programas para execução

• Ou mesmo somente para a execução de múltiplas threads de um programa

– Programa faz “chamadas de sistema” ao Sistema Operacional (OS) para ter acesso aos serviços disponíveis.

DB file_name “out.txt” -- store file name

MOV R0, 1324 -- system call “open” id

MOV R1, file_name -- address of file-name

INT 34 -- cause a system call

JZ R0, L1 -- if zero-> error

. . . read the fileJMP L2 -- bypass

error cond.L1: . . . handle the errorL2:




Ambiente de Desenvolvimento

• Processador de Desenvolvimento– Processador no qual escrevemos e depuramos os programas

• Usualmente um PC

• Processador Alvo– Processador no qual o programa irá funcionar (no sistema

embarcado)• Frequentemente é diferente do processador de desenvolvimento

Processador de Desenvolvimento Processador Alvo




Processo de Desenvolvimento do Software

Compiler

Linker

C File C File Asm. File

Binary File

Binary File

Binary File

Exec. File

Assembler

Library

Implementation Phase

Debugger

Profiler

Verification Phase

• Compiladores– Crosscompilers

• Funciona em um processador mas gera o código para a execução em outro

• Montadores (assemblers)

• Ligadores (linkers)• Depuradores• Profilers




Executando um Programa

• Se o processador de desenvolvimento é diferente do processador alvo, como é possível executar o código compilado? Existem duas opções:– executar em um sistema com o processador alvo

– simular o processador alvo no sistema de desenvolvimento

• Simulação– Primeiro método: Linguagem de Descrição de Hardware (HDL)

• lenta e nem sempre disponível

– Segundo método: Instruction set simulator (ISS)• executa no processador de desenvolvimento as instruções do processador

alvo por meio de uma tradução de um conjunto de instruções para outro




Simulador de um conjunto de instruções para um processador simples

#include <stdio.h>typedef struct { unsigned char first_byte, second_byte;} instruction;

instruction program[1024]; //instruction memoryunsigned char memory[256]; //data memory

void run_program(int num_bytes) {

int pc = -1; unsigned char reg[16], fb, sb; while( ++pc < (num_bytes / 2) ) { fb = program[pc].first_byte; sb = program[pc].second_byte; switch( fb >> 4 ) { case 0: reg[fb & 0x0f] = memory[sb]; break; case 1: memory[sb] = reg[fb & 0x0f]; break; case 2: memory[reg[fb & 0x0f]] = reg[sb >> 4]; break; case 3: reg[fb & 0x0f] = sb; break; case 4: reg[fb & 0x0f] += reg[sb >> 4]; break; case 5: reg[fb & 0x0f] -= reg[sb >> 4]; break; case 6: pc += sb; break; default: return –1;

} } return 0;}

int main(int argc, char *argv[]) {

FILE* ifs;

If( argc != 2 || (ifs = fopen(argv[1], “rb”) == NULL ) { return –1; } if (run_program(fread(program, sizeof(program) == 0) {

print_memory_contents();return(0);

} else return(-1);}




Testando e Depurando

Fase de Implementação

Fase de Implementação

Fase de Verificação

Fase de Verificação

Emulator

Debugger/ ISS

Programador

Processador de Desenvolvimento

(a) (b)

Ferramentas Externas

• ISS – Controle da execução no tempo –

define breakpoints, examina valores de registradores, define valores, executa código passo-a-passo, ...

– Mas não interage com o ambiente real

• Download para a placa teste– Usa dispositivo programador– Executado em ambiente real

porém sem controle

• Emulador: solução de compromisso

– Execução em ambiente real, em velocidade real ou próximo dela.

– Permite algum controle a partir do PC




Processadores para Área de Aplicação Específicas (ASIPs)

• Processadores de Propósito Geral (GPP)– Em alguma ocasiões é muito genérico para ser efetivo em aplicações

exigentes• e.g., processamento de vídeo – exige buffers gigantescos e opera com

arranjos de dados extremamente longos; ineficiente em um GPP

– Mas, processadores dedicados possuem alto custo NRE e não são programáveis

• ASIPs – voltado para um campo particular de aplicação– Contém características de arquitetura específicas para aquele campo

• e.g., controle embarcado, processamento digital de sinais, processamento de vídeos, processamento de redes, telecomunicações etc

– Mais específico, porém ainda programável




Exemplo comum de ASIP: Microcontrolador

Para aplicações de controle embarcadas– Leitura de sensores, ajustando atuadores– Na maioria das vezes lida com eventos (bits): o dado está presente, mas não em

grandes quantidades– e.g., VCR, acionador de discos, câmera digital (assumindo SPP para compressão

de imagem), máquina de lavar, forno de microondas• Características do microcontrolador

– Periféricos no chip• Temporizadores, conversores analógico-digital, comunicação serial, etc.• Fortemente integrados para o programador• São tipicamente uma parte do espaço de registradores

– Memória de programa e de dados no chip– Programas tem acesso direto aos pinos do chip– Instruções especializadas para a manipulação de bits e outras operações em

baixo nível




Outro Exemplo de ASIP: Processador Digital de Sinais (DSP)

• Para aplicações de processamento de sinais– Grande quantidade de dados digitalizados, normalmente em

fluxos

– Transformação de dados deve ser realizada rapidamente

– e.g., filtro de voz para telefone celulares, TV digital, sintetizador de música

• Características do DSP– Várias unidades de execução de instruções

– Operações “multiplica-e-acumula” em uma única instrução

– Operações vetoriais eficientes – e.g., soma de dois arranjos• ULAs vetoriais, buffer para loops, etc.




Tendência: ASIPs ainda mais customizados

• No passado, microprocessadores eram adquiridos como chips• Hoje, processadores estão sendo adquiridos como Propriedade

Intelectual (IP)– e.g., modelo VHDL

• Oportunidade de adicionar hardware de datapath customizado e umas poucas instruções, ou apagar algumas instruções– Pode ter impactos significativos no desempenho, tamanho e potência

consumida– Problema: necessidade de compilador/depurador para o ASIP

customizado• Lembre-se: a maioria dos desenvolvedores utiliza linguagem estrutural• Uma solução: geração automática de compiladores/depuradores

– e.g., www.tensillica.com• Outra solução: retargettable compilers

– e.g., www.improvsys.com (arquiteturas VLIW customizadas)

http://www.tensillica.com/



http://www.improvsys.com/






Selecionando um Microprocessador

• Critérios– Técnicos: velocidade, potência consumida, tamanho, custo– Outros: ambiente de desenvolvimento, familiaridade, licenciamento etc

• Velocidade: como avaliar a velocidade do processador?– Velocidade do sinal de relógio – mas o número de instruções por ciclo

pode variar– Instruções por segundo – mas o trabalho realizado por instrução pode

variar– Continua ...




Selecionando um Microprocessador (cont.)

• Velocidade: como avaliar a velocidade do processador? (continuação...)– Dhrystone: Synthetic Benchmark – Programas Sintéticos de Avaliação,

desenvolvido em 1984.

• Unidade de medida: Dhrystones/segundo.• MIPS: 1 MIPS = 1757 Dhrystones/segundo (baseado no VAX 11/780

de Digital). A.k.a. Dhrystone MIPS. Usado comumente hoje em dia.– Ex: 750 MIPS = 750*1757 = 1,317,750 Dhrystones/segundo

– SPEC: conjunto de programas mais realistas para a avaliação de processadores para desktops

– EEMBC – EDN Embedded Benchmark Consortium, www.eembc.org• Pacotes de benchmarks: setor automotivo, eletrônica de consumo,

áreas de redes, automação de escritórios e telecomunicações

http://www.eembc.org/







Processadores de Propósito Geral

Processor Clock speed Periph. Bus Width MIPS Power Trans. PriceGeneral Purpose Processors

Intel PIII 1GHz 2x16 KL1, 256KL2, MMX

32 ~900 97W ~7M $900

IBMPowerPC750X

550 MHz 2x32 KL1, 256KL2

32/64 ~1300 5W ~7M $900

MIPSR5000

250 MHz 2x32 K2 way set assoc.

32/64 NA NA 3.6M NA

StrongARMSA-110

233 MHz None 32 268 1W 2.1M NA

MicrocontrollerIntel8051

12 MHz 4K ROM, 128 RAM,32 I/O, Timer, UART

8 ~1 ~0.2W ~10K $7

Motorola68HC811

3 MHz 4K ROM, 192 RAM,32 I/O, Timer, WDT,SPI

8 ~.5 ~0.1W ~10K $5

Digital Signal ProcessorsTI C5416 160 MHz 128K, SRAM, 3 T1

Ports, DMA, 13ADC, 9 DAC

16/32 ~600 NA NA $34

LucentDSP32C

80 MHz 16K Inst., 2K Data,Serial Ports, DMA

32 40 NA NA $75

Sources: Intel, Motorola, MIPS, ARM, TI, and IBM Website/Datasheet; Embedded Systems Programming, Nov. 1998




Projetando um Processador de Propósito Geral

• Não é um projeto que um projetista de sistemas embarcados faria– Entretanto, é interessante

observar como um processador genérico pode ser projetado de forma top-down

– Na prática, os processadores não são construídos desta maneira

• projetos muito mais otimizados

• desenvolvimento muito mais bottom-up

Declarations: bit PC[16], IR[16]; bit M[64k][16], RF[16][16];

Aliases: op IR[15..12] rn IR[11..8] rm IR[7..4]

dir IR[7..0] imm IR[7..0] rel IR[7..0]

Reset

Fetch

Decode

IR=M[PC];PC=PC+1

Mov1 RF[rn] = M[dir]

Mov2

Mov3

Mov4

Add

Sub

Jz01100101

01000011

00100001

op =

0000

M[dir] = RF[rn]

M[rn] = RF[rm]

RF[rn]= imm

RF[rn] =RF[rn]+RF[rm]

RF[rn] = RF[rn]-RF[rm]

PC=(RF[rn]=0) ?rel :PC

to Fetch

to Fetch

to Fetch

to Fetch

to Fetch

to Fetch

to Fetch

PC=0;

from states below

FSMD




Arquitetura de um Microprocessador Simples

Dispositivos de armazenamento para cada variável declarada

– Conjunto de registradores armazena cada uma das variáveis

• Unidades funcionais para executar as operações FSMD

– Uma só ULA para todas as operações

• Conexões são adicionadas entre as portas dos componentes de acordo com as operações da FSM

• Criação de identificadores únicos para cada sinal de controle

Datapath

IRPC

Controller(Next-state and

controllogic; state register)

Memory

RF (16)

RFwa

RFwe

RFr1a

RFr1e

RFr2a

RFr2eRFr1 RFr2

RFw

ALUALUs

2x1 mux

ALUz

RFs

PCld

PCinc

PCclr

3x1 muxMsMweMre

To all input control signals

From all output control signals

Control unit

16Irld

2

1

0

A D

1

0




Um Microprocessador Simples

FSM operations that replace the FSMD operations after a datapath is created

RFwa=rn; RFwe=1; RFs=01;Ms=01; Mre=1;

RFr1a=rn; RFr1e=1; Ms=01; Mwe=1;

RFr1a=rn; RFr1e=1; Ms=10; Mwe=1;

RFwa=rn; RFwe=1; RFs=10;

RFwa=rn; RFwe=1; RFs=00;RFr1a=rn; RFr1e=1;RFr2a=rm; RFr2e=1; ALUs=00RFwa=rn; RFwe=1; RFs=00;RFr1a=rn; RFr1e=1;RFr2a=rm; RFr2e=1; ALUs=01PCld= ALUz;RFrla=rn;RFrle=1;

MS=10;Irld=1;Mre=1;PCinc=1;

PCclr=1;Reset

Fetch

Decode

IR=M[PC];PC=PC+1

Mov1 RF[rn] = M[dir]

Mov2

Mov3

Mov4

Add

Sub

Jz0110

0101

0100

0011

0010

0001

op =

0000

M[dir] = RF[rn]

M[rn] = RF[rm]

RF[rn]= imm

RF[rn] =RF[rn]+RF[rm]

RF[rn] = RF[rn]-RF[rm]

PC=(RF[rn]=0) ?rel :PC

to Fetch

to Fetch

to Fetch

to Fetch

to Fetch

to Fetch

to Fetch

PC=0;

from states below

FSMD

Datapath

IRPC

Controller(Next-state and

controllogic; state

register)

Memory

RF (16)

RFwa

RFwe

RFr1a

RFr1e

RFr2a

RFr2eRFr1 RFr2

RFw

ALUALUs

2x1 mux

ALUz

RFs

PCld

PCinc

PCclr

3x1 muxMsMweMre

To all input control signals

From all output control signals

Control unit

16Irld

2

1

0

A D

1

0

Você acabou de construir um processador!!




Resumo do Capítulo

• Processadores de Propósito Geral– Bom desempenho, baixo NRE, flexíveis (várias aplicações)

• Controladores, datapaths e memórias• Prevalecem linguagem estruturadas

– Mas programação em linguagem assembly ainda pode ser necessária• Grande disponibilidade de ferramentas

– Incluindo simuladores de conjuntos de instruções e emuladores de circuitos

• ASIPs– Microcontroladores, DSP, processadores de rede, ASIPs customizados

• A escolha entre os vários tipos de processadores disponíveis é um passo importante dentro do projeto

• O desenvolvimento de um processador de propósito geral é conceitualmente o mesmo que desenvolver um processador customizado de propósito único

Embedded Systems Design: A Unified Hardware/Software...

Documents

Transcript of Embedded Systems Design: A Unified Hardware/Software...