Aula 03 Aritmética.

Apresentação em tema: "Aula 03 Aritmética."— Transcrição da apresentação:

1 Aula 03 Aritmética

2 Computador de von Neumann

3 Unidade lógica e aritmética
Diz respeito a: Desempenho (segundos, ciclos, instruções) Abstrações: Arquitetura do Conjunto de Instruções Linguagem Assembly e Linguagem de Máquina Para que serve: Implementar a Arquitetura 32 operation result a b ALU

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

5 Fluxo de Controle Instrução slt – set on less than
if $s1 < $s2 then $t0 = 1 slt $t0, $s1, $s2 else $t0 = 0

6 Números Bits são apenas bits (sem nenhum significado inerente) — convenções definem a relação entre bits e números Números Binários (base 2) decimal: n-1 Naturalmente resultam em algumas sofisticações: números são finitos (overflow) números fracionários e reais números negativos p.ex., no MIPS não existe instrução de subtração imediata - addi pode adicionar um número negativo) Como representamos números negativos? i.e., que padrões de bits representam os números?

7 Possíveis Representações
Sinal e Magnitude Complemento de Complemento de = = = = = = = = = = = = = = = = = = = = = = = = -1 Comparações: balanceamento, número de zeros, facilidade de operações Qual é o melhor? Por que?

8 MIPS Números sinalizados de 32 bits: two = 0ten two = + 1ten two = + 2ten two = + 2,147,483,646ten two = + 2,147,483,647ten two = – 2,147,483,648ten two = – 2,147,483,647ten two = – 2,147,483,646ten two = – 3ten two = – 2ten two = – 1ten maxint minint

9 Operações em Complemento de 2
Negar um número em complemento de 2: inverter todos os bits e somar 1 lembrança: “negar” e “inverter” são diferentes! Convertendo um número de n bits em números com mais de n bits: Um dado imediato de 16 bits do MIPS é convertido para 32 bits em aritmética Copiar o bit mais significativo (o bit de sinal) para outros bits > > "sign extension"

10 Adição & Subtração Como no curso primário (carry/borrow)      0101 Operações em complemento de 2 subtração usando soma de números negativos  1010 Overflow (resultado muito grande para um computador de tamanho de palavra finito): P.ex., somando dois números de n-bits não resulta em n-bits  0001 note que o bit de overflow é enganoso, ele não significa um carry de transbordo

11 Detectando Overflow Não ocorre overflow
quando se soma um número positivo e um negativo quando os sinais são os mesmos para a subtração Overflow ocorre quando o valor afeta o sinal: quando somando dois positivos resulta num negativo ou, somando dois negativos resulta num positivo ou, subtraindo um negativo de um positivo e dá um negativo ou, subtraindo um positivo de um negativo e dá um positivo Considerar as operações A + B, e A – B Pode ocorrer overflow se B é 0 ? Pode ocorrer overflow se A é 0 ?

12 Efeitos do Overflow Uma exceção (interrupt) ocorre
A instrução salta para endereço predefinido para a rotina de exceção O endereço da instrução interrompida é salvo para possível retorno Nem sempre se requer a detecção do overflow — novas instruções MIPS: addu, addiu, subu nota: addiu still sign-extends! nota: sltu, sltiu for unsigned comparisons

13 Revisão: Álgebra Booleana & Portas
Problema: Considerar uma função lógica com 3 entradas: A, B, e C. A saída D é “true” se pelo menos uma entrada é “true” A saída E é “true” se exatamente duas entradas são “true” A saída F é “true” somente se todas as três entradas são “true” Mostrar a tabela verdade para essas três funções. Mostrar as equações Booleanas para as três funções. Mostrar uma implementação consistindo de portas inversoras, AND, e OR.

14 Uma ALU (arithmetic logic unit)
Seja uma ALU para suportar as instruções andi e ori Projetar uma ALU de 1 bit, e replicá-la 32 vezes Possível implementação (soma-de-produtos): operation result op a b res a b

