EA960 Aritmética e Representação Numérica

EA960 Aritmética e Representação Numérica Faculdade de Engenharia Elétrica e de Computação (FEEC) Universidade Estadual de Campinas (UNICAMP) Prof. Levy Boccato

Introdução Até o momento, nos preocupamos apenas com escolhas ligadas ao conjunto de instruções, partindo do pressuposto que as grandezas manipuladas são essencialmente números com ou sem sinal. Algumas perguntas importantes, porém, precisam ser analisadas: Como podemos representar frações e números reais? O que acontece se uma operação cria um número que excede o limite representável? Como o hardware efetivamente multiplica ou divide os números? 2

Adição Processo: vai-um (carry) Implementação: Circuito somador com propagação do bit de transporte; Ou, então, com cálculo antecipado de todos os bits de transporte. Estas opções diferem em relação ao atraso de propagação, ao número de portas lógicas, etc. 3

Adição Problema: o resultado da adição (e subtração) pode ultrapassar os limites definidos pelo tamanho da palavra. Esta condição é conhecida como estouro aritmético ou overflow. Em que condições o overflow pode ocorrer quando a instrução add $t0, $t1, $t2 é executada? Se $t0 e $t1 possuem sinais diferentes, jamais ocorre overflow. Por quê? 4

Adição A soma de dois números de N bits precisaria, em tese, de (N + 1) bits para sua representação completa. A falta deste (N+1)-ésimo bit significa que quando o overflow ocorre, o bit de sinal (do registrador) recebe um valor lógico que corresponde a um bit do resultado, em vez do bit de sinal do número produzido. Logo, para detectar overflow, basta olhar para o bit de sinal do resultado armazenado. Condições: Soma de dois positivos = número negativo. Soma de dois negativos = número positivo. 5

Adição Processador MIPS As instruções addu, addiu e subu ignoram a ocorrência de overflow. Por outro lado, as instruções add, addi e sub causam exceções relacionadas a overflow. Tratamento da exceção: O endereço da instrução que causou a exceção é salvo no registrador EPC (exception program counter). O processador desvia para um endereço pré-definido em que há uma rotina de tratamento específica para aquele evento. A instrução mfc0 (move from coprocessor reg) copia o valor de EPC em um registrador ($k0 ou $k1, para evitar a perda do conteúdo de outros registradores), de modo que o processador possa retornar à execução normal após a ação de correção. 6

Adição Processador MIPS Não possui uma instrução de desvio que permita o teste da ocorrência de overflow. Como fazer esta checagem em software? A. Números com sinal addu $t0, $t1, $t2 xor $t3, $t1, $t2 slt $t3, $t3, $zero bne $t3, $zero, sem_overflow xor $t3, $t0, $t1 slt $t3, $t3, $zero bne $t3, $zero, overflow Se $t1 e $t2 tiverem sinais distintos, o OUexclusivo entre eles será um número cujo bit mais significativo será igual a 1. Logo, em complemento de 2, o resultado da operação XOR será um número negativo. A mesma ideia é explorada para testar se o sinal do resultado confere com o esperado (i.e., igual ao dos operandos). 7

Adição Processador MIPS Não possui uma instrução de desvio que permita o teste da ocorrência de overflow. Como fazer esta checagem em software? B. Números sem sinal Bastaria testar se o resultado é menor que 2 32-1. addu $t0, $t1, $t2 nor $t3, $t1, $zero sltu $t3, $t3, $t2 bne $t3, $zero, overflow Uma forma engenhosa de fazer isto consiste em, primeiro, obter o complemento de 1 do primeiro operando ($t1). OBS: complemento de 1 = 2 32 1 $t1 Em seguida, testamos se o complemento de 1 deste operando é menor que o segundo operando. Ou seja, 2 32 1 $t1 < $t2 Isto é equivalente a testar: 2 32 1 < $t1 + $t2 8

Multiplicação Relembrando o procedimento: 1001 x 1000 = 1 x 1000 + 0 x 10 x 1000 + 0 x 100 x 1000 + 1 x 1000 x 1000 multiplicando multiplicador produto 1000 1001 1000 0000 0000 1000 1001000 O deslocamento alinha o resultado conforme a casa do dígito multiplicador (unidade, dezena, centena, etc.) O resultado pode ter, no máximo, um número de dígitos equivalente à soma das quantidades de dígitos dos operandos. 9

