DCC006 – Organização de Computadores I

Aula 2 – Instruções
A linguagem do Computador

Prof. Omar Paranaiba Vilela Neto

 Relembrando
Linguagem de alto nível
• Nível de abstração próximo do
domínio do problema
• Focado em produtividade e
portabilidade

Linguagem Assembly
• Representação textual de
instruções

Linguagem de Hardware
• Dígitos binários (bits)
• Codifica instruções e dados
 Conjunto de Instruções - ISA
 O repertório de instruções de um
computador
 Computadores diferentes possuem
conjuntos de instruções diferentes
 Mas comum em muitos aspectos
 Primeiros computadores tinham conjuntos
de instruções muito simples
 Implementações simplificadas
 Muitos computadores modernos também
tem conjuntos de instruções muito simples
 Conjunto de Instruções do RISC-V
 Usado como exemplo neste curso
 Desenvolvido na UC Berkeley como ISA aberto
 2010
 Agora gerenciado pela RISC-V Foundation
(riscv.org)
 Típico de muitos ISAs modernos
 Veja o cartão de referência do RISC-V (Moodle)
 ISAs similares possuem um vasto mercado em
sistemas embarcados
 Aplicações em eletrônicos, equipamento de
rede/armazenamento, câmeras, impressoras, …
 Um programa exemplo
.data
vetor: .word 10 20 30 40 50
.text
jal ra, L1
L1: addi x28,zero,1 Pseudo-instruções
addi x29,zero,1
addi x30,zero,1 Ajudam o compilador a
addi x31,zero,24 montar o programa.
sw x28 0(x31)
sw x29 4(x31) Em geral começam com
addi x31, x31,8 um caractere espacial
L2: beq x10, x30, L3
add x5, x28, x29
sw x5, 0(x31)
addi x31, x31, 4 Instruções
add x28, x29, zero
add x29, x5, zero São o programa em si.
addi x30,x30,1
beq zero,zero, L2
L3: jalr ra 0(zero)
 RISC-V - Aritmética

• Todas instruções tem 3 operandos

• A ordem dos operandos é fixa (destino primeiro)

Exemplo:

Código C: A = B + C

Código RISC-V: add A, B, C

• Operandos devem ser registradores, só existem 32 registradores

– Tamanho dos registradores: 64 bits. (Double word)

• Principio de Projeto 1: Simplicidade favorece regularidade

 RISC-V - Registradores
• Operandos de instruções Aritméticas devem ser
registradores,
— só existem 32 registradores
• Compilador associa variáveis com registradores

Registradores (números e nomes)

 x0 (zero): the constant value 0
 x1 (ra): return address
 x2 (sp): stack pointer
 x3 (gp): global pointer
 x4 (tp): thread pointer
 x5 – x7, x28 – x31 (t0-t6): temporaries
 x8 (s0/fp): frame pointer / saved register0
 x9, x18 – x27 (s1-s11): saved registers
 x10 – x11 (a0, a1): function arguments/results
 x12 – x17 (a2-a7): function arguments
 RISC-V - Aritmética

• Todas instruções tem 3 operandos

• A ordem dos operandos é fixa (destino primeiro)

Exemplo:

Código C: A = B + C

Código RISC-V: add x5, x6, x7

(associação com variáveis pelo compilador)

• Operandos devem ser registradores, só existem 32 registradores

– Tamanho dos registradores: 64 bits. (RISC-V)

• Principio de Projeto 2: Menor é mais rápido.

– Razão para poucos registradores
 RISC-V - Aritmética
• Principio de projeto: simplicidade favorece a regularidade.

• Código C: F = (G + H) - (I + J)
• F,...,J em x19,...,x23

• Código Intermediário: add t0, G, H

add t1, I,
J
sub F, t0,
t1

• Código RISC-V: add x5, x20, x21

add x6,
x22, x23
sub x19,
x5, x6
 RISC-V - Aritmética

Como fazer quando um programa

tem muitas variáveis?
Registradores x Memória

Por quê não usamos a Memória?

Controle Entrada
Memória
Datapath Saída

Processador I/O
 Organização da Memória
• Visto como uma matriz unidimensional, com um endereço.
• Um endereço de memória é um índice em uma matriz
• endereçamento de Byte aponta para um byte da memória.

0 8 bits de dados

1 8 bits de dados

2 8 bits de dados

3 8 bits de dados

