Anotações da 2a Edição

Transcrição

1 Anotações da 2a Edição OBS: Essas anotações são adaptações do material suplementar (apresentações PPT) ao Livro do Hennessy e Patterson. Supõe-se que os estudantes tenham noções de lógica digital e linguagem assembly para o entendimento das aulas. 1

2 Conjunto de Instruções MIPS 2

3 Aritmética MIPS Todas as Instruções tem 3 operandos Ordem dos operandos é fixa (destino sempre primeiro) Exemplo: C code: C = A + B MIPS code: add $s0, $s1, $s2 (associado a variáveis definidas pelo compilador) 3

4 Aritmética MIPS Princípios de design: simplicidade favorece a regularidade. Por que? Obviamente, isto complica algumas coisas... C code: A = B + C + D; E = F - A; MIPS code: add $t0, $s1, $s2 add $s0, $t0, $s3 sub $s4, $s5, $s0 Operandos devem ser registradores, e só existem 32 deles Princípio de Projeto: quanto menor, mais rápido! Por que? 4

5 Registradores x Memória Operandos das Instruções Aritméticas devem ser registradores, Somente 32 registradores estão disponíveis O Compilador associa variáveis com registradores... O que significa um programa com muitas variáveis? Control Input Memory Datapath Output Processor I/O 5

6 Organização da Memória Memória: enorme vetor unidimensional acessado por endereços. Endereço de memória = índice para o vetor Endereçar um Byte" = índice que aponta para um byte da memória bits of data 8 bits of data 8 bits of data 8 bits of data 8 bits of data 8 bits of data 8 bits of data 6

7 Organização da Memória Bytes são interessantes, mas geralmente o acesso é feito a palavras mais longas que 1 byte Como vimos, para o MIPS, a palavra é de 32 bits (4 bytes) bits of data 32 bits of data 32 bits of data 32 bits of data 2 32 bytes com endereços byte de 0 a palavras com endereços 0, 4, 8, registradores armazenam 32 bits de dados Palavras são alinhadas: Assim, o que representam os 2 bits menos significativos do endereço de uma palavra? 7

8 Instruções Instruções load (trazer de) e store (enviar para) Exemplo: C code: MIPS code: A[12] = h + A[12]; lw $t0, 36($s3) add $t0, $s2, $t0 sw $t0, 36($s3) O destino da palavra ($t0) a ser armazenada vem no início da instrução sw Lembre-se que todos os operandos aritméticos são registradores e não endereços de memória! 8

9 Um 1o. Exemplo Como poderíamos escrever esse código de troca de valor de duas posições (k e k+1) de um vetor? swap(int v[], int k); { int temp; temp = v[k] v[k] = v[k+1]; v[k+1] = temp; } swap: muli $4, $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

10 Mas, aprendemos que: MIPS Carrega palavras, mas acessa bytes Aritmética somente em registradores Instrução Significado add $s1, $s2, $s3 $s1 = $s2 + $s3 sub $s1, $s2, $s3 $s1 = $s2 $s3 lw $s1, 100($s2) $s1 = Memory[$s2+100] sw $s1, 100($s2) Memory[$s2+100] = $s1 10

11 Instruções MIPS Todas as instruções têm 32 bits Todas têm opcode (código de instrução) de 6 bits O modo de endereçamento é codificado juntamente com o opcode opcode 11

12 Linguagem de Máquina Instruções, assim como registradores de palavras de dados, tem tamanho de 32 bits Exemplo: add $t0, $s1, $s2 registradores têm números, $t0=8, $s1=17, $s2=18 Formato de uma Instrução R típico: op rs rt rd shamt funct Observe a ordem na instrução assembly e na implementação! São diferentes! Você pode imaginar o que esses nomes (siglas) indicam? op código de operação rs, rt registradores fonte rd registrador destino shamt (shift amount) é usado em instruções de deslocamento funct código de função da ULA. É associado ao campo op (no caso de ULA é 00000) 12

