2.

9 O Desempenho da CPU O desempenho de uma CPU na execuo de um programa pode ser medido atravs do tempo que esta CPU gasta para executar este programa. Quanto menor o tempo, maior o desempenho. O tempo de execuo de um programa, T, pode ser expresso por:
T (segundos) = N (instruo) x C (ciclo/instruo) x S (segundos/ciclo)

onde N o nmero total de instrues executadas, C (ou clocks por ciclo de mquina Clocks per Cycle (CPI)) a mdia do nmero de ciclos por instruo e S o nmero de segundos por ciclo. Em uma primeira aproximao, N, C e S so afetados primariamente: pela capacidade de otimizao do compilador; pela arquitetura do processador e de seu conjunto de instrues; e pela tecnologia empregada na implementao da mquina. Ns podemos medir o nmero de instrues executadas em um programa com ferramentas de software conhecidas como execution profilers ou atravs de simuladores da arquitetura, por exemplo. O nmero de segundos (na verdade, nano ou pico segundos hoje em dia) por ciclo de mquina normalmente indicado no manual da mquina. O CPI, por outro lado, depende de vrios fatores, tais como a organizao de memria da mquina, o conjunto de instrues do processador, a mistura de instrues executadas pela aplicao, a arquitetura do processador, etc. Exerccio: Um projetista de compiladores est tentando decidir sobre qual seqncia de instrues ele deve utilizar para implementar um comando de uma linguagem de alto nvel. Ele dispe das seguintes informaes: Existem duas seqncias de instrues possveis para implementar o comando. Seqncia 1: duas instrues A, uma B e duas C; seqncia 2: quatro A, uma B e uma C. Na mquina alvo, a instruo A tem o CPI de 1, a instruo B tem CPI de 2 e a C, de 3. 1 - Que seqncia de cdigo executa mais instrues? 2 - Qual seqncia executa mais rpido? 3 - Qual o CPI para cada seqncia? Respostas:
1: seq1 = 2+1+2 = 5 instrues; seq2 = 4+1+1 = 6 instrues, logo, resposta = seq2 2: seq1 = 2x1 + 1x 2 + 2x3 = 10 ciclos; seq2 = 4x1 + 1x2 + 1x3 = 9 ciclos 3: CPI(seq1) = 10 ciclos / 5 instrues = 2 CPI; CPI(seq2) = 9 / 6 = 1.5 CPI

aula5.doc

1 de 63

2.10 Unidades de Medida de Desempenho 2.10.1 MIPS Million Instructions per Second A unidade MIPS pode ser definida como: MIPS = Freqencia de Clock / CPIx106 O Tempo de Execuo de um programa pode ser definido em funo da unidade MIPS: Tempo de execuo = No. de Instrues / MIPSx106 MIPS uma unidade de performance ruim porque: Primeiro, ns no podemos comparar computadores com conjuntos de instrues diferentes usando MIPS. Isso porque, o nmero de instrues necessrio para executar um determinado programa nestes dois computadores vai quase certamente diferir e, se a freqncia de clock for a mesma, o computador que demora mais para executar o programa aparentemente ter o mesmo desempenho do que demora menos. Segundo, a quantidade de MIPS varia entre programas em um mesmo computador, assim, uma mquina no pode ter uma performance nica em termos de MIPS. Terceiro, a medida de desempenho em termos de MIPS pode variar inversamente com o desempenho verdadeiro, como podemos demonstrar resolvendo o exerccio abaixo. Exerccio: Sabendo que, para um programa especfico e para um computador com clock de 100MHz, o compilador 1 gera 5 milhes de instrues do tipo A, 1 milho do tipo B e 1 milho do tipo C, e que o compilador 2 gera 10 milhes do tipo A, 1 milho do tipo B e 1 milho do tipo C, e que o CPI de cada instruo igual ao do exerccio anterior, mostre que a medida de performance em termos de MIPS pode variar inversamente com a performance verdadeira. Suponha que cada instruo gerada executada apenas uma vez.

aula5.doc

2 de 63

2.10.2 MFLOPS Million Floating-Point Operations per Second A unidade MFLOPS definida como: MFLOPS = nmero de operaes de ponto flutuante em um programa / tempo de execuo x 106 Embora, a primeira vista, o nmero de operaes de ponto flutuante de um programa parea ser o mesmo para diferentes computadores, ele no devido ao fato de diferentes computadores terem conjuntos de instrues de ponto flutuante diferentes. Por esse e outros problemas, MFLOPS tambm no uma boa unidade de medida de performance. 2.10.3 SPEC Medir o tempo de execuo usando um conjunto de programas de uso generalizado, com entradas conhecidas, e sob circunstncias conhecidas e especificadas a melhor maneira de se medir o desempenho de um computador. As unidades de medidas SPECint e SPECfp so consideradas, atualmente, boas unidades de medida de desempenho.

3 Instrues: A Linguagem da Mquina

Para controlar o hardware de um computador voc precisa falar a linguagem dele. As palavras que um computador entende so chamadas instrues e seu vocabulrio chamado conjunto de instrues (instruction set). Instrues de mquina devem ser simples para: (i) facilitar o projeto e implementao do hardware, (ii) ser de rpida execuo pelo hardware, e (iii) facilitar o projeto e a implementao do compilador. Ns estudaremos o conjunto de instrues dos processadores MIPS. 3.1 Operaes Bsicas Todos os computadores tm que ser capazes de fazer operaes aritmticas. De acordo com a Instruction Set Architecture (ISA) dos processadores MIPS, add a, b, c instrui o processador a somar b e c e colocar o resultado em a. Se precisarmos somar quatro valores, b, c, d, e, precisamos de mais instrues: add a, b, c add a, a, d
aula5.doc 3 de 63

add a, a, e O nmero natural de operandos para uma operao como a adio trs. Assim, para tornar o hardware dos processadores mais simples, trs operandos sempre tm que ser usados para operaes deste tipo na maioria dos processadores atuais. Hardware para instrues com um nmero de operandos varivel mais complicado e freqentemente mais lento. Esta situao destaca o primeiro de quatro princpios bsicos do projeto de hardware: Princpio 1: Regularidade favorece a simplicidade Ou seja, bom que a maioria ou todas as instrues tenham um nmero de operandos igual, pois isso tornar a implementao do hardware do processador mais simples.

aula5.doc

4 de 63

Um compilador recebe um programa em linguagem de alto nvel e gera como sada um programa em linguagem de mquina. Uma forma mais legvel de linguagem de mquina a linguagem de montagem, ou assembly language. A linha de cdigo em linguagem C abaixo f = (g + h) (i + j); /* isto uma linha de um programa em C */ Pode ser traduzida para o trecho de cdigo em assembly abaixo add t0, g, h # a varivel temporria t0 contm g + h add t1, i, j # a varivel temporria t1 contm i + j sub f, t0, t1 # f recebe t0 t1, ou (g + h) (i + j) 3.2 Operandos Operandos de instrues de mquina no podem ser de qualquer tipo: na ISA MIPS eles tm que ser um dos registradores do processador ou uma constante. O tamanho dos registradores da ISA MIPS 32 bits e grupos de 32bits nesta ISA so chamados de word. Existem apenas 32 registradores na ISA MIPS para operandos inteiros, cujos nomes so $0, $1, $31, e operaes lgicas e aritmticas apenas ocorrem entre estes registradores. A razo para este pequeno nmero de registradores o segundo princpio para o projeto de hardware: Princpio 2: Menor mais rpido Associar variveis do programa em alto nvel a registradores tarefa do compilador. No ltimo exemplo da seo anterior, as variveis f, g, h, i e j podem ser associadas aos registradores $16, $17, $18, $19 e $20, respectivamente: add $8, $17, $18 add $9, $19, $20 sub $16, $8, $9 # o registrador $8 contm g + h # o registrador $9 contm i + j # f recebe $8 $9, ou (g + h) (i + j)

aula5.doc

5 de 63

Estruturas de dados maiores que 32 bits, como matrizes por exemplo, so mantidas na memria. Para operar sobre elas, o processador tem que trazlas, por partes, para seus registradores, realizar as operaes, e transferi-las por partes de volta para a memria. Exemplo: g = h + A[i]; /* Cdigo C. A um vetor de bytes. */ add $8, $9, $19 lb $8, 0($8) add $17, $18, $8 # $9 contm o endereo de A na memria e $8, um # registrador temporrio, recebe A + i # o registrador temporrio $8 recebe A[i] # g = h + A[i]

Neste trecho de cdigo, a primeira instruo add calcula o endereo na memria do elemento i do vetor de bytes A. O registrador $9 contm o endereo do primeiro elemento de A (o elemento de ordem 0, na linguagem C) e o registrador $19 o valor da varivel i. A instruo lb ( load byte) l a posio de memria cujo endereo 0 (uma constante) mais o valor do registrador $8 o processador soma a constante 0, especificada pelo compilador, com o endereo em $8 e usa o resultado como endereo para a leitura de A[i] da memria. A memria do computador um grande vetor no caso da ISA MIPS ela pode ter 232 bytes. Se, como no exemplo anterior, o vetor A um vetor de bytes, a varivel i ($19) tem que ser incrementada de 1 em assembly quando incrementada de 1 em C. Se A um vetor de words, i tambm deve ser incrementada de 1 em C, mas deve ser incrementada de 4 em assembly para avanar de 1 no vetor. Alm disso, uma instruo que l words da memria deve ser usada: lw ou load word. Na ISA MIPS, existe tambm uma instruo para ler grupamentos de 16 bits: lh, ou load half word. Para escrever dados na memria a instruo store utilizada: A[i] = h + A[i]; add $7, $9, $19 lb $8, 0($7) add $8, $18, $8 sb $8, 0($7) # o registrador temporrio $7, recebe A + i # $8 recebe A[i] # $8 = h + A[i] # guarda h + A[i] em A[i]

aula5.doc

6 de 63

Existem, tambm, as instrues sw e sh. Freqentemente, programas possuem mais que 32 variveis. Assim, os compiladores tm que otimizar o uso dos registrados, transferindo variveis da memria para registradores e vice-versa quando necessrio. Na verdade, registradores existem porque o acesso a eles mais rpido do que memria ( possvel implementar uma ISA sem registradores). 3.3 O Formato das Instrues Para fornecer instrues ao computador temos que usar cdigos em binrio (nmeros na base 10 so ditos decimais, na base 2, binrios). Para facilitar a leitura humana de nmeros binrios, a base 16 ou nmeros em hexadecimal , muitas vezes, utilizada:
Decimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Binrio 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 Hexadecimal 0 1 2 3 4 5 6 7 8 9 A B C D E F

Instrues so mantidas dentro do computador no formato binrio e podem ser representadas por nmeros. Na verdade, cada campo de uma instruo pode ser representado por um nmero: add $8, $17, $18
nome ordem No. bits decimal binario hexadecimal op 1 6 0 00 0000 00 rs 2 5 17 1 0001 11 rt 3 5 18 1 0010 12 rd 4 5 8 0 1000 08 shamt 5 5 0 0 0000 00 funct 6 6 32 10 0000 20

O primeiro e o ltimo campo acima, combinados, informam ao processador que a instruo um add. Os campos 2 e 3 informam quais so os registradores com os operandos fonte. O campo 4, o registrador com o operando destino. O campo 5 no utilizado nesta instruo e recebe zero.
aula5.doc 7 de 63

Cada campo tem um nome: op = operao (tambm conhecido como opcode); rs e rt = 1o. e 2o. registradores fonte, respectivamente; rd = registrador destino; shamt = tamanho do deslocamento (shift amount, usando em instrues de deslocamento, que veremos adiante); e funct = funo (function, indica uma variao especfica da instruo indicada em op). Todas as instrues da MIPS ISA tm 32 bits de largura. Uma instruo lw precisa especificar dois registradores e uma constante. Para acomodar estas informaes em 32 bits, um formato diferente de instruo utilizado: lw $8, 1200($19)
nome No. bits decimal op 6 35 rs 5 19 rt 5 8 address 16 1200

Note que o significado do campo rt mudou nesta instruo, ele indica um registrador que escrito (registrador destino). Para o processador saber qual o formato da instruo, ele consulta o campo op. No caso da lw, um compromisso teve que ser feito entre a largura da instruo, o nmero de campos e o tamanho da constante address da instruo lw. Isto ilustra o terceiro princpio do projeto de hardware: Princpio 3: Bons projetos exigem compromissos. Exemplo de Exerccio: Traduza o trecho de cdigo em C abaixo para linguagem assembly e para linguagem de mquina. O endereo do vetor de words, A, est no registrador $17, o registrador $18 contem o valor da varivel h e $19 contem 4 vezes i. A[i] = h + A[i]; Assembly add $7, $17, $19 lw $8, 0($7) add $8, $18, $8 sw $8, 0($7)