4 8 bits de dados

5 8 bits de dados

6 8 bits de dados

...
 Organização da Memória

• Bytes são pequenos, mas vários dados usam “double words”

• Para o RISC-V, uma palavra dupla tem 64 bits ou 8 bytes.

0 64 bits de dados

8 64 bits de dados

64 bits de dados
Registradores retém 64 bits de dados
16
24 64 bits de dados

...

• 232 bytes com endereço de byte de 0 to 232-1

• 229 palavras duplas com endereço de byte 0, 8, 16, ... 2 32-8
 RISC-V – Acesso à Memória
• Instruções load e store

• Load – Carrega conteúdo da memória para o registrador

– ld x5, 8(x6)


Store – Copia conteúdo do registrador na memória


sd x5, 8(x6)
 RISC-V – Acesso à Memória
Copiar dados de → para Instrução

Memória → Registrador load double(ld)

Registrador → Memória store double(sd)

Formato: ld x5,8 (x6)

instrução registrador base,

que armazena o
registrador de endereço base
destino offset (em 15
bytes)
 RISC-V – Acesso à Memória

• Instruções load e store

• Exemplo:

Código C: A[12] = h + A[8];

Código RISC-V: ld x9, 64(x22)

add x9, x21, x9
sd x9, 96(x22)

• Store tem destino por último

• Relembre operandos aritméticos são registradores, não
memória!
 RISC-V – Acesso à Memória

 RISC-V byte/halfword/word load/store

 Load byte/halfword/word: Sign extend to 64 bits in rd
 lb rd, offset(rs1)
 lh rd, offset(rs1)
 lw rd, offset(rs1)
 Load byte/halfword/word unsigned: Zero extend to 64 bits in rd
 lbu rd, offset(rs1)
 lhu rd, offset(rs1)
 lwu rd, offset(rs1)
 Store byte/halfword/word: Store rightmost 8/16/32 bits
 sb rs2, offset(rs1)
 sh rs2, offset(rs1)
 sw rs2, offset(rs1)
 RISC-V – Aritmética com imediatos

• Todas instruções tem 3 operandos

• Um operando pode ser um número imediato

• Exemplo:

Código C: A = B + 21

Código RISC-V: addi x5, x6, 21

(associação com variáveis pelo compilador)

• Faça o caso comum rápido

• Pequenas constantes são comuns

• Operando imediato evita um load
 Revisão: Números Inteiros
• Bits são bits
— convenções define relação entre bits e números
• Números Binários (base 2)
• 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001...
decimal: 0...2n-1


mais complicado:
números são finitos (overflow)
frações e números reais
números negativos
i.e., RISC-V não tem instrução subi; (addi
pode somar um número negativo)

• Como nós representamos um número negativo?

i.e., qual padrão representará os números?
 Revisão: Números Inteiros
• Saídas: balanço, números de zeros, facilidade das operações

• Qual é a melhor? Porque?

Sinal Magnitude: Complemento de 1: Complemento de 2:

000 = +0 000 = +0 000 = +0
001 = +1 001 = +1 001 = +1
010 = +2 010 = +2 010 = +2
011 = +3 011 = +3 011 = +3
100 = -0 100 = -3 100 = -4
101 = -1 101 = -2 101 = -3
110 = -2 110 = -1 110 = -2
111 = -3 111 = -0 111 = -1
• • •
 Revisão: Números Inteiros
32 bit complemento de dois:

0000 0000 0000 0000 0000 0000 0000 0000two = 0ten

0000 0000 0000 0000 0000 0000 0000 0001two = + 1ten
0000 0000 0000 0000 0000 0000 0000 0010two = + 2ten
...
0111 1111 1111 1111 1111 1111 1111 1110two = + 2,147,483,646ten maxint
0111 1111 1111 1111 1111 1111 1111 1111two = + 2,147,483,647ten
1000 0000 0000 0000 0000 0000 0000 0000two = – 2,147,483,648ten minint
1000 0000 0000 0000 0000 0000 0000 0001two = – 2,147,483,647ten
1000 0000 0000 0000 0000 0000 0000 0010two = – 2,147,483,646ten
...
1111 1111 1111 1111 1111 1111 1111 1101two = – 3ten
1111 1111 1111 1111 1111 1111 1111 1110two = – 2ten
1111 1111 1111 1111 1111 1111 1111 1111two = – 1ten
•
• No conjunto de instruções do RISC-V