13 Linguagem de Máquina Considere as instruções load-word e store-word: O que o princípio da regularidade nos traz? Novo princípio: Bons projetos envolve um compromisso... Introdução de um novo tipo de formato de Instrução Instruções tipo-i para transferência de dados (lw e sw) Outros formatos para instruções tipo-r para registradores Exemplo: lw $t1, 32($s2) op rs rt 16 bit number rs registrador-base para o cálculo do endereço de memória rt registrador-destino (para lw) ou registrador-fonte (para sw) Onde está o compromisso? 13

14 Controle de Fluxo no MIPS Pontos de decisão podem criar instruções alterar o fluxo de controle, i.e., mudar a próxima instrução a ser executada Endereço destino sempre especificado! Instruções MIPS de desvio condicional: bne $t0, $t1, Label beq $t0, $t1, Label Exemplo: if (i!=j) h=i+j; bne $s0, $s1, Label... Label: add $s3, $s0, $s

15 Uso de instruções de controle 15

16 Controle de Fluxo Instruções MIPS de desvio incondicional (jumps): 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ê poderia pensar numa construção simples de um loop em MIPS? 16

17 Mais ainda: 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. instr. label L se $s4!= $s5 beq $s4,$s5,l Prox. instr. label L se $s4 == $s5 j L Prox. instr. label L Formatos: R op rs rt rd shamt funct I,J* op rs rt endereço 16 bit ou imediato J op endereço de 26 bits J* = desvio condicional 17

18 Controle do Fluxo Temos: beq, bne E se quisermos uma nova instrução do tipo branch-if-less-than? if $s1 < $s2 then slt $t0,$s1,$s2 $t0 = 1 else $t0 = 0 Usando beq, bne e $t0 pode se implementar a lógica requerida A Instrução pode ser usada para construir "blt $s1,$s2,label" é possível se construir estruturas de controle genéricas Note que o montador necessita de um registrador para fazer isso existem políticas de uso específicas para os registradores 18

19 Convenções e Política de Uso dos 32 Registradores MIPS Nome No.Registrador 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-$t temporários $s0-$s salvos/armazenados $t8-$t mais temporários $gp 28 ponteiro global $sp 29 ponteiro de pilha (stack pointer) $fp 30 ponteiro de quadro (frame pointer) $ra 31 endereço de retorno OBS: Registro 1, chamado $at, é reservado para o montador. Os registros 26 e 27, chamados $k0 e $k1, são reservados para o Sistema Operacional 19

20 Constantes Constantes pequenas são usadas frequentemente... Ex: A = A + 5; B = B + 1; C = C - 18; Soluções? Colocar constantes típicas na memória e carregá-las. Criar registradores hard-wired para certas constantes: ex. $zero Instruções MIPS para imediatos: addi $29, $29, 4 slti $8, $18, 10 andi $29, $29, 6 ori $29, $29, 4 Como podemos fazer isso? Lembram-se da instrução muli do 1º exemplo (swap) 20

21 O que fazer com grandes constantes? É possível carregar constantes de 32 bits em um registrador Devem ser usadas 2 instruções para implementar isso: 1. Nova Instrução load upper immediate lui $t0, preenchida com zeros Depois, completar os bits de ordem mais baixa à direita, i.e., ori $t0, $t0, ori

22 Linguagem Assembly x Linguagem de Máquina Assembly proporciona uma representação simbólica conveniente MUITO MAIS FÁCIL que escrever dígitos binários Ex: registrador destino é sempre o primeiro Linguagem de Máquina está em outro nível de abstração Ex: destino não é preenchido primeiro na instrução tipo-r Assembly disponibiliza apenas pseudoinstruções ex., move $t0,$t1 existe somente em Assembly Poderia ser implementado usando add $t0,$t1,$zero Quando se considera desempenho, deve-se pensar em contar instruções reais em linguagem de máquina 22

23 Uso das instruções 23

