arquitetura do conjunto de instruções – isa - aula - 02

5/17/2018 Arquitetura do conjunto de instru es ISA - Aula - 02 - slidepdf.com

http://slidepdf.com/reader/full/arquitetura-do-conjunto-de-instrucoes-isa-aula-02 1/38

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



Arquitetura do Conjunto de InstruçõesInstruction Set Architecture (ISA)

Conjunto de instruções

software

hardware



Computador de von Neumann

- instruções e dados na mesmamemória

- as instruções são lidas damemória e executadasna 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 leiturae execução das instruções

http://pt.wikipedia.org/wiki/Imagem:Von_Neumann_architecture.png



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 eprocessadores 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



Abstração

• Descendo no nívelde abstraçõesrevelam-se outrasinformações

swap(int v[], int k)

{int temp;temp = v[k];

v[k] = v[k+1];

v[k+1] = temp;

}

swap:

muli $2, $5,4add $2, $4,$2lw $15, 0($2)

lw $16, 4($2)

sw $16, 0($2)sw $15, 4($2)

jr $31

00000000101000010000000000011000

0000000010001110000110000010000110001100011000100000000000000000

10001100111100100000000000000100

1010110011110010000000000000000010101100011000100000000000000100

00000011111000000000000000001000

Binary machinelanguageprogram(for MIPS)

C compiler

Assembler

Assembly

languageprogram(for MIPS)

High-levellanguageprogram(in C)



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



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



Que operações são necessáriasAritmé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



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



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, $s2

(associado às variáveis pelo compilador)



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



Registradores vs. Memória

Processor I/O

Control

Datapath

Memory

Input

Output

• 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?



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.

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



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, ... 232

-4• Words são alinhados:

O que significam os dois bits menos significativos de um endereçode word?

0

4

812

...

32 bits of data

32 bits of data

32 bits of data

32 bits of data

Os registradores carregam dados de

32 bits



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 dememória!



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 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



• 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

000000 10001 10010 01001 00000 100000

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

35 18 9 32

Linguagem de Máquina



• 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 podemtambé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 Memorymemory for data, programs,

compilers, editors, etc.

Conceito de Programa Armazenado na

memória (von Neumann)



• 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, Labelbeq $t0, $t1, Label

• Exemplo: if (i==j) h = i + j;

bne $s0, $s1, Labeladd $s3, $s0, $s1

Label: ....

Instruções de Controle



• Instruções de salto incondicional 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: ...

Instruções de Controle



Revisã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 Next instr. is at Label if $s4 = $s5

beq $s4,$s5,L Next instr. is at Label if $s4 = $s5j Label Next instr. is at Label

• Formatos:

op rs rt rd shamt functop rs rt 16 bit address

op 26 bit address

R

I

J



• 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

Fluxo de Controle



Regra para o uso de registradores

Name Register number Usage

$zero 0 the constant value 0

$v0-$v1 2-3 values for results and expression evaluation

$a0-$a3 4-7 arguments$t0-$t7 8-15 temporaries

$s0-$s7 16-23 saved

$t8-$t9 24-25 more temporaries

$gp 28 global pointer

$sp 29 stack pointer$fp 30 frame pointer

$ra 31 return address



• Constantes pequenas são usadas frequentemente (50% dosoperandos)

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

Constantes



• Gostariamos de carregar constantes de 32 bits em um registrador

• Devemos usar duas instruções, a instrução "load upper immediate"lui $t0, 1010101010101010

• Então devemos carregar os bits menos significativos à direita, i.e.,

ori $t0, $t0, 1010101010101010

1010101010101010 0000000000000000

0000000000000000 1010101010101010

1010101010101010 1010101010101010

ori

1010101010101010 0000000000000000

Preenchido com zeros

E as constantes maiores?



• 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

Ling. Assembly vs. Ling. de

Máquina



• 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

op rs rt rd shamt funct

op rs rt 16 bit address

op 26 bit address

R

IJ

Visão geral do MIPS



• 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

op 26 bit address

I

J

Endereços em Branchs e Jumps



• Instruções

bne $t4,$t5,Label A próxima instrução é no Label se $t4<>$t5beq $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 addressI

Endereços em Branchs

R i d



Resumindo:

MIPS operands

Name 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

230

memor Memory[4], ..., sequential words differ by 4. Memory holds data structures, such as arrays,

words Memory[4294967292] and spilled registers, such as those saved on procedure calls.

Posição rápida para os dados: os dados devem estar em registradorespara realizar aritmética

Registrador $zero sempre contem valor 0Registrador $at é reservado para o assembler manipular constantes grandes

Memória: acessada somente por instruções de transferência de dadosEndereçado por bytes, tal que as palavras seqüenciais difiram de 4 no endereçoMemória contem estrutura de dados, como arrays, e valores de registradores que

transbordaram



MIPS assembly language

Category Instruction Example Meaning Commentsadd add $s1, $s2, $s3 $s1 = $s2 + $s3 Three operands; data in registers

Arithmetic subtract sub $s1, $s2, $s3 $s1 = $s2 - $s3 Three operands; data in registers

add immediate addi $s1, $s2, 100 $s1 = $s2 + 100 Used to add constants

load w ord lw $s1, 100($s2) $s1 = Memory[$s2 + 100 Word from memory to register

store w ord sw $s1, 100($s2) Memory[$s2 + 100] = $s1 Word f rom register to memory

Data transfer load byte lb $s1, 100($s2) $s1 = Memory[$s2 + 100 Byte from memory to register

store byte sb $s1, 100($s2) Memory[$s2 + 100] = $s1 Byte from register to memoryload upper

immediate

lui $s1, 100 $s1 = 100 * 216 Loads constant in upper 16 bits

branch on equal beq $s1, $s2, 25 if ($s1 == $s2) go to

PC + 4 + 100

Equal test; PC-relative branch

Conditional

branch on not equal bne $s1, $s2, 25 if ($s1 != $s2) go to

PC + 4 + 100

Not equal test; PC-relative

branch set on less than slt $s1, $s2, $s3 if ($s2 < $s3) $s1 = 1;else $s1 = 0

Compare less than; for beq, bne

set less than

immediate

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

else $s1 = 0

Compare less than constant

jump j 2500 go to 10000 Jump to target address

Uncondi- jump register jr $ra go to $ra For sw itch, procedure return

tional jump jump and link jal 2500 $ra = PC + 4; go to 10000 For procedure call

1 I di t dd i



Byte Halfword Word

Registers

Memory

Memory

Word

Memory

Word

Register

Register

1. Immediate addressing

2. Register addressing

3. Base addressing

4. PC-relative addressing

5. Pseudodirect addressing

op rs rt

op rs rt

op rs rt

op

op

rs rt

Address

Address

Address

rd . . . funct

Immediate

PC

PC

+

+



• 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

Arquiteturas Alternativas



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 sobreelementos 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 não for 0 vai para loop



Intel 80x86A partir do 80386 , também chamado de IA-32

• 1978: Intel 8086 é anunciado (arquitetura de 16 bits)

• 1980: 8087 é adicionado o coprocessador de ponto flutuante

• 1982: 80286 aumenta o espaço de endereçamento para 24 bits, +instruções

• 1985: 80386 estende para 32 bits, novos modos de endereçamento

• 1989-1995: 80486, Pentium, Pentium Pro e algumas novasinstruçõ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”



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 complexosp.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íceisde 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”

arquitetura do conjunto de instruções – isa - aula - 02

Documents