Organiza ção e Arquitetura de computadores -...

OrganizaOrganizaçção e Arquitetura ão e Arquitetura de computadoresde computadores

Prof. Dr. Luciano José Senger

Instruções: a linguagem de máquina

ConteConteúúdodo• Introdução• Operações no hardware do computador• Operandos do hardware do computador• Representando instruções no computador• Operações lógicas• Instruções para tomada de decisões • Suporte para procedimentos no hardware do computador• Comunicando-se com as pessoas • Endereçamento no MIPS para operados imediatos e endereços de 32

bits• Traduzindo e iniciando um programa• Como os compiladores otimizam • Um exemplo de ordenação na linguagem C para juntar tudo isso• Vida real: instruções do IA-32• Falácias e armadilhas• Comentários finais• Leituras e exercícios

IntroduIntroduççãoão

• Para controlar o hardware do computador, énecessário falar a sua linguagem

• Palavras da linguagem do computador são chamadas de instruções = vocabulário é chamado de conjunto de instruções

• Apresentação das instruções através de uma abordagem top-down

• Linguagens de computadores são semelhantes (entre diferentes arquiteturas), ao contrário da linguagem dos humanos

IntroduIntroduççãoão

• É fácil ver, por métodos lógicos formais, que existem certos [conjuntos de instruções] que são adequados para controlar e causar a execução de qualquer seqüência de operações... As considerações decisivas, do ponto de vista atual, na seleção de um [conjunto de instruções], são mais de natureza prática: a simplicidade do equipamento exigido pelo [conjunto de instruções] e a clareza de sua aplicação para os problemas realmente importantes, junto com a velocidade com que tratam esses problemas– Burks, Goldstine e von Neumann, 1947

• Conjunto de instruções (a ponta do iceberg)