24 Uso das instruções 24

25 Outras questões Coisas que não estão sendo cobertas aqui: Suporte a procedures Carregadores (loaders), ligadores (linkers,), pilhas (stacks), frames, recursão, etc. Manipulação de strings e ponteiros Interrupções e exceções Chamadas de sistema (system calls) Alguns desses pontos serão tratados no futuro e em outros cursos O foco agora está em questões ligadas à arquitetura: Básico da linguagem de máquina MIPS e código de máquina Construção de um processor para executar estas instruções. 25

26 Sumarização: Conjunto de Instruções MIPS 26

27 Visão Geral do MIPS Instruções simples, todas com largura de 32 bits Bastante estruturada, pouca carga desnecessária nas instruções Somente 3 formatos de instrução R I J op rs rt rd shamt funct op rs rt 16 bit address op 26 bit address Apostar no compilador para obter desempenho Quais são os objetivos de um compilador? Ajudar o compilador no que nós queremos... 27

28 Papel fundamental do Compilador Sem otimizações 28

29 Endereços em Desvios (Branches) e Saltos (Jumps) Instruções: bne $t4,$t5,label beq $t4,$t5,label j Label Prox Instr. está em Label se $t4 $t5 Prox Instr. está em Label se $t4=$t5 Prox Instr. está em Label Formatos: I J op rs rt 16 bit address op 26 bit address Endereços não estão em 32 bits Como manipular isso para Instruções load e store? 29

30 Endereços em Desvios (Branches) Instruções: bne $t4,$t5,label beq $t4,$t5,label Formatos: Prox Instr. está em Label se $t4 $t5 Prox Instr. está em Label se $t4=$t5 I op rs rt 16 bit address Pode especificar um registrador (lw e sw) e adicioná-lo a um endereço Usar o Registrador de Endereço de Instrução (PC = program counter) 16 bits parece pouco, entretanto muitos desvios são próximos (princípio da localidade) Instruções Jump usam apenas os bits de mais alta ordem do PC Endereços limitados a 256 MB (pense no porquê...) 30

31 Sumário: Registradores MIPS Nome Exemplo Comentários $s0-$s7, $t0-$t9, $zero, Localizações rápidas de dados. No MIPS, os dados devem estar nos registradores 32 registradores $a0-$a3, $v0-$v1, $gp, aritméticos. O Registrador $zero no MIPS é sempre igual a 0. Registrador $at é $fp, $sp, $ra, $at reservado para o montador manipular constantes grandes. Memory[0], Acessado somento por instruções de transferência de dados. MIPS usa endereços de bytes, e palavras sequenciais diferenciam de memory Memory[4],..., Memória armazena estruturas de dados, como vetores, e registros encadeados, words Memory[ ] como aqueles salvos em procedure calls. 31

32 Sumário: Assembly MIPS Linguagem Assembly MIPS Categoria Instrução Exemplo Significado Comentário add add $s1, $s2, $s3 $s1 = $s2 + $s3 3 operandos; dados em registradores Arim ética subtract sub $s1, $s2, $s3 $s1 = $s2 - $s3 3 operandos; dados em registradores add immediate addi $s1, $s2, 100 $s1 = $s Usado para adicionar constantes load w ord lw $s1, 100($s2) $s1 = Memory[$s ] Palavra da memória para registrador Transf. de store w ord sw $s1, 100($s2) Memory[$s ] = $s1 Palavra do registrador para memória dados load byte lb $s1, 100($s2) $s1 = Memory[$s ] Byte da memória para registrador store byte sb $s1, 100($s2) Memory[$s ] = $s1 Byte do registrador para memória load upper lui $s1, 100 $s1 = 100 * 2 16 Carregar constante no 16 bits immediate superiores branch on equal beq $s1, $s2, 25 if ($s1 == $s2) go to PC Teste de igualdade; desvio PC-relativo Desvio branch on not equal bne $s1, $s2, 25 Condicional set on less than slt $s1, $s2, $s3 if ($s1!= $s2) go to PC if ($s2 < $s3) $s1 = 1; else $s1 = 0 Teste de Desigualdade; desvio PCrelativo Comparar menor que; para beq, bne set less than slti $s1, $s2, if ($s2 < 100) $s1 = 1; Constante na comparação menor que immediate 100 else $s1 = 0 jump j 2500 go to Saltar para o endereço alvo Desvio jump register jr $ra go to $ra Para escolha, retorno de procedimento Incondicional jump and link jal 2500 $ra = PC + 4; go to Para chamada de procedimento 32