# o temporrio $7 recebe A + (i * 4) # o registrador temporrio $8 recebe A[i] # o registrador temporrio $8 recebe h + A[i] # escreve h + A[i] em A[i]

aula5.doc

8 de 63

linguagem de mquina
decimal decimal decimal decimal binrio binrio binrio binrio 0 35 0 43 00 0000 10 0011 00 0000 10 1011 17 7 18 7 1 0001 0 0111 1 0010 0 0111 19 8 8 8 1 0011 0 1000 0 1000 0 1000 7 8 0 0 0 0 0 0000 0000 0000 0000 0000 0 0000 0000 0000 0000 0000 32 32

0 0111 0 1000

10 0000 10 0000

aula5.doc

9 de 63

A linguagem assembly , obviamente, muito mais fcil de usar que a linguagem de mquina. Alm de traduzir os smbolos para nmeros, assemblers tratam variaes de certas instrues como se elas fossem instrues independentes. Por exemplo, o hardware de um processador MIPS sempre l zero do registrador $0, e escritas em $0 no tem efeito. Assim, assemblers traduzem a instruo move $8, $18 para add $8, $0, $18 # $8 recebe 0 + $18 # $8 recebe o valor de $18

A pseudo instruo move (ou freqentemente em assemblers mov) facilita a o entendimento do que o programa de fato faz. O funcionamento dos computadores baseado em dois princpios chave: 1. Instrues so representadas como nmeros. 2. Programas podem ser guardados em memria, e podem ser lidos e escritos como nmeros. Em conjunto, estes princpios definem o conceito de programa armazenado. 3.4 Instrues de Desvio Editor (cdigo de mquina) baseado nos dados de entrada e processador Um processador capaz de tomar decises nos valores computados duranteTexto a em execuo das instrues. Em linguagens linguagem C de alto nvel, o comando if (se) pode ser usado para tomada de decises. Na MIPS ISA, a instruo abaixocompilador usada (cdigo de mquina) para tomar uma deciso de acordo com o contedo de dois registradores.
Folha de pagamento (dados)

memria

beq reg1, reg2, endereo Esta instruo manda o processador ir para o endereo especificado se o contedo de reg1 for igual ao de reg2. Exerccio: No fragmento de cdigo em C abaixo, f, g, h, i e j so variveis. if (i == j) goto L1; i = g + h; f = f i;

L1:

aula5.doc

10 de 63

Assumindo que as cinco variveis correspondem aos cinco registradores $16, , $20, qual o cdigo assembly equivalente ao fragmento em C acima? Resposta: beq $19, $20, L1 add $19, $17, $18 sub $16, $16, $19

L1:

Instrues so guardadas na memria dos computadores do mesmo modo que outras words de dados. Assim, instrues tm endereos de memria do mesmo modo que words de dados. O label L1 acima corresponde ao endereo da instruo sub; os assemblers cuidam de transformar labels em endereos de memria ou outros valores eventualmente necessrios para simplificar o trabalho do programador.

aula5.doc

11 de 63

Outro exemplo: C if (i == j) f = g + h; else f = g h; Assembly bne $19, $20, Else add $16, $17, $18 j Exit Else: sub $16, $17, $18 Exit:

i == j

i == j?

i != j Else:

f=g+h

f=g-h

Exit:

Mais um exemplo: Faa um programa em C que some os salrios de todos os funcionrios de uma firma. A firma tem 10 funcionrios e os salrios esto guardados no vetor SAL. Traduza o programa para o assembly da MIPS ISA. C total = 0; i = 0; while (i != 10) /* enquanto i for diferente de 10 */ { total = total + SAL[i]; i = i + 1; } Assembly: ($8 total, $9 i, e $12 o endereo do primeiro elemento de SAL) add $8, $0, $0 # total = 0 add $9, $0, $0 #i=0 add $10, $0, 10*4 # $10 contem a constante 10*4 While: beq $9, $10, Exit # while add $11, $12, $9 # $12 contem o endereo de SAL lw $11, 0($11) # $11 = SAL[i] add $8, $8, $11 # total = total + SAL[i] add $9, $9, 4 #i=i+1 j While Exit:
aula5.doc 12 de 63

A MIPS ISA inclui uma instruo para fazer testes sobre o contedo de registradores a instruo slt, ou set on less than (ligue se menor que). Esta instruo testa o contedo de dois registradores e torna o contedo de um terceiro igual a 1 ou 0 se o primeiro menor ou no menor que o segundo, respectivamente. Por exemplo, slt $8, $19, $20 torna o contedo do registrador $8 igual a 1 se o contedo de $19 menor que o de $20; caso contrario, $8 recebe 0. Compiladores e montadores MIPS usam as instrues slt, beq, bne e o contedo fixo, zero, de $0 para fazer todos os testes. Exemplo: slt $1, $16, $17 bne $1, $0, Less # $1 recebe 1 se $16 < $17 # o desvio tomado se $1 != 0, isto , se $16 < $17

Muitos montadores para a ISA MIPS transformam a pseudo-instruo blt para a seqncia acima. Muitas linguagens possuem comando equivalente ao switch do C: switch (k) { case 0: /* k == 0 */ f = i + j; break; case 1: /* k == 1 */ f = g + h; break; case 2: /* k == 2 */ f = g - h; break; case 3: /* k == 3 */ f = i - j; break; default: f = 0;
aula5.doc 13 de 63

} A instruo jr (jump register), que desloca o fluxo de controle para o endereo guardado em um registrador, pode ser usada para implementar o comando switch.

aula5.doc

14 de 63

Exemplo: Assumindo que as variveis f, g, , k esto alo cadas nos registradores $16, , $21 e que o vetor JumpTable contm o endereo dos comandos case acima, o cdigo assembly abaixo equivalente ao cdigo C acima: blt $21, $0, Default move $10, 4 bge $21, $10, Default sll $9, $21, 2 lw $8, JumpTable($9) jr $8 add $16, $19, $20 j Exit add $16, $17, $18 j Exit sub $16, $17, $18 j Exit sub $16, $19, $20 j Exit move $16, 0 j Exit # se k < 0, vai para Default # o temporrio $10 = 4 # se k >= 4, vai para Default # o temporrio $9 = k*4 # temp. $8 recebe o endereo do Case # em JumpTable[k] # salta para o Case apropriado

Case0: Case1: Case2: Case3: Default:

JumpTable: .word Case0, Case1, Case2, Case3 Exit:

aula5.doc

15 de 63

Procedimentos e funes so utilizados para tornar os programas mais legveis e para permitir a fcil reutilizao de cdigo (a linguagem C s tem funes). Exemplo: #include <stdio.h> int maior (int a, int b) { if (a > b) return (a); else return (b); } int main () { int x, a, b; a = 1; b = 2; x = maior (a, b); printf (a = %d, b = %d, maior = %d \n, a, b, x); return (0); } A funo printf faz parte de um conjunto de funes que j vem junto com o compilador. Ela imprime na sada o que est entre aspas, a menos que apaream os caracteres % e \. Nestes casos, ela imprime as variveis listadas aps as aspas conforme os tipos especificados (o i indica inteiro) ou o caracter especial \{caracter}. Para imprimir % usa-se %% e para imprimir \ usa-se \\. Veja um manual de C para mais detalhes sobre a printf e outras funes padro. Para permitir a chamada de procedimentos em assembly, so necessrias uma (i) instruo para desviar para o inicio de uma funo e (ii) outra para retornar para a instruo logo aps a instruo de desvio, aps a execuo da funo. A instruo da MIPS ISA que usada para desviar para o incio da funo instruo jump-and-link ou jal:

aula5.doc

16 de 63

Funo:

jr $31 jal Funo add $8, $9, $10

# fim de Funo # salta para Funo # depois que executar a funo Funo, # a execuo continua aqui

Seguinte:

Esta instruo salta para o endereo Funo e, alm disso, guarda o endereo da instruo seguinte a ela prpria (no caso acima, o endereo Seguinte) no registrador $31. Este endereo chamado de return address, ou endereo de retorno. No fim da execuo da funo, a instruo jr $31 utilizada para retornar para o cdigo que chamou a funo. Quando uma funo chama outra funo, o endereo de retorno pode ser perdido. Exemplo: jr $31 jal C jr $31 A: retA: jr $31 jal B

C:

# esta instruo retorna para retB

B:

# aps este jal, $31 contm o endereo retB: retA foi # perdido! # esta instruo desviaria para retB

retB:

# aps este jal, $31 contm o endereo retA

aula5.doc

17 de 63

Para evitar isso, uma estrutura de dados chamada de stack (pilha) utilizada para guardar os endereos de retorno. Por conveno da linguagem assembly do MIPS, o registrador $29 aponta para o primeiro elemento livre do stack e o stack cresce para baixo (endereos menores). C: jr $31 sw $31, 0($29) sub $29, $29, 4 jal C add $29, $29, 4 lw $31, 0($29) jr $31 A: sw $31, 0($29) sub $29, $29, 4 jal B add $29, $29, 4 lw $31, 0($29) jr $31

# esta instruo desvia para retB

B:

# guarda o antigo valor de $31 na pilha (retA) # ajusta o ponteiro da pilha # aps este jal, $31 contm o endereo retB

retB: # prepara para remover um item da pilha # l o endereo de retorno anterior para $31 (retA) # retorna para A

# guarda o antigo valor de $31 na pilha # ajusta o ponteiro da pilha # aps este jal, $31 contm o endereo retA

retA: # prepara para remover um item da pilha

aula5.doc

18 de 63

Alm de um padro para qual registrador aponta para o stack e de como ele cresce, outras convenes tambm so necessrias. Seguem algumas convenes da linguagem assembly do MIPS: $1 ($at), $26 ($k0) e $27 ($k1) so reservados para o sistema operacional e o assembler e no devem ser utilizados pelo usurio $4-$7 ($a0-$a3) so usados para passar os primeiros 4 argumentos para funes (argumentos adicionais so passados via stack) $2, $3 ($v0, $v1) so usados para retornar valores de funes $8-$15, $24 e $25 ($t0-$t9) so registradores temporrios caller-saved: podem ser usados para guardar valores que no precisam ser mantidos entre chamadas de funo $16-$23 ($s0-$s7) so registradores callee-saved: contm valores que devem ser preservados entre chamadas de funo $28 ($gp) global pointer: aponta para as variveis globais $29 ($sp) stack pointer: aponta para a primeira posio livre do stack $30 ($fp) frame pointer: aponta para o inicio da rea de trabalho da funo corrente que acaba no stack $31 ($ra) contm o return address gerado pelas instrues jal No nvel de linguagem de montagem, quando uma funo chama outra (caller chama callee) as convenes mencionadas tem que ser observadas para garantir que elas operem em conjunto corretamente. Para facilitar esta interao, um bloco de memria chamado de stack frame utilizado. Esta rea de memria utilizada para vrios propsitos: Guardar valores passados como argumentos da funo callee Salvar registradores cujo valor tenha que ser preservado entre chamadas Prover espao para variveis locais s funes O stack frame consiste na rea de memria entre o frame pointer, que aponta para a primeira word do stack frame, e o stack pointer, que aponta para a primeira word aps o stack frame. Como o stack (pilha) cresce para baixo (endereos menores), o frame pointer contm um endereo mais alto que o stack pointer. Como exemplo das convenes da linguagem assembly do MIPS, vamos examinar um programa em assembly que executa o cdigo em C abaixo. #include <stdio.h>

aula5.doc

19 de 63

int maior (int a, int b) { if (a > b) return (a); else return (b); } int main () { int a, b, x; a = 1; b = 2; x = maior (a, b); printf (a = %i, b = %i, maior = %i\n, a, b, x); return (0); }

aula5.doc

20 de 63

No programa em assembly, um stack frame como o mostrado a seguir empregado: Stack Frame Antes da chamada Livre $t0 $t1 $fp $ra ($sp) Depois da chamada 0($sp) 4($sp) 8($sp) 12($sp) 16($sp) 20($sp) 24($sp) 28($sp) $fp (32($sp))