• lb: load byte com sinal

• lbu: load byte sem sinal (positivo)
Traduzindo para a Linguagem da Máquina

 Instruções são codificadas em binário

 Chamado de Código de Máquina

 Instruções RISC-V
 Codificado como palavras de 32-bit
 Pequeno número de formatos codificando: código da
operação, número dos registradores, ...
 Regularidade!
Traduzindo para a Linguagem da Máquina
Instruções Tipo-R
funct7 rs2 rs1 funct3 rd opcode
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits

 Instruction fields
 opcode: código da operação
 rd: número do registrador de destino
 funct3: 3-bit código de função (adicional ao opcode)
 rs1: número do primeiro registrador de origem
 rs2: número do segundoregistrador de origem
 funct7: 7-bit código de função (adicional ao opcode)
Traduzindo para a Linguagem da Máquina
Instruções Tipo-I
immediate rs1 funct3 rd opcode
12 bits 5 bits 3 bits 5 bits 7 bits

 Aritmética imediata e load

 rs1: número do registrador de origem ou base
 immediate: operando constante ou offset adicionado à base
 Complemento de 2, valor será estendido

• Principio de Projeto 3: Bons projetos demandam bons

compromissos.
– Diferentes formatos complica a decodificação, mas permite
instruções uniformes de 32 bits
– Manter os formatos o mais similar possível.
Traduzindo para a Linguagem da Máquina
Instruções Tipo-S
imm[11:5] rs2 rs1 funct3 imm[4:0] opcode
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits

 Formato diferente para instruções Store

 rs1: número do registrador de base
 rs2: número do registrador de origem
 immediate: offset adicionado à base
 Separado para que rs1 e rs2 estejam sempre no mesmo local
Traduzindo para a Linguagem da Máquina
Instruções Tipo-R
funct7 rs2 rs1 funct3 rd opcode
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits

Instruções Tipo-I
immediate rs1 funct3 rd opcode
12 bits 5 bits 3 bits 5 bits 7 bits

Instruções Tipo-S
imm[11:5] rs2 rs1 funct3 imm[4:0] opcode
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits
Traduzindo para a Linguagem da Máquina
Traduzindo para a Linguagem da Máquina
Exemplo Tipo-R
funct7 rs2 rs1 funct3 rd opcode
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits

add x9,x20,x21
0 21 20 0 9 51

0000000 10101 10100 000 01001 0110011

0000 0001 0101 1010 0000 0100 1011 0011two = 015A04B316

Traduzindo para a Linguagem da Máquina
Traduzindo para a Linguagem da Máquina

Agora vocês entendem!

 Armazenamento de Programas

The BIG Picture

 Instruções representadas em
binários, como dados.
 Instruções e dados
armazenados na memória
 Programas podem operar em
programas
 ex., Compiladores, ligadores, …
 Compatibilidade binária
permite programas
compilados funcionarem em
computadores diferentes
 ISAs Padronizados
 RISC-V – Operações Lógicas

Instruções para manipulação de bits

Operation C Java RISC-V

Shift left << << slli
Shift right >> >>> srli
Bit-by-bit AND & & and, andi
Bit-by-bit OR | | or, ori
Bit-by-bit XOR ^ ^ xor, xori
Bit-by-bit NOT ~ ~
 RISC-V – Operações Lógicas
Exemplo OR

or x9,x10,x11

x10 00000000 00000000 00000000 00000000 00000000 00000000 00001101 11000000

x11 00000000 00000000 00000000 00000000 00000000 00000000 00111100 00000000

x9 00000000 00000000 00000000 00000000 00000000 00000000 00111101 11000000

 RISC-V – Operações Condicionais
 Desvia para a instrução marcada se a condição
for verdadeira
 Caso contrário, continua sequencialmente

 beq rs1, rs2, L1

 se (rs1 == rs2) desvia para a instrução marcada L1

 bne rs1, rs2, L1

 se (rs1 != rs2) desvia para a instrução marcada L1

 blt rs1, rs2, L1

 Se (rs1 < rs2) desvia para a instrução marcada L1

 bge rs1, rs2, L1

 se (rs1 >= rs2) desvia para a instrução marcada L1
 RISC-V – Operações Condicionais
Exemplo IF
 C:
if (i==j) f = g+h;
else f = g-h;
 f, g, … em t0, t1, …

 RISC-V:
