Document

Notas da terceira edição
Nota: essas notas normalmente são complementadas por
outros materiais, como problemas do texto que podem
ser trabalhados em sala de aula. É provável que você
queira personalizar esse material para que se ajuste às
necessidades dos seus alunos. Essas notas foram
prepararadas com base em uma turma de alunos que
já aprendeu sobre desenvolvimento com lógica e
freqüentou um laboratório prático de programação de
linguagem assembly que não segue um formato de
aula comum.
1
Capítulo 1
2
Introdução
• O objetivo deste curso é mostrar como os computadores funcionam
• Mas o que queremos dizer com a palavra “computador”?
• Diferentes tipos: desktop, servidores, dispositivos embutidos
– Diferentes usos: automóveis, design gráfico, finanças, genética...
– Diferentes fabricantes: Intel, Apple, IBM, Microsoft, Sun...
– Diferentes tecnologias subjacentes e diferentes custos!
• Analogia: Pense em um curso sobre “veículos automotivos”
– Muitas semelhanças de um veículo para outro (por exemplo, volantes)
– Grandes diferenças de um veículo para outro (por exemplo, gasolina, álcool)
• Melhor maneira de aprender:
– Concentrar em um exemplo específico e aprender como ele funciona
– Abordar princípios gerais e perspectivas históricas
3
Por que aprender esse assunto?
• Você deseja se tornar um “cientista da computação”
• Você deseja desenvolver softwares utilizáveis (precisam de desempenho)
• Você precisa tomar uma decisão em relação a uma compra ou oferecer conselhos
de “especialista”
• Tanto o hardware quanto o software afetam o desempenho:
– O algoritmo determina o número de instruções na origem
– Linguagem/compilador/arquitetura determinam as instruções da máquina
(Capítulos 2 e 3)
– Processador/memória determinam a velocidade com que as instruções são
executadas (Capítulos 5, 6 e 7)
• Avaliando e entendendo o desempenho no Capítulo 4
4
O que é um computador?
• Componentes:
– entrada (mouse, teclado)
– saída (monitor, impressora)
– memória (unidades de disco, DRAM, SRAM, CD)
– rede
• Nosso foco principal: o processador (caminho de dados e controle)
– Implementado usando milhões de transistores
– Impossível de entender olhando para os transistores
– Precisamos...
5
Abstração
• Uma boa dica para obter mais informações
é aprofundar-se nos componentes
Programa
em linguagem
de alto nível
(em C)
• Uma abstração omite detalhes desnecessários
swap (int v[], int k)
{int temp;
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
}
e ajuda a entender a complexidade
Compilador
Programa
em linguagem
assembly
(para MIPS)
Quais são alguns dos detalhes que aparecem
nestas abstrações familiares?
swap:
muli
add
lw
lw
sw
sw
jr
$2, $5, 4
$2, $4, $2
$15, 0($2)
$16, 4($2)
$16, 0($2)
$15 4($2)
$31
Assembler
Programa em
linguagem de
máquina binária
(para MIPS)
000000001010000100000000000000011000
000000000001100110000001100000100001
100011000110001000000000000000000000
100011001111001000000000000000000100
101011001111001000000000000000000000
101011000110001000000000000000000100
000000111110000000000000000000000100
6
Como os computadores funcionam?
• É preciso entender abstrações como:
–
–
–
–
–
–
–
–
–
–
–
Software de aplicações
Software de sistemas
Linguagem assembly
Linguagem de máquina
Aspectos de arquitetura, como caches, memória virtual, canalização
Lógica seqüencial, máquinas de estado finito
Lógica combinatória, circuitos aritméticos
Lógica booleana, 1s e 0s
Transistores usados para construir portões lógicos (CMOS)
Semicondutores/silício usados para construir transistores
Propriedades dos átomos, elétrons e dinâmica quantitativa
• Muito o que aprender!
7
Arquitetura do conjunto de instruções
• Uma abstração muito importante
– interface entre o hardware e o software de baixo nível
– padroniza instruções, padrões de bits de linguagem de máquina etc.
– vantagem: diferentes implementações da mesma arquitetura
– desvantagem: algumas vezes impede o uso de inovações
Verdadeiro ou falso: A compatibilidade binária é extremamente importante?
• Arquiteturas de conjunto de instruções modernas:
– IA-32, PowerPC, MIPS, SPARC, ARM e outras
8
Perspectiva histórica
• O ENIAC, construído na Segunda Guerra Mundial, foi o primeiro computador de
finalidade geral
– Usado para calcular tabelas de disparo de artilharia
– 24 metros de comprimento por 2,5 metros de altura e dezenas de centímetros de
profundidade
– Cada um dos 20 registradores de 10 dígitos tinha 60 centímetros de comprimento
– Usava 18.000 válvulas
– Efetuava 1.900 adições por segundo
– Desde então:
Lei de Moore:
A capacidade dos transistores
dobra a cada 18 a 24 meses
9
Capítulo 2
10
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...
1400
1300
1200
Milhões de processadores
1100
1000
Outro
SPARC
Hitachi SH
PowerPC
Motorola 68K
900
MIPS
IA-32
800
ARM
700
600
500
400
300
200
100
0
1998
1999
2000
2001
2002
11
Aritmética MIPS
• Todas as instruções possuem três operandos
• A ordem do operando é fixa (destino primeiro)
Exemplo:
Código C:
a = b + c
Código MIPS:
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.”
12
Aritmética MIPS
• Princípio de projeto: a simplicidade favorece a regularidade.
• É claro, isso complica algumas coisas...
Código C:
a = b + c + d;
Código MIPS:
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ê?
13
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
Processador
Saída
E/S
14
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.
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
...
15
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.
0
4
32 bits de dados
8
12
32 bits de dados
32 bits de dados
Os registradores armazenam 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?
16
Instruções
• Instruções load e store
• Exemplo:
Código C:
A[12] = h + A[8];
Código MIPS:
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)
17
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
Æ
18
Até agora, aprendemos:
• MIPS
– carga de words mas endereçamento de bytes
– aritmética apenas em registradores
• Instrução
add $s1, $s2, $s3
sub $s1, $s2, $s3
lw $s1, 100($s2)
sw $s1, 100($s2)
Significado
$s1 = $s2 + $s3
$s1 = $s2 – $s3
$s1 = Memory[$s2+100]
Memory[$s2+100] = $s1
19
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:
000000
10001
10010
01000
00000
100000
op
rs
rt
rd
shamt
funct
• Você sabe o significado dos nomes de campo?
20
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)
35
18
9
op
rs
rt
32
número de bit 16
• Qual é o compromisso?
21
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
22
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:
....
23
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?
24
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
shamt
funct
endereço de 26 bits
25
Fluxo de controle
• Temos: beq e bne; e branch-if-less-than?
• Nova instrução:
if
slt $t0, $s1, $s2
$s1 < $s2 then
$t0 = 1
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
26
Política das convenções de uso
Nome
Número do registrador
$zero
0
Uso
O valor constante 0
$v0-$v1
2-3
Valores para resultados e
avaliação de expressões
$a0-$a3
4-7
Argumentos
$t0-$t7
8-15
Temporários
$s0-$s7
16-23
Valores salvos
$t8-$t9
24-25
Mais temporários
$gp
28
Ponteiro global
$sp
29
Pointeiro 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
27
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:
addi $29, $29, 4
slti $8, $18, 10
andi $29, $29, 6
ori $29, $29, 4
• Princípio de projeto: Torne o caso comum rápido. Que formato?
28
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:
ori $t0, $t0, 1010101010101010
1010101010101010
0000000000000000
0000000000000000
1010101010101010
1010101010101010
1010101010101010
ori
29
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 “pseudoinstruçõ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
30
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 no Capítulo 4.
31
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
rd
I
op
rs
rt
endereço de 16 bits
J
op
shamt
funct
endereço de 26 bits
• nos baseamos no compilador para obter desempenho
– quais são os objetivos do compilador?
• ajudamos o compilador onde podemos
32
Endereços em desvios e jumps
• 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
j Label
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?
33
Endereços em desvios
• Instruções:
bne $t4,$t5,Label
beq $t4,$t5,Label
A próxima instrução está em Label se $t4¹$t5
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
34
Resumindo
Operandos MIPS
Nome
Exemplo
Comentários
32
registradores
$s0-$s7, $t0-$t9, $zero,
$a0-$a3, $v0-$v1, $gp, $fp, $sp,
$ra, $at
Memória[0],
Memória[4].....
Memória[4294967292]
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.
Acessadas apenas por instruções de transferência de dados. O MIPS utiliza endereços em bytes, de modo
que os endereços em words seqüenciais diferem em 4 vezes. A memória contém estruturas de dados, arrays
e spilled registers, como aqueles salvos nas chamadas de procedimento.
30
2 words na
memória
Assembly do MIPS
Categoria
Instrução
Exemplo
Significado
Comentários
Aritmética
add
subtract
add immediate
load word
[TD]add $s1,$s2,$s3[TN]
[TD]sub $s1,$s2,$s3[TN]
addi $s1,$s2,100[TN]
[TD]lw $s1,100($s2)[TN]
[TD]$s1 = $s2 + $s3[TN]
[TD]$s1 = $s2- $s3[TN]
[TD]$s1=$s2 + 100[TN]
$s1 = Memória[$s2 + 100
Três operandos; dados nos registradores
Três operandos; dados nos registradores
Usada para somar constantes
Dados da memória para o registrador
store word
load byte
store byte
load upper immed.
branch on equal
[TD]sw $s1,100($s2)[TN]
lb $s1,100($s2)[TN]
sb $s1,100($s2)[TN]
[TD]lui $s1,100[TN]
beq $s1,$s2,25
Dados do registrador para a memória
Byte da memória para o registrador
Byte de um registrador para a memória
Carrega constante nos 16 bits mais altos
Testa igualdade; desvio relativo ao PC
branch on not equal
set on less than
bne $s1,$s2,25
slt $s1,$s2,$s3
set less than
immediate
jump
slti $s1,$s2,100
Memória[$s2 + 100] = $s1
$s1 = Memória[$s2 + 100
Memória[$s2+100] = $s1
[TD]$s1 = 100 * 216[TN]
if ($s1 == $s2) go to
PC + 4 + 100
if ($s1 != $s2) go to PC + 4 + 100
if ($s2 < $s3) $s1 = 1; else $s1 =
0
if ($s2 < 100) $s1 = 1; else $s1 = 0
j 2500
go to 10000
Desvia para endereço de destino
jump register
jump and link
jr $ra
jal 2500
go to [TD]$ra[TN]
[TD]$ra[TN] = PC + 4. go to 10000
Para switch e retorno de procedimento
Para chamada de procedimento
Transferência
de dados
Desvio
condicional
Desvio
incondicional
Testa desigualdade; relativo ao PC
Compara menor que; usado com beq, bne
Compara menor que constante
35
1. Endereçamento imediato
op
rs
rt
Imediato
2. Endereçamento em registrador
op
rs
rd
rt
...
Registradores
funct
Registrador
3. Endereçamento de base
op
rs
rt
Memória
Endereço
+
Registrador
Byte
Halfword
Word
4. Endereçamento relativo ao PC
op
rs
Endereço
rt
PC
Memória
Word
5. Endereçamento pseudodireto
op
Endereço
PC
Memória
Word
36
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.
• Vejamos (brevemente) o IA-32
37
IA-32
•
•
•
•
•
•
•
•
•
•
1978: O Intel 8086 é anunciado (arquitetura de 16 bits)
1980: O coprocessador de ponto flutuante 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”.
38
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”
39
Registradores e endereçamento de dados do IA-32
• Registradores no subconjunto de 32 bits que surgiram com o 80386
Nome
Uso
31
0
EAX
GPR0
ECX
GPR1
EDX
GPR2
EBX
GPR3
ESP
GPR4
EBP
GPR5
ESI
GPR6
EDI
GPR7
EIP
EFLAGS
CS
Ponteiro do segmento de código
SS
Ponteiro do segmento de pilha (topo da pilha)
DS
Ponteiro do segmento de dados 0
ES
Ponteiro do segmento de dados 1
FS
Ponteiro do segmento de dados 2
GS
Ponteiro do segmento de dados 3
Ponteiro de instrução (PC)
Códigos de condição
40
Restrições de registrador do IA-32
• Os registradores não são de “finalidade geral” — observe as restrições abaixo
Modo
Registrador indireto
Descrição
Restrições de registrador
Equivalente MIPS
Endereço está em um registrador.
não ESP ou EBP
lw $s0,0($s1)
Modo base com 8 ou 32 bits de
deslocamento
Endereço é o conteúdo do registrador base
mais deslocamento.
não ESP ou EBP
lw $s0,100($s1)#deslocamento
£ 16 bits
Base mais índice escalado
x Índice), onde
O endereço é Base + (2
Escala tem o valor 0, 1, 2 ou 3.
Base: qualquer GPR
Índice: não ESP
mul $t0,$s2,4
add $t0,$t0,$s1
lw $s0,0($t0)
Escala
x Índice) +
O endereço é Base + (2
deslocamento, onde Escala tem o valor 0, 1, 2
ou 3.
Base: qualquer GPR
Índice: não ESP
mul $t0,$s2,4
add $t0,$t0,$s1
lw $s0,100($t0)#deslocamento
£ 16 bits
Base mais índice escalado com 8 ou
32 bits de deslocamento
Escala
FIGURA 2.42 Modos de endereçamento de 32 bits do IA-32 com restrições de registrador e o código MIPS equivalente. O modo de endereçamento Base mais Índice Escalado, que não aparece no MIPS ou no PowerPC, foi incluído para evitar as multiplicações por quatro (fator de escala 2) para
transformar um índice de um registrador em um endereço em bytes (ver Figuras 2.34 e 2.36). Um fator de escala 1 é usado para dados de 16 bits, e um fator
de escala 3 para dados de 64 bits. O fator de escala 0 significa que o endereço não é escalado. Se o deslocamento for maior do que 16 bits no segundo ou
quarto modos, então o modo MIPS equivalente precisaria de mais duas instruções: um lui para ler os 16 bits mais altos do deslocamento e um add para
somar a parte alta do endereço ao registrador base $s1 (a Intel oferece dois nomes diferentes para o que é chamado modo de endereçamento com base com base e indexado -, mas eles são basicamente idênticos, e os combinamos aqui).
41
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
Instrução
JE nome
JMP nome
CALL nome
MOVW EBX,[EDI+45]
PUSH ESI
POP EDI
ADD EAX,#6765
TEST EDX,#42
MOVSL
Função
se for igual(códigos de condição) {EIP=nome};
EIP-128 nome < EIP+128
EIP=nome
SP=SP-4; M[SP]=EIP+5; EIP=nome;
EBX=M[EDI+45]
SP=SP-4; M[SP]=ESI
EDI=M[SP]; SP=SP+4
EAX= EAX+6765
Define códigos de condição (flags) com EDX e 42
M[EDI]=M[ESI];
EDI=EDI+4; ESI=ESI+4
FIGURA 2.43 Algumas instruções IA-32 típicas e suas funções. Uma lista de operações
freqüentes aparece na Figura 2.44. O CALL salva na pilha o EIP da próxima instrução (EIP é o PC da Intel).
42
Formatos de instruções IA-32
• Formatos típicos: (observe os diferentes tamanhos)
a. JE EIP + deslocamento
4
4
8
CondiDeslocamento
ção
JE
b. CALL
8
32
Deslocamento (offset)
CALL
c. MOV EBX, [EDI + 45]
6
1 1
8
8
MOV
d w
Pós-byte r/m
Deslocamento
d. PUSH ESI
5
3
PUSH
Reg
e. ADD EAX, #6765
4
3 1
32
Imediato
ADD Reg w
f. TEST EDX, #42
7
1
TEST
w
8
Pós-byte
32
Imediato
43
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:
– a simplicidade favorece a regularidade
– menor é mais rápido
– um bom projeto exige comprometimento
– torne o caso comum rápido
• Arquitetura do conjunto de instruções
– uma abstração muito importante!
44
Capítulo 3
45
Números
• Bits são apenas bits (nenhum significado inerente)
— convenções definem a 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
• Obviamente, torna-se mais complicado:
números são finitos (overflow)
frações e números reais
números negativos
por exemplo, nenhuma instrução subi do MIPS; addi pode somar
um número negativo
• Como representamos os números negativos?
Por exemplo, que padrões de bit representarão esses números?
46
Representações possíveis
• Sinal e magnitude:
000 = +0
001 = +1
010 = +2
011 = +3
100 = –0
101 = –1
110 = –2
111 = –3
Complemento a um
000 = +0
001 = +1
010 = +2
011 = +3
100 = –3
101 = –2
110 = –1
111 = –0
Complemento a dois
000 = +0
001 = +1
010 = +2
011 = +3
100 = –4
101 = –3
110 = –2
111 = –1
• Questões: equilíbrio, número de zeros, facilidade de operações
• Qual é o melhor? Por quê?
47
MIPS
• Números de 32 bits com sinal:
0000
0000
0000
...
0111
0111
1000
1000
1000
...
1111
1111
1111
0000 0000 0000 0000
0000 0000 0000 0000
0000 0000 0000 0000
0000 0000
0000 0000
0000 0000
0000bin = 0dec
0001bin = + 1dec
0010bin = + 2dec
1111
1111
0000
0000
0000
1111
1111
0000
0000
0000
1110bin
1111bin
0000bin
0001bin
0010bin
1111
1111
0000
0000
0000
1111
1111
0000
0000
0000
1111
1111
0000
0000
0000
1111 1111 1111 1111
1111 1111 1111 1111
1111 1111 1111 1111
1111
1111
0000
0000
0000
1111 1111
1111 1111
1111 1111
=
=
=
=
=
+
+
-
2,147,483,646dec
2,147,483,647dec
2,147,483,648dec
2,147,483,647dec
2,147,483,646dec
maxint
minint
1111bin = - 3dec
1111bin = - 2dec
1111bin = - 1dec
48
Operações de complemento a dois
• Negar um número de complemento a dois: inverta todos os bits e some 1
– lembre-se: “negar” e “inverter” são muito diferentes!
• Converter números de n bits em números com mais de n bits:
– o campo imediato de 16 bits do MIPS é convertido em 32 bits para aritmética
– copie o bit mais significativo (o bit de sinal) para os outros bits
0010 –> 0000 0010
1010 –> 1111 1010
• “extensão de sinal” (lbu versus lb)
49
Adição e subtração
• Exatamente como aprendemos na escola (emprestar/subir 1s)
0111
+ 0110
0111
– 0110
0110
– 0101
• Facilidade de operações do complemento a dois
– subtração usando adição para números negativos
0111
+ 1010
• Overflow (resultado muito grande para a word finita do computador):
– por exemplo, somar dois números de n bits não produz um número de n bits
0111
+ 0001
1000
note que o termo overflow é um pouco confuso;
ele não significa que um carry “transbordou”
50
Detectando overflow
• Nenhum overflow quando somar um número positivo com um negativo
• Nenhum overflow quando sinais são iguais para subtração
• O overflow ocorre quando o valor afeta o sinal:
– overflow ao somar dois positivos produz um negativo
– ou, somar dois negativos produz um positivo
– ou, subtraia um negativo de um positivo e obtenha um negativo
– ou, subtraia um positivo de um negativo e obtenha um positivo
• Considere as operações A + B e A – B
– Pode ocorrer overflow se B for 0?
– Pode ocorrer overflow se A for 0?
51
Efeitos do overflow
• Uma exceção (interrupção) ocorre
– O controle salta para um endereço predefinido para exceção
– O endereço interrompido é salvo para uma possível retomada
• Detalhes baseados na linguagem/sistema de software
– exemplo: controle de vôo versus dever de casa
• Nem sempre desejamos detectar overflow – novas instruções MIPS: addu, addiu,
subu
– Nota: addiu
– Nota: sltu, sltiu
ainda com extensão de sinal
para comparações sem sinal
52
Multiplicação
• Mais complexa do que a adição
– realizada através de deslocamento e adição
• Mais tempo e mais área
• Vejamos três versões baseadas em um algoritmo da escola
0010
x 1011
(multiplicando)
(multiplicador)
• Números negativos: converta e multiplique
– existem técnicas melhores mas não as veremos
53
Multiplicação: Implementação
Início
Multiplicador0 = 1
Multiplicando
1. Testar
Multiplicador0
Multiplicador0 = 0
1a. Soma multiplicando ao produto e
coloca o resultado no registrador Produto
Deslocar
à esquerda
64 bits
Multiplicador
Deslocar
à direita
ALU de 64 bits
2. Deslocar registrador Multiplicando 1 bit à esquerda
32 bits
Produto
Escrever
Teste de
controle
3. Deslocar registrador Multiplicador 1 bit à direita
64 bits
Não: < 32 repetições
32ª repetição?
Caminho de dados
Sim: 32 repetições
Controle
Fim
54
Versão final
• O multiplicador inicia na metade direita do produto
Início
Produto0 = 1
1. Testar
Produto0
Produto0 = 0
Multiplicando
32 bits
ALU de 32 bits
Deslocar à direita
Produto
Escrever
Teste de
controle
3. Desloque o registrador Produto 1 bit para a direita
64 bits
32ª repetição?
O que entra aqui?
Não: < 32 repetições
Sim: 32 repetições
Fim
55
Ponto flutuante (um breve exame)
• Precisamos de uma maneira de representar
– números com frações, por exemplo, 3,1416
– números muito pequenos, por exemplo, 0,000000001
– números muito grandes, por exemplo, 3,15576 × 109
• Representação:
– sinal, expoente, significando: (–1)sinal × significando × 2expoente
– mais bits para o significando fornece mais precisão
• mais bits para o expoente aumenta a faixa
• Padrão de ponto flutuante IEEE 754:
– precisão única: expoente de 8 bits, significando de 23 bits
– precisão dupla: expoente de 11 bits, significando de 52 bits
56
Padrão de ponto flutuante IEEE 754
• O bit “1” inicial do significando está implícito
• O expoente é “desviado” para facilitar a classificação
– todos os 0s são o menor expoente, todos os 1s são o maior
– desvio do 127 para precisão única e do 1023 para precisão dupla
– resumo: (–1)sinal × (1 + significando) × 2expoente – desvio
• Exemplo:
– decimal: –0,75 = – ( ½ + ¼ )
– binário: –0,11 = – 1,1 × 2–1
– ponto flutuante: expoente = 126 = 01111110
– precisão única IEEE: 10111111010000000000000000000000
57
Adição de ponto flutuante
Expoente
Sinal
Fração
Expoente
Sinal
Fração
1. Compare os expoentes dos dois números.
Desloque o menor número para a direita até
que seu expoente combine com o expoente maior.
ALU pequena
Diferença
do expoente
0
Início
2. Some os significandos
0
1
0
1
3. Normalize a soma, deslocando para a direita
e incrementando o expoente, ou deslocando para
a esquerda e decrementando o expoente.
Desloca
à direita
Controle
1
Overflow ou
underflow?
ALU grande
Sim
Não
0
0
1
Exceção
1
4. Arredonde o significando para
o número de bits apropriado
Incrementa ou
decrementa
Desloca para
esquerda ou direita
Não
Hardware de
arredondamento
Ainda
normalizado?
Sim
Sinal
Expoente
Fração
Fim
58
Complexidades do ponto flutuante
• As operações são um pouco mais complicadas (veja o texto)
• Além do overflow podemos ter o “underflow”
• A precisão pode ser um grande problema
– O IEEE 754 mantém dois bits extras, guarda e arredondamento
– quatro modos de arredondamento
– positivo dividido por zero produz “infinidade”
– zero dividido por zero não produz um número
– outras complexidades
• Implementar o padrão pode ser arriscado
• Não usar o padrão pode ser ainda pior
– veja no texto a descrição do 80x86 e o bug do Pentium!
59
Resumo do Capítulo 3
• A aritmética de computador é restrita por uma precisão limitada
• Os padrões de bit não têm um significado inerente mas existem padrões
– complemento a dois
– ponto flutuante IEEE 754
• As instruções de computador determinam o “significado” dos padrões de bit
• O desempenho e a precisão são importantes; portanto, existem muitas
complexidades nas máquinas reais
• A escolha do algoritmo é importante e pode levar a otimizações de hardware
para espaço e tempo (por exemplo, multiplicação)
• Você fazer uma revisão pode ser uma boa idéia (a Seção 3.10 é uma ótima leitura!)
60
Capítulo 4
61
Desempenho
• Meça, informe e resuma
• Faça escolhas inteligentes
• Veja através da propaganda de marketing
• Vital para entender a motivação organizacional subjacente
Por que alguns hardwares são melhores do que outros
para diferentes programas?
Que fatores do desempenho de sistema são relacionados
ao hardware? (por exemplo, precisamos de uma nova
máquina ou de um novo sistema operacional?)
Como o conjunto de instruções da máquina afeta o
desempenho?
62
Qual destes aviões possui o melhor desempenho?
Avião
Passageiros
Autonomia
(milhas)
Velocidade
(milhas por hora)
Boeing 737-100
101
630
598
Boeing 747
470
4150
610
BAC/Sud Concorde
132
4000
1350
Douglas DC-8-50
146
8720
544
• O quanto mais rápido é o Concorde comparado com o 747?
• O quanto maior é o 747 do que o Douglas DC-8?
63
Desempenho do computador: TEMPO, TEMPO, TEMPO
• Tempo de resposta (latência)
– Quanto tempo leva para meu trabalho ser realizado?
– Quanto tempo leva para realizar um trabalho?
– Quanto tempo preciso esperar para a consulta ao banco de dados?
• Vazão (throughput)
– Quantos trabalhos a máquina pode realizar ao mesmo tempo?
– Qual é a velocidade de execução média?
– Quanto trabalho está sendo feito?
• Se atualizarmos uma máquina com um novo processador, em que melhoramos?
• Se acrescentarmos uma máquina ao laboratório, em que melhoramos?
64
Tempo de execução
• Tempo decorrido
– conta tudo (acessos a disco e a memória, E/S etc.)
– um número útil, mas normalmente não é ideal para fins de comparação
• Tempo de CPU
– não conta E/S ou tempo gasto executando outros programas
– pode ser dividido em tempo de sistema e tempo de usuário
• Nosso foco: tempo de CPU do usuário
– tempo gasto executando as linhas de código que estão “em” nosso programa
65
Definição de desempenho do livro
• Para um programa sendo executado na máquina X,
DesempenhoX = 1 / Tempo_execuçãoX
• “X é n vezes mais rápido do que Y”
DesempenhoX / DesempenhoY = n
• Problema:
– a máquina A executa um programa em 20 segundos
– a máquina B executa o mesmo programa em 25 segundos
66
Ciclos de clock
• Em vez de informar o tempo de execução em segundos, normalmente usamos
ciclos
segundos
programa
=
ciclos
programa
x
segundos
ciclos
• As marcações de clock indicam quando iniciar as atividades (uma abstração):
tempo
• tempo de ciclo = tempo entre as marcações = segundos por ciclo
• velocidade de clock (freqüência) = ciclos por segundo (1 Hz. = 1 ciclo/segundo)
Um clock de 4 Ghz possui um tempo de ciclo de
1
x 1012 =250 picosegundos (ps)
9
4 x 10
67
Como melhorar o desempenho
segundos
programa
=
ciclos
programa
x
segundos
ciclos
• Portanto, para melhorar o desempenho (tudo mais sendo igual), você
pode (aumentar ou diminuir?)
o número de ciclos necessários para um programa, ou
o tempo de ciclo de clock ou, dito de outra maneira,
a velocidade de clock.
68
Quantos ciclos são necessários para um programa?
. . .
6ª instrução
5ª instrução
4ª instrução
3ª instrução
2ª instrução
1ª instrução
• Poderíamos considerar que o número de ciclos é igual ao número de instruções
Tempo
Essa suposição é incorreta;
diferentes instruções levam diferentes períodos de tempo em
diferentes máquinas.
Por quê? Dica: lembre-se de que essas são instruções de máquina,
não linhas de código C.
69
Diferentes números de ciclos para diferentes instruções
tempo
• A multiplicação leva mais tempo do que a adição
• As operações de ponto flutuante levam mais tempo do que as operações de inteiros
• Acessar a memória leva mais tempo do que acessar os registradores
• Importante: Mudar o tempo de ciclo normalmente muda o número de ciclos
necessários para várias instruções (veja mais posteriormente)
70
Exemplo
• Nosso programa favorito é executado em 10 segundos no computador A, que
possui um clock de 4 GHz. Estamos tentando ajudar um projetista de computador
a construir uma nova máquina B, que execute esse programa em 6 segundos.
O projetista determinou que um aumento substancial na velocidade de clock é
possível, mas esse aumento afetará o restante do projeto da CPU, fazendo com que
o computador B exija 1,2 vez mais ciclos de clock do que o computador A para esse
programa. Que velocidade de clock devemos pedir para que o projetista almeje?
• Não entre em pânico! Podemos resolver isso facilmente usando os princípios
básicos
71
Agora que entendemos os ciclos
• Um determinado programa exigirá
– um determinado número de instruções (instruções de máquina)
– um determinado número de ciclos
– um determinado número de segundos
• Temos um vocabulário que relaciona essas quantidades:
– tempo de ciclo (segundos por ciclo)
– velocidade de clock (ciclos por segundo)
– CPI (ciclos por instrução)
uma aplicação com excessivo uso de ponto flutuante pode
ter uma CPI mais alta
– MIPS (milhões de instruções por segundo)
isso seria mais alto para um programa usando instruções simples
72
Desempenho
• O desempenho é determinado pelo tempo de execução
• Qualquer uma das outras variáveis igualam o desempenho?
– número de ciclos para executar o programa?
– número de instruções no programa?
– número de ciclos por segundo?
– número médio de ciclos por instrução?
– número médio de instruções por segundo?
• Armadilha comum: pensar que uma das variáveis é indicadora do desempenho,
quando na realidade não é.
73
Exemplo de CPI
• Suponha que tenhamos duas implementações da mesma arquitetura do conjunto de
instruções (ISA)
Para um determinado programa,
A máquina A tem um tempo de ciclo de clock de 250 ps e uma CPI de 2,0
A máquina B tem um tempo de ciclo de clock de 500 ps e uma CPI de 1,2
Que máquina é mais rápida para esse programa e quão mais rápida ela é?
• Se duas máquinas possuem a mesma ISA, qual de nossas quantidades (por
exemplo, velocidade de clock, CPI, tempo de execução, número de instruções,
MIPS) será sempre idêntica?
74
Exemplo de número de instruções
• Um projetista de compilador está tentando decidir entre duas seqüências de código
para um determinada máquina. Com base na implementação de hardware, existem
três classes diferentes de instruções: Classe A, Classe B e Classe C, e elas exigem
um, dois e três ciclos, respectivamente.
A primeira seqüência de código possui 5 instruções: 2 de A, 1 de B e 2 de C.
A segunda seqüência possui 6 instruções: 4 de A, 1 de B e 1 de C.
Que seqüência será mais rápida? O quanto mais rápida? Qual é a CPI para cada
seqüência?
75
Exemplo de MIPS
• Dois compiladores diferentes estão sendo testados para uma máquina de 4 GHz
com três classes diferentes de instruções: Classe A, Classe B e Classe C, e elas
exigem um, dois e três ciclos, respectivamente. Ambos os compiladores são usados
para produzir código para um grande software.
O código do primeiro compilador usa 5 milhões de instruções da Classe A, 1 milhão
de instruções da Classe B e 1 milhão de instruções da Classe C.
O código do segundo compilador usa 10 milhões de instruções da Classe A, 1
milhão de instruções da Classe B e 1 milhão de instruções da Classe C.
• Que seqüência será mais rápida de acordo com o MIPS?
• Que seqüência será mais rápida de acordo com o tempo de execução?
76
Benchmarks
• A melhor forma de determinar desempenho é executando uma aplicação real
– Usa programas típicos do workload esperado
– Ou, típico da classe de aplicações esperada — por exemplo,
compiladores/editores, aplicações científicas, design gráfico etc.
• Benchmarks pequenos
– ótimos para arquitetos e projetistas
– fácil de padronizar
– pode ser forçado
• SPEC (System Performance Evaluation Cooperative)
– as empresas concordaram sobre um conjunto de programas e entradas reais
– valioso indicador do desempenho (e da tecnologia do compilador)
– ainda pode ser forçado
77
Jogos de benchmark
• A Intel reconheceu, envergonhada, na sexta-feira que um bug em um programa de
software conhecido como um compilador levou a empresa a anunciar uma
velocidade 10 por cento maior dos seus chips microprocessadores em um
benchmark da área. Entretanto, os analistas do setor disseram que o erro de
codificação foi um comentário infeliz sobre uma prática comum de “mentir” nos
testes de desempenho padronizados. O erro foi atribuído à Intel dois dias atrás pela
concorrente Motorola, em um teste conhecido como SPECint92. A Intel reconheceu
que havia “otimizado” seu compilador para melhorar suas pontuações de teste.
A empresa também havia dito que não gostava da prática, mas que foi forçada
a fazer as otimizações porque seus concorrentes estavam fazendo o mesmo.
No coração do problema da Intel está a prática de “ajustar” os programas de
compilador para reconhecerem certos problemas de computação no teste e, então,
substituir por partes especiais do código escritas a mão.
Sábado, 6 de janeiro de 1996 — New York Times
78
SPEC ‘89
• “Melhorias” e desempenho de compilador
800
700
Taxa de desempenho SPEC
600
500
400
300
200
100
0
gcc
espresso
spice
doduc
nasa7
li
Benchmark
eqntott
matrix300
fpppp
tomcatv
Compilador
Compilador melhorado
79
SPEC CPU2000
Benchmarks de inteiros
Nome
gzip
vpr
gcc
mcf
crafty
parser
eon
perlbmk
gap
vortex
bzip2
twolf
Descrição
Compactação
Posicionamento e roteamento de circuitos FPGA
O compilador C Gnu
Otimização combinatória
Programa de xadrez
Programa de processamento de textos
Visualização por computador
Aplicação Perl
Teoria de grupo, interpretador
Banco de dados orientado a objetos
Compactação
Simulador de posicionamento e roteamento de circuitos
Benchmarks de ponto flutuante
Nome
Wupwise
Swim
Mgrid
Applu
Mesa
Galgel
Art
Equake
Facerec
Ammp
Lucas
Fma3d
Sixtrack
Apsi
Tipo
Cromodinâmica Quântica
Modelo de água rasa
Solver multigrade no campo 3D potencial
Equação diferencial parcial parabólica/elíptica
Biblioteca de gráficos tridimensionais
Dinâmica computacional de fluidos
Reconhecimento de imagem usando redes neurais
Simulação de propagação de ondas sísmicas
Reconhecimento de imagem de rostos
Química computacional
Teste de primalidade
Simulação de choque usando método de elementos finitos
Projeto de acelerador de física nuclear de alta energia
Meteorologia: distribuição de poluentes
FIGURA 4.5 Os benchmarks SPEC CPU2000. Os 12 benchmarks de inteiros no lado esquerdo da tabela são escritos em C e C++, enquanto os benchmarks de ponto flutuante no lado direito são escritos em Fortran (77 ou 90) e em C. Para obter mais informações sobre o SPEC e os benchmarks SPEC,
veja www.spec.org. Os benchmarks SPEC CPU usam o tempo de relógio como métrica, mas, como há pouca E/S, eles medem o desempenho da CPU.
80
SPEC 2000
Dobrar a velocidade de clock dobra o desempenho?
Uma máquina com uma velocidade de clock mais lenta pode ter um desempenho melhor?
81
Experiência
• Telefone para um grande vendedor de computadores e diga que você está com
dificuldade de decidir entre dois computadores diferentes, especificamente, que
está confuso quanto aos pontos fortes e fracos dos processadores
(Por exemplo, entre Pentium 4 2Ghz e Celeron M 1.4 Ghz)
• Que tipo de resposta você provavelmente receberá?
• Que tipo de resposta você poderia dar a um amigo com a mesma dúvida?
82
Lei de Amdahl
Tempo de execução após melhoria = Tempo de execução não afetado
+ (Tempo de execução afetado / Quantidade de melhoria)
• Exemplo:
“Suponha que um programa seja executado em 100 segundos em uma
máquina, com multiplicação responsável por 80 segundos desse tempo. O quanto
precisamos melhorar a velocidade da multiplicação se queremos que o programa
seja executado 4 vezes mais rápido?”
Que tal torná-lo 5 vezes mais rápido?
• Princípio: torne o caso comum rápido
83
Exemplo
• Suponha que melhoramos uma máquina fazendo todas as instruções de ponto
flutuante serem executadas cinco vezes mais rápido. Se o tempo de execução de
algum benchmark antes da melhoria do ponto flutuante é 10 segundos, qual será o
aumento de velocidade se metade dos 10 segundos é gasta executando instruções
de ponto flutuante?
• Estamos procurando um benchmark para mostrar a nova unidade de ponto
flutuante descrita acima e queremos que o benchmark geral mostre um aumento de
velocidade de 3 vezes. Um benchmark que estamos considerando é executado
durante 100 segundos com o hardware de ponto flutuante antigo. Quanto do tempo
de execução as instruções de ponto flutuante teriam que considerar para produzir
nosso aumento de velocidade desejado nesse benchmark?
84
Lembre-se
• O desempenho é específico a um determinado programa
– O tempo de execução total é um resumo consistente do desempenho
• Para uma determinada arquitetura, os aumentos de desempenho vêm de:
• aumentos na velocidade de clock (sem efeitos de CPI adversos)
– melhorias na organização do processador que diminuem a CPI
– melhorias no compilador que diminuem a CPI e/ou a contagem de instruções
– escolhas de algoritmo/linguagem que afetam a contagem de instruções
• Armadilha: esperar que a melhoria em um aspecto do desempenho de uma máquina
afete o seu desempenho total
85
Vamos construir um processador
• Estamos quase prontos para entrar no Capítulo 5 e iniciar a construção de um
processador
• Primeiro, vamos revisar a lógica booleana e construir a ALU de que precisaremos
(material do Apêndice B)
operação
a
32
ALU
resultado
32
b
32
86
Revisão: Álgebra booleana e portões
• Problema: Considere uma função lógica com três entradas: A, B e C.
A saída D é verdadeira se pelo menos uma entrada for verdadeira
A saída E é verdadeira se exatamente duas entradas forem verdadeiras
A saída F é verdadeira apenas se todas as três entradas forem verdadeiras
• Mostre a tabela de verdade para essas três funções.
• Mostre as equações booleanas para essas três funções.
• Mostre a implementação consistindo de portões inversores, AND e OR.
87
Uma ALU (unidade lógica aritmética)
• Vamos construir uma ALU para dar suporte às instruções andi e ori
– construiremos apenas uma ALU de 1 bit e usaremos 32 deles
operação
a
op a
b
res
resultado
b
• Implementação possível (soma-dos-produtos):
88
Revisão: o multiplexador
• Seleciona uma das entradas para ser a saída, com base em uma entrada de controle
S
Nota: chamamos isso de um mux de duas entradas, mesmo
que ele tenha três entradas!
A
0
B
1
C
• Vamos construir nossa ALU usando um MUX:
89
Diferentes implementações
• Não é fácil decidir a “melhor” maneira de construir algo
– não queremos entradas demais em um único portão
– não queremos ter que atravessar muitos portões
– para nossos objetivos, a facilidade de compreensão é importante
• Vejamos uma ALU de 1 bit para adição:
CarryIn
a
Sum
cout = a b + a cin + b cin
sum = a xor b xor cin
b
CarryOut
• Como poderíamos construir uma ALU de 1 bit para add, and e or?
• Como poderíamos construir uma ALU de 32 bits?
90
Construindo uma ALU de 32 bits
Operação
CarryIn
a0
b0
CarryIn
ALU0
CarryOut
Resultado0
CarryIn
ALU1
CarryOut
Resultado1
CarryIn
ALU2
CarryOut
Resultado2
Operação
CarryIn
a1
a
b1
0
1
Resultado
a2
b2
b
+
CarryOut
2
..
.
a31
b31
..
.
CarryIn
ALU31
..
.
Resultado31
91
E quanto à subtração (a – b)?
• Método do complemento a dois: simplesmente negue b e some.
• Como negamos?
• Uma solução muito inteligente:
Binvert
Operação
CarryIn
a
0
1
b
0
+
Resultado
2
1
CarryOut
92
Acrescentando uma função NOR
• Também podemos escolher inverter a. Como obtemos um “a NOR b”?
Operação
Ainvert
Binvert
a
CarryIn
0
0
1
1
b
0
+
Resultado
2
1
CarryOut
93
Adequando a ALU ao MIPS
• Precisamos oferecer suporte à instrução set-on-less-than (slt)
• lembre-se: slt é uma instrução aritmética
– produz um 1 se rs < rt e produz um 0 em caso contrário
– use subtração: (a–b) < 0 implica a < b
• Precisamos aceitar teste de igualdade (beq $t5, $t6, $t7)
• use subtração: (a–b) = 0 implica a = b
94
Suporte a slt
• Podemos imaginar a idéia?
Binvert
Binvert
CarryIn
CarryIn
a
a
Operação
Ainvert
Operação
Ainvert
0
0
0
0
1
1
1
1
Resultado
Resultado
b
0
+
b
0
+
2
2
1
1
Less
Less
3
3
Set
CarryOut
Detecção
de overflow
Overflow
Todos os outros bits
Use esta ALU para o bit mais significativo
95
Suporte a slt
Operação
Binvert
Ainvert
CarryIn
a0
b0
CarryIn
ALU0
Less
CarryOut
Resultado0
a1
b1
0
CarryIn
ALU1
Less
CarryOut
Resultado1
a2
b2
0
CarryIn
ALU2
Less
CarryOut
Resultado2
..
.
.
..
. . ..
..
a31
b31
0
..
. CarryIn
CarryIn
ALU31
Less
..
.
Resultado31
Set
Overflow
96
Teste de igualdade
• Observe as linhas de controle:
Operação
Bnegate
Ainvert
0000
0001
0010
0110
0111
1100
=
=
=
=
=
=
and
or
add
subtract
slt
NOR
a0
b0
CarryIn
ALU0
Less
CarryOut
a1
b1
0
CarryIn
ALU1
Less
CarryOut
CarryIn
ALU2
Less
CarryOut
a2
b2
0
• Nota: zero é um 1 quando o
resultado é zero!
..
.
.
..
. .. ..
.
a31
b31
0
Result0
Result1
..
.
Result2
..
. CarryIn
CarryIn
ALU31
Less
Zero
..
.
..
.
Result31
Set
Overflow
97
Conclusão
• Podemos construir uma ALU para aceitar o conjunto de instruções MIPS
– idéia básica: usar um multiplexador para selecionar a saída que desejamos
– podemos realizar subtração eficientemente usando o complemento a dois
– podemos duplicar uma ALU de 1 bit para produzir uma ALU de 32 bits
• Pontos importantes sobre hardware
– todos os portões estão sempre operando
– a velocidade de um portão é influenciada pelo número de entradas do portão
– a velocidade de um circuito é influenciada pelo número de portões na série (no
“caminho crítico” ou no “nível mais profundo da lógica”)
• Nosso foco principal: compreensão; entretanto,
– Mudanças inteligentes na organização podem melhorar o desempenho
(semelhante a usar melhores algoritmos no software)
– Vimos isso na multiplicação; agora vejamos na adição
98
Problema: o somador com carry ripple é lento
• Uma ALU de 32 bits é tão rápida quanto uma ALU de 1 bit?
• Existe mais de uma maneira de fazer adição?
– dois extremos: carry ripple e soma-de-produtos
Você consegue ver o ripple? Como você se livraria dele?
c1
c2
c3
c4
=
=
=
=
b 0 c0
b 1 c1
b 2 c2
b 3 c3
+
+
+
+
a 0 c0
a 1 c1
a 2 c2
a 3 c3
+
+
+
+
a0b0
a1b1c2 =
a2b2 c3 =
a3b3 c4 =
Inviável! Por quê?
99
Somador com carry look-ahead
• Um método intermediário entre nossos dois extremos
• Motivação:
– Se não soubéssemos o valor do carry-in, o que poderíamos fazer?
– Quando sempre geraríamos um carry?
g i = a i bi
– Quando propagaríamos o carry?
p i = ai + bi
• Nos livramos do ripple?
c1
c2
c3
c4
=
=
=
=
g0
g1
g2
g3
+
+
+
+
p 0 c0
p 1 c1
p 2 c2
p 3 c3
c2 =
c3 =
c4 =
Viável! Por quê?
100
Use princípio para construir somadores maiores
CarryIn
a0
b0
a1
b1
a2
b2
a3
b3
a4
b4
a5
b5
a6
b6
a7
b7
a8
b8
a9
b9
a10
b10
a11
b11
a12
b12
a13
b13
a14
b14
a15
b15
CarryIn
Resultado0–3
ALU0
P0
G0
pi
gi
C1
ci + 1
CarryIn
Unidade de carry lookahead
Resultado4–7
• Não podemos construir um somador de
16 bits dessa maneira... (grande demais)
ALU1
P1
G1
pi + 1
gi + 1
C2
• Poderíamos usar o carry ripple dos
ci + 2
CarryIn
somadores CLA de 4 bits
Resultado8–11
• Melhor ainda: use o princípio CLA
novamente!
ALU2
P2
G2
pi + 2
gi + 2
C3
ci + 3
CarryIn
Resultado12–15
ALU3
P3
G3
pi + 3
gi + 3
C4
CarryOut
ci + 4
101
Resumo da ALU
•
•
•
•
Podemos construir uma ALU para aceitar adição MIPS
Nosso foco está na compreensão, não no desempenho
Processadores reais usam técnicas mais sofisticadas para aritmética
Onde o desempenho não é vital, as linguagens de descrição de hardware permitem
que os projetistas automatizem completamente a criação do hardware!
module MIPSALU (ALUctl, A, B, ALUOut, Zero);
input [3:0] ALUctl;
input [31:0] A,B;
output reg [31:0] ALUOut;
output Zero;
assign Zero = (ALUOut==0); // Zero é verdadeiro se ALUOut é 0; vai para algum lugar
always @(ALUctl, A, B) // reavalia se estes mudarem
case (ALUctl)
0: ALUOut <= A & B;
1: ALUOut <= A | B;
2: ALUOut <= A + B;
6: ALUOut <= A - B;
7: ALUOut <= A < B ? 1:0;
12: ALUOut <= ~(A | B); // resultado é nor
default: ALUOut <= 0; // default é 0, não deverá acontecer;
endcase
endmodule
FIGURA B4.3 Uma definição comportamental em Verilog de uma ALU MIPS. Isso poderia ser sintetizado por meio
de uma biblioteca de módulos contendo operações aritméticas e lógicas básicas.
102
Capítulo 5
103
O processador: caminho de dados e controle
• Estamos prontos para ver uma implementação do MIPS
• Simplificada para conter apenas:
– instruções de referência à memória: lw, sw
– instruções lógicas e aritméticas: add, sub, and, or, slt
– instruções de fluxo de controle: beq, j
• Implementação genérica:
– use o contador de programa (PC) para fornecer endereço de instrução
– obtenha a instrução da memória
– leia os registradores
– use a instrução para decidir exatamente o que fazer
• Todas as instruções usam a ALU após lerem os registradores
Por quê? Referência à memória? Aritmética? Fluxo de controle?
104
Mais detalhes de implementação
• Visão abstrata/simplificada:
4
Add
Add
Dados
PC
Endereço
Instrução
Memória
de instruções
Nº do Registrador
Registradores
Nº do Registrador
Nº do Registrador
ALU
Endereço
Memória
de dados
Dados
Dois tipos de unidades funcionais:
– elementos que operam nos valores de dados (combinacionais)
– elementos que contêm estado (seqüenciais)
105
Elementos de estado
• Sem clock versus com clock
• Clocks usados na lógica síncrona
– quando um elemento que contém estado deve ser atualizado?
Transição de descida
Período de clock
Transição de subida
tempo de ciclo
106
Um elemento de estado sem clock
• O trinco set-reset
– a saída depende das entradas presentes e também das entradas passadas
R
Q
Q
S
107
Trincos e flip-flops
• A saída é igual ao valor armazenado dentro do elemento (não é necessário pedir
permissão para olhar o valor)
• A mudança do estado (valor) é baseada no clock
• Trincos: sempre que as entradas mudarem e o clock for afirmado
• Flip-flop: o estado muda apenas em uma transição
de clock (metodologia de acionamento por transição)
“Logicamente verdadeiro”
— poderia significar eletricamente baixo
Uma metodologia de clocking define quando os sinais podem ser lidos e quando
podem ser escritos — não desejaríamos ler um sinal ao mesmo tempo em que ele
estivesse sendo escrito
108
Trinco D
• Duas entradas:
– o valor de dados a ser armazenado (D)
– o sinal de clock (C) indicando quando ler e armazenar D
• Duas saídas:
– o valor do estado interno (Q) e seu complemento
C
Q
D
C
Q
Q
D
109
Flip-flop D
• A saída muda apenas na transição do clock
D
Q
D
C
Q
D
D
latch
D
latch
C
Q
Q
Q
C
D
C
Q
110
Nossa implementação
• Uma metodologia de acionamento por transição
• Execução típica:
– ler conteúdo de alguns elementos de estado,
– enviar valores através de alguma lógica combinacional
– escrever os resultados em um ou mais elementos de estado
Elemento
de estado
1
Lógica combinacional
Elemento
de estado
2
Ciclo de clock
111
Arquivo de registrador
• Construído usando flip-flops D
Registrador de
leitura número 1
Registrador 0
Registrador 1
...
Registrador de
leitura número 1
Registrador de
leitura número 2
Banco de registradores
Registrador
para escrita
Dados para
escrita
Registrador n – 2
Dados da
leitura 1
Dados da
leitura 2
M
u
x
Dados da
leitura 1
M
u
x
Dados da
leitura 2
Registrador n – 1
Registrador de
leitura número 2
Write
Você entende? Qual é o “Mux” acima?
112
Abstração
• Certifique-se de ter entendido as abstrações!
• Algumas vezes é fácil achar que entendeu, quando não entendeu
Select
A31
Select
B31
A
B
M
u
x
C31
32
32
M
u
x
32
C
A30
B30
M
u
x
C30
..
.
..
.
A0
B0
M
u
x
C0
113
Arquivo de registrador
• Nota: ainda usamos o clock real para determinar quando escrever
Escrita
C
0
1
Número do
registrador
Decodificador
n-para-2n
Registrador 0
..
.
D
C
Registrador 1
n –1
n
D
..
.
C
Registrador n – 2
D
C
Registrador n – 1
Dados para
o registrador
D
114
Implementação simples
• Inclui as unidades funcionais de que precisamos para cada instrução
Endereço
de instrução
EscreveMem
Instrução
Add Soma
PC
Memória
de instruções
a. Memória de instruções
b. Contador de programa
c. Somador
Endereço
Dados
para
escrita
Dados
da
leitura
Memória
de dados
16
Extensão
de sinal
32
LeMem
a. Unidade de memória de dados b. Unidade de extensão de sinal
5
Números dos
registradores
5
5
Dados
Registrador
de leitura 1
4
Dados da
leitura 1
Registrador
de leitura 2
Registradores
Registrador
para escrita
Dados da
leitura 2
Dados
para escrita
Dados
Operação da ALU
Zero
ALU
Resultado
da ALU
Por que precisamos disso?
EscreveReg
a. Registradores
b. ALU
115
Construindo o caminho de dados
• Use multiplexadores para uni-los
OrigPC
M
u
x
Add
Add
4
Deslocamento
de 2 à
esquerda
PC
Endereço
de Leitura
Instrução
Memória de
instruções
Registrador
de leitura 1
OrigALU
Dados
da leitura 1
Operação da ALU
EscreveMem
Registrador
de leitura 2
Registradores
Dados
Registrador
da
leitura
2
para escrita
M
u
x
Dados
para escrita
Zero
ALU
Resultado
da ALU
MemparaReg
Endereço
Dados
da leitura
M
u
x
Memória
Dados
de dados
para escrita
EscreveReg
16
4
Resultado
da ALU
Extensão
de sinal
32
LeMem
116
Controle
• Selecionar as operações a serem realizadas (ALU, leitura/escrita etc.)
• Controlar o fluxo de dados (entradas do multiplexador)
• Informações vêm dos 32 bits da instrução
• Exemplo:
add $8, $17, $18
Formato de instrução:
000000
10001
10010
01000
00000
100000
op
rs
rt
rd
shamt
funct
• Operação da ALU com base no tipo de instrução e código de função
117
Controle
• Por exemplo, o que a ALU deve fazer com essa instrução
• Exemplo: lw $1, 100($2)
35
2
1
op
rs
rt
100
offset de 16 bits
• Entrada do controle da ALU
0000
0001
0010
0110
0111
1100
AND
OR
add
subtract
set-on-less-than
NOR
• Por que o código para subtrair é 0110 e não 0011?
118
Controle
• Precisa descrever hardware para calcular entrada de controle da ALU de 4 bits
– tipo de instrução dada
00 = lw, sw
01 = beq,
OpALU calculado do tipo de instrução
10 = aritmética
– código de função para aritmética
• Descreva-o usando uma tabela verdade (pode se tornar portões):
OpALU
Campo func.
OpALU1
OpALU 0
F5
F4
F3
F2
F1
F0
Operação
0
X
1
1
1
1
1
0
1
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
0
0
0
0
1
X
X
0
0
1
1
0
X
X
0
1
0
0
1
X
X
0
0
0
1
0
0010
0110
0010
0110
0000
0001
0111
FIGURA 5.13 A tabela verdade para os três bits de controle da ALU (chamados Operação). As entradas são OpALU e o campo de código func.
Apenas as entradas para as quais o controle da ALU é ativado são mostradas. Algumas entradas “don’t care” foram incluídas. Por exemplo, como OpALU
não usa a codificação 11, a tabela verdade pode conter entradas 1X e X1, em vez de 10 e 01. Além disso, quando o campo func é usado, os dois primeiros
bits (F5 e F4) dessas instruções são sempre 10; portanto, eles são termos don’t care e são substituídos por XX na tabela verdade.
119
Add
4
Instrução [31:26]
PC
Endereço
de Leitura
RegDst
Branch
LeMem
MemparaReg
OpALU
EscreveMem
OrigALU
EscreveReg
Instrução [25:21]
Registrador
de leitura 1
Instrução [20:16]
Registrador
de leitura 2
Instrução
[31:0]
Memória de
instruções
Controle
Instrução [15:11]
Instrução [15:0]
0
M
u
x
1
Registrador
para escrita
Dados
da
leitura 1
Dados
da
leitura 2
1
M
u
x
0
Dados
para
escrita Registradores
16
Extensão
de sinal
Resultado
Add da ALU
Deslocamento
de 2 à
esquerda
Zero
ALU
Resultado
da ALU
0
M
u
x
1
Endereço
Dados
da
leitura
1
M
u
x
0
Dados Memória
para
de dados
escrita
32
Controle
da ALU
Instrução [5:0]
Instrução
formato R
lw
sw
beq
RegDst
1
0
X
X
OrigALU
0
1
1
0
Mempara
Reg
0
1
X
X
Escreve
Reg
1
1
0
0
Le
Mem
0
1
0
0
Escreve
Mem
0
0
1
0
Branch
0
0
0
1
ALUOpl
1
0
0
0
ALUOp0
0
0
0
1
120
Controle
• Lógica combinacional simples (tabelas verdade)
Entradas
Op5
Op4
Op3
Op2
OpALU
Op1
Bloco de controle da ALU
Op0
OpALU0
OpALU1
Saídas
F3
F2
F (5–0)
Operação 1
Operation
Iw
sw
beq
RegDst
OrigALU
MemparaReg
F1
Operação 0
F0
Formato R
Operação 2
EscreveReg
LeMem
EscreveMem
Branch
OpALU1
OpALU0
121
Nossa estrutura de controle simples
• Toda a lógica é combinacional
• Esperamos que tudo se acalme e a coisa certa seja feita
– a ALU pode não produzir a “resposta certa” imediatamente
– usamos sinais de escrita junto com o clock para determinar quando escrever
• Tempo de ciclo determinado pela duração do caminho mais longo
Elemento
de estado
1
Lógica combinacional
Elemento
de estado
2
Ciclo de clock
Estamos ignorando alguns detalhes como tempos de setup e hold
122
Implementação de ciclo único
• Calcule o tempo de ciclo considerando os retardos insignificantes, exceto:
– memória (200ps),
ALU e somadores (100ps)
acesso ao arquivo de registrador (50ps)
OrigPC
M
u
x
Add
Add
4
Deslocamento
de 2 à
esquerda
PC
Endereço
de Leitura
Instrução
Memória de
instruções
Registrador
de leitura 1
OrigALU
Dados
da leitura 1
Operação da ALU
EscreveMem
Registrador
de leitura 2
Registradores
Dados
Registrador
da leitura 2
para escrita
M
u
x
Dados
para escrita
Zero
ALU
Resultado
da ALU
MemparaReg
Endereço
Dados
da leitura
M
u
x
Memória
Dados
de dados
para escrita
EscreveReg
16
4
Resultado
da ALU
Extensão
de sinal
32
LeMem
123
Nosso direcionamento
• Problemas de ciclo único:
– e se tivéssemos uma instrução mais complicada, como ponto flutuante?
– desperdício de área
• Uma solução:
– usar um tempo de ciclo “menor”
– fazer com que diferentes instruções usem diferentes números de ciclos
– um caminho de dados “multiciclo”:
PC
Endereço
Registrador
de instrução
A
Nº do Registrador
Registradores
Nº do Registrador
Instrução
Memória ou dados
Dados
Dados
Registrador
de dados
da memória
ALU
SaídaALU
B
Nº do Registrador
124
Método multiciclo
• Vamos reutilizar unidades funcionais
– ALU usada para calcular endereço e incrementar o PC
– Memória usada para instrução e dados
• Nossos sinais de controle não serão determinados diretamente pela instrução
– por exemplo, o que a ALU deve fazer para uma instrução “subtração”?
• Usaremos uma máquina de estado finito para controle
125
Método multiciclo
• Divida as instruções em etapas, cada uma durando um ciclo
– equilibre a quantidade de trabalho a ser feito
– restrinja cada ciclo para usar apenas uma unidade funcional
• No final de um ciclo
– armazene os valores para uso em ciclos posteriores (a coisa mais fácil a fazer)
– introduza registradores “internos” adicionais
PC
0
M
u
x
1
Endereço
Memória
DadosMem
Dados
para escrita
Instrução
[25:21]
Instrução
[20:16]
Instrução
[15:0]
Registrador
de instrução
Instrução
[15:0]
Registrador
de dados
da memória
0
M
u
x
1
Registrador
de leitura 1
Instrução
[15:11]
0
M
u
x
1
0
M
u
x
1
16
Dados
da
Registrador leitura 1
de leitura 2
Registradores
Registrador Dados
da
para escrita
leitura 2
Dados para
escrita
Extensão 32
de sinal
A
B
4
Zero
ALU
Resultado
da ALU
SaídaALU
0
1 M
u
2 x
3
Deslocamento
de 2 à
esquerda
126
Instruções da perspectiva da ISA
• Considere cada instrução da perspectiva da ISA.
• Exemplo:
– A instrução add muda um registrador.
– Registrador especificado pelos bits 15:11 da instrução.
– Instrução especificada pelo PC.
– Novo valor é a soma (“op”) dos dois registradores.
– Registradores especificados pelos bits 25:21 e 20:16 da instrução
Reg[Memory[PC][15:11]]
<=
Reg[Memory[PC][25:21]] op
Reg[Memory[PC][20:16]]
– Para conseguir isso, precisamos desmembrar a instrução (um tanto como
introduzir variáveis ao programar).
127
Desmembrando uma instrução
• Definição ISA da aritmética:
Reg[Memory[PC][15:11]]
<=
Reg[Memory[PC][25:21]] op
Reg[Memory[PC][20:16]]
• Poderia ser dividida em:
– IR <= Memory[PC]
– A <= Reg[IR[25:21]]
– B <= Reg[IR[20:16]]
– ALUOut <= A op B
– Reg[IR[20:16]] <= ALUOut
• Esquecemos uma parte importante da definição da aritmética!
– PC <= PC + 4
128
Conceito subjacente do método multiciclo
• Definimos cada instrução da perspectiva ISA (faça isso!)
• Divida-a em etapas seguindo nossa regra de que os dados fluem através de, no
máximo, uma grande unidade funcional (por exemplo, distribua o trabalho entre as
etapas)
• Introduza novos registradores conforme necessário (por exemplo, A, B, ALUOut,
MDR, etc.)
• Finalmente, experimente concentrar o máximo em cada etapa (evite ciclos
desnecessários), enquanto também tenta compartilhar etapas quando possível
(minimiza o controle e ajuda a simplificar a solução)
• Resultado: a implementação multiciclo do nosso livro!
129
Cinco etapas de execução
• Busca da instrução
• Decodificação da instrução e busca dos registradores
• Execução, cálculo do endereço de memória ou conclusão do desvio
• Acesso à memória ou conclusão da instrução tipo R
• Etapa de escrita adiada (write-back)
AS INSTRUÇÕES LEVAM DE 3 A 5 CICLOS!
130
Etapa 1: Busca da instrução
• Use o PC para obter a instrução e colocá-la no registrador Instrução.
• Incremente o PC em 4 e coloque o resultado novamente no PC.
• Pode ser descrita brevemente usando a RTL (Register-Transfer Language —
linguagem de transferência de registrador)
IR <= Memory[PC];
PC <= PC + 4;
Podemos descobrir os valores dos sinais de controle?
Qual é a vantagem de atualizar o PC agora?
131
Etapa 2: Decodificação da instrução e busca dos
registradores
• Leia os registradores rs e rt no caso de precisarmos deles
• Calcule o endereço de desvio no caso de a instrução ser um branch
• RTL:
A <= Reg[IR[25:21]];
B <= Reg[IR[20:16]];
ALUOut <= PC + (sign-extend(IR[15:0]) < 2);
• Não estamos definindo quaisquer linhas de controle com base no tipo de instrução
(estamos ocupados “decodificando-a” em nossa lógica de controle)
132
Etapa 3 (dependente da instrução)
• ALU está desempenhando uma de três funções, com base no tipo de instrução
– Referência à memória:
ALUOut <= A + sign-extend(IR[15:0]);
– Tipo R:
ALUOut <= A op B;
– Branch:
if (A==B) PC <= ALUOut;
133
Etapa 4: (Tipo R ou acesso à memória)
• Loads e stores acessam a memória
MDR <= Memory[ALUOut];
ou
Memory[ALUOut] <= B;
• Instruções Tipo R terminam
Reg[IR[15:11]] <= ALUOut;
A escrita na verdade ocorre no final do ciclo na transição
134
Etapa 5: Escrita adiada
• Reg[IR[20:16]] <= MDR;
Que instrução precisa disso?
135
Resumo
Etapa
Ação para instruções
tipo R
Ação para instruções de acesso à memória
Busca da instrução
Ação para jumps
IR <= Memória[PC]
PC <= PC + 4
Decodificação da instrução e
busca dos registradores
A <= Reg[IR[25:21]]
B <= Reg[IR[20:16]]
SaídaALU <= PC + (estende-sinal (IR[15:0]) << 2)
Execução, cálculo do endereço,
conclusão do desvio/jump
SaídaALU <= A op B
SaídaALU <= A + estende-sinal
(IR[15:0])
Acesso à memória ou
conclusão de instrução tipo R
Reg[IR[15:11]]<=
SaídaALU
Load: MDR <= Memória[SaídaALU]
ou
Store: Memória [SaídaALU] <= B
Conclusão da leitura da
memória
Ação para desvios
if (A == B)
PC <= SaídaALU
PC <= {PC [31:28],
(IR[25:0]],2’b00)}
Load: Reg[IR[20:16]] <= MDR
FIGURA 5.30 Resumo das etapas realizadas para executar qualquer classe de instrução. As instruções levam de três a cinco etapas de execução. As duas primeiras etapas são independentes da classe de instrução. Após essas etapas, uma instrução leva ainda de um a três ciclos para ser concluída, dependendo da classe de instrução. As entradas vazias da etapa de acesso à memória ou a etapa de conclusão da leitura da memória indicam que a
classe de instrução específica leva menos ciclos. Em uma implementação multiciclo, uma nova instrução será iniciada tão logo a instrução atual seja concluída; portanto, esses ciclos não são ociosos ou desperdiçados. Na verdade, como mencionado anteriormente, o banco de registradores lê todos os ciclos, mas, como o IR não muda, os valores lidos do banco de registradores são idênticos. Em especial, o valor lido para o registrador B durante a etapa de
decodificação da instrução, para uma instrução de desvio ou tipo R, é o mesmo valor armazenado em B durante a etapa de execução e, depois, usado na
etapa de acesso à memória para uma instrução store word.
136
Perguntas simples
• Quantos ciclos serão necessários para executar este código?
lw $t2, 0($t3)
lw $t3, 4($t3)
beq $t2, $t3, Label
add $t5, $t2, $t3
sw $t5, 8($t3)
Label:
...
#considere not
• O que está ocorrendo durante o 8º ciclo da execução?
• Em que ciclo ocorre a adição real de $t2 e $t3?
137
OrigPC
EscrevePCCond
EscrevePC
Saídas
IouD
LeMem
Controle
EscreveIR
OrigBALU
OrigAALU
EscreveMem
MemparaReg
OpALU
EscreveReg
Op
[5:0]
RegDst
26
Instrução [25:0]
PC
0
M
u
x
1
Instrução
[31:26]
Endereço
Memória
DadosMem
Dados
para escrita
Instrução
[25:21]
Instrução
[20:16]
Instrução
[15:0]
Registrador
de instrução
Instrução
[15:0]
Registrador
de dados
da memória
Instrução
[15:11]
0
M
u
x
1
0
M
u
x
1
16
Registrador
de leitura 1 Dados
da
Registrador
leitura 1
de leitura 2
Registradores
Registrador Dados
para escrita
da
Dados para leitura 2
A
28
B
Deslocamento
de 2 à
esquerda
4
Endereço
do jump
[31:0]
0
M
1 u
x
2
PC [31:28]
ALU Zero
Resultado
da ALU
escrita
Extensão 32
de sinal
0
M
u
x
1
Deslocamento
de 2 à
esquerda
SaídaALU
0
1 M
u
2 x
3
Controle
da ALU
Instrução [5:0]
138
Revisão: Máquinas de estado finito
• Máquinas de estado finito:
– um conjunto de estados e
– próxima função de estado (determinada pelo estado atual e pela entrada)
– função de saída (determinada pelo estado atual e possivelmente pela entrada)
Próximo
estado
Estado atual
Função de
próximo estado
Clock
Entradas
Função
de saída
Saídas
– Usaremos uma máquina de Moore (saída com base apenas no estado atual)
139
Revisão: Máquinas de estado finito
• Exemplo:
B.37 Um amigo gostaria que você construísse um “olho eletrônico” para ser usado
como um dispositivo de segurança falso. O dispositivo consiste em três luzes
alinhadas, controladas pelas saídas Esquerda, Centro e Direita, que, se afirmadas,
indicam que uma luz deve ser ligada. Apenas uma luz é acesa de cada vez, e
a luz “move-se” da esquerda para a direita e, depois, da direita para a esquerda,
afugentando, assim, os ladrões, que acreditam que o dispositivo está monitorando
suas ações. Desenhe uma representação gráfica para a máquina de estado finito
usada para especificar o olho eletrônico. Note que a velocidade do movimento do
olho será controlada pela velocidade do clock (que não deve ser muito alta) e que
basicamente não existem entradas.
140
Implementando o controle
• O valor dos sinais de controle depende de:
– que instrução está sendo executada
– que etapa está sendo realizada
• Use as informações que acumulamos para especificar uma máquina de estado finito
– especifique a máquina de estado finito graficamente ou
– use microprogramação
• A implementação pode ser derivada da especificação
141
Busca da instrução
Busca dos registradores/
LeMem
decodificação da instrução
OrigAALU = 0
1
IouD = 0
OrigAALU = 0
EscreveIR
OrigBALU = 11
OrigBALU = 01
OpALU = 00
OpALU = 00
EscrevePC
OrigPC = 00
Especificação gráfica da FSM
0
Início
• Nota:
– não se preocupe se não for mencionada
necessários?
Cálculo do endereço
de memória
2
(Op
8
OrigAALU = 1
OrigBALU = 00
OpALU = 10
OrigAALU = 1
OrigBALU = 00
OpALU = 01
EscrevePCCond
OrigPC = 01
Conclusão
do jump
9
EscrevePC
OrigPC = 10
p
=
W
'S
')
Acesso à
memória
Acesso à
memória
5
LeMem
IouD = 1
4
6
(O
3
Conclusão
do branch
Execução
OrigAALU = 1
OrigBALU = 10
OpALU = 00
= 'B
EQ
')
R)
o
tip
=
p
(O
(Op = 'LW')
• Quantos bits de estado serão
p=
(O
– caso contrário, valor exato
'SW
u(
)o
'
'LW
=
Op
(Op = 'J')
')
– afirmada se apenas nome
EscreveMem
IouD = 1
Conclusão de tipo R
7
RegDst = 1
EscreveReg
MemparaReg = 0
Etapa de
conclusão
da leitura
de memória
RegDst = 1
EscreveReg
MemparaReg = 0
142
Máquina de estado finito para controle
• Implementação:
EscrevePC
EscrevePCCond
IouD
LeMem
EscreveMem
EscreveIR
MemparaReg
Lógica de controle
OrigPC
Saídas
OpALU
OrigBALU
OrigAALU
EscreveReg
RegDst
NS3
NS2
NS1
NS0
Registrador de instrução€
Campo opcode
S0
S1
S2
S3
Op0
Op1
Op2
Op3
Op4
Op5
Entradas
Registrador de estado
143
Implementação PLA
• Se seu selecionasse uma linha horizontal ou vertical, você poderia explicá-la?
144
Implementação da ROM
• ROM = “Read Only Memory”
– os valores dos locais de memória são fixados antecipadamente
• Uma ROM pode ser usada para implementar uma tabela verdade
– se o endereço for m bits, podemos endereçar 2m entradas na ROM.
– nossas saídas são os bits de dados para os quais o endereço aponta.
m
n
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
1
1
0
0
0
0
0
1
1
0
0
0
1
1
1
0
0
0
0
0
1
1
1
0
0
0
0
1
0
1
m é a “altura” e n é a “largura”
145
Implementação da ROM
• Quantas entradas existem?
6 bits para opcode, 4 bits para estado = 10 linhas de endereço
(por exemplo, 210 = 1024 endereços diferentes)
• Quantas saídas existem?
16 saídas do controle do caminho de dados, 4 bits de estado = 20 saídas
• A ROM possui 210 x 20 = 20K bits (e um tamanho bastante incomum)
• Muito ineficiente, já que, para muitas das entradas, as saídas são iguais
– por exemplo, opcode freqüentemente é ignorado
146
ROM versus PLA
• Divida a tabela em duas partes
– 4 bits de estado indicam as 16 saídas, 24 × 16 bits de ROM
– 10 bits informam os próximos 4 bits de estado, 210 × 4 bits of ROM
– Total: 4,3 Kbits de ROM
• A PLA é muito menor
– pode compartilhar termos de produto
– precisa apenas entradas que produzem uma saída ativa
– pode levar em conta don’t cares
• O tamanho é (no. de entradas × no. de termos-produto) + (no. de saídas × no. de
termos-produto)
Para este exemplo = (10x17)+(20x17) = 510 células de PLA
• As células de PLA normalmente possuem o tamanho aproximado de uma célula de
ROM (ligeiramente maior)
147
Outro estilo de implementação
• Instruções complexas: o “próximo estado” normalmente é o estado atual + 1
EscrevePC
EscrevePCCond
IouD
Unidade de
controle
LeMem
EscreveMem
PLA ou ROM
Saídas
EscreveIR
EscreveB
MemparaReg
OrigPC
OpALU
OrigBALU
OrigAALU
EscreveReg
RegDst
Entrada
CtlEnd
1
Estado
Somador
Op[5–0]
Lógica se seleção
de endereço
Campo opcode€
do registrador Instruction
148
Detalhes
Op
000000
000010
000100
100011
101011
ROM de despacho 1
Nome do opcode
formato R
jmp
beq
lw
sw
Valor
0110
1001
1000
0010
0010
ROM de despacho 2
Nome do opcode
lw
sw
Op
100011
101011
Valor
0011
0101
PLA ou ROM
1
Estado
Somador
Mux
3
2
1
CtlEnd
0
0
ROM de despacho 2
Ação do controle de endereço
Usa o estado incrementado
Usa a ROM de despacho 1
Usa a ROM de despacho 2
Usa o estado incrementado
Substitui o número do estado por 0
Substitui o número do estado por 0
Usa o estado incrementado
Substitui o número do estado por 0
Substitui o número do estado por 0
Substitui o número do estado por 0
Valor de
CtlEnd
3
1
2
3
0
0
3
0
0
0
ROM de despacho 1
Lógica de seleção
de endereço
Op
Número
do estado
0
1
2
3
4
5
6
7
8
9
Campo opcode do
registrador Instruction
149
Microprogramação
Unidade de
controle
Memória de microcódigo
Saídas
Entrada
EscrevePC
EscrevePCCond
IouD
LeMem
EscreveMem
EscreveIR
EscreveB
MemparaReg
OrigPC
OpALU
OrigBALU
OrigAALU
EscreveReg
RegDst
CtlEnd
Caminho
de dados
1
Contador de microprograma
Somador
Op[5–0]
Lógica de seleção de endereço
Campo opcode do
registrador Instruction
• Quais são as microinstruções?
150
Microprogramação
• Uma metodologia de especificação
– apropriada se houver centenas de opcodes, modos, ciclos etc.
– sinais especificados simbolicamente usando microinstruções
Rótulo
Fetch
Mem 1
LW2
Controle da
ALU
Add
Add
Add
SRC1
SRC2
PC
PC
A
4
Extshft
Extend
Controle do
registrador
Memória
Lê PC
Controle
EscrevePC
ALU
Lê
Lê ALU
Escreve MDR
SW2
Rformat1
Escreve
ALU
Código Func
A
B
Escreve ALU
BEQ1
Subt
A
JUMP1
B
ALU
Out-cond
Endereço de
jump
Seqüenciação
Seq
Dispatch 1
Dispstch 2
Seq
Fetch
Fetch
Seq
Fetch
Fetch
Fetch
• Duas implementações da mesma arquitetura possuem o mesmo microcódigo?
• O que um microassembler faria?
151
Formato da microinstrução
Nome do campo
Controle da ALU
SRC1
SRC2
Controle dos
Registradores
Valor
Add
Subt
Func code
PC
A
B
4
Extend
Extshft
Read
Sinais ativos
OpALU = 00
OpALU = 01
OpALU = 10
OrigAALU = 0
OrigAALU = 1
OrigBALU = 00
OrigBALU = 01
OrigBALU = 10
OrigBALU = 11
Write ALU
EscreveReg,
RegDst = 1,
MemparaReg = 0
EscreveReg,
RegDst = 0,
MemparaReg = 1
LeMem,
IouD = 0,
LeMem,
IouD = 1
EscreveMem,
IouD = 1
OrigPC = 00,
EscrevePC
OrigPC = 01,
EscrevePCCond
OrigPC = 10,
EscrevePC
CtlEnd = 11
CtlEnd = 00
CtlEnd = 01
CtlEnd = 10
Write MDR
Memória
Read PC
Read ALU
Write ALU
Controle de
escrita no PC
ALU
ALUOut-cond
jump address
Seqüenciamento
Seq
Fetch
Dispatch 1
Dispatch 2
Comentário
Faz com que a ALU realize uma soma.
Faz com que a ALU realize uma subtração; isso implementa a comparação para desvios.
Usa o código de função da instrução para determinar o controle da ALU.
Usa o PC como a primeira entrada da ALU.
O registrador A é a primeira entrada da ALU.
O registrador B é a segunda entrada da ALU.
Usa 4 como a segunda entrada da ALU.
Usa a saída da unidade de extensão de sinal como a segunda entrada da ALU.
Usa a saída da unidade de deslocamento em dois bits como a segunda entrada da ALU.
Lê dois registradores usando os campos rs e rt do IR como os números de registrador e colocando
os dados nos registradores A e B.
Escreve num registrador usando o campo rd do IR como o número de registrador e o conteúdo de
SaídaALU como os dados.
Escreve num registrador usando o campo rt do IR como o número de registrador e o conteúdo de
MDR como os dados.
Lê a memória usando o PC como o endereço; escreve o resultado no IR (e no MDR).
Lê a memória usando SaídaALU como o endereço; escreve o resultado no MDR.
Escreve na memória usando SaídaALU como o endereço e o conteúdo de B como os dados.
Escreve a saída da ALU no PC.
Se a saída Zero da ALU estiver ativa, escreve o PC com o conteúdo do registrador SaídaALU.
Escreve o PC com o endereço de jump da instrução.
Escolhe a próxima microinstrução seqüencialmente.
Vai para a primeira microinstrução para iniciar uma nova instrução.
Despacha usando a ROM 1.
Despacha usando a ROM 2.
152
Maximamente versus minimamente codificado
• Nenhuma codificação:
– 1 bit para cada operação de caminho de dados
– mais rápido, exige mais memória (lógica)
– usada para Vax 780 — incrível memória de 400K!
• Muita codificação:
– envia as microinstruções através da lógica para obter sinais de controle
– usa menos memória, mais lento
• Contexto histórico do CISC:
– Muita lógica para colocar em um único chip com tudo mais
– Use uma ROM (ou mesmo RAM) para armazenar o microcódigo
– É fácil acrescentar novas instruções
153
Microcódigo: negociações
• A distinção entre especificação e implementação às vezes é vaga
• Vantagens da especificação:
– Fácil de projetar e escrever
– Projeto da arquitetura e do microcódigo em paralelo
• Vantagens da implementação (ROM fora do chip)
– Fácil de mudar, já que os valores estão na memória
– Pode emular outras arquiteturas
– Pode fazer uso dos registradores internos
• Desvantagens da implementação, MAIS LENTA, agora que:
– O conteúdo é implementado no mesmo chip do processador
– Agora a ROM não é mais rápida do que a RAM
– Não há necessidade de voltar e fazer mudanças
154
Perspectiva histórica
• Nas décadas de 1960 e 1970, a microprogramação era muito importante para
implementar máquinas
• Isso levou a ISAs mais sofisticadas e ao VAX
• Na década de 1980, os processadores RISC com base em pipelining se tornaram
populares
• Também é possível canalizar as microinstruções!
• As implementações dos processadores de arquitetura IA-32 desde o 486 usam:
– “controle hardwired” para implementações mais simples (menos ciclos, controle
FSM implementado usando PLA ou lógica aleatória)
– “controle microcodificado” para instruções mais complexas (grande número de
ciclos, loja de controle central)
• A arquitetura IA-64 usa a ISA no estilo RISC e pode ser implementada sem uma
grande loja de controle central
155
Pentium 4
• O pipelining é importante (o último IA-32 sem ela foi o 80386 em 1985)
Controle
Controle
Interface
de E/S
Capítulo 7
Cache de instrução
Cache
de dados
Ponto flutuante
e multimídia
aperfeiçoados
Caminho
de dados
de inteiro
Controle
Suporte a hyperthreading
de pipelining avançado
Cache
secundário
e interface
de memória
Capítulo 6
Controle
• O pipelining é usado para as instruções simples beneficiadas pelos compiladores
“Explicado de forma simples, uma implementação de alto desempenho precisa
garantir que as instruções simples sejam executadas rapidamente e que o peso
das complexidades do conjunto de instruções penalize as instruções complexas,
usadas com menos freqüência.”
156
Pentium 4
• Em algum lugar em todo esse controle, precisamos manipular instruções
complexas
Controle
Controle
Interface
de E/S
Cache de instrução
Cache
de dados
Ponto flutuante
e multimídia
aperfeiçoados
Caminho
de dados
de inteiro
Cache
secundário
e interface
de memória
Controle
Suporte a hyperthreading
de pipelining avançado
Controle
• O processador executa microinstruções simples, de 70 bits de largura (hardwired)
• 120 linhas de controle para o caminho de dados de inteiro (400 para ponto flutuante)
• Se uma instrução exigir mais de 4 microinstruções para ser implementada, controle
da ROM de microcódigo (8000 microinstruções)
• Isso é complicado!
157
Resumo do Capítulo 5
• Se entendermos as instruções...
Podemos construir um processador simples!
• Se as instruções duram diferentes períodos de tempo, o multiciclo é melhor
• O caminho de dados é implementado usando:
– Lógica combinacional para aritmética
– Elementos de preservação de estado para se lembrar dos bits
• Controle implementado usando:
– Lógica combinacional para implementação de ciclo único
– Máquina de estado finito para implementação de multicilo
158
Capítulo 6
159
Pipelining
• Melhore o desempenho aumentando a vazão da instrução
A aceleração ideal é o número de estágios no pipeline. Conseguimos isso?
160
Pipelining
• O que o facilita
– todas as instruções possuem o mesmo tamanho
– apenas alguns formatos de instrução
– operandos de memória aparecem apenas em loads e stores
• O que o dificulta?
– riscos estruturais: suponha que tivéssemos apenas uma memória
– riscos de controle: necessidade de se preocupar com instruções ramificadas
– riscos de dados: uma instrução depende de uma instrução anterior
• Construiremos um pipeline simples e veremos esses problemas
• Falaremos sobre os processadores modernos e o que realmente o torna difícil
– tratamento de exceções
– tentar melhorar o desempenho com execução fora de ordem etc.
161
Conceito básico
IF: Busca de instruções
ID: Decodificação de EX: Execução/cálculo
de endereço
instruções/leitura do
banco de registradores
MEM: Acesso à
memória
WB: Escrita adiada
Add
Resultado
ADD
do
Somador
4
Desloc. 2
esq.
0
M
u
x
1
PC
Endereço
Instrução
Memória de
instruções
Registrador
de leitura 1
Dados da
leitura 1
Registrador
de leitura 2
Registradores
Registrador
Dados da
para escrita
leitura 2
Dados
para escrita
16
Extensão
de sinal
Zero
0
M
u
x
1
ALU Resultado da ALU
Endereço
Dados
da leitura
Memória
de dados
Dados
para escrita
1
M
u
x
0
32
• O que precisamos acrescentar para realmente dividir os caminhos de
dados em estágios?
162
Caminho de dados em pipeline
IF/ID
ID/EX
EX/MEM
MEM/WB
Add
Resul-
Add tado do
4
Somador
Desloc.
2 esq.
PC
Endereço
Memória
de instruções
Instrução
0
M
u
x
1
Registrador
Dados
de leitura 1
da leitura 1
Registrador
de leitura 2
Registradores
Dados
Registrador
da leitura 2
para escrita
Dados para
escrita
Resul-
ALU tado da
0
M
u
x
1
ALU
Endereço
Memória
de dados
Dados
da leitura
0
M
u
x
1
Dados
para escrita
16
Extensão
de sinal
32
Você consegue encontrar um problema mesmo se não houver dependências?
Que instruções podemos executar para manifestar o problema?
163
Caminho de dados corrigido
IF/ID
ID/EX
MEM/WB
EX/MEM
Add
Resultado
Add do
Somador
4
Desloc.
2 esq.
PC
Endereço
Memória de
instruções
Instrução
0
M
u
x
1
Registrador
de leitura 1
Dados da
leitura 1
Registrador
de leitura 2
Registradores
Dados da
Registrador
leitura 2
para escrita
0
M
u
x
1
Dados
para escrita
Zero
ALU Resultado da ALU
Dados
da leitura
Endereço
Memória
de dados
0
M
u
x
1
Dados
para escrita
16
Extensão
de sinal
32
164
Representando pipelines graficamente
Ordem de
execução do
programa
(em instruções)
lw $1, 100($0)
lw $2, 200($0)
lw $3, 300($0)
Tempo (em ciclos de
clock)
CC 1
CC 2
IM
Reg
IM
CC 3
ALU
Reg
IM
CC 4
CC 5
DM
Reg
ALU
DM
Reg
ALU
DM
Reg
CC 6
CC7
Reg
• Pode ajudar a responder questões como estas:
– quantos ciclos leva para executar esse código?
– qual é a ALU sendo executada durante o ciclo 4?
– use essa representação para ajudar a entender os caminhos de dados
165
Controle do pipeline
OrigPC
ID/EX
IF/ID
MEM/WB
EX/MEM
Add
Resultado
Add do
Somador
4
Desloc.
2 esq.
EscreveReg
PC
Endereço
Instrução
0
M
u
x
1
Branch
Memória de
instruções
Registrador
de leitura 1
Dados da
leitura 1
Registrador
de leitura 2
Registradores
Dados da
Registrador
leitura 2
para escrita
EscreveMem
OrigALU
0
M
u
x
1
Dados
da leitura
Zero
ALU Resultado da ALU
MemparaReg
Dados
da leitura
Endereço
Memória
de dados
1
M
u
x
0
Dados
para escrita
Instrução
(15-0)
Instrução
(20-16)
Instrução
(15-11)
16
Extensão 32
de sinal
6
0
M
u
x
1
Controle
da ALU
LeMem
OpALU
RegDst
166
Controle de pipeline
• Temos 5 estágios. O que precisa ser controlado em cada estágio?
– Busca da instrução e incremento do PC
– Decodificação da instrução / Busca do registrador
– Execução
– Estágio de memória
– Escrita adiada
• Como o controle seria manipulado em uma fábrica de automóveis?
– um espetacular centro de controle dizendo a todo mundo o que fazer?
– deveríamos usar uma máquina de estado finito?
167
Controle do pipeline
• Transfira os sinais de componente exatamente como os dados
Linhas de controle do estágio de
cálculo de endereço/execução
Linhas de controle do estágio
de acesso à memória
Linhas de controle
do estágio de
escrita do resultado
Instrução
RegDst
OpALU1
OpALU0
OrigALU
Branch
LeMem
Escreve
Mem
Escreve
Reg
Mem para
Reg
Formato R
1
1
0
0
0
0
0
1
0
lw
0
0
0
1
0
1
0
1
1
sw
X
0
0
1
0
0
1
0
X
beq
X
0
1
0
1
0
0
0
X
168
Caminho de dados com controle
OrigPC
ID/EX
Controle
IF/ID
WB
EX/MEM
M
WB
EX
M
MEM/WB
WB
Add
Resultado
Add do
Somador
4
Memória de
instruções
Registrador
de leitura 1
Dados da
leitura 1
Registrador
de leitura 2
Registradores
Dados da
Registrador
leitura 2
para escrita
Zero
ALU Resultado da ALU
0
M
u
x
1
Dados
da leitura
MemparaReg
Endereço
Branch
OrigALU
EscreveMem
EscreveReg
PC
Instrução
0
M
u
x
1
Desloc.
2 esq.
Dados
da leitura
Endereço
Memória
de dados
0
M
u
x
1
Dados
para escrita
Instrução
(15-0)
16
Extensão
de sinal
32
6
Controle
ALU
Instrução
(20-16)
Instrução
(15-11)
LeMem
OpALU
0
M
u
x
1
RegDst
169
Dependências
• Problemas com o início da próxima instrução antes do término da primeira
– dependências que “voltam no tempo” são hazards de dados
Tempo (em ciclos de clock)
CC 1
CC 2
Valor do
registrador $2: 10
10
CC 3
CC 4
CC 5
10
10
10/–20
DM
Reg
CC 6
–20
CC 7
CC 8
–20
–20
CC 9
–20
Ordem de
execução
do programa
(em instruções)
sub $2, $1, $3
and $12, $2, $5
or $13, $6, $2
add $14, $2, $2
sw $15, 100($2)
IM
Reg
IM
Reg
IM
DM
Reg
IM
Reg
DM
Reg
IM
Reg
DM
Reg
Reg
DM
Reg
170
Solução de software
• Faça o compilador garantir a inexistência de hazards
• Onde inserimos os “nops”?
sub
and
or
add
sw
$2, $1, $3
$12, $2, $5
$13, $6, $2
$14, $2, $2
$15, 100($2)
• Problema: isso realmente nos torna lentos!
171
Forwarding
• Use resultados temporários, não espere que eles sejam escritos
– forwarding do arquivo de registrador para manipular read/write para o mesmo
registrador
– forwarding da ALU
Tempo (em ciclos de clock)
CC 1
CC 2
CC 3
Valor do registrador $2:
10
10
10
Valor de EX/MEM:
X
X
X
Valor de MEM/WB:
X
X
X
CC 4
CC 5
CC 6
CC 7
CC 8
CC 9
10
–20
X
10/–20
X
–20
–20
X
X
–20
X
X
–20
X
X
–20
X
X
DM
Reg
Ordem de
execução
do programa
(em instruções)
sub $2 $1, $3
and $12, $2 $5
or $13, $6, $2
add $14, $2 $2
sw $15, 100($2)
E se este $2 fosse $13?
IM
Reg
IM
Reg
IM
DM
Reg
IM
Reg
DM
Reg
IM
Reg
DM
Reg
Reg
DM
Reg
172
Forwarding
• A idéia principal (alguns detalhes não mostrados)
ID/EX
EX/MEM
MEM/WB
M
u
x
ForwardA
Registradores
ALU
M
u
x
Memória
de dados
M
u
x
ForwardB
Rs
Rt
Rt
Rd
EX/MEM.RegistradorRd
M
u
x
Unidade de
forwarding
MEM/WB.RegistradorRd
173
Forwarding nem sempre é possível
• Load word ainda pode causar um hazard:
– uma instrução tenta ler um registrador seguindo uma instrução load que escreve
no mesmo registrador.
Tempo (em ciclos de clock)
CC 1
CC 2
CC 3
CC 4
CC 5
DM
Reg
CC 6
CC 7
CC 8
CC 9
Ordem de
execução
do programa
(em instruções)
lw $2, 20($1)
and $4, $2, $5
or $8, $2, $6
add $9, $4, $2
slt $1, $6, $7
IM
Reg
IM
Reg
IM
DM
Reg
IM
Reg
DM
Reg
IM
Reg
DM
Reg
Reg
DM
Reg
Portanto, precisamos de uma unidade de detecção de hazard para “deter” (stall) a
instrução load
174
Stalls
• Podemos ocasionar um stall no pipeline mantendo uma instrução no mesmo
estágio
Tempo (em ciclos de clock)
CC 1
CC 2
CC 3
CC 4
CC 5
DM
Reg
CC 6
CC 7
CC 8
CC 9
CC 10
Ordem de
execução
do programa
(em instruções)
lw $2, 20($1)
IM
Reg
bolha
and torna-se nop
add $4, $2, $5
or $8, $2, $6
add $9, $4, $2
IM
Reg
IM
DM
Reg
IM
Reg
DM
DM
Reg
IM
Reg
Reg
Reg
DM
Reg
175
Unidade de detecção de hazard
• Ocasione um stall deixando que uma instrução que não escreverá nada prossiga
Unidade de
detecção
de hazards
EscreveIF/ID
ID/EX.MemRead
ID/EX
M
u
x
EscrevePC
Controle
IF/ID
0
WB
EX/MEM
M
WB
MEM/WB
EX
M
WB
PC
Memória de
instruções
Instrução
M
u
x
Registradores
ALU
M
u
x
Memória
de dados
M
u
x
IF/ID.RegistradorRs
IF/ID.RegistradorRt
IF/ID.RegistradorRt
Rt
IF/ID.RegistradorRd
Rd
M
u
x
ID/EX.RegistradorRt
Rs
Rt
Unidade de
forwarding
176
Hazards de desvio
• Quando decidimos desviar, outras instruções estão no pipeline!
Tempo (em ciclos de clock)
CC 1
CC 2
CC 3
CC 4
CC 5
DM
Reg
CC 6
CC 7
CC 8
CC 9
Ordem de
execução
do programa
(em instruções)
40 beq $1, $3, 28
44 and $12, $2, $5
48 or $13, $6, $2
IM
Reg
IM
Reg
IM
DM
Reg
52 add $14, $2, $2
72 lw $4, 50($7)
IM
Reg
DM
Reg
IM
Reg
DM
Reg
Reg
DM
Reg
• Estamos prevendo “desvio não tomado”
– precisamos acrescentar hardware para descartar instruções se
estivermos errados
177
Descartando instruções
IF.Flush
Unidade de
detecção
de hazards
ID/EX
WB
Controle
0
IF/ID
M
u
x
+
EX/MEM
M
WB
EX/MEM
EX
M
WB
+
4
M
u
x
Desloc.
2 esq.
Registradores
PC
=
M
u
x
Memória de
instruções
ALU
Memória
de dados
M
u
x
M
u
x
Extensão de
sinal
M
u
x
Unidade de
forwarding
Nota: também movemos a decisão de desvio para o estágio ID
178
Desvios
• Se o desvio for tomado, temos uma penalidade de um ciclo
• Para nosso projeto simples, isso é razoável
• Com pipelines mais profundos, a penalidade aumenta e a previsão de desvio
estático diminui drasticamente o desempenho
• Solução: previsão de desvio dinâmico
Tomado
Não tomado
Previsão tomada
Previsão tomada
Tomado
Tomado
Não tomado
Não tomado
Previsão não tomada
Previsão não tomada
Tomado
Não tomada
Um esquema de previsão de dois bits
179
Previsão de desvio
• Técnicas sofisticadas:
– Um “buffer de destino de desvio” nos ajuda a consultar o destino.
– Correlacionar previsores que baseiem a previsão no comportamento global e nos
desvios recentemente executados (por exemplo, previsão para uma instrução de
desvio específica com base no que ocorreu nos desvios anteriores).
– Previsores de competição que usam diferentes tipos de estratégias de previsão e
controlam qual delas está sendo melhor executada.
– Um “espaço de retardo de desvio” que o compilador tenta preencher com uma
instrução útil (forma a parte do retardo de um ciclo da ISA).
• Previsão de desvio é especialmente importante porque permite que outras técnicas
de pipelining mais avançadas sejam eficazes!
• Os processadores modernos prevêem corretamente 95% das vezes!
180
Melhorando o desempenho
• Tente evitar stalls! Por exemplo, reordene estas instruções:
lw
lw
sw
sw
$t0,
$t2,
$t2,
$t0,
0($t1)
4($t1)
0($t1)
4($t1)
• Programação de pipeline dinâmica
– O hardware escolhe que instruções executar em seguida
– Executará instruções fora de ordem (por exemplo, não espera que uma
dependência seja resolvida, e sim continua executando!)
– Especula sobre desvios e mantém o pipeline cheio (pode precisar reverter se a
previsão for incorreta)
• Tentando explorar o paralelismo em nível de instrução
181
Pipelining avançado
• Aumenta a profundidade do pipeline
• Inicia mais de uma instrução em cada ciclo (despacho múltiplo)
• Desdobramento de loop para expor mais ILP (melhor programação)
• Processadores “superescalares”
– DEC Alpha 21264: pipeline de 9 estágios, despacho de 6 instruções
• Todos os processadores modernos são superescalares e despacham instruções
múltiplas normalmente com algumas limitações (por exemplo, diferentes “pipes”)
• VLIW: Very Long Instruction Word (palavra de instrução muito longa) – despacho
múltiplo estático (se baseia mais na tecnologia do compilador)
• Essa aula forneceu o conhecimento de que você precisa para aprender mais!
182
Resumo do Capítulo 6
• O pipelining não melhora a latência, mas melhora a vazão
Despacho múltiplo
com pipeline
(Seção 6.9)
Menor
Ciclo único
(Seção 5.4)
Menos
Instruções por clock (IPC = 1/CPI)
Mais
Despacho múltiplo
com pipeline profundo
(Seção 6.10)
Especializado
Pipeline
Hardware
Multiciclo
(Seção 5.5)
Despacho múltiplo
com pipeline
profundo (Seção 6.10)
Compartilhado
Velocidade de clock
Maior
Pipeline
profundo
Despacho múltiplo
com pipeline
(Seção 6.9)
Ciclo único
(Seção 5.4)
Pipeline
Pipeline
profundo
Multiciclo
(Seção 5.5)
1
Várias
Latência no uso das instruções
183
Capítulo 7
184
Memórias: Revisão
• SRAM:
– o valor é armazenado em um par de portões invertidos
– muito rápida, mas ocupa mais espaço do que a DRAM (4 a 6 transistores)
• DRAM:
– o valor é armazenado como uma carga no capacitor (precisa ser atualizada)
– muito pequena, porém, mais lenta do que a SRAM (fator de 5 a 10)
Linha de word
A
B
A
B
Transistor de passagem
Capacitor
Linha de bit
185
Explorando a hierarquia da memória
• Os usuários querem memórias grandes e rápidas!
Os tempos de acesso da SRAM são 0,5 a 5 ns ao custo de US$ 4000 a
US$ 10000 por GB.
Os tempos de acesso são 50 a 70 ns ao custo de US$ 100 a US$ 200
por GB.
Os tempos de acesso a disco são 5 a 20 milhões de ns ao custo de
US$ 0,50 a US$ 2 por GB.
2004
• Tente oferecer isso a eles
– Construa uma hierarquia de memória
CPU
Nível 1
Níveis na hierarquia
de memória
Aumentando a distância
da CPU no tempo
de acesso
Nível 2
…
Nível n
Tamanho da memória em cada nível
186
Localidade
• Um princípio que faz da hierarquia de memória uma boa idéia
• Se um item for referenciado,
localidade temporal: tenderá a ser referenciada novamente em breve
localidade espacial: itens próximos tenderão a ser referenciados em breve
Por que o código possui localidade?
• Nosso foco inicial: dois níveis (superior, inferior)
– bloco: unidade mínima de dados
– acerto: os dados solicitados estão no nível superior
– falha: os dados solicitados não estão no nível superior
187
Cache
• Dois problemas:
– Como sabemos se um item de dados está no cache?
– Se estiver, como encontrá-lo?
• Nosso primeiro exemplo:
– O tamanho do bloco é uma word de dados
– “diretamente mapeado”
Para cada item de dados no nível inferior, existe exatamente
um local no caminho onde ele pode estar.
Por exemplo, muitos itens no nível inferior compartilham locais
no nível superior
188
Cache diretamente mapeado
• Mapeamento: O endereço é o módulo do número de blocos no cache
000
001
010
011
100
101
110
111
Cache
00001
00101
01001
01101
10001
10101
11001
11101
Memória
189
Cache diretamente mapeado
• Para MIPS:
Endereço (mostrando as posições dos bits)
31 30
13 12 11
2 10
Offset
do byte
Acerto
20
10
Tag
Dados
Índice
x
Índice
x
0
1
2
Validade
alid
Tag
Dados
1021
1022
1023
20
32
=
De que tipo de localidade estamos nos valendo?
190
Cache diretamente mapeado
• Tirando vantagem da localidade espacial:
Endereço (mostrando as posições dos bits)
31
14 13
65
210
18
Acerto
8
4
Tag
Offset
do byte
Dados
Offset do bloco
Índice
18 bits
V
512 bits
Tag
Dados
256
Entradas
16
32
32
32
=
Mux
32
191
Acertos versus falhas
• Acertos de leitura
– é isso o que queremos!
• Falhas de leitura
– ocasione um stall na CPU, busque o bloco da memória, distribua para o cache,
reinicie
• Acertos de escrita:
– podem substituir os dados no cache e na memória (escrita direta)
– escrevem os dados apenas no cache (escrita adiada no cache posteriormente)
• Falhas de escrita:
– lêem o bloco inteiro para o cache, depois escrevem a word
192
Problemas de hardware
• Facilite a leitura de múltiplas words usando bancos de memória
CPU
CPU
CPU
Multiplexador
Cache
Cache
Cache
Barramento
Barramento
Barramento
Memória
Banco de Banco de Banco de Banco de
memória 0 memória 1 memória 2 memória 3
b. Organização de memória larga
c. Organização de memória intercalada
Memória
a. Organização de memória
com uma word de largura
• Isso pode ficar muito mais complicado...
193
Desempenho
• Aumentar os tamanhos de bloco tende a reduzir a taxa de falhas:
40%
35%
Taxa de falhas
30%
25%
20%
15%
10%
5%
0%
4
16
64
Tamanho de bloco (bytes)
256
1 KB
8 KB
16 KB
64 KB
256 KB
• Use caches divididos porque existe mais localidade espacial no código:
Programa
gcc
spice
Tamanho de bloco
em words
Taxa de falhas
de instrução
Taxa de falha
de dados
Taxa de falhas
combinadas efetiva
1
6,1%
2,1%
5,4%
4
2,0%
1,7%
1,9%
1
1,2
1,3
1,2%
4
0,3
0,6
0,4%
194
Desempenho
• Modelo simplificado:
Tempo de execução = (ciclos de execução + ciclos de stall) × tempo de ciclo
Ciclos de stall = número de instruções × taxa de falhas × penalidade de falha
• Duas maneiras de melhorar o desempenho:
– reduzir a taxa de falhas
– reduzir a penalidade de falhas
O que acontece se aumentarmos o tamanho de bloco?
195
Reduzindo a taxa de falhas com associatividade
Associativa por conjunto de uma via
(diretamente mapeada)
Bloco
0
Tag Dados
Associativa por conjunto de duas vias
1
2
3
4
5
6
Conjunto Tag Dados Tag Dados
0
1
2
3
7
Associativa por conjunto de quatro vias
Conjunto Tag Dados Tag Dados Tag Dados Tag Dados
0
1
Associativa por conjunto de oito vias (totalmente associativa)
Tag Dados Tag Dados Tag Dados Tag Dados Tag Dados Tag Dados Tag Dados Tag Dados
Comparado com o mapeamento direto, forneça uma série de referências que:
– resulte em uma taxa de falhas usando um cache associativo de duas vias
– resulte em uma taxa de falhas maior usando um cache associativo de duas vias
considerando que usamos a estratégia de substituição “usada menos recentemente”
196
Uma implementação
31 30
12 11 10 9 8
22
Índice
0
1
2
V Tag
Dados
3210
8
V Tag
Dados
V Tag
Dados
V Tag
Dados
253
254
255
22
=
=
=
32
=
Multiplexador 4 para 1
Acerto
Dados
197
Desempenho
15%
1 KB
Taxa de falhas
12%
2 KB
9%
4 KB
6%
8 KB
16 KB
32 KB
3%
64 KB
128 KB
0
Uma via
Duas vias
Quatro vias
Oito vias
Associatividade
198
Reduzindo a penalidade de falhas com caches multinível
• Acrescente um segundo cache de nível:
– normalmente o cache primário está no mesmo chip do processador
– use SRAMs para acrescentar outro cache acima da memória principal (DRAM)
– a penalidade de falhas diminui se os dados estiverem no cache de segundo nível
• Exemplo:
– CPI de 1,0 em uma máquina de 5 GHz com uma taxa de falhas de 5%, acesso a
DRAM de 100 ns
– Acrescentar cache de segundo nível com tempo de acesso de 5 ns diminui a taxa
de falhas para 0,5%
• Usando caches multinível:
– tente otimizar o tempo de acerto no cache de primeiro nível
– tente otimizar a taxa de falhas no cache de segundo nível
199
Complexidades de cache
– Nem sempre é fácil entender as implicações dos caches:
1200
2000
1600
Ciclos de clock/item
Instruções/item
Radix Sort
Radix Sort
1000
800
600
400
200
Quicksort
0
1200
800
400
Quicksort
0
4
8
16
32
64
128 256 512 1024 2048 4096
4
8
16
32
64
128 256 512 1024 2048 4096
Tamanho (K itens a ordenar)
Tamanho (K itens a ordenar)
Comportamento teórico de Radix Sort
versus Quicksort
Comportamento observado de Radix Sort
versus Quicksort
200
Complexidades de cache
• Veja o porquê:
5
Radix Sort
Falhas de cache/item
4
3
2
1
Quicksort
0
4
8
16
32
64
128 256 512 1024 2048 4096
Tamanho (K itens a ordenar)
• O desempenho do sistema de memória normalmente é um fator crítico
– caches multinível, processadores em pipeline, dificultam a previsão
de resultados
– otimizações de compilador para aumentar a localidade algumas vezes
prejudicam o ILP
• Difícil prever o melhor algoritmo: é preciso dados experimentais
201
Memória virtual
• A memória principal pode atuar como um cache para o armazenamento secundário
(disco)
Endereços físicos
Endereços virtuais
Tradução de endereço
Endereços do disco
• Vantagens:
– ilusão de ter mais memória física
– remanejamento do programa
– proteção
202
Páginas: blocos de memória virtual
• Falhas de página: Os dados não estão na memória; recupere-os do disco
– enorme penalidade de falha; portanto, as páginas devem ser bastante grandes
(por exemplo, 4KB)
– é importante reduzir as falhas de página (LRU vale a pena)
– pode manipular as falhas no software em vez de no hardware
– como a escrita direta é muito onerosa, usamos escrita adiada
Endereço virtual
31 30 29 28 27
15 14 13 12 11 10 9 8
Número de página virtual
3210
Offset de página
Tradução
29 28 27
15 14 13 12 11 10 9 8
Número de página física
3210
Offset de página
Endereço físico
203
Tabelas de página
Número de página
virtual
Tabela de páginas
Validade
1
1
1
1
0
1
1
0
1
1
0
1
Página física ou
endereço de disco
Memória física
Armazenamento em disco
204
Tabelas de página
Registrador de tabela de páginas
Endereço virtual
31 30 29 28 27
15 14 13 12 11 10 9 8
Número de página virtual
Offset de página
12
20
Validade
3 2 1 0
Número de página física
Tabela de páginas
18
Se for 0, então a página
não está presente na memória
29 28 27
15 14 13 12 11 10 9 8
Número de página física
3 2 1 0
Offset de página
Endereço físico
205
Tornando a tradução de endereço rápida
• Um cache para traduções de endereço: translation-lookaside buffer (TLB)
Número de
página virtual
o
çã cia
de ifica rên
a
e
lid od ef
Va M R
1
1
1
1
0
1
TLB
Tag
Endereço de
página física
0 1
1 1
1 1
0 1
0 0
0 1
Memória física
Tabela de páginas
ão ia
e icaç ênc
d
f
r Endereços de página
a i
lid od efe
física ou de disco
Va M R
1
1
1
1
0
1
1
0
1
1
0
1
Valores típicos:
1
0
0
0
0
0
0
0
1
1
0
1
1
0
0
1
0
1
1
0
1
1
0
1
Armazenamento em disco
16-512 entradas,
taxa de falhas: 0,01% – 1%
penalidade de falhas: 10-100 ciclos
206
TLBs e caches
Endereço virtual
Acesso à TLB
Exceção de
falha de TLB
Não
Sim
Acerto de
TLB?
Endereço físico
Não
Sim
Escrita?
Tente ler os dados
da cache
Stall de falha de
cache durante
leitura do bloco
Não
Sim
Não
Bit de acesso
de escrita
ligado?
Exceção de proteção
de escrita
Sim
Tente escrever os
dados na cache
Acerto de cache?
Envie os dados
para a CPU
Stall de falha de
cache durante
leitura do bloco
Não
Sim
Acerto de cache?
Escreva os dados na cache,
atualize o bit de modificação
e coloque os dados e o
endereço no buffer de escrita
207
TLBs e caches
Endereço virtual
31 30 29
14 13 12 11 10 9
Número de página virtual
o
çã
TLB hit
Offset de página
12
20
e a
ad ific
id od
l
Va M
TLB
3 2 1 0
Número de página física
Tag
=
=
=
=
=
=
20
Offset de página
Número de página física
Endereço físico
Offset
Tag de endereço físico
Índice de cache
de bloco
18
8
4
Offset
de byte
2
8
12
Validade
Dados
Tag
Cache
=
Acerto
de cache
32
Dados
208
Sistemas modernos
Característica
Intel Pentium P4
Endereço virtual
Endereço físico
Tamanho de página
Organização de TLB
32 bits
36 bits
4KB, 2/4MB
1 TLB para instruções e 1 TLB para dados
Ambas são associativas por conjunto de
quatro vias
Ambas usam substituição pseudo-LRU
Ambas têm 128 entradas
Falhas de TLB tratadas por hardware
AMD Opteron
48 bits
40 bits
4KB, 2/4MB
2 TLBs para instruções e 2 TLBs para dados
Ambas as TLBs L1 são totalmente associativas, substituição LRU
Ambas as TLBs L2 são associativas por conjunto de quatro vias, LRU com round-robin
Ambas as TLBs L1 têm 40 entradas
Ambas as TLBs L2 têm 512 entradas
Falhas de TLB tratadas por hardware
FIGURA 7.34 Tradução de endereços e hardware TLB para o Intel Pentium P4 e o AMD Opteron. O tamanho de word define o tamanho máximo do endereço virtual, mas um processador não
precisa usar todos esses bits. O tamanho de endereço físico é independente do tamanho de word. O P4 tem uma TLB para instruções e uma TLB idêntica separada para dados, enquanto o Opteron
possui uma TLB L1 e uma TLB L2 para instruções e TLBs L1 e L2 idênticas para dados. Os dois processadores fornecem suporte para páginas grandes, que são usadas para coisas como o sistema
operacional ou para mapear um buffer de quadro. O esquema de página grande evita o uso de um grande número de entradas para mapear um único objeto que está sempre presente.
Característica
Organização de cache L1
Tamanho de cache L1
Associatividade de cache L1
Substituição L1
Tamanho de bloco L1
Política de escrita L1
Organização de cache L2
Tamanho de cache L2
Associatividade de cache L2
Substituição L2
Tamanho de bloco L2
Política de escrita L2
Intel Pentium P4
Caches de instruções e de dados divididos
8KB para dados, cache de trace de 96KB para
instruções RISC (operações RISC de 12K)
Associativa por conjunto de 4 vias
Substituição LRU aproximada
64 bytes
Escrita direta
Unificada (instruções e dados)
512KB
Associativa por conjunto de 8 vias
Substituição LRU aproximada
128 bytes
Escrita direta
AMD Opteron
Caches de instruções e de dados divididos
64KB cada para instruções/dados
Associativa por conjunto de 2 vias
Substituição LRU
64 bytes
Escrita adiada
Unificada (instruções e dados)
1024KB (1MB)
Associativa por conjunto de 16 vias
Substituição LRU aproximada
64 bytes
Escrita adiada
FIGURA 7.35 Caches de primeiro nível e segundo nível do Intel Pentium P4 e do AMD Opteron. As caches primárias do P4 são fisicamente indexadas e rotuladas; para uma
descrição das alternativas, veja o Detalhe na página 527.
209
Sistemas modernos
• As coisas estão ficando complicadas!
MPU
AMD Opteron
Conjunto de instruções
Aplicação pretendida
2
Tamanho do die (mm )
(2004)
Instruções despachadas
por clock
Velocidade de clock (2004)
Cache de instruções
Latência (clocks)
Cache de dados
Latência (clocks)
Entradas de TLB (TLB
I/D/L2)
Tamanho de página
mínimo
Cache L2 on-chip
Cache L2 off-chip
Tamanho de bloco (L1/L2,
bytes)
Intrinsity FastMATH
Intel Pentium 4
Intel PXA250
ARM
Embutido de baixo
consumo
Sun UltraSPARC IV
IA-32, AMD64
Servidor
MIPS32
Embutido
IA-32
Desktop
SPARC v9
Servidor
193
122
217
3
2
3 operações RISC
1
4×2
2,0GHz
64KB, associativa por
conjunto de 2 vias
3
64KB, associativa por
conjunto de 2 vias
3
40/40/512/512
2,0GHz
16KB, diretamente
mapeada
4
16KB, associativa por
conjunto de 1 via
3
16
3,2GHz
cache de trace com 12000
operações RISC (~96 KB)
4
8KB, associativa por
conjunto de 4 vias
2
128/128
0,4GHz
32KB, associativa por
conjunto de 32 vias
1
32KB, associativa por
conjunto de 32 vias
1
32/32
1,2GHz
32KB, associativa por
conjunto de 4 vias
2
64KB, associativa por
conjunto de 4 vias
2
128/512
4KB
4KB
4KB
1KB
8KB
1024KB,
associativa por
conjunto de 16 vias
—
1024KB,
associativa por
conjunto de 4 vias
—
512KB,
associativa por conjunto
de 8 vias
—
—
—
—
64
64
64/128
32
16MB, associativa por
conjunto de 2 vias
32
356
FIGURA 7.36 Microprocessadores para desktops, embutidos e para servidores em 2004. De uma perspectiva da hierarquia de memória, a
principal diferença entre as categorias é a cache L2. Não há uma cache L2 para o embutido de baixo consumo, uma grande L2 on-chip para o
embutido e para o desktop e uma off-chip de 16 MB para o servidor. As velocidades de clock de processador também variam: 0,4 GHz para embutido
de baixo consumo, 1 GHz ou mais alta para o restante. Observe que o UltraSPARC IV possui dois processadores no chip.
210
Alguns problemas
• As velocidades do processador continuam a aumentar muito rápido
– muito mais rápido do que os tempos de acesso à DRAM ou ao disco
100.000
10.000
1.000
Desempenho
CPU
100
10
Memória
19
80
19
81
19
82
19
83
19
84
19
85
19
86
19
87
19
88
19
89
19
90
19
91
19
92
19
93
19
94
19
95
19
96
19
97
19
98
19
99
20
00
20
01
20
02
20
03
20
04
20
05
1
Ano
• Desafio de projeto: lidar com essa crescente disparidade
– Prefetching? Caches de terceiro nível e mais? Projeto de memória?
211
Capítulos 8 e 9
(abordagem parcial)
212
Interface entre processadores e periféricos
• O projeto de E/S é afetado por muitos fatores (expansibilidade, resiliência)
• Desempenho:
– latência de acesso
– vazão
– conexão entre os dispositivos e o sistema
– a hierarquia de memória
– o sistema operacional
• Uma variedade de usuários diferentes (por exemplo, bancos, supercomputadores,
engenheiros)
Interrupções
Processador
Cache
Barramento de E/S de memória
Memória
principal
Controlador
de E/S
Disco
Disco
Controlador
de E/S
Controlador
de E/S
Saída
gráfica
Rede
213
E/S
• Importante, mas negligenciada
“As dificuldades em avaliar e projetar sistemas de E/S freqüentemente têm
relegado a E/S à condição de segunda classe”
“os cursos em todos os aspectos da computação, da programação à arquitetura
de computador, normalmente ignoram a E/S ou a abordam superficialmente”
“os livros-texto deixam o assunto para o final, o que pode fazer com que alunos e
instrutores o pulem”
• CULPADOS!
– não veremos a E/S em muito detalhe aqui.
– não deixe de ler o Capítulo 8 inteiro.
– você provavelmente assistirá a uma aula de rede!
214
Dispositivos de E/S
• Dispositivos muito diversos
– comportamento (por exemplo, entrada versus saída)
– parceiro (quem está no outro lado?)
– velocidade de dados
Interrupções
Processador
Cache
Barramento de E/S de memória
Memória
principal
Controlador
de E/S
Disco
Disco
Controlador
de E/S
Controlador
de E/S
Saída
gráfica
Rede
FIGURA 8.2 Uma coleção típica de dispositivos de E/S. As conexões entre os dispositivos de
E/S, processador e memória normalmente são chamadas de barramentos. A comunicação entre
os dispositivos e o processador utiliza interrupções e protocolos no barramento, conforme veremos
neste capítulo. A Figura 8.11, na página 585, mostra a organização para um PC desktop.
215
Exemplo de E/S: Unidades de disco
Pratos
Trilhas
Prato
Setores
Trilha
• Para acessar dados:
– busca: posiciona a cabeça sobre a trilha correta (3 a 14 ms em média)
– latência rotacional: espera pelo setor desejado (0,5 rpm)
– transferência: recupera os dados (um ou mais setores; 30 a 80 MB/seg)
216
Exemplo de E/S: Barramentos
• Link de comunicação compartilhado (um ou mais fios)
• Projeto difícil:
– pode ser gargalo
– extensão do barramento
– número de dispositivos
– negociações (buffers para largura de banda maior aumenta a latência)
– suporte para muitos dispositivos diferentes
– custo
• Tipos de barramento:
– processador-memória (curto, projeto personalizado e de alta velocidade)
– backplane (alta velocidade, freqüentemente padronizado; por exemplo, PCI)
– E/S (longo, diferentes dispositivos; por exemplo, USB, Firewire)
• Síncrono versus assíncrono
– usam um clock e um protocolo síncronos, rápidos e pequenos, mas cada
dispositivo precisa operar na mesma velocidade e a variação de clock exige que o
barramento seja curto
– não usam um clock, mas usam hanshaking
217
Padrões de barramento de E/S
• Hoje temos dois padrões de barramento dominantes:
Características
Tipo de barramento
Largura básica do barramento de dados (sinais)
Clock
Largura de banda máxima teórica
Facilidade de conexão
Número máximo de dispositivos
Tamanho máximo do barramento (fio de cobre)
Nome do padrão
Firewire (1394)
E/S
4
assíncrono
50MB/seg (Firewire 400) ou 100MB/seg
(Firewire 800)
sim
63
4,5 metros
IEEE 1394, 1394b
USB 2.0
E/S
2
assíncrono
0,2MB/seg (baixa velocidade), 1,5MB/seg (velocidade
plena) ou 60MB/seg (velocidade alta)
sim
127
5 metros
USB Implementors Forum
FIGURA 8.9 Principais características dos dois padrões de barramento de E/S dominantes.
218
Outros aspectos importantes
• Arbitração de barramento:
– arbitração de margarida (não muito justa)
– arbitração centralizada (exige um árbitro), por exemplo, PCI
– detecção de colisão, por exemplo, Ethernet
• Sistema operacional:
– polling
– interrupções
– acesso direto à memória (DMA)
• Técnicas de análise de desempenho:
– teoria do enfileiramento
– simulação
– análise; por exemplo, encontrar o link mais fraco (veja “Projeto de sistema de
E/S”)
• Muitos desenvolvimentos recentes
219
Pentium 4
• Opções de E/S
Chip set 875P
Segmento de destino
PC de
desempenho
Barramento do sistema (64 bits)
800/533MHz
Hub controlador de memória (“bridge norte”)
DDR 400
(3,2GB/seg)
DIMMs da
memória
principal
DDR 400
(3,2GB/seg)
42,5 x 42,5mm,
1005
37,5 x 37,5mm,
760
Processador
Pentium 4
Velocidade da memória
DDR 400/
333/266 SDRAM
DDR 266/200,
PC133 SDRAM
Barramento do sistema (800MHz, 604GB/seg)
AGP 8X
Hub
Saída
(2,1GB/seg)
controlador
gráfica
de memória
CSA
(bridge norte)
(0,266GB/seg)
Ethernet 1 Gbit
82875P
Barramentos de memória, larguras
Número de DIMMs, suporte a Mbit da
DRAM
Capacidade máxima da memória
Correção de erro da memória disponível?
Barramento gráfico AGP, velocidade
Controlador gráfico
2x72
4, 128/256/
512Mbits
4GB
sim
sim, 8X ou 4X
Externo
1x64
2, 128/256/
512Mbits
2GB
não
não
Interno
(Extreme Graphics)
não
266MHz
(266MB/seg) ATA paralelo
(100MB/seg)
ATA serial
(150MB/seg)
ATA paralelo
(100MB/seg)
Disco
Estéreo
(som
surround)
AC/97
(1MB/seg)
USB 2.0
(60MB/seg)
...
PC de menor
custo
400MHz
Tamanho do pacote, pinos
ATA serial
(150MB/seg)
Disco
Chip set 845GL
Hub
controlador
de E/S
(bridge sul)
82801EB
CD/DVD
Fita
(20 MB/seg)
Ethernet 10/100 Mbit
Barramento PC
(132MB/seg)
Interface CSA Gigabit Ethernet
sim
Velocidade de interface da bridge sul (8 bits)
266MHz
Hub controlador de E/S (“bridge sul”)
Tamanho do pacote, pinos
Barramento PCI: largura, velocidade,
masters
Controlador MAC Ethernet, interface
Portas USB 2.0, controladoras
Portas ATA 100
Controlador ATA serial 150, portas
Controlador RAID 0
Controlador de áudio AC-97, interface
Gerenciamento de E/S
31 x 31mm, 460
32 bits, 33MHz,
6 masters
100/10Mbits
8, 4
2
sim, 2
sim
sim
SMbus 2.0, GPIO
31 x 31mm, 421
32 bits, 33MHz,
6 masters
100/10Mbits
6, 3
2
não
não
sim
SMbus 2.0, GPIO
FIGURA 8.12 Dois chip sets de E/S Pentium 4 da Intel. A bridge norte 845GL utiliza muito menos
pinos do que o 875, com apenas um barramento de memória e omitindo o barramento AGP e a interface Gigabit Ethernet. Observe que a natureza serial do USB e da ATA serial significa que mais duas
portas USB e mais duas portas ATA serial precisam de apenas mais 39 pinos na bridge sul do chip set
875 versus o chip set 845GL.
220
Falácias e armadilhas
• Falácia: O tempo médio para falha (MTTF) indicado para discos é 1.200.000 horas ou
quase 140 anos, de modo que os discos praticamente nunca falham.
• Falácia: O armazenamento de disco magnético está com seus dias contados; será
substituído.
• Falácia: Um barramento de 100 MB/seg pode transferir 100 MB por segundo.
• Armadilha: Mover funções da CPU para o processador de E/S, esperando melhorar
o desempenho sem análise.
221
Multiprocessadores
• Idéia: criar computadores poderosos conectando muitos computadores menores
boa notícia:
funciona para compartilhamento de tempo
(melhor do que um supercomputador)
má notícia:
é muito difícil escrever bons programas concorrentes,
muitas falhas comerciais
Processador
Processador
Processador
Processador
Processador
...
Processador
Cache
Cache
Cache
Cache
Cache
...
Cache
Memória
Memória
...
Memória
Barramento único
Memória
E/S
Rede
222
Perguntas
• Como os processadores paralelos compartilham dados?
– espaço de endereço único (SMP versus NUMA)
– transferência de mensagens
• Como os processadores paralelos são coordenados?
– sincronização (bloqueios, semáforos)
– primitivas send/receive embutidas
– protocolos de sistema operacional
• Como eles são implementados?
– conectados por um único barramento
– conectados por uma rede
223
Supercomputadores
Representação dos 500 maiores sites de supercomputador durante uma década:
SIMD (Single Instruction Multiple Data)
500
Cluster
(rede de estações
de trabalho)
Cluster
(rede de
SMPs)
400
300
MPPs
(Massively
Parallel
Processors)
200
100
SMPs
(Shared
Memory
Multiprocessors)
0
93 93 94 94 95 95 96 96 97 97 98 98 99 99 00
Uniprocessadores
224
Usar múltiplos processadores – uma idéia antiga
• Alguns projetos SIMD:
Instituição
Universidade de
Illinois
ICL
Goodyear
Thinking Machines
Maspar
Nome
Número máximo de
processadores
Bits/proc.
Velocidade de clock
do proc. (MHz)
Tamanho/sistema de
memória máximo (MB)
Número de FPUs
BW/sistema de
comunicações (MB/s)
Ano
Illiac IV
64
64
13
64
1
2.560
1972
DAP
MPP
CM-2
MP-1216
4.096
16.384
65.536
16.384
1
1
1
4
5
10
7
25
0
0
2048 (opcional)
0
2
2
512
256 ou 1024
2.560
20.480
16.384
23.000
1980
1982
1987
1989
FIGURA 9.11.1 Características de cinco computadores SIMD. Número de FPUs significa o número de unidades de ponto flutuante.
• Os custos para o Illiac IV aumentaram de US$ 8 milhões em 1966 para US$ 32
milhões em 1972 apesar da conclusão de apenas ¼ da máquina. Levou três outros
anos para que ele estivesse operacional!
“Por sorte ou por azar, os arquitetos de computador
não são facilmente desencorajados”
Muitos projetos e idéias interessantes, muitas falhas, poucos sucessos
225
Topologias
226
Clusters
• Construídos a partir de computadores inteiros
• Redes independentes e escaláveis
• Vantagens:
– Muitas aplicações receptivas a máquinas frouxamente agrupadas
– Exploram redes locais
– Econômicos / fáceis de expandir
• Desvantagens:
– Custos de administração não necessariamente baixos
– Conectados usando barramento de E/S
• Altamente disponíveis devido à separação das memórias
• Em teoria, devemos ser capazes de fazer melhor
227
Google
• Serve uma média de 1.000 consultas por segundo
• Usa 6.000 processadores e 12.000 discos
• Dois locais físicos no Vale do Silício e dois na Virgínia
• Cada local está conectado à Internet usando OC48 (2488 Mbit/seg)
• Confiabilidade:
– Em um dia típico, 20 máquinas precisam ser reiniciadas (erros de software)
– Menos de 2% das máquinas são substituídas a cada ano
Em certo sentido, são idéias simples bem executadas.
Melhores (e mais baratas) do que outros métodos
envolvendo maior complexidade.
228
Comentários finais
• Evolução versus revolução
“Na maioria das vezes, o custo da inovação é devido a ser muito problemático para
os usuários de computador.”
Microprocessador de processamento paralelo
Uso especial
SIMD massivo
Multiprocessador CC-NUMA
(Reprogramar)
Clusters
Multiprocessador CC-UMA
(Recompilar)
RISC
Instruções vetoriais
Instruções de multimídia
(Novas
bibliotecas)
Memória virtual
Superescalar
Multiprocessador com time sharing
Pipelining
Evolucionário
Cache
Microprogramação
(Compatível
a nível binário)
Revolucionário
“A aceitação de idéias de hardware exige aceitação pelas pessoas de software;
portanto, as pessoas de hardware precisam aprender mais sobre software. Além
disso, se as pessoas de software quiserem boas máquinas, elas precisam aprender
mais sobre hardware para serem capazes de se comunicar com — e, portanto,
influenciar — os projetistas de hardware.”
229