Antes de uma funo caller chamar uma callee, o stack pointer aponta para a primeira posio livre do stack. Depois da chamada, uma funo callee simples prepara seu stack frame como mostrado acima, por exemplo. A estrutura de dados stack frame permite fcil acesso a valores de interesse usando instrues de load/store como abaixo: sw $ra, 20($sp) # guarda o endereo de retorno para a # funo chamadora (caller) no stack # frame # guarda o frame pointer no stack frame # guarda uma varivel da funo # callee no stack frame # restaura o endereo de retorno para a caller # restaura o frame pointer da caller

sw $fp, 16($sp) sw $t0, 4($sp)

lw $ra, 20($sp) lw $fp, 16($sp)

Stack frames podem ser maiores e ter vrias sees, dependendo da funo callee. Funes callee mais complexas requerem stack frames maiores para guardar o contedo de registradores que ela precisa salvar antes de usar, como por exemplo $s0-$s7, e suas variveis locais que no puderem ser alocadas em registradores, como vetores, por exemplo.

aula5.doc

21 de 63

Verso em assembly do programa em C (pode ser simulada com o programa PCspim: (http://pages.cs.wisc.edu/~larus/spim.html): .data .ascii # indica que o que vem abaixo so dados a = %i, b = %i, maior = %i\n

MENS:

main:

.text # indica que o que vem abaixo cdigo subu $sp, $sp, 32 # separa um frame de 32 bytes no stack # para a funo chamada (callee), main # (push) sw $ra, 20($sp) # guarda no frame o endereo de retorno # para a funo chamadora (caller), que o # Sistema Operacional (S.O.) sw $fp, 16($sp) # guarda o frame pointer do S.O. addu $fp, $sp, 32 # ajusta o frame pointer para a funo main add $t0, $0, 1 add $t1, $0, 2 sw $t0, 4($sp) sw $t1, 8($sp) #a=1 #b=2 # separa 4($sp) para a # separa 8($sp) para b # Parmetros de maior() # os parmetros so passados em $a0 # e $a1 # maior() retorna o maior em $v0 # l a de volta para seu registrador # l b de volta para seu registrador # Parmetros de printf() # coloca o endereo MENS em $a0 # coloca a e b em $a1 e $a2 # x=maior(a, b); x colocado em $a3 # parmetros em $a0, $a1, $a2, $a3 # como no temos printf no simulador # vamos usar uma syscall do pcspin # 4 o codigo para imprimir string

move $a0, $t0 move $a1, $t1 jal maior lw $t0, 4($sp) lw $t1, 8($sp)

la $a0, MENS move $a1, $t0 move $a2, $t1 move $a3, $v0 jal printf add $v0, $0, 4

syscall
aula5.doc 22 de 63

add $v0, $0, 0 lw $ra, 20($sp) lw $fp, 16($sp) addu $sp, $sp, 32 jr $ra maior: Else:

# return (0) # restaura o $ra para o S.O. # restaura o frame pointer do S.O. # remove o stack frame de main() # retorna para o S.O.

bgt $a0, $a1, Then # $a0 contm a e $a1 contm b move $v0, $a1 # coloca b (se ele for maior) em $v0 jr $ra # retorna para main() Then: move $v0, $a0 # coloca a (se ele for maior) em $v0 jr $ra # retorna para main() 3.5 Endereamento Instrues podem ser classificadas de acordo com o nmero de endereos que elas utilizam. No se deve esquecer que o conjunto de registradores dos processadores constitui, de fato, uma memria (de alta velocidade) e define um espao de endereamento. Uma instruo que soma o contedo do registrador 1 ao do registrador 2 e coloca o resultado no registrador 3 deve ser classificada como tendo trs endereos porque ela deve especificar quais so os trs registradores que sero utilizados. A instruo MIPS: add r3, r1, r2 <==> r3 = r1+r2; uma instruo de trs endereos. Instrues de zero, um, dois e trs endereos so comuns. Instrues de dois endereos compem grande parte da ISA IBM370. A instruo do IBM370: ADD R1, R2 <==> R1 = R1+R2 exemplo de uma instruo de dois endereos. Instrues de um endereo so comuns no Pentium. Estas instrues usam um registrador implcito como operando: o acumulador. A instruo: add bx <==> ax = ax + bx (ax o acumulador) uma instruo de um endereo. Instrues de zero endereo so comuns nos processadores Transputer e operam sobre dados na pilha. A instruo: add
aula5.doc 23 de 63

remove dois elementos da pilha, soma-os, e coloca o resultado no topo da pilha.

aula5.doc

24 de 63

3.5.1 Endereamento de Registrador Operandos de instrues podem ser acessados de diversas maneiras diferentes. No modo de endereamento conhecido como endereamento de registrador, o contedo de um registrador o operando. Exemplo: add $3, $2, $1 Nesta instruo, o modo de endereamento dos trs operandos endereamento de registrador. 3.5.2 Endereamento Imediato Neste modo de endereamento, o operando uma constante embutida na prpria instruo (o i de addi indica este tipo de endereamento): addi $3, $2, 10 A constante 10 codificada na instruo como indicado abaixo: nome No. bits decimal op 6 8 rs 5 2 rt 5 3 immediate 16 10

Constantes so normalmente de pequeno valor em programas tpicos e 16 bits o suficiente para codificar a maioria delas nas instrues. No entanto, s vezes elas so grandes. O conjunto de instrues MIPS inclui a instruo lui, load upper immediate (carregue na parte alta o imediato), que carrega um valor imediato de 16 bits nos 16 bits de mais alta ordem de um registrador especificado e zera os 16 bits de mais baixa ordem: lui $8, 255 nome No. bits decimal op 6 15 rs 5 0 Rt 5 8 immediate 16 255

aula5.doc

25 de 63

Uma instruo or (ou lgico) pode, ento, ser usada junto com a lui para compor constantes de 32 bits: 0xaaaa4444: .ascii string lui $8, 0xaaaa or $8, $8, 0x4444 3.5.3 Endereamento Relativo ao PC As instrues de desvio condicional da ISA MIPS usam uma constante para o operando que indica qual o endereo de desvio. Exemplo: bne $8, $21, 100 nome No. bits decimal op 6 5 Rs 5 8 Rt 5 21 immediate 16 100

Uma constante de 16 bits no permite acessar todas as instrues da memria, que endereada com 32 bits. No entanto, na maioria dos casos, as instrues de desvio condicional saltam para instrues prximas a ela na memria. Por essa razo, a constante que indica o endereo de desvio indica, na verdade, qual a distncia ao alvo do desvio relativa posio da instruo de desvio na memria. Para saber qual instruo deve ser trazida da memria para ser executada, o processador usa o registrador PC (Program Counter contador de programa). Quando uma instruo de desvio condicional trazida da memria, o registrador PC contm o endereo dela. Assim, quando um desvio tomado, o processador apenas soma a constante (valor imediato) ao PC e coloca o resultado em PC. O que faz com que o fluxo de execuo seja desviado para o novo endereo em PC. Para tornar o hardware mais simples e poderoso, a constante indica, na verdade, a distncia relativa instruo imediatamente aps o desvio e a distncia indicada em words.

aula5.doc

26 de 63

Diferente das instrues de desvio condicional, as instrues jal e j no somam sua constante (valor imediato) ao PC, mas substituem 26 bits de PC por ela os 4 bits de mais alta ordem e os dois de mais baixa ordem (que so sempre iguais a zero no PC porque as instrues so de 32 bits) no so alterados. j 10000 nome No. bits decimal op 6 2 Address 26 10000

Se os 4 bits de mais alta ordem de PC forem iguais a zero, esta operao equivalente a saltar para o endereo igual a quatro vezes o valor da constante. Este esquema simples de implementar no hardware (no necessrio fazer a soma). As complexidades que ele traz so tratadas pelo assembler (montador). Exemplo: label endereo loop: 1000 1004 1008

instruo add $t0, $t0, 1 beq $t0, $t1, Exit (1) j loop (250)

# PC = PC + 4 + Exit (1) * 4 = # 1012 # PC = loop * 4 = 1000 (os dois # bits de mais alta ordem de PC # so iguais a zero)

Exit: 1012

aula5.doc

27 de 63

3.5.3 Endereamento Base mais Deslocamento Este tipo de endereamento utilizado pelas instrues load/store: lw $8, 1200($19) Nome No. bits Decima l op 6 35 rs 5 19 Rt 5 8 address 16 1200

sw $8, 1200($19) nome No. bits decimal op 6 43 rs 5 19 Rt 5 8 Address 16 1200

O segundo operando (o primeiro o registrador $8), que est na memria, acessado no endereo: 1200+$19 Que igual ao contedo do registrador base, $19, mais a constante de deslocamento 1200.

aula5.doc

28 de 63

Sumrio:

Existem outras formas de endereamento presentes em outros processadores mas no no MIPS. 3.6 Arrays versus Pointers Muitos programadores iniciantes acham o conceito de pointer difcil de entender. Contudo, um exemplo em assembly pode tornar o entendimento deste conceito mais fcil. O trecho de cdigo em C abaixo limpa o contedo de um array. void clear_array (char array[], int size) { int i;

aula5.doc

29 de 63

for (i = 0; i < size; i = i + 1) array[i] = 0; /* o elemento i de array recebe zero */ } O trecho abaixo faz a mesma coisa usando pointers. void clear_array_p (char *array, int size) { char *p; for (p = array; p < array+size; p = p + 1) *p = 0; /* a posio de memria apontada por p recebe zero */ } O trecho em assembly abaixo implementa a primeira verso. Os registradores $4 e $5 so usados para passar os parmetros para a funo. clear_array: mov $2, $0 loop: add $14, $2, $4 sb $0, 0($14) addi $2, $2, 1 blt $2, $5, loop jr $31 #i=0 # $4 = endereo do array; $14 aponta para # array[i] # array[i] = 0 #i=i+1 # $5 = size; se i < size vai para loop

aula5.doc

30 de 63

O trecho em assembly abaixo implementa a verso usando pointers. clear_array_p: mov $2, $4 add $14, $4, $5 sb $0, 0($2) add $2, $2, 1 blt $2, $14, loop # p = array # $14 = endereo do array + tamanho # do array ($5) # *p = 0; o mesmo que array[i] = 0 #p=p+1 # se p < array+size vai para loop

loop:

A verso com pointers mais rpida (apenas trs instrues no loop) porque a varivel i no precisa ser mantida o pointer p aponta diretamente para o item a ser alterado. 4. Montadores, Interpretadores Ligadores, Carregadores, Compiladores e

4.1 Montadores Os montadores, ou assemblers, montam um programa em linguagem de mquina a partir de sua verso em linguagem de montagem, ou linguagem assembly. Eles: 1. Acham um endereo inicial para o programa 2. Convertem pseudo-instrues para o conjunto de instrues equivalente 3. Convertem macros no conjunto de instrues e dados equivalentes 4. Transformam cada parte dos comandos em linguagem assembly em opcode, nmero de registrador, constante, etc 5. Escrevem o programa em linguagem de mquina em um arquivo com as instrues ordenadas e com os endereos indicados por elas, especificados como labels, j convertidos para nmeros quando possvel O arquivo gerado pelo montador chamado de arquivo objeto e, em geral, no pode ser executado diretamente pela mquina por conter referncias a sub-rotinas e dados especificados em outros arquivos. Um arquivo objeto tpico para o sistema operacional Unix contm seis sees distintas: 1. header descreve as posies e os tamanhos das outras sees 2. text segment contm o cdigo em linguagem de mquina 3. data segment contm os dados especificados no arquivo fonte 4. relocation information lista as instrues e palavras de dados que dependem de endereos absolutos
aula5.doc 31 de 63

5. symbol table associa endereos com smbolos especificados no arquivo fonte e lista os smbolos no resolvidos (que esto ligados a outros arquivos) 6. debugging information contm uma descrio sucinta de como o arquivo foi compilado, de modo a permitir que um programa debugger possa encontrar instrues e endereos indicados no arquivo fonte

aula5.doc

32 de 63

Formato de um header de arquivo a.out antigo:

struct _exec_header { unsigned char unsigned char unsigned short int unsigned int unsigned int unsigned int unsigned int unsigned int unsigned int unsigned int }; dynToolVer; machineType; magicNumber; textSize; dataSize; bssSize; symbolTabSize; entryPoint; textRelSize; dataRelSize;

O header a primeira seo do arquivo a.out. As demais sees so escritas em sequencia no a.out. Para gerar um programa executvel a partir de um ou mais arquivos objeto temos que usar um linker.

aula5.doc

33 de 63

4.2 Ligadores Muitas vezes, um programa pode ser decomposto em vrias rotinas, cada uma responsvel por aspectos especficos da computao a ser executada pelo programa. Por exemplo: um programa para computar o total da folha de pagamento de uma empresa pode ser divido em uma rotina que calcule a salrio de cada funcionrio, levando em considerao o fundo de garantia, contribuio ao INSS, etc, e uma outra que compute o total a ser despendido para o pagamento de todos os funcionrios. float calcula_um_salrio (float salrio_base) { float salrio_total; salrio_total = salrio_base + salrio_base * FATOR_FGTS + salrio_base * FATOR_INSS; return (salrio_total); } float salrio_total (float salrio_base[], int numero_funcionrios) { int i; float total; total = 0.0; for (i = 0; i < numero_funcionrios; i++) total = total + calcula_um_salrio (salrio_base [i]); return (total); } Estas rotinas podem estar em arquivos separados. Na verdade, programas grandes so, em geral, divididos em diversas rotinas que so, por sua vez, agrupadas em diversos arquivos. Ligadores, ou likers, so programas especiais que recebem como entrada os arquivos objeto correspondentes a estes arquivos e geram como sada o programa final em linguagem de mquina.

aula5.doc

34 de 63

Um linker realiza, ento, quatro tarefas bsicas: 1. Determina as posies de memria para os trechos de cdigo de cada mdulo que compe o programa sendo linkado 2. Resolve as referncias entre os arquivos 3. Procura nas bibliotecas (libraries), indicadas pelo programador, as rotinas usadas nos fontes de cada mdulo 4. Indica ao programador quais so os labels que no foram resolvidos (no tenham correspondente em nenhum mdulo ou library indicados) Assim como os arquivos objeto, os programas executveis gerados por linkers so divididos em sees. Na verdade, as sees so as mesmas presentes nos arquivos objeto, exceto que, neste caso, no h smbolos no resolvidos. 4.3 Carregadores Programas que tenham sido linkados sem erros podem ser executados. Para executar um programa, um programa carregador, ou loader, utilizado. O loader , em geral, parte do sistema operacional. Para iniciar a execuo de um programa, o sistema operacional (loader) realiza as seguintes operaes: 1. L o header do executvel para determinar o tamanho das suas diversas partes 2. Separa um trecho da memria para receber os segmentos text, data, e tambm para acomodar o stack 3. Copia as instrues e os dados para o trecho de memria separado 4. Copia os argumentos passados ao programa para a rea de memria separada para stack 5. Inicializa os registradores do processador para valores apropriados (em particular, o que guarda o endereo do topo do stack) 6. Salta para a primeira instruo do programa usando a instruo da mquina utilizada para chamada de procedimento (jal, no caso da MIPS ISA) 4.4 Compiladores Compiladores so programas que recebem como entrada arquivos texto contendo mdulos escritos em linguagem de alto nvel e geram como sada arquivos objeto correspondentes a cada mdulo, ou, se todas as bibliotecas e mdulos so apresentados como entrada, geram um programa executvel diretamente.

aula5.doc

35 de 63

4.5 Interpretadores Programas interpretadores recebem como entrada arquivos texto contendo programas em linguagem assembly ou linguagem de alto nvel, ou arquivos binrios com instrues de mquina, e os executam diretamente. Interpretadores percorrem os programas, a partir de seu ponto de entrada, executando cada comando. Algumas vezes, antes de poderem ser interpretados, os programas tem que ser pr-processados. No caso de Java, por exemplo, o programa fonte transformado em byte-code, em um processo equivalente ao processo de compilao, e posteriormente pode ser interpretado (executado) por uma mquina virtual Java. Na verdade, os processadores so interpretadores implementados em hardware! 5. Aritmtica de Computador 5.1 Nmeros negativos Nmeros podem ser representados em qualquer base. Ns, humanos, preferimos usar a base 10, talvez porque tenhamos 5 dedos em cada mo. Existem vrias vantagens em usar nmeros binrios em computadores; assim, computadores usam nmeros binrios e toda a sua aritmtica baseada nisso. Para ns, humanos, nmeros no tm, necessariamente, um limite de tamanho. Computadores, por razes de custo e dificuldade de implementao, tm limites no tamanho dos nmeros que podem ser representados em suas operaes bsicas. Na MIPS ISA o tamanho bsico dos nmeros inteiros 32 bits. Com 32 bits um processador MIPS pode representar o zero e nmeros positivos que vo de 1 a 2 32 1 (4.294.967.295). Mas como representar nmeros negativos? O ideal seria ter um nmero igual de nmeros negativos e positivos. Contudo, temos tambm que representar o zero. Como 2 32 um nmero par, optou-se por termos 231 1 nmeros positivos, o zero, e 231 nmeros negativos, com um nmero negativo a mais que o total de nmeros positivos. Esta regra tambm vale quando o computador tem menos bits para representar nmeros inteiros. Assim, temos:

aula5.doc

36 de 63

Com 32 bits base 2 (binrio)

0000 0000 0000 0111 0111 0111 1000 1000 1000 1000 1111 1111 0000 0000 0000 0000 0000 0000 0000 0000 0000 1111 1111 1111 0000 0000 0000 0000 1111 1111 1111 0000 0000 0000 0000 1111 1111 1111 0000 0000 0000 0000 0000 0000 0000 0000 = 0 0000 0000 0000 0001 = 1 0000 0000 0000 0010 = 2 1111 1111 1111 0000 0000 0000 0000 1111 1111 1111 0000 0000 0000 0000 1111 1111 1111 0000 0000 0000 0000 1101 1110 1111 0000 0001 0010 0011 = = = = = = = 2.147.483.645 2.147.483.646 2.147.483.647 -2.147.483.648 -2.147.483.647 -2.147.483.646 -2.147.483.645

base 10 (decimal)

1111 1111 1111 1111 1111 1111

1111 1111 1111 1110 = -2 1111 1111 1111 1111 = -1

aula5.doc

37 de 63

Com 4 bits base 2 (binrio)

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 = = = = = = = = = = = = = = = = 0 1 2 3 4 5 6 7 -8 -7 -6 -5 -4 -3 -2 -1

base 10 (decimal)

Em alguns casos, nmeros negativos no so teis ou no faz sentido utilizalos. Este o caso de endereos de memria, por exemplo. No faz sentido usar endereos de memria negativos. Muitas instrues aritmticas operam em dois modos: signed (com sinal) ou unsigned (sem sinal). O modo default (definido a priori) signed; quando queremos que a instruo opere sem sinal (considerando todos os nmeros como positivos) temos que especificar. Por exemplo: slt sltu $8, $16, $17 $9, $16, $17 # comparao com sinal (signed) # comparao sem sinal (unsigned)

Exerccio: Suponha que $16 contenha o nmero binrio:

1111 1111 1111 1111 1111 1111 1111 1111

e que $17 contenha o nmero binrio:

0000 0000 0000 0000 0000 0000 0000 0001

Quais so os valores de $8 e $9 aps a execuo das instrues abaixo? slt $8, $16, $17 sltu $9, $16, $17

aula5.doc

38 de 63

5.2 Soma e Subtrao Para somar nmeros binrios podemos usar a mesma tcnica que usamos quando somamos nmeros decimais: somar dois dgitos de cada vez. Exemplo: decimal
18 +25 = -43

binrio (8 bits)
0001 0010 +0001 1001 = --------00010 1011

A subtrao tambm usa a mesma tcnica: decimal

25 18 = -07

binrio
0001 1001 0001 0010 = --------0000 0111

ou, somado com o -18

0001 1001 +1110 1110 = --------0000 0111

Em hardware a subtrao normalmente implementada com a soma com o complemento de dois do subtraendo. O complemento de dois de um nmero binrio igual a seu complemento bit-a-bit mais 1. O complemento de dois de 18 : 18 = complemento bit-a-bit = complemento bit-a-bit +1 =
0001 0010 1110 1101 1110 1110

Assim, a operao 25 18 em binrio pode, tambm, ser feita (e em geral feita) como abaixo:
0001 1001 +1110 1101 + 1 = --------0000 0111

complemento (complemento de 1) de 18

aula5.doc

39 de 63

Um problema ocorre quando os nmeros somados produzem um resultado com mais bits do que o pode ser representado. Quando isso ocorre, diz-se que houve um overflow (transbordo). Pode acontecer overflow em somas e em subtraes. A tabela abaixo indica em quais situaes podemos afirmar que ocorreu um overflow. A Operando A B Operando B C Resultado A+B 0 0 <0 A+B <0 <0 0 AB 0 <0 <0 AB <0 0 0 (o zero sozinho indica nmeros positivos ou o nmero zero) Quando ocorre um overflow, o processador deve indicar ao programador. Processadores usam interrupes (ou excees) para indicar eventos como um overflow. Para evitar a sinalizao de um overflow quando ele no faz sentido, instrues que desconsideram sinais so utilizadas: add (soma com sinal) e addi (soma imediato com sinal), causam excees quando o processador configurado para tal addu (soma sem sinal), addui (soma imediato sem sinal), no causam excees 5.3 Operaes Lgicas Operaes lgicas, tais como E, OU, OU EXCLUSIVO e NEGAO, so feitas bit a bit. Exemplo: binrio (8 bits) 0001 0010 &0001 1001 = -------------0001 0000 Outro tipo de operao lgica sempre presente em computadores o shift (deslocamento): para direita: 0010 1011 >> 1 = 0001 0101
aula5.doc 40 de 63

Operao

para esquerda: 0010 1011 << 1 = 0101 0110 5.4 Unidade Aritmtica e Lgica (Arithmetic and Logic Unit ALU) A ALU a parte central do hardware de uma CPU. Ela responsvel por realizar operaes aritmticas e lgicas bsicas, e pode ser implementada com quatro componentes: porta E (And), porta OU (Or), inversor (Inverter) e multiplexador (multiplexor). a 0 0 1 1 a 0 0 1 1 a 0 1 d 0 1 b 0 1 0 1 c=a.b 0 0 0 1

E (AND)

a b

OU (OR)

a b

b c=a+b 0 0 1 1 0 1 1 1 c=a 1 0 c= a b

Inversor

Multiplexador

a b

c
1

Uma ALU de um bit para as operaes E e OU pode ser implementada como abaixo:
Operao
a

Resultado
b

aula5.doc

41 de 63

Podemos implementar um somador de 1 bit usando os componentes bsicos. Para isso, iniciamos com a tabela verdade do somador de um bit.

aula5.doc

42 de 63

a 0 0 0 0 1 1 1 1

Entradas b 0 0 1 1 0 0 1 1

vem um 0 1 0 1 0 1 0 1

Sadas vai um soma 0 0 0 1 0 1 1 0 0 1 1 0 1 0 1 1

A sada vai um igual a 1 quando: vai_um = a.b.vem_um + a.b.vem_um + a.b.vem_um + a.b.vem_um (5.1) onde . representa um E lgico, + representa um OU e entradas sublinhadas indicam um termo verdadeiro quando a entrada igual a zero. A equao 5.1 pode ser simplificada para: vai_um = b.vem_um + a.vem_um + a.b (5.2)

j que (a.b.x + a.b.x) = (a.b). O circuito equivalente equao 5.2 como abaixo:
vem um

vai um

Exerccio: Faa a equao e o circuito que produz o bit de soma.

aula5.doc

43 de 63

Uma ALU de 1 bit para a soma, o E e o OU lgicos pode ser implementada como abaixo:
Operao vem um
a

0 1 2

Resultado

vai um

Uma ALU de 32 bits:

vem um Operao

a0

vem um ALU0
resultado0

b0

vai um

a1

vem um ALU0
resultado1

b1

vai um

. . .

a31

vem um ALU0
resultado31

b31

vai um

aula5.doc

44 de 63

aula5.doc

45 de 63

Para implementar a subtrao, podemos mudar nossa ALU de um bit bsica para permitir a inverso da entrada b e a soma de 1 atravs do vem um:
b_invertido Operao vem um
a b
0 1

0 1 2

Resultado

vai um

Mudanas especficas no bit de mais alta ordem permitem incluir o teste de overflow. Para incluir a operao feita pela instruo slt (set on less than), temos que adicionar uma entrada less no multiplexador de resultado. Esta entrada conectada ao zero nas ALUs dos bits 1 at 31 (ALU[1-31]). A ALU do bit de mais alta ordem (ALU31) modificada para gerar o sinal set, que ser igual a 1 se a < b. O sinal set fica conectado entrada less do bit de mais baixa ordem (ALU0).
b_invertido Operao vem um
a b
0 1

0 1 2

Resultado

+ less
3

set Deteco de overflow

overflow

vai um

aula5.doc

46 de 63

As instrues de desvio, beq e bne, podem tambm usar a ALU para saber se dois registradores so iguais ou diferentes. Para isso, basta subtrair o valor em um registrador pelo valor no outro e testar se o resultado igual a zero. At este ponto, a ALU capaz de realizar a subtrao, mas no a comparao para ver se o resultado igual a zero. Para implementar a comparao, basta incluir uma porta OU na sada da ALU e um inversor na sada desta:
vem um Operao

a0

vem um ALU0 less vai um

resultado0

b0

a1
0

vem um ALU0 less vai um

resultado1

b1

. . .

. . .

zero

a31
0

vem um ALU0 less vai um

set resultado31 overflow

b31

Outras funes de interesse, como o OU EX CLUSIVO (exclusive or ou xor), podem ser includas na ALU. Algumas operaes no so, em geral, implementadas na ALU. Exemplos: shift, multiplicao, diviso e operaes de ponto flutuante.

aula5.doc

47 de 63

O smbolo normalmente usado para representar uma ALU como abaixo:

a b

controle zero

ALU overflow resultado

vai um

Controle 000 001 010 110 111

Operao feita pela ALU E OU soma subtrao set-on-less-than

5.4 Multiplicao Inteira Podemos realizar a operao de multiplicao de nmeros decimais como abaixo: 1000 x 1001 -----1000 0000 0000 1000 ----------1001000 multiplicando multiplicador

produto

Um fato importante mostrado pelo exemplo acima que o produto tem muito mais casas decimais que o multiplicando e o multiplicador. Na verdade, se o multiplicando tem m casa e o multiplicador tem n casas, o produto tem m+ n casas. Se os nmeros acima so binrios, a operao de multiplicao pode ser feita da mesma maneira e o resultado teria os mesmos dgitos (1000 = 8, 1001 = 9; 1000x1001 = 1001000 = 72). Na verdade, a multiplicao binria consiste, neste caso, apenas em copiar o multiplicando deslocado do nmero apropriado de casas ou copiar zero deslocado do nmero apropriado de casas.

aula5.doc

48 de 63

Para implementar a multiplicao via hardware existem vrias possibilidades. Vamos analisar vrias delas. Mas antes, precisamos compreender como funcionam os flip-flops. Flip-Flops Flip-flops so dispositivos eletrnicos capazes de guardar estado. O mais simples o S-R:

Um tipo muito importante de flip-flop o flip-flop tipo D. Existem dois tipos: acionado por nvel e acionado pela borda. Abaixo o acionado por nvel:

aula5.doc

49 de 63

E o abaixo o acionado pela borda:

Podemos agrupar flip-flops acionados pela borda ou por nvel de modo a implementar registradores como os de um processador MIPS.

aula5.doc

50 de 63

Podemos agrupar registradores do tipo D acionados pela borda de modo a implementar um registrador de deslocamento:

C.3. Primeiro hardware e algoritmo para a multiplicao A figura abaixo mostra o nosso primeiro hardware para multiplicao.

Vamos assumir que o multiplicador esta no registrador multiplier (multiplicador em ingls), que o multiplicando esta no registrador multiplicand e que o registrador com o produto est inicializado com zero. O hardware da figura acima testa o bit de mais baixa ordem do multiplicador e, se seu valor 1, soma o valor do multiplicando com o valor no registrador produto e guarda o resultado no registrador produto; caso contrrio, o

aula5.doc

51 de 63

hardware no altera o valor do registrador produto. Alm disso, o hardware desloca o contedo do registrador multiplicador de um bit para a direita e o valor do registrador multiplicando de um bit para a esquerda. Este processo repetido at que o registrador multiplicador tenha sido deslocado de 32 bits.

aula5.doc

52 de 63

A figura abaixo apresenta o funcionamento deste hardware de multiplicao na forma algortmica.

aula5.doc

53 de 63

Exemplo de funcionamento:

11

Se cada passo acima necessitasse de um ciclo de clock, este algoritmo levaria quase 100 ciclos de clock para fazer esta multiplicao. Operaes de adio e subtrao ocorrem com uma freqncia de 5 a 100 vezes maior que a multiplicao; assim, uma diferena de 100 vezes no tempo destas operaes pode no afetar fortemente o desempenho em muitos programas. Contudo, j vimos que a lei de Amdahl mostra que mesmo operaes lentas com freqncia moderada podem afetar negativamente o desempenho do computador.

aula5.doc

54 de 63

C.4. Segundo hardware e algoritmo para a multiplicao Pioneiros da computao observaram que metade dos bits do multiplicando do nosso hardware anterior era sempre igual a zero. Assim, uma ALU de 64 bits era um desperdcio. A figura abaixo mostra o nosso segundo hardware para multiplicao. Nele, o produto deslocado para a direita e o multiplicando no precisa, ento, ser deslocado.

aula5.doc

55 de 63

A figura abaixo mostra o algoritmo implementado por este hardware.

aula5.doc

56 de 63

Veja um exemplo da operao do nosso segundo hardware de multiplicao inteira:

aula5.doc

57 de 63

C.5. Terceiro hardware e algoritmo para a multiplicao Os pioneiros da computao logo observaram que, no ltimo hardware apresentado, a metade dos bits do produto era jogada fora no processo de multiplicao, ao mesmo tempo em que um nmero de bits igual era jogado fora do multiplicador. Assim, eles criaram o nosso terceiro hardware, que como abaixo.

Neste hardware, os 32 bits de baixa ordem do produto so carregados inicialmente com o valor do multiplicador, ao passo que seus 32 bits de mais baixa ordem so inicialmente zerados. No final do processo, o registrador produto contm o resultado da multiplicao.

aula5.doc

58 de 63

A figura abaixo mostra o algoritmo implementado por nosso hardware final.

C.6. C.7. Multiplicao com sinal At agora ns apenas estudamos multiplicao sem sinal. A maneira mais simples de implementar a multiplicao com sinal separar os bits de sinal (fazer a multiplicao de 31 bits, apenas) e, no final da multiplicao, colocar o sinal no produto usando a regra que aprendemos no primrio: o sinal do produto negativo quando os sinais do multiplicando e do multiplicador so diferentes.

aula5.doc

59 de 63

2.6 Comparando e Sumarizando Desempenho Mesmo tomando o cuidado de indicar todos os parmetros relevantes, dvidas podem surgir quando comparamos ou sumarizamos desempenho.
Programa P1 (seg.) Programa P2 (seg.) Tempo Total Computador A 1 1000 1001 Computador B 10 100 110 Computador C 20 20 40

Usando diferentes definies de mais rpido, temos: A 10 vezes mais rpido que B para o programa P1. No entanto, B 10 vezes mais rpido que A para o programa P2. Se tomarmos o tempo total para executar P1 e P2 como medida de desempenho, C o computador mais rpido; contudo, ele 20 vezes mais lento que A na execuo do programa P1. Etc A melhor forma de sumarizar desempenho o tempo total de execuo. Assim, quando comparando o desempenho de computadores para um conjunto de programas (benchmark suite) podemos sumarizar o desempenho das seguintes formas: Mdia aritmtica dos tempos de execuo equivalente soma dos tempos de execuo Mdia aritmtica de Tempo (i,n) =
1 n Tempoi n i 1

Se o desempenho expresso como uma taxa (rate), a mdia harmnica acompanha a soma dos tempos de execuo. Mdia harmnica de Taxa (i,n) =
n

Taxa
i 1

aula5.doc

60 de 63

Programa P1 (seg.) Programa P2 (seg.) Tempo Total Mdia Aritmtica Mdia Harmnica

Computador A 1 1000 1001 500,5 1,998

Computador B 10 100 110 55,0 18,181

Computador C 20 20 40 20,0 20,000

aula5.doc

61 de 63

 A mdia geomtrica dos tempos normalizados tambm utilizada para sumarizar desempenho. Mdia geomtrica do Tempo Normalizado (i,n) =
n

Tnormalizado
i 1

Uma caracterstica da mdia geomtrica que ela melhora igualmente se um benchmark do suite melhorado de 2 para 1 ou se um outro melhorado de 2000 para 1000. A normalizao pode causar interpretaes errneas da mdia aritmtica tambm, como mostrado abaixo.
Computador A 1.0 1.0 1.0 1.0 1.0 Normalizado por A Computador B 10.0 0.1 5.05 1.0 0.11 Computador C 20.0 0.02 10.01 0.63 0.04

Programa P1 (seg.) Programa P2 (seg.) Mdia Aritmtica Mdia Geomtrica Tempo Total

2.7 Princpios Quantitativos para o Projeto de Computadores O principal princpio a ser seguido : Torne mais rpidas as tarefas mais freqentes. Este princpio pode ser quantificado pela lei de Amdahl: A quantidade de melhoria de desempenho provida por um atributo da arquitetura limitada pela quantidade de tempo que este atributo utilizado. A lei de Amdahl define o speedup que pode ser obtido por um atributo particular de um sistema.
Tempo de execuo da tarefa inteira sem usar o novo atributo Speedup = _____________________________________________________________ Tempo de execuo da tarefa inteira usando o novo atributo quando possvel

aula5.doc

62 de 63

2.8 O Tempo de Execuo de um Programa Se apenas o processador (CPU) levado em considerao, o tempo de execuo de um programa pode ser definido como: Tempo de CPU de um Programa = Ciclos de Clock despendidos no Programa x Tempo de um Ciclo Ou, Tempo de CPU de um Programa = Ciclos de Clock despendidos no Programa / Freqncia de Clock Exerccio: Um programa roda em 10 segundos em um computador A, que tem um clock de 100MHz. Se um computador B gasta 1.2 vezes mais ciclos de clock para rodar o mesmo programa, mas roda este programa em 6 segundos, qual a freqncia de clock do computador B? 10s = x_ciclos / 100MHz; x_ciclos = 10s x 100MHz 6s = 1.2 x x_ciclos / x_MHz; x_MHz = 1.2 x 10s x 100MHz / 6s x_MHz = 200MHz

aula5.doc

63 de 63

5.5 Diviso Inteira A diviso o recproco da multiplicao; ela menos freqente nos programas e mais complexa de implementar em hardware. Seguindo o exemplo que usamos para multiplicao, vamos comear a estudar a diviso binria relembrando nossos conhecimentos sobre diviso decimal. Podemos dividir 1.001.010 por 1000 como abaixo:

dividendo 1001010 - 1000 0001 10 101 1010 - 1000 0010

divisor 1000 1001

quociente

resto

Os dois operandos, dividendo (dividend) e divisor (divisor), produzem dois resultados na diviso: quociente (quotient) e resto (remainder). A relao entre os operandos e os resultados da diviso pode tambm ser expressa como: dividendo = quociente x divisor + resto onde o resto menor que o divisor. Algumas vezes, programas usam a operao de diviso apenas para obter o resto. Como no caso da multiplicao, para implementar a diviso em hardware existem vrias possibilidades. Vamos analisar vrias delas, da mais intuitiva a mais eficiente e atualmente utilizada nos processadores.

aula18.doc

1 de 16

Primeiro hardware e algoritmo para a diviso A figura abaixo mostra o nosso primeiro hardware para diviso.

Este hardware imita o algoritmo que usamos para a diviso decimal. Para iniciar uma diviso, zeramos o registrador de quocient, carregamos os 32 bits de mais alta ordem do registrador divisor com o divisor e o registrador remaider com o dividendo.

aula18.doc

2 de 16

A figura abaixo apresenta o funcionamento deste hardware de diviso na forma algortmica.

O hardware do computador no experto como um ser humano para ver que o divisor menor que o dividendo. Por isso, ele primeiro subtrai o divisor do dividendo e, se o resultado for negativo, ele restaura o valor do dividendo somando o divisor com o dividendo novamente. O resultado da diviso estar nos registradores quotient e remaider no fim de 33 passos. A razo para 33 e no 32 passos ficar clara na nossa prxima verso do algoritmo.
aula18.doc 3 de 16

Exemplo de funcionamento do algoritmo:

00

Como pode ser observado acima, precisamos de 5 iteraes do algoritmo para fazer uma diviso de 4 bits.

aula18.doc

4 de 16

Segundo hardware e algoritmo para a diviso Como no caso da multiplicao, os pioneiros da computao observaram que a metade dos bits do divisor do nosso hardware anterior era sempre igual a zero. Assim, uma ALU de 64 bits era um desperdcio. A figura abaixo mostra o nosso segundo hardware para diviso. Nele, o resto deslocado para a esquerda e o divisor no precisa, ento, ser deslocado. O alinhamento da entrada esquerda e da sada da ALU com relao ao registrador remainder garantem o correto funcionamento deste novo hardware. Para iniciar uma diviso, zeramos o registrador quocient, carregamos o registrador divisor com o divisor e o registrador remaider com o dividendo.

A segunda melhora proporcionada pelo hardware acima vem do fato de que o primeiro passo de sua operao nunca produz um 1 no quociente: como a diviso por zero no uma operao vlida, o valor inicial do divisor ser sempre maior que o contedo da parte alta do remainder, que inicialmente igual a zero. Atravs da inverso da ordem das operaes para (i) deslocar o remainder e ento (ii) fazer a primeira subtrao, um passo do algoritmo pode ser eliminado.

aula18.doc

5 de 16

A figura abaixo mostra o algoritmo implementado pelo segundo hardware de diviso.

aula18.doc

6 de 16

Veja agora um exemplo da operao do nosso segundo hardware de diviso inteira:

aula18.doc

7 de 16

Terceiro hardware e algoritmo para a diviso Como no caso da multiplicao, os pioneiros da computao observaram que, no ltimo hardware apresentado, a metade dos bits do registrador remainder era jogada fora no processo de diviso, ao mesmo tempo em que um nmero igual de bits era jogado fora do registrador quotient. Assim, eles criaram o nosso terceiro hardware, que como abaixo.

Neste hardware, os 32 bits de baixa ordem do remainder so carregados inicialmente com o valor do dividendo, ao passo que seus 32 bits de mais alta ordem so inicialmente zerados. A cada passo da diviso, um bit do quociente inserido no registrador; o dividendo deslocado em conjunto. Uma conseqncia de juntar os dois registradores e usar a nova ordem das operaes introduzida no algoritmo anterior o deslocamento do resto de um passo a mais que o necessrio. Para corrigir isso, no final do processo, a parte alta do registrador remainder deslocada de um bit para a direita. O registrador remainder conter, aps a diviso, o resto na parte alta e o quociente na parte baixa.

aula18.doc

8 de 16

A figura abaixo mostra o algoritmo implementado por nosso hardware final.

aula18.doc

9 de 16

Veja abaixo um hardware/algoritmo.

exemplo

de

diviso

usando

este

ltimo

1110

Diviso com sinal At agora ns apenas estudamos a diviso sem sinal. A maneira mais simples de implementar a diviso com sinal separar os bits de sinal (fazer a diviso de 31 bits, apenas) e, no final da diviso, colocar o sinal no quociente usando a regra que aprendemos no primrio: o sinal da diviso negativo quando os sinais do divisor e do dividendo so diferentes. Um complicador que temos que colocar o sinal do resto corretamente tambm. Para isso podemos usar a equao: dividendo = quociente x divisor + resto Esta equao esta sempre correta. Experimentando com ela possvel verificar que o sinal do resto sempre igual ao sinal do dividendo. Assim, a diviso com sinal torna o sinal do quociente negativo se o sinal do divisor e do dividendo so diferentes e torna o sinal do resto sempre igual ao sinal do dividendo. O mesmo hardware para a diviso pode ser usado para a multiplicao. Para isso, necessrio que o registrador de 64 bits possa ser deslocado para a direita e para a esquerda e que a ALU possa somar e subtrair. Processadores MIPS possuem, alm dos 32 registradores para operaes inteiras, dois registradores para apoiar a multiplicao e a diviso: Hi e Lo. A tabela a seguir mostra como usar as instrues de multiplicao, diviso e de leitura de Hi e Lo.
aula18.doc 10 de 16

/ /

O assembler da MIPS ISA permite que se utilize pseudo-instrues para multiplicao e diviso com trs operandos. Neste caso, o assembler usa as instrues mflo e mfhi para copiar os registradores Hi e Lo para os registradores apropriados. A diviso por zero produz infinito como resultado. Esta uma operao ilegal em qualquer computador. Muitas mquinas detectam diviso por zero em hardware. A MIPS ISA exige que o teste seja feito por software.

aula18.doc

11 de 16

5.5 Nmeros de Ponto Flutuante Alm dos nmeros inteiros, com e sem sinal, linguagens de programao de alto-nvel incluem facilidades para representar os nmeros reais da matemtica. Veja alguns exemplos de nmeros reais: 3.141592 (pi) 2.71828 (e) 0.000000001 ou 1.0 x 10-9 3,155,760,000 ou 3.15576 x 109 A notao usada nos dois ltimos nmeros acima chamada de notao cientfica. Um nmero em notao cientfica com apenas um nmero diferente de zero esquerda do ponto decimal dito normalizado. Assim, 1.0 x 10-9 est normalizado, enquanto que 10 x 10-8 e 0.1 x 10-10 no esto. Ns tambm podemos escrever nmeros binrios em notao cientfica: 1.0 x 2-1 A aritmtica computacional que suporta nmeros binrios no formato acima conhecida como aritmtica de ponto flutuante (floating point) porque ela representa nmeros onde o ponto decimal no est fixo: nos nmeros inteiros o ponto decimal est fixo logo aps o ltimo algarismo direita. Na linguagem C, variveis do tipo ponto flutuante so declaradas como abaixo: int i; float f; /* i uma varivel do tipo inteiro */ /* f uma varivel do tipo ponto flutuante */

A forma binria de nmeros em notao cientfica como abaixo: 1.xxxxxx x 2yyyy onde xxxxxx e yyyy so nmeros binrios.

aula18.doc

12 de 16

Os nmeros de ponto flutuante da MIPS ISA podem ser representados em dois formatos distintos, que so parte do IEEE 754 floating-point standard (Standard 754 do Instituto dos Engenheiros Eletricistas e Eletrnicos dos Estados Unidos):

O bit S o sinal, o campo exponent o expoente e mantissa so os bits de mantissa, ou bits significantes do nmero. Em preciso simples podemos representar nmeros na faixa que vai de (na base 10) 2.0 x 10 38 a 2.0 x 10-38, enquanto que em preciso dupla podemos representar nmeros na faixa que vai de (na base 10) 2.0 x 10 308 a 2.0 x 10-308, aproximadamente. possvel que ocorra um overflow como resultado de uma operao de ponto flutuante. Um overflow em ponto flutuante ocorre quando o nmero de bits do expoente do resultado maior que o nmero de bits possvel no formato em que a operao realizada (preciso simples ou dupla). Em certos casos, o resultado de uma operao pode ser um nmero pequeno demais para ser representado (o nmero de bits do expoente negativo grande demais). Este evento conhecido como underflow.

aula18.doc

13 de 16

Para comprimir mais bits na parte significante dos nmeros de ponto flutuante, o padro IEEE 754 torna implcito o 1 antes do ponto dos nmeros binrios normalizados. Assim, o campo significand dos nmeros de preciso simples tem, na verdade, 24 bits, enquanto que o dos nmeros de preciso dupla tem 53 bits. Uma vez que o nmero zero no tem um 1 antes do ponto, ele representado com o expoente reservado, zero. Assim, se numerarmos os bits do significand da esquerda para direita como s1, s2, , os nmeros restantes so representados como abaixo: (-1)S x (1 + (s1 x 2-1) + (s2 x 2-2) + (s3 x 2-3) + ) x 2E Os projetistas do padro IEEE 754 queriam, tambm, que nmeros na representao ponto flutuante pudessem ser facilmente manipulados por operaes inteiras. Por isso que o bit de sinal o bit de mais alta ordem, o que permite fazer o teste de maior ou menor que zero facilmente, usando as mesmas instrues para este teste em inteiros. O teste de zero igual para nmeros inteiros e de ponto flutuante, j que o zero tem a mesma representao para os dois tipos de nmero. Colocar o expoente antes do significante simplifica a ordenao de nmeros de ponto flutuante, j que nmeros normalizados com expoentes maiores aparentam de fato ser maiores se so lidos como inteiros e tem o mesmo sinal. Nmeros com expoentes negativos no poderiam ser ordenados como inteiros se o padro IEEE 754 usasse a mesma notao que aprendemos para nmeros negativos para representar expoentes negativos. A notao mais desejvel, neste caso, representaria o expoente mais negativo como 00000 e o expoente mais positivo como 11111. Uma notao deste tipo chamada de biased notation (notao deslocada). O IEEE 754 usa um deslocamento de 127 para preciso simples. Assim, 1 representado pelo padro de bits 1+127, ou 126 = 0111 1110, e +1 representado por 1+127, ou 128 = 1000 0000. Isso significa que, segundo o IEEE 754, devemos aplicar a formula abaixo para saber o valor de um nmero expresso no formato de ponto flutuante: (-1)S x (1 + significand) x 2(exponent bias)

aula18.doc

14 de 16

O valor do deslocamento (bias) para o expoente na preciso simples igual a 127 e para o expoente na preciso dupla igual a 1023. Como mencionado anteriormente o expoente igual a zero usado para representar o zero. Na verdade, combinaes de valores reservados do expoente com valores especficos da mantissa so usadas para representar tambm o overflow, o underflow, +, - e NaN (Not a Number). Existem trs tipos de operaes que podem retornar NaN: Operaes que produzem um nmero indeterminado: o As divises 0/0 e / o As multiplicaes 0 e 0 o As adies + (- ), (- ) + e subtraes equivalentes o O padro IEEE 754 define funes especficas para calcular potncias: A funo powr define 00, 1 e 0 como NaN. Mas note que as funes pow e pown definem as trs formas acima como 1.0. Operaes reais com resultados complexos, por exemplo: o A raiz quadrada de um nmero negativo. o O logaritmo de um nmero negativo o O arco seno ou coseno de um nmero que menor do que -1 ou maior do que 1. Operaes com um NaN como pelo menos um de seus operandos. Codificaes de valores especiais no padro IEEE 754:

Exerccio: Mostre a representao binria, no padro IEEE 754, do nmero 0.75 em preciso simples e dupla. Resposta:

aula18.doc

15 de 16

Preciso simples
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 1 0 1 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Preciso dupla
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 1 0 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

aula18.doc

16 de 16

5.7 Operaes Aritmticas com nmeros de Ponto Flutuante Para somar dois nmeros na base 10 em notao cientfica temos que: 1. 2. 3. 4. alinhar os pontos decimais somar os nmeros normalizar o resultado arredondar o resultado para o nmero mximo de casas permitido

Exemplo: Some o nmero 9.999 x 101 com o nmero 1.61 x 10-1. Apresente o resultado com quatro dgitos significativos. 1. Alinhamos o ponto decimal do nmero de menor expoente: 1.61 x 10-1 => 0.016 x 101 2. Somamos 0.016 x 101 + 9.999 x 101 = 10.015 x 101 3. Normalizamos 10.015 x 101 => 1.0015 x 102 4. Arredondamos 1.002 x 102

aula19.doc

1 de 6

Um hardware para somar nmeros de ponto flutuante tem que fazer as mesmas operaes com nmeros binrios. O algoritmo para soma de nmeros em ponto flutuante abaixo pode ser implementado em hardware.

Vamos ver um exemplo do uso do algoritmo acima. Exemplo: Some os nmeros 0.5 e 0.4375 em binrio e apresente o resultado com 4 bits de preciso; trunque o resultado na fase de arredondamento.

aula19.doc

2 de 6

Primeiro, vamos converter os nmeros para notao binria: 0.5 = 1/2 = 0.1 (binrio) = 0.1 x 20 = 1.000 x 2-1 -0.4375 = -7/16 = -7/24 = -0.0111 (binrio) = -1.110 x 2-2 Passo 1: Igualar os expoentes (modificar o nmero menor) -1.110 x 2-2 => -0.111 x 2-1 Passo 2: Somar as partes significantes 1.000 x 2-1 + (-0.111 x 2-1) = 0.001 x 2-1 Passo 3: Normalizar o resultado 0.001 x 2-1 => 1.0 x 2-4 Passo 4: Arredondamento O nmero final (acima) j est OK.

aula19.doc

3 de 6

O hardware abaixo pode ser utilizado para soma de nmeros de ponto flutuante conforme o algoritmo apresentado.

A subtrao, multiplicao e a diviso em ponto flutuante seguem um raciocnio equivalente ao da soma. 5.8 Aritmtica Precisa Diferente da aritmtica inteira, que nos computadores representa exatamente o seu equivalente matemtico, a aritmtica de ponto flutuante apenas uma aproximao de sua equivalente matemtica. Isso acontece porque, na matemtica, existem infinitos Nmeros Reais entre 0 e 1, por exemplo; enquanto que na aritmtica de ponto flutuante existe um certo nmero de nmeros do ponto flutuante apenas.

aula19.doc

4 de 6

A figura abaixo apresenta as instrues de ponto flutuante da MIPS ISA.

aula19.doc

5 de 6

Esta tabela mostra o quanto cada uma das instrues estudadas at agora usada em dois programas reais: gcc um compilador, e spice um programa para analisar o comportamento de circuitos eltricos.

aula19.doc

6 de 6

6 O Processador
6.1 Introduo Um processador uma mquina de estados que executa a seguinte seqncia de estados continuamente: 1. Leia da memria a instruo apontada pelo registrador Program Counter (PC) 2. Incremente o PC (PC = PC + 1; ou PC = PC + 4 se a instruo for de 4 bytes) 3. Decodifique a instruo 4. Execute a instruo 5. Volte ao passo 1 Um gerador de pulsos usado para indicar quando o processador deve passar de um estado para o outro. Convencionou-se chamar este gerador de pulsos de clock (relgio). A freqncia mxima de operao do processador, ou seja, o quo rpido ele pode passar por estes passos, em GHz, normalmente indicada como fator de desempenho dos computadores. Um GHz (giga Hertz, ou bilhes de Hertz) equivale a um bilho de pulsos por segundo. Uma mquina de estados composta por dois tipos de circuitos interligados de forma apropriada: circuitos combinacionais e circuitos capazes de guardar estados. Circuitos combinacionais possuem entradas e sadas, e suas sadas dependem nica e exclusivamente de suas entradas. Portas lgicas (E, OU, etc) so exemplos de circuitos combinacionais. Na verdade, todos os circuitos combinacionais so ou uma porta lgica, ou uma combinao de portas lgicas. Um circuito capaz de guardar estados retm o valor de um certo nmero de bits at que um novo valor seja escrito nele. Como um exemplo de circuito capaz de guardar estados, podemos citar o registrador PC. Na verdade, todos os registradores e toda a memria de um computador so circuitos capazes de guardar estados. A memria pode ser vista como uma caixa preta, contendo um registrador especfico para cada endereo, sendo que cada um deles pode ser lido ou escrito independentemente. O banco de registradores de um computador , na verdade, uma pequena memria de acesso rpido.
aula20.doc 1 de 11

Existem dois tipos bsicos de registrador: acionado por nvel ou acionado por borda. Os registradores acionados por nvel copiam a entrada para sada enquanto o sinal de clock estiver alto (ou quando ele estiver baixo). Registradores acionados por borda copiam o valor da entrada para a sada quando ocorrer uma transio de clock de alto para baixo (ou de baixo para alto). A figura abaixo mostra uma mquina de estados genrica implementada com registradores acionados por borda:
clock Registradores Lgica Combinacional

clock

Na figura, na primeira subida do clock o estado dos registradores modificado para o valor presente em suas entradas. O novo estado apresentado nas sadas dos registradores logo aps a subida do clock. Estas sadas so aplicadas s entradas da lgica combinacional, que opera sobre elas e produz uma nova entrada para os registradores. Quando da prxima subida do clock, as novas sadas da lgica combinacional sero as novas entradas dos registradores. Assim, os estados guardados nos registradores evoluem de acordo o estado inicial e conforme o especificado pela lgica combinacional. Um computador , na verdade, uma mquina de estados bastante complexa, projetada para, a partir de um estado inicial, mudar seu estado interno (memria, registradores, etc) de acordo com o especificado por uma seqncia instrues, que so, na verdade, parte do estado inicial!

aula20.doc

2 de 11

6.2 Datapath (Caminho dos Dados) Os circuitos que compem um processador podem ser divididos em duas partes: o datapath e o controle. Os circuitos que formam o datapath so responsveis pela manipulao dos dados; a ALU faz parte do datapath, por exemplo. Os circuitos de controle so responsveis, como o nome diz, por controlar o datapath. Vamos fazer uma anlise de um datapath tpico, o datapath de um processador MIPS. A figura abaixo mostra alguns componentes deste datapath.

A memria e o PC so capazes de guardar estados, enquanto que o somador combinacional. A memria usada para guardar as instrues e os dados dos programas, PC guarda o endereo da instruo corrente e o somador pode ser usado para incrementar o PC de modo a faz-lo apontar para a prxima instruo.

aula20.doc

3 de 11

Estes circuitos podem ser agrupados para compor a parte do datapath responsvel por trazer instrues da memria:

Neste datapath, a cada subida do clock o PC recebe (PC)+4. A instruo, cujo endereo igual ao contedo de PC, disponibilizada na sada da memria de instrues (Instruction memory) logo aps a atualizao do contedo do PC. A memria de instrues composta por registradores (milhes deles) acionados por nvel; isto , basta apresentar o endereo que a memria devolve a instruo correspondente. As instrues trazidas da memria so utilizadas por outras partes do datapath, como veremos a seguir.

aula20.doc

4 de 11

Os componentes abaixo podem ser usados para compor a parte do datapath responsvel por implementar a maioria das instrues lgicas e aritmticas:

aula20.doc

5 de 11

Os componentes mostrados na figura anterior podem ser agrupados como abaixo:

Na figura acima, uma parte dos bits da instruo usada para determinar quais registradores sero lidos e qual ser escrito durante a execuo da instruo. Por exemplo, se a instruo a add $8, $17, $18
nome campo No. bits decimal op 1 6 0 rs 2 5 17 rt 3 5 18 rd 4 5 8 shamt 5 5 0 funct 6 6 32

os bits que especificam os registradores de leitura $17 e $18, campos 2 e 3 acima, so apresentados s entradas Read register 1 (Registrador de leitura 1) e Read register 2 (Registrador de leitura 2) do banco de registradores Registers, respectivamente, enquanto que os bits que especificam o registrador de escrita $8 (campo 4) so apresentados entrada Write register (Registrador de escrita). Logo aps a apresentao dos bits que especificam os registradores que sero lidos, o banco de registradores disponibiliza o contedo dos respectivos registradores nas sadas Read data 1 (Dado de leitura 1) e Read data 2 (Dado de leitura 2). A ALU recebe estes valores e opera sobre eles, conforme o que determina a instruo, e disponibiliza o resultado da operao na sua sada. Esta, levada entrada Write data (Dado de escrita). No final do ciclo de clock, o valor computado pela ALU escrito no registrador especificado em Write register.
aula20.doc 6 de 11

Para implementar as instrues de leitura e escrita na memria, precisamos dos componentes abaixo:

A memria de dados guarda os dados a serem manipulados pelo processador. A unidade de extenso de sinal usada para transformar a constante de 16 bits, que um dado imediato das instrues de leitura e escrita na memria (fazem parte da instruo), em um valor de 32 bits. A operao de extenso de sinal consiste em copiar o bit de sinal da constante de 16 bits, o bit 15, para os bits 16-31 da sada da unidade de extenso de sinal.

aula20.doc

7 de 11

Os componentes acima podem ser agrupados para implementar a parte do datapath responsvel pelas instrues de leitura e escrita na memria como abaixo:

Como no caso das instrues lgicas e aritmticas, parte dos bits da instruo usada para determinar quais registradores sero lidos e qual ser escrito durante a execuo da instruo (se a instruo for de leitura na memria). A constante de 16 bits, que sempre aparece nas instrues de leitura e escrita na memria, tem que ser estendida de sinal para ser somada ao registrador que usado para compor o endereo. Por exemplo, se a instruo a lw $8, 1200($19)
nome campo No. bits decimal op 1 6 35 rs 2 5 19 rt 3 5 8 address 4 16 1200

os bits que especificam o registrador de leitura $19, campos 2 acima, so apresentados entrada Read register 1 do banco de registradores Registers, enquanto que os bits que especificam o registrador de escrita $8 (campo 3) so apresentados entrada Write register. Logo aps a apresentao dos bits que especificam o registrador $19, o banco de registradores disponibiliza o seu contedo na sada Read data 1. Ao mesmo tempo, a constante 1200 apresentada unidade de extenso de sinal, que disponibiliza o valor 1200 extendido de sinal na entrada de baixo da ALU.

aula20.doc

8 de 11

A ALU recebe o contedo de $19 e a constante 1200 extendida de sinal e disponibiliza a soma destes dois valores na sua sada. Esta, levada s entradas Read address (Endereo de leitura) e Write address (Endereo de escrita) da Data memory (Memria de dados). No caso da instruo lw $8, 1200($19), no final do ciclo de clock o contedo da posio de memria apontado pelo endereo 1200+($19) escrito no registrador especificado em Write register. Se a instruo em questo fosse o sw $8, 1200($19) ao invs do lw, o contedo do registrador $8 seria escrito no endereo 1200+($19) atravs da entrada Write data (Dado de escrita) da memria.

aula20.doc

9 de 11

Para implementar as instrues de desvio beq e bne podemos usar o datapath abaixo:

No caso da instruo bne $8, $21, 100

nome campo No. bits decimal op 1 6 5 rs 2 5 8 rt 3 5 21 address 4 16 100

os bits que especificam os registradores de leitura $8 e $21, campos 2 e 3 acima, so apresentados s entradas Read register 1 e Read register 2 do banco de registradores Registers, respectivamente. Logo aps a apresentao dos bits que especificam os registradores $8 e $21, o banco de registradores disponibiliza seus contedos nas sadas Read data 1 e 2. Ao mesmo tempo, a constante 100 apresentada unidade de extenso de sinal, que disponibiliza o valor 100 extendido de sinal e deslocado para a esquerda de dois bits na entrada do Adder (somador).

aula20.doc

10 de 11

A constante 100 extendida de sinal deslocada de dois, que equivalente a multiplica-la por quatro. Isto feito porque as instrues sempre ocupam endereos mltiplos de quatro na memria (porque elas so de 32 bits, ou quatro bytes). A constante somada com (PC)+4 por Adder e, na sada deste disponibilizado o Branch target (Alvo do desvio), que o endereo da prxima instruo que deve ser executada no caso do desvio ser tomado. O processador decidir se o desvio deve ser tomado ou no de acordo com o resultado computado pela ALU a partir de Read data 1 e 2. No caso das instrues beq e bne, a ALU subtrai Read data 2 de Read data 1 (computa $8 - $21, no caso da instruo bne $8, $21, 100). Dependendo do resultado ser igual a zero ou no e da instruo ser beq ou bne, a branch control logic (lgica de controle de desvio) copia o valor branch target para o PC ou no.

aula20.doc

11 de 11

6.3 Uma Implementao Exemplo de um Processador Agora estamos prontos para implementar um processador inteiro a partir dos blocos bsicos que estudamos. A figura abaixo mostra um datapath capaz de executar instrues de leitura e escrita na memria e instrues lgicas e aritmticas.

Neste datapath, o multiplexador mais esquerda seleciona ou um registrador ou uma constante de 16 bits retirada da prpria instruo. Ele auxilia a implementao de instrues com e sem operando imediato. Por exemplo: add $2, $3, $4 sub $2, $3, $4 # Estas instrues no tm operando imediato. O # multiplexador recebe um comando para colocar # o valor do registrador na entrada inferior da ALU

addi $2, $3, 1000 # Para estas duas instrues, o multiplexador lw $2, 1000($3) # recebe comando para colocar o valor do # operando imediato 1000 na entrada inferior da # ALU

aula21.doc

1 de 20

Os bits que compem as primeiras duas instrues so como abaixo: Formato da instruo add $2, $3, $4
nome No. bits decimal op 6 0 rs 5 3 rt 5 4 rd 5 2 shamt 5 0 funct 6 32

Formato da instruo sub $2, $3, $4

nome No. bits decimal op 6 0 rs 5 3 rt 5 4 rd 5 2 shamt 5 0 funct 6 34

Note que o campo op igual para o add e o sub: o campo funct que diferencia as duas instrues. Os formatos das instrues com operando imediato mostradas acima so: Formato da instruo addi $2, $3, 1000
nome No. bits decimal op 6 4 rs 5 3 rt 5 2 imm 16 1000

Formato da instruo lw $2, 1000($3)

nome No. bits decimal op 6 35 rs 5 3 rt 5 2 address 16 1000

Note que os bits que determinam qual o registrador destino da operao (resultado da soma ou o valor lido da memria) no ficam no mesmo lugar que nas instrues anteriores. Note tambm que o campo de 16 bits mais a direita no tem o mesmo nome para as instrues addi e lw. O nome diferente para indicar funes diferentes: na instruo addi este campo simplesmente um valor imediato enquanto que na instruo lw ele um valor imediato que ajuda a compor um endereo.

aula21.doc

2 de 20

Podemos adicionar ao datapath anterior os circuitos responsveis por trazer uma instruo da memria como demonstrado abaixo.

Com mais alguns circuitos podemos fazer um datapath capaz de executar instrues de desvio:

aula21.doc

3 de 20

As diversas instrues da MIPS ISA possuem formatos diferentes, cada um para uma classe especfica de instrues. Para controlar o datapath adequadamente os bits dos campos de cada formato tm que ser separados e levados a diferentes partes do datapath para exercer o controle adequado execuo de cada instruo. A figura abaixo mostra trs classes de instruo da MIPS ISA.

aula21.doc

4 de 20

No datapath abaixo, os bits que compem a instruo foram separados e levados a diversas partes do datapath para exercer seu controle. Contudo, alguns circuitos precisam de controle adicional, como o banco de registradores, o multiplexador que determina Write Register, o multiplexador na entrada inferior da ALU, etc, indicados na figura.

aula21.doc

5 de 20

Para implementar o controle adicional inclumos uma unidade de controle como indicado abaixo:

aula21.doc

6 de 20

A figura anterior mostra um processador completo, com um datapath e o circuito de controle deste datapath. Este processador pode executar a instruo add $2, $3, $4 seguindo os seguintes passos: 1. A instruo add $2, $3, $4 lida da memria e o PC incrementado (fetch). 2. Os registradores $3 e $4 so lidos do banco de registradores. O multiplexador mais esquerda posicionado de acordo com o formato da instruo lida no passo 1. 3. O campo funct e o campo op da instruo so usados para especificar a operao soma. O multiplexador central posicionado de modo a colocar na sada o valor do registrador $4. A ALU realiza a soma dos valores lidos do banco de registradores. 4. O multiplexador na extrema direita posicionado de modo a transferir a sada da ALU (e no um dado lido da memria). O valor na sada do multiplexador (resultado da soma computada pela ALU) escrito no registrador $2. A implementao do controle do processador mostrada combinatorial; isto , no existem, na verdade, os quatro passos indicados acima. O datapath opera em um nico ciclo de relgio e os sinais dentro do datapath podem variar de forma imprevisvel durante o ciclo. Os sinais estabilizam aproximadamente na ordem indicada acima porque nesta ordem que a informao flui no datapath. Para este processador funcionar corretamente, a durao do ciclo de clock tem que ser ajustada para que no final do ciclo, na subida do clock seguinte, o dado a ser escrito em $2 e novo valor de PC estejam prontos para serem escritos no banco de registradores e no registrador PC, respectivamente. Os registradores do banco de registradores e o PC tm que ser registradores acionados por borda.

aula21.doc

7 de 20

Vamos ver agora como a instruo lw $2, 1000($3) pode ser executada pelo mesmo processador. Os passos abaixo mostram o fluxo de informaes no datapath durante a execuo desta instruo: 1. A instruo lw $2, 1000($3) lida da memria e o PC incrementado (fetch). 2. O registrador $3 lido do banco de registradores. O multiplexador mais esquerda posicionado de acordo com o formato da instruo lida no passo 1. 3. O campo op da instruo usado para especificar a operao soma. O multiplexador central posicionado de modo a colocar na sada o valor imediato 1000. A ALU realiza a soma do valor lido do banco de registradores com a constante imediata 1000. 4. A memria recebe um comando de leitura e a sada da ALU usada como endereo para o acesso de leitura. 5. O multiplexador na extrema direita da figura do processador posicionado de modo a transferir o dado lido da memria. O valor na sada do multiplexador escrito no registrador $2. A instruo beq $3, $4, 1000 pode ser executada com os seguintes passos: 1. A instruo beq $3, $4, 1000 lida da memria e o PC incrementado (fetch). 2. Os registradores $3 e $4 so lidos do banco de registradores. 3. O campo op da instruo usado para especificar a operao subtrao. O multiplexador central posicionado de modo a colocar na sada o valor do registrador $4. A ALU realiza a subtrao dos valores lidos do banco de registradores e sua sada zero posicionada de acordo com o resultado. O valor de PC+4 somado com o valor 1000 (com sinal estendido) multiplicado por 4 (deslocado de d ois bits para a esquerda). 4. A sada zero da ALU usada para decidir qual valor ser escrito no registrador PC no fim do ciclo: PC+4 ou PC+4 + (1000 * 4).

aula21.doc

8 de 20

6.4 Um Exemplo com Mltiplos Ciclos de Clock por Instruo Na implementao do processador MIPS mostrada, todas as instrues executam em um ciclo e, assim, o CPI de todas elas igual a 1. Isso, no entanto, faz com que o tempo de ciclo tenha que ser igual ao da instruo que demora mais para executar. Exerccio: Se assumirmos que em uma implementao de um processador MIPS: a) As memrias tenham um tempo de acesso (da aplicao do endereo de acesso at a disponibilizao dos dados na sada) de 10 ns. b) A ALU e os somadores demorem 10 ns para fazer suas operaes. c) O banco de registradores tenha um tempo de acesso de 5 ns. d) Os multiplexadores, a unidade de controle, a unidade de extenso de sinal, acessos ao PC e os fios conectando os componentes no atrasam a propagao dos sinais. Qual o valor ideal do perodo de clock para as instrues add, lw e beq? Qual o perodo de clock que este processador tem que ter? Resposta: Para executar cada uma das instrues temos que: fetch leitura dos ALU add registradores fetch leitura dos ALU lw registradores fetch leitura dos ALU beq registradores

