ARQUITECTURA DE COMPUTADORES CAPÍTULO III AULA I, II e III Abril 2014
Índice Aritmética para computadores Intro Adição e subtração Multiplicação Divisão Virgula Flutuante Virgula Flutuante - aritmética
Intro Como é feita uma adição? Como são efectuadas multiplicações? E fracções? Como são representadas? E os números reais? Como se converte de decimal para binário? E quando um resultado não cabe em 32bits? Como funciona a ALU?
Adição e subtração Como vimos anteriormente, a adição é uma instrução base de aritmética, suportada por qualquer processador. Em MIPS utilizamos a instrução add. Mas o que acontece realmente quando o processador executa um add? Ocorre um soma binária, onde: 1 + 1 = 10 1 + 0 = 1 0 + 0 = 0 0 + 1 = 1 1 + 1 + 1 = 11
Adição e subtração Considere-se os seguintes registos: $s0 = 0000 0000 0000 0000 0000 0000 0000 1110 $s1 = 0000 0000 0000 0000 0000 0000 0000 1101 Qual o resultados de $t0, em add $t0, $s0,$s1? 0000 0000 0000 0000 0000 0000 0000 1110 + 0000 0000 0000 0000 0000 0000 0000 1101 0000 0000 0000 0000 0000 0000 0001 1011 1 1
Adição e subtração Outra operação de base é a subtracção. Em MIPS utilizamos a instrução sub. Mas o que acontece realmente quando o processador executa um sub? Ocorre um soma binária, onde: 1-0 = 1 1 1 = 0 0 0 = 0 0 1 = 1 e vai 1 para subtrair no próximo
Adição e subtração Considere-se os seguintes registos: $s0 = 0000 0000 0000 0000 0000 0000 0000 1110 $s1 = 0000 0000 0000 0000 0000 0000 0000 1101 Qual o resultados de $t0, em sub $t0, $s0,$s1? 0000 0000 0000 0000 0000 0000 0000 1110-0000 0000 0000 0000 0000 0000 0000 1101 (1) 0000 0000 0000 0000 0000 0000 0000 0001
Adição e subtração O que acontece quando: A + B < 0, sendo A e B ambos 0; A + B 0, sendo A e B ambos < 0; A B < 0, sendo A 0 e B < 0; A B 0, sendo A < 0 e B 0; São casos de Overflow. add, addi e sub reconhecem overflow através do sinal invertido (signed). addu, addiu, e subu ignoram overflow.
Adição e subtração Exemplo: 0 1011 1110 + 0 1111 1101 1 1011 1011 Existem compiladores, como por exemplo o compilador de C, que ignoram Overflows, uma vez que compilam somente para instruções unsigned.
Adição e subtração Adições, subtrações e lógica são suportadas pela ALU: Arithmetic Logic Unit. Central Processing Unit Input Device Unidade de Controlo Unidade Aritmética/Lógica Output Device Unidade de memória Programa Código Dados
Multiplicação Nas aulas anteriores aprendemos que ao efectuar um shift left logic (sll), estamos a multiplicar um determinado valor por m = 2 n. sll $t0, $s0, 2, ou seja, $t0 = 2 2 x $s0. Porém, nem sempre o valor de multiplicação é uma constante, nem uma potência de 2.
Multiplicação Regras de multiplicação de base 2: 0 x 0 = 0; 0 x 1 = 0; 1 x 0 = 0; 1 x 1 = 1; Exemplo: 1110 x 101 1110 0000 1110 1000110
Multiplicação 0010 x 0011 0010 0010 0000 0000 0000110
Multiplicação Multiplicação em MIPS: mult $s,$t multu $s,$t O resultado, de 64bits, é colocado em dois registos específicos: LO e HI. mfhi $s, HI -> move o valor de HI para o registo $s mflo $s, LO -> move o valor de LO para o registo $s Multiplicação em MIPS não reconhece overflows
Divisão Regras e divisão para base 2 0/1 = 0 1/1 = 1 1/0 = N/A 0/0 = N/A Exemplo: 1110 10-10 111 11-10 10-10 0 Exemplo: 101110 11-11 1111 101-11 101-11 100-11 001
Divisão Exemplo: 0111 10-10 11 11-10 1
Divisão Divisão em MIPS: div $s,$t => LO = $s / $t HI = $s % $t divu $s,$t O resultado, de 32bits, é colocado em LO, enquanto que o resto é colocado em HI. mfhi $s, HI -> move o valor de HI para o registo $s mflo $s, LO -> move o valor de LO para o registo $s
Índice Aritmética para computadores Intro Adição e subtração Multiplicação Divisão Virgula Flutuante Virgula Flutuante - aritmética Paralelismo e aritmética
Floating Point Para além dos números naturais, é comum em computação utilizarem-se números reais. PI = 3.14159265 0.00000001 ou 1.0 x 10 8 3,234,345,000 ou 3.234345 x 10 9 Etc À representação apresentada nos dois últimos exemplos denomina-se de notação científica. A notação científica normalizada não permite zeros à esquerda da vírgula. 1.0 x 10 9 - Normalizado 10.0 x 10 8 - Não Normalizado
Floating Point Em computação, a notação científica é também aplicada à numeração binária. Porém, de modo a garantir a normalização da mesma, a base deixa de ser decimal (10), passando a ser binária (2). Exemplo: 10 9 => 2 9 Aritmética computacional com suporte para notação científica de base 2, denomina-se de vírgula flutuante.
Floating Point Ao seguir a notação normalizada, existem três benefícios: 1. Simplifica a troca de dados com vírgula flutuante. 2. Simplifica os cálculos aritméticos entre estes números. 3. Aumenta a precisão dos números guardados numa word (32 bits). Uma vez que não gasta bits à esquerda, permite guardar um maior número de casas decimais e assim aumentar a precisão.
Floating Point Representação: Na representação de uma vírgula flutuante existem dois parâmetros configuráveis: A fração ou mantissa; O expoente; Considere: 1.xxxxxx x 10 yyyyyy, onde 1.x representa a fração e y o expoente. Maior o x, maior a precisão. Maior o y, maior o alcance. Logo, deve existir um balanço entre precisão e alcance, considerando o limite de uma word.
Floating Point Representação em MIPS: 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 s Expoente Fracção 8 bits 23 bits Formula genérica: ( 1) s x F x 2 E Exemplo: 1.00000000 x 2 11010110101101011010111
Floating Point Limites: 2.0 x 10 35 2.0 x 10 35 Tal como nos números inteiros, existe o perigo de overflow em vírgulas flutuantes: Overflow em vírgula flutuante ocorre quando o valor de um expoente positivo é tão grande que não cabe nos bits para ele destinados. Underflow em vírgula flutuante ocorre quando o valor de um expoente negativo é tão grande que não cabe nos bits para eles destinados.
Floating Point Uma forma de reduzir o perigo de overflow ou underflow é aumentar o campo destinado ao expoente. Em linguagem C isso é implementado através do tipo double: double precision floating point. Um double utiliza duas words de 32 bits cada. A versão normal denomina-se de single precision floating point, que ocupa somente uma word de 32 bits. Em linguagem C é o tipo float.
Floating Point Representação de um double em MIPS: 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 s Expoente Fracção 11 bits 20 bits 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 Fracção (continuação) 32 bits
Floating Point Limites de um double: 2.0 x 10 305 2.0 x 10 305 O formato e codificação dos diferentes modos de representação de virgulas flutuantes são definidos pela norma IEEE 754 floating-point standard, desde 1980.
Floating Point Como vimos nos exemplos de números reais a representação de expoentes negativos é também bastante usada. Para representar a negação do expoente, poderíamos seguir a mesma regra do sinal aplicada ao bit mais significativo. Porém, o IEEE 754 define que os expoentes mais negativos devem ser representados por 00 00 e os mais positivos por 11 11. A isto chama-se de convenção tendenciosa.
Floating Point A convenção tendenciosa, utiliza um valor tendencioso para obter os expoentes no formato pretendido, nomeadamente o número 127 (1023 para double). Assim, o expoente representado é obtido através da soma do expoente mais o valor tendencioso. 30 29 28 27 26 25 24 23 Exemplo: 1.0 x 2 1-1 + 127 = 126 = 0111 1110 1 1 1 1 1 1 1 1 30 29 28 27 26 25 24 23 0 1 1 1 1 1 1 0
Floating Point Sendo assim a formula genérica obtida anteriormente é alterada para: ( 1) s x 1 + F x 2 E Bias Deste modo os limites reais de vírgulas flutuantes simples, são: Exemplo: Menor ±1.00000000000000000000000 x 2 126 Maior ±1.11111111111111111111111 x 2 127
Floating Point Exercício: Converta o número real -0.875 para notação cientifica base 2 e respetiva virgula flutuante simples. -0.875-7 / 8 #Fração decimal -7 / 2 3 #decimal sobre base binária -0111 / 2 3 #Fração binária -0111 x 2 3 # Fração invertida -0.111 x 2 0 # Notação científica -1.11 x 2 1 # Notação científica normalizada Pode utilizar a calculadora online para verificar o resultado em: http://babbage.cs.qc.cuny.edu/ieee-754.old/decimal.html
Floating Point Exercício: Converta o número real -0.875 para notação cientifica base 2 e respetiva virgula flutuante simples. Aplicando -1.11 x 2 1 a ( 1) s x 1 + F x 2 E Bias obtém-se ( 1) 1 x 1 + 1100 0000 0000 0000 0000 000 x 2 126 127 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 1 0 1 1 1 1 1 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Floating Point Definições do IEEE 754
Floating Point
Índice Aritmética para computadores Intro Adição e subtração Multiplicação Divisão Virgula Flutuante Virgula Flutuante - aritmética
Floating Point - Adição De modo a somar vírgulas flutuantes ambos os operandos devem ter o mesmo expoente, sendo o expoente igual ao maior entre os dois. Calcule a seguinte operação de base 10, considerando um máximo de 4 bits. 9.999 x 10 1 + 1.610 x 10 1 1. Colocar o segundo operando no formato 10 1 visto ser o maior expoente entre os dois. 0.1610 x 10 0 0.01610 x 10 1
Floating Point - Adição 2. Arrendondar a fração para a quantidade de bits suportada (ex. 4 bits). 0.01610 x 10 1 0.016 x 10 1 3. Alinhar ambos os operando pela vírgula e somar 9.999 x 10 1 0.016 x 10 1 10.015 x 10 1
Floating Point - Adição 4. Normalizar o resultado 10.015 x 10 1 1.0015 x 10 2 5. Arredondar o resultado para os 4 bits totais 10.015 x 10 1 1.0015 x 10 2 1.002 x 10 2
Floating Point - Adição
Floating Point - Adição Exercício: Some 0.5 com 0.875 em base 2. 0.5 => 1/2 => 1/2 1 => 1.0 x 2 1 0.875 =? Inteiro = 0 + Decimal = 0.875 x 2 = 1.750 0.750 x 2 = 1.500 0.500 x 2 = 1.000 0.000 x 2 = 0.000 Logo: 0.875 = 0.1110 = 1.110 x 2 1 0x2 0 + 1x2 1 + 1x2 2 + 1x2 3 = = 0 + 0.5 + 0.25 + 0.125 = = 0.875 Ou: 0.875 => 7/8 => 7/2 3 => 0111 x 2 3 => 1.11 x 2 1
Floating Point - Adição Exercício: Some 0.5 com 0.875 em base 2. 1.000 x 2 1 +1.110 x 2 1 10.110 x 2 1 Normalizando: 10.110 x 2 1 => 1.0110 x 2 0 Verificar overflow e underflow: 127 0-126 => OK Arredondar caso necessário: 1.0110 x 2 0 => 1.011 x 2 0
Floating Point - Adição Exercício: Some 0.5 com 0.875 em base 2. Converter para decimal e observar o resultado: 1.011 x 2 0 = = 1 x 2 0 + 0 x 2 1 + 1 x 2 2 + 1 x 2 3 = = 1 + 0.25 + 0.125 = = 1.375
Floating Point - Subtração Exercício: Calcule 0.5-0.375 em base 2. 0.5 = 1.0 x 2 1 = 0.1 x 2 0 0.375 = 0 + decimal 0.375 x 2 = 0.75 0.75 x 2 = 1.5 0.5 x 2 = 1.0 0.375 = 0.011 x 2 0 0.100-0.011 0.001 x 2 0 = 1.0 x 2 3 0.001 Normalizar: 0.01 x 2 1 = 1.0 x x 2 3 127-3 -126, logo não existe overflow 0.001 = 2 3 = 0.125 0.5 0.375 = 0.125
Floating Point - Multiplicação Tal como na adição, vamos exemplificar com numeração base 10. Considere o seguinte exemplo, com o limite de duas casas decimais: 5.23 x 10 2 x 2.40 x 10 5 Ao contrário da adição, na multiplicação não é necessário alinhar os expoentes. Em contrapartida o expoente resulta da soma dos dois expoentes presentes na operação.
Floating Point - Multiplicação Assim: 5.23 x 10 2 x 2.40 x 10 5 000 2092 1046. 125520 x 10 7 Normalizando: 1.25520 x 10 6 Testar overflow ou underflow: 127-6 -126 Arredondar: 1.26 x 10 6
Floating Point - Multiplicação
Floating Point - Multiplicação Exercício: 0.375 x 2 = 0.75 0.75 x 2 = 1.5 0.5 x 2 = 1.0 0.375 = 0.011 = 1.1 x 2 2 Calcule 0.375 x 0.5 em base 2 0.5 x 2 = 1.0 1.1 x 2 2 0.5 = 0.1 x 2 2 = 1.0 x 2 1 x 1.0 x 2 1 0 0 1 1 1. 1 0 x 2 3 0.375 x 0.5 = 0.1875 1. 1 0 x 2 3 = 0.00110 = 2 3 + 2 4 = 0.125 + 0.0625 = 0.1875 Normalizando: OK Testar overflow ou underflow: 127-3 -126 OK Arredondar: OK
Floating Point - Multiplicação Exercício: Divida 1.5 por 0.5 em base 2 1.5 x 2 = 1.1 x 2 0 0.5 x 2 = 1.0 0.5 = 0.1 x 2 2 = 1.0 x 2 1 1.10 x 2 0 1.00 x 2 1 = 1.10 x 2 0 x 1.00 x 2 1 = 1.10 x 2 1 Normalizando: OK Testar overflow ou underflow: 127 1-126 OK Arredondar: OK 1.5 / 0.5 = 3 1.10 x 2 1 = 11.0 = 1 x 2 2 + 1 x 2 1 = 3
Floating Point EM MIPS O MIPS suporta a norma IEEE 754, tanto em precisão simples como em double, através das seguintes instruções: Função Instrução Operação Adiciona (precisão simples) add.s $f2, $f4, $f6 $f2 = $f4 + $f6 Subtrai (precisão simples) sub.s $f2, $f4, $f6 $f2 = $f4 - $f6 Multiplica (precisão simples) mul.s $f2, $f4,$f6 $f2 = $f4 x $f6 Divisão (precisão simples) div.s $f2,$f4,$f6 $f2 = $f4 / $f6 Adiciona (precisão dupla) add.d $f2, $f4, $f6 $f2 = $f4 + $f6 Subtrai (precisão dupla) sub.d $f2, $f4, $f6 $f2 = $f4 - $f6 Multiplica (precisão dupla) mul.d $f2, $f4,$f6 $f2 = $f4 x $f6 Divisão (precisão dupla) div.d $f2,$f4,$f6 $f2 = $f4 / $f6
Floating Point EM MIPS O MIPS tem um coprocessador próprio para tratar vírgulas flutuantes, denominado de co-processor 1 (C1) O MIPS utiliza uma floating point conditional flag para guardar resultados FP. Função Instrução Operação Load lwc1 $f2, 0( $f6) $f2 = $f6[0] Store swc1 $f2, 0($f6) $f6[0] = $f2 Comparação (precisão simples) c.x.s $f2, $f4 (eq, neq,lt,le,gt,ge) Comparação (precisão dupla) c.x.d $f2, $f4 (eq, neq,lt,le,gt,ge) Se $f2 x $f4 Se $f2 x $f4 coloca a flag a true Atua conforme a flag movet $t0,$t1 Move $t1 para $t0 se flag = true
Floating Point EM MIPS O C1 contem 32 registos FP, de $f0 a $f31 de 32 bits cada. Uma vez que os registos $fx são registos de 32 bits, a representação de doubles ocupa dois registos. Para além das instruções apresentadas, existem várias outras instruções para, entre outros: Mover valores entre registos, Mover valores entre registos com base nas flags condicionais Mover valores co co-processador 1 para o 0 e vice-versa, Etc
Floating Point EM MIPS
Dúvidas e Questões Abril 2014