Aula-02 Arquitetura do conjunto de instruções – ISA (Instruction Set Architecture)

Apresentação em tema: "Aula-02 Arquitetura do conjunto de instruções – ISA (Instruction Set Architecture)"— Transcrição da apresentação:

1 Aula-02 Arquitetura do conjunto de instruções – ISA (Instruction Set Architecture)

2 Arquitetura do Conjunto de Instruções
Instruction Set Architecture (ISA) software Conjunto de instruções hardware

3 Computador de von Neumann
- instruções e dados na mesma memória - as instruções são lidas da memória e executadas na unidade de processamento, uma a uma - as instruções são armazenadas na mesma seqüência da execução - a unidade de controle é responsável pelo controle da leitura e execução das instruções

4 Arquitetura do Conjunto de Instruções Instruction Set Architecture (ISA)
O que vem a ser um conjunto de instruções? a fronteira entre o hardware e o software cada instrução é diretamente executada pelo hardware Como é representado? por um formato binário pois o hardware só entende bits os entes físicos são bits, bytes, words, n-words tamanho de palavra (word) é tipicamente 32 ou 64 bits hoje em dia, mas pequenos tamanhos são encontrados em processadores embarcados e processadores DSPs opções – formatos de comprimentos fixos e variáveis Fixos – cada instrução codificado num campo de mesmo tamanho (tipicamente uma palavra) Variáveis – meia palavra, palavra, múltiplas palavras

5 Abstração Descendo no nível de abstrações revelam-se outras informações

6 Exemplo ampliado 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

7 Características das instruções
Usualmente uma operação simples Identificada pelo campo de op-code Mas operações requerem operandos – 0, 1 ou 2 Para identificar onde eles estão, eles devem ser endereçados Endereço é para uma parte do armazenamento Possibilidades típicas de armazenamento são memória principal, registradores ou pilha 2 opções: endereçamento explícito ou implícito Implícito – o código de operação (op-code) implica no endereço dos operandos ADD numa máquina a pilha – retira (pop) 2 elementos do topo da pilha, e coloca (push) o resultado Explícito – o endereço é especificado em algum campo da instrução notar o potencial para 3 endereços – 2 operandos + 1 destino quais são as vantagens do endereçametno de registradores vs memória

8 Que operações são necessárias
Aritmética + lógica ADD, SUB, MULT, DIV, SHIFT – lógico e aritmético, AND, OR, XOR, NOT Transferência de dados – copy, load, store Controle – branch, jump, call, return, trap Sistema – gerenciamento de memória e SO Ponto Flutuante Mesmo que as aritméticas porém usam operandos maiores ecimal – se fosse operar em decimal String – move, compare, search Manipulação de campos de bits

9 Arquitetura do Conjunto de Instruções do MIPS:
Iremos trabalhar com a arquitetura do conjunto de instruções MIPS, projetado na Universidade de Stanford pela equipe do Prof. John Hennessy. similar a outras arquiteturas desenvolvidas desde 1980 Princípio da regularidade, p.ex.: todas as instruções de 32 bits Princípio da simplicidade, p.ex.: instruções simples, somente 3 formatos de instruções Usado por NEC, Nintendo, Silicon Graphics, Sony

10 Aritmética MIPS Todas as instruções tem 3 operandos
A ordem dos operandos é fixa (primeiro o operando destino) Exemplo: C code: A = B + C MIPS code: add $s0, $s1, $s (associado às variáveis pelo compilador)

11 Aritmética MIPS Princípio: simplicidade favorece regularidade.
C code: A = B + C + D; E = F - A; MIPS code: add $t0, $s1, $s2 add $s0, $t0, $s3 sub $s4, $s5, $s0 Os operandos devem ser registradores Somente 32 registradores disponíveis no MIPS

12 Registradores vs. Memória
Os operandos de instruções arithméticas devem ser registradores, — somente 32 registradores disponíveis O compilador associa variáveis a registradores E programas com um número grande de variáveis? Processor I/O Control Datapath Memory Input Output

