Transcript
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
