Arquitetura FPU: Implementação no MIPS32

Transcrição

1 Universidade Federal de Santa Catarina CTC - Centro Tecnológico Ciências da Computação INE Linguagem Assembly Arquitetura FPU: Implementação no MIPS32 Alunos: Guilherme Fernandes Raphanelli Diogo D. Fonseca dos Santos

2 SUMÁRIO 1. Introdução Representação Binária Registradores Formato de Valores para FPRs Instruções Exceções na FPU Invalid Operation Exception Division By Zero Exception Underflow Exception Overflow Exception Inexact Exception Exercícios Detecção de Overflow para Multiplicação Visualização de Contexto...10 APÊNDICE A Detecção de overflow em multipicação em Ponto flutuante...12 APÊNDICE B Visualização de CONTExto da FPU...14

3 1 1. Introdução O suporte para operações de ponto flutuante nas diferentes arquiteturas é normalmente dado através de componentes diferentes de onde ocorrem as operações com inteiros. Estes componentes são designados como Floating-Point Unit (FPU), ou unidade de ponto flutuante. Na arquitetura MIPS32 - chamada de MIPS ao longo do documento - a FPU é implementada principalmente através do Co-processador 1, o co-processador de ponto flutuante, também conhecido como floating-point accelerator (FPA). Para utilizar a FPU no MIPS é necessário que ela esteja habilitada. Para isto é necessário habilitar o Co-processador 1 através de uma operação privilegiada fornecida pelo Coprocessador de Controle do Sistema. Este documento abordará diferentes aspectos da FPU do MIPS, expostos no seguintes capítulos: 2. Representação Binária A arquitetura MIPS segue o padrão Institute of Electrical and Electronics Engineers (IEEE) 754, o IEEE Standard for Binary Floating-Point Arithmetic. Este padrão define os tipos de dados em ponto flutuante, as operações aritméticas, de comparação e de conversão básicas, e um modelo computacional. A FPU do MIPS oferece suporte aos tipos de dados em ponto flutuante e ao tipos de dados em ponto fixo. Os tipos de dados em ponto flutuante implementados são os single precision, ou de precisão única, e double precision, ou de precisão dobrada, como definidos pelo IEEE 754. O tipo de dado em ponto fixo é o de inteiros sinalizados, fornecido pela arquitetura da CPU. Os formatos definidos são os seguintes:

4 ponto flutuante 32-bit single precision (tipo S, pode ser visto na Figura 1). ponto flutuante 64-bit double precision (tipo D, pode ser visto na Figura 2). ponto fixo 32-bit word (tipo W, pode ser visto na Figura 3). 2 Figura 1 - Formato tipo S Figura 2 - Formato tipo D O formato tipo W oferece a mesma representação utilizada pela CPU nas operações de ponto fixo, mas não suportando inteiros não sinalizados. O formato tipo S é uma representação de ponto flutuante com 32-bits, tendo 8 bits para o expoente, 23 bits de mantissa e 1 para sinalização. O tipo D estende esta representação para 11 bits de expoente e 52 de mantissa. Para acomodar este formato na arquitetura MIPS32, a FPU divide o número em dois registradores de 32- bits, como mostrado na Figura 2. Figura 3 - Formato tipo W 3. Registradores As CPUs MIPS possuem 32 registradores de ponto flutuante, normalmente referidos como $f0-f$31. Entretanto, mesmo as CPUs MIPS32 possuem suporte a números ponto flutuante double precision de 64 bits. Assim, estas CPUs apenas

5 realizam operações aritméticas nos 16 registradores pares, sendo os 16 registradores ímpares usados para cuidar dos 32 bits mais significativos destes números de 64 bits. Para a manipulação de dados inteiros qualquer registrador pode ser utilizado. 3 Registrador Nome Uso $f0,$f2 fv0-fv1 Valor retornado por funções. $f4,$f6,$f8,$f10 ft0-ft3 Temporários. $f12,$f14 fa0-fa1 Argumentos de funções $f16,$f18 ft4-ft5 Temporários. $f20,$f22,$f24 $f26,$f28,$f30 fs0-fs5 Variáveis de registro. Tabela 1 - Convenção para Registradores da FPU Assim como os registradores de uso geral, os registradores de operando ponto flutuante (FPR) também possuem uma convenção de nomes e de uso. A convenção de uso é análoga à dos registrados de uso geral. A Tabela 1 descreve estas convenções. A arquitetura MIPS32 também suporta registradores para controle de ponto flutuante, os Floating Point Control registers (FCRs). Existem 5 registradores para controle da FPU, com 32 bits cada. Os registradores suportados são os seguintes: FIR - FP Implementation and Revision register FCCR - FP Condition Codes register FEXR - FP Exceptions register

