Capítulo 3 Permission is granted to copy and distribute this material for educational purposes only, provided that the complete bibliographic citation and following credit line is included: "Copyright 1998 Morgan Kaufmann Publishers." Permission is granted to alter and distribute this material provided that the following credit line is included: "Adapted from Computer Organization and Design: The Hardware/Software Interface, 2nd Edition David A. Patterson, John L. Hennessy Morgan Kaufmann, 2nd ed., 1997, ISBN 1558604286 Copyright 1998 Morgan Kaufmann Publishers." Lecture slides created by Michael Wahl in English Tradução: Christian Lyra Gomes Revisão: Wagner M. N. Zola This material may not be copied or distributed for commercial purposes without express written permission of the copyright holder. 1 Instruções: Linguagem da máquina Mais primitivas do que linguagens de alto nível ex. não possuem controles de fluxo sofisticados Muito restritivas ex. instruções aritméticas MIPS Nós estaremos trabalhando com a arquitetura de conjunto de instruções MIPS similar a outras arquiteturas desenvolvidas desde 1980 usada por NEC, Nintendo, Silicon Graphics, Sony Objetivos do projeto: maximizar desempenho e reduzir custos, reduzir tempo de projeto 2
Aritmética MIPS Todas as instruções tem 3 operandos A ordem dos operando é fixa (primeiro destino) Exemplo: Código C: A = B + C Código MIPS : add $s0, $s1, $s2 (associado a variáveis pelo compilador) 3 Aritmética MIPS Princípio de projeto: simplicidade favorece regularidade. Por que? Claro que isso complica outras coisas... código C: A = B + C + D; E = F - A; código MIPS: add $t0, $s1, $s2 add $s0, $t0, $s3 sub $s4, $s5, $s0 Operandos precisam ser registradores, e apenas 32 registradores são fornecidos Princípio de projeto: menor é mais rápido. Por que? 4
Registradores vs. Memória Operandos de instruçõs aritméticas precisam ser registradores, apenas 32 registradores são fornecidos O compilador associa variáveis com registradores E quando o programa possui muitas variáveis? Controle Entrada Memória Datapath Saída Processador I/O 5 Organização da memória É vista como uma lista (array) uni-dimensional grande, com endereços. Um endereço de memória é um índice do array Endereçamento do Byte" significa que um índice aponta para um byte na memória. 0 1 2 3 4 5 6... 8 bits de dados 8 bits de dados 8 bits de dados 8 bits de dados 8 bits de dados 8 bits de dados 8 bits de dados 6
Organização da memória Bytes são legais, mas a maioria dos items de dados usam palavras maiores No MIPS, uma palavra são 32 bits ou 4 bytes. 0 4 8 12... 32 bits de dados 32 bits de dados 32 bits de dados 32 bits de dados Registradores armazenam 32 bits de dados 2 32 bytes com endereços de bytes de 0 a 2 32-1 2 30 palavras com endereços de bytes 0, 4, 8,... 2 32-4 Palavras são alinhadas Quais são os dois bits menos significativos de um endereço de palavra? 7 Instruções Instruções de carga e armazenamento Exemplo: código C: código MIPS: A[8] = h + A[8]; lw $t0, 32($s3) add $t0, $s2, $t0 sw $t0, 32($s3) instrução de armazenamento tem o destino por último Lembre-se operandos aritméticos são registradores e não memória! 8
Nosso primeiro exemplo Conseguimos entender esse 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 9 Até então nós aprendemos: MIPS carregamos palavras mas endereçamos bytes aritmética utiliza registradores apenas Instrução Significado add $s1, $s2, $s3 $s1 = $s2 + $s3 sub $s1, $s2, $s3 $s1 = $s2 $s3 lw $s1, 100($s2) $s1 = Memória[$s2+100] sw $s1, 100($s2) Memória[$s2+100] = $s1 10
Linguagem de máquina Instruções, assim como registradores e palavras de dados, também tem largura de 32 bits Exemplo: add $t0, $s1, $s2 registradores possuem números, $t0=9, $s1=17, $s2=18 Formato da Instrução: 000000 10001 10010 01000 00000 100000 op rs rt rd shamt funct Você consegue descobrir o que significa os nomes dos campos? 11 Linguagem de máquina Considere as instruções de carga de palavra e armazenamento de palavra, O que os princípios de regularidade nos levaria a fazer? Novo princípio: Bom projeto demanda um compromisso Introduz um novo tipo de formato de instrução Tipo-I (I-type) para instruções de transferência de dados o outro formato era o tipo-r (R-type) para registradores Exemplo: lw $t0, 32($s2) 35 18 9 32 op rs rt número de16 bits Onde está o compromisso? 12
Conceito de programa armazenado Instruções são bits Programas são armazenado na memória para serem lidos ou escritos, da mesma forma que dados Processador Memória Memória para dados, programas, compiladores, editores, etc. Ciclo de Busca e Execução Instruções são buscadas e colocadas em um registrador especial Bits no registrador controlam as ações subsequentes Busca a próxima instrução e continua 13 Controle Instruções de tomada de decisão altera o controle do fluxo, isto é, mudam a próxima instrução a ser executada instruções de desvio condicional 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:... 14
Controle Instruções de desvio incondicionais do MIPS: j label Exemplo: if (i!=j) beq $s4, $s5, Lab1 h=i+j; add $s3, $s4, $s5 else j Lab2 h=i-j; Lab1: sub $s3, $s4, $s5 Lab2:... Você consegue construir um loop simples? 15 Até então: Instrução Significado add $s1,$s2,$s3 $s1 = $s2 + $s3 sub $s1,$s2,$s3 $s1 = $s2 $s3 lw $s1,100($s2) $s1 = Memory[$s2+100] sw $s1,100($s2) Memory[$s2+100] = $s1 bne $s4,$s5,l Prox. Instruc em Label se $s4 $s5 beq $s4,$s5,l Prox. Instruc em Label se $s4 = $s5 j Label Prox. Instruc em Label Formatos: R I J op rs rt rd shamt funct op rs rt 16 bit address op 26 bit address 16
Controle de fluxo Nós temos: beq, bne, e Branch-if-less-than (desvia se menor que)? Nova instrução: if $s1 < $s2 then $t0 = 1 slt $t0, $s1, $s2 else $t0 = 0 Podemos usar essa instrução para construir "blt $s1, $s2, Label" podemos agora construir estruturas de controle genéricas Note que o assembler necessita de um registrador para fazer isso, existe uma política de convenções de uso dos registradores 17 2 Política de Convenções de Uso Nome Registrador No Uso $zero 0 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 salvos $t8-$t9 24-25 mais temporários $gp 28 ponteiro global $sp 29 stack pointer $fp 30 frame pointer $ra 31 endereço de retorno 18
Constantes Constantes pequenas são usadas com bastante freqüência (50% dos operandos) ex., A = A + 5; B = B + 1; C = C - 18; Soluções? Por que não? Colocar as constantes típicas em memória e carregar elas. Criar registradores fixos (como o $zero) para constantes como o um (1). Instruções MIPS: addi $29, $29, 4 slti $8, $18, 10 andi $29, $29, 6 ori $29, $29, 4 Como fazer isso funcionar? 19 3 E quando as constantes são grandes? Nós queremos carregar constantes de 32 bits em um registrador Devemos usar duas instruções, nova instrução "load upper immediate" lui $t0, 1010101010101010 Preenchido com zeros 1010101010101010 0000000000000000 Depois devemos deixar os bits de ordem mais baixa certos, i.e., ori $t0, $t0, 1010101010101010 1010101010101010 0000000000000000 ori 0000000000000000 1010101010101010 1010101010101010 1010101010101010 20
Linguagem Assembly vs. Linguagem de Máquina Assembly provê uma representação simbólica conveniente Muito mais simples do que escrever números ex., destino primeiro Linguagem de máquina é a realidade por debaixo ex., destino não é mais por primeiro Assembly pode prover 'pseudo instruções' ex., mover $t0, $t1 existe apenas no Assembly Pode ser implementada usando add $t0,$t1,$zero Quando for considerar o desempenho você deve contar as instruções reais 21 Outros pontos Coisas que não iremos cobrir suporte para procedimentos ligadores (linkers), carregadores (loaders), layout de memória stacks, frames, recursão manipulação de strings e ponteiros interrupções e excessões chamadas de sistema e convenções alguns desses nós iremos falar mais tarde Nós focaremos nos pontos relativos a arquitetura básico da linguagem assembly MIPS e código de máquina Nós construiremos um processador para executar essas instruções. 22
Visão geral do MIPS Instruções simples tem largura de 32 bits bem estruturada, sem bagagem desnecessária apenas 3 formatos de instrução R I J op rs rt rd shamt funct op rs rt 16 bit address op 26 bit address depende do compilador para alcançar desempenho quais devem ser os objetivos do compilador? Ajudar o compilador onde for possível 23 Endereços em desvios e saltos Instruções: bne $t4,$t5,label Próxima instrução no Label se $t4 $t5 beq $t4,$t5,label Próxima instrução no Label se $t4 = $t5 j Label Formatos: Próxima instrução no Label I J op rs rt 16 bit address op 26 bit address Endereços não são 32 bits Como nós lidamos com isso nas instruções para carregar e armazenar? 24
Endereços nos desvios Instruções: bne $t4,$t5,label beq $t4,$t5,label Formatos: Próxima instrução no Label se $t4 $t5 Próxima instrução no Label se $t4=$t5 I op rs rt 16 bit address Podemos especificar um registrador (como no lw e sw) e adicionar ele ao endereço usa o Registrador de Endereço de Instrução (PC = program counter) A maioria dos desvios é local (princípio da localidade) Instruções de salto usam os bits de alta ordem do PC limitações de endereço de 256 MB 25 Resumindo: Operandos MIPS Nome Exemplo Comentário $s0-$s7, $t0-$t9, $zero, Localização rápida de dados. No MIPS, os dados devem estar em registradores para 32 registers $a0-$a3, $v0-$v1, $gp, serem usados em op aritméticas. No MIPS o registrador $zero é sempre igual a 0. $fp, $sp, $ra, $at O registrador $at é reservado pelo assembler para lidar com constantes grandes. Memory[0], Acessado apenas pelas instruções de transferência de dados. MIPS usa endereços de byte, 2 30 memory Memory[4],..., então palavras em seqüência diferem por 4. Memória guarda estruturas de dados, como array words Memory[4294967292] e cospem registradores, como aqueles salvos nas chamadas de procedmento. Linguagem assembly MIPS Categoria Instrução Exemplo Significado Comentário $s1, $s2, $s2 + $s3 dados nos registradores add add $s3 $s1 = Três operandos; Aritmética subtract sub $s1, $s2, $s3 $s1 = $s2 - $s3 Três operandos; dados nos registradores add immediate addi $s1, $s2, 100 $s1 = $s2 + 100 Usado para adicionar constantes load word lw $s1, 100($s2) $s1 = Memory[$s2 + 100] Palavra da memória para o registrador store word sw $s1, 100($s2) Memory[$s2 + 100] = $s1 Palavra do registrador para memória load byte lb $s1, 100($s2) $s1 = Memory[$s2 + 100] Byte da memória para o registrador transferência store byte sb $s1, 100($s2) Memory[$s2 + 100] = $s1 Byte do registrador para a memória load upper lui $s1, 100 $s1 = 100 * 2 16 Carrega constante nos 16 bits superiores de dados immediate branch on equal beq $s1, $s2, 25 if ($s1 == $s2) go to PC + 4 + 100 Teste Igual; Desvio relativo ao PC branch on not equal bne $s1, $s2, 25 if ($s1!= $s2) go to Desvio PC + 4 + 100 Condicional set on less than slt $s1, $s2, $s3 if ($s2 < $s3 ) $s1 = 1; else $s1 = 0 Teste não igual; relativo ao PC comparação menor que; para beq, bne set less than immediate slti $s1, $s2, 100 if ($s2 < 100 ) $s1 = 1; else $s1 = 0 Comparação menor que constante jump j 2500 go to 10000 Salta para endereço Saltos jump register jr $ra go to $ra Para troca, retorno de procedimento jump and link jal 2500 $ra = PC + 4; go to 10000 para chamada de procedimento 26
1. Im mediat e addressing op rs rt Im mediat e 2. Regist er addressing op rs rt rd... f unct Reg ist ers Register 3. Base addressi ng op rs rt Address M emory Register + Byt e Halfword Word 4. PC-relati ve addressing op rs rt Address M emory PC + Word 5. Pseudodirect addressi ng op Address M emory PC Word 27 Arquiteturas Alternativas Projeto alternativo: prover operações mais poderosas objetivo é reduzir o número de instruções executadas o perigo é ter um tempo de ciclo mais lento e/ou uma maior CPI As vezes é referido como RISC vs. CISC virtualmente todas os novos conjuntos de instrução são RISC desde 1982 VAX: minimiza o tamanho do código, faz com que a linguagem assembly seja fácil instruções variando de 1 a 54 bytes de comprimento! Nós iremos olhar o PowerPc e o 80x86 28
PowerPC Endereçamento Indexado exemplo: lw $t1,$a0+$s3 #$t1=memory[$a0+$s3] O que nós temos que fazer no MIPS? Endereçamento atualizado atualiza um registrador como parte da carga (para percorrer arrays) exemplo: lwu $t0,4($s3) #$t0=memory[$s3+4];$s3=$s3+4 O que nós temos que fazer no MIPS? Outros: carga múltipla/armazenamento múltiplo um registrador contador especial bc Loop decrementa contador, se não 0 vai para loop 29 80x86 1978: O Intel 8086 é anunciado (arquitetura de 16 bits) 1980: O co-processador de ponto flutuante 8087 é adicionado 1982: O 80286 aumenta o espaço de endereçamento para 24 bits, +instruções 1985: O 80386 estende para 32 bits, novos modos de endereçamento 1989-1995: O 80486, Pentium, Pentium Pro adicionam novas instruções (maioria projetada para aumentar o desempenho) 1997: MMX é adicionado Essa história ilustra o impacto das algemas de ouro da compatibilidade Adicionando novos recursos como quem adiciona roupas a uma mala amontoada uma arquitetura que é difícil de explicar e impossível de amar 30
Uma arquitetura dominante: 80x86 Veja o seu livro texto para uma descrição mais detalhada Complexidade: Instruções de 1 a 17 bytes de comprimento um operando pode agir como uma fonte e um destino ao mesmo tempo um operando pode vir da memória modos de endereçamento complexos ex., índice base ou escalonado com deslocamento de 8 ou 32 bits Ajuda salvadora: as instruções mais freqüentemente usadas não são difíceis de construir compiladores evitam as partes da arquitetura que são mais lentas o que falta em estilo ao 80x86 sobra em quantidade, o que faz ele bonito a partir da perspectiva certa 31 Sumário Complexidade das Instruções é apenas uma variável menor contagem de instruções vs. maior CPI / menor freqüência de relógio Princípios de projeto: simplicidade favorece regularidade menor é mais rápido bom projeto demanda compromisso torne o caso comum rápido arquitetura de conjunto de instruções uma abstração muito importante! 32