13 Organização de Memória
Vista como um grande vetor unidimensional, com endereços. Um endereço de memória é um índice para o vetor "Byte addressing" significa que o índice aponta para um byte de memória. 8 bits of data 1 8 bits of data 2 8 bits of data 3 8 bits of data 4 8 bits of data 5 8 bits of data 6 8 bits of data ...

14 Organização de Memória
A maioria dos dados usam palavras ou "words" Para MIPS, um word é constituído de 32 bits ou 4 bytes. 232 bytes têm endereços de 0 a 232-1 230 words têm endereços de bytes 0, 4, 8, Words são alinhados: O que significam os dois bits menos significativos de um endereço de word? 32 bits of data Os registradores carregam dados de 32 bits 4 32 bits of data 8 32 bits of data 12 32 bits of data ...

15 Instruções de referência à memória
Instruções Load-Word e Store-Word Exemplo: C code: A[8] = h + A[8]; MIPS code: lw $t0, 32($s3) add $t0, $s2, $t0 sw $t0, 32($s3) Store-Word tem destino por último Lembrar que os operandos aritméticos são de registradores, não de memória!

16 Nosso Primeiro Exemplo
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

17 O que vimos: MIPS — carrega words mas endereça bytes — aritmética somente usando 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

18 Linguagem de Máquina Instruções, como registradores e words, tem também 32 bits Exemplo: add $t0, $s1, $s2 registradores tem numerações, $t0=9, $s1=17, $s2=18 Formato de Instruções aritméticas - tipo-R (registradores): op rs rt rd shamt funct

19 Linguagem de Máquina Considerar as instruções load-word e store-word,
Introduz um novo tipo de formato de instrução tipo-I para instruções de transferência de dados outro formato é o tipo-R para registradores Exemplo: lw $t0, 32($s2) Formato das instruções tipo-I op rs rt 16 bit number

20 Conceito de Programa Armazenado na memória (von Neumann)
Instruções são conjunto de bits Os programas são armazenados na memória —para serem lidos e executados Se as instruções estão na mesma memória como os dados, elas podem também serem lidas e escritas como se fossem dados. Ciclos de Fetch & Execute Instruções são lidas (fetched) e colocadas num registrador especial Os bits no registrador "controlam" as ações subsequentes Busca (Fetch) a próxima instrução e continua Processor Memory memory for data, programs, compilers, editors, etc.

21 Instruções de Controle
Instruções de tomadas de decisão altera o fluxo de controle, i.e., muda 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: ....

22 Instruções de Controle
Instruções de salto incondicional do MIPS: j label Exemplo: if (i!=j) beq $s4, $s5, Lab h=i+j; add $s3, $s4, $s5 else j Lab h=i-j; Lab1: sub $s3, $s4, $s5 Lab2: ...

23 Revisão: op rs rt rd shamt funct R I op rs rt 16 bit address J
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 Next instr. is at Label if $s4 = $s5 beq $s4,$s5,L Next instr. is at Label if $s4 = $s5 j Label Next instr. is at Label Formatos: R I J op rs rt rd shamt funct op rs rt 16 bit address op bit address

24 Fluxo de Controle Temos: beq, bne, que tal Branch-if-less-than?
Nova instrução: if $s1 < $s2 then $t0 = 1 slt $t0, $s1, $s2 else $t0 = 0 Pode-se usar essa instrução para "blt $s1, $s2, Label" — pode agora construir estruturas de controle geral Note que o assembler precisa de um registrador para tal, — existe uma regra para o uso de registradores

25 Regra para o uso de registradores