33 Mais detalhes sobre formas de endereçamento MIPS 1. Immediate addressing op rs rt Immediate 2. Register addressing op rs rt rd... funct Registers Register 3. Base addressing op rs rt Address Memory Register + Byte Halfword Word 4. PC-relative addressing op rs rt Address Memory PC + Word 33

34 op rs rt Address Memory Detalhes sobre Register formas de + endereçamento Byte Halfword Word 4. PC-relative addressing op rs rt Address Memory PC + Word 5. Pseudodirect addressing op Address Memory PC Word 34

35 Arquiteturas Alternativas Projetos alternativos: Prover operações mais poderosas Objetivo: reduzir o número de Instruções executadas Perigo é aumentar o tempo de ciclo e/ou aumentar o CPI Algumas vezes associado ao confronto RISC x CISC Virtualmente, todos os Conjuntos de Instruções de 1982 a 95 foram RISC VAX: minimizar o tamanho do código, de forma a tornar a linguagem assembly mais fácil Instruções de tamanho 1 a 54 bytes! Para que assembly mais fácil? Rapidamente, olhar as arquiteturas PowerPC e 80x86 (detalhes no livro do Sttalings) 35

36 PowerPC Endereçamento Indexado Ex: lw $t1,$a0+$s3 #$t1=memory[$a0+$s3] Como isso seria feito no MIPS? Atualizar endereçamento Atualizar um registrador como parte da carga (para andar através de arrays) Ex: lwu $t0,4($s3) #$t0=memory[$s3+4];$s3=$s3+4 Como isso seria feito no MIPS? Outros: Múltiplos load/store Um registrador contador especial bc Loop decrementa contador, se!= 0 goto loop 36

37 80x : O Intel 8086 é anunciado (arquitetura 16 bit) 1980: O coprocessador 8087 floating point é adicionado 1982: O amplia o espaço de endereçamento para 24 bits, + Instruções 1985: O estende para 32 bits, novos modos de endereçamento : O 80486, Pentium, Pentium Pro adicionam poucas Instruções (maioria delas projetadas para ganho de desempenho) 1997: MMX é adicionado This history illustrates the impact of the golden handcuffs of compatibility adding new features as someone might add clothing to a packed bag an architecture that is difficult to explain and impossible to love (Hennessy & Patterson) 37

38 A arquitetura dominante: 80x86 Leia o livro texto para uma descrição mais detalhada Complexidade: Instruções com tamanho de 1 a 17 bytes 1 operando pode funcionar como fonte e destino 1 operando pode vir da memória Modos de endereçamento complexos Ex: índice de base ou de escala com deslocamento de 8 ou 32 bits Pontos interessantes: As instruções mais frequentemente usadas não são tão difíceis de construir Compiladores evitam porções da arquitetura que são lentas what the 80x86 lacks in style is made up in quantity, making it beautiful from the right perspective (Hennessy & Patterson) 38

39 Sumário Complexidade da Instrução é apenas UMA das variáveis Número de instruções mais baixo vs. alto CPI / taxa de clock mais baixa Princípios de projeto: Simplicidade favorece regularidade Quanto menor, mais rápido Um bom projeto implica em compromisso Fazer o caso comum mais rápido Conjunto de Instruções da Arquitetura (Instruction Set Architecture) Uma abstração MUITO importante! 39