bne t3, t4, Else
add t0, t1, t2
beq zero,zero,Exit // incondicional
Else: sub t0, t1, t2
Exit: …
 RISC-V – Operações Condicionais
Exemplo Loop
 C:
while (save[i] == k) i += 1;
 i em t0, k em t1, endereço de save em t2

 RISC-V:
Loop: slli t3, t0, 3
add t3, t3, t2
ld t4, 0(t3)
bne t4, t1, Exit
addi t0, t0, 1
beq zero, zero, Loop
Exit: …
 RISC-V – Rótulos
Loop: slli t3, t0, 3 slli t3, t0, 3
add t3, t3, t2 add t3, t3, t2
ld t4, 0(t3) ld t4, 0(t3)
bne t4, t1, Exit bne t4, t1, 8
addi t0, t0, 1 addi t0, t0, 1
beq zero, zero, Loop beq zero, zero, -
Exit: … 24
…
 Rótulos auxiliam o programador de assembly
 Rótulos existem somente no assembly: são traduzidos para
imediatos ao gerar o código de máquina
 Alguns rótulos que viram imediatos:
 Nomes de variáveis alocadas no .data
 Nomes de procedimentos
 Desvios condicionais e incondicionais
 RISC-V – Chamada de Procedimento

Procedimentos: Conjunto de instruções com função definida

Realizam uma série de operações como base em valores de
parâmetros

Podem retornar valores computados


Motivos para o uso de procedimentos:


Tornar o programa mais fácil de ser entendido


Permitir a reutilização do código do procedimento


Permitir que o programador se concentre em uma parte do
código (os parâmetros funcionam como barreira)
 RISC-V – Chamada de Procedimento

Etapas para execução de um procedimento

1 - Colocar parâmetros em um lugar onde o procedimento pode acessar;

2 - Transferir o controle para o procedimento

3 - Adquirir os recursos de armazenamento necessários para o procedimento

4 - Realizar a tarefa desejada

5 - Colocar o valor de retorno em um local onde o programa que chamou o

procedimento possa acessá-lo

6 – Liberar os recursos de armazenamento

7 - Retornar o controle para o ponto de origem. Um procedimento pode ser chamado

por vários pontos em um programa.
 RISC-V – Chamada de Procedimento
Registradores de procedimento


x10-x17 (a0-a7): registradores de argumento do procedimento;

x10-x11 (r0,r1): registradores de valores de retorno;

x1 (ra): registrador de endereço de retorno – retorna ao ponto de origem;

PC: contador de programa – guarda o endereço da instrução
executada.

Instruções de procedimento


jal ra, PROC

Pula para o procedimento “PROC” e coloca o endereço de retorno em x1

ra = PC + 4

PC = PC + PROC

jalr zero, 0(ra)

 RISC-V – Chamada de Procedimento
O que fazer se um procedimento precisar de mais
registradores?

Algumas opções:

x5-x7, x28-x31 (t0-t6): registradores temporários não preservados;

x8, x9, x18-x27 (s0-s11): registradores salvos que precisam ser preservados.

Onde preservar os registradores salvos?

Em uma pilha na memória


sp: stack pointer – apontador de pilha.
 RISC-V – Chamada de Procedimento
Exemplo
RISC-V code:

folha:
addi sp, sp, -24
int folha (int g, int h, int i, int j) sd s2, 16(sp)
{ sd s3, 8(sp)
sd s4, 0(sp)
int f;
add s2, a0, a1
add s3, a2, a3
f = (g+h) – (i+j); sub s4, s2, s3
return f addi r0, s4, 0
} ld s4, 0(sp)
ld s3, 8(sp)
ld s2, 16(sp)
addi sp, sp, 24
jalr zero, 0(ra)
RISC-V – Chamada de Procedimento
 RISC-V – Chamada de Procedimento
Exemplo – Chama de procedimento – Recursivo
RISC-V code:
04: fact: addi sp, sp, -16
08: sd ra, 8(sp)
12: sd a0, 0(sp)
16: addi t0, a0, -1
int fact (int n) 20: bge t0, zero, L1
24: addi r0, zero, 1
{ 28: addi sp, sp, 16
if (n < 1) return (1); 32: jalr zero, 0(ra)
else return (n * fact(n-1)); 36: L1: addi a0, a0, -1
40: jal ra, fact
} 44: addi t1, r0, 0
48: ld a0, 0(sp)
52: ld ra, 8(sp)
56: addi sp, sp, 16
60: mul r0, a0, t1
64: jalr zero, 0(ra)
68: main: addi a0, zero, 7
72: jal ra, fact
 RISC-V – Array x Ponteiro