26 Constantes Constantes pequenas são usadas frequentemente (50% dos operandos) p.ex., A = A + 5; B = B + 1; C = C - 18; Soluções? Colocar as constantes típicas nas instruções criar registradores hardwired (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

27 E as constantes maiores?
Gostariamos de carregar constantes de 32 bits em um registrador Devemos usar duas instruções, a instrução "load upper immediate" lui $t0, Então devemos carregar os bits menos significativos à direita, i.e., ori $t0, $t0, Preenchido com zeros ori

28 Ling. Assembly vs. Ling. de Máquina
Assembly provê uma representação simbólica conveniente Mais fácil que escrever números P.ex., o operando destino é o primeiro A linguagem de máquina é a realidade num nível inferior P.ex., destino não é o primeiro Assembly pode prover 'pseudoinstruções' P.ex., “move $t0, $t1” existe somente em Assembly Seria implementada usando “add $t0,$t1,$zero” Quando o assunto é o desempenho devem ser consideradas as instruções reais

29 Visão geral do MIPS Instruções simples todas de 32 bits
Bem estruturadas Somente três formatos de instruções Confiar no compilador para obter desempenho — quais são os objetivos do compilador? Ajudar o compilador onde é possível R I J op rs rt rd shamt funct op rs rt 16 bit address op bit address

30 Endereços em Branchs e Jumps
Instruções: bne $t4,$t5,Label A próxima instrução é no Label se $t4 <>$t5 beq $t4,$t5,Label A próxima instrução é no Label se $t4 = $t5 j Label A próxima instrução é no Label Formatos: Endereços não são de 32 bits — Como manipulá-los com instruções de load e store? op rs rt 16 bit address I J op bit address

31 Endereços em Branchs Instruções
bne $t4,$t5,Label A próxima instrução é no Label se $t4<>$t5 beq $t4,$t5,Label A próxima instrução é no Label se $t4=$t5 Formatos: Pode especificar um registrador (como lw e sw) e adicioná-lo ao endereço usar Instruction Address Register (PC = program counter) A maioria dos branchs são locais (princípio da localidade) Instruções de Jump usa apenas os bits de alta ordem do PC Limite de endereçamento de 256 MB op rs rt 16 bit address I

32 Resumindo: Posição rápida para os dados: os dados devem estar em registradores para realizar aritmética Registrador $zero sempre contem valor 0 Registrador $at é reservado para o assembler manipular constantes grandes Memória: acessada somente por instruções de transferência de dados Endereçado por bytes, tal que as palavras seqüenciais difiram de 4 no endereço Memória contem estrutura de dados, como arrays, e valores de registradores que transbordaram

33

34

35 Arquiteturas Alternativas
Alternativas de Projeto: Prover operações mais potentes A meta é reduzir o número de instruções executadas O perigo é um tempo de ciclo mais lento e/ou um CPI maior As vezes referidos como “RISC vs. CISC” virtualmente todos os novos conjuntos de instruções desde 1982 tem sido RISC Veremos o PowerPC e 80x86

36 PowerPC Indexed addressing
exemplo: lw $t1,$a0+$s3 #$t1=Memory[$a0+$s3] O que devemos fazer no MIPS? Update addressing Atualizar um registrador como parte do load (para operar sobre elementos de vetores) exemplo: lwu $t0,4($s3) #$t0=Memory[$s3+4];$s3=$s3+4 Outros: load multiple/store multiple Um registrador contador especial “bc Loop” decrementar o contador, e se não for 0 vai para loop

37 A partir do 80386 , também chamado de IA-32
Intel 80x86 A partir do , também chamado de IA-32 1978: Intel 8086 é anunciado (arquitetura de 16 bits) 1980: é adicionado o coprocessador de ponto flutuante 1982: aumenta o espaço de endereçamento para 24 bits, + instruções 1985: estende para 32 bits, novos modos de endereçamento : , Pentium, Pentium Pro e algumas novas instruções (a maioria para melhorar o 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”

38 Uma arquitetura dominante: 80x86
Complexidade: Instruções de 1 a 17 bytes um operando deve agir como fonte e destino um operando pode vir da memória Modos de endereçamento complexos p.ex., “base ou scaled index com deslocamento de 8 ou 32 bit” Salvando a graça: As instruções mais frequentemente usadas não são tão difíceis de serem construidas Os compiladores evitam as 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”