15 Revisão: Multiplexador
Seleciona uma das entradas para a saída, baseado numa entrada de controle Seja construir a nossa ALU usando um MUX: S C A B nota: mux de 2-entradas embora tenha 3 entradas! 1

16 Implementação de ALU de um bit
Não é fácil decidir a “melhor” forma para construir algo Não queremos muitas entradas para uma única porta (fan-in) Não queremos distribuir para muitas portas (fan-out) Para o nosso propósito, facilidade de compreensão é importante Seja a ALU de 1-bit para soma: Como construir uma ALU de 1-bit para soma, AND e OR? Como construir uma ALU de 32-bits? cout = a b + a cin + b cin sum = a xor b xor cin

17 Construindo uma ALU de 32 bits

18 E sobre subtração (a – b) ?
Técnica do complemento de 2: apenas negar b e somar. Como negar? Solução:

19 Outras operações da ALU do MIPS
Deve suportar a instrução set-on-less-than (slt) lembrar: slt é uma instrução aritmética produz um 1 se rs < rt, e 0 caso contrário usar subtração: (a - b) < 0 implica a < b Deve suportar o teste para igualdade (beq $t5, $t6, $t7) usar subtração: (a - b) = 0 implica a = b

20 Suportando slt Desenhando a idéia?

21

22 Teste de igualdade Nota: zero é 1 quando o resultado é zero!

23 Linhas de controle Operation 000 = and 001 = or 010 = add 110 = subtract 111 = slt Binvert

24 Conclusão Podemos construir uma ALU para suportar o conjunto de instruções MIPS -- usando multiplexador para selecionar a saída desejada realizando uma subtração usando o complemento de 2 replicando uma ALU de 1-bit para produzir uma ALU de 32-bits Pontos importantes sobre o hardware Todas as portas estão sempre trabalhando A velocidade de uma porta é afetada pelo número de entradas da porta A velocidade de um circuito é afetado pelo número de portas em série (no caminho crítico ou nivel mais profundo da lógica) Mudanças inteligentes na organização pode melhorar o desempenho (similar a usar algoritmos melhores em software)

25 Problema: somador ripple carry (vai-um propagado) é lento
Uma ALU de 32-bits é tão rápida quanto uma ALU de 1-bit? Existem mais de uma forma de somar? dois extremos: ripple carry e soma-de-produtos Voce pode ver a propagação do vai-um? Como resolvê-lo? c1 = a0c0 + b0c0 + a0b0 = (a0 + b0)c0 + a0b0 c2 = a1c1 + b1c1 + a1b1 c3 = a2c2 + b2c2 + a2b2 c4 = a3c3 + b3c3 + a3b3

26 Somador de vai-um antecipado - (Carry-lookahead) - CLA
Uma técnica intermediária entre dois extremos Motivação: Se não sabemos o valor do carry-in, o que fazemos? Quando sempre geramos um carry? gi = ai bi Quando propagamos um carry? pi = ai + bi Resolvemos o ripple calculando o vai-um antecipadamente, usando as equações: c1 = g0 + p0c0 c2 = g1 + p1c1 c3 = g2 + p2c2 c4 = g3 + p3c3

27 Construção de somadores grandes
usar o princípio de CLA novamente!

28 Multiplicação Mais complicado que soma Mais tempo e mais área
Realizado via deslocamento e soma Mais tempo e mais área Vejamos 3 versões baseados no algoritmo (multiplicando) __x_ (multiplicador) Números negativos: converter e multiplicar

29 Multiplicação: Implementação

30 Segunda Versão

31 Versão Final

32 Multiplicação Paralela
a a a a a a0 = A x b b b b b b0 = B ___________________________________ a5b0 a4b0 a3b0 a2b0 a1b0 a0b0 = W1 a5b1 a4b1 a3b1 a2b1 a1b1 a0b = W2 a5b2 a4b2 a3b2 a2b2 a1b2 a0b = W3 a5b3 a4b3 a3b3 a2b3 a1b3 a0b = W4 a5b4 a4b4 a3b4 a2b4 a1b4 a0b = W5 a5b5 a4b5 a3b5 a2b5 a1b5 a0b = W6 _________________________________________________________________ P11 P10 P P8 P P6 P P P P P P0 = AxB=P