Multiplicação Relembrando o procedimento: 10

Multiplicação Primeira implementação: Decide quando os registradores contendo o multiplicador e o multiplicando são deslocados, e quando um valor é escrito no registrador Produto. 11

Multiplicação O algoritmo e o hardware anteriores podem ser facilmente refinados para consumir um ciclo de relógio por passo (iteração). Como? Operações em paralelo: os deslocamentos são feitos enquanto o multiplicando é somado ao produto caso o bit menos significativo do multiplicador seja igual a 1. O hardware também pode economizar unidades de armazenamento, eliminando porções dos registradores que não são utilizadas. 12

Multiplicação Segunda implementação: O multiplicador está inicialmente armazenado na meia palavra inferior do registrador de produto. A cada iteração, o tamanho (em bits) do produto cresce na mesma proporção em que os bits do multiplicador são retirados. 13

Multiplicação E se os números forem inteiros? 1ª abordagem: 1) Conversão dos números para os respectivos valores positivos; 2) Multiplicação convencional; 3) Ajuste do sinal do resultado conforme os sinais dos operandos observados no passo 1. 2ª abordagem: Podemos utilizar o mesmo algoritmo visto anteriormente, tomando apenas o cuidado de efetuar a extensão de sinal toda vez que um valor for deslocado. 14

Multiplicação Terceira implementação: Ideia: a possibilidade de o multiplicando ser somado é conhecida no início da operação por meio da observação dos N bits do multiplicador. Organização: árvore faz com que o tempo para o término da operação completa seja proporcional a log 2 (N). CUIDADO!!!! Trade-off entre desempenho e complexidade. 15

Multiplicação Processador MIPS: Dois registradores especiais de 32 bits para armazenar o produto: HI bits mais significativos; LO bits menos significativos; Instruções: mult rs, rt multu rs, rt mfhi rd mflo rd O produto, com 64 bits, é armazenado em HI LO. Move o conteúdo de HI / LO para um registrador. Útil para o teste de overflow. mul rd, rs, rt Os 32 bits menos significativos do produto são armazenados em rd. 16

Divisão Assim como ocorre com a multiplicação, existem várias estratégias para realizar a operação de divisão. Ideias iniciais: Dividendo 10011 101-0101 01001 00011-0101 0100 Resto Divisor Quociente Enquanto o dividendo for menor que o divisor, os bits do quociente são iguais a zero e acrescentamos um dígito ao dividendo a cada tentativa. Quando a subtração é possível, o quociente é deslocado para a esquerda e um bit igual a 1 é inserido. 17

Divisão Algoritmo: Inicialmente, o valor do dividendo é armazenado no regist. Resto. 18

Divisão Hardware imediato: O divisor ocupa inicialmente os 32 bits mais significativos do registrador. Decide quando deslocar o conteúdo dos registradores Divisor e Quociente, além de armazenar um novo valor no Resto. 19

Divisão Exemplo: 10 3 (4 bits) Iteração 0 Dividendo / Resto 0 0 0 0 1 0 1 0 Divisor 0 0 1 1 0 0 0 0 Quociente 0 0 0 0 20

Divisão Exemplo: 10 3 (4 bits) Iteração 1 (1) Resto = Resto Divisor. Dividendo / Resto 1 1 0 1 1 0 1 0 (2) Rem < 0 Resto = Resto + Divisor ; Desloca Quociente e insere um zero. Dividendo / Resto Quociente 0 0 0 0 1 0 1 0 0 0 0 0 Divisor (3) Desloca o divisor para a direita. 0 0 0 1 1 0 0 0 21

Divisão Exemplo: 10 3 (4 bits) Iteração 4 (1) Resto = Resto Divisor. Dividendo / Resto 0 0 0 0 0 1 0 0 (2) Rem >= 0 Desloca Quociente e insere um bit 1. Dividendo / Resto Quociente 0 0 0 0 0 1 0 0 0 0 0 1 Divisor (3) Desloca o divisor para a direita. 0 0 0 0 0 0 1 1 24