escrita no registrador acesso escrita no memria registrador

Assim, o perodo de clock ideal para a instruo add igual a 10+5+10+5 = 30ns, para a instruo lw igual a 10+5+10+10+5 = 40ns, e para a instruo beq igual a 10+5+10 = 25ns. Como o perodo de clock do processador tem que ser igual ao perodo de clock necessrio execuo da instruo mais demorada, o perodo de clock deste processador tem que ser igual a 40ns.

aula21.doc

9 de 20

Atravs do exemplo dado por este exerccio podemos ver que o ideal seria termos um tempo de ciclo diferente para cada instruo ou uma soluo equivalente. Uma soluo elegante equivalente usar mais de um ciclo para executar cada instruo. Com esta soluo possvel reutilizar unidades funcionais durante a execuo de uma instruo, o que permite implementar o processador com menos componentes. Em um processador implementado desta maneira, cada passo que usamos para entender a execuo de cada instruo poderia, por exemplo, ocorrer em um ciclo independente. Dependendo da instruo sendo executada, um nmero maior ou menor de ciclos seria necessrio. A tabela abaixo um sumrio dos passos necessrios para executar as instrues que estudamos.

Note que, considerando a tabela acima, a princpio trs registradores novos seriam agora necessrios: A, B e Target. Os registradores A e B guardariam temporariamente os valores lidos do banco de registradores, enquanto que o registrador Target guardaria temporariamente o endereo alvo de uma possvel instruo de desvio. Para cada ciclo de clock um dos passos executado na ordem indicada na tabela. Dependendo da instruo, alguns dos passos no so executados. Observe que nenhum passo necessita de mais que uma operao de ALU ou soma de endereo. Assim, apenas uma ALU bastaria para implementar todo o processador se usssemos mltiplos ciclos para executar cada instruo: teramos apenas que direcionar os dados corretos para a ALU a cada ciclo. A figura a seguir mostra como podemos implementar um processador para o