33 Somadores CPA – Carry Propagation Adder
Faz a adição de 2 números A e B para produzir o resultado A + B. CSA – Carry Save Adder Faz a adição de 3 números A, B e D, produzindo dois resultados: soma S e vai-um C. Matematicamente, tem-se A + B + D = S + C. A = B = D = __________________________ C = S = A + B + D = S + C =

34 Circuito de Multiplicação Paralela

35 Exemplo

36 Ponto Flutuante Necessitamos de uma forma para representar
Números com frações, p.ex., Números muito pequenos, p.ex., Números muito grandes, p.ex., ´ 109 Representação: Sinal, expoente, significando: (–1)sinal ´ significando ´ 2expoente Mais bits para o significando dá mais resolução Mais bits para o expoente aumenta o intervalo (range) Padrão ponto flutuante IEEE 754: Precisão simples: expoente de 8 bits, significando de 23 bits Precisão dupla: expoente de 11 bits, significando de 52 bit

37 Padrão de ponto flutuante IEEE 754
O primeiro bit (leading bit), “1” do significando é implícito Expoente é “polarizado” para fazer a separação facilmente bias de 127 para precisão simples e 1023 para precisão dupla Resumo: (–1)sinal ´ (1+significando) ´ 2expoente – bias Exemplo: decimal: = -3/4 = -3/22 binário: = -1.1 x 2-1 Ponto flutuante: expoente = 126 = Precisão simples IEEE:

38 Complexidade do Ponto Flutuante
Além do overflow tem “underflow” Precisão pode ser um grande problema IEEE 754 mantem dois extra bits, guard e round Quatro modos de arredondamento positivo dividido por zero resulta em “infinito” zero dividido por zero resulta em “not a number” Outras complexidades A Implementação do padrão pode ser complicado Não usar o padrão pode ser mesmo pior

39 Representação ponto flutuante
Formato s é o bit de sinal s = 0 positivo s=1 negativo exp é usado para obter E frac é usado para obter M Valor representado (-1)s M 2E Significando M é um valor fracionário no intervalo [1.0,2.0), para números normalizados e [0 e 1) para números denormalizados Exponente E fornece o peso em potência de dois s exp frac

40 Valores numéricos Normalizados
Condição  exp  000…0 e exp  111…1 Expoente codificado como valor polarizado (biased)  E = exp – bias exp : valor não sinalizado bias : valor da polarização Precisão Simples: 127 (exp: 1…254, E: -126…127) Precisão dupla: 1023 (exp: 1…2046, E: -1022…1023) Em geral: bias = 2e-1 - 1, onde e e´ o numero de bits do expoente Significando codificado com bit 1 mais significativo (leading bit) implicito  M = 1.xxx…x2  xxx…x: bits da frac Minimo quando 000…0 (M = 1.0) Maximo quando 111…1 (M = 2.0 – ) O bit extra (leading bit 1) e´ obtido “implicitamente”

41 Valores denormalizados
Condição  exp = 000…0 Valor Valor do Expoente E = –Bias + 1 Valor do Significando M = 0.xxx…x2 xxx…x: bits de frac Casos exp = 000…0, frac = 000…0 Representa valor 0 Nota-se que existem valores distintos +0 e –0 exp = 000…0, frac  000…0 Numeros muito próximos de 0.0 Perde precisão à medida que vai diminuindo “ underflow gradual”

42 Valores especiais Condição exp = 111…1 Casos exp = 111…1, frac = 000…0
Representa valor(infinito) Operação que transborda (overflow) Ambos positivo e negativo P. ex., 1.0/0.0 = 1.0/0.0 = +, 1.0/0.0 =  exp = 111…1, frac  000…0 Not-a-Number (NaN) Nenhum valor numérico pode ser determinado P. ex., sqrt(–1), 