Divisão Exemplo: 10 3 (4 bits) Iteração 5 (1) Resto = Resto Divisor. Dividendo / Resto 0 0 0 0 0 0 0 1 (2) Rem >= 0 Desloca Quociente e insere um bit 1. Dividendo / Resto Quociente 0 0 0 0 0 0 0 1 0 0 1 1 Divisor (3) Desloca o divisor para a direita. 0 0 0 0 0 0 0 1 25

Divisão Hardware aprimorado: Note a semelhança entre este circuito e aquele destinado à multiplicação. 26

Divisão Divisão com sinal: A abordagem mais simples consiste em lembrar dos sinais dos operandos, convertê-los para seus equivalentes positivos, realizar a divisão e, finalmente, ajustar o sinal do quociente caso necessário. Convenção para evitar ambiguidades: o sinal do resto é determinado pelo sinal do dividendo. Cuidado: há a possibilidade de divisão por zero. 27

Divisão MIPS: Também usa os registradores Hi e Lo para a operação de divisão. Hi (32 bits): contém o resto. Lo (32 bits): contém o quociente. O Software precisa verificar uma eventual divisão por zero e a ocorrência de overflow. Instruções: div rs, rt divu rs, rt mfhi e mflo possibilitam o acesso aos resultados. 28

Ponto Flutuante De que maneira números reais podem ser representados em computador? Exemplos: 0,33 2,71828 (e) 3.847.992.023,45 Problema: o conjunto (e qualquer subintervalo) dos números reais não é contável. Consequência: o que se processa em computador necessariamente é uma aproximação do conjunto dos números reais. Duas questões, portanto, são bastante importantes na escolha de uma representação para esta classe de números: Qual a faixa de valores representáveis? Qual a precisão que se atinge com a representação adotada? 29

Ponto Flutuante A representação em ponto flutuante é o padrão adotado pelos sistemas computacionais para expressar um número real. Notação científica: Um único dígito à esquerda da vírgula (ponto decimal ou binário). Normalização: o único dígito antes da vírgula sempre é diferente de zero. Exemplos: 4,0 10-9 (Normalizado) 1,011 2-8 (Normalizado) 0,1011 2-7 (Não-normalizado) 30

Ponto Flutuante Vantagens da notação científica normalizada: Simplifica a troca de dados que incluem números representados em ponto flutuante. Simplifica os algoritmos para aritmética de ponto flutuante. Aumenta a precisão dos números que podem ser armazenados em uma palavra. 0 s desnecessários são substituídos por dígitos verdadeiros à direita da vírgula. 31

Ponto Flutuante Representação (normalizada): 1,xxxxxx 2 2 yyyy k bits m bits O primeiro bit indica o sinal do número. O campo seguinte contém os bits referentes ao expoente (positivo ou negativo), cujo tamanho afeta decisivamente a faixa de números representáveis. O último campo, denominado fração (mantissa ou magnitude), contém os dígitos válidos na forma normalizada. O tamanho deste campo determina a precisão da representação. Geral: (-1) S F 2 E yyyy 1,xxxxxx 2 Sinal Expoente Fração, Mantissa ou Magnitude 32

Ponto Flutuante A representação em ponto flutuante está sujeita à ocorrência de overflow: Quando o expoente se torna excessivamente grande, não podendo ser representado no campo correspondente, temos um overflow. Há, também, a possibilidade de outro evento excepcional, denominado underflow: Quando o valor calculado se torna tão pequeno que não pode ser representado, temos um underflow. Ou, equivalentemente, um underflow ocorre quando o expoente negativo para a representação do número se torna muito grande e não cabe no campo correspondente. 33

Ponto Flutuante Solução de compromisso: Aumentar o número de bits destinados ao expoente amplia a faixa de números que podem ser representados. Além disso, reduz a possibilidade de ocorrência de overflow / underflow. Aumentar o número de bits destinados à mantissa melhora a precisão ou a capacidade de aproximação associada à representação adotada. Limitação: tamanho da palavra (memória / registrador). 34

