Você está na página 1de 38

Arquitetura do conjunto de instrues ISA (Instruction Set Architecture)

Arquitetura do Conjunto de Instrues


Instruction Set Architecture (ISA)

software

Conjunto de instrues

hardware

Computador de von Neumann


- instrues e dados na mesma memria - as instrues so lidas da memria e executadas na unidade de processamento, uma a uma - as instrues so armazenadas na mesma seqncia da execuo

- a unidade de controle responsvel pelo controle da leitura e execuo das instrues

Arquitetura do Conjunto de Instrues Instruction Set Architecture (ISA)


O que vem a ser um conjunto de instrues? a fronteira entre o hardware e o software cada instruo diretamente executada pelo hardware Como representado? por um formato binrio pois o hardware s entende bits os entes fsicos so bits, bytes, words, n-words tamanho de palavra (word) tipicamente 32 ou 64 bits hoje em dia, mas pequenos tamanhos so encontrados em processadores embarcados e processadores DSPs opes formatos de comprimentos fixos e variveis Fixos cada instruo codificado num campo de mesmo tamanho (tipicamente uma palavra) Variveis meia palavra, palavra, mltiplas palavras

High-level language program (in C)

Abstrao
Descendo no nvel de abstraes revelam-se outras informaes
Assembly language program (for MIPS)

swap(int v[], int k) {int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; }

C compiler

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

Assembler

Binary machine language program (for MIPS)

00000000101000010000000000011000 00000000100011100001100000100001 10001100011000100000000000000000 10001100111100100000000000000100 10101100111100100000000000000000 10101100011000100000000000000100 00000011111000000000000000001000

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

Caractersticas das instrues


Usualmente uma operao simples Identificada pelo campo de op-code Mas operaes requerem operandos 0, 1 ou 2 Para identificar onde eles esto, eles devem ser endereados Endereo para uma parte do armazenamento Possibilidades tpicas de armazenamento so memria principal, registradores ou pilha 2 opes: endereamento explcito ou implcito Implcito o cdigo de operao (op-code) implica no endereo dos operandos ADD numa mquina a pilha retira (pop) 2 elementos do topo da pilha, e coloca (push) o resultado Explcito o endereo especificado em algum campo da instruo notar o potencial para 3 endereos 2 operandos + 1 destino quais so as vantagens do endereametno de registradores vs memria

Que operaes so necessrias


Aritmtica + lgica ADD, SUB, MULT, DIV, SHIFT lgico e aritmtico, AND, OR, XOR, NOT Transferncia de dados copy, load, store

Controle branch, jump, call, return, trap


Sistema gerenciamento de memria e SO Ponto Flutuante Mesmo que as aritmticas porm usam operandos maiores ecimal se fosse operar em decimal String move, compare, search Manipulao de campos de bits

Arquitetura do Conjunto de Instrues do MIPS:


Iremos trabalhar com a arquitetura do conjunto de instrues MIPS, projetado na Universidade de Stanford pela equipe do Prof. John Hennessy. similar a outras arquiteturas desenvolvidas desde 1980 Princpio da regularidade, p.ex.: todas as instrues de 32 bits Princpio da simplicidade, p.ex.: instrues simples, somente 3
formatos de instrues

Usado por NEC, Nintendo, Silicon Graphics, Sony

Aritmtica MIPS
Todas as instrues tem 3 operandos A ordem dos operandos fixa (primeiro o operando destino) Exemplo:

C code:
MIPS code:

A = B + C
add $s0, $s1, $s2 (associado s variveis pelo compilador)

Aritmtica MIPS
Princpio: simplicidade favorece regularidade.

C code:

A = B + C + D; E = F - A; add $t0, $s1, $s2 add $s0, $t0, $s3 sub $s4, $s5, $s0

MIPS code:

Os operandos devem ser registradores Somente 32 registradores disponveis no MIPS

Registradores vs. Memria


Os operandos de instrues arithmticas devem ser registradores, somente 32 registradores disponveis O compilador associa variveis a registradores E programas com um nmero grande de variveis?

Control Memory Datapath


Processor

Input

Output
I/O

Organizao de Memria
Vista como um grande vetor unidimensional, com endereos. Um endereo de memria um ndice para o vetor "Byte addressing" significa que o ndice aponta para um byte de memria.
0 1 2 3 4 5 6 ...
8 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

Organizao de Memria
A maioria dos dados usam palavras ou "words" Para MIPS, um word constitudo de 32 bits ou 4 bytes.
0 4 8 12 ...
32 bits of data 32 bits of data 32 bits of data 32 bits of data

Os registradores carregam dados de

32 bits

232 bytes tm endereos de 0 a 232-1 230 words tm endereos de bytes 0, 4, 8, ... 232-4 Words so alinhados: O que significam os dois bits menos significativos de um endereo de word?