6 4 FENR - FP Enables register FCSR - FP Control/Status register O acesso a estes registradores não é privilegiado, eles podem ser acessados por qualquer programa que consiga executar instruções de ponto flutuante. Os FCRs podem ser acessados através das instruções CTC1 e CFC Formato de Valores para FPRs Ao contrário da CPU, a FPU não interpreta a codificação binária dos operadores de origem nem produz uma codificação binária para o resultado de cada operação. Um valor guardado em um FPR tem um formato, ou tipo, e pode ser usado apenas por instruções que operam nesse formato. Este formato pode ser: uninterpreted (não interpretado), unknown (desconhecido), ou um dos tipos numéricos válidos, single, double ou word. Um valor é definido como uninterpreted após ser carregado em um registrador ponto flutuante como dado binário, o que acontece usando moves a partir de inteiros ou loads. Assim que este registrador for utilizado por uma função de formato específico, o valor será definido como sendo do mesmo formato. O formato unknown é utilizado quando uma operação de um formato utiliza um registrador de origem com um valor de formato diferente. Neste caso, tanto o valor utilizado quanto o resultado são definidos como unknown. 4. Instruções Os co-processadores, assim como a CPU, operam em dados naturalmente alinhados. A FPU possui loads e stores que

7 usam o mesmo tipo de endereçamento registrador+offset usado pela CPU. As instruções da FPU possuem formatos diferentes dos especificados para as instruções da CPU. As instruições normalmente possuem uma versão double e uma single, identificadas por d e s respectivamente. A Tabela 2 mostra algumas destas instruções. 5 Instrução lwc1 fd, disp(rs) swc1 fd, disp(rs) mtc1 rs, fd mfc1 rd, fs mov.s fs,fd Uso fd = *(rs + disp). Load da memória para registrador. Pode-se usar as pseudo-intruções l.s fd, address (single) ou l.d(double). *(rs+disp) = fd. Store do registrador para memória. Pseudo-instruções: s.s ou s.d. fd = rs. Move de registrador inteiro (rs) para registrador fp (fd). 32bits não interpretados. rd = fs. Move de registrador fp para registrador inteiro. 32bits não interpretados. fd = fs. Move entre registradores fp. mov.d fs,fd add.s fd, fs1, fs2 fd = fs1 + fs2. add.d fd, fs1, fs2 mul.s fd, fs1, fs2 fd = fs1 x fs2. mul.d fd, fs1, fs2 Tabela 2 - Instruções FP MIPS32 A FPU oferece diversas operações além das operações básicas mostradas na Tabela 2. As operações podem ser separadas em 6 classes distintas: Instruções para transferência de dados, instruções aritméticas, instruções de conversão, instruções para mover valores de operando formatados, instruções condicionais e instruções variadas. Estas operações podem ser encontradas em [2].

8 6 5. Exceções na FPU As exceções FPU são implementadas na arquitetura MIPS FPU com os campos Cause, Enable e campos de Flag do registrador Control/Status. Os bits de Flag implementam os flags de status de exceção IEEE, e os bit Cause e Enable controlam o trapping de exceções. Cada campo tem um bit para cada uma das cinco condições de exceção da IEEE. A FPU possui um modo de funcionamento especial, o precise exception mode. Neste modo o trap é gerado antes que a instrução que causou a exceção, ou qualquer instrução em seguida, possa terminar e escrever seus resultados. Se desejado, o software que detecta a exceção pode recomeçar a execução da instrução interrompida depois de tratá-la. As cinco exceções FPU IEEE implementadas na arquitetura MIPS32 são: Invalid-Operation Exception (Operação Inválida), Division-By-Zero Exception (Divisão por zero), Underflow Exception, Overflow Exception e Inexact Exception. Estas exceções serão explicadas a seguir. 5.1.Invalid Operation Exception Algumas situações que são definadas como uma operação inválida: Um ou ambos os operandos de uma operação aritmética sinalizam NaN. Adição ou subtração: subtração de infinitos. Multiplicação: 0 vezes infinito, com quaisquer sinais. Divisão: 0/0 ou divisão de infinitos, com quaisquer sinais.