clear1(int array[], int size) { clear2(int *array, int size) {
int i; int *p;
for (i = 0; i < size; i += 1) for (p = &array[0]; p < &array[size];
array[i] = 0; p = p + 1)
} *p = 0;
}

addi sp,sp,-8 addi sp,sp,-8

sw ra, 0(sp) sw ra, 0(sp)
addi t0,zero,0 // i = 0 add t0,zero,a0 // p = address
loop1: // of array[0]
slli t1,t0,3 // t1 = i * 8 slli t1,a1,3 // t1 = size * 8
add t2,a0,t1 // x7 = address add t2,a0,t1 // t2 = address
// of array[i] // of array[size]
sd zero,0(t2) // array[i] = 0 loop2:
addi t0,t0,1 // i = i + 1 sd zero,0(t0) // Memory[p] = 0
blt t0,a1,loop1 // if (i<size) addi t0,t0,8 // p = p + 8
// go to loop1 bltu t0,t2,loop2 //if(p<&array[size])
lw ra, 0(sp) lw ra, 0(sp) // go to loop2
addi sp,sp,8 addi sp,sp,8
 Declarando um vetor em assembly
.data
vetor: .word 10 20 30 40 50
.text

 Utilize pseudo-instruções para facilitar!

 Declaração de um rótulo para o vetor
 Alocação automática no heap feita pelo montador
 Alocações ficam alinhadas na memória e uma após a
outra
 Acesso ao vetor (carga do endereço do vetor em
um registrador) – Instrução load address
 la t0, vetor
Traduzindo e Iniciando um Programa
Traduzindo e Iniciando um Programa

Traduz do alto nível para o

assembly
Traduzindo e Iniciando um Programa

Traduz para a linguagem da

máquina
Traduzindo e Iniciando um Programa

Muitos compiladores produzem o

módulo objeto diretamente
Traduzindo e Iniciando um Programa

Junta com bibliotecas e resolve

pendências – cria executável
Traduzindo e Iniciando um Programa

Static linking
Traduzindo e Iniciando um Programa

Copia o executável para a

memória
 Efeito da otimização do compilador
Programa Sort - Compilado com gcc para Pentium 4 no Linux

3 Relative Performance 140000 Instruction count

2.5 120000
100000
2
80000
1.5
60000
1
40000
0.5 20000
0 0
none O1 O2 O3 none O1 O2 O3

180000 Clock Cycles 2 CPI

160000
140000 1.5
120000
100000
1
80000
60000
40000 0.5
20000
0 0
none O1 O2 O3 none O1 O2 O3
Comparação com o MIPS
RISC vs. CISC
CISC
Complex Instruction Set Computer (Computador com um Conjunto Complexo de
Instruções)

Caracterizam-se por:

• Conjunto alargado de instruções

• Instruções complexas
• Instruções altamente especializadas
• Existência de vários formatos de instruções
• Suporte de vários modos de endereçamento
• Suporte para operandos em memória
• Baseado na microprogramação
• Exemplos: 80x86 de Intel, 680x0 de Motorola

58
CISC – Vantagens
• Programação de código de máquina mais fácil
• Código executável pequeno → menos memória necessário
• Instruções memória-à-memória (carregar e armazenar dados com
mesma instrução) → menos registradores necessários

Ótimo para os primeiros computadores (memória,

registradores caros)

59
CISC – Desvantagens
• Aumento de complexidade de processadores novos por
causa da inclusão das instruções velhas
• Muitas instruções especiais - menos usadas
• Execução de varias instruções complexas mais lento do
que execução da sequencia equivalente
• Alta complexidade
• Pipelining muito difícil → frequência de clock reduzido
• Tratamento de eventos externos (Interrupts) mais difícil
• Execução de instruções simples demora mais do que
necessário

Menos aplicável para computadores atuais

60
RISC
Reduced Instruction Set Computer (Computador com um Conjunto Reduzido
de Instruções)

• Menor quantidade de instruções (Intel 80486 com 200 instruções versus

SPARC com 50 instruções)
• Instruções mais simples
• Largura fixa de cada instrução
• Cada instrução demora um ciclo de clock (ou menos)
• Exemplos: MIPS, SPARC, Apple iPhone (Samsung ARM1176JZF),
Processadores novos do Intel (parcialmente)