Instrues de referncia memria


Instrues Load-Word e Store-Word Exemplo: C code: MIPS code: A[8] = h + A[8]; lw $t0, 32($s3) add $t0, $s2, $t0 sw $t0, 32($s3)

Store-Word tem destino por ltimo Lembrar que os operandos aritmticos so de registradores, no de memria!

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

O que vimos:
MIPS carrega words mas enderea bytes aritmtica somente usando registradores Instruo 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

Linguagem de Mquina
Instrues, como registradores e words, tem tambm 32 bits Exemplo: add $t0, $s1, $s2 registradores tem numeraes, $t0=9, $s1=17, $s2=18 Formato de Instrues aritmticas - tipo-R (registradores):

op

rs

rt 10010

rd 01001

shamt 00000

funct 100000

000000 10001

Linguagem de Mquina
Considerar as instrues load-word e store-word, Introduz um novo tipo de formato de instruo tipo-I para instrues de transferncia de dados outro formato o tipo-R para registradores Exemplo: lw $t0, 32($s2) Formato das instrues tipo-I
op 35 rs 18 rt 9 16 bit number 32

Conceito de Programa Armazenado na memria (von Neumann)


Instrues so conjunto de bits Os programas so armazenados na memria para serem lidos e executados Se as instrues esto na mesma memria como os dados, elas podem tambm serem lidas e escritas como se fossem dados. memory for data, programs, compilers, editors, etc.

Processor

Memory

Ciclos de Fetch & Execute Instrues so lidas (fetched) e colocadas num registrador especial Os bits no registrador "controlam" as aes subsequentes Busca (Fetch) a prxima instruo e continua

Instrues de Controle
Instrues de tomadas de deciso altera o fluxo de controle, i.e., muda a prxima instruo a ser executada Instrues 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: ....

Instrues de Controle

Instrues de salto incondicional 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: ...

Reviso:
Instruo 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 Formatos: Significado $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

R I J

op op op

rs rs

rt rt

rd

shamt

funct

16 bit address

26 bit address

Fluxo de Controle
Temos: beq, bne, que tal Branch-if-less-than? Nova instruo: if $s1 < $s2 then $t0 = 1 slt $t0, $s1, $s2 else $t0 = 0 Pode-se usar essa instruo 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

Regra para o uso de registradores


Name Register number $zero 0 $v0-$v1 2-3 $a0-$a3 4-7 $t0-$t7 8-15 $s0-$s7 16-23 $t8-$t9 24-25 $gp 28 $sp 29 $fp 30 $ra 31 Usage the constant value 0 values for results and expression evaluation arguments temporaries saved more temporaries global pointer stack pointer frame pointer return address

Constantes
Constantes pequenas so usadas frequentemente (50% dos operandos) p.ex., A = A + 5; B = B + 1; C = C - 18; Solues? Colocar as constantes tpicas nas instrues criar registradores hardwired (como $zero) para constantes como um. Instrues MIPS: addi $29, $29, 4 slti $8, $18, 10 andi $29, $29, 6 ori $29, $29, 4

E as constantes maiores?
Gostariamos de carregar constantes de 32 bits em um registrador Devemos usar duas instrues, a instruo "load upper immediate" lui $t0, 1010101010101010
Preenchido com zeros
1010101010101010 0000000000000000

Ento devemos carregar os bits menos significativos direita, i.e., ori $t0, $t0, 1010101010101010

1010101010101010 0000000000000000 ori 1010101010101010

0000000000000000 1010101010101010

1010101010101010

Ling. Assembly vs. Ling. de Mquina


Assembly prov uma representao simblica conveniente Mais fcil que escrever nmeros P.ex., o operando destino o primeiro A linguagem de mquina a realidade num nvel inferior P.ex., destino no o primeiro Assembly pode prover 'pseudoinstrues' 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 instrues reais

Viso geral do MIPS


Instrues simples todas de 32 bits Bem estruturadas Somente trs formatos de instrues
R I J op op op rs rs rt rt rd shamt funct 16 bit address

26 bit address

Confiar no compilador para obter desempenho quais so os objetivos do compilador? Ajudar o compilador onde possvel

Endereos em Branchs e Jumps


Instrues: bne $t4,$t5,Label beq $t4,$t5,Label j Label Formatos:

A prxima instruo no Label se $t4 <>$t5 A prxima instruo no Label se $t4 = $t5 A prxima instruo no Label

I
J

op op

rs

rt

16 bit address

26 bit address

Endereos no so de 32 bits Como manipul-los com instrues de load e store?

Endereos em Branchs
Instrues bne $t4,$t5,Label beq $t4,$t5,Label Formatos: I op rs rt 16 bit address

A prxima instruo no Label se $t4<>$t5 A prxima instruo no Label se $t4=$t5