aula21.doc

10 de 20

conjunto de instrues MIPS (MIPS ISA) desta nova forma (mltiplos ciclos por instruo).

aula21.doc

11 de 20

aula21.doc

12 de 20

A unidade de controle deste processador no combinacional, como a da primeira implementao esta unidade de controle uma mquina de estados. Um diagrama de blocos desta mquina de estados seria como abaixo:

Uma descrio completa desta mquina de estados deve incluir todos os sinais para controlar o processador, gerados a cada estado, e especificar como ocorrem as transies entre os estados. A figura a seguir mostra a mquina de estados completa.

aula21.doc

13 de 20

aula21.doc

14 de 20

Os crculos representam os estados e as setas indicam as transies de um estado para outro. Uma transio de estado ocorre a cada ciclo de clock. Quando mais de uma seta sai de um estado, como no estado 1, o estado destino aquele para o qual as condies indicadas na seta de transio correspondente so verdadeiras. Os sinais de controle gerados em cada estado esto dentro de cada crculo. O nmero de ciclos de clock necessrios para executar uma instruo igual ao nmero de estados que tem que ser percorridos para execut-la. Esta mquina de estados pode ser implementada com um registrador de quatro bits, e lgica combinacional para gerar o estado seguinte e as sadas correspondentes a cada estado, como indicado na figura abaixo:

