Organização e Projetos de Computadores
Capítulo 2
Hennessy • Patterson
1
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Instruções
•
•
Linguagem da máquina
Vamos trabalhar com a arquitetura do conjunto de instruções MIPS
- Semelhante a outras arquiteturas desenvolvidas desde a década
de 1980
- Quase 100 milhões de processadores MIPS fabricados em 2002
- Usada pela NEC, Nintendo, Cisco, Silicon Graphics, Sony...
Hennessy • Patterson
2
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Aritmética MIPS
•
Todas as instruções possuem três operandos
• A ordem do operando é fixa (destino primeiro)
Exemplo:
Código C:
Código MIPS:
a=b+c
add a, b, c
(falaremos sobre registradores em breve)
“O número natural de operandos para uma operação como adição
é três... Exigir que cada instrução tenha exatamente três
operandos, nem mais nem menos, está de acordo com a filosofia
de manter o hardware simples.”
Hennessy • Patterson
3
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Aritmética MIPS
• Princípio de projeto: A simplicidade favorece a
regularidade.
• É claro que isso complica algumas coisas...
Código C:
Código MIPS:
a = b + c + d;
add a, b, c
add a, a, d
• Os operandos precisam ser registradores, apenas 32
registradores fornecidos
• Cada registrador contém 32 bits
• Princípio de projeto: Quanto menor, melhor. Por quê?
Hennessy • Patterson
4
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Registradores versus memória
• Os operandos das instruções aritméticas precisam ser
registradores — apenas 32 registradores fornecidos
• O compilador associa variáveis com registradores
• E quanto aos programas com muitas variáveis?
Entrada
Controle
Memória
Caminho de
dados
Saída
Processador
E/S
Hennessy • Patterson
5
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Organização da memória
• Vista como um array grande e unidimensional, com um
endereço.
• Um endereço de memória é um índice para o array.
• “Endereçamento de byte” significa que o índice aponta
para um byte da memória.
8 bits de dados
8 bits de dados
8 bits de dados
8 bits de dados
8 bits de dados
8 bits de dados
8 bits de dados
Hennessy • Patterson
6
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Organização da memória
• Os bytes são bons, mas a maioria dos itens de dados
usam “words” maiores
• Para o MIPS, uma word possui 32 bits ou 4 bytes.
32 bits de dados
32 bits de dados
Os registradores armazenam 32 bits de dados
32 bits de dados
32 bits de dados
232 bytes com endereços de byte de 0 a 232-1
230 words com endereços de byte 0, 4, 8, ... 232-4
As words são alinhadas
Por exemplo, quais são os 2 bits menos significativos de um
endereço de word?
Hennessy • Patterson
7
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Instruções
• Instruções load e store
• Exemplo:
Código C:
Código MIPS:
A[12] = h + A[8];
lw $t0, 32($s3)
add $t0, $s2, $t0
sw $t0, 48($s3)
• Pode se referir aos registradores por nome (por
exemplo, $s2, $t2) em vez do número
• A instrução store word tem o destino por último
• Lembre-se de que os operandos são registradores,
não memória!
Não podemos escrever: add 48($s3), $s2, 32($s3)
Hennessy • Patterson
8
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Nosso primeiro exemplo
•
Você pode descobrir o código?
swap(int v[], int k);
{ int temp;
temp = v[k]
v[k] = v[k+1];
v[k+1] = temp;
}
swap:
muli $2, $5, 4
add $2, $4, $2
lw $15, 0($2)
lw $16, 4($2)
sw $16, 0($2)
sw $15, 4($2)
jr $31
Hennessy • Patterson
9
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Até agora, aprendemos:
• MIPS
- carga de words mas endereçamento de
bytes
- aritmética apenas em registradores
• Instrução
Significado
add $s1, $s2, $s3
$s1 = $s2 + $s3
sub $s1, $s2, $s3
$s1 = $s2 – $s3
lw $s1, 100($s2)
$s1 =
Memory[$s2+100]
sw $s1, 100($s2)
Memory[$s2+100] =
$s1
Hennessy • Patterson
10
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Linguagem de máquina
• Instruções, como registradores e words de
dados, também possuem 32 bits de tamanho
- Exemplo: add $t1, $s1, $s2
- Registradores têm números, $t1=9, $s1=17,
$s2=18
• Formato da instrução:
Você sabe o significado dos nomes de campo?
Hennessy • Patterson
11
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Linguagem de máquina
Pense nas instruções load-word e store-word
- O que o princípio da regularidade nos levaria a fazer?
- Novo princípio: Um bom projeto exige
comprometimento
• Introduza um novo tipo de formato de instrução
- Tipo I para instruções de transferência de dados
- Outro formato era o tipo R para o registrador
• Exemplo: lw $t0, 32($s2)
23
18
9
32
op
rs
rt
número de 16 bits
Qual é o compromisso?
Hennessy • Patterson
12
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Conceito do programa armazenado
• Instruções são bits
• Programas são armazenados na memória – para serem
lidos ou escritos exatamente como os dados
Memória para dados, programas,
compiladores, editores etc.
Processador
Memória
• Ciclo de execução e busca
- As instruções são buscadas e colocadas em um registrador
especial
- Os bits no registrador “controlam” as ações subseqüentes
- Busca a próxima instrução e continua
Hennessy • Patterson
13
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Controle
•
Instruções de tomada de decisão
- altera o fluxo de controle
- por exemplo, mudar a “próxima” instrução a ser
executada
• Instruções de desvio condicionais do MIPS:
bne $t0, $t1, Label
beq $t0, $t1, Label
• Exemplo:
if (i==j) h = i + j;
bne $s0, $s1, Label
add $s3, $s0, $s1
Label: ....
Hennessy • Patterson
14
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Controle
• Instruções de desvio incondicionais do MIPS:
j label
• Exemplo:
if (i!=j)
h=i+j;
else
h=i-j;
beq $s4, $s5, Lab1
add $s3, $s4, $s5
j Lab2
Lab1: sub $s3, $s4, $s5
Lab2: ...
• Você pode construir um “loop for” simples?
Hennessy • Patterson
15
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Até agora:
•
•
Instrução
Significado
add $s1,$s2,$s3
sub $s1,$s2,$s3
lw $s1,100($s2)
sw $s1,100($s2)
bne $s4,$s5,L
beq $s4,$s5,L
j Label
$s1 = $s2 + $s3
$s1 = $s2 – $s3
$s1 = Memory[$s2+100]
Memory[$s2+100] = $s1
Next instr. is at Label if $s4 ≠ $s5
Next instr. is at Label if $s4 = $s5
Next instr. is at Label
Formatos:
R
op
rs
rt
rd
I
op
rs
rt
endereço de 16 bits
J
op
endereço de 26 bits
Hennessy • Patterson
16
shamt
funct
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Fluxo de controle
•
Temos: beq e bne; e branch-if-less-than?
• Nova instrução:
if $s1 < $s2 then
$t0 = 1
slt $t0, $s1, $s2
else
$t0 = 0
• Podemos usar essa instrução para construir "blt $s1, $s2,
Label“ - agora podemos construir estruturas de controle gerais
• Note que o assembler precisa de um registrador para fazer isso
- existe uma política das convenções de uso para registradores
Hennessy • Patterson
17
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Política das convenções de uso
Nome
$zero
Número do
registrador
0
Uso
O valor constante 0
$v0-$v1
02/mar
Valores para resultados e
avaliação de expressões
$a0-$a3
04/jul
Argumentos
$t0-$t7
ago/15
Temporários
$s0-$s7
16-23
Valores salvos
$t8-$t9
24-25
Mais temporários
$gp
28
Ponteiro global
$sp
29
Ponteiro de pilha
$fp
30
Pointeiro de quadro
$ra
31
Endereço de retorno
Registrador 1 ($at) reservado para o assembler, 26-27 para o sistema operacional
Hennessy • Patterson
18
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Constantes
•
Constantes pequenas são usadas muito freqüentemente (50% dos
operandos)
Por exemplo:
A = A + 5;
B = B + 1;
C = C - 18;
• Soluções? Por que não?
- coloque “constantes típicas” na memória e carregue-as.
- crie registradores “hard-wired” (como $zero) para constantes
como um.
• Instruções MIPS:
•
Princípio de projeto: agilizar o caso comum. Que formato?
Hennessy • Patterson
19
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
E quanto às constantes maiores?
•
•
Gostaríamos de ser capazes de carregar uma constante de 32 bits
em um registrador
Precisamos usar duas instruções; nova instrução “load upper
immediate”:
preenchido com zeros
•
Depois, precisamos acertar os bits de ordem inferior, por exemplo:
Hennessy • Patterson
20
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
E quanto às constantes maiores?
•
•
Gostaríamos de ser capazes de carregar uma constante de 32 bits em um
registrador
Precisamos usar duas instruções; nova instrução “load upper immediate”:
lui $t0, 1010101010101010
1010101010101010
•
preenchido com zeros
0000000000000000
Depois, precisamos acertar os bits de ordem inferior, por exemplo:
Hennessy • Patterson
21
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Linguagem assembly versus linguagem
de máquina
•
O assembly fornece uma representação simbólica conveniente
- muito mais fácil do que escrever números
- por exemplo, destino primeiro
• A linguagem de máquina é realidade subjacente
- por exemplo, o destino não é mais o primeiro
• O assembly pode fornecer “pseudo-instruções”
- por exemplo, “move $t0, $t1” existe apenas no assembly
- seria mais bem implementada usando “add $t0,$t1,$zero”
• Ao considerar o desempenho, você deve contar as instruções
reais
Hennessy • Patterson
22
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Outras questões
•
Abordadas em seu laboratório de programação de linguagem
assembly:
- suporte para procedimentos
- linkers, carregadores, layout da memória
- pilhas, quadros, recursão
- manipulação de strings e ponteiros
- interrupções e exceções
- chamadas de sistema e convenções
• Veremos alguns desses mais adiante
• Estudaremos as otimizações de compilador quando chegarmos no
Capítulo 4.
Hennessy • Patterson
23
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Visão geral do MIPS
• instruções simples, todas com 32 bits
• muito estruturado, nenhuma bagagem desnecessária
• apenas três formatos de instrução
R
op
rs
rt
I
op
rs
rt
J
op
rd
shamt
funct
endereço de 16 bits
endereço de 26 bits
• nos baseamos no compilador para obter desempenho
— quais são os objetivos do compilador?
• ajudamos o compilador onde podemos
Hennessy • Patterson
24
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Endereços em desvios e jumps
•
Instruções:
bne $t4,$t5,Label
beq $t4,$t5,Label
j Label
•
A próxima instrução está em Label se $t4 ° $t5
A próxima instrução está em Label se $t4 = $t5
A próxima instrução está em Label
Formatos:
I
op
J
op
rs
rt
endereço de 16 bits
endereço de 26 bits
Os endereços não são de 32 bits
— Como manipular isso com instruções load e store?
Hennessy • Patterson
25
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Endereços em desvios
• Instruções:
bne $t4,$t5,Label
A próxima instrução está em Label se $t4 ≠ $t5
beq $t4,$t5,Label
A próxima instrução está em Label se $t4 = $t5
• Formatos:
I
•
•
op
rs
rt
endereço de 16 bits
Poderíamos especificar um registrador (como lw e sw) e
acrescentá-lo ao endereço
- use o registrador de endereço de instrução (PC = contador do
programa)
- a maioria dos desvios é local (princípio da localidade)
As instruções jump usam apenas bits de ordem superior do PC
- limites de endereço de 256 MB:
Hennessy • Patterson
26
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Resumindo:
Operandos MIPS
Nome
32 registradores
Exemplo
$s0-$s7, $t0-$t9,
$zero, $a0-$a3,
$v0-$v1, $gp, $fp,
$sp, $ra, $at
Hennessy • Patterson
Comentários
Locais rápidos para dados. No MIPS, os dados
precisam estar em registradores para a realização
De operações aritméticas. O registrador MIPS
$zero sempre é igual a 0. O registrador $at é
reservado para o assembler tratar de constantes
grandes.
27
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Resumindo: (Cont.)
Assembly do MIPS
Categoria
Instrução
Exemplo
Significado
Comentários
Aritmética
add
add $s1,$s2,$s3
$s1 = $s2 + $s3
Três operandos; dados nos registradores
subtract
sub $s1,$s2,$s3
$s1 = $s2- $s3
Três operandos; dados nos registradores
add immediate
addi
$s1=$s2 + 100
Usada para somar constantes
$s1,$s2,10
0
Transferência
de dados
Desvio
condicional
Desvio
incondicional
load word
lw $s1,100($s2)
$s1 = Memória[$s2 + 100]
Dados da memória para o registrador
store word
sw $s1,100($s2)
Memória[$s2 + 100] = $s1
Dados do registrador para a memória
load byte
lb $s1,100($s2)
$s1 = Memória[$s2 + 100]
Byte da memória para registrador
store byte
sb $s1,100($s2)
Memória[$s2+100] = $s1
Byte de um registrador para memória
load upper immed.
lui $s1,100
$s1 = 100 * 216
Carrega constante nos 16 bits mais altos
branch on equal
beq $s1,$s2,25
if ($s1 == $s2) go to PC + 4 + 100
Testa igualdade; desvio relativo ao PC
branch on not equal
bne $s1,$s2,25
if ($s1 != $s2) go to PC + 4 + 100
Testa desigualdade; relativo ao PC
set on less than
slt $s1,$s2,$s3
if ($s2 < $s3) $s1 = 1; else $s1 = 0
Compara menor que; usado com beq, bne
set less than
immediate
Slti$s1,$s2,100
if ($s2 < 100) $s1 = 1; else $s1 = 0
Compara menor que constante
jump
j 2500
go to 10000
Desvia para endereço de destino
jump register
jr $ra
go to $ra
Para switch e retorno de procedimento
jump and link
jal 2500
$ra = PC + 4. go to 10000
Para chamada de procedimento
Hennessy • Patterson
28
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Hennessy • Patterson
29
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Arquiteturas alternativas
• Alternativa de projeto:
- forneça operações mais poderosas
- o objetivo é reduzir o número de instruções executadas
- o risco é um tempo de ciclo mais lento e/ou uma CPI mais alta
-“O caminho em direção à complexidade da
operação é, portanto, repleto de perigos. Para evitar
esses problemas, os projetistas passaram para
instruções mais simples. A Seção 2.17 demonstra as
armadilhas da complexidade.”
• Vejamos (brevemente) o IA-32
Hennessy • Patterson
30
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
IA-32
•
•
•
•
•
•
•
•
•
•
•
1978: O Intel 8086 é anunciado (arquitetura de 16 bits)
1980: O co-processador de ponto flutuante Intel 8087 é acrescentado
1982: O 80286 aumenta o espaço de endereçamento para 24 bits; mais
instruções
1985: O 80386 estende para 32 bits; novos modos de endereçamento
1989-1995: O 80486, Pentium e Pentium Pro acrescentam algumas instruções
(especialmente projetadas para um maior desempenho)
1997: 57 novas instruções “MMX” são acrescentadas; Pentium II
1999: O Pentium III acrescenta outras 70 instruções (SSE)
2001: Outras 144 instruções (SSE2)
2003: A AMD estende a arquitetura para aumentar o espaço de endereço para
64 bits; estende todos os registradores para 64 bits, além de outras mudanças
(AMD64)
2004: A Intel se rende e abraça o AMD64 (o chama EM64T) e inclui mais
extensões de mídia
Essa história ilustra o impacto das “algemas douradas” da compatibilidade
“adicionando novos recursos da mesma forma que se coloca roupas em uma
sacola”, uma arquitetura “difícil de explicar e impossível de amar”.
Hennessy • Patterson
31
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Visão geral do IA-32
•
Complexidade:
- instruções de 1 a 17 bytes de tamanho
- um operando precisa agir como origem e destino
- um operando pode vir da memória
- modos de endereçamento complexos, por exemplo, “índice
base ou escalado com deslocamento de 8 ou 32 bits”
• Graça salvadora:
- as instruções mais usadas não são difíceis de construir
- os compiladores evitam as partes da arquitetura que são
lentas
“O que o 80x86 perde em estilo é compensado na quantidade,
tornando-o belo, do ponto de vista apropriado”
Hennessy • Patterson
32
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Registradores e endereçamento
de dados do IA-32
•
Registradores no subconjunto de 32 bits que surgiram com o 80386
Hennessy • Patterson
33
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Restrições de registrador do IA-32
Hennessy • Patterson
34
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Instruções típicas do IA-32
•
Quatro tipos principais de instruções de inteiro:
- Movimento de dados, incluindo move, push, pop
- Aritmética e lógica (registrador de destino ou memória)
- Fluxo de controle (uso de códigos de condição/flags)
- Instruções de string, incluindo movimento e comparação de
strings
Hennessy • Patterson
35
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Formatos de instruções IA-32
• Formatos típicos: (observe os diferentes tamanhos)
Hennessy • Patterson
36
©2005 Elsevier Editora Ltda
Organização e Projetos de Computadores
Resumo
• A complexidade da instrução é apenas uma variável
- instrução mais baixa versus CPI mais alta /
velocidade de clock mais baixa
• Princípios de projeto:
- simplicidade favorece a regularidade
- menor é melhor
- bom projeto exige comprometimento
- agilizar o caso comum
• Arquitetura do conjunto de instruções
- uma abstração muito importante!
Hennessy • Patterson
37
©2005 Elsevier Editora Ltda