• Exemplo: MIPS (http://en.wikipedia.org/wiki/MIPS_architecture)– Conjunto de instruções criados a partir da década de 80

– 100 milhões de processadores fabricados em 2002

– ATI, Broadcom, Cisco, NEC, Nintendo, SiliconGraphics, Sony, Texas Instruments e Toshiba

• Processador RISC (conjunto reduzido de instruções)– Tamanho de instruções fixo (fixed instruction lengths)– Instruções de load-store (load-store instruction sets)– Modos de endereçamento limitado (limited addressing modes)– Operações limitadas (limited operations)

IntroduIntroduççãoão IntroduIntroduççãoão

• Arquiteturas de programa armazenado

• Control necessita1. Instruções de entrada da

memória2. Sinais para controlar o fluxo de

informação entre oscomponentes do caminho de dados

3. Sequenciamento de instruções

Fetch

DecodeExec

CPU

Control

Datapath

Memory Devices

Input

Output

• Datapath tem– componentes – unidades funcionais e banco de registradores– Interconexões - componentes que são conectados de forma que as

instruções possam ser executadas e os dados possam ser trazidos e armazenados na memória

ConteConteúúdodo

• Introdução ��• Operações no hardware do computador• Operandos do hardware do computador• Representando instruções no computador• Operações lógicas• Instruções para tomada de decisões • Suporte para procedimentos no hardware do computador• Comunicando-se com as pessoas • Endereçamento no MIPS para operados imediatos e endereços de 32


OperaOperaçções do hardware do computadorões do hardware do computador

• Todo computador precisa realizar operações aritméticasadd a, b, c

• Instrui o computador para realizar a soma entre as variáveis b e c e armazenar o resultado em a

• Exemplo: colocar a soma de b, c, d, e e na variável a:

• Em linguagem de alto nível a = b + c + d + e• Em Assembly MIPS:

add a, b, c # soma b+c é colocada em a

add a, a, d # soma b+c+d está em a

add a, a, e # soma b+c+d+e está em a


• O número natural de operandos para uma operação de adição é três

• Exigir que cada instrução tenha exatamente três operações nem mais nem menos, está de acordo com manter o hardware simples: o hardware para um número variável de operandos é mais complicado do que o hardware para um número fixo:

• Princípio de projeto 1: simplicidade favorece a regularidade


• Contra-exemplo: IA-32 (p.e. Pentium)– ADD AX,BX

• Compilando duas instruções de atribuição C no MIPS:

a = b + c;

d = a – e;

– a tradução é realizada pelo compilador

– Em MIPS:

add a, b, c

sub d, a, e

OperaOperaçções no hardware do computadorões no hardware do computador

• Compilando uma instrução complexa no MIPSf = (g + h) – (i + j)

• O compilador precisa desmembrar essa instrução em várias instruções assembly, pois somente uma operação érealizada por instrução MIPS

add t0, g, h # var. temp. t0 contém g+h

add t1, i, j # var. temp. t1 contém i+j

sub f, t0, t1 # f recebe t0 – t1

• Note que uma expressão na linguagem C gera 3 instruções assembly para o MIPS

• Reflexão: um número maior de instruções de máquina por expressão é melhor ou pior?

ConteConteúúdodo• Introdução ��• Operações no hardware do computador ��• Operandos do hardware do computador• Representando instruções no computador• Operações lógicas• Instruções para tomada de decisões • Suporte para procedimentos no hardware do computador• Comunicando-se com as pessoas • Endereçamento no MIPS para operados imediatos e endereços de 32


OperandosOperandos no hardware do computadorno hardware do computador

• Ao contrário dos programas nas linguagens de alto nível, os operandos das instruções aritméticas são restritos, precisam ser de um grupo limitado de locais especiais, embutidos diretamente no hardware, chamados registradores (registers)

• Os registradores são os tijolos da construção do computador – primitivas usadas no projeto do computador e são visíveis para o programador

• O tamanho dos registrados na arquitetura MIPS é32 bits; grupos de 32 bits ocorrem com tanta freqüência no MIPS que recebem o nome de palavra (word)


n.a.reserved for assembler1$at

yesreturn addr (hardware)31$rayesframe pointer30$fpyesstack pointer29$spyesglobal pointer28$gpnotemporaries24-25$t8 - $t9yessaved values16-23$s0 - $s7notemporaries8-15$t0 - $t7yesarguments4-7$a0 - $a3noreturned values2-3$v0 - $v1

n.a.constant 0 (hardware)0$zero

Preserve on call?

UsageRegister Number

Name


• Uma diferença entre variáveis de um programa em linguagem de alto nível e os registradores é que o número de registradores é limitado

• O computador MIPS tem 32 registradores• Princípio de projeto 2: menor significa mais rápido

– Uma quantidade muito grande de registradores pode aumentar o tempo do ciclo de clock simplesmente porque os sinais eletrônicos levam mais tempo quando precisam atravessar uma distância maior

• Deve-se equilibrar o “desejo” dos programas por mais registradores com o desejo do projetista de manter o ciclo de clock mais rápido

• Um número maior de registradores necessita de um número maior de bits para representação: influência no tamanho da instrução


• A convenção no MIPS é usar nomes com um sinal de $ seguido de dois caracteres para representar um registrador.– $S0, $S1, $T0, $T1

• Compilando uma atribuição em C usando registradores:f = (g + h) – (i + j)

add $t0, $s1, $s2

add $t1, $s3, $s4

sub $s0, $t0, $t1


• Operandos na memória– Operações aritméticas só ocorrem com os registradores

nas instruções MIPS; assim o MIPS deve ter instruções que transferem os dados entre o processador e a memória: instruções de transferência de dados

– Para acessar uma word na memória, é necessário passar o endereço de memória a ser utilizado


• A instrução que copia dados da memória para um registrador tradicionalmente é chamada de load

• O formato da instrução load é o nome da operação seguido pelo registrador a ser carregado, depois uma constante e o registrador usado para acessar a memória.

• A soma da parte constante da instrução com o conteúdo do segundo registrador forma o endereço de memória


• Compilando uma atribuição quando um operando está na memória– Vamos supor que A seja uma sequência de 100 words e

que o compilador tenha associado as variáveis g e h aos registradores $s1 e $s2. Vamos supor que o endereço inicial da seqüência esteja no endereço armazenado em $s3 (endereço base)

g = h + A[8];

– embora haja uma única operação nessa instrução de atribuição, um dos operandos está na memória, de modo que precisamos transferir A[8] para um registrador ($s3 contém elemento base) :

lw $t0, 8($s3)

#registrador temporário recebe A[8]

OperandosOperandos no hardware de computadorno hardware de computador

• Compilando uma atribuição quando um

operando está na memória (cont.)

– A instrução seguinte (add) pode operar sobre o valor

em $t0, já que é um registrador:

lw $t0, 8($s3)

add $s1, $s2, $t0

– A constante na instrução é chamada de offset e o

registrador acrescentado para formar o endereço é

chamado de registrador base


• Interface hardware/software– Além de associar variáveis a registradores, o compilador aloca

estrutura de dados, como vetores, em locais na memória– Como os bytes de 8 bits são úteis em muitos programas, a maioria

das arquiteturas endereça bytes individuais– Endereços de words combinam os endereços dos 4 bytes dentro da

palavra

• No MIPS, palavras precisam começar em endereços que sejam múltiplos de 4


• No MIPS, palavras precisam começar em endereços que sejam múltiplos de 4 (restrição de alinhamento)

• O endereçamento em bytes afeta o índice do array: para obter o endereço em bytes de maneira apropriada o offset necessita ser igual a 4x8=32

• A instrução complementar ao load chama-se store; ela copia dados de um registrador para a memória

• A instrução store é representada pelo mnemônico sw

OperandosOperandos no hardware do computador no hardware do computador

• Compilando com load e store

– Suponha que a variável h esteja associada ao registrador $s2 e o endereço base do vetor A esteja armazenado em $s3. Qual código assembly do MIPS para a instrução de atribuição C a seguir?

– A[12] = h + A[8]

– Embora seja uma instrução na linguagem C, dois operandos estão na memória; são necessárias instruções para buscar os dois operandos da memória:

lw $t0, 32($s3) # reg. temp. $t0 recebe A[8]

add $t0, $s2, $t0 # reg. temp. $t0 recebe h + A[8]

sw $t0, 48($s3) # armazena resultado em A[12]


• Interface hardware/software– Muitos programas têm mais variáveis do que os computadores têm

registradores– O compilador tenta manter as variáveis mais utilizadas nos

registradores e coloca as restantes na memória, usando load e storepara movimentar os dados

– O processo de colocar variáveis menos utilizadas na memória ou aquelas que só serão empregadas mais tarde é denominado spillingregisters

– Registradores, apesar de serem mais reduzidos e terem um tamanho menor que a memória principal, são mais rápidos: isso define a preocupação com a utilização correta dos registradores

• Constantes ou operandos imediatos– Muitas vezes, os valores que necessitam ser trabalhados são

passados na instrução como constantes, e não como endereços de memória; quando os dados são passados dessa forma, como constantes, é utilizado o modo de endereçamento imediato


• Trabalhando com constantes– Usando apenas instruções, teríamos de ler uma

constante da memória para utilizá-la:lw $t0, EndConstante4($s1)

add $s3, $s3, $t0

– Supondo que EndConstante4 seja o endereço de memória para a constante 4

– Uma alternativa que evita a instrução load, e assim uma leitura em memória, é oferecer instruções aritméticas em que o operando seja uma constante

– Essa instrução (no caso de uma soma) é chamada de add imediato, ou addi:

addi $s3, $s3, 4 # $s3 = $s3 + 4


• Trabalhando com constantes (cont.)

– Princípio de projeto 3: agilize os casos mais comuns

– Os operandos com constantes ocorrem com bastante

freqüência e, incluindo constantes dentro das instruções

aritméticas, as operações tornam-se mais rápidas para

serem executadas

ConteConteúúdodo

• Introdução ��• Operações no hardware do computador ��• Operandos do hardware do computador ��• Representando instruções no computador

• Operações lógicas• Instruções para tomada de decisões • Suporte para procedimentos no hardware do computador• Comunicando-se com as pessoas • Endereçamento no MIPS para operados imediatos e endereços de 32


Representando instruRepresentando instruçções no computadorões no computador

• Embora quando programa-se em assembly utiliza-se mnemônicos (como lw, sw, add e sub), as instruções são representadas e executadas através de um conjunto de bits

• Além disso, como os registradores são parte de quase todas as instruções, é preciso haver uma convenção para mapear os nomes dos registradores em números binários– $s0 a $s7 são mapeados nos registradores de 16 a 23;– $t0 a $t7 são mapeados nos registradores de 8 a 15;

• Exercício: qual é o código binário para o registrador $s7?


• Traduzindo uma instrução assembly MIPS para uma instrução de máquina:

add $t0, $s1, $s2

320818170

• Cada um desse segmentos de uma instrução é chamado campo; o primeiro e o último campos combinados dizem ao computador MIPS que essa instrução realiza soma

• O segundo campo indica o número do registrador que é o primeiro operando de origem da operação de soma (17 = $t1)

• O terceiro campo indica o outro operando de origem (18 = $t2)• O quarto campo contém o número do registrador que receberá o

resultado (8 = $s0)• O quinto campo não é empregado nessa instrução


• Esse layout da instrução é chamado de formato de instrução

• As instruções no MIPS tem todas 32 bits de tamanho• Os campos do MIPS

– op: operação básica, tradicionalmente chamada de opcode– rs: o registrador do primeiro operando de origem– rt: o registrador do segundo operando de origem– rd: o registrador do operando de destino– shamt: shift amount; quantidade de deslocamento– funct: função; esse campo seleciona a variante específica da

operação no campo op, e as vezes, é chamado de código de função

Funct

(6 bits)

shamt

(5 bits)

rd

(5 bits)

rt

(5 bits)

rs

(5 bits)

op

(6 bits)


• Problemas de endereçamento– Existe um problema quando uma instrução precisa de campos

maiores do que aqueles mostrados. Por exemplo, a instrução lwprecisa especificar dois registradores e uma constante; se o endereço tivesse apenas 5 bits do formato anterior, a constante estaria limitada a 32 (2^5)

– Existe então um conflito entre manter entre o desejo de manter todas as instruções com o mesmo tamanho e o desejo de ter uma instrução único

– Princípio de Projeto 4: um bom projeto exige bons compromissos– O compromisso escolhido pelos projetistas do MIPS é manter todas

as instruções com o mesmo tamanho, exigindo assim diferentes formatos para os campos para diferentes tipos de instruções

– O formato anterior é chamado de tipo R (de registrador) ou formato R.

– Um segundo tipo de formato de instrução é chamado de formato I, utilizando pelas instruções imediatas e de transferência de dados.


• Formato IConstante ou endereço

(16 bits)

rt

(5 bits)

rs

(5 bits)

op

(6 bits)

– O endereço de 16 bits significa que uma instrução lw pode carregar qualquer word dentro de uma região de +/- 2^15 do endereço do registrador base (8192 words)

– De modo semelhante, a soma imediata é limitada a constantes que não sejam maiores do que 2^15

lw $t0, 32($s3)

– Aqui, 19 (para $s3) é colocado no campo rs, 8 (para $t0) é colocado no campo rt e 32 é colocado no campo de endereço (veja que o formato mudou: o campo rt especifica o registrador de destino, que recebe o resultado do lw


• Traduzindo do assembly MIPS para a linguagem de máquina– Se $t1 possui a base do array A e $s2 corresponde a h:

– A[300] = h + A[300];– É compilada para:

lw $t0, 1200($t1) # reg. $t0 recebe A[300]

add $t0, $s2, $t0 # reg. $t0 recebe h + A[300]

sw $t0, 1200($t1) # armazena h +A[300] na mem.

12008935

12008943

32088180


– A instrução lw é representada por 35 no opcode

– O registrador base 9 ($t1) é especificado no segundo campo (rs) e o

registrador de destino 8 ($t0) é especificado no terceiro campo (rt)

– O offset para selecionar A[300] (1200=300x4) aparece no campo final

– A instrução add é especificada com opcode 0 e funct 32

– A instrução sw é identificada com 43 no opcode

– Importante: lembre-se que os valores estão representados em

decimal, mas na verdade são representados em binário.

12008935

12008943

32088180


• Por que o MIPS não tem uma instrução de

subtração imediata?

– Constantes negativas aparecem com muito menos

frequência em C e Java, e por isso não são o caso

comum e não merecem suporte especial

– Como o campo imediato mantém constantes negativas

e positivas, a soma imediata de um valor negativo é

igual a subtração imediata com um número positivo, de

modo que a subtração imediata é supérflua

ConteConteúúdodo

• Introdução ��• Operações no hardware do computador ��• Operandos do hardware do computador ��• Representando instruções no computador ��• Operações lógicas

• Instruções para tomada de decisões • Suporte para procedimentos no hardware do computador• Comunicando-se com as pessoas • Endereçamento no MIPS para operados imediatos e endereços de 32


OperaOperaçções lões lóógicasgicas

• Embora o projeto do primeiros computadores se

concentrasse em words completas, logo ficou claro que é

útil atuar sobre campos de bits de uma word

– Operações lógicas servem para empacotar e desempacotar grupos

de bits em words

nor~~NOT bit a bit

or, ori||OR bit a bit

and, andi&&AND bit a bit

srl>>>>Shift a direita

sll<<<<Shift a esquerda

Instruções MIPSOperadores JavaOperadores COperações lógicas


• Operações de deslocamento (shifts)– Movem todos os bits de uma word para esquerda ou

para direita, preenchendo com zero os bits que ficaram vazios

– Shift left logical:

sll $t2, $s0, 4 # reg $t2 = reg $s0 << 4 bits

– O campo da instrução MIPS chamado de shamt (shiftamount) é usado nas instruções de deslocamento

– ssl é codificada com zeros nos campos op e funct, rdcontém $t2, rt contém $s0 e shamt contém 4

– rs não é utilizado.

0 (funct)4 (shamt)10 (rd)16 (rt)0 (rs)0 (op)


• Operações de deslocamento

– O deslocamento lógico à esquerda de i bits gera o mesmo

resultado que multiplicar por 2^i

• Operações lógicas

– A operação AND é útil para isolar bits de uma palavra (operações

com máscara)

and $t0, $t1, $t2 # $t0 = $t1 & $t2

– Para colocar um bit em 1 em um grupo de bits, pode-se utilizar a

operação OR

or $t0, $t1, $t2 # $t0 = $t1 | $t2


• Operações lógicas– Os projetistas do MIPS decidiram incluir a instrução

NOR no lugar de NOT: se um operando for zero, a instrução é equivalente a NOT:

• A NOR 0 = NOT (A OR 0) = NOT (A)

nor $t0, $t1, $t3 # $t0 = ~($t1 | $t3)

– O MIPS oferece instruções lógicas para trabalhar com

constantes (modo de endereçamento imediato)

• AND imediato (andi)

• OR imediato (ori)

ConteConteúúdodo

• Introdução ��• Operações no hardware do computador ��• Operandos do hardware do computador ��• Representando instruções no computador ��• Operações lógicas ��• Instruções para tomada de decisões

• Suporte para procedimentos no hardware do computador• Comunicando-se com as pessoas • Endereçamento no MIPS para operados imediatos e endereços de 32


InstruInstruçções para tomada de decisõesões para tomada de decisões

• O que diferencia o computador de uma calculadora simples é a capacidade de tomar decisões– Em linguagens de alto nível: if, else, goto

• Instruções de desvio condicional no MIPS– Branch if equal (desvie se igual)

beq registrador1, registrador2, L1

– Essa instrução significa ir até a instrução rotulada por L1 se o valor no registrador1 for igual ao valor no registrador2

– O rótulo é alterado pelo compilador por endereços de memória


• Instruções de desvio condicional no MIPS– Branch if not equal (desvie se não for igual)

Bne registrador1, registrador2, L1

– Significa desviar o fluxo de execução para o rótulo L1caso os valores contidos nos registradores registrador1 e registrador2 forem diferentes

• Compilando if-then-else em desvios condicionais– No segmento de código a seguir f, g, h, i e j são

variáveis. Se as cinco variáveis correspondem aos cinco registradores de $s0 a $s4, qual é o código compilado para esta instrução if em C?

if (i == j) f = g + h; else f = g – h;


bne $s3, $s4, Else

add $s0, $s1, $s2

j Exit

Else: sub $s0, $s1, $s2

Exit:

A instrução j implementa o desvio incondicional (jump)


• Interface hardware/software– Compiladores criam estruturas mais próximas a

linguagem humana como while, do until, etc.– Compilando um loop while em C

While (save[i] == k)

i+= 1;

– Suponha que i e k correspondam aos registradores $s3 e $s5 e base do vetor save esteja em $s6. Qual o código em MIPS que corresponde a esse segmento C?


loop: sll $t1, $s3, 2 # $t1 = 4 * i

add $t1, $t1, $s6 # $t1 = endereço de save[i]

lw $t0, 0($t1) #$t0 = save[i]

bne $t0, $s5, Exit # vá para Exit se save[i] <> k

addi $s3, $s3, 1 # i += 1

j Loop

Exit:

While (save[i] == k)

i+= 1;

Suponha que i e k correspondam aos registradores $s3 e $s5 e base do vetor save esteja em $s6. Qual o código em MIPS que corresponde a esse segmento C?


• Bloco básico– Uma seqüência de instruções sem desvios (exceto, possivelmente

no final) e sem destinos de desvio ou rótulos de desvio (exceto, possivelmente, no início

– Uma das primeiras fases da compilação é desmembrar o programa em blocos básicos

• Testes de igualdade em assembly MIPS– Comparações são realizadas de forma que a instrução compara

dois registradores e atribui 1 a um terceiro registrador se o primeiro for menor que o segundo; caso contrário, é atribuído 0

– Set on less than (atribuir se menor que)slt $t0, $s3, $s4

– Significa que é atribuído 1 ao registrador $t0 se o valor no registrador $s3 for menor que o valor no registrador $s4


• Testes de igualdade em assembly MIPS– Operadores constantes são populares nas comparações– Como o registrador $zero sempre tem 0, pode-se

comparar com zero; para comparar com outros valores, existe uma versão com endereçamento imediato da instrução slt:

slti $t0, $s2, 10 # $t0 =1 se $s2 < 10

• Interface hardware/software– Os compiladores MIPS utilizam as instruções slt, slti,

beq, bne e o valor fixo 0 para criar todas as condições relativas: igual, diferente, menor que, menor ou igual,maior que, maior ou igual

– Assim, as construções lógicas de linguagens de alto nível, como C e Java, são mapeadas em instruções assembly de desvio condicional

ConteConteúúdodo• Introdução ��• Operações no hardware do computador ��• Operandos do hardware do computador ��• Representando instruções no computador ��• Operações lógicas ��• Instruções para tomada de decisões ��• Suporte para procedimentos no hardware do computador• Comunicando-se com as pessoas • Endereçamento no MIPS para operados imediatos e endereços de 32

bits• Traduzindo e iniciando um programa• Como os compiladores otimizam • Um exemplo de ordenação na linguagem C para juntar tudo isso• Arrays versus ponteiros• Vida real: instruções do IA-32• Falácias e armadilhas• Leituras e exercícios

Suporte para procedimentosSuporte para procedimentos

• Procedimentos ou funções – construções das linguagens de programação que

servem para estruturar programas, tornando-os mais fáceis de entender, depurar e reutilizar

– Seis etapas1. Colocar parâmetros em um lugar onde o procedimento possa

acessá-lo2. Transferir o controle para o procedimento3. Adquirir os recursos de armazenamento necessários para o

procedimento4. Realizar a tarefa desejada5. Colocar o valor de retorno em um local onde o programa que

o chamou possa acessá-lo6. Retornar o controle para o ponto de origem , pois um

procedimento pode ser chamado de vários pontos de um programa

Suporte para procedimentosSuporte para procedimentos

• O software do MIPS utiliza a seguinte convenção na alocação de seus 32 registradores para chamada de procedimentos:– $a0 - $a3: quatro registradores de argumento, para

passar parâmetros;– $v0 - $v1: dois registradores de valor, para valores de

retorno– $ra: um registrador de endereço de retorno, para

retornar ao ponto de origem do programa que efetuou a chamada

– Além de alocar esses registradores, o assembly do MIPS inclui uma instrução apenas para os procedimentos: ela desvia para um endereço e simultaneamente salva o endereço da instrução seguinte no registrador $ra(instrução jump-and-link)

Suporte a procedimentos no hardwareSuporte a procedimentos no hardware

• Instrução jump-and-link (jal)– Jal EnderecoProcedimento– O “link” é armazenado no registrador $ra, denominado endereço

de retorno– Implícita na idéia de programa armazenado é a necessidade de ter

um registrador para manter o endereço da instrução atual que estásendo executada, chamado de contador de programa ou PC (program counter)

– A instrução jal salva PC+4 no registrador $ra para o link com a instrução seguinte, a fim de preparar o retorno do procedimento

– Para apoiar tais situações, computadores como o MIPS utilizam uma instrução de jump register (jr), significando um desvio incondicional para o endereço especificado no registrador:

Jr $ra– Assim, o programa que chama o procedimento, coloca os valores

de parâmetro em $a0 - $a3 e utiliza jal X par desviar para o procedimento X.

– O procedimento X realiza as suas operações, coloca os resultados em $v0 - $v1 e retorna o controle para o caller usando jr $ra


• Usando mais registradores– Suponha que um compilador precise de mais

registradores para um procedimento do que os quatro disponíveis: utiliza-se a pilha (stack)

• Pilha– Estrutura de dados – fila em que o último que entra é o

primeiro que sai– Stack pointer é ajustado em uma word para cada

registrador salvo ou restaurado• Push insere itens• Pop remove itens

– O MIPS tem o registrador $sp, stack pointer, usado para salvar os registradores necessários pelo procedimento chamado

– As pilhas crescem de endereços maiores para menores


• Compilando um procedimento em Cint exemplo_folha (int g, int h, int i, int j){

int f;

f = ( g + h ) – ( i + j );

Return f;

}

– As variáveis de parâmetro g, h, i e j correspondem ao registradores de argumento $a0 - $a3 e f corresponde a $s0

exemplo_folha:

addi $sp, $sp, -12 # ajusta a pilha (3 itens)

sw $t1, 8($sp) # salva registrador


sw $s0, 0($sp) # salva registrador


exemplo_folha:





add $t0, $a0, $a1 # $t0 contém g+h

add $t1, $a2, $a3 # $t1 contém i+j

sub $s0, $t0, $t1 # f = (g+h) – (i+j)

add $v0, $s0, $zero # copia f para reg. de retorno


• Preparando o retorno

exemplo_folha:





add $t0, $a0, $a1 # $t0 contém g+h

add $t1, $a2, $a3 # $t1 contém i+j

sub $s0, $t0, $t1 # f = (g+h) – (i+j)

add $v0, $s0, $zero # copia f para reg. de retorno

lw $s0, 0($sp)

lw $t0, 4($sp)

lw St1, 8($sp)

addi $sp, $sp, 12 # exclui 3 itens da pilha

jr $ra


• O software do MIPS separa 18 dos registradores em dois grupos (convenção)– $t0-$t9: 10 registradores temporários que não são

preservados pelo procedimento chamado– $s0-$s7: 8 registradores que precisam ser preservados

em uma chamada (se forem usados, o procedimento chamado os salva e restaura)

• Procedimentos aninhados– A solução é empilhar os valores dos registradores que

vão ser utilizados• Código que chama: empilha $a?, $t?• Procedimento chamado: empilha $ra e registradores usados por

ele• Resumo: sempre é interessante empilhar registradores usados

pelo procedimento

Suporte a procedimentos no hardwareSuporte a procedimentos no hardwareint fact (int n){

if (n < 1) return(1);

else return (n * fact(n-1));

}

fact:

addi $sp, $sp, -8 # ajusta pilha para 2 itens

sw $ra, 4($sp) # salva endereço de retorno

sw $a0, 0($sp) # salva o argumento n

slti $t0, $a0, 1 # teste para n < 1

beq $t0, $zero, L1 # se n>= 1, desvia para L1

addi $v0, $zero, 1 # prepara o “retorna 1”

addi $sp, $sp, 8 # retira dois itens da pilha

jr $ra # retorna

L1:

addi $a0,$a0, -1 # argumento recebe n-1

jal fact # chama fact com n-1

lw $a0, 0($sp) # retorna de jal: restaura o arg. N

lw $ra, 4($sp) # restaura o endereço de retorno

addi $sp, $sp, 8 # ajusta pilha para remover 2 itens

mul $v0, $a0, $v0 # calcula n * fact(n-1)

jr $ra # retorna para o procedimento que chamou


• Interface hardware/software– Uma variável em C é um local na memória, e sua interpretação

depende tanto do seu tipo quanto da classe de armazenamento– A linguagem C possui duas classes de armazenamento: estáticas e

automáticas– As variáveis automáticas são locais a um procedimento e são

descartadas quando o procedimento termina.– As variáveis estáticas permanecem durante entradas e saídas de

procedimento– As variáveis C declaradas fora de procedimentos são consideradas

estáticas, assim como as variáveis declaradas dentro de procedimento com a palavra reservada static

– Para simplificar o acesso aos dados estáticos, o software do MIPS reserva outro registrador, chamado de ponteiro global, e referenciado como $gp

– $gp é um ponteiro global que referencia a memória para facilitar o acesso através de operações simples de load e store.


• Reservando espaço para novos dados na pilha– A pilha também é utilizada para armazenar variáveis

que são locais ao procedimento, que não cabem nos registradores, como arrays ou estruturas locais

– O segmento da pilha que contém todos os registradores salvos e as variáveis locais de um procedimento échamado de frame de procedimento ou registro de ativação


• Reservando espaço para novos dados no heap– Além de variáveis que são locais ao procedimentos,

programadores precisam de espaço para variáveis estáticas e para estrutura de dados dinâmicas

O segmento de um

arquivo-objeto Unix que

contém o código em

linguagem de máquina

para as rotinas do

arquivo-fonte


• Reservando espaço para novos dados no heap– A forma de reservar memória permite que a pilha e o

heap cresçam um em direção ao outro, permitindo o uso eficiente da memória enquanto os dois segmentos aumentam e diminuem

– A forma pela qual os endereços são usados são convenções do software e não fazem parte da arquitetura MIPS

– A linguagem C aloca e libera espaço no heap com funções explícitas

• malloc(): aloca espaço no heap

• free(): libera espaço no heap

ConteConteúúdodo

• Introdução ��• Operações no hardware do computador ��• Operandos do hardware do computador ��• Representando instruções no computador ��• Operações lógicas ��• Instruções para tomada de decisões ��• Suporte para procedimentos no hardware do computador ��• Comunicando-se com as pessoas

• Endereçamento no MIPS para operados imediatos e endereços de 32 bits

• Traduzindo e iniciando um programa• Como os compiladores otimizam • Um exemplo de ordenação na linguagem C para juntar tudo isso• Vida real: instruções do IA-32• Falácias e armadilhas• Comentários finais• Leituras e exercícios

ComunicandoComunicando--se com as pessoasse com as pessoas

• Representação de caracteres– Código ASCII de 8 bits– Computadores necessitam de instruções que realizem a

movimentação de grupos de bits de palavraslb $t0, 0($sp)

Sb $t0, 0($sp)

– Caracteres são representados por conjuntos de strings, com geralmente três opções para representação:

• A primeira posição da string é reservada para indicar o tamnhode uma string;

• Uma variável acompanhante possui o tamanho da string (como uma estrutura);

• A última posição da string é ocupada por um caractere que serve para marcar o final da string ( ‘\0’ na linguagem C; ‘$’x86)


• Compilando um procedimento de cópia de string para demonstrar o uso de strings em C

void strcpy(char x[], char y[]){

int i;

i = 0;

while ( (x[i] = y[i]) != ‘\0’)

i += 1;

}

– Considerando que os endereços base para os arrays x e y são encontrados em $a0 e $a1

strcpy:

addi $sp, $sp, -4

sw $s0, 0($sp)

add $s0, $zero, $zero

L1:


strcpy:

addi $sp, $sp, -4

sw $s0, 0($sp)

add $s0, $zero, $zero

L1: add $t1, $s0, $a1 # endereço de y[i] em $t1

lb $t2, 0($t1) # $t2 = y[i], como é um byte, não i * 4

add $t3, $s0, $a0 # endereço de x[i] em $t3

sb $t2, 0($t3) # x[i] = y[i]

beq $t2, $zero, L2 # se y[i]== 0 , vai para L2

addi $s0, $s0, 1 # i = i + 1

j L1

L2: lw $s0, 0 ($sp)

addi $sp, $sp, 4

jr $ra


• Caracteres e strings em Java– Unicode é uma codificação universal dos alfabetos da

maior parte das linguagens humanas– 16 bits para representar um caractere

lh $t0, 0($sp)

sh $t0, 0($sp)

– Ao contrário da linguagem C, Java reserva uma wordpara indicar o tamanho da string

ConteConteúúdodo

• Introdução ��• Operações no hardware do computador ��• Operandos do hardware do computador ��• Representando instruções no computador ��• Operações lógicas ��• Instruções para tomada de decisões ��• Suporte para procedimentos no hardware do computador ��• Comunicando-se com as pessoas ��• Endereçamento no MIPS para operados imediatos e endereços de 32

bits

• Traduzindo e iniciando um programa• Como os compiladores otimizam • Um exemplo de ordenação na linguagem C para juntar tudo isso• Vida real: instruções do IA-32• Falácias e armadilhas• Comentários finais• Leituras e exercícios

EndereEndereççamento no MIPS para imediatosamento no MIPS para imediatos

• Endereçamento no MIPS para operandosimediatos e endereços de 32 bits– Embora manter todas as instruções com 32 bits de

tamanho seja interessante, em certas situações éconveniente ter uma constante de 32 bits ou endereços de 32 bits

– Embora as constantes na maioria das vezes sejam curtas e caibam em um campo de 16 bits, às vezes elas são maiores

– O conjunto de instruções MIPS inclui a instrução loadupper immediate (lui) especificamente para atribuir os 16 bits mais altos de uma constante a um registrador, permitindo que uma instrução subseqüente atribua os 16 bits mais baixos de uma constante

– Exemplo lui $t0, 255

EndereEndereççamento no MIPS para imediatosamento no MIPS para imediatos

• Carregando uma constante de 32 bits– Qual é o código em assembly do MIPS para carregar

esta constante de 32 bits no registrador $s0?– 0000 0000 0011 1101 0000 1001 0000 0000

lui $s0, 61

ori $s0, $s0, 2304

• Endereçamento em desvios condicionais e jumps– As instruções de jump no MIPS possuem o

endereçamento mais simples possível. Elas utilizam o último formato de instruções do MIPS, chamado de J, que consiste em 6 bits para o campo de operação e o restante dos bits para o campo de endereço

EndereEndereççamento MIPS para imediatosamento MIPS para imediatos

• Desvios condicionais e jumps– 26 bits são alocados para o campo de endereço (32 – 6)– Em desvios condicionais, é necessário especificar dois

operandos além do endereço de desvio: 6 bits de opcode, 5 bits para registrador, 5 bits para registrador, 16 bits para endereço

– Se os endereços do programa tivessem que caber nesse campo de 16 bits, nenhum programa poderia ser maior que 2**16

– Uma alternativa seria especificar um registrador que sempre seria somado ao endereço de desvio, de modeque uma instrução de desvio pudesse calcular o seguinte:

• Contador de programa = Registrador + endereço de desvio

EndereEndereççamento do MIPS para desviosamento do MIPS para desvios

• Desvios condicionais– Qual registrador usar?– A resposta vem da observação de como os desvios

condicionais são usados– Os desvios condicionais são encontrados em loops e em

instruções if, de modo que costumam desviar para uma instrução próxima.

– Por exemplo, cerca de metade de todos os desvios condicionais nos benchmarks SPEC2000 vão para locais a menos de 16 instruções

– Como o contador de instruções contém o endereço da instrução atual, podemos desviar em +/- 2**15 palavras da instrução atual se o usarmos o PC como registrador a ser somado ao endereço.

EndereEndereççamento no MIPS para desviosamento no MIPS para desvios

• Desvios condicionais– Essa forma de endereçamento é denominada

endereçamento relativo ao PC– Como na maioria dos computadores atuais, o MIPS

utiliza o endereçamento relativo ao PC para todos os desvios condicionais.

– Instruções JAL chamam procedimentos que não tem motivos para estarem próximas à instrução atual: a arquitetura MIPS utiliza o formato longo (J) para instruções de chamada de procedimento

– Como todas as instruções tem tamanho de 4 bytes, o MIPS aumenta o alcance do endereçamento interpretando o campo de endereçamento relativo a word, e não ao byte: assim, o campo de 16 bits pode se desviar para uma distância quatro vezes maior; da mesma forma, o campo de 28 bits nas instruções de jump também endereçam words.

EndereEndereççamento de desvios no MIPSamento de desvios no MIPS

• Exemplo– Se considerarmos que o loop inicia na posição de

memória 80000, qual é o código de máquina para esse loop?

loop: sll $t1, $s3, 2 # $t1 = 4 * i

add $t1, $t1, $s6 # $t1 = endereço de save[i]

lw $t0, 0($t1) #$t0 = save[i]

bne $t0, $s5, Exit # vá para Exit se save[i] <> k

addi $s3, $s3, 1 # i += 1

j Loop

Exit:

EndereEndereççamento de desvios no MIPSamento de desvios no MIPS

2000280020

11919880016

2218580012

0893580008

3209229080004

049190080000

EndereEndereççamento no MIPSamento no MIPS

• Resumo dos modos de endereçamento– Endereçamento de registrador: onde o operando é um

registrador;– Endereçamento de base e deslocamento: onde o

operando está no local de memória cujo endereço é a soma de um registrador e uma constante de instrução

– Endereçamento imediato: onde o operando é uma constante dentro da própria instrução

– Endereçamento relativo ao PC: onde o endereçamento éa soma do PC e uma constante na instrução

– Endereçamento pseudodireto: onde o endereço de jumpsão os 26 bits da instrução concatenados com os bits mais altos do PC

EndereEndereççamento no MIPSamento no MIPS

• Interface hardware/software– Embora as instruções

estudadas tem 32 bits em tamanho, a arquitetura MIPS tem extensões de 64 bits, em resposta a necessidade de software para programas maiores

• Uma única instrução pode trabalhar com modos de endereçamento diferentes:

ConteConteúúdodo


bits ��• Traduzindo e iniciando um programa

• Como os compiladores otimizam • Um exemplo de ordenação na linguagem C para juntar tudo isso• Vida real: instruções do IA-32• Falácias e armadilhas• Comentários finais• Leituras e exercícios

Traduzindo e iniciando um programaTraduzindo e iniciando um programa• Hierarquia de tradução

para a linguagem C– Um programa em alto

nível é inicialmente compilado para um programa em assembly, e depois montado em um módulo objeto em linguagem de máquina. O link-editor combina os vários módulos com as rotinas de biblioteca para resolver todas as referências. O loader, então, coloca o código de máquina nos locais apropriados em memória, para ser executado pelo processador.

Traduzindo e iniciando um programaTraduzindo e iniciando um programa

• Compilador– O compilador transforma o programa C em um programa em

assembly, uma forma simbólica daquilo que a máquina entende.

• Montador– As arquiteturas aceitam a programação em pseudo-instruções e

mnemônicos, que são convertidos em linguagem de máquina pelo montador

– O montador transforma o programa assembly em um arquivo objeto, que é uma combinação de instruções em linguagem de máquina, dados e informações necessárias para colocar instruções na memória

– Para produzir a versão binária das instruções, precisa determinar os endereços de todos os rótulos - os montadores registram os rótulos utilizados nos desvios e nas instruções de transferência de dados por meio de uma tabela de símbolos, que contém pares de símbolo e endereço


• Arquivo objeto em sistemas UNIX– Cabeçalho: descreve o tamanho e posições das outras

partes do código– Segmento de texto: código em linguagem de máquina– Segmento de dados: contém os dados alocados por toda

a vida do programa (dados estáticos)– Informações de relocação: identificam instruções e

words que dependem de endereços absolutos quando o programa é carregado na memória

– Tabela de símbolos: contém os rótulos restantes que não estão definidos, como referências externas

– Informações de depuração


• Linkeditor (link-edição)– Colocar os módulos de código e dados simbolicamente na

memória– Determinar os endereços de rótulos de dados e instruções– Remendar referências internas e externas– O linkeditor produz um arquivo executável, que tem o mesmo

formato do arquivo objeto, exceto que não tem referências não resolvidas

– Linkedição estática x dinâmica– Desvantagens da linkedição estática:

• Rotinas de biblioteca fazem parte do código e não podem ser atualizadas

• Carrega a biblioteca inteira, mesmo se parte da biblioteca nunca seja chamada

– Desvantagens da linkedição dinâmica:• Execução dos programas pode se tornar mais lenta• Erros de execução em programas que necessitam de bibliotecas

dinâmicas não existentes.

ConteConteúúdodo


bits ��• Traduzindo e iniciando um programa ��• Como os compiladores otimizam

• Um exemplo de ordenação na linguagem C para juntar tudo isso• Vida real: instruções do IA-32• Falácias e armadilhas• Comentários finais• Leituras e exercícios

Como os compiladores otimizamComo os compiladores otimizam

• Compiladores– Construídos considerando um conjunto de fases de

otimização– Otimização: espaço de armazenamento e velocidade de

execução


• Compilador– Afeta significantemente o desempenho dos programas– Transformação de alto nível: procedimentos inline

– Loop unrolling – desdobramento de loops• for (i = 0; i < 100; i++) g ();

• Depois do loop unrolling. • for (i = 0; i < 100; i += 2) { g (); g (); }

– Otimizações• Otimizações locais atuam dentro de um bloco básico• Otimizações globais atuam entre blocos básicos• Alocação de registradores


• Otimizações locais– Eliminação de sub-expressões comuns

• x[i] = x[i] + 4

• O cálculo do endereço de x[] ocorre duas vezes

– Outras otimizações• Redução de força: substitui operações complexas por outras mais

simples, por exemplo um mult por um deslocamento à esquerda

• Propagação de constante: encontram constantes no código e as propagam, encolhendo os valores de constante sempre que possível

• Propagação de cópia: propaga valores que são cópias simples, eliminando a necessidade de ler valores

• Eliminação de local de armazenamento: encontra locais com armazenamento não utilizados

• Eliminação de código morto: encontra fragmentos de código que nunca são utilizados – código morto ocorre com bastante freqüência.

Como os compiladores otimizamComo os compiladores otimizam• Otimizações globais

– Movimentação de código

• Encontra código que é invarianteno loop; um trecho que código que calcula o mesmo valor, independente da iteração corrente do loop;

– Eliminação de variável de indução

• É um combinação de transformações que reduz o trabalho na indexação de arrays

ConteConteúúdodo


bits ��• Traduzindo e iniciando um programa ��• Como os compiladores otimizam ��• Um exemplo de ordenação na linguagem C para juntar tudo isso

• Vida real: instruções do IA-32• Falácias e armadilhas• Comentários finais• Leituras e exercícios

Exemplo de ordenaExemplo de ordenaçção na linguagem Cão na linguagem C

• O procedimento swap

void swap(int v[], int k){

int temp;

temp = v[k];

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

v[k+1] = temp;

}

sll $t1, $a1, 2 # registrador $t1 = k * 4

add $t1, $a0, $t1 # $t1 = v + (k*4)

lw $t0, 0($t1) # $t0 = v[k] (temp)

lw $t2, 4($t1) # $t2 = v[k+1];

sw $t2, 0($t0) # v[k] = registrador $t2

sw $t0, 4($t1) # v[k+1] = registrador $t0 (temp)


• O procedimento swap completo

swap:

sll $t1, $a1, 2 # registrador $t1 = k * 4

add $t1, $a0, $t1 # $t1 = v + (k*4)

lw $t0, 0($t1) # $t0 = v[k] (temp)

lw $t2, 4($t1) # $t2 = v[k+1];

sw $t2, 0($t0) # v[k] = registrador $t2

sw $t0, 4($t1) # v[k+1] = registrador $t0 (temp)

jr $ra


• O procedimento sort

void sort(int v[], int n){

int i, j;

for(i=0; i < n; i++){

for(j=i-1; j >=0 && v[j] > v[j+1]; j --){

swap(v,j);

}

}

• Alocação de registradores para sort

– Os dois parâmetros do procedimento sort, v e n, estão nos registradores de parâmetro $a0 e $a1, e alocamos o registrador $s0 a i e o registrador $1 a j


• Código para o procedimento sort (primeiro loop)– loops são compostos de 3 partes:

• Inicialização das variáveis de controle

• Teste da condição de controle

• Incremento da variável de controle

move $s0, $zero #i=0

For1tst: slt $t0, $s0, $a1

beq $t0, $zero, exit1

...

addi $s0, S0,1

j for1slt

exit1

Exemplo de ordenaExemplo de ordenaçção da linguagem Cão da linguagem C

• Código para o procedimento sort (segundo loop)– for(j=i-1; j >=0 && v[j] > v[j+1]; j --)

– Teste de loop composto de duas partes:• J >-0

• V[j] > v[j+1]

addi $s1, $1, -1 #j=i-1

For2tst: slti $t0, $1, 0 # $t0 = 1 se j < 0

bne $t0, $zero, exit2

sll $t1, $s1, 2 # $t1 = j * 4

add $t2, $a0, $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 $t4 >= $t3

beq $t0, $zero, exit2

... (corpo do for 2)

add $1, $1, -1 # j -= 1

j for2tst

exit2:

Exemplo de ordenaExemplo de ordenaçção em Cão em C

• Chamada de procedimento em sort– swap(i,j)

– jal swap

• Passando parâmetros em sort– Os procedimentos sort e swap utilizam como parâmetros os

registradores $a0, $a1– É necessário então salvar os registradores em $s2 e $3 antes da

chamada do procedimento (melhor que salvar na pilha)• move $s2, $a0

• move $s3, $a1

– Depois passamos os parâmetros para swap da

seguinte forma:

• move $a0, $s2

• move $a1, $s1

Exemplo de ordenaExemplo de ordenaçção em Cão em C

• Preservando registradores em sort

– Deve-se salvar o endereço de retorno $ra (lembre-se que são loops aninhados)

– O procedimento sort também utiliza registradores salvos, de modo que precisam ser salvos

– Ao final do procedimento, os registradores devem ser restaurados na ordem inversa

addi $sp, $sp, -20 # 5 registradores

sw $ra, 16($sp) # salva $ra na pilha

sw $s3, 12($sp) # sala $s3 na pilha

sw $s2, 8($sp)

sw $s1, 4($sp)

sw $s0, 0($sp)

ConteConteúúdodo• Introdução ��• Operações no hardware do computador ��• Operandos do hardware do computador ��• Representando instruções no computador ��• Operações lógicas ��• Instruções para tomada de decisões ��• Suporte para procedimentos no hardware do computador ��• Comunicando-se com as pessoas ��• Endereçamento no MIPS para operados imediatos e endereços de 32

bits ��• Traduzindo e iniciando um programa ��• Como os compiladores otimizam ��• Um exemplo de ordenação na linguagem C para juntar tudo isso ��

• Vida real: instruções do IA-32• Falácias e armadilhas• Comentários finais• Leituras e exercícios

Vida real: instruVida real: instruçções do IAões do IA--3232

• Os projetistas– Oferecem às vezes um conjunto de operações mais

poderosas do que aquelas encontradas no MIPS• O objetivo é reduzir o número de instruções executadas por um

programa• O perigo é que essa redução pode ocorrer ao custo da

simplicidade, aumentando o tempo que um programa leva para executar, pois as instruções são mais lentas.

• Essa lentidão pode ser o resultado de um ciclo de clock mais lento ou a requisição de mais ciclos de clock do que uma seqüência mais simples

Vida real: instruVida real: instruçções do IAões do IA--3232• IA-32

– Arquitetura que evoluiu ao longo do tempo, sendo produto de diferentes grupos independentes, que modificaram a arquitetura por 20 anos,acrescentando novos recursos ao conjunto de instruções original, como alguém poderia acrescentar roupas em uma mala pronta

– Marcos importantes:• 1978: Intel 8086 – extensão do assembly para o 8080; arquitetura de 16 bits com

registradores de 16 bits, com usos dedicados, ao contrário do MIPS, que tem registradores de propósito geral; endereçamento de memória com 20 bits

• 1980: coprocessador 8087 anunciado; estende o conjunto original de instruções em 60 instruções de ponto flutuante

• 1982: 80286 com endereçamento de memória de 24 bits com um modelo de proteção de memória

• 1985: 80386, processador de 32 bits com novos modos de endereçamento e registradores de 32 bits

• 1989-95: 80486, Pentium, ...• 1997: instruções MMX nos processadores Pentium• 1999: melhorias nas instruções SIMD e oito registradores adicionais; instruções

SSE (Streaming SIMD extensions)• 2001: extensões com 144 instruções adicionais para lidar com operações

multimídia, exploração da computação paralela nos chips• 2003: AMD anuncia extensões arquitetônicas para aumentar o espaço de

endereçamento de memória de 32 para 64 bits, alargando os registradores para 64 bits

Vida real: instruVida real: instruçções do IAões do IA--3232

• Registradores e instruções

FalFaláácias e armadilhascias e armadilhas

• Falácias– Instruções mais poderosas significam

maior desempenho– Escreva em assembly para ter melhor

desempenho

• Armadilha– Esquecer que os endereços seqüenciais de

word em máquinas com endereçamento em bytes não diferem em 1.

ComentComentáários finaisrios finais

• Programa armazenado– Permite a construção de máquinas de propósito geral– A seleção de um conjunto de instruções que a máquina possa

entender exige um equilíbrio delicado entre a quantidade de instruções necessárias para executar programas, a quantidade de ciclos de clock por instrução e a velocidade do

– Princípios de projeto:• Simplicidade favorece a regularidade: instruções de mesmo tamanho e

se possível com o mesmo significado quanto aos operandos• Menor é mais rápido: o desejo de velocidade é o motivo para que o

MIPS tenha apenas 32 registradores• Torne os casos comuns mais velozes: alguns exemplos são os desvios

em relação ao contador de programa e endereçamento imediato para constantes

• Um bom projeto exige bons compromissos: exemplo é o compromisso de manter todas as instruções com o mesmo tamanho frente ànecessidade de representação de constantes que necessitam de mais bits para a representação

ComentComentáários finaisrios finais

• Instruções MIPS– Cada categoria de instruções MIPS está associada a

construções que aparecem nas linguagens de programação

• Instruções aritméticas correspondem às operações encontradas nas instruções de atribuição

• Instruções de transferência de dados provavelmente ocorrerão quando se lida com estruturas de dados, como arrays e estruturas

• Os desvios condicionais são usados em instruções if e em loops

• Os jumps incondicionais são usados em chamadas de procedimento e retornos, e para instruções case/switch

Leituras e exercLeituras e exercíícioscios

• Leituras– Patterson, capítulo 2

• Exercícios– Patterson, capítulo 2

Organiza ção e Arquitetura de computadores -...

Documents

Transcript of Organiza ção e Arquitetura de computadores -...