9 7 5.2.Division By Zero Exception Acusa-se uma execeção de Divisão por zero se o divisor for zero e o dividendo for um número finito diferente de zero. O resultado, caso nenhuma trap ocorra, é definido como infinito. As divisões (0/0) e ( /0) não causam a exceção de divisão por zero. O resultado de (0/0) é uma exceção inválida da operação. O resultado de ( /0) é uma infinidade corretamente sinalizada. 5.3.Underflow Exception Duas situações podem causar uma exceção de underflow: Tininess: a criação de um resultado não-zero minúsculo que, por ser minúsculo, pode causar alguma outra exceção mais tarde como o excesso na divisão. Perda de exatidão: a perda de exatidão extraordinária que ocorre na aproximação de tais números minúsculos com números não-normalizados. 5.4.Overflow Exception Uma exceção de overflow acontece quando o valor de um resultado arredondado em ponto flutuante, caso o expoente não tivesse limites, é maior do que o formato de destino com o maior número finito. 5.5.Inexact Exception

10 8 Uma Inexact Exception ocorre nas seguintes situações: O resultado arredondado de uma operação não é exato. O resultado arredondado de uma operação gera overflow sem ocasionar um trap de overflow. 6. Exercícios O exercício de detecção de overflow para multiplicação e o de visualização de contexto desenvolvidos em sala de aula foram modificados para utilizarem a FPU. Muitas modificações foram necessárias dadas as diferenças entre a CPU e a FPU, e pelas dificuldades do ambiente de testes. As ferramentas SPIM e gxemul foram utilizadas para reproduzir ao máximo as condições sob as quais os exercícios foram feitos no laboratório. 6.1.Detecção de Overflow para Multiplicação O exercício original era realizar manualmente a detecção de overflow de uma multiplicação, o que para números inteiros era realizado comparando-se os sinais. Os números de ponto flutuante, segundo o padrão IEEE 754 implementado pelo MIPS32, possuem um indicador próprio de overflow, tornando desnecessária a técnica anterior. Quando uma operação em ponto flutuante gera um número muito grande para ser armazenado, situação conhecida como overflow, a FPU automaticamente define todos os bits de expoente do registrador destino como 1. Esta configuração significa um número tido como infinito, positivo ou negativo dependendo do bit de sinal, podendo ser utilizada para a verificação do overflow. O código fonte criado pode ser visto no Apêndice A.

11 As primeiras diferenças com relação ao código anterior do exercício surgem no momento da entrada de dados do usuário. O código de chamada de sistema 6 é utilizado, ao invés do 5 original, para obter um número em ponto flutuante. Esta chamada de sistema coloca o número recebido no registrador $f0. 9 Figura 4 - Multiplicação em Ponto Flutuante Depois de multiplicados os números recebidos, o resultado é movido para um registrador de uso geral. Operações de bits são utilizadas para se isolar os bits de expoente e verificar se todos estão habilitados. Caso afirmativo, é caracterizada a ocorrência de overflow e ocorre a notificação ao usuário. Caso contrário, o resultado é apresentado utilizando-se o código de chamada de sistema 2, que imprime um número em ponto flutuante. Esta chamada de sistema utiliza o registrador $f12 como argumento. Uma operação bem sucedida pode ser vista na Figura 4, e uma onde ocorre overflow na Figura 5. Figura 5 - Overflow Detectado

12 Visualização de Contexto O objetivo deste exercício era a visualização do estado dos registradores de uso geral. Isto era realizado através da chamada de funções implementadas em C, utilizando o template para assembly. Para o exercício original era necessário o salvamento de contexto, mas tratando-se dos registradores da FPU isto não é necessário, já que estes registradores são completamente independentes do fluxo normal dos programas. O código fonte novo pode ser visto no Apêndice B. As primeiras dificuldades encontradas para imprimir o estado atual dos registradores da FPU foram relativas à falta de acesso direto através do template de assembly a estes registradores. Sendo assim, a maneira encontrada para realizar a tarefa foi, para cada registrador, copiar o valor do registrador de ponto flutuante para um registrador de uso geral, imprimindo-se então o valor deste registrador. Para facilitar a impressão das mensagens relativas a cada registrador, a estrutura da função print_register foi modificada, adicionando-lhe um argumento. A Figura 6, que pode ser encontrada junto ao código no Apêndice II, mostra o funcionamento deste programa. Uma versão modificada deste código foi implementada para verificar a consistência das informações através do SPIM. A Figura 7 mostra o resultado, podendo ser encontrada junto ao código no Apêndice B. REFERÊNCIAS BIBLIOGRÁFICAS 1 SWEETMAN, D. See MIPS Run. EUA. Morgan Kaufmann Publishers, 1999.