Ponto Flutuante Padrão IEEE 754 (1985): Formato simples (single): 8 bits 23 bits 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 S Expoente Fração Formato duplo (double): 11 bits 52 bits 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 S Expoente Fração 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 Fração (continuação) 35

Ponto Flutuante Padrão IEEE 754 (1985): Bit escondido: dado que o bit mais significativo guardado na mantissa sempre seria igual a 1 por causa da normalização, ele não precisa ser armazenado junto com os demais bits, i.e., ele pode ser implícito à representação. Deste modo, no formato single, teremos efetivamente 24 bits de mantissa (1 implícito e 23 armazenados). No caso double, serão 53 bits. 36

Ponto Flutuante Padrão IEEE 754 (1985): Para facilitar a comparação entre dois números representados em ponto flutuante, o expoente é armazenado antes da mantissa. Contudo, expoentes negativos complicam um pouco a comparação, pois à primeira vista se parecem com valores de maior magnitude (sem sinal) lembrar que o bit mais significativo é igual a 1. Desejável: maior expoente positivo = 11111 menor expoente negativo = 00000 Esta convenção nos leva à notação polarizada, na qual um bias é subtraído do expoente (sem sinal) armazenado para determinar o valor real deste campo. Valor escolhido: bias = 127 (single) bias = 1023 (double) 37

Ponto Flutuante Padrão IEEE 754 (1985): Com estas modificações, a representação em ponto flutuante segundo o padrão IEEE 754 é expressa da seguinte forma: (-1) S (1 + mantissa) 2 (expoente bias) Expandindo em função dos bits da mantissa b0, b1, b2, : (-1) S (1 +(b1 2-1 ) + (b2 2-2 ) + (b3 2-3 ) + ) 2 (expoente bias) Ou, equivalentemente: (-1) S (1 +((b1 2 22 ) + (b2 2 21 ) + + (b23 2 0 )) 2-23 ) 2 (expoente bias) 38

Ponto Flutuante Padrão IEEE 754 (1985): Números positivos: Menor expoente armazenado: 1 Maior expoente armazenado: 254 0 1,000... 2-126 1,111... 2-126 1,000... 2 127 1,111... 2 127 Precisão: 2-23 2-126 Precisão: 2-23 2 127 Números negativos: -1,111... 2 127-1,000... 2 127-1,111... 2-126 -1,000... 2-126 0 Precisão: 2-23 2 127 Precisão: 2-23 2-126 39

Ponto Flutuante Padrão IEEE 754 (1985): Representação do zero: Menor expoente: 000...0 Menor fração ou mantissa: 000...0 Símbolos especiais: O maior expoente (255) é reservado para símbolos especiais. Por exemplo, em vez de uma divisão por zero causar uma exceção, um símbolo + ou - pode ser retornado. Neste caso, a representação adotada é: expoente = 255 e fração = 000...0 Operações inválidas como 0 / 0 ou uma subtração entre dois valores infinitos produzem um símbolo NaN (not a number). A representação adotada para esta condição é: expoente = 255 e fração = valor não-nulo. 40

Ponto Flutuante Padrão IEEE 754 (1985): Em vez de haver um vazio (gap) entre o 0 e o menor valor normalizado, o padrão IEEE 754 aceita os chamados números não-normalizados. Características: Expoente armazenado é o mesmo que o utilizado para o valor zero (00...0). Fração não-nula. Correspondência: (-1) S (0 + fração) 2-126 Exemplo: Menor valor não-normalizado (single): 0,000...001 2-126 = 2-149. Maior valor não-normalizado (single): 0,111...111 2-126 = (1 2-23 ) 2-126. 41

Ponto Flutuante Exemplo: k = 4 e m = 2 Neste caso, o bias é igual a 7. Expoente = 0 reservado para o 0 e para os números não-normalizados. 1,00 2-6 = 0,01562500 1,01 2-6 = 0,01953125 1,10 2-6 = 0,02343750 1,11 2-6 = 0,02734375 Menor expoente válido 1,00 2 7 = 128 1,01 2 7 = 160 1,10 2 7 = 192 1,11 2 7 = 224 Maior expoente válido Expoente = 15 reservado para ± e NaN. 42