61
RISC - Vantagens

• Menos transistores (área) para implementar lógica

• Instruções para acesso à memória (armazenar/ e

carregar dados) são separados

• Complexidade baixa

• Menos sujeito às falhas

• Tempo de decodificação reduzido

62
RISC – Desvantagens

• Mais registradores necessários

• Compilação de código de máquina mais

complicado

• Código mais complexo / maior

63
RISC vs. CISC

• CISC:
• Redução do número de instruções por programa
• Aumento do número de ciclos por instrução

• RISC:
• Redução do número de ciclos por instrução
• Aumento de número de instruções por programa

64
 X86 ISA
 Evolução com compatibilidade contínua
 8080 (1974): 8-bit microprocessor
 Acumulador, mais 3 register idexados
 8086 (1978): extensão 16-bit do 8080
 Complex instruction set (CISC)
 8087 (1980): co-processador floating-point
 Adiciona instruções FP e pilha de registradores
 80286 (1982): endereçamento 24-bit, MMU
 Memoria segmentada, mapeamento e proteção
 80386 (1985): extensão 32-bit (agora IA-32)
 Modos de endereçamento e operações adicionais
 Mapeamento de memória mapeada e segmentada
 X86 ISA
 Evolução continua…
 i486 (1989): pipelined, on-chip caches and FPU
 Competidores compativeis: AMD, Cyrix, …
 Pentium (1993): superscalar, 64-bit datapath
 Versões seguintes adicinaram instruções MMX (Multi-Media
eXtension)
 O famoso FDIV bug – grande prejuízo
 Pentium Pro (1995), Pentium II (1997)
 Nova organização (see Colwell, The Pentium Chronicles)
 Pentium III (1999)
 Adicionou SSE (Streaming SIMD Extensions) e registradores
associados
 Pentium 4 (2001)
 Nova organização
 Adicionou instruções SSE2
 X86 ISA
 E continua…
 AMD64 (2003): extensão da arquitetura para 64 bits
 EM64T – Extended Memory 64 Technology (2004)
 AMD64 adotado pela Intel (com refinamentos)
 Adiciona instruções SSE3
 Intel Core (2006)
 Adiciona instruções SSE4, Suporte a máquina virtual
 AMD64 (anunciado 2007): instruções SSE5
 Advanced Vector Extension (anunciado em 2008)
Registradores X86
 Endereçamento X86
 Dois operandos por instruções

 Modos de endereçamentos de memória

 Address in register
 Address = Rbase + displacement
 Address = Rbase + 2scale × Rindex (scale = 0, 1, 2, or 3)
 Address = Rbase + 2scale × Rindex + displacement
Instruções X86
 Tamanho variável
 Bytes de sufixo
especificam modo de
endereçamento
 Bytes de prefix
modificam a
operação
 Tamanho do operando
repetição, travamento
(concorrência), …
 Instruções X86
 Um conjunto de instruções complexo
dificulta a implementação
 Tradução da instrução para microinstruções
mais simples
 Instruções simples: tradução 1–1
 Instruções complexas: 1– muitas
 Caminho de dados internamente similar ao
RISC
 Viável devido à dominância do mercado
 Desempenho comparável ao RISC
 Compiladores evitam instruções complexas
CISC - Microprogramação
Instrução CISC
Decodificador

Nano-
Processador Microcódigo

• Cada instrução CISC separado em: instrução de

máquina, tipo de endereçamento e endereços,
registradores
• Seguinte: Envio de instruções pequenas (microcódigo)
para Nano-processador (processador no processador)
• Execução de uma instrução CISC demora vários ciclos
de clock
72
RISC vs. CISC - Hoje
Fronteiras indistintas

• Processadores RISC atuais usam técnicas CISC (por exemplo, mais

instruções, instruções mais complexos)
• Processadores CISC atuais usam técnicas RISC (p.e., um ciclo de clock por
instrução – ou menos, menos instruções)
• Técnicas avançadas (p.e., pipelining, branch prediction) aplicadas em
processadores RISC e CISC
• Outros fatores podem ser mais importante (p.e., Cache)
• Mas: Sistemas embutidos só com processadores RISC
• Área (CISC grande demais)
• Consumo de energia / dissipação de calor

73