Arquitetura e Organização de Computadores. Capítulo 2 Conjunto de Instruções

Transcrição

1 Arquitetura e Organização de Computadores Capítulo 2 Conjunto de Instruções

2 Material adaptado de: Patterson e Henessy, Computer Organization and Design 4 th Edition 2

3 É o repertório de instruções de um computador; Computadores diferentes possuem conjuntos de instruções diferentes: Mas em muitos aspectos eles são comuns; Computadores antigos tinham conjuntos de instruções bem simples: Implementação simplificada; Muitos computadores modernos também possuem conjunto de instruções simplificados. Conjunto de Instruções - ISA 3

4 Usado como exemplo durante este curso; Stanford MIPS comercializado pelo MIPS Technologies ( Grande parte do mercado de sistemas embarcados: Aplicações em Consumer Eletronics, Network/Storage, equipamentos, câmeras, impressoras,... Típico de muitos ISAs modernos: Vejam MIPS Reference Data. MIPS Instruction Set 4

5 Todo computador deve ser capaz de executar operações aritméticas: Notação da MIPS Assembly Language: add a, b, c instrui o computado a adicionar duas variáveis b e c e colocar o resultado da soma em a: a = b + c Operações Aritméticas 5

6 Essa notação é fixa, ou seja, sem variações. Se você quiser fazer... então é necessário... a = b + c + d + e add a, b, c # The sum of b and c is placed in a. add a, a, d # The sum of b, c, and d is now in a. add a, a, e # The sum of b, c, d, and e is now in a. Operações Aritméticas 6

7 Simplicidade favorece a regularidade ; Todas as operações aritméticas possuim o mesmo formato; Regularidade faz implementação mais simples; Simplicidade permite alto desempenho a um baixo custo. Princípio de Projeto 1 7

8 Código C: f = (g + h) - (i + j); Código compilado do MIPS: add t0, g, h # temp t0 = g + h add t1, i, j # temp t1 = i + j sub f, t0, t1 # f = t0 - t1 Exemplo: Operações aritméticas 8

9 Instruções aritméticas usam operandos que vem de registradores; MIPS possui 32 x32-bit registradores (banco de registradores): Usado para dados que são frequentemente utilizados; Numerados de 0 a 31; 32-bit de dados é chamado de word ; Nomes dos registradores: $t0, $t1,..., $t9 para dados temporários (variáveis do compilador); $s0, $s1,..., $s7 para dados não-temporários (variáveis do programador). Operandos em registradores 9

10 Menor é mais rápido ; Um número grande de registradores pode aumentar o tempo do ciclo de clock, tornando o sistema lento. Princípio de Projeto 2 10

11 Código C: f = (g + h) - (i + j); f,, j in $s0,, $s4 Código compilado do MIPS: add $t0, $s1, $s2 add $t1, $s3, $s4 sub $s0, $t0, $t1 Exemplo: Operandos em registradores 11

12 Linguagens de programação possuem variáveis que contem dados simples, mas eles também tem estruturas de dados mais complexas (arrays e structures): Podem conter mais dados do que o número de registradores em um computador. Como computadores podem representar e acessar grandes estruturas de dados? 12

13 Memória principal é usada para dados compostos: Arrays, structures, dynamic data; Para realizar operações aritméticas: Carregar valores da memória em registadores; Armazenar resultados do registrador na memória. Memória é endereçada a bytes: Cada endereço identifica unicamente um byte. Operandos na Memória 13

14 Words são alinhadas na memória: Endereços tem que ser múltiplo de 4 (4 Bytes => 32 bits); MIPS é Big Endian: Byte mais significativo está no menor endereço da palavra; OBS: Little Endian; Byte menos significativo está no menor endereço da palavra. Operandos na memória 14

15 Memória é um grande unidimensional array com o endereço atuando como índice deste array; Inicia em 0. OBS: O que é a memória? 15

16 A instrução que copia dados da memória para os registradores é tradicionalmente chamada de load; A que faz a operação inversa é chamada de store; A instrução de load é composta pelo registrador destino, uma constante e registrador de base: A soma da constante com o registrador base é utilizado para acessar a memória; Instrução do MIPS é lw (load word). Carregar dados da memória 16

17 Código C: g = h + A[8]; g in $s1, h in $s2, base address of A in $s3 Código compilado do MIPS: Índice 8 requer um deslocamento (offset) de 32 4 bytes por word lw $t0, 32($s3) # load word add $s1, $s2, $t0 offset base register Exemplo 1: Operandos na memória 17

18 Código C: A[12] = h + A[8]; h está em $s2, endereço base de A está em $s3 Código compilado para o MIPS: Índice 8 requer um deslocamento (offset) de 32 Índice 12 requer um deslocamento (offset) de 48 lw $t0, 32($s3) # load word add $t0, $s2, $t0 sw $t0, 48($s3) # store word Exemplo 2: Operandos na memória 18

19 São constantes especificadas em uma instrução: addi $s3, $s3, 4 Não possui instrução de subtração com imediato: Usar constantes negativas: addi $s2, $s1, -1 Operandos Imediatos 19

20 Faça o caso comum mais rápido Pequenas constantes são comuns ao programas; Operando imediato evita instruções de load. Princípio de Projeto 3 20

21 O registrador 0 ($zero) é a constante 0: Não pode ser sobrescrito; Útil para operações comuns: Ex: mover dados entre registradores: add $t2, $s1, $zero # move $s1 para $t2 A constante Zero 21

22 NÚMEROS INTEIROS COM OU SEM SINAL 22

23 Dado um número de n-bits: Alcance: 0 até 2 n -1 Exemplo: x x2 x2 n1 n2 1 0 n 1 n = = = Para 32 bits: 0 até x2x Números Inteiros Binários sem Sinal 23

24 Dado um número de n-bits: x x2 x2 Alcance: -2 n-1 até 2 n-1 1 Exemplo: n1 n2 1 0 n 1 n = = 2,147,483, ,147,483,644 = 4 10 Para 32 bits: até x2x Inteiros em Complemento a 2 com Sinal 24

25 Bit 31 é o bit de sinal: 1 para números negativo; 0 para não números não-negativos; -(-2 n-1 ) não pode ser representado; Números não-negativos tem a mesma representação em inteiros sem sinal e em complemento a dois; Alguns números específicos: 0: : Mais-negativo: Mais-positivo: Inteiros em Complemento a 2 com Sinal 25

26 Complemento dos bits somados a 1: Complemento significa: 1 0, 0 1 Exemplo: negar +2 x 2 x1 x +2 = = = x Negação com Sinal 26

27 Representando um número utilizando mais bits: Preservar o valor numérico; No ISA do MIPS: addi: estende o valor do imediato; lb, lh: estende o valor do byte/halfword carregados; beq, bne: estente o valor do deslocamento; Replicar o valor do sinal para esquerda: Valores sem sinal: sempre estender com 0s; Exemplo: 8-bit para 16-bit +2: => : => Extensão de Sinal 27

28 REPRESENTANDO INSTRUÇÕES 28

29 Instruções são codificadas em binário (números): Chamado de código de máquina: Instruções do MIPS: Codificadas como palavras de 32-bits; Um pequeno número de formatos codificam o código da operação (opcode), números dos registadores,... Regularidade! Números dos registradores: $t0 - $t7 são os registradores números 8 15; $t8 - $t9 são os registradores números 24 25; $s0 - $s7 são os registradores números 16 23; Representação de uma instrução 29

30 op rs rt rd shamt funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits Campos da instrução: op: código da operação (opcode); rs: número do primeiro registrador fonte; rt: número do segundo registrador fonte; rd: número do registrador de destino; shamt: quantidade de shifs (00000 por enquanto); funct: código da função (estende o opcode). Instruções do formato R 30

31 op rs rt rd shamt funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits add $t0, $s1, $s2 special $s1 $s2 $t0 0 add = Exemplo do formato R 31

32 Base 16: Representação compacta de cadeias de bits; 4 bits por cada dígito hexadecimal; Example: eca Hexadecimal 32

33 op rs rt constant or address 6 bits 5 bits 5 bits 16 bits Operações aritméticas com imediatos e instruções de load/store: rt: número do registrador destino ou fonte; Constante: até ; Endereço: deslocamento (offset) adicionado ao registrador base rs; Instruções do formato I 33

34 Bons projetos demandam bons compromissos ; Diferentes formatos complicam a decodificação das instruções, mas permite instruções do mesmo tamanho; Mantenha os formatos das instruções o mais similar possível: R-type (para registradores) ou R-format. I-type (para imediatos) ou I-format. Princípio de Projeto 4 34

35 Se $t1 tem o endereço base do array A e $s2 corresponde ao, então a sentença: é compilada para: A[300] = h + A[300]; lw $t0,1200($t1) # Temporary reg $t0 gets A[300] add $t0,$s2,$t0 # Temporary reg $t0 gets h + A[300] sw $t0,1200($t1) # Stores h + A[300] back into A[300] Qual é o código de máquina para essas três instruções? Exemplo: Traduzindo Assembly para código de máquina 35

36 The BIG Picture Instruções são representados em binários, como os dados; Instruções e dados são armazenados na memória; Programas podem operar sobre programas; Compatibilidade binária permite programas funcionarem em diferentes computadores ISAs padronizados. Computadores com programas armazenados 36

37 OPERAÇÕES LÓGICAS 37

38 Instruções para manipulação da cadeia de bits: Útil para extração ou inserção de grupos de bits em uma palavra. Operações Lógicas 38

39 op rs rt rd shamt funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits Desloca a cadeia de bits para esquerda ou direita; shamt: número de bits para deslocar; Shift Left Logical (sll): Desloca para esquerda e preenche com zeros no final; sll de i-bits multiplica a palavra por 2 i ; Shift Right Logical (srl): Desloca para direita e preenche com zeros no início; srl de i-bits divide a palavra por 2 i (só para números sem sinal). Operações de shift 39

40 Útil para mascarar bits em uma palavra: Selecionar alguns bits, limpando os outros com 0; and $t0, $t1, $t2 $t2 $t1 $t Operações de AND 40

41 Útil para incluir bits em uma palavra: Seta alguns bits para 1 sem mudar os outros; or $t0,$t1, $t2 $t2 $t1 $t Operações de OR 41

42 Útil para inverter bits em uma palavra: Muda 0 para 1, e 1 para 0; MIPS tem uma operação de NOR com 3 operandos: a NOR b == NOT (a OR b) nor $t0, $t1, $zero Register 0: always read as zero $t1 $t Operações de NOT 42

43 INSTRUÇÕES PARA TOMAR DECISÕES 43

44 O que diferencia um computador de uma calculadora simples é a habilidade de tomar decisões; A tomada de decisão é representada em linguagens de programação através das sentenças de if, algumas vezes combinadas com sentenças de go to e rótulos (labels). O diferencial do computador 44

45 Desvia (branch) para um rótulo se a condição da instrução for verdadeiro: Caso contrário, continua sequencialmente; beq rs, rt, L1 Se (rs == rt) então desvia para a instrução rotulada de L1; bne rs, rt, L1 Se (rs!= rt) então desvia para a instrução rotulada de L1; j L1 Pulo (jump) incondicional para a instrução rotulada de L1. Operações condicionais 45

46 Código C: if (i==j) f = g+h; else f = g-h; f, g, em $s0, $s1, Código compilado do MIPS: bne $s3, $s4, Else add $s0, $s1, $s2 j Exit Else: sub $s0, $s1, $s2 Exit: Exemplo: Compilando Assembler calculates addresses sentenças if 46

47 Código C: while (save[i] == k) i += 1; i em $s3, k em $s5, endereço base do save está $s6 Código compilado do MIPS: Loop: sll $t1, $s3, 2 add $t1, $t1, $s6 lw $t0, 0($t1) bne $t0, $s5, Exit addi $s3, $s3, 1 j Loop Exit: Exemplo: Compilando sentenças de Loop 47

48 Um bloco básico é uma sequência de instruções com: Nenhuma instrução de desvio (exceto no final) Nenhum alvo de uma instrução de desvio (exceto no começo) Um compilador identifica blocos básicos para otimizações; Um processador avançado pode acelerar a execução de um bloco básico. Blocos básicos 48

49 Seta o resultado para 1 se a condição é verdadeira: Caso contrário, seta para 0; slt rd, rs, rt Se (rs < rt) então rd = 1, caso contrário rd = 0; slti rt, rs, constante Se (rs < constante) então rt = 1, caso contrário rt = 0; Usado em combinação com beq, bne: slt $t0, $s1, $s2 # if ($s1 < $s2) bne $t0, $zero, L # branch to L Mais operações condicionais 49

50 Por que não blt, bge, etc? Hardware para <,, é mais lento que =, Combinando isso com o branch em si envolve mais trabalho por instrução, levando um clock mais lento; Todas as intruções seriam penalizadas! beq e bne são os casos mais comuns; Este é um bom compromisso de projeto (princípio 4); Projeto das instruções de desvio 50

51 Comparação com sinal: slt, slti Comparação sem sinal: sltu, sltui Exemplo: $s0 = $s1 = slt $t0, $s0, $s1 # signed 1 < +1 $t0 = 1 sltu $t0, $s0, $s1 # unsigned +4,294,967,295 > +1 $t0 = 0 Sinal vs. Sem sinal 51

52 CHAMADA DE PROCEDIMENTOS 52

53 Passos de uma chamada de procedimento: 1. Colocar parâmetros nos registradores; 2. Transferir o controle para o procedimento; 3. Adquirir espaço de armazenamento para o procedimento; 4. Executar as operações do procedimento; 5. Colocar o resultado em um registrador para quem chamou o procedimento; 6. Retornar para o local da chamada. Chamada de procedimento 53

54 $a0 $a3: parâmetros (reg s 4 7); $v0, $v1: retorno (reg s 2 e 3); $t0 $t9: temporários: Podem ser sobrescritos pelo procedimento; $s0 $s7: salvos ou globais: Devem ser salvos/recuperados pelo procedimento; $gp: Ponteiro global para dados estáticos (reg 28); $sp: Ponteiro da pilha (stack pointer) (reg 29); $fp: Ponteiro da janela (frame pointer) (reg 30); $ra: Endereço para retorno do procedimento (reg 31). Convenção: Uso de registradores 54

55 Chamada de procedimento: jump and link (pular e conectar): jal <rótulo> Salva o endereço da instrução seguinte ao jal no $ra (link); Pula para o endereço alvo (rótulo); Retorno de procedimento: jump register (pular para o registrador): jr $ra Copia $ra no contador de programa; Instruções para chamar procedimentos 55

56 C code: int leaf_exemple (int g, h, i, j) { int f; f = (g + h) - (i + j); return f; } Parâmetros g,, j em $a0,, $a3 f em $s0 (obriga a salvar $s0 na pilha) Resultado em $v0 Exemplo: Chamada de procedimento folha 56

57 Código MIPS: leaf_example: addi $sp, $sp, -4 sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 add $v0, $s0, $zero lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra Save $s0 on stack Procedure body Result Restore $s0 Return Exemplo: Chamada de procedimento folha 57

58 Procedimentos que chamam outros procedimentos; Para uma chamada aninhada, os procedimentos devem salvar na pilha: O seu endereço de retorno; Quaisquer parâmetros e temporários que serão necessários após a chamada do outro procedimento; Retirar dados da pilha após a chamada. Procedimentos não- folha 58

59 Código C: int fact (int n) { if (n < 1) return f; else return n * fact(n - 1); } Parâmetros em $a0 Resultado em $v0 Exemplo: Procedimento não- folha 59

60 Código MIPS: fact: addi $sp, $sp, -8 # adjust stack for 2 items sw $ra, 4($sp) # save return address sw $a0, 0($sp) # save argument slti $t0, $a0, 1 # test for n < 1 beq $t0, $zero, L1 addi $v0, $zero, 1 # if so, result is 1 addi $sp, $sp, 8 # pop 2 items from stack jr $ra # and return L1: addi $a0, $a0, -1 # else decrement n jal fact # recursive call lw $a0, 0($sp) # restore original n lw $ra, 4($sp) # and return address addi $sp, $sp, 8 # pop 2 items from stack mul $v0, $a0, $v0 # multiply to get result jr $ra # and return 60

61 ORGANIZAÇÃO DA MEMÓRIA 61

62 Variáveis locais armazenadas pelo procedimento; Janela do procedimento (frame): Usado por alguns compiladores para gerenciar o armazenamento na pilha Dados locais na pilha 62

63 Text: código do programa; Static Data: variáveis globais: Ex. variáveis estáticas em C, arrays constantes e strings; $gp inicializado para tratar endereços nesse segmento; Dynamic Data: heap: Ex. malloc em C, new em Java; Stack: armazenamento automático; Layout da Memória 63

64 MANIPULANDO DADOS 64

65 Conjunto de caracteres codificados em bytes: ASCII: 128 caracteres: 95 gráficos, 33 de controle; Latin-1: 256 caracteres: ASCII. +96 caracteres gráficos; Unicode: conjunto de caracteres de 32 bits: Usado em Java, C++,... Maioria dos alfabetos mundiais, mais símbolos; UTF-8, UTF-16: tamanhos variáveis de codificação. Caracteres 65

66 Load/store byte/halfword instruções do MIPS: Utilizado principalmente para trabalhar com strings; lb rt, offset(rs) lh rt, offset(rs) Estende o sinal para 32 bits em rt lbu rt, offset(rs) lhu rt, offset(rs) Estende zero para 32 bits em rt sb rt, offset(rs) sh rt, offset(rs) Escreve o byte/halfword mais a direita de rt na memória. Operações com byte e meia-palavra 66

67 Código C: String terminada em NULL; void strcpy (char x[], char y[]) { int i; i = 0; while ((x[i]=y[i])!='\0') i += 1; } Endereços de x, y em $a0, $a1; i em $s0. Exemplo: Copiar String 67

68 MIPS code: strcpy: addi $sp, $sp, -4 # adjust stack for 1 item sw $s0, 0($sp) # save $s0 add $s0, $zero, $zero # i = 0 L1: add $t1, $s0, $a1 # addr of y[i] in $t1 lbu $t2, 0($t1) # $t2 = y[i] add $t3, $s0, $a0 # addr of x[i] in $t3 sb $t2, 0($t3) # x[i] = y[i] beq $t2, $zero, L2 # exit loop if y[i] == 0 addi $s0, $s0, 1 # i = i + 1 j L1 # next iteration of loop L2: lw $s0, 0($sp) # restore saved $s0 addi $sp, $sp, 4 # pop 1 item from stack jr $ra # and return Exemplo: Copiar String 68

69 Maioria das constantes são pequenas: Imediato de 16-bits é suficiente; Para uma constante ocasional de 32-bits: lui rt, constant Copia constante de 16 bits para a parte mais significativa do rt Zera os 16 bits menos significativos. lhi $s0, ori $s0, $s0, Constantes de 32-bits 69

70 ENDEREÇAMENTO DE DESVIOS 70

71 As instruções de desvio especificam: Opcode, dois registradores, endereço alvo; Maioria dos desvios são desvios curtos: Para cima ou para baixo: op rs rt constant or address 6 bits 5 bits 5 bits 16 bits Endereçamento relativo ao contador de programa (PC): Endereço Alvo = PC + (offset x 4); OBS: PC já incrementado de 4. Endereçamento de desvios condicionais (branch) 71

72 Os alvos da instruções de jump (j e jal) podem ser qualquer lugar no segmento de texto: O endereço alvo vem codificado na instrução: op address 6 bits 26 bits (Pseudo) endereçamento direto: Endereço Alvo = PC : (address x 4) Concatenação Endereçamento de desvios incodicionais (jump) 72

73 Código de um loop de um exemplo anterior: Assuma que o loop está localizado a partir do endereço 80000: Loop: sll $t1, $s3, add $t1, $t1, $s lw $t0, 0($t1) bne $t0, $s5, Exit addi $s3, $s3, j Loop Exit: Exemplo: Endereçamento alvo 73

74 Se o alvo de um branch é um rótulo muito distante para ser codificado em 16 bits, então o Assembler reescreve o código da seguinte forma: Exemplo: beq $s0,$s1, L1 bne $s0,$s1, L2 j L1 L2: Desvios condicionais para áreas distantes 74

75 Resumo dos modos de endereçamento 75

76 SINCRONIZAÇÃO 76

77 Dois processadores compartilhando ao mesma região de memória: P1 escreve, então P2 lê; Condição de corrida de P1 e P2 não sincronizarem: Resultado vai depender da ordem dos acessos; Necessário suporte de hardware: Operação atômica de leitura/escrita na memória; Ninguém acessa o dado entre a leitura e a escrita; Pode ser uma instrução única: Ex. swap atômico entre registrador e memória; Ou um par de instruções atômicas. Sincronização 77

78 Load Linked: ll rt, offset(rs) Store Conditional: sc rt, offset(rs) Sucesso se o endereço não mudou desde o ll: Retorna 1 em rt; Falha se o endereço mudou: Retorna 0 em rt; Sincronização no MIPS 78

79 Swap atômico (test/set lock) try: add $t0,$zero,$s4 ;copy exchange value ll $t1,0($s1) ;load linked sc $t0,0($s1) ;store conditional beq $t0,$zero,try ;branch store fails add $s4,$zero,$t1 ;put load value in $s4 Exemplo: Swap atômico 79

80 TRADUÇÃO E INICIALIZAÇÃO 80

81 Many compilers produce object modules directly Static linking Tradução e Inicialização 81

82 Maioria das instruções do Assembler representam instruções de máquina de uma-para-um; Pseudoinstruções: fruto da imaginação do Assembler: move $t0, $t1 add $t0, $zero, $t1 blt $t0, $t1, L slt $at, $t0, $t1 bne $at, $zero, L $at (register 1): assembler temporary Pseudoinstruções 82

83 Provê informações para a construção de um programa completo a partir dos pedaços: Header: descreve o conteúdo do código objeto; Text Segment: instruções traduzidas; Static Data Segment: dados alocados durante a vida do programa (variáveis globais); Relocation Info: para conteúdos que dependem da localização absoluta do programa carregado; Symbol Table: definições globais e referências externas; Debug Info: para associação com o código fonte. Produzindo um Código Objeto (Partes dos Programas) 83

84 Produz uma imagem executável: 1. Unifica os segmentos; 2. Resolve os rótulos (determina o seus endereços); 3. Corrige as referências externas e as dependente de localização; Pode deixar as dependências de localização para serem corrigidas durante o processo de Loader: Com memória virtual, isso não é necessário; Programa pode ser carregado em uma localização absoluta no espaço da memória virtual. Linkando Código Objeto 84

85 Carrega o arquivo de imagem do disco para a memória: 1. Lê o Header para determinar o tamanho dos segmentos; 2. Cria um espaço de endereçamento virtual; 3. Copia instruções e os dados inicializados para a memória: Ou configura as entradas da tabela de páginas para que ocorram faltas; 4. Carrega os argumentos na pilha; 5. Inicializa os registradores (incluindo $sp, $fp, $gp); 6. Desvia para a rotina de inicialização: Copia os argumentos para $a0,... e chama a main ; Quando a main retorna, executa a Syscall Exit. Carregando um programa 85

86 Só carrega/linka a biblioteca de procedimentos quando é chamada: Necessita que o código do procedimento seja realocável; Evita o inchaço do executável causado pela linkagem estática de todas as bibliotecas referenciadas; Automaticamente pega novas versões das bibliotecas. Linkagem Dinâmica 86

87 Indirection table Stub: Loads routine ID, Jump to linker/loader Linker/loader code Dynamically mapped code Lazy Linkage 87

88 Simple portable instruction set for the JVM Compiles bytecodes of hot methods into native code for host machine Interprets bytecodes Iniciando aplicações Java 88

89 COLOCANDO TUDO JUNTO 89

90 Ilustra o uso de instruções em Assembly para uma função de Bubble Sort em C; Procedimento de SWAP (folha): void swap(int v[], int k) { int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; } v em $a0, k em $a1, temp em $t0 Exemplo: Ordenação em C 90

91 swap: sll $t1, $a1, 2 # $t1 = k * 4 add $t1, $a0, $t1 # $t1 = v+(k*4) # (address of v[k]) lw $t0, 0($t1) # $t0 (temp) = v[k] lw $t2, 4($t1) # $t2 = v[k+1] sw $t2, 0($t1) # v[k] = $t2 (v[k+1]) sw $t0, 4($t1) # v[k+1] = $t0 (temp) jr $ra # return to calling routine Procedimento de SWAP 91

92 Não-folha (chama swap): void sort (int v[], int n) { int i, j; for (i = 0; i < n; i += 1) { for (j = i 1; j >= 0 && v[j] > v[j + 1]; j -= 1) { swap(v,j); } } } v em $a0, k em $a1, i em $s0, j em $s1 Procedimento de ordenação em C 92

93 move $s2, $a0 # save $a0 into $s2 move $s3, $a1 # save $a1 into $s3 move $s0, $zero # i = 0 for1tst: slt $t0, $s0, $s3 # $t0 = 0 if $s0 $s3 (i n) beq $t0, $zero, exit1 # go to exit1 if $s0 $s3 (i n) addi $s1, $s0, 1 # j = i 1 for2tst: slti $t0, $s1, 0 # $t0 = 1 if $s1 < 0 (j < 0) bne $t0, $zero, exit2 # go to exit2 if $s1 < 0 (j < 0) sll $t1, $s1, 2 # $t1 = j * 4 add $t2, $s2, $t1 # $t2 = v + (j * 4) lw $t3, 0($t2) # $t3 = v[j] lw $t4, 4($t2) # $t4 = v[j + 1] slt $t0, $t4, $t3 # $t0 = 0 if $t4 $t3 beq $t0, $zero, exit2 # go to exit2 if $t4 $t3 move $a0, $s2 # 1st param of swap is v (old $a0) move $a1, $s1 # 2nd param of swap is j jal swap # call swap procedure addi $s1, $s1, 1 # j = 1 j for2tst # jump to test of inner loop exit2: addi $s0, $s0, 1 # i += 1 j for1tst # jump to test of outer loop Corpo do procedimento Move params Outer loop Inner loop Pass params & call Inner loop Outer loop 93

94 sort: addi $sp,$sp, 20 # make room on stack for 5 registers sw $ra, 16($sp) # save $ra on stack sw $s3,12($sp) # save $s3 on stack sw $s2, 8($sp) # save $s2 on stack sw $s1, 4($sp) # save $s1 on stack sw $s0, 0($sp) # save $s0 on stack # procedure body exit1: lw $s0, 0($sp) # restore $s0 from stack lw $s1, 4($sp) # restore $s1 from stack lw $s2, 8($sp) # restore $s2 from stack lw $s3,12($sp) # restore $s3 from stack lw $ra,16($sp) # restore $ra from stack addi $sp,$sp, 20 # restore stack pointer jr $ra # return to calling routine Procedimento completo 94

95 Compiled with gcc for Pentium 4 under Linux Relative Performance none O1 O2 O Instruction count none O1 O2 O Clock Cycles none O1 O2 O3 Efeitos da otimização do compilador CPI none O1 O2 O3 95

96 3 Bubblesort Relative Performance C/none C/O1 C/O2 C/O3 Java/int Java/JIT 2.5 Quicksort Relative Performance C/none C/O1 C/O2 C/O3 Java/int Java/JIT 3000 Quicksort vs. Bubblesort Speedup Efeitos da C/none C/O1 C/O2 C/O3 Java/int Java/JIT linguagem e algoritmo 96

97 Número de instruções e CPI não são bons avaliadores de de desempenho isolados; Otimizações do compilador são sensíveis ao algoritmo; Código compilado para Java/JIT é significantemente mais rápido que o interpretado pela JVM: Comparável com o código C otimizado; Nada pode corrigir um algoritmo ruim! Lições aprendidas 97

98 Indexar array envolve: Multiplicação do índice pelo tamanho do elemento; Adicionar ao endereço base do array; Ponteiros corresponde diretamente ao endereço da memória: Evita a complexidade de indexação. Arrays vs. Ponteiros 98

99 clear1(int array[], int size) { int i; for (i = 0; i < size; i += 1) array[i] = 0; } move $t0,$zero # i = 0 loop1: sll $t1,$t0,2 # $t1 = i * 4 add $t2,$a0,$t1 # $t2 = # &array[i] sw $zero, 0($t2) # array[i] = 0 addi $t0,$t0,1 # i = i + 1 slt $t3,$t0,$a1 # $t3 = # (i < size) bne $t3,$zero,loop1 # if ( ) # goto loop1 clear2(int *array, int size) { int *p; for (p = &array[0]; p < &array[size]; p = p + 1) *p = 0; } move $t0,$a0 # p = & array[0] sll $t1,$a1,2 # $t1 = size * 4 add $t2,$a0,$t1 # $t2 = # &array[size] loop2: sw $zero,0($t0) # Memory[p] = 0 addi $t0,$t0,4 # p = p + 4 slt $t3,$t0,$t2 # $t3 = #(p<&array[size]) bne $t3,$zero,loop2 # if ( ) # goto loop2 Exemplo: Limpando um array 99

100 Multiplicar a força reduzida do uso do shift; Versão com array necessita que os shifts estejam dentro do loop; Parte do cálculo do índice para o i incrementado; Compilador por alcançar o mesmo efeito com o uso manual de ponteiros: Eliminação da variável de indução; Melhor para fazer o programa mais claro e seguro; Comparação entre Array e Ponteiro 100

101 ARM: processador embarcado mais popular; Conjunto de instruções similar ao do MIPS; ARM MIPS Date announced Instruction size 32 bits 32 bits Address space 32-bit flat 32-bit flat Data alignment Aligned Aligned Data addressing modes 9 3 Registers bit bit Input/output Memory mapped Memory mapped Similaridades ARM & MIPS 101

102 Usa códigos condicionais para resultado de uma operação lógica/aritmética; Negativo, zero, carry, overflow; Compara instruções para mudar os código de condição sem manter o resultado; Cada instrução pode ser condicional: 4 bits mais significativos da instrução: valor da condição; Evita branchs sobre instruções simples. Comparação e Desvio no ARM 102

103 Codificação das Instruções 103

104 Evolução com compatibilidade: 8080 (1974): 8-bit microprocessor Accumulator, plus 3 index-register pairs 8086 (1978): 16-bit extension to 8080 Complex instruction set (CISC) 8087 (1980): floating-point coprocessor Adds FP instructions and register stack (1982): 24-bit addresses, MMU Segmented memory mapping and protection (1985): 32-bit extension (now IA-32) Additional addressing modes and operations Paged memory mapping as well as segments Intel x86 ISA 104

105 ... i486 (1989): pipelined, on-chip caches and FPU Compatible competitors: AMD, Cyrix, Pentium (1993): superscalar, 64-bit datapath Later versions added MMX (Multi-Media extension) instructions The infamous FDIV bug Pentium Pro (1995), Pentium II (1997) New microarchitecture (see Colwell, The Pentium Chronicles) Pentium III (1999) Added SSE (Streaming SIMD Extensions) and associated registers Pentium 4 (2001) New microarchitecture Added SSE2 instructions Intel x86 ISA 105

106 ... AMD64 (2003): extended architecture to 64 bits EM64T Extended Memory 64 Technology (2004) AMD64 adopted by Intel (with refinements) Added SSE3 instructions Intel Core (2006) Added SSE4 instructions, virtual machine support AMD64 (announced 2007): SSE5 instructions Intel declined to follow, instead Advanced Vector Extension (announced 2008) Longer SSE registers, more instructions Se a Intel não estender a compatibilidade, seus concorrentes irão! Technical elegance market success Intel x86 ISA 106

107 Registradores do x86 107

108 Dois operandos por instrução: Source/dest operand Register Register Register Memory Memory Second source operand Register Immediate Memory Register Immediate Modos de endereçamento da memória: Address in register Address = R base + displacement Address = R base + 2 scale R index (scale = 0, 1, 2, or 3) Address = R base + 2 scale R index + displacement Modos de endereçamento x86 108

109 Tamanho da codificação variável: Sufixo especifica o modo de endereçamento; Prefixo modifica a operação: Codificação das instruções Tamanho do operado, repetição, travamento,... do x86 109

110 Instruções complexas fazem a implementação difícil: Hardware traduz instruções para microoperações mais simples: Instruções simples: 1 1; Instruções complexas: 1 muitos; Microengine similar a um RISC; Marke share tornou isto economicamente viável; Desempenho comparável ao RISC: Compiladores evitam instruções complexas. Implementando IA

111 Instruções poderosas alto desempenho: Poucas instruções necessárias; Instruções complexas são difíceis de implementar: Podem deixar lenta todas as instruções, incluindo as simples; Compiladores são bons em fazer código rápido com instruções simples; Uso de código Assembly para alto desempenho: Compiladores modernos conseguem lidar melhor com processadores modernos; Mais linhas de código mais erros e menos produtividade Falácias 111

112 Compatibilidade conjunto de instruções não muda: Eles acrescentam mais instruções. x86 instruction set Falácias 112