aula21.doc

15 de 20

6.5 Microprogramao Implementar um processador como o discutido na seo anterior fcil se a ISA possui apenas umas poucas instrues. Mas mesmo a MIPS ISA, que uma ISA bem simples, possui cerca de 100 instrues. A mquina de estados necessria para implementar um processador para a MIPS ISA completa teria muitos estados e seria complicada de implementar. No entanto, a implementao pode ser bastante simplificada atravs do uso da microprogramao. Uma unidade de controle implementada segundo a tcnica da microprogramao como um pequeno computador dentro do computador. O programa que esta micromquina executa chamado de microprograma e cada sub-rotina do microprograma executa uma parte de uma instruo. Em geral, as microinstrues que implementam o fetch so comuns a todas as instrues e um segmento de microprograma adicional usado para implementar, ou emular, cada instruo.

aula21.doc

16 de 20

A figura abaixo mostra uma unidade de controle microprogramada.

aula21.doc

17 de 20

A figura abaixo mostra um microprograma, com 10 microinstrues, capaz de emular algumas instrues que estudamos usando a micromquina acima e o datapath da Figura 5.39.
M0 M1 M2 M3 M4 M5 M6 M7 M8 M9

Na figura acima, ALU control a sada da lgica de mesmo nome da Figura 5.39; SRC1 e SRC2 so os sinais de controle ALUSelA e ALUSelB, respectivamente; ALU destination uma composio dos sinais TargetWrite e RegWrite; Memory uma composio dos sinais IorD, MemRead e MemWrite; Memory register uma composio dos sinais IRWrite e MemtoReg; PCWrite control uma composio de PCSource, PCWrite e PCWriteCond; e Sequencing so as linhas de controle Sequencing control da Figura 5.52. Assim como uma instruo de mquina pode ser representada simbolicamente em linguagem assembly, uma microinstruo pode ser representada simbolicamente, como fizemos no microprograma acima.