Ponto Flutuante Padrão IEEE 754 (1985): Quadro resumo: 43

Ponto Flutuante Padrão IEEE 754 (1985): Exemplo: decimal para ponto flutuante (1) 0,625 base decimal (2) 0,101 2 base 2 (3) Normalizando: 1,01 2-1 (4) Sinal: 0 (5) Expoente: -1 + 127 = 126 (6) Fração: 01000...0 0 0 1 1 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 S Expoente Fração (7) Palavra armazenada: 0x3f20 0000 44

Ponto Flutuante Padrão IEEE 754 (1985): Exemplo: ponto flutuante para decimal 1 1 0 0 0 0 0 1 1 0 1 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 S Expoente Fração (1) Palavra armazenada: 0xc1b2 4000 (2) Sinal = 1 número negativo (3) Expoente = 131 removendo a polarização, obtemos o expoente verdadeiro: 131 127 = 4. (4) Fração = 2-2 + 2-3 + 2-6 + 2-9 (5) Valor: (-1) S (1 + fração) 2 (expoente bias) (-1) (1 + 0,392578125) 2 4 = - 22,28125 45

Ponto Flutuante Adição: Passo 1: alinhar o ponto binário (decimal) tendo como referência o número com maior expoente. Para isto, basta deslocar o significando do menor número para a direita até que seu expoente corrigido se torne equivalente à referência. Passo 2: efetuar a operação de adição. Passo 3: normalizar o resultado. Passo 4: arredondar (truncar) para que valor obtido possua exatamente o número de dígitos permitido. Passo 5: caso necessário, efetuar nova normalização. 46

Ponto Flutuante Adição: 47

Ponto Flutuante Adição: Exemplo: 0,5 0,4375 Usando 4 bits para a representação: 0,5 = 0,1 2 0 = 1,000 2-1 -0,4375 = - 0,0111 2 0 = -1,110 2-2 O significando do número com menor expoente (no caso, -1,110) é deslocado para a direita até que seu expoente atinja o valor -1. -1,110 2-2 = -0,111 2-1 Soma: 1,000 2-1 0,111 2-1 = 0,001 2-1 48

Ponto Flutuante Adição: Exemplo: 0,5 0,4375 Normalize a soma, verificando a ocorrência de overflow ou underflow. 0,001 2-1 = 1,000 2-4 Arrendonde o resultado (neste caso em particular, não há necessidade de mudança). 1,000 2-4 = 0,0625. 49

Ponto Flutuante Hardware: Primeiro, o expoente de um operando é subtraído do outro usando uma pequena ALU para descobrir qual deles é o maior e qual a diferença entre estes valores. Esta diferença controla os três multiplexadores; da esquerda para a direita, eles selecionam o maior expoente, o significando do menor número e o significando do maior número. O menor significando é deslocado para a direita e, então, os significandos são somados com o auxílio da ALU ampliada. Em seguida, a soma é deslocada para a direita ou esquerda e o expoente é incrementado ou decrementado (Normalização) O hardware de arredondamento cria o resultado final, o que pode exigir uma nova etapa de normalização. 50

Ponto Flutuante Multiplicação: Passo 1: calcular o expoente. Basta somar os expoentes armazenados!? E subtrair a polarização. Passo 2: multiplicar os significandos. Passo 3: normalizar o resultado. Passo 4: arredondar (truncar) para que valor obtido possua exatamente o número de dígitos permitido. Se necessário, efetuar nova normalização. Passo 5: determinar o sinal do resultado. 51

Ponto Flutuante Multiplicação: 52

Ponto Flutuante Multiplicação: Exemplo: 0,5 (-0,4375) Usando 4 bits para a representação: 0,5 = 0,1 2 0 = 1,000 2-1 -0,4375 = - 0,0111 2 0 = -1,110 2-2 Somando os expoentes sem bias: -1 + (-2) = -3 Multiplicando os significandos: 1,000 0,111 = 1,110000 Podemos manter apenas 4 bits 1,110 2-3 53