Pode especificar um registrador (como lw e sw) e adicion-lo ao endereo usar Instruction Address Register (PC = program counter) A maioria dos branchs so locais (princpio da localidade) Instrues de Jump usa apenas os bits de alta ordem do PC Limite de endereamento de 256 MB

Resumindo:
MIPS operands Example Comments $s0-$s7, $t0-$t9, $zero, Fast locations for data. In MIPS, data must be in registers to perform 32 registers $a0-$a3, $v0-$v1, $gp, arithmetic. MIPS register $zero always equals 0. Register $at is $fp, $sp, $ra, $at reserved for the assembler to handle large constants. Memory[0],
Accessed only by data transfer instructions. MIPS uses byte addresses, so sequential words differ by 4. Memory holds data structures, such as arrays, and spilled registers, such as those saved on procedure calls.

Name

2 memory Memory[4], ...,


words Memory[4294967292]

30

Posio rpida para os dados: os dados devem estar em registradores para realizar aritmtica Registrador $zero sempre contem valor 0 Registrador $at reservado para o assembler manipular constantes grandes Memria: acessada somente por instrues de transferncia de dados Endereado por bytes, tal que as palavras seqenciais difiram de 4 no endereo Memria contem estrutura de dados, como arrays, e valores de registradores que transbordaram

Category
add

Instruction

MIPS assembly language Example Meaning add $s1, $s2, $s3 $s1 = $s2 + $s3 sub $s1, $s2, $s3 addi $s1, $s2, 100 lw $s1, 100($s2) sw $s1, 100($s2) lb $s1, 100($s2) sb $s1, 100($s2) lui $s1, 100 beq $s1, $s2, 25 $s1, $s2, 25 $s1, $s2, $s3 $s1 = $s2 - $s3

Comments
Three operands; data in registers Three operands; data in registers

Arithmetic

subtract

add immediate load w ord store w ord Data transfer load byte store byte load upper immediate branch on equal

$s1 = $s2 + 100 Used to add constants $s1 = Memory[$s2 + 100]Word from memory to register Memory[$s2 + 100] = $s1 Word from register to memory $s1 = Memory[$s2 + 100]Byte from memory to register Memory[$s2 + 100] = $s1 Byte from register to memory $s1 = 100 * 2
16

Loads constant in upper 16 bits Equal test; PC-relative branch Not equal test; PC-relative Compare less than; for beq, bne Compare less than constant

if ($s1 == $s2) go to PC + 4 + 100 if ($s1 != $s2) go to PC + 4 + 100 if ($s2 < $s3) $s1 = 1; else $s1 = 0 else $s1 = 0

branch on not equal bne

Conditional branch

set on less than set less than immediate

slt slti j jr jal

$s1, $s2, 100 if ($s2 < 100) $s1 = 1; 2500 $ra 2500

Unconditional jump

jump jump register jump and link

go to 10000 Jump to target address go to $ra For sw itch, procedure return $ra = PC + 4; go to 10000 For procedure call

1. Immediate addressing op rs rt Immediate

2. Register addressing op rs rt rd ... funct Registers Register

3. Base addressing op rs rt Address Memor y

Register

Byte

Halfword

Word

4. PC-relative addressing op rs rt Address Memor y

PC

Word

5. Pseudodirect addressing op Address Memor y

PC

Word

Arquiteturas Alternativas
Alternativas de Projeto: Prover operaes mais potentes A meta reduzir o nmero de instrues 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 instrues desde 1982 tem sido RISC

Veremos o PowerPC e 80x86

PowerPC
Indexed addressing exemplo: lw $t1,$a0+$s3 O que devemos fazer no MIPS?

#$t1=Memory[$a0+$s3]

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 O que devemos fazer no MIPS? Outros: load multiple/store multiple Um registrador contador especial bc Loop decrementar o contador, e se no for 0 vai para loop

Intel 80x86
A partir do 80386 , tambm chamado de IA-32 1978: Intel 8086 anunciado (arquitetura de 16 bits) 1980: 8087 adicionado o coprocessador de ponto flutuante 1982: 80286 aumenta o espao de endereamento para 24 bits, + instrues 1985: 80386 estende para 32 bits, novos modos de endereamento 1989-1995: 80486, Pentium, Pentium Pro e algumas novas instrues (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

Uma arquitetura dominante: 80x86


Complexidade: Instrues de 1 a 17 bytes um operando deve agir como fonte e destino um operando pode vir da memria Modos de endereamento complexos p.ex., base ou scaled index com deslocamento de 8 ou 32 bit Salvando a graa: As instrues mais frequentemente usadas no so to difceis de serem construidas Os compiladores evitam as pores da arquitetura que so lentas what the 80x86 lacks in style is made up in quantity, making it beautiful from the right perspective

Você também pode gostar