43 Resumo da codificação de números reais em ponto flutuante
 + -Normalizado -Denorm +Denorm +Normalizado NaN NaN 0 +0

44 Representação ilustrativa de 8 bits
Representação ponto flutuante de 8 bits O bit de sinal e´ o bit mais significativo. Os seguintes quatro bits são expoente, com bias de 7. Os últimos três bits bits são frac Semelhante a forma geral no formato IEEE normalizado, denormalizado Representação de 0, NaN, infinito 7 6 3 2 s exp frac

45 Valores Relativos ao Expoente
exp E 2E /64 (denorms) /64 /32 /16 /8 /4 /2 n/a (inf, NaN)

46 Intervalo s exp frac E Valor 0 0000 000 -6 0
/8*1/64 = 1/512 /8*1/64 = 2/512 … /8*1/64 = 6/512 /8*1/64 = 7/512 /8*1/64 = 8/512 /8*1/64 = 9/512 /8*1/2 = 14/16 /8*1/2 = 15/16 /8*1 = 1 /8*1 = 9/8 /8*1 = 10/8 /8*128 = 224 /8*128 = 240 n/a inf Mais perto de zero números denormalizados maior denorm menor norm perto de 1 abaixo números Normalizados perto de 1 acima maior norm

47 Distribuição de valores
Formato de 6-bits tipo IEEE e = 3 bits de expoente f = 2 bits de fracao bias e´ 3 Notar como a distribuição fica mais densa perto de zero.

48 Distribuição de Valores perto de zero
Formato de 6-bits, tipo IEEE e = 3 bits de expoente f = 2 bits de fração Bias igual a 3

49 Numeros interessantes
Descrição exp frac valor numérico Zero 00…00 00…00 0.0 menor Pos. Denorm. 00…00 00…01 2– {23,52} X 2– {126,1022} Single  1.4 X 10–45 Double  4.9 X 10–324 maior Denorm. 00…00 11…11 (1.0 – ) X 2– {126,1022} Single  1.18 X 10–38 Double  2.2 X 10–308 menor Pos. Norm. 00…01 00… X 2– {126,1022} Um 01…11 00…00 1.0 maior Normalized 11…10 11…11 (2.0 – ) X 2{127,1023} Single  3.4 X 1038 Double  1.8 X 10308

50 Operações em ponto flutuante
Conceitualmente Primeiro computar o resultado exato Fazê-lo enquadrar na precisão desejada transborda se o expoente for muito grande arredonda para caber no frac Modos de arredondamento –1.50 Zero –1 Round down (-) –2 Round up (+) –1 Nearest Even (default) –2 Nota: 1. Round down: resultado e´perto mas não maior que o resultado verdadeiro. 2. Round up: resultado e´perto mas não menor do que o resultado verdadeiro.

51 Multiplicação em FP Operandos Resultado exato Representação final
(–1)s1 M1 2E1 * (–1)s2 M2 2E2 Resultado exato (–1)s M 2E Sinal s: s1 xor s2 Significando M: M1 * M2 Expoente E: E1 + E2 Representação final se M ≥ 2, deslocar à direita M, incrementar E se E fora do intervalo, overflow Arredonda M para caber em frac

52 Adição FP Operandos (–1)s1 M1 2E1 (–1)s2 M2 2E2 Assumir E1 > E2
Resultado exato (–1)s M 2E Sinal s, significando M: Resultado de alinhamento e adição Expoente E: E1 Representação final Se M ≥ 2, deslocar à direita M, incrementa E Se M < 1, deslocar à esquerda M de k posições, decrementar E de k Overflow se E fora do intervalo arredonda M para caber em frac (–1)s1 M1 (–1)s2 M2 E1–E2 + (–1)s M

53 Ariane 5 Explodiu 37 segundos após decolagem Por que?
Foi computada a velocidade horizontal como número em ponto flutuante Convertido para inteiro de 16-bits Funcionou bem para Ariane 4 Ocorreu Overflow para Ariane 5 Foi usado o mesmo software