aula21.doc

18 de 20

Um micro-assembler geralmente usado para converter o microprograma simblico em um microprograma em linguagem de micro mquina (bits). Cada microinstruo simblica da figura acima seria, ento, transformada em uma microinstruo binria por um micro-assembler especfico para a microarquitetura definida pelo controlador de microcdigo da Figura 5.52 e pelo datapath da Figura 5.39. Exerccio: Calcule o nmero de bits necessrio para codificar uma microinstruo da micromquina em estudo. No microprograma da Figura 5.51, uma instruo lw executada atravs da seqncia de microinstrues M0, M1, M2, M3, M4. Exerccio: Indique quais seqncias de microinstrues executam um add e um sw.

6.6 Excees e Interrupes Uma exceo um evento inesperado que pode ocorrer dentro do processador; um overflow, por exemplo. Interrupes so eventos inesperados que ocorrem fora do processador; um click no mouse usualmente gera uma interrupo no processador. Excees e interrupes desviam o fluxo de execuo dos programas para rotinas especficas de tratamento de modo similar ao que fazem as instrues de chamada de procedimento (jal). A figura abaixo mostra como dois estados para tratar excees poderiam ser includos na mquina de estados que implementa o nosso processador. Estados adicionais poderiam ser includos para tratar de interrupes.

aula21.doc

19 de 20

aula21.doc

20 de 20