13 2 MIPS Technologies. MIPS32 Architecture For Programmers Volume I: Introduction to the MIPS32 Architecture. mar

14 12 APÊNDICE A DETECÇÃO DE OVERFLOW EM MULTIPICAÇÃO EM PONTO FLUTUANTE ### ### Area de Dados ### data get_v1:.asciiz "Enter the first value: " get_v2:.asciiz "Enter the second value: " put_res:.asciiz "The result is equal " overflow:.asciiz "Ocorreu overflow. " ### ### Area de Codigo ### text.globl main main: addiu $sp, $sp, -4 sw $ra, 0($sp) la $a0, get_v1 li $v0, 4 li $v0, 6 mov.d $f12, $f0 la $a0, get_v2 li $v0, 4 li $v0, 6 mul.s $f12, $f12, $f0 mfc1 $t0, $f12 srl $t0, $t0, 23 addi $t1, $zero, 255 and $t0, $t0, $t1 bne $t0, $t1, result over: la $a0, overflow li $v0, 4 j prologue result: la $a0, put_res li $v0, 4 li $v0, 2

15 13 prologue: lw $ra, 0($sp) addiu $sp, $sp, 4 jr $ra ### ### Funcao para imprimir elemento na tela ### data.globl newline newline:.asciiz "\n".globl comma comma:.asciiz ",".text.globl print_cmd print_cmd: beq $a0, $zero, F0 li $v0, 1 li $v0, 4 la $a0 comma jr $ra F0:li $v0, 4 la $a0 newline jr $ra.globl print_int print_int: li $v0, 1 li $v0, 4 la $a0 newline jr $ra.globl print_string print_string: li $v0, 4 jr $ra Código 1 - multiplicação. asm

16 14 APÊNDICE B VISUALIZAÇÃO DE CONTEXTO DA FPU ### ### Area de Dados ### data n1:.float 3.5 n2:.float msg:.asciiz "Mostrando registradores da FPU: \n" ### ### Area de Codigo ### extern print_register.extern printstr.text.globl main: main addiu $sp, $sp, -4 sw $ra, 0($sp) l.s l.s $f4, n1 $f6, n2 mul.s $f12, $f4, $f6 cvt.d.s $f22, $f12 mul.d $f24, $f22, $f22 mul.d $f26, $f24, $f24 la jal $4, msg printstr #Imprimindo $f0 mfc1 $16, $f0 addi $4, $0, 16 addi $5, $0, 0 jal print_register #Imprimindo $f1 mfc1 $16, $f1 addi $4, $0, 16 addi $5, $0, 1 jal print_register mfc1 $16, $f2 addi $4, $0, 16 addi $5, $0, 2 jal print_register mfc1 $16, $f3 addi $4, $0, 16 addi $5, $0, 3

17 15 jal print_register mfc1 $16, $f4 addi $4, $0, 16 addi $5, $0, 4 jal print_register mfc1 $16, $f5 addi $4, $0, 16 addi $5, $0, 5 jal print_register mfc1 $16, $f6 addi $4, $0, 16 addi $5, $0, 6 jal print_register mfc1 $16, $f7 addi $4, $0, 16 addi $5, $0, 7 jal print_register ### Código encurtado, continuava assim para todos os registradores ### mfc1 $16, $f31 addi $4, $0, 16 addi $5, $0, 31 jal print_register.globl prologue prologue: lw $ra, 0($sp) addiu $sp, $sp, 4 jr $ra Código 2 - contexto.asm ### ### Area de Dados ### data n1:.float 3.5 n2:.float msg:.asciiz "Mostrando registradores da FPU: \n" ### ### Area de Codigo ### text.globl main main: addiu $sp, $sp, -4 sw $ra, 0($sp)

18 16 l.s l.s $f4, n1 $f6, n2 mul.s $f12, $f4, $f6 cvt.d.s $f22, $f12 mul.d $f24, $f22, $f22 mul.d $f26, $f24, $f24.globl prologue prologue: lw $ra, 0($sp) addiu $sp, $sp, 4 jr $ra Código 3 - Programa auxiliar, contexto- spim. asm Figura 6 - Resultado da Execução do programa contexto.asm

19 Figura 7 - Visualização do contexto através do SPIM 17