Ponto Flutuante Multiplicação: Exemplo: 0,5 (-0,4375) O produto já está normalizado e não houve overflow / underflow. Não há necessidade de arredondar. Sinal: como os sinais dos operandos eram diferentes, o resultado será negativo. -1,110 2-3 Convertendo para decimal: -1,110 2-3 = -0,21875 54

Ponto Flutuante Bits de guarda e arredondamento: Para arredondar os números de maneira mais precisa, o hardware pode incluir bits extras nos cálculos. O padrão IEEE 574 prevê o uso de dois bits extras à direita durante as somas intermediárias, denominados bits de guarda e arredondamento. Exemplo: 2,56 10 0 + 2,34 10 2 Com bits extras: 2,3400 + 0,0256 = 2,3656 10 2 Arredondamento: 2,37 10 2 Sem bits extras: 2,34 + 0,02 = 2,36 10 2 55

Ponto Flutuante Sticky bit: Terceiro bit extra usado para melhorar a aproximação/arredondamento. Se existem bits não-nulos à direita do bit de arredondamento, o sticky bit é 1; caso contrário, ele é zero. Atrativo: permite que o computador enxergue a diferença existente entre, por exemplo, 0,5000...000 e 0,5000...001 durante a etapa de arredondamento. Exemplo: 5,01 10-1 + 2,34 10 2. Mesmo com os bits de arredondamento e de guarda, a soma seria realizada entre 2,34 e 0,005. O sticky bit, neste caso, assumiria o valor 1, uma vez que haveria dígitos não-nulos à direita do bit de arredondamento. Sem o sticky bit: a soma seria 2,345 = 2,34. Com o sticky bit: a soma também seria 2,345, mas com a informação de que havia mais dígitos. Então, o arredondamento seria para o valor 2,35. 56

Ponto Flutuante A arquitetura MIPS oferece um conjunto de instruções específicas para trabalhar com números reais em representação com ponto flutuante. Adição: add.s e add.d Subtração: sub.s e sub.d Multiplicação: mul.s e mul.d Divisão: div.s e div.d Comparação: c.x.s e c.x.d, onde X = {eq, neq, lt, le, gt e ge} Desvio: bc1t (branch, true) e bc1f (branch, false) 57

Ponto Flutuante Há 32 registradores, denotados por $f0-$f31, destinados especificamente para operações em ponto flutuante. Estes registradores podem ser agrupados em pares para a representação com precisão dupla. Neste caso, uma referência ao registrador $f0 é interpretada como uma tentativa de acesso ao conteúdo (64 bits) de $f0 - $f1. Há instruções específicas para mover dados da memória para estes registradores: lwc1 e swc1. OBS: a abreviação c1 vem de coprocessador 1 antigamente, a ULA de ponto flutuante ficava em um chip separado do processador. 58

Ponto Flutuante Resumo: 59

Considerações Finais Alguns erros comuns: Deslocamento para a direita sempre implementa a divisão por uma potência de 2. Isso é verdade desde que seja um número sem sinal. Adição em ponto flutuante é associativa! Por causa da precisão limitada, é possível que arredondamentos intermediários levem a resultados diferentes dependendo da ordem em que as somas são feitas. Exemplo: a = -1,5 10 38 b = 1,5 10 38 c = 1 (a + b) + c = 1 a + (b + c) = 0 60

Números + Programa Armazenado Importante: uma sequência de bits armazenada na memória não possui um significado intrínseco; isto é, ela pode ser interpretada de maneiras diferentes: Número sem sinal; Número inteiro; Número em representação de ponto flutuante; Caractere (ASCII); Instrução de máquina. A operação que atua sobre os bits armazenados em uma dada palavra é que determina o significado desta sequência de bits. Importante: há uma diferença fundamental entre os números representados em computador e os números do mundo real. Magnitude limitada. Precisão limitada. Podemos representar apenas 2 N números, onde N é o número de bits para armazenamento/representação. 61

Créditos Figuras extraídas de D. A. Patterson e J. L. Hennessy, Computer Organization and Design: The Hardware/Software Interface, Morgan Kauffman, 5ª edição, 2013. http://textbooks.elsevier.com/web/product_details.aspx?